webmachine 1.2.2 → 1.6.0

data/lib/webmachine/adapters.rb

@@ -5,8 +5,7 @@ module Webmachine
   # Contains classes and modules that connect Webmachine to Ruby
   # application servers.
   module Adapters
-    autoload :Mongrel,  'webmachine/adapters/mongrel'
     autoload :Reel,     'webmachine/adapters/reel'
-    autoload :Hatetepe, 'webmachine/adapters/hatetepe'
+    autoload :HTTPkit,  'webmachine/adapters/httpkit'
   end
 end

data/lib/webmachine/adapters/httpkit.rb

@@ -0,0 +1,74 @@
+require 'webmachine/adapter'
+require 'webmachine/constants'
+require 'webmachine/version'
+require 'httpkit'
+require 'webmachine/version'
+require 'webmachine/response'
+require 'webmachine/request'
+require 'webmachine/headers'
+
+module Webmachine
+  module Adapters
+    class HTTPkit < Adapter
+      VERSION_STRING = "#{Webmachine::SERVER_STRING} HTTPkit/#{::HTTPkit::VERSION}".freeze
+
+      def options
+        @options ||= {
+          :address => application.configuration.ip,
+          :port => application.configuration.port,
+          :handlers => [
+            ::HTTPkit::Server::TimeoutsHandler.new,
+            ::HTTPkit::Server::KeepAliveHandler.new,
+            self
+          ]
+        }
+      end
+
+      def run
+        ::HTTPkit.start do
+          ::HTTPkit::Server.start(options)
+        end
+      end
+
+      # Called by HTTPkit::Server for every request
+      def serve(request, served)
+        response = Webmachine::Response.new
+        application.dispatcher.dispatch(convert_request(request), response)
+
+        served.fulfill(convert_response(response))
+      end
+
+      private
+
+      # Converts HTTPkit::Request to Webmachine::Request
+      def convert_request(request)
+        Webmachine::Request.new(
+          request.http_method.to_s.upcase,
+          request.uri,
+          Webmachine::Headers[request.headers.dup],
+          request.body)
+      end
+
+      # Converts Webmachine::Response to HTTPkit::Response
+      def convert_response(response)
+        response.headers[SERVER] = VERSION_STRING
+
+
+        ::HTTPkit::Response.new(
+          response.code.to_i,
+          response.headers,
+          convert_body(response.body))
+      end
+
+      # HTTPkit::Body accepts strings and enumerables, i.e. Webmachine's
+      # Callable, Enumerable, IO, and Fiber encoders are supported.
+      def convert_body(body)
+        if body.respond_to?(:call)
+          [body.call]
+        else
+          body || ''
+        end
+      end
+    end
+  end
+end

data/lib/webmachine/adapters/lazy_request_body.rb

@@ -1,5 +1,4 @@
-
-module Webmachine
+module Webmachine
   module Adapters
     # Wraps a request body so that it can be passed to
     # {Request} while still lazily evaluating the body.

data/lib/webmachine/adapters/rack.rb

@@ -1,17 +1,23 @@
+require 'webmachine/adapter'
 require 'rack'
-require 'webmachine/version'
+require 'webmachine/constants'
 require 'webmachine/headers'
 require 'webmachine/request'
 require 'webmachine/response'
-require 'webmachine/dispatcher'
+require 'webmachine/version'
 require 'webmachine/chunked_body'
 
 module Webmachine
   module Adapters
     # A minimal "shim" adapter to allow Webmachine to interface with Rack. The
     # intention here is to allow Webmachine to run under Rack-compatible
-    # web-servers, like unicorn and pow, and is not intended to allow Webmachine
-    # to be "plugged in" to an existing Rack app as middleware.
+    # web-servers, like unicorn and pow.
+    #
+    # The adapter expects your Webmachine application to be mounted at the root path -
+    # it will NOT allow you to nest your Webmachine application at an arbitrary path
+    # eg. map "/api" { run MyWebmachineAPI }
+    # To use map your Webmachine application at an arbitrary path, use the
+    # `Webmachine::Adapters::RackMapped` subclass instead.
     #
     # To use this adapter, create a config.ru file and populate it like so:
     #
@@ -26,7 +32,7 @@ module Webmachine
     # all "just work".
     #
     # And for development or testing your application can be run with Rack's
