goliath 0.9.4 → 1.0.0.beta.1

data/lib/goliath/request.rb

@@ -16,6 +16,30 @@ module Goliath
 
     attr_accessor :app, :conn, :env, :response, :body
 
+    class << self
+      ##
+      # Allow user to redefine how fibers are handled, the
+      # default is to spawn a new fiber each time but another
+      # option is to use a pool of fibers.
+      #
+      attr_accessor :execute_block
+
+      ##
+      # Allow users to redefine what exactly is logged
+      #
+      attr_accessor :log_block
+    end
+
+    self.log_block = proc do |env, response, elapsed_time|
+      env[RACK_LOGGER].info("Status: #{response.status}, " +
+          "Content-Length: #{response.headers['Content-Length']}, " +
+          "Response Time: #{"%.2f" % elapsed_time}ms")
+    end
+
+    self.execute_block = proc do |&block|
+      Fiber.new(&block).resume
+    end
+
     def initialize(app, conn, env)
       @app  = app
       @conn = conn
@@ -120,7 +144,7 @@ module Goliath
       begin
         @env[ASYNC_CLOSE].call(@env) if @env[ASYNC_CLOSE]
       rescue Exception => e
-        server_exception(e)
+        @env[RACK_LOGGER].error("on_close Exception: #{e.class}, message: #{e.message}")
       end
     end
 
@@ -132,7 +156,7 @@ module Goliath
     #
     # @return [Nil]
     def process
-      Fiber.new {
+      Goliath::Request.execute_block.call do
         begin
           @state = :finished
           @env['rack.input'].rewind if @env['rack.input']
@@ -140,7 +164,7 @@ module Goliath
         rescue Exception => e
           server_exception(e)
         end
-      }.resume
+      end
     end
 
     # Invoked by the app / middleware once the request
@@ -171,11 +195,16 @@ module Goliath
           begin
             @response.status, @response.headers, @response.body = status, headers, body
             @response.each { |chunk| @conn.send_data(chunk) }
-            @env[RACK_LOGGER].info("Status: #{@response.status}, " +
-                                   "Content-Length: #{@response.headers['Content-Length']}, " +
-                                   "Response Time: #{"%.2f" % ((Time.now.to_f - @env[:start_time]) * 1000)}ms")
 
-                                   @conn.terminate_request(keep_alive)
+            elapsed_time = (Time.now.to_f - @env[:start_time]) * 1000
+            begin
+              Goliath::Request.log_block.call(@env, @response, elapsed_time)
+            rescue => err
+              # prevent an infinite loop if the block raised an error
+              @env[RACK_LOGGER].error("log block raised #{err}")
+            end
+
+            @conn.terminate_request(keep_alive)
           rescue Exception => e
             server_exception(e)
           end
@@ -194,11 +223,14 @@ 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, {}, ('{"error":"%s"}' % e.message)]
       else
         @env[RACK_LOGGER].error("#{e.message}\n#{e.backtrace.join("\n")}")
-        status, headers, body = [500, {}, 'An error happened']
+        message = Goliath.env?(:production) ? 'An error happened' : e.message
+
+        status, headers, body = [500, {}, message]
       end
+
       headers['Content-Length'] = body.bytesize.to_s
       @env[:terminate_connection] = true
       post_process([status, headers, body])

data/lib/goliath/response.rb

@@ -59,10 +59,8 @@ module Goliath
 
         if vs.is_a?(String)
           vs.each_line { |v| @headers[k] = v.chomp }
-
         elsif vs.is_a?(Time)
           @headers[k] = vs
-
         else
           vs.each { |v| @headers[k] = v.chomp }
         end

data/lib/goliath/runner.rb

@@ -4,6 +4,44 @@ require 'optparse'
 require 'log4r'
 
 module Goliath
+
+  # The default run environment, should one not be set.
+  DEFAULT_ENV = :development
+
+  # The environment for a Goliath app can come from a variety of different
+  # sources.  Due to the loading order of middleware, we must parse this out
+  # at load-time rather than run time.
+  #
+  # Note that, as implemented, you cannot pass -e as part of a compound flag
+  # (e.g. `-sve production`) as it won't be picked up.  The example given would
+  # have to be provided as `-sv -e production`.
+  #
+  # For more detail, see: https://github.com/postrank-labs/goliath/issues/18
+  class EnvironmentParser
+
+    # Work out the current runtime environemnt.
+    #
+    # The sources of environment, in increasing precedence, are:
+    #
+    #   1. Default (see Goliath::DEFAULT_ENV)
+    #   2. RACK_ENV
+    #   3. -e/--environment command line options
+    #   4. Hard-coded call to Goliath#env=
+    #
+    # @param argv [Array] The command line arguments
+    # @return [Symbol] The current environemnt
+    def self.parse(argv = [])
+      env = ENV["RACK_ENV"] || Goliath::DEFAULT_ENV
+      if (i = argv.index('-e')) || (i = argv.index('--environment'))
+        env = argv[i + 1]
+      end
+      env.to_sym
+    end
+  end
+
+  # Set the environment immediately before we do anything else.
+  Goliath.env = Goliath::EnvironmentParser.parse(ARGV)
+
   # The Goliath::Runner is responsible for parsing any provided options, setting up the
   # rack application, creating a logger, and then executing the Goliath::Server with the loaded information.
   class Runner
