jruby-http-kit 0.0.1

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

@@ -0,0 +1,181 @@
+package org.httpkit.server;
+
+import org.httpkit.ProtocolException;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+public class WSDecoder {
+
+    public static final byte OPCODE_CONT = 0x0;
+    public static final byte OPCODE_TEXT = 0x1;
+    public static final byte OPCODE_BINARY = 0x2;
+    public static final byte OPCODE_CLOSE = 0x8;
+    public static final byte OPCODE_PING = 0x9;
+    public static final byte OPCODE_PONG = 0xA;
+
+    public enum State {
+        FRAME_START, READ_LENGTH, READ_2_LENGTH, READ_8_LENGTH, MASKING_KEY, PAYLOAD, CORRUPT
+    }
+
+    private State state = State.FRAME_START;
+    private byte[] content;
+    private int idx = 0;
+
+    private int payloadLength;
+    private int payloadRead;
+    private int maskingKey;
+    private boolean finalFlag;
+    private int opcode = -1;
+    private int framePayloadIndex; // masking per frame
+
+    // 8 bytes are enough
+    // protect against long/short/int are not fully received
+    private ByteBuffer tmpBuffer = ByteBuffer.allocate(8);
+
+    private boolean isAvailable(ByteBuffer src, int length) {
+        while (tmpBuffer.position() < length) {
+            if (src.hasRemaining()) {
+                tmpBuffer.put(src.get());
+            } else {
+                return false;
+            }
+        }
+        tmpBuffer.flip(); // for read
+        return true;
+    }
+
+    public Frame decode(ByteBuffer buffer) throws ProtocolException {
+        while (buffer.hasRemaining()) {
+            switch (state) {
+                case FRAME_START:
+                    byte b = buffer.get(); // FIN, RSV, OPCODE
+                    finalFlag = (b & 0x80) != 0;
+
+                    int tmpOp = b & 0x0F;
+                    if (opcode != -1 && tmpOp != opcode) {
+                        // TODO ping frame in fragmented text frame
+                        throw new ProtocolException("opcode mismatch: pre: " + opcode + ", now: "
+                                + tmpOp);
+                    }
+                    opcode = tmpOp;
+                    state = State.READ_LENGTH;
+                    break;
+                case READ_LENGTH:
+                    b = buffer.get(); // MASK, PAYLOAD LEN 1
+                    boolean masked = (b & 0x80) != 0;
+                    if (!masked) {
+                        throw new ProtocolException("unmasked client to server frame");
+                    }
+                    payloadLength = b & 0x7F;
+                    if (payloadLength == 126) {
+                        state = State.READ_2_LENGTH;
+                    } else if (payloadLength == 127) {
+                        state = State.READ_8_LENGTH;
+                    } else {
+                        state = State.MASKING_KEY;
+                    }
+                    break;
+                case READ_2_LENGTH:
+                    if (isAvailable(buffer, 2)) {
+                        payloadLength = tmpBuffer.getShort() & 0xFFFF;
+                        tmpBuffer.clear();
+                        if (payloadLength < 126) {
+                            throw new ProtocolException(
+                                    "invalid data frame length (not using minimal length encoding)");
+                        }
+                        state = State.MASKING_KEY;
+                    }
+                    break;
+                case READ_8_LENGTH:
+                    if (isAvailable(buffer, 8)) {
+                        long length = tmpBuffer.getLong();
+                        tmpBuffer.clear();
+                        // if negative, that too big, drop it.
+                        if (length < 65536) {
+                            throw new ProtocolException("invalid data frame length. max payload length 4M");
+                        }
+                        abortIfTooLarge(length);
+                        payloadLength = (int) length;
+                        state = State.MASKING_KEY;
+                    }
+                    break; // wait for more data from TCP
+                case MASKING_KEY:
+                    if (isAvailable(buffer, 4)) {
+                        maskingKey = tmpBuffer.getInt();
+                        tmpBuffer.clear();
+                        if (content == null) {
+                            content = new byte[payloadLength];
+                        } else if (payloadLength > 0) {
+                            abortIfTooLarge(content.length + payloadLength);
+                            /*
+                             * TODO if an attacker sent many fragmented frames, only one
+                             * byte of data per frame, server end up reallocate many
+                             * times. may not be a problem
+                             */
+                            // resize
+                            content = Arrays.copyOf(content, content.length + payloadLength);
+                        }
+                        framePayloadIndex = 0; // reset
+                        state = State.PAYLOAD;
+                        // No break. since payloadLength can be 0
+                    } else {
+                        break; // wait for more data from TCP
+                    }
+                case PAYLOAD:
+                    int read = Math.min(buffer.remaining(), payloadLength - payloadRead);
+                    if (read > 0) {
+                        buffer.get(content, idx, read);
+
+                        byte[] mask = ByteBuffer.allocate(4).putInt(maskingKey).array();
+                        for (int i = 0; i < read; i++) {
+                            content[i + idx] = (byte) (content[i + idx] ^ mask[(framePayloadIndex + i) % 4]);
+                        }
+
+                        payloadRead += read;
+                        idx += read;
+                    }
+                    framePayloadIndex += read;
+
+                    // all read (this frame)
+                    if (payloadRead == payloadLength) {
+                        if (finalFlag) {
+                            switch (opcode) {
+                                case OPCODE_TEXT:
+                                    return new Frame.TextFrame(content);
+                                case OPCODE_BINARY:
+                                    return new Frame.BinaryFrame(content);
+                                case OPCODE_PING:
+                                    return new Frame.PingFrame(content);
+                                case OPCODE_CLOSE:
+                                    return new Frame.CloseFrame(content);
+                                default:
+                                    throw new ProtocolException("not impl for opcode: " + opcode);
+                            }
+                        } else {
+                            state = State.FRAME_START;
+                            payloadRead = 0;
+                        }
+                    }
+                    break;
+            }
+        }
+        return null; // wait for more bytes
+    }
+
+    public void abortIfTooLarge(long length) throws ProtocolException {
+        // TODO configurable
+        if (length > 1024 * 1024 * 4) { // 4M, drop if message is too big
+            throw new ProtocolException("Max payload length 4m, get: " + length);
+        }
+    }
+
+    public void reset() {
+        state = State.FRAME_START;
+        payloadRead = 0;
+        idx = 0;
+        opcode = -1;
+        content = null;
+        framePayloadIndex = 0;
+    }
+}

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

