goliath 0.9.0

data/lib/goliath/rack/tracer.rb

@@ -0,0 +1,31 @@
+module Goliath
+  module Rack
+    # Middleware to inject the tracer statistics into the response headers.
+    #
+    # @example
+    #  use Goliath::Rack::Tracer
+    #
+    class Tracer
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        async_cb = env['async.callback']
+
+        env['async.callback'] = Proc.new do |status, headers, body|
+          async_cb.call(post_process(env, status, headers, body))
+          env.logger.info env.trace_stats.collect{|s| s.join(':')}.join(', ')
+        end
+
+        status, headers, body = @app.call(env)
+        post_process(env, status, headers, body)
+      end
+
+      def post_process(env, status, headers, body)
+        extra = { 'X-PostRank' => env.trace_stats.collect{|s| s.join(': ')}.join(', ')}
+        [status, headers.merge(extra), body]
+      end
+    end
+  end
+end

data/lib/goliath/rack/validation/boolean_value.rb

@@ -0,0 +1,59 @@
+module Goliath
+  module Rack
+    module Validation
+      # A middleware to validate a given value is boolean. This will attempt to do the following
+      # conversions:
+      #  true  = 'true'  | 't' | 1
+      #  false = 'false' | 'f' | 0
+      #
+      # If the parameter is not provided the :default is used.
+      #
+      # @example
+      #  use Goliath::Rack::Validation::BooleanValue, {:key => 'raw', :default => false}
+      #
+      class BooleanValue
+        # Called by the framework to create the validator
+        #
+        # @param app The app object
+        # @param opts [Hash] The options hash
+        # @option opts [String] :key The key to access in the parameters
+        # @option opts [Boolean] :default The default value to set
+        # @return [Goliath::Rack::Validation::BooleanValue] The validator
+        def initialize(app, opts = {})
+          @app = app
+          @key = opts[:key]
+          raise Exception.new("BooleanValue key required") if @key.nil?
+
+          @default = opts[:default]
+        end
+
+        def call(env)
+          if !env['params'].has_key?(@key) || env['params'][@key].nil? || env['params'][@key] == ''
+            env['params'][@key] = @default
+
+          else
+            if env['params'][@key].instance_of?(Array)
+              env['params'][@key] = env['params'][@key].first
+            end
+
+            if env['params'][@key].downcase == 'true' ||
+                env['params'][@key].downcase == 't' ||
+                env['params'][@key].to_i == 1
+              env['params'][@key] = true
+
+            elsif env['params'][@key].downcase == 'false' ||
+                env['params'][@key].downcase == 'f' ||
+                env['params'][@key].to_i == 0
+              env['params'][@key] = false
+
+            else
+              env['params'][@key] = @default
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/validation/default_params.rb

@@ -0,0 +1,46 @@
+require 'goliath/rack/validation_error'
+
+module Goliath
+  module Rack
+    module Validation
+      # A middleware to validate that a parameter always has a value
+      #
+      # @example
+      #  use Goliath::Rack::Validation::DefaultParams, {:key => 'order', :defaults => 'pubdate'}
+      #
+      class DefaultParams
+        # Called by the framework to create the validator
+        #
+        # @param app The app object
+        # @param opts [Hash] The options hash
+        # @option opts [String] :key The key to access in the parameters
+        # @option opts :defaults The default value to assign if the key is empty or non-existant
+        # @return [Goliath::Rack::Validation::DefaultParams] The validator
+        def initialize(app, opts = {})
+          @app = app
+          @defaults = opts[:defaults]
+          raise Exception.new("Must provide defaults to DefaultParams") if @defaults.nil?
+
+          @key = opts[:key]
+          raise Exception.new("must provide key to DefaultParams") if @key.nil? || @key =~ /^\s*$/
+        end
+
+        def call(env)
+          if !env['params'].has_key?(@key) || env['params'][@key].nil?
+            env['params'][@key] = @defaults
+
+          elsif env['params'][@key].is_a?(Array) && env['params'][@key].empty?
+            env['params'][@key] = @defaults
+
+          elsif env['params'][@key].is_a?(String)
+            if env['params'][@key] =~ /^\s*$/
+              env['params'][@key] = @defaults
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/validation/numeric_range.rb

