jubilee 2.0.0.beta-java → 2.0.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb61786745898bab811507f1d76d6bbdc77e5485
-  data.tar.gz: 03df7c9f9b145f2287a1b453aef1e1159a85a899
+  metadata.gz: 31e24331a936300e3f3bb67b16e5b05376fcb2aa
+  data.tar.gz: 22ec68885ddfd56a2b0d42fe1be450e40d596e7b
 SHA512:
-  metadata.gz: 707de86b4d5b2bda6e5a10726209642f7d703533b59e7b6069683efa4202b960213118a384771150f27d2fa4848547641abb273788f5d64397dee5ca247ac362
-  data.tar.gz: a2fa31e40c0dae6c7e4e023c3293c157fd54984530277bdc1c586abee40ed6f078ddf228067bf0de2a554d78686954a35c5bb489913018844e07180d0a509b56
+  metadata.gz: ad993339e4c2e8ff3314c17836fd8902c83db105b86554b88d90bc38d0117d25548919dcad367cd204f013b39639d4a94191b50d158f5d836906fe045b5d9b5f
+  data.tar.gz: 8e3144d4805b226a6e82da0f01ec069402cf21d050eb0df1af16ab89e4dd42c1885c82de3c88ad1773fc46be3d6a5147efbcf470bc1f995a587f8d658067554b

data/examples/chatapp/Gemfile

@@ -2,4 +2,4 @@ source "https://rubygems.org"
 gem 'sinatra'
 gem 'haml'
 
-gem 'jubilee', '2.0.0.alpha1'
+gem 'jubilee', '2.0.0.beta'

data/examples/chatapp/Gemfile.lock

@@ -4,7 +4,7 @@ GEM
     ffi (1.9.3-java)
     haml (4.0.4)
       tilt
-    jubilee (2.0.0.alpha1-java)
+    jubilee (2.0.0.beta-java)
       rack (>= 1.4.1)
       spoon (~> 0.0.4)
     rack (1.5.2)
@@ -23,5 +23,5 @@ PLATFORMS
 
 DEPENDENCIES
   haml
-  jubilee (= 2.0.0.alpha1)
+  jubilee (= 2.0.0.beta)
   sinatra

data/lib/jubilee/version.rb

@@ -3,7 +3,7 @@ module Jubilee
     MAJOR = 2
     MINOR = 0
     PATCH = 0
-    BUILD = "beta"
+    BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
   end

data/lib/vertx.rb

@@ -16,6 +16,7 @@ include Java
 
 require 'vertx/buffer'
 require 'vertx/event_bus'
+require 'vertx/http'
 
 # This is the module for vertx related feature like EventBus and SharedData,
 # these features are built into jubilee server, by requiring 'vertx' in your

data/lib/vertx/http.rb

