jubilee 2.1.0.beta-java → 2.1.0.rc1-java

data/src/main/assembly/mod.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
+
+    <formats>
+        <format>zip</format>
+    </formats>
+
+    <includeBaseDirectory>false</includeBaseDirectory>
+
+    <fileSets>
+        <fileSet>
+            <outputDirectory></outputDirectory>
+            <directory>${mods.directory}/${module.name}</directory>
+            <includes>
+                <include>**</include>
+            </includes>
+        </fileSet>
+    </fileSets>
+</assembly>

data/{java/src → src/main/java}/org/jruby/jubilee/JubileeVerticle.java

@@ -3,7 +3,6 @@ package org.jruby.jubilee;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyInstanceConfig;
-import org.jruby.RubyString;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.vertx.java.core.Handler;
 import org.vertx.java.core.http.HttpServer;
@@ -11,6 +10,7 @@ import org.vertx.java.core.http.HttpServerRequest;
 import org.vertx.java.core.json.JsonArray;
 import org.vertx.java.core.json.JsonObject;
 import org.vertx.java.platform.Verticle;
+import org.vertx.java.platform.impl.JRubyVerticleFactory;
 import org.vertx.java.platform.impl.WrappedVertx;
 
 import java.io.IOException;
@@ -22,9 +22,18 @@ import java.util.List;
  * Created by isaiah on 23/01/2014.
  */
 public class JubileeVerticle extends Verticle {
+    private String rackup;
+
+    public JubileeVerticle(){}
+
+    public JubileeVerticle(String rackup) {
+        this.rackup = rackup;
+    }
 
     @Override
     public void start() {
+        JRubyVerticleFactory.vertx = vertx;
+        JRubyVerticleFactory.container = container;
         JsonObject config = container.config();
         HttpServer httpServer = vertx.createHttpServer();
         String root = config.getString("root", ".");
@@ -93,7 +102,8 @@ public class JubileeVerticle extends Verticle {
     }
 
     private IRubyObject initRackApplication(JsonObject config) {
-        String rackup = config.getString("rackup");
+        if (this.rackup == null)
+            this.rackup = config.getString("rackup");
         String rackScript = "require 'rack'\n" +
                 "require 'jubilee'\n" +
                 "app, _ = Rack::Builder.parse_file('" + rackup + "')\n";

data/src/main/java/org/jruby/jubilee/JubileeVerticleFactory.java

@@ -0,0 +1,258 @@
+/*
+ * Copyright 2011-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jruby.jubilee;
+
+import org.jruby.*;
+import org.jruby.embed.EvalFailedException;
+import org.jruby.embed.InvokeFailedException;
+import org.jruby.embed.LocalContextScope;
+import org.jruby.embed.ScriptingContainer;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.vertx.java.core.Handler;
+import org.vertx.java.core.Vertx;
+import org.vertx.java.core.VertxException;
+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 org.vertx.java.core.logging.Logger;
+import org.vertx.java.platform.Container;
+import org.vertx.java.platform.Verticle;
+import org.vertx.java.platform.VerticleFactory;
+import org.vertx.java.platform.impl.WrappedVertx;
+import org.vertx.java.platform.impl.JRubyVerticleFactory;
+
+import java.io.*;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class JubileeVerticleFactory implements VerticleFactory {
+
+    private ClassLoader cl;
+    private ScriptingContainer scontainer;
+    private static final AtomicInteger seq = new AtomicInteger();
+
+    public static Vertx vertx;
+    public static Container container;
+
+    public JubileeVerticleFactory() {
+    }
+
+    @Override
+    public void init(Vertx vertx, Container container, ClassLoader cl) {
+        this.cl = cl;
+        // These statics are used by the Rhino scripts to look up references to vertx and the container
+        JRubyVerticleFactory.vertx = vertx;
+        JubileeVerticleFactory.vertx = vertx;
+        JubileeVerticleFactory.container = container;
+        ClassLoader old = Thread.currentThread().getContextClassLoader();
+        try {
+            Thread.currentThread().setContextClassLoader(cl);
+            this.scontainer = new ScriptingContainer(LocalContextScope.SINGLETHREAD);
+            scontainer.setCompatVersion(CompatVersion.RUBY1_9);
+            //Prevent JRuby from logging errors to stderr - we want to log ourselves
+            scontainer.setErrorWriter(new NullWriter());
+        } finally {
+            Thread.currentThread().setContextClassLoader(old);
+        }
+    }
+
+    @Override
+    public Verticle createVerticle(String rackup) throws Exception {
+        return new RackVerticle(rackup);
+    }
+
+    public void reportException(Logger logger, Throwable t) {
+        RaiseException je = null;
+        if (t instanceof EvalFailedException) {
+            EvalFailedException e = (EvalFailedException)t;
+            Throwable cause = e.getCause();
+            if (cause instanceof RaiseException) {
+                je = (RaiseException)cause;
+            }
+        } else if (t instanceof RaiseException) {
+            je = (RaiseException)t;
+        }
+
+        if (je != null) {
+
+            RubyException re = je.getException();
+
+            String msg;
+            if (re instanceof RubyNameError) {
+                RubyNameError rne = (RubyNameError)re;
+                msg = "Invalid or undefined name: " + rne.name().toString();
+            } else {
+                msg = re.message.toString();
+            }
+
+            StringBuilder backtrace = new StringBuilder();
+            IRubyObject bt = re.backtrace();
+
+            if (bt instanceof List) {
+                for (Object obj : (List<?>)bt) {
+                    if (obj instanceof String) {
+                        String line = (String)obj;
+                        addToBackTrace(backtrace, line);
+                    }
+                }
+            }
+            logger.error("Exception in Ruby verticle: " + msg +
+                    "\n" + backtrace);
+        } else {
+            logger.error("Unexpected exception in Ruby verticle", t);
+        }
+    }
+
+    private void addToBackTrace(StringBuilder backtrace, String line) {
+        if (line.contains(".rb")) {
+            //We filter out any Java stack trace
+            backtrace.append(line).append('\n');
+        }
+    }
+
+    // This method synchronizes the callback into the JRuby code to make sure we don't have concurrent requires
+    // or loads occurring in the same JRuby container
+    public static synchronized void requireCallback(Runnable runnable) {
+        runnable.run();
+    }
+
+    // This MUST be static or we will get a leak since JRuby maintains it and a non static will hold a reference
+    // to this
+    private static class NullWriter extends Writer {
+
+        public void write(char[] cbuf, int off, int len) throws IOException {
+        }
+
+        public void flush() throws IOException {
+        }
+
+        public void close() throws IOException {
+        }
+    }
+
+    public void close() {
+        scontainer.clear();
+        // JRuby keeps a static reference to a runtime - we must clear this manually to avoid a leak
+        Ruby.clearGlobalRuntime();
+    }
+    public class RackVerticle extends Verticle {
+        public RackVerticle(String rackup) {
+            this.rackup = rackup;
+            this.vertx = JubileeVerticleFactory.vertx;
+            this.container = JubileeVerticleFactory.container;
+        }
+
+        public void start() {
+            JsonObject config = container.config();
+            synchronized (JubileeVerticleFactory.class) {
+                try (InputStream is = cl.getResourceAsStream(rackup)) {
+                    if (is == null) {
+                        throw new IllegalArgumentException("Cannot find verticle: " + rackup);
+                    }
+                    modName = "Mod___VertxInternalVert__" + seq.incrementAndGet();
+                    StringBuilder svert = new StringBuilder( "require 'jubilee/jubilee_require'\n").append("module ").append(modName).append(";extend self;");
+                    String rackScript = "require 'rack'\n" +
+                            "require 'jubilee'\n" +
+                            "app, _ = Rack::Builder.parse_file('" + rackup + "')\n";
+                    if (!config.getBoolean("quiet", true) && config.getString("environment").equals("development")) {
+                        rackScript += "logger = STDOUT\n" +
+                                "app = Rack::CommonLogger.new(app, logger)\n";
+                    }
+                    rackScript += "Jubilee::Application.new(app)\n";
+                    svert.append(rackScript);
+                    svert.append("end");
+                    rackApplication = (IRubyObject)scontainer.runScriptlet(new StringReader(svert.toString()), rackup);
+                } catch (Exception e) {
+                    throw new VertxException(e);
+                }
+            }
+            httpServer = vertx.createHttpServer();
+
+            final RackApplication app;
+            boolean ssl = config.getBoolean("ssl", false);
+            try {
+                app = new RackApplication((WrappedVertx) vertx, rackApplication.getRuntime().getCurrentContext(), rackApplication, config);
+                httpServer.setAcceptBacklog(10000);
+                httpServer.requestHandler(new Handler<HttpServerRequest>() {
+                    public void handle(final HttpServerRequest req) {
+                        app.call(req);
+                    }
+                });
+                if (config.containsField("event_bus")) {
+                    JsonArray allowAll = new JsonArray();
+                    allowAll.add(new JsonObject());
+
+                    JsonArray incomingAllowed;
+                    JsonArray outgoingAllowed;
+
+                    if (config.containsField("event_bus_security")) {
+                        JsonObject securitySettings = config.getObject("event_bus_security");
+                        incomingAllowed = securitySettings.getArray("incoming", allowAll);
+                        outgoingAllowed = securitySettings.getArray("outgoing", allowAll);
+                    } else {
+                        incomingAllowed = allowAll;
+                        outgoingAllowed = allowAll;
+                    }
+                    JsonObject ebconf = new JsonObject();
+                    ebconf.putString("prefix", config.getString("event_bus"));
+                    vertx.createSockJSServer(httpServer).bridge(ebconf, incomingAllowed, outgoingAllowed);                        
+
+                }
+                if (ssl) httpServer.setSSL(true).setKeyStorePath(config.getString("keystore_path"))
+                        .setKeyStorePassword(config.getString("keystore_password"));
+                httpServer.listen(config.getInteger("port", 8080), config.getString("host", "localhost"));
+            } catch (IOException e) {
+                container.logger().fatal("Failed to create RackApplication");
+            }
+        }
+
+        @Override
+        public void stop() {
+            if (this.httpServer != null)
+                this.httpServer.close();
+            if (rackApplication != null) {
+                try {
+                    // We call the script with receiver = null - this causes the method to be called on the top level
+                    // script
+                    scontainer.callMethod(rackApplication, "vertx_stop");
+                } catch (InvokeFailedException e) {
+                    Throwable cause = e.getCause();
+                    if (cause instanceof RaiseException) {
+                        // Gosh, this is a bit long winded!
+                        RaiseException re = (RaiseException) cause;
+                        String msg = "(NoMethodError) undefined method `vertx_stop'";
+                        if (re.getMessage().startsWith(msg)) {
+                            // OK - method is not mandatory
+                            return;
+                        }
+                    }
+                    throw e;
+                } finally {
+                    // Remove the module const
+                    scontainer.runScriptlet("Object.send(:remove_const, :" + modName + ")");
+                }
+            }
+        }
+
+        private String rackup;
+        private IRubyObject rackApplication;
+        private String modName;
+        private HttpServer httpServer;
+    }
+}

data/{java/src → src/main/java}/org/jruby/jubilee/RackApplication.java

@@ -41,7 +41,7 @@ public class RackApplication {
 
     public RackApplication(WrappedVertx vertx, ThreadContext context, IRubyObject app, JsonObject config) throws IOException {
         this.app = app;
-        this.ssl = config.getBoolean("ssl");
+        this.ssl = config.getBoolean("ssl", false);
         this.hideErrorStack = config.getBoolean("hide_error_stack", false);
         this.vertx = vertx;
         this.runtime = context.runtime;
@@ -92,10 +92,12 @@ public class RackApplication {
                 try {
                     // This is a different context, do NOT replace runtime.getCurrentContext()
                     IRubyObject result = app.callMethod(runtime.getCurrentContext(), "call", rackEnv.getEnv(request, input, ssl));
+                    /*
                     if (request.isHijacked()) {
                         // It's the hijacker's response to close the socket.
                         return;
                     }
+                    */
                     RackResponse response = (RackResponse) JavaEmbedUtils.rubyToJava(runtime, result, RackResponse.class);
                     RubyHttpServerResponse resp = new RubyHttpServerResponse(runtime,
                             httpServerResponseClass, request);

data/{java/src → src/main/java}/org/jruby/jubilee/RackEnvironment.java

@@ -100,8 +100,8 @@ public class RackEnvironment {
         env.lazyPut(RACK_KEY.RUN_ONCE, runtime.getFalse(), false);
 
         // Hijack handling
-        env.lazyPut(RACK_KEY.HIJACK_P, runtime.getTrue(), false);
-        env.lazyPut(RACK_KEY.HIJACK, hijackProc(env, request), false);
+        env.lazyPut(RACK_KEY.HIJACK_P, runtime.getFalse(), false);
+//        env.lazyPut(RACK_KEY.HIJACK, hijackProc(env, request), false);
 
 
         final int contentLength = getContentLength(headers);

data/src/main/resources/META-INF/services/org.vertx.java.deploy.impl.jruby.JubileeVerticleFactory

@@ -0,0 +1 @@
+org.vertx.java.deploy.impl.jruby.JubileeVerticleFactory

data/src/main/resources/mod.json

@@ -0,0 +1,11 @@
+{
+  "system": true,
+  "resident": true,
+  "includes": "io.vertx~lang-jruby~2.1.0-final",
+
+  "description":"Rack application runner",
+  "licenses": ["MIT"],
+  "author": "isaiah",
+  "keywords": ["rack", "rails"],
+  "homepage": "https://github.com/isaiah/jubilee"
+}

data/test/jubilee/test_upload.rb

@@ -128,7 +128,9 @@ class TestUpload < MiniTest::Unit::TestCase
     assert_raises(Errno::ECONNRESET, Errno::EPIPE) do
       16384.times { sock.syswrite(buf) }
     end
-    sock.gets
+    assert_raises(Errno::ECONNRESET) do
+      sock.gets
+    end
     sock.close
   end
 

data/vertx_classpath.txt

@@ -0,0 +1,12 @@
+# This file contains information on where to find the resources of your module during development
+# This file is used when running your module as you develop - it tells Vert.x where to find
+# the resources of your module
+
+# Feel free to edit it if you have a non standard project structure and put the resources of your
+# module elsewhere
+
+src/main/resources
+target/classes
+target/dependencies
+lib/
+bin

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: jubilee
 version: !ruby/object:Gem::Version
-  version: 2.1.0.beta
+  version: 2.1.0.rc1
 platform: java
 authors:
 - Isaiah Peng
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-07-24 00:00:00.000000000 Z
+date: 2014-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rack
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 1.4.1
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: 1.4.1
+  name: rack
   prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: spoon
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 0.0.4
+        version: 1.4.1
+- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.0.4
+  name: spoon
   prerelease: false
   type: :runtime
-- !ruby/object:Gem::Dependency
-  name: jeweler
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.8.7
+        version: 0.0.4
+- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.8.7
+  name: jeweler
   prerelease: false
   type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
 description: Jubilee is a rack server for JRuby built upon the high performance Vertx platform. It provides the best features of Vertx such as EventBus, SharedData, and clustering.
 email: issaria@gmail.com
 executables:
@@ -67,7 +67,6 @@ files:
 - CHANGELOG
 - Gemfile
 - Gemfile.lock
-- Guardfile
 - KNOWN_ISSUES
 - LICENSE.txt
 - README.md
@@ -79,6 +78,7 @@ files:
 - examples/chatapp/Gemfile.lock
 - examples/chatapp/README.md
 - examples/chatapp/app.rb
+- examples/chatapp/config.json
 - examples/chatapp/config.ru
 - examples/chatapp/public/assets/javascripts/application.js
 - examples/chatapp/public/assets/javascripts/jquery.js
@@ -89,53 +89,52 @@ files:
 - examples/client/vertxbus.js
 - examples/jubilee.conf.rb
 - examples/keystore.jks
+- jars/annotations-1.3.2.jar
 - jars/hazelcast-3.2.3.jar
 - jars/jackson-annotations-2.2.2.jar
 - jars/jackson-core-2.2.2.jar
 - jars/jackson-databind-2.2.2.jar
+- jars/lang-jruby-2.1.0-final.jar
+- jars/log4j-1.2.16.jar
 - jars/netty-all-4.0.20.Final.jar
-- jars/vertx-core-2.1.1.jar
-- jars/vertx-hazelcast-2.1.1.jar
-- jars/vertx-platform-2.1.1.jar
-- java/resources/META-INF/services/org.vertx.java.core.spi.cluster.ClusterManagerFactory
-- java/resources/default-cluster.xml
-- java/src/jubilee/JubileeService.java
-- java/src/org/jruby/jubilee/Const.java
-- java/src/org/jruby/jubilee/JubileeVerticle.java
-- java/src/org/jruby/jubilee/RackApplication.java
-- java/src/org/jruby/jubilee/RackEnvironment.java
-- java/src/org/jruby/jubilee/RackEnvironmentHash.java
-- java/src/org/jruby/jubilee/RackInput.java
-- java/src/org/jruby/jubilee/RackResponse.java
-- java/src/org/jruby/jubilee/RubyCallable.java
-- java/src/org/jruby/jubilee/RubyChannel.java
-- java/src/org/jruby/jubilee/RubyHttpServerResponse.java
-- java/src/org/jruby/jubilee/RubyNetSocket.java
-- java/src/org/jruby/jubilee/RubyPlatformManager.java
-- java/src/org/jruby/jubilee/impl/RubyIORackInput.java
-- java/src/org/jruby/jubilee/impl/RubyNullIO.java
-- java/src/org/jruby/jubilee/utils/RubyHelper.java
-- java/src/org/jruby/jubilee/vertx/JubileeVertx.java
+- jars/slf4j-api-1.6.2.jar
+- jars/vertx-core-2.1.2.jar
+- jars/vertx-hazelcast-2.1.2.jar
+- jars/vertx-platform-2.1.2.jar
 - jubilee.gemspec
+- lib/container.rb
+- lib/core/buffer.rb
+- lib/core/datagram.rb
+- lib/core/dns.rb
+- lib/core/event_bus.rb
+- lib/core/file_system.rb
+- lib/core/http.rb
+- lib/core/net.rb
+- lib/core/network_support.rb
+- lib/core/parsetools.rb
+- lib/core/shared_data.rb
+- lib/core/sock_js.rb
+- lib/core/ssl_support.rb
+- lib/core/streams.rb
+- lib/core/tcp_support.rb
+- lib/core/timers.rb
+- lib/core/vertx_require.rb
+- lib/core/wrapped_handler.rb
 - lib/jubilee.rb
 - lib/jubilee/application.rb
 - lib/jubilee/cli.rb
 - lib/jubilee/configuration.rb
 - lib/jubilee/const.rb
+- lib/jubilee/jubilee.jar
+- lib/jubilee/jubilee_require.rb
 - lib/jubilee/response.rb
 - lib/jubilee/server.rb
 - lib/jubilee/version.rb
 - lib/rack/handler/jubilee.rb
+- lib/test_utils.rb
 - lib/vertx.rb
-- lib/vertx/README.md
-- lib/vertx/buffer.rb
-- lib/vertx/event_bus.rb
-- lib/vertx/http.rb
-- lib/vertx/shared_data.rb
-- lib/vertx/ssl_support.rb
-- lib/vertx/streams.rb
-- lib/vertx/tcp_support.rb
-- lib/vertx/wrapped_handler.rb
+- lib/vertx_tests.rb
+- pom.xml
 - spec/apps/rack/basic/config.ru
 - spec/apps/rails4/basic/.gitignore
 - spec/apps/rails4/basic/Gemfile
@@ -210,6 +209,28 @@ files:
 - spec/integration/basic_rails4_spec.rb
 - spec/integration/basic_sinatra_spec.rb
 - spec/spec_helper.rb
+- src/main/assembly/mod.xml
+- src/main/java/jubilee/JubileeService.java
+- src/main/java/org/jruby/jubilee/Const.java
+- src/main/java/org/jruby/jubilee/JubileeVerticle.java
+- src/main/java/org/jruby/jubilee/JubileeVerticleFactory.java
+- src/main/java/org/jruby/jubilee/RackApplication.java
+- src/main/java/org/jruby/jubilee/RackEnvironment.java
+- src/main/java/org/jruby/jubilee/RackEnvironmentHash.java
+- src/main/java/org/jruby/jubilee/RackInput.java
+- src/main/java/org/jruby/jubilee/RackResponse.java
+- src/main/java/org/jruby/jubilee/RubyCallable.java
+- src/main/java/org/jruby/jubilee/RubyHttpServerResponse.java
+- src/main/java/org/jruby/jubilee/RubyNetSocket.java
+- src/main/java/org/jruby/jubilee/RubyPlatformManager.java
+- src/main/java/org/jruby/jubilee/impl/RubyIORackInput.java
+- src/main/java/org/jruby/jubilee/impl/RubyNullIO.java
+- src/main/java/org/jruby/jubilee/utils/RubyHelper.java
+- src/main/java/org/jruby/jubilee/vertx/JubileeVertx.java
+- src/main/resources/META-INF/services/org.vertx.java.core.spi.cluster.ClusterManagerFactory
+- src/main/resources/META-INF/services/org.vertx.java.deploy.impl.jruby.JubileeVerticleFactory
+- src/main/resources/default-cluster.xml
+- src/main/resources/mod.json
 - test/.ruby-version
 - test/apps/app.rb
 - test/apps/checker.ru
@@ -238,6 +259,7 @@ files:
 - test/jubilee/test_server.rb
 - test/jubilee/test_upload.rb
 - test/test_helper.rb
+- vertx_classpath.txt
 homepage: http://isaiah.github.io/jubilee
 licenses:
 - MIT