jubilee 0.5.0 → 1.0.0.beta1

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

@@ -2,148 +2,167 @@ 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.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;
 
 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 String eventBusPrefix;
-  private int numberOfWorkers;
-  private int port;
-  private String host;
+    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 numberOfWorkers;
+    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(Server.class);
-  }
+    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);
+        }
+    };
 
-  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);
     }
-  };
 
-  public Server(Ruby ruby, RubyClass rubyClass) {
-    super(ruby, rubyClass);
-    vertx = VertxFactory.newVertx();
-    httpServer = vertx.createHttpServer();
-  }
+    /**
+     * Initialize jubilee server, take a rack application and a configuration hash as parameter
+     *
+     * @param context
+     * @param args
+     * @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");
+        RubySymbol number_of_workers_k = runtime.newSymbol("number_of_workers");
 
-  /**
-   * Initialize jubilee server, take a rack application and a configuration hash as parameter
-   * @param context
-   * @param args
-   * @param block
-   * @return
-   */
-  @JRubyMethod(name = "initialize")
-  public IRubyObject initialize(ThreadContext context, IRubyObject app, IRubyObject config, Block block) {
-    Ruby runtime = getRuntime();
-    RubyHash options = config.convertToHash();
-    RubySymbol port_k = runtime.newSymbol("Port");
-    RubySymbol host_k = runtime.newSymbol("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");
-    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()) {
+        /* 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();
-    } else {
-        this.host = "0.0.0.0";
-    }
-    this.ssl = options.op_aref(context, ssl_k).isTrue();
-    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();
-    }
-    if (options.has_key_p(eventbus_prefix_k).isTrue()) {
-      this.eventBusPrefix = options.op_aref(context, eventbus_prefix_k).toString();
+
+        this.ssl = options.op_aref(context, ssl_k).isTrue();
+        this.numberOfWorkers = Integer.parseInt(options.op_aref(context, number_of_workers_k).toString());
+        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();
+        }
+        this.app = new RackApplication(app, this.ssl, this.numberOfWorkers);
+        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();
+        return this;
     }
-    running = false;
-    return this;
-  }
 
-  /**
-   * Start http server, initialize states
-   * @param context
-   * @param block
-   * @return
-   */
-  @JRubyMethod(name = "start")
-  public IRubyObject start(final ThreadContext context, final Block block) {
-    this.running = true;
-    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);
-      // TODO read inbounds and outbounds from config file
-      vertx.createSockJSServer(httpServer).bridge(config, new JsonArray(), new JsonArray());
+    /**
+     * 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;
+        return this;
     }
-    if (ssl) httpServer.setSSL(true).setKeyStorePath(this.keyStorePath)
-            .setKeyStorePassword(this.keyStorePassword);
-    httpServer.listen(this.port, this.host);
-    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;
-  }
+    /**
+     * 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) {
-      if (args.length == 1)
-        app.shutdown(args[0].isTrue());
-      else
-        app.shutdown(false);
+    /**
+     * 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?");
+            this.running = false;
+            httpServer.close();
+            if (block.isGiven()) block.yieldSpecific(context);
+        } else {
+            getRuntime().getOutputStream().println("jubilee server not running?");
+        }
+        return getRuntime().getNil();
     }
-    return getRuntime().getNil();
-  }
 }

data/java/src/org/jruby/jubilee/vertx/JubileeVertx.java

@@ -0,0 +1,38 @@
+package org.jruby.jubilee.vertx;
+
+import org.vertx.java.core.Vertx;
+import org.vertx.java.core.VertxFactory;
+import org.vertx.java.core.eventbus.EventBus;
+import org.vertx.java.core.shareddata.SharedData;
+
+/**
+ * Created with IntelliJ IDEA.
+ * User: isaiah
+ * Date: 20/09/2013
+ * Time: 15:24
+ */
+public class JubileeVertx {
+    public static Vertx vertx;
+    private JubileeVertx() {
+    }
+    public static synchronized Vertx init(int port, String host) {
+        if (vertx != null) return vertx;
+        vertx = VertxFactory.newVertx(port, host);
+        return vertx;
+    }
+    public static synchronized Vertx init(String host) {
+        if (vertx != null) return vertx;
+        vertx = VertxFactory.newVertx(host);
+        return vertx;
+    }
+    public static synchronized Vertx init() {
+        if (vertx != null) return vertx;
+        vertx = VertxFactory.newVertx();
+        return vertx;
+    }
+
+    public synchronized static Vertx vertx() {
+        if (vertx == null) init();
+        return vertx;
+    }
+}

data/jubilee.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "jubilee"
-  s.version = "0.5.0"
+  s.version = "1.0.0.beta1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Isaiah Peng"]
-  s.date = "2013-09-19"
+  s.date = "2013-09-22"
   s.description = "Jubilee is a experimental webserver built for speed, it's based on Vertx."
   s.email = "issaria@gmail.com"
   s.executables = ["jubilee", "jubilee_d"]
