Использование модуля «подпроцесс» с таймаутом

325

Вот код Python для запуска произвольной команды, возвращающей свои stdoutданные, или для создания исключения для ненулевых кодов выхода:

proc = subprocess.Popen(
    cmd,
    stderr=subprocess.STDOUT,  # Merge stdout and stderr
    stdout=subprocess.PIPE,
    shell=True)

communicate используется для ожидания завершения процесса:

stdoutdata, stderrdata = proc.communicate()

subprocessМодуль не поддерживает тайм - аута - способность убивать процесс , протекающий в течение более чем X количества секунд - таким образом, communicateможет длиться вечно бежать.

Как проще всего реализовать таймауты в программе на Python, предназначенной для работы в Windows и Linux?

Шридхар Ратнакумар
источник
2
Соответствующая запись в системе отслеживания проблем Python: bugs.python.org/issue5673
Шридхар Ратнакумар
10
Используйте pypi.python.org/pypi/subprocess32 для Python2.x. Это бэкпорт Python 3.x. У него есть аргумент времени ожидания для call () и wait ().
Геттли
1
pypi.python.org/pypi/subprocess32 не работает в Windows :(
adrianX

Ответы:

170

В Python 3.3+:

from subprocess import STDOUT, check_output

output = check_output(cmd, stderr=STDOUT, timeout=seconds)

output является байтовой строкой, которая содержит объединенную команду stdout, данные stderr.

check_outputповышает CalledProcessErrorненулевой статус выхода, как указано в тексте вопроса, в отличие от proc.communicate()метода.

Я удалил, shell=Trueпотому что это часто используется без необходимости. Вы всегда можете добавить его обратно, если это cmdдействительно необходимо. Если вы добавите shell=Trueie, если дочерний процесс порождает своих потомков; check_output()может вернуться намного позже, чем указывает время ожидания, см. Ошибка таймаута подпроцесса .

Функция тайм-аута доступна в Python 2.x через subprocess32обратный порт модуля 3.2+ подпроцесса.

JFS
источник
17
Действительно, поддержка тайм-аута подпроцесса существует в бэкпорте subprocess32, который я поддерживаю для использования на Python 2. pypi.python.org/pypi/subprocess32
gps
8
@gps Sridhar попросил о кроссплатформенном решении, в то время как ваш бэкпорт поддерживает только POSIX: когда я попробовал его, MSVC пожаловался (ожидаемый) на отсутствие unistd.h :)
Shmil The Cat
Если вам не нужен вывод, вы можете просто использовать subprocess.call.
Кайл Гибсон
Начиная с Python3.5, используйте subprocess.run () с capture_output = True и используйте параметр encoding для получения вывода usefoul.
М.Кеспер
1
@MKesper: 1 check_output()- это предпочтительный способ получения вывода (он возвращает результат напрямую, не игнорирует ошибки, он доступен всегда). 2 run()- более гибкий, но run()игнорирует ошибку по умолчанию и требует дополнительных шагов для получения выходных данных 3 check_output()- реализован в терминахrun() и, следовательно, принимает большинство одинаковых аргументов. 4 нит: capture_outputдоступен начиная с 3,7, а не 3,5
JFS
205

Я не знаю много о деталях низкого уровня; но, учитывая, что в python 2.6 API предлагает возможность ожидания потоков и завершения процессов, как насчет запуска процесса в отдельном потоке?

import subprocess, threading

class Command(object):
    def __init__(self, cmd):
        self.cmd = cmd
        self.process = None

    def run(self, timeout):
        def target():
            print 'Thread started'
            self.process = subprocess.Popen(self.cmd, shell=True)
            self.process.communicate()
            print 'Thread finished'

        thread = threading.Thread(target=target)
        thread.start()

        thread.join(timeout)
        if thread.is_alive():
            print 'Terminating process'
            self.process.terminate()
            thread.join()
        print self.process.returncode

command = Command("echo 'Process started'; sleep 2; echo 'Process finished'")
command.run(timeout=3)
command.run(timeout=1)

Вывод этого фрагмента в моей машине:

Thread started
Process started
Process finished
Thread finished
0
Thread started
Process started
Terminating process
Thread finished
-15

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

