sanford 0.1.0 → 0.2.0

data/lib/sanford/runner.rb

@@ -0,0 +1,50 @@
+require 'ostruct'
+require 'sanford-protocol'
+
+require 'sanford/logger'
+
+module Sanford
+
+  class Runner
+
+    ResponseArgs = Struct.new(:status, :data)
+
+    attr_reader :handler_class, :request, :logger
+
+    def initialize(handler_class, request, logger = nil)
+      @handler_class, @request = handler_class, request
+      @logger = logger || Sanford::NullLogger.new
+      @handler = @handler_class.new(self)
+    end
+
+    def run
+      response_args = catch_halt do
+        @handler.init
+        @handler.run
+      end
+      Sanford::Protocol::Response.new(response_args.status, response_args.data)
+    end
+
+    module HaltMethods
+
+      # It's best to keep what `halt` and `catch_halt` return in the same format.
+      # Currently this is a `ResponseArgs` object. This is so no matter how the
+      # block returns (either by throwing or running normally), you get the same
+      # thing kind of object.
+
+      def halt(status, options = nil)
+        options = OpenStruct.new(options || {})
+        response_status = [ status, options.message ]
+        throw :halt, ResponseArgs.new(response_status, options.data)
+      end
+
+      def catch_halt(&block)
+        catch(:halt){ ResponseArgs.new(*block.call) }
+      end
+
+    end
+    include HaltMethods
+
+  end
+
+end

data/lib/sanford/server.rb

@@ -1,37 +1,53 @@
-# Sanford's server uses DatTCP for a TCP Server. When a client connects, the
-# `serve` method is called. Sanford creates a new instance of a connection
-# handler and hands it the service host and client socket. This is because the
-# `serve` method can be accessed by multiple threads, so we essentially create a
-# new connection handler per thread.
-#
 require 'dat-tcp'
+require 'sanford-protocol'
 
-require 'sanford/connection'
+require 'sanford/host_data'
+require 'sanford/worker'
 
 module Sanford
 
   class Server
     include DatTCP::Server
 
-    attr_reader :service_host
+    attr_reader :host_data
 
-    def initialize(service_host, options = {})
-      @service_host = service_host
-      super(self.service_host.ip, self.service_host.port, options)
+    def initialize(host, options = {})
+      @host_data = host.kind_of?(Sanford::HostData) ? host : Sanford::HostData.new(host)
+      super(@host_data.ip, @host_data.port, options)
     end
 
     def name
-      self.service_host.name
+      @host_data.name
     end
 
+    # `serve` can be called at the same time by multiple threads. Thus we create
+    # a new instance of the handler for every request.
     def serve(socket)
-      connection = Sanford::Connection.new(self.service_host, socket)
-      connection.process
+      Sanford::Worker.new(@host_data, Connection.new(socket)).run
     end
 
     def inspect
       reference = '0x0%x' % (self.object_id << 1)
-      "#<#{self.class}:#{reference} @service_host=#{self.service_host.inspect}>"
+      "#<#{self.class}:#{reference} @service_host=#{@host_data.inspect}>"
+    end
+
+    class Connection
+
+      DEFAULT_TIMEOUT = 1
+
+      def initialize(socket)
+        @connection = Sanford::Protocol::Connection.new(socket)
+        @timeout    = (ENV['SANFORD_TIMEOUT'] || DEFAULT_TIMEOUT).to_f
+      end
+
+      def read_data
+        @connection.read(@timeout)
+      end
+
+      def write_data(data)
+        @connection.write data
+      end
+
     end
 
   end

data/lib/sanford/service_handler.rb

@@ -1,4 +1,3 @@
-require 'ostruct'
 require 'sanford-protocol'
 
 module Sanford
@@ -15,77 +14,69 @@ module Sanford
       false
     end
 
-    attr_reader :logger, :request
-
-    def initialize(logger, request)
-      @logger = logger
-      @request = request
+    def initialize(runner)
+      @sanford_runner = runner
     end
 
     def init
+      self.run_callback 'before_init'
       self.init!
+      self.run_callback 'after_init'
     end
 
     def init!
     end
 
