jruby-http-kit 0.0.1

data/src/org/httpkit/client/Request.java

@@ -0,0 +1,74 @@
+package org.httpkit.client;
+
+import org.httpkit.PriorityQueue;
+
+import javax.net.ssl.SSLException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectionKey;
+
+public class Request implements Comparable<Request> {
+
+    final InetSocketAddress addr;
+    final Decoder decoder;
+    final ByteBuffer[] request; // HTTP request
+    final RequestConfig cfg;
+    private final PriorityQueue<Request> clients; // update timeout
+
+    // is modify from the loop thread. ensure only called once
+    private boolean isDone = false;
+
+    boolean isReuseConn = false; // a reused socket sent the request
+    boolean isConnected = false;
+    SelectionKey key; // for timeout, close connection
+
+    private long timeoutTs; // future time this request timeout, ms
+
+    public Request(InetSocketAddress addr, ByteBuffer[] request, IRespListener handler,
+                   PriorityQueue<Request> clients, RequestConfig config) {
+        this.cfg = config;
+        this.decoder = new Decoder(handler, config.method);
+        this.request = request;
+        this.clients = clients;
+        this.addr = addr;
+        this.timeoutTs = config.timeout + System.currentTimeMillis();
+    }
+
+    public void onProgress(long now) {
+        if (cfg.timeout + now - timeoutTs > 800) {
+            // update time
+            clients.remove(this);
+            timeoutTs = cfg.timeout + now;
+            clients.offer(this);
+        }
+    }
+
+    public void finish() {
+        clients.remove(this);
+        if (isDone)
+            return;
+        isDone = true;
+        decoder.listener.onCompleted();
+    }
+
+    public boolean isTimeout(long now) {
+        return timeoutTs < now;
+    }
+
+    public void finish(Throwable t) {
+        clients.remove(this);
+        if (isDone)
+            return;
+        isDone = true;
+        decoder.listener.onThrowable(t);
+    }
+
+    public int compareTo(Request o) {
+        return (int) (timeoutTs - o.timeoutTs);
+    }
+
+    public void recycle(Request old) throws SSLException {
+        this.key = old.key;
+    }
+}
+

data/src/org/httpkit/client/RequestConfig.java

@@ -0,0 +1,28 @@
+package org.httpkit.client;
+
+import org.httpkit.HttpMethod;
+
+import java.util.Map;
+
+public class RequestConfig {
+    public static String DEFAULT_USER_AGENT = "http-kit/2.0";
+
+    final int timeout;
+    final int keepAlive;
+    final Object body;
+    final Map<String, Object> headers;
+    final HttpMethod method;
+
+    public RequestConfig(HttpMethod method, Map<String, Object> headers, Object body,
+                         int timeoutMs, int keepAliveMs) {
+        this.timeout = timeoutMs;
+        this.keepAlive = keepAliveMs;
+        this.headers = headers;
+        this.body = body;
+        this.method = method;
+    }
+
+    public RequestConfig() { // for easy test only
+        this(HttpMethod.GET, null, null, 40000, -1);
+    }
+}

data/src/org/httpkit/client/RespListener.java

