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

data/lib/core/sock_js.rb

@@ -0,0 +1,116 @@
+# Copyright 2011 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.
+
+require 'core/streams'
+require 'core/ssl_support'
+module Vertx
+
+  # This is an implementation of the server side part of {"https://github.com/sockjs"}
+  #
+  # SockJS enables browsers to communicate with the server using a simple WebSocket-like api for sending
+  # and receiving messages. Under the bonnet SockJS chooses to use one of several protocols depending on browser
+  # capabilities and what appears to be working across the network.
+  #
+  # Available protocols include:
+  #
+  # WebSockets
+  # xhr-polling
+  # xhr-streaming
+  # json-polling
+  # event-source
+  # html-file
+  #
+  # This means, it should just work irrespective of what browser is being used, and whether there are nasty
+  # things like proxies and load balancers between the client and the server.
+  #
+  # For more detailed information on SockJS, see their website.
+  #
+  # On the server side, you interact using instances of {SockJSSocket} - this allows you to send data to the
+  # client or receive data via the {ReadStream#data_handler}.
+  #
+  # You can register multiple applications with the same SockJSServer, each using different path prefixes, each
+  # application will have its own handler, and configuration is described in a Hash.
+  #
+  # @author {http://tfox.org Tim Fox}
+  class SockJSServer
+
+    # Create a new SockJSServer
+    # @param http_server [HttpServer] You must pass in an instance of {HttpServer}
+    def initialize(http_server)
+      @j_server = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createSockJSServer(http_server._to_java_server)
+    end
+
+    # Install an application
+    # @param config [Hash] Configuration for the application
+    # @param proc [Proc] Proc representing the handler
+    # @param hndlr [Block] Handler to call when a new {SockJSSocket is created}
+    def install_app(config, proc = nil, &hndlr)
+      hndlr = proc if proc
+      j_config = org.vertx.java.core.json.JsonObject.new(config)
+      @j_server.installApp(j_config) { |j_sock|
+        hndlr.call(SockJSSocket.new(j_sock))
+      }
+      self
+    end
+
+    def bridge(config, inbound_permitted, outbound_permitted, auth_timeout = 5 * 60 * 1000, auth_address = nil)
+      j_inbound_permitted = org.vertx.java.core.json.JsonArray.new(inbound_permitted)
+      j_outbound_permitted = org.vertx.java.core.json.JsonArray.new(outbound_permitted)
+      @j_server.bridge(org.vertx.java.core.json.JsonObject.new(config), j_inbound_permitted,
+                       j_outbound_permitted, auth_timeout, auth_address)
+      self
+    end
+
+  end
+
+  # You interact with SockJS clients through instances of SockJS socket.
+  # The API is very similar to {WebSocket}. It implements both
+  # {ReadStream} and {WriteStream} so it can be used with {Pump} to enable
+  # flow control.
+  #
+  # @author {http://tfox.org Tim Fox}
+  class SockJSSocket
+
+    include ReadStream, WriteStream
+
+    # @private
+    def initialize(j_sock)
+      @j_del = j_sock
+      @handler_id = EventBus.register_simple_handler { |msg|
+        write(msg.body)
+      }
+    end
+
+    # Close the socket
+    def close
+      EventBus.unregister_handler(@handler_id)
+      @j_del.close
+    end
+
+    # When a SockJSSocket is created it automatically registers an event handler with the system, the ID of that
+    # handler is given by {#handler_id}.
+    # Given this ID, a different event loop can send a buffer to that event handler using the event bus. This
+    # allows you to write data to other SockJSSockets which are owned by different event loops.
+    def handler_id
+      @handler_id
+    end
+
+    # @private
+    def _to_java_socket
+      @j_del
+    end
+
+  end
+
+end

data/lib/{vertx → core}/ssl_support.rb

@@ -121,6 +121,26 @@ module Vertx
 
   end
 
+  # A mixin module allowing Server SSL attributes to be set on classes
+  #
+  # @author {http://tfox.org Tim Fox}
+  module ServerSSLSupport
+
+    def client_auth_required=(val)
+      @j_del.setClientAuthRequired(val)
+      self
+    end
+
+    def client_auth_required(val = nil)
+      if val
+        @j_del.setClientAuthRequired(val)
+        self
+      else
+        @j_del.isClientAuthRequired
+      end
+    end
+  end
+
   # A mixin module allowing Client SSL attributes to be set on classes
   #
   # @author {http://tfox.org Tim Fox}
@@ -140,4 +160,4 @@ module Vertx
       end
     end
   end
-end
+end

data/lib/{vertx → core}/streams.rb

@@ -14,21 +14,7 @@
 
 module Vertx
 
