Python locks.Event类代码示例

 def __init__(self):
     self.connected = False
     self.connected_event = Event()
     self.disconnected_event = Event()
     self.presence_queue = Queue()
     self.message_queue = Queue()
     self.error_queue = Queue()

class ResolveTimeoutTestCase(AsyncHTTPTestCase):
    def setUp(self):
        self.cleanup_event = Event()
        test = self

        # Dummy Resolver subclass that never finishes.
        class BadResolver(Resolver):
            @gen.coroutine
            def resolve(self, *args, **kwargs):
                yield test.cleanup_event.wait()
                # Return something valid so the test doesn't raise during cleanup.
                return [(socket.AF_INET, ("127.0.0.1", test.get_http_port()))]

        super(ResolveTimeoutTestCase, self).setUp()
        self.http_client = SimpleAsyncHTTPClient(resolver=BadResolver())

    def get_app(self):
        return Application([url("/hello", HelloWorldHandler)])

    def test_resolve_timeout(self):
        with self.assertRaises(HTTPTimeoutError):
            self.fetch("/hello", connect_timeout=0.1, raise_error=True)

        # Let the hanging coroutine clean up after itself
        self.cleanup_event.set()
        self.io_loop.run_sync(lambda: gen.sleep(0))

    def test_connect_timeout(self):
        timeout = 0.1

        cleanup_event = Event()
        test = self

        class TimeoutResolver(Resolver):
            async def resolve(self, *args, **kwargs):
                await cleanup_event.wait()
                # Return something valid so the test doesn't raise during shutdown.
                return [(socket.AF_INET, ("127.0.0.1", test.get_http_port()))]

        with closing(self.create_client(resolver=TimeoutResolver())) as client:
            with self.assertRaises(HTTPTimeoutError):
                yield client.fetch(
                    self.get_url("/hello"),
                    connect_timeout=timeout,
                    request_timeout=3600,
                    raise_error=True,
                )

        # Let the hanging coroutine clean up after itself. We need to
        # wait more than a single IOLoop iteration for the SSL case,
        # which logs errors on unexpected EOF.
        cleanup_event.set()
        yield gen.sleep(0.2)

 def get(self):
     logging.debug("queuing trigger")
     event = Event()
     self.queue.append(event.set)
     if self.get_argument("wake", "true") == "true":
         self.wake_callback()
     yield event.wait()

 def get(self):
     logging.debug("queuing trigger")
     self.queue.append(self.finish)
     if self.get_argument("wake", "true") == "true":
         self.wake_callback()
     never_finish = Event()
     yield never_finish.wait()

    def test_http10_no_content_length(self):
        # Regression test for a bug in which can_keep_alive would crash
        # for an HTTP/1.0 (not 1.1) response with no content-length.
        conn = HTTP1Connection(self.client_stream, True)
        self.server_stream.write(b"HTTP/1.0 200 Not Modified\r\n\r\nhello")
        self.server_stream.close()

        event = Event()
        test = self
        body = []

        class Delegate(HTTPMessageDelegate):
            def headers_received(self, start_line, headers):
                test.code = start_line.code

            def data_received(self, data):
                body.append(data)

            def finish(self):
                event.set()

        yield conn.read_response(Delegate())
        yield event.wait()
        self.assertEqual(self.code, 200)
        self.assertEqual(b''.join(body), b'hello')

    def test_read_until_regex_max_bytes(self):
        rs, ws = yield self.make_iostream_pair()
        closed = Event()
        rs.set_close_callback(closed.set)
        try:
            # Extra room under the limit
            fut = rs.read_until_regex(b"def", max_bytes=50)
            ws.write(b"abcdef")
            data = yield fut
            self.assertEqual(data, b"abcdef")

            # Just enough space
            fut = rs.read_until_regex(b"def", max_bytes=6)
            ws.write(b"abcdef")
            data = yield fut
            self.assertEqual(data, b"abcdef")

            # Not enough space, but we don't know it until all we can do is
            # log a warning and close the connection.
            with ExpectLog(gen_log, "Unsatisfiable read"):
                rs.read_until_regex(b"def", max_bytes=5)
                ws.write(b"123456")
                yield closed.wait()
        finally:
            ws.close()
            rs.close()