@@ -28,11 +28,15 @@ Gem::Specification.new do |s|
     "VERSION",
     "bin/jubilee",
     "bin/jubilee_d",
+    "examples/client/sockjs-0.3.4.min.js",
+    "examples/client/vertxbus.js",
+    "examples/jubilee.conf.rb",
     "examples/jubilee/keystore.jks",
     "examples/jubilee/server-keystore.jks",
-    "examples/ssl/ServerTest.java",
-    "examples/ssl/webroot/index.html",
+    "jars/hazelcast-2.6.jar",
+    "jars/jackson-annotations-2.2.2.jar",
     "jars/jackson-core-2.2.2.jar",
+    "jars/jackson-databind-2.2.2.jar",
     "jars/netty-all-4.0.4.Final.jar",
     "jars/vertx-core-2.1.0-SNAPSHOT.jar",
     "java/src/jubilee/JubileeService.java",
@@ -48,6 +52,7 @@ Gem::Specification.new do |s|
     "java/src/org/jruby/jubilee/impl/NullIO.java",
     "java/src/org/jruby/jubilee/impl/RubyIORackErrors.java",
     "java/src/org/jruby/jubilee/impl/RubyIORackInput.java",
+    "java/src/org/jruby/jubilee/vertx/JubileeVertx.java",
     "jubilee.gemspec",
     "lib/jubilee.rb",
     "lib/jubilee/application.rb",
@@ -59,10 +64,15 @@ Gem::Specification.new do |s|
     "lib/jubilee/server.rb",
     "lib/jubilee/version.rb",
     "lib/rack/handler/jubilee.rb",
+    "lib/vertx.rb",
+    "lib/vertx/README.md",
+    "lib/vertx/buffer.rb",
+    "lib/vertx/event_bus.rb",
+    "lib/vertx/shared_data.rb",
     "test/.ruby-version",
     "test/config/app.rb",
     "test/jubilee/test_cli.rb",
-    "test/jubilee/test_config.rb",
+    "test/jubilee/test_configuration.rb",
     "test/jubilee/test_rack_server.rb",
     "test/jubilee/test_response.rb",
     "test/jubilee/test_server.rb",
@@ -77,7 +87,7 @@ Gem::Specification.new do |s|
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
   s.rubygems_version = "1.8.24"
-  s.summary = "JRuby webserver based on Vertx"
+  s.summary = "More than a server for rack applications."
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/lib/jubilee/cli.rb

@@ -12,20 +12,26 @@ module Jubilee
     end
 
     def parse_options
-      @parser.parse! @argv
+      argv = @argv.dup
+      @parser.parse! argv
       if @argv.last
-        @options[:rackup] = @argv.shift
+        @options[:rackup] = argv.shift
       end
     end
 
     def run
       parse_options
-      @config = Jubilee::Configuration.new(@options)
-      server = Jubilee::Server.new(@config.app, @options)
-      server.start
-      puts "Jubilee is listening on port #{@config.port}, press Ctrl+C to quit"
-      starter = org.jruby.jubilee.deploy.Starter.new
-      starter.block
+      if @options[:daemon]
+        puts "Starting Jubilee in daemon mode..."
+        `jubilee_d #{(@argv - ["-d", "--daemon"]).join(" ")}`
+      else
+        @config = Jubilee::Configuration.new(@options)
+        server = Jubilee::Server.new(@config.app, @config.options)
+        server.start
+        puts "Jubilee is listening on port #{@config.options[:Port]}, press Ctrl+C to quit"
+        starter = org.jruby.jubilee.deploy.Starter.new
+        starter.block
+      end
     end
 
     def setup_options