Я не проверял в Windows; но, помимо обновления примера команды, я думаю, что она должна работать, так как я не нашел в документации ничего, что говорило бы о том, что thread.join или process.terminate не поддерживаются.

jcollado
источник
16
+1 За независимость от платформы. Я запустил это на Linux и Windows 7 (Cygwin и обычный Windows Python) - работает, как и ожидалось, во всех трех случаях.
phooji
7
Я немного изменил ваш код, чтобы иметь возможность передавать нативные попенские кварги и помещать их в суть. Теперь он готов использовать многоцелевой; gist.github.com/1306188
Кирпит
2
Для любого, у кого была проблема @redice, этот вопрос может помочь. Короче говоря, если вы используете shell = True, оболочка становится дочерним процессом, который уничтожается, и его команда (дочерний процесс дочернего процесса) живет.
Anson
6
Этот ответ не обеспечивает ту же функциональность оригинала, так как он не возвращает стандартный вывод.
Стивенбез
2
thread.is_alive может привести к состоянию гонки. См ostricher.com/2015/01/python-subprocess-with-timeout
ChaimKut
132

Ответ jcollado может быть упрощен с помощью класса threading.Timer :

import shlex
from subprocess import Popen, PIPE
from threading import Timer

def run(cmd, timeout_sec):
    proc = Popen(shlex.split(cmd), stdout=PIPE, stderr=PIPE)
    timer = Timer(timeout_sec, proc.kill)
    try:
        timer.start()
        stdout, stderr = proc.communicate()
    finally:
        timer.cancel()

# Examples: both take 1 second
run("sleep 1", 5)  # process ends normally at 1 second
run("sleep 5", 1)  # timeout happens at 1 second
sussudio
источник
11
+1 за простое портативное решение. Вам не нужно lambda:t = Timer(timeout, proc.kill)
JFS
3
+1 Это должен быть принятый ответ, потому что он не требует изменения способа запуска процесса.
Дейв Брэнтон
1
Почему это требует лямбда? Не может ли связанный метод p.kill быть использован без лямбды?
Дэнни Стейпл
//, Хотели бы вы включить пример использования этого?
Натан Басанезе
1
@tuk timer.isAlive()before timer.cancel()означает, что все закончилось нормально
Чарльз
83

Если вы на Unix,

import signal
  ...
class Alarm(Exception):
    pass

def alarm_handler(signum, frame):
    raise Alarm

signal.signal(signal.SIGALRM, alarm_handler)
signal.alarm(5*60)  # 5 minutes
try:
    stdoutdata, stderrdata = proc.communicate()
    signal.alarm(0)  # reset the alarm
except Alarm:
    print "Oops, taking too long!"
    # whatever else
Алекс Мартелли
источник
3
Что ж, меня интересует кроссплатформенное решение, которое работает, по крайней мере, на win / linux / mac.
Шридхар Ратнакумар
1
Мне нравится этот Unix-ориентированный подход. В идеале можно было бы объединить это с подходом, специфичным для окон (с использованием CreateProcess и Jobs) ... но пока решение, приведенное ниже, является простым, легким и пока работает.
Шридхар Ратнакумар
3
Я добавил портативное решение, см. Мой ответ
flybywire
4
Это решение будет работать only_if signal.signal (signal.SIGALARM, alarm_handler) вызывается из основного потока. См. Документацию для сигнала
volatilevoid
К сожалению, при запуске (в linux) в контексте модуля Apache (например, mod_python, mod_perl или mod_php) я обнаружил, что использование сигналов и аварийных сигналов запрещено (предположительно, потому что они мешают собственной логике IPC в Apache). Таким образом, чтобы достичь цели тайм-аута команды, я был вынужден написать «родительские циклы», которые запускают дочерний процесс, а затем сидят в «спящем» цикле, наблюдая за часами (и, возможно, также отслеживая выходные данные дочернего процесса).
Питер
44

Вот решение Алекса Мартелли как модуля с правильным процессом убийства. Другие подходы не работают, потому что они не используют proc.communicate (). Поэтому, если у вас есть процесс, который производит много выходных данных, он заполнит свой выходной буфер и затем заблокируется, пока вы не прочитаете что-то из него.

from os import kill
from signal import alarm, signal, SIGALRM, SIGKILL
from subprocess import PIPE, Popen

