def test_periodic(self): test = self ioloop = get_event_loop() d = pulsar.Deferred() # class p: def __init__(self, loops): self.loops = loops self.c = 0 def __call__(self): self.c += 1 if self.c == self.loops: try: raise ValueError('test periodic') except Exception: mute_failure(test, sys.exc_info()) raise finally: d.callback(self.c) # every = 2 loops = 2 track = p(loops) start = time.time() periodic = ioloop.call_repeatedly(every, track) loop = yield d taken = time.time() - start self.assertEqual(loop, loops) self.assertTrue(taken > every * loops) self.assertTrue(taken < every * loops + 2) self.assertTrue(periodic.cancelled) self.assertFalse(ioloop.has_callback(periodic.handler))
def test_periodic(self): test = self ioloop = get_event_loop() d = pulsar.Deferred() # class p: def __init__(self, loops): self.loops = loops self.c = 0 def __call__(self): self.c += 1 if self.c == self.loops: try: raise ValueError('test periodic') except Exception: mute_failure(test, sys.exc_info()) raise finally: d.callback(self.c) # every = 2 loops = 2 track = p(loops) start = time.time() periodic = ioloop.call_repeatedly(every, track) loop = yield d taken = time.time() - start self.assertEqual(loop, loops) self.assertTrue(taken > every*loops) self.assertTrue(taken < every*loops + 2) self.assertTrue(periodic.cancelled) self.assertFalse(ioloop.has_callback(periodic.handler))
def test_call_at(self): ioloop = get_event_loop() d1 = pulsar.Deferred() d2 = pulsar.Deferred() c1 = ioloop.call_at(ioloop.timer()+1, lambda: d1.callback(ioloop.timer())) c2 = ioloop.call_later(1, lambda: d2.callback(ioloop.timer())) t1, t2 = yield pulsar.multi_async((d1, d2)) self.assertTrue(t1 <= t2)
def test_call_at(self): ioloop = get_event_loop() d1 = pulsar.Deferred() d2 = pulsar.Deferred() c1 = ioloop.call_at(ioloop.timer() + 1, lambda: d1.callback(ioloop.timer())) c2 = ioloop.call_later(1, lambda: d2.callback(ioloop.timer())) t1, t2 = yield pulsar.multi_async((d1, d2)) self.assertTrue(t1 <= t2)
def test_call_soon(self): ioloop = get_event_loop() d = pulsar.Deferred() callback = lambda: d.callback(current_thread().ident) cbk = ioloop.call_soon(callback) self.assertEqual(cbk.callback, callback) self.assertEqual(cbk.args, ()) # we should be able to wait less than a second yield d self.assertEqual(d.result, ioloop.tid)
def __init__(self, *args, **kwargs): _from_sock = kwargs.pop('_from_sock', None) if _from_sock: self._sock = _from_sock else: self._sock = socket(*args, **kwargs) self._sock.setblocking(False) self._event_loop = get_event_loop() assert isinstance(self._loop, GreenUnixSelectorLoop), \ 'GreenUnixSelectorLoop event loop is required'
def test_start_serving_ipv6(self): loop = get_event_loop() sockets = yield loop.start_serving(Protocol,'::1', 0) self.assertEqual(len(sockets), 1) sock = sockets[0] self.assertEqual(sock.family, socket.AF_INET6) address = sock.getsockname() faddress = format_address(address) self.assertEqual(faddress, '[::1]:%s' % address[1]) loop.stop_serving(sock) self.assertTrue(is_socket_closed(sock))
def test_event_loop(self): '''Test event loop in test worker''' worker = pulsar.get_actor() loop = pulsar.get_request_loop() event_loop = get_event_loop() self.assertTrue(loop.running) self.assertTrue(event_loop.running) self.assertNotEqual(loop, event_loop) self.assertEqual(worker.event_loop, event_loop) self.assertEqual(worker.tid, worker.event_loop.tid) self.assertNotEqual(worker.tid, loop.tid) self.assertTrue(str(event_loop))
def test_call_later_cheat(self): ioloop = get_event_loop() def dummy(d, sleep=None): d.callback(time.time()) if sleep: time.sleep(sleep) d1 = pulsar.Deferred() d2 = pulsar.Deferred() ioloop.call_later(0, dummy, d1, 0.2) ioloop.call_later(-5, dummy, d2) yield d2 self.assertTrue(d1.result < d2.result)
def test_create_connection_local_addr(self): from test.support import find_unused_port loop = get_event_loop() with run_test_server(loop, EchoServerProtocol) as server: yield server.start_serving() host = server.address[0] port = find_unused_port() tr, pr = yield loop.create_connection(SimpleProtocol, *server.address, local_addr=(host, port)) expected = pr.transport.get_extra_info('socket').getsockname()[1] self.assertEqual(port, expected) tr.close()
def test_create_connection_error(self): loop = get_event_loop() exc = None try: yield loop.create_connection(Protocol, '127.0.0.1', 0, sock=1) except ValueError as e: exc = e assert exc exc = None try: yield loop.create_connection(Protocol) except ValueError as e: exc = e assert exc
def test_start_serving_error(self): loop = get_event_loop() exc = None try: yield loop.start_serving(Protocol, '127.0.0.1', 0, sock=1) except ValueError as e: exc = e assert exc exc = None try: yield loop.start_serving(Protocol) except ValueError as e: exc = e assert exc
def test_pool(self): pool = self.get_pool(threads=2) self.assertEqual(pool._state, 0) self.assertEqual(pool.status, 'running') self.assertEqual(pool.event_loop, get_event_loop()) self.assertNotEqual(pool.event_loop, get_request_loop()) #give a chance to start the pool yield async_while(3, lambda: not pool.num_threads) self.assertEqual(pool.num_threads, 2) pool.close() self.assertEqual(pool._state, 1) self.assertEqual(pool.status, 'closed') pool.join() yield async_while(3, lambda: pool.num_threads) self.assertFalse(pool.num_threads)
def test_start_serving(self): protocol_factory = lambda : Connection() loop = get_event_loop() sockets = yield loop.start_serving(server_protocol,'127.0.0.1', 0) self.assertEqual(len(sockets), 1) socket = sockets[0] fn = socket.fileno() events, read, write, error = loop.io.handlers(fn) self.assertEqual(events, READ) self.assertTrue(read) self.assertFalse(write) self.assertFalse(error) loop.stop_serving(socket) self.assertRaises(KeyError, loop.io.handlers, fn) self.assertTrue(is_socket_closed(socket))
def get_event_loop(self): '''Return the :class:`EventLoop` used by this :class:`Client`. The event loop can be set during initialisation. If :attr:`force_sync` is ``True`` a specialised event loop is created. ''' if self.event_loop: return self.event_loop elif self.force_sync: logger = logging.getLogger(('pulsar.%s' % self).lower()) self.event_loop = new_event_loop(iothreadloop=False, logger=logger) return self.event_loop else: return get_event_loop()
def test_call_later(self): ioloop = get_event_loop() d = pulsar.Deferred() timeout1 = ioloop.call_later(20, lambda: d.callback(current_thread().ident)) timeout2 = ioloop.call_later(10, lambda: d.callback(current_thread().ident)) # lets wake the ioloop self.assertTrue(ioloop.has_callback(timeout1)) self.assertTrue(ioloop.has_callback(timeout2)) timeout1.cancel() timeout2.cancel() self.assertTrue(timeout1.cancelled) self.assertTrue(timeout2.cancelled) timeout1 = ioloop.call_later(0.1, lambda: d.callback(current_thread().ident)) yield d self.assertTrue(d.done()) self.assertEqual(d.result, ioloop.tid) self.assertFalse(ioloop.has_callback(timeout1))
def test_run_in_thread_loop(self): event_loop = get_event_loop() def simple(a, b): return a + b d = run_in_loop_thread(event_loop, simple, 1, 2) self.assertIsInstance(d, Deferred) result = yield d self.assertEqual(result, 3) d = run_in_loop_thread(event_loop, simple, 1, 'a') self.assertIsInstance(d, Deferred) try: result = yield d except TypeError: pass else: assert False, "TypeError not raised"
def test_run_in_thread_loop(self): event_loop = get_event_loop() def simple(a, b): return a + b d = run_in_loop_thread(event_loop, simple, 1, 2) self.assertIsInstance(d, Deferred) result = yield d self.assertEqual(result, 3) d = run_in_loop_thread(event_loop, simple, 1, "a") self.assertIsInstance(d, Deferred) try: result = yield d except TypeError: pass else: assert False, "TypeError not raised"
def test_echo_serve(self): loop = get_event_loop() server = TcpServer(loop, '127.0.0.1', 0, EchoServerProtocol) yield server.start_serving() sock = server.sock fn = sock.fileno() self.assertFalse(is_socket_closed(sock)) client = Echo() address = sock.getsockname() result = yield client.request(address, b'Hello!') self.assertEqual(result, b'Hello!') self.assertEqual(server.concurrent_connections, 1) result = yield client.request(address, b'ciao') self.assertEqual(result, b'ciao') self.assertEqual(server.concurrent_connections, 1) yield server.stop_serving() yield async_while(3, lambda: not is_socket_closed(sock)) self.assertTrue(is_socket_closed(sock))
def test_call_later(self): ioloop = get_event_loop() d = pulsar.Deferred() timeout1 = ioloop.call_later( 20, lambda: d.callback(current_thread().ident)) timeout2 = ioloop.call_later( 10, lambda: d.callback(current_thread().ident)) # lets wake the ioloop self.assertTrue(ioloop.has_callback(timeout1)) self.assertTrue(ioloop.has_callback(timeout2)) timeout1.cancel() timeout2.cancel() self.assertTrue(timeout1.cancelled) self.assertTrue(timeout2.cancelled) timeout1 = ioloop.call_later( 0.1, lambda: d.callback(current_thread().ident)) yield d self.assertTrue(d.done()) self.assertEqual(d.result, ioloop.tid) self.assertFalse(ioloop.has_callback(timeout1))
def test_call_every(self): test = self ioloop = get_event_loop() thread = current_thread() d = pulsar.Deferred() test = self # class p: def __init__(self, loop): self.loop = loop self.c = 0 self.prev_loop = 0 def __call__(self): try: test.assertNotEqual(current_thread(), thread) if self.prev_loop: test.assertEqual(ioloop.num_loops, self.prev_loop + 1) except Exception: d.callback(sys.exc_info()) else: self.prev_loop = ioloop.num_loops self.c += 1 if self.c == self.loop: d.callback(self.c) try: raise ValueError('test call every') except Exception: mute_failure(test, Failure(sys.exc_info())) raise # loops = 5 track = p(loops) start = time.time() periodic = ioloop.call_every(track) loop = yield d self.assertEqual(loop, loops) self.assertTrue(periodic.cancelled) self.assertFalse(ioloop.has_callback(periodic.handler))
def test_call_every(self): test = self ioloop = get_event_loop() thread = current_thread() d = pulsar.Deferred() test = self # class p: def __init__(self, loop): self.loop = loop self.c = 0 self.prev_loop = 0 def __call__(self): try: test.assertNotEqual(current_thread(), thread) if self.prev_loop: test.assertEqual(ioloop.num_loops, self.prev_loop + 1) except Exception: d.callback(sys.exc_info()) else: self.prev_loop = ioloop.num_loops self.c += 1 if self.c == self.loop: d.callback(self.c) try: raise ValueError("test call every") except Exception: mute_failure(test, Failure(sys.exc_info())) raise # loops = 5 track = p(loops) start = time.time() periodic = ioloop.call_every(track) loop = yield d self.assertEqual(loop, loops) self.assertTrue(periodic.cancelled) self.assertFalse(ioloop.has_callback(periodic.handler))
def test_has_event_loop(self): loop = get_event_loop() client = Echo(event_loop=loop) self.assertTrue(client.event_loop) self.assertEqual(client.event_loop, loop) self.assertEqual(client.get_event_loop(), loop)
def test_event_loop(self): client = Echo() self.assertFalse(client.event_loop) self.assertTrue(client.get_event_loop()) self.assertEqual(client.get_event_loop(), get_event_loop())
def callInThread(self, f, *args, **kw): return get_event_loop().call_soon(lambda: f(*args, **kw))
def removeAll(self): return get_event_loop().remove_all()
def test_create_connection_error(self): loop = get_event_loop() try: result = yield loop.create_connection(Protocol,'127.0.0.1', 9898) except socket.error: pass
def addWriter(self, writer): return get_event_loop().add_writer(writer.fileno(), writer.doWrite)
def test_io_loop(self): ioloop = get_event_loop() self.assertTrue(ioloop) self.assertNotEqual(ioloop.tid, current_thread().ident)
def addReader(self, reader): return get_event_loop().add_reader(reader.fileno(), reader.doRead)
def test_request_loop(self): request_loop = pulsar.get_request_loop() event_loop = get_event_loop() self.assertNotEqual(event_loop, request_loop)
def removeReader(self, reader): return get_event_loop().remove_reader(reader.fileno())
def removeWriter(self, writer): return get_event_loop().remove_writer(writer.fileno())
def callFromThread(self, f, *args, **kw): return get_event_loop().call_soon_threadsafe(lambda: f(*args, **kw))
def test_event_loop(self): q1 = Queue(event_loop=get_request_loop()) q2 = Queue(event_loop=get_event_loop()) q3 = Queue() self.assertEqual(q2.event_loop, q3.event_loop) self.assertNotEqual(q1.event_loop, q3.event_loop)
def callLater(self, _seconds, f, *args, **kw): return get_event_loop().call_later(_seconds, lambda: f(*args, **kw))