Python: sous-processus.appel, stdout vers un fichier, stderr dans un fichier, afficher stderr sur l'écran en temps réel

Vous peut le faire avec subprocess, mais il n'est pas trivial. Si vous regardez la Fréquemment Utilisé Des Arguments dans les docs, vous verrez que vous pouvez passer PIPE comme le stderr argument, qui crée une nouvelle pipe, passe d'un côté du tuyau pour le processus de l'enfant, et fait de l'autre côté à la disposition de l'utiliser comme stderr attribut.*

Ainsi, vous aurez besoin pour l'entretien de la canalisation, de l'écriture à l'écran et dans le fichier. En général, les détails de droite pour cela est très difficile.** Dans votre cas, il n'y a qu'un seul canal, et vous avez l'intention de l'entretenir de manière synchrone, c'est pas si mal que ça.

import subprocess
proc = subprocess.Popen(['path_to_tool', '-option1', 'option2'],
                        stdout=file_out, stderr=subprocess.PIPE)
for line in proc.stderr:
    sys.stdout.write(line)
    log_file.write(line)
proc.wait()

(À noter qu'il y a quelques problèmes à l'aide for line in proc.stderr:—en fait, si ce que vous êtes en train de lire s'avère ne pas être ligne-mis en mémoire tampon pour une raison quelconque, vous pouvez vous asseoir autour d'attente pour un retour à la ligne, même si il y a effectivement une demi-ligne de données à traiter. Vous pouvez lire les morceaux à la fois, avec, disons, read(128), ou même read(1), pour obtenir les données de manière plus fluide, si nécessaire. Si vous avez besoin d'obtenir effectivement chaque octet dès qu'il arrive, et ne peuvent pas se permettre le coût de read(1), vous aurez besoin de mettre le tuyau en mode sans blocage et de lire de manière asynchrone.)

---

Mais si vous êtes sous Unix, il pourrait être plus simple d'utiliser la tee de commande pour le faire pour vous.

Pour un quick&solution sale, vous pouvez utiliser le shell pour tuyau à travers elle. Quelque chose comme ceci:

subprocess.call('path_to_tool -option1 option2 2|tee log_file 1>2', shell=True,
                stdout=file_out)

Mais je ne veux pas de shell de débogage de la tuyauterie; nous allons le faire en Python, comme le montre dans les docs:

tool = subprocess.Popen(['path_to_tool', '-option1', 'option2'],
                        stdout=file_out, stderr=subprocess.PIPE)
tee = subprocess.Popen(['tee', 'log_file'], stdin=tool.stderr)
tool.stderr.close()
tee.communicate()

---

Enfin, il y a une douzaine ou plus de niveau supérieur, les wrappers autour de sous-processus et/ou de l'environnement sur PyPI—sh, shell, shell_command, shellout, iterpipes, sarge, cmd_utils, commandwrapper, etc. Recherche pour "shell", "sous-processus", "processus", "ligne de commande", etc. et de trouver celui que vous aimez qui rend le problème trivial.

---

Que faire si vous avez besoin de recueillir à la fois stderr et stdout?

Le moyen facile de le faire est de simplement rediriger l'un à l'autre, comme Sven Marnach suggère dans un commentaire. Il suffit de changer le Popen paramètres comme ceci:

