récupérer stdout en temps réel à partir d'un sous-processus

Question

Je veux subprocess.Popen() rsync.exe sous Windows, et imprimer le stdout en Python.

Mon code fonctionne, mais il n'affiche pas la progression jusqu'à ce qu'un transfert de fichier soit effectué ! Je veux imprimer la progression pour chaque fichier en temps réel.

J'utilise maintenant Python 3.1 car j'ai entendu dire qu'il devrait mieux gérer les entrées-sorties.

import subprocess, time, os, sys

cmd = "rsync.exe -vaz -P source/ dest/"
p, line = True, 'start'

p = subprocess.Popen(cmd,
                     shell=True,
                     bufsize=64,
                     stdin=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE)

for line in p.stdout:
    print(">>> " + str(line.rstrip()))
    p.stdout.flush()

Answer 1

Quelques règles de base pour subprocess .

• Jamais utiliser shell=True . Il invoque inutilement un processus shell supplémentaire pour appeler votre programme.
• Lors de l'appel de processus, les arguments sont transmis sous forme de listes. sys.argv en python est une liste, de même que argv en C. Vous passez donc un liste a Popen pour appeler les sous-processus, et non une chaîne de caractères.
• Ne pas rediriger stderr à un PIPE quand tu ne le lis pas.
• Ne pas rediriger stdin quand tu n'écris pas dessus.

Ejemplo:

import subprocess, time, os, sys
cmd = ["rsync.exe", "-vaz", "-P", "source/" ,"dest/"]

p = subprocess.Popen(cmd,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.STDOUT)

for line in iter(p.stdout.readline, b''):
    print(">>> " + line.rstrip())

Cela dit, il est probable que rsync mette en mémoire tampon sa sortie lorsqu'il détecte qu'il est connecté à un tuyau et non à un terminal. C'est le comportement par défaut - lorsqu'ils sont connectés à un tuyau, les programmes doivent explicitement vider stdout pour obtenir des résultats en temps réel, sinon la bibliothèque C standard mettra en mémoire tampon.

Pour tester cela, essayez d'exécuter ceci à la place :

cmd = [sys.executable, 'test_out.py']

et créer un test_out.py avec le contenu :

import sys
import time
print ("Hello")
sys.stdout.flush()
time.sleep(10)
print ("World")

L'exécution de ce sous-processus devrait vous donner "Hello" et attendre 10 secondes avant de donner "World". Si cela se produit avec le code python ci-dessus et non avec rsync c'est-à-dire rsync lui-même met en tampon la sortie, donc vous n'avez pas de chance.

Une solution serait de se connecter directement à un pty en utilisant quelque chose comme pexpect .

Answer 2

for line in p.stdout:
  ...

bloque toujours jusqu'au prochain saut de ligne.

Pour un comportement "en temps réel", vous devez faire quelque chose comme ceci :

while True:
  inchar = p.stdout.read(1)
  if inchar: #neither empty string nor None
    print(str(inchar), end='') #or end=None to flush immediately
  else:
    print('') #flush for implicit line-buffering
    break

La boucle while se termine lorsque le processus enfant ferme son stdout ou sort. read()/read(-1) bloquerait jusqu'à ce que le processus enfant ferme son stdout ou sorte.

Answer 3

Votre problème est :

for line in p.stdout:
    print(">>> " + str(line.rstrip()))
    p.stdout.flush()

l'itérateur lui-même a une mise en mémoire tampon supplémentaire.

Essayez de faire comme ça :

while True:
  line = p.stdout.readline()
  if not line:
     break
  print line

Answer 4

Vous ne pouvez pas faire en sorte que stdout imprime sans tampon vers un tuyau (à moins que vous puissiez réécrire le programme qui imprime vers stdout), voici donc ma solution :

Redirige stdout vers sterr, qui n'est pas mis en mémoire tampon. '<cmd> 1>&2' devrait le faire. Ouvrez le processus comme suit : myproc = subprocess.Popen('<cmd> 1>&2', stderr=subprocess.PIPE)
Vous ne pouvez pas distinguer stdout ou stderr, mais vous obtenez toutes les sorties immédiatement.

J'espère que cela aidera toute personne confrontée à ce problème.

Answer 5

Change le stdout du processus rsync pour qu'il soit non bufferisé.

p = subprocess.Popen(cmd,
                     shell=True,
                     bufsize=0,  # 0=unbuffered, 1=line-buffered, else buffer-size
                     stdin=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     stdout=subprocess.PIPE)