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

Question

Je lance un sous-processus avec la commande suivante :

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

Cependant, quand j'essaie de tuer en utilisant :

p.terminate()

ou

p.kill()

La commande continue de s'exécuter en arrière-plan, et je me demande comment je peux mettre fin au processus.

Notez que lorsque je lance la commande avec :

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

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

Answer 1

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 la session au processus parent des processus engendrés/enfants, qui est un shell dans votre cas. Cela en fera le chef de groupe des processus. Donc maintenant, lorsqu'un signal est envoyé au chef de 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

Answer 2

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

p.kill() finit par tuer le processus shell et cmd est toujours en cours.

J'ai trouvé une solution pratique :

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

Cela permettra à cmd d'hériter du processus de l'interpréteur de commandes, au lieu que l'interpréteur de commandes lance un processus enfant, qui n'est pas tué. p.pid sera alors l'identifiant de votre processus cmd.

p.kill() devrait fonctionner.

Je ne sais pas quel effet cela aura sur votre tuyau.

Answer 3

Si vous pouvez utiliser psutil alors 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)

Answer 4

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.exe et le programme pour lequel j'ai donné la commande.

(Sous Windows)

Answer 5

Comme Sai l'a dit, le shell est l'enfant, donc les signaux sont interceptés par lui -- la meilleure façon que j'ai trouvée 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 vous le souhaitez.