jubilee 1.1.0-java

data/lib/jubilee/configuration.rb

@@ -0,0 +1,177 @@
+# -*- 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_accessor :config_file
+    attr_reader :options
+
+    def initialize(options, &block)
+      @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
+      @app ||= load_rack_adapter(@options, &@block)
+      if !@options[:quiet] and @options[:environment] == "development"
+        logger = @options[:logger] || STDOUT
+        Rack::CommonLogger.new(@app, logger)
+      else
+        @app
+      end
+    end
+
+    # 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
+      @options[:chdir] = path
+    end
+
+    # 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:8080/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
+
+    # 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
+    #
+    #    clustering true # enable cluster mode, default to "0.0.0.0:5701"
+    #    clustering "0.0.0.0"
+    #    clustering "0.0.0.0:5701"
+    #    clustering 5701
+    def clustering(address)
+      if addr == true
+        @options[:cluster_host] = "0.0.0.0"
+      else
+        @options[:cluster_host], @options[:cluster_port] = expand_addr(address)
+      end
+    end
+
+    # enable debug messages
+    def debug(bool)
+      set_bool(:debug, bool)
+    end
+
+    # 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
+    def load_rack_adapter(options, &block)
+      if block
+        inner_app = Rack::Builder.new(&block).to_app
+      else
+        if options[:rackup]
+          Kernel.load(options[:rackup])
+          inner_app = Object.const_get(File.basename(options[:rackup], '.rb').capitalize.to_sym).new
+        else
+          Dir.chdir options[:chdir] if options[:chdir]
+          inner_app, _ = Rack::Builder.parse_file "config.ru"
+        end
+      end
+      inner_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/const.rb

@@ -0,0 +1,40 @@
+module Jubilee
+  module Const
+    JUBILEE_VERSION = Version::STRING
+    HTTP_11 = "HTTP/1.1".freeze
+    HTTP_10 = "HTTP/1.0".freeze
+
+    SERVER_SOFTWARE = "SERVER_SOFTWARE".freeze
+    SERVER_PROTOCOL = "SERVER_PROTOCOL".freeze
+    GATEWAY_INTERFACE = "GATEWAY_INTERFACE".freeze
+    SERVER_NAME = "SERVER_NAME".freeze
+    SERVER_PORT = "SERVER_PORT".freeze
+
+    CGI_VER = "CGI/1.2".freeze
+
+    RACK_INPUT = "rack.input".freeze
+
+    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+    GET = 'GET'.freeze
+    POST = "POST".freeze
+    REQUEST_PATH = "REQUEST_PATH".freeze
+    REQUEST_URI = "REQUEST_URI".freeze
+    PATH_INFO = "PATH_INFO".freeze
+    QUERY_STRING = "QUERY_STRING".freeze
+
+    CONTENT_LENGTH = "Content-Length".freeze
+    TRANSFER_ENCODING = "Transfer-Encoding".freeze
+
+    HTTP_VERSION = "HTTP_VERSION".freeze
+    HTTP_HOST = "HTTP_HOST".freeze
+    HTTP_USER_AGENT = "HTTP_USER_AGENT".freeze
+    HTTP_ACCEPT = "HTTP_ACCEPT".freeze
+    HTTP_COOKIE = "HTTP_COOKIE".freeze
+    HTTP_ACCEPT_LANGUAGE = "HTTP_ACCEPT_LANGUAGE".freeze
+    HTTP_ACCEPT_ENCODING = "HTTP_ACCEPT_ENCODING".freeze
+    HTTP_CONNECTION = "HTTP_CONNECTION".freeze
+    NEWLINE = "\n".freeze
+
+    STATUS_WITH_NO_ENTITY_BODY = Hash[[204,205,304].map{|s| [s, true]}]
+  end
+end

data/lib/jubilee/response.rb

