Project Grizzly

/**
 * Suspend the {@link Response}. Suspending a {@link Response} will
 * tell the underlying container to avoid recycling objects associated with
 * the current instance, and also to avoid committing response.
 */
public void suspend() {
    ...
}

/**
 * Suspend the {@link Response}. Suspending a {@link Response} will
 * tell the underlying container to avoid recycling objects associated with
 * the current instance, and also to avoid committing response.
 *
 * @param timeout The maximum amount of time,
 * a {@link Response} can be suspended. When the timeout expires (because
 * nothing has been written or because the {@link Response#resume()}),
 * the {@link Response} will be automatically
 * resumed and committed. Usage of any methods of a {@link Response} that
 * times out will throw an {@link IllegalStateException}.
 * @param timeunit timeout units
 *
 */
public void suspend(final long timeout, final TimeUnit timeunit) {
    ...
}

/**
 * Suspend the {@link Response}. Suspending a {@link Response} will
 * tell the underlying container to avoid recycling objects associated with
 * the current instance, and also to avoid committing response. When the
 * {@link Response#resume()} is invoked, the container will
 * make sure {@link CompletionHandler#completed(Object)}
 * is invoked with the original <tt>attachment</tt>.
 * If the timeout expires, the
 * {@link org.glassfish.grizzly.CompletionHandler#cancelled()} is invoked with
 * the original <tt>attachment</tt> and the {@link Response} committed.
 *
 * @param timeout The maximum amount of time the {@link Response} can be suspended.
 * When the timeout expires (because nothing has been written or because the
 * {@link Response#resume()}), the {@link Response}
 * will be automatically resumed and committed. Usage of any methods of a
 * {@link Response} that times out will throw an {@link IllegalStateException}.
 * @param timeunit timeout units
 * @param completionHandler a {@link org.glassfish.grizzly.CompletionHandler}
 */
public void suspend(final long timeout,
                    final TimeUnit timeunit,
                    final CompletionHandler<Response> completionHandler) {
    ...
}

/**
 * Suspend the {@link Response}. Suspending a {@link Response} will
 * tell the underlying container to avoid recycling objects associated with
 * the current instance, and also to avoid committing response. When the
 * {@link Response#resume()} is invoked, the container will
 * make sure {@link CompletionHandler#completed(Object)}
 * is invoked with the original <tt>attachment</tt>.
 * If the timeout expires, the
 * {@link org.glassfish.grizzly.CompletionHandler#cancelled()} is invoked with the
 * original <tt>attachment</tt> and the {@link Response} committed.
 *
 * @param timeout The maximum amount of time the {@link Response} can be suspended.
 * When the timeout expires (because nothing has been written or because the
 * {@link Response#resume()}), the {@link Response}
 * will be automatically resumed and committed. Usage of any methods of a
 * {@link Response} that times out will throw an {@link IllegalStateException}.
 * @param timeunit timeunit
 * @param completionHandler a {@link org.glassfish.grizzly.CompletionHandler}
 * @param timeoutHandler {@link TimeoutHandler} to customize the suspended
 *  <tt>Response</tt> timeout logic.
 */
public void suspend(final long timeout,
                    final TimeUnit timeunit,
                    final CompletionHandler<Response> completionHandler,
                    final TimeoutHandler timeoutHandler) {
    ...
}

/**
 * Complete the {@link Response} and finish/commit it. If a
 * {@link CompletionHandler} has been defined, its
 * {@link CompletionHandler#completed(Object)} will first be invoked,
 * then the {@link Response#finish()}.
 * Those operations commit the response.
 */
public void resume() {
    ...
}

/**
 * Get the context of the suspended <tt>Response</tt>.
 *
 * @return the context of the suspended <tt>Response</tt>.
 */
public SuspendContext getSuspendContext() {
    ...
}

/**
 * Return <tt>true<//tt> if that {@link Response#suspend()} has been
 * invoked and set to <tt>true</tt>
 * @return <tt>true<//tt> if that {@link Response#suspend()} has been
 * invoked and set to <tt>true</tt>
 */
public boolean isSuspended() {
    ...
}

final AccessLogBuilder builder = new AccessLogBuilder("/tmp/access.log");
builder.instrument(httpServer.getServerConfiguration());

/**
 * The {@link HttpServer} addon interface, responsible for adding
 * features like WebSockets, Comet to HttpServer.
 */
public interface AddOn {
    /**
     * The method, which will be invoked by {@link HttpServer} in order to
     * initialize the AddOn on the passed {@link NetworkListener}.
     * Most of the time the AddOn implementation will update the passed
     * {@link NetworkListener}'s {@link FilterChainBuilder} by adding custom
     * {@link Filter}(s), which implement AddOn's logic.
     *
     * @param networkListener the {@link NetworkListener} the addon is being
     *          initialized on.
     * @param builder the {@link FilterChainBuilder},
     *          representing the {@link NetworkListener} logic.
     */
    public void setup(NetworkListener networkListener,
            FilterChainBuilder builder);
}

