sanford 0.14.0 → 0.15.0

data/lib/sanford/connection_handler.rb

@@ -7,10 +7,6 @@ module Sanford
 
   class ConnectionHandler
 
-    ProcessedService = Struct.new(
-      :request, :handler_class, :response, :exception, :time_taken
-    )
-
     attr_reader :server_data, :connection
     attr_reader :logger
 
@@ -38,47 +34,52 @@ module Sanford
     protected
 
     def run!
-      service = ProcessedService.new
+      processed_service = ProcessedService.new
       begin
         request = Sanford::Protocol::Request.parse(@connection.read_data)
         self.log_request(request)
-        service.request = request
+        processed_service.request = request
 
         route = @server_data.route_for(request.name)
         self.log_handler_class(route.handler_class)
-        service.handler_class = route.handler_class
+        processed_service.handler_class = route.handler_class
 
         response = route.run(request, @server_data)
-        service.response = response
+        processed_service.response = response
       rescue StandardError => exception
-        self.handle_exception(service, exception, @server_data)
+        self.handle_exception(exception, @server_data, processed_service)
       ensure
-        self.write_response(service)
+        self.write_response(processed_service)
       end
-      service
+      processed_service
     end
 
-    def write_response(service)
+    def write_response(processed_service)
       begin
-        @connection.write_data service.response.to_hash
+        @connection.write_data processed_service.response.to_hash
       rescue StandardError => exception
-        service = self.handle_exception(service, exception)
-        @connection.write_data service.response.to_hash
+        processed_service = self.handle_exception(
+          exception,
+          @server_data,
+          processed_service
+        )
+        @connection.write_data processed_service.response.to_hash
       end
       @connection.close_write
-      service
+      processed_service
     end
 
-    def handle_exception(service, exception, server_data = nil)
-      error_handler = Sanford::ErrorHandler.new(
-        exception,
-        server_data,
-        service.request
-      )
-      service.response  = error_handler.run
-      service.exception = error_handler.exception
-      self.log_exception(service.exception)
-      service
+    def handle_exception(exception, server_data, processed_service)
+      error_handler = Sanford::ErrorHandler.new(exception, {
+        :server_data   => server_data,
+        :request       => processed_service.request,
+        :handler_class => processed_service.handler_class,
+        :response      => processed_service.response
+      })
+      processed_service.response  = error_handler.run
+      processed_service.exception = error_handler.exception
+      self.log_exception(processed_service.exception)
+      processed_service
     end
 
     def raise_if_debugging!(exception)
@@ -101,18 +102,7 @@ module Sanford
     def log_complete(processed_service)
       log_verbose "===== Completed in #{processed_service.time_taken}ms " \
                   "#{processed_service.response.status} ====="
-      summary_line_args = {
-        'time'    => processed_service.time_taken,
-        'handler' => processed_service.handler_class
-      }
-      if processed_service.response
-        summary_line_args['status'] = processed_service.response.code
-      end
-      if (request = processed_service.request)
-        summary_line_args['service'] = request.name
-        summary_line_args['params']  = request.params
-      end
-      log_summary SummaryLine.new(summary_line_args)
+      log_summary build_summary_line(processed_service)
     end
 
     def log_exception(exception)
@@ -129,6 +119,32 @@ module Sanford
       self.logger.summary.send(level, "[Sanford] #{message}")
     end
 
+    def build_summary_line(processed_service)
+      summary_line_args = {
+        'time'    => processed_service.time_taken,
+        'handler' => processed_service.handler_class
+      }
+      if (request = processed_service.request)
+        summary_line_args['service'] = request.name
+        summary_line_args['params']  = request.params.to_hash
+      end
+      if (response = processed_service.response)
+        summary_line_args['status'] = response.code
+      end
+      if (exception = processed_service.exception)
+        summary_line_args['error'] = "#{exception.class}: #{exception.message}"
+      end
+      SummaryLine.new(summary_line_args)
+    end
+
+    module SummaryLine
+      KEYS = %w{time status handler service params error}.freeze
+
+      def self.new(line_attrs)
+        KEYS.map{ |k| "#{k}=#{line_attrs[k].inspect}" }.join(' ')
+      end
+    end
+
     module RoundedTime
       ROUND_PRECISION = 2
       ROUND_MODIFIER = 10 ** ROUND_PRECISION
@@ -137,12 +153,9 @@ module Sanford
       end
     end
 
-    module SummaryLine
-      def self.new(line_attrs)
-        attr_keys = %w{time status handler service params}
-        attr_keys.map{ |k| "#{k}=#{line_attrs[k].inspect}" }.join(' ')
-      end
-    end
+    ProcessedService = Struct.new(
+      :request, :handler_class, :response, :exception, :time_taken
+    )
 
   end
 

