Ability to use Granian with asyncio.create_task

[XavierGeerinck]

Hi!

For my application I am trying out the Granian server. However, for testing it, I would like to spin it up in the background through asyncio.create_task(server.start())

I currently see the server starting, but it blocking the entire event loop. Is there any known way of making it not block the event loop?

[gi0baro]

@XavierGeerinck I'm not sure what you're referring to by server.start, as Granian interface doesn't have a start method. Also, Granian doesn't expose coroutines, so I'm not sure why you want to run sync functions in an event loop.

Probably you want to run Granian.serve in a separated thread, but without additional context is hard for me to suggest viable solutions here.

[XavierGeerinck]

Apologies, will provide as much context as I can.

I implemented an abstraction to let me pick between protocols (http or gRPC). for The first I am trying to have Granian implemented as a HTTP Server. For that, I have a class that implements the start method for the specific protocol as such:

class ServerHTTP:
    async def start(self):
        self._server = Granian(
            # target="asgi:app",
            # target=app,
            target="dyn",
            interface="rsgi",
            address=self.host,
            port=int(self.port),
            # workers=self.config.get("workers", 5),
            threading_mode=ThreadModes.workers,
            # opt=True, # Enable loop optimizations
            backlog=2048,
            # log_level="error",
        )

        self._server.started = True
        self._server.serve(target_loader=granian_app_loader(self))

Now to test this, I have a test suite that uses an util and starts up the HTTP server in the background:

async def create_server(protocol="grpc", host="127.0.0.1", port=1337):
    server = server_make.make(
        server_impl=MockServerImpl,
        host=host,
        port=port,
        protocol=protocol
    )

    # Start it in the background and return the task
    server_task = asyncio.create_task(server.start())

    # Ensure the server started
    timeout = 5
    while not system_util.is_port_in_use(port):
        await asyncio.sleep(0.05)
        timeout -= 0.1
        if timeout <= 0:
            raise Exception("Server did not start within the given timeout")

    return server, server_task

Where asyncio.create_task(server.start()) is being called to instantiate the Granian HTTP Server

For my gRPC implementation this runs fine, for FastAPI this runs fine, but for Granian this appears to fail.

[gi0baro]

By FastAPI you mean uvicorn, right?

I'm not sure about all the implications, but maybe you can wrap Granian.serve in asyncio.to_thread?
Something like:

class ServerHTTP:
    async def start(self):
        self._server = ...
        self._server.started = True
        return await asyncio.to_thread(self._server.serve, target_loader=granian_app_loader(self))

or even just:

class ServerHTTP:
    def start(self):
        self._server = ...
        self._server.started = True
        return asyncio.to_thread(self._server.serve, target_loader=granian_app_loader(self))

[XavierGeerinck]

When I try that, Granian is unable to start:

Task exception was never retrieved
future: <Task finished name='Task-4' coro=<Server.start() done, defined at /home/xanrin/masked/masked/masked/masked/networking/http/server.py:117> exception=ValueError('signal only works in main thread')>
Traceback (most recent call last):
  File "/home/xanrin/masked/masked/masked_core/masked_core/networking/http/server.py", line 146, in start
    return await async_util.to_thread(self._server.serve, target_loader=granian_app_loader(self))
  File "/home/xanrin/masked/masked/masked/masked/utils/async_util.py", line 21, in to_thread
    return await loop.run_in_executor(None, func_call)
  File "/home/xanrin/.pyenv/versions/3.8.18/lib/python3.8/concurrent/futures/thread.py", line 57, in run
    result = self.fn(*self.args, **self.kwargs)
  File "/home/xanrin/.pyenv/versions/3.8.18/lib/python3.8/site-packages/granian/server.py", line 451, in serve
    serve_method(spawn_target, target_loader)
  File "/home/xanrin/.pyenv/versions/3.8.18/lib/python3.8/site-packages/granian/server.py", line 399, in _serve
    sock = self.startup(spawn_target, target_loader)
  File "/home/xanrin/.pyenv/versions/3.8.18/lib/python3.8/site-packages/granian/server.py", line 352, in startup
    self.setup_signals()
  File "/home/xanrin/.pyenv/versions/3.8.18/lib/python3.8/site-packages/granian/server.py", line 344, in setup_signals
    signal.signal(sig, self.signal_handler_interrupt)
  File "/home/xanrin/.pyenv/versions/3.8.18/lib/python3.8/signal.py", line 47, in signal
    handler = _signal.signal(_enum_to_int(signalnum), _enum_to_int(handler))
ValueError: signal only works in main thread

[gi0baro]

So I think that the only remaining option on the table is to subclass Granian to skip signals setup to allow asyncio.to_thread to work, eg:

class GranianNoSig(Granian):
    def setup_signals(self):
        return

But this also means you have to manually handle the shutdown process, thus somewhere in your code on exit you should call:

self._server.signal_handler_interrupt()

I know this looks anything but clean, but it depends on how Granian workers management is implemented: it relies on processes and threads, not on asyncio.

[XavierGeerinck]

Thank you! That seems to do the trick!! I am fine with using the signal handler as there is code wrapped around my server taking care of successful termination.