Python: Unterprozess.Anruf, stdout zu Datei stderr zu Datei -, Anzeige-stderr auf dem Bildschirm in Echtzeit

Du kann dies mit subprocessaber es ist nicht trivial. Wenn man sich die Häufig Verwendete Argumente in den docs, Sie werden sehen, dass Sie passieren kann PIPE als stderr argument, das schafft eine neue Leitung, geht eine Seite von dem Rohr zu der Kind-Prozess, und lässt die andere Seite, die als die stderr Attribut.*

Also, werden Sie brauchen, Dienst, Leitung, schreiben auf den Bildschirm und in die Datei. Im Allgemeinen, der details ist für das ist sehr schwierig.** In Ihrem Fall gibt es nur ein Rohr, und Sie planen, über die Wartung synchron, so dass es nicht schlecht ist.

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()

(Beachten Sie, dass es gibt einige Probleme mit for line in proc.stderr:—im Grunde, wenn das, was Sie gerade Lesen, stellt sich heraus, nicht zu sein, line-buffered-aus irgendeinem Grund, können Sie sitzen herum und warten für einen Zeilenumbruch, obwohl es eigentlich eine halbe Zeile Wert-Daten zu verarbeiten. Sie können Lesen chunks gleichzeitig mit, sagen wir, read(128) oder sogar read(1)um die Daten reibungslos, wenn nötig. Wenn Sie brauchen, um tatsächlich jedes byte, sobald es ankommt, und können es sich nicht leisten, die Kosten der read(1) werden Sie brauchen, um das Rohr in den non-blocking Modus und Lesen asynchron.)

Aber wenn du auf Unix, ist es möglicherweise einfacher zu verwenden, die tee - Befehl, um es für Sie tun.

Für eine quick&dirty Lösung verwenden, können Sie die shell-Rohr durch. So etwas wie dieses:

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

Aber ich will nicht Debuggen von shell-Rohrleitungen; let ' s do it in Python, wie gezeigt in den 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()

Schließlich gibt es ein Dutzend oder mehr höher-level-Wrapper für Teilprozesse und/oder der shell auf PyPI—shshellshell_commandshelloutiterpipessargecmd_utilscommandwrapperetc. Die Suche nach "shell", "Teilprozess", "Prozess", "Kommandozeile", etc. und finden, die Sie mögen, macht das problem trivial.

Was, wenn Sie brauchen, um zu sammeln, sowohl stderr und stdout?

Den einfachen Weg, es zu tun, ist nur eine Umleitung auf die andere, wie Sven Marnach schlägt in einem Kommentar. Ändern Sie einfach die Popen Parameter wie folgt:

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

Und dann überall verwendet werden tool.stderr verwenden tool.stdout statt—z.B., für das Letzte Beispiel:

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

Aber dies hat einige Nachteile. Offensichtlich mischen der zwei Ströme zusammen bedeutet, dass Sie nicht log stdout zu file_out und stderr zu log_file, oder kopiere Standardausgabe auf Ihrem stdout und stderr zu Ihrem stderr. Aber es bedeutet auch, die Bestellung kann nicht deterministisch sein—wenn der Subprozess schreibt immer zwei Zeilen auf stderr vor dem schreiben etwas nach stdout, Sie könnten am Ende immer ein Bündel von stdout zwischen diesen beiden Linien, sobald Sie mischen die streams. Und es bedeutet, Sie teilen sich den stdout - buffering-Modus, so dass, wenn Sie sich auf die Tatsache, dass die linux/glibc-stderr garantiert, um sein line-buffered (es sei denn, der Teilprozess ausdrücklich ändert es), das kann nicht mehr wahr sein.

Wenn Sie behandeln müssen, die zwei Prozesse getrennt, es wird schwieriger. Früher habe ich gesagt, dass die Wartung der pipe on-the-fly ist einfach, solange man nur eine Leitung und kann es synchron. Wenn Sie zwei Rohre, das ist offensichtlich nicht mehr wahr. Stell dir vor, du wartest auf tool.stdout.read()und neue Daten, die von tool.stderr. Wenn es zu viele Daten, es kann dazu führen, das Rohr zu überlaufen und den Unterprozess zu blockieren. Aber selbst wenn das nicht geschehen ist, können Sie offensichtlich nicht in der Lage zu Lesen und zu protokollieren stderr Daten, bis etwas kommt von stdout.

Wenn Sie das pipe-through-tee Lösung, die vermeidet, dass das anfängliche problem... aber nur, indem Sie ein neues Projekt erstellen, das ist genauso schlimm. Sie haben zwei tee Instanzen, und während Sie anrufen communicate auf der einen, die anderen sitzen herum und warten für immer.

So, so oder so, müssen Sie irgendeine Art von asynchroner Mechanismus. Sie können dies tun, ist mit threads, ein select Reaktor, so etwas wie gevent usw.

Hier ist eine quick-and-dirty-Beispiel:

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()

Allerdings gibt es einige Sonderfälle, wo das nicht funktioniert. (Das problem ist die Reihenfolge, in der SIGCHLD und SIGPIPE/EPIPE/EOF ankommen. Ich denke keine, die Auswirkungen auf uns hier, da wir verschicken keine Eingabe... aber nicht das können Sie mir glauben, ohne zu denken es durch und/oder zu testen.) Die Unterprozess.kommunizieren Funktion von 3,3+ bekommt alle fummeligen details. Aber Sie finden es viel einfacher zu verwenden, eine der async-Teilprozess-wrapper-Implementierungen finden Sie auf PyPI und ActiveState, oder sogar den Teilprozess Sachen von einer vollwertigen async-framework wie Verdreht.

* Die docs nicht wirklich erklären, was die Rohre sind, fast als ob Sie erwarten, dass Sie eine alte Unix-C hand... Aber einige der Beispiele, insbesondere in der Ersatz Älterer Funktionen mit der subprocess - Modul Abschnitt zeigen, wie Sie verwendet werden, und es ist ziemlich einfach.

** Der schwierige Teil ist die Sequenzierung von zwei oder mehr Rohre richtig. Wenn Sie warten auf ein Rohr, die anderen dürfen überlauf und block, der verhindert, warten, auf das andere je zu Ende. Die einzige einfache Möglichkeit, dies zu umgehen, erstellen Sie einen thread, um jedes Rohr. (Auf den meisten *nix-Plattformen, die Sie verwenden können, eine select oder poll Reaktor statt, aber die cross-Plattform ist unglaublich schwer.) Die Quelle , um das Modul vor allem communicate und seine Helfer, zeigt, wie es zu tun. (Ich verlinkte auf 3.3, weil in früheren Versionen communicate selbst bekommt einige wichtige Dinge falsch...) Das ist, warum, Wann immer möglich, die Sie verwenden möchten communicate wenn Sie mehr als eine Pfeife. In Ihrem Fall, Sie können nicht communicateaber zum Glück brauchen Sie nicht mehr als ein Rohr.

InformationsquelleAutor der Antwort abarnert

Musste ich ein paar änderungen an @abarnert Antwort für Python 3. Dies scheint zu funktionieren:

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()

InformationsquelleAutor der Antwort Timmmm