goliath 0.9.2 → 0.9.4

data/examples/config/auth_and_rate_limit.rb

@@ -11,20 +11,23 @@ environment(:development) do
   timebin = ((Time.now.to_i / 3600).floor * 3600)
 
   # This user's calls should all go through
-  config['api_auth_db'].collection('AccountInfo').save({
+  config['api_auth_db'].collection(:account_info).save({
       :_id => 'i_am_awesome', 'valid' => true,  'max_call_rate' => 1_000_000 })
 
   # this user's account is disabled
-  config['api_auth_db'].collection('AccountInfo').save({
+  config['api_auth_db'].collection(:account_info).save({
       :_id => 'i_am_lame',    'valid' => false, 'max_call_rate' => 1_000 })
 
   # this user has not been seen, but will very quickly hit their limit
-  config['api_auth_db'].collection('AccountInfo').save({
+  config['api_auth_db'].collection(:account_info).save({
       :_id => 'i_am_limited', 'valid' => true, 'max_call_rate' =>     10 })
+  config['api_auth_db'].collection(:usage_info).save({
+      :_id => "i_am_limited-#{timebin}", 'calls' =>  0 })
 
   # fakes a user with a bunch of calls already made this hour -- two more = no yuo
-  config['api_auth_db'].collection('AccountInfo').save({
+  config['api_auth_db'].collection(:account_info).save({
       :_id => 'i_am_busy',    'valid' => true, 'max_call_rate' =>  1_000 })
-  config['api_auth_db'].collection('UsageInfo').save({
+  config['api_auth_db'].collection(:usage_info).save({
       :_id => "i_am_busy-#{timebin}", 'calls' =>  999 })
+
 end

data/examples/config/content_stream.rb

@@ -10,21 +10,17 @@ amqp_config = {
 }
 
 conn = AMQP.connect(amqp_config)
-
 xchange = AMQP::Channel.new(conn).fanout('stream')
+
 q = AMQP::Channel.new(conn).queue('stream/StreamAPI')
 q.bind(xchange)
 
-# pull data off the exchange and push to streams
-q.pop do |data|
-  if data.nil?
-    EM.add_timer(1) { q.pop }
-  else
-    config['channel'].push(data)
-    q.pop
-  end
+def handle_message(metadata, payload)
+  config['channel'].push(payload)
 end
 
+q.subscribe(&method(:handle_message))
+
 # push data into the stream. (Just so we have stuff going in)
 count = 0
 EM.add_periodic_timer(2) do

data/examples/early_abort.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+$:<< '../lib' << 'lib'
+require 'goliath'
+
+class EarlyAbort < Goliath::API
+  include Goliath::Validation
+  MAX_SIZE = 10
+  TEST_FILE = "/tmp/goliath-test-error.log"
+
+  def on_headers(env, headers)
+    env.logger.info 'received headers: ' + headers.inspect
+    env['async-headers'] = headers
+
+    if env['HTTP_X_CRASH'] && env['HTTP_X_CRASH'] == 'true'
+      raise Goliath::Validation::NotImplementedError.new("Can't handle requests with X-Crash: true.")
+    end
+  end
+
+  def on_body(env, data)
+    env.logger.info 'received data: ' + data
+    (env['async-body'] ||= '') << data
+    size = env['async-body'].size
+
+    if size >= MAX_SIZE
+      raise Goliath::Validation::BadRequestError.new("Payload size can't exceed #{MAX_SIZE} bytes. Received #{size.inspect} bytes.")
+    end
+  end
+
+  def on_close(env)
+    env.logger.info 'closing connection'
+  end
+
+  def response(env)
+    File.open(TEST_FILE, "w+") { |f| f << "response that should not be here"}
+    [200, {}, "OK"]
+  end
+end

data/examples/env_use_statements.rb

@@ -4,6 +4,9 @@ $:<< '../lib' << 'lib'
 require 'goliath'
 require 'yajl'
 
+# API must be started with -e [production, development, ...]
+# or set your ENV['RACK_ENV'] to specify the environemtn
+
 class EnvUseStatements < Goliath::API
   if Goliath.dev?
     use Goliath::Rack::Render, 'json'

data/examples/favicon.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require 'time'
+
+#
+# Reads a favicon.ico statically at load time, renders it on any request for
+# '/favicon.ico', and sends every other request on downstream.
+#
+# If you will be serving even one more file than this one, you should instead
+# use Rack::Static:
+#
+#     use(Rack::Static, # render static files from ./public
+#            :root => Goliath::Application.app_path("public"),
+#            :urls => ["/favicon.ico", '/stylesheets', '/javascripts', '/images'])
+#
+class Favicon
+  def initialize(app, filename)
+    @@favicon  = File.read(filename)
+    @@last_mod = File.mtime(filename).utc.rfc822
+    @@expires  = Time.at(Time.now + 604800).utc.rfc822 # 1 week from now
+    @app = app
+  end
+
+  def call(env, *args)
+    if env['REQUEST_PATH'] == '/favicon.ico'
+      return [200, {"Last-Modified"=> @@last_mod.to_s, "Expires" => @@expires, "Content-Type"=>"image/vnd.microsoft.icon"}, @@favicon]
+    else
+      return @app.call(env)
+    end
+  end
+end
+
+if File.expand_path($0) == File.expand_path(__FILE__)
+  $:<< '../lib' << 'lib'
+  require 'goliath'
+  puts "starting hello world!"
+  class HelloWorld < Goliath::API
+    HelloWorld.use(Favicon, File.expand_path(File.dirname(__FILE__)+"/public/favicon.ico"))
+  end
+  require(File.dirname(__FILE__)+'/hello_world.rb')
+end

data/examples/http_log.rb

@@ -56,6 +56,7 @@ class HttpLog < Goliath::API
   # Write the request information into mongo
   def record(process_time, resp, client_headers, response_headers)
     e = env
+    e.trace('http_log_record')
     EM.next_tick do
       doc = {
         request: {
@@ -81,4 +82,4 @@ class HttpLog < Goliath::API
       e.mongo.insert(doc)
     end
   end
-end
+end

data/examples/rack_routes.rb

@@ -26,6 +26,17 @@ class PostHelloWorld < Goliath::API
   end
 end
 
+class HeaderCollector < Goliath::API
+  def on_headers(env, header)
+    @headers ||= {}
+    @headers.merge!(header)
+  end
+
+  def response(env)
+    [200, {}, "headers: #{@headers.inspect}"]
+  end
+end
+
 class HelloNumber < Goliath::API
   use Goliath::Rack::Params
   def response(env)
@@ -76,6 +87,14 @@ class RackRoutes < Goliath::API
     run HelloWorld.new
   end
 
+  head "/hello_world" do
+    run HelloWorld.new
+  end
+
+  map "/headers", HeaderCollector do
+    use Goliath::Rack::Validation::RequestMethod, %w(GET)
+  end
+
   map "/bonjour" do
     run Bonjour.new
   end

data/examples/rasterize/rasterize.rb

@@ -2,6 +2,7 @@
 $: << File.dirname(__FILE__)+'/../../lib'
 require 'goliath'
 require 'postrank-uri'
+require File.dirname(__FILE__)+'/../favicon'
 
 # Install phantomjs: http://code.google.com/p/phantomjs/wiki/QuickStart
 # $> ruby rasterize.rb -sv
@@ -9,7 +10,7 @@ require 'postrank-uri'
 
 class Rasterize < Goliath::API
   use Goliath::Rack::Params
-
+  use Favicon, File.expand_path(File.dirname(__FILE__)+"/../public/favicon.ico")
   use Goliath::Rack::Validation::RequestMethod, %w(GET)
   use Goliath::Rack::Validation::RequiredParam, {:key => 'url'}
 

data/examples/rasterize/rasterize_and_shorten.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 $: << File.dirname(__FILE__)+'/../../lib'
 require File.dirname(__FILE__)+'/rasterize'
+require File.dirname(__FILE__)+'/../favicon'
 
 require 'goliath'
 require 'em-synchrony/em-http'
@@ -11,18 +12,21 @@ require 'postrank-uri'
 # generate a shortened link, stuffing it in the header. Both requests happen
 # simultaneously.
 #
-class ShortenURL < Goliath::Synchrony::MultiReceiver
+class ShortenURL
+  include Goliath::Rack::BarrierAroundware
   SHORTENER_URL_BASE = 'http://is.gd/create.php'
+  attr_accessor :shortened_url
 
   def pre_process
     target_url = PostRank::URI.clean(env.params['url'])
     shortener_request = EM::HttpRequest.new(SHORTENER_URL_BASE).aget(:query => { :format => 'simple', :url => target_url })
-    enqueue :shortener, shortener_request
+    enqueue :shortened_url, shortener_request
+    return Goliath::Connection::AsyncResponse
   end
 
   def post_process
-    if successes[:shortener]
-      headers['X-Shortened-URI'] = successes[:shortener].response
+    if shortened_url
+      headers['X-Shortened-URI'] = shortened_url.response
     end
     [status, headers, body]
   end
@@ -30,8 +34,9 @@ end
 
 class RasterizeAndShorten < Rasterize
   use Goliath::Rack::Params
+  use Favicon, File.expand_path(File.dirname(__FILE__)+"/../public/favicon.ico")
   use Goliath::Rack::Validation::RequestMethod, %w(GET)
   use Goliath::Rack::Validation::RequiredParam, {:key => 'url'}
   #
-  use Goliath::Rack::AsyncAroundware, ShortenURL
+  use Goliath::Rack::BarrierAroundwareFactory, ShortenURL
 end

data/goliath.gemspec

@@ -8,14 +8,12 @@ Gem::Specification.new do |s|
   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.homepage = 'http://goliath.io/'
+  s.summary = 'Async framework for writing API servers'
   s.description = s.summary
 
-  s.required_ruby_version = '>=1.9.2'
-
   s.add_dependency 'eventmachine', '>= 1.0.0.beta.3'
-  s.add_dependency 'em-synchrony', '>= 0.3.0.beta.1'
+  s.add_dependency 'em-synchrony', '>= 1.0.0'
   s.add_dependency 'http_parser.rb'
   s.add_dependency 'log4r'
 
@@ -24,13 +22,13 @@ Gem::Specification.new do |s|
   s.add_dependency 'rack-respond_to'
   s.add_dependency 'async-rack'
   s.add_dependency 'multi_json'
-  s.add_dependency 'http_router', '~> 0.8.9'
+  s.add_dependency 'http_router', '~> 0.9.0'
 
-  s.add_development_dependency 'rake', '0.8.7'
+  s.add_development_dependency 'rake', '>=0.8.7'
   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 'em-http-request', '>=1.0.0'
+  s.add_development_dependency 'em-mongo', '~> 0.4.0'
   s.add_development_dependency 'yajl-ruby'
   s.add_development_dependency 'rack-rewrite'
   s.add_development_dependency 'multipart_body'

data/lib/goliath/api.rb

@@ -125,9 +125,6 @@ module Goliath
       def map(name, *args, &block)
         opts = args.last.is_a?(Hash) ? args.pop : {}
         klass = args.first
-        if klass && block_given?
-          raise "Can't provide class and block to map"
-        end
         maps.push([name, klass, opts, block])
       end
 
@@ -137,7 +134,7 @@ module Goliath
           opts = args.last.is_a?(Hash) ? args.pop : {}
           klass = args.first
           opts[:conditions] ||= {}
-          opts[:conditions][:request_method] = [#{http_method == :get ? "'HEAD', 'GET'" : http_method.to_s.upcase.inspect}]
+          opts[:conditions][:request_method] = [#{http_method.to_s.upcase.inspect}]
           map(name, klass, opts, &block)
         end
         EOT
@@ -281,5 +278,20 @@ module Goliath
     def chunked_streaming_response(status_code = 200, headers = {})
       streaming_response(status_code, headers.merge(Goliath::Response::CHUNKED_STREAM_HEADERS))
     end
+
+    # Helper method to initialize the approriate API handler
+    #
+    # Called by the parser once headers are available to detect
+    # which API class should be handling the incoming request
+    def set_event_handler!(env)
+      if self.class.maps?
+        response = self.class.router.recognize(env)
+        if response = self.class.router.recognize(env) and response.respond_to?(:path) and response.path.route.api_class
+          env.event_handler = response.path.route.api_class.new
+        end
+      end
+      env.event_handler ||= self
+    end
+
   end
 end

data/lib/goliath/connection.rb

@@ -15,7 +15,6 @@ module Goliath
     attr_reader   :parser
 
     AsyncResponse = [-1, {}, []]
-
     def post_init
       @current = nil
       @requests = []
@@ -24,7 +23,7 @@ module Goliath
       @parser = Http::Parser.new
       @parser.on_headers_complete = proc do |h|
 
-        env = Goliath::Env.new
+        env = Thread.current[GOLIATH_ENV] = Goliath::Env.new
         env[SERVER_PORT] = port.to_s
         env[RACK_LOGGER] = logger
         env[OPTIONS]     = options
@@ -32,12 +31,14 @@ module Goliath
         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)
+        r.parse_header(h, @parser) do
+          @api.set_event_handler!(env) if @api
+
+          env[ASYNC_HEADERS] = env.event_handler.method(:on_headers) if env.event_handler.respond_to? :on_headers
+          env[ASYNC_BODY]    = env.event_handler.method(:on_body)    if env.event_handler.respond_to? :on_body
+          env[ASYNC_CLOSE]   = env.event_handler.method(:on_close)   if env.event_handler.respond_to? :on_close
+        end
 
         @requests.push(r)
       end

data/lib/goliath/deprecated/async_aroundware.rb

@@ -0,0 +1,133 @@
+module Goliath
+  module Rack
+    #
+    # Note: This class is deprecated. Instead, use BarrierAroundwareFactory
+    # (orchestrates multiple concurrent requests) or SimpleAroundwareFactory
+    # (like AsyncMiddleware, but with a simpler interface).
+    #
+    # The differences:
+    # * ResponseReceiver/MultiReceiver was a stupid name. The thing that has
+    #   pre_ and post_process is the Aroundware, the thing that manufactures
+    #   it is an AroundwareFactory.
+    # * An aroundware's pre_process may return a direct response, which is
+    #   immediately sent back upstream (no further downstream processing
+    #   happens). In the typical case, you will want to add
+    #       return Goliath::Connection::AsyncResponse
+    #   to your pre_process method.
+    # * ResponseReceiver used to masquerade as callback and middleware. Yuck.
+    #   The downstream response is now set via #accept_response, not #call.
+    #
+    # * change
+    #       use Goliath::Rack::AsyncAroundware, MyObsoleteReceiver
+    #   to
+    #       use Goliath::Rack::BarrierAroundwareFactory, MyHappyBarrier
+    # * `BarrierAroundware` provides the combined functionality of
+    #   `MultiReceiver` and `ResponseReceiver`, which will go away. It's now a
+    #   mixin (module) so you're not forced to inherit from it.
+    # * There is no more `responses` method: either use instance accessors or
+    #   look in the `successes`/`failures` hashes for yourresults.
+    # * Both enqueued responses and the downstream response are sent to
+    #   `accept_response`; there is no more  `call` method.
+    # * `MongoReceiver` will go away, because there's no need for it. See
+    #   `examples/auth_and_rate_limit.rb` for examples
+    #
+    class AsyncAroundware
+      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 < Goliath::Rack::MultiReceiver
+      #     def initialize(env, aq)
+      #       @awesomeness_quotient = aq
+      #       super(env)
+      #     end
+      #     # ... define pre_process and post_process ...
+      #   end
+      #
+      #   class AwesomeApiWithShortening < Goliath::API
+      #     use Goliath::Rack::AsyncAroundware, Awesomizer2011, 3
+      #     # ... stuff ...
+      #   end
+      #
+      # @param app [#call] the downstream app
+      # @param aroundware_klass a class that quacks like a
+      #   Goliath::Rack::ResponseReceiver and an EM::Deferrable
+      # @param *args [Array] extra args to pass to the aroundware
+      # @return [Goliath::Rack::AsyncAroundware]
+      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
+
+        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.call(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...
+        downstream_callback = Proc.new do |resp|
+          safely(env){ aroundware.call(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.callback(&invoke_upstream_chain)
+        aroundware.errback(&invoke_upstream_chain)
+      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 AsyncAroundware at creation
+      #
+      # @param env [Goliath::Env] The goliath environment
+      # @return [Goliath::Rack::ResponseReceiver] The response_receiver to process this request
+      def new_aroundware(env)
+        @aroundware_klass.new(env, *@aroundware_args)
+      end
+
+    end
+  end
+end