def run(args, cwd = None, shell = False, kill_tree = True, timeout = -1, env = None):
    '''
    Run a command with a timeout after which it will be forcibly
    killed.
    '''
    class Alarm(Exception):
        pass
    def alarm_handler(signum, frame):
        raise Alarm
    p = Popen(args, shell = shell, cwd = cwd, stdout = PIPE, stderr = PIPE, env = env)
    if timeout != -1:
        signal(SIGALRM, alarm_handler)
        alarm(timeout)
    try:
        stdout, stderr = p.communicate()
        if timeout != -1:
            alarm(0)
    except Alarm:
        pids = [p.pid]
        if kill_tree:
            pids.extend(get_process_children(p.pid))
        for pid in pids:
            # process might have died before getting to this line
            # so wrap to avoid OSError: no such process
            try: 
                kill(pid, SIGKILL)
            except OSError:
                pass
        return -9, '', ''
    return p.returncode, stdout, stderr

def get_process_children(pid):
    p = Popen('ps --no-headers -o pid --ppid %d' % pid, shell = True,
              stdout = PIPE, stderr = PIPE)
    stdout, stderr = p.communicate()
    return [int(p) for p in stdout.split()]

if __name__ == '__main__':
    print run('find /', shell = True, timeout = 3)
    print run('find', shell = True)
Björn Lindqvist
источник
3
Это не будет работать на окнах, плюс порядок функций обратный.
Хэмиш Грубиджан
3
Это иногда приводит к исключению, когда другой обработчик регистрирует себя на SIGALARM и убивает процесс, прежде чем этот «убивает», добавленный обходной путь. Кстати, отличный рецепт! Я использовал это для запуска 50 000 ошибочных процессов до сих пор без остановки или сбоя обработчика.
Ярослав Булатов
Как это можно изменить для запуска в многопоточном приложении? Я пытаюсь использовать его из рабочих потоков и получитьValueError: signal only works in main thread
Вим
@ Ярослав Булатов Спасибо за информацию. Какой обходной путь вы добавили для решения упомянутой проблемы?
jpswain
1
Просто добавил блок "try; catch", он внутри кода. Кстати, в долгосрочной перспективе это оказалось источником проблем, потому что вы можете установить только один обработчик SIGALARM, а другие процессы могут сбросить его. Одно из решений этой проблемы приведено здесь - stackoverflow.com/questions/6553423/…
Ярослав Булатов
18

Я изменил ответ sussudio . Теперь функция возвращает: ( returncode, stdout, stderr, timeout) - stdoutи stderrдекодируется для UTF-8 строки

def kill_proc(proc, timeout):
  timeout["value"] = True
  proc.kill()