@@ -0,0 +1,677 @@
+# 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 'vertx/streams'
+require 'vertx/ssl_support'
+require 'vertx/tcp_support'
+require 'vertx/wrapped_handler'
+
+module Vertx
+  # An HTTP client.
+  # A client maintains a pool of connections to a specific host, at a specific port. The HTTP connections can act
+  # as pipelines for HTTP requests.
+  # It is used as a factory for {HttpClientRequest} instances which encapsulate the actual HTTP requests. It is also
+  # used as a factory for {WebSocket WebSockets}.
+  #
+  # @author {http://tfox.org Tim Fox}
+  class HttpClient
+
+    include SSLSupport, ClientSSLSupport, TCPSupport
+
+    # Create a new HttpClient
+    def initialize(config = {})
+      @j_del = org.jruby.jubilee.vertx.JubileeVertx.vertx().createHttpClient()
+      self.compression = config[:try_compression] if config.has_key?(:try_compression)
+    end
+
+    # Enables HTTP compression.
+    # exposes a = method to set or unset compression support.
+    # @param [Boolean] supported whether enable compression or not
+    def compression=(supported)
+      @j_del.setTryUseCompression(supported)
+    end
+
+    # Tests if client is trying to use HTTP compression or not
+    # @return [Boolean] true if Client is trying using HTTP compression, false if it doesn't
+    def compression
+      @j_del.getTryUseCompression
+    end
+
+    # Letting the developer choose between compression? or compression while developing
+    alias_method :compression?, :compression
+
+    # Set the exception handler.
+    # @param [Block] hndlr A block to be used as the handler
+    def exception_handler(&hndlr)
+      @j_del.exceptionHandler(hndlr)
+      self
+    end
+
+    # Set the maximum pool size.
+    # The client will maintain up to this number of HTTP connections in an internal pool
+    # @param [FixNum] val. The maximum number of connections (default to 1).
+    def max_pool_size=(val)
+      @j_del.setMaxPoolSize(val)
+      self
+    end
+
+    # Get or set the max pool size
+    def max_pool_size(val = nil)
+      if val
+        @j_del.setMaxPoolSize(val)
+        self
+      else
+        @j_del.getMaxPoolSize
+      end
+    end
+
+    # If val is true then, after the request has ended the connection will be returned to the pool
+    # where it can be used by another request. In this manner, many HTTP requests can be pipe-lined over an HTTP connection.
+    # Keep alive connections will not be closed until the {#close} method is invoked.
+    # If val is false then a new connection will be created for each request and it won't ever go in the pool,
+    # the connection will closed after the response has been received. Even with no keep alive, the client will not allow more
+    # than {#max_pool_size} connections to be created at any one time.
+    # @param [Boolean] val. The value to use for keep_alive
+    def keep_alive=(val)
+      @j_del.setTCPKeepAlive(val)
+      self
+    end
+
+    # Get or set keep alive
+    def keep_alive(val = nil)
+      if val
+        @j_del.setKeepAlive(val)
+        self
+      else
+        @j_del.isKeepAlive
+      end
+    end
+
+    # Set the port that the client will attempt to connect to on the server on. The default value is 80
+    # @param [FixNum] val. The port value.
+    def port=(val)
+      @j_del.setPort(val)
+      self
+    end
+
+    # Get or set port
+    def port(val = nil)
+      if val
+        @j_del.setPort(val)
+        self
+      else
+        @j_del.getPort
+      end
+    end
+
+    # Set the host name or ip address that the client will attempt to connect to on the server on.
+    # @param [String] host. The host name or ip address to connect to.
+    def host=(val)
+      @j_del.setHost(val)
+      self
+    end
+
+    # Get or set host
+    def host(val = nil)
+      if val
+        @j_del.setHost(val)
+        self
+      else
+        @j_del.getHost
+      end
+    end
+
+    # Get or set verify host
+    def verify_host(val = nil)
+      if val
+        @j_del.setVerifyHost(val)
+        self
+      else
+        @j_del.isVerifyHost
+      end
+    end
+
+    # Gets the max WebSocket Frame size in bytes
+    # @return [int] Max WebSocket frame size
+    def max_websocket_frame_size
+      @j_del.getMaxWebSocketFrameSize
+    end
+
+    # Sets the maximum WebSocket frame size in bytes. Default is 65536 bytes.
+    # @param [int] size
+    def max_websocket_frame_size=(size)
+      @j_del.setMaxWebSocketFrameSize(size)
+    end
+
+    # Attempt to connect a WebSocket to the specified URI.
+    # The connect is done asynchronously and the handler is called with a  {WebSocket} on success.
+    # @param [String] uri. A relative URI where to connect the WebSocket on the host, e.g. /some/path
+    # @param [Block] hndlr. The handler to be called with the {WebSocket}
+    def connect_web_socket(uri, &hndlr)
+      @j_del.connectWebsocket(uri) { |j_ws| hndlr.call(WebSocket.new(j_ws)) }
+      self
+    end
+
+    # This is a quick version of the {#get} method where you do not want to do anything with the request
+    # before sending.
+    # Normally with any of the HTTP methods you create the request then when you are ready to send it you call
+    # {HttpClientRequest#end} on it. With this method the request is immediately sent.
+    # When an HTTP response is received from the server the handler is called passing in the response.
+    # @param [String] uri. A relative URI where to perform the GET on the server.
+    # @param [Hash] headers. A Hash of headers to pass with the request.
+    # @param [Block] hndlr. The handler to be called with the {HttpClientResponse}
+    def get_now(uri, headers = nil, &hndlr)
+      @j_del.getNow(uri, headers, resp_handler(hndlr))
+      self
+    end
+
+    # This method returns an {HttpClientRequest} instance which represents an HTTP OPTIONS request with the specified uri.
+    # When an HTTP response is received from the server the handler is called passing in the response.
+    # @param [String] uri. A relative URI where to perform the OPTIONS on the server.
+    # @param [Block] hndlr. The handler to be called with the {HttpClientResponse}
+    def options(uri, &hndlr)
+      HttpClientRequest.new(@j_del.options(uri, resp_handler(hndlr)))
+    end
+
+    # This method returns an {HttpClientRequest} instance which represents an HTTP GET request with the specified uri.
+    # When an HTTP response is received from the server the handler is called passing in the response.
+    # @param [String] uri. A relative URI where to perform the GET on the server.
+    # @param [Block] hndlr. The handler to be called with the {HttpClientResponse}
+    def get(uri, &hndlr)
+      HttpClientRequest.new(@j_del.get(uri, resp_handler(hndlr)))
+    end
+
+    # This method returns an {HttpClientRequest} instance which represents an HTTP HEAD request with the specified uri.
+    # When an HTTP response is received from the server the handler is called passing in the response.
+    # @param [String] uri. A relative URI where to perform the HEAD on the server.
+    # @param [Block] hndlr. The handler to be called with the {HttpClientResponse}
+    def head(uri, &hndlr)
+      HttpClientRequest.new(@j_del.head(uri, resp_handler(hndlr)))
+    end
+
+    # This method returns an {HttpClientRequest} instance which represents an HTTP POST request with the specified uri.
+    # When an HTTP response is received from the server the handler is called passing in the response.
+    # @param [String] uri. A relative URI where to perform the POST on the server.
+    # @param [Block] hndlr. The handler to be called with the {HttpClientResponse}
+    def post(uri, &hndlr)
+      HttpClientRequest.new(@j_del.post(uri, resp_handler(hndlr)))
+    end
+
+    # This method returns an {HttpClientRequest} instance which represents an HTTP PUT request with the specified uri.
+    # When an HTTP response is received from the server the handler is called passing in the response.
+    # @param [String] uri. A relative URI where to perform the PUT on the server.
+    # @param [Block] hndlr. The handler to be called with the {HttpClientResponse}
+    def put(uri, &hndlr)
+      HttpClientRequest.new(@j_del.put(uri, resp_handler(hndlr)))
+    end
+
+    # This method returns an {HttpClientRequest} instance which represents an HTTP DELETE request with the specified uri.
+    # When an HTTP response is received from the server the handler is called passing in the response.
+    # @param [String] uri. A relative URI where to perform the DELETE on the server.
+    # @param [Block] hndlr. The handler to be called with the {HttpClientResponse}
+    def delete(uri, &hndlr)
+      HttpClientRequest.new(@j_del.delete(uri, resp_handler(hndlr)))
+    end
+
+    # This method returns an {HttpClientRequest} instance which represents an HTTP TRACE request with the specified uri.
+    # When an HTTP response is received from the server the handler is called passing in the response.
+    # @param [String] uri. A relative URI where to perform the TRACE on the server.
+    # @param [Block] hndlr. The handler to be called with the {HttpClientResponse}
+    def trace(uri, &hndlr)
+      HttpClientRequest.new(@j_del.trace(uri, resp_handler(hndlr)))
+    end
+
+    # This method returns an {HttpClientRequest} instance which represents an HTTP CONNECT request with the specified uri.
+    # When an HTTP response is received from the server the handler is called passing in the response.
+    # @param [String] uri. A relative URI where to perform the CONNECT on the server.
+    # @param [Block] hndlr. The handler to be called with the {HttpClientResponse}
+    def connect(uri, &hndlr)
+      HttpClientRequest.new(@j_del.connect(uri, resp_handler(hndlr)))
+    end
+
+    # This method returns an {HttpClientRequest} instance which represents an HTTP PATCH request with the specified uri.
+    # When an HTTP response is received from the server the handler is called passing in the response.
+    # @param [String] uri. A relative URI where to perform the PATCH on the server.
+    # @param [Block] hndlr. The handler to be called with the {HttpClientResponse}
+    def patch(uri, &hndlr)
+      HttpClientRequest.new(@j_del.patch(uri, resp_handler(hndlr)))
+    end
+
+    # This method returns an {HttpClientRequest} instance which represents an HTTP request with the specified method and uri.
+    # When an HTTP response is received from the server the handler is called passing in the response.
+    # @param [String] method. The HTTP method. Can be one of OPTIONS, HEAD, GET, POST, PUT, DELETE, TRACE, CONNECT.
+    # @param [String] uri. A relative URI where to perform the OPTIONS on the server.
+    # @param [Block] hndlr. The handler to be called with the {HttpClientResponse}
+    def request(method, uri, &hndlr)
+      HttpClientRequest.new(@j_del.request(method, uri, resp_handler(hndlr)))
+    end
+
+    # Close the client. Any unclosed connections will be closed.
+    def close
+      @j_del.close
+    end
+
+    # @private
+    def resp_handler(hndlr)
+      Proc.new { |j_del| hndlr.call(HttpClientResponse.new(j_del)) }
+    end
+
+    private :resp_handler
+
+  end
+
+  # Encapsulates a client-side HTTP request.
+  #
+  # Instances of this class are created by an {HttpClient} instance, via one of the methods corresponding to the
+  # specific HTTP methods, or the generic {HttpClient#request} method.
+  #
+  # Once an instance of this class has been obtained, headers can be set on it, and data can be written to its body,
+  # if required. Once you are ready to send the request, the {#end} method must called.
+  #
+  # Nothing is sent until the request has been internally assigned an HTTP connection. The {HttpClient} instance
+  # will return an instance of this class immediately, even if there are no HTTP connections available in the pool. Any requests
+  # sent before a connection is assigned will be queued internally and actually sent when an HTTP connection becomes
+  # available from the pool.
+  #
+  # The headers of the request are actually sent either when the {#end} method is called, or, when the first
+  # part of the body is written, whichever occurs first.
+  #
+  # This class supports both chunked and non-chunked HTTP.
+  #
+  # @author {http://tfox.org Tim Fox}
+  class HttpClientRequest
+
+    include WriteStream
+
+    # @private
+    def initialize(j_del)
+      @j_del = j_del
+    end
+
+    # MultiMap of headers for the request
+    def headers
+      if !@headers
+        @headers = MultiMap.new(@j_del.headers)
+      end
+      @headers
+    end
+
+    # Inserts a header into the request.
+    # @param [String] key The header key
+    # @param [Object] value The header value. to_s will be called on the value to determine the actual String value to insert.
+    # @return [HttpClientRequest] self So multiple operations can be chained.
+    def put_header(key, value)
+      @j_del.putHeader(key, value.to_s)
+      self
+    end
+
+    # Write a [String] to the request body.
+    # @param [String] str. The string to write.
+    # @param [String] enc. The encoding to use.
+    # @return [HttpClientRequest] self So multiple operations can be chained.
+    def write_str(str, enc = "UTF-8")
+      @j_del.write(str, enc)
+      self
+    end
+
+    # Forces the head of the request to be written before {#end} is called on the request. This is normally used
+    # to implement HTTP 100-continue handling, see {#continue_handler} for more information.
+    # @return [HttpClientRequest] self So multiple operations can be chained.
+    def send_head
+      @j_del.sendHead
+      self
+    end
+
+    # Ends the request. If no data has been written to the request body, and {#send_head} has not been called then
+    # the actual request won't get written until this method gets called.
+    # Once the request has ended, it cannot be used any more, and if keep alive is true the underlying connection will
+    # be returned to the {HttpClient} pool so it can be assigned to another request.
+    def end
+      @j_del.end
+      self
+    end
+
+    # Same as {#write_buffer_and_end} but writes a String
+    # @param [String] str The String to write
+    # @param [String] enc The encoding
+    def write_str_and_end(str, enc = "UTF-8")
+      @j_del.end(str, enc)
+      self
+    end
+
+    # Same as {#end} but writes some data to the response body before ending. If the response is not chunked and
+    # no other data has been written then the Content-Length header will be automatically set
+    # @param [Buffer] chunk The Buffer to write
+    def write_buffer_and_end(chunk)
+      @j_del.end(chunk._to_java_buffer)
+      self
+    end
+
+    # Sets whether the request should used HTTP chunked encoding or not.
+    # @param [Boolean] val. If val is true, this request will use HTTP chunked encoding, and each call to write to the body
+    # will correspond to a new HTTP chunk sent on the wire. If chunked encoding is used the HTTP header
+    # 'Transfer-Encoding' with a value of 'Chunked' will be automatically inserted in the request.
+    # If chunked is false, this request will not use HTTP chunked encoding, and therefore if any data is written the
+    # body of the request, the total size of that data must be set in the 'Content-Length' header before any
+    # data is written to the request body.
+    # @return [HttpClientRequest] self So multiple operations can be chained.
+    def chunked=(val)
+      @j_del.setChunked(val)
+      self
+    end
+
+    # Get or set chunked
+    def chunked(val = nil)
+      if val
+        @j_del.setChunked(val)
+        self
+      else
+        @j_del.getChunked
+      end
+    end
+
+    # If you send an HTTP request with the header 'Expect' set to the value '100-continue'
+    # and the server responds with an interim HTTP response with a status code of '100' and a continue handler
+    # has been set using this method, then the handler will be called.
+    # You can then continue to write data to the request body and later end it. This is normally used in conjunction with
+    # the {#send_head} method to force the request header to be written before the request has ended.
+    # @param [Block] hndlr. The handler
+    def continue_handler(&hndlr)
+      @j_del.continueHandler(hndlr)
+      self
+    end
+
+    # Get or set timeout
+    def timeout(val = nil)
+      if val
+        @j_del.setTimeout(val)
+        self
+      else
+        @j_del.getTimeout
+      end
+    end
+
+  end
+
+  # Encapsulates a client-side HTTP response.
+  #
+  # An instance of this class is provided to the user via a handler that was specified when one of the
+  # HTTP method operations, or the generic {HttpClient#request} method was called on an instance of {HttpClient}.
+  #
+  # @author {http://tfox.org Tim Fox}
+  class HttpClientResponse
+
+    include ReadStream
+
+    # @private
+    def initialize(j_del)
+      @j_del = j_del
+    end
+
+    # @return [FixNum] the HTTP status code of the response.
+    def status_code
+      @j_del.statusCode
+    end
+
+    # @return [String] the status message
+    def status_message
+      @j_del.statusMessage
+    end
+
+    # Get a header value
+    # @param [String] key. The key of the header.
+    # @return [String] the header value.
+    def header(key)
+      @j_del.getHeader(key)
+    end
+
+    # Get all the headers in the response.
+    # @return [MultiMap]. The headers
+    def headers
+      if !@headers
+        @headers = MultiMap.new(@j_del.headers)
+      end
+      @headers
+    end
+
+    # Get all the trailers in the response.
+    # @return [MultiMap]. The trailers
+    def trailers
+      if !@trailers
+        @trailers = MultiMap.new(@j_del.trailers)
+      end
+      @trailers
+    end
+
+    # Get all cookies
+    def cookies
+      if !@cookies
+        @cookies = @j_del.cookies
+      end
+      @cookies
+    end
+
+    # Set a handler to receive the entire body in one go - do not use this for large bodies
+    def body_handler(&hndlr)
+      @j_del.bodyHandler(hndlr)
+      self
+    end
+
+  end
+
+  # Represents a WebSocket.
+  #
+  # Instances of this class are created by an {HttpClient} instance when a client succeeds in a WebSocket handshake with a server.
+  # Once an instance has been obtained it can be used to send or receive buffers of data from the connection,
+  # a bit like a TCP socket.
+  #
+  # @author {http://tfox.org Tim Fox}
+  class WebSocket
+
+    include ReadStream, WriteStream
+
+    # @private
+    def initialize(j_ws)
+      @j_del = j_ws
+      @binary_handler_id = EventBus.register_simple_handler { |msg|
+        write_binary_frame(msg.body)
+      }
+      @text_handler_id = EventBus.register_simple_handler { |msg|
+        write_text_frame(msg.body)
+      }
+      @j_del.closeHandler(Proc.new {
+        EventBus.unregister_handler(@binary_handler_id)
+        EventBus.unregister_handler(@text_handler_id)
+        @close_handler.call if @close_handler
+      })
+    end
+
+    # Write data to the WebSocket as a binary frame
+    # @param [Buffer] buffer. Data to write.
+    def write_binary_frame(buffer)
+      @j_del.writeBinaryFrame(buffer._to_java_buffer)
+      self
+    end
+
+    # Write data to the WebSocket as a text frame
+    # @param [String] str. String to write.
+    def write_text_frame(str)
+      @j_del.writeTextFrame(str)
+      self
+    end
+
+    # Close the WebSocket
+    def close
+      @j_del.close
+    end
+
+    # When a Websocket is created it automatically registers an event handler with the system, the ID of that
+    # handler is given by {#binary_handler_id}.
+    # Given this ID, a different event loop can send a binary frame to that event handler using the event bus. This
+    # allows you to write data to other WebSockets which are owned by different event loops.
+    def binary_handler_id
+      @binary_handler_id
+    end
+
+    # When a Websocket is created it automatically registers an event handler with the system, the ID of that
+    # handler is given by {#text_handler_id}.
+    # Given this ID, a different event loop can send a text frame to that event handler using the event bus. This
+    # allows you to write data to other WebSockets which are owned by different event loops.
+    def text_handler_id
+      @text_handler_id
+    end
+
+    # Set a closed handler on the WebSocket.
+    # @param [Block] hndlr A block to be used as the handler
+    def close_handler(&hndlr)
+      @close_handler = hndlr;
+    end
+
+  end
+
+  # A map which can hold multiple values for one name / key
+  #
+  # @author Norman Maurer
+  class MultiMap
+
+    # @private
+    def initialize(j_map)
+      @j_map = j_map
+    end
+
+    # Call the handler for each header name and its value. If there are multiple values are stored for
+    # a header name it will be called for each of them
+    #
+    def each(&hndlr)
+      names.each do |name|
+        values = @j_map.getAll(name)
+        for v in values
+          hndlr.call(name, v)
+        end
+      end
+    end
+
+    # Returns the value of with the specified name.  If there are
+    # more than one values for the specified name, the first value is returned.
+    #
+    # @param name The name of the header to search
+    # @return The first header value or nil if there is no such entry
+    def get(name)
+      @j_map.get(name)
+    end
+
+    # Returns the value of with the specified name.  If there are
+    # more than one values for the specified name, the first value is returned.
+    #
+    # @param name The name of the header to search
+    # @return The first header value or nil if there is no such entry
+    def [](name)
+      @j_map.get(name)
+    end
+
+
+    # Set a value with the specified name and value.
+    #
+    # @param name The name
+    # @param value The value being added
+    # @return self
+    def []=(name, value)
+      @j_map.set(name, value)
+      self
+    end
+
+    # Returns the values with the specified name
+    #
+    # @param name The name to search
+    # @return [Array] A immutable array of values which will be empty if no values
+    #         are found
+    def get_all(name)
+      @j_map.getAll(name).to_a
+    end
+
+    # Returns true if an entry with the given name was found
+    def contains(name)
+      @j_map.contains(name)
+    end
+
+    # Returns true if the map is empty
+    def empty?
+      @j_map.isEmpty()
+    end
+
+    # Return a Set which holds all names of the entries
+    #
+    # @return [Set] The set which holds all names or an empty set if it is empty
+    def names
+     @j_map.names()
+    end
+
+
+    # Adds a new value with the specified name and value.
+    #
+    # @param name The name
+    # @param value The value being added
+    # @return self
+    def add(name, value)
+      @j_map.add(name, value)
+      self
+    end
+
+    # Set a value with the specified name and value.
+    #
+    # @param name The name
+    # @param value The value being added
+    # @return self
+    def set(name, value)
+      @j_map.set(name, value)
+      self
+    end
+
+    # Set a value with the specified name and value.
+    #
+    # @param name The name
+    # @param value The value being added
+    # @return self
+    def set_all(map)
+      @j_map.set(map._j_map)
+      self
+    end
+
+    # Remove the values with the given name
+    #
+    # @param name The name
+    # @return self
+    def remove(name)
+      @j_map.remove(name)
+      self
+    end
+
+    # Remove all entries
+    #
+    # @return self
+    def clear
+      @j_map.clear()
+      self
+    end
+
+    # Return the number of names in this instance
+    def size
+      @j_map.size()
+    end
+
+    def _j_map
+      @j_map
+    end
+  end
+end

