sanford 0.17.0 → 0.18.0

data/lib/sanford/server_data.rb

@@ -2,20 +2,17 @@ module Sanford
 
   class ServerData
 
-    # The server uses this to "compile" its configuration for speed. NsOptions
-    # is relatively slow everytime an option is read. To avoid this, we read the
-    # options one time here and memoize their values. This way, we don't pay the
-    # NsOptions overhead when reading them while handling a request.
-
-    attr_reader :name
-    attr_reader :pid_file
-    attr_reader :receives_keep_alive
-    attr_reader :worker_class, :worker_params, :num_workers
-    attr_reader :debug, :logger, :dtcp_logger, :verbose_logging
-    attr_reader :template_source, :shutdown_timeout
-    attr_reader :init_procs, :error_procs
-    attr_reader :router, :routes
+    # The server uses this to "compile" the common configuration data used
+    # by the server instances, error handlers and routes. The goal here is
+    # to provide these with a simplified interface with the minimal data needed
+    # and to decouple the configuration from each thing that needs its data.
+
     attr_accessor :ip, :port
+    attr_reader :name, :pid_file, :shutdown_timeout
+    attr_reader :worker_class, :worker_params, :num_workers
+    attr_reader :error_procs, :template_source, :logger, :router
+    attr_reader :receives_keep_alive, :verbose_logging
+    attr_reader :debug, :dtcp_logger, :routes, :process_label
 
     def initialize(args = nil)
       args ||= {}
@@ -24,26 +21,28 @@ module Sanford
       @port     = !(v = ENV['SANFORD_PORT'].to_s).empty? ? v.to_i : args[:port]
       @pid_file = args[:pid_file]
 
-      @receives_keep_alive = !!args[:receives_keep_alive]
-
-      @worker_class  = args[:worker_class]
-      @worker_params = args[:worker_params] || {}
-      @num_workers   = args[:num_workers]
-
-      @debug           = !ENV['SANFORD_DEBUG'].to_s.empty?
-      @logger          = args[:logger]
-      @dtcp_logger     = @logger if @debug
-      @verbose_logging = !!args[:verbose_logging]
+      @shutdown_timeout = args[:shutdown_timeout]
 
+      @worker_class    = args[:worker_class]
+      @worker_params   = args[:worker_params] || {}
+      @num_workers     = args[:num_workers]
+      @error_procs     = args[:error_procs] || []
       @template_source = args[:template_source]
+      @logger          = args[:logger]
+      @router          = args[:router]
 
-      @shutdown_timeout = args[:shutdown_timeout]
+      @receives_keep_alive = !!args[:receives_keep_alive]
+      @verbose_logging     = !!args[:verbose_logging]
 
-      @init_procs  = args[:init_procs]  || []
-      @error_procs = args[:error_procs] || []
+      @debug       = !ENV['SANFORD_DEBUG'].to_s.empty?
+      @dtcp_logger = @logger if @debug
+      @routes      = build_routes(args[:routes] || [])
 
-      @router = args[:router]
-      @routes = build_routes(args[:routes] || [])
+      @process_label = if (label = ENV['SANFORD_PROCESS_LABEL'].to_s).empty?
+        "#{@name}-#{@ip}-#{@port}"
+      else
+        label
+      end
     end
 
     def route_for(name)

data/lib/sanford/template_source.rb

@@ -69,8 +69,8 @@ module Sanford
 
   class NullTemplateSource < TemplateSource
 
-    def initialize
-      super('')
+    def initialize(root = nil)
+      super(root || '')
     end
 
   end

data/lib/sanford/version.rb

@@ -1,3 +1,3 @@
 module Sanford
-  VERSION = "0.17.0"
+  VERSION = "0.18.0"
 end

data/sanford.gemspec

@@ -18,10 +18,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert", ["~> 2.15.0"])
+  gem.add_development_dependency("assert", ["~> 2.16.1"])
 
-  gem.add_dependency("dat-tcp",          ["~> 0.8.0"])
-  gem.add_dependency("much-plugin",      ["~> 0.1.0"])
-  gem.add_dependency("ns-options",       ["~> 1.1.6"])
-  gem.add_dependency("sanford-protocol", ["~> 0.11.0"])
+  gem.add_dependency("dat-tcp",          ["~> 0.8.1"])
+  gem.add_dependency("much-plugin",      ["~> 0.2.0"])
+  gem.add_dependency("sanford-protocol", ["~> 0.12.0"])
 end

data/test/helper.rb

@@ -12,3 +12,14 @@ require 'pathname'
 ROOT_PATH = Pathname.new(File.expand_path('../..', __FILE__))
 
 require 'test/support/factory'
