def test_call_at(self): loop = get_event_loop() d1 = Future() d2 = Future() c1 = loop.call_at(loop.time() + 1, lambda: d1.set_result(loop.time())) c2 = loop.call_later(1, lambda: d2.set_result(loop.time())) t1, t2 = yield pulsar.multi_async((d1, d2)) self.assertTrue(t1 <= t2)
def test_multi(self): d1 = Future() d2 = Future() d = multi_async([d1, d2, 'bla']) self.assertFalse(d.done()) d2.set_result('first') self.assertFalse(d.done()) d1.set_result('second') result = yield from d self.assertEqual(result, ['second', 'first', 'bla'])
def shutdown(self, wait=True): with self._shutdown_lock: self._shutdown = True self._put(None) if wait: self._waiter = Future(loop=self._loop) return self._waiter
def test_chain(self): loop = get_event_loop() future = Future() next = chain_future(future, callback=lambda r: r+2) loop.call_later(0.2, future.set_result, 1) result = yield next self.assertEqual(result, 3)
def test_periodic(self): test = self loop = get_event_loop() waiter = Future() 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: waiter.set_result(self.c) raise every = 2 loops = 2 track = p(loops) start = loop.time() periodic = call_repeatedly(loop, every, track) self.assertIsInstance(periodic, LoopingCall) done = yield waiter taken = loop.time() - start self.assertEqual(done, loops) self.assertTrue(taken > every * loops) self.assertTrue(taken < every * loops + 2) self.assertTrue(periodic.cancelled) self.assertFalse(has_callback(loop, periodic.handler))
def test_coroutine1(self): loop = get_event_loop() d1 = Future() loop.call_later(0.2, d1.set_result, 1) a = yield c_summation(d1) self.assertEqual(a, 3) self.assertEqual(d1.result(), 1)
def _throttle(self, rw): self.logger.debug('Throttling %s', self._types[rw]) if rw: assert not self._throttle[rw] self._throttle[rw] = Future(self.protocol._loop) else: self._throttle[rw] = True t = self.protocol._transport t.pause_reading()
def coro1(): done = yield 3 fut = Future() fut._loop.call_soon(fut.set_exception, ValueError('test')) try: yield fut except ValueError: done += 1 coroutine_return(done)
async def test_json_with_async_string2(self): d = Future() astr = wsgi.String(d) response = wsgi.Json({'bla': astr}) self.assertEqual(len(response.children), 1) result = response.render() self.assertIsInstance(result, Future) d.set_result('ciao') result = await result self.assertEqual(result, json.dumps({'bla': 'ciao'}))
def test_call_soon(self): ioloop = get_event_loop() tid = yield loop_thread_id(ioloop) d = Future() callback = lambda: d.set_result(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 result = yield d self.assertEqual(result, tid)
def test_ping_pong_monitor(self): value = yield 3 self.assertEqual(value, 3) try: future = Future() future.set_exception(ValueError('test')) yield future except ValueError: pass pong = yield send('monitor', 'ping') self.assertEqual(pong, 'pong')
def submit(self, func, *args, **kwargs): '''Equivalent to ``func(*args, **kwargs)``. This method create a new task for function ``func`` and adds it to the queue. Return a :class:`~asyncio.Future` called back once the task has finished. ''' with self._shutdown_lock: if self._shutdown: raise RuntimeError( 'cannot schedule new futures after shutdown') future = Future(loop=self._loop) self._put((future, func, args, kwargs)) return future
def _(*args, **kwargs): res = callable(*args, **kwargs) if isinstance(res, types.GeneratorType): res = _inlineCallbacks(None, res, Deferred()) if isinstance(res, Deferred): future = Future() res.addCallbacks( future.set_result, lambda failure: future.set_exception(failure.value)) future._deferred = res return future else: raise TypeError( "Callable %r should return a generator or a twisted Deferred" % callable)
def acquire(self, timeout=None): """Acquires the lock if in the unlocked state otherwise switch back to the parent coroutine. """ green = getcurrent() parent = green.parent if parent is None: raise MustBeInChildGreenlet('GreenLock.acquire in main greenlet') if self._local.locked: future = Future(loop=self._loop) self._queue.append(future) parent.switch(future) self._local.locked = green return self.locked()
def acquire(self, timeout=None): '''Acquires the lock if in the unlocked state otherwise switch back to the parent coroutine. ''' green = getcurrent() parent = green.parent if parent is None: raise RuntimeError('acquire in main greenlet') if self._local.locked: future = Future(loop=self._loop) self._queue.append(future) parent.switch(future) self._local.locked = green return self.locked()
def test_yield(self): '''Yielding a future calling back on separate thread''' worker = pulsar.get_actor() loop = get_event_loop() loop_tid = yield pulsar.loop_thread_id(loop) self.assertNotEqual(worker.tid, current_thread().ident) self.assertEqual(loop_tid, current_thread().ident) yield None self.assertEqual(loop_tid, current_thread().ident) d = Future(loop=worker._loop) # We are calling back the future in the event_loop which is on # a separate thread def _callback(): d.set_result(current_thread().ident) worker._loop.call_soon_threadsafe( worker._loop.call_later, 0.2, _callback) result = yield d self.assertEqual(worker.tid, result) self.assertNotEqual(worker.tid, current_thread().ident) self.assertEqual(loop_tid, current_thread().ident)
def __call__(self, actor=None): """Register this application with the (optional) calling ``actor``. If an ``actor`` is available (either via the function argument or via the :func:`~pulsar.async.actor.get_actor` function) it must be ``arbiter``, otherwise this call is no-op. If no actor is available, it means this application starts pulsar engine by creating the ``arbiter`` with its :ref:`global settings <setting-section-global-server-settings>` copied to the arbiter :class:`.Config` container. :return: the ``start`` one time event fired once this application has fired it. """ if actor is None: actor = get_actor() monitor = None if actor and actor.is_arbiter(): monitor = actor.get_actor(self.name) if monitor is None and (not actor or actor.is_arbiter()): self.cfg.on_start() self.logger = self.cfg.configured_logger() if not actor: actor = pulsar.arbiter(cfg=self.cfg.clone()) else: self.update_arbiter_params(actor) if not self.cfg.exc_id: self.cfg.set('exc_id', actor.cfg.exc_id) if self.on_config(actor) is not False: start = Future(loop=actor._loop) actor.bind_event('start', partial(self._add_monitor, start)) return start else: return elif monitor: raise ImproperlyConfigured('%s already started ' % monitor.name) else: raise ImproperlyConfigured('Cannot start application from %s' % actor)
def switch_to_ssl(self, prev_response): '''Wrap the transport for SSL communication.''' request = prev_response._request.request connection = prev_response._connection loop = connection._loop sock = connection._transport._sock # set a new connection_made event connection.events['connection_made'] = OneTime(loop=loop) connection._processed -= 1 connection.producer._requests_processed -= 1 waiter = Future(loop=loop) loop._make_ssl_transport(sock, connection, request._ssl, waiter, server_side=False, server_hostname=request._netloc) yield from waiter response = connection.current_consumer() response.start(request) yield from response.on_finished if response.request_again: response = response.request_again prev_response.request_again = response
def __init__(self, headers, parser, transport=None): self.headers = headers self.parser = parser self.transport = transport self.buffer = b'' self.on_message_complete = Future()
def send(self, message): assert self._waiting is None self._waiting = d = Future(loop=self._loop) self._transport.sendto(to_bytes(message) + self.separator) return d
def AsyncResponseMiddleware(environ, resp): '''This is just for testing the asynchronous response middleware ''' future = Future() future._loop.call_soon(future.set_result, resp) return future
def async_func(loop, value): p = Future(loop=loop) loop.call_later(DELAY, p.set_result, value) return p