-  # A mixin module which represents a stream of data that can be written to.
-  #
-  # Any class that mixes in this module can be used by a {Pump} to pump data from a {ReadStream} to it.
-  #
-  # @author {http://tfox.org Tim Fox}
-  module WriteStream
-
-    # Write some data to the stream. The data is put on an internal write queue, and the write actually happens
-    # asynchronously. To avoid running out of memory by putting too much on the write queue,
-    # check the {#write_queue_full?} method before writing. This is done automatically if using a {Pump}.
-    # @param [Buffer]. The buffer to write.
-    def write(buff)
-      @j_del.write(buff._to_java_buffer)
-      self
-    end
+  module DrainSupport
 
     # Set the maximum size of the write queue. You will still be able to write to the stream even
     # if there is more data than this in the write queue. This is used as an indicator by classes such as
@@ -64,6 +50,25 @@ module Vertx
       @j_del.exceptionHandler(hndlr)
       self
     end
+  end
+
+  # A mixin module which represents a stream of data that can be written to.
+  #
+  # Any class that mixes in this module can be used by a {Pump} to pump data from a {ReadStream} to it.
+  #
+  # @author {http://tfox.org Tim Fox}
+  module WriteStream
+
+    include DrainSupport
+
+    # Write some data to the stream. The data is put on an internal write queue, and the write actually happens
+    # asynchronously. To avoid running out of memory by putting too much on the write queue,
+    # check the {#write_queue_full?} method before writing. This is done automatically if using a {Pump}.
+    # @param [Buffer]. The buffer to write.
+    def write(buff)
+      @j_del.write(buff._to_java_buffer)
+      self
+    end
 
     # @private
     def _to_write_stream
@@ -72,12 +77,8 @@ module Vertx
 
   end
 
-  # A mixin module which represents a stream of data that can be read from.
-  #
-  # Any class that mixes in this module can be used by a {Pump} to pump data from a {ReadStream} to it.
-  #
-  # @author {http://tfox.org Tim Fox}
-  module ReadStream
+
+  module ReadSupport
 
     # Set a data handler. As data is read, the handler will be called with the data.
     # @param [Block] hndlr. The data handler
@@ -106,6 +107,16 @@ module Vertx
       @j_del.exceptionHandler(hndlr)
       self
     end
+  end
+
+  # A mixin module which represents a stream of data that can be read from.
+  #
+  # Any class that mixes in this module can be used by a {Pump} to pump data from a {ReadStream} to it.
+  #
+  # @author {http://tfox.org Tim Fox}
+  module ReadStream
+
+    include ReadSupport
 
     # Set an end handler on the stream. Once the stream has ended, and there is no more data to be read, this handler will be called.
     # @param [Block] hndlr. The exception handler

data/lib/{vertx → core}/tcp_support.rb

@@ -13,47 +13,14 @@
 # limitations under the License.
 
 module Vertx
+  require 'core/network_support'
 
   # Mixin module that provides all the common TCP params that can be set.
   #
   # @author {http://tfox.org Tim Fox}
   module TCPSupport
 
-    # Set the TCP send buffer size.
-    # @param [FixNum] val. The size in bytes.
-    # @return [] A reference to self so invocations can be chained
-    def send_buffer_size=(val)
-      @j_del.setSendBufferSize(val)
-      self
-    end
-
-    # Set or get send buffer size for fluent API
-    def send_buffer_size(val = nil)
-      if val
-        @j_del.setSendBufferSize(val)
-        self
-      else
-        @j_del.getSendBufferSize
-      end
-    end
-
-    # Set the TCP receive buffer size.
-    # @param [FixNum] val. The size in bytes.
-    # @return [] A reference to self so invocations can be chained
-    def receive_buffer_size=(val)
-      @j_del.setReceiveBufferSize(val)
-      self
-    end
-
-    # Set or get send buffer size for fluent API
-    def send_receive_size(val = nil)
-      if val
-        @j_del.setReceiveBufferSize(val)
-        self
-      else
-        @j_del.getReceiveBufferSize
-      end
-    end
+    include NetworkSupport
 
     # Set the TCP keep alive setting.
     # @param [Boolean] val. If true, then TCP keep alive will be enabled.
@@ -147,4 +114,23 @@ module Vertx
 
   end
 
-end
+  module ServerTCPSupport
+    # Set the accept backlog
+    # @param [FixNum] val.
+    # @return [] A reference to self so invocations can be chained
+    def accept_backlog=(val)
+      @j_del.setAcceptBacklog(val)
+      self
+    end
+
+    # Set or get the accept backlog for fluent API
+    def accept_backlog(val = nil)
+      if val
+        @j_del.setAcceptBacklog(val)
+        self
+      else
+        @j_del.getAcceptBacklog
+      end
+    end
+  end
+end

data/lib/core/timers.rb

