Running whitenoise behind a WSGI-to-ASGI adapter

I’m about to deploy a django app. I was originally going to use uvicorn with Django 3.0, but after seeing whitenoise doesn’t work with asgi servers yet was thinking of just reverting back to wsgi.

I just came across @tomchristie’s pull request and he mentions he’s able to (non-ideally) get it working with a wsgi-to-asgi adapter. I was wondering if there’s any additional information on how to get that working.

Ideally I’d like to just swap that out whenever whitenoise goes asgi, instead of reverting from uvicorn to gunicorn.

Thanks for the continued work on a great project!

[kmichel2]

Hi, I’ve had success in using WhiteNoiseMiddleware in an async context in Django, but I noticed that WhiteNoiseMiddleware does not inherit from MiddlewareMixin.

The consequence is that WhiteNoiseMiddleware does not get the full async compatibility layer from Django 3.1.

It would not be a full async support but maybe implementing sync_capable=True and being able to call an async get_response (and be called as async) could be a useful improvement of WhiteNoiseMiddleware.

It would reduce the time spent in the sync emulation layer (which is a separate thread with essentially zero concurrency because Django calls sync_to_async with the thread_sensitive=True option) and allow async views to pass through directly when not serving a static file request.

Copying the behaviour of MiddlewareMixin, it could roughly look like this:

class AsyncWhitenoiseMiddleware(WhiteNoiseMiddleware):
    sync_capable = True
    async_capable = True

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._async_check()

    def _async_check(self):
        if asyncio.iscoroutinefunction(self.get_response):
            self._is_coroutine = asyncio.coroutines._is_coroutine

    def __call__(self, request):
        if asyncio.iscoroutinefunction(self.get_response):
            return self.__acall__(request)
        else:
            return super().__call__(request)

    async def __acall__(self, request):
        response = self.process_request(request)
        if response is None:
            response = await self.get_response(request)
        return response

It’s probably better to inherit from MiddlewareMixin instead of duplicating code.

In the previous code, process_request is called directly, which means doing disk IO in the main async thread. This is not ideal but probably not awful, I’d guess static files are very likely to be quickly available from the system cache.

[evansd]

Hi, yes DjangoWhitenoise acts as standard Django middleware so should run fine via the compatibility layer. I’d love to get native ASGI integration into Whitenoise but super busy with the medical day job at the moment and ENOTIME 😃