Débogage d'un sous-processus.Popen appel

J'ai été en utilisant subprocess.Popen avec succès dans le passé, lors de l'emballage des binaires avec un script python pour le format des arguments /personnaliser etc...

L'élaboration d'un nième wrapper, j'ai fait comme d'habitude... mais rien ne se passe.

Voici le petit code:

print command
p = subprocess.Popen(command, shell = True)
result = p.communicate()[0]
print vars(p)
return result

Et voici le résultat:

/usr/bin/sh /tmp/run/launch.sh
{'_child_created': True, 'returncode': 0, 'stdout': None, 'stdin': None, 'pid': 21650, 'stderr': None, 'universal_newlines': False}

Comme vous pouvez le voir, le but est de créer un script shell configuration de tout ce dont j'ai besoin, et puis l'exécuter. Je préfère l'utilisation de python véritable code, mais malheureusement launch.sh appel de la 3e partie des scripts shell que je n'ai aucune envie d'essayer et de se répliquer (si j'ai insisté pour une api python pour plus d'un an maintenant).

Le problème est que:

le shell script n'est pas exécuté (il doit frayer processus de sortie et quelques petites choses)
pas de python exception est levée
il n'y a rien dans le p objet qui indique qu'une erreur s'est produite

J'ai essayé check_call sans succès non plus...

Je suis à une perte quant à ce que je dois faire, et serait très heureux si quelqu'un pouvait point de ma faute ou de me diriger vers la résolution...

EDIT:

Essayer de l'exécuter sur Linux (sh)
shell est nécessaire pour la substitution de variables dans les scripts invoquée

EDIT 2:

Suivantes badp suggestion, j'ai modifié le code et ajouté

subprocess.Popen('ps', shell = True).communicate()

Juste après p = ... ligne qui crée le processus, voici les résultats:

/usr/bin/sh /tmp/run/launch.sh
  PID TTY          TIME CMD
29978 pts/0    00:00:01 zsh
 1178 pts/0    00:00:01 python
 1180 pts/0    00:00:00 sh <defunct>
 1181 pts/0    00:00:00 ps
None

Apparemment, le processus est lancé (même si <defunct>) et il est aussi à noter que j'ai un petit problème en passant les paramètres...

Grâce.

Êtes-vous sûr que le script est en fait pas lancé? Vous pouvez le vérifier en essayant d'appeler stat sur /proc/child-pid-goes-here/ immédiatement après l'appel de Popen
Quelle est la valeur de la commande?
La valeur est imprimée au début de la sortie /usr/bin/sh /tmp/run/launch.sh
Pour le moment j'ai une solution simple: j'ai ajouté #!/usr/bin/sh au début de mon launch.sh fichier et de le substituer la commande pour /tmp/run/launch.sh. Les travaux de cette. Pourrait-il être que je ne devrais pas explicitement état sh ... si j'utilise également shell = True ?

OriginalL'auteur Matthieu M. | 2010-02-05

python subprocess

4

J'ai enfin trouvé la réponse à ma question, merci pour badp et ses suggestions pour le débogage.

De l'python page sur le sous-processus module:

La exécutable argument spécifie le programme à exécuter. Il est très rare d'avoir besoin de: Habituellement, le programme à exécuter est définie par l'argument args. Si shell=True, le exécutable argument spécifie le shell à utiliser. Sur Unix, le shell par défaut est /bin/sh. Sur Windows, le shell par défaut est spécifiée par le COMSPEC variable d'environnement. La seule raison pour laquelle vous avez besoin de spécifier shell=True sur Windows est où la commande que vous souhaitez exécuter est en fait intégré à la coque, par exemple,dir, copy. Vous n'avez pas besoin shell=True pour exécuter un fichier de commandes, ni d'exécuter une console executable.

Depuis que je suis sur Linux et utilisant shell=True, ma commande est en fait une liste d'arguments pour être exécuté par exécutable, qui est par défaut /bin/sh. Ainsi, la commande d'exécution a été: /bin/sh /usr/bin/sh /tmp/run/launch.sh... qui n'a pas bien fonctionné.

Et je devrais avoir utilisé soit:
```
subprocess.Popen('/tmp/run/launch.sh', shell=True)
```
ou
```
subprocess.Popen('/tmp/run/launch.sh', executable = '/usr/bin/sh', shell=True)
```
C'est difficile que shell=True serait effectivement modifier la valeur par défaut exécutable valeur que sous Linux...

La marque de ce que l'on a accepté la réponse, alors 🙂 (Non, vous n'obtenez pas de rep.)
Représentant n'a pas vraiment d'importance pour moi 🙂 Mais il y a une sécurité: je ne peux pas accepter ma propre réponse avant quelques jours. J'ai oublié de upvote votre réponse mais, je vais corriger cela.
J'ai eu un problème connexe et vu que la suppression de "shell=True," a permis à la normale de passage de paramètres positionnels de mon .sh script. Il en était autrement en essayant de lancer /bin/sh-c blah.sh param1 . Sur ma machine -c attend une chaîne. Si je l'ai exécuté manuellement comme: /bin/sh-c "blah.sh param1" il serait de travailler. Pourquoi le /bin/sh-c sont ajoutés? Parce que le shell=True argument a été activé. De le désactiver si vous n'avez pas besoin.

OriginalL'auteur Matthieu M.
3

Essayez ceci:
```
p = subprocess.Popen(command,
                     shell = True, #is this even needed?
                     stdin = subprocess.PIPE,
                     stdout = subprocess.PIPE,
                   # stderr = subprocess.STDOUT #uncomment if reqd
                    )
```
Testé à travailler sur Windows avec le ping de commande. Cela vous permet de communicate, qui peut vous aider à trouver pourquoi le script n'est pas lancé dans la première place 🙂

ping fonctionne très bien, merci, le problème est avec cette commande particulière. Aussi shell est nécessaire parce que j'ai besoin de bénéficier de l'variables de ma coquille de l'environnement.

OriginalL'auteur badp

Vous devez vous connecter pour publier un commentaire.