data/lib/sanford/error_handler.rb

@@ -1,16 +1,15 @@
-require 'ostruct'
 require 'sanford-protocol'
 
 module Sanford
 
   class ErrorHandler
 
-    attr_reader :exception, :server_data, :request
-    attr_reader :error_procs
+    attr_reader :exception, :context, :error_procs
 
-    def initialize(exception, server_data = nil, request = nil)
-      @exception, @server_data, @request = exception, server_data, request
-      @error_procs = @server_data ? @server_data.error_procs.reverse : []
+    def initialize(exception, context_hash)
+      @exception   = exception
+      @context     = ErrorContext.new(context_hash)
+      @error_procs = context_hash[:server_data].error_procs.reverse
     end
 
     # The exception that we are generating a response for can change in the case
@@ -24,44 +23,69 @@ module Sanford
       @error_procs.each do |error_proc|
         result = nil
         begin
-          result = error_proc.call(@exception, @server_data, @request)
+          result = error_proc.call(@exception, @context)
         rescue StandardError => proc_exception
           @exception = proc_exception
         end
-        response ||= self.response_from_proc(result)
+        response ||= response_from_proc(result)
       end
-      response || self.response_from_exception(@exception)
+      response || response_from_exception(@exception)
     end
 
-    protected
+    private
 
     def response_from_proc(result)
-      case result
-      when Sanford::Protocol::Response
+      if result.kind_of?(Sanford::Protocol::Response)
         result
-      when Integer, Symbol
+      elsif result.kind_of?(Integer) || result.kind_of?(Symbol)
         build_response result
       end
     end
 
     def response_from_exception(exception)
-      case(exception)
-      when Sanford::Protocol::BadMessageError, Sanford::Protocol::Request::InvalidError
+      if exception.kind_of?(Sanford::Protocol::BadMessageError) ||
+         exception.kind_of?(Sanford::Protocol::Request::InvalidError)
         build_response :bad_request, :message => exception.message
-      when Sanford::NotFoundError
+      elsif exception.kind_of?(Sanford::NotFoundError)
         build_response :not_found
-      when Sanford::Protocol::TimeoutError
+      elsif exception.kind_of?(Sanford::Protocol::TimeoutError)
         build_response :timeout
-      when Exception
+      else
         build_response :error, :message => "An unexpected error occurred."
       end
     end
 
     def build_response(status, options = nil)
-      options = OpenStruct.new(options || {})
-      Sanford::Protocol::Response.new([ status, options.message ], options.data)
+      options ||= {}
+      Sanford::Protocol::Response.new(
+        [status, options[:message]],
+        options[:data]
+      )
     end
 
   end
 
+  class ErrorContext
+    attr_reader :server_data
+    attr_reader :request, :handler_class, :response
+
+    def initialize(args)
+      @server_data   = args[:server_data]
+      @request       = args[:request]
+      @handler_class = args[:handler_class]
+      @response      = args[:response]
+    end
+
+    def ==(other)
+      if other.kind_of?(self.class)
+        self.server_data   == other.server_data &&
+        self.request       == other.request &&
+        self.handler_class == other.handler_class &&
+        self.response      == other.response
+      else
+        super
+      end
+    end
+  end
+
 end

data/lib/sanford/process.rb

@@ -14,20 +14,19 @@ module Sanford
       @pid_file = PIDFile.new(@server.pid_file)
       @restart_cmd = RestartCmd.new
 
-      @server_ip = default_if_blank(ENV['SANFORD_IP'], @server.configured_ip)
-      @server_port = default_if_blank(
-        ENV['SANFORD_PORT'],
-        @server.configured_port
-      ){ |v| v.to_i }
-      @server_fd = ignore_if_blank(ENV['SANFORD_SERVER_FD']){ |v| v.to_i }
-      @listen_args = @server_fd ? [ @server_fd ] : [ @server_ip, @server_port ]
+      @server_ip   = @server.configured_ip
+      @server_port = @server.configured_port
+      @server_fd   = if !ENV['SANFORD_SERVER_FD'].to_s.empty?
+        ENV['SANFORD_SERVER_FD'].to_i
+      end
+      @listen_args = @server_fd ? [@server_fd] : [@server_ip, @server_port]
 
       @name = "sanford-#{@server.name}-#{@server_ip}-#{@server_port}"
 
-      @client_fds = (ENV['SANFORD_CLIENT_FDS'] || "").split(',').map(&:to_i)
+      @client_fds = ENV['SANFORD_CLIENT_FDS'].to_s.split(',').map(&:to_i)
 
-      @daemonize = !!options[:daemonize]
-      @skip_daemonize = !!ignore_if_blank(ENV['SANFORD_SKIP_DAEMONIZE'])
+      @daemonize      = !!options[:daemonize]
+      @skip_daemonize = !ENV['SANFORD_SKIP_DAEMONIZE'].to_s.empty?
     end
 
     def run
