goliath 0.9.1 → 0.9.2

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

@@ -1,4 +1,4 @@
-require 'goliath/rack/validation_error'
+require 'goliath/rack/validator'
 
 module Goliath
   module Rack
@@ -9,6 +9,7 @@ module Goliath
       #  use Goliath::Rack::Validation::RequestMethod, %w(GET POST)
       #
       class RequestMethod
+        include Goliath::Rack::Validator
         attr_reader :methods
 
         ERROR = 'Invalid request method'
@@ -24,7 +25,7 @@ module Goliath
         end
 
         def call(env)
-          raise Goliath::Validation::Error.new(400, ERROR) unless methods.include?(env['REQUEST_METHOD'])
+          return validation_error(405, ERROR, "Allow" => methods.map{|m| m.to_s.upcase}.join(', ')) unless methods.include?(env['REQUEST_METHOD'])
           @app.call(env)
         end
       end

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

@@ -1,4 +1,4 @@
-require 'goliath/rack/validation_error'
+require 'goliath/rack/validator'
 
 module Goliath
   module Rack
@@ -9,7 +9,8 @@ module Goliath
       #  use Goliath::Rack::Validation::RequiredParam, {:key => 'mode', :type => 'Mode'}
       #
       class RequiredParam
-        attr_reader :type, :key
+        include Goliath::Rack::Validator
+        attr_reader :type, :key, :message
 
         # Creates the Goliath::Rack::Validation::RequiredParam validator
         #
@@ -17,38 +18,39 @@ module Goliath
         # @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)
+        # @option opts [String] :message The message string to display after the type string. (default: 'identifier missing')
         # @return [Goliath::Rack::Validation::RequiredParam] The validator
         def initialize(app, opts = {})
           @app = app
           @key = opts[:key] || 'id'
           @type = opts[:type] || @key.capitalize
+          @message = opts[:message] || 'identifier missing'
         end
 
         def call(env)
-          key_valid!(env['params'])
+          return validation_error(400, "#{@type} #{@message}") unless key_valid?(env['params'])
           @app.call(env)
         end
 
-        def key_valid!(params)
-          error = false
+        def key_valid?(params)
           if !params.has_key?(key) || params[key].nil? ||
               (params[key].is_a?(String) && params[key] =~ /^\s*$/)
-            error = true
+            return false
           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*$/
+                return true unless k.is_a?(String)
+                return true unless k =~ /^\s*$/
               end
             end
-            error = true
+            return false
           end
 
-          raise Goliath::Validation::Error.new(400, "#{@type} identifier missing") if error
+          true
         end
       end
     end
   end
-end
+end

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

@@ -1,4 +1,4 @@
-require 'goliath/rack/validation_error'
+require 'goliath/rack/validator'
 
 module Goliath
   module Rack
@@ -10,6 +10,8 @@ module Goliath
       #  use Goliath::Rack::Validation::RequiredValue, {:key => 'baz', :values => 'awesome'}
       #
       class RequiredValue
+        include Goliath::Rack::Validator
+
         attr_reader :key, :values
 
         # Creates the Goliath::Rack::Validation::RequiredValue validator.
@@ -26,31 +28,25 @@ module Goliath
         end
 
         def call(env)
-          value_valid!(env['params'])
+          return validation_error(400, "Provided #{@key} is invalid") unless value_valid?(env['params'])
           @app.call(env)
         end
 
-        def value_valid!(params)
-          error = false
+        def value_valid?(params)
           if !params.has_key?(key) || params[key].nil? ||
               (params[key].is_a?(String) && params[key] =~ /^\s*$/)
-            error = true
+            return false
           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
+            return false if params[key].empty?
+            params[key].each { |k| return false unless values.include?(k) }
+
           elsif !values.include?(params[key])
-            error = true
+            return false
           end
 
-          raise Goliath::Validation::Error.new(400, "Provided #{@key} is invalid") if error
+          true
         end
       end
     end

data/lib/goliath/rack/validator.rb

@@ -0,0 +1,51 @@
+module Goliath
+  module Rack
+    module Validator
+      module_function
+
+      # @param status_code [Integer] HTTP status code for this error.
+      # @param msg [String] message to inject into the response body.
+      # @param headers [Hash] Response headers to preserve in an error response;
+      #   (the Content-Length header, if any, is removed)
+      def validation_error(status_code, msg, headers={})
+        headers.delete('Content-Length')
+        [status_code, headers, {:error => msg}]
+      end
+
+      # Execute a block of code safely.
+      #
+      # If the block raises any exception that derives from
+      # Goliath::Validation::Error (see specifically those in
+      # goliath/validation/standard_http_errors.rb), it will be turned into the
+      # corresponding 4xx response with a corresponding message.
+      #
+      # If the block raises any other kind of error, we log it and return a
+      # less-communicative 500 response.
+      #
+      # @example
+      #   # will convert the ForbiddenError exception into a 403 response
+      #   # and an uncaught error in do_something_risky! into a 500 response
+      #   safely(env, headers) do
+      #     raise ForbiddenError unless account_info['valid'] == true
+      #     do_something_risky!
+      #     [status, headers, body]
+      #   end
+      #
+      #
+      # @param env [Goliath::Env] The current request env
+      # @param headers [Hash] Response headers to preserve in an error response
+      #
+      def safely(env, headers={})
+        begin
+          yield
+        rescue Goliath::Validation::Error => e
+          validation_error(e.status_code, e.message, headers)
+        rescue Exception => e
+          env.logger.error(e.message)
+          env.logger.error(e.backtrace.join("\n"))
+          validation_error(500, e.message, headers)
+        end
+      end
+    end
+  end
+end

