What is best (most easiest and elegant) way to send message to client after long period of time?

I am creating resource booking system with server and client applications. Client application is simple command line tool that can be used to add and remove resources into and from the system and book them. After client is done with the resource it is responsible to inform server that it is done with the booking and resource becomes available for someone else to use. If resource is not available at the time of booking, the client application stays waiting for resource to become available. Server keeps track of bookings and is responsible to notify waiting client when requested resource becomes available.

I am trying to figure out what is best way to make possible to notify waiting client about their resource becoming available. My idea was to spin up small server in the client application when booking is requested and include the address and the port number in the request. Server could then send message back to the client.

Current booking system contains so much code that I created smaller example of this mechanism. Client can send it's address to server and server periodically sends message to the client until it doesn't respond anymore.

server.py

import asyncio
from typing import List

from aiohttp import ClientConnectorError, ClientSession, web
from aiohttp.web_request import Request


async def handle(request: Request):
    subscriber = await request.text()

    print(f"New subscriber {subscriber}")

    request.app["subscribers"].append(subscriber)

    return web.Response()


app = web.Application()
app.add_routes([web.post("/", handle)])


async def periodic_publish(subscribers: List[str]):
    while True:
        await asyncio.sleep(2)

        print(f"{subscribers=}")

        async with ClientSession() as session:
            to_remove = []
            for i, subscriber in enumerate(subscribers):
                try:
                    async with session.post(
                        subscriber, data="Here is your subscription"
                    ) as response:
                        body = await response.text()
                        print(f"Response from subscriber: {body}")
                except ClientConnectorError:
                    print(f"Could not connect to {subscriber}")
                    to_remove.append(i)

        for subscriber_i in reversed(to_remove):
            subscribers.pop(subscriber_i)


if __name__ == "__main__":
    subscribers = []
    loop = asyncio.get_event_loop()
    loop.create_task(periodic_publish(subscribers))
    app["subscribers"] = subscribers
    web.run_app(app, port=8080, loop=loop)

client.py

import asyncio
import sys

import aioconsole
import aiohttp
from aiohttp import web
from aiohttp.web_request import Request

port = int(sys.argv[1])


async def handle(request: Request):
    message = await request.text()

    print(f'New message "{message}"')

    return web.Response(text="Thank you!")


app = web.Application()
app.add_routes([web.post("/", handle)])


async def cli():
    async with aiohttp.ClientSession() as session:
        async with session.post(
            "http://localhost:8080/", data=f"http://localhost:{port}/"
        ) as response:
            print("Status:", response.status)
            print("Content-type:", response.headers["content-type"])

            body = await response.text()
            print("Body:", body)

    await aioconsole.aprint("Hit enter to exit.")
    await aioconsole.ainput()
    await aioconsole.aprint("Bye!")


loop = asyncio.get_event_loop()
runner = web.AppRunner(app)
loop.run_until_complete(runner.setup())
site = web.TCPSite(runner, port=port)
loop.run_until_complete(site.start())
loop.run_until_complete(cli())

This is also a learning opportunity to me. What would be other ways of achieving this considering the client is just command line tool that can terminated if user gets tired of waiting?

Other comments regarding my usage of asyncio and aiohttp are also welcome. First time using both.

Rather than having your server call back to your client, it would probably make more sense to have your client make polling calls to your server to check if it's ready. This keeps the call pattern simple (calls between the server and client only flow one way).

You could write your own polling logic, but you might also want to explore a polling library that would implement this for you.