@@ -74,15 +73,6 @@ module Sanford
       @restart_cmd.run
     end
 
-    def default_if_blank(value, default, &block)
-      ignore_if_blank(value, &block) || default
-    end
-
-    def ignore_if_blank(value, &block)
-      block ||= proc{ |v| v }
-      block.call(value) if value && !value.empty?
-    end
-
   end
 
   class RestartCmd

data/lib/sanford/server.rb

@@ -28,7 +28,7 @@ module Sanford
       def initialize
         self.class.configuration.validate!
         @server_data = ServerData.new(self.class.configuration.to_hash)
-        @dat_tcp_server = DatTCP::Server.new{ |socket| serve(socket) }
+        @dat_tcp_server = build_dat_tcp_server
       rescue InvalidError => exception
         exception.set_backtrace(caller)
         raise exception
@@ -83,6 +83,8 @@ module Sanford
         @dat_tcp_server.listen(*args) do |server_socket|
           configure_tcp_server(server_socket)
         end
+        @server_data.ip   = self.ip
+        @server_data.port = self.port
       end
 
       def start(*args)
@@ -107,6 +109,18 @@ module Sanford
 
       private
 
+      def build_dat_tcp_server
+        s = DatTCP::Server.new{ |socket| serve(socket) }
+
+        # add any configured callbacks
+        self.server_data.worker_start_procs.each{ |p| s.on_worker_start(&p) }
+        self.server_data.worker_shutdown_procs.each{ |p|  s.on_worker_shutdown(&p) }
+        self.server_data.worker_sleep_procs.each{ |p| s.on_worker_sleep(&p) }
+        self.server_data.worker_wakeup_procs.each{ |p| s.on_worker_wakeup(&p) }
+
+        s
+      end
+
       def serve(socket)
         connection = Connection.new(socket)
         if !keep_alive_connection?(connection)
@@ -171,6 +185,22 @@ module Sanford
         self.configuration.error_procs << block
       end
 
+      def on_worker_start(&block)
+        self.configuration.worker_start_procs << block
+      end
+
+      def on_worker_shutdown(&block)
+        self.configuration.worker_shutdown_procs << block
+      end
+
+      def on_worker_sleep(&block)
+        self.configuration.worker_sleep_procs << block
+      end
+
+      def on_worker_wakeup(&block)
+        self.configuration.worker_wakeup_procs << block
+      end
+
       def router(value = nil, &block)
         self.configuration.router = value if !value.nil?
         self.configuration.router.instance_eval(&block) if block
@@ -244,7 +274,7 @@ module Sanford
       include NsOptions::Proxy
 
       option :name,     String,  :required => true
-      option :ip,       String,  :required => true, :default => '0.0.0.0'
+      option :ip,       String,  :required => true
       option :port,     Integer, :required => true
       option :pid_file, Pathname
 
@@ -256,12 +286,18 @@ module Sanford
 
       attr_accessor :init_procs, :error_procs
       attr_accessor :router
+      attr_reader :worker_start_procs, :worker_shutdown_procs
+      attr_reader :worker_sleep_procs, :worker_wakeup_procs
 
       def initialize(values = nil)
         super(values)
+        self.ip   = !(v = ENV['SANFORD_IP'].to_s).empty?   ? v : '0.0.0.0'
+        self.port = !(v = ENV['SANFORD_PORT'].to_s).empty? ? v : nil
         @init_procs, @error_procs = [], []
+        @worker_start_procs, @worker_shutdown_procs = [], []
+        @worker_sleep_procs, @worker_wakeup_procs   = [], []
         @router = Sanford::Router.new
-        @valid = nil
+        @valid  = nil
       end
 
       def routes
@@ -270,10 +306,14 @@ module Sanford
 
       def to_hash
         super.merge({
-          :init_procs  => self.init_procs,
-          :error_procs => self.error_procs,
-          :router => self.router,
-          :routes => self.routes
+          :init_procs            => self.init_procs,
+          :error_procs           => self.error_procs,
+          :worker_start_procs    => self.worker_start_procs,
+          :worker_shutdown_procs => self.worker_shutdown_procs,
+          :worker_sleep_procs    => self.worker_sleep_procs,
+          :worker_wakeup_procs   => self.worker_wakeup_procs,
+          :router                => self.router,
+          :routes                => self.routes
         })
       end
 

data/lib/sanford/server_data.rb

@@ -8,12 +8,14 @@ module Sanford
     # NsOptions overhead when reading them while handling a request.
 
     attr_reader :name
