m2r 1.0.0 → 2.0.0

data/lib/m2r/handler.rb

@@ -17,8 +17,12 @@ module M2R
 
     # @param [ConnectionFactory, Connection, #connection] connection_factory
     #   Factory for generating connections
-    def initialize(connection_factory)
+    #
+    # @param [#parse] parser
+    #   Parser of M2 requests
+    def initialize(connection_factory, parser)
       @connection = connection_factory.connection
+      @parser     = parser
     end
 
     # Start processing request
@@ -44,12 +48,14 @@ module M2R
     # Callback when a request is received
     # @api public
     # @!visibility public
+    # @param [Request] request Request object
     def on_request(request)
     end
 
     # Override to return a response
     # @api public
     # @!visibility public
+    # @param [Request] request Request object
     # @return [Response, String, #to_s] Response that should be sent to
     #   Mongrel2 instance
     def process(request)
@@ -60,24 +66,30 @@ module M2R
     # because client already disconnected.
     # @api public
     # @!visibility public
+    # @param [Request] request Request object
     def on_disconnect(request)
     end
 
     # Callback when async-upload started
     # @api public
     # @!visibility public
+    # @param [Request] request Request object
     def on_upload_start(request)
     end
 
     # Callback when async-upload finished
     # @api public
     # @!visibility public
+    # @param [Request] request Request object
     def on_upload_done(request)
     end
 
     # Callback after process_request is done
     # @api public
     # @!visibility public
+    # @param [Request] request Request object
+    # @param [Response, String, #to_s] response Response that should be sent to
+    #   Mongrel2 instance
     def after_process(request, response)
       return response
     end
@@ -85,6 +97,9 @@ module M2R
     # Callback after sending the response back
     # @api public
     # @!visibility public
+    # @param [Request] request Request object
+    # @param [Response, String, #to_s] response Response that was sent to
+    #   Mongrel2 instance
     def after_reply(request, response)
     end
 
@@ -93,18 +108,39 @@ module M2R
     # resources (closing files etc)
     # @api public
     # @!visibility public
+    # @note `response` might be nil depending on when exception occured.
+    # @note In case of error this callback is called before on_error
+    # @param [Request] request Request object
+    # @param [Response, String, #to_s, nil] response Response that was sent to
+    #   Mongrel2 instance
     def after_all(request, response)
     end
 
+    # Callback when exception occured
+    # @api public
+    # @!visibility public
+    # @note `request` and/or `response` might be nil depending on when error occured
+    # @param [Request, nil] request Request object
+    # @param [Response, String, #to_s, nil] response Response that might have been sent to
+    #   Mongrel2 instance
+    # @param [StandardError] error
+    def on_error(request, response, error)
+    end
+
     private
 
+    def next_request
+      @parser.parse @connection.receive
+    end
+
     def one_loop
       on_wait
       throw :stop if stop?
-      request_lifecycle(@connection.receive)
+      response = request_lifecycle(request = next_request)
+    rescue => error
+      on_error(request, response, error)
     end
 
-
     def request_lifecycle(request)
       on_request(request)
 
@@ -118,6 +154,7 @@ module M2R
       @connection.reply(request, response)
 
       after_reply(request, response)
+      return response
     ensure
       after_all(request, response)
     end

data/lib/m2r/headers.rb

@@ -7,7 +7,11 @@ module M2R
     include Enumerable
 
     # @param [Hash, #inject] hash Collection of headers
-    def initialize(hash = {})
+    # @param [true, false] compatible Whether the hash already contains
+    #   downcased strings only. If so it is going to be directly as
+    #   container for the headers.
+    def initialize(hash = {}, compatible = false)
+      @headers = hash and return if compatible
       @headers = hash.inject({}) do |headers,(header,value)|
         headers[transform_key(header)] = value
         headers
@@ -63,6 +67,10 @@ module M2R
       env
     end
 
+    def empty?
+      @headers.empty?
+    end
+
     protected
 
     def transform_key(key)

data/lib/m2r/http/close.rb

@@ -0,0 +1,30 @@
+module M2R
+  module HTTP
+
+    # Detect that whether connection should be closed
+    # based on http protocol version and `Connection' header
+    # We do not support persistent connections for HTTP 1.0
+    module Close
+
+      # @return [true, false] Information whether HTTP Connection should
+      #   be closed after processing the request. Happens when HTTP/1.0
+      #   or request has Connection=close header.
+      def close?
+        unsupported_version? || connection_close?
+      end
+
+      protected
+
+      # http://en.wikipedia.org/wiki/HTTP_persistent_connection
+      def unsupported_version?
+        http_version != 'HTTP/1.1'
+      end
+
+      def connection_close?
+        headers['Connection'] == 'close'
+      end
+
+    end
+
+  end
+end

data/lib/m2r/rack_handler.rb

