goliath 0.9.0

data/lib/goliath/application.rb

@@ -0,0 +1,90 @@
+module Goliath
+  # The main execution class for Goliath. This will execute in the at_exit
+  # handler to run the server.
+  #
+  # @private
+  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
+    CALLERS_TO_IGNORE = [ # :nodoc:
+      /\/goliath(\/(application))?\.rb$/, # all goliath code
+      /rubygems\/custom_require\.rb$/,    # rubygems require hacks
+      /bundler(\/runtime)?\.rb/,          # bundler require hacks
+      /<internal:/                        # internal in ruby >= 1.9.2
+    ]
+
+    # @todo add rubinius (and hopefully other VM impls) ignore patterns ...
+    CALLERS_TO_IGNORE.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
+
+    # Like Kernel#caller but excluding certain magic entries and without
+    # line / method information; the resulting array contains filenames only.
+    def self.caller_files
+      caller_locations.map { |file, line| file }
+    end
+
+    # Like caller_files, but containing Arrays rather than strings with the
+    # first element being the file, and the second being the line.
+    def self.caller_locations
+      caller(1).
+        map    { |line| line.split(/:(?=\d|in )/)[0,2] }.
+        reject { |file, line| CALLERS_TO_IGNORE.any? { |pattern| file =~ pattern } }
+    end
+
+    # Find the app_file that was used to execute the application
+    #
+    # @return [String] The app file
+    def self.app_file
+      c = caller_files.first
+      c = $0 if !c || c.empty?
+      c
+    end
+
+    # Execute the application
+    #
+    # @return [Nil]
+    def self.run!
+      file = File.basename(app_file, '.rb')
+      klass = Kernel.const_get(camel_case(file))
+      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.load_plugins(klass.plugins)
+      runner.run
+    end
+
+    private
+
+    # Convert a string to camel case
+    #
+    # @param str [String] The string to convert
+    # @return [String] The camel cased string
+    def self.camel_case(str)
+      return str if str !~ /_/ && str =~ /[A-Z]+.*/
+
+      str.split('_').map { |e| e.capitalize }.join
+    end
+  end
+
+  at_exit do
+    if $!.nil? && $0 == Goliath::Application.app_file
+      Application.run!
+    end
+  end
+end

data/lib/goliath/connection.rb

@@ -0,0 +1,94 @@
+require 'http/parser'
+require 'goliath/env'
+
+module Goliath
+  # The Goliath::Connection class handles sending and receiving data
+  # from the client.
+  #
+  # @private
+  class Connection < EM::Connection
+    include Constants
+
+    attr_accessor :app, :api, :port, :logger, :status, :config, :options
+    attr_reader   :parser
+
+    AsyncResponse = [-1, {}, []].freeze
+
+    def post_init
+      @current = nil
+      @requests = []
+      @pending  = []
+
+      @parser = Http::Parser.new
+      @parser.on_headers_complete = proc do |h|
+
+        env = Goliath::Env.new
+        env[OPTIONS]     = options
+        env[SERVER_PORT] = port.to_s
+        env[LOGGER]      = logger
+        env[OPTIONS]     = options
+        env[STATUS]      = status
+        env[CONFIG]      = config
+        env[REMOTE_ADDR] = remote_address
+
+        env[ASYNC_HEADERS] = @api.method(:on_headers) if @api.respond_to? :on_headers
+        env[ASYNC_BODY]    = @api.method(:on_body) if @api.respond_to? :on_body
+        env[ASYNC_CLOSE]   = @api.method(:on_close) if @api.respond_to? :on_close
+
+        r = Goliath::Request.new(@app, self, env)
+        r.parse_header(h, @parser)
+
+        @requests.push(r)
+      end
+
+      @parser.on_body = proc do |data|
+        @requests.first.parse(data)
+      end
+
+      @parser.on_message_complete = proc do
+        req = @requests.shift
+
+        if @current.nil?
+          @current = req
+          @current.succeed
+        else
+          @pending.push(req)
+        end
+
+        req.process
+      end
+    end
+
+    def receive_data(data)
+      begin
+        @parser << data
+      rescue HTTP::Parser::Error => e
+        terminate_request(false)
+      end
+    end
+
+    def unbind
+      @requests.map {|r| r.close }
+      @pending.map  {|r| r.close }
+      @current.close if @current
+    end
+
+    def terminate_request(keep_alive)
+      if req = @pending.shift
+        @current = req
+        @current.succeed
+      else
+        @current.close
+        @current = nil
+      end
+
+      close_connection_after_writing rescue nil if !keep_alive
+    end
+
+    def remote_address
+      Socket.unpack_sockaddr_in(get_peername)[1]
+    rescue Exception
+      nil
+    end
+  end
+end

data/lib/goliath/constants.rb

