ASGI websockets behavior websocket.connect and websocket.accept

[cirospaciari]

Just testing the websockets ASGI protocol behavior, in uvicorn and others, the following code i used

async def app(scope, receive, send):
    
    # handle non websocket
    if scope['type'] == 'http':
        
        await send({
            'type': 'http.response.start',
            'status': 200,
            'headers': [
                [b'content-type', b'text/plain'],
            ],
        })
        await send({
            'type': 'http.response.body',
            'body': b'Connect via ws protocol!',
        })
    if scope['type'] != 'websocket':
       return
    protocols = scope.get('subprotocols', [])
    
    scope = await receive()
    # get connection
    assert scope['type'] == 'websocket.connect'
    # accept connection
    await send({
        'type': 'websocket.accept',
        'subprotocol': protocols[0] if len(protocols) > 0 else None 
    })
    # get data
    while True:
        scope = await receive()
        type = scope['type']
        # disconnected!
        if type == 'websocket.disconnect':
            print("disconnected!", scope)
            break
        
        # echo!
        await send({
            'type': 'websocket.send',
            'bytes': scope.get('bytes', None),
            'text': scope.get('text', '')
        })

The order:
scope['type'] = websocket:
call await receive() to get the first websocket.connect
send websocket.accept to accept the connection
call await receive() to get websocket.receive or websocket.disconnect
send websocket.close if i want to end the connection

In granian ASGI:

async def app(scope, receive, send):
    
    # handle non websocket
    if scope['type'] == 'http':
        
        await send({
            'type': 'http.response.start',
            'status': 200,
            'headers': [
                [b'content-type', b'text/plain'],
            ],
        })
        await send({
            'type': 'http.response.body',
            'body': b'Connect via ws protocol!',
        })
    if scope['type'] != 'websocket':
       return
    protocols = scope.get('subprotocols', [])
    
    # accept connection
    await send({
        'type': 'websocket.accept',
        'subprotocol': protocols[0] if len(protocols) > 0 else None 
    })
   scope = await receive()
   assert scope['type'] == 'websocket.connect'
    # get data
    while True:
        scope = await receive()
        type = scope['type']
        # disconnected!
        if type == 'websocket.disconnect':
            print("disconnected!", scope)
            break
        
        # echo!
        await send({
            'type': 'websocket.send',
            'bytes': scope.get('bytes', None),
            'text': scope.get('text', '')
        })

The order:
scope['type'] = websocket:
send websocket.accept to accept the connection
call await receive() to get the first websocket.connect
call await receive() to get websocket.receive or websocket.disconnect
send websocket.close if i want to end the connection

Falcon source code for ASGI for reference:

    async def _handle_websocket(self, ver, scope, receive, send):
        first_event = await receive()
        if first_event['type'] != EventType.WS_CONNECT:
            # NOTE(kgriffs): The handshake was abandoned or this is a message
            #   we don't support, so bail out. This also fulfills the ASGI
            #   spec requirement to only process the request after
            #   receiving and verifying the first event.
            await send({'type': EventType.WS_CLOSE, 'code': WSCloseCode.SERVER_ERROR})
            return

https://github.com/falconry/falcon/blob/master/falcon/asgi/app.py Line 970

ASGI spec about websocket.connect

"This message must be responded to with either an Accept message or a Close message before the socket will pass websocket.receive messages. The protocol server must send this message during the handshake phase of the WebSocket and not complete the handshake until it gets a reply, returning HTTP status code 403 if the connection is denied."
https://asgi.readthedocs.io/en/latest/specs/www.html#connect-receive-event

Another thing is if i call in granian

        await send({
            'type': 'websocket.send',
            'bytes': None,
            'text': 'something'
        })

It will send an empty binary message instead of using the 'text', in uvicorn the 'text' is sent if bytes is None
In ASGI docs:

"Exactly one of bytes or text must be non-None. One or both keys may be present, however."
https://asgi.readthedocs.io/en/latest/specs/www.html#send-send-event

[cirospaciari]

Just opening the discussion before opening any Issue as an draft, Loving your work with Granian, i just implemented ASGI protocol wrapper for socketify.py, and i was testing against granian, uvicorn and using Falcon as Web Framework and found this out of spec things. Also wanna ask for an WebSocket sample of RSGI to test, thanks!

[gi0baro]

