jubilee 0.1.2

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

@@ -0,0 +1,111 @@
+package org.jruby.jubilee.impl;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+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;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 11/26/12
+ * Time: 12:11 PM
+ */
+public class NullIO extends RubyObject implements RackInput {
+    public static RubyClass createNullIOClass(Ruby ruby) {
+        RubyModule jModule = ruby.defineModule("Jubilee");
+        RubyClass nullIOClass = jModule.defineClassUnder("NullIO", ruby.getObject(), ALLOCATOR);
+        nullIOClass.defineAnnotatedMethods(NullIO.class);
+        return nullIOClass;
+    }
+
+    public static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        @Override
+        public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+            return new NullIO(ruby, rubyClass);
+        }
+    };
+
+    public NullIO(Ruby ruby) {
+        this(ruby, createNullIOClass(ruby));
+    }
+
+    public NullIO(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    /**
+     * 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
+     */
+    @Override
+    @JRubyMethod(name = "gets")
+    public IRubyObject gets(ThreadContext context) {
+        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) {
+        return getRuntime().getNil();
+    }
+
+    /**
+     * 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) {
+        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) {
+        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.
+     */
+    @Override
+    public IRubyObject close(ThreadContext context) {
+      return getRuntime().getNil();
+    }
+}

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

@@ -0,0 +1,68 @@
+package org.jruby.jubilee.impl;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.jubilee.RackErrors;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 11/26/12
+ * Time: 12:03 PM
+ */
+public class RubyIORackErrors extends RubyObject implements RackErrors {
+
+    public static RubyClass createRubyIORackErrorsClass(Ruby runtime) {
+        RubyModule jModule = runtime.defineModule("Jubilee");
+        RubyClass rackErrorsClass = jModule.defineClassUnder("RubyIORackErrors", runtime.getObject(), ALLOCATOR);
+        rackErrorsClass.defineAnnotatedMethods(RubyIORackErrors.class);
+        return rackErrorsClass;
+    }
+
+    public static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        @Override
+        public IRubyObject allocate(Ruby ruby, RubyClass rubyClass) {
+            return new RubyIORackErrors(ruby, rubyClass);
+        }
+    };
+
+    public RubyIORackErrors(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public RubyIORackErrors(Ruby runtime) {
+        super(runtime, createRubyIORackErrorsClass(runtime));
+    }
+
+    @Override
+    @JRubyMethod(name = "puts")
+    public IRubyObject puts(ThreadContext context, IRubyObject arg) {
+        //getRuntime().getOutputStream().println(arg.toString());
+        return null;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    @Override
+    @JRubyMethod
+    public IRubyObject write(ThreadContext context, IRubyObject string) {
+        //getRuntime().getOutputStream().println(string.toString());
+        return null;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    @Override
+    @JRubyMethod
+    public IRubyObject flush() {
+        return null;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+
+    @Override
+    @JRubyMethod
+    public IRubyObject close() {
+        return null;  //To change body of implemented methods use File | Settings | File Templates.
+    }
+}

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

@@ -0,0 +1,164 @@
+package org.jruby.jubilee.impl;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+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.vertx.java.core.buffer.Buffer;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 11/26/12
+ * Time: 10:12 PM
+ */
+public class RubyIORackInput extends RubyObject implements RackInput {
+  private ChannelBuffer buf;
+  private CountDownLatch bodyLatch;
+
+  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, Buffer buf, CountDownLatch bodyLatch) {
+    this(runtime, createRubyIORackInputClass(runtime));
+    this.buf = buf.getChannelBuffer();
+    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();
+    }
+    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);
+    }
+    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();
+    }
+    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;
+    }
+    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);
+    }
+    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();
+  }
+}

data/lib/jubilee.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), "../jars/vertx-core-1.3.0.final.jar")
+require File.join(File.dirname(__FILE__), "../jars/netty-3.6.0.Beta1.jar")
+
+require 'jubilee/jubilee.jar'
+require 'rack'
+require 'jubilee/const'
+require 'jubilee/server'
+require 'jubilee/application'
+require 'jubilee/configuration'
+require 'jubilee/response'
+require 'rack/handler/jubilee'