@@ -0,0 +1,51 @@
+module Goliath
+  # Constants used by the system to access data.
+  module Constants
+    INITIAL_BODY = ''
+    # Force external_encoding of request's body to ASCII_8BIT
+    INITIAL_BODY.encode!(Encoding::ASCII_8BIT) if INITIAL_BODY.respond_to?(:encode)
+
+    SERVER_SOFTWARE = 'SERVER_SOFTWARE'
+    SERVER          = 'Goliath'
+
+    HTTP_PREFIX     = 'HTTP_'
+    LOCALHOST       = 'localhost'
+    LOGGER          = 'logger'
+    STATUS          = 'status'
+    CONFIG          = 'config'
+    OPTIONS         = 'options'
+
+    RACK_INPUT      = 'rack.input'
+    RACK_VERSION    = 'rack.version'
+    RACK_ERRORS     = 'rack.errors'
+    RACK_MULTITHREAD = 'rack.multithread'
+    RACK_MULTIPROCESS = 'rack.multiprocess'
+    RACK_RUN_ONCE   = 'rack.run_once'
+    RACK_VERSION_NUM = [1, 0]
+
+    ASYNC_CALLBACK  = 'async.callback'
+    ASYNC_HEADERS   = 'async.headers'
+    ASYNC_BODY      = 'async.body'
+    ASYNC_CLOSE     = 'async.close'
+
+    STREAM_START    = 'stream.start'
+    STREAM_SEND     = 'stream.send'
+    STREAM_CLOSE    = 'stream.close'
+
+    SERVER_NAME     = 'SERVER_NAME'
+    SERVER_PORT     = 'SERVER_PORT'
+    SCRIPT_NAME     = 'SCRIPT_NAME'
+    REMOTE_ADDR     = 'REMOTE_ADDR'
+    CONTENT_LENGTH  = 'CONTENT_LENGTH'
+    REQUEST_METHOD  = 'REQUEST_METHOD'
+    REQUEST_URI     = 'REQUEST_URI'
+    QUERY_STRING    = 'QUERY_STRING'
+    HTTP_VERSION    = 'HTTP_VERSION'
+    REQUEST_PATH    = 'REQUEST_PATH'
+    PATH_INFO       = 'PATH_INFO'
+    FRAGMENT        = 'FRAGMENT'
+    CONNECTION      = 'CONNECTION'
+
+    GOLIATH_ENV     = 'goliath.env'
+  end
+end

data/lib/goliath/env.rb

@@ -0,0 +1,92 @@
+require 'goliath/constants'
+
+module Goliath
+  # Holds information for the current request.
+  #
+  # Goliath::Env also provides access to the logger, configuration information
+  # and anything else set into the config data during initialization.
+  class Env < Hash
+    include Constants
+
+    # Create a new Goliath::Env object
+    #
+    # @return [Goliath::Env] The Goliath::Env object
+    def initialize
+      self[SERVER_SOFTWARE]   = SERVER
+      self[SERVER_NAME]       = LOCALHOST
+      self[RACK_VERSION]      = RACK_VERSION_NUM
+      self[RACK_ERRORS]       = STDERR
+      self[RACK_MULTITHREAD]  = false
+      self[RACK_MULTIPROCESS] = false
+      self[RACK_RUN_ONCE]     = false
+
+      self[:start_time] = Time.now.to_f
+      self[:time] = Time.now.to_f
+      self[:trace] = []
+    end
+
+    # Add a trace timer with the given name into the environment. The tracer will
+    # provide information on the amount of time since the previous call to {#trace}
+    # or since the Goliath::Env object was initialized.
+    #
+    # @example
+    #   trace("initialize hash")
+    #   ....
+    #   trace("Do something else")
+    #
+    # @param name [String] The name of the trace to add
+    def trace(name)
+      self[:trace].push([name, "%.2f" % ((Time.now.to_f - self[:time]) * 1000)])
+      self[:time] = Time.now.to_f
+    end
+
+    # Retrieve the tracer stats for this request environment. This can then be
+    # returned in the headers hash to in development to provide some simple
+    # timing information for the various API components.
+    #
+    # @example
+    #   [200, {}, {:meta => {:trace => env.trace_stats}}, {}]
+    #
+    # @return [Array] Array of [name, time] pairs with a Total entry added.d
+    def trace_stats
+      self[:trace] + [['total', self[:trace].collect { |s| s[1].to_f }.inject(:+).to_s]]
+    end
+
+    # If the API is a streaming API this will send the provided data to the client.
+    # There will be no processing done on the data when this is called so it's the
+    # APIs responsibility to have the data formatted as needed.
+    #
+    # @param data [String] The data to send to the client.
+    def stream_send(data)
+      self[STREAM_SEND].call(data)
+    end
+
+    # If the API is a streaming API this will be executed by the API to signal that
+    # the stream is complete. This will close the connection with the client.
+    def stream_close
+      self[STREAM_CLOSE].call
+    end
+
+    # @param name [Symbol] The method to check if we respond to it.
+    # @return [Boolean] True if the Env responds to the method, false otherwise
+    def respond_to?(name)
+      return true if has_key?(name.to_s)
+      return true if self['config'] && self['config'].has_key?(name.to_s)
+      super
+    end
+
+    # The Goliath::Env will provide any of it's keys as a method. It will also provide
+    # any of the keys in the config object as methods. The methods will return
+    # the value of the key. If the key doesn't exist in either hash this will
+    # fall back to the standard method_missing implementation.
+    #
+    # @param name [Symbol] The method to look for
+    # @param args The arguments
+    # @param blk A block
+    def method_missing(name, *args, &blk)
+      return self[name.to_s] if has_key?(name.to_s)
+      return self['config'][name.to_s] if self['config'] && self['config'].has_key?(name.to_s)
+      super(name, *args, &blk)
+    end
+  end
+end

