jubilee 0.4.0 → 0.4.1

data/java/src/org/jruby/jubilee/RackResponse.java

@@ -2,8 +2,6 @@ package org.jruby.jubilee;
 
 import org.vertx.java.core.http.HttpServerResponse;
 
-import java.util.Map;
-
 /**
  * Created with IntelliJ IDEA.
  * User: isaiah

data/java/src/org/jruby/jubilee/Server.java

@@ -1,12 +1,16 @@
 package org.jruby.jubilee;
 
-import org.vertx.java.core.*;
-import org.vertx.java.core.http.*;
-
 import org.jruby.*;
-import org.jruby.runtime.*;
-import org.jruby.runtime.builtin.*;
 import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.vertx.java.core.Handler;
+import org.vertx.java.core.Vertx;
+import org.vertx.java.core.VertxFactory;
+import org.vertx.java.core.http.HttpServer;
+import org.vertx.java.core.http.HttpServerRequest;
 import org.vertx.java.core.json.JsonArray;
 import org.vertx.java.core.json.JsonObject;
 
@@ -19,6 +23,7 @@ public class Server extends RubyObject {
   private String keyStorePath;
   private String keyStorePassword;
   private String eventBusPrefix;
+  private int numberOfWorkers;
   private int port;
   private String host;
 
@@ -57,14 +62,17 @@ public class Server extends RubyObject {
     RubySymbol keystore_path_k = runtime.newSymbol("keystore_path");
     RubySymbol keystore_password_k = runtime.newSymbol("keystore_password");
     RubySymbol eventbus_prefix_k = runtime.newSymbol("eventbus_prefix");
-    this.port = RubyInteger.num2int(options.op_aref(context, port_k));
+    RubySymbol number_of_workers_k = runtime.newSymbol("number_of_workers");
+    this.port = RubyInteger.fix2int(options.op_aref(context, port_k));
     if (options.has_key_p(host_k).isTrue()) {
         this.host = options.op_aref(context, host_k).toString();
     } else {
         this.host = "0.0.0.0";
     }
     this.ssl = options.op_aref(context, ssl_k).isTrue();
-    this.app = new RackApplication(app, this.ssl);
+    if (options.has_key_p(number_of_workers_k).isTrue())
+      this.numberOfWorkers = RubyInteger.fix2int(options.op_aref(context, number_of_workers_k));
+    this.app = new RackApplication(app, this.ssl, this.numberOfWorkers);
     if (options.has_key_p(keystore_path_k).isTrue()) {
       this.keyStorePath = options.op_aref(context, keystore_path_k).toString();
       this.keyStorePassword = options.op_aref(context, keystore_password_k).toString();

data/java/src/org/jruby/jubilee/impl/DefaultRackEnvironment.java

@@ -1,11 +1,10 @@
 package org.jruby.jubilee.impl;
 
-import org.jruby.RubyArray;
-import org.jruby.RubyString;
-import org.jruby.jubilee.RackEnvironment;
-import org.jruby.jubilee.Const;
 import org.jruby.Ruby;
 import org.jruby.RubyHash;
+import org.jruby.RubyString;
+import org.jruby.jubilee.Const;
+import org.jruby.jubilee.RackEnvironment;
 import org.jruby.jubilee.RackInput;
 import org.vertx.java.core.MultiMap;
 import org.vertx.java.core.http.HttpServerRequest;
@@ -19,81 +18,82 @@ import java.util.Map;
  * Time: 11:40 AM
  */
 public class DefaultRackEnvironment implements RackEnvironment {
-  private RubyHash env;
-  private MultiMap headers;
-  private Ruby runtime;
+    private RubyHash env;
+    private MultiMap headers;
+    private Ruby runtime;
 
-  public DefaultRackEnvironment(final Ruby runtime, final HttpServerRequest request, RackInput input, boolean isSSL) {
+    public DefaultRackEnvironment(final Ruby runtime, final HttpServerRequest request, RackInput input, boolean isSSL) {
 
-    this.runtime = runtime;
-    // DEFAULT
-    env = RubyHash.newHash(runtime);
-    env.put(Const.RACK_VERSION, Const.RackVersion(runtime));
-    env.put(Const.RACK_ERRORS, new RubyIORackErrors(runtime));
-    env.put(Const.RACK_MULTITHREAD, true);
-    env.put(Const.RACK_MULTIPROCESS, false);
-    env.put(Const.RACK_RUNONCE, true);
-    if (isSSL)
-      env.put(Const.URL_SCHEME, Const.HTTPS);
-    else
-      env.put(Const.URL_SCHEME, Const.HTTP);
-    env.put(Const.SCRIPT_NAME, "");
+        this.runtime = runtime;
+        // DEFAULT
+        env = RubyHash.newHash(runtime);
+        env.put(Const.RACK_VERSION, Const.RackVersion(runtime));
+        env.put(Const.RACK_ERRORS, new RubyIORackErrors(runtime));
+        env.put(Const.RACK_MULTITHREAD, true);
+        env.put(Const.RACK_MULTIPROCESS, false);
+        env.put(Const.RACK_RUNONCE, true);
+        if (isSSL)
+            env.put(Const.URL_SCHEME, Const.HTTPS);
+        else
+            env.put(Const.URL_SCHEME, Const.HTTP);
+        env.put(Const.SCRIPT_NAME, "");
 
-    env.put(Const.SERVER_PROTOCOL, Const.HTTP_11);
-    env.put(Const.SERVER_SOFTWARE, Const.JUBILEE_VERSION);
-    env.put(Const.GATEWAY_INTERFACE, Const.CGI_VER);
+        env.put(Const.SERVER_PROTOCOL, Const.HTTP_11);
+        env.put(Const.SERVER_SOFTWARE, Const.JUBILEE_VERSION);
+        env.put(Const.GATEWAY_INTERFACE, Const.CGI_VER);
 
-    // Parse request headers
-    headers = request.headers();
-    String host;
-    if ((host = headers.get(Const.Vertx.HOST)) != null) {
-      int colon = host.indexOf(":");
-      if (colon > 0) {
-        env.put(Const.SERVER_NAME, host.substring(0, colon));
-        env.put(Const.SERVER_PORT, host.substring(colon + 1));
-      } else {
-        env.put(Const.SERVER_NAME, host);
-        env.put(Const.SERVER_PORT, Const.PORT_80);
-      }
+        // Parse request headers
+        headers = request.headers();
+        String host;
+        if ((host = headers.get(Const.Vertx.HOST)) != null) {
+            int colon = host.indexOf(":");
+            if (colon > 0) {
+                env.put(Const.SERVER_NAME, host.substring(0, colon));
+                env.put(Const.SERVER_PORT, host.substring(colon + 1));
+            } else {
+                env.put(Const.SERVER_NAME, host);
+                env.put(Const.SERVER_PORT, Const.PORT_80);
+            }
 
-    } else {
-      env.put(Const.SERVER_NAME, Const.LOCALHOST);
-      env.put(Const.SERVER_PORT, Const.PORT_80);
-    }
+        } else {
+            env.put(Const.SERVER_NAME, Const.LOCALHOST);
+            env.put(Const.SERVER_PORT, Const.PORT_80);
+        }
+
+        env.put(Const.RACK_INPUT, input);
+        env.put(Const.REQUEST_METHOD, request.method());
+        env.put(Const.REQUEST_PATH, request.path());
+        env.put(Const.REQUEST_URI, request.uri());
+        env.put(Const.QUERY_STRING, orEmpty(request.query()));
+        env.put(Const.REMOTE_ADDR, request.remoteAddress().getHostString());
+        env.put(Const.HTTP_HOST, host);
+        env.put(Const.HTTP_COOKIE, orEmpty(headers.get(Const.Vertx.COOKIE)));
+        env.put(Const.HTTP_USER_AGENT, headers.get(Const.Vertx.USER_AGENT));
+        env.put(Const.HTTP_ACCEPT, headers.get(Const.Vertx.ACCEPT));
+        env.put(Const.HTTP_ACCEPT_LANGUAGE, orEmpty(headers.get(Const.Vertx.ACCEPT_LANGUAGE)));
+        env.put(Const.HTTP_ACCEPT_ENCODING, orEmpty(headers.get(Const.Vertx.ACCEPT_ENCODING)));
+        env.put(Const.HTTP_CONNECTION, orEmpty(headers.get(Const.Vertx.CONNECTION)));
+        env.put(Const.HTTP_CONTENT_TYPE, orEmpty(headers.get(Const.Vertx.CONTENT_TYPE)));
 
-    env.put(Const.RACK_INPUT, input);
-    env.put(Const.REQUEST_METHOD, request.method());
-    env.put(Const.REQUEST_PATH, request.path());
-    env.put(Const.REQUEST_URI, request.uri());
-    env.put(Const.QUERY_STRING, orEmpty(request.query()));
-    env.put(Const.REMOTE_ADDR, request.remoteAddress().getHostString());
-    env.put(Const.HTTP_HOST, host);
-    env.put(Const.HTTP_COOKIE, orEmpty(headers.get(Const.Vertx.COOKIE)));
-    env.put(Const.HTTP_USER_AGENT, headers.get(Const.Vertx.USER_AGENT));
-    env.put(Const.HTTP_ACCEPT, headers.get(Const.Vertx.ACCEPT));
-    env.put(Const.HTTP_ACCEPT_LANGUAGE, orEmpty(headers.get(Const.Vertx.ACCEPT_LANGUAGE)));
-    env.put(Const.HTTP_ACCEPT_ENCODING, orEmpty(headers.get(Const.Vertx.ACCEPT_ENCODING)));
-    env.put(Const.HTTP_CONNECTION, orEmpty(headers.get(Const.Vertx.CONNECTION)));
-    env.put(Const.HTTP_CONTENT_TYPE, orEmpty(headers.get(Const.Vertx.CONTENT_TYPE)));
-    String contentLength;
-    if ((contentLength = headers.get(Const.Vertx.CONTENT_LENGTH)) != null)
-      env.put(Const.HTTP_CONTENT_LENGTH, contentLength);
-    env.put(Const.PATH_INFO, request.path());
+        String contentLength;
+        if ((contentLength = headers.get(Const.Vertx.CONTENT_LENGTH)) != null)
+            env.put(Const.HTTP_CONTENT_LENGTH, contentLength);
+        env.put(Const.PATH_INFO, request.path());
 
-    // Additional headers
-    for (Map.Entry<String, String> var : Const.ADDITIONAL_HEADERS.entrySet())
-      setRackHeader(var.getKey(), var.getValue());
-  }
+        // Additional headers
+        for (Map.Entry<String, String> var : Const.ADDITIONAL_HEADERS.entrySet())
+            setRackHeader(var.getKey(), var.getValue());
+    }
 
-  public RubyHash getEnv() {
-    return env;
-  }
+    public RubyHash getEnv() {
+        return env;
+    }
 
-  private RubyString orEmpty(String jString) {
-    return jString == null ? RubyString.newEmptyString(runtime) : RubyString.newString(runtime, jString);
-  }
+    private RubyString orEmpty(String jString) {
+        return jString == null ? RubyString.newEmptyString(runtime) : RubyString.newString(runtime, jString);
+    }
 
-  private void setRackHeader(String vertxHeader, String rackHeader) {
-    if (headers.contains(vertxHeader)) env.put(rackHeader, headers.get(vertxHeader));
-  }
+    private void setRackHeader(String vertxHeader, String rackHeader) {
+        if (headers.contains(vertxHeader)) env.put(rackHeader, headers.get(vertxHeader));
+    }
 }