-    # This method has very specific handling when before/after callbacks halt.
-    # It should always return a response tuple: `[ status, data ]`
-    # * If `before_run` halts, then the handler is not 'run' (it's `init` and
-    #   `run` methods are not called) and it's response tuple is returned.
-    # * If `after_run` halts, then it's response tuple is returned, even if
-    #   calling `before_run` or 'running' the handler generated a response
-    #   tuple.
-    # * If `before_run` and `after_run` do not halt, then the response tuple
-    #   from 'running' is used.
     def run
-      response_tuple = self.run_callback 'before_run'
-      response_tuple ||= catch(:halt) do
-        self.init
-        data = self.run!
-        [ 200, data ]
-      end
-      after_response_tuple = self.run_callback 'after_run'
-      (response_tuple = after_response_tuple) if after_response_tuple
-      response_tuple
+      self.run_callback 'before_run'
+      data = self.run!
+      self.run_callback 'after_run'
+      [ 200, data ]
     end
 
     def run!
       raise NotImplementedError
     end
 
+    def inspect
+      reference = '0x0%x' % (self.object_id << 1)
+      "#<#{self.class}:#{reference} @request=#{self.request.inspect}>"
+    end
+
+    protected
+
+    def before_init
+    end
+
+    def after_init
+    end
+
     def before_run
     end
 
     def after_run
     end
 
-    def params
-      self.request.params
+    # Helpers
+
+    def halt(*args)
+      @sanford_runner.halt(*args)
     end
 
-    def inspect
-      reference = '0x0%x' % (self.object_id << 1)
-      "#<#{self.class}:#{reference} @request=#{self.request.inspect}>"
+    def request
+      @sanford_runner.request
     end
 
-    protected
+    def params
+      self.request.params
+    end
 
-    def halt(status, options = nil)
-      options = OpenStruct.new(options || {})
-      response_status = [ status, options.message ]
-      throw(:halt, [ response_status, options.data ])
+    def logger
+      @sanford_runner.logger
     end
 
-    # Notes:
-    # * Callbacks need to catch :halt incase the halt method is called. They
-    #   also need to be sure to return nil if nothing is thrown, so that it
-    #   is not considered as a response.
-    def run_callback(name)
-      catch(:halt) do
-        self.send(name.to_s)
-        nil
-      end
+    def run_callback(callback)
+      self.send(callback.to_s)
     end
 
   end

data/lib/sanford/test_runner.rb

@@ -0,0 +1,47 @@
+require 'sanford-protocol'
+
+require 'sanford/logger'
+require 'sanford/runner'
+
+module Sanford
+
+  class TestRunner
+    include Sanford::Runner::HaltMethods
+
+    attr_reader :handler, :response, :request, :logger
+
+    def initialize(handler_class, params = {}, logger = nil)
+      @handler_class  = handler_class
+      @request        = params.kind_of?(Sanford::Protocol::Request) ? params : test_request(params)
+      @logger         = logger || Sanford::NullLogger.new
+
+      @handler  = @handler_class.new(self)
+      @response = build_response catch(:halt){ @handler.init; nil }
+    end
+
+    def run
+      @response ||= build_response catch_halt{ @handler.run }
+    end
+
+    protected
+
+    def test_request(params)
+      Sanford::Protocol::Request.new('test_version', 'test_service', params)
+    end
+
+    def build_response(response_args)
+      Sanford::Protocol::Response.new(response_args.status, response_args.data) if response_args
+    end
+
+    module Helpers
+      module_function
+
+      def test_runner(*args)
+        TestRunner.new(*args)
+      end
+
+    end
+
+  end
+
+end

data/lib/sanford/version.rb

@@ -1,3 +1,3 @@
 module Sanford
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/sanford/worker.rb

