goliath 0.9.2 → 0.9.4

data/lib/goliath/rack/barrier_aroundware_factory.rb

@@ -0,0 +1,60 @@
+module Goliath
+  module Rack
+    #
+    # Include this to enable middleware that can perform pre- and
+    # post-processing, orchestrating multiple concurrent requests.
+    #
+    # For internal reasons, you can't do the following as you would in Rack:
+    #
+    #   def call(env)
+    #     # ... do pre-processing
+    #     status, headers, body = @app.call(env)
+    #     new_body = make_totally_awesome(body) ## !! BROKEN !!
+    #     [status, headers, new_body]
+    #   end
+    #
+    # This class creates an "aroundware" helper to do that kind of
+    # processing. Goliath proceeds asynchronously, but will still "unwind" the
+    # request by walking up the callback chain. Delegating out to the aroundware
+    # also lets you carry state around -- the ban on instance variables no
+    # longer applies, as each aroundware is unique per request.
+    #
+    # The strategy here is similar to that in EM::Multi. Figuring out what goes
+    # on there will help you understand this.
+    #
+    # @see EventMachine::Multi
+    # @see Goliath::Rack::SimpleAroundware
+    # @see Goliath::Rack::SimpleAroundwareFactory
+    # @see Goliath::Rack::BarrierAroundware
+    #
+    class BarrierAroundwareFactory < Goliath::Rack::SimpleAroundwareFactory
+      include Goliath::Rack::Validator
+
+      # Put aroundware in the middle of the async_callback chain:
+      # * save the old callback chain;
+      # * have the downstream callback send results to the aroundware (possibly
+      #   completing it)
+      # * set the old callback chain to fire when the aroundware completes
+      def hook_into_callback_chain(env, aroundware)
+        async_callback = env['async.callback']
+
+        # The response from the downstream app is accepted by the aroundware...
+        downstream_callback = Proc.new do |resp|
+          safely(env){ aroundware.accept_response(:downstream_resp, true, resp) }
+        end
+
+        # .. but the upstream chain is only invoked when the aroundware completes
+        invoke_upstream_chain = Proc.new do
+          new_resp = safely(env){ aroundware.post_process }
+          async_callback.call(new_resp)
+        end
+
+        env['async.callback'] = downstream_callback
+        aroundware.add_to_pending(:downstream_resp)
+        aroundware.callback(&invoke_upstream_chain)
+        aroundware.errback(&invoke_upstream_chain)
+      end
+
+    end
+  end
+end

data/lib/goliath/rack/builder.rb

@@ -1,11 +1,22 @@
 require 'http_router'
 
+class HttpRouter::Route
+  attr_accessor :api_class
+end
+
 module Goliath
   module Rack
     class Builder < ::Rack::Builder
       attr_accessor :params
+      attr_reader :inner_app
       include Params::Parser
 
+      alias_method :original_run, :run
+      def run(app)
+        @inner_app = app
+        original_run(app)
+      end
+
       # Builds the rack middleware chain for the given API
       #
       # @param klass [Class] The API class to build the middlewares for
@@ -18,15 +29,21 @@ module Goliath
           end
           if klass.maps?
             klass.maps.each do |path, route_klass, opts, blk|
