sanford 0.4.0 → 0.6.0

data/lib/sanford/error_handler.rb

@@ -9,6 +9,7 @@ module Sanford
 
     def initialize(exception, host_data = nil, request = nil)
       @exception, @host_data, @request = exception, host_data, request
+      @keep_alive = @host_data ? @host_data.keep_alive : false
       @error_proc = @host_data ? @host_data.error_proc : proc{ }
     end
 

data/lib/sanford/host.rb

@@ -1,7 +1,7 @@
 require 'ns-options'
 require 'pathname'
+require 'singleton'
 
-require 'sanford/exceptions'
 require 'sanford/logger'
 
 module Sanford
@@ -18,14 +18,15 @@ module Sanford
       # 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{ }
-      option :setup_proc,       Proc,     :default => proc{ }
+      option :name,                 String
+      option :ip,                   String,   :default => '0.0.0.0'
+      option :port,                 Integer
+      option :pid_file,             Pathname
+      option :logger,                         :default => proc{ Sanford.config.logger }
+      option :verbose_logging,                :default => true
+      option :receives_keep_alive,            :default => false
+      option :error_proc,           Proc,     :default => proc{ }
+      option :init_proc,            Proc,     :default => proc{ }
 
       def initialize(host)
         self.name = host.class.to_s
@@ -60,8 +61,8 @@ module Sanford
       self.configuration.port *args
     end
 
-    def pid_dir(*args)
-      self.configuration.pid_dir *args
+    def pid_file(*args)
+      self.configuration.pid_file *args
     end
 
     def logger(*args)
@@ -72,12 +73,16 @@ module Sanford
       self.configuration.verbose_logging *args
     end
 
+    def receives_keep_alive(*args)
+      self.configuration.receives_keep_alive *args
+    end
+
     def error(&block)
       self.configuration.error_proc = block
     end
 
-    def setup(&block)
-      self.configuration.setup_proc = block
+    def init(&block)
+      self.configuration.init_proc = block
     end
 
     def version(name, &block)

data/lib/sanford/host_data.rb

@@ -1,4 +1,3 @@
-require 'sanford/exceptions'
 require 'sanford/service_handler'
 
 module Sanford
@@ -10,27 +9,23 @@ module Sanford
     # 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
+    # NOTE: The `name` attribute shouldn't be removed, it is used to identify
+    # a `HostData`, particularly in error handlers
+    attr_reader :name, :logger, :verbose, :keep_alive, :error_proc
 
     def initialize(service_host, options = nil)
-      configuration = service_host.configuration.to_hash.merge(remove_nil_values(options || {}))
+      service_host.configuration.init_proc.call
 
-      @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]
-      @setup_proc         = configuration[:setup_proc]
+      overrides = self.remove_nil_values(options || {})
+      configuration = service_host.configuration.to_hash.merge(overrides)
 
-      @versioned_services = service_host.versioned_services
-      @handlers = {}
+      @name       = configuration[:name]
+      @logger     = configuration[:logger]
+      @verbose    = configuration[:verbose_logging]
+      @keep_alive = configuration[:receives_keep_alive]
+      @error_proc = configuration[:error_proc]
 
-      raise Sanford::InvalidHostError.new(service_host) if !self.port
-    end
-
-    def setup
-      @setup_proc.call
-      @handlers = @versioned_services.inject({}) do |hash, (version, services)|
+      @handlers = service_host.versioned_services.inject({}) do |hash, (version, services)|
         hash.merge({ version => self.constantize_services(services) })
       end
     end
@@ -59,4 +54,13 @@ module Sanford
 
   end
 
+  NotFoundError = Class.new(RuntimeError)
+
+  class NoHandlerClassError < RuntimeError
+    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/runner.rb

@@ -1,8 +1,6 @@
 require 'ostruct'
 require 'sanford-protocol'
 
-require 'sanford/logger'
-
 module Sanford
 
   class Runner
@@ -11,9 +9,14 @@ module Sanford
 
     attr_reader :handler_class, :request, :logger
 
