sanford 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA512: 
-  metadata.gz: 179edb42ed70349903ee1c61dac5d041ce8ccf2224121e952871965635ea4f26541f58468c3f7bfc6842dfae80551993dae461845024e26a89bfbbfb315f144a
-  data.tar.gz: dc50fc52dcabe5aaea8969654bdd1af13fc40cb1bd62ffaafc38a845b3fe1127a17b1f1adfcd2880a828a18241b869c5f4ad3782c71bcd40c5635d285e633a3a
+  data.tar.gz: b37cfd3f2c40682c86f0beb66377fa878e9e9afa7176607ef4c8d5ca342f6bbf5bc79be72e6f57a34d77730bead2c61af1c3cde5e336ede29fb1de4f3910528e
+  metadata.gz: db614d3e51992924e70599df591799d0437fc39790fdf279bf5f896db4dfab2d4f7da2f205d9d9cd1128aa120f6f7f14eb827a9cd3888fe2e9223188f5ddc21c
 SHA1: 
-  metadata.gz: da5833891f1c7570eb1cb642bbd506487eb2f3c8
-  data.tar.gz: 3b093248ea8ac8cd931f1cb05db52d676a34494c
+  data.tar.gz: 982aa3206746b65d6fd27d6c285df134f78a8e80
+  metadata.gz: e351442a99e056e6b8779701e9357dcb306cf48a

data/Gemfile

@@ -3,4 +3,4 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'pry', "~> 0.9.0"
-gem 'bson_ext'
+gem 'bson_ext', '~>1.7'

data/bench/report.rb

@@ -1,3 +1,5 @@
+$LOAD_PATH.push(File.expand_path('../..', __FILE__))
+
 require 'benchmark'
 require 'bench/client'
 

data/bench/report.txt

@@ -2,46 +2,37 @@ Running benchmark report...
 
 Hitting "simple" service with {}, 10000 times
 ....................................................................................................
-Total Time:   7600.3550ms
-Average Time:    0.7600ms
-Min Time:        0.3941ms
-Max Time:       38.5608ms
+Total Time:   7117.6994ms
+Average Time:    0.7117ms
+Min Time:        0.4079ms
+Max Time:       71.8839ms
 
 Distribution (number of requests):
-  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
-    1.9ms: 1
-  2ms: 4
-  6ms: 1
-  7ms: 1
+  0ms: 9917
+    0.4ms: 2569
+    0.5ms: 2754
+    0.6ms: 2608
+    0.7ms: 1654
+    0.8ms: 262
+    0.9ms: 70
+  1ms: 62
+    1.0ms: 31
+    1.1ms: 17
+    1.2ms: 7
+    1.3ms: 5
+    1.5ms: 1
+    1.8ms: 1
+  3ms: 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
+  27ms: 1
+  41ms: 1
+  47ms: 1
+  65ms: 4
+  66ms: 1
+  67ms: 5
+  68ms: 3
+  70ms: 1
+  71ms: 1
 
 Done running benchmark report

data/lib/sanford/connection_handler.rb

@@ -1,4 +1,5 @@
 require 'benchmark'
+require 'dat-worker-pool'
 require 'sanford-protocol'
 require 'sanford/error_handler'
 require 'sanford/logger'
@@ -45,6 +46,11 @@ module Sanford
 
         response = route.run(request, @server_data)
         processed_service.response = response
+      rescue DatWorkerPool::ShutdownError => exception
+        error = ShutdownError.new(exception.message)
+        error.set_backtrace(exception.backtrace)
+        self.handle_exception(error, @server_data, processed_service)
+        raise exception
       rescue StandardError => exception
         self.handle_exception(exception, @server_data, processed_service)
       ensure
@@ -101,9 +107,8 @@ module Sanford
     end
 
     def log_exception(exception)
-      backtrace = exception.backtrace.join("\n")
-      message = "#{exception.class}: #{exception.message}\n#{backtrace}"
-      log_verbose(message, :error)
+      log_verbose("#{exception.class}: #{exception.message}", :error)
+      (exception.backtrace || []).each{ |l| log_verbose(l, :error) }
     end
 
     def log_verbose(message, level = :info)
@@ -154,4 +159,6 @@ module Sanford
 
   end
 
+  ShutdownError = Class.new(DatWorkerPool::ShutdownError)
+
 end