/**
 * WebSockets {@link AddOn} for the {@link org.glassfish.grizzly.http.server.HttpServer}.
 */
public class WebSocketAddOn implements AddOn {

    @Override
    public void setup(final NetworkListener networkListener,
            final FilterChainBuilder builder) {

        // Get the index of HttpCodecFilter in the HttpServer filter chain
        final int httpCodecFilterIdx = builder.indexOfType(HttpCodecFilter.class);

        if (httpCodecFilterIdx >= 0) {
            // Insert the WebSocketFilter right after HttpCodecFilter
            builder.add(httpCodecFilterIdx + 1, new WebSocketFilter());
        }
    }
}

public class MyHttpHandler extends HttpHandler {
    ...................................

    /**
     * Returns the <tt>HttpHandler</tt> preferred {@link ExecutorService} to process
     * passed {@link Request}. The <tt>null</tt> return value means process in
     * current thread.
     *
     * The default implementation returns <tt>null</tt> if current thread is not
     * {@link Transport} service thread ({@link Threads#isService()}). Otherwise
     * returns worker thread pool of the {@link Transport} this {@link Request}
     * belongs to ({@link org.glassfish.grizzly.Transport#getWorkerThreadPool()}).
     *
     * @param request the {@link Request} to be processed.
     * @return the <tt>HttpHandler</tt> preferred {@link ExecutorService} to process
     * passed {@link Request}. The <tt>null</tt> return value means process in
     * current thread.
     */
    @Override
    protected ExecutorService getThreadPool(final Request request) {
        // return ExecutorService to process this Request
    }
}

networkListener.getTransport().setWorkerThreadPoolConfig(null);

/**
 * This handler using non-blocking streams to read POST data and echo it
 * back to the client.
 */
private static class NonBlockingEchoHandler extends HttpHandler {


    // -------------------------------------------- Methods from HttpHandler


    @Override
    public void service(final Request request,
                        final Response response) throws Exception {

        final char[] buf = new char[128];
        final NIOReader in = request.getNIOReader(); // return the non-blocking InputStream
        final NIOWriter out = response.getNIOWriter();

        response.suspend();

        // If we don't have more data to read - onAllDataRead() will be called
        in.notifyAvailable(new ReadHandler() {

            @Override
            public void onDataAvailable() throws Exception {
                System.out.printf("[onDataAvailable] echoing %d bytes\n", in.readyData());
                echoAvailableData(in, out, buf);
                in.notifyAvailable(this);
            }

            @Override
            public void onError(Throwable t) {
                System.out.println("[onError]" + t);
                response.resume();
            }

            @Override
            public void onAllDataRead() throws Exception {
                System.out.printf("[onAllDataRead] length: %d\n", in.readyData());
                try {
                    echoAvailableData(in, out, buf);
                } finally {
                    try {
                        in.close();
                    } catch (IOException ignored) {
                    }

                    try {
                        out.close();
                    } catch (IOException ignored) {
                    }

                    response.resume();
                }
            }
        });

    }

    private void echoAvailableData(NIOReader in, NIOWriter out, char[] buf)
            throws IOException {

        while(in.isReady()) {
            int len = in.read(buf);
            out.write(buf, 0, len);
        }
    }

} // END NonBlockingEchoHandler

public static void main(String[] args) {

    // create a basic server that listens on port 8080.
    final HttpServer server = HttpServer.createSimpleServer();

    final ServerConfiguration config = server.getServerConfiguration();

    // Map the path, /echo, to the NonBlockingEchoHandler
    config.addHttpHandler(new NonBlockingEchoHandler(), "/echo");

    try {
        server.start();
        Client client = new Client();
        client.run();
    } catch (IOException ioe) {
        LOGGER.log(Level.SEVERE, ioe.toString(), ioe);
    } finally {
        server.shutdownNow();
    }
}

private static final class ClientFilter extends BaseFilter {

            private static final String[] CONTENT = {
                "contentA-",
                "contentB-",
                "contentC-",
                "contentD"
            };

            private FutureImpl<String> future;

            private StringBuilder sb = new StringBuilder();

            // ---------------------------------------------------- Constructors


            private ClientFilter(FutureImpl<String> future) {
                this.future = future;
            }


            // ----------------------------------------- Methods from BaseFilter