data/lib/vertx/ssl_support.rb

@@ -0,0 +1,143 @@
+# 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
+
+  # A mixin module allowing SSL attributes to be set on classes
+  #
+  # @author {http://tfox.org Tim Fox}
+  module SSLSupport
+
+    # Set whether the server or client will use SSL.
+    # @param [Boolean] val. If true then ssl will be used.
+    # @return [] self. So multiple invocations can be chained.
+    def ssl=(val)
+      @j_del.setSSL(val)
+      self
+    end
+
+    # Set or get ssl for fluent API
+    def ssl(ssl = nil)
+      if ssl
+        @j_del.setSSL(ssl)
+        self
+      else
+        @j_del.isSSL
+      end
+    end
+
+    # Set the path to the SSL key store. This method should only be used with the client/server in SSL mode, i.e. after {#ssl=}
+    # has been set to true.
+    # The SSL key store is a standard Java Key Store, and should contain the client/server certificate. For a client, it's only necessary to supply
+    # a client key store if the server requires client authentication via client certificates.
+    # @param [String] val. The path to the key store
+    # @return [] self. So multiple invocations can be chained.
+    def key_store_path=(val)
+      @j_del.setKeyStorePath(val)
+      self
+    end
+
+    # Set or get key store path for fluent API
+    def key_store_path(path = nil)
+      if path
+        @j_del.setKeyStorePath(path)
+        self
+      else
+        @j_del.getKeyStorePath
+      end
+    end
+
+    # Set the password for the SSL key store. This method should only be used with the client in SSL mode, i.e. after {#ssl=}
+    # has been set to true.
+    # @param [String] val. The password.
+    # @return [] self. So multiple invocations can be chained.
+    def key_store_password=(val)
+      @j_del.setKeyStorePassword(val)
+      self
+    end
+
+    # Set or get key store password for fluent API
+    def key_store_password(password = nil)
+      if password
+        @j_del.setKeyStorePassword(password)
+        self
+      else
+        @j_del.getKeyStorePassword
+      end
+    end
+
+    # Set the path to the SSL trust store. This method should only be used with the client/server in SSL mode, i.e. after {#ssl=}
+    # has been set to true.
+    # The SSL trust store is a standard Java Key Store, and should contain the certificate(s) of the clients/servers that the server/client trusts. The SSL
+    # handshake will fail if the server provides a certificate that the client does not trust, or if client authentication is used,
+    # if the client provides a certificate the server does not trust.<p>
+    # @param [String] val. The path to the trust store
+    # @return [] self. So multiple invocations can be chained.
+    def trust_store_path=(val)
+      @j_del.setTrustStorePath(val)
+      self
+    end
+
+    # Set or get trust store path for fluent API
+    def trust_store_path(path = nil)
+      if path
+        @j_del.setTrustStorePath(path)
+        self
+      else
+        @j_del.getTrustStorePath
+      end
+    end
+
+    # Set the password for the SSL trust store. This method should only be used with the client in SSL mode, i.e. after {#ssl=}
+    # has been set to true.
+    # @param [String] val. The password.
+    # @return [] self. So multiple invocations can be chained.
+    def trust_store_password=(val)
+      @j_del.setTrustStorePassword(val)
+      self
+    end
+
+    # Set or get trust store password for fluent API
+    def trust_store_password(password = nil)
+      if password
+        @j_del.setTrustStorePassword(password)
+        self
+      else
+        @j_del.getTrustStorePassword
+      end
+    end
+
+  end
+
+  # A mixin module allowing Client SSL attributes to be set on classes
+  #
+  # @author {http://tfox.org Tim Fox}
+  module ClientSSLSupport
+
+    def trust_all=(val)
+      @j_del.setTrustAll(val)
+      self
+    end
+
+    def trust_all(val = nil)
+      if val
+        @j_del.setTrustAll(val)
+        self
+      else
+        @j_del.isTrustAll
+      end
+    end
+  end
+end