data/lib/goliath/request.rb

@@ -1,5 +1,7 @@
 require 'eventmachine'
 require 'goliath/constants'
+require 'goliath/response'
+require 'goliath/validation'
 require 'async_rack'
 require 'stringio'
 
@@ -26,8 +28,11 @@ module Goliath
 
       @env[STREAM_SEND]  = proc { |data| callback { @conn.send_data(data) } }
       @env[STREAM_CLOSE] = proc { callback { @conn.terminate_request(false) } }
-      @env[STREAM_START] = proc do
+      @env[STREAM_START] = proc do |status, headers|
         callback do
+          @response.status = status
+          @response.headers = headers
+
           @conn.send_data(@response.head)
           @conn.send_data(@response.headers_output)
         end
@@ -125,14 +130,15 @@ module Goliath
     #
     # @return [Nil]
     def process
-      begin
-        @state = :finished
-        @env['rack.input'].rewind if @env['rack.input']
-        post_process(@app.call(@env))
-
-      rescue Exception => e
-        server_exception(e)
-      end
+      Fiber.new {
+        begin
+          @state = :finished
+          @env['rack.input'].rewind if @env['rack.input']
+          post_process(@app.call(@env))
+        rescue Exception => e
+          server_exception(e)
+        end
+      }.resume
     end
 
     # Invoked by the app / middleware once the request
@@ -164,10 +170,10 @@ module Goliath
             @response.status, @response.headers, @response.body = status, headers, body
             @response.each { |chunk| @conn.send_data(chunk) }
             @env[RACK_LOGGER].info("Status: #{@response.status}, " +
-                              "Content-Length: #{@response.headers['Content-Length']}, " +
-                              "Response Time: #{"%.2f" % ((Time.now.to_f - @env[:start_time]) * 1000)}ms")
+                                   "Content-Length: #{@response.headers['Content-Length']}, " +
+                                   "Response Time: #{"%.2f" % ((Time.now.to_f - @env[:start_time]) * 1000)}ms")
 
-            @conn.terminate_request(keep_alive)
+                                   @conn.terminate_request(keep_alive)
           rescue Exception => e
             server_exception(e)
           end
@@ -185,24 +191,32 @@ module Goliath
     # @param e [Exception] The exception to log
     # @return [Nil]
     def server_exception(e)
-      @env[RACK_LOGGER].error("#{e.message}\n#{e.backtrace.join("\n")}")
-      post_process([500, {}, 'An error happened'])
+      if e.is_a?(Goliath::Validation::Error)
+        status, headers, body = [e.status_code, {}, ('{"error":"%s"}'%e.message)]  #
+      else
+        @env[RACK_LOGGER].error("#{e.message}\n#{e.backtrace.join("\n")}")
+        status, headers, body = [500, {}, 'An error happened']
+      end
+      headers['Content-Length'] = body.bytesize.to_s
+      @env[:terminate_connection] = true
+      post_process([status, headers, body])
     end
 
     # Used to determine if the connection should  be kept open
     #
     # @return [Boolean] True to keep the connection open, false otherwise
     def keep_alive
+      return false if @env[:terminate_connection]
       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
+      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
+        # 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

data/lib/goliath/response.rb

@@ -18,11 +18,12 @@ module Goliath
     # The body to send
     attr_accessor :body
 
-    SERVER = 'Server'.freeze
-    DATE = 'Date'.freeze
+    SERVER = 'Server'
+    DATE = 'Date'
 
     # Used to signal that a response is a streaming response
     STREAMING = :goliath_stream_response
+    CHUNKED_STREAM_HEADERS = { 'Transfer-Encoding' => 'chunked' }
 
     def initialize
       @headers = Goliath::Headers.new

data/lib/goliath/runner.rb

@@ -4,7 +4,7 @@ require 'optparse'
 require 'log4r'
 
 module Goliath
-  # The Goliath::Runner is responsible for parsing any provided options, settting up the
+  # The Goliath::Runner is responsible for parsing any provided options, setting up the
   # rack application, creating a logger, and then executing the Goliath::Server with the loaded information.
   class Runner
     # The address of the server @example 127.0.0.1
@@ -63,6 +63,7 @@ module Goliath
     def initialize(argv, api)
       api.options_parser(options_parser, options) if api
       options_parser.parse!(argv)
+      Goliath.env = options.delete(:env)
 
       @api = api
       @address = options.delete(:address)
@@ -88,7 +89,8 @@ module Goliath
 
         :daemonize => false,
         :verbose => false,
