jubilee 1.1.0-java

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,11 @@
+package org.jruby.jubilee;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 11/29/12
+ * Time: 5:39 PM
+ */
+public interface RackResponse {
+    public void respond(RubyHttpServerResponse response);
+}

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

@@ -0,0 +1,88 @@
+package org.jruby.jubilee;
+
+import org.jruby.*;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.vertx.java.core.http.HttpServerResponse;
+
+import java.util.Arrays;
+
+/**
+ * Created by isaiah on 21/12/2013.
+ */
+@JRubyClass(name = "HttpServerResponse")
+public class RubyHttpServerResponse extends RubyObject {
+  private HttpServerResponse resp;
+  private String lineSeparator;
+
+  public static RubyClass createHttpServerResponseClass(final Ruby runtime) {
+    RubyModule mJubilee = runtime.getOrCreateModule("Jubilee");
+    RubyClass klazz = mJubilee.defineClassUnder("HttpServerResponse", runtime.getObject(), new ObjectAllocator() {
+      @Override
+      public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+        return new RubyHttpServerResponse(ruby, rubyClass);
+      }
+    });
+    klazz.defineAnnotatedMethods(RubyHttpServerResponse.class);
+    return klazz;
+  }
+
+  public RubyHttpServerResponse(Ruby ruby, RubyClass rubyClass) {
+    super(ruby, rubyClass);
+  }
+
+  public RubyHttpServerResponse(Ruby ruby, RubyClass rubyClass, HttpServerResponse resp) {
+    super(ruby, rubyClass);
+    this.resp = resp;
+    this.lineSeparator = System.getProperty("line.separator");
+  }
+
+  @JRubyMethod
+  public IRubyObject write(ThreadContext context, IRubyObject string) {
+    this.resp.write(string.asJavaString());
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod(name = "status_code=")
+  public IRubyObject setStatusCode(ThreadContext context, IRubyObject statusCode) {
+    this.resp.setStatusCode(RubyNumeric.num2int(statusCode));
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod(name = "chunked=")
+  public IRubyObject setChunked(ThreadContext context, IRubyObject chunked) {
+    this.resp.setChunked(chunked.isTrue());
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod(name = "put_header")
+  public IRubyObject putHeader(ThreadContext context, IRubyObject key, IRubyObject val) {
+    String cookie = val.asJavaString();
+    if (cookie.indexOf(this.lineSeparator) != -1)
+      this.resp.putHeader(key.asJavaString(),
+              Arrays.asList(val.asJavaString().split(this.lineSeparator)));
+    else this.resp.putHeader(key.asJavaString(), val.asJavaString());
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod(name = "send_file")
+  public IRubyObject sendFile(ThreadContext context, IRubyObject filePath) {
+    this.resp.sendFile(filePath.asJavaString());
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod
+  public IRubyObject end(ThreadContext context) {
+    this.resp.end();
+    return context.runtime.getNil();
+  }
+
+  @JRubyMethod(name = "put_default_headers")
+  public IRubyObject putDefaultHeaders(ThreadContext context) {
+    this.resp.putHeader("Server", Const.JUBILEE_VERSION);
+    return context.runtime.getNil();
+  }
+}

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

@@ -0,0 +1,171 @@
+package org.jruby.jubilee;
+
+import org.jruby.*;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.jubilee.vertx.JubileeVertx;
+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.http.HttpServer;
+import org.vertx.java.core.http.HttpServerRequest;
+import org.vertx.java.core.json.JsonArray;
+import org.vertx.java.core.json.JsonObject;
+
+import java.io.IOException;
+
+public class RubyServer extends RubyObject {
+    private Vertx vertx;
+    private HttpServer httpServer;
+    private RackApplication app;
+    private boolean running = false;
+    private boolean ssl = false;
+    private String keyStorePath;
+    private String keyStorePassword;
+    private String eventBusPrefix;
+    private int port;
+    private String host;
+    private int clusterPort;
+    private String clusterHost;
+
+    public static void createServerClass(Ruby runtime) {
+        RubyModule mJubilee = runtime.defineModule("Jubilee");
+        RubyClass serverClass = mJubilee.defineClassUnder("VertxServer", runtime.getObject(), ALLOCATOR);
+        serverClass.defineAnnotatedMethods(RubyServer.class);
+    }
+
+    private static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+            return new RubyServer(ruby, rubyClass);
+        }
+    };
+
+    public RubyServer(Ruby ruby, RubyClass rubyClass) {
+        super(ruby, rubyClass);
+    }
+
+    /**
+     * Initialize jubilee server, take a rack application and a configuration hash as parameter
+     *
+     * @param context
+     * @param app
+     * @param config
+     * @param block
+     * @return
+     */
+    @JRubyMethod(name = "initialize")
+    public IRubyObject initialize(ThreadContext context, IRubyObject app, IRubyObject config, Block block) {
+        Ruby runtime = getRuntime();
+        /* configuration keys */
+        RubyHash options = config.convertToHash();
+        RubySymbol port_k = runtime.newSymbol("Port");
+        RubySymbol host_k = runtime.newSymbol("Host");
+        RubySymbol cluster_port_k = runtime.newSymbol("cluster_port");
+        RubySymbol cluster_host_k = runtime.newSymbol("cluster_host");
+        RubySymbol ssl_k = runtime.newSymbol("ssl");
+        RubySymbol keystore_path_k = runtime.newSymbol("keystore_path");
+        RubySymbol keystore_password_k = runtime.newSymbol("keystore_password");
+        RubySymbol eventbus_prefix_k = runtime.newSymbol("eventbus_prefix");
+
+        /* retrieve from passed in options */
+        this.port = Integer.parseInt(options.op_aref(context, port_k).toString());
+        this.host = options.op_aref(context, host_k).toString();
+
+        this.ssl = options.op_aref(context, ssl_k).isTrue();
+        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();
+        }
+        if (options.has_key_p(eventbus_prefix_k).isTrue())
+            this.eventBusPrefix = options.op_aref(context, eventbus_prefix_k).toString();
+
+        /* init vertx */
+        if (options.has_key_p(cluster_host_k).isTrue()) {
+            this.clusterHost = options.op_aref(context, cluster_host_k).toString();
+            if (options.has_key_p(cluster_port_k).isTrue()) {
+                this.clusterPort = Integer.parseInt(options.op_aref(context, cluster_port_k).toString());
+                this.vertx = JubileeVertx.init(clusterPort, clusterHost);
+            }
+            this.vertx = JubileeVertx.init(clusterHost);
+        } else {
+            this.vertx = JubileeVertx.init();
+        }
+
+        httpServer = vertx.createHttpServer();
+        try {
+            this.app = new RackApplication(vertx, context, app, this.ssl);
+            if (block.isGiven()) block.yieldSpecific(context, this);
+        } catch (IOException e) {
+            // noop
+        }
+        return this;
+    }
+
+    /**
+     * Start http server, initialize states
+     *
+     * @param context
+     * @param block
+     * @return
+     */
+    @JRubyMethod(name = "start")
+    public IRubyObject start(final ThreadContext context, final Block block) {
+        httpServer.setAcceptBacklog(10000);
+        httpServer.requestHandler(new Handler<HttpServerRequest>() {
+            public void handle(final HttpServerRequest req) {
+                app.call(req);
+            }
+        });
+        if (eventBusPrefix != null) {
+            JsonObject config = new JsonObject().putString("prefix", eventBusPrefix);
+            JsonArray allowAll = new JsonArray();
+            allowAll.add(new JsonObject());
+            // TODO read inbounds and outbounds from config file
+            vertx.createSockJSServer(httpServer).bridge(config, allowAll, allowAll);
+        }
+        if (ssl) httpServer.setSSL(true).setKeyStorePath(this.keyStorePath)
+                .setKeyStorePassword(this.keyStorePassword);
+        httpServer.listen(this.port, this.host);
+        this.running = true;
+        if (block.isGiven()) block.yieldSpecific(context, this);
+        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) {
+        // FIXME
+        //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) {
+            this.running = false;
+            httpServer.close();
+            // DO I need to stop?
+            //vertx.stop();
+            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/RubyIORackInput.java

@@ -0,0 +1,201 @@
+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;
+import org.jruby.jubilee.RackInput;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.jruby.util.StringSupport;
+import org.vertx.java.core.http.HttpServerRequest;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 11/26/12
+ * Time: 10:12 PM
+ */
+public class RubyIORackInput extends RubyObject implements RackInput {
+    private Encoding BINARY = ASCIIEncoding.INSTANCE;
+    private int len;
+    private boolean chunked;
+    private ByteBuf buf;
+    private AtomicBoolean eof;
+
+    public static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        @Override
+        public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+            return new RubyIORackInput(ruby, rubyClass);
+        }
+    };
+
+    public static RubyClass createIORackInputClass(Ruby runtime) {
+        RubyModule jModule = runtime.getOrCreateModule("Jubilee");
+        RubyClass rackIOInputClass = jModule.defineClassUnder("IORackInput", runtime.getObject(), ALLOCATOR);
+        rackIOInputClass.defineAnnotatedMethods(RubyIORackInput.class);
+        return rackIOInputClass;
+    }
+
+    public RubyIORackInput(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public RubyIORackInput(Ruby runtime, RubyClass rubyClass, HttpServerRequest request, ByteBuf buf, AtomicBoolean eof) {
+        this(runtime, rubyClass);
+        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
+    @JRubyMethod
+    public IRubyObject gets(ThreadContext context) {
+      Ruby runtime = context.runtime;
+      RubyString line = RubyString.newEmptyString(context.runtime, BINARY);
+
+        if (isEOF()) return runtime.getNil();
+
+        int lineEnd = -1;
+        while (lineEnd == -1 && !eof.get()) {
+            lineEnd = buf.indexOf(buf.readerIndex(), buf.writerIndex(), Const.EOL);
+        }
+
+        // No line break found, read all
+        if (lineEnd == -1)
+            return readAll(runtime, line);
+
+        int readLength = lineEnd - buf.readerIndex();
+        byte[] dst = new byte[readLength + 1];
+        buf.readBytes(dst);
+        return line.cat(dst);
+    }
+
+    /**
+     * 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) {
+        Ruby runtime = context.runtime;
+        RubyString dst = RubyString.newStringNoCopy(context.runtime, new ByteList(), BINARY, StringSupport.CR_VALID);
+        if (isEOF())
+            return runtime.getNil();
+        int length;
+        switch (args.length) {
+            case 0:
+                return readAll(runtime, dst);
+            case 1:
+                length = RubyNumeric.num2int(args[0]);
+                break;
+            default:
+                length = RubyNumeric.num2int(args[0]);
+                dst = (RubyString) args[1];
+        }
+        if (length < 0)
+            runtime.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) length -= toRead;
+        return dst.cat(buffer, 0, length);
+    }
+
+    /**
+     * 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 context.runtime.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 context.runtime.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 context.runtime.getNil();
+    }
+
+    private int readableBytes() {
+      if (! this.chunked) {
+        return Math.min(buf.readableBytes(), this.len - buf.readerIndex());
+      }
+      return buf.readableBytes();
+    }
+
+    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(Ruby runtime, RubyString dst) {
+        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];
+        buf.readBytes(data);
+        dst.cat(data);
+        return dst.isEmpty() ? runtime.getNil() : dst;
+    }
+}