Enforce serial requests in asyncio

Question

I've been using asyncio and the http requests package aiohttp recently and I've run into a problem.

My application talks to a REST API.

for some API endpoints it makes sense to be able to dispatch multiple requests in parallel. Eg. sending different queries in the request to the same endpoint to get different data.

Though for some endpoints, this doesn't make sense. As in the endpoint always takes the same arguments (authentication) and returns requested information. (No point asking for the same data multiple times before the server has responded once) For these endpoints I need to enforce a 'serial' flow of requests. In that my program should only be able to send a request when it's not waiting for a response. (the typical behavior of blocking requests).

Of course I don't want to block.

This is an abstraction of what I intend to do. Essentially wrap the endpoint in an async generator that enforces this serial behavior.

I feel like I'm reinventing the wheel, Is there a common solution to this issue?

import asyncio
from time import sleep

# Encapsulate the idea of an endpoint that can't handle multiple requests
async def serialendpoint():
    count = 0
    while True:
        count += 1
        await asyncio.sleep(2)
        yield str(count)


# Pretend client object
class ExampleClient(object):
    gen = serialendpoint()

    # Simulate a http request that sends multiple requests
    async def simulate_multiple_http_requests(self):
        print(await self.gen.asend(None))
        print(await self.gen.asend(None))
        print(await self.gen.asend(None))
        print(await self.gen.asend(None))

async def other_stuff():
    for _ in range(6):
        await asyncio.sleep(1)
        print('doing async stuff')

client = ExampleClient()

loop = asyncio.get_event_loop()

loop.run_until_complete(asyncio.gather(client.simulate_multiple_http_requests(), 
                                       client.simulate_multiple_http_requests(), 
                                       other_stuff()))

outputs

doing async stuff
1
doing async stuff
doing async stuff
2
doing async stuff
doing async stuff
3
doing async stuff
4
5
6
7
8

update

This is the actual async generator I implemented:

All the endpoints that require serial behavior get assigned a serial_request_async_generator during the import phase. Which meant I couldn't initialize them with an await 'async_gen'.asend(None) as the await is only allowed in an async coroutine. The compromise is that every serial request at runtime must .asend(None) before asending the actual arguments. There must be a better way!

async def serial_request_async_generator():
    args, kwargs = yield
    while True:
        yield await request(*args, **kwargs)  # request is an aiohttp request
        args, kwargs = yield

Enforce serial requests in asyncio

0 Answers