sanford 0.1.0 → 0.2.0

data/bench/report.txt

@@ -2,9 +2,39 @@ Running benchmark report...
 
 Hitting "simple" service with {}, 10000 times
 ....................................................................................................
-Total Time:   15768.8473ms
-Average Time:     1.5768ms
-Min Time:         0.9949ms
-Max Time:       102.2670ms
+Total Time:   10195.4432ms
+Average Time:     1.0195ms
+Min Time:         0.7040ms
+Max Time:       117.8309ms
+
+Distribution (number of requests):
+  0ms: 8897
+    0.7ms: 6897
+    0.8ms: 1451
+    0.9ms: 549
+  1ms: 1049
+    1.0ms: 308
+    1.1ms: 236
+    1.2ms: 198
+    1.3ms: 134
+    1.4ms: 66
+    1.5ms: 44
+    1.6ms: 26
+    1.7ms: 18
+    1.8ms: 15
+    1.9ms: 4
+  117ms: 1
+  2ms: 24
+  3ms: 7
+  4ms: 2
+  82ms: 1
+  83ms: 1
+  84ms: 3
+  85ms: 2
+  86ms: 2
+  88ms: 3
+  89ms: 4
+  90ms: 2
+  91ms: 2
 
 Done running benchmark report

data/bench/runner.rb

@@ -43,10 +43,11 @@ module Bench
       output("\n", false)
 
       total_time = benchmarks.inject(0){|s, n| s + n }
+      average = total_time / benchmarks.size
       data = {
         :number_of_requests => times,
         :total_time_taken   => self.round_and_display(total_time),
-        :average_time_taken => self.round_and_display(total_time / benchmarks.size),
+        :average_time_taken => self.round_and_display(average),
         :min_time_taken     => self.round_and_display(benchmarks.min),
         :max_time_taken     => self.round_and_display(benchmarks.max)
       }
@@ -55,6 +56,19 @@ module Bench
       output "Average Time: #{data[:average_time_taken].rjust(size)}ms"
       output "Min Time:     #{data[:min_time_taken].rjust(size)}ms"
       output "Max Time:     #{data[:max_time_taken].rjust(size)}ms"
+
+      output "\n"
+
+      distribution = Distribution.new(benchmarks)
+
+      output "Distribution (number of requests):"
+      distribution.each do |grouping|
+        output "  #{grouping.time}ms: #{grouping.number_of_requests}"
+        grouping.precise_groupings.each do |precise_grouping|
+          output "    #{precise_grouping.time}ms: #{precise_grouping.number_of_requests}"
+        end
+      end
+
       output "\n"
     end
 
@@ -97,6 +111,113 @@ module Bench
       [ integer, fractional.ljust(4, '0') ].join('.')
     end
 
+    class Distribution
+
+      def initialize(benchmarks)
+        hash = benchmarks.inject({}) do |hash, benchmark|
+          index = Index.new(benchmark).number
+          hash[index] ||= Grouping.new(index)
+          hash[index].add(benchmark)
+          hash
+        end
+        @groupings = hash.values.sort
+      end
+
+      def each(&block)
+        @groupings.each(&block)
+      end
+
+      class BaseGrouping
+
+        def self.max_time(time = nil)
+          size = time.to_s.size
+          @max_time = size if size > @max_time.to_i
+          @max_time
+        end
+
+        def self.max_number(number = nil)
+          size = number.to_s.size
+          @max_size = size if size > @max_size.to_i
+          @max_size
+        end
+
+        attr_reader :name
+
+        def initialize(index)
+          @name = index.to_s
+          @set  = []
+          self.class.max_time(index.to_s.size)
+        end
+
+        def add(benchmark)
+          result = @set.push(benchmark)
+          self.class.max_number(@set.size.to_s.size)
+          result
+        end
+
+        def time
+          @name.rjust(self.class.max_time)
+        end
+
+        def number_of_requests
+          @set.size.to_s.rjust(self.class.max_number)
+        end
+
+        def <=>(other)
+          self.name.to_f <=> other.name.to_f
+        end
+
+      end
+
+      class Grouping < BaseGrouping
+
+        def initialize(index)
+          super
+          @precise_groupings = {}
+        end
+
+        def add(benchmark)
+          add_precise_grouping(benchmark) if self.collect_precise?
+          super(benchmark)
+        end
+
+        def collect_precise?
+          @name.to_i <= 1
+        end
+
+        def precise_groupings
+          @precise_groupings.values.sort
+        end
+
+        protected
+
+        def add_precise_grouping(benchmark)
+          index = PreciseIndex.new(benchmark).number
+          @precise_groupings[index] ||= BaseGrouping.new(index)
+          @precise_groupings[index].add(benchmark)
+        end
+
+      end
+
+      class Index < Struct.new(:number)
+
+        def initialize(benchmark)
+          super benchmark.to_i
+        end
+      end
+
+      class PreciseIndex < Struct.new(:number)
+
+        MODIFIER = 10.to_f
+
+        def initialize(benchmark)
+          super((benchmark * MODIFIER).to_i / MODIFIER)
+        end
+
+      end
+
+    end
+
   end
 
 end

