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

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

@@ -12,12 +12,106 @@
 # 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'
+require 'core/streams'
+require 'core/ssl_support'
+require 'core/tcp_support'
+require 'core/wrapped_handler'
 
 module Vertx
+
+  # An HTTP and WebSockets server
+  #
+  # @author {http://tfox.org Tim Fox}
+  class HttpServer
+
+    include SSLSupport, ServerSSLSupport, TCPSupport, ServerTCPSupport
+
+    # Letting the developer choose between compression? or compression while developing
+    #alias_method :compression?, :compression
+
+    # Create a new HttpServer.
+    # using an optional hash to configure the HttpServer on instantiation.
+    # @param [Hash] config an Hash of configurations.
+    def initialize(config = {})
+      @j_del = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createHttpServer
+      self.compression = config[:compression] if config.has_key?(:compression)
+      self
+    end
+
+    # Set the HTTP request handler for the server.
+    # As HTTP requests arrive on the server a new {HttpServerRequest} instance will be created and passed to the handler.
+    # @param [Block] hndlr A block to be used as the handler
+    def request_handler(rm = nil, &hndlr)
+      if (rm && (rm.is_a? RouteMatcher))
+        @j_del.requestHandler { |j_del| rm.input(HttpServerRequest.new(j_del))}
+      else
+        @j_del.requestHandler { |j_del| hndlr.call(HttpServerRequest.new(j_del)) }
+      end
+      self
+    end
+
+    # Set the WebSocket handler for the server.
+    # As WebSocket requests arrive on the server and are accepted a new {WebSocket} instance will be created and
+    # passed to the handler.
+    # @param [Block] hndlr A block to be used as the handler
+    def websocket_handler(&hndlr)
+      @j_del.websocketHandler do |param|
+        hndlr.call(ServerWebSocket.new(param))
+      end
+      self
+    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.setCompressionSupported(supported)
+    end
+
+    # Tests if compression is supported.
+    # @return [Boolean] true if compression is supported or false if it doesn't
+    def compression
+      @j_del.isCompressionSupported
+    end
+
+    # Letting the developer choose between compression? or compression while developing
+    alias_method :compression?, :compression
+
+    # Instruct the server to listen for incoming connections.
+    # @param [FixNum] port. The port to listen on.
+    # @param [FixNum] host. The host name or ip address to listen on.
+    # @param [Block] hndlr The handler will be called when the server is listening, or it failed to listen
+    def listen(port, host = "0.0.0.0", &hndlr)
+      @j_del.listen(port, host, ARWrappedHandler.new(hndlr) { |j_del| self })
+    end
+
+    # Close the server. The handler will be called when the close is complete.
+    def close(&hndlr)
+      if hndlr
+        @j_del.close(ARWrappedHandler.new(hndlr))
+      else
+        @j_del.close
+      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
+
+    # @private
+    def _to_java_server
+      @j_del
+    end
+  end
+
   # 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.
@@ -31,7 +125,7 @@ module Vertx
 
     # Create a new HttpClient
     def initialize(config = {})
-      @j_del = org.jruby.jubilee.vertx.JubileeVertx.vertx().createHttpClient()
+      @j_del = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createHttpClient
       self.compression = config[:try_compression] if config.has_key?(:try_compression)
     end
 
@@ -470,6 +564,277 @@ module Vertx
 
   end
 