tool = subprocess.Popen(['path_to_tool', '-option1', 'option2'],
                        stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

Et puis partout vous avez utilisé tool.stderr, utilisez tool.stdout au lieu—par exemple, pour le dernier exemple:

tee = subprocess.Popen(['tee', 'log_file'], stdin=tool.stdout)
tool.stdout.close()
tee.communicate()

Mais cela a un compromis. De toute évidence, le mélange des deux ruisseaux ensemble signifie que vous ne pouvez pas vous connecter stdout pour file_out et stderr de log_file, ou copie stdout pour votre stdout et stderr de votre stderr. Mais cela signifie également que la commande peut être non-déterministe—si le sous-processus toujours écrit deux lignes sur la sortie stderr avant d'écrire quelque chose sur la sortie standard, vous pourriez finir par avoir un tas de stdout entre ces deux lignes une fois que vous mélangez les cours d'eau. Et cela signifie qu'ils doivent partager les la sortie standard du mode de mise en mémoire tampon, de sorte que si vous étiez en s'appuyant sur le fait que linux/glibc garanties stderr être tamponnée (sauf si le sous-processus explicitement change), qui peut ne plus être vrai.

---

Si vous avez besoin pour gérer les deux processus séparément, il devient de plus en plus difficile. Plus tôt, j'ai dit que l'entretien de la conduite à la volée est facile aussi longtemps que vous avez un tuyau et peut-service de manière synchrone. Si vous avez deux tuyaux, qui de toute évidence n'est plus vrai. Imaginez que vous êtes en attente sur tool.stdout.read(), et de nouvelles données à partir de tool.stderr. Si il y a trop de données, il peut causer le tuyau de débordement et le processus secondaire à bloc. Mais même si cela n'arrive pas, de toute évidence vous ne serez pas en mesure de lire les journaux et le stderr de données jusqu'à ce que quelque chose vient de stdout.

Si vous utilisez le canal de communication par le biais dutee solution, qui évite le problème initial... mais seulement par la création d'un nouveau projet qui est tout aussi mauvais. Vous avez deux tee cas, et pendant que vous êtes à l'appel de communicate sur l'un, l'autre est assis autour d'attente pour toujours.

Donc, de toute façon, vous avez besoin d'une sorte de mécanisme asynchrone. Vous pouvez le faire avec les fils, un select réacteur, quelque chose comme gevent, etc.

Voici un moyen rapide et sale exemple:

proc = subprocess.Popen(['path_to_tool', '-option1', 'option2'],
                        stdout=subprocess.PIPE, stderr=subprocess.PIPE)
def tee_pipe(pipe, f1, f2):
    for line in pipe:
        f1.write(line)
        f2.write(line)
t1 = threading.Thread(target=tee_pipe, args=(proc.stdout, file_out, sys.stdout))
t2 = threading.Thread(target=tee_pipe, args=(proc.stderr, log_file, sys.stderr))
t3 = threading.Thread(proc.wait)
t1.start(); t2.start(); t3.start()
t1.join(); t2.join(); t3.join()

Toutefois, il existe certains cas où cela ne marchera pas. (Le problème, c'est l'ordre dans lequel SIGCHLD et SIGPIPE/EPIPE/expressions du FOLKLORE arriver. Je ne pense pas que tout cela va nous affecter, car nous ne sommes pas d'envoi de l'entrée... mais ne me faites pas confiance sur qui à tort et à travers et/ou de test.) Le sous-processus.communiquer fonction de 3,3+ obtient toutes les délicats détails à droite. Mais vous pouvez trouver beaucoup plus simple d'utiliser l'un de l'async-sous-processus wrapper implémentations vous pouvez trouver sur PyPI et ActiveState, ou même les choses à partir d'un sous-processus à part entière async cadre comme Tordu.

---

* Les documents ne sont pas vraiment expliquer ce que les tuyaux sont, presque comme s'ils attendent que vous pour être un vieux C Unix main... Mais quelques-uns des exemples, en particulier dans le Remplacement des Anciens Fonctions avec le sous-processus Module l'article, de montrer comment ils sont utilisés, et c'est assez simple.

** La partie la plus difficile est de séquençage de deux ou plusieurs tuyaux correctement. Si vous attendez sur un tuyau, l'autre peut déborder et de bloquer, empêcher votre attente sur l'autre de la finition. Le moyen le plus facile de contourner ce problème est de créer un thread de service de chaque tuyau. (Sur la plupart des *nix plates-formes, vous pouvez utiliser un select ou poll réacteur au lieu de cela, mais de la croix-plate-forme est incroyablement difficile.) La source pour le module, en particulier communicate et ses assistants, montre comment le faire. (Je l'ai lié à 3.3, parce que dans les versions antérieures, communicate lui-même obtient des choses importantes que de mal...) C'est pourquoi, chaque fois que possible, vous souhaitez utiliser communicate si vous avez besoin de plus d'une pipe. Dans votre cas, vous ne pouvez pas utiliser communicate, mais heureusement, vous n'avez pas besoin de plus d'une pipe.

J'ai dû faire quelques modifications pour @abarnert réponse pour Python 3. Cela semble fonctionner:

def tee_pipe(pipe, f1, f2):
    for line in pipe:
        f1.write(line)
        f2.write(line)

proc = subprocess.Popen(["/bin/echo", "hello"],
                        stdout=subprocess.PIPE,
                        stderr=subprocess.PIPE)

# Open the output files for stdout/err in unbuffered mode.
out_file = open("stderr.log", "wb", 0)
err_file = open("stdout.log", "wb", 0)

stdout = sys.stdout
stderr = sys.stderr

# On Python3 these are wrapped with BufferedTextIO objects that we don't
# want.
if sys.version_info[0] >= 3:
    stdout = stdout.buffer
    stderr = stderr.buffer

# Start threads to duplicate the pipes.
out_thread = threading.Thread(target=tee_pipe,
                              args=(proc.stdout, out_file, stdout))
err_thread = threading.Thread(target=tee_pipe,
                              args=(proc.stderr, err_file, stderr))

out_thread.start()
err_thread.start()

# Wait for the command to finish.
proc.wait()

# Join the pipe threads.
out_thread.join()
err_thread.join()