Guardar stdout del subproceso.Pobre al archivo, además de escribir más cosas en el archivo

Question

Estoy escribiendo un script python que usa subprocess.Popen para ejecutar dos programas (a partir del código C compilado) que producen stdout. El script obtiene esa salida y la guarda en un archivo. Debido a que el resultado a veces es lo suficientemente grande como para abrumar el subproceso.PIPE, haciendo que el script se cuelgue, envío el stdout directamente al archivo de registro. Quiero que mi script escriba algo al principio y al final del archivo, y entre los dos subprocesos. Llamadas de acceso público. Sin embargo, cuando miro mi archivo de registro, todo lo que escribí en el archivo de registro del script está todo junto en la parte superior del archivo, seguido de todo el stdout ejecutable. ¿Cómo puedo intercalar mi texto agregado al archivo?

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

El archivo de registro tiene: Calling ejecutable Un Calling ejecutable B Más cosas [... stdout de ambos ejecutables ...]

¿Hay alguna manera de eliminar la salida estándar de la A a la el registro después de llamar a Popen, por ejemplo? Una cosa más que podría ser relevante: el Ejecutable A se inicia y luego se pone en B, y luego de que B imprima y termine, A imprime más y finaliza.

Estoy usando Python 2.4 en RHE Linux.

Answer 1

Puede llamar a .wait() en cada objeto Popen para asegurarse de que haya finalizado y luego llamar a log.flush(). Tal vez algo como esto:

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

Si necesita interactuar con el objeto Popen en su función externa se podía mover el .wait() llama a allí en su lugar.

Answer 2

Debe esperar hasta que el proceso haya terminado antes de continuar. También he convertido el código para usar un administrador de contexto, que es más limpio.

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" 

Answer 3

Digo, simplemente mantenlo real simple. pseudocódigo lógica básica:

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 

Answer 4

Según entiendo A espera del programa para B a hacer su cosa y A salidas sólo después de B salidas.

Si B puede empezar sin A correr entonces se podría iniciar los procesos en el orden inverso:

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

Nota: llamar log.flush() en los procesos principales no tiene efecto en los archivos de memoria intermedia en los procesos hijos.

Si los procesos secundarios utilizan bloques de almacenamiento temporal de la salida estándar entonces se podría tratar de obligarlos a eliminar cuanto antes el uso de pexpect, pty, or stdbuf (se supone que los procesos utilizan la línea de búfer si se ejecuta de forma interactiva o uso de la biblioteca C stdio para E/S).