data/bench/services.rb

@@ -1,8 +1,11 @@
 class BenchHost
   include Sanford::Host
 
-  self.port     = 12000
-  self.pid_dir  = File.expand_path("../../tmp", __FILE__)
+  port     12000
+  pid_dir  File.expand_path("../../tmp", __FILE__)
+
+  logger           Logger.new(STDOUT)
+  verbose_logging  false
 
   version 'v1' do
     service 'simple', 'BenchHost::Simple'

data/lib/sanford/error_handler.rb

@@ -0,0 +1,60 @@
+require 'ostruct'
+require 'sanford-protocol'
+
+module Sanford
+
+  class ErrorHandler
+
+    attr_reader :exception, :host_data, :request
+
+    def initialize(exception, host_data, request = nil)
+      @exception, @host_data, @request = exception, host_data, request
+    end
+
+    # The exception that we are generating a response for can change in the case
+    # that the configured error proc raises an exception. If this occurs, a
+    # response will be generated for that exception, instead of the original
+    # one. This is designed to avoid "hidden" errors happening, this way the
+    # server will respond and log based on the last exception that occurred.
+
+    def run
+      begin
+        result = @host_data.error_proc.call(@exception, @host_data, @request)
+      rescue Exception => proc_exception
+        @exception = proc_exception
+      end
+      self.response_from_proc(result) || self.response_from_exception(@exception)
+    end
+
+    protected
+
+    def response_from_proc(result)
+      case result
+      when Sanford::Protocol::Response
+        result
+      when Integer, Symbol
+        build_response result
+      end
+    end
+
+    def response_from_exception(exception)
+      case(exception)
+      when Sanford::Protocol::BadMessageError, Sanford::Protocol::BadRequestError
+        build_response :bad_request, :message => exception.message
+      when Sanford::NotFoundError
+        build_response :not_found
+      when Sanford::Protocol::TimeoutError
+        build_response :timeout
+      when Exception
+        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)
+    end
+
+  end
+
+end

data/lib/sanford/exceptions.rb

@@ -1,37 +1,38 @@
 module Sanford
 
-  class BaseError < RuntimeError; end
+  BaseError = Class.new(RuntimeError)
 
-  class NotFoundError < BaseError; end
+  NotFoundError = Class.new(RuntimeError)
 
   class NoHostError < BaseError
     attr_reader :message
 
     def initialize(host_name)
-      @message = if Sanford.config.hosts.empty?
-        "No hosts have been defined. " \
-        "Please define a host before trying to run Sanford."
+      message = if Sanford.hosts.empty?
+        "No hosts have been defined. Please define a host before trying to run Sanford."
       else
         "A host couldn't be found with the name #{host_name.inspect}. "
       end
+      super message
     end
+
   end
 
   class InvalidHostError < BaseError
-    attr_reader :message
 
     def initialize(host)
-      @message = "A port must be configured or provided to build an instance of '#{host}'"
+      super "A port must be configured or provided to run a server for '#{host}'"
     end
+
   end
 
   class NoHandlerClassError < BaseError
-    attr_reader :message
 