@@ -7,9 +7,9 @@ module M2R
   class RackHandler < Handler
     attr_accessor :app
 
-    def initialize(app, connection_factory)
+    def initialize(app, connection_factory, parser)
       @app = app
-      super(connection_factory)
+      super(connection_factory, parser)
 
       trap('INT') { stop }
     end
@@ -36,7 +36,7 @@ module M2R
       status, headers, body = @app.call(env)
       buffer = ""
       body.each { |part| buffer << part }
-      return Response.new(status, headers, buffer)
+      return Response.new.status(status).headers(headers).body(buffer)
     end
 
     def after_all(request, response)

data/lib/m2r/reply.rb

@@ -0,0 +1,15 @@
+require 'm2r/response'
+require 'm2r/response/content_length'
+require 'm2r/response/to_request'
+
+module M2R
+  # Response object to be used without any other framework
+  # doing the job of handling content lenght and dealing with
+  # 'Connection' header.
+  #
+  # @api public
+  class Reply < Response
+    include Response::ContentLength
+    include Response::ToRequest
+  end
+end

data/lib/m2r/request.rb

@@ -1,4 +1,6 @@
+require 'set'
 require 'm2r'
+require 'm2r/http/close'
 require 'm2r/request/base'
 require 'm2r/request/upload'
 require 'm2r/headers'
@@ -8,10 +10,17 @@ module M2R
   # @api public
   class Request
     # @api private
-    TRUE_STRINGS     = %w(true yes on 1).map(&:freeze).freeze
+    TRUE_STRINGS            = Set.new(%w(true yes on 1).map(&:freeze)).freeze
+    # @api private
+    MONGREL2_BASE_HEADERS   = Set.new(%w(pattern method path query url_scheme version).map(&:upcase).map(&:freeze)).freeze
+    # @api private
+    MONGREL2_UPLOAD_HEADERS = Set.new(%w(x-mongrel2-upload-start x-mongrel2-upload-done).map(&:downcase).map(&:freeze)).freeze
+    # @api private
+    MONGREL2_HEADERS        = (MONGREL2_BASE_HEADERS + MONGREL2_UPLOAD_HEADERS).freeze
 
     include Base
     include Upload
+    include HTTP::Close
 
     # @return [String] UUID of mongrel2 origin instance
     attr_reader :sender
@@ -29,14 +38,16 @@ module M2R
     # @param [String] conn_id Mongrel2 connection id sending this request
     # @param [String] path HTTP Path of request
     # @param [M2R::Headers] headers HTTP headers of request
+    # @param [M2R::Headers] headers Additional mongrel2 headers
     # @param [String] body HTTP Body of request
-    def initialize(sender, conn_id, path, headers, body)
-      @http_headers, @mongrel_headers = split_headers(headers)
-      @sender  = sender
-      @conn_id = conn_id
-      @path    = path
-      @body    = body
-      @data    = MultiJson.load(@body) if json?
+    def initialize(sender, conn_id, path, http_headers, mongrel_headers, body)
+      @sender           = sender
+      @conn_id          = conn_id
+      @path             = path
+      @http_headers     = http_headers
+      @mongrel_headers  = mongrel_headers
+      @body             = body
+      @data             = MultiJson.load(@body) if json?
     end
 
     # Parse Mongrel2 request received via ZMQ message
@@ -51,8 +62,11 @@ module M2R
 
       headers, rest = TNetstring.parse(rest)
       body, _       = TNetstring.parse(rest)
-      headers       = Headers.new MultiJson.load(headers)
-      self.new(sender, conn_id, path, headers, body)
+      headers       = MultiJson.load(headers)
+      headers, mong = split_headers(headers)
+      headers       = Headers.new headers, true
+      mong          = Headers.new mong, true
+      self.new(sender, conn_id, path, headers, mong, body)
     end
 
     # @return [M2R::Headers] HTTP headers
@@ -80,6 +94,10 @@ module M2R
       @mongrel_headers['url_scheme'] || mongrel17_scheme
     end
 
+    def http_version
+      @mongrel_headers['version']
+    end
+
     # @return [true, false] Internal mongrel2 message to handler issued when
     #   message delivery is not possible because the client already
     #   disconnected and there is no connection with such {#conn_id}
@@ -87,13 +105,6 @@ module M2R
       json? and @data['type'] == 'disconnect'
     end
 
-    # @return [true, false] Information whether HTTP Connection should
-    #   be closed after processing the request. Happens when HTTP/1.0
-    #   or request has Connection=close header.
-    def close?
-      unsupported_version? or connection_close?
-    end
-
     protected
 
     def mongrel17_scheme
@@ -105,25 +116,21 @@ module M2R
       (ENV['HTTPS'] || "").downcase
     end
 