-    # builtin Server identically to the Mongrel and WEBrick adapters with:
+    # builtin Server identically to the WEBrick adapter with:
     #
     #     MyApplication.run
     #
@@ -34,49 +40,48 @@ module Webmachine
       # Used to override default Rack server options (useful in testing)
       DEFAULT_OPTIONS = {}
 
+      REQUEST_URI = 'REQUEST_URI'.freeze
+      VERSION_STRING = "#{Webmachine::SERVER_STRING} Rack/#{::Rack.version}".freeze
+      NEWLINE = "\n".freeze
+
       # Start the Rack adapter
       def run
         options = DEFAULT_OPTIONS.merge({
           :app => self,
-          :Port => configuration.port,
-          :Host => configuration.ip
-        }).merge(configuration.adapter_options)
+          :Port => application.configuration.port,
+          :Host => application.configuration.ip
+        }).merge(application.configuration.adapter_options)
 
         @server = ::Rack::Server.new(options)
         @server.start
       end
 
-      def shutdown
-        @server.server.shutdown if @server
-      end
-
       # Handles a Rack-based request.
       # @param [Hash] env the Rack environment
       def call(env)
         headers = Webmachine::Headers.from_cgi(env)
 
         rack_req = ::Rack::Request.new env
-        request = Webmachine::Request.new(rack_req.request_method,
-                                          URI.parse(rack_req.url),
-                                          headers,
-                                          RequestBody.new(rack_req))
+        request = build_webmachine_request(rack_req, headers)
 
         response = Webmachine::Response.new
-        @dispatcher.dispatch(request, response)
+        application.dispatcher.dispatch(request, response)
 
-        response.headers['Server'] = [Webmachine::SERVER_STRING, "Rack/#{::Rack.version}"].join(" ")
+        response.headers[SERVER] = VERSION_STRING
 
         rack_status  = response.code
-        rack_headers = response.headers.flattened("\n")
+        rack_headers = response.headers.flattened(NEWLINE)
         rack_body = case response.body
                     when String # Strings are enumerable in ruby 1.8
                       [response.body]
                     else
-                      if response.body.respond_to?(:call)
+                      if (io_body = IO.try_convert(response.body))
+                        io_body
+                      elsif response.body.respond_to?(:call)
                         Webmachine::ChunkedBody.new(Array(response.body.call))
                       elsif response.body.respond_to?(:each)
                         # This might be an IOEncoder with a Content-Length, which shouldn't be chunked.
-                        if response.headers["Transfer-Encoding"] == "chunked"
+                        if response.headers[TRANSFER_ENCODING] == "chunked"
                           Webmachine::ChunkedBody.new(response.body)
                         else
                           response.body
@@ -90,7 +95,39 @@ module Webmachine
         rack_res.finish
       end
 
+      protected
+      def routing_tokens(rack_req)
+        nil # no-op for default, un-mapped rack adapter
+      end
+
+      def base_uri(rack_req)
+        nil # no-op for default, un-mapped rack adapter
+      end
+
+      private
+      def build_webmachine_request(rack_req, headers)
+        RackRequest.new(rack_req.request_method,
+                                rack_req.url,
+                                headers,
+                                RequestBody.new(rack_req),
+                                routing_tokens(rack_req),
+                                base_uri(rack_req),
+                                rack_req.env
+                               )
+      end
+
+      class RackRequest < Webmachine::Request
+        attr_reader :env
+
+        def initialize(method, uri, headers, body, routing_tokens, base_uri, env)
+          super(method, uri, headers, body, routing_tokens, base_uri)
+          @env = env
+        end
+      end
+
       class RackResponse
+        ONE_FIVE = '1.5'.freeze
+
         def initialize(body, status, headers)
           @body    = body
           @status  = status
@@ -98,8 +135,8 @@ module Webmachine
         end
 
         def finish
-          @headers['Content-Type'] ||= 'text/html' if rack_release_enforcing_content_type
-          @headers.delete('Content-Type')          if response_without_body
+          @headers[CONTENT_TYPE] ||= TEXT_HTML if rack_release_enforcing_content_type
+          @headers.delete(CONTENT_TYPE)        if response_without_body
           [@status, @headers, @body]
         end
 
@@ -110,7 +147,7 @@ module Webmachine
         end
 
         def rack_release_enforcing_content_type