@@ -0,0 +1,59 @@
+module Goliath
+  module Rack
+    module Validation
+      # A middleware to validate that a parameter value is within a given range. If the value
+      # falls outside the range, or is not provided the default will be used, if provided.
+      # If no default the :min or :max values will be applied to the parameter.
+      #
+      # @example
+      #  use Goliath::Rack::Validation::NumericRange, {:key => 'num', :min => 1, :max => 30, :default => 10}
+      #  use Goliath::Rack::Validation::NumericRange, {:key => 'num', :min => 1}
+      #  use Goliath::Rack::Validation::NumericRange, {:key => 'num', :max => 10}
+      #
+      class NumericRange
+        # Called by the framework to create the Goliath::Rack::Validation::NumericRange validator
+        #
+        # @param app The app object
+        # @param opts [Hash] The options hash
+        # @option opts [String] :key The key to look for in the parameters
+        # @option opts [Integer] :min The minimum value
+        # @option opts [Integer] :max The maximum value
+        # @option opts [Integer] :default The default to set if outside the range
+        # @return [Goliath::Rack::Validation::NumericRange] The validator
+        def initialize(app, opts = {})
+          @app = app
+          @key = opts[:key]
+          raise Exception.new("NumericRange key required") if @key.nil?
+
+          @min = opts[:min]
+          @max = opts[:max]
+          raise Exception.new("NumericRange requires :min or :max") if @min.nil? && @max.nil?
+
+          @default = opts[:default]
+        end
+
+        def call(env)
+          if !env['params'].has_key?(@key) || env['params'][@key].nil?
+            env['params'][@key] = value
+
+          else
+            if env['params'][@key].instance_of?(Array) then
+              env['params'][@key] = env['params'][@key].first
+            end
+            env['params'][@key] = env['params'][@key].to_i
+
+            if (!@min.nil? && env['params'][@key] < @min) || (!@max.nil? && env['params'][@key] > @max)
+              env['params'][@key] = value
+            end
+          end
+
+          @app.call(env)
+        end
+
+        def value
+          @default || @min || @max
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/validation/request_method.rb

@@ -0,0 +1,33 @@
+require 'goliath/rack/validation_error'
+
+module Goliath
+  module Rack
+    module Validation
+      # A middleware to validate that the request had a given HTTP method.
+      #
+      # @example
+      #  use Goliath::Rack::Validation::RequestMethod, %w(GET POST)
+      #
+      class RequestMethod
+        attr_reader :methods
+
+        ERROR = 'Invalid request method'
+
+        # Called by the framework to create the Goliath::Rack::Validation::RequestMethod validator
+        #
+        # @param app The app object
+        # @param methods [Array] The accepted request methods
+        # @return [Goliath::Rack::Validation::RequestMethod] The validator
+        def initialize(app, methods = [])
+          @app = app
+          @methods = methods
+        end
+
+        def call(env)
+          raise Goliath::Validation::Error.new(400, ERROR) unless methods.include?(env['REQUEST_METHOD'])
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/validation/required_param.rb

@@ -0,0 +1,54 @@
+require 'goliath/rack/validation_error'
+
+module Goliath
+  module Rack
+    module Validation
+      # A middleware to validate that a given parameter is provided.
+      #
+      # @example
+      #  use Goliath::Rack::Validation::RequiredParam, {:key => 'mode', :type => 'Mode'}
+      #
+      class RequiredParam
+        attr_reader :type, :key
+
+        # Creates the Goliath::Rack::Validation::RequiredParam validator
+        #
+        # @param app The app object
+        # @param opts [Hash] The validator options
+        # @option opts [String] :key The key to look for in params (default: id)
+        # @option opts [String] :type The type string to put in the error message. (default: :key)
+        # @return [Goliath::Rack::Validation::RequiredParam] The validator
+        def initialize(app, opts = {})
+          @app = app
+          @key = opts[:key] || 'id'
+          @type = opts[:type] || @key.capitalize
+        end
+
+        def call(env)
+          key_valid!(env['params'])
+          @app.call(env)
+        end
+
+        def key_valid!(params)
+          error = false
+          if !params.has_key?(key) || params[key].nil? ||
+              (params[key].is_a?(String) && params[key] =~ /^\s*$/)
+            error = true
+          end
+
+          if params[key].is_a?(Array)
+            unless params[key].compact.empty?
+              params[key].each do |k|
+                return unless k.is_a?(String)
+                return unless k =~ /^\s*$/
+              end
+            end
+            error = true
+          end
+
+          raise Goliath::Validation::Error.new(400, "#{@type} identifier missing") if error
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/validation/required_value.rb

