How to handle different (url) websocket connections in netty

Question

Websocket example in netty (examples) has a http request handler which:

1. performs hand shaking (at first)

2. (then) handles different types of WebSocket frames, eventually "TextWebSocketFrame"s.

There is only one url for websocket connections in this example.

The problem is, when TextWebSocketFrame based actual websocket communication starts, there is no direct way to determine websocket url from TextWebSocketFrames themselves (correct me if I am wrong).

So, how to handle different (url) websocket connections in netty?

One solution can be registering channels and their "websocket connection urls" during handshaking process.

The other is having only one websocket connection url and resolving different contexts by adding extra information to websocket messages (TextWebSocketFrames).

I don't find these solutions elegant, so any ideas?

Answer 1

It is my understanding that when you perform a web socket handshake, it is to a specific URL. That is specified in the web socket standard. See RFC 6455. Hence, there is no URL information in the TextWebSocketFrame because the assumption is that the frame will be sent to the URL to which the socket is bound.

To handle different URLs, you will have to either:

1. Setup a different pipeline and bind to a different IP and/or port for each URL, or
2. Like you stated, customise the hand shake and store the URL with the channel.

Personally, I've just used JSON in a TextWebSocketFrame. In my JSON, I have a field that states the intended action. This field is used for routing to the appropriate message handler.

I think it comes down to a design decision. WebSockets are intended for long lived connections where a request message can have 0, 1 or > 1 responses. This contrasts the REST style 1 request and 1 responses model.

Hope this helps.

Answer 2

The question "how to handle different (url) websocket connections in netty" does not make sense, I presume that the author meant to ask "how to serve multiple different websocket paths on a single port:host".

The question is valid because the HTTP protocol, (at least version 1.1,) WebSockets, and web browsers all support this scenario:

• Client connects to server and the two start exchanging HTTP request/response pairs.
• Client sends the HTTP request to upgrade to WebSocket, server honors it, and now a WebSocket is established between client and server.
• The original HTTP connection remains open, so client and server can continue exchanging HTTP request/response pairs in parallel to the WebSocket. (In light of this, the term "upgrade" is a misnomer, because the connection is not upgraded at all; instead, a new connection is established for the WebSocket.)
• Since the HTTP connection is still available, the client can send another HTTP upgrade request, thus creating another WebSocket. On the client side, it would look like this:

    socket1 = new WebSocket( "https://acme.com:8443/alpha" );
    socket2 = new WebSocket( "https://acme.com:8443/bravo" );

However, you can't have that, because Netty in all its magnificent glory and terrifying complexity does not exactly support that, and this is true even now, 10 years after the question was asked.

That's because:

• Only one ServerBootstrap can bind to a given port on a given host.
  _{(That's how the socket layer works.)}
• A ServerBootstrap can only have one "Child Handler".
  _{(ServerBootstrap.childHandler() silently fails to report an error if you invoke it twice, but only the last invocation takes effect.)}
• A ChannelPipeline can only have one WebSocketServerProtocolHandler.
  _{(Only the first WebSocketServerProtocolHandler that you add works, and Netty silently fails to issue an error if you add more.)}
• A WebSocketServerProtocolHandler accepts one and only one webSocketPath.

So, there you have it, a port:host can only have one webSocketPath, and that's a Netty limitation.

It might be possible to overcome this limitation by rewriting WebSocketServerProtocolHandler, but #aintNoBodyGotNoTimeFoDat.

Luckily, Netty does support another feature which makes it possible to achieve a similar thing. The constructor of WebSocketServerProtocolHandler supports a poorly documented and poorly named checkStartsWith parameter which, if set to true, will cause the handler to honor websocket negotiation requests not only on the given webSocketPath but also for any webSocket path that starts with the given webSocketpath and continues with a '?' or a '/' followed by other stuff. So, the code on the client would then look like this:

    socket1 = new WebSocket( "https://acme.com:8443/allWebSocketsHere/alpha" );
    socket2 = new WebSocket( "https://acme.com:8443/allWebSocketsHere/bravo" );

If you decide to build your netty server to handle this, the next problem you will face is how to obtain the "/allWebSocketsHere/alpha" and "allWebSocketsHere/bravo" parts. Luckily, someone else has already figured that out, see "Netty: How to use query string with websocket?" https://stackoverflow.com/a/47897963/773113