相关疑难解决方法(0)

可能重复:
具有超时的子进程

在Python中执行以下操作的最简单方法是什么:

• 运行外部流程
• 捕获字符串,stderr和退出状态中的stdout
• 设置超时.

我想要这样的东西:

import proc

try:
    status, stdout, stderr = proc.run(["ls", "-l"], timeout=10)
except proc.Timeout:
    print "failed"

我想使用子进程来运行程序,我需要限制执行时间.例如,如果运行时间超过2秒,我想杀死它.

对于常见程序,kill()运行良好.但是,如果我尝试运行/usr/bin/time something,kill()不能真正杀死该程序.

我的下面的代码似乎不能很好地工作.该程序仍在运行.

import subprocess
import time

exec_proc = subprocess.Popen("/usr/bin/time -f \"%e\\n%M\" ./son > /dev/null", stdout = subprocess.PIPE, stderr = subprocess.STDOUT, shell = True)

max_time = 1
cur_time = 0.0
return_code = 0
while cur_time <= max_time:
    if exec_proc.poll() != None:
        return_code = exec_proc.poll()
        break
    time.sleep(0.1)
    cur_time += 0.1

if cur_time > max_time:
    exec_proc.kill()

我正在使用依赖于SIGALRM来设置警报中断的配方 - 使用带有超时的模块"子进程 "

问题是我有多个Python脚本使用signal.ALARM进程来设置超时,并且只调用最新的警报.有什么好方法可以改善这些多个Python函数设置超时？

我编写了一个Python脚本,使用wget下载并转换许多图像,然后通过链接subprocess调用使用ImageMagick :

for img in images: 
  convert_str = 'wget -O  ./img/merchant/download.jpg %s; ' % img['url'] 
  convert_str += 'convert ./img/merchant/download.jpg -resize 110x110 ' 
  convert_str += ' -background white -gravity center -extent 110x110' 
  convert_str += ' ./img/thumbnails/%s.jpg' % img['id']
  subprocess.call(convert_str, shell=True)

如果我convert_str在命令行手动运行内容,它似乎没有任何错误,但如果我运行脚本使其重复执行,它有时会给我以下输出:

--2013-06-19 04:01:50--  
http://www.lkbennett.com/medias/sys_master/8815507341342.jpg
Resolving www.lkbennett.com... 157.125.69.163
Connecting to www.lkbennett.com|157.125.69.163|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 22306 (22K) [image/jpeg]
Saving to: `/home/me/webapps/images/m/img/merchant/download.jpg'

 0K .......... .......... .                               100% 1.03M=0.02s

2013-06-19 04:01:50 (1.03 MB/s) - 
`/home/annaps/webapps/images/m/img/merchant/download.jpg' …

我意识到这可能与使用带有超时的模块'subprocess'重复.如果是的话,我道歉,只想澄清一些事情.

我正在创建一个子进程,我想运行一段时间,如果它在那段时间内没有完成,我希望它抛出一个错误.以下代码中的某些内容是否有效,或者我们是否必须使用其他问题中回答的信号？提前致谢!:

def run(self):
    self.runTestCmd()
    self.waitTestComplete(self.timeout)

def runTestCmd(self):
    self.proc = subprocess.Popen("./configure", shell=True)

def waitTestComplete(self, timeout):
    st = time.time() 
    while (time.time()-st) < timeout:
        if self.proc.poll() == 0:
            return True
        else:
            time.sleep(2)
    raise TestError("timed out waiting for test to complete")

有没有办法让产生新线程的父级捕获产生的线程异常？以下是我想要完成的一个真实的基本示例.当引发Exception时它应该停止计数,但我不知道如何捕获它.异常线程安全吗？我希望能够使用该Subprocess模块,但我不习惯使用Python 2.3,我不知道如何做到这一点.可能使用该threading模块？

import time
import thread

def test(): 
    try:
        test = thread.start_new_thread(watchdog, (5,))
        count(10)
    except:
        print('Stopped Counting')

def count(num):
    for i in range(num):
        print i
        time.sleep(1)

def watchdog(timeout):
    time.sleep(timeout)
    raise Exception('Ran out of time')

if __name__ == '__main__':
    test()

UPDATE

我的原始代码有点误导.它真的在寻找更像这样的东西:

import time
import thread
import os

def test(): 
    try:
        test = thread.start_new_thread(watchdog, (5,))
        os.system('count_to_10.exe')
    except:
        print('Stopped Counting')

