Question

我有读取这样的网址的代码：

from urllib2 import Request, urlopen
req = Request(url)
for key, val in headers.items():
    req.add_header(key, val)
res = urlopen(req, timeout = timeout)
# This line blocks
content = res.read()

超时适用于urlopen（）调用。但是然后代码进入res.read（）调用，我想要读取响应数据，并且不会在那里应用超时。因此，读取调用可能几乎永远挂起，等待来自服务器的数据。我发现的唯一解决方案是使用一个信号来中断read（），因为我使用的是线程，所以不适合我。

还有哪些其他选择？是否有一个Python的HTTP库来处理读取超时？我看过httplib2和请求，他们似乎遇到了与上面相同的问题。我不想使用套接字模块编写自己的非阻塞网络代码，因为我认为应该已经有了一个库。

更新：以下所有解决方案都不适用于我。您可以自己查看设置套接字或urlopen超时在下载大文件时无效：

from urllib2 import urlopen
url = 'http://iso.linuxquestions.org/download/388/7163/http/se.releases.ubuntu.com/ubuntu-12.04.3-desktop-i386.iso'
c = urlopen(url)
c.read()

至少在使用Python 2.7.3的Windows上，超时被完全忽略。

Answer 1

我在测试中发现（使用描述here的技术）urlopen()调用中设置的超时也会影响read()调用：

import urllib2 as u
c = u.urlopen('http://localhost/', timeout=5.0)
s = c.read(1<<20)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib/python2.7/socket.py", line 380, in read
    data = self._sock.recv(left)
  File "/usr/lib/python2.7/httplib.py", line 561, in read
    s = self.fp.read(amt)
  File "/usr/lib/python2.7/httplib.py", line 1298, in read
    return s + self._file.read(amt - len(s))
  File "/usr/lib/python2.7/socket.py", line 380, in read
    data = self._sock.recv(left)
socket.timeout: timed out

也许这是新版本的功能？我在开箱即用的12.04 Ubuntu上使用Python 2.7。

Answer 2

如果没有通过线程或其他方式使用某种异步计时器，任何库都不可能这样做。原因是timeout，httplib和其他库中使用的urllib2参数会在基础timeout上设置socket。这实际上做了什么在documentation。

中解释

SO_RCVTIMEO

设置超时值，该值指定输入函数在完成之前等待的最长时间。它接受一个timeval结构，其中包含秒数和微秒数，指定等待输入操作完成的时间限制。如果接收操作在很长时间内被阻止而没有接收到其他数据，则如果没有收到数据，它将返回部分计数或errno设置为[EAGAIN]或[EWOULDBLOCK]。

粗体部分是关键。如果在socket.timeout窗口的持续时间内没有收到单个字节，则仅引发timeout。换句话说，这是接收字节之间的timeout。

使用threading.Timer的简单函数如下：

import httplib
import socket
import threading

def download(host, path, timeout = 10):
    content = None

    http = httplib.HTTPConnection(host)
    http.request('GET', path)
    response = http.getresponse()

    timer = threading.Timer(timeout, http.sock.shutdown, [socket.SHUT_RD])
    timer.start()

    try:
        content = response.read()
    except httplib.IncompleteRead:
        pass

    timer.cancel() # cancel on triggered Timer is safe
    http.close()

    return content

>>> host = 'releases.ubuntu.com'
>>> content = download(host, '/15.04/ubuntu-15.04-desktop-amd64.iso', 1)
>>> print content is None
True
>>> content = download(host, '/15.04/MD5SUMS', 1)
>>> print content is None
False

除了检查None之外，还可以捕获不在函数内部但在其外部的httplib.IncompleteRead异常。如果HTTP请求没有Content-Length标题，则后一种情况不起作用。

Answer 3

一种可能（不完美）的解决方案是设置全局套接字超时，更详细地解释here：

import socket
import urllib2

# timeout in seconds
socket.setdefaulttimeout(10)

# this call to urllib2.urlopen now uses the default timeout
# we have set in the socket module
req = urllib2.Request('http://www.voidspace.org.uk')
response = urllib2.urlopen(req)

但是，这仅在您愿意全局修改套接字模块的所有用户的超时时才有效。我在Celery任务中运行请求，因此这样做会使Celery工作程序代码本身的超时混乱。

我很高兴听到任何其他解决方案......

Answer 4

我希望这是一个常见的问题，然而 - 在任何地方都找不到答案......只是使用超时信号为此构建了一个解决方案：

import urllib2
import socket

timeout = 10
socket.setdefaulttimeout(timeout)