data/lib/sanford/error_handler.rb

@@ -45,13 +45,13 @@ module Sanford
     def response_from_exception(exception)
       if exception.kind_of?(Sanford::Protocol::BadMessageError) ||
          exception.kind_of?(Sanford::Protocol::Request::InvalidError)
-        build_response :bad_request, :message => exception.message
+        build_response 400, :message => exception.message # BAD REQUEST
       elsif exception.kind_of?(Sanford::NotFoundError)
-        build_response :not_found
+        build_response 404 # NOT FOUND
       elsif exception.kind_of?(Sanford::Protocol::TimeoutError)
-        build_response :timeout
+        build_response 408 # TIMEOUT
       else
-        build_response :error, :message => "An unexpected error occurred."
+        build_response 500, :message => "An unexpected error occurred." # ERROR
       end
     end
 

data/lib/sanford/io_pipe.rb

@@ -0,0 +1,40 @@
+module Sanford
+
+  class IOPipe
+
+    NULL = File.open('/dev/null', 'w')
+    NUMBER_OF_BYTES = 1
+
+    attr_reader :reader, :writer
+
+    def initialize
+      @reader = NULL
+      @writer = NULL
+    end
+
+    def setup
+      @reader, @writer = ::IO.pipe
+    end
+
+    def teardown
+      @reader.close unless @reader === NULL
+      @writer.close unless @writer === NULL
+      @reader = NULL
+      @writer = NULL
+    end
+
+    def read
+      @reader.read_nonblock(NUMBER_OF_BYTES)
+    end
+
+    def write(value)
+      @writer.write_nonblock(value[0, NUMBER_OF_BYTES])
+    end
+
+    def wait(timeout = nil)
+      !!::IO.select([@reader], nil, nil, timeout)
+    end
+
+  end
+
+end

data/lib/sanford/process.rb

@@ -1,17 +1,27 @@
+require 'sanford/io_pipe'
 require 'sanford/pid_file'
 
 module Sanford
 
   class Process
 
-    attr_reader :server, :name, :pid_file, :restart_cmd
+    HALT    = 'H'.freeze
+    STOP    = 'S'.freeze
+    RESTART = 'R'.freeze
+
+    WAIT_FOR_SIGNALS_TIMEOUT = 15
+
+    attr_reader :server, :name, :pid_file, :signal_io, :restart_cmd
     attr_reader :server_ip, :server_port, :server_fd, :client_fds
 
     def initialize(server, options = nil)
       options ||= {}
       @server = server
+      @name   = "sanford: #{@server.process_label}"
       @logger = @server.logger
-      @pid_file = PIDFile.new(@server.pid_file)
+
+      @pid_file    = PIDFile.new(@server.pid_file)
+      @signal_io   = IOPipe.new
       @restart_cmd = RestartCmd.new
 
       @server_ip   = @server.configured_ip
@@ -21,12 +31,10 @@ module Sanford
       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'].to_s.split(',').map(&:to_i)
 
-      @daemonize      = !!options[:daemonize]
-      @skip_daemonize = !ENV['SANFORD_SKIP_DAEMONIZE'].to_s.empty?
+      skip_daemonize = ignore_if_blank(ENV['SANFORD_SKIP_DAEMONIZE'])
+      @daemonize = !!options[:daemonize] && !skip_daemonize
     end
 
     def run
@@ -40,37 +48,82 @@ module Sanford
       @pid_file.write
       log "PID: #{@pid_file.pid}"
 
-      ::Signal.trap("TERM"){ @server.stop }
-      ::Signal.trap("INT"){ @server.halt }
-      ::Signal.trap("USR2"){ @server.pause }
+      @signal_io.setup
+      trap_signals(@signal_io)
 
-      thread = @server.start(@client_fds)
-      log "#{@server.name} server started and ready."
-      thread.join
-      run_restart_cmd if @server.paused?
-    rescue StandardError => exception
-      log "Error: #{exception.message}"
-      log "#{@server.name} server never started."
+      start_server(@server, @client_fds)
+
+      signal = catch(:signal) do
+        wait_for_signals(@signal_io, @server)
+      end
+      @signal_io.teardown
+
+      run_restart_cmd(@restart_cmd, @server) if signal == RESTART
     ensure
       @pid_file.remove
     end
 
-    def daemonize?
-      @daemonize && !@skip_daemonize
-    end
+    def daemonize?; @daemonize; end
 
     private
 
