def get(self, udid):
''' get new task '''
timeout = self.get_argument('timeout', 20.0)
if timeout is not None:
timeout = float(timeout)
que = self.ques[udid]
try:
item = yield que.get(timeout=time.time()+timeout) # timeout is a timestamp, strange
print 'get from queue:', item
self.write(item)
que.task_done()
except gen.TimeoutError:
print 'timeout'
self.write('')
finally:
self.finish()
python类TimeoutError()的实例源码
def get(self, udid):
''' get new task '''
timeout = self.get_argument('timeout', 20.0)
if timeout is not None:
timeout = float(timeout)
que = self.ques[udid]
try:
item = yield que.get(timeout=time.time()+timeout) # timeout is a timestamp, strange
print 'get from queue:', item
self.write(item)
que.task_done()
except gen.TimeoutError:
print 'timeout'
self.write('')
finally:
self.finish()
def test_handle_layer_error(self):
context = LayerContext(
mode="socks", src_stream=self.src_stream, port=443, scheme="h2")
layer_manager._handle_layer_error(gen.TimeoutError("timeout"), context)
context.src_stream.close.assert_called_once_with()
context.src_stream.reset_mock()
layer_manager._handle_layer_error(DestNotConnectedError("stream closed"), context)
context.src_stream.close.assert_not_called()
context.src_stream.reset_mock()
layer_manager._handle_layer_error(DestStreamClosedError("stream closed"), context)
context.src_stream.close.assert_called_once_with()
context.src_stream.reset_mock()
layer_manager._handle_layer_error(SrcStreamClosedError("stream closed"), context)
context.src_stream.close.assert_not_called()
context.src_stream.reset_mock()
layer_manager._handle_layer_error(iostream.StreamClosedError("stream closed"), context)
context.src_stream.close.assert_called_once_with()
def test_handle_connection_timeout(self):
self.layer.socks_conn = Mock()
self.layer.socks_conn.send = Mock(side_effect=self.collect_send_event)
socks_request = Request(
REQ_COMMAND["CONNECT"], ADDR_TYPE["IPV4"],
u"1.2.3.4", self.port)
self.layer.create_dest_stream = Mock(
side_effect=self.create_raise_exception_function(TimeoutError))
addr_future = self.layer.handle_request_and_create_destination(
socks_request)
with self.assertRaises(DestNotConnectedError):
yield addr_future
self.assertIsNotNone(self.event)
self.assertIsInstance(self.event, Response)
self.assertEqual(self.event.status, RESP_STATUS["NETWORK_UNREACHABLE"])
self.assertEqual(self.event.atyp, ADDR_TYPE["IPV4"])
self.assertEqual(self.event.addr, IPv4Address(u"1.2.3.4"))
self.assertEqual(self.event.port, self.port)
def _handle_layer_error(error, layer):
if isinstance(error, gen.TimeoutError):
logger.warn("{0} timeout".format(layer))
layer.src_stream.close()
elif isinstance(error, DestNotConnectedError):
logger.warn("{0} destination not connected".format(layer))
elif isinstance(error, DestStreamClosedError):
logger.error("{0} failed with {1}".format(layer, error))
layer.src_stream.close()
elif isinstance(error, SrcStreamClosedError):
logger.error("{0} failed with {1}".format(layer, error))
elif isinstance(error, iostream.StreamClosedError):
# NOTE: unhandled StreamClosedError, print stack to find out where
logger.exception("{0} failed with {1}".format(layer, error))
layer.src_stream.close()
elif isinstance(error, TlsError):
logger.error(error)
layer.src_stream.close()
else:
logger.exception("{0} unhandled exception {1}".format(layer, error))
layer.src_stream.close()
def handle_request_and_create_destination(self, event):
"""Handle the socks request from source
Create destination connection
Returns:
tuple: (dest_stream, host, port)
"""
if event.cmd != REQ_COMMAND["CONNECT"]:
logger.debug("Unsupport connect type")
yield self.send_event_to_src_conn(Response(
RESP_STATUS["COMMAND_NOT_SUPPORTED"],
event.atyp, event.addr, event.port), raise_exception=False)
raise ProtocolError("Unsupport bind type")
try:
dest_stream = yield self.create_dest_stream((str(event.addr), event.port))
except gen.TimeoutError as e:
yield self.handle_timeout_error(e, event)
except iostream.StreamClosedError as e:
yield self.handle_stream_closed_error(e, event)
else:
yield self.send_event_to_src_conn(Response(
RESP_STATUS["SUCCESS"],
event.atyp, event.addr, event.port))
raise gen.Return((dest_stream, event.addr, event.port))
def _set_timeout(future, timeout):
if timeout:
def on_timeout():
future.set_exception(gen.TimeoutError())
io_loop = ioloop.IOLoop.current()
timeout_handle = io_loop.add_timeout(timeout, on_timeout)
future.add_done_callback(
lambda _: io_loop.remove_timeout(timeout_handle))
def put(self, item, timeout=None):
"""Put an item into the queue, perhaps waiting until there is room.
Returns a Future, which raises `tornado.gen.TimeoutError` after a
timeout.
"""
try:
self.put_nowait(item)
except QueueFull:
future = Future()
self._putters.append((item, future))
_set_timeout(future, timeout)
return future
else:
return gen._null_future
def get(self, timeout=None):
"""Remove and return an item from the queue.
Returns a Future which resolves once an item is available, or raises
`tornado.gen.TimeoutError` after a timeout.
"""
future = Future()
try:
future.set_result(self.get_nowait())
except QueueEmpty:
self._getters.append(future)
_set_timeout(future, timeout)
return future
def join(self, timeout=None):
"""Block until all items in the queue are processed.
Returns a Future, which raises `tornado.gen.TimeoutError` after a
timeout.
"""
return self._finished.wait(timeout)
def wait(self, timeout=None):
"""Block until the internal flag is true.
Returns a Future, which raises `tornado.gen.TimeoutError` after a
timeout.
"""
if timeout is None:
return self._future
else:
return gen.with_timeout(timeout, self._future)
def acquire(self, timeout=None):
"""Attempt to lock. Returns a Future.
Returns a Future, which raises `tornado.gen.TimeoutError` after a
timeout.
"""
return self._block.acquire(timeout)
def test_wait_timeout_preempted(self):
c = locks.Condition()
# This fires before the wait times out.
self.io_loop.call_later(0.01, c.notify)
wait = c.wait(timedelta(seconds=0.02))
yield gen.sleep(0.03)
yield wait # No TimeoutError.
def test_event_timeout(self):
e = locks.Event()
with self.assertRaises(TimeoutError):
yield e.wait(timedelta(seconds=0.01))
# After a timed-out waiter, normal operation works.
self.io_loop.add_timeout(timedelta(seconds=0.01), e.set)
yield e.wait(timedelta(seconds=1))
def test_acquire_timeout(self):
sem = locks.Semaphore(2)
yield sem.acquire()
yield sem.acquire()
acquire = sem.acquire(timedelta(seconds=0.01))
self.io_loop.call_later(0.02, sem.release) # Too late.
yield gen.sleep(0.3)
with self.assertRaises(gen.TimeoutError):
yield acquire
sem.acquire()
f = sem.acquire()
self.assertFalse(f.done())
sem.release()
self.assertTrue(f.done())
def test_acquire_timeout_preempted(self):
sem = locks.Semaphore(1)
yield sem.acquire()
# This fires before the wait times out.
self.io_loop.call_later(0.01, sem.release)
acquire = sem.acquire(timedelta(seconds=0.02))
yield gen.sleep(0.03)
yield acquire # No TimeoutError.
def test_context_manager_timeout_error(self):
sem = locks.Semaphore(value=0)
with self.assertRaises(gen.TimeoutError):
with (yield sem.acquire(timedelta(seconds=0.01))):
pass
# Counter is still 0.
self.assertFalse(sem.acquire().done())
def test_acquire_timeout(self):
lock = locks.Lock()
lock.acquire()
with self.assertRaises(gen.TimeoutError):
yield lock.acquire(timeout=timedelta(seconds=0.01))
# Still locked.
self.assertFalse(lock.acquire().done())
def test_get_timeout(self):
q = queues.Queue()
get_timeout = q.get(timeout=timedelta(seconds=0.01))
get = q.get()
with self.assertRaises(TimeoutError):
yield get_timeout
q.put_nowait(0)
self.assertEqual(0, (yield get))
def test_get_clears_timed_out_putters(self):
q = queues.Queue(1)
# First putter succeeds, remainder block.
putters = [q.put(i, timedelta(seconds=0.01)) for i in range(10)]
put = q.put(10)
self.assertEqual(10, len(q._putters))
yield gen.sleep(0.02)
self.assertEqual(10, len(q._putters))
self.assertFalse(put.done()) # Final waiter is still active.
q.put(11)
self.assertEqual(0, (yield q.get())) # get() clears the waiters.
self.assertEqual(1, len(q._putters))
for putter in putters[1:]:
self.assertRaises(TimeoutError, putter.result)
def test_get_clears_timed_out_getters(self):
q = queues.Queue()
getters = [q.get(timedelta(seconds=0.01)) for _ in range(10)]
get = q.get()
self.assertEqual(11, len(q._getters))
yield gen.sleep(0.02)
self.assertEqual(11, len(q._getters))
self.assertFalse(get.done()) # Final waiter is still active.
q.get() # get() clears the waiters.
self.assertEqual(2, len(q._getters))
for getter in getters:
self.assertRaises(TimeoutError, getter.result)
def test_put_timeout_preempted(self):
q = queues.Queue(1)
q.put_nowait(0)
put = q.put(1, timeout=timedelta(seconds=0.01))
q.get()
yield gen.sleep(0.02)
yield put # No TimeoutError.
def test_put_clears_timed_out_putters(self):
q = queues.Queue(1)
# First putter succeeds, remainder block.
putters = [q.put(i, timedelta(seconds=0.01)) for i in range(10)]
put = q.put(10)
self.assertEqual(10, len(q._putters))
yield gen.sleep(0.02)
self.assertEqual(10, len(q._putters))
self.assertFalse(put.done()) # Final waiter is still active.
q.put(11) # put() clears the waiters.
self.assertEqual(2, len(q._putters))
for putter in putters[1:]:
self.assertRaises(TimeoutError, putter.result)
def test_put_clears_timed_out_getters(self):
q = queues.Queue()
getters = [q.get(timedelta(seconds=0.01)) for _ in range(10)]
get = q.get()
q.get()
self.assertEqual(12, len(q._getters))
yield gen.sleep(0.02)
self.assertEqual(12, len(q._getters))
self.assertFalse(get.done()) # Final waiters still active.
q.put(0) # put() clears the waiters.
self.assertEqual(1, len(q._getters))
self.assertEqual(0, (yield get))
for getter in getters:
self.assertRaises(TimeoutError, getter.result)
def test_join_timeout(self):
q = self.queue_class()
q.put(0)
with self.assertRaises(TimeoutError):
yield q.join(timeout=timedelta(seconds=0.01))
def test_timeout(self):
with self.assertRaises(gen.TimeoutError):
yield gen.with_timeout(datetime.timedelta(seconds=0.1),
Future())
def _set_timeout(future, timeout):
if timeout:
def on_timeout():
future.set_exception(gen.TimeoutError())
io_loop = ioloop.IOLoop.current()
timeout_handle = io_loop.add_timeout(timeout, on_timeout)
future.add_done_callback(
lambda _: io_loop.remove_timeout(timeout_handle))
def put(self, item, timeout=None):
"""Put an item into the queue, perhaps waiting until there is room.
Returns a Future, which raises `tornado.gen.TimeoutError` after a
timeout.
"""
try:
self.put_nowait(item)
except QueueFull:
future = Future()
self._putters.append((item, future))
_set_timeout(future, timeout)
return future
else:
return gen._null_future
def get(self, timeout=None):
"""Remove and return an item from the queue.
Returns a Future which resolves once an item is available, or raises
`tornado.gen.TimeoutError` after a timeout.
"""
future = Future()
try:
future.set_result(self.get_nowait())
except QueueEmpty:
self._getters.append(future)
_set_timeout(future, timeout)
return future
def join(self, timeout=None):
"""Block until all items in the queue are processed.
Returns a Future, which raises `tornado.gen.TimeoutError` after a
timeout.
"""
return self._finished.wait(timeout)