+
+JOIN_SECONDS = 0.1
+
+# 1.8.7 backfills
+
+# Array#sample
+if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
+  class Array
+    alias_method :sample, :choice
+  end
+end

data/test/support/app_server.rb

@@ -10,13 +10,16 @@ LOGGER = Logger.new(ROOT_PATH.join('log/app_server.log').to_s)
 LOGGER.datetime_format = "" # turn off the datetime in the logs
 
 class AppERBEngine < Sanford::TemplateEngine
-  RenderScope = Struct.new(:view)
+  RenderScope = Class.new(Struct.new(:view)) do
+    def get_binding; binding; end
+  end
 
   def render(path, service_handler, locals)
     require 'erb'
     full_path = ROOT_PATH.join("test/support/#{path}.erb")
-    binding = RenderScope.new(service_handler).send(:binding)
-    ERB.new(File.read(full_path)).result(binding)
+
+    b = RenderScope.new(service_handler).get_binding
+    ERB.new(File.read(full_path)).result(b)
   end
 end
 

data/test/support/factory.rb

@@ -12,4 +12,11 @@ module Factory
     exception
   end
 
+  def self.protocol_response
+    Sanford::Protocol::Response.new(
+      [Factory.integer(999), Factory.text],
+      { Factory.string => Factory.string }
+    )
+  end
+
 end

data/test/system/server_tests.rb

@@ -308,9 +308,9 @@ module Sanford::Server
     should "return a response generated by the error handler" do
       assert_equal 200, subject.code
       assert_nil subject.status.message
-      expected = "The server on #{AppServer.ip}:#{AppServer.port} " \
-                 "threw a StandardError."
-      assert_equal expected, subject.data
+      exp = "The server on #{AppServer.ip}:#{AppServer.port} " \
+            "threw a StandardError."
+      assert_equal exp, subject.data
     end
 
   end
@@ -346,6 +346,24 @@ module Sanford::Server
 
   end
 
+  class WithEnvProcessLabelTests < SystemTests
+    desc "with a process label env var"
+    setup do
+      ENV['SANFORD_PROCESS_LABEL'] = Factory.string
+
+      @server = AppServer.new
+    end
+    teardown do
+      ENV.delete('SANFORD_PROCESS_LABEL')
+    end
+    subject{ @server }
+
+    should "set the daemons process label to the env var" do
+      assert_equal ENV['SANFORD_PROCESS_LABEL'], subject.process_label
+    end
+
+  end
+
   class TestClient
     attr_accessor :delay, :bytes
 

data/test/system/service_handler_tests.rb

@@ -62,8 +62,8 @@ module Sanford::ServiceHandler
     setup do
       @params = { 'message' => Factory.text }
       @runner = test_runner(AppHandlers::Template, {
-        :params => @params,
-        :template_source => AppServer.configuration.template_source
+        :params          => @params,
+        :template_source => AppServer.config.template_source
       })
       @handler = @runner.handler
     end
@@ -78,8 +78,8 @@ module Sanford::ServiceHandler
     should "return a 200 response and render the template when run" do
       response = @runner.run
       assert_equal 200, response.code
-      expected = "ERB Template Message: #{@params['message']}\n"
-      assert_equal expected, response.data
+      exp = "ERB Template Message: #{@params['message']}\n"
+      assert_equal exp, response.data
     end
 
   end

data/test/unit/cli_tests.rb

@@ -129,8 +129,8 @@ class Sanford::CLI
     end
 
     should "output the error with the help" do
-      expected = "#{@command.inspect} is not a valid command"
-      assert_includes expected, @kernel_spy.output
+      exp = "#{@command.inspect} is not a valid command"
+      assert_includes exp, @kernel_spy.output
       assert_includes "Usage: sanford", @kernel_spy.output
     end
 

data/test/unit/connection_handler_tests.rb

@@ -84,59 +84,99 @@ class Sanford::ConnectionHandler
 
   end
 
-  class RunWithExceptionTests < InitTests
-    desc "and run with a route that throws an exception"
+  class RunWithExceptionSetupTests < InitTests
     setup do
-      Assert.stub(@route, :run){ raise @exception }
+      @route_exception = Factory.exception
+      Assert.stub(@route, :run){ raise @route_exception }
+      Assert.stub(Sanford::ErrorHandler, :new) do |*args|
+        @error_handler_spy = ErrorHandlerSpy.new(*args)
+      end
+    end
 
-      error_handler = Sanford::ErrorHandler.new(@exception, {
-        :server_data => @server_data,
-        :request     => @request
-      })
-      @expected_response  = error_handler.run
-      @expected_exception = error_handler.exception
+  end
 
+  class RunWithExceptionTests < RunWithExceptionSetupTests
+    desc "and run with an exception"
+    setup do
       @processed_service = @connection_handler.run
     end