+    def start_server(server, client_fds)
+      server.start(client_fds)
+      log "#{server.name} server started and ready."
+    rescue StandardError => exception
+      log "#{server.name} server never started."
+      raise exception
+    end
+
+    def trap_signals(signal_io)
+      trap_signal('INT'){  signal_io.write(HALT) }
+      trap_signal('TERM'){ signal_io.write(STOP) }
+      trap_signal('USR2'){ signal_io.write(RESTART) }
+    end
+
+    def trap_signal(signal, &block)
+      ::Signal.trap(signal, &block)
+    rescue ArgumentError
+      log "'#{signal}' signal not supported"
+    end
+
+    def wait_for_signals(signal_io, server)
+      loop do
+        ready = signal_io.wait(WAIT_FOR_SIGNALS_TIMEOUT)
+        handle_signal(signal_io.read, server) if ready
+
+        if !server.running?
+          log "Server crashed, restarting"
+          start_server(server, server.client_file_descriptors)
+        end
+      end
+    end
+
+    def handle_signal(signal, server)
+      log "Got '#{signal}' signal"
+      case signal
+      when HALT
+        server.halt(true)
+      when STOP
+        server.stop(true)
+      when RESTART
+        server.pause(true)
+      end
+      throw :signal, signal
+    end
+
+    def run_restart_cmd(restart_cmd, server)
+      log "Restarting #{server.name} daemon..."
+      restart_cmd.run(server)
+    end
+
     def log(message)
       @logger.info "[Sanford] #{message}"
     end
 
-    def run_restart_cmd
-      log "Restarting #{@server.name} daemon..."
-      ENV['SANFORD_SERVER_FD'] = @server.file_descriptor.to_s
-      ENV['SANFORD_CLIENT_FDS'] = @server.client_file_descriptors.join(',')
-      ENV['SANFORD_SKIP_DAEMONIZE'] = 'yes'
-      @restart_cmd.run
+    def ignore_if_blank(value, &block)
+      block ||= proc{ |v| v }
+      block.call(value) if value && !value.empty?
     end
 
   end
@@ -84,9 +137,36 @@ module Sanford
       @argv = [Gem.ruby, $0, ARGV.dup].flatten
     end
 
-    def run
-      Dir.chdir self.dir
-      Kernel.exec(*self.argv)
+    if RUBY_VERSION == '1.8.7'
+
+      def run(server)
+        ENV['SANFORD_SERVER_FD']      = server.file_descriptor.to_s
+        ENV['SANFORD_CLIENT_FDS']     = server.client_file_descriptors.join(',')
+        ENV['SANFORD_SKIP_DAEMONIZE'] = 'yes'
+        Dir.chdir self.dir
+        Kernel.exec(*self.argv)
+      end
+
+    else
+
+      def run(server)
+        env = {
+          'SANFORD_SERVER_FD'      => server.file_descriptor.to_s,
+          'SANFORD_CLIENT_FDS'     => server.client_file_descriptors.join(','),
+          'SANFORD_SKIP_DAEMONIZE' => 'yes'
+        }
+        # in ruby 1.9+ the `Kernel.exec` method is passed file descriptor
+        # redirects, this makes it so the child process that we are running via
+        # the `exec` has access to the file descriptors and can open them
+        fd_redirects = (
+          [server.file_descriptor] +
+          server.client_file_descriptors
+        ).inject({}){ |h, fd| h.merge!(fd => fd) }
+        options = { :chdir => self.dir }.merge!(fd_redirects)
+
+        Kernel.exec(*([env] + self.argv + [options]))
+      end
+
     end
 
     private

data/lib/sanford/router.rb

@@ -24,6 +24,11 @@ module Sanford
       @routes.push(Sanford::Route.new(name, handler_name))
     end
 
+    def validate!
+      self.routes.each(&:validate!)
+      true
+    end
+
     def inspect
       reference = '0x0%x' % (self.object_id << 1)
       "#<#{self.class}:#{reference} " \

data/lib/sanford/server.rb

@@ -1,8 +1,5 @@
 require 'dat-tcp'
 require 'much-plugin'
-require 'ns-options'
-require 'ns-options/boolean'
-require 'pathname'
 require 'sanford-protocol'
 require 'socket'
 require 'sanford/logger'