def run(cmd, timeout_sec):
  proc = subprocess.Popen(shlex.split(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  timeout = {"value": False}
  timer = Timer(timeout_sec, kill_proc, [proc, timeout])
  timer.start()
  stdout, stderr = proc.communicate()
  timer.cancel()
  return proc.returncode, stdout.decode("utf-8"), stderr.decode("utf-8"), timeout["value"]
Michal Zmuda
источник
18

удивил, что никто не упомянул использование timeout

timeout 5 ping -c 3 somehost

Очевидно, что это не подходит для каждого варианта использования, но если вы работаете с простым сценарием, это трудно победить.

Также доступно как gtimeout в coreutils через homebrewдля пользователей Mac.

Карстен
источник
1
вы имели в виду: proc = subprocess.Popen(['/usr/bin/timeout', str(timeout)] + cmd, ...). Есть ли timeoutкоманда на Windows, как спрашивает OP?
JFS
В Windows можно использовать такие приложения, как git bash, которые позволяют использовать утилиты bash в Windows.
Каушик Ачарья
@KaushikAcharya, даже если вы используете git bash, когда python вызывает подпроцесс, он будет работать в Windows, поэтому этот обход не будет работать.
Наман Чикара
16

timeoutтеперь поддерживается с помощью call()и communicate()в модуле подпроцесса (по состоянию на Python3.3):

import subprocess

subprocess.call("command", timeout=20, shell=True)

Это вызовет команду и вызовет исключение

subprocess.TimeoutExpired

если команда не заканчивается через 20 секунд.

Затем вы можете обработать исключение, чтобы продолжить ваш код, например:

try:
    subprocess.call("command", timeout=20, shell=True)
except subprocess.TimeoutExpired:
    # insert code here

Надеюсь это поможет.

James
источник
существует существующий ответ, в котором упоминается timeoutпараметр . Хотя упоминание об этом еще раз не повредит.
JFS
// Я думаю, что OP ищет решение для старого Python.
Натан Басанезе
11

Другой вариант - записать во временный файл, чтобы предотвратить блокировку stdout вместо необходимости опроса с connect (). Это сработало для меня, где другие ответы не сделали; например на окнах.

    outFile =  tempfile.SpooledTemporaryFile() 
    errFile =   tempfile.SpooledTemporaryFile() 
    proc = subprocess.Popen(args, stderr=errFile, stdout=outFile, universal_newlines=False)
    wait_remaining_sec = timeout

    while proc.poll() is None and wait_remaining_sec > 0:
        time.sleep(1)
        wait_remaining_sec -= 1

    if wait_remaining_sec <= 0:
        killProc(proc.pid)
        raise ProcessIncompleteError(proc, timeout)

    # read temp streams from start
    outFile.seek(0);
    errFile.seek(0);
    out = outFile.read()
    err = errFile.read()
    outFile.close()
    errFile.close()
Matt
источник
Кажется неполным - что такое tempfile?
spiderplant0
Включите «import tempfile», «import time» и «shell = True» в вызове «Popen» (будьте осторожны с «shell = True»)!
Эдуардо Лусио
11

Я не знаю , почему это не так , но упоминался Python 3.5, есть новая subprocess.runуниверсальная команда (которая предназначена для замены check_call, check_output...) и который имеет timeoutпараметр , а также.

subprocess.run (args, *, stdin = Нет, ввод = Нет, stdout = Нет, stderr = Нет, shell = False, cwd = Нет, тайм-аут = Нет, проверка = Ложь, кодировка = Нет, ошибки = Нет)

Run the command described by args. Wait for command to complete, then return a CompletedProcess instance.

Возникает subprocess.TimeoutExpiredисключение по истечении времени ожидания.

Жан-Франсуа Фабр
источник
6

Вот мое решение, я использовал Thread и Event:

import subprocess
from threading import Thread, Event

def kill_on_timeout(done, timeout, proc):
    if not done.wait(timeout):
        proc.kill()

def exec_command(command, timeout):

    done = Event()
    proc = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

    watcher = Thread(target=kill_on_timeout, args=(done, timeout, proc))
    watcher.daemon = True
    watcher.start()

    data, stderr = proc.communicate()
    done.set()

    return data, stderr, proc.returncode

В действии:

In [2]: exec_command(['sleep', '10'], 5)
Out[2]: ('', '', -9)

In [3]: exec_command(['sleep', '10'], 11)
Out[3]: ('', '', 0)
RSK
источник
5

Решением, которое я использую, является префикс команды оболочки с ограничением по времени . Если команда занимает слишком много времени, timelimit остановит его, и Popen получит код возврата, установленный timelimit. Если это> 128, это означает, что ограничение по времени убило процесс.

Смотрите также подпроцесс python с тайм-аутом и большим выводом (> 64 КБ)

оборота борцмейер
источник
Я использую аналогичный инструмент под названием timeout- packages.ubuntu.com/search?keywords=timeout - но ни один из них не работает в Windows, не так ли?
Шридхар Ратнакумар
5

Я добавил решение с многопоточностью jcolladoв мой модуль Python easyprocess .

Установка:

pip install easyprocess

Пример:

from easyprocess import Proc

# shell is not supported!
stdout=Proc('ping localhost').call(timeout=1.5).stdout
print stdout
понты
источник
Модуль easyprocess ( code.activestate.com/pypm/easyprocess ) работал для меня, даже используя его из многопроцессорной обработки.
iChux
5

если вы используете Python 2, попробуйте

import subprocess32

try:
    output = subprocess32.check_output(command, shell=True, timeout=3)
except subprocess32.TimeoutExpired as e:
    print e
Тхонг Ку
источник
1
Вероятно, не работает на Windows, как было задано в первоначальном вопросе
Жан-Франсуа Т.
5

Добавление команды Linux timeoutне является плохим решением проблемы, и оно сработало для меня.

cmd = "timeout 20 "+ cmd
subprocess.Popen(cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(output, err) = p.communicate()
Викрам Хосакоте
источник
Как я могу получить распечатанные строки во время выполнения подпроцесса? - Выходные сообщения возвращаются подпроцессом.
Аммад
3

Я реализовал то, что я мог собрать из нескольких из них. Это работает в Windows, и так как это вики сообщества, я думаю, я бы тоже поделился своим кодом:

class Command(threading.Thread):
    def __init__(self, cmd, outFile, errFile, timeout):
        threading.Thread.__init__(self)
        self.cmd = cmd
        self.process = None
        self.outFile = outFile
        self.errFile = errFile
        self.timed_out = False
        self.timeout = timeout

    def run(self):
        self.process = subprocess.Popen(self.cmd, stdout = self.outFile, \
            stderr = self.errFile)

        while (self.process.poll() is None and self.timeout > 0):
            time.sleep(1)
            self.timeout -= 1

        if not self.timeout > 0:
            self.process.terminate()
            self.timed_out = True
        else:
            self.timed_out = False

Затем из другого класса или файла:

        outFile =  tempfile.SpooledTemporaryFile()
        errFile =   tempfile.SpooledTemporaryFile()

        executor = command.Command(c, outFile, errFile, timeout)
        executor.daemon = True
        executor.start()

        executor.join()
        if executor.timed_out:
            out = 'timed out'
        else:
            outFile.seek(0)
            errFile.seek(0)
            out = outFile.read()
            err = errFile.read()

        outFile.close()
        errFile.close()
joslinm
источник
На самом деле, это, вероятно, не работает. В terminate()Функция отмечает поток прекращенным, но фактически не прекращается поток! Я могу проверить это в * nix, но у меня нет компьютера с Windows для тестирования.
Dotancohen
2

Когда вы поймете, что весь процесс работает в * unix, вы легко найдете более простое решение:

Рассмотрим этот простой пример того, как сделать методу timeabletable connect () meth с помощью select.select () (в настоящее время доступно почти все на * nix). Это также можно записать с помощью epoll / poll / kqueue, но вариант select.select () может быть хорошим примером для вас. И основные ограничения select.select () (скорость и 1024 макс. Fds) не применимы для вашей задачи.

Это работает под * nix, не создает потоков, не использует сигналы, может быть запущено из любого потока (не только основного), и достаточно быстро для чтения 250 Мбит / с данных со стандартного выхода на моей машине (i5 2.3 ГГц).

Существует проблема в присоединении stdout / stderr в конце связи. Если у вас огромный вывод программы, это может привести к большому использованию памяти. Но вы можете позвонить общаться () несколько раз с меньшими тайм-аутами.

class Popen(subprocess.Popen):
    def communicate(self, input=None, timeout=None):
        if timeout is None:
            return subprocess.Popen.communicate(self, input)

        if self.stdin:
            # Flush stdio buffer, this might block if user
            # has been writing to .stdin in an uncontrolled
            # fashion.
            self.stdin.flush()
            if not input:
                self.stdin.close()

        read_set, write_set = [], []
        stdout = stderr = None

        if self.stdin and input:
            write_set.append(self.stdin)
        if self.stdout:
            read_set.append(self.stdout)
            stdout = []
        if self.stderr:
            read_set.append(self.stderr)
            stderr = []

        input_offset = 0
        deadline = time.time() + timeout

        while read_set or write_set:
            try:
                rlist, wlist, xlist = select.select(read_set, write_set, [], max(0, deadline - time.time()))
            except select.error as ex:
                if ex.args[0] == errno.EINTR:
                    continue
                raise

            if not (rlist or wlist):
                # Just break if timeout
                # Since we do not close stdout/stderr/stdin, we can call
                # communicate() several times reading data by smaller pieces.
                break

            if self.stdin in wlist:
                chunk = input[input_offset:input_offset + subprocess._PIPE_BUF]
                try:
                    bytes_written = os.write(self.stdin.fileno(), chunk)
                except OSError as ex:
                    if ex.errno == errno.EPIPE:
                        self.stdin.close()
                        write_set.remove(self.stdin)
                    else:
                        raise
                else:
                    input_offset += bytes_written
                    if input_offset >= len(input):
                        self.stdin.close()
                        write_set.remove(self.stdin)

            # Read stdout / stderr by 1024 bytes
            for fn, tgt in (
                (self.stdout, stdout),
                (self.stderr, stderr),
            ):
                if fn in rlist:
                    data = os.read(fn.fileno(), 1024)
                    if data == '':
                        fn.close()
                        read_set.remove(fn)
                    tgt.append(data)

        if stdout is not None:
            stdout = ''.join(stdout)
        if stderr is not None:
            stderr = ''.join(stderr)

        return (stdout, stderr)
Вадим Финт
источник
2
Это решает только половину проблемы Unix.
Spaceghost
2

Вы можете сделать это используя select

import subprocess
from datetime import datetime
from select import select

def call_with_timeout(cmd, timeout):
    started = datetime.now()
    sp = subprocess.Popen(cmd, stdout=subprocess.PIPE)
    while True:
        p = select([sp.stdout], [], [], timeout)
        if p[0]:
            p[0][0].read()
        ret = sp.poll()
        if ret is not None:
            return ret
        if (datetime.now()-started).total_seconds() > timeout:
            sp.kill()
            return None
dspeyer
источник
1

Я успешно использовал killableprocess в Windows, Linux и Mac. Если вы используете Cygwin Python, вам понадобится версия killableprocess OSAF, потому что в противном случае родные процессы Windows не будут уничтожены.

Хейкки Тойвонен
источник
Похоже, что killableprocess не добавляет время ожидания для вызова Popen.communicate ().
Вим Коенен
1

Хотя я не смотрел на это широко, это декоратор, который я нашел в ActiveState, кажется весьма полезным для такого рода вещей. Вместе с тем subprocess.Popen(..., close_fds=True), по крайней мере, я готов к написанию сценариев в Python.

Этеш Чоудхури
источник
Этот декоратор использует signal.alarm, который недоступен в Windows.
13
1

Это решение убивает дерево процессов в случае shell = True, передает параметры процессу (или нет), имеет тайм-аут и получает выходные данные stdout, stderr и процесса обратного вызова (он использует psutil для kill_proc_tree). Это было основано на нескольких решениях, опубликованных в SO, включая Jcollado. Публикация в ответ на комментарии Ансона и Храдице в ответе jcollado. Протестировано в Windows Srvr 2012 и Ubuntu 14.04. Обратите внимание, что для Ubuntu вам нужно изменить вызов parent.children (...) на parent.get_children (...).

def kill_proc_tree(pid, including_parent=True):
  parent = psutil.Process(pid)
  children = parent.children(recursive=True)
  for child in children:
    child.kill()
  psutil.wait_procs(children, timeout=5)
  if including_parent:
    parent.kill()
    parent.wait(5)

def run_with_timeout(cmd, current_dir, cmd_parms, timeout):
  def target():
    process = subprocess.Popen(cmd, cwd=current_dir, shell=True, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)

    # wait for the process to terminate
    if (cmd_parms == ""):
      out, err = process.communicate()
    else:
      out, err = process.communicate(cmd_parms)
    errcode = process.returncode

  thread = Thread(target=target)
  thread.start()

  thread.join(timeout)
  if thread.is_alive():
    me = os.getpid()
    kill_proc_tree(me, including_parent=False)
    thread.join()
Томас
источник
1

Есть идея создать подкласс класса Popen и расширить его с помощью некоторых простых декораторов методов. Давайте назовем это ExpurablePopen.

from logging import error
from subprocess import Popen
from threading import Event
from threading import Thread


class ExpirablePopen(Popen):

    def __init__(self, *args, **kwargs):
        self.timeout = kwargs.pop('timeout', 0)
        self.timer = None
        self.done = Event()

        Popen.__init__(self, *args, **kwargs)

    def __tkill(self):
        timeout = self.timeout
        if not self.done.wait(timeout):
            error('Terminating process {} by timeout of {} secs.'.format(self.pid, timeout))
            self.kill()

    def expirable(func):
        def wrapper(self, *args, **kwargs):
            # zero timeout means call of parent method
            if self.timeout == 0:
                return func(self, *args, **kwargs)

            # if timer is None, need to start it
            if self.timer is None:
                self.timer = thr = Thread(target=self.__tkill)
                thr.daemon = True
                thr.start()

            result = func(self, *args, **kwargs)
            self.done.set()

            return result
        return wrapper

    wait = expirable(Popen.wait)
    communicate = expirable(Popen.communicate)


if __name__ == '__main__':
    from subprocess import PIPE

    print ExpirablePopen('ssh -T git@bitbucket.org', stdout=PIPE, timeout=1).communicate()
Александр Яковлев
источник
1

У меня была проблема с тем, что я хотел завершить многопоточный подпроцесс, если это заняло больше времени, чем заданное время ожидания. Я хотел установить время ожидания Popen(), но оно не сработало. Затем я понял, что Popen().wait()он равен, call()и у меня возникла идея установить тайм-аут в .wait(timeout=xxx)методе, который наконец заработал. Таким образом, я решил это так:

import os
import sys
import signal
import subprocess
from multiprocessing import Pool

cores_for_parallelization = 4
timeout_time = 15  # seconds

def main():
    jobs = [...YOUR_JOB_LIST...]
    with Pool(cores_for_parallelization) as p:
        p.map(run_parallel_jobs, jobs)

def run_parallel_jobs(args):
    # Define the arguments including the paths
    initial_terminal_command = 'C:\\Python34\\python.exe'  # Python executable
    function_to_start = 'C:\\temp\\xyz.py'  # The multithreading script
    final_list = [initial_terminal_command, function_to_start]
    final_list.extend(args)

    # Start the subprocess and determine the process PID
    subp = subprocess.Popen(final_list)  # starts the process
    pid = subp.pid

    # Wait until the return code returns from the function by considering the timeout. 
    # If not, terminate the process.
    try:
        returncode = subp.wait(timeout=timeout_time)  # should be zero if accomplished
    except subprocess.TimeoutExpired:
        # Distinguish between Linux and Windows and terminate the process if 
        # the timeout has been expired
        if sys.platform == 'linux2':
            os.kill(pid, signal.SIGTERM)
        elif sys.platform == 'win32':
            subp.terminate()

if __name__ == '__main__':
    main()
Šjor
источник
0

К сожалению, я обязан очень строгими правилами раскрытия исходного кода моим работодателем, поэтому я не могу предоставить настоящий код. Но, на мой вкус, лучшее решение - создать подкласс, переопределяющий Popen.wait()опрос, а не ждать бесконечно, и Popen.__init__принять параметр тайм-аута. Как только вы это сделаете, все остальные Popenметоды (которые вызывают wait) будут работать, как ожидается, в том числе communicate.

Патрик Наркинский
источник
0

https://pypi.python.org/pypi/python-subprocess2 предоставляет расширения для модуля подпроцесса, которые позволяют ждать до определенного периода времени, в противном случае прерываются.

Итак, чтобы подождать до 10 секунд до завершения процесса, в противном случае убейте:

pipe  = subprocess.Popen('...')

timeout =  10

results = pipe.waitOrTerminate(timeout)

Это совместимо как с Windows, так и с Unix. «results» - это словарь, он содержит «returnCode», который является возвратом приложения (или «None», если его нужно было убить), а также «actionTaken». который будет "SUBPROCESS2_PROCESS_COMPLETED", если процесс завершен нормально, или маской "SUBPROCESS2_PROCESS_TERMINATED" и SUBPROCESS2_PROCESS_KILLED в зависимости от предпринятых действий (подробности см. в документации)

Тим Саванна
источник
0

для python 2.6+ используйте gevent

 from gevent.subprocess import Popen, PIPE, STDOUT

 def call_sys(cmd, timeout):
      p= Popen(cmd, shell=True, stdout=PIPE)
      output, _ = p.communicate(timeout=timeout)
      assert p.returncode == 0, p. returncode
      return output

 call_sys('./t.sh', 2)

 # t.sh example
 sleep 5
 echo done
 exit 1
бее
источник
0

Python 2.7

import time
import subprocess

def run_command(cmd, timeout=0):
    start_time = time.time()
    df = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    while timeout and df.poll() == None:
        if time.time()-start_time >= timeout:
            df.kill()
            return -1, ""
    output = '\n'.join(df.communicate()).strip()
    return df.returncode, output
Джой Ван
источник
-1
import subprocess, optparse, os, sys, re, datetime, threading, time, glob, shutil, xml.dom.minidom, traceback

class OutputManager:
    def __init__(self, filename, mode, console, logonly):
        self.con = console
        self.logtoconsole = True
        self.logtofile = False

        if filename:
            try:
                self.f = open(filename, mode)
                self.logtofile = True
                if logonly == True:
                    self.logtoconsole = False
            except IOError:
                print (sys.exc_value)
                print ("Switching to console only output...\n")
                self.logtofile = False
                self.logtoconsole = True

    def write(self, data):
        if self.logtoconsole == True:
            self.con.write(data)
        if self.logtofile == True:
            self.f.write(data)
        sys.stdout.flush()

def getTimeString():
        return time.strftime("%Y-%m-%d", time.gmtime())

def runCommand(command):
    '''
    Execute a command in new thread and return the
    stdout and stderr content of it.
    '''
    try:
        Output = subprocess.Popen(command, stdout=subprocess.PIPE, shell=True).communicate()[0]
    except Exception as e:
        print ("runCommand failed :%s" % (command))
        print (str(e))
        sys.stdout.flush()
        return None
    return Output

def GetOs():
    Os = ""
    if sys.platform.startswith('win32'):
        Os = "win"
    elif sys.platform.startswith('linux'):
        Os = "linux"
    elif sys.platform.startswith('darwin'):
        Os = "mac"
    return Os


def check_output(*popenargs, **kwargs):
    try:
        if 'stdout' in kwargs: 
            raise ValueError('stdout argument not allowed, it will be overridden.') 

        # Get start time.
        startTime = datetime.datetime.now()
        timeoutValue=3600

        cmd = popenargs[0]

        if sys.platform.startswith('win32'):
            process = subprocess.Popen( cmd, stdout=subprocess.PIPE, shell=True) 
        elif sys.platform.startswith('linux'):
            process = subprocess.Popen( cmd , stdout=subprocess.PIPE, shell=True ) 
        elif sys.platform.startswith('darwin'):
            process = subprocess.Popen( cmd , stdout=subprocess.PIPE, shell=True ) 

        stdoutdata, stderrdata = process.communicate( timeout = timeoutValue )
        retcode = process.poll()

        ####################################
        # Catch crash error and log it.
        ####################################
        OutputHandle = None
        try:
            if retcode >= 1:
                OutputHandle = OutputManager( 'CrashJob_' + getTimeString() + '.txt', 'a+', sys.stdout, False)
                OutputHandle.write( cmd )
                print (stdoutdata)
                print (stderrdata)
                sys.stdout.flush()
        except Exception as e:
            print (str(e))

    except subprocess.TimeoutExpired:
            ####################################
            # Catch time out error and log it.
            ####################################
            Os = GetOs()
            if Os == 'win':
                killCmd = "taskkill /FI \"IMAGENAME eq {0}\" /T /F"
            elif Os == 'linux':
                killCmd = "pkill {0)"
            elif Os == 'mac':
                # Linux, Mac OS
                killCmd = "killall -KILL {0}"

            runCommand(killCmd.format("java"))
            runCommand(killCmd.format("YouApp"))

            OutputHandle = None
            try:
                OutputHandle = OutputManager( 'KillJob_' + getTimeString() + '.txt', 'a+', sys.stdout, False)
                OutputHandle.write( cmd )
            except Exception as e:
                print (str(e))
    except Exception as e:
            for frame in traceback.extract_tb(sys.exc_info()[2]):
                        fname,lineno,fn,text = frame
                        print "Error in %s on line %d" % (fname, lineno)
PeterZhao
источник
это мерзость
Кори Голдберг
-2

Просто пытался написать что-то попроще.

#!/usr/bin/python

from subprocess import Popen, PIPE
import datetime
import time 

popen = Popen(["/bin/sleep", "10"]);
pid = popen.pid
sttime = time.time();
waittime =  3

print "Start time %s"%(sttime)

while True:
    popen.poll();
    time.sleep(1)
    rcode = popen.returncode
    now = time.time();
    if [ rcode is None ]  and  [ now > (sttime + waittime) ] :
        print "Killing it now"
        popen.kill()
Джабир Ахмед
источник
time.sleep (1) - очень плохая идея - представьте, что вы хотите запустить много команд, которые будут занимать около 0,002 сек. Вам лучше подождать, пока poll () (см. Select, для Linux рекомендуется epol :)
ddzialak