goliath 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c49ef49ca7b81daf949084e54013fe33751d9461
-  data.tar.gz: c9bd1ae49086f0fa8ff01dd8617994156ff1b448
+  metadata.gz: 2657a958a80151a0eab64c006eb13a4905156cc3
+  data.tar.gz: b140e7bdc85173bb06adeef69b504d7ab39d5197
 SHA512:
-  metadata.gz: 4d9e9698db573be7495f89394bae42ad613397489a5e979994b29ee1518238c73884444f8be2bdef7b7bea936a1bced59b07e7d85eb5cec5dc1e2fb75758de8a
-  data.tar.gz: 4a800250911ccb181214f88c43442539b18cb96676b960ffa8e7a3acddc1aa3413d83c58bab1b389280d09f4822ac97f815be9db80cd8dde52483a006e991062
+  metadata.gz: bdf5b587bcc2edefd5242b4c447e45787bd9affff51010c47484b9644ba005bc194d68b939c7117f78d375e3ebc16e05abc1292ff3b34626d9329fd140551957
+  data.tar.gz: 1cec64325f506e5838ec7893055c5e15cd52375c0e435b8cab69057d17424aa535f02537eab764a551064a161baeab27245d3a00a451ca0ca8215e720c3d0f1e

data/README.md

@@ -64,13 +64,14 @@ Goliath has been used in production environments for 2+ years, across many diffe
 * [Middleware](https://github.com/postrank-labs/goliath/wiki/Middleware)
 * [Configuration](https://github.com/postrank-labs/goliath/wiki/Configuration)
 * [Plugins](https://github.com/postrank-labs/goliath/wiki/Plugins)
+* [Zero Downtime Restart](https://github.com/postrank-labs/goliath/wiki/Zero-downtime-restart)
+
 
 ### Hands-on applications:
 
-If you are you new to EventMachine, or want a detailed walk-through of building a Goliath powered API? You're in luck, we have two super-awesome Peepcode screencasts which will teach you all you need to know:
+If you are you new to EventMachine, or want a detailed walk-through of building a Goliath powered API? You're in luck, a super-awesome Pluralsight screencast which will teach you all you need to know:
 
-* [Meet EventMachine: Part 1](http://peepcode.com/products/eventmachine) - introduction to EM, Fibers, etc.
-* [Meet EventMachine: Part 2](http://peepcode.com/products/eventmachine-ii) - building an API with Goliath
+* [Meet EventMachine](http://www.pluralsight.com/courses/meet-eventmachine) - introduction to EM, Fibers, building an API with Goliath
 
 Additionally, you can also watch this presentation from GoGaRuCo 2011, which describes the design and motivation behind Goliath:
 
@@ -90,4 +91,4 @@ Other resources:
 
 ## License & Acknowledgments
 
-Goliath is distributed under the MIT license, for full details please see the LICENSE file.
+Goliath is distributed under the MIT license, for full details please see the LICENSE file.

data/goliath.gemspec

@@ -12,13 +12,14 @@ Gem::Specification.new do |s|
   s.summary = 'Async framework for writing API servers'
   s.description = s.summary
 
-  s.required_ruby_version = '>=1.9.2'
+  s.required_ruby_version = '>=2.1.0'
 
   s.add_dependency 'eventmachine', '>= 1.0.0.beta.4'
   s.add_dependency 'em-synchrony', '>= 1.0.0'
-  s.add_dependency 'em-websocket', "0.3.8"
-  s.add_dependency 'http_parser.rb', '0.6.0'
+  s.add_dependency 'em-websocket', '0.3.8'
+  s.add_dependency 'http_parser.rb', '>= 0.6.0'
   s.add_dependency 'log4r'
+  s.add_dependency 'einhorn'
 
   s.add_dependency 'rack', '>=1.2.2'
   s.add_dependency 'rack-contrib'
@@ -27,7 +28,8 @@ Gem::Specification.new do |s|
   s.add_dependency 'multi_json'
 
   s.add_development_dependency 'rake', '>=0.8.7'
-  s.add_development_dependency 'rspec', '>2.0'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'test-unit'
   s.add_development_dependency 'nokogiri'
   s.add_development_dependency 'em-http-request', '>=1.0.0'
   s.add_development_dependency 'em-mongo', '~> 0.4.0'
@@ -35,14 +37,15 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'multipart_body'
   s.add_development_dependency 'amqp', '>=0.7.1'
   s.add_development_dependency 'em-websocket-client'
+  s.add_development_dependency 'em-eventsource'
 
   s.add_development_dependency 'tilt', '>=1.2.2'
   s.add_development_dependency 'haml', '>=3.0.25'
   s.add_development_dependency 'yard'
 
-  s.add_development_dependency 'guard', '~> 1.8.3'
-  s.add_development_dependency 'guard-rspec', '~> 3.1.0'
-  s.add_development_dependency 'listen', '~> 1.3.1'
+  s.add_development_dependency 'guard', '~> 2.0'
+  s.add_development_dependency 'guard-rspec', '~> 4.0'
+  s.add_development_dependency 'listen', '~> 2.0'
 
   if RUBY_PLATFORM != 'java'
     s.add_development_dependency 'yajl-ruby'

data/lib/goliath/api.rb

@@ -172,7 +172,7 @@ module Goliath
 
       rescue Goliath::Validation::Error => e
         env[RACK_EXCEPTION] = e
-        env[ASYNC_CALLBACK].call(validation_error(e.status_code, e.message))
+        env[ASYNC_CALLBACK].call(validation_error(e.status_code, e.message, e.headers))
 
       rescue Exception => e
         logthis = "#{e.backtrace[0]}: #{e.message} (#{e.class})\n"

data/lib/goliath/rack/jsonp.rb

@@ -18,10 +18,15 @@ module Goliath
           response = body
         end
 
+        response = "#{env.params['callback']}(#{response})"
+
         headers[Goliath::Constants::CONTENT_TYPE] = 'application/javascript'
-        [status, headers, ["#{env.params['callback']}(#{response})"]]
+        if headers['Content-Length']
+          headers['Content-Length'] = response.bytesize.to_s
+        end
+
+        [status, headers, [response]]
       end
     end
   end
 end
-

data/lib/goliath/rack/params.rb

@@ -60,10 +60,11 @@ module Goliath
       end
 
       def call(env)
-        Goliath::Rack::Validator.safely(env) do
+        error_response = Goliath::Rack::Validator.safely(env) do
           env['params'] = retrieve_params(env)
-          @app.call(env)
+          nil
         end
+        error_response || @app.call(env)
       end
     end
   end

data/lib/goliath/rack/validator.rb

@@ -39,7 +39,7 @@ module Goliath
         begin
           yield
         rescue Goliath::Validation::Error => e
-          validation_error(e.status_code, e.message, headers)
+          validation_error(e.status_code, e.message, e.headers.merge(headers))
         rescue Exception => e
           env.logger.error(e.message)
           env.logger.error(e.backtrace.join("\n"))

data/lib/goliath/request.rb

@@ -92,7 +92,7 @@ module Goliath
 
         @env[REQUEST_METHOD]  = parser.http_method
         @env[REQUEST_URI]     = parser.request_url
-        @env[QUERY_STRING]    = uri.query
+        @env[QUERY_STRING]    = uri.query || ''.freeze
         @env[HTTP_VERSION]    = parser.http_version.join('.')
         @env[SCRIPT_NAME]     = ""
         @env[REQUEST_PATH]    = uri.path
@@ -226,7 +226,7 @@ module Goliath
     # @return [Nil]
     def server_exception(e)
       if e.is_a?(Goliath::Validation::Error)
-        status, headers, body = [e.status_code, {}, ('{"error":"%s"}' % e.message)]
+        status, headers, body = [e.status_code, e.headers, ('{"error":"%s"}' % e.message)]
       else
         @env[RACK_LOGGER].error("#{e.message}\n#{e.backtrace.join("\n")}")
         message = Goliath.env?(:production) ? 'An error happened' : e.message

data/lib/goliath/runner.rb

@@ -150,6 +150,7 @@ module Goliath
         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.on('-E', '--einhorn', "Use Einhorn socket manager") { |v| @options[:einhorn] = true }
 
         opts.separator ""
         opts.separator "Daemon options:"
@@ -211,7 +212,8 @@ module Goliath
 
           File.umask(0000)
 
-          stdout_log_file = "#{File.dirname(@log_file)}/#{File.basename(@log_file)}_stdout.log"
+          log_extension = File.extname(@log_file)
+          stdout_log_file = "#{File.dirname(@log_file)}/#{File.basename(@log_file, log_extension)}_stdout#{log_extension}"
 
           STDIN.reopen("/dev/null")
           STDOUT.reopen(stdout_log_file, "a")
@@ -296,8 +298,7 @@ module Goliath
      # @return [Nil]
      def run_server
        log = setup_logger
-
-       log.info("Starting server on #{@address}:#{@port} in #{Goliath.env} mode. Watch out for stones.")
+       log.info("Starting server on http#{ @server_options[:ssl] ? 's' : nil }://#{@address}:#{@port} in #{Goliath.env} mode. Watch out for stones.")
 
        server = setup_server(log)
        server.api.setup if server.api.respond_to?(:setup)

data/lib/goliath/server.rb

@@ -1,4 +1,5 @@
 require 'em-synchrony'
+require 'einhorn'
 require 'goliath/connection'
 require 'goliath/goliath'
 
@@ -83,7 +84,7 @@ module Goliath
 
         EM.set_effective_user(options[:user]) if options[:user]
 
-        config[Goliath::Constants::GOLIATH_SIGNATURE] = EM.start_server(address, port, Goliath::Connection) do |conn|
+        config[Goliath::Constants::GOLIATH_SIGNATURE] = start_server(options) do |conn|
           if options[:ssl]
             conn.start_tls(
               :private_key_file => options[:ssl_key],
@@ -105,9 +106,23 @@ module Goliath
       end
     end
 
+    def start_server(options, &blk)
+      if options[:einhorn]
+        fd_num = Einhorn::Worker.socket!
+        socket = Socket.for_fd(fd_num)
+
+        EM.attach_server(socket, Goliath::Connection, &blk)
+      else
+        EM.start_server(address, port, Goliath::Connection, &blk)
+      end
+    end
+
     # Stops the server running.
     def stop
-      EM.stop
+      EM.add_timer(0) do
+        logger.info('Stopping server...')
+        EM.stop
+      end
     end
 
     # Loads a configuration file

data/lib/goliath/test_helper_sse.rb

@@ -0,0 +1,76 @@
+require 'em-eventsource'
+
+module Goliath
+  module TestHelper
+    class SSEHelper
+      attr_reader :connection
+      def initialize(url)
+        @message_queue = EM::Queue.new
+        @named_queues = {}
+        @connection = EM::EventSource.new(url)
+      end
+
+      def listen
+        @connection.message do |message|
+          @message_queue.push(message)
+        end
+      end
+
+      def listen_to(name)
+        queue = (@named_queues[name] ||= [])
+        @connection.on(name) do |message|
+          queue.push(message)
+        end
+      end
+
+      def receive
+        pop_queue(@message_queue)
+      end
+
+      def receive_on(name)
+        queue = @named_queues.fetch(name) do
+          raise ArgumentError, "You have to call listen_to('#{name}') first"
+        end
+
+        pop_queue(queue)
+      end
+
+      def with_async_http
+        klass = EM::HttpConnection
+        if klass.instance_methods.include?(:aget)
+          begin
+            klass.send(:class_eval) do
+              alias :sget :get
+              alias :get :aget
+            end
+            yield if block_given?
+          ensure
+            klass.send(:class_eval) do
+              alias :get :sget
+              remove_method :sget
+            end
+          end
+        else
+          yield if block_given?
+        end
+      end
+
+      protected
+
+      def pop_queue(queue)
+        fiber = Fiber.current
+        queue.pop { |m| fiber.resume(m) }
+        Fiber.yield
+      end
+    end
+
+    def sse_client_connect(path,&blk)
+      url = "http://localhost:#{@test_server_port}#{path}"
+      client = SSEHelper.new(url)
+      client.with_async_http { client.connection.start }
+      client.listen
+      Fiber.new { blk.call(client) }.resume if blk
+      stop
+    end
+  end
+end

data/lib/goliath/validation/error.rb

@@ -4,6 +4,8 @@ module Goliath
     class Error < StandardError
       # The status code to return from the error handler
       attr_accessor :status_code
+      # The headers to return from the error handler
+      attr_accessor :headers
 
       # Create a new Goliath::Validation::Error.
       #
@@ -13,9 +15,10 @@ module Goliath
       # @param status_code [Integer] The status code to return
       # @param message [String] The error message to return
       # @return [Goliath::Validation::Error] The Goliath::Validation::Error
-      def initialize(status_code, message)
+      def initialize(status_code, message, headers = {})
         super(message)
         @status_code = status_code
+        @headers = headers
       end
     end
   end

data/lib/goliath/version.rb

@@ -1,4 +1,4 @@
 module Goliath
   # The current version of Goliath
-  VERSION = '1.0.4'
+  VERSION = '1.0.5'
 end

data/spec/integration/early_abort_spec.rb

@@ -25,7 +25,7 @@ describe EarlyAbort do
 
       post_request(request_data, err) do |c|
         c.response.should == "{\"error\":\"Can't handle requests with X-Crash: true.\"}"
-        File.exist?("/tmp/goliath-test-error.log").should be_false
+        File.exist?("/tmp/goliath-test-error.log").should be false
       end
     end
   end
@@ -36,8 +36,8 @@ describe EarlyAbort do
 
       post_request(request_data, err) do |c|
         c.response.should =~ /Payload size can't exceed 10 bytes/
-        File.exist?("/tmp/goliath-test-error.log").should be_false
+        File.exist?("/tmp/goliath-test-error.log").should be false
       end
     end
   end
-end
+end

data/spec/integration/event_stream_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require File.join(File.dirname(__FILE__), '../../', 'lib/goliath/test_helper_sse')
+require File.join(File.dirname(__FILE__), '../../', 'lib/goliath')
+require File.join(File.dirname(__FILE__), '../../', 'lib/goliath/api')
+
+class EventStreamEndpoint < Goliath::API
+  def self.events
+    @events ||= EM::Queue.new
+  end
+
+  def response(env)
+    self.class.events.pop do |event|
+      payload = if event.key?(:name)
+        "event: #{event[:name]}\ndata: #{event[:data]}\n\n"
+      else
+        "data: #{event[:data]}\n\n"
+      end
+      env.stream_send(payload)
+    end
+    streaming_response(200, 'Content-Type' => 'text/event-stream')
+  end
+end
+
+describe 'EventStream' do
+  include Goliath::TestHelper
+
+  context 'named events' do
+    it 'should accept stream' do
+      with_api(EventStreamEndpoint, {:verbose => true, :log_stdout => true}) do |server|
+        sse_client_connect('/stream') do |client|
+          client.listen_to('custom_event')
+          EventStreamEndpoint.events.push(name: 'custom_event', data: 'content')
+          client.receive_on('custom_event').should == ['content']
+          client.receive.should == []
+        end
+      end
+    end
+  end
+
+  context 'unnamed events' do
+    it 'should accept stream' do
+      with_api(EventStreamEndpoint, {:verbose => true, :log_stdout => true}) do |server|
+        sse_client_connect('/stream') do |client|
+          EventStreamEndpoint.events.push(data: 'content')
+          client.receive.should == ['content']
+        end
+      end
+    end
+  end
+end

data/spec/integration/exception_handling_spec.rb

@@ -0,0 +1,202 @@
+# This integration spec isn't *quite* about exception handling. It's more of a
+# regression test, since Goliath::Rack::Params used to swallow any exception
+# generated downstream from it in the middleware chain (even though
+# Goliath::API#call handles exceptions already).
+
+require 'spec_helper'
+
+class ExceptionHandlingMiddleware
+  include Goliath::Rack::AsyncMiddleware
+  include Goliath::Constants
+
+  def call(env)
+    # This kind of relies on downstream middleware raising their own exceptions
+    # if something goes wrong. Alternatively, they could rescue the exception
+    # and set env[RACK_EXCEPTION]. See #post_process.
+    super
+  rescue Exception => e
+    handle_exception(e)
+  end
+
+  def post_process(env, status, headers, body)
+    # If an exception was raised by Goliath::API#call, it will store the
+    # exception in env[RACK_EXCEPTION] and automatically generate an error
+    # response. We circumvent the usual error response by returning our own.
+    return handle_exception(env[RACK_EXCEPTION]) if env[RACK_EXCEPTION]
+    [status, headers, body]
+  end
+
+  private
+
+  def handle_exception(e)
+    # You could imagine this middleware having some sort of side effect, like
+    # sending your team an email alert detailing the exception. For the
+    # purposes of the spec, we'll just return some text.
+    [200, {}, "Exception raised: #{e.message}"]
+  end
+end
+
+class ExceptionRaisingMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    raise env.params['raise'] if env.params['raise']
+    @app.call(env)
+  end
+end
+
+class ExceptionHandlingAPI < Goliath::API
+  # The exception handling middleware should come first in the chain so that
+  # any exception in the rest of the chain gets rescued.
+  use ExceptionHandlingMiddleware
+
+  # Require param parsing before the exception raising middleware, because the
+  # latter depends on params being parsed. Herein lies the regression:
+  # Goliath::Rack::Params used to swallow any exceptions raised downstream from
+  # it (here, ExceptionRaisingMiddleware), so any upstream middleware (here,
+  # ExceptionHandlingMiddleware) would be none the wiser. Really, the only
+  # thing Goliath::Rack::Params should be worried about is whether it can parse
+  # the params.
+  use Goliath::Rack::Params
+
+  # Allow us to raise an exception on demand with the param raise=<message>.
+  # You could imagine something less dumb for a real-life application that
+  # incidentally raises an exception, if you'd like.
+  use ExceptionRaisingMiddleware
+
+  def response(env)
+    # Goliath::API#call ensures that any exceptions raised here get rescued and
+    # stored in env[RACK_EXCEPTION].
+    fail env.params['fail'] if env.params['fail']
+    [200, {}, 'No exceptions raised']
+  end
+end
+
+describe ExceptionHandlingAPI do
+  let(:err) { Proc.new { fail 'API request failed' } }
+
+  context 'when no exceptions get raised' do
+    let(:query) { '' }
+
+    it 'returns a normal response' do
+      with_api(ExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          c.response_header.status.should == 200
+          c.response.should == 'No exceptions raised'
+        end
+      end
+    end
+  end
+
+  context 'when a middleware raises an exception' do
+    let(:query) { 'raise=zoinks' }
+
+    it 'handles the exception using ExceptionHandlingMiddleware' do
+      with_api(ExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          c.response_header.status.should == 200
+          c.response.should == 'Exception raised: zoinks'
+        end
+      end
+    end
+  end
+
+  context 'when the API raises an exception' do
+    let(:query) { 'fail=jinkies' }
+
+    it 'handles the exception using ExceptionHandlingMiddleware' do
+      with_api(ExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          c.response_header.status.should == 200
+          c.response.should == 'Exception raised: jinkies'
+        end
+      end
+    end
+  end
+
+  context 'when param parsing raises an exception' do
+    let(:query) { 'ambiguous[]=&ambiguous[4]=' }
+
+    it 'returns a validation error generated by Goliath::Rack::Params' do
+      with_api(ExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          c.response_header.status.should == 400
+          c.response.should == "[:error, \"Invalid parameters: Rack::Utils::ParameterTypeError\"]"
+        end
+      end
+    end
+  end
+end
+
+# This API has the same setup as ExceptionHandlingAPI, except for the crucial
+# difference that it does *not* use ExceptionHandlingMiddleware. This is to
+# make sure that exceptions are still rescued somewhere in an API call, even
+# though they aren't getting swallowed by Goliath::Rack::Params anymore.
+
+class PassiveExceptionHandlingAPI < Goliath::API
+  use Goliath::Rack::Params
+  use ExceptionRaisingMiddleware
+
+  def response(env)
+    fail env.params['fail'] if env.params['fail']
+    [200, {}, 'No exceptions raised']
+  end
+end
+
+describe PassiveExceptionHandlingAPI do
+  let(:err) { Proc.new { fail 'API request failed' } }
+
+  context 'when no exceptions get raised' do
+    let(:query) { '' }
+
+    it 'returns a normal response' do
+      with_api(PassiveExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          c.response_header.status.should == 200
+          c.response.should == 'No exceptions raised'
+        end
+      end
+    end
+  end
+
+  context 'when a middleware raises an exception' do
+    let(:query) { 'raise=ruh-roh' }
+
+    it 'returns the server error generated by Goliath::Request#process' do
+      with_api(PassiveExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          c.response_header.status.should == 500
+          c.response.should == 'ruh-roh'
+        end
+      end
+    end
+  end
+
+  context 'when the API raises an exception' do
+    let(:query) { 'fail=puppy-power' }
+
+    it 'returns the validation error generated by Goliath::API#call' do
+      with_api(PassiveExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          c.response_header.status.should == 500
+          c.response.should == '[:error, "puppy-power"]'
+        end
+      end
+    end
+  end
+
+  context 'when param parsing raises an exception' do
+    let(:query) { 'ambiguous[]=&ambiguous[4]=' }
+
+    it 'returns a validation error generated by Goliath::Rack::Params' do
+      with_api(PassiveExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          c.response_header.status.should == 400
+          c.response.should == '[:error, "Invalid parameters: Rack::Utils::ParameterTypeError"]'
+        end
+      end
+    end
+  end
+end