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