-    subject{ @processed_service }
 
-    should "return a processed service with an exception" do
-      assert_instance_of ProcessedService, subject
-      assert_equal @expected_response,  subject.response
-      assert_equal @expected_exception, subject.exception
+    should "run an error handler" do
+      assert_equal @route_exception, @error_handler_spy.passed_exception
+      exp = {
+        :server_data   => @server_data,
+        :request       => @processed_service.request,
+        :handler_class => @processed_service.handler_class,
+        :response      => nil
+      }
+      assert_equal exp, @error_handler_spy.context_hash
+      assert_true @error_handler_spy.run_called
     end
 
-    should "have written the error response to the connection" do
-      assert_equal @expected_response, @connection.response
+    should "store the error handler response and exception on the processed service" do
+      assert_equal @error_handler_spy.response,  @processed_service.response
+      assert_equal @error_handler_spy.exception, @processed_service.exception
+    end
+
+    should "write the error response to the connection" do
+      assert_equal @error_handler_spy.response, @connection.response
       assert_true @connection.write_closed
     end
 
   end
 
-  class RunWithExceptionWhileWritingTests < InitTests
+  class RunWithShutdownErrorTests < RunWithExceptionSetupTests
+    desc "and run with a dat worker pool shutdown error"
+    setup do
+      @shutdown_error = DatWorkerPool::ShutdownError.new(Factory.text)
+      Assert.stub(@route, :run){ raise @shutdown_error }
+    end
+
+    should "run an error handler" do
+      assert_raises{ @connection_handler.run }
+
+      passed_exception = @error_handler_spy.passed_exception
+      assert_instance_of Sanford::ShutdownError, passed_exception
+      assert_equal @shutdown_error.message, passed_exception.message
+      assert_equal @shutdown_error.backtrace, passed_exception.backtrace
+      assert_true @error_handler_spy.run_called
+    end
+
+    should "raise the shutdown error" do
+      assert_raises(@shutdown_error.class){ @connection_handler.run }
+    end
+
+  end
+
+  class RunWithExceptionWhileWritingTests < RunWithExceptionSetupTests
     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 => @server_data,
-        :request     => @request
-      })
-      @expected_response  = error_handler.run
-      @expected_exception = error_handler.exception
-
       @processed_service = @connection_handler.run
     end
     subject{ @processed_service }
 
-    should "return a processed service with an exception" do
-      assert_instance_of ProcessedService, subject
-      assert_equal @expected_response,  subject.response
-      assert_equal @expected_exception, subject.exception
+    should "run an error handler" do
+      assert_equal @connection.write_exception, @error_handler_spy.passed_exception
+      exp = {
+        :server_data   => @server_data,
+        :request       => @processed_service.request,
+        :handler_class => @processed_service.handler_class,
+        :response      => @response
+      }
+      assert_equal exp, @error_handler_spy.context_hash
+      assert_true @error_handler_spy.run_called
+    end
+
+    should "store the error handler response and exception on the processed service" do
+      assert_equal @error_handler_spy.response,  @processed_service.response
+      assert_equal @error_handler_spy.exception, @processed_service.exception
     end
 
-    should "have written the error response to the connection" do
-      assert_equal @expected_response, @connection.response
+    should "write the error response to the connection" do
+      assert_equal @error_handler_spy.response, @connection.response
       assert_true @connection.write_closed
     end
 
@@ -161,19 +201,21 @@ class Sanford::ConnectionHandler
     should "have logged the service" do
       time_taken = @processed_service.time_taken
       status = @processed_service.response.status.to_s
-      expected = "[Sanford] ===== Received request =====" \
-                 "[Sanford]   Service: #{@request.name.inspect}" \
-                 "[Sanford]   Params:  #{@request.params.inspect}" \
-                 "[Sanford]   Handler: #{@route.handler_class}" \
-                 "[Sanford] ===== Completed in #{time_taken}ms #{status} ====="
-      assert_equal expected, subject.info_logged.join
+      exp = "[Sanford] ===== Received request =====" \
+            "[Sanford]   Service: #{@request.name.inspect}" \
+            "[Sanford]   Params:  #{@request.params.inspect}" \
+            "[Sanford]   Handler: #{@route.handler_class}" \
+            "[Sanford] ===== Completed in #{time_taken}ms #{status} ====="
+      assert_equal exp, subject.info_logged.join
     end
 
     should "log an exception when one is thrown" do
       err = @processed_service.exception
-      backtrace = err.backtrace.join("\n")
-      expected = "[Sanford] #{err.class}: #{err.message}\n#{backtrace}"
-      assert_equal expected, subject.error_logged.join
+      exp = "[Sanford] #{err.class}: #{err.message}"
+      assert_equal exp, subject.error_logged.first
+      err.backtrace.each do |l|
+        assert_includes "[Sanford] #{l}", subject.error_logged
+      end
     end
 
   end