@@ -0,0 +1,58 @@
+require 'goliath/rack/validation_error'
+
+module Goliath
+  module Rack
+    module Validation
+      # Middleware to validate that a given parameter has a specified value.
+      #
+      # @example
+      #  use Goliath::Rack::Validation::RequiredValue, {:key => 'mode', :values => %w(foo bar)}
+      #  use Goliath::Rack::Validation::RequiredValue, {:key => 'baz', :values => 'awesome'}
+      #
+      class RequiredValue
+        attr_reader :key, :values
+
+        # Creates the Goliath::Rack::Validation::RequiredValue validator.
+        #
+        # @param app The app object
+        # @param opts [Hash] The options to create the validator with
+        # @option opts [String] :key The key to look for in params (default: id)
+        # @option opts [String | Array] :values The values to verify are in the params
+        # @return [Goliath::Rack::Validation::RequiredValue] The validator
+        def initialize(app, opts = {})
+          @app = app
+          @key = opts[:key] || 'id'
+          @values = [opts[:values]].flatten
+        end
+
+        def call(env)
+          value_valid!(env['params'])
+          @app.call(env)
+        end
+
+        def value_valid!(params)
+          error = false
+          if !params.has_key?(key) || params[key].nil? ||
+              (params[key].is_a?(String) && params[key] =~ /^\s*$/)
+            error = true
+          end
+
+          if params[key].is_a?(Array)
+            error = true if params[key].empty?
+
+            params[key].each do |k|
+              unless values.include?(k)
+               error = true
+               break
+              end
+            end
+          elsif !values.include?(params[key])
+            error = true
+          end
+
+          raise Goliath::Validation::Error.new(400, "Provided #{@key} is invalid") if error
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/validation_error.rb

@@ -0,0 +1,38 @@
+module Goliath
+  module Validation
+    # A information about exceptions raised during validation.
+    class Error < StandardError
+      # The status code to return from the error handler
+      attr_accessor :status_code
+
+      # Create a new Goliath::Validation::Error.
+      #
+      # @example
+      #  raise Goliath::Validation::Error.new(401, "Invalid credentials")
+      #
+      # @param status_code [Integer] The status code to return
+      # @param message [String] The error message to return
+      # @return [Goliath::Validation::Error] The Goliath::Validation::Error
+      def initialize(status_code, message)
+        super(message)
+        @status_code = status_code
+      end
+    end
+  end
+
+  module Rack
+    # Middleware to catch {Goliath::Validation::Error} exceptions
+    # and returns the [status code, no headers, :error => exception message]
+    class ValidationError
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue Goliath::Validation::Error => e
+        [e.status_code, {}, {:error => e.message}]
+      end
+    end
+  end
+end

data/lib/goliath/request.rb