@@ -0,0 +1,11 @@
+package org.httpkit.server;
+
+public class WsAtta extends ServerAtta {
+
+    final public WSDecoder decoder;
+
+    public WsAtta(AsyncChannel channel) {
+        this.decoder = new WSDecoder();
+        this.channel = channel;
+    }
+}

data/src/org/httpkit/timer/CancelableFutureTask.java

@@ -0,0 +1,52 @@
+package org.httpkit.timer;
+
+import clojure.lang.IFn;
+import org.httpkit.PriorityQueue;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class CancelableFutureTask implements Comparable<CancelableFutureTask> {
+
+    private final int timeout;
+    private final IFn futureTask;
+    public final long timeoutTs;
+
+    private final AtomicBoolean done = new AtomicBoolean(false);
+    private final PriorityQueue<CancelableFutureTask> queue;
+
+    public CancelableFutureTask(int timeout, IFn task, PriorityQueue<CancelableFutureTask> queue) {
+        this.timeoutTs = System.currentTimeMillis() + timeout;
+        this.timeout = timeout;
+        this.futureTask = task;
+        this.queue = queue;
+    }
+
+    public String toString() {
+        long now = System.currentTimeMillis();
+        if (done.get()) {
+            return "timeout=" + timeout + "ms, done or canceled";
+        } else {
+            return "timeout=" + timeout + "ms, due in " + (timeoutTs - now) + "ms";
+        }
+    }
+
+    public void runTask() {
+        if (done.compareAndSet(false, true)) {
+            futureTask.invoke();
+        }
+    }
+
+    public boolean cancel() {
+        boolean b = done.compareAndSet(false, true);
+        if (b) {// ok, not done
+            synchronized (queue) {
+                queue.remove(this);
+            }
+        }
+        return b;
+    }
+
+    public int compareTo(CancelableFutureTask o) {
+        return (int) (timeoutTs - o.timeoutTs);
+    }
+}

data/src/org/httpkit/timer/TimerService.java

