goliath 0.9.1 → 0.9.2

data/lib/goliath/application.rb

@@ -1,3 +1,20 @@
+require 'goliath/goliath'
+require 'goliath/runner'
+require 'goliath/rack'
+
+# Pre-load the goliath environment so it's available as we try to parse the class.
+# This means we can use Goliath.dev? or Goliath.prod? in the use statements.
+#
+# Note, as implmented, you have to have -e as it's own flag, you can't do -sve dev
+# as it won't pickup the e flag.
+env = ENV['RACK_ENV']
+env ||= begin
+          if ((i = ARGV.index('-e')) || (i = ARGV.index('--environment')))
+            ARGV[i + 1]
+          end
+        end
+Goliath.env = env if env
+
 module Goliath
   # The main execution class for Goliath. This will execute in the at_exit
   # handler to run the server.
@@ -6,9 +23,10 @@ module Goliath
   class Application
     # Most of this stuff is straight out of sinatra.
 
-    # Set of caller regex's to be skippe when looking for our API file
+    # Set of caller regex's to be skipped when looking for our API file
     CALLERS_TO_IGNORE = [ # :nodoc:
-      /\/goliath(\/(application))?\.rb$/, # all goliath code
+      /\/goliath(\/application)?\.rb$/, # all goliath code
+      /\/goliath(\/(rack|validation|plugins)\/)/, # all goliath code
       /rubygems\/custom_require\.rb$/,    # rubygems require hacks
       /bundler(\/runtime)?\.rb/,          # bundler require hacks
       /<internal:/                        # internal in ruby >= 1.9.2
@@ -40,34 +58,66 @@ module Goliath
       c
     end
 
+    # Returns the userland class which inherits the Goliath API
+    #
+    # @return [String] The app class
+    def self.app_class
+      @app_class
+    end
+
+    # Sets the userland class that should use the Goliath API
+    #
+    # @param app_class [String|Symbol|Constant] The new app class
+    # @return [String] app_class The new app class
+    def self.app_class=(app_class)
+      @app_class = app_class.to_s
+    end
+
+    # Retrive the base directory for the API before we've changed directories
+    #
+    # @note Note sure of a better way to handle this. Goliath will do a chdir
+    #       when the runner is executed. If you need the +root_path+ before
+    #       the runner is executing (like, in a use statement) you need this method.
+    #
+    # @param args [Array] Any arguments to append to the path
+    # @return [String] path for the given arguments
+    def self.app_path(*args)
+      @app_path ||= File.expand_path(File.dirname(app_file))
+      File.join(@app_path, *args)
+    end
+
+    # Retrieve the base directory for the API
+    #
+    # @param args [Array] Any arguments to append to the path
+    # @return [String] path for the given arguments
+    def self.root_path(*args)
+      return app_path(args) if Goliath.test?
+
+      @root_path ||= File.expand_path("./")
+      File.join(@root_path, *args)
+    end
+
     # Execute the application
     #
     # @return [Nil]
     def self.run!
-      file = File.basename(app_file, '.rb')
-      klass = begin
-        Kernel.const_get(camel_case(file))
+      unless @app_class
+        file = File.basename(app_file, '.rb')
+        @app_class = camel_case(file)
+      end
+
+      begin
+        klass = Kernel
+        @app_class.split('::').each do |con|
+          klass = klass.const_get(con)
+        end
       rescue NameError
-        raise NameError, "Class #{camel_case(file)} not found."
+        raise NameError, "Class #{@app_class} not found."
       end
       api = klass.new
 
       runner = Goliath::Runner.new(ARGV, api)
-      runner.load_app do
-        klass.middlewares.each do |mw|
-          use(*(mw[0..1].compact), &mw[2])
-        end
-
-        # If you use map you can't use run as
-        # the rack builder will blowup.
-        if klass.maps.empty?
-          run api
-        else
-          klass.maps.each do |mp|
-            map(mp.first, &mp.last)
-          end
-        end
-      end
+      runner.app = Goliath::Rack::Builder.build(klass, api)
 
       runner.load_plugins(klass.plugins)
       runner.run

data/lib/goliath/connection.rb

@@ -1,5 +1,7 @@
 require 'http/parser'
 require 'goliath/env'
+require 'goliath/constants'
+require 'goliath/request'
 
 module Goliath
   # The Goliath::Connection class handles sending and receiving data
@@ -12,7 +14,7 @@ module Goliath
     attr_accessor :app, :api, :port, :logger, :status, :config, :options
     attr_reader   :parser
 
-    AsyncResponse = [-1, {}, []].freeze
+    AsyncResponse = [-1, {}, []]
 
     def post_init
       @current = nil
@@ -76,7 +78,7 @@ module Goliath
       if req = @pending.shift
         @current = req
         @current.succeed
-      else
+      elsif @current
         @current.close
         @current = nil
       end

data/lib/goliath/constants.rb

@@ -22,6 +22,7 @@ module Goliath
     RACK_RUN_ONCE   = 'rack.run_once'
     RACK_VERSION_NUM = [1, 0]
     RACK_LOGGER     = 'rack.logger'
+    RACK_EXCEPTION  = 'rack.exception'
 
     ASYNC_CALLBACK  = 'async.callback'
     ASYNC_HEADERS   = 'async.headers'

data/lib/goliath/env.rb

@@ -47,7 +47,7 @@ module Goliath
     # @example
     #   [200, {}, {:meta => {:trace => env.trace_stats}}, {}]
     #
-    # @return [Array] Array of [name, time] pairs with a Total entry added.d
+    # @return [Array] Array of [name, time] pairs with a Total entry added.
     def trace_stats
       self[:trace] + [['total', self[:trace].collect { |s| s[1].to_f }.inject(:+).to_s]]
     end
@@ -67,6 +67,45 @@ module Goliath
       self[STREAM_CLOSE].call
     end
 
+    # Sends a chunk in a Chunked transfer encoding stream.
+    #
+    #     Each chunk starts with the number of octets of the data it embeds expressed
+    #     in hexadecimal followed by optional parameters (chunk extension) and a
+    #     terminating CRLF (carriage return and line feed) sequence, followed by the
+    #     chunk data. The chunk is terminated by CRLF. If chunk extensions are
+    #     provided, the chunk size is terminated by a semicolon followed with the
+    #     extension name and an optional equal sign and value
+    #
+    # Note: chunk extensions aren't provided yet
+    #
+    # This will do nothing if the chunk is empty -- sending a zero-length chunk
+    # signals the end of a stream.
+    #
+    def chunked_stream_send(chunk)
+      return if chunk.empty?
+      chunk_len_in_hex = chunk.bytesize.to_s(16)
+      body = [chunk_len_in_hex, "\r\n", chunk, "\r\n"].join
+      stream_send(body)
+    end
+
+    # Sends the terminating chunk in a chunked transfer encoding stream, and
+    # closes the stream.
+    #
+    #     The last chunk is a zero-length chunk, with the chunk size coded as 0, but
+    #     without any chunk data section.  The final chunk may be followed by an
+    #     optional trailer of additional entity header fields that are normally
+    #     delivered in the HTTP header to allow the delivery of data that can only
+    #     be computed after all chunk data has been generated. The sender may
+    #     indicate in a Trailer header field which additional fields it will send
+    #     in the trailer after the chunks.
+    #
+    # Note: trailer headers aren't provided yet
+    #
+    def chunked_stream_close
+      stream_send([0, "\r\n", "\r\n"].join)
+      stream_close
+    end
+
     # Convenience method for accessing the rack.logger item in the environment.
     #
     # @return [Logger] The logger object

data/lib/goliath/goliath.rb

@@ -1,49 +1,64 @@
 require 'eventmachine'
 require 'http/parser'
 require 'async_rack'
+require 'goliath/constants'
+require 'goliath/version'
 
 # The Goliath Framework
 module Goliath
   module_function
 
-  @env = :development
+  ENVIRONMENTS = [:development, :production, :test, :staging]
 
   # Retrieves the current goliath environment
   #
   # @return [String] the current environment
   def env
-    @env
+    @env or fail "environment has not been set"
   end
 
   # Sets the current goliath environment
   #
-  # @param [String] env the environment string of [dev|prod|test]
-  def env=(env)
-    case(env.to_s)
-    when 'dev'  then @env = :development
-    when 'prod' then @env = :production
-    when 'test' then @env = :test
+  # @param [String|Symbol] env the environment symbol of [dev | development | prod | production | test]
+  def env=(e)
+    es = case(e.to_sym)
+    when :dev  then :development
+    when :prod then :production
+    else e.to_sym
+    end
+
+    if ENVIRONMENTS.include?(es)
+      @env = es
+    else
+      fail "did not recognize environment: #{e}, expected one of: #{ENVIRONMENTS.join(', ')}"
     end
   end
 
   # Determines if we are in the production environment
   #
-  # @return [Boolean] true if current environemnt is production, false otherwise
+  # @return [Boolean] true if current environment is production, false otherwise
   def prod?
-    @env == :production
+    env == :production
   end
 
   # Determines if we are in the development environment
   #
-  # @return [Boolean] true if current environemnt is development, false otherwise
+  # @return [Boolean] true if current environment is development, false otherwise
   def dev?
-    @env == :development
+    env == :development
   end
 
   # Determines if we are in the test environment
   #
-  # @return [Boolean] true if current environemnt is test, false otherwise
+  # @return [Boolean] true if current environment is test, false otherwise
   def test?
-    @env == :test
+    env == :test
+  end
+
+  # Determines if we are in the staging environment
+  #
+  # @return [Boolean] true if current environment is staging.
+  def staging?
+    env == :staging
   end
-end
+end

data/lib/goliath/headers.rb

@@ -1,8 +1,8 @@
 module Goliath
   # @private
   class Headers
-    HEADER_FORMAT      = "%s: %s\r\n".freeze
-    ALLOWED_DUPLICATES = %w(Set-Cookie Set-Cookie2 Warning WWW-Authenticate).freeze
+    HEADER_FORMAT      = "%s: %s\r\n"
+    ALLOWED_DUPLICATES = %w(Set-Cookie Set-Cookie2 Warning WWW-Authenticate)
 
     def initialize
       @sent = {}

data/lib/goliath/plugins/latency.rb

@@ -21,13 +21,19 @@ module Goliath
         @last = Time.now.to_f
       end
 
+      @@recent_latency = 0
+      def self.recent_latency
+        @@recent_latency
+      end
+
       # Called automatically to start the plugin
       def run
         EM.add_periodic_timer(1) do
-          @logger.info "LATENCY: #{Time.now.to_f - @last}"
+          @@recent_latency = (Time.now.to_f - @last)
+          @logger.info "LATENCY: #{@@recent_latency}"
           @last = Time.now.to_f
         end
       end
     end
   end
-end
+end

data/lib/goliath/rack.rb

@@ -0,0 +1,18 @@
+module Goliath
+  module Rack
+    autoload :AsyncAroundware,        'goliath/rack/async_aroundware'
+    autoload :AsyncMiddleware,        'goliath/rack/async_middleware'
+    autoload :Builder,                'goliath/rack/builder'
+    autoload :DefaultMimeType,        'goliath/rack/default_mime_type'
+    autoload :DefaultResponseFormat,  'goliath/rack/default_response_format'
+    autoload :Formatters,             'goliath/rack/formatters'
+    autoload :Heartbeat,              'goliath/rack/heartbeat'
+    autoload :JSONP,                  'goliath/rack/jsonp'
+    autoload :Params,                 'goliath/rack/params'
+    autoload :Render,                 'goliath/rack/render'
+    autoload :Templates,              'goliath/rack/templates'
+    autoload :Tracer,                 'goliath/rack/tracer'
+    autoload :Validator,              'goliath/rack/validator'
+    autoload :Validation,             'goliath/rack/validation'
+  end
+end

data/lib/goliath/rack/async_aroundware.rb

@@ -0,0 +1,56 @@
+module Goliath
+  module Rack
+    class AsyncAroundware
+      # Create a new AsyncAroundware
+      #
+      # @example
+      #   class MyResponseReceiver < Goliath::Rack::MultiReceiver
+      #     # ... define pre_process and post_process ...
+      #   end
+      #
+      #   class AsyncAroundwareDemoMulti < Goliath::API
+      #     use Goliath::Rack::AsyncAroundware, MyResponseReceiver
+      #     # ... stuff ...
+      #   end
+      #
+      # @param app [#call] the downstream app
+      # @param response_receiver_klass a class that quacks like a
+      #   Goliath::Rack::ResponseReceiver and an EM::Deferrable
+      # @param *args [Array] extra args to pass to the response_receiver
+      def initialize app, response_receiver_klass, *args
+        @app = app
+        @response_receiver_klass = response_receiver_klass
+        @response_receiver_args  = args
+      end
+
+      #
+      def call(env)
+        response_receiver = new_response_receiver(env)
+
+        # put response_receiver in the middle of the async_callback chain:
+        # * save the old callback chain;
+        # * put the response_receiver in as the new async_callback;
+        # * when the response_receiver completes, invoke the old callback chain
+        async_callback = env['async.callback']
+        env['async.callback'] = response_receiver
+        response_receiver.callback{ do_postprocess(env, async_callback, response_receiver) }
+        response_receiver.errback{  do_postprocess(env, async_callback, response_receiver) }
+
+        response_receiver.pre_process
+
+        response_receiver.call(@app.call(env))
+      end
+
+      def new_response_receiver(env)
+        @response_receiver_klass.new(env, *@response_receiver_args)
+      end
+
+      include Goliath::Rack::Validator
+      def do_postprocess(env, async_callback, response_receiver)
+        Goliath::Rack::Validator.safely(env) do
+          async_callback.call(response_receiver.post_process)
+        end
+      end
+    end
+  end
+end

data/lib/goliath/rack/async_middleware.rb

@@ -0,0 +1,93 @@
+module Goliath
+  module Rack
+    #
+    # Include this to enable middleware that can perform 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
+    #
+    # By including this middleware, you can do that kind of "around" middleware:
+    # it lets goliath proceed asynchronously, but still "unwind" the request by
+    # walking up the callback chain.
+    #
+    # @example
+    #   class AwesomeMiddleware
+    #     include Goliath::Rack::AsyncMiddleware
+    #
+    #     def call(env)
+    #       awesomness_quotient = 3
+    #       # the extra args sent to super are passed along to post_process
+    #       super(env, awesomness_quotient)
+    #     end
+    #
+    #     def post_process(env, status, headers, body, awesomness_quotient)
+    #       new_body = make_totally_awesome(body, awesomness_quotient)
+    #       [status, headers, new_body]
+    #     end
+    #   end
+    #
+    # @note Some caveats on writing middleware. Unlike other Rack powered app
+    #   servers, Goliath creates a single instance of the middleware chain at
+    #   startup, and reuses it for all incoming requests. Since everything is
+    #   asynchronous, you can have multiple requests using the middleware chain
+    #   at the same time. If your middleware tries to store any instance or
+    #   class level variables they'll end up getting stomped all over by the
+    #   next request. Everything that you need to store needs to be stored in
+    #   local variables.
+    module AsyncMiddleware
+      # Called by the framework to create the middleware.
+      #
+      # @param app [Proc] The application
+      # @return [Goliath::Rack::AsyncMiddleware]
+      def initialize(app)
+        @app = app
+      end
+
+      # Store the previous async.callback into async_cb and redefines it to be
+      # our own. When the asynchronous response is done, Goliath can "unwind"
+      # the request by walking up the callback chain.
+      #
+      # However, you will notice that we execute the post_process method in the
+      # default return case. If the validations fail later in the middleware
+      # chain before your classes response(env) method is executed, the response
+      # will come back up through the chain normally and be returned.
+      #
+      # To do preprocessing, override this method in your subclass and invoke
+      # super(env) as the last line.  Any extra arguments will be made available
+      # to the post_process method.
+      #
+      # @param env [Goliath::Env] The goliath environment
+      # @return [Array] The [status_code, headers, body] tuple
+      def call(env, *args)
+        async_cb = env['async.callback']
+
+        env['async.callback'] = Proc.new do |status, headers, body|
+          async_cb.call(post_process(env, status, headers, body, *args))
+        end
+
+        status, headers, body = @app.call(env)
+
+        if status == Goliath::Connection::AsyncResponse.first
+          [status, headers, body]
+        else
+          post_process(env, status, headers, body, *args)
+        end
+      end
+
+      # Override this method in your middleware to perform any
+      # postprocessing. Note that this can be called in the asynchronous case
+      # (walking back up the middleware async.callback chain), or synchronously
+      # (in the case of a validation error, or if a downstream middleware
+      # supplied a direct response).
+      def post_process(env, status, headers, body)
+        [status, headers, body]
+      end
+    end
+  end
+end