@@ -63,7 +101,9 @@ module Goliath
     def initialize(argv, api)
       api.options_parser(options_parser, options) if api
       options_parser.parse!(argv)
-      Goliath.env = options.delete(:env)
+
+      # We've already dealt with the environemnt, so just discard it.
+      options.delete(:env)
 
       @api = api
       @address = options.delete(:address)
@@ -90,7 +130,7 @@ module Goliath
         :daemonize => false,
         :verbose => false,
         :log_stdout => false,
-        :env => :development,
+        :env => Goliath::DEFAULT_ENV
       }
 
       @options_parser ||= OptionParser.new do |opts|
@@ -99,7 +139,10 @@ module Goliath
         opts.separator ""
         opts.separator "Server options:"
 
-        opts.on('-e', '--environment NAME', "Set the execution environment (prod, dev or test) (default: #{@options[:env]})") { |val| @options[:env] = val }
+        # The environment isn't set as part of this option parsing routine, but
+        # we'll leave the flag here so a call to --help shows it correctly.
+        opts.on('-e', '--environment NAME', "Set the execution environment (default: #{@options[:env]})") { |val| @options[:env] = val }
+
         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 }
@@ -142,7 +185,7 @@ module Goliath
     #
     # @return [Nil]
     def run
-      unless Goliath.test?
+      unless Goliath.env?(:test)
         $LOADED_FEATURES.unshift(File.basename($0))
         Dir.chdir(File.expand_path(File.dirname($0)))
       end
@@ -165,6 +208,7 @@ module Goliath
           STDERR.reopen(STDOUT)
 
           run_server
+          remove_pid
         end
       else
         run_server
@@ -244,5 +288,12 @@ module Goliath
        FileUtils.mkdir_p(File.dirname(@pid_file))
        File.open(@pid_file, 'w') { |f| f.write(pid) }
      end
+
+     # Remove the pid file specified by @pid_file
+     #
+     # @return [Nil]
+     def remove_pid
+       File.delete(@pid_file)
+     end
   end
 end

data/lib/goliath/server.rb

@@ -73,14 +73,17 @@ module Goliath
       EM.synchrony do
         trap("INT")  { EM.stop }
         trap("TERM") { EM.stop }
-        trap("HUP")  { load_config(options[:config]) }
+
+        if RUBY_PLATFORM !~ /mswin|mingw/
+          trap("HUP")  { load_config(options[:config]) }
+        end
 
         load_config(options[:config])
         load_plugins
 
         EM.set_effective_user(options[:user]) if options[:user]
 
