goliath 0.9.0

data/examples/hello_world.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+$:<< '../lib' << 'lib'
+
+require 'goliath'
+
+class HelloWorld < Goliath::API
+  def response(env)
+    [200, {}, "hello world"]
+  end
+end

data/examples/http_log.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+#
+# Simple example that takes all requests and forwards them to
+# another API using EM-HTTP-Request. Information about the
+# request and response is then stored into a Mongo database.
+#
+
+$: << "../lib" << "./lib"
+
+require 'rubygems'
+require 'goliath'
+require 'em-mongo'
+require 'em-http'
+require 'em-synchrony/em-http'
+require 'pp'
+
+class HttpLog < Goliath::API
+  use ::Rack::Reloader, 0 if Goliath.dev?
+  use Goliath::Rack::Params
+
+  def on_headers(env, headers)
+    env.logger.info 'proxying new request: ' + headers.inspect
+    env['client-headers'] = headers
+  end
+
+  def response(env)
+    start_time = Time.now.to_f
+
+    params = {:head => env['client-headers'], :query => env.params}
+
+    req = EM::HttpRequest.new("#{forwarder}#{env[Goliath::Request::REQUEST_PATH]}")
+    resp = case(env[Goliath::Request::REQUEST_METHOD])
+      when 'GET'  then req.get(params)
+      when 'POST' then req.post(params.merge(:body => env[Goliath::Request::RACK_INPUT].read))
+      when 'HEAD' then req.head(params)
+      else p "UNKNOWN METHOD #{env[Goliath::Request::REQUEST_METHOD]}"
+    end
+
+    process_time = Time.now.to_f - start_time
+
+    response_headers = {}
+    resp.response_header.each_pair do |k, v|
+      response_headers[to_http_header(k)] = v
+    end
+
+    record(process_time, resp, env['client-headers'], response_headers)
+
+    [resp.response_header.status, response_headers, resp.response]
+  end
+
+  # Need to convert from the CONTENT_TYPE we'll get back from the server
+  # to the normal Content-Type header
+  def to_http_header(k)
+    k.downcase.split('_').collect { |e| e.capitalize }.join('-')
+  end
+
+  # Write the request information into mongo
+  def record(process_time, resp, client_headers, response_headers)
+    e = env
+    EM.next_tick do
+      doc = {
+        request: {
+          http_method: e[Goliath::Request::REQUEST_METHOD],
+          path: e[Goliath::Request::REQUEST_PATH],
+          headers: client_headers,
+          params: e.params
+        },
+        response: {
+          status: resp.response_header.status,
+          length: resp.response.length,
+          headers: response_headers,
+          body: resp.response
+        },
+        process_time: process_time,
+        date: Time.now.to_i
+      }
+
+      if e[Goliath::Request::RACK_INPUT]
+        doc[:request][:body] = e[Goliath::Request::RACK_INPUT].read
+      end
+
+      e.mongo.insert(doc)
+    end
+  end
+end

data/examples/rack_routes.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+$:<< '../lib' << 'lib'
+
+require 'goliath'
+
+# Example demonstrating how to have an API acting as a router.
+# RackRoutes defines multiple uris and how to map them accordingly.
+# Some of these routes are redirected to other Goliath API.
+#
+# The reason why only the last API is being used by the Goliath Server
+# is because its name matches the filename.
+# All the APIs are available but by default the server will use the one
+# matching the file name.
+
+# Our custom Goliath API
+class HelloWorld < Goliath::API
+  def response(env)
+    [200, {}, "hello world!"]
+  end
+end
+
+class Bonjour < Goliath::API
+  def response(env)
+    [200, {}, "bonjour!"]
+  end
+end
+
+class RackRoutes < Goliath::API
+  map '/version' do
+    run Proc.new { |env| [200, {"Content-Type" => "text/html"}, ["Version 0.1"]] }
+  end
+
+  map "/hello_world" do
+    run HelloWorld.new
+  end
+
+  map "/bonjour" do
+    run Bonjour.new
+  end
+
+  map '/' do
+    run Proc.new { |env| [404, {"Content-Type" => "text/html"}, ["Try /version /hello_world or /bonjour"]] }
+  end
+end