@@ -40,17 +46,17 @@ module Jubilee
         o.separator ""
         o.separator "Server options:"
 
-        #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 "-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
+          @options[:working_directory] = arg
         end
         o.on "-p", "--port PORT", "Defind which PORT the server should bind" do |arg|
-          @options[:Port] = arg
+          @options[:Port] = arg.to_i
         end
         o.on "--host HOST", "Defind which HOST the server should bind, default 0.0.0.0" do |arg|
           @options[:Host] = arg
@@ -70,11 +76,17 @@ module Jubilee
           @options[:keystore_password] = arg
         end
         o.separator ""
-        o.separator "Event bus options"
-        o.on "--eventbus PREFIX", "Event bus prefix" do |arg|
+        o.separator "Event bus options:"
+        o.on "--eventbus PREFIX", "Event bus prefix, use allow-all policy by default" do |arg|
           @options[:eventbus_prefix] = arg
         end
 
+        o.separator ""
+        o.separator "Clustering options:"
+        o.on "--cluster", "Enable clustering" do
+          @options[:cluster_host] = "0.0.0.0"
+        end
+
         o.separator ""
         o.separator "Common options:"
         o.on "--verbose", "Log low level debug information" do

data/lib/jubilee/configuration.rb

@@ -1,10 +1,25 @@
+# -*- encoding: binary -*-
+
 module Jubilee
+  # Implements a simple DSL for configuring a Jubilee server
+  #
+  # See https://github.com/isaiah/jubilee/examples/jubilee.conf.rb
+  # for example configuration files.
   class Configuration
-    attr_reader :app
+
+    attr_accessor :config_file
+    attr_reader :options
 
     def initialize(options, &block)
-      @options = options
+      config_file = options.delete(:config_file)
+      @options = options.dup
       @block = block
+
+      reload
+    end
+
+    def reload
+      instance_eval(File.read(config_file), config_file) if config_file
     end
 
     def app
@@ -17,24 +32,82 @@ module Jubilee
       end
     end
 
-    def port
-      @options[:Port]
+    # sets the host and port jubilee listens to +address+ may be an Integer port 
+    # number for a TCP port or an "IP_ADDRESS:PORT" for TCP listeners
+    #
+    #   listen 3000 # listen to port 3000 on all TCP interfaces
+    #   listen "127.0.0.1:3000"  # listen to port 3000 on the loopback interface
+    #   listen "[::1]:3000" # listen to port 3000 on the IPv6 loopback interface
+    def listen(address)
+      @options[:host], @options[:port] = expand_addr(address)
+    end
+
+    # sets the working directory for jubilee
+    def working_directory(path)
+      path = File.expand_path(path)
+      if config_file && config_file[0] != ?/ && ! File.readable?("#{path}/#{config_file}")
+         raise ArgumentError,
+              "config_file=#{config_file} would not be accessible in" \
+              " working_directory=#{path}"
+      end
+    end
+
+    # sets the number of worker threads in the threads pool, Each worker thread
+    # will serve exactly one client at a time.
+    def worker_threads(nr)
+      set_int(:worker_threads, nr, 1)
     end
 
-    def host
-      @options[:Host]
+    # set the event bus bridge prefix, prefix, options
+    # eventbus /eventbus, inbound: {foo:bar}, outbound: {foo: bar}
+    # will set the event bus prefix as eventbus "/eventbus", it can be
+    # connected via new EventBus("http://localhost:3215/eventbus"), inbound and
+    # outbound options are security measures that will filter the messages
+    def eventbus(prefix, options = {})
+      @options[:event_bus][:prefix] = prefix
+      @options[:event_bus][:inbound] = options[:inbound]
+      @options[:event_bus][:outbound] = options[:outbound]
     end
 
-    def ssl
-      @options[:ssl]
+    # Set the host and port to be discovered by other jubilee instances in the network
+    # +address+ may be an Integer port number for a TCP port or an
+    # "IP_ADDRESS:PORT" for TCP listeners, or "IP_ADDRESS" and let the system
+    # to assign a port
+    def clustering(address)
+      @options[:cluster_host], @options[:cluster_port] = expand_addr(address)
     end
