jubilee 0.1.2

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

@@ -0,0 +1,78 @@
+package org.jruby.jubilee;
+
+import org.jruby.Ruby;
+import org.jruby.javasupport.JavaEmbedUtils;
+import org.jruby.jubilee.impl.DefaultRackEnvironment;
+import org.jruby.jubilee.impl.RubyIORackInput;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.vertx.java.core.Handler;
+import org.vertx.java.core.SimpleHandler;
+import org.vertx.java.core.Vertx;
+import org.vertx.java.core.buffer.Buffer;
+import org.vertx.java.core.http.HttpServerRequest;
+
+import java.util.concurrent.*;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 11/29/12
+ * Time: 5:40 PM
+ */
+public class RackApplication {
+  private IRubyObject app;
+  private boolean ssl;
+  private Buffer bodyBuf;
+  private Vertx vertx;
+
+  private ExecutorService exec;
+
+  public RackApplication(Vertx vertx, IRubyObject app, boolean ssl) {
+    this.app = app;
+    this.ssl = ssl;
+    bodyBuf = new Buffer(0);
+    this.vertx = vertx;
+    exec = Executors.newCachedThreadPool();
+  }
+
+  public void call(final HttpServerRequest request) {
+    final Ruby runtime = app.getRuntime();
+    final CountDownLatch bodyLatch = new CountDownLatch(1);
+    request.dataHandler(new Handler<Buffer>() {
+      @Override
+      public void handle(Buffer buffer) {
+        bodyBuf.appendBuffer(buffer);
+      }
+    });
+    // TODO optimize by use NullIO when there is no body here.
+    Runnable task = new Runnable() {
+      @Override
+      public void run() {
+        RackInput input = new RubyIORackInput(runtime, bodyBuf, bodyLatch);
+        RackEnvironment env = new DefaultRackEnvironment(runtime, request, input, ssl);
+        IRubyObject result = app.callMethod(runtime.getCurrentContext(), "call", env.getEnv());
+        final RackResponse response = (RackResponse) JavaEmbedUtils.rubyToJava(runtime, result, RackResponse.class);
+        vertx.runOnLoop(new SimpleHandler() {
+          @Override
+          public void handle() {
+            response.respond(request.response);
+          }
+        });
+      }
+    };
+    exec.execute(task);
+    request.endHandler(new SimpleHandler() {
+      @Override
+      protected void handle() {
+        bodyLatch.countDown();
+      }
+    });
+  }
+
+  public void shutdown(boolean force) {
+    if (force)
+      exec.shutdownNow();
+    else
+      exec.shutdown();
+  }
+}

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

@@ -0,0 +1,13 @@
+package org.jruby.jubilee;
+
+import org.jruby.RubyHash;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 11/26/12
+ * Time: 11:33 AM
+ */
+public interface RackEnvironment {
+    public RubyHash getEnv();
+}

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

@@ -0,0 +1,44 @@
+package org.jruby.jubilee;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 11/26/12
+ * Time: 12:01 PM
+ */
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public interface RackErrors {
+     /**
+     * puts must be called with a single argument that responds to to_s.
+     *
+     * @param context ruby context
+     * @param arg must respond to to_s
+     * @return nil
+     */
+    IRubyObject puts( ThreadContext context, IRubyObject arg );
+
+    /**
+     * write must be called with a single argument that is a String.
+     *
+     * @param context ruby context
+     * @param string a Ruby String
+     * @return nil
+     */
+    IRubyObject write( ThreadContext context, IRubyObject string );
+
+    /**
+     * flush must be called without arguments and must be called in order to make the error appear for sure.
+     *
+     * @return nil
+     */
+    IRubyObject flush();
+
+    /**
+     * close must never be called on the error stream.
+     *
+     * @return nil
+     */
+    IRubyObject close();
+}

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

@@ -0,0 +1,62 @@
+package org.jruby.jubilee;
+
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * @author isaiah
+ * @since Nov 26, 2012
+ *
+ * Specification for Rack input, translated to a Java interface.
+ * @author nicksieger
+ */
+public interface RackInput
+{
+    /**
+     * gets must be called without arguments and return a string, or nil on EOF.
+     * @param context it's a JRuby thing
+     * @return a string, or nil on EOF
+     */
+    IRubyObject gets( ThreadContext context );
+
+    /**
+     * 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
+     */
+    IRubyObject read( ThreadContext context, IRubyObject[] args );
+
+    /**
+     * 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
+     */
+    public IRubyObject each( ThreadContext context, Block block );
+
+    /**
+     * 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
+     */
+    public IRubyObject rewind( ThreadContext context );
+
+    /**
+     * 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.
+     */
+    public IRubyObject close(ThreadContext context);
+}
+

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

@@ -0,0 +1,16 @@
+package org.jruby.jubilee;
+
+import org.jruby.runtime.builtin.IRubyObject;
+import org.vertx.java.core.http.HttpServerResponse;
+
+import java.util.Map;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 11/29/12
+ * Time: 5:39 PM
+ */
+public interface RackResponse {
+    public void respond(HttpServerResponse response);
+}

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

