async def test_event(self):
async def setter():
assert not event.is_set()
event.set()
event = Event()
async with create_task_group() as tg:
tg.start_soon(setter)
await event.wait()
assert event.is_set()
async def remote_select_channel_contents(self, **kwargs):
peers_to_query = self.get_known_subscribed_peers_for_node(
kwargs["channel_pk"], kwargs["origin_id"])
if not peers_to_query:
raise NoChannelSourcesException()
result = []
async with create_task_group() as tg:
got_at_least_one_response = Event()
async def _send_remote_select(peer):
request = self.send_remote_select(peer,
force_eva_response=True,
**kwargs)
await request.processing_results
# Stop execution if we already received the results from another coroutine
if result or got_at_least_one_response.is_set():
return
result.extend(request.processing_results.result())
got_at_least_one_response.set()
for peer in peers_to_query:
# Before issuing another request, check if we possibly already received a response
if got_at_least_one_response.is_set():
break
# Issue a request to another peer
tg.start_soon(_send_remote_select, peer)
with move_on_after(happy_eyeballs_delay):
await got_at_least_one_response.wait()
await got_at_least_one_response.wait()
# Cancel the remaining requests so we don't have to wait for them to finish
tg.cancel_scope.cancel()
request_results = [r.md_obj.to_simple_dict() for r in result]
return request_results
async def test_increase_tokens(self):
async def setter():
# Wait until waiter() is inside the limiter block
await event1.wait()
async with limiter:
# This can only happen when total_tokens has been increased
event2.set()
async def waiter():
async with limiter:
event1.set()
await event2.wait()
limiter = CapacityLimiter(1)
event1, event2 = Event(), Event()
async with create_task_group() as tg:
tg.start_soon(setter)
tg.start_soon(waiter)
await wait_all_tasks_blocked()
assert event1.is_set()
assert not event2.is_set()
limiter.total_tokens = 2
assert event2.is_set()