-        :log_stdout => false
+        :log_stdout => false,
+        :env => :development,
       }
 
       @options_parser ||= OptionParser.new do |opts|
@@ -97,7 +99,7 @@ module Goliath
         opts.separator ""
         opts.separator "Server options:"
 
-        opts.on('-e', '--environment NAME', "Set the execution environment (prod, dev or test) (default: #{Goliath.env})") { |val| Goliath.env = val }
+        opts.on('-e', '--environment NAME', "Set the execution environment (prod, dev or test) (default: #{@options[:env]})") { |val| @options[:env] = val }
 
         opts.on('-a', '--address HOST', "Bind to HOST address (default: #{@options[:address]})") { |addr| @options[:address] = addr }
         opts.on('-p', '--port PORT', "Use PORT (default: #{@options[:port]})") { |port| @options[:port] = port.to_i }
@@ -115,14 +117,6 @@ module Goliath
       end
     end
 
-    # Given a block, this will use Rack::Builder to create the application
-    #
-    # @param blk [Block] The application block to load
-    # @return [Object] The Rack application
-    def load_app(&blk)
-      @app = ::Rack::Builder.app(&blk)
-    end
-
     # Stores the list of plugins to be used by the server
     #
     # @param plugins [Array] The list of plugins to use

data/lib/goliath/server.rb

@@ -68,7 +68,7 @@ module Goliath
     # start listening for requests
     #
     # @return Does not return until the server has halted.
-    def start
+    def start(&blk)
       EM.synchrony do
         trap("INT")  { EM.stop }
         trap("TERM") { EM.stop }
@@ -90,6 +90,7 @@ module Goliath
           conn.options = options
         end
 
+        blk.call(self) if blk
       end
     end
 

data/lib/goliath/synchrony/mongo_receiver.rb

@@ -0,0 +1,64 @@
+require 'goliath/synchrony/response_receiver'
+
+module Goliath
+  module Synchrony
+    #
+    # Currently, you must provide in the env a method 'mongo' that returns a mongo
+    # collection or collection proxy (probably by setting it up in the config).
+    #
+    # This will almost certainly change to something less crappy.
+    #
+    class MongoReceiver
+      include Goliath::Synchrony::ResponseReceiver
+      include EM::Deferrable
+      include Goliath::Rack::Validator
+
+      def initialize(env, db_name)
+        @env = env
+        @pending_queries = 0
+        @db = env.config[db_name]
+      end
+
+      def db
+        @db
+      end
+
+      def finished?
+        response_received? && (@pending_queries == 0)
+      end
+
+      def enqueue(handle, req_id)
+        # ... requests aren't deferrables so they're tracked in @pending_queries
+      end
+
+      def find(collection, selector={}, opts={}, &block)
+        @pending_queries += 1
+        db.collection(collection).find(selector, opts) do |result|
+          yield result
+          @pending_queries -= 1
+          self.succeed if finished?
+        end
+      end
+
+      def first(collection, selector={}, opts={}, &block)
+        opts[:limit] = 1
+        find(collection, selector, opts) do |result|
+          yield result.first
+        end
+      end
+
+      def insert(collection, *args)
+        db.collection(collection).insert(*args)
+      end
+      def update(collection, *args)
+        db.collection(collection).update(*args)
+      end
+      def save(collection, *args)
+        db.collection(collection).save(*args)
+      end
+      def remove(collection, *args)
+        db.collection(collection).remove(*args)
+      end
+    end
+  end
+end

data/lib/goliath/synchrony/response_receiver.rb

@@ -0,0 +1,64 @@
+module Goliath
+  module Synchrony
+
+    #
+    # FIXME: generalize this to work with any deferrable
+    module ResponseReceiver
+      attr_accessor :env, :status, :headers, :body
+
+      # Override this method in your middleware to perform any preprocessing
+      # (launching a deferred request, perhaps)
+      def pre_process
+      end
+
+      # Override this method in your middleware to perform any postprocessing.  This
+      # will only be invoked when the deferrable and the response have been
+      # received.
+      #
+      # @return [Array] array contains [status, headers, body]
+      def post_process
+        [status, headers, body]
+      end
+
+      # Invoked by the async_callback chain. Stores the [status, headers, body]
+      # for post_process'ing
+      def call shb
+        return shb if shb.first == Goliath::Connection::AsyncResponse.first
+        @status, @headers, @body = shb
+        succeed if finished?
+      end
+
+      # Have we received a response?
+      def response_received?
+        !! @status
+      end
+    end
+
+    class MultiReceiver < EM::Synchrony::Multi
+      include ResponseReceiver
+
+      # Create a new MultiReceiver
+      # @param env [Goliath::Env] the current environment
+      def initialize env
+        @env = env
+        super()
+      end
+
+      alias_method :enqueue, :add
+
+      def successes
+        responses[:callback]
+      end
+
+      def failures
+        responses[:errback]
+      end
+
+      # Finished if we received a response and the multi request is finished
+      def finished?
+        super && response_received?
+      end
+    end
+
+  end
+end