            @SuppressWarnings({"unchecked"})
            @Override
            public NextAction handleConnect(FilterChainContext ctx) throws IOException {
                System.out.println("\nClient connected!\n");

                HttpRequestPacket request = createRequest();
                System.out.println("Writing request:\n");
                System.out.println(request.toString());
                ctx.write(request); // write the request

                // for each of the content parts in CONTENT, wrap in a Buffer,
                // create the HttpContent to wrap the buffer and write the
                // content.
                MemoryManager mm = ctx.getConnection().getTransport().getMemoryManager();
                for (int i = 0, len = CONTENT.length; i < len; i++) {
                    HttpContent.Builder contentBuilder = request.httpContentBuilder();
                    Buffer b = Buffers.wrap(mm, CONTENT[i]);
                    contentBuilder.content(b);
                    HttpContent content = contentBuilder.build();
                    System.out.printf("(Client writing: %s)\n", b.toStringContent());
                    ctx.write(content);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // since the request created by createRequest() is chunked,
                // we need to write the trailer to signify the end of the
                // POST data
                ctx.write(request.httpTrailerBuilder().build());

                System.out.println("\n");

                return ctx.getStopAction(); // discontinue filter chain execution

            }


            @Override
            public NextAction handleRead(FilterChainContext ctx) throws IOException {

                HttpContent c = (HttpContent) ctx.getMessage();
                Buffer b = c.getContent();
                if (b.hasRemaining()) {
                    sb.append(b.toStringContent());
                }

                // Last content from the server, set the future result so
                // the client can display the result and gracefully exit.
                if (c.isLast()) {
                    future.result(sb.toString());
                }
                return ctx.getStopAction(); // discontinue filter chain execution

            }


            // ------------------------------------------------- Private Methods


            private HttpRequestPacket createRequest() {

                HttpRequestPacket.Builder builder = HttpRequestPacket.builder();
                builder.method("POST");
                builder.protocol("HTTP/1.1");
                builder.uri("/echo");
                builder.chunked(true);
                HttpRequestPacket packet = builder.build();
                packet.addHeader(Header.Host, HOST + ':' + PORT);
                return packet;

            }

        }

    } // END Client

private static final class Client {

    private static final String HOST = "localhost";
    private static final int PORT = 8080;

    public void run() throws IOException {
        final FutureImpl<String> completeFuture = SafeFutureImpl.create();

        // Build HTTP client filter chain
        FilterChainBuilder clientFilterChainBuilder = FilterChainBuilder.stateless();
        // Add transport filter
        clientFilterChainBuilder.add(new TransportFilter());

        // Add HttpClientFilter, which transforms Buffer <-> HttpContent
        clientFilterChainBuilder.add(new HttpClientFilter());
        // Add ClientFilter
        clientFilterChainBuilder.add(new ClientFilter(completeFuture));


        // Initialize Transport
        final TCPNIOTransport transport =
               TCPNIOTransportBuilder.newInstance().build();
        // Set filterchain as a Transport Processor
        transport.setProcessor(clientFilterChainBuilder.build());

        try {
            // start the transport
            transport.start();

            Connection connection = null;

            // Connecting to a remote Web server
            Future<Connection> connectFuture = transport.connect(HOST, PORT);
            try {
                // Wait until the client connect operation will be completed
                // Once connection has been established, the POST will
                // be sent to the server.
                connection = connectFuture.get(10, TimeUnit.SECONDS);

                // Wait no longer than 30 seconds for the response from the
                // server to be complete.
                String result = completeFuture.get(30, TimeUnit.SECONDS);

                // Display the echoed content
                System.out.println("\nEchoed POST Data: " + result + '\n');
            } catch (Exception e) {
                if (connection == null) {
                    LOGGER.log(Level.WARNING, "Connection failed.  Server is not listening.");
                } else {
                    LOGGER.log(Level.WARNING, "Unexpected error communicating with the server.");
                }
            } finally {
                // Close the client connection
                if (connection != null) {
                    connection.close();
                }
            }
        } finally {
            // stop the transport
            transport.shutdownNow();
        }
    }

Sep 22, 2011 3:22:58 PM org.glassfish.grizzly.http.server.NetworkListener start
INFO: Started listener bound to [0.0.0.0:8080]
Sep 22, 2011 3:22:58 PM org.glassfish.grizzly.http.server.HttpServer start
INFO: [HttpServer] Started.

Client connected!

Writing request:

HttpRequestPacket (
   method=POST
   url=/echo
   query=null
   protocol=HTTP/1.1
   content-length=-1
   headers=\[
      Host=localhost:8080]
)
(Client writing: contentA-)
[onDataAvailable] echoing 9 bytes

(delay 2 seconds)

(Client writing: contentB-)
[onDataAvailable] echoing 9 bytes

(delay 2 seconds)

(Client writing: contentC-)
[onDataAvailable] echoing 9 bytes

(delay 2 seconds)

(Client writing: contentD)
[onDataAvailable] echoing 8 bytes


[onAllDataRead] length: 0

Echoed POST Data: contentA-contentB-contentC-contentD

Sep 22, 2011 3:23:06 PM org.glassfish.grizzly.http.server.NetworkListener stop
INFO: Stopped listener bound to \[0.0.0.0:8080]

git clone https://github.com/eclipse-ee4j/grizzly.git
cd grizzly
git checkout initial-contribution
cd samples/http-server-samples