+  # Encapsulates a server-side HTTP request.
+  #
+  # An instance of this class is created for each request that is handled by the server and is passed to the user via the
+  # handler specified using {HttpServer#request_handler}.
+  #
+  # Each instance of this class is associated with a corresponding {HttpServerResponse} instance via the field {#response}.
+  #
+  # @author {http://tfox.org Tim Fox}
+  class HttpServerRequest
+
+    include ReadStream
+
+    # @private
+    def initialize(j_del)
+      @j_del = j_del
+      @resp = HttpServerResponse.new(@j_del.response)
+    end
+
+    # @return [String] The Http version
+    def version
+      if !@vrsn
+        @vrsn = @j_del.version.toString
+      end
+      @vrsn
+    end
+
+    # @return [String] The HTTP method, one of HEAD, OPTIONS, GET, POST, PUT, DELETE, CONNECT, TRACE
+    def method
+      @j_del.method
+    end
+
+    # @return [String] The uri of the request. For example 'http://www.somedomain.com/somepath/somemorepath/somresource.foo?someparam=32&someotherparam=x'
+    def uri
+      @j_del.uri
+    end
+
+    # @return [String] The path part of the uri. For example /somepath/somemorepath/somresource.foo
+    def path
+      @j_del.path
+    end
+
+    # @return [String] The query part of the uri. For example someparam=32&someotherparam=x
+    def query
+      @j_del.query
+    end
+
+    # @return [MultiMap] The request parameters
+    def params
+      if !@params
+        @params = MultiMap.new(@j_del.params)
+      end
+      @params
+    end
+
+    # @return [HttpServerResponse] The response. Each instance of this class has an {HttpServerResponse} instance attached to it. This is used
+    # to send the response back to the client.
+    def response
+      @resp
+    end
+
+    # @return [MultiMap] The request headers
+    def headers
+      if !@headers
+        @headers = MultiMap.new(@j_del.headers)
+      end
+      @headers
+    end
+
+    # You must call this function with true before receiving the request body if you expect it to
+    # contain a multi-part form
+    def expect_multipart=(expect)
+      @j_del.expectMultiPart(expect)
+      self
+    end
+
+    # @return [MultiMap] Returns a map of all form attributes which was found in the request. Be aware that this
+    # message should only get
+    # called after the endHandler was notified as the map will be filled on-the-fly.
+    def form_attributes
+      if !@attrs
+        @attrs = MultiMap.new(@j_del.formAttributes)
+      end
+      @attrs
+    end
+
+    # Set the upload handler. The handler will get notified once a new file upload was received and so allow to
+    # get notified by the upload in progress.
+    def upload_handler(&hndlr)
+      @j_del.uploadHandler do |j_upload|
+          hndlr.call(HttpServerFileUpload.new(j_upload))
+      end
+      self
+    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
+
+    # Get the remote address
+    def remote_address
+      @j_del.remoteAddress
+    end
+
+    # Get the absolute URI
+    def absolute_uri
+      @j_del.absoluteURI
+    end
+
+    def _to_java_request
+      @j_del
+    end
+
+  end
+
+  # Encapsulates a server-side HTTP response.
+  #
+  # An instance of this class is created and associated to every instance of {HttpServerRequest} that is created.
+  #
+  # It allows the developer to control the HTTP response that is sent back to the client for the corresponding HTTP
+  # request. It contains methods that allow HTTP headers and trailers to be set, and for a body to be written out
+  # to the response.
+  #
+  # @author {http://tfox.org Tim Fox}
+  class HttpServerResponse
+
+    include WriteStream
+
+    # @private
+    def initialize(j_del)
+      @j_del = j_del
+    end
+
+    def status_code=(val)
+      @j_del.setStatusCode(val)
+    end
+
+    # Get or set the status code
+    def status_code(val = nil)
+      if val
+        @j_del.setStatusCode(val)
+        self
+      else
+        @j_del.getStatusCode
+      end
+    end
+
+    # Set the status message
+    def status_message=(val)
+      @j_del.setStatusMessage(val)
+    end
+
+    # Get or set the status message
+    def status_message(val = nil)
+      if val
+        @j_del.setStatusMessage(val)
+        self
+      else
+        @j_del.getStatusMessage
+      end
+    end
+
+    # Sets whether this response uses HTTP chunked encoding or not.
+    # @param [Boolean] val. If val is true, this response 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 response.
+    # If chunked is false, this response will not use HTTP chunked encoding, and therefore if any data is written the
+    # body of the response, the total size of that data must be set in the 'Content-Length' header before any
+    # data is written to the response body.
+    # An HTTP chunked response is typically used when you do not know the total size of the request body up front.
+    # @return [HttpServerResponse] 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
+
+    # @return [MultiMap] The response headers
+    def headers
+      if !@headers
+        @headers = MultiMap.new(@j_del.headers)
+      end
+      @headers
+    end
+
+    # Inserts a header into the response.
+    # @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
+
+    # Inserts a trailer into the response.
+    # @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_trailer(key, value)
+      @j_del.putTrailer(key, value.to_s)
+      self
+    end
+
+    # The response trailers
+    def trailers
+      if !@trailers
+        @trailers = MultiMap.new(@j_del.trailers)
+      end
+      @trailers
+    end
+
+    # Write a String to the response. The handler will be called when the String has actually been written to the wire.
+    # @param [String] str. The string to write
+    # @param [String] enc. Encoding to use.
+    # @return [HttpServerResponse] self So multiple operations can be chained.
+    def write_str(str, enc = "UTF-8")
+      @j_del.write(str, enc)
+      self
+    end
+
+    # Tell the kernel to stream a file directly from disk to the outgoing connection, bypassing user-space altogether
+    # (where supported by the underlying operating system. This is a very efficient way to serve files.
+    # @param [String] path. Path to file to send.
+    # @param [String] not_found_file Path to file containing 404 resource in case resource can't be found
+    # @return [HttpServerResponse] self So multiple operations can be chained.
+    def send_file(path, not_found_file = nil, &block)
+      if not_found_file.nil?
+        if block_given?
+          @j_del.sendFile(path, ARWrappedHandler.new(block))
+        else
+          @j_del.sendFile(path)
+        end
+      else
+        if block_given?
+          @j_del.sendFile(path, not_found_file, ARWrappendHandler.new(block))
+        else
+          @j_del.sendFile(path, not_found_file)
+        end
+      end
+      self
+    end
+
+    # Ends the response. If no data has been written to the response body, the actual response won't get written until this method gets called.
+    # Once the response has ended, it cannot be used any more, and if keep alive is true the underlying connection will
+    # be closed.
+    # @param [String,Buffer] data. Optional String or Buffer to write before ending the response
+    def end(data = nil)
+      if (data.is_a? String) || (data.is_a? Buffer)
+        @j_del.end(data)
+      else
+        @j_del.end
+      end
+    end
+
+    # Close the underlying TCP connection
+    def close
+      @j_del.close
+    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.
@@ -540,6 +905,221 @@ module Vertx
 
   end
 
