Wie verwende ich subprocess.Popen, um mehrere Prozesse über Pipes zu verbinden?

Question

Wie führe ich den folgenden Shell-Befehl unter Verwendung der Python subprocess Modul?

echo "input data" | awk -f script.awk | sort > outfile.txt

Die Eingabedaten werden aus einer Zeichenkette stammen, daher brauche ich eigentlich keine echo . Ich habe so weit gekommen, kann jemand erklären, wie ich es zu bekommen, um durch Rohr sort auch?

p_awk = subprocess.Popen(["awk","-f","script.awk"],
                          stdin=subprocess.PIPE,
                          stdout=file("outfile.txt", "w"))
p_awk.communicate( "input data" )

UPDATE : Beachten Sie, dass die unten stehende akzeptierte Antwort die Frage nicht wirklich beantwortet, aber ich glaube, dass S. Lott Recht hat und es besser ist, dieses Problem gar nicht erst zu lösen!

Answer 1

Inspiriert durch die Antwort von @Cristian. Ich hatte genau das gleiche Problem, allerdings mit einem anderen Befehl. Deshalb füge ich hier mein getestetes Beispiel ein, das meiner Meinung nach hilfreich sein könnte:

grep_proc = subprocess.Popen(["grep", "rabbitmq"],
                             stdin=subprocess.PIPE, 
                             stdout=subprocess.PIPE)
subprocess.Popen(["ps", "aux"], stdout=grep_proc.stdin)
out, err = grep_proc.communicate()

Dies wird getestet.

Was wurde getan?

• Für faul erklärt grep Ausführung mit stdin aus der Pipe. Dieser Befehl wird in der ps Befehlsausführung, wenn die Pipe mit dem stdout von ps .
• Aufrufen des primären Befehls ps mit stdout an die Pipe gerichtet, die von der grep Befehl.
• Grep kommuniziert, um stdout aus der Pipe zu holen.

Ich mag diese Art und Weise, weil es eine natürliche Rohrkonzeption ist, die sanft mit subprocess Schnittstellen.

Answer 2

In den vorherigen Antworten wurde ein wichtiger Punkt übersehen. Ersetzen der Shell-Pipeline ist grundsätzlich korrekt, wie von geocar hervorgehoben. Es ist fast ausreichend für den Betrieb communicate auf das letzte Element der Pipe.

Das verbleibende Problem ist die Übergabe der Eingangsdaten zur Pipeline. Bei mehreren Unterprozessen kann eine einfache communicate(input_data) auf das letzte Element funktioniert nicht - es bleibt für immer hängen. Sie müssen eine Pipeline und ein Kind manuell wie folgt erstellen:

import os
import subprocess

input = """\
input data
more input
""" * 10

rd, wr = os.pipe()
if os.fork() != 0: # parent
    os.close(wr)
else:              # child
    os.close(rd)
    os.write(wr, input)
    os.close(wr)
    exit()

p_awk = subprocess.Popen(["awk", "{ print $2; }"],
                         stdin=rd,
                         stdout=subprocess.PIPE)
p_sort = subprocess.Popen(["sort"], 
                          stdin=p_awk.stdout,
                          stdout=subprocess.PIPE)
p_awk.stdout.close()
out, err = p_sort.communicate()
print (out.rstrip())

Jetzt liefert das Kind die Eingabe über die Pipe, und das Elternteil ruft communicate() auf, was wie erwartet funktioniert. Mit diesem Ansatz können Sie beliebig lange Pipelines erstellen, ohne einen Teil der Arbeit an die Shell delegieren zu müssen. Leider ist die Teilprozessdokumentation wird dies nicht erwähnt.

Es gibt Möglichkeiten, den gleichen Effekt ohne Rohre zu erzielen:

from tempfile import TemporaryFile
tf = TemporaryFile()
tf.write(input)
tf.seek(0, 0)

Verwenden Sie nun stdin=tf para p_awk . Es ist eine Frage des Geschmacks, was Sie bevorzugen.

Die obige Lösung ist immer noch nicht 100%ig äquivalent zu Bash-Pipelines, da die Signalverarbeitung anders ist. Sie können dies sehen, wenn Sie ein weiteres Pipe-Element hinzufügen, das die Ausgabe von sort z.B. head -n 10 . Mit dem obigen Code, sort gibt eine Fehlermeldung "Broken pipe" an stderr . Sie werden diese Meldung nicht sehen, wenn Sie dieselbe Pipeline in der Shell ausführen. (Das ist allerdings der einzige Unterschied, das Ergebnis in stdout ist derselbe). Der Grund dafür scheint zu sein, dass Pythons Popen setzt SIG_IGN para SIGPIPE , während die Schale sie bei SIG_DFL et sort Die Signalverarbeitung ist in diesen beiden Fällen unterschiedlich.

Answer 3

EDITAR: pipes ist unter Windows verfügbar, scheint aber nicht wirklich zu funktionieren. Arbeit unter Windows. Siehe Kommentare unten.

Die Python-Standardbibliothek enthält jetzt die pipes Modul für diese Aufgabe:

https://docs.python.org/2/library/pipes.html , https://docs.python.org/3.4/library/pipes.html

Ich bin mir nicht sicher, wie lange es dieses Modul schon gibt, aber dieser Ansatz scheint wesentlich einfacher zu sein als das Herumhantieren mit subprocess .

Answer 4

Für mich ist der folgende Ansatz der sauberste und am einfachsten zu lesende

from subprocess import Popen, PIPE

def string_to_2_procs_to_file(input_s, first_cmd, second_cmd, output_filename):
    with open(output_filename, 'wb') as out_f:
        p2 = Popen(second_cmd, stdin=PIPE, stdout=out_f)
        p1 = Popen(first_cmd, stdout=p2.stdin, stdin=PIPE)
        p1.communicate(input=bytes(input_s))
        p1.wait()
        p2.stdin.close()
        p2.wait()

die wie folgt aufgerufen werden kann:

string_to_2_procs_to_file('input data', ['awk', '-f', 'script.awk'], ['sort'], 'output.txt')