@@ -0,0 +1,124 @@
+require 'benchmark'
+require 'sanford-protocol'
+
+require 'sanford/error_handler'
+require 'sanford/logger'
+require 'sanford/runner'
+
+module Sanford
+
+  class Worker
+
+    ProcessedService = Struct.new(:request, :handler_class, :response, :exception, :time_taken)
+
+    attr_reader :logger
+
+    def initialize(host_data, connection)
+      @host_data, @connection = host_data, connection
+
+      @logger = Sanford::Logger.new(@host_data.logger, @host_data.verbose)
+    end
+
+    def run
+      processed_service = nil
+      self.log_received
+      benchmark = Benchmark.measure do
+        processed_service = self.run!
+      end
+      processed_service.time_taken = self.round_time(benchmark.real)
+      self.log_complete(processed_service)
+      self.raise_if_debugging!(processed_service.exception)
+      processed_service
+    end
+
+    protected
+
+    def run!
+      request, handler_class, response, exception = nil, nil, nil, nil
+      begin
+        request = Sanford::Protocol::Request.parse(@connection.read_data)
+        self.log_request(request)
+        handler_class = @host_data.handler_class_for(request.version, request.name)
+        self.log_handler_class(handler_class)
+        response = Sanford::Runner.new(handler_class, request, @host_data.logger).run
+      rescue Exception => exception
+        error_handler = Sanford::ErrorHandler.new(exception, @host_data, request)
+        response = error_handler.run
+        self.log_exception(error_handler.exception)
+      ensure
+        @connection.write_data response.to_hash
+      end
+      ProcessedService.new(request, handler_class, response, exception)
+    end
+
+    def raise_if_debugging!(exception)
+      raise exception if exception && ENV['SANFORD_DEBUG']
+    end
+
+    def log_received
+      self.logger.verbose.info("Received request")
+    end
+
+    def log_request(request)
+      self.logger.verbose.info("  Version: #{request.version.inspect}")
+      self.logger.verbose.info("  Service: #{request.name.inspect}")
+      self.logger.verbose.info("  Params:  #{request.params.inspect}")
+    end
+
+    def log_handler_class(handler_class)
+      self.logger.verbose.info("  Handler: #{handler_class}")
+    end
+
+    def log_complete(processed_service)
+      self.logger.verbose.info "Completed in #{processed_service.time_taken}ms " \
+        "#{processed_service.response.status}\n"
+      self.logger.summary.info self.summary_line(processed_service).to_s
+    end
+
+    def log_exception(exception)
+      self.logger.verbose.error("#{exception.class}: #{exception.message}")
+      self.logger.verbose.error(exception.backtrace.join("\n"))
+    end
+
+    def summary_line(processed_service)
+      SummaryLine.new.tap do |line|
+        if (request = processed_service.request)
+          line.add 'version', request.version
+          line.add 'service', request.name
+          line.add 'params',  request.params
+        end
+        line.add 'handler',   processed_service.handler_class
+        line.add 'status',    processed_service.response.status.code if processed_service.response
+        line.add 'duration',  processed_service.time_taken
+      end
+    end
+
+    ROUND_PRECISION = 2
+    ROUND_MODIFIER = 10 ** ROUND_PRECISION
+    def round_time(time_in_seconds)
+      (time_in_seconds * 1000 * ROUND_MODIFIER).to_i / ROUND_MODIFIER.to_f
+    end
+
+    class SummaryLine
+
+      def initialize
+        @hash = {}
+      end
+
+      def add(key, value)
+        @hash[key] = value.inspect if value
+      end
+
+      # change the key's order in the array to change the order to change the
+      # order they appear in when logged
+      def to_s
+        [ 'version', 'service', 'handler', 'status', 'duration', 'params' ].map do |key|
+          "#{key}=#{@hash[key]}" if @hash[key]
+        end.compact.join(" ")
+      end
+
+    end
+
+  end
+
+end

data/lib/sanford.rb

@@ -1,12 +1,26 @@
 module Sanford; end
 
-require 'sanford/config'
-require 'sanford/manager'
+require 'ns-options'
+require 'pathname'
+require 'set'
+
 require 'sanford/host'
+require 'sanford/server'
+require 'sanford/service_handler'
 require 'sanford/version'
 
+ENV['SANFORD_SERVICES_CONFIG'] ||= 'config/services'
+
 module Sanford
 