+  # Instances of this class are created when a WebSocket is accepted on the server.
+  # It extends {WebSocket} and adds methods to reject the WebSocket and to get path and headers
+  class ServerWebSocket < WebSocket
+
+    # @private
+    def initialize(j_ws)
+      super(j_ws)
+      @j_del = j_ws
+    end
+
+    # Reject the WebSocket
+    # This can be called in the WebSocket connect handler on the server side and
+    # will cause the WebSocket connection attempt to be rejected, returning a
+    # 404 to the client.
+    def reject
+      @j_del.reject
+    end
+
+    # Return the headers of the handshake request
+    # @return [MultiMap] The handshake headers
+    def headers
+      if !@headers
+        @headers = MultiMap.new(@j_del.headers)
+      end
+      @headers
+    end
+
+    # The path the WebSocket connect was attempted at.
+    def path
+      @j_del.path
+    end
+  end
+
+  # This class allows you to do route requests based on the HTTP verb and the request URI, in a manner similar
+  # to <a href="http://www.sinatrarb.com/">Sinatra</a> or <a href="http://expressjs.com/">Express</a>.
+  #
+  # RouteMatcher also lets you extract parameters from the request URI either a simple pattern or using
+  # regular expressions for more complex matches. Any parameters extracted will be added to the requests parameters
+  # which will be available to you in your request handler.
+  #
+  # It's particularly useful when writing REST-ful web applications.
+  #
+  # To use a simple pattern to extract parameters simply prefix the parameter name in the pattern with a ':' (colon).
+  #
+  # Different handlers can be specified for each of the HTTP verbs, GET, POST, PUT, DELETE etc.
+  #
+  # For more complex matches regular expressions can be used in the pattern. When regular expressions are used, the extracted
+  # parameters do not have a name, so they are put into the HTTP request with names of param0, param1, param2 etc.
+  #
+  # Multiple matches can be specified for each HTTP verb. In the case there are more than one matching patterns for
+  # a particular request, the first matching one will be used.
+  #
+  # @author {http://tfox.org Tim Fox}
+  class RouteMatcher
+    def initialize
+      @j_del = org.vertx.java.core.http.RouteMatcher.new
+    end
+
+    # This method is called to provide the matcher with data.
+    # @param [HttpServerRequest] request. Input request to the parser.
+    def input(request)
+      @j_del.handle(request._to_java_request)
+    end
+
+    # Specify a handler that will be called for a matching HTTP GET
+    # @param [String] The simple pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def get(pattern, &hndlr)
+      @j_del.get(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP PUT
+    # @param [String] The simple pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def put(pattern, &hndlr)
+      @j_del.put(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP POST
+    # @param [String] The simple pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def post(pattern, &hndlr)
+      @j_del.post(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP DELETE
+    # @param [String] The simple pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def delete(pattern, &hndlr)
+      @j_del.delete(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP OPTIONS
+    # @param [String] The simple pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def options(pattern, &hndlr)
+      @j_del.options(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP HEAD
+    # @param [String] The simple pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def head(pattern, &hndlr)
+      @j_del.head(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP TRACE
+    # @param [String] The simple pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def trace(pattern, &hndlr)
+      @j_del.trace(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP PATCH
+    # @param [String] The simple pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def patch(pattern, &hndlr)
+      @j_del.patch(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP CONNECT
+    # @param [String] The simple pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def connect(pattern, &hndlr)
+      @j_del.connect(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for any matching HTTP request
+    # @param [String] The simple pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def all(pattern, &hndlr)
+      @j_del.all(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP GET
+    # @param [String] A regular expression for a pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def get_re(pattern, &hndlr)
+
+      @j_del.getWithRegEx(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP PUT
+    # @param [String] A regular expression for a pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def put_re(pattern, &hndlr)
+      @j_del.putWithRegEx(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP POST
+    # @param [String] A regular expression for a pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def post_re(pattern, &hndlr)
+      @j_del.postWithRegEx(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP DELETE
+    # @param [String] A regular expression for a pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def delete_re(pattern, &hndlr)
+      @j_del.deleteWithRegEx(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP OPTIONS
+    # @param [String] A regular expression for a pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def options_re(pattern, &hndlr)
+      @j_del.optionsWithRegEx(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP HEAD
+    # @param [String] A regular expression for a pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def head_re(pattern, &hndlr)
+      @j_del.headWithRegEx(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP TRACE
+    # @param [String] A regular expression for a pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def trace_re(pattern, proc = nil, &hndlr)
+      @j_del.traceWithRegEx(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP PATCH
+    # @param [String] A regular expression for a pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def patch_re(pattern, &hndlr)
+      @j_del.patchWithRegEx(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for a matching HTTP CONNECT
+    # @param [String] A regular expression for a pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def connect_re(pattern, &hndlr)
+      @j_del.connectWithRegEx(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called for any matching HTTP request
+    # @param [String] A regular expression for a pattern
+    # @param [Block] hndlr A block to be used as the handler
+    def all_re(pattern, &hndlr)
+      @j_del.allWithRegEx(pattern) { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+    # Specify a handler that will be called when nothing matches
+    # Default behaviour is to return a 404
+    # @param [Block] hndlr A block to be used as the handler
+    def no_match(&hndlr)
+      @j_del.noMatch { |j_req| hndlr.call(HttpServerRequest.new(j_req)) }
+    end
+
+  end
+
+
   # A map which can hold multiple values for one name / key
   #
   # @author Norman Maurer
@@ -674,4 +1254,54 @@ module Vertx
       @j_map
     end
   end
+
+  # An Upload which was found in the HttpServerMultipartRequest while handling it.
+  #
+  # @author Norman Maurer
+  #
+  class HttpServerFileUpload
+
+    include ReadStream
+
+    # @private
+    def initialize(j_del)
+      @j_del = j_del
+    end
+
+    # Stream the content of this upload to the given filename.
+    def stream_to_file_system(filename)
+      @j_del.streamToFileSystem(filename)
+      self
+    end
+
+    # Returns the filename of the attribute
+    def filename
+      @j_del.filename()
+    end
+
+    # Returns the name of the attribute
+    def name
+      @j_del.name()
+    end
+
+   # Returns the contentType for the upload
+    def content_type
+      @j_del.contentType()
+    end
+
+    #Returns the contentTransferEncoding for the upload
+    def content_transfer_encoding
+      @j_del.contentTransferEncoding()
+    end
+
+    # Returns the charset for the upload
+    def charset
+      @j_del.charset().toString()
+    end
+
+    #Returns the size of the upload (in bytes)
+    def size
+      @j_del.size()
+    end
+  end
 end