Question

in my second question on netty. We are just starting with it. And we have a design where we need to use HTTP with long polling HTTP Streaming. We are estimating from 5k – 50k connected users with an opened connection. We know tomcat won’t handle, so we look over netty to accomplish the task.

The design should be simple enough, but we can’t use websockets (we would love to use hornetQ on top of netty with websocket/stomp support) but we can’t.

So basically we will have server pushing events (we may even use JS SSE to do that) in the connected clients.

Clients will subscribe to an endpoint based on a url (like a queue on JMS, much much simpler though)

So we will have a process on the server side that generate events and notifies the interested channels (we are using a simple observer pattern for this).

So a channel subscribes to those process and then receive events from them.

My question here today is to see if the design approach we used is the right one considering netty’s architecture.

public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
    service.subscribe(this);
    this.context = ctx;
    ctx.sendUpstream(e);
}

//this method gets called by the service when a server event happens
public void onUpdate(String message) {
  ChannelBuffer buffer = Channels.buffer(message.getBytes().length());
  buffer.writeBytes(message.getBytes());
  ChannelFuture future = Channels.future(this.context.getChannel());
  future.addListener(ChannelFutureListener.CLOSE);
  Channels.write(this.context,future,buffer);
}

Regards

Answer 1

Looks ok, but there’s not much there. How are you handling the long poll initiation and the possible subsequent timeout ? (Or perhaps you’re totally good with that….. this is not the spanish inquisition)

One thing you might consider, depending on the number and popularity of your “URL queues” is to use a ChannelGroup as the container for all channels subscribed to that url queue. That way, you can just write the message to the group. Plus, when the channels close, they will be ejected from the group, so there’s some code simplification there.

Also, have you considered HTTP Streaming ? Not as good as websockets, but better than long polling, in my view.

I’m not 110% confident that all the implementations are perfect, but I have put together a test project that demonstrates JSON push using netty for long polling, websockets and http streaming. There is also a javascript client that adapts to the push type that you select.You might find it useful (and I am happy to get any feedback on it….)