@@ -0,0 +1,89 @@
+package org.httpkit.timer;
+
+import clojure.lang.IFn;
+import org.httpkit.HttpUtils;
+import org.httpkit.PriorityQueue;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class TimerService implements Runnable {
+
+    private final PriorityQueue<CancelableFutureTask> queue = new PriorityQueue<CancelableFutureTask>();
+    private final AtomicBoolean started = new AtomicBoolean(false);
+
+    public CancelableFutureTask scheduleTask(int timeout, IFn task) {
+        // start the timer thread, if not started
+        if (started.compareAndSet(false, true)) {
+            // the timer thread will kill itself when no job to schedule for too
+            // much time. restart if new job come it
+            Thread t = new Thread(this, "timer-service");
+            t.start();
+        }
+
+        CancelableFutureTask t = new CancelableFutureTask(timeout, task, queue);
+        synchronized (queue) {
+            queue.offer(t);
+            queue.notify();
+        }
+        return t;
+    }
+
+    public static final TimerService SERVICE = new TimerService();
+
+    @Override
+    public String toString() {
+        return "pending=" + queue.size() + ", thread started:" + started.get();
+    }
+
+    public void run() {
+        // if 2 checks of the queue, find it empty, stop self
+        boolean emptyQueueWaited = false;
+        CancelableFutureTask task;
+        while (true) {
+            synchronized (queue) {
+                task = queue.peek();
+            }
+            if (task == null) {
+                synchronized (queue) {
+                    try {
+                        // wait 2 minute before kill self
+                        queue.wait(1000 * 120);
+                        if (emptyQueueWaited) {
+                            started.compareAndSet(true, false);
+                            break; // die, will restart
+                        } else {
+                            emptyQueueWaited = true; // queue is empty
+                        }
+                    } catch (InterruptedException ignore) {
+                    }
+                }
+            } else {
+                emptyQueueWaited = false;
+                long due = task.timeoutTs - System.currentTimeMillis();
+                // schedule to run in 1000ms, maybe run in 1000ms, 1001ms, ...
+                if (due <= 0) {
+                    try {
+                        task.runTask();
+                    } catch (Exception e) {
+                        HttpUtils.printError("In timer: " + task, e);
+                    }
+                    synchronized (queue) { // remove
+                        if (task == queue.peek()) {
+                            queue.poll(); // much faster
+                        } else {
+                            queue.remove(task);
+                        }
+                    }
+                } else {
+                    synchronized (queue) {
+                        try {
+                            queue.wait(due); // others may notify you
+                        } catch (InterruptedException ignore) {
+                            // maybe more urgent job come in
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

metadata

@@ -0,0 +1,241 @@
+--- !ruby/object:Gem::Specification
+name: jruby-http-kit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dmitriy Rozhkov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-09-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: webmachine
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+description: ''
+email:
+- rojkov.dmitry@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- example/config.ru
+- example/hello_world.rb
+- example/rack.rb
+- example/ring.rb
+- example/sinatra/app.rb
+- example/sinatra/config.ru
+- example/webmachine/Gemfile
+- example/webmachine/Gemfile.lock
+- example/webmachine/app.rb
+- jruby-http-kit.gemspec
+- lib/http_kit.rb
+- lib/http_kit/rack_handler.rb
+- lib/http_kit/server.rb
+- lib/http_kit/version.rb
+- lib/java/clojure-1.5.1.jar
+- lib/java/http-kit.jar
+- lib/rack/handler/http_kit.rb
+- lib/rack/http_kit.rb
+- lib/webmachine/adapters/ring.rb
+- spec/spec_helper.rb
+- spec/support/test_resource.rb
+- spec/webmachine/ring_adapter_spec.rb
+- src/.classpath
+- src/.project
+- src/org/httpkit/BytesInputStream.class
+- src/org/httpkit/BytesInputStream.java
+- src/org/httpkit/DateFormatter.class
+- src/org/httpkit/DynamicBytes.class
+- src/org/httpkit/DynamicBytes.java
+- src/org/httpkit/HTTPException.class
+- src/org/httpkit/HTTPException.java
+- src/org/httpkit/HeaderMap.class
+- src/org/httpkit/HeaderMap.java
+- src/org/httpkit/HttpMethod.class
+- src/org/httpkit/HttpMethod.java
+- src/org/httpkit/HttpStatus.class
+- src/org/httpkit/HttpStatus.java
+- src/org/httpkit/HttpUtils.class
+- src/org/httpkit/HttpUtils.java
+- src/org/httpkit/HttpVersion.class
+- src/org/httpkit/HttpVersion.java
+- src/org/httpkit/LineReader.class
+- src/org/httpkit/LineReader.java
+- src/org/httpkit/LineTooLargeException.class
+- src/org/httpkit/LineTooLargeException.java
+- src/org/httpkit/PrefixThreadFactory.class
+- src/org/httpkit/PrefixThreadFactory.java
+- src/org/httpkit/PriorityQueue.class
+- src/org/httpkit/PriorityQueue.java
+- src/org/httpkit/ProtocolException.class
+- src/org/httpkit/ProtocolException.java
+- src/org/httpkit/RequestTooLargeException.class
+- src/org/httpkit/RequestTooLargeException.java
+- src/org/httpkit/client/AbortException.class
+- src/org/httpkit/client/AbortException.java
+- src/org/httpkit/client/Decoder.class
+- src/org/httpkit/client/Decoder.java
+- src/org/httpkit/client/Handler.class
+- src/org/httpkit/client/HttpClient.class
+- src/org/httpkit/client/HttpClient.java
+- src/org/httpkit/client/HttpsRequest.class
+- src/org/httpkit/client/HttpsRequest.java
+- src/org/httpkit/client/IFilter$1.class
+- src/org/httpkit/client/IFilter$MaxBodyFilter.class
+- src/org/httpkit/client/IFilter.class
+- src/org/httpkit/client/IFilter.java
+- src/org/httpkit/client/IRespListener.class
+- src/org/httpkit/client/IRespListener.java
+- src/org/httpkit/client/IResponseHandler.class
+- src/org/httpkit/client/IResponseHandler.java
+- src/org/httpkit/client/PersistentConn.class
+- src/org/httpkit/client/PersistentConn.java
+- src/org/httpkit/client/Request.class
+- src/org/httpkit/client/Request.java
+- src/org/httpkit/client/RequestConfig.class
+- src/org/httpkit/client/RequestConfig.java
+- src/org/httpkit/client/RespListener.class
+- src/org/httpkit/client/RespListener.java
+- src/org/httpkit/client/SslContextFactory.class
+- src/org/httpkit/client/SslContextFactory.java
+- src/org/httpkit/client/State.class
+- src/org/httpkit/client/TimeoutException.class
+- src/org/httpkit/client/TimeoutException.java
+- src/org/httpkit/client/TrustManagerFactory$1.class
+- src/org/httpkit/client/TrustManagerFactory.class
+- src/org/httpkit/server/AsyncChannel.class
+- src/org/httpkit/server/AsyncChannel.java
+- src/org/httpkit/server/ClojureRing.class
+- src/org/httpkit/server/Frame$BinaryFrame.class
+- src/org/httpkit/server/Frame$CloseFrame.class
+- src/org/httpkit/server/Frame$PingFrame.class
+- src/org/httpkit/server/Frame$TextFrame.class
+- src/org/httpkit/server/Frame.class
+- src/org/httpkit/server/Frame.java
+- src/org/httpkit/server/HttpAtta.class
+- src/org/httpkit/server/HttpAtta.java
+- src/org/httpkit/server/HttpDecoder$State.class
+- src/org/httpkit/server/HttpDecoder.class
+- src/org/httpkit/server/HttpDecoder.java
+- src/org/httpkit/server/HttpHandler.class
+- src/org/httpkit/server/HttpRequest.class
+- src/org/httpkit/server/HttpRequest.java
+- src/org/httpkit/server/HttpServer.class
+- src/org/httpkit/server/HttpServer.java
+- src/org/httpkit/server/IHandler.class
+- src/org/httpkit/server/IHandler.java
+- src/org/httpkit/server/LinkingRunnable.class
+- src/org/httpkit/server/Rack.class
+- src/org/httpkit/server/RackApplication.class
+- src/org/httpkit/server/RackApplication.java
+- src/org/httpkit/server/RackHandler$1.class
+- src/org/httpkit/server/RackHandler.class
+- src/org/httpkit/server/RackHandler.java
+- src/org/httpkit/server/RackHttpHandler.class
+- src/org/httpkit/server/RackHttpHandler.java
+- src/org/httpkit/server/RespCallback.class
+- src/org/httpkit/server/RespCallback.java
+- src/org/httpkit/server/RingHandler$1.class
+- src/org/httpkit/server/RingHandler.class
+- src/org/httpkit/server/RingHandler.java
+- src/org/httpkit/server/ServerAtta.class
+- src/org/httpkit/server/ServerAtta.java
+- src/org/httpkit/server/WSDecoder$State.class
+- src/org/httpkit/server/WSDecoder.class
+- src/org/httpkit/server/WSDecoder.java
+- src/org/httpkit/server/WSHandler.class
+- src/org/httpkit/server/WsAtta.class
+- src/org/httpkit/server/WsAtta.java
+- src/org/httpkit/timer/CancelableFutureTask.class
+- src/org/httpkit/timer/CancelableFutureTask.java
+- src/org/httpkit/timer/TimerService.class
+- src/org/httpkit/timer/TimerService.java
+homepage: https://github.com/nLight/jruby-http-kit
+licenses:
+- ''
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.0
+signing_key:
+specification_version: 4
+summary: JRuby wrapper for Clojure HTTP Kit library.
+test_files:
+- spec/spec_helper.rb
+- spec/support/test_resource.rb
+- spec/webmachine/ring_adapter_spec.rb