import time
import signal

def timeout_catcher(signum, _):
    raise urllib2.URLError("Read timeout")

signal.signal(signal.SIGALRM, timeout_catcher)

def safe_read(url, timeout_time):
    signal.setitimer(signal.ITIMER_REAL, timeout_time)
    url = 'http://uberdns.eu'
    content = urllib2.urlopen(url, timeout=timeout_time).read()
    signal.setitimer(signal.ITIMER_REAL, 0)
    # you should also catch any exceptions going out of urlopen here,
    # set the timer to 0, and pass the exceptions on.

解决方案信号部分的功劳归于此：btw：python timer mystery

Answer 5

pycurl.TIMEOUT option works for the whole request：

#!/usr/bin/env python3
"""Test that pycurl.TIMEOUT does limit the total request timeout."""
import sys
import pycurl

timeout = 2 #NOTE: it does limit both the total *connection* and *read* timeouts
c = pycurl.Curl()
c.setopt(pycurl.CONNECTTIMEOUT, timeout)
c.setopt(pycurl.TIMEOUT, timeout)
c.setopt(pycurl.WRITEFUNCTION, sys.stdout.buffer.write)
c.setopt(pycurl.HEADERFUNCTION, sys.stderr.buffer.write)
c.setopt(pycurl.NOSIGNAL, 1)
c.setopt(pycurl.URL, 'http://localhost:8000')
c.setopt(pycurl.HTTPGET, 1)
c.perform()

代码在~2秒内引发超时错误。我已经使用服务器测试了总读取超时，该服务器以多个块的形式发送响应，时间小于块之间的超时时间：

$ python -mslow_http_server 1

其中slow_http_server.py：

#!/usr/bin/env python
"""Usage: python -mslow_http_server [<read_timeout>]

   Return an http response with *read_timeout* seconds between parts.
"""
import time
try:
    from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer, test
except ImportError: # Python 3
    from http.server import BaseHTTPRequestHandler, HTTPServer, test

def SlowRequestHandlerFactory(read_timeout):
    class HTTPRequestHandler(BaseHTTPRequestHandler):
        def do_GET(self):
            n = 5
            data = b'1\n'
            self.send_response(200)
            self.send_header("Content-type", "text/plain; charset=utf-8")
            self.send_header("Content-Length", n*len(data))
            self.end_headers()
            for i in range(n):
                self.wfile.write(data)
                self.wfile.flush()
                time.sleep(read_timeout)
    return HTTPRequestHandler

if __name__ == "__main__":
    import sys
    read_timeout = int(sys.argv[1]) if len(sys.argv) > 1 else 5
    test(HandlerClass=SlowRequestHandlerFactory(read_timeout),
         ServerClass=HTTPServer)

我测试了the total connection timeout with http://google.com:22222。

Answer 6

任何异步网络库都应该允许在任何I / O操作上强制执行总超时，例如gevent code example：

#!/usr/bin/env python2
import gevent
import gevent.monkey # $ pip install gevent
gevent.monkey.patch_all()

import urllib2

with gevent.Timeout(2): # enforce total timeout
    response = urllib2.urlopen('http://localhost:8000')
    encoding = response.headers.getparam('charset')
    print response.read().decode(encoding)

这里是asyncio equivalent：

#!/usr/bin/env python3.5
import asyncio
import aiohttp # $ pip install aiohttp

async def fetch_text(url):
    response = await aiohttp.get(url)
    return await response.text()

text = asyncio.get_event_loop().run_until_complete(
    asyncio.wait_for(fetch_text('http://localhost:8000'), timeout=2))
print(text)

test http server is defined here。

Answer 7

这不是我看到的行为。当通话超时时我收到URLError：

from urllib2 import Request, urlopen
req = Request('http://www.google.com')
res = urlopen(req,timeout=0.000001)
#  Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
#  ...
#  raise URLError(err)
#  urllib2.URLError: <urlopen error timed out>

你不能抓住这个错误，然后避免尝试阅读res吗？当我在此之后尝试使用res.read()时，我得到NameError: name 'res' is not defined.这就是你需要的东西：

try:
    res = urlopen(req,timeout=3.0)
except:           
    print 'Doh!'
finally:
    print 'yay!'
    print res.read()

我想手动实现超时的方法是通过multiprocessing，不是吗？如果作业尚未完成，您可以终止它。

Answer 8

在read语句中出现套接字超时问题。对我有用的是把urlopen和read都放在try语句中。希望这有帮助！

使用urllib2或任何其他http库读取超时

8 个答案: