sanford 0.6.0 → 0.6.1

data/Rakefile

@@ -1,6 +1,3 @@
 require "bundler/gem_tasks"
 
 require 'bench/tasks'
-
-require "assert/rake_tasks"
-Assert::RakeTasks.install

data/lib/sanford/host.rb

@@ -25,6 +25,7 @@ module Sanford
       option :logger,                         :default => proc{ Sanford.config.logger }
       option :verbose_logging,                :default => true
       option :receives_keep_alive,            :default => false
+      option :runner,                         :default => proc{ Sanford.config.runner }
       option :error_proc,           Proc,     :default => proc{ }
       option :init_proc,            Proc,     :default => proc{ }
 
@@ -77,6 +78,10 @@ module Sanford
       self.configuration.receives_keep_alive *args
     end
 
+    def runner(*args)
+      self.configuration.runner *args
+    end
+
     def error(&block)
       self.configuration.error_proc = block
     end

data/lib/sanford/host_data.rb

@@ -11,7 +11,7 @@ module Sanford
 
     # 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
+    attr_reader :name, :logger, :verbose, :keep_alive, :runner, :error_proc
 
     def initialize(service_host, options = nil)
       service_host.configuration.init_proc.call
@@ -23,6 +23,7 @@ module Sanford
       @logger     = configuration[:logger]
       @verbose    = configuration[:verbose_logging]
       @keep_alive = configuration[:receives_keep_alive]
+      @runner     = configuration[:runner]
       @error_proc = configuration[:error_proc]
 
       @handlers = service_host.versioned_services.inject({}) do |hash, (version, services)|
@@ -30,6 +31,10 @@ module Sanford
       end
     end
 
+    def run(handler_class, request)
+      self.runner.new(handler_class, request, self.logger).run
+    end
+
     def handler_class_for(version, service)
       version_group = @handlers[version] || {}
       version_group[service] || raise(Sanford::NotFoundError)

data/lib/sanford/runner.rb

@@ -3,50 +3,72 @@ require 'sanford-protocol'
 
 module Sanford
 
-  class Runner
+  module Runner
 
     ResponseArgs = Struct.new(:status, :data)
 
     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
+    def self.included(klass)
+      klass.class_eval{ extend ClassMethods }
     end
 
     def initialize(handler_class, request, logger = nil)
       @handler_class, @request = handler_class, request
       @logger = logger || Sanford.config.logger
       @handler = @handler_class.new(self)
+      self.init
+    end
+
+    def init
+      self.init!
+    end
+
+    def init!
     end
 
     def run
-      response_args = catch_halt do
-        @handler.init
-        @handler.run
-      end
+      response_args = catch_halt{ self.run!(@handler) }
       Sanford::Protocol::Response.new(response_args.status, response_args.data)
     end
 
-    module HaltMethods
+    def run!
+      raise NotImplementedError
+    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.
+    # 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 = OpenStruct.new(options || {})
-        response_status = [ status, options.message ]
-        throw :halt, ResponseArgs.new(response_status, options.data)
-      end
+    def halt(status, options = nil)
+      options = OpenStruct.new(options || {})
+      response_status = [ status, options.message ]
+      throw :halt, ResponseArgs.new(response_status, options.data)
+    end
 
-      def catch_halt(&block)
-        catch(:halt){ ResponseArgs.new(*block.call) }
+    def catch_halt(&block)
+      catch(:halt){ ResponseArgs.new(*block.call) }
+    end
+
+    module ClassMethods
+
+      def run(handler_class, params = nil, logger = nil)
+        request = Sanford::Protocol::Request.new('version', 'name', params || {})
+        self.new(handler_class, request, logger).run
       end
 
     end
-    include HaltMethods
+
+  end
+
+  class DefaultRunner
+    include Sanford::Runner
+
+    def run!(handler)
+      handler.init
+      handler.run
+    end
 
   end
 

data/lib/sanford/service_handler.rb

@@ -93,7 +93,7 @@ module Sanford
     module ClassMethods
 
       def run(params = nil, logger = nil)
-        Sanford::Runner.run(self, params || {}, logger)
+        Sanford.config.runner.run(self, params || {}, logger)
       end
 
     end

data/lib/sanford/test_runner.rb

@@ -5,19 +5,20 @@ require 'sanford/runner'
 module Sanford
 
   class TestRunner
-    include Sanford::Runner::HaltMethods
+    include Sanford::Runner
 
-    attr_reader :handler, :response, :request, :logger
+    attr_reader :handler, :response
 
-    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.config.logger
-
-      @handler  = @handler_class.new(self)
+    def init!
+      if !@request.kind_of?(Sanford::Protocol::Request)
+        @request = test_request(@request)
+      end
       @response = build_response catch(:halt){ @handler.init; nil }
     end
 