@@ -0,0 +1,160 @@
+package org.httpkit.client;
+
+import org.httpkit.*;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.Charset;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.concurrent.ExecutorService;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.Inflater;
+import java.util.zip.InflaterInputStream;
+
+import static org.httpkit.HttpUtils.CONTENT_ENCODING;
+import static org.httpkit.HttpUtils.CONTENT_TYPE;
+
+class Handler implements Runnable {
+
+    private final int status;
+    private final Map<String, Object> headers;
+    private final Object body;
+    private final IResponseHandler handler;
+
+    public Handler(IResponseHandler handler, int status, Map<String, Object> headers,
+                   Object body) {
+        this.handler = handler;
+        this.status = status;
+        this.headers = headers;
+        this.body = body;
+    }
+
+    public Handler(IResponseHandler handler, Throwable e) {
+        this(handler, 0, null, e);
+    }
+
+    public void run() {
+        if (body instanceof Throwable) {
+            handler.onThrowable((Throwable) body);
+        } else {
+            handler.onSuccess(status, headers, body);
+        }
+    }
+}
+
+/**
+ * Accumulate all the response, call upper logic at once, for easy use
+ */
+public class RespListener implements IRespListener {
+
+    private boolean isText() {
+        if (status.getCode() == 200) {
+            String type = HttpUtils.getStringValue(headers, CONTENT_TYPE);
+            if (type != null) {
+                type = type.toLowerCase();
+                // TODO may miss something
+                return type.contains("text") || type.contains("json") || type.contains("xml");
+            } else {
+                return false;
+            }
+        } else {  // non 200: treat as text
+            return true;
+        }
+    }
+
+    private DynamicBytes unzipBody() throws IOException {
+        String encoding = HttpUtils.getStringValue(headers, CONTENT_ENCODING);
+        if (encoding == null || body.length() == 0) {
+            return body;
+        }
+
+        encoding = encoding.toLowerCase();
+        BytesInputStream bis = new BytesInputStream(body.get(), body.length());
+        InputStream is;
+
+        if ("gzip".equals(encoding) || "x-gzip".equals(encoding)) {
+            is = new GZIPInputStream(bis);
+        } else if ("deflate".equals(encoding) || "x-deflate".equals(encoding)) {
+            // http://stackoverflow.com/questions/3932117/handling-http-contentencoding-deflate
+            is = new InflaterInputStream(bis, new Inflater(true));
+        } else {
+            return body; // not compressed
+        }
+
+        DynamicBytes unzipped = new DynamicBytes(body.length() * 5);
+        byte[] buffer = new byte[4096];
+        int read;
+        while ((read = is.read(buffer)) != -1) {
+            unzipped.append(buffer, read);
+        }
+        is.close();
+        return unzipped;
+    }
+
+    private final DynamicBytes body;
+
+    // can be empty
+    private Map<String, Object> headers = new TreeMap<String, Object>();
+    private HttpStatus status;
+    private final IResponseHandler handler;
+    private final IFilter filter;
+    private final ExecutorService pool;
+    final int coercion;
+
+    public RespListener(IResponseHandler handler, IFilter filter, ExecutorService pool, int coercion) {
+        body = new DynamicBytes(1024 * 8);
+        this.filter = filter;
+        this.handler = handler;
+        this.coercion = coercion;
+        this.pool = pool;
+    }
+
+    public void onBodyReceived(byte[] buf, int length) throws AbortException {
+        body.append(buf, length);
+        if (filter != null && !filter.accept(body)) {
+            throw new AbortException("Rejected when reading body, length: " + body.length());
+        }
+    }
+
+    public void onCompleted() {
+        if (status == null) {
+            pool.submit(new Handler(handler, new ProtocolException("No status")));
+            return;
+        }
+        try {
+            DynamicBytes bytes = unzipBody();
+            // 1=> auto, 2=>text, 3=>stream, 4=>byte-array
+            if (coercion == 2 || (coercion == 1 && isText())) {
+                Charset charset = HttpUtils.detectCharset(headers, bytes);
+                String html = new String(bytes.get(), 0, bytes.length(), charset);
+                pool.submit(new Handler(handler, status.getCode(), headers, html));
+            } else {
+                BytesInputStream is = new BytesInputStream(bytes.get(), bytes.length());
+                if (coercion == 4) { // byte-array
+                    pool.submit(new Handler(handler, status.getCode(), headers, is.bytes()));
+                } else {
+                    pool.submit(new Handler(handler, status.getCode(), headers, is));
+                }
+            }
+        } catch (IOException e) {
+            handler.onThrowable(e);
+        }
+    }
+
+    public void onThrowable(Throwable t) {
+        pool.submit(new Handler(handler, t));
+    }
+
+    public void onHeadersReceived(Map<String, Object> headers) throws AbortException {
+        this.headers = headers;
+        if (filter != null && !filter.accept(headers)) {
+            throw new AbortException("Rejected when header received");
+        }
+    }
+
+    public void onInitialLineReceived(HttpVersion version, HttpStatus status)
+            throws AbortException {
+        this.status = status;
+    }
+}

data/src/org/httpkit/client/SslContextFactory.java

