sanford 0.15.1 → 0.16.0

data/lib/sanford/service_handler.rb

@@ -1,12 +1,13 @@
+require 'much-plugin'
+
 module Sanford
 
   module ServiceHandler
+    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
@@ -15,24 +16,29 @@ module Sanford
         @sanford_runner = runner
       end
 
-      def init
-        run_callback 'before_init'
+      def sanford_init
+        self.sanford_run_callback 'before_init'
         self.init!
-        run_callback 'after_init'
+        self.sanford_run_callback 'after_init'
       end
 
       def init!
       end
 
-      def run
-        run_callback 'before_run'
+      def sanford_run
+        self.sanford_run_callback 'before_run'
         data = self.run!
-        run_callback 'after_run'
-        [ 200, data ]
+        self.sanford_run_callback 'after_run'
+        [200, data]
       end
 
       def run!
-        raise NotImplementedError
+      end
+
+      def sanford_run_callback(callback)
+        (self.class.send("#{callback}_callbacks") || []).each do |callback|
+          self.instance_eval(&callback)
+        end
       end
 
       def inspect
@@ -40,21 +46,26 @@ module Sanford
         "#<#{self.class}:#{reference} @request=#{request.inspect}>"
       end
 
+      def ==(other_handler)
+        self.class == other_handler.class
+      end
+
       private
 
       # Helpers
 
-      def render(*args); @sanford_runner.render(*args); end
-      def halt(*args);   @sanford_runner.halt(*args);   end
-      def request;       @sanford_runner.request;       end
-      def params;        @sanford_runner.params;        end
-      def logger;        @sanford_runner.logger;        end
+      # utils
+      def logger; @sanford_runner.logger; end
 
-      def run_callback(callback)
-        (self.class.send("#{callback}_callbacks") || []).each do |callback|
-          self.instance_eval(&callback)
-        end
-      end
+      # request
+      def request; @sanford_runner.request; end
+      def params;  @sanford_runner.params;  end
+
+      # response
+      def status(*args); @sanford_runner.status(*args); end
+      def data(*args);   @sanford_runner.data(*args);   end
+      def halt(*args);   @sanford_runner.halt(*args);   end
+      def render(*args); @sanford_runner.render(*args); end
 
     end
 
@@ -83,6 +94,22 @@ module Sanford
 
     end
 
+    module TestHelpers
+
+      def self.included(klass)
+        require 'sanford/test_runner'
+      end
+
+      def test_runner(handler_class, args = nil)
+        TestRunner.new(handler_class, args)
+      end
+
+      def test_handler(handler_class, args = nil)
+        test_runner(handler_class, args).handler
+      end
+
+    end
+
   end
 
 end

data/lib/sanford/test_runner.rb

@@ -8,53 +8,57 @@ module Sanford
 
   class TestRunner < Runner
 
-    attr_reader :response
-
     def initialize(handler_class, args = nil)
       if !handler_class.include?(Sanford::ServiceHandler)
-        raise InvalidServiceHandlerError, "#{handler_class.inspect} is not a"\
-                                          " Sanford::ServiceHandler"
+        raise InvalidServiceHandlerError, "#{handler_class.inspect} is not a " \
+                                          "Sanford::ServiceHandler"
       end
 
-      args = (args || {}).dup
+      a = (args || {}).dup
       super(handler_class, {
-        :request         => args.delete(:request),
-        :params          => normalize_params(args.delete(:params) || {}),
-        :logger          => args.delete(:logger),
-        :router          => args.delete(:router),
-        :template_source => args.delete(:template_source)
+        :logger          => a.delete(:logger),
+        :router          => a.delete(:router),
+        :template_source => a.delete(:template_source),
+        :request         => a.delete(:request),
+        :params          => normalize_params(a.delete(:params) || {})
       })
-      args.each{ |key, value| @handler.send("#{key}=", value) }
+      a.each{ |key, value| @handler.send("#{key}=", value) }
 
-      return_value = catch(:halt){ @handler.init; nil }
-      @response = build_and_serialize_response{ return_value } if return_value
+      @halted = false
+      catch(:halt){ self.handler.sanford_init }
     end
 
-    # If `init` generated a response, we don't want to `run` at all. This makes
-    # the `TestRunner` behave similar to the `SanfordRunner`, i.e. `halt` in
-    # `init` stops processing where `halt` is called.
+    def halted?; @halted; end
 
     def run
-      @response ||= build_and_serialize_response{ self.handler.run }
+      catch(:halt){ self.handler.sanford_run } if !self.halted?
+      self.to_response
+    end
+
+    # attempt to encode (and then throw away) the response
+    # this will error on the developer if it can't encode their response
+    def to_response
+      super.tap do |response|
+        Sanford::Protocol.msg_body.encode(response.to_hash) if response
+      end
+    end
+
+    # helpers
+
+    def halt(*args)
+      @halted = true
+      super
     end
 
     private
 