-    def initialize(host, handler_class_name)
-      @message = "Sanford couldn't find the service handler '#{handler_class_name}'." \
+    def initialize(handler_class_name)
+      super "Sanford couldn't find the service handler '#{handler_class_name}'. " \
         "It doesn't exist or hasn't been required in yet."
     end
+
   end
 
 end

data/lib/sanford/host.rb

@@ -1,136 +1,93 @@
-# Sanford's Host mixin is used to define service hosts. When mixed into a class
-# it provides the interface for configuring the service host and for adding
-# versioned services. It also contains the logic for routing a request to a
-# a service handler.
-#
-# Options:
-# * `name`    - A string for naming this host. This can be used when specifying
-#               a host with the rake tasks and will be used to name the PID
-#               file. Defaults to the class's name.
-# * `ip`      - The string for the ip that the TCP Server should bind to. This
-#               defaults to '0.0.0.0'.
-# * `port`    - The integer for the port that the TCP Server should bind to.
-#               This isn't defaulted and must be provided.
-# * `pid_dir` - The directory to write the PID file to. This is defaulted to
-#               Dir.pwd.
-# * `logger`  - The logger to use if the Sanford server logs messages. This is
-#               defaulted to an instance of Ruby's Logger.
-#
-require 'logger'
 require 'ns-options'
 require 'pathname'
 
-require 'sanford/config'
-require 'sanford/exception_handler'
 require 'sanford/exceptions'
-require 'sanford/service_handler'
+require 'sanford/logger'
 
 module Sanford
+
   module Host
 
-    # Notes:
-    # * When Host is included on a class, it needs to mixin NsOptions and define
-    #   the options directly on the class (instead of on the Host module).
-    #   Otherwise, NsOptions will not work correctly for the class.
-    def self.included(host_class)
-      host_class.class_eval do
-        include NsOptions
-        extend Sanford::Host::Interface
-
-        options :config do
-          option :name,     String,   :default => host_class.to_s
-          option :ip,       String,   :default => '0.0.0.0'
-          option :port,     Integer
-          option :pid_dir,  Pathname, :default => Dir.pwd
-          option :logger,             :default => proc{ Sanford::NullLogger.new }
-
-          option :exception_handler,        :default => Sanford::ExceptionHandler
-          option :versioned_services, Hash, :default => {}
-        end
+    class Configuration
+      include NsOptions::Proxy
+
+      # A Host's configuration is a seperate ns-options proxy class because
+      # `Host` is a module, so it itself cannot be a ns-options proxy (and
+      # still function as a mixin). Also, since it is making the `Host`
+      # a `Singleton`, mixing that with `NsOptions::Proxy` could have strange
+      # effects (messing up someone's `initialize`). Thus, the `Configuration`
+      # is a separate class and not on the `Host` directly.
+
+      option :name,             String
+      option :ip,               String,   :default => '0.0.0.0'
+      option :port,             Integer
+      option :pid_dir,          Pathname, :default => Dir.pwd
+      option :logger,                     :default => proc{ Sanford::NullLogger.new }
+      option :verbose_logging,            :default => true
+      option :error_proc,       Proc,     :default => proc{ }
+
+      def initialize(host)
+        self.name = host.class.to_s
       end
-      Sanford.config.hosts.add(host_class)
-    end
 
-    INTERFACE_OPTIONS = [ :name, :ip, :port, :pid_dir, :logger, :exception_handler ]
-
-    # Notes:
-    # * The `initialize` takes the values configured on the class and merges
-    #   the passed in options. This is used to set the individual instance's
-    #   configuration (which allows overwriting options like the port).
-    def initialize(options = nil)
-      options = self.remove_nil_values(options)
-      config_options = self.class.config.to_hash.merge(options)
-      self.config.apply(config_options)
-      raise(Sanford::InvalidHostError.new(self.class)) if !self.port
     end
 
-    INTERFACE_OPTIONS.each do |name|
-
-      define_method(name) do
-        self.config.send(name)
+    def self.included(host_class)
+      host_class.class_eval do
+        include Singleton
+        extend Sanford::Host::ClassMethods
       end
-
+      Sanford.register(host_class)
     end
 