@@ -0,0 +1,79 @@
+package org.httpkit.client;
+
+import javax.net.ssl.*;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+
+
+public class SslContextFactory {
+
+    private static final String PROTOCOL = "TLS";
+    private static final SSLContext CLIENT_CONTEXT;
+
+    static {
+        SSLContext clientContext = null;
+
+        try {
+            clientContext = SSLContext.getInstance(PROTOCOL);
+            clientContext.init(null, TrustManagerFactory.getTrustManagers(),
+                    null);
+        } catch (Exception e) {
+            throw new Error(
+                    "Failed to initialize the client-side SSLContext", e);
+        }
+
+        CLIENT_CONTEXT = clientContext;
+    }
+
+    public static SSLContext getClientContext() {
+        return CLIENT_CONTEXT;
+    }
+
+    public static SSLEngine trustAnybody() {
+        return CLIENT_CONTEXT.createSSLEngine();
+    }
+}
+
+
+class TrustManagerFactory extends TrustManagerFactorySpi {
+
+    private static final TrustManager DUMMY_TRUST_MANAGER = new X509TrustManager() {
+        public X509Certificate[] getAcceptedIssuers() {
+            return new X509Certificate[0];
+        }
+
+        public void checkClientTrusted(X509Certificate[] chain,
+                                       String authType) throws CertificateException {
+            // Always trust
+        }
+
+        public void checkServerTrusted(X509Certificate[] chain,
+                                       String authType) throws CertificateException {
+            // Always trust
+        }
+    };
+
+    public static TrustManager[] getTrustManagers() {
+        return new TrustManager[]{DUMMY_TRUST_MANAGER};
+    }
+
+    @Override
+    protected TrustManager[] engineGetTrustManagers() {
+        return getTrustManagers();
+    }
+
+    @Override
+    protected void engineInit(KeyStore keystore) throws KeyStoreException {
+        // Unused
+    }
+
+    @Override
+    protected void engineInit(
+            ManagerFactoryParameters managerFactoryParameters)
+            throws InvalidAlgorithmParameterException {
+        // Unused
+    }
+}

data/src/org/httpkit/client/TimeoutException.java

@@ -0,0 +1,12 @@
+package org.httpkit.client;
+
+import org.httpkit.HTTPException;
+
+public class TimeoutException extends HTTPException {
+
+    private static final long serialVersionUID = 1L;
+
+    public TimeoutException(String msg) {
+        super(msg);
+    }
+}

data/src/org/httpkit/server/AsyncChannel.java