+    def self.run(handler_class, params = nil, logger = nil)
+      request = Sanford::Protocol::Request.new('version', 'name', params || {})
+      self.new(handler_class, request, logger).run
+    end
+
     def initialize(handler_class, request, logger = nil)
       @handler_class, @request = handler_class, request
-      @logger = logger || Sanford::NullLogger.new
+      @logger = logger || Sanford.config.logger
       @handler = @handler_class.new(self)
     end
 

data/lib/sanford/server.rb

@@ -1,4 +1,5 @@
 require 'dat-tcp'
+require 'ostruct'
 require 'sanford-protocol'
 
 require 'sanford/host_data'
@@ -8,28 +9,47 @@ module Sanford
 
   class Server
     include DatTCP::Server
+    attr_reader :sanford_host, :sanford_host_data, :sanford_host_options
+
+    def initialize(host, options = nil)
+      options ||= {}
+      @sanford_host = host
+      @sanford_host_options = {
+        :receives_keep_alive => options.delete(:keep_alive),
+        :verbose_logging     => options.delete(:verbose)
+      }
+      super options
+    end
 
-    attr_reader :host_data
-
-    def initialize(host, options = {})
-      @host_data = host.kind_of?(Sanford::HostData) ? host : Sanford::HostData.new(host)
-      @host_data.setup
-      super(@host_data.ip, @host_data.port, options)
+    # 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
 
-    def name
-      @host_data.name
+    def on_run
+      @sanford_host_data = Sanford::HostData.new(@sanford_host, @sanford_host_options)
     end
 
     # `serve` can be called at the same time by multiple threads. Thus we create
     # a new instance of the handler for every request.
+    # When using TCP_CORK, you "cork" the socket, handle it and then "uncork"
+    # it, see the `TCPCork` module for more info.
     def serve(socket)
-      Sanford::Worker.new(@host_data, Connection.new(socket)).run
+      TCPCork.apply(socket)
+      connection = Connection.new(socket)
+      if !self.keep_alive_connection?(connection)
+        Sanford::Worker.new(@sanford_host_data, connection).run
+      end
+      TCPCork.remove(socket)
     end
 
-    def inspect
-      reference = '0x0%x' % (self.object_id << 1)
-      "#<#{self.class}:#{reference} @service_host=#{@host_data.inspect}>"
+    protected
+
+    def keep_alive_connection?(connection)
+      @sanford_host_data.keep_alive && connection.peek_data.empty?
     end
 
     class Connection
@@ -49,6 +69,38 @@ module Sanford
         @connection.write data
       end
 
+      def peek_data
+        @connection.peek(@timeout)
+      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 it's 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
 
   end

data/lib/sanford/service_handler.rb

@@ -1,4 +1,5 @@
 require 'sanford-protocol'
+require 'sanford/runner'
 
 module Sanford
 
@@ -14,6 +15,12 @@ module Sanford
       false
     end
 
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+      end
+    end
+
     def initialize(runner)
       @sanford_runner = runner
     end
@@ -59,6 +66,10 @@ module Sanford
 
     # Helpers
 
+    def run_handler(handler_class, params = nil)
+      handler_class.run(params || {}, self.logger)
+    end
+
     def halt(*args)
       @sanford_runner.halt(*args)
     end
@@ -79,6 +90,14 @@ module Sanford
       self.send(callback.to_s)
     end
 
+    module ClassMethods
+
+      def run(params = nil, logger = nil)
+        Sanford::Runner.run(self, params || {}, logger)
+      end
+
+    end
+
   end
 
 end

data/lib/sanford/test_runner.rb

@@ -1,6 +1,5 @@
 require 'sanford-protocol'
 
-require 'sanford/logger'
 require 'sanford/runner'
 
 module Sanford
@@ -11,9 +10,9 @@ module Sanford
     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_class = handler_class
+      @request       = params.kind_of?(Sanford::Protocol::Request) ? params : test_request(params)
+      @logger        = logger || Sanford.config.logger
 
       @handler  = @handler_class.new(self)
       @response = build_response catch(:halt){ @handler.init; nil }

data/lib/sanford/version.rb