@@ -0,0 +1,69 @@
+require 'java'
+module Jubilee
+  class Response
+    include Const
+    include org.jruby.jubilee.RackResponse
+
+    def initialize(array)
+      @status, @headers, @body = *array
+      @status = @status.to_i
+      @content_length = nil
+      if @body.kind_of? Array and @body.size == 1
+        @content_length = @body[0].bytesize
+      end
+    end
+
+    # See Rack::Utils::
+    def respond(response)
+      no_body = @status < 200 || STATUS_WITH_NO_ENTITY_BODY[@status]
+      write_status(response)
+      write_headers(response)
+      if no_body
+        response.end
+      else 
+        if @body.respond_to?(:to_path)
+          response.send_file(@body.to_path)
+        else
+          write_body(response)
+          response.end
+        end
+      end
+    rescue NativeException => e
+      puts e
+    ensure
+      @body.close if @body.respond_to?(:close)
+    end
+
+    private
+    def write_status(response)
+      response.status_code = @status
+    end
+
+    def write_headers(response)
+      @headers.each do |key, values|
+        case key
+        when CONTENT_LENGTH
+          @content_length = values
+          next
+        when TRANSFER_ENCODING
+          @content_length = nil
+        end
+        # Multiple values are joined by \n
+        response.put_header(key, values)
+      end
+    end
+
+    def write_body(response)
+      response.put_default_headers
+      if @content_length
+        response.put_header(CONTENT_LENGTH, @content_length.to_s)
+      else
+        response.chunked = true
+      end
+
+      @body.each do |part|
+        response.write(part)
+      end
+    end
+  end
+end

data/lib/jubilee/server.rb

@@ -0,0 +1,12 @@
+require 'rack/methodoverride'
+module Jubilee
+  class Server < VertxServer
+    def initialize(app, opts = {})
+      options = {Port: 8080, ssl: false}.merge(opts)
+      if (options[:ssl]) && options[:keystore_path].nil?
+          raise ArgumentError, "Please provide a keystore for ssl"
+      end
+      super(Application.new(app), options)
+    end
+  end
+end

data/lib/jubilee/version.rb

@@ -0,0 +1,10 @@
+module Jubilee
+  module Version
+    MAJOR = 1
+    MINOR = 1
+    PATCH = 0
+    BUILD = nil
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+  end
+end

data/lib/rack/chunked.rb

@@ -0,0 +1,38 @@
+# Rails use this to chunk it's streaming response body, which we don't need
+module Rack
+  class Chunked
+    class Body
+      def initialize(body)
+        @body = body
+      end
+
+      def each
+        @body.each {|chunk| yield chunk}
+      end
+
+      def close
+        @body.close if @body.respond_to?(:close)
+      end
+    end
+
+    include Rack::Utils
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = HeaderHash.new(headers)
+
+      unless env['HTTP_VERSION'] == 'HTTP/1.0' ||
+           STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
+           headers['Content-Length'] ||
+           headers['Transfer-Encoding']
+        headers.delete('Content-Length')
+        headers.delete('Transfer-Encoding')
+      end
+      [status, headers, body]
+    end
+  end
+end

data/lib/rack/handler/jubilee.rb

@@ -0,0 +1,44 @@
+require 'rack/handler'
+require 'jubilee'
+require 'java'
+
+module Rack
+  module Handler
+    module Jubilee
+      DEFAULT_OPTIONS = {
+        :Host => '0.0.0.0',
+        :Port => 3000,
+        :Verbose => false
+      }
+      def self.run(app, options = {})
+        options = DEFAULT_OPTIONS.merge(options)
+
+        if options[:Verbose]
+          app = Rack::CommonLogger.new(app, STDOUT)
+        end
+
+        if options[:environment]
+          ENV["RACK_ENV"] = options[:environment].to_s
+        end
+
+        @server = ::Jubilee::Server.new(app, options)
+
+        puts "Jubilee #{::Jubilee::Const::JUBILEE_VERSION} starting..."
+        puts "* Environment: #{ENV['RACK_ENV']}"
+        puts "* Listening on http://#{options[:Host]}:#{options[:Port]}"
+
+        yield @server if block_given?
+
+        @server.start
+        @starter = org.jruby.jubilee.deploy.Starter.new
+        @starter.block
+      end
+
+      def self.shutdown
+        @server.stop{ @starter.unblock }
+        exit
+      end
+    end
+    register :jubilee, Jubilee
+  end
+end

data/lib/vertx.rb

@@ -0,0 +1,26 @@
+# 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.
+
+include Java
+
+require 'vertx/buffer'
+require 'vertx/event_bus'
+
+# This is the module for vertx related feature like EventBus and SharedData,
+# these features are built into jubilee server, by requiring 'vertx' in your
+# rack application, you get access to the functionalities offered by vertx
+# platform.
+
+module Vertx
+end

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.

data/lib/vertx/buffer.rb

