Python Event.wait方法代码示例

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
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)

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
 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()

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
 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()

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
    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()

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
    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')

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
    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()

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
def test_exit_callback():
    to_child = mp_context.Queue()
    from_child = mp_context.Queue()
    evt = Event()

    @gen.coroutine
    def on_stop(_proc):
        assert _proc is proc
        yield gen.moment
        evt.set()

    # Normal process exit
    proc = AsyncProcess(target=feed, args=(to_child, from_child))
    evt.clear()
    proc.set_exit_callback(on_stop)
    proc.daemon = True

    yield proc.start()
    yield gen.sleep(0.05)
    assert proc.is_alive()
    assert not evt.is_set()

    to_child.put(None)
    yield evt.wait(timedelta(seconds=3))
    assert evt.is_set()
    assert not proc.is_alive()

    # Process terminated
    proc = AsyncProcess(target=wait)
    evt.clear()
    proc.set_exit_callback(on_stop)
    proc.daemon = True

    yield proc.start()
    yield gen.sleep(0.05)
    assert proc.is_alive()
    assert not evt.is_set()

    yield proc.terminate()
    yield evt.wait(timedelta(seconds=3))
    assert evt.is_set()

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
    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")

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
    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()

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
 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()

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
    def test_prepare_curl_callback_stack_context(self):
        exc_info = []
        error_event = Event()

        def error_handler(typ, value, tb):
            exc_info.append((typ, value, tb))
            error_event.set()
            return True

        with ExceptionStackContext(error_handler):
            request = HTTPRequest(self.get_url('/custom_reason'),
                                  prepare_curl_callback=lambda curl: 1 / 0)
        yield [error_event.wait(), self.http_client.fetch(request)]
        self.assertEqual(1, len(exc_info))
        self.assertIs(exc_info[0][0], ZeroDivisionError)

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
 def test_read_until_regex_max_bytes_inline(self):
     rs, ws = yield self.make_iostream_pair()
     closed = Event()
     rs.set_close_callback(closed.set)
     try:
         # Similar to the error case in the previous test, but the
         # ws writes first so rs reads are satisfied
         # inline.  For consistency with the out-of-line case, we
         # do not raise the error synchronously.
         ws.write(b"123456")
         with ExpectLog(gen_log, "Unsatisfiable read"):
             rs.read_until_regex(b"def", max_bytes=5)
             yield closed.wait()
     finally:
         ws.close()
         rs.close()

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
    def asyncSetUp(self):
        listener, port = bind_unused_port()
        event = Event()

        def accept_callback(conn, addr):
            self.server_stream = IOStream(conn)
            self.addCleanup(self.server_stream.close)
            event.set()

        add_accept_handler(listener, accept_callback)
        self.client_stream = IOStream(socket.socket())
        self.addCleanup(self.client_stream.close)
        yield [self.client_stream.connect(('127.0.0.1', port)),
               event.wait()]
        self.io_loop.remove_handler(listener)
        listener.close()

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
    def _start(self, timeout=3, **kwargs):
        if isinstance(self._start_arg, Scheduler):
            self.scheduler = self._start_arg
            self.center = self._start_arg.center
        if isinstance(self._start_arg, str):
            ip, port = tuple(self._start_arg.split(':'))
            self._start_arg = (ip, int(port))
        if isinstance(self._start_arg, tuple):
            r = coerce_to_rpc(self._start_arg, timeout=timeout)
            try:
                ident = yield r.identity()
            except (StreamClosedError, OSError):
                raise IOError("Could not connect to %s:%d" % self._start_arg)
            if ident['type'] == 'Center':
                self.center = r
                self.scheduler = Scheduler(self.center, loop=self.loop,
                                           **kwargs)
                self.scheduler.listen(0)
            elif ident['type'] == 'Scheduler':
                self.scheduler = r
                self.scheduler_stream = yield connect(*self._start_arg)
                yield write(self.scheduler_stream, {'op': 'register-client',
                                                    'client': self.id})
                if 'center' in ident:
                    cip, cport = ident['center']
                    self.center = rpc(ip=cip, port=cport)
                else:
                    self.center = self.scheduler
            else:
                raise ValueError("Unknown Type")

        if isinstance(self.scheduler, Scheduler):
            if self.scheduler.status != 'running':
                yield self.scheduler.sync_center()
                self.scheduler.start(0)
            self.scheduler_queue = Queue()
            self.report_queue = Queue()
            self.coroutines.append(self.scheduler.handle_queues(
                self.scheduler_queue, self.report_queue))

        start_event = Event()
        self.coroutines.append(self._handle_report(start_event))

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

# 需要导入模块: from tornado.locks import Event [as 别名]
# 或者: from tornado.locks.Event import wait [as 别名]
class ImageMutex():

    def __init__(self):
        self._mutex = Event()
        self._blocked = count()
        self._building_log = []
        self._exception = None

    @gen.coroutine
    def block(self):
        value = self._blocked.__next__()  # single bytecode operation
        if value:
            yield self._mutex.wait()
        return value

    def __enter__(self):
        if self._exception is not None:
            raise self._exception
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self._building_log = []
        if isinstance(exc_value, Exception):
            self._exception = exc_value
        self._mutex.set()

    def timeout_happened(self):
        self._exception = Exception('This image is too heavy to build')
        self._building_log = []

    def add_to_log(self, message, level=1):
        if not self._exception:
            self._building_log.append({
                'text': message,
                'level': level
            })

    @property
    def building_log(self):
        return self._building_log

    @property
    def last_exception(self):
        return self._exception