Come uccidere un processo figlio python creato con subprocess.check_output() quando il genitore muore?

Question

Sono in esecuzione su una macchina Linux uno script Python che crea un processo figlio utilizzando subprocess.check_output() come segue:

subprocess.check_output(["ls", "-l"], stderr=subprocess.STDOUT) 

Il problema è che, anche se il processo padre muore, il bambino è ancora in esecuzione . C'è un modo in cui posso uccidere il processo figlio anche quando il genitore muore?

Answer 1

Il tuo problema è con l'utilizzo di subprocess.check_output - lei ha ragione, non è possibile ottenere il bambino PID utilizzando tale interfaccia.Uso Popen invece:

proc = subprocess.Popen(["ls", "-l"], stdout=PIPE, stderr=PIPE) 

# Here you can get the PID 
global child_pid 
child_pid = proc.pid 

# Now we can wait for the child to complete 
(output, error) = proc.communicate() 

if error: 
    print "error:", error 

print "output:", output 

Per essere sicuri di uccidere il bambino in uscita:

import os 
import signal 
def kill_child(): 
    if child_pid is None: 
     pass 
    else: 
     os.kill(child_pid, signal.SIGTERM) 

import atexit 
atexit.register(kill_child) 

Answer 2

Manualmente si potrebbe fare questo:

ps aux | grep <process name>

ottenere il PID (seconda colonna) e

kill -9 <PID> -9 è quello di forzare ucciderlo

Answer 3

Non conosco le specifiche , ma il modo migliore è ancora di rilevare gli errori (e forse anche tutti gli errori) con il segnale e terminare qualsiasi processo rimanente.

import signal 
import sys 
import subprocess 
import os 

def signal_handler(signal, frame): 
    sys.exit(0) 
signal.signal(signal.SIGINT, signal_handler) 

a = subprocess.check_output(["ls", "-l"], stderr=subprocess.STDOUT) 

while 1: 
    pass # Press Ctrl-C (breaks the application and is catched by signal_handler() 

Questo è solo un mockup, avresti bisogno di catturare più di un semplice SIGINT ma l'idea potrebbe iniziare e avresti bisogno di verificare la presenza di processo generato in qualche modo ancora.

http://docs.python.org/2/library/os.html#os.kill http://docs.python.org/2/library/subprocess.html#subprocess.Popen.pid http://docs.python.org/2/library/subprocess.html#subprocess.Popen.kill

Mi consiglia di riscrivere una versione personalizzata di check_output causa come ho appena realizzato check_output è in realtà solo per il semplice ecc debug dal momento che non è possibile interagire tanto con esso durante l'esecuzione di ..

Rewrite check_output:

from subprocess import Popen, PIPE, STDOUT 
from time import sleep, time 

def checkOutput(cmd): 
    a = Popen('ls -l', shell=True, stdin=PIPE, stdout=PIPE, stderr=STDOUT) 
    print(a.pid) 
    start = time() 
    while a.poll() == None or time()-start <= 30: #30 sec grace period 
     sleep(0.25) 
    if a.poll() == None: 
     print('Still running, killing') 
     a.kill() 
    else: 
     print('exit code:',a.poll()) 
    output = a.stdout.read() 
    a.stdout.close() 
    a.stdin.close() 
    return output 

e fare quello vuoi con esso, pe raccoglie le esecuzioni attive in una variabile temporanea e le uccide all'uscita con il segnale o altri mezzi di errore/arresto del ciclo principale.

Alla fine, è ancora necessario prendere le terminazioni nell'applicazione principale per poter uccidere in sicurezza qualsiasi bambino, il modo migliore per avvicinarsi a questo è con try & except o signal.

Answer 4

Sì, è possibile ottenere questo con due metodi. Entrambi richiedono l'utilizzo di Popen anziché di check_output. Il primo è un metodo più semplice, utilizzando try..finally, come segue:

from contextlib import contextmanager 

@contextmanager 
def run_and_terminate_process(*args, **kwargs): 
try: 
    p = subprocess.Popen(*args, **kwargs) 
    yield p   
finally: 
    p.terminate() # send sigterm, or ... 
    p.kill()  # send sigkill 

def main(): 
    with run_and_terminate_process(args) as running_proc: 
     # Your code here, such as running_proc.stdout.readline() 

Questa cattura SIGINT (tastiera interrupt) e SIGTERM, ma non SIGKILL (se uccidi il tuo script con -9).

L'altro metodo è un po 'più complesso e utilizza il prtl PR_SET_PDEATHSIG di ctypes. Il sistema invierà un segnale al bambino una volta che il genitore esce per qualsiasi motivo (anche sigkill).

import signal 
import ctypes 
libc = ctypes.CDLL("libc.so.6") 
def set_pdeathsig(sig = signal.SIGTERM): 
    def callable(): 
     return libc.prctl(1, sig) 
    return callable 
p = subprocess.Popen(args, preexec_fn = set_pdeathsig(signal.SIGTERM))