@@ -0,0 +1,251 @@
+# 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.
+
+require 'vertx/shared_data'
+
+module Vertx
+
+  # A Buffer represents a sequence of zero or more bytes that can be written to or read from, and which expands
+  # as necessary to accomodate any bytes written to it.
+  #
+  # Buffers are used in many places in vert.x, for example to read/write data to/from {NetSocket}, {AsyncFile},
+  # {WebSocket}, {HttpClientRequest}, {HttpClientResponse}, {HttpServerRequest}, {HttpServerResponse} etc.
+  #
+  # There are two ways to write data to a Buffer: The first method involves methods that take the form set_XXX.
+  # These methods write data into the buffer starting at the specified position. The position does not have to be inside data that
+  # has already been written to the buffer; the buffer will automatically expand to encompass the position plus any data that needs
+  # to be written. All positions are measured in bytes and start with zero.
+  #
+  # The second method involves methods that take the form append-XXX; these methods append data at the end of the buffer.
+  # Methods exist to both set and append all primitive types, String and  other instances of Buffer.
+  #
+  # Data can be read from a buffer by invoking methods which take the form get_XXX. These methods take a parameter
+  # representing the position in the Buffer from where to read data.
+  #
+  # @author {http://tfox.org Tim Fox}
+  class Buffer
+
+    # @private
+    def initialize(j_buffer)
+      @buffer = j_buffer
+    end
+
+    # Creates a new empty buffer. The {#length} of the buffer immediately after creation will be zero.
+    # @param initial_size_hint [FixNum] is a hint to the system for how much memory
+    # to initially allocate to the buffer to prevent excessive automatic re-allocations as data is written to it.
+    def Buffer.create(initial_size_hint = 0)
+      Buffer.new(org.vertx.java.core.buffer.Buffer.new(initial_size_hint))
+    end
+
+    # Create a new Buffer from a String
+    # @param str [String] The String to encode into the Buffer
+    # @param enc [String] Encoding to use. Defaults to "UTF-8"
+    def Buffer.create_from_str(str, enc = "UTF-8")
+      Buffer.new(org.vertx.java.core.buffer.Buffer.new(str, enc))
+    end
+
+    # Return a String representation of the buffer.
+    # @param enc [String] The encoding to use. Defaults to "UTF-8"
+    # @return [String] a String representation of the buffer.
+    def to_s(enc = "UTF-8")
+      @buffer.toString(enc)
+    end
+
+    # Get the byte at position pos in the buffer.
+    # @param pos [FixNum] the position in the buffer from where to retrieve the byte
+    # @return [FixNum] the byte
+    def get_byte(pos)
+      @buffer.getByte(pos)
+    end
+
+    # Get the FixNum represented by a sequence of bytes starting at position pos in the buffer.
+    # @param pos [FixNum] the position in the buffer from where to retrieve the FixNum.
+    # @param bytes [FixNum] the number of bytes to retrieve from position pos to create the FixNum. Valid values are 1, 2, 4 and 8.
+    # @return [FixNum] the FixNum
+    def get_fixnum(pos, bytes)
+      case bytes
+        when 1
+          @buffer.getByte(pos)
+        when 2
+          @buffer.getShort(pos)
+        when 4
+          @buffer.getInt(pos)
+        when 8
+          @buffer.getLong(pos)
+        else
+          raise "bytes must be 1, 2, 4, or 8"
+      end
+    end
+
+    # Get the Float represented by a sequence of bytes starting at position pos in the buffer.
+    # @param pos [Float] the position in the buffer from where to retrieve the Float.
+    # @param bytes [Float] the number of bytes to retrieve from position pos to create the Float. Valid values are 4 and 8.
+    # @return [Float] the Float
+    def get_float(pos, bytes)
+      case bytes
+        when 4
+          @buffer.getFloat(pos)
+        when 8
+          @buffer.getDouble(pos)
+        else
+          raise "bytes must be 4 or 8"
+      end
+    end
+
+    # Return bytes from the buffer interpreted as a String
+    # @param pos [FixNum] the position in the buffer from where to start reading
+    # @param end_pos [FixNum] the position in the buffer to end reading
+    # @param enc [String] The encoding to use
+    # @return [String] the String
+    def get_string(pos, end_pos, enc = 'UTF-8')
+      @buffer.getString(pos, end_pos, enc)
+    end
+
+    # Return bytes in the buffer as a Buffer
+    # @param start_pos [FixNum] - the position in this buffer from where to start the copy.
+    # @param end_pos [FixNum] - the copy will be made up to index end_pos - 1
+    # @return [Buffer] the copy
+    def get_buffer(pos, end_pos)
+      j_buff = @buffer.getBuffer(pos, end_pos)
+      Buffer.new(j_buff)
+    end
+
+    # Appends another buffer to the end of this buffer. The buffer will expand as necessary to accomodate any bytes
+    # written.
+    # @param buff [Buffer] the buffer to append.
+    # @return [Buffer] a reference to self so multiple operations can be appended together.
+    def append_buffer(buff)
+      @buffer.appendBuffer(buff._to_java_buffer)
+      self
+    end
+
+    # Appends a FixNum to the end of this buffer. The buffer will expand as necessary to accomodate any bytes written.
+    # @param num [FixNum] the fixnum to append.
+    # @param bytes [FixNum] the number of bytes to write in the buffer to represent the fixnum. Valid values are 1, 2, 4 and 8.
+    # @return [Buffer] a reference to self so multiple operations can be appended together.
+    def append_fixnum(num, bytes)
+      case bytes
+        when 1
+          @buffer.appendByte(num)
+        when 2
+          @buffer.appendShort(num)
+        when 4
+          @buffer.appendInt(num)
+        when 8
+          @buffer.appendLong(num)
+        else
+          raise "bytes must be 1, 2, 4, or 8"
+      end
+      self
+    end
+
+    # Appends a Float to the end of this buffer. The buffer will expand as necessary to accomodate any bytes written.
+    # @param num [Float] the float to append.
+    # @param bytes [FixNum] the number of bytes to write in the buffer to represent the float. Valid values are 4 and 8.
+    # @return [Buffer] a reference to self so multiple operations can be appended together.
+    def append_float(num, bytes)
+      case bytes
+        when 4
+          @buffer.appendFloat(num)
+        when 8
+          @buffer.appendDouble(num)
+        else
+          raise "bytes must be 4 or 8"
+      end
+    end
+
+    # Appends a string to the end of this buffer. The buffer will expand as necessary to accomodate any bytes written.
+    # @param str [String] the string to append.
+    # @param enc [String] the encoding to use. Defaults to "UTF-8"
+    # @return [Buffer] a reference to self so multiple operations can be appended together.
+    def append_str(str, enc = "UTF-8")
+      @buffer.appendString(str, enc)
+      self
+    end
+
+    # Sets bytes in the buffer to a representation of a FixNum. The buffer will expand as necessary to accomodate any bytes written.
+    # @param pos [FixNum] - the position in the buffer from where to start writing the FixNum
+    # @param num [FixNum]  - the FixNum to write
+    # @param bytes [FixNum] - the number of bytes to write to represent the FixNum. Valid values are 1, 2, 4, and 8
+    # @return [Buffer] a reference to self so multiple operations can be appended together.
+    def set_fixnum(pos, num, bytes)
+      case bytes
+        when 1
+          @buffer.setByte(pos, num)
+        when 2
+          @buffer.setShort(pos, num)
+        when 4
+          @buffer.setInt(pos, num)
+        when 8
+          @buffer.setLong(pos, num)
+        else
+          raise "bytes must be 1, 2, 4, or 8"
+      end
+      self
+    end
+
+    # Sets bytes in the buffer to a representation of a Float. The buffer will expand as necessary to accomodate any bytes written.
+    # @param pos [FixNum] - the position in the buffer from where to start writing the Float
+    # @param num [Float]  - the Float to write
+    # @param bytes [FixNum] - the number of bytes to write to represent the Float. Valid values are 4 and 8
+    # @return [Buffer] a reference to self so multiple operations can be appended together.
+    def set_float(pos, num, bytes)
+      case bytes
+        when 4
+          @buffer.setFloat(pos, num)
+        when 8
+          @buffer.setDouble(pos, num)
+        else
+          raise "bytes must be 4 or 8"
+      end
+      self
+    end
+
+    # Sets bytes in this buffer to the bytes of the specified buffer. The buffer will expand as necessary to accomodate any bytes written.
+    # @param pos [FixNum] - the position in this buffer from where to start writing the buffer
+    # @param buff [Buffer] - the buffer to write into this buffer
+    # @return [Buffer] a reference to self so multiple operations can be appended together.
+    def set_buffer(pos, buff)
+      @buffer.setBytes(pos, buff._to_java_buffer)
+      self
+    end
+
+    # Set bytes in the buffer to the string encoding in the specified encoding
+    # @param pos [FixNum] - the position in this buffer from where to start writing the string
+    # @param str [String] the string
+    # @param enc [String] the encoding
+    # @return [Buffer] a reference to self so multiple operations can be appended together.
+    def set_string(pos, str, enc = 'UTF-8')
+      @buffer.setString(pos, str, enc)
+      self
+    end
+
+    # @return [FixNum] the length of this buffer, in bytes.
+    def length
+      @buffer.length
+    end
+
+    # Get a copy of the entire buffer.
+    # @return [Buffer] the copy
+    def copy
+      Buffer.new(@buffer.copy())
+    end
+
+    # @private
+    def _to_java_buffer
+      @buffer
+    end
+
+  end
+end