@@ -1,3 +1,3 @@
 module Sanford
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/sanford/worker.rb

@@ -77,7 +77,7 @@ module Sanford
     end
 
     def log_received
-      self.logger.verbose.info("Received request")
+      self.logger.verbose.info("===== Received request =====")
     end
 
     def log_request(request)
@@ -91,8 +91,8 @@ module Sanford
     end
 
     def log_complete(processed_service)
-      self.logger.verbose.info "Completed in #{processed_service.time_taken}ms " \
-        "#{processed_service.response.status}\n"
+      self.logger.verbose.info "===== Completed in #{processed_service.time_taken}ms " \
+        "#{processed_service.response.status} ====="
       self.logger.summary.info self.summary_line(processed_service).to_s
     end
 
@@ -109,7 +109,7 @@ module Sanford
           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 'status',    processed_service.response.code if processed_service.response
         line.add 'duration',  processed_service.time_taken
       end
     end
@@ -130,8 +130,6 @@ module Sanford
         @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]

data/sanford.gemspec

@@ -17,8 +17,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency("daemons",           ["~>1.1"])
-  gem.add_dependency("dat-tcp",           ["~>0.1"])
+  gem.add_dependency("dat-tcp",           ["~>0.2"])
   gem.add_dependency("ns-options",        ["~>1.0"])
   gem.add_dependency("sanford-protocol",  ["~>0.5"])
 

data/test/support/fake_connection.rb

@@ -7,9 +7,18 @@ class FakeConnection
     self.new(request.to_hash, raise_on_write)
   end
 
-  def initialize(read_data, raise_on_write = false)
-    @raise_on_write = raise_on_write
-    @read_data = read_data
+  def initialize(*args)
+    if args.first.kind_of?(Sanford::Protocol::Connection)
+      protocol_connection = args.first
+      @read_data = proc{ protocol_connection.read }
+      @write_data = proc{|data| protocol_connection.write(data) }
+    else
+      @read_data, @raise_on_write = args
+    end
+  end
+
+  def read_data
+    @read_data.kind_of?(Proc) ? @read_data.call : @read_data
   end
 
   def write_data(data)

data/test/support/helpers.rb

@@ -1,50 +1,31 @@
 module Test
 
-  module Environment
-
-    def self.store_and_clear_hosts
-      @previous_hosts = Sanford.hosts.instance_variable_get("@set").dup
-      Sanford.hosts.clear
-    end
-
-    def self.restore_hosts
-      Sanford.instance_variable_set("@hosts", Sanford::Hosts.new(@previous_hosts))
-      @previous_hosts = nil
-    end
-
-  end
-
   module ForkServerHelper
 
-    def start_server(server, &block)
+    def start_server(host, &block)
       begin
-        pid = fork do
-          trap("TERM"){ server.stop }
-          server.start
-          server.join_thread
-        end
-        sleep 0.3 # Give time for the socket to start listening.
+        server = Sanford::Server.new(host, { :ready_timeout => 0.1 })
+        server.listen(host.ip, host.port)
+        thread = server.run
         yield
       ensure
-        if pid
-          Process.kill("TERM", pid)
-          Process.wait(pid)
-        end
+        server.halt if server
+        thread.join if thread
       end
     end
 
   end
 
-  module ForkManagerHelper
+  module ManagerHelper
 
     # start a Sanford server using Sanford's manager in a forked process
-    def call_sanford_manager(*args, &block)
+    def fork_and_call(proc, &block)
       pid = fork do
         STDOUT.reopen('/dev/null') unless ENV['SANFORD_DEBUG']
-        trap("TERM"){ exit }
-        Sanford::Manager.call(*args)
+        manager = proc.call
+        trap("TERM"){ manager.stop }
       end
-      sleep 1.5 # give time for the command to run
+      sleep 0.3 # give time for the command to run
       yield
     ensure
       if pid
@@ -59,10 +40,6 @@ module Test
       socket.close rescue false
     end
 
-    def expected_pid_file(host, ip, port)
-      host.pid_dir.join("#{ip}_#{port}_#{host}.pid")
-    end
-
   end
 
 end