data/java/src/org/jruby/jubilee/impl/RubyIORackInput.java

@@ -1,6 +1,8 @@
 package org.jruby.jubilee.impl;
 
 import io.netty.buffer.ByteBuf;
+import org.jcodings.specific.ASCIIEncoding;
+import org.jcodings.Encoding;
 import org.jruby.*;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.jubilee.Const;
@@ -9,10 +11,10 @@ import org.jruby.runtime.Block;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
-import org.vertx.java.core.buffer.Buffer;
+import org.vertx.java.core.http.HttpServerRequest;
 
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * Created with IntelliJ IDEA.
@@ -21,144 +23,178 @@ import java.util.concurrent.TimeUnit;
  * Time: 10:12 PM
  */
 public class RubyIORackInput extends RubyObject implements RackInput {
-  private ByteBuf buf;
-  private CountDownLatch bodyLatch;
+    private Encoding BINARY = ASCIIEncoding.INSTANCE;
+    private HttpServerRequest request;
+    private int len;
+    private boolean chunked;
+    private ByteBuf buf;
+    private AtomicBoolean eof;
 
-  public static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+    public static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        @Override
+        public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+            return new RubyIORackInput(ruby, rubyClass);
+        }
+    };
+
+    public static RubyClass createRubyIORackInputClass(Ruby runtime) {
+        RubyModule jModule = runtime.defineModule("Jubilee");
+        RubyClass rackIOInputClass = jModule.defineClassUnder("RubyIORackInput", runtime.getObject(), ALLOCATOR);
+        rackIOInputClass.defineAnnotatedMethods(RubyIORackInput.class);
+        return rackIOInputClass;
+    }
+
+    public RubyIORackInput(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public RubyIORackInput(Ruby runtime, HttpServerRequest request, ByteBuf buf, AtomicBoolean eof) {
+        this(runtime, createRubyIORackInputClass(runtime));
+        this.request = request;
+        String hdr = request.headers().get(Const.Vertx.CONTENT_LENGTH);
+        this.chunked = hdr == null;
+        this.len = this.chunked ? 0 : Integer.parseInt(hdr);
+        this.buf = buf;
+        this.eof = eof;
+    }
+
+    /**
+     * gets must be called without arguments and return a string, or nil on EOF.
+     * <p/>
+     * this method return one line a time.
+     *
+     * @param context it's a JRuby thing
+     * @return a string, or nil on EOF
+     */
     @Override
-    public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
-      return new RubyIORackInput(ruby, rubyClass);
+    @JRubyMethod
+    public IRubyObject gets(ThreadContext context) {
+      RubyString line = RubyString.newEmptyString(getRuntime(), BINARY);
+        if (isEOF())
+            return getRuntime().getNil();
+        int lineEnd = -1;
+        while (lineEnd == -1 && !isEOF())
+            lineEnd = buf.indexOf(buf.readerIndex(), buf.writerIndex(), Const.EOL);
+
+        // No line break found, read all
+        if (lineEnd == -1)
+            return readAll(line);
+
+        int readLength = lineEnd - buf.readerIndex();
+        byte[] dst = new byte[readLength + 1];
+        buf.readBytes(dst);
+        return line.cat(dst);
     }
-  };
-
-  public static RubyClass createRubyIORackInputClass(Ruby runtime) {
-    RubyModule jModule = runtime.defineModule("Jubilee");
-    RubyClass rackIOInputClass = jModule.defineClassUnder("RubyIORackInput", runtime.getObject(), ALLOCATOR);
-    rackIOInputClass.defineAnnotatedMethods(RubyIORackInput.class);
-    return rackIOInputClass;
-  }
-
-  public RubyIORackInput(Ruby runtime, RubyClass metaClass) {
-    super(runtime, metaClass);
-  }
-
-  public RubyIORackInput(Ruby runtime, Buffer buf, CountDownLatch bodyLatch) {
-    this(runtime, createRubyIORackInputClass(runtime));
-    this.buf = buf.getByteBuf();
-    this.bodyLatch = bodyLatch;
-  }
-
-  /**
-   * gets must be called without arguments and return a string, or nil on EOF.
-   * <p/>
-   * this method return one line a time.
-   *
-   * @param context it's a JRuby thing
-   * @return a string, or nil on EOF
-   */
-  @Override
-  @JRubyMethod
-  public IRubyObject gets(ThreadContext context) {
-    // TODO this is not the optimistic way. remove the latch and implement tee_input as unicorn
-    try {
-      bodyLatch.await(10, TimeUnit.SECONDS);
-    } catch (InterruptedException ignore) {
-      return getRuntime().getNil();
+
+    /**
+     * read behaves like IO#read. Its signature is read([length, [buffer]]). If given,
+     * length must be an non-negative Integer (>= 0) or nil, and buffer must be a
+     * String and may not be nil. If length is given and not nil, then this method
+     * reads at most length bytes from the input stream. If length is not given or
+     * nil, then this method reads all data until EOF. When EOF is reached, this
+     * method returns nil if length is given and not nil, or "" if) length is not
+     * given or is nil. If buffer is given, then the read data will be placed into
+     * buffer instead of a newly created String object.
+     *
+     * @param context it's a JRuby thing
+     * @param args    [length, [buffer]]
+     * @return nil if length is given and not nil, or "" if length is not given or nil
+     */
+    @Override
+    @JRubyMethod(optional = 2)
+    public IRubyObject read(ThreadContext context, IRubyObject[] args) {
+        RubyString dst = RubyString.newEmptyString(getRuntime(), BINARY);
+        if (isEOF())
+            return getRuntime().getNil();
+        int length;
+        switch (args.length) {
+            case 0:
+                return readAll(dst);
+            case 1:
+                length = RubyInteger.num2int(args[0]);
+                break;
+            default:
+                length = RubyInteger.num2int(args[0]);
+                dst = (RubyString) args[1];
+        }
+        if (length < 0)
+            getRuntime().newArgumentError("Negative length " + length + " given");
+        byte[] buffer = new byte[length];
+        int toRead = length;
+        while (toRead > 0 && !isEOF()) {
+            int len = Math.min(toRead, readableBytes());
+            buf.readBytes(buffer, length - toRead, len);
+            toRead = toRead - len;
+        }
+        if (toRead > 0)
+            buffer = Arrays.copyOfRange(buffer, 0, length - toRead);
+        return dst.cat(buffer);
     }
-    if (buf.readableBytes() == 0)
-      return getRuntime().getNil();
-    int lineEnd = buf.indexOf(buf.readerIndex(), buf.capacity(), Const.EOL);
-    int readLength;
-    if ((readLength = lineEnd - buf.readerIndex()) > 0) {
-      byte[] dst = new byte[readLength + 1];
-      buf.readBytes(dst, 0, readLength + 1);
-      return RubyString.newString(getRuntime(), dst);
+
+    /**
+     * each must be called without arguments and only yield Strings.
+     *
+     * @param context it's a JRuby thing
+     * @param block   that receives yield of Strings
+     * @return pretty much nil
+     */
+    @Override
+    @JRubyMethod
+    public IRubyObject each(ThreadContext context, Block block) {
+        IRubyObject str;
+        while (!(str = gets(context)).isNil()) {
+            block.yield(context, str);
+        }
+        return getRuntime().getNil();
+    }
+
+    /**
+     * rewind must be called without arguments. It rewinds the input stream back
+     * to the beginning. It must not raise Errno::ESPIPE: that is, it may not be
+     * a pipe or a socket. Therefore, handler developers must buffer the input
+     * data into some rewindable object if the underlying input stream is not rewindable.
+     *
+     * @param context it's a JRuby thing
+     * @return pretty much nil
+     */
+    @Override
+    @JRubyMethod
+    public IRubyObject rewind(ThreadContext context) {
+        buf.readerIndex(0);
+        return getRuntime().getNil();
     }
-    return getRuntime().getNil();
-  }
-
-  /**
-   * read behaves like IO#read. Its signature is read([length, [buffer]]). If given,
-   * length must be an non-negative Integer (>= 0) or nil, and buffer must be a
-   * String and may not be nil. If length is given and not nil, then this method
-   * reads at most length bytes from the input stream. If length is not given or
-   * nil, then this method reads all data until EOF. When EOF is reached, this
-   * method returns nil if length is given and not nil, or "" if) length is not
-   * given or is nil. If buffer is given, then the read data will be placed into
-   * buffer instead of a newly created String object.
-   *
-   * @param context it's a JRuby thing
-   * @param args    [length, [buffer]]
-   * @return nil if length is given and not nil, or "" if length is not given or nil
-   */
-  @Override
-  @JRubyMethod(optional = 2)
-  public IRubyObject read(ThreadContext context, IRubyObject[] args) {
-    try {
-      bodyLatch.await(10, TimeUnit.SECONDS);
-    } catch (InterruptedException ignore) {
-      return getRuntime().getNil();
+
+    /**
+     * Close the input. Exposed only to the Java side because the Rack spec says
+     * that application code must not call close, so we don't expose a close method to Ruby.
+     */
+    @JRubyMethod
+    public IRubyObject close(ThreadContext context) {
+        buf.clear();
+        return getRuntime().getNil();
     }
-    if (buf.readableBytes() == 0)
-      return getRuntime().getNil();
-    int length;
-    switch (args.length) {
-      case 0:
-        length = buf.readableBytes();
-        break;
-      case 1:
-        int len = RubyInteger.num2int(args[0]);
-        length = len > buf.readableBytes() ? buf.readableBytes() : len;
-        break;
-      default:
-        len = RubyInteger.num2int(args[0]);
-        length = len > buf.readableBytes() ? buf.readableBytes() : len;
+
+    private int readableBytes() {
+      if (! this.chunked) {
+        return Math.min(buf.readableBytes(), this.len - buf.readerIndex());
+      }
+      return buf.readableBytes();
     }
-    byte[] dst = new byte[length];
-    buf.readBytes(dst, 0, length);
-    return RubyString.newString(getRuntime(), dst);
-  }
-
-  /**
-   * each must be called without arguments and only yield Strings.
-   *
-   * @param context it's a JRuby thing
-   * @param block   that receives yield of Strings
-   * @return pretty much nil
-   */
-  @Override
-  @JRubyMethod
-  public IRubyObject each(ThreadContext context, Block block) {
-    IRubyObject str;
-    while (!(str = gets(context)).isNil()) {
-      block.yield(context, str);
+
+    private boolean isEOF() {
+        while (buf.readableBytes() == 0 && !eof.get())
+            ; // wait while there is nothing to read
+        return buf.readableBytes() == 0 && eof.get();
+    }
+
+    private IRubyObject readAll(RubyString dst) {
+        buf.readerIndex(0);
+        while(!eof.get())
+            ; // wait until all data received
+        int length = this.chunked ? buf.readableBytes() : Math.min(this.len, buf.readableBytes());
+        byte[] data = new byte[length];
+        dst.cat(data);
+        buf.readBytes(data);
+        return dst.isEmpty() ? getRuntime().getNil() : dst;
     }
-    return getRuntime().getNil();
-  }
-
-  /**
-   * rewind must be called without arguments. It rewinds the input stream back
-   * to the beginning. It must not raise Errno::ESPIPE: that is, it may not be
-   * a pipe or a socket. Therefore, handler developers must buffer the input
-   * data into some rewindable object if the underlying input stream is not rewindable.
-   *
-   * @param context it's a JRuby thing
-   * @return pretty much nil
-   */
-  @Override
-  @JRubyMethod
-  public IRubyObject rewind(ThreadContext context) {
-    buf.readerIndex(0);
-    return getRuntime().getNil();
-  }
-
-  /**
-   * Close the input. Exposed only to the Java side because the Rack spec says
-   * that application code must not call close, so we don't expose a close method to Ruby.
-   */
-  @JRubyMethod
-  public IRubyObject close(ThreadContext context) {
-    buf.clear();
-    return getRuntime().getNil();
-  }
 }