-    def run(request)
-      request_handler(request).run
-    end
+    attr_reader :configuration, :versioned_services
 
-    def inspect
-      reference = '0x0%x' % (self.object_id << 1)
-      "#<#{self.class}:#{reference} ip=#{self.config.ip.inspect} " \
-      "port=#{self.config.port.inspect}>"
+    def initialize
+      @configuration = Configuration.new(self)
+      @versioned_services = {}
     end
 
-    protected
-
-    def request_handler(request)
-      handler_class(get_handler_class_name(request)).new(self.logger, request)
+    def name(*args)
+      self.configuration.name *args
     end
 
-    def handler_class(class_name_str)
-      self.logger.info("  Handler: #{class_name_str.inspect}")
-      Sanford::ServiceHandler.constantize(class_name_str).tap do |handler_class|
-        raise Sanford::NoHandlerClassError.new(self, class_name_str) if !handler_class
-      end
+    def ip(*args)
+      self.configuration.ip *args
     end
 
-    def get_handler_class_name(request)
-      services = self.config.versioned_services[request.version] || {}
-      services[request.name].tap do |name|
-        raise Sanford::NotFoundError if !name
-      end
+    def port(*args)
+      self.configuration.port *args
     end
 
-    def remove_nil_values(options)
-      (options || {}).inject({}) do |hash, (k, v)|
-        hash.merge!({ k => v }) if !v.nil?
-        hash
-      end
+    def pid_dir(*args)
+      self.configuration.pid_dir *args
     end
 
-    module Interface
-
-      INTERFACE_OPTIONS.each do |name|
-
-        define_method(name) do |*args|
-          self.config.send("#{name}=", *args) if !args.empty?
-          self.config.send(name)
-        end
+    def logger(*args)
+      self.configuration.logger *args
+    end
 
-        define_method("#{name}=") do |new_value|
-          self.config.send("#{name}=", new_value)
-        end
+    def verbose_logging(*args)
+      self.configuration.verbose_logging *args
+    end
 
-      end
+    def error(&block)
+      self.configuration.error_proc = block
+    end
 
-      def version(name, &block)
-        version_group = Sanford::Host::VersionGroup.new(name, &block)
-        self.config.versioned_services.merge!(version_group.to_hash)
-      end
+    def version(name, &block)
+      version_group = Sanford::Host::VersionGroup.new(name, &block)
+      @versioned_services.merge!(version_group.to_hash)
+    end
 
+    def inspect
+      reference = '0x0%x' % (self.object_id << 1)
+      "#<#{self.class}:#{reference} ip=#{self.configuration.ip.inspect} " \
+      "port=#{self.configuration.port.inspect}>"
     end
 
+    protected
+
     class VersionGroup
       attr_reader :name, :services
 
@@ -158,5 +115,26 @@ module Sanford
 
     end
 
+    module ClassMethods
+
+      # the class level of a `Host` should just proxy it's methods down to it's
+      # instance (it's a `Singleton`)
+
+      # `name` is defined by all objects, so we can't rely on `method_missing`
+      def name(*args)
+        self.instance.name(*args)
+      end
+
+      def method_missing(method, *args, &block)
+        self.instance.send(method, *args, &block)
+      end
+
+      def respond_to?(method)
+        super || self.instance.respond_to?(method)
+      end
+
+    end
+
   end
+
 end

data/lib/sanford/host_data.rb