@@ -23,11 +20,35 @@ module Sanford
 
     module InstanceMethods
 
-      attr_reader :server_data, :dat_tcp_server
+      attr_reader :server_data
 
       def initialize
-        self.class.configuration.validate!
-        @server_data = ServerData.new(self.class.configuration.to_hash)
+        config = self.class.config
+        begin
+          config.validate!
+        rescue InvalidError => exception
+          exception.set_backtrace(caller)
+          raise exception
+        end
+
+        @server_data = ServerData.new({
+          :name                => config.name,
+          :ip                  => config.ip,
+          :port                => config.port,
+          :pid_file            => config.pid_file,
+          :shutdown_timeout    => config.shutdown_timeout,
+          :worker_class        => config.worker_class,
+          :worker_params       => config.worker_params,
+          :num_workers         => config.num_workers,
+          :error_procs         => config.error_procs,
+          :template_source     => config.template_source,
+          :logger              => config.logger,
+          :router              => config.router,
+          :receives_keep_alive => config.receives_keep_alive,
+          :verbose_logging     => config.verbose_logging,
+          :routes              => config.routes
+        })
+
         @dat_tcp_server = DatTCP::Server.new(self.server_data.worker_class, {
           :num_workers      => self.server_data.num_workers,
           :logger           => self.server_data.dtcp_logger,
@@ -36,13 +57,6 @@ module Sanford
             :sanford_server_data => self.server_data
           })
         })
-      rescue InvalidError => exception
-        exception.set_backtrace(caller)
-        raise exception
-      end
-
-      def name
-        @server_data.name
       end
 
       def ip
@@ -61,6 +75,10 @@ module Sanford
         @dat_tcp_server.client_file_descriptors
       end
 
+      def name
+        @server_data.name
+      end
+
       def configured_ip
         @server_data.ip
       end
@@ -69,6 +87,10 @@ module Sanford
         @server_data.port
       end
 
+      def process_label
+        @server_data.process_label
+      end
+
       def pid_file
         @server_data.pid_file
       end
@@ -110,8 +132,16 @@ module Sanford
         @dat_tcp_server.halt(*args)
       end
 
+      def listening?
+        @dat_tcp_server.listening?
+      end
+
+      def running?
+        @dat_tcp_server.running?
+      end
+
       def paused?
-        @dat_tcp_server.listening? && !@dat_tcp_server.running?
+        self.listening? && !self.running?
       end
 
       private
@@ -128,149 +158,157 @@ module Sanford
 
     module ClassMethods
 
-      def configuration
-        @configuration ||= Configuration.new
+      def config
+        @config ||= Config.new
+      end
+
+      def name(value = nil)
+        self.config.name = value if !value.nil?
+        self.config.name
       end
 
-      def name(*args)
-        self.configuration.name *args
+      def ip(value = nil)
+        self.config.ip = value if !value.nil?
+        self.config.ip
       end
 
-      def ip(*args)
-        self.configuration.ip *args
+      def port(value = nil)
+        self.config.port = value if !value.nil?
+        self.config.port
       end
 
-      def port(*args)
-        self.configuration.port *args
+      def pid_file(value = nil)
+        self.config.pid_file = value if !value.nil?
+        self.config.pid_file
       end
 
-      def pid_file(*args)
-        self.configuration.pid_file *args
+      def shutdown_timeout(value = nil)
+        self.config.shutdown_timeout = value if !value.nil?
+        self.config.shutdown_timeout
       end
 
-      def worker_class(new_worker_class = nil)
-        self.configuration.worker_class = new_worker_class if new_worker_class
-        self.configuration.worker_class
+      def worker_class(value = nil)
+        self.config.worker_class = value if !value.nil?
+        self.config.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
+      def worker_params(value = nil)
+        self.config.worker_params = value if !value.nil?
+        self.config.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
+        self.config.num_workers = new_num_workers if new_num_workers
+        self.config.num_workers
       end
       alias :workers :num_workers
 
-      def receives_keep_alive(*args)
-        self.configuration.receives_keep_alive *args
+      def init(&block)
+        self.config.init_procs << block
       end
 
-      def verbose_logging(*args)
-        self.configuration.verbose_logging *args
+      def error(&block)
+        self.config.error_procs << block
       end
 
-      def logger(*args)
-        self.configuration.logger *args
+      def template_source(value = nil)
+        self.config.template_source = value if !value.nil?
+        self.config.template_source
       end
 