-          ::Rack.release < '1.5'
+          ::Rack.release < ONE_FIVE
         end
       end
 
@@ -123,6 +160,15 @@ module Webmachine
           @request = request
         end
 
+        # Rack Servers differ in the way you can access their request bodys.
+        # While some allow you to directly get a Ruby IO object others don't.
+        # You have to check the methods they expose, like #gets, #read, #each, #rewind and maybe others.
+        # See: https://github.com/rack/rack/blob/rack-1.5/lib/rack/lint.rb#L296
+        # @return [IO] the request body
+        def to_io
+          @request.body
+        end
+
         # Converts the body to a String so you can work with the entire
         # thing.
         # @return [String] the request body as a string
@@ -150,6 +196,5 @@ module Webmachine
         end
       end # class RequestBody
     end # class Rack
-
   end # module Adapters
 end # module Webmachine

data/lib/webmachine/adapters/rack_mapped.rb

@@ -0,0 +1,42 @@
+require 'webmachine/adapters/rack'
+
+module Webmachine
+  module Adapters
+    # Provides the same functionality as the parent Webmachine::Adapters::Rack
+    # adapter, but allows the Webmachine application to be hosted at an
+    # arbitrary path in a parent Rack application (as in Rack `map` or Rails
+    # routing `mount`)
+    #
+    # This functionality is separated out from the parent class to preserve
+    # backward compatibility in the behaviour of the parent Rack adpater.
+    #
+    # To use the adapter in a parent Rack application, map the Webmachine
+    # application as follows in a rackup file or Rack::Builder:
+    #
+    #   map '/foo' do
+    #     run SomeotherRackApp
+    #
+    #     map '/bar' do
+    #       run MyWebmachineApp.adapter
+    #     end
+    #   end
+    class RackMapped < Rack
+
+      protected
+
+      def routing_tokens(rack_req)
+        routing_match = rack_req.path_info.match(Webmachine::Request::ROUTING_PATH_MATCH)
+        routing_path = routing_match ? routing_match[1] : ""
+        routing_path.split(SLASH)
+      end
+
+      def base_uri(rack_req)
+        # rack SCRIPT_NAME env var doesn't end with "/". This causes weird
+        # behavour when URI.join concatenates URI components in
+        # Webmachine::Decision::Flow#n11
+        script_name = rack_req.script_name + SLASH
+        URI.join(rack_req.base_url, script_name)
+      end
+    end # class RackMapped
+  end # module Adapters
+end # module Webmachine

data/lib/webmachine/adapters/reel.rb

@@ -1,40 +1,42 @@
+require 'webmachine/adapter'
+require 'webmachine/constants'
+require 'set'
+require 'celluloid/current'
 require 'reel'
-require 'webmachine/version'
 require 'webmachine/headers'
 require 'webmachine/request'
 require 'webmachine/response'
-require 'webmachine/dispatcher'
-require 'set'
 
 module Webmachine
   module Adapters
     class Reel < Adapter
       # Used to override default Reel server options (useful in testing)
       DEFAULT_OPTIONS = {}
-      
+
       def run
         @options = DEFAULT_OPTIONS.merge({
-          :port => configuration.port,
-          :host => configuration.ip
-        }).merge(configuration.adapter_options)
+          :port => application.configuration.port,
+          :host => application.configuration.ip
+        }).merge(application.configuration.adapter_options)
 
-        if extra_verbs = configuration.adapter_options[:extra_verbs]
+        if extra_verbs = application.configuration.adapter_options[:extra_verbs]
           @extra_verbs = Set.new(extra_verbs.map(&:to_s).map(&:upcase))
         else
           @extra_verbs = Set.new
         end
 
-        @server = ::Reel::Server.supervise(@options[:host], @options[:port], &method(:process))
+        if @options[:ssl]
+          unless @options[:ssl][:cert] && @options[:ssl][:key]
+            raise ArgumentError, 'Certificate or Private key missing for HTTPS Server'
+          end
+          @server = ::Reel::Server::HTTPS.supervise(@options[:host], @options[:port], @options[:ssl], &method(:process))
+        else
+          @server = ::Reel::Server::HTTP.supervise(@options[:host], @options[:port], &method(:process))
+        end
 
-        # FIXME: this will no longer work on Ruby 2.0. We need Celluloid.trap
-        trap("INT") { @server.terminate; exit 0 }
         Celluloid::Actor.join(@server)
       end
 