@@ -0,0 +1,55 @@
+require 'sanford/exceptions'
+require 'sanford/service_handler'
+
+module Sanford
+
+  class HostData
+
+    # When trying to run a server for a host, we need to build up the host's
+    # data to increase the performance of the server. This is done by
+    # constantizing a host's handlers and merging a host's configuration with
+    # optional overrides.
+
+    attr_reader :name, :ip, :port, :pid_dir, :logger, :verbose, :error_proc
+
+    def initialize(service_host, options = nil)
+      configuration = service_host.configuration.to_hash.merge(remove_nil_values(options || {}))
+
+      @name               = configuration[:name]
+      @ip, @port          = configuration[:ip], configuration[:port]
+      @pid_dir            = configuration[:pid_dir]
+      @logger, @verbose   = configuration[:logger], configuration[:verbose_logging]
+      @error_proc         = configuration[:error_proc]
+
+      @handlers = service_host.versioned_services.inject({}) do |hash, (version, services)|
+        hash.merge({ version => self.constantize_services(services) })
+      end
+
+      raise Sanford::InvalidHostError.new(service_host) if !self.port
+    end
+
+    def handler_class_for(version, service)
+      version_group = @handlers[version] || {}
+      version_group[service] || raise(Sanford::NotFoundError)
+    end
+
+    protected
+
+    def constantize_services(services)
+      services.inject({}) do |hash, (name, handler_class_name)|
+        hash.merge({ name => self.constantize(handler_class_name) })
+      end
+    end
+
+    def constantize(handler_class_name)
+      Sanford::ServiceHandler.constantize(handler_class_name) ||
+        raise(Sanford::NoHandlerClassError.new(handler_class_name))
+    end
+
+    def remove_nil_values(hash)
+      hash.inject({}){|h, (k, v)| !v.nil? ? h.merge({ k => v }) : h }
+    end
+
+  end
+
+end

data/lib/sanford/logger.rb

@@ -0,0 +1,23 @@
+module Sanford
+
+  class Logger
+    attr_reader :summary, :verbose
+
+    def initialize(logger, verbose = true)
+      loggers = [ logger, Sanford::NullLogger.new ]
+      loggers.reverse! if !verbose
+      @verbose, @summary = loggers
+    end
+
+  end
+
+  class NullLogger
+    require 'logger'
+
+    ::Logger::Severity.constants.each do |name|
+      define_method(name.downcase){|*args| } # no-op
+    end
+
+  end
+
+end

data/lib/sanford/manager.rb

@@ -1,44 +1,35 @@
-# The Manager class is responsible for managing sanford's server process. Given
-# a host, it can start and stop the host's server process. This is done using
-# the Daemons gem and `run_proc`. The class provides a convenience method on the
-# class called `call`, which will find a host, build a new manager and call the
-# relevant action (this is what the rake tasks use).
-#
 require 'daemons'
 
-require 'sanford/config'
-require 'sanford/exceptions'
+require 'sanford/host_data'
 require 'sanford/server'
 
 module Sanford
 
   class Manager
-    attr_reader :host, :process_name
 
     def self.call(action, options = nil)
       options ||= {}
-      options[:host]  ||= ENV['SANFORD_HOST']
       options[:ip]    ||= ENV['SANFORD_IP']
       options[:port]  ||= ENV['SANFORD_PORT']
 
-      host_class = if (host_class_or_name = options.delete(:host))
-        Sanford.config.find_host(host_class_or_name)
-      else
-        Sanford.config.hosts.first
-      end
-      raise(Sanford::NoHostError.new(host_class_or_name)) if !host_class
-      self.new(host_class, options).call(action)
+      name = options.delete(:host) || ENV['SANFORD_HOST']
+      service_host = name ? Sanford.hosts.find(name) : Sanford.hosts.first
+      raise(Sanford::NoHostError.new(name)) if !service_host
+
+      self.new(service_host, options).call(action)
     end
 
-    def initialize(host_class, options = {})
-      @host = host_class.new(options)
+    attr_reader :host, :process_name
+
+    def initialize(service_host, options = {})
+      @host = Sanford::HostData.new(service_host, options)
       @process_name = [ self.host.ip, self.host.port, self.host.name ].join('_')
     end
 
     def call(action)
-      options = self.default_options.merge({ :ARGV => [ action.to_s ] })
-      FileUtils.mkdir_p(options[:dir])
-      ::Daemons.run_proc(self.process_name, options) do
+      daemons_options = self.default_options.merge({ :ARGV => [ action.to_s ] })
+      FileUtils.mkdir_p(daemons_options[:dir])
+      ::Daemons.run_proc(self.process_name, daemons_options) do
         server = Sanford::Server.new(self.host)
         server.start
         server.join_thread

data/lib/sanford/rake.rb

@@ -12,6 +12,7 @@ module Sanford::Rake
 
         task :load_manager => :setup do
           require 'sanford'
+          require 'sanford/manager'
           Sanford.init
         end