@@ -0,0 +1,286 @@
+package org.httpkit.server;
+
+import clojure.lang.IFn;
+import clojure.lang.Keyword;
+import org.httpkit.DynamicBytes;
+import org.httpkit.HeaderMap;
+import org.httpkit.HttpVersion;
+import sun.misc.Unsafe;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.net.Socket;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.SocketChannel;
+import java.util.Map;
+
+import static org.httpkit.HttpUtils.*;
+import static org.httpkit.server.ClojureRing.*;
+import static org.httpkit.server.WSDecoder.*;
+
+@SuppressWarnings({"unchecked"})
+public class AsyncChannel {
+    static final Unsafe unsafe;
+    static final long closedRanOffset;
+    static final long closeHandlerOffset;
+    static final long receiveHandlerOffset;
+    static final long headerSentOffset;
+
+    private final SelectionKey key;
+    private final HttpServer server;
+
+    private HttpRequest request;     // package private, for http 1.0 keep-alive
+
+    volatile int closedRan = 0; // 0 => false, 1 => run
+    // streaming
+    private volatile int isHeaderSent = 0;
+
+    private volatile IFn receiveHandler = null;
+    volatile IFn closeHandler = null;
+
+    static {
+        try {
+            // Unsafe instead of AtomicReference to save few bytes of RAM per connection
+            Field field = Unsafe.class.getDeclaredField("theUnsafe");
+            field.setAccessible(true);
+            unsafe = (Unsafe) field.get(null);
+
+            closedRanOffset = unsafe.objectFieldOffset(
+                    AsyncChannel.class.getDeclaredField("closedRan"));
+            closeHandlerOffset = unsafe.objectFieldOffset(
+                    AsyncChannel.class.getDeclaredField("closeHandler"));
+            receiveHandlerOffset = unsafe.objectFieldOffset(
+                    AsyncChannel.class.getDeclaredField("receiveHandler"));
+            headerSentOffset = unsafe.objectFieldOffset(
+                    AsyncChannel.class.getDeclaredField("isHeaderSent"));
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+
+    // messages sent from a WebSocket client should be handled orderly by server
+    // Changed from a Single Thread(IO event thread), no volatile needed
+    LinkingRunnable serialTask;
+
+    public AsyncChannel(SelectionKey key, HttpServer server) {
+        this.key = key;
+        this.server = server;
+    }
+
+    public void reset(HttpRequest request) {
+        this.request = request;
+        serialTask = null;
+        unsafe.putOrderedInt(this, closedRanOffset, 0); // lazySet to false
+        unsafe.putOrderedInt(this, headerSentOffset, 0);
+
+        unsafe.putOrderedObject(this, closeHandlerOffset, null); // lazySet to null
+        unsafe.putOrderedObject(this, receiveHandlerOffset, null); // lazySet to null
+    }
+
+    private static final byte[] finalChunkBytes = "0\r\n\r\n".getBytes();
+    private static final byte[] newLineBytes = "\r\n".getBytes();
+
+    private static ByteBuffer chunkSize(int size) {
+        String s = Integer.toHexString(size) + "\r\n";
+        return ByteBuffer.wrap(s.getBytes());
+    }
+
+    private void firstWrite(Object data, boolean close) throws IOException {
+        ByteBuffer buffers[];
+        int status = 200;
+        Object body = data;
+        HeaderMap headers;
+        if (data instanceof Map) {
+            Map<Keyword, Object> resp = (Map<Keyword, Object>) data;
+            headers = HeaderMap.camelCase((Map) resp.get(HEADERS));
+            status = getStatus(resp);
+            body = resp.get(BODY);
+        } else {
+            headers = new HeaderMap();
+        }
+
+        if (headers.isEmpty()) { // default 200 and text/html
+            headers.put("Content-Type", "text/html; charset=utf-8");
+        }
+
+        if (request.isKeepAlive && request.version == HttpVersion.HTTP_1_0) {
+            headers.put("Connection", "Keep-Alive");
+        }
+
+        if (close) { // normal response, Content-Length. Every http client understand it
+            buffers = HttpEncode(status, headers, body);
+        } else {
+            headers.put("Transfer-Encoding", "chunked"); // first chunk
+            ByteBuffer[] bb = HttpEncode(status, headers, body);
+            if (body == null) {
+                buffers = bb;
+            } else {
+                buffers = new ByteBuffer[]{bb[0], chunkSize(bb[1].remaining()), bb[1],
+                        ByteBuffer.wrap(newLineBytes)};
+            }
+        }
+        if (close) {
+            onClose(0);
+        }
+        server.tryWrite(key, buffers);
+    }
+
+
+    private void writeChunk(Object body, boolean close) throws IOException {
+        if (body instanceof Map) { // only get body if a map
+            body = ((Map<Keyword, Object>) body).get(BODY);
+        }
+        if (body != null) { // null is ignored
+            ByteBuffer buffers[];
+            ByteBuffer t = bodyBuffer(body);
+            if (t.hasRemaining()) {
+                ByteBuffer size = chunkSize(t.remaining());
+                buffers = new ByteBuffer[]{size, t, ByteBuffer.wrap(newLineBytes)};
+                server.tryWrite(key, buffers);
+            }
+        }
+        if (close) {
+            serverClose(0);
+        }
+    }
+
+    public void setReceiveHandler(IFn fn) {
+        if (!unsafe.compareAndSwapObject(this, receiveHandlerOffset, null, fn)) {
+            throw new IllegalStateException("receive handler exist: " + receiveHandler);
+        }
+    }
+
+    public void messageReceived(final Object mesg) {
+        IFn f = receiveHandler;
+        if (f != null) {
+            f.invoke(mesg); // byte[] or String
+        }
+    }
+
+    public void sendHandshake(Map<String, Object> headers) {
+        HeaderMap map = HeaderMap.camelCase(headers);
+        server.tryWrite(key, HttpEncode(101, map, null));
+    }
+
+    public void setCloseHandler(IFn fn) {
+        if (!unsafe.compareAndSwapObject(this, closeHandlerOffset, null, fn)) { // only once
+            throw new IllegalStateException("close handler exist: " + closeHandler);
+        }
+        if (closedRan == 1) { // no handler, but already closed
+            fn.invoke(K_UNKNOWN);
+        }
+    }
+
+    public void onClose(int status) {
+        if (unsafe.compareAndSwapInt(this, closedRanOffset, 0, 1)) {
+            IFn f = closeHandler;
+            if (f != null) {
+                f.invoke(readable(status));
+            }
+        }
+    }
+
+    // also sent CloseFrame a final Chunk
+    public boolean serverClose(int status) {
+        if (!unsafe.compareAndSwapInt(this, closedRanOffset, 0, 1)) {
+            return false; // already closed
+        }
+        if (isWebSocket()) {
+            server.tryWrite(key, WsEncode(OPCODE_CLOSE, ByteBuffer.allocate(2)
+                    .putShort((short) status).array()));
+        } else {
+            server.tryWrite(key, ByteBuffer.wrap(finalChunkBytes));
+        }
+        IFn f = closeHandler;
+        if (f != null) {
+            f.invoke(readable(0)); // server close is 0
+        }
+        return true;
+    }
+
+    public boolean send(Object data, boolean close) throws IOException {
+        if (closedRan == 1) {
+            return false;
+        }
+
+        if (isWebSocket()) {
+            if (data instanceof Map) { // only get the :body if map
+                Object tmp = ((Map<Keyword, Object>) data).get(BODY);
+                if (tmp != null) { // save contains(BODY) && get(BODY)
+                    data = tmp;
+                }
+            }
+
+            if (data instanceof String) { // null is not allowed
+                server.tryWrite(key, WsEncode(OPCODE_TEXT, ((String) data).getBytes(UTF_8)));
+            } else if (data instanceof byte[]) {
+                server.tryWrite(key, WsEncode(OPCODE_BINARY, (byte[]) data));
+            } else if (data instanceof InputStream) {
+                DynamicBytes bytes = readAll((InputStream) data);
+                server.tryWrite(key, WsEncode(OPCODE_BINARY, bytes.get(), bytes.length()));
+            } else if (data != null) { // ignore null
+                String mesg = "send! called with data: " + data.toString() +
+                        "(" + data.getClass() + "), but only string, byte[], InputStream expected";
+                throw new IllegalArgumentException(mesg);
+            }
+
+            if (close) {
+                serverClose(1000);
+            }
+        } else {
+            if (isHeaderSent == 1) {  // HTTP Streaming
+                writeChunk(data, close);
+            } else {
+                isHeaderSent = 1;
+                firstWrite(data, close);
+            }
+        }
+        return true;
+    }
+
+    public String toString() {
+        Socket s = ((SocketChannel) key.channel()).socket();
+        return s.getLocalSocketAddress() + "<->" + s.getRemoteSocketAddress();
+    }
+
+    public boolean isWebSocket() {
+        return key.attachment() instanceof WsAtta;
+    }
+
+    public boolean isClosed() {
+        return closedRan == 1;
+    }
+
+    static Keyword K_BY_SERVER = Keyword.intern("server-close");
+    static Keyword K_CLIENT_CLOSED = Keyword.intern("client-close");
+
+    // http://datatracker.ietf.org/doc/rfc6455/?include_text=1
+    // 7.4.1. Defined Status Codes
+    static Keyword K_WS_1000 = Keyword.intern("normal");
+    static Keyword K_WS_1001 = Keyword.intern("going-away");
+    static Keyword K_WS_1002 = Keyword.intern("protocol-error");
+    static Keyword K_WS_1003 = Keyword.intern("unsupported");
+    static Keyword K_UNKNOWN = Keyword.intern("unknown");
+
+    private static Keyword readable(int status) {
+        switch (status) {
+            case 0:
+                return K_BY_SERVER;
+            case -1:
+                return K_CLIENT_CLOSED;
+            case 1000:
+                return K_WS_1000;
+            case 1001:
+                return K_WS_1001;
+            case 1002:
+                return K_WS_1002;
+            case 1003:
+                return K_WS_1003;
+            default:
+                return K_UNKNOWN;
+        }
+    }
+}