def shutdown(self, wait=True):
with self._shutdown_lock:
self._shutdown = True
self._put(None)
if wait:
self._waiter = create_future(self._loop)
return self._waiter
def __init__(self, wsgi, environ, start_response):
self.wsgi = wsgi
self.environ = environ
self.connection = wsgi_request(self.environ).cache.connection
self.debug = self.connection._loop.get_debug()
self.start_response = start_response
self.future = create_future()
def shutdown(self, wait=True):
with self._shutdown_lock:
self._shutdown = True
self._put(None)
if wait:
self._waiter = create_future(self._loop)
return self._waiter
async def test_retry(self):
meta = {'max_retries': 3, 'retry_delay': 1}
done = create_future()
class CheckRetry:
count = 1
message_id = None
def __call__(self, _, event, task):
if task.name == 'subtraction':
if task.meta.get('from_task') == self.message_id:
self.count += 1
if task.retry == 3:
done.set_result(task)
else:
self.message_id = task.id
check_retry = CheckRetry()
await self.api.on_events('task', 'done', check_retry)
try:
task = await self.api.tasks.queue('subtraction',
a=1,
b='foo',
delay=1,
callback=False,
meta_params=meta)
self.assertEqual(task.status_string, 'QUEUED')
check_retry.message_id = task.id
task = await done
self.assertEqual(check_retry.count, 3)
self.assertEqual(task.status_string, 'FAILURE')
finally:
await self.api.remove_event_callback('task', 'done', check_retry)
def __init__(self, wsgi, environ, start_response):
self.wsgi = wsgi
self.environ = environ
self.connection = wsgi_request(self.environ).cache.connection
self.debug = self.connection._loop.get_debug()
self.start_response = start_response
self.future = create_future()
def __iter__(self):
while True:
data = self.file.read(self.block)
if not data:
break
future = create_future()
future.set_result(data)
yield future
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 = create_future(self._loop)
self._queue.append(future)
parent.switch(future)
self._local.locked = green
return self.locked()
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')
if self.in_green_worker:
return wait(func(*args, **kwargs))
else:
future = create_future(self._loop)
self._put((future, func, args, kwargs))
return future
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')
if self.in_green_worker:
return wait(func(*args, **kwargs))
else:
future = create_future(self._loop)
self._put((future, func, args, kwargs))
return future
async def _test_fail_subscribe(self):
channels = self.channels()
original, warning, critical = self._patch(channels, channels.pubsub,
'subscribe')
await channels.connect()
args, kw = await critical.end
self.assertEqual(len(args), 3)
self.assertEqual(args[1], channels)
self.assertEqual(args[2], 2)
critical.end = create_future()
args, kw = await critical.end
self.assertEqual(len(args), 3)
self.assertEqual(args[1], channels)
self.assertEqual(args[2], 2.25)
channels.pubsub.subscribe = original
args, kw = await warning.end
self.assertEqual(len(args), 3)
self.assertEqual(args[1], channels)
self.assertEqual(args[2], channels.status_channel)
def wait_for_stop(test, aid, terminating=False):
'''Wait for an actor to stop'''
actor = arbiter()
waiter = create_future(loop=actor._loop)
def remove():
test.assertEqual(actor.event('periodic_task').unbind(check), 1)
waiter.set_result(None)
def check(caller, **kw):
test.assertEqual(caller, actor)
if not terminating:
test.assertFalse(aid in actor.managed_actors)
elif aid in actor.managed_actors:
return
actor._loop.call_soon(remove)
actor.event('periodic_task').bind(check)
return waiter
def wait_for_stop(test, aid, terminating=False):
'''Wait for an actor to stop'''
actor = arbiter()
waiter = create_future(loop=actor._loop)
def remove():
test.assertEqual(actor.event('periodic_task').unbind(check), 1)
waiter.set_result(None)
def check(caller, **kw):
test.assertEqual(caller, actor)
if not terminating:
test.assertFalse(aid in actor.managed_actors)
elif aid in actor.managed_actors:
return
actor._loop.call_soon(remove)
actor.event('periodic_task').bind(check)
return waiter
async def _test_fail_subscribe(self):
channels = self.channels()
original, warning, critical = self._patch(
channels, channels.pubsub, 'subscribe'
)
await channels.connect()
args, kw = await critical.end
self.assertEqual(len(args), 3)
self.assertEqual(args[1], channels)
self.assertEqual(args[2], 2)
critical.end = create_future()
args, kw = await critical.end
self.assertEqual(len(args), 3)
self.assertEqual(args[1], channels)
self.assertEqual(args[2], 2.25)
channels.pubsub.subscribe = original
args, kw = await warning.end
self.assertEqual(len(args), 3)
self.assertEqual(args[1], channels)
self.assertEqual(args[2], channels.status_channel)
def AsyncResponseMiddleware(environ, resp):
'''This is just for testing the asynchronous response middleware
'''
future = create_future()
future._loop.call_soon(future.set_result, resp)
return future
def post_async(self, request):
future = create_future()
future._loop.call_later(0.5, lambda: future.set_result(['Hello!']))
return future
def async_func(loop, value):
p = create_future(loop)
loop.call_later(DELAY, p.set_result, value)
return p
def __init__(self):
self.end = create_future()
def post_async(self, request):
future = create_future()
future._loop.call_later(0.5, lambda: future.set_result(['Hello!']))
return future
async def async_function(test):
future = create_future()
future._loop.call_later(1, future.set_result, True)
result = await future
test.assertEqual(result, True)
return result
def AsyncResponseMiddleware(environ, resp):
'''This is just for testing the asynchronous response middleware
'''
future = create_future()
future._loop.call_soon(future.set_result, resp)
return future
def __init__(self):
self.end = create_future()
def async_func(loop, value):
p = create_future(loop)
loop.call_later(DELAY, p.set_result, value)
return p
async def async_function(test):
future = create_future()
future._loop.call_later(1, future.set_result, True)
result = await future
test.assertEqual(result, True)
return result