data/examples/stream.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+$:<< '../lib' << 'lib'
+
+#
+# A simple HTTP streaming API which returns a 200 response for any GET request
+# and then emits numbers 1 through 10 in 1 second intervals, and then closes the
+# connection.
+#
+# A good use case for this pattern would be to provide a stream of updates or a
+# 'firehose' like API to stream data back to the clients. Simply hook up to your
+# datasource and then stream the data to your clients via HTTP.
+#
+
+require 'goliath'
+
+class Stream < Goliath::API
+  def on_close(env)
+    env.logger.info "Connection closed."
+  end
+
+  def response(env)
+    i = 0
+    pt = EM.add_periodic_timer(1) do
+      env.stream_send("#{i} ")
+      i += 1
+    end
+
+    EM.add_timer(10) do
+      pt.cancel
+
+      env.stream_send("!! BOOM !!\n")
+      env.stream_close
+    end
+
+    [200, {}, Goliath::Response::STREAMING]
+  end
+end

data/examples/valid.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+$:<< '../lib' << 'lib'
+
+require 'goliath'
+
+class Valid < Goliath::API
+
+  # reload code on every request in dev environment
+  use ::Rack::Reloader, 0 if Goliath.dev?
+
+  use Goliath::Rack::Params
+  use Goliath::Rack::ValidationError
+
+  use Goliath::Rack::Validation::RequiredParam, {:key => 'test'}
+
+  def response(env)
+    [200, {}, 'OK']
+  end
+end

data/goliath.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'goliath/version'
+
+Gem::Specification.new do |s|
+  s.name = 'goliath'
+  s.version = Goliath::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['dan sinclair', 'Ilya Grigorik']
+  s.email = ['dj2@everburning.com', 'ilya@igvita.com']
+  s.homepage = 'http://labs.postrank.com/'
+  s.summary = 'Framework for writing API servers'
+  s.description = s.summary
+
+  s.required_ruby_version = '>=1.9.2'
+
+  s.add_dependency 'eventmachine', '>= 1.0.0.beta.1'
+  s.add_dependency 'em-synchrony', '>= 0.3.0.beta.1'
+  s.add_dependency 'http_parser.rb'
+  s.add_dependency 'log4r'
+
+  s.add_dependency 'rack'
+  s.add_dependency 'rack-contrib'
+  s.add_dependency 'rack-respond_to'
+  s.add_dependency 'async-rack'
+  s.add_dependency 'multi_json'
+
+  s.add_development_dependency 'rspec', '>2.0'
+  s.add_development_dependency 'nokogiri'
+  s.add_development_dependency 'em-http-request', '>= 1.0.0.beta.1'
+  s.add_development_dependency 'em-mongo'
+  s.add_development_dependency 'yajl-ruby'
+  s.add_development_dependency 'rack-rewrite'
+
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'bluecloth'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ['lib']
+end

data/lib/goliath.rb

@@ -0,0 +1,38 @@
+require 'eventmachine'
+require 'http/parser'
+require 'async_rack'
+require 'stringio'
+
+require 'goliath/version'
+require 'goliath/goliath'
+require 'goliath/runner'
+require 'goliath/server'
+require 'goliath/constants'
+require 'goliath/connection'
+require 'goliath/request'
+require 'goliath/response'
+require 'goliath/headers'
+require 'goliath/http_status_codes'
+
+require 'goliath/rack/default_response_format'
+require 'goliath/rack/heartbeat'
+require 'goliath/rack/params'
+require 'goliath/rack/render'
+require 'goliath/rack/default_mime_type'
+require 'goliath/rack/tracer'
+require 'goliath/rack/validation_error'
+require 'goliath/rack/formatters/json'
+require 'goliath/rack/formatters/html'
+require 'goliath/rack/formatters/xml'
+require 'goliath/rack/jsonp'
+
+require 'goliath/rack/validation/request_method'
+require 'goliath/rack/validation/required_param'
+require 'goliath/rack/validation/required_value'
+require 'goliath/rack/validation/numeric_range'
+require 'goliath/rack/validation/default_params'
+require 'goliath/rack/validation/boolean_value'
+
+require 'goliath/api'
+
+require 'goliath/application'

data/lib/goliath/api.rb