def watchdog(timeout):
    time.sleep(timeout)
    raise Exception('Ran out of time')

if __name__ == '__main__':
    test()

我试图创建一个看门狗来杀死os.system调用,如果该程序由于某种原因挂起.

我有一个python脚本,它启动了几个进程.每个进程基本上只调用一个shell脚本:

from multiprocessing import Process
import os
import logging

def thread_method(n = 4):
    global logger
    command = "~/Scripts/run.sh " + str(n) + " >> /var/log/mylog.log"
    if (debug): logger.debug(command)
    os.system(command)

我发布了几个这些线程,它们都是在后台运行的.我希望在这些线程上有一个超时,这样如果超过超时,它们就会被杀死:

t = []
for x in range(10):
    try:
        t.append(Process(target=thread_method, args=(x,) ) )
        t[-1].start()
    except Exception as e:
        logger.error("Error: unable to start thread")
        logger.error("Error message: " + str(e))
logger.info("Waiting up to 60 seconds to allow threads to finish")
t[0].join(60)
for n in range(len(t)):
    if t[n].is_alive():
    logger.info(str(n) + " is still alive …

我在Python 3中生成具有超时的异步子进程时遇到问题.

我想要实现的目标:我希望异步生成多个进程而不等待结果,但我还要确保每个生成的进程都会在给定的超时内结束.

我在这里发现了类似的问题:在Python中使用模块'subprocess'和超时以及异步后台进程？但他们没有解决我的问题.

我的代码看起来像这样.我有使用模块'subprocess'和超时建议的Command类:

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

  def run(self, timeout):
    def target():
      print('Thread started')
      args = shlex.split(self.cmd)
      self.process = subprocess.Popen(args, 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()

然后当我想要产生子进程时:

for system in systems:
  for service in to_spawn_system_info:
    command_str = "cd {0} && python proc_ip.py {1} {2} 0 2>>{3}".format(home_dir,
        service, system, service_log_dir)
    command = Command(command_str)
    command.run(timeout=60)

当我运行它时,输出似乎等待每个命令生成并结束.我明白了

Thread …

我想在多线程python程序的每个线程中执行外部程序.

假设最大运行时间设置为1秒.如果启动过程在1秒内完成,则主程序捕获其输出以进行进一步处理.如果它没有在1秒内完成,主程序只是终止它并启动另一个新进程.

怎么实现这个？

我正在 python 脚本下运行，该脚本最终运行 shell 脚本，该脚本为我提供了 k8s 命名空间中正在运行的版本列表。得到结果，但需要时间 > 3 秒。因此，这导致了松弛的“操作超时”。我是Python新手，已经阅读了有关延迟的各种文档，但这并没有帮助，因为这些文档非常复杂。

from subprocess import Popen, PIPE
from subprocess import check_output
from flask import Flask

def get_shell_script_output_using_communicate():
    session = subprocess.Popen(['./version.sh'], stdout=PIPE, stderr=PIPE)
    stdout, stderr = session.communicate()
    if stderr:
        raise Exception("Error "+str(stderr))
    return stdout.decode('utf-8')

def get_shell_script_output_using_check_output():
    stdout = check_output(['./version.sh']).decode('utf-8')
    return stdout

app = Flask(__name__)

@app.route('/test',methods=['POST'])
def home():
    return '`Version List` ```'+get_shell_script_output_using_check_output()+'```'

app.run(host='0.0.0.0', port=5002, debug=True)

即使命令花费超过 10 秒，是否有办法获得响应？谢谢！

有没有办法从python启动和停止进程？我说的是在正常运行时用 ctrl+z 停止的继续进程。我想启动这个过程，等待一段时间然后终止它。我正在使用Linux。

这个问题不像我的，因为在那里，用户只需要运行这个过程。我需要运行它并停止它。

我正在通过 SSH 发送命令。这个特定的命令恰好告诉机器重新启动。不幸的是，这会挂起我的 SSH 会话并且不会返回，因此我的脚本无法继续转发到其他任务。

我尝试过修改命令本身以包含“退出”和/或转义命令的各种组合，但在这些情况下，机器都不会在重新启动和关闭 SSH 会话的命令时启动。我还尝试过 SSH 的 ConnectTimeout 和 ClientAlive 选项，但它们似乎使重新启动命令被忽略。

我在这里缺少一些明显的命令吗？