Jak zakończyć podprocesję Pythona uruchomioną z shell = True

Uruchamiam podproces za pomocą następującego polecenia:

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

Jednak gdy próbuję zabić za pomocą:

p.terminate()

lub

p.kill()

Polecenie działa w tle, więc zastanawiałem się, jak mogę faktycznie zakończyć proces.

Zauważ, że kiedy uruchamiam polecenie z:

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

To kończy się pomyślnie podczas wydawania p.terminate().

Użyj grupy procesów , aby umożliwić wysyłanie sygnału do całego procesu w grupach. W tym celu powinieneś dołączyć identyfikator sesji do procesu nadrzędnego procesów spawnowanych / potomnych, który w twoim przypadku jest powłoką. Dzięki temu będzie liderem grupy w procesach. Tak więc teraz, gdy sygnał jest wysyłany do lidera grupy procesów, jest on przekazywany do wszystkich procesów potomnych tej grupy.

Oto kod:

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()w końcu zabija proces powłoki i cmdnadal działa.

Znalazłem wygodny sposób naprawy:

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

Spowoduje to, że cmd odziedziczy proces powłoki, zamiast zmuszać powłokę do uruchomienia procesu potomnego, który nie zostanie zabity. p.pidbędzie wtedy identyfikatorem twojego procesu cmd.

p.kill() powinno działać.

Nie wiem jednak, jak to wpłynie na twoją fajkę.

Jeśli możesz użyć psutil , to działa idealnie:

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)

Mógłbym to zrobić za pomocą

from subprocess import Popen

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

zabił program cmd.exei program, dla którego wydałem polecenie.

(W systemie Windows)

Gdy shell=Truepowłoka jest procesem potomnym, a polecenia są jej potomkami. Więc każdy SIGTERMlub SIGKILLzabije powłokę, ale nie jego procesów potomnych, a ja nie pamiętam, to dobry sposób, aby to zrobić. Najlepszym sposobem, jaki mogę wymyślić, jest użycie shell=False, w przeciwnym razie, gdy zabijesz proces powłoki nadrzędnej, pozostawi on niedziałający proces powłoki.

Żadna z tych odpowiedzi nie działała dla mnie, więc zostawiam kod, który działał. W moim przypadku nawet po zabiciu procesu .kill()i otrzymaniu .poll()kodu powrotu proces nie został zakończony.

Zgodnie z subprocess.Popen dokumentacją :

„... w celu prawidłowego wyczyszczenia dobrze zachowana aplikacja powinna zabić proces potomny i zakończyć komunikację ...”

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

W moim przypadku brakowało połączenia proc.communicate()po proc.kill(). To czyści proces stdin, stdout ... i kończy proces.

Jak powiedział Sai, powłoka jest dzieckiem, więc przechwytuje przez nią sygnały - najlepszym sposobem, jaki znalazłem, jest użycie shell = False i użycie shlex do podzielenia linii poleceń:

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

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

Następnie p.kill () i p.terminate () powinny działać zgodnie z oczekiwaniami.

Czuję, że moglibyśmy użyć:

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

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

to nie zabije całego twojego zadania, ale proces z p.pid

Wiem, że to stare pytanie, ale może pomóc komuś, kto szuka innej metody. Tego używam w systemie Windows do zabijania wywoływanych przeze mnie procesów.

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

/ IM to nazwa obrazu, możesz także zrobić / PID, jeśli chcesz. / T zabija proces, podobnie jak procesy potomne. Siła / F ją kończy. si, jak już ustawiłem, to sposób, w jaki to robisz bez pokazywania okna CMD. Ten kod jest używany w Pythonie 3.

Wyślij sygnał do wszystkich procesów w grupie

    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)

Nie widziałem tego tutaj wspomnianego, więc zamieszczam to na wypadek, gdyby ktoś tego potrzebował. Jeśli wszystko, co chcesz zrobić, to upewnić się, że podproces zakończy się powodzeniem, możesz umieścić go w menedżerze kontekstu. Na przykład chciałem, aby moja standardowa drukarka wydrukowała obraz, a użycie menedżera kontekstu zapewniło zakończenie podprocesu.

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

Uważam, że ta metoda jest również wieloplatformowa.