@@ -0,0 +1,199 @@
+require 'eventmachine'
+require 'goliath/constants'
+require 'async_rack'
+require 'stringio'
+
+module Goliath
+  # Goliath::Request is responsible for processing a request and returning
+  # the result back to the client.
+  #
+  # @private
+  class Request
+    include EM::Deferrable
+    include Constants
+
+    attr_accessor :app, :conn, :env, :response, :body
+
+    def initialize(app, conn, env)
+      @app  = app
+      @conn = conn
+      @env  = env
+
+      @response = Goliath::Response.new
+      @body = StringIO.new(INITIAL_BODY.dup)
+      @env[RACK_INPUT] = body
+      @env[ASYNC_CALLBACK] = method(:post_process)
+
+      @env[STREAM_SEND]  = proc { |data| callback { @conn.send_data(data) } }
+      @env[STREAM_CLOSE] = proc { callback { @conn.terminate_request(false) } }
+      @env[STREAM_START] = proc do
+        callback do
+          @conn.send_data(@response.head)
+          @conn.send_data(@response.headers_output)
+        end
+      end
+
+      @state = :processing
+    end
+
+    # Invoked by connection when header parsing is complete.
+    # This method is invoked only once per request.
+    #
+    # @param h [Hash] Request headers
+    # @param parser [Http::Parser] The parsed used to parse the request
+    # @return [Nil]
+    def parse_header(h, parser)
+      h.each do |k, v|
+        @env[HTTP_PREFIX + k.gsub('-','_').upcase] = v
+      end
+
+      @env[STATUS]          = parser.status_code
+      @env[REQUEST_METHOD]  = parser.http_method
+      @env[REQUEST_URI]     = parser.request_url
+      @env[QUERY_STRING]    = parser.query_string
+      @env[HTTP_VERSION]    = parser.http_version.join('.')
+      @env[SCRIPT_NAME]     = parser.request_path
+      @env[REQUEST_PATH]    = parser.request_path
+      @env[PATH_INFO]       = parser.request_path
+      @env[FRAGMENT]        = parser.fragment
+
+      begin
+        @env[ASYNC_HEADERS].call(@env, h) if @env[ASYNC_HEADERS]
+      rescue Exception => e
+        server_exception(e)
+      end
+    end
+
+    # Invoked by connection when new body data is
+    # parsed from the existing TCP stream.
+    #
+    # @note In theory, we can make this stream the
+    # data into the processing step for async
+    # uploads, etc. This would also require additional
+    # callbacks for headers, etc.. Maybe something to
+    # explore later.
+    #
+    # @param data [String] The received data
+    # @return [Nil]
+    def parse(data)
+      begin
+        if @env[ASYNC_BODY]
+          @env[ASYNC_BODY].call(@env, data)
+        else
+          @body << data
+        end
+      rescue Exception => e
+        server_exception(e)
+      end
+    end
+
+    # Called to determine if the request has received all data from the client
+    #
+    # @return [Boolean] True if all data is received, false otherwise
+    def finished?
+      @state == :finished
+    end
+
+    # Invoked by connection when upstream client
+    # terminates the current TCP session.
+    #
+    # @return [Nil]
+    def close
+      @response.close rescue nil
+
+      begin
+        @env[ASYNC_CLOSE].call(@env) if @env[ASYNC_CLOSE]
+      rescue Exception => e
+        server_exception(e)
+      end
+    end
+
+    # Invoked by connection when the parsing of the
+    # HTTP request and body complete. From this point
+    # all synchronous middleware will run until either
+    # an immediate response is served, or an async
+    # response is indicated.
+    #
+    # @return [Nil]
+    def process
+      begin
+        @state = :finished
+        post_process(@app.call(@env))
+
+      rescue Exception => e
+        server_exception(e)
+      end
+    end
+
+    # Invoked by the app / middleware once the request
+    # is complete. A special async code is returned if
+    # the response is not ready yet.
+    #
+    # Sending of the data is deferred until the request
+    # is marked as ready to push data by the connection.
+    # Hence, two pipelined requests can come in via same
+    # connection, first can take take 1s to render, while
+    # second may take 0.5. Because HTTP spec does not
+    # allow for interleaved data exchange, we block the
+    # second request until the first one is done and the
+    # data is sent.
+    #
+    # However, processing on the server is done in parallel
+    # so the actual time to serve both requests in scenario
+    # above, should be ~1s + data transfer time.
+    #
+    # @param results [Array] The status, headers and body to return to the client
+    # @return [Nil]
+    def post_process(results)
+      begin
+        status, headers, body = results
+        return if status && status == Goliath::Connection::AsyncResponse.first
+
+        callback do
+          begin
+            @response.status, @response.headers, @response.body = status, headers, body
+            @response.each { |chunk| @conn.send_data(chunk) }
+            @env[LOGGER].info("Status: #{@response.status}, " +
+                              "Content-Length: #{@response.headers['Content-Length']}, " +
+                              "Response Time: #{"%.2f" % ((Time.now.to_f - @env[:start_time]) * 1000)}ms")
+
+            @conn.terminate_request(keep_alive)
+          rescue Exception => e
+            server_exception(e)
+          end
+        end
+
+      rescue Exception => e
+        server_exception(e)
+      end
+    end
+
+    private
+
+    # Handles logging server exceptions
+    #
+    # @param e [Exception] The exception to log
+    # @return [Nil]
+    def server_exception(e)
+      @env[LOGGER].error("#{e.message}\n#{e.backtrace.join("\n")}")
+      post_process([500, {}, 'An error happened'])
+    end
+
+    # Used to determine if the connection should  be kept open
+    #
+    # @return [Boolean] True to keep the connection open, false otherwise
+    def keep_alive
+      case @env[HTTP_VERSION]
+        # HTTP 1.1: all requests are persistent requests, client
+        # must send a Connection:close header to indicate otherwise
+        when '1.1' then
+          (@env[HTTP_PREFIX + CONNECTION].downcase != 'close') rescue true
+
+          # HTTP 1.0: all requests are non keep-alive, client must
+          # send a Connection: Keep-Alive to indicate otherwise
+        when '1.0' then
+          (@env[HTTP_PREFIX + CONNECTION].downcase == 'keep-alive') rescue false
+      end
+    end
+  end
+end