+    # we override the `run` method because the TestRunner wants to control
+    # storing any generated response. If `init` generated a response, we don't
+    # want to `run` at all.
     def run
       @response ||= build_response catch_halt{ @handler.run }
     end
@@ -25,7 +26,7 @@ module Sanford
     protected
 
     def test_request(params)
-      Sanford::Protocol::Request.new('test_version', 'test_service', params)
+      Sanford::Protocol::Request.new('version', 'name', params)
     end
 
     def build_response(response_args)
@@ -35,8 +36,8 @@ module Sanford
     module Helpers
       module_function
 
-      def test_runner(*args)
-        TestRunner.new(*args)
+      def test_runner(handler_class, params = nil, logger = nil)
+        TestRunner.new(handler_class, params || {}, logger)
       end
 
     end

data/lib/sanford/version.rb

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

data/lib/sanford/worker.rb

@@ -44,7 +44,7 @@ module Sanford
         self.log_handler_class(handler_class)
         service.handler_class = handler_class
 
-        response = Sanford::Runner.new(handler_class, request, @host_data.logger).run
+        response = @host_data.run(handler_class, request)
         service.response = response
       rescue Exception => exception
         self.handle_exception(service, exception, @host_data)

data/lib/sanford.rb

@@ -6,6 +6,7 @@ require 'set'
 
 require 'sanford/host'
 require 'sanford/logger'
+require 'sanford/runner'
 require 'sanford/server'
 require 'sanford/service_handler'
 require 'sanford/version'
@@ -40,6 +41,7 @@ module Sanford
     include NsOptions::Proxy
     option :services_file,  Pathname, :default => ENV['SANFORD_SERVICES_FILE']
     option :logger,                   :default => Sanford::NullLogger.new
+    option :runner,                   :default => Sanford::DefaultRunner
   end
 
   class Hosts

data/sanford.gemspec

@@ -21,6 +21,6 @@ Gem::Specification.new do |gem|
   gem.add_dependency("ns-options",        ["~>1.0"])
   gem.add_dependency("sanford-protocol",  ["~>0.5"])
 
-  gem.add_development_dependency("assert",        ["~>1.0"])
+  gem.add_development_dependency("assert",        ["~>2.0"])
   gem.add_development_dependency("assert-mocha",  ["~>1.0"])
 end

data/test/support/helpers.rb

@@ -1,6 +1,6 @@
 module Test
 
-  module ForkServerHelper
+  module SpawnServerHelper
 
     def start_server(host, &block)
       begin
@@ -16,30 +16,4 @@ module Test
 
   end
 
-  module ManagerHelper
-
-    # start a Sanford server using Sanford's manager in a forked process
-    def fork_and_call(proc, &block)
-      pid = fork do
-        STDOUT.reopen('/dev/null') unless ENV['SANFORD_DEBUG']
-        manager = proc.call
-        trap("TERM"){ manager.stop }
-      end
-      sleep 0.3 # give time for the command to run
-      yield
-    ensure
-      if pid
-        Process.kill("TERM", pid)
-        Process.wait(pid)
-      end
-    end
-
-    def open_socket(host, port)
-      socket = TCPSocket.new(host, port)
-    ensure
-      socket.close rescue false
-    end
-
-  end
-
 end

data/test/system/request_handling_test.rb

@@ -233,7 +233,7 @@ class RequestHandlingTest < Assert::Context
   end
 
   class ForkedServerTest < RequestHandlingTest
-    include Test::ForkServerHelper
+    include Test::SpawnServerHelper
   end
 
   # Simple service test that echos back the params sent to it

data/test/unit/host_data_test.rb

@@ -13,8 +13,8 @@ class Sanford::HostData
     end
     subject{ @host_data }
 
-    should have_instance_methods :name, :logger, :verbose, :error_proc,
-      :handler_class_for
+    should have_instance_methods :name, :logger, :verbose, :keep_alive, :runner,
+      :error_proc, :run, :handler_class_for
 
     should "default it's configuration from the service host, but allow overrides" do
       host_data = Sanford::HostData.new(TestHost, :verbose_logging => false)

data/test/unit/host_test.rb

@@ -13,7 +13,8 @@ module Sanford::Host
     subject{ MyHost.instance }
 
     should have_instance_methods :configuration, :name, :ip, :port, :pid_file,
-      :logger, :verbose_logging, :error, :init, :version, :versioned_services
+      :logger, :verbose_logging, :runner, :error, :init, :version,
+      :versioned_services
 
     should "get and set it's configuration options with their matching methods" do
       subject.name 'my_awesome_host'

data/test/unit/manager_test.rb

@@ -140,7 +140,4 @@ module Sanford::Manager
 
   end
 