@@ -0,0 +1,73 @@
+# Copyright 2011 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.
+
+module Vertx
+
+  @@j_vertx = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx()
+
+  # Sets a one-shot timer that will fire after a certain delay.
+  # This method will accept either a Proc or a block.
+  # @param [FixNum] delay the delay, in milliseconds
+  # @param [Proc] proc a proc representing the code that will be run after the delay
+  # @param [Block] hndlr a block representing the code that will be run after the delay
+  # @return [FixNum] the unique id of the timer
+  def Vertx.set_timer(delay, proc = nil, &hndlr)
+    hndlr = proc if proc
+    @@j_vertx.setTimer(delay, hndlr)
+  end
+
+  # Sets a periodic timer.
+  # This method will accept either a Proc or a block.
+  # @param [FixNum] delay the period of the timer, in milliseconds
+  # @param [Proc] proc a proc representing the code that will be run when the timer fires
+  # @param [Block] hndlr a block representing the code that will be when the timer fires
+  # @return [FixNum] the unique id of the timer
+  def Vertx.set_periodic(delay, proc = nil, &hndlr)
+    hndlr = proc if proc
+    @@j_vertx.setPeriodic(delay, hndlr)
+  end
+
+  # Cancels a timer.
+  # @param [FixNum] id the id of the timer, as returned from {Vertx.set_timer} or {Vertx.set_periodic}
+  # @return [Boolean] true if the timer was cancelled, false if it wasn't found.
+  def Vertx.cancel_timer(id)
+    @@j_vertx.cancelTimer(id)
+  end
+
+  # Put the handler on the event queue for this loop so it will be run asynchronously
+  # ASAP after this event has been processed
+  # @param [Proc] proc a proc representing the code that will be run ASAP
+  # @param [Block] hndlr a block representing the code that will be run ASAP
+  def Vertx.run_on_context(proc = nil, &hndlr)
+    hndlr = proc if proc
+    @@j_vertx.runOnContext(hndlr)
+  end
+
+  # Get a reference to the current context
+  def Vertx.current_context
+    Context.new(@@j_vertx.currentContext())
+  end
+
+  class Context
+    # @private
+    def initialize(j_del)
+      @j_del = j_del
+    end
+
+    def run_on_context(&hndlr)
+      @j_del.runOnContext(hndlr)
+    end
+  end
+
+end

data/lib/core/vertx_require.rb

@@ -0,0 +1,25 @@
+# Redefine the require and load methods so we can make them synchronized
+
+require 'jruby/synchronized'
+
+module Kernel
+  # make an alias of the original require
+  alias_method :original_require, :require
+  alias_method :original_load, :load
+
+  def require name
+    org.vertx.java.platform.impl.JRubyVerticleFactory.requireCallback do
+      #puts "in require callback"
+      original_require name
+    end
+  end
+
+  def load name
+    org.vertx.java.platform.impl.JRubyVerticleFactory.requireCallback do
+      #puts "in require callback"
+      original_load name
+    end
+  end
+
+end
+

data/lib/jubilee.rb

@@ -1,11 +1,5 @@
-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-3.2.3.jar")
-require File.join(File.dirname(__FILE__), "../jars/vertx-core-2.1.1.jar")
-require File.join(File.dirname(__FILE__), "../jars/vertx-hazelcast-2.1.1.jar")
-require File.join(File.dirname(__FILE__), "../jars/vertx-platform-2.1.1.jar")
-require File.join(File.dirname(__FILE__), "../jars/netty-all-4.0.20.Final.jar")
+# this is only used when it's running as a rubygem
+Dir[File.expand_path("../../jars/*.jar", __FILE__)].each{|jar| require jar}
 
 require 'jubilee/jubilee.jar'
 require 'rack'
@@ -16,3 +10,6 @@ require 'jubilee/application'
 require 'jubilee/configuration'
 require 'jubilee/response'
 require 'rack/handler/jubilee'
+
+module Jubilee
+end

data/lib/jubilee/cli.rb

@@ -129,7 +129,7 @@ module Jubilee
         end
 
         o.on "-v", "--version", "Print the version information" do
-          puts "jubilee version #{Jubilee::Version::STRING} on Vert.x 2.1.1"
+          puts "jubilee version #{Jubilee::Version::STRING} on Vert.x 2.1.2"
           exit 0
         end
       end

data/lib/jubilee/jubilee_require.rb

@@ -0,0 +1,24 @@
+# Redefine the require and load methods so we can make them synchronized
+
+require 'jruby/synchronized'
+
+module Kernel
+  # make an alias of the original require
+  alias_method :original_require, :require
+  alias_method :original_load, :load
+
+  def require(*params)
+    org.vertx.java.platform.impl.JRubyVerticleFactory.requireCallback do
+      #puts "in require callback"
+      original_require(*params)
+    end
+  end
+
+  def load(*params)
+    org.vertx.java.platform.impl.JRubyVerticleFactory.requireCallback do
+      #puts "in require callback"
+      original_load(*params)
+    end
+  end
+
+end