data/lib/goliath/goliath.rb

@@ -0,0 +1,49 @@
+require 'eventmachine'
+require 'http/parser'
+require 'async_rack'
+
+# The Goliath Framework
+module Goliath
+  module_function
+
+  @env = 'development'
+
+  # Retrieves the current goliath environment
+  #
+  # @return [String] the current environment
+  def env
+    @env
+  end
+
+  # Sets the current goliath environment
+  #
+  # @param [String] env the environment string of [dev|prod|test]
+  def env=(env)
+    case(env)
+    when 'dev' then @env = 'development'
+    when 'prod' then @env = 'production'
+    when 'test' then @env = 'test'
+    end
+  end
+
+  # Determines if we are in the production environment
+  #
+  # @return [Boolean] true if current environemnt is production, false otherwise
+  def prod?
+    @env == 'production'
+  end
+
+  # Determines if we are in the development environment
+  #
+  # @return [Boolean] true if current environemnt is development, false otherwise
+  def dev?
+    @env == 'development'
+  end
+
+  # Determines if we are in the test environment
+  #
+  # @return [Boolean] true if current environemnt is test, false otherwise
+  def test?
+    @env == 'test'
+  end
+end

data/lib/goliath/headers.rb

@@ -0,0 +1,37 @@
+module Goliath
+  # @private
+  class Headers
+    HEADER_FORMAT      = "%s: %s\r\n".freeze
+    ALLOWED_DUPLICATES = %w(Set-Cookie Set-Cookie2 Warning WWW-Authenticate).freeze
+
+    def initialize
+      @sent = {}
+      @out = []
+    end
+
+    def []=(key, value)
+      return if @sent.has_key?(key) && !(ALLOWED_DUPLICATES.include?(key))
+
+      value = case value
+        when Time then value.httpdate
+        when NilClass then return
+        else value.to_s
+      end
+
+      @sent[key] = value
+      @out << HEADER_FORMAT % [key, value]
+    end
+
+    def [](key)
+      @sent[key]
+    end
+
+    def has_key?(key)
+      @sent[key] ? true : false
+    end
+
+    def to_s
+      @out.join
+    end
+  end
+end

data/lib/goliath/http_status_codes.rb

@@ -0,0 +1,44 @@
+module Goliath
+  # Every standard HTTP code mapped to the appropriate message.
+  #
+  # @author Mongrel.
+  HTTP_STATUS_CODES = {
+    100 => 'Continue',
+    101 => 'Switching Protocols',
+    200 => 'OK',
+    201 => 'Created',
+    202 => 'Accepted',
+    203 => 'Non-Authoritative Information',
+    204 => 'No Content',
+    205 => 'Reset Content',
+    206 => 'Partial Content',
+    300 => 'Multiple Choices',
+    301 => 'Moved Permanently',
+    302 => 'Moved Temporarily',
+    303 => 'See Other',
+    304 => 'Not Modified',
+    305 => 'Use Proxy',
+    400 => 'Bad Request',
+    401 => 'Unauthorized',
+    402 => 'Payment Required',
+    403 => 'Forbidden',
+    404 => 'Not Found',
+    405 => 'Method Not Allowed',
+    406 => 'Not Acceptable',
+    407 => 'Proxy Authentication Required',
+    408 => 'Request Time-out',
+    409 => 'Conflict',
+    410 => 'Gone',
+    411 => 'Length Required',
+    412 => 'Precondition Failed',
+    413 => 'Request Entity Too Large',
+    414 => 'Request-URI Too Large',
+    415 => 'Unsupported Media Type',
+    500 => 'Internal Server Error',
+    501 => 'Not Implemented',
+    502 => 'Bad Gateway',
+    503 => 'Service Unavailable',
+    504 => 'Gateway Time-out',
+    505 => 'HTTP Version not supported'
+  }
+end