Speichern stdout aus Teilprozess.Popen auf Datei und schreiben mehr Dinge auf die Datei

Ich Schreibe ein python-Skript, dass verwendet Teilprozess.Popen ausführen von zwei Programmen (aus der kompilierte C-code), die jeder produzieren stdout. Das script bekommt, dass die Ausgabe und speichert Sie in einer Datei. Weil die Ausgabe ist manchmal groß genug, um zu überwältigen Teilprozess.ROHR, wodurch das Skript zu hängen, ich schicke die Standardausgabe direkt in die log-Datei. Ich möchte mein Skript etwas schreiben zu Beginn und am Ende der Datei, und zwischen den beiden Teilprozess.Popen Anrufe. Allerdings, wenn ich mir meine log-Datei, alles, was ich schrieb, um die log-Datei aus dem script alle zusammen am Anfang der Datei, gefolgt von allen ausführbaren Datei stdout. Wie kann ich interleave meine hinzugefügten text in der Datei?

def run(cmd, logfile):
    p = subprocess.Popen(cmd, shell=True, universal_newlines=True, stdout=logfile)
    return p

def runTest(path, flags, name):
    log = open(name, "w")
    print >> log, "Calling executable A"
    a_ret = run(path + "executable_a_name" + flags, log)
    print >> log, "Calling executable B"
    b_ret = run(path + "executable_b_name" + flags, log)
    print >> log, "More stuff"
    log.close()

Die log-Datei hat:
Aufruf von ausführbaren Ein
Aufruf von ausführbaren B
Mehr Zeug
[... stdout aus beiden executables ...]

Gibt es eine Möglichkeit kann ich Ein flush stdout, um das Protokoll nach dem Aufruf von Popen, zum Beispiel? Eine weitere Sache, die relevant sein könnten: Executable A beginnt dann pends auf B und nach B Zeug druckt und abgeschlossen ist, Ein und gibt dann mehr Material und Oberflächen.

Ich bin mit Python 2.4 auf RHE Linux.

InformationsquelleAutor der Frage jasper77 | 2010-07-06

  1. 17

    Könnte man sagen .wait() auf jeder Popen-Objekt, um sicher zu sein, dass es fertig ist und dann call log.flush(). Vielleicht so etwas wie dieses:

    def run(cmd, logfile):
    p = subprocess.Popen(cmd, shell=True, universal_newlines=True, stdout=logfile)
    ret_code = p.wait()
    logfile.flush()
    return ret_code

    Wenn Sie brauchen, um die Interaktion mit dem Popen-Objekt in Ihrer äußeren Funktion, die Sie verschieben konnte .wait () - Aufruf statt.

    InformationsquelleAutor der Antwort Benno

  2. 2

    Müssen Sie warten, bis der Prozess beendet ist, bevor Sie fortfahren. Ich habe auch konvertiert den code-Kontext-manager, der ist sauberer.

    def run(cmd, logfile):
    p = subprocess.Popen(cmd, shell=True, universal_newlines=True, stdout=logfile)
    p.wait()
    return p

def runTest(path, flags, name):
    with open(name, "w") as log:
        print >> log, "Calling executable A"
        a_ret = run(path + "executable_a_name" + flags, log)
        print >> log, "Calling executable B"
        b_ret = run(path + "executable_b_name" + flags, log)
        print >> log, "More stuff"

    InformationsquelleAutor der Antwort Chris B.

  3. 2

    Ich Sag nur keep it real einfach. Pseudo-code, basic-Logik:

    write your start messages to logA
execute A with output to logA
write your in-between messages to logB
execute B with output to logB
write your final messages to logB
when A & B finish, write content of logB to the end of logA
delete logB

    InformationsquelleAutor der Antwort Peter Lyons

  4. 2

    Wie ich es verstehe A Programm wartet auf B zu tun, seine Sache und A Ausfahrten nur nach B beendet.

    Wenn B starten können, ohne A läuft, dann könnte man anfangen, die Prozesse in der umgekehrten Reihenfolge:

    from os.path import join as pjoin
from subprocess import Popen

def run_async(cmd, logfile):
    print >>log, "calling", cmd
    p = Popen(cmd, stdout=logfile)
    print >>log, "started", cmd
    return p

def runTest(path, flags, name):
    log = open(name, "w", 1)  # line-buffered
    print >>log, 'calling both processes'
    pb = run_async([pjoin(path, "executable_b_name")] + flags.split(), log)
    pa = run_async([pjoin(path, "executable_a_name")] + flags.split(), log)
    print >>log, 'started both processes'
    pb.wait()
    print >>log, 'process B ended'
    pa.wait()
    print >>log, 'process A ended'
    log.close()

    Hinweis: der Aufruf log.flush() in die wichtigsten Prozesse hat keinen Einfluss auf die Datei Puffer in die Kind-Prozesse.

    Wenn untergeordnete Prozesse, die Verwendung von block-buffering für stdout, dann können Sie versuchen, Sie zu zwingen zu erröten früher mit pexpect, pty, oder stdbuf (es wird davon ausgegangen, dass die Prozesse verwenden Sie die line-Pufferung, wenn Sie Sie interaktiv laufen lassen, oder Sie nutzen C stdio-Bibliothek für I/O).

    InformationsquelleAutor der Antwort jfs

Schreibe einen Kommentar