-    def unsupported_version?
-      @http_headers['version'] != 'HTTP/1.1'
-    end
-
-    def connection_close?
-      @http_headers['connection'] == 'close'
-    end
-
     def json?
       method == 'JSON'
     end
 
-    def split_headers(headers)
-      mongrel = Headers.new
-      mongrel_headers.each do |header|
-        next unless headers[header]
-        mongrel[header] = headers.delete(header)
+    def self.split_headers(headers)
+      http    = {}
+      mongrel = {}
+      headers.each do |header, value|
+        if MONGREL2_HEADERS.include?(header)
+          mongrel[header.downcase] = value
+        else
+          http[header] = value
+        end
       end
-      return headers, mongrel
+      return http, mongrel
     end
   end
 end

data/lib/m2r/request/base.rb

@@ -4,8 +4,6 @@ module M2R
   #
   # @private
   module Base
-    MONGREL2_BASE_HEADERS = %w(pattern method path query url_scheme).map(&:freeze).freeze
-
     # @return [StringIO] Request body encapsulated in IO compatible object
     # @api public
     def body_io
@@ -22,12 +20,6 @@ module M2R
       body_io.close
     end
 
-    protected
-
-    def mongrel_headers
-      MONGREL2_BASE_HEADERS
-    end
-
   end
 end
 

data/lib/m2r/request/upload.rb

@@ -3,10 +3,6 @@ module M2R
   # Contains methods for recognizing such requests and reading them.
   # @private
   module Upload
-    # Headers related to async-upload feature
-    # @private
-    MONGREL2_UPLOAD_HEADERS = %w(x-mongrel2-upload-start x-mongrel2-upload-done).map(&:freeze).freeze
-
     # @return [true,false] True if this is async-upload related request
     # @api public
     def upload?
@@ -49,12 +45,6 @@ module M2R
       super
       File.delete(body_io.path) if upload_done?
     end
-
-    protected
-
-    def mongrel_headers
-      super + MONGREL2_UPLOAD_HEADERS
-    end
   end
 end
 

data/lib/m2r/response.rb

@@ -1,11 +1,14 @@
 require 'm2r'
+require 'm2r/http/close'
 require 'm2r/response/content_length'
+require 'm2r/response/to_request'
 
 module M2R
   # Simplest possible abstraction layer over HTTP request
   #
   # @api public
   class Response
+    include HTTP::Close
 
     # @private
     VERSION      = "HTTP/1.1".freeze
@@ -66,37 +69,80 @@ module M2R
     }
     STATUS_CODES.freeze
 
-    # @return [Fixnum] HTTP Status code
-    attr_reader :status
+    attr_reader :reason
+
+    def initialize
+      status(200)
+      headers(Headers.new)
+      body("")
+      http_version(VERSION)
+    end
 
-    # @return [Hash, Headers] Collection of response HTTP Headers
-    attr_reader :headers
+    # @param [Fixnum, #to_i] value HTTP status code
+    def status(value = GETTER)
+      if value == GETTER
+        @status
+      else
+        @status = value.to_i
+        @reason = STATUS_CODES[@status]
+        self
+      end
+    end
 
-    # @return [String] HTTP Body
-    attr_reader :body
+    # @param [Hash] value HTTP headers
+    def headers(value = GETTER)
+      if value == GETTER
+        @headers
+      else
+        @headers = value
+        self
+      end
+    end
 
-    # @return [String] HTTP Status code description
-    attr_reader :reason
+    # @param [Hash] header HTTP header key
+    # @param [Hash] value HTTP header value
+    def header(header, value = GETTER)
+      if value == GETTER
+        @headers[header]
+      else
+        @headers[header] = value
+        self
+      end
+    end
+
+    # @param [String, nil] value HTTP body
+    def body(value = GETTER)
+      if value == GETTER
+        @body
+      else
+        @body = value
+        self
+      end
+    end
 
-    # @param [Fixnum, #to_i] status HTTP status code
-    # @param [Hash] headers HTTP headers
-    # @param [String, nil] body HTTP body
-    def initialize(status, headers, body = nil)
-      @status  = status.to_i
-      @headers = headers
-      @body    = body || ""
-      @reason  = STATUS_CODES[status.to_i]
+    # @param [String, nil] version HTTP body
+    def http_version(value = GETTER)
+      if value == GETTER
+        @version
+      else
+        @version = value
+        self
+      end
     end
 
     # @return [String] HTTP Response
     def to_s
-      response = "#{VERSION} #{status} #{reason}#{CRLF}"
+      response = "#{http_version} #{status} #{reason}#{CRLF}"
       unless headers.empty?
         response << headers.map { |h, v| "#{h}: #{v}" }.join(CRLF) << CRLF
       end
       response << CRLF
-      response << body
+      response << body.to_s
       response
     end
+
+    protected
+
+    GETTER = Object.new
   end
 end