@@ -0,0 +1,104 @@
+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;
+
+public class Server extends RubyObject {
+  final private Vertx vertx;
+  final private HttpServer httpServer;
+  private RackApplication app;
+  private boolean running;
+  private boolean ssl = false;
+  private String keyStorePath;
+  private String keyStorePassword;
+  private int port;
+
+  public static void createServerClass(Ruby runtime) {
+    RubyModule mJubilee = runtime.defineModule("Jubilee");
+    RubyClass serverClass = mJubilee.defineClassUnder("VertxServer", runtime.getObject(), ALLOCATOR);
+    serverClass.defineAnnotatedMethods(Server.class);
+  }
+
+  private static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+    public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+      return new Server(ruby, rubyClass);
+    }
+  };
+
+  public Server(Ruby ruby, RubyClass rubyClass) {
+    super(ruby, rubyClass);
+    vertx = Vertx.newVertx();
+    httpServer = vertx.createHttpServer();
+  }
+
+  @JRubyMethod(name = "initialize", required = 2, optional = 3)
+  public IRubyObject initialize(ThreadContext context, IRubyObject[] args, Block block) {
+    this.port = RubyInteger.num2int(args[1]);
+    if (args.length > 2) {
+      this.ssl = args[2].isTrue();
+    }
+    this.app = new RackApplication(vertx, args[0], this.ssl);
+    if (args.length > 3)
+      this.keyStorePath = args[3].toString();
+    if (args.length > 4)
+      this.keyStorePassword = args[4].toString();
+    running = false;
+    return this;
+  }
+
+  @JRubyMethod(name = "start", optional = 1)
+  public IRubyObject start(final ThreadContext context, final IRubyObject[] args, final Block block) {
+    this.running = true;
+    httpServer.setAcceptBacklog(10000);
+    httpServer.requestHandler(new Handler<HttpServerRequest>() {
+      public void handle(final HttpServerRequest req) {
+        app.call(req);
+      }
+    });
+    if (ssl) httpServer.setSSL(true).setKeyStorePath(this.keyStorePath)
+            .setKeyStorePassword(this.keyStorePassword);
+    httpServer.listen(this.port);
+    return this;
+  }
+
+  /**
+   * Set timeout for keep alive connection
+   * @param context
+   * @param timeout (in TimeUnit.SECONDS)
+   * @return this
+   */
+  @JRubyMethod(name = "persistent_timeout=")
+  public IRubyObject setPersistentTimeout(final ThreadContext context, final IRubyObject timeout) {
+    httpServer.setPersistentTimeout(RubyInteger.fix2long(timeout) * 1000);
+    return this;
+  }
+
+  /**
+   * Stop the HttpServer
+   * @param context
+   * @param args if shutdown abruptly
+   * @param block callback on close
+   * @return
+   */
+  @JRubyMethod(name = {"stop", "close"}, optional = 1)
+  public IRubyObject close(ThreadContext context, IRubyObject[] args, Block block) {
+    if (running) {
+      if (args.length == 1)
+        app.shutdown(args[0].isTrue());
+      else
+        app.shutdown(false);
+
+      this.running = false;
+      httpServer.close();
+      if (block.isGiven()) block.yieldSpecific(context);
+    } else {
+      getRuntime().getOutputStream().println("jubilee server not running?");
+    }
+    return getRuntime().getNil();
+  }
+}

data/java/src/org/jruby/jubilee/deploy/Starter.java

@@ -0,0 +1,26 @@
+package org.jruby.jubilee.deploy;
+
+import java.util.concurrent.CountDownLatch;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 12/3/12
+ * Time: 7:37 PM
+ */
+public class Starter {
+  private CountDownLatch stopLatch = new CountDownLatch(1);
+
+  public void block() {
+    while(true) {
+      try {
+        stopLatch.await();
+        break;
+      } catch (InterruptedException ignore) {}
+    }
+  }
+
+  public void unblock() {
+    stopLatch.countDown();
+  }
+}

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

@@ -0,0 +1,98 @@
+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.jubilee.RackInput;
+import org.vertx.java.core.http.HttpServerRequest;
+
+import java.util.Map;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 11/26/12
+ * Time: 11:40 AM
+ */
+public class DefaultRackEnvironment implements RackEnvironment {
+  private RubyHash env;
+  private  Map<String, String> headers;
+  private Ruby runtime;
+
+  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, "");
+
+    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);
+      }
+
+    } 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.remoteAddr);
+    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);
+
+    // Additional headers
+    for (Map.Entry<String, String> var : Const.ADDITIONAL_HEADERS.entrySet())
+      setRackHeader(var.getKey(), var.getValue());
+  }
+
+  public RubyHash getEnv() {
+    return env;
+  }
+
+  private RubyString orEmpty(String jString) {
+    return jString == null ? RubyString.newEmptyString(runtime) : RubyString.newString(runtime, jString);
+  }
+
+  private void setRackHeader(String vertxHeader, String rackHeader) {
+    if (headers.containsKey(vertxHeader)) env.put(rackHeader, headers.get(vertxHeader));
+  }
+}