Como finalizar um subprocesso python iniciado com shell = True

Estou iniciando um subprocesso com o seguinte comando:

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

No entanto, quando tento matar usando:

p.terminate()

ou

p.kill()

O comando continua sendo executado em segundo plano, então eu queria saber como posso realmente finalizar o processo.

Observe que quando executo o comando com:

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

Ele termina com êxito ao emitir o arquivo p.terminate().

Use um grupo de processos para permitir o envio de um sinal para todo o processo nos grupos. Para isso, você deve anexar uma identificação de sessão ao processo pai dos processos gerados / filhos, que é um shell no seu caso. Isso o tornará o líder do grupo nos processos. Portanto, agora, quando um sinal é enviado ao líder do grupo de processos, ele é transmitido a todos os processos filhos desse grupo.

Aqui está o 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()acaba matando o processo do shell e cmdainda está em execução.

Encontrei uma correção conveniente por:

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

Isso fará com que o cmd herde o processo do shell, em vez de o shell iniciar um processo filho, que não é morto. p.pidserá o ID do seu processo de cmd então.

p.kill() Deveria trabalhar.

Não sei que efeito isso terá no seu cachimbo.

Se você pode usar o psutil , isso funciona perfeitamente:

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)

Eu poderia fazer isso usando

from subprocess import Popen

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

matou o cmd.exe programa que eu dei o comando.

(No Windows)

Quando shell=Trueo shell é o processo filho e os comandos são seus filhos. Portanto, qualquer um SIGTERMou SIGKILLmatará o shell, mas não seus processos filhos, e não me lembro de uma boa maneira de fazê-lo. A melhor maneira de pensar é usar shell=False, caso contrário, quando você mata o processo de shell pai, ele deixa um processo de shell desativado.

Nenhuma dessas respostas funcionou para mim, então estou deixando o código que funcionou. No meu caso, mesmo depois de encerrar o processo .kill()e obter uma.poll() encerrar código de retorno, o processo não foi encerrado.

Seguindo a subprocess.Popen documentação :

"... para limpar adequadamente um aplicativo bem-comportado, deve matar o processo filho e concluir a comunicação ..."

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

No meu caso, estava faltando a proc.communicate()chamada depois proc.kill(). Isso limpa o processo stdin, stdout ... e encerra o processo.

Como Sai disse, o shell é o filho, então os sinais são interceptados por ele - a melhor maneira que eu encontrei é usar shell = False e usar shlex para dividir a linha de comando:

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

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

Então p.kill () e p.terminate () devem funcionar como você espera.

o que eu sinto que poderí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)

isso não matará toda a sua tarefa, mas o processo com o p.pid

Sei que essa é uma pergunta antiga, mas isso pode ajudar alguém que procura um método diferente. É isso que eu uso no Windows para matar processos que chamei.

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

/ IM é o nome da imagem, você também pode fazer / PID, se quiser. / T mata o processo e os processos filho. / F force termina. si, como eu o defini, é como você faz isso sem mostrar uma janela CMD. Este código é usado no python 3.

Envie o sinal para todos os processos em 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)

Eu não vi isso mencionado aqui, por isso estou colocando lá fora, caso alguém precise. Se tudo o que você deseja é garantir que seu subprocesso seja encerrado com êxito, você pode colocá-lo em um gerenciador de contexto. Por exemplo, eu queria que minha impressora padrão imprimisse uma imagem e o uso do gerenciador de contexto garantisse que o subprocesso fosse encerrado.

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

Eu acredito que esse método também é multiplataforma.