sanford 0.15.1 → 0.16.0

data/Gemfile

@@ -2,7 +2,7 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'rake'
-gem 'pry', "~> 0.9.0"
+gem 'rake', "~> 10.4.0"
+gem 'pry',  "~> 0.9.0"
 
 gem 'bson_ext'

data/bench/config.sanford

@@ -1,3 +1,6 @@
+LOGGER = Logger.new(STDOUT)
+LOGGER.datetime_format = "" # turn off the datetime in the logs
+
 class BenchServer
   include Sanford::Server
 
@@ -5,7 +8,7 @@ class BenchServer
   port     59284
   pid_file File.expand_path("../../tmp/bench_server.pid", __FILE__)
 
-  logger          Logger.new(STDOUT)
+  logger          LOGGER
   verbose_logging false
 
   router do
@@ -16,9 +19,13 @@ class BenchServer
     include Sanford::ServiceHandler
 
     def run!
-      { :string => 'test', :int => 1, :float => 2.1, :boolean => true,
-        :hash => { :something => 'else' }, :array => [ 1, 2, 3 ],
-        :request_number => self.request.params['request_number']
+      { :string         => 'test',
+        :int            => 1,
+        :float          => 2.1,
+        :boolean        => true,
+        :hash           => { :something => 'else' },
+        :array          => [1, 2, 3],
+        :request_number => params['request_number']
       }
     end
 

data/bench/report.rb

@@ -81,7 +81,7 @@ module Bench
             output "  #{response.status}"
             output "  #{response.data.inspect}"
           end
-        rescue Exception => exception
+        rescue StandardError => exception
           puts "FAILED -> #{exception.class}: #{exception.message}"
           puts exception.backtrace.join("\n")
         end

data/bench/report.txt

@@ -2,40 +2,46 @@ Running benchmark report...
 
 Hitting "simple" service with {}, 10000 times
 ....................................................................................................
-Total Time:   5192.7267ms
-Average Time:    0.5192ms
-Min Time:        0.3479ms
-Max Time:       56.1919ms
+Total Time:   7600.3550ms
+Average Time:    0.7600ms
+Min Time:        0.3941ms
+Max Time:       38.5608ms
 
 Distribution (number of requests):
-  0ms: 9929
-    0.3ms: 6583
-    0.4ms: 2845
-    0.5ms: 289
-    0.6ms: 130
-    0.7ms: 47
-    0.8ms: 23
-    0.9ms: 12
-  1ms: 31
-    1.0ms: 10
-    1.1ms: 6
-    1.2ms: 5
-    1.3ms: 5
-    1.4ms: 1
-    1.5ms: 2
+  0ms: 9812
+    0.3ms: 15
+    0.4ms: 2030
+    0.5ms: 2816
+    0.6ms: 3236
+    0.7ms: 1250
+    0.8ms: 327
+    0.9ms: 138
+  1ms: 134
+    1.0ms: 60
+    1.1ms: 24
+    1.2ms: 16
+    1.3ms: 11
+    1.4ms: 5
+    1.5ms: 6
+    1.6ms: 5
+    1.7ms: 4
     1.8ms: 2
-  2ms: 1
-  5ms: 1
+    1.9ms: 1
+  2ms: 4
+  6ms: 1
   7ms: 1
-  16ms: 1
-  24ms: 1
-  28ms: 5
-  29ms: 13
-  30ms: 4
-  31ms: 2
-  32ms: 5
-  33ms: 4
-  34ms: 1
-  56ms: 1
+  8ms: 1
+  9ms: 1
+  10ms: 1
+  28ms: 1
+  30ms: 5
+  31ms: 14
+  32ms: 9
+  33ms: 7
+  34ms: 4
+  35ms: 2
+  36ms: 1
+  37ms: 1
+  38ms: 1
 
 Done running benchmark report

data/lib/sanford/connection_handler.rb

@@ -27,7 +27,6 @@ module Sanford
       end
       processed_service.time_taken = RoundedTime.new(benchmark.real)
       self.log_complete(processed_service)
-      self.raise_if_debugging!(processed_service.exception)
       processed_service
     end
 
@@ -82,10 +81,6 @@ module Sanford
       processed_service
     end
 
-    def raise_if_debugging!(exception)
-      raise exception if exception && ENV['SANFORD_DEBUG']
-    end
-
     def log_received
       log_verbose "===== Received request ====="
     end

data/lib/sanford/runner.rb

@@ -12,21 +12,25 @@ module Sanford
 
   class Runner
 
-    ResponseArgs = Struct.new(:status, :data)
+    DEFAULT_STATUS_CODE = 200.freeze
+    DEFAULT_STATUS_MSG  = nil.freeze
+    DEFAULT_DATA        = nil.freeze
 
     attr_reader :handler_class, :handler
-    attr_reader :request, :params, :logger, :router, :template_source
+    attr_reader :logger, :router, :template_source
+    attr_reader :request, :params
 
     def initialize(handler_class, args = nil)
-      @handler_class = handler_class
+      @status_code, @status_msg, @data = nil, nil, nil
 
-      a = args || {}
-      @request         = a[:request]
-      @params          = a[:params] || {}
-      @logger          = a[:logger] || Sanford::NullLogger.new
-      @router          = a[:router] || Sanford::Router.new
-      @template_source = a[:template_source] || Sanford::NullTemplateSource.new
+      args ||= {}
+      @logger          = args[:logger] || Sanford::NullLogger.new
+      @router          = args[:router] || Sanford::Router.new
+      @template_source = args[:template_source] || Sanford::NullTemplateSource.new
+      @request         = args[:request]
+      @params          = args[:params] || {}
 
+      @handler_class = handler_class
       @handler = @handler_class.new(self)
     end
 
@@ -34,32 +38,34 @@ module Sanford
       raise NotImplementedError
     end
 
-    def render(path, locals = nil)
-      self.template_source.render(path, self.handler, locals || {})
+    def to_response
+      Sanford::Protocol::Response.new(
+        [@status_code || DEFAULT_STATUS_CODE, @status_msg || DEFAULT_STATUS_MSG],
+        @data.nil? ? DEFAULT_DATA : @data
+      )
     end
 
-    # 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 ||= {}
-      message = options[:message] || options['message']
-      response_status = [ status, message ]
-      response_data = options[:data] || options['data']
-      throw :halt, ResponseArgs.new(response_status, response_data)
+    def status(*args)
+      if !args.empty?
+        @status_msg  = (args.pop)[:message] if args.last.kind_of?(::Hash)
+        @status_code = args.first           if !args.empty?
+      end
+      [@status_code, @status_msg]
     end
 
-    private
+    def data(value = nil)
+      @data = value if !value.nil?
+      @data
+    end
 
-    def catch_halt(&block)
-      catch(:halt){ ResponseArgs.new(*block.call) }
+    def halt(*args)
+      self.status(*args)
+      self.data((args.pop)[:data]) if args.last.kind_of?(::Hash)
+      throw :halt
     end
 
-    def build_response(&block)
-      args = catch_halt(&block)
-      Sanford::Protocol::Response.new(args.status, args.data)
+    def render(path, locals = nil)
+      self.data(self.template_source.render(path, self.handler, locals || {}))
     end
 
   end

data/lib/sanford/sanford_runner.rb

@@ -5,19 +5,12 @@ module Sanford
   class SanfordRunner < Runner
 
     def run
-      build_response do
-        run_callbacks self.handler_class.before_callbacks
-        self.handler.init
-        return_value = self.handler.run
-        run_callbacks self.handler_class.after_callbacks
-        return_value
+      catch(:halt) do
+        self.handler.sanford_run_callback 'before'
+        catch(:halt){ self.handler.sanford_init; self.handler.sanford_run }
+        self.handler.sanford_run_callback 'after'
       end
-    end
-
-    private
-
-    def run_callbacks(callbacks)
-      callbacks.each{ |proc| self.handler.instance_eval(&proc) }
+      self.to_response
     end
 
   end

data/lib/sanford/server.rb

@@ -1,4 +1,5 @@
 require 'dat-tcp'
+require 'much-plugin'
 require 'ns-options'
 require 'ns-options/boolean'
 require 'pathname'
@@ -8,17 +9,16 @@ require 'sanford/logger'
 require 'sanford/router'
 require 'sanford/server_data'
 require 'sanford/template_source'
-require 'sanford/connection_handler'
+require 'sanford/worker'
 
 module Sanford
 
   module Server
+    include MuchPlugin
 
-    def self.included(klass)
-      klass.class_eval do
-        extend ClassMethods
-        include InstanceMethods
-      end
+    plugin_included do
+      extend ClassMethods
+      include InstanceMethods
     end
 
     module InstanceMethods
@@ -28,7 +28,14 @@ module Sanford
       def initialize
         self.class.configuration.validate!
         @server_data = ServerData.new(self.class.configuration.to_hash)
-        @dat_tcp_server = build_dat_tcp_server
+        @dat_tcp_server = DatTCP::Server.new(self.server_data.worker_class, {
+          :num_workers      => self.server_data.num_workers,
+          :logger           => self.server_data.dtcp_logger,
+          :shutdown_timeout => self.server_data.shutdown_timeout,
+          :worker_params    => self.server_data.worker_params.merge({
+            :sanford_server_data => self.server_data
+          })
+        })
       rescue InvalidError => exception
         exception.set_backtrace(caller)
         raise exception
@@ -109,34 +116,10 @@ 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)
-          Sanford::ConnectionHandler.new(@server_data, connection).run
-        end
-      end
-
-      def keep_alive_connection?(connection)
-        @server_data.receives_keep_alive && connection.peek_data.empty?
-      end
-
       # TCP_NODELAY is set to disable buffering. In the case of Sanford
       # communication, we have all the information we need to send up front and
       # are closing the connection, so it doesn't need to buffer.
       # See http://linux.die.net/man/7/tcp
-
       def configure_tcp_server(tcp_server)
         tcp_server.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
       end
@@ -165,6 +148,22 @@ module Sanford
         self.configuration.pid_file *args
       end
 
+      def worker_class(new_worker_class = nil)
+        self.configuration.worker_class = new_worker_class if new_worker_class
+        self.configuration.worker_class
+      end
+
+      def worker_params(new_worker_params = nil)
+        self.configuration.worker_params = new_worker_params if new_worker_params
+        self.configuration.worker_params
+      end
+
+      def num_workers(new_num_workers = nil)
+        self.configuration.num_workers = new_num_workers if new_num_workers
+        self.configuration.num_workers
+      end
+      alias :workers :num_workers
+
       def receives_keep_alive(*args)
         self.configuration.receives_keep_alive *args
       end
@@ -177,6 +176,11 @@ module Sanford
         self.configuration.logger *args
       end
 
+      def shutdown_timeout(new_timeout = nil)
+        self.configuration.shutdown_timeout = new_timeout if new_timeout
+        self.configuration.shutdown_timeout
+      end
+
       def init(&block)
         self.configuration.init_procs << block
       end
@@ -185,22 +189,6 @@ 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
@@ -213,66 +201,11 @@ module Sanford
 
     end
 
-    class Connection
-      DEFAULT_TIMEOUT = 1
-
-      attr_reader :timeout
-
-      def initialize(socket)
-        @socket     = 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)
-        TCPCork.apply(@socket)
-        @connection.write data
-        TCPCork.remove(@socket)
-      end
-
-      def peek_data
-        @connection.peek(@timeout)
-      end
-
-      def close_write
-        @connection.close_write
-      end
-    end
-
-    module TCPCork
-      # On Linux, use TCP_CORK to better control how the TCP stack
-      # packetizes our stream. This improves both latency and throughput.
-      # TCP_CORK disables Nagle's algorithm, which is ideal for sporadic
-      # traffic (like Telnet) but is less optimal for HTTP. Sanford is similar
-      # to HTTP, it doesn't receive sporadic packets, it has all its data
-      # come in at once.
-      # For more information: http://baus.net/on-tcp_cork
-
-      if RUBY_PLATFORM =~ /linux/
-        # 3 == TCP_CORK
-        def self.apply(socket)
-          socket.setsockopt(::Socket::IPPROTO_TCP, 3, true)
-        end
-
-        def self.remove(socket)
-          socket.setsockopt(::Socket::IPPROTO_TCP, 3, false)
-        end
-      else
-        def self.apply(socket)
-        end
-
-        def self.remove(socket)
-        end
-      end
-    end
-
     class Configuration
       include NsOptions::Proxy
 
+      DEFAULT_NUM_WORKERS = 4
+
       option :name,     String,  :required => true
       option :ip,       String,  :required => true, :default => '0.0.0.0'
       option :port,     Integer, :required => true
@@ -285,16 +218,18 @@ module Sanford
       option :template_source, :default => proc{ NullTemplateSource.new }
 
       attr_accessor :init_procs, :error_procs
+      attr_accessor :worker_class, :worker_params, :num_workers
+      attr_accessor :shutdown_timeout
       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)
         @init_procs, @error_procs = [], []
-        @worker_start_procs, @worker_shutdown_procs = [], []
-        @worker_sleep_procs, @worker_wakeup_procs   = [], []
-        @router = Sanford::Router.new
+        @worker_class     = DefaultWorker
+        @worker_params    = nil
+        @num_workers      = DEFAULT_NUM_WORKERS
+        @shutdown_timeout = nil
+        @router           = Sanford::Router.new
         @valid  = nil
       end
 
@@ -304,14 +239,14 @@ module Sanford
 
       def to_hash
         super.merge({
-          :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
+          :init_procs       => self.init_procs,
+          :error_procs      => self.error_procs,
+          :worker_class     => self.worker_class,
+          :worker_params    => self.worker_params,
+          :num_workers      => self.num_workers,
+          :shutdown_timeout => self.shutdown_timeout,
+          :router           => self.router,
+          :routes           => self.routes
         })
       end
 
@@ -325,11 +260,16 @@ module Sanford
         if !self.required_set?
           raise InvalidError, "a name, ip and port must be configured"
         end
+        if !self.worker_class.kind_of?(Class) || !self.worker_class.include?(Sanford::Worker)
+          raise InvalidError, "worker class must include `#{Sanford::Worker}`"
+        end
         self.routes.each(&:validate!)
         @valid = true
       end
     end
 
+    DefaultWorker = Class.new{ include Sanford::Worker }
+
     InvalidError = Class.new(RuntimeError)
 
   end

data/lib/sanford/server_data.rb

@@ -10,10 +10,10 @@ module Sanford
     attr_reader :name
     attr_reader :pid_file
     attr_reader :receives_keep_alive
-    attr_reader :verbose_logging, :logger, :template_source
+    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 :worker_start_procs, :worker_shutdown_procs
-    attr_reader :worker_sleep_procs, :worker_wakeup_procs
     attr_reader :router, :routes
     attr_accessor :ip, :port
 
@@ -26,18 +26,22 @@ module Sanford
 
       @receives_keep_alive = !!args[:receives_keep_alive]
 
-      @verbose_logging = !!args[:verbose_logging]
+      @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]
+
       @template_source = args[:template_source]
 
+      @shutdown_timeout = args[:shutdown_timeout]
+
       @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