Esempio n. 1
0
    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))
Esempio n. 2
0
 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))
Esempio n. 3
0
 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)
Esempio n. 4
0
 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)
Esempio n. 5
0
 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)
Esempio n. 6
0
 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'
Esempio n. 7
0
 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)
Esempio n. 8
0
 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))
Esempio n. 9
0
File: me.py Progetto: japaks/pulsar
 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))
Esempio n. 10
0
 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)
Esempio n. 11
0
 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()
Esempio n. 12
0
 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
Esempio n. 13
0
 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
Esempio n. 14
0
    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)
Esempio n. 15
0
 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)
Esempio n. 16
0
 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))
Esempio n. 17
0
    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()
Esempio n. 18
0
    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()
Esempio n. 19
0
 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)
     
     
Esempio n. 20
0
 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))
Esempio n. 21
0
    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"
Esempio n. 22
0
    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"
Esempio n. 23
0
 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))
Esempio n. 24
0
 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))
Esempio n. 25
0
    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))
Esempio n. 26
0
    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))
Esempio n. 27
0
 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)
Esempio n. 28
0
 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)
Esempio n. 29
0
 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())
Esempio n. 30
0
 def callInThread(self, f, *args, **kw):
     return get_event_loop().call_soon(lambda: f(*args, **kw))
Esempio n. 31
0
 def removeAll(self):
     return get_event_loop().remove_all()
Esempio n. 32
0
 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
Esempio n. 33
0
 def addWriter(self, writer):
     return get_event_loop().add_writer(writer.fileno(), writer.doWrite)
Esempio n. 34
0
 def test_io_loop(self):
     ioloop = get_event_loop()
     self.assertTrue(ioloop)
     self.assertNotEqual(ioloop.tid, current_thread().ident)
Esempio n. 35
0
 def addReader(self, reader):
     return get_event_loop().add_reader(reader.fileno(), reader.doRead)
Esempio n. 36
0
 def addWriter(self, writer):
     return get_event_loop().add_writer(writer.fileno(), writer.doWrite)
Esempio n. 37
0
 def test_request_loop(self):
     request_loop = pulsar.get_request_loop()
     event_loop = get_event_loop()
     self.assertNotEqual(event_loop, request_loop)
Esempio n. 38
0
 def removeReader(self, reader):
     return get_event_loop().remove_reader(reader.fileno())
Esempio n. 39
0
 def removeWriter(self, writer):
     return get_event_loop().remove_writer(writer.fileno())
Esempio n. 40
0
 def test_request_loop(self):
     request_loop = pulsar.get_request_loop()
     event_loop = get_event_loop()
     self.assertNotEqual(event_loop, request_loop)
Esempio n. 41
0
 def removeAll(self):
     return get_event_loop().remove_all()
Esempio n. 42
0
 def callFromThread(self, f, *args, **kw):
     return get_event_loop().call_soon_threadsafe(lambda: f(*args, **kw))
Esempio n. 43
0
 def removeWriter(self, writer):
     return get_event_loop().remove_writer(writer.fileno())
Esempio n. 44
0
 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)
Esempio n. 45
0
 def removeReader(self, reader):
     return get_event_loop().remove_reader(reader.fileno())
Esempio n. 46
0
 def callLater(self, _seconds, f, *args, **kw):
     return get_event_loop().call_later(_seconds, lambda: f(*args, **kw))
Esempio n. 47
0
 def addReader(self, reader):
     return get_event_loop().add_reader(reader.fileno(), reader.doRead)
Esempio n. 48
0
 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())
Esempio n. 49
0
 def callInThread(self, f, *args, **kw):
     return get_event_loop().call_soon(lambda: f(*args, **kw))
Esempio n. 50
0
 def test_io_loop(self):
     ioloop = get_event_loop()
     self.assertTrue(ioloop)
     self.assertNotEqual(ioloop.tid, current_thread().ident)
Esempio n. 51
0
 def callFromThread(self, f, *args, **kw):
     return get_event_loop().call_soon_threadsafe(lambda: f(*args, **kw))
Esempio n. 52
0
 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)