@@ -0,0 +1,165 @@
+require 'goliath/response'
+require 'goliath/request'
+
+module Goliath
+  # All Goliath APIs subclass Goliath::API. All subclasses _must_ override the
+  # {#response} method.
+  #
+  # @example
+  #  require 'goliath'
+  #
+  #  class HelloWorld < Goliath::API
+  #    def response(env)
+  #      [200, {}, "hello world"]
+  #    end
+  #  end
+  #
+  class API
+    class << self
+      # Retrieves the middlewares defined by this API server
+      #
+      # @return [Array] array contains [middleware class, args, block]
+      def middlewares
+        @middlewares ||= [[::Rack::ContentLength, nil, nil],
+                          [Goliath::Rack::DefaultResponseFormat, nil, nil]]
+      end
+
+      # Specify a middleware to be used by the API
+      #
+      # @example
+      #  use Goliath::Rack::Validation::RequiredParam, {:key => 'echo'}
+      #
+      #  use ::Rack::Rewrite do
+      #    rewrite %r{^(.*?)\??gziped=(.*)$}, lambda { |match, env| "#{match[1]}?echo=#{match[2]}" }
+      #  end
+      #
+      # @param name [Class] The middleware class to use
+      # @param args Any arguments to pass to the middeware
+      # @param block A block to pass to the middleware
+      def use(name, args = nil, &block)
+        middlewares.push([name, args, block])
+      end
+
+      # Returns the plugins configured for this API
+      #
+      # @return [Array] array contains [plugin name, args]
+      def plugins
+        @plugins ||= []
+      end
+
+      # Specify a plugin to be used by the API
+      #
+      # @example
+      #  plugin Goliath::Plugin::Latency
+      #
+      # @param name [Class] The plugin class to use
+      # @param args The arguments to the plugin
+      def plugin(name, *args)
+        plugins.push([name, args])
+      end
+
+      # Returns the router maps configured for the API
+      #
+      # @return [Array] array contains [path, block]
+      def maps
+        @maps ||= []
+      end
+
+      # Specify a router map to be used by the API
+      #
+      # @example
+      #  map '/version' do
+      #    run Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Version 0.1"]] }
+      #  end
+      #
+      # @param name [String] The URL path to map
+      # @param block The code to execute
+      def map(name, &block)
+        maps.push([name, block])
+      end
+    end
+
+    # Default stub method to add options into the option parser.
+    #
+    # @example
+    #  def options_parser(opts, options)
+    #    options[:test] = 0
+    #    opts.on('-t', '--test NUM', "The test number") { |val| options[:test] = val.to_i }
+    #  end
+    #
+    # @param opts [OptionParser] The options parser
+    # @param options [Hash] The hash to insert the parsed options into
+    def options_parser(opts, options)
+    end
+
+    # Accessor for the current env object
+    #
+    # @note This will not work in a streaming server. You must pass around the env object.
+    #
+    # @return [Goliath::Env] The current environment data for the request
+    def env
+      Thread.current[Goliath::Constants::GOLIATH_ENV]
+    end
+
+    # The API will proxy missing calls to the env object if possible.
+    #
+    # The two entries in this example are equivalent as long as you are not
+    # in a streaming server.
+    #
+    # @example
+    #   logger.info "Hello"
+    #   env.logger.info "Hello"
+
+    def method_missing(name, *args, &blk)
+      name = name.to_s
+      if env.respond_to?(name)
+        env.send(name, *args, &blk)
+      else
+        super(name.to_sym, *args, &blk)
+      end
+    end
+
+    # {#call} is executed automatically by the middleware chain and will setup
+    # the environment for the {#response} method to execute. This includes setting
+    # up a new Fiber, handing any execptions thrown from the API and executing
+    # the appropriate callback method for the API.
+    #
+    # @param env [Goliath::Env] The request environment
+    # @return [Goliath::Connection::AsyncResponse] An async response.
+    def call(env)
+      Fiber.new {
+        begin
+          Thread.current[Goliath::Constants::GOLIATH_ENV] = env
+          status, headers, body = response(env)
+
+          if body == Goliath::Response::STREAMING
+            env[Goliath::Constants::STREAM_START].call(status, headers)
+          else
+            env[Goliath::Constants::ASYNC_CALLBACK].call([status, headers, body])
+          end
+
+        rescue Exception => e
+          env.logger.error(e.message)
+          env.logger.error(e.backtrace.join("\n"))
+
+          env[Goliath::Constants::ASYNC_CALLBACK].call([400, {}, {:error => e.message}])
+        end
+      }.resume
+
+      Goliath::Connection::AsyncResponse
+    end
+
+    # Response is the main implementation method for Goliath APIs. All APIs
+    # should override this method in order to do any actual work.
+    #
+    # The response method will be executed in a new Fiber and wrapped in a
+    # begin rescue block to handle an thrown API errors.
+    #
+    # @param env [Goliath::Env] The request environment
+    # @return [Array] Array contains [Status code, Headers Hash, Body]
+    def response(env)
+      env.logger.error('You need to implement response')
+      [400, {}, {:error => 'No response implemented'}]
+    end
+  end
+end