@@ -198,14 +240,14 @@ class Sanford::ConnectionHandler
       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} " \
-                 "error=#{exception_msg.inspect}"
-      assert_equal expected, subject.info_logged.join
+      exp = "[Sanford] " \
+            "time=#{time_taken} " \
+            "status=#{status} " \
+            "handler=#{@route.handler_class} " \
+            "service=#{@request.name.inspect} " \
+            "params=#{@request.params.inspect} " \
+            "error=#{exception_msg.inspect}"
+      assert_equal exp, subject.info_logged.join
     end
 
     should "not have logged the exception" do
@@ -216,6 +258,24 @@ class Sanford::ConnectionHandler
 
   TestHandler = Class.new
 
+  class ErrorHandlerSpy
+    attr_reader :passed_exception, :context_hash, :exception, :response
+    attr_reader :run_called
+
+    def initialize(exception, context_hash)
+      @passed_exception = exception
+      @context_hash     = context_hash
+      @exception        = Factory.exception
+      @response         = Factory.protocol_response
+      @run_called       = false
+    end
+
+    def run
+      @run_called = true
+      @response
+    end
+  end
+
   class SpyLogger
     attr_reader :info_logged, :error_logged
 

data/test/unit/error_handler_tests.rb

@@ -100,7 +100,7 @@ class Sanford::ErrorHandler
     subject{ @response }
 
     should "return a bad request response" do
-      exp = Sanford::Protocol::Response.new([:bad_request, @exception.message])
+      exp = Sanford::Protocol::Response.new([400, @exception.message])
       assert_equal exp, subject
     end
 
@@ -117,7 +117,7 @@ class Sanford::ErrorHandler
     subject{ @response }
 
     should "return a bad request response" do
-      exp = Sanford::Protocol::Response.new([:bad_request, @exception.message])
+      exp = Sanford::Protocol::Response.new([400, @exception.message])
       assert_equal exp, subject
     end
 
@@ -134,7 +134,7 @@ class Sanford::ErrorHandler
     subject{ @response }
 
     should "return a not found response" do
-      exp = Sanford::Protocol::Response.new(:not_found)
+      exp = Sanford::Protocol::Response.new(404)
       assert_equal exp, subject
     end
 
@@ -151,7 +151,7 @@ class Sanford::ErrorHandler
     subject{ @response }
 
     should "return a timeout response" do
-      exp = Sanford::Protocol::Response.new(:timeout)
+      exp = Sanford::Protocol::Response.new(408)
       assert_equal exp, subject
     end
 
@@ -168,7 +168,7 @@ class Sanford::ErrorHandler
     subject{ @response }
 
     should "return an error response" do
-      exp = Sanford::Protocol::Response.new([:error, "An unexpected error occurred."])
+      exp = Sanford::Protocol::Response.new([500, "An unexpected error occurred."])
       assert_equal exp, subject
     end
 
@@ -198,7 +198,7 @@ class Sanford::ErrorHandler
     end
 
     should "return an error response" do
-      exp = Sanford::Protocol::Response.new([:error, "An unexpected error occurred."])
+      exp = Sanford::Protocol::Response.new([500, "An unexpected error occurred."])
       assert_equal exp, @response
     end
 
@@ -208,7 +208,7 @@ class Sanford::ErrorHandler
     desc "with a protocol response returned from an error proc"
     setup do
       @proc_response = Sanford::Protocol::Response.new(Factory.integer)
-      @error_proc_spies.choice.response = @proc_response
+      @error_proc_spies.sample.response = @proc_response
 
       @response = @handler.run
     end
@@ -224,7 +224,7 @@ class Sanford::ErrorHandler
     desc "with a response code returned from an error proc"
     setup do
       @response_code = Factory.integer
-      @error_proc_spies.choice.response = @response_code
+      @error_proc_spies.sample.response = @response_code
 
       @response = @handler.run
     end
@@ -240,15 +240,15 @@ class Sanford::ErrorHandler
   class RunWithSymbolFromErrorProcTests < RunSetupTests
     desc "with a response symbol returned from an error proc"
     setup do
-      @response_symbol = [:not_found, :bad_request, :error].choice
-      @error_proc_spies.choice.response = @response_symbol
+      @response_code = [400, 404, 500].sample
+      @error_proc_spies.sample.response = @response_code
 
       @response = @handler.run
     end
     subject{ @response }
 
     should "use the response symbol to build a response and return it" do
-      exp = Sanford::Protocol::Response.new(@response_symbol)
+      exp = Sanford::Protocol::Response.new(@response_code)
       assert_equal exp, subject
     end