-      def shutdown
-        @server.terminate! if @server
-      end
-
       def process(connection)
         connection.each_request do |request|
           # Users of the adapter can configure a custom WebSocket handler
@@ -54,7 +56,7 @@ module Webmachine
           # state machine. Do the "Railsy" thing and handle them like POSTs
           # with a magical parameter
           if @extra_verbs.include?(request.method)
-            method = "POST"
+            method = POST_METHOD
             param  = "_method=#{request.method}"
             uri    = request_uri(request.url, request.headers, param)
           else
@@ -64,8 +66,9 @@ module Webmachine
 
           wm_headers  = Webmachine::Headers[request.headers.dup]
           wm_request  = Webmachine::Request.new(method, uri, wm_headers, request.body)
+
           wm_response = Webmachine::Response.new
-          @dispatcher.dispatch(wm_request, wm_response)
+          application.dispatcher.dispatch(wm_request, wm_response)
 
           fixup_headers(wm_response)
           fixup_callable_encoder(wm_response)
@@ -77,13 +80,9 @@ module Webmachine
       end
 
       def request_uri(path, headers, extra_query_params = nil)
-        host_parts = headers.fetch('Host').split(':')
         path_parts = path.split('?')
-
-        uri_hash = {host: host_parts.first, path: path_parts.first}
-
-        uri_hash[:port]  = host_parts.last.to_i if host_parts.length == 2
-        uri_hash[:query] = path_parts.last      if path_parts.length == 2
+        uri_hash = {path: path_parts.first}
+        uri_hash[:query] = path_parts.last if path_parts.length == 2
 
         if extra_query_params
           if uri_hash[:query]

data/lib/webmachine/adapters/webrick.rb

@@ -1,9 +1,11 @@
+require 'webmachine/adapter'
 require 'webrick'
-require 'webmachine/version'
+require 'webmachine/constants'
 require 'webmachine/headers'
+require 'webmachine/adapters/lazy_request_body'
 require 'webmachine/request'
 require 'webmachine/response'
-require 'webmachine/dispatcher'
+require 'webmachine/version'
 
 module Webmachine
   module Adapters
@@ -15,22 +17,19 @@ module Webmachine
       # Starts the WEBrick adapter
       def run
         options = DEFAULT_OPTIONS.merge({
-          :Port => configuration.port,
-          :BindAddress => configuration.ip
-        }).merge(configuration.adapter_options)
-        @server = Server.new(dispatcher, options)
-        trap("INT") { shutdown }
+          :Port => application.configuration.port,
+          :BindAddress => application.configuration.ip,
+          :application => application
+        }).merge(application.configuration.adapter_options)
+        @server = Server.new(options)
         @server.start
       end
 
-      def shutdown
-        @server.shutdown if @server
-      end
-
       # WEBRick::HTTPServer that is run by the WEBrick adapter.
       class Server < ::WEBrick::HTTPServer
-        def initialize(dispatcher, options)
-          @dispatcher = dispatcher
+
+        def initialize(options)
+          @application = options[:application]
           super(options)
         end
 
@@ -42,8 +41,9 @@ module Webmachine
                                             wreq.request_uri,
                                             header,
                                             LazyRequestBody.new(wreq))
+
           response = Webmachine::Response.new
-          @dispatcher.dispatch(request, response)
+          @application.dispatcher.dispatch(request, response)
           wres.status = response.code.to_i
 
           headers = response.headers.flattened.reject { |k,v| k == 'Set-Cookie' }
@@ -52,12 +52,12 @@ module Webmachine
           cookies = [response.headers['Set-Cookie'] || []].flatten
           cookies.each { |c| wres.cookies << c }
 
-          wres['Server'] = [Webmachine::SERVER_STRING, wres.config[:ServerSoftware]].join(" ")
+          wres[SERVER] = [Webmachine::SERVER_STRING, wres.config[:ServerSoftware]].join(" ")
           case response.body
           when String
             wres.body << response.body
           when Enumerable
-            wres.chunked = response.headers['Transfer-Encoding'] == 'chunked'
+            wres.chunked = response.headers[TRANSFER_ENCODING] == 'chunked'
             response.body.each {|part| wres.body << part }
           else
             if response.body.respond_to?(:call)