-    # Stringify and encode/decode to ensure params are valid and are
+    # stringify and encode/decode to ensure params are valid and are
     # in the format they would normally be when a handler is built and run.
     def normalize_params(params)
       p = Sanford::Protocol::StringifyParams.new(params)
       Sanford::Protocol.msg_body.decode(Sanford::Protocol.msg_body.encode(p))
     end
 
-    def build_and_serialize_response(&block)
-      build_response(&block).tap do |response|
-        # attempt to serialize (and then throw away) the response data
-        # this will error on the developer if it can't serialize their response
-        Sanford::Protocol.msg_body.encode(response.to_hash) if response
-      end
-    end
-
   end
 
 end

data/lib/sanford/version.rb

@@ -1,3 +1,3 @@
 module Sanford
-  VERSION = "0.15.1"
+  VERSION = "0.16.0"
 end

data/lib/sanford/worker.rb

@@ -0,0 +1,106 @@
+require 'much-plugin'
+require 'dat-tcp/worker'
+require 'sanford/connection_handler'
+require 'sanford/server_data'
+
+module Sanford
+
+  module Worker
+    include MuchPlugin
+
+    plugin_included do
+      include DatTCP::Worker
+      include InstanceMethods
+
+    end
+
+    module InstanceMethods
+
+      def work!(client_socket)
+        connection = Connection.new(client_socket)
+        return if sanford_keep_alive_connection?(connection)
+        Sanford::ConnectionHandler.new(params[:sanford_server_data], connection).run
+      ensure
+        connection.close rescue false
+      end
+
+      private
+
+      def sanford_keep_alive_connection?(connection)
+        params[:sanford_server_data].receives_keep_alive && connection.peek_data.empty?
+      end
+
+    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 write_data(data)
+        TCPCork.apply(@socket)
+        @connection.write data
+        TCPCork.remove(@socket)
+      end
+
+      def read_data;   @connection.read(@timeout); end
+      def peek_data;   @connection.peek(@timeout); end
+      def close;       @connection.close;          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
+
+    module TestHelpers
+      include MuchPlugin
+
+      plugin_included do
+        include DatTCP::Worker::TestHelpers
+        include InstanceMethods
+      end
+
+      module InstanceMethods
+
+        def test_runner(worker_class, options = nil)
+          options ||= {}
+          options[:params] = {
+            :sanford_server_data => Sanford::ServerData.new,
+          }.merge(options[:params] || {})
+          super(worker_class, options)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/sanford.gemspec

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

data/test/support/app_server.rb

@@ -6,6 +6,9 @@ if !defined?(ROOT_PATH)
   ROOT_PATH = Pathname.new(File.expand_path('../../..', __FILE__))
 end
 
+LOGGER = Logger.new(ROOT_PATH.join('log/app_server.log').to_s)
+LOGGER.datetime_format = "" # turn off the datetime in the logs
+
 class AppERBEngine < Sanford::TemplateEngine
   RenderScope = Struct.new(:view)
 
@@ -26,7 +29,7 @@ class AppServer
 
   receives_keep_alive true
 
-  logger Logger.new(ROOT_PATH.join('log/app_server.log').to_s)
+  logger LOGGER
   verbose_logging true
 
   router do
@@ -62,7 +65,7 @@ module AppHandlers
     include Sanford::ServiceHandler
 
     def run!
-      params['message']
+      data(params['message'])
     end
   end
 
@@ -78,7 +81,7 @@ module AppHandlers
     include Sanford::ServiceHandler
 
     def run!
-      Class.new
+      data(Class.new)
     end
   end
 
@@ -121,7 +124,7 @@ module AppHandlers
 
     def run!
       halt(200, :message => "in run") if params['when'] == 'run'
-      false
+      data(false)
     end
 
     after_run do

data/test/system/server_tests.rb

@@ -284,7 +284,7 @@ module Sanford::Server
 
       assert_equal 200, subject.code
       assert_equal 'in after run', subject.status.message
-      assert_nil subject.data
+      assert_false subject.data
     end
 
     should "allow halting in an after callback" do
@@ -293,7 +293,7 @@ module Sanford::Server
 
       assert_equal 200, subject.code
       assert_equal 'in after', subject.status.message
-      assert_nil subject.data
+      assert_false subject.data
     end
 
   end
@@ -320,7 +320,11 @@ module Sanford::Server
     setup do
       # get our current ip address, need something different than 0.0.0.0 and
       # 127.0.0.1 to bind to
