Ответ 1

Ваша проблема заключается в использовании subprocess.check_output - вы правы, вы не можете получить дочерний PID с помощью этого интерфейса. Вместо этого используйте Popen:

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

Чтобы вы убили ребенка при выходе:

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)

Ответ 2

Да, вы можете добиться этого двумя способами. Для обоих из них требуется использовать Popen вместо check_output. Первый - более простой метод, используя try..finally, следующим образом:

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()

Это приведет к сбою синтаксиса (прерывание клавиатуры) и сигмерм, но не sigkill (если вы убьете script с -9).

Другой метод немного сложнее и использует ctypes prctl PR_SET_PDEATHSIG. Система отправит сигнал ребенку после выхода родителя по какой-либо причине (даже сигкилл).

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

Ответ 3

Не знаю специфики, но лучше всего по-прежнему ловить ошибки (и, возможно, даже все ошибки) с сигналом и завершать любые оставшиеся процессы там.

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()

Это всего лишь макет, вам нужно поймать больше, чем просто SIGINT, но идея может помочь вам начать, и вам нужно будет как-то проверить процесс порождения.

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

Я бы рекомендовал переписать персонализированную версию check_output, поскольку я только что понял, что check_output действительно просто для простой отладки и т.д., так как вы не можете так много взаимодействовать с ней во время выполнения.

Переписать 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

И сделайте все, что вы хотели бы с ним, возможно, сохраните активные исполнения во временной переменной и убейте их при выходе с сигналом или другими средствами для интродукции ошибок/выключения основного цикла.

В конце концов, вам все равно нужно поймать завершение в главном приложении, чтобы безопасно убить любых дочерних элементов, лучший способ приблизиться к этому - с помощью try & except или signal.

Ответ 4

Вручную вы можете сделать это:

ps aux | grep <process name>

получить PID (второй столбец) и

kill -9 <PID> -9 - заставить его убить.