Come terminare un sottoprocesso di Python avviato con shell = True

Sto avviando un sottoprocesso con il seguente comando:

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

Tuttavia, quando provo a uccidere usando:

p.terminate()

o

p.kill()

Il comando continua a essere eseguito in background, quindi mi chiedevo come posso effettivamente terminare il processo.

Si noti che quando eseguo il comando con:

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

Si interrompe correttamente durante l'emissione del file p.terminate().

Utilizzare un gruppo di processi in modo da consentire l'invio di un segnale a tutto il processo nei gruppi. Per questo, è necessario collegare un ID di sessione al processo padre dei processi generati / figlio, che è una shell nel tuo caso. Questo lo renderà il capogruppo dei processi. Quindi ora, quando un segnale viene inviato al leader del gruppo di processi, viene trasmesso a tutti i processi figlio di questo gruppo.

Ecco il codice:

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()finisce per uccidere il processo di shell ed cmdè ancora in esecuzione.

Ho trovato una soluzione conveniente da:

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

Questo farà sì che cmd erediti il ​​processo della shell, invece di far avviare alla shell un processo figlio, che non viene ucciso. p.pidsarà quindi l'id del tuo processo cmd.

p.kill() dovrebbe funzionare.

Non so quale effetto avrà questo sulla tua pipa.

Se puoi usare psutil , allora funziona perfettamente:

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)

Potrei farlo usando

from subprocess import Popen

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

ha ucciso il cmd.exee il programma per il quale ho dato il comando.

(Su Windows)

Quando shell=Truela shell è il processo figlio e i comandi sono i suoi figli. Quindi, qualsiasi SIGTERMo SIGKILLucciderà il guscio, ma non i suoi processi figli, e non mi ricordo un buon modo per farlo. Il modo migliore a cui riesco a pensare è quello di usarlo shell=False, altrimenti quando si interrompe il processo della shell genitore, si lascerà un processo della shell defunto.

Nessuna di queste risposte ha funzionato per me, quindi sto lasciando il codice che ha funzionato. Nel mio caso, anche dopo aver terminato il processo .kill()e aver ottenuto un .poll()codice di ritorno, il processo non si è interrotto.

A seguito della subprocess.Popen documentazione :

"... per pulire correttamente un'applicazione ben educata dovrebbe interrompere il processo figlio e terminare la comunicazione ..."

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

Nel mio caso mi mancava la proc.communicate()chiamata dopo proc.kill(). Questo pulisce il processo stdin, stdout ... e termina il processo.

Come ha detto Sai, la shell è il bambino, quindi i segnali sono intercettati da essa - il modo migliore che ho trovato è usare shell = False e usare shlex per dividere la riga di comando:

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

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

Quindi p.kill () e p.terminate () dovrebbero funzionare come previsto.

cosa sento che potremmo usare:

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

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

questo non ucciderà tutte le tue attività ma il processo con p.pid

So che questa è una vecchia domanda, ma ciò può aiutare qualcuno alla ricerca di un metodo diverso. Questo è quello che uso su Windows per uccidere i processi che ho chiamato.

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

/ IM è il nome dell'immagine, puoi anche fare / PID se lo desideri. / T uccide sia il processo che i processi figlio. / F force lo termina. si, come ho impostato, è come farlo senza mostrare una finestra CMD. Questo codice è utilizzato in Python 3.

Invia il segnale a tutti i processi nel gruppo

    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)

Non ho visto questo menzionato qui, quindi lo sto mettendo fuori nel caso qualcuno ne avesse bisogno. Se tutto quello che vuoi fare è assicurarti che il tuo sottoprocesso si concluda correttamente, potresti metterlo in un gestore di contesto. Ad esempio, volevo che la mia stampante standard stampasse un'immagine in uscita e l'utilizzo del gestore del contesto garantiva la chiusura del sottoprocesso.

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...')

Credo che questo metodo sia anche multipiattaforma.