Currently I spent my spare time on OSGifying a WebSocket based continuous integration system. The project was created by a small group of my sponsees, and the aim of it is not replacing current leading products, such as Go, but assessing some interesting emerging technologies which appears on ThoughtWorks Technical Radar. And this project uses Scala, Neo4J, JAX-RS, Non-Blocking I/O server side and HTML5.

We had a working prototype 3 months ago. And the performance was pretty awesome.The server can easily support 500 agents with default JVM heap. And scale up to couple of thousands agents within 2G memory allocation.

In the way of OSGifying the WebSocket part, we found out the current implementation of Grizzly OSGi HttpService only supports Comet but not WebSockets. Well, to be fair, the code has not been touched since late 2009, and not until 1.9.19-beta2, Grizzly itself didn’t support WebSockets neither. So in a nut shell, we have to patch the code by ourselves.

The essence part of the patch is pretty straightforward, the only thing we need to do is add a WebSocketAsyncFilter to the AsyncHandler of GrizzlyWebServer instance:

SelectorThread st = ws.getSelectorThread();
st.setEnableAsyncExecution(true);
AsyncHandler asyncHandler = new DefaultAsyncHandler();
asyncHandler.addAsyncFilter(new WebSocketAsyncFilter());
st.setAsyncHandler(asyncHandler);

One more thing left is make it play nicely with the previous Comet support. After reading the code, I personally don’t think it make much sense to support both Comet and WebSocket at same time(unless for the legacy), so I decided to only support either Comet or WebSocket. Here are how the activator looks like

 private static final String COM_SUN_GRIZZLY_ASYNC_SUPPORT = "com.sun.grizzly.async.support";

    private enum AsyncSupport {
        COMET {
            @Override
            public AsyncFilter createFilter() {
                return new CometAsyncFilter();
            }
        },
        WEBSOCKETS {
            @Override
            public AsyncFilter createFilter() {
                return new WebSocketAsyncFilter();
            }
        };

        public abstract AsyncFilter createFilter();
    }

    public void start(final BundleContext bundleContext) throws Exception {
        logTracker = new ServiceTracker(bundleContext, LogService.class.getName(), null);
        logTracker.open();
        logger = new Logger(logTracker);
        logger.info("Starting Grizzly OSGi HttpService");

        int port = readProperty(bundleContext, ORG_OSGI_SERVICE_HTTP_PORT, 80);
        if (bundleContext.getProperty(ORG_OSGI_SERVICE_HTTPS_PORT) != null) {
            logger.warn("HTTPS not supported yet.");
        }
        startGrizzly(port, readAsyncSupport(bundleContext));
        serviceFactory = new HttpServiceFactory(ws, logger, bundleContext.getBundle());
        registration = bundleContext.registerService(
                HttpService.class.getName(), serviceFactory,
                new Properties());
    }

    private AsyncSupport readAsyncSupport(BundleContext bundleContext) {
        try {
            boolean cometEnabled = readProperty(bundleContext, COM_SUN_GRIZZLY_COMET_SUPPORT, false);
            String asyncSupport = readProperty(bundleContext, COM_SUN_GRIZZLY_ASYNC_SUPPORT, cometEnabled ? "COMET" : null);
            return (asyncSupport != null) ? AsyncSupport.valueOf(asyncSupport.toUpperCase()) : null;
        } catch (IllegalArgumentException e) {
            return null;
        }
    }

    private void startGrizzly(int port, AsyncSupport asyncSupport) throws IOException {
        ws = new GrizzlyWebServer(port);
        if (asyncSupport != null) {
            logger.info(new StringBuilder().append("Enabling ").append(asyncSupport.toString()).append(".").toString());
            SelectorThread st = ws.getSelectorThread();
            st.setEnableAsyncExecution(true);
            AsyncHandler asyncHandler = new DefaultAsyncHandler();
            asyncHandler.addAsyncFilter(asyncSupport.createFilter());
            st.setAsyncHandler(asyncHandler);
        }
        ws.setMaxThreads(5);
        ws.useAsynchronousWrite(true);
        ws.start();
    }

And the full patch could be found here.