-  # ServerHandler run/start and SignalHandler stop/restart are tested with
-  # system tests: test/system/managing_test.rb
-
 end

data/test/unit/runner_test.rb

@@ -1,12 +1,12 @@
 require 'assert'
 
-class Sanford::Runner
+module Sanford::Runner
 
   class BaseTest < Assert::Context
     desc "Sanford::Runner"
     setup do
       request = Sanford::Protocol::Request.new('v1', 'test', {})
-      @runner = Sanford::Runner.new(BasicServiceHandler, request)
+      @runner = Sanford::DefaultRunner.new(BasicServiceHandler, request)
     end
     subject{ @runner }
 
@@ -25,7 +25,7 @@ class Sanford::Runner
     should "be able to build a runner with a handler class and params" do
       response = nil
       assert_nothing_raised do
-        response = Sanford::Runner.run(BasicServiceHandler, {})
+        response = Sanford::DefaultRunner.run(BasicServiceHandler, {})
       end
 
       assert_equal 200, response.code

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sanford
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: 
   segments: 
   - 0
   - 6
-  - 0
-  version: 0.6.0
+  - 1
+  version: 0.6.1
 platform: ruby
 authors: 
 - Collin Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-02-21 00:00:00 Z
+date: 2013-02-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false
@@ -70,11 +70,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 3
         segments: 
-        - 1
+        - 2
         - 0
-        version: "1.0"
+        version: "2.0"
   requirement: *id004
   name: assert
   type: :development
@@ -135,7 +135,6 @@ files:
 - test/support/service_handlers.rb
 - test/support/services.rb
 - test/support/simple_client.rb
-- test/system/managing_test.rb
 - test/system/request_handling_test.rb
 - test/unit/config_test.rb
 - test/unit/error_handler_test.rb
@@ -190,7 +189,6 @@ test_files:
 - test/support/service_handlers.rb
 - test/support/services.rb
 - test/support/simple_client.rb
-- test/system/managing_test.rb
 - test/system/request_handling_test.rb
 - test/unit/config_test.rb
 - test/unit/error_handler_test.rb

data/test/system/managing_test.rb

@@ -1,94 +0,0 @@
-require 'assert'
-
-require 'sanford/cli'
-
-class ManagingTest < Assert::Context
-  include Test::ManagerHelper
-  desc "Using Sanford's Manager"
-  setup do
-    @start_options = { :host => 'MyHost', :ip => 'localhost', :port => 12345 }
-  end
-
-  class RunTest < ManagingTest
-    desc "to run a server"
-    setup do
-      @proc = proc{ Sanford::Manager.call(:run, @start_options) }
-    end
-
-    should "run the server specified and write a PID file" do
-      self.fork_and_call(@proc) do
-        assert_nothing_raised{ self.open_socket('localhost', 12345) }
-        assert File.exists?('tmp/my_host.pid')
-      end
-    end
-
-  end
-
-  class StartTest < ManagingTest
-    desc "to start a daemonized server"
-    setup do
-      @proc = proc{ Sanford::Manager.call(:start, @start_options) }
-    end
-    teardown do
-      Sanford::Manager.call(:stop, @start_options)
-    end
-
-    should "run the server specified and write a PID file" do
-      self.fork_and_call(@proc) do
-        assert_nothing_raised{ self.open_socket('localhost', 12345) }
-        assert File.exists?('tmp/my_host.pid')
-      end
-    end
-
-  end
-
-  class StopTest < ManagingTest
-    desc "to stop a daemonized server"
-    setup do
-      @start_proc = proc{ Sanford::Manager.call(:start, @start_options) }
-    end
-
-    should "stop the server specified and remove the PID file" do
-      self.fork_and_call(@start_proc) do
-        Sanford::Manager.call(:stop, @start_options)
-        sleep 1
-
-        assert_raises{ self.open_socket('localhost', 12345) }
-        assert_not File.exists?('tmp/my_host_localhost_12345.pid')
-      end
-    end
-
-  end
-
-  class RestartTest < ManagingTest
-    desc "to restart a daemonized server"
-    setup do
-      @start_proc = proc{ Sanford::Manager.call(:start, @start_options) }
-    end
-
-    should "stop the server specified and remove the PID file" do
-      self.fork_and_call(@start_proc) do
-        exception = nil
-        stop = false
-        thread = Thread.new do
-          while !stop do
-            begin
-              self.open_socket('localhost', 12345)
-              sleep 0.1
-            rescue Exception => exception
-            end
-          end
-        end
-        Sanford::Manager.call(:restart, @start_options)
-        thread.join(1)
-
-        # make sure we didn't lost the ability to connect
-        assert_nil exception
-
-        stop = true
-        thread.join
-      end
-    end
-  end
-
-end