Checking if a websocket consumer has been accepted

[TheStaticTurtle]

Hi

I'm currently building a generic decorator that auto-handles exceptions and sends them to the client.
A simplified version looks like this:

def consumer_handler_error_autohandle(response_message_type):
    def decorator(func):
        @functools.wraps(func)
        async def wrapper(self, *args, **kwargs):
            try:
                await func(self, *args, **kwargs)
            except Exception as err:
                self._logger.error(f"{func.__name__}({args}, {kwargs}) failed: {err}")
                try:
                    await self.send(json.dumps({"type": response_message_type, "error": str(err) }))
                except Exception as err2:
                    self._logger.critical(f"Failed to send error message to client", exc_info=err2)
        return wrapper
    return decorator

This works very well for my application. The issue arises when I decorate the connect function. If the exception happens before the call to accept, (which it does because rights and other things are checked before) there is no way of sending the error.

For my application I can just accept the socket, send an error message, and close it immediately afterward.
So after much trial and error, I found a way to check if the socket has been accepted, but it's not pretty:

is_still_connecting = self.base_send.__self__.real_send.args[0].state == WebSocketProtocol.STATE_CONNECTING
if is_still_connecting:
    await self.accept()

Short of doing a subclass and implementing an accepted flag myself inside the consumer, is there a build in way of checking if the the consumer has sent the accept message?

Thanks,
Samuel

[AdilHaydar]

Hi! 👋

I faced a similar issue when trying to handle exceptions in the connect() method before calling accept(). Instead of relying on internal real_send.args[0].state checks, a cleaner approach is to set your own _accepted flag inside the consumer.

Example:

class MyConsumer(AsyncWebsocketConsumer):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._accepted = False

    async def connect(self):
        try:
            # Your access checks or setup here
            await self.accept()
            self._accepted = True
        except Exception as e:
            if not self._accepted:
                await self.accept()
                self._accepted = True
            await self.send(json.dumps({"error": str(e)}))
            await self.close()

This avoids depending on internal WebSocket state and gives you full control over whether accept() was called.

Hope this helps!