Cómo terminar un subproceso de Python lanzado con shell = True

Estoy iniciando un subproceso con el siguiente comando:

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

Sin embargo, cuando trato de matar usando:

p.terminate()

o

p.kill()

El comando sigue ejecutándose en segundo plano, así que me preguntaba cómo puedo realmente terminar el proceso.

Tenga en cuenta que cuando ejecuto el comando con:

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

Se termina con éxito al emitir el p.terminate().

Utilice un grupo de procesos para permitir el envío de una señal a todo el proceso en los grupos. Para eso, debe adjuntar una identificación de sesión al proceso primario de los procesos generados / secundarios, que es un shell en su caso. Esto lo convertirá en el líder del grupo de los procesos. Entonces, cuando se envía una señal al líder del grupo de procesos, se transmite a todos los procesos secundarios de este grupo.

Aquí está el código:

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()termina matando el proceso de shell y cmdtodavía se está ejecutando.

Encontré una solución conveniente para esto:

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

Esto hará que cmd herede el proceso de shell, en lugar de que el shell inicie un proceso hijo, que no se mata. p.pidserá la identificación de su proceso de cmd entonces.

p.kill() Deberia trabajar.

Sin embargo, no sé qué efecto tendrá esto en tu tubería.

Si puede usar psutil , entonces esto funciona perfectamente:

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)

Podría hacerlo usando

from subprocess import Popen

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

mató al cmd.exey al programa para el que le di la orden.

(En Windows)

Cuando shell=Trueel shell es el proceso hijo, y los comandos son sus hijos. Entonces cualquiera SIGTERMo SIGKILLmatará el shell pero no sus procesos hijos, y no recuerdo una buena manera de hacerlo. La mejor manera en que puedo pensar es en usar shell=False, de lo contrario, cuando elimine el proceso de shell principal, dejará un proceso de shell inactivo.

Ninguna de estas respuestas funcionó para mí, así que estoy dejando el código que funcionó. En mi caso, incluso después de finalizar el proceso .kill()y obtener un .poll()código de retorno, el proceso no finalizó.

Siguiendo la subprocess.Popen documentación :

"... con el fin de limpiar correctamente una aplicación con buen comportamiento debería matar el proceso secundario y finalizar la comunicación ..."

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

En mi caso, me faltaba el proc.communicate()después de llamar proc.kill(). Esto limpia el proceso stdin, stdout ... y termina el proceso.

Como dijo Sai, el shell es el niño, por lo que las señales son interceptadas por él; la mejor manera que he encontrado es usar shell = False y usar shlex para dividir la línea de comando:

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

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

Entonces p.kill () y p.terminate () deberían funcionar como espera.

lo que siento que podríamos usar:

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

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

esto no matará toda su tarea sino el proceso con el p.pid

Sé que esta es una vieja pregunta, pero puede ayudar a alguien que busca un método diferente. Esto es lo que uso en Windows para eliminar los procesos que he llamado.

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

/ IM es el nombre de la imagen, también puede hacer / PID si lo desea. / T mata tanto el proceso como los procesos secundarios. / F fuerza lo termina. si, como lo tengo configurado, es cómo hacer esto sin mostrar una ventana CMD. Este código se usa en python 3.

Enviar la señal a todos los procesos en grupo

    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)

No he visto esto mencionado aquí, así que lo estoy publicando en caso de que alguien lo necesite. Si todo lo que quiere hacer es asegurarse de que su subproceso finalice correctamente, puede ponerlo en un administrador de contexto. Por ejemplo, quería que mi impresora estándar imprimiera una imagen y al usar el administrador de contexto me aseguré de que el subproceso terminara.

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

Creo que este método también es multiplataforma.