-      def shutdown_timeout(new_timeout = nil)
-        self.configuration.shutdown_timeout = new_timeout if new_timeout
-        self.configuration.shutdown_timeout
+      def logger(value = nil)
+        self.config.logger = value if !value.nil?
+        self.config.logger
       end
 
-      def init(&block)
-        self.configuration.init_procs << block
+      def router(value = nil, &block)
+        self.config.router = value if !value.nil?
+        self.config.router.instance_eval(&block) if block
+        self.config.router
       end
 
-      def error(&block)
-        self.configuration.error_procs << block
-      end
+      # flags
 
-      def router(value = nil, &block)
-        self.configuration.router = value if !value.nil?
-        self.configuration.router.instance_eval(&block) if block
-        self.configuration.router
+      def receives_keep_alive(value = nil)
+        self.config.receives_keep_alive = value if !value.nil?
+        self.config.receives_keep_alive
       end
 
-      def template_source(*args)
-        self.configuration.template_source(*args)
+      def verbose_logging(value = nil)
+        self.config.verbose_logging = value if !value.nil?
+        self.config.verbose_logging
       end
 
     end
 
-    class Configuration
-      include NsOptions::Proxy
-
-      DEFAULT_NUM_WORKERS = 4
+    class Config
 
-      option :name,     String,  :required => true
-      option :ip,       String,  :required => true, :default => '0.0.0.0'
-      option :port,     Integer, :required => true
-      option :pid_file, Pathname
+      DEFAULT_NUM_WORKERS = 4.freeze
+      DEFAULT_IP_ADDRESS  = '0.0.0.0'.freeze
 
-      option :receives_keep_alive, NsOptions::Boolean, :default => false
-
-      option :verbose_logging, :default => true
-      option :logger,          :default => proc{ NullLogger.new }
-      option :template_source, :default => proc{ NullTemplateSource.new }
-
-      attr_accessor :init_procs, :error_procs
+      attr_accessor :name, :ip, :port, :pid_file, :shutdown_timeout
       attr_accessor :worker_class, :worker_params, :num_workers
-      attr_accessor :shutdown_timeout
-      attr_accessor :router
+      attr_accessor :init_procs, :error_procs, :template_source, :logger, :router
+      attr_accessor :receives_keep_alive, :verbose_logging
 
-      def initialize(values = nil)
-        super(values)
-        @init_procs, @error_procs = [], []
+      def initialize
+        @name             = nil
+        @ip               = DEFAULT_IP_ADDRESS
+        @port             = nil
+        @pid_file         = nil
+        @shutdown_timeout = nil
         @worker_class     = DefaultWorker
         @worker_params    = nil
         @num_workers      = DEFAULT_NUM_WORKERS
-        @shutdown_timeout = nil
+        @init_procs       = []
+        @error_procs      = []
+        @template_source  = Sanford::NullTemplateSource.new(ENV['PWD'])
+        @logger           = Sanford::NullLogger.new
         @router           = Sanford::Router.new
-        @valid  = nil
+
+        @receives_keep_alive = false
+        @verbose_logging     = true
+
+        @valid = nil
       end
 
       def routes
-        @router.routes
-      end
-
-      def to_hash
-        super.merge({
-          :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
-        })
+        self.router.routes
       end
 
       def valid?
         !!@valid
       end
 
+      # for the config to be considered "valid", a few things need to happen.
+      # The key here is that this only needs to be done _once_ for each config.
+
       def validate!
-        return @valid if !@valid.nil?
+        return @valid if !@valid.nil? # only need to run this once per config
+
+        # ensure all user and plugin configs/settings are applied
         self.init_procs.each(&:call)
-        if !self.required_set?
-          raise InvalidError, "a name, ip and port must be configured"
+        [:name, :ip, :port].each do |a|
+          if self.send(a).nil?
+            raise InvalidError, "a name, ip and port must be configured"
+          end
         end
+
+        # validate the worker class
         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
+
+        # validate the router
+        self.router.validate!
+
+        @valid = true # if it made it this far, it's valid!
       end
+
     end
 
     DefaultWorker = Class.new{ include Sanford::Worker }
-
-    InvalidError = Class.new(RuntimeError)
+    InvalidError  = Class.new(RuntimeError)
 
   end