-    
-    def keystore_path
-      @options[:keystore_path]
+
+    # enable debug messages
+    def debug(bool)
+      set_bool(:debug, bool)
     end
 
-    def keystore_password
-      @options[:keystore_password]
+    # enable daemon mode
+    def daemonize(bool)
+      set_bool(:debug, bool)
+    end
+
+    # enable https mode, provide the :keystore path and password
+    def ssl(options = {})
+      set_path(:ssl_keystore, options[:keystore])
+      @options[:ssl_password] = options[:password]
+      @options[:ssl] = true
+    end
+
+    # sets the path for the PID file of the jubilee event loop
+    def pid(path)
+      set_path(:pid, path)
+    end
+
+    # Allows redirecting $stderr to a given path, if you are daemonizing and
+    # useing the default +logger+, this defautls to log/jubilee.stderr.log
+    def stderr_path(path)
+      set_path(:stderr_path, path)
+    end
+
+    # live stderr_path, this defaults to log/jubilee.stdout.log when daemonized
+    def stdout_path(path)
+      set_path(:stdout_path, path)
     end
 
     private
@@ -51,11 +124,50 @@ module Jubilee
         end
       end
       inner_app
-      #Rack::Builder.new do
-      #  use Rack::MethodOverride
-      #  use Rack::CommonLogger, $stderr
-      #  run inner_app
-      #end.to_app
+    end
+
+    def expand_addr(addr)
+      return ["0.0.0.0", addr] if addr === Integer
+      case addr
+      when %r{\A(?:\*:)?(\d+)\z}
+        ["0.0.0.0", $1]
+      when %r{\A\[([a-fA-F0-9:]+)\]:(\d+)\z}, %r{\A(.*):(\d+)\z}
+        canonicalize_tcp($1, $2.to_i)
+      when %r{\A?:\*\z}
+        [addr, nil]
+      else
+        raise ArgumentError, "unrecognizable address #{var}=#{addr.inspect}"
+      end
+    end
+
+    def set_int(var, n, min)
+      Integer === n or raise ArgumentError, "not an integer: #{var}=#{n.inspect}"
+      n >= min or raise ArgumentError, "too low (< #{min}): #{var}=#{n.inspect}"
+      @options[var] = n
+    end
+
+    def set_path(var, path)
+      case path
+      when NilClass, String
+        @options[var] = path
+      else
+        raise ArgumentError
+      end
+    end
+
+    def set_bool(var, bool)
+      case bool
+      when true, false
+        @options[var] = bool
+      else
+        raise ArgumentError, "#{var}=#{bool.inspect} not a boolean"
+      end
+    end
+
+    def canonicalize_tcp(addr, port)
+      packed = Socket.pack_sockaddr_in(port, addr)
+      port, addr = Socket.unpack_sockaddr_in(packed)
+      /:/ =~ addr ? ["[#{addr}]",port] : [addr, port]
     end
   end
 end

data/lib/jubilee.rb

@@ -1,4 +1,7 @@
 require File.join(File.dirname(__FILE__), "../jars/jackson-core-2.2.2.jar")
+require File.join(File.dirname(__FILE__), "../jars/jackson-databind-2.2.2.jar")
+require File.join(File.dirname(__FILE__), "../jars/jackson-annotations-2.2.2.jar")
+require File.join(File.dirname(__FILE__), "../jars/hazelcast-2.6.jar")
 require File.join(File.dirname(__FILE__), "../jars/vertx-core-2.1.0-SNAPSHOT.jar")
 require File.join(File.dirname(__FILE__), "../jars/netty-all-4.0.4.Final.jar")
 

data/lib/vertx/README.md

@@ -0,0 +1,7 @@
+Because embeded Vertx doesn't support modules, I have to copy the ruby api
+from the [mod-lang-jruby](https://github.com/vert-x/mod-lang-jruby) project.
+
+Some of the files that are not required for the jubilee api are removed.
+
+These files are exactly the same as the original project, except the directory
+name changed to follow the ruby conversion of namespaces.