Comment terminer un sous-processus python lancé avec shell = True

Je lance un sous-processus avec la commande suivante:

p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)

Cependant, lorsque j'essaie de tuer en utilisant:

p.terminate()

ou

p.kill()

La commande continue de s'exécuter en arrière-plan, alors je me demandais comment puis-je réellement mettre fin au processus.

Notez que lorsque j'exécute la commande avec:

p = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)

Il se termine avec succès lors de l'émission du p.terminate().

Utilisez un groupe de processus afin de permettre l'envoi d'un signal à tous les processus des groupes. Pour cela, vous devez attacher un identifiant de session au processus parent des processus générés / enfants, qui est un shell dans votre cas. Cela en fera le chef de groupe des processus. Alors maintenant, lorsqu'un signal est envoyé au leader du groupe de processus, il est transmis à tous les processus enfants de ce groupe.

Voici le code:

import os
import signal
import subprocess

# The os.setsid() is passed in the argument preexec_fn so
# it's run after the fork() and before  exec() to run the shell.
pro = subprocess.Popen(cmd, stdout=subprocess.PIPE, 
                       shell=True, preexec_fn=os.setsid) 

os.killpg(os.getpgid(pro.pid), signal.SIGTERM)  # Send the signal to all the process groups

p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
p.kill()

p.kill()finit par tuer le processus shell et cmdest toujours en cours d'exécution.

J'ai trouvé un correctif pratique en:

p = subprocess.Popen("exec " + cmd, stdout=subprocess.PIPE, shell=True)

Cela entraînera cmd à hériter du processus shell, au lieu d'avoir le shell lancer un processus enfant, qui ne sera pas tué. p.pidsera alors l'id de votre processus cmd.

p.kill() devrait marcher.

Je ne sais pas cependant quel effet cela aura sur votre pipe.

Si vous pouvez utiliser psutil , cela fonctionne parfaitement:

import subprocess

import psutil


def kill(proc_pid):
    process = psutil.Process(proc_pid)
    for proc in process.children(recursive=True):
        proc.kill()
    process.kill()


proc = subprocess.Popen(["infinite_app", "param"], shell=True)
try:
    proc.wait(timeout=3)
except subprocess.TimeoutExpired:
    kill(proc.pid)

Je pourrais le faire en utilisant

from subprocess import Popen

process = Popen(command, shell=True)
Popen("TASKKILL /F /PID {pid} /T".format(pid=process.pid))

il a tué le cmd.exeet le programme pour lequel j'ai donné la commande.

(Sous Windows)

Lorsque shell=Truele shell est le processus enfant et que les commandes sont ses enfants. Donc, tout SIGTERMou SIGKILLva tuer le shell mais pas ses processus enfants, et je ne me souviens pas d'une bonne façon de le faire. La meilleure façon que je puisse penser est d'utiliser shell=False, sinon lorsque vous tuez le processus shell parent, il laissera un processus shell défunt.

Aucune de ces réponses n'a fonctionné pour moi, donc je laisse le code qui a fonctionné. Dans mon cas, même après avoir tué le processus avec .kill()et obtenu un .poll()code retour, le processus ne s'est pas terminé.

Suite à la subprocess.Popen documentation :

"... afin de nettoyer correctement une application bien tenue devrait tuer le processus enfant et terminer la communication ..."

proc = subprocess.Popen(...)
try:
    outs, errs = proc.communicate(timeout=15)
except TimeoutExpired:
    proc.kill()
    outs, errs = proc.communicate()

Dans mon cas, je manquais le proc.communicate()après avoir appelé proc.kill(). Cela nettoie le processus stdin, stdout ... et met fin au processus.

Comme l'a dit Sai, le shell est l'enfant, donc les signaux sont interceptés par lui - le meilleur moyen que j'ai trouvé est d'utiliser shell = False et d'utiliser shlex pour diviser la ligne de commande:

if isinstance(command, unicode):
    cmd = command.encode('utf8')
args = shlex.split(cmd)

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

Ensuite, p.kill () et p.terminate () devraient fonctionner comme prévu.

ce que je pense que nous pourrions utiliser:

import os
import signal
import subprocess
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)

os.killpg(os.getpgid(pro.pid), signal.SIGINT)

cela ne tuera pas toute votre tâche mais le processus avec le p.pid

Je sais que c'est une vieille question mais cela peut aider quelqu'un qui cherche une méthode différente. C'est ce que j'utilise sur Windows pour tuer les processus que j'ai appelés.

si = subprocess.STARTUPINFO()
si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
subprocess.call(["taskkill", "/IM", "robocopy.exe", "/T", "/F"], startupinfo=si)

/ IM est le nom de l'image, vous pouvez également faire / PID si vous le souhaitez. / T tue le processus ainsi que les processus enfants. / F force y met fin. si, comme je l'ai défini, est la façon dont vous faites cela sans afficher de fenêtre CMD. Ce code est utilisé en python 3.

Envoyer le signal à tous les processus du groupe

    self.proc = Popen(commands, 
            stdout=PIPE, 
            stderr=STDOUT, 
            universal_newlines=True, 
            preexec_fn=os.setsid)

    os.killpg(os.getpgid(self.proc.pid), signal.SIGHUP)
    os.killpg(os.getpgid(self.proc.pid), signal.SIGTERM)

Je n'ai pas vu cela mentionné ici, donc je le mets au cas où quelqu'un en aurait besoin. Si tout ce que vous voulez faire est de vous assurer que votre sous-processus se termine avec succès, vous pouvez le placer dans un gestionnaire de contexte. Par exemple, je voulais que mon imprimante standard imprime une image et que le gestionnaire de contexte garantisse la fin du sous-processus.

import subprocess

with open(filename,'rb') as f:
    img=f.read()
with subprocess.Popen("/usr/bin/lpr", stdin=subprocess.PIPE) as lpr:
    lpr.stdin.write(img)
print('Printed image...')

Je pense que cette méthode est également multiplateforme.