data/lib/jubilee/application.rb

@@ -0,0 +1,13 @@
+module Jubilee
+  class Application
+    def initialize(rack_app)
+      unless @app = rack_app
+        raise "rack application not found, make sure the rackup file path is correct"
+      end
+    end
+
+    def call(env)
+      Response.new(@app.call(env))
+    end
+  end
+end

data/lib/jubilee/cli.rb

@@ -0,0 +1,74 @@
+require 'optparse'
+require 'jubilee'
+require 'java'
+
+module Jubilee
+  class CLI
+    # Parsed options
+    attr_accessor :options
+    def initialize(argv)
+      @argv = argv
+      setup_options
+    end
+
+    def parse_options
+      @parser.parse! @argv
+      if @argv.last
+        @options[:rackup] = @argv.shift
+      end
+    end
+
+    def run
+      parse_options
+      @config = Jubilee::Configuration.new(@options)
+      @config.load
+      server = Jubilee::Server.new(@config.app, {port: @config.port, ssl: @config.ssl})
+      server.start
+      puts "Jubilee is listening on port #{@config.port}, press Ctrl+C to quit"
+      starter = org.jruby.jubilee.deploy.Starter.new
+      starter.block
+    end
+
+    def setup_options
+      @options = {
+        debug: false,
+        daemon: false,
+        port: 3215,
+        ssl: false,
+        environment: "development"
+      }
+      @parser = OptionParser.new do |o|
+        #o.on "-c", "--config PATH", "Load PATH as a config file" do |arg|
+        #  @options[:config_file] = arg
+        #end
+        #o.on "-d", "--daemon", "Daemonize the server" do
+        #  @options[:daemon] = true
+        #end
+        o.on "--dir DIR", "Change to DIR before starting" do |arg|
+          @options[:chdir] = arg
+        end
+        o.on "-p", "--port PORT", "Defind which PORT the server should bind" do |arg|
+          @options[:port] = arg
+        end
+        o.on "--ssl", "Enable SSL connection" do 
+          @options[:ssl] = true
+        end
+        o.on "--verbose", "Log low level debug information" do
+          @options[:debug] = true
+        end
+        o.on "-e", "--environment ENV", "Rack environment" do |arg|
+          @options[:environment] = arg
+        end
+        o.on "-q", "--quiet" do
+          @options[:quiet] = true
+        end
+      end
+
+      @parser.banner = "jubilee <options> <rackup file>"
+      @parser.on_tail "-h", "--help", "Show this message" do
+        puts @parser
+        exit 1
+      end
+    end
+  end
+end

data/lib/jubilee/configuration.rb

@@ -0,0 +1,52 @@
+module Jubilee
+  class Configuration
+    def initialize(options, &block)
+      @options = options
+      @block = block
+    end
+
+    def load
+      @app = load_rack_adapter(@options, &@block)
+    end
+
+    def app
+      if !@options[:quiet] and @options[:environment] == "development"
+        logger = @options[:logger] || STDOUT
+        Rack::CommonLogger.new(@app, logger)
+      else
+        @app
+      end
+    end
+
+    def port
+      @options[:port]
+    end
+
+    def ssl
+      @options[:ssl]
+    end
+
+    #def self.load(config)
+    #  rackup_code = ::File.read(config)
+    #  eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, config)
+    #end
+
+    private
+    def load_rack_adapter(options, &block)
+      if block
+        app = Rack::Builder.new(&block).to_app
+      else
+        if options[:rackup]
+          Kernel.load(options[:rackup])
+          app = Object.const_get(File.basename(options[:rackup], '.rb').capitalize.to_sym).new
+        else
+          Dir.chdir options[:chdir] if options[:chdir]
+          app, opts = Rack::Builder.parse_file "config.ru"
+        end
+      end
+      app
+      #Rack::Lint.new(Rack::CommonLogger.new(app, STDOUT))
+    end
+
+  end
+end