class QueueDriver:
    def __init__(self,**settings):
        self.settings = settings
        self._finished = Event()
        self._getters = collections.deque([])  # Futures.
        self._putters = collections.deque([])
        self.initialize(**settings)

    def initialize(self,**settings):
        pass

    def over(self):
        self._finished.set()

    def save(self):
        raise NotImplementedError()

    def get(self):
        raise NotImplementedError()

    def put(self):
        raise NotImplementedError()

    def join(self,timeout=None):
        return self._finished.wait(timeout)

class GameHandler(WebSocketHandler):
    def __init__(self, *args, **kwargs):
        super(GameHandler, self).__init__(*args, **kwargs)
        self.game = None
        self.player = None
        self.answered = Event()

    def open(self):
        pass

    def auth(self, data):
        self.game = GameLoader.load(data["game"])
        self.player = data["player"]
        self.game.handlers[self.player] = self
        self.game.introduce(self.player)

    def on_message(self, message):
        data = Dumper.load(message)
        if data["action"] == "auth":
            self.auth(data)
        if self.game is None:
            self.close()
        if data["action"] == "move":
            self.game.take_action(self.player, data)
        if data["action"] == "answer":
            self.answered.set()

    def on_close(self):
        print("WebSocket closed")

    def check_origin(self, origin):
        return True

 def start_night(self):
     self.look_own_card_done = Event()
     self.werewolves_wake_up_done = Event()
     yield [
         self.look_own_card(),
         self.werewolves_wake_up(),
         self.seer_wake_up(),
     ]

    class Waiter(object):
        def __init__(self):
            self.event = Event()

        @gen.coroutine
        def set(self):
            self.event.set()

        @gen.coroutine
        def wait(self):
            yield self.event.wait()

    def _start(self):
        if self.scheduler.status != 'running':
            yield self.scheduler._sync_center()
            self.scheduler.start()

        start_event = Event()
        self.coroutines = [
                self.scheduler.handle_queues(self.scheduler_queue, self.report_queue),
                self.report(start_event)]

        _global_executor[0] = self
        yield start_event.wait()
        logger.debug("Started scheduling coroutines. Synchronized")

    def test_idle_after_use(self):
        stream = yield self.connect()
        event = Event()
        stream.set_close_callback(event.set)

        # Use the connection twice to make sure keep-alives are working
        for i in range(2):
            stream.write(b"GET / HTTP/1.1\r\n\r\n")
            yield stream.read_until(b"\r\n\r\n")
            data = yield stream.read_bytes(11)
            self.assertEqual(data, b"Hello world")

        # Now let the timeout trigger and close the connection.
        yield event.wait()

 def __init__(self, logger, loop, sqs_client,
              metric_prefix='emitter'):
     self.emitter = sqs_client
     self.logger = logger
     self.loop = loop
     self.metric_prefix = metric_prefix
     self.output_error = Event()
     self.state = RUNNING
     self.sender_tag = 'sender:%s.%s' % (self.__class__.__module__,
                                         self.__class__.__name__)
     self._send_queue = Queue()
     self._should_flush_queue = Event()
     self._flush_handle = None
     self.loop.spawn_callback(self._onSend)

 def test_read_until_regex_max_bytes_ignores_extra(self):
     rs, ws = yield self.make_iostream_pair()
     closed = Event()
     rs.set_close_callback(closed.set)
     try:
         # Even though data that matches arrives the same packet that
         # puts us over the limit, we fail the request because it was not
         # found within the limit.
         ws.write(b"abcdef")
         with ExpectLog(gen_log, "Unsatisfiable read"):
             rs.read_until_regex(b"def", max_bytes=5)
             yield closed.wait()
     finally:
         ws.close()
         rs.close()