-        EM.start_server(address, port, Goliath::Connection) do |conn|
+        config[Goliath::Constants::GOLIATH_SIGNATURE] = EM.start_server(address, port, Goliath::Connection) do |conn|
           if options[:ssl]
             conn.start_tls(
               :private_key_file => options[:ssl_key],
@@ -111,7 +114,8 @@ module Goliath
       file ||= "#{config_dir}/#{api_name}.rb"
       return unless File.exists?(file)
 
-      eval(IO.read(file))
+      proc = Proc.new {} # create proc to grab binding
+      eval(IO.read(file), proc.binding, file)
     end
 
     # Retrieves the configuration directory for the server

data/lib/goliath/test_helper.rb

@@ -1,8 +1,9 @@
 require 'em-synchrony'
 require 'em-synchrony/em-http'
 
+require 'goliath/api'
 require 'goliath/server'
-require 'goliath/rack/builder'
+require 'goliath/rack'
 require 'rack'
 
 module Goliath
@@ -16,7 +17,7 @@ module Goliath
   #     it 'returns the echo param' do
   #       with_api(Echo) do
   #         get_request({:query => {:echo => 'test'}}, err) do |c|
-  #           b = Yajl::Parser.parse(c.response)
+  #           b = MultiJson.load(c.response)
   #           b['response'].should == 'test'
   #         end
   #       end
@@ -39,21 +40,43 @@ module Goliath
       op = OptionParser.new
 
       s = Goliath::Server.new
-      s.logger = mock('log').as_null_object
+      s.logger = setup_logger(options)
       s.api = api.new
       s.app = Goliath::Rack::Builder.build(api, s.api)
       s.api.options_parser(op, options)
       s.options = options
-      s.port = @test_server_port = port
+      s.port = port
+      s.plugins = api.plugins
+      @test_server_port = s.port if blk
       s.start(&blk)
       s
     end
 
+    def setup_logger(opts)
+      return fake_logger if opts[:log_file].nil? && opts[:log_stdout].nil?
+
+      log = Log4r::Logger.new('goliath')
+      log_format = Log4r::PatternFormatter.new(:pattern => "[#{Process.pid}:%l] %d :: %m")
+      log.level = opts[:verbose].nil? ? Log4r::INFO : Log4r::DEBUG
+
+      if opts[:log_stdout]
+        log.add(Log4r::StdoutOutputter.new('console', :formatter => log_format))
+      elsif opts[:log_file]
+        file = opts[:log_file]
+        FileUtils.mkdir_p(File.dirname(file))
+
+       log.add(Log4r::FileOutputter.new('fileOutput', {:filename => file,
+                                                       :trunc => false,
+                                                       :formatter => log_format}))
+      end
+      log
+    end
+
     # Stops the launched API
     #
     # @return [Nil]
     def stop
-      EM.stop
+      EM.stop_event_loop
     end
 
     # Wrapper for launching API and executing given code block. This
@@ -84,33 +107,33 @@ module Goliath
       req.errback { stop }
     end
 
-    # Make a HEAD request the currently launched API.
+    # Make a HEAD request against the currently launched API.
     #
     # @param request_data [Hash] Any data to pass to the HEAD request.
     # @param errback [Proc] An error handler to attach
     # @param blk [Proc] The callback block to execute
     def head_request(request_data = {}, errback = nil, &blk)
-      req = test_request(request_data).head(request_data)
+      req = create_test_request(request_data).head(request_data)
       hookup_request_callbacks(req, errback, &blk)
     end
 
-    # Make a GET request the currently launched API.
+    # Make a GET request against the currently launched API.
     #
     # @param request_data [Hash] Any data to pass to the GET request.
     # @param errback [Proc] An error handler to attach
     # @param blk [Proc] The callback block to execute
     def get_request(request_data = {}, errback = nil, &blk)
-      req = test_request(request_data).get(request_data)
+      req = create_test_request(request_data).get(request_data)
       hookup_request_callbacks(req, errback, &blk)
     end
 
-    # Make a POST request the currently launched API.
+    # Make a POST request against the currently launched API.
     #
     # @param request_data [Hash] Any data to pass to the POST request.
     # @param errback [Proc] An error handler to attach
     # @param blk [Proc] The callback block to execute
     def post_request(request_data = {}, errback = nil, &blk)
-      req = test_request(request_data).post(request_data)
+      req = create_test_request(request_data).post(request_data)
       hookup_request_callbacks(req, errback, &blk)
     end
 
@@ -120,23 +143,54 @@ module Goliath
     # @param errback [Proc] An error handler to attach
     # @param blk [Proc] The callback block to execute
     def put_request(request_data = {}, errback = nil, &blk)
-      req = test_request(request_data).put(request_data)
+      req = create_test_request(request_data).put(request_data)
       hookup_request_callbacks(req, errback, &blk)
     end
 
-    # Make a DELETE request the currently launched API.
+    # Make a PATCH request against the currently launched API.
+    #
+    # @param request_data [Hash] Any data to pass to the PUT request.
+    # @param errback [Proc] An error handler to attach
+    # @param blk [Proc] The callback block to execute
+    def patch_request(request_data = {}, errback = nil, &blk)
+      req = create_test_request(request_data).patch(request_data)
+      hookup_request_callbacks(req, errback, &blk)
+    end
+
+    # Make a DELETE request against the currently launched API.
     #
     # @param request_data [Hash] Any data to pass to the DELETE request.
     # @param errback [Proc] An error handler to attach
     # @param blk [Proc] The callback block to execute
     def delete_request(request_data = {}, errback = nil, &blk)
-      req = test_request(request_data).delete(request_data)
+      req = create_test_request(request_data).delete(request_data)
+      hookup_request_callbacks(req, errback, &blk)
+    end
+
+    # Make an OPTIONS request against the currently launched API.
+    #
+    # @param request_data [Hash] Any data to pass to the OPTIONS request.
+    # @param errback [Proc] An error handler to attach
+    # @param blk [Proc] The callback block to execute
+    def options_request(request_data = {}, errback = nil, &blk)
+      req = create_test_request(request_data).options(request_data)
       hookup_request_callbacks(req, errback, &blk)
     end
 
-    def test_request(request_data)
+    def create_test_request(request_data)
       path = request_data.delete(:path) || ''
-      EM::HttpRequest.new("http://localhost:#{@test_server_port}#{path}")
+      opts = request_data.delete(:connection_options) || {}
+      EM::HttpRequest.new("http://localhost:#{@test_server_port}#{path}", opts)
+    end
+
+    private
+
+    def fake_logger
+      Class.new do
+        def method_missing(name, *args, &blk)
+          nil
+        end
+      end.new
     end
   end
 end

data/lib/goliath/test_helper_ws.rb

@@ -0,0 +1,42 @@
+require 'em-websocket-client'
+
+module Goliath
+  module TestHelper
+    class WSHelper
+      attr_reader :connection
+      def initialize(url)
+        @queue = EM::Queue.new
+
+        fiber = Fiber.current
+        @connection = EventMachine::WebSocketClient.connect(url)
+        @connection.errback do |e|
+          puts "Error encountered during connection: #{e}"
+          EM::stop_event_loop
+        end
+
+        @connection.callback { fiber.resume }
+        @connection.disconnect { EM::stop_event_loop }
+        @connection.stream { |m| @queue.push(m) }
+
+        Fiber.yield
+      end
+
+      def send(m)
+        @connection.send_msg(m)
+      end
+
+      def receive
+        fiber = Fiber.current
+        @queue.pop {|m| fiber.resume(m) }
+        Fiber.yield
+      end
+    end
+
+    def ws_client_connect(path,&blk)
+      url = "ws://localhost:#{@test_server_port}#{path}"
+      client = WSHelper.new(url)
+      blk.call(client) if blk
+      stop
+    end
+  end
+end

data/lib/goliath/version.rb

@@ -1,4 +1,4 @@
 module Goliath
   # The current version of Goliath
-  VERSION = '0.9.4'
+  VERSION = '1.0.0.beta.1'
 end

data/lib/goliath/websocket.rb

@@ -0,0 +1,80 @@
+require 'em-websocket'
+
+module Goliath
+  class WebSocket < Goliath::API
+    include Goliath::Constants
+
+    def on_open(env) ; end
+    def on_message(env, msg) ; end
+    def on_close(env) ; end
+    def on_error(env, error) ; end
+
+    def on_headers(env, headers)
+      env['goliath.request-headers'] = headers
+    end
+
+    def on_body(env, data)
+      env.handler.receive_data(data)
+    end
+
+    def response(env)
+      request = {}
+
+      # em-websockets expects the keys to all be lowercase so we need to convert
+      env['goliath.request-headers'].each_pair do |key, value|
+        request[key.downcase] = value
+      end
+
+      request['path'] = env[REQUEST_PATH]
+      request['method'] = env[REQUEST_METHOD]
+      request['query'] = env[QUERY_STRING]
+
+      old_stream_send = env[STREAM_SEND]
+      old_stream_close = env[STREAM_CLOSE]
+      env[STREAM_SEND]  = proc { |data| env.handler.send_text_frame(data) }
+      env[STREAM_CLOSE] = proc { |code, body| env.handler.close_websocket(code, body) }
+      env[STREAM_START] = proc { }
+
+      conn = Class.new do
+        def initialize(env, parent, stream_send, connection_close)
+          @env = env
+          @parent = parent
+          @stream_send = stream_send
+          @connection_close = connection_close
+        end
+
+        def trigger_on_open
+          @parent.on_open(@env)
+        end
+
+        def trigger_on_close
+          @parent.on_close(@env)
+        end
+
+        def trigger_on_message(msg)
+          @parent.on_message(@env, msg)
+        end
+
+        def close_connection_after_writing
+          @connection_close.call
+        end
+
+        def send_data(data)
+          @stream_send.call(data)
+        end
+      end.new(env, self, old_stream_send, old_stream_close)
+
+      upgrade_data = env[UPGRADE_DATA]
+      begin
+        env['handler'] = EM::WebSocket::HandlerFactory.build_with_request(conn, request,
+            upgrade_data, false, false)
+      rescue Exception => e
+        env.logger.error("#{e.message}\n#{e.backtrace.join("\n")}")
+        return [500, {}, {:error => "Upgrade failed"}]
+      end
+      env['handler'].run
+
+      Goliath::Connection::AsyncResponse
+    end
+  end
+end

data/spec/integration/async_request_processing.rb

@@ -12,7 +12,7 @@ describe 'Async Request processing' do
       err = Proc.new { fail "API request failed" }
 
       post_request(request_data, err) do |c|
-        resp = Yajl::Parser.parse(c.response)
+        resp = MultiJson.load(c.response)
         resp['body'].should match('some=data')
         resp['head'].should include('X-Upload')
       end

data/spec/integration/early_abort_spec.rb

@@ -16,14 +16,10 @@ describe EarlyAbort do
     end
   end
 
-  # The following two tests are very brittle, since they depend on the speed
-  # of the machine executing the test and the size of the incoming data
-  # packets. I hope someone more knowledgeable will be able to refactor these
-  # ;-)
   it 'fails without going in the response method if exception is raised in on_header hook' do
     with_api(EarlyAbort) do
       request_data = {
-        :body => (["abcd"] * 200_000).join,
+        :body => "a" * 20,
         :head => {'X-Crash' => 'true'}
       }
 
@@ -36,9 +32,7 @@ describe EarlyAbort do
 
   it 'fails without going in the response method if exception is raised in on_body hook' do
     with_api(EarlyAbort) do
-      request_data = {
-        :body => (["abcd"] * 200_000).join
-      }
+      request_data = { :body => "a" * 20 }
 
       post_request(request_data, err) do |c|
         c.response.should =~ /Payload size can't exceed 10 bytes/
@@ -46,5 +40,4 @@ describe EarlyAbort do
       end
     end
   end
-
-end
+end

data/spec/integration/echo_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require File.join(File.dirname(__FILE__), '../../', 'examples/echo')
 require 'multipart_body'
-require 'yajl'
+require 'yajl' if RUBY_PLATFORM != 'java'
 
 describe Echo do
   let(:err) { Proc.new { fail "API request failed" } }
@@ -9,7 +9,7 @@ describe Echo do
   it 'returns the echo param' do
     with_api(Echo) do
       get_request({:query => {:echo => 'test'}}, err) do |c|
-        b = Yajl::Parser.parse(c.response)
+        b = MultiJson.load(c.response)
         b['response'].should == 'test'
       end
     end
@@ -18,9 +18,9 @@ describe Echo do
   it 'returns error without echo' do
     with_api(Echo) do
       get_request({}, err) do |c|
-        b = Yajl::Parser.parse(c.response)
+        b = MultiJson.load(c.response)
         b['error'].should_not be_nil
-        b['error'].should == 'Echo identifier missing'
+        b['error'].should == 'echo identifier missing'
       end
     end
   end
@@ -28,7 +28,7 @@ describe Echo do
   it 'echos POST data' do
     with_api(Echo) do
       post_request({:body => {'echo' => 'test'}}, err) do |c|
-        b = Yajl::Parser.parse(c.response)
+        b = MultiJson.load(c.response)
         b['response'].should == 'test'
       end
     end
@@ -41,7 +41,7 @@ describe Echo do
 
       post_request({:body => body.to_s,
                     :head => head}, err) do |c|
-        b = Yajl::Parser.parse(c.response)
+        b = MultiJson.load(c.response)
         b['response'].should == 'test'
       end
     end
@@ -49,12 +49,12 @@ describe Echo do
 
   it 'echos application/json POST body data' do
     with_api(Echo) do
-      body = Yajl::Encoder.encode({'echo' => 'My Echo'})
+      body = MultiJson.dump({'echo' => 'My Echo'})
       head = {'content-type' => 'application/json'}
 
       post_request({:body => body.to_s,
                     :head => head}, err) do |c|
-        b = Yajl::Parser.parse(c.response)
+        b = MultiJson.load(c.response)
         b['response'].should == 'My Echo'
       end
     end

data/spec/integration/jsonp_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+class JSON_API < Goliath::API
+  use Goliath::Rack::Params
+  use Goliath::Rack::JSONP
+  use Goliath::Rack::Render, 'json'
+
+  def response(env)
+    [200, {'CONTENT_TYPE' => 'application/json'}, "OK"]
+  end
+end
+
+describe 'JSONP' do
+  let(:err) { Proc.new { fail "API request failed" } }
+
+  it 'sets the content type' do
+    with_api(JSON_API) do
+      get_request({:query => {:callback => 'test'}}, err) do |c|
+        c.response_header['CONTENT_TYPE'].should =~ %r{^application/javascript}
+      end
+    end
+  end
+
+  it 'wraps response with callback' do
+    with_api(JSON_API) do
+      get_request({:query => {:callback => 'test'}}, err) do |c|
+        c.response.should =~ /^test\(.*\)$/
+      end
+    end
+  end
+end