data/lib/vertx/streams.rb

@@ -0,0 +1,172 @@
+# 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
+
+  # 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
+
+    # 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
+    # {Pump} to provide flow control.
+    # @param [FixNum] size. The maximum size, in bytes.
+    def write_queue_max_size=(size)
+      @j_del.setWriteQueueMaxSize(size)
+    end
+
+    # For a fluent API
+    def write_queue_max_size(size)
+      @j_del.setWriteQueueMaxSize(size)
+      self
+    end
+
+    # Is the write queue full?
+    # @return [Boolean] true if there are more bytes in the write queue than the max write queue size.
+    def write_queue_full?
+      @j_del.writeQueueFull
+    end
+
+    # Set a drain handler on the stream. If the write queue is full, then the handler will be called when the write
+    # queue has been reduced to maxSize / 2. See {Pump} for an example of this being used.
+    # @param [Block] hndlr. The drain handler
+    def drain_handler(&hndlr)
+      @j_del.drainHandler(hndlr)
+      self
+    end
+
+    # Set an exception handler on the stream.
+    # @param [Block] hndlr. The exception handler
+    def exception_handler(&hndlr)
+      @j_del.exceptionHandler(hndlr)
+      self
+    end
+
+    # @private
+    def _to_write_stream
+      @j_del
+    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
+
+    # Set a data handler. As data is read, the handler will be called with the data.
+    # @param [Block] hndlr. The data handler
+    def data_handler(&hndlr)
+      @j_del.dataHandler(Proc.new { |j_buff|
+        hndlr.call(Buffer.new(j_buff))
+      })
+      self
+    end
+
+    # Pause the ReadStream. After calling this, the ReadStream will aim to send no more data to the {#data_handler}
+    def pause
+      @j_del.pause
+      self
+    end
+
+    # Resume reading. If the ReadStream has been paused, reading will recommence on it.
+    def resume
+      @j_del.resume
+      self
+    end
+
+    # Set an execption handler on the stream.
+    # @param [Block] hndlr. The exception handler
+    def exception_handler(&hndlr)
+      @j_del.exceptionHandler(hndlr)
+      self
+    end
+
+    # 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
+    def end_handler(&hndlr)
+      @j_del.endHandler(hndlr)
+      self
+    end
+
+    # @private
+    def _to_read_stream
+      @j_del
+    end
+
+  end
+
+  # Pumps data from a {ReadStream} to a {WriteStream} and performs flow control where necessary to
+  # prevent the write stream from getting overloaded.
+  #
+  # Instances of this class read bytes from a ReadStream and write them to a WriteStream. If data
+  # can be read faster than it can be written this could result in the write queue of the WriteStream growing
+  # without bound, eventually causing it to exhaust all available RAM.
+  # To prevent this, after each write, instances of this class check whether the write queue of the WriteStream
+  # is full, and if so, the ReadStream is paused, and a {WriteStream#drain_handler} is set on the WriteStream.
+  # When the WriteStream has processed half of its backlog, the drain_handler will be called,
+  # which results in the pump resuming the ReadStream.
+  #
+  # This class can be used to pump from any {ReadStream} to any { WriteStream},
+  # e.g. from an {HttpServerRequest} to an {AsyncFile}, or from {NetSocket} to a {WebSocket}.
+  #
+  # @author {http://tfox.org Tim Fox}
+  class Pump
+    def initialize(read_stream, write_stream)
+      raise "read_stream is not a ReadStream" if !read_stream.is_a? ReadStream
+      raise "write_stream is not a WriteStream" if !write_stream.is_a? WriteStream
+      j_rs = read_stream._to_read_stream
+      j_ws = write_stream._to_write_stream
+      @j_pump = org.vertx.java.core.streams.Pump.createPump(j_rs, j_ws)
+    end
+
+    # Set the write queue max size
+    # @param [FixNum] The write queue max size
+    def write_queue_max_size=(val)
+      @j_pump.setWriteQueueMaxSize(val)
+      self
+    end
+
+    # Start the Pump. The Pump can be started and stopped multiple times.
+    def start
+      @j_pump.start
+      self
+    end
+
+    # Stop the Pump. The Pump can be started and stopped multiple times.
+    def stop
+      @j_pump.stop
+      self
+    end
+
+    # @return [FixNum] Return the total number of bytes pumped by this pump.
+    def bytes_pumped
+      @j_pump.bytesPumped
+    end
+  end
+end