No worries, in fact it's super-helpful to receive feedbacks and reports on the implementation! And also thank you for the compliments!
I gonna run some tests locally to verify your points and eventually open up the two issues for what you reported.

Regarding websockets and RSGI, the only existing code blocks I can suggest you to look at the moment are the RSGI test app and maybe the emmett implementation, but the latter is still in development, so don't take it as granted.

[cirospaciari]

No worries, in fact it's super-helpful to receive feedbacks and reports on the implementation! And also thank you for the compliments! I gonna run some tests locally to verify your points and eventually open up the two issues for what you reported.

Regarding websockets and RSGI, the only existing code blocks I can suggest you to look at the moment are the RSGI test app and maybe the emmett implementation, but the latter is still in development, so don't take it as granted.

I want to implement, RSGI for socketify.py too, actually i'm working on WSGI, ASGI, RGSI and SSGI (an custom insterface inspired by RGSI), and wanna to add RSGI and SSGI to Falcon, converting the current ASGI, the difference for SSGI is that you can mix sync and async by default and can use multiple interfaces if the server supports it (like ASGI for WebSockets and SSGI or RSGI for HTTP or vice versa).

[gi0baro]

I want to implement, RSGI for socketify.py too, actually i'm working on WSGI, ASGI, RGSI and SSGI (an custom insterface inspired by RGSI), and wanna to add RSGI and SSGI to Falcon, converting the current ASGI, the difference for SSGI is that you can mix sync and async by default and can use multiple interfaces if the server supports it (like ASGI for WebSockets and SSGI or RSGI for HTTP or vice versa).

Sounds cool and promising. I'm also considering to split RSGI spec for v2 in two sub-specs like RASGI and RSSGI to support also a synchronous interface in RSGI. While I have a pretty much clear picture in my mind for the HTTP part, websockets sound quite hard to handle synchronously considering the lower rust implementation. But we will see.

[cirospaciari]

I want to implement, RSGI for socketify.py too, actually i'm working on WSGI, ASGI, RGSI and SSGI (an custom insterface inspired by RGSI), and wanna to add RSGI and SSGI to Falcon, converting the current ASGI, the difference for SSGI is that you can mix sync and async by default and can use multiple interfaces if the server supports it (like ASGI for WebSockets and SSGI or RSGI for HTTP or vice versa).

Sounds cool and promising. I'm also considering to split RSGI spec for v2 in two sub-specs like RASGI and RSSGI to support also a synchronous interface in RSGI. While I have a pretty much clear picture in my mind for the HTTP part, websockets sound quite hard to handle synchronously considering the lower rust implementation. But we will see.

I really understand you about sync support for websockets, in case of socketify.py is always handle in async way, but not necessary with async/await functions like in ASGI, take a look:

def ws_open(ws):
    print("A WebSocket got connected!")
    ws.send("Hello World!", OpCode.TEXT)


def ws_message(ws, message, opcode):
    print(message, opcode)
    # Ok is false if backpressure was built up, wait for drain
    ok = ws.send(message, opcode)


app = App()
app.ws(
    "/*",
    {
        "compression": CompressOptions.SHARED_COMPRESSOR,
        "max_payload_length": 16 * 1024 * 1024,
        "idle_timeout": 12,
        "open": ws_open,
        "message": ws_message,
        "drain": lambda ws: print(
            "WebSocket backpressure: %s", ws.get_buffered_amount()
        ),
        "close": lambda ws, code, message: print("WebSocket closed"),
    },
)
app.any("/", lambda res, req: res.end("Nothing to see here!'"))
app.listen(
    3000,
    lambda config: print("Listening on port http://localhost:%d now\n" % (config.port)),
)
app.run()

This allows to avoid the overhead of asyncio, i also allow adding async methods on open, message, close etc and i just do an if inspect.iscoroutinefunction(handler) to check and ensure the run, the performance for now is really great with pub/sub, take a look on some fresh numbers i got today about websockets.

Framework/lib	Messages/second
socketify.py	1228800
bun.sh	847922
falcon+socketify.py-asgi	203200
node.js	192351
falcon + uvicorn pypy3	54584
uvicorn	38352
falcon + uvicorn python3	27648

[gi0baro]

This is now tracked in #19 and #20

[cirospaciari]

Thanks @gi0baro i really want to test Granian WebSocket performance using ASGI and RSGI 🦾