-    attr_reader :ip, :port
     attr_reader :pid_file
     attr_reader :receives_keep_alive
     attr_reader :verbose_logging, :logger, :template_source
     attr_reader :init_procs, :error_procs
+    attr_reader :worker_start_procs, :worker_shutdown_procs
+    attr_reader :worker_sleep_procs, :worker_wakeup_procs
     attr_reader :router, :routes
+    attr_accessor :ip, :port
 
     def initialize(args = nil)
       args ||= {}
@@ -31,6 +33,11 @@ module Sanford
       @init_procs  = args[:init_procs]  || []
       @error_procs = args[:error_procs] || []
 
+      @worker_start_procs    = args[:worker_start_procs]
+      @worker_shutdown_procs = args[:worker_shutdown_procs]
+      @worker_sleep_procs    = args[:worker_sleep_procs]
+      @worker_wakeup_procs   = args[:worker_wakeup_procs]
+
       @router = args[:router]
       @routes = build_routes(args[:routes] || [])
     end

data/lib/sanford/version.rb

@@ -1,3 +1,3 @@
 module Sanford
-  VERSION = "0.14.0"
+  VERSION = "0.15.0"
 end

data/sanford.gemspec

@@ -18,9 +18,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency("dat-tcp",          ["~> 0.6"])
+  gem.add_dependency("dat-tcp",          ["~> 0.7"])
   gem.add_dependency("ns-options",       ["~> 1.1"])
   gem.add_dependency("sanford-protocol", ["~> 0.11"])
 
-  gem.add_development_dependency("assert", ["~> 2.14"])
+  gem.add_development_dependency("assert", ["~> 2.15"])
 end

data/test/support/app_server.rb

@@ -21,7 +21,7 @@ class AppServer
   include Sanford::Server
 
   name 'app'
-  ip   'localhost'
+  ip   '127.0.0.1'
   port 12000
 
   receives_keep_alive true
@@ -45,9 +45,10 @@ class AppServer
     template_source s
   end
 
-  error do |exception, server_data, request|
-    if request && request.name == 'custom_error'
-      data = "The server on #{server_data.ip}:#{server_data.port} " \
+  error do |exception, context|
+    if context.request && context.request.name == 'custom_error'
+      data = "The server on " \
+             "#{context.server_data.ip}:#{context.server_data.port} " \
              "threw a #{exception.class}."
       Sanford::Protocol::Response.new(200, data)
     end

data/test/support/factory.rb

@@ -3,4 +3,12 @@ require 'assert/factory'
 module Factory
   extend Assert::Factory
 
+  def self.exception(klass = nil, message = nil)
+    klass ||= StandardError
+    message ||= Factory.text
+    exception = nil
+    begin; raise(klass, message); rescue StandardError => exception; end
+    exception
+  end
+
 end

data/test/unit/connection_handler_tests.rb

@@ -89,12 +89,11 @@ class Sanford::ConnectionHandler
     setup do
       Assert.stub(@route, :run){ raise @exception }
 
-      error_handler = Sanford::ErrorHandler.new(
-        @exception,
-        @server_data,
-        @request
-      )
-      @expected_response = error_handler.run
+      error_handler = Sanford::ErrorHandler.new(@exception, {
+        :server_data => @server_data,
+        :request     => @request
+      })
+      @expected_response  = error_handler.run
       @expected_exception = error_handler.exception
 
       @processed_service = @connection_handler.run
@@ -117,16 +116,13 @@ class Sanford::ConnectionHandler
   class RunWithExceptionWhileWritingTests < InitTests
     desc "and run with an exception thrown while writing the response"
     setup do
-      Assert.stub(@route, :run){ @response }
-
       @connection.raise_on_write = true
 
-      error_handler = Sanford::ErrorHandler.new(
-        @connection.write_exception,
-        @server_data,
-        @request
-      )
-      @expected_response = error_handler.run
+      error_handler = Sanford::ErrorHandler.new(@connection.write_exception, {
+        :server_data => @server_data,
+        :request     => @request
+      })
+      @expected_response  = error_handler.run
       @expected_exception = error_handler.exception
 
       @processed_service = @connection_handler.run
@@ -217,12 +213,14 @@ class Sanford::ConnectionHandler
     should "have logged the service" do
       time_taken = @processed_service.time_taken
       status = @processed_service.response.status.to_i
+      exception_msg = "#{@exception.class}: #{@exception.message}"
       expected = "[Sanford] " \
                  "time=#{time_taken} " \
                  "status=#{status} " \
                  "handler=#{@route.handler_class} " \
                  "service=#{@request.name.inspect} " \
-                 "params=#{@request.params.inspect}"
+                 "params=#{@request.params.inspect} " \
+                 "error=#{exception_msg.inspect}"
       assert_equal expected, subject.info_logged.join
     end