+  def self.register(host)
+    @hosts.add(host)
+  end
+
+  def self.hosts
+    @hosts
+  end
+
   def self.config
     Sanford::Config
   end
@@ -17,14 +31,43 @@ module Sanford
   end
 
   def self.init
+    @hosts ||= Hosts.new
     require self.config.services_config
   end
 
-  class NullLogger
-    require 'logger'
+  module Config
+    include NsOptions::Proxy
+
+    option :services_config,  Pathname, :default => ENV['SANFORD_SERVICES_CONFIG']
+
+  end
+
+  class Hosts
+
+    def initialize(values = [])
+      @set = Set.new(values)
+    end
+
+    # We want class names to take precedence over a configured name, so that if
+    # a user specifies a specific class, they always get it
+    def find(name)
+      self.find_by_class_name(name) || self.find_by_name(name)
+    end
+
+    def find_by_class_name(class_name)
+      @set.detect{|host_class| host_class.to_s == class_name.to_s }
+    end
+
+    def find_by_name(name)
+      @set.detect{|host_class| host_class.name == name.to_s }
+    end
+
+    def method_missing(method, *args, &block)
+      @set.send(method, *args, &block)
+    end
 
-    Logger::Severity.constants.each do |name|
-      define_method(name.downcase){|*args| } # no-op
+    def respond_to?(method)
+      super || @set.respond_to?(method)
     end
 
   end

data/sanford.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency("daemons",           ["~>1.1"])
   gem.add_dependency("dat-tcp",           ["~>0.1"])
-  gem.add_dependency("ns-options",        ["~>1.0.0"])
+  gem.add_dependency("ns-options",        ["~>1.0"])
   gem.add_dependency("sanford-protocol",  ["~>0.5"])
 
   gem.add_development_dependency("assert",        ["~>1.0"])

data/test/helper.rb

@@ -11,6 +11,7 @@ Sanford.configure do |config|
 end
 Sanford.init
 
+require 'test/support/fake_connection'
 require 'test/support/service_handlers'
 require 'test/support/simple_client'
 require 'test/support/helpers'

data/test/support/fake_connection.rb

@@ -0,0 +1,18 @@
+class FakeConnection
+
+  attr_reader :read_data, :response
+
+  def self.with_request(version, name, params = {})
+    request = Sanford::Protocol::Request.new(version, name, params)
+    self.new(request.to_hash)
+  end
+
+  def initialize(read_data)
+    @read_data = read_data
+  end
+
+  def write_data(data)
+    @response = Sanford::Protocol::Response.parse(data)
+  end
+
+end

data/test/support/helpers.rb

@@ -3,19 +3,17 @@ module Test
   module Environment
 
     def self.store_and_clear_hosts
-      @previous_hosts = Sanford.config.hosts.dup
-      Sanford.config.hosts.clear
+      @previous_hosts = Sanford.hosts.instance_variable_get("@set").dup
+      Sanford.hosts.clear
     end
 
     def self.restore_hosts
-      Sanford.config.hosts = @previous_hosts
+      Sanford.instance_variable_set("@hosts", Sanford::Hosts.new(@previous_hosts))
       @previous_hosts = nil
     end
 
   end
 
-
-
   module ForkServerHelper
 
     def start_server(server, &block)
@@ -37,18 +35,16 @@ module Test
 
   end
 
-
-
   module ForkManagerHelper
 
     # start a Sanford server using Sanford's manager in a forked process
     def call_sanford_manager(*args, &block)
       pid = fork do
-        STDOUT.reopen('/dev/null')
+        STDOUT.reopen('/dev/null') unless ENV['SANFORD_DEBUG']
         trap("TERM"){ exit }
         Sanford::Manager.call(*args)
       end
-      sleep 1 # give time for the command to run
+      sleep 1.5 # give time for the command to run
       yield
     ensure
       if pid
@@ -64,7 +60,7 @@ module Test
     end
 
     def expected_pid_file(host, ip, port)
-      host.config.pid_dir.join("#{ip}_#{port}_#{host}.pid")
+      host.pid_dir.join("#{ip}_#{port}_#{host}.pid")
     end
 
   end