-              blk ||= Proc.new {
-                run Builder.build(route_klass, route_klass.new)
-              }
-              klass.router.add(path, opts.dup).to {|env|
+              route = klass.router.add(path, opts.dup)
+              route.api_class = route_klass
+              route.to {|env|
                 builder = Builder.new
                 env['params'] ||= {}
                 env['params'].merge!(env['router.params']) if env['router.params']
                 builder.params = builder.retrieve_params(env)
-                builder.instance_eval(&blk)
+                builder.instance_eval(&blk) if blk
+                route_klass.middlewares.each do |mw|
+                  builder.instance_eval { use mw[0], *mw[1], &mw[2] }
+                end if route_klass
+                if route_klass or blk.nil?
+                  raise "You cannot use `run' and supply a routing class at the same time" if builder.inner_app
+                  builder.instance_eval { run env.event_handler }
+                end
                 builder.to_app.call(env)
               }
             end
@@ -36,7 +53,6 @@ module Goliath
           end
         end
       end
-
     end
   end
 end

data/lib/goliath/rack/heartbeat.rb

@@ -7,17 +7,20 @@ module Goliath
     #  use Goliath::Rack::Heartbeat
     #
     class Heartbeat
-      def initialize(app)
-        @app = app
+      def initialize(app, opts = {})
+        @app  = app
+        @opts = opts
+        @opts[:path]     ||= '/status'
+        @opts[:response] ||= [200, {}, 'OK']
       end
 
       def call(env)
-        if env['PATH_INFO'] == '/status'
-          [200, {}, 'OK']
+        if env['PATH_INFO'] == @opts[:path]
+          @opts[:response]
         else
           @app.call(env)
         end
       end
     end
   end
-end
+end

data/lib/goliath/rack/simple_aroundware.rb

@@ -0,0 +1,114 @@
+module Goliath
+  module Rack
+
+    #
+    # This module gives you ergonomics similar to traditional Rack middleware:
+    #
+    # * Use instance variables! Each SimpleAroundware is unique to its request.
+    # * You have accessors for env and (once in post_process) status, headers,
+    #   body -- no more shipping them around to every method.
+    #
+    # If in your traditional rack middleware you'd do this:
+    #
+    #     class MyRackMiddleware
+    #       def call(env)
+    #         get_ready_to_be_totally_awesome()
+    #         status, headers, body = @app.call(env)
+    #         new_body = make_totally_awesome(body)
+    #         [status, headers, new_body]
+    #       end
+    #     end
+    #
+    # You'd now do this:
+    #
+    #     class MyAwesomeAroundware
+    #       include Goliath::Rack::SimpleAroundware
+    #       def pre_process
+    #         get_ready_to_be_totally_awesome()
+    #       end
+    #       def post_process
+    #         new_body = make_totally_awesome(body)
+    #         [status, headers, new_body]
+    #       end
+    #     end
+    #
+    # And you'd include it in your endpoint like this:
+    #
+    #     class AwesomeApi < Goliath::API
+    #       use Goliath::Rack::SimpleAroundwareFactory, MyAwesomeAroundware
+    #     end
+    #
+    # @example
+    #     # count incoming requests, outgoing responses, and
+    #     # outgoing responses by status code
+    #     class StatsdLogger
+    #       include Goliath::Rack::SimpleAroundware
+    #       def pre_process
+    #         statsd_count("reqs.#{config['statsd_name']}.in")
+    #         Goliath::Connection::AsyncResponse
+    #       end
+    #       def post_process
+    #         statsd_count("reqs.#{config['statsd_name']}.out")
+    #         statsd_count("reqs.#{config['statsd_name']}.#{status}")
+    #         [status, headers, body]
+    #       end
+    #       def statsd_count(name, count=1, sampling_frac=nil)
+    #         # ...
+    #       end
+    #     end
+    #
+    #     class AwesomeApiWithLogging < Goliath::API
+    #       use Goliath::Rack::Params
+    #       use Goliath::Rack::SimpleAroundwareFactory, StatsdLogger
+    #       def response(env)
+    #         # ... do something awesome
+    #       end
+    #     end
+    #
+    module SimpleAroundware
+      include Goliath::Rack::Validator
+
+      # The request environment, set in the initializer
+      attr_reader :env
+      # The response, set by the SimpleAroundware's downstream
+      attr_accessor :status, :headers, :body
+
+      # @param env [Goliath::Env] The request environment
+      # @return [Goliath::Rack::SimpleAroundware]
+      def initialize(env)
+        @env = env
+      end
+
+      # Override this method in your middleware to perform any preprocessing
+      # (launching a deferred request, perhaps).
+      #
+      # You must return Goliath::Connection::AsyncResponse if you want processing to continue
+      #
+      # @return [Array] array contains [status, headers, body]
+      def pre_process
+        Goliath::Connection::AsyncResponse
+      end
+
+      # Override this method in your middleware to perform any postprocessing.
+      # This will only be invoked when all deferred requests (including the
+      # response) have completed.
+      #
+      # @return [Array] array contains [status, headers, body]
+      def post_process
+        [status, headers, body]
+      end
+
+      # Virtual setter for the downstream middleware/endpoint response
+      def downstream_resp=(status_headers_body)
+        @status, @headers, @body = status_headers_body
+      end
+
+      # On receipt of an async result,
+      # * call the setter for that handle if any (on receipt of :shortened_url,
+      def accept_response(handle, resp_succ, resp)
+        self.downstream_resp = resp
+      end
+
+    end
+  end
+end

data/lib/goliath/rack/simple_aroundware_factory.rb

@@ -0,0 +1,121 @@
+module Goliath
+  module Rack
+    #
+    # Include this to enable middleware that can perform pre- and
+    # post-processing.
+    #
+    # For internal reasons, you can't do the following as you would in Rack:
+    #
+    #   def call(env)
+    #     # ... do pre-processing
+    #     status, headers, body = @app.call(env)
+    #     new_body = make_totally_awesome(body) ## !! BROKEN !!
+    #     [status, headers, new_body]
+    #   end
+    #
+    # This class creates a "aroundware" helper to do that kind of
+    # processing. Goliath proceeds asynchronously, but will still "unwind" the
+    # request by walking up the callback chain. Delegating out to the aroundware
+    # also lets you carry state around -- the ban on instance variables no
+    # longer applies, as each aroundware is unique per request.
+    #
+    # @see Goliath::Rack::AsyncMiddleware
+    # @see Goliath::Rack::SimpleAroundware
+    # @see Goliath::Rack::BarrierAroundware
+    #
+    class SimpleAroundwareFactory
+      include Goliath::Rack::Validator
+
+      # Called by the framework to create the middleware.
+      #
+      # Any extra args passed to the use statement are sent to each
+      # aroundware_klass as it is created.
+      #
+      # @example
+      #   class Awesomizer2011
+      #     include Goliath::Rack::SimpleAroundware
+      #     def initialize(env, aq)
+      #       @awesomeness_quotient = aq
+      #       super(env)
+      #     end
+      #     # ... define pre_process and post_process ...
+      #   end
+      #
+      #   class AwesomeApiWithShortening < Goliath::API
+      #     use Goliath::Rack::SimpleAroundwareFactory, Awesomizer2011, 3
+      #     # ... stuff ...
+      #   end
+      #
+      # @param app [#call] the downstream app
+      # @param aroundware_klass a class that quacks like a
+      #   Goliath::Rack::SimpleAroundware and an EM::Deferrable
+      # @param *args [Array] extra args to pass to the aroundware
+      # @return [Goliath::Rack::AroundwareFactory]
+      def initialize app, aroundware_klass, *args
+        @app = app
+        @aroundware_klass = aroundware_klass
+        @aroundware_args  = args
+      end
+
+      # Coordinates aroundware to process a request.
+      #
+      # We hook the aroundware in the middle of the async_callback chain:
+      # * send the downstream response to the aroundware, whether received directly
+      #   from @app.call or via async callback
+      # * have the upstream callback chain be invoked when the aroundware completes
+      #
+      # @param env [Goliath::Env] The goliath environment
+      # @return [Array] The [status_code, headers, body] tuple
+      def call(env)
+        aroundware = new_aroundware(env)
+
+        aroundware_resp = aroundware.pre_process
+        return aroundware_resp if final_response?(aroundware_resp)
+
+        hook_into_callback_chain(env, aroundware)
+
+        downstream_resp = @app.call(env)
+
+        # if downstream resp is final, pass it to the aroundware; it will invoke
+        # the callback chain at its leisure. Our response is *always* async.
+        if final_response?(downstream_resp)
+          aroundware.accept_response(:downstream_resp, true, downstream_resp)
+        end
+        return Goliath::Connection::AsyncResponse
+      end
+
+      # Put aroundware in the middle of the async_callback chain:
+      # * save the old callback chain;
+      # * have the downstream callback send results to the aroundware (possibly
+      #   completing it)
+      # * set the old callback chain to fire when the aroundware completes
+      def hook_into_callback_chain(env, aroundware)
+        async_callback = env['async.callback']
+
+        # The response from the downstream app is accepted by the aroundware...
+        # ... and we immediately call post_process and hand it upstream
+        downstream_callback = Proc.new do |resp|
+          safely(env){ aroundware.accept_response(:downstream_resp, true, resp) }
+          new_resp = safely(env){ aroundware.post_process }
+          async_callback.call(new_resp)
+        end
+
+        env['async.callback'] = downstream_callback
+      end
+
+      def final_response?(resp)
+        resp != Goliath::Connection::AsyncResponse
+      end
+
+      # Generate a aroundware to process the request, using request env & any args
+      # passed to this AroundwareFactory at creation
+      #
+      # @param env [Goliath::Env] The goliath environment
+      # @return [Goliath::Rack::SimpleAroundware] The aroundware to process this request
+      def new_aroundware(env)
+        @aroundware_klass.new(env, *@aroundware_args)
+      end
+
+    end
+  end
+end

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

@@ -12,6 +12,13 @@ module Goliath
         include Goliath::Rack::Validator
         attr_reader :type, :key, :message
 
+        # extracted from activesupport 3.0.9
+        if defined?(Encoding) && "".respond_to?(:encode)
+          NON_WHITESPACE_REGEXP = %r![^[:space:]]!
+        else
+          NON_WHITESPACE_REGEXP = %r![^\s#{[0x3000].pack("U")}]!
+        end
+        
         # Creates the Goliath::Rack::Validation::RequiredParam validator
         #
         # @param app The app object
@@ -34,7 +41,7 @@ module Goliath
 
         def key_valid?(params)
           if !params.has_key?(key) || params[key].nil? ||
-              (params[key].is_a?(String) && params[key] =~ /^\s*$/)
+              (params[key].is_a?(String) && params[key] !~ NON_WHITESPACE_REGEXP)
             return false
           end
 
@@ -42,7 +49,7 @@ module Goliath
             unless params[key].compact.empty?
               params[key].each do |k|
                 return true unless k.is_a?(String)
-                return true unless k =~ /^\s*$/
+                return true unless k !~ NON_WHITESPACE_REGEXP
               end
             end
             return false

data/lib/goliath/request.rb

@@ -71,6 +71,8 @@ module Goliath
       @env[PATH_INFO]       = parser.request_path
       @env[FRAGMENT]        = parser.fragment
 
+      yield if block_given?
+
       begin
         @env[ASYNC_HEADERS].call(@env, h) if @env[ASYNC_HEADERS]
       rescue Exception => e
@@ -200,6 +202,11 @@ module Goliath
       headers['Content-Length'] = body.bytesize.to_s
       @env[:terminate_connection] = true
       post_process([status, headers, body])
+
+      # Mark the request as complete to force a flush on the response.
+      # Note: #on_body and #response hooks may still fire if the data
+      # is already in the parser buffer.
+      succeed
     end
 
     # Used to determine if the connection should  be kept open

data/lib/goliath/runner.rb

@@ -100,19 +100,31 @@ module Goliath
         opts.separator "Server options:"
 
         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 }
+        opts.on('-S', '--socket FILE', "Bind to unix domain socket") { |v| @options[:address] = v; @options[:port] = nil }
+
+        opts.separator ""
+        opts.separator "Daemon options:"
 
         opts.on('-u', '--user USER', "Run as specified user") {|v| @options[:user] = v }
+        opts.on('-c', '--config FILE', "Config file (default: ./config/<server>.rb)") { |v| @options[:config] = v }
+        opts.on('-d', '--daemonize', "Run daemonized in the background (default: #{@options[:daemonize]})") { |v| @options[:daemonize] = v }
         opts.on('-l', '--log FILE', "Log to file (default: off)") { |file| @options[:log_file] = file }
         opts.on('-s', '--stdout', "Log to stdout (default: #{@options[:log_stdout]})") { |v| @options[:log_stdout] = v }
-
-        opts.on('-c', '--config FILE', "Config file (default: ./config/<server>.rb)") { |v| @options[:config] = v }
         opts.on('-P', '--pid FILE', "Pid file (default: off)") { |file| @options[:pid_file] = file }
-        opts.on('-d', '--daemonize', "Run daemonized in the background (default: #{@options[:daemonize]})") { |v| @options[:daemonize] = v }
-        opts.on('-v', '--verbose', "Enable verbose logging (default: #{@options[:verbose]})") { |v| @options[:verbose] = v }
 
+        opts.separator ""
+        opts.separator "SSL options:"
+        opts.on('--ssl', 'Enables SSL (default: off)') {|v| @options[:ssl] = v }
+        opts.on('--ssl-key FILE', 'Path to private key') {|v| @options[:ssl_key] = v }
+        opts.on('--ssl-cert FILE', 'Path to certificate') {|v| @options[:ssl_cert] = v }
+        opts.on('--ssl-verify', 'Enables SSL certificate verification') {|v| @options[:ssl_verify] = v }
+
+        opts.separator ""
+        opts.separator "Common options:"
+
+        opts.on('-v', '--verbose', "Enable verbose logging (default: #{@options[:verbose]})") { |v| @options[:verbose] = v }
         opts.on('-h', '--help', 'Display help message') { show_options(opts) }
       end
     end