-      ENV['SANFORD_IP']   = IPSocket.getaddress(Socket.gethostname)
+      ENV['SANFORD_IP'] = Socket.getaddrinfo(
+        Socket.gethostname,
+        80,
+        Socket::AF_INET
+      ).first[3]
       ENV['SANFORD_PORT'] = (AppServer.port + 1).to_s
 
       @server = AppServer.new

data/test/system/service_handler_tests.rb

@@ -1,13 +1,12 @@
 require 'assert'
 require 'sanford/service_handler'
 
-require 'sanford/test_helpers'
 require 'test/support/app_server'
 
 module Sanford::ServiceHandler
 
   class SystemTests < Assert::Context
-    include Sanford::TestHelpers
+    include Sanford::ServiceHandler::TestHelpers
 
     desc "Sanford::ServiceHandler"
 

data/test/unit/connection_handler_tests.rb

@@ -142,22 +142,6 @@ class Sanford::ConnectionHandler
 
   end
 
-  class RunWithExceptionWhileDebuggingTests < InitTests
-    desc "and run with a route that throws an exception in debug mode"
-    setup do
-      ENV['SANFORD_DEBUG'] = '1'
-      Assert.stub(@route, :run){ raise @exception }
-    end
-    teardown do
-      ENV.delete('SANFORD_DEBUG')
-    end
-
-    should "raise the exception" do
-      assert_raises(@exception.class){ @connection_handler.run }
-    end
-
-  end
-
   class RunWithVerboseLoggingTests < UnitTests
     desc "run with verbose logging"
     setup do

data/test/unit/runner_tests.rb

@@ -1,6 +1,7 @@
 require 'assert'
 require 'sanford/runner'
 
+require 'sanford-protocol'
 require 'sanford/logger'
 require 'sanford/router'
 require 'sanford/template_source'
@@ -12,23 +13,35 @@ class Sanford::Runner
     desc "Sanford::Runner"
     setup do
       @handler_class = TestServiceHandler
-      @runner_class = Sanford::Runner
+      @runner_class  = Sanford::Runner
     end
     subject{ @runner_class }
 
+    should "know its default status code " do
+      assert_equal 200, subject::DEFAULT_STATUS_CODE
+    end
+
+    should "know its default status msg " do
+      assert_equal nil, subject::DEFAULT_STATUS_MSG
+    end
+
+    should "know its default data" do
+      assert_equal nil, subject::DEFAULT_DATA
+    end
+
   end
 
   class InitTests < UnitTests
     desc "when init"
     setup do
-      source = FakeTemplateSource.new
-      @runner = @runner_class.new(@handler_class, :template_source => source)
+      @runner = @runner_class.new(@handler_class)
     end
     subject{ @runner }
 
     should have_readers :handler_class, :handler
-    should have_readers :request, :params, :logger, :router, :template_source
-    should have_imeths :run
+    should have_readers :logger, :router, :template_source
+    should have_readers :request, :params
+    should have_imeths :run, :to_response
     should have_imeths :halt
 
     should "know its handler class and handler" do
@@ -36,68 +49,166 @@ class Sanford::Runner
       assert_instance_of @handler_class, subject.handler
     end
 
-    should "default its settings" do
+    should "default its attrs" do
       runner = @runner_class.new(@handler_class)
-      assert_nil runner.request
-      assert_equal ::Hash.new, runner.params
       assert_kind_of Sanford::NullLogger, runner.logger
       assert_kind_of Sanford::Router, runner.router
       assert_kind_of Sanford::NullTemplateSource, runner.template_source
+
+      assert_nil runner.request
+
+      assert_equal({}, subject.params)
+    end
+
+    should "know its attrs" do
+      args = {
+        :logger          => 'a-logger',
+        :router          => 'a-router',
+        :template_source => 'a-source',
+        :request         => 'a-request',
+        :params          => {}
+      }
+
+      runner = @runner_class.new(@handler_class, args)
+
+      assert_equal args[:logger],          runner.logger
+      assert_equal args[:router],          runner.router
+      assert_equal args[:template_source], runner.template_source
+      assert_equal args[:request],         runner.request
+      assert_equal args[:params],          runner.params
     end
 
     should "not implement its run method" do
       assert_raises(NotImplementedError){ subject.run }
     end
 
