我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用tornado.gen.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())