data/lib/vertx/tcp_support.rb

@@ -0,0 +1,150 @@
+# 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.
+
+module Vertx
+
+  # 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
+
+    # Set the TCP keep alive setting.
+    # @param [Boolean] val. If true, then TCP keep alive will be enabled.
+    # @return [] A reference to self so invocations can be chained
+    def tcp_keep_alive=(val)
+      @j_del.setTCPKeepAlive(val)
+      self
+    end
+
+    # Set or get TCP keep alive for fluent API
+    def tcp_keep_alive(val = nil)
+      if val
+        @j_del.setTCPKeepAlive(val)
+        self
+      else
+        @j_del.getTCPKeepAlive
+      end
+    end
+
+    # Set the TCP reuse address setting.
+    # @param [Boolean] val. If true, then TCP reuse address will be enabled.
+    # @return [] A reference to self so invocations can be chained
+    def reuse_address=(val)
+      @j_del.setReuseAddress(val)
+      self
+    end
+
+    # Set or get TCP reuse address for fluent API
+    def reuse_address(val = nil)
+      if val
+        @j_del.setReuseAddress(val)
+        self
+      else
+        @j_del.isReuseAddress
+      end
+    end
+
+    # Set the TCP so linger setting.
+    # @param [FixNum] val. Set TCP soLinger
+    # @return [] A reference to self so invocations can be chained
+    def so_linger=(val)
+      @j_del.setSoLinger(val)
+      self
+    end
+
+    # Set or get TCP so linger for fluent API
+    def so_linger(val = nil)
+      if val
+        @j_del.setSoLinger(val)
+        self
+      else
+        @j_del.getSoLinger
+      end
+    end
+
+    # Set the TCP traffic class setting.
+    # @param [FixNum] val. The TCP traffic class setting.
+    # @return [] A reference to self so invocations can be chained
+    def traffic_class=(val)
+      @j_del.setTrafficClass(val)
+      self
+    end
+
+    # Set or get TCP traffic class for fluent API
+    def traffic_class(val = nil)
+      if val
+        @j_del.setTrafficClass(val)
+        self
+      else
+        @j_del.getTrafficClass
+      end
+    end
+
+    # Set to use pooled buffers
+    # @param [Boolean] val.
+    # @return [] A reference to self so invocations can be chained
+    def use_pooled_buffers=(val)
+      @j_del.setUsedPooledBuffers(val)
+      self
+    end
+
+    # Set or get use_pooled_buffers for fluent API
+    def use_pooled_buffers(val = nil)
+      if val
+        @j_del.setUsePooledBuffers(val)
+        self
+      else
+        @j_del.isUsePooledBuffers
+      end
+    end
+
+  end
+
+end

data/lib/vertx/wrapped_handler.rb

@@ -0,0 +1,28 @@
+module Vertx
+
+  # @private
+  class ARWrappedHandler
+    include org.vertx.java.core.AsyncResultHandler
+  
+    def initialize(handler, &result_converter)
+      @handler = handler
+      @result_converter = result_converter
+    end
+  
+    def handle(future_result)
+      if @handler
+        if future_result.succeeded
+          if @result_converter
+            @handler.call(nil, @result_converter.call(future_result.result))
+          else
+            @handler.call(nil, future_result.result)
+          end
+        else
+          @handler.call(future_result.cause, nil)
+        end
+      end
+    end
+  
+  end
+  
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jubilee
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta
+  version: 2.0.0
 platform: java
 authors:
 - Isaiah Peng
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-01-26 00:00:00.000000000 Z
+date: 2014-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -130,7 +130,12 @@ files:
 - 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
 - spec/apps/rack/basic/config.ru
 - spec/apps/rails4/basic/.gitignore
 - spec/apps/rails4/basic/Gemfile
@@ -231,9 +236,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project:
 rubygems_version: 2.1.9