-    should "use the template source to render" do
-      path = 'template.json'
-      locals = { 'something' => Factory.string }
-      exp = subject.template_source.render(path, subject.handler, locals)
-      assert_equal exp, subject.render(path, locals)
+    should "know its `to_response` representation" do
+      exp = Sanford::Protocol::Response.new(
+        [subject.class::DEFAULT_STATUS_CODE, subject.class::DEFAULT_STATUS_MSG],
+        subject.class::DEFAULT_DATA
+      )
+      assert_equal exp, subject.to_response
+
+      code, msg, data = Factory.integer, Factory.string, Factory.text
+      subject.status(code, :message => msg)
+      subject.data(data)
+      exp = Sanford::Protocol::Response.new([code, msg], data)
+      assert_equal exp, subject.to_response
     end
 
-    should "default its locals to an empty hash when rendering" do
-      path = Factory.file_path
-      exp = subject.template_source.render(path, subject.handler, {})
-      assert_equal exp, subject.render(path)
+    should "know and set its response status" do
+      assert_equal [nil, nil], subject.status
+
+      code, msg = Factory.integer, Factory.string
+      subject.status(code, :message => msg)
+      assert_equal [code, msg], subject.status
     end
 
-    should "throw halt with response args using `halt`" do
-      code = Factory.integer
-      message = Factory.string
-      data = Factory.string
+    should "know and set its response data" do
+      assert_nil subject.data
 
-      result = catch(:halt) do
-        subject.halt(code, :message => message, :data => data)
-      end
-      assert_instance_of ResponseArgs, result
-      assert_equal [ code, message ], result.status
-      assert_equal data, result.data
+      exp = Factory.text
+      subject.data exp
+      assert_equal exp, subject.data
+    end
+
+  end
+
+  class HaltTests < InitTests
+    desc "the `halt` method"
+    setup do
+      @code    = Factory.integer
+      @message = Factory.string
+      @data    = Factory.string
+    end
+
+    should "set response attrs and halt execution" do
+      runner = runner_halted_with()
+      assert_nil runner.status.first
+      assert_nil runner.status.last
+      assert_nil runner.data
+
+      runner = runner_halted_with(@code)
+      assert_equal @code, runner.status.first
+      assert_nil runner.status.last
+      assert_nil runner.data
+
+      runner = runner_halted_with(:message => @message)
+      assert_nil runner.status.first
+      assert_equal @message, runner.status.last
+      assert_nil runner.data
+
+      runner = runner_halted_with(:data => @data)
+      assert_nil runner.status.first
+      assert_nil runner.status.last
+      assert_equal @data, runner.data
+
+      runner = runner_halted_with(@code, :message => @message)
+      assert_equal @code,    runner.status.first
+      assert_equal @message, runner.status.last
+      assert_nil runner.data
+
+      runner = runner_halted_with(@code, :data => @data)
+      assert_equal @code, runner.status.first
+      assert_nil runner.status.last
+      assert_equal @data, runner.data
+
+      runner = runner_halted_with({
+        :message => @message,
+        :data => @data
+      })
+      assert_nil runner.status.first
+      assert_equal @message, runner.status.last
+      assert_equal @data,    runner.data
+
+      runner = runner_halted_with(@code, {
+        :message => @message,
+        :data => @data
+      })
+      assert_equal @code,    runner.status.first
+      assert_equal @message, runner.status.last
+      assert_equal @data,    runner.data
     end
 
-    should "accept string keys using `halt`" do
-      code = Factory.integer
-      message = Factory.string
-      data = Factory.string
+    private
 
-      result = catch(:halt) do
-        subject.halt(code, 'message' => message, 'data' => data)
+    def runner_halted_with(*halt_args)
+      @runner_class.new(@handler_class).tap do |runner|
+        catch(:halt){ runner.halt(*halt_args) }
       end
-      assert_instance_of ResponseArgs, result
-      assert_equal [ code, message ], result.status
-      assert_equal data, result.data
+    end
+
+  end
+
+  class RenderTests < InitTests
+    desc "the `render` method"
+    setup do
+      @template_name = Factory.path
+      @locals = { Factory.string => Factory.string }
+      data = @data = Factory.text
+      @render_called_with = nil
+      @source = @runner.template_source
+      Assert.stub(@source, :render){ |*args| @render_called_with = args; data }
+    end
+
+    should "call to the template source's render method and set the return value as data" do
+      subject.render(@template_name, @locals)
+      exp = [@template_name, subject.handler, @locals]
+      assert_equal exp,   @render_called_with
+      assert_equal @data, subject.data
+    end
+
+    should "default the locals if none given" do
+      subject.render(@template_name)
+      exp = [@template_name, subject.handler, {}]
+      assert_equal exp, @render_called_with
     end
 
   end
 
   class TestServiceHandler
     include Sanford::ServiceHandler
-  end
 
-  class FakeTemplateSource
-    def render(path, service_handler, locals)
-      [path.to_s, service_handler.class.to_s, locals]
-    end
   end
 
 end