sanford 0.10.1 → 0.11.0

data/lib/sanford/server_data.rb

@@ -0,0 +1,47 @@
+module Sanford
+
+  class ServerData
+
+    # The server uses this to "compile" its configuration for speed. NsOptions
+    # is relatively slow everytime an option is read. To avoid this, we read the
+    # options one time here and memoize their values. This way, we don't pay the
+    # NsOptions overhead when reading them while handling a request.
+
+    attr_reader :name
+    attr_reader :ip, :port
+    attr_reader :pid_file
+    attr_reader :logger, :verbose_logging
+    attr_reader :receives_keep_alive
+    attr_reader :error_procs
+    attr_reader :routes
+    attr_reader :template_source
+
+    def initialize(args = nil)
+      args ||= {}
+      @name = args[:name]
+      @ip   = args[:ip]
+      @port = args[:port]
+      @pid_file = args[:pid_file]
+      @logger = args[:logger]
+      @verbose_logging = !!args[:verbose_logging]
+      @receives_keep_alive = !!args[:receives_keep_alive]
+      @error_procs = args[:error_procs] || []
+      @routes = build_routes(args[:routes] || [])
+      @template_source = args[:template_source]
+    end
+
+    def route_for(name)
+      @routes[name] || raise(NotFoundError, "no service named '#{name}'")
+    end
+
+    private
+
+    def build_routes(routes)
+      routes.inject({}){ |h, route| h.merge(route.name => route) }
+    end
+
+  end
+
+  NotFoundError = Class.new(RuntimeError)
+
+end

data/lib/sanford/service_handler.rb

@@ -1,22 +1,7 @@
-require 'sanford/sanford_runner'
-require 'sanford/template_source'
-
 module Sanford
 
   module ServiceHandler
 
-    DISALLOWED_TEMPLATE_EXTS = Sanford::TemplateSource::DISALLOWED_ENGINE_EXTS
-
-    def self.constantize(class_name)
-      names = class_name.to_s.split('::').reject{|name| name.empty? }
-      klass = names.inject(Object) do |constant, name|
-        constant.const_get(name)
-      end
-      klass == Object ? false : klass
-    rescue NameError
-      false
-    end
-
     def self.included(klass)
       klass.class_eval do
         extend ClassMethods
@@ -31,18 +16,18 @@ module Sanford
       end
 
       def init
-        self.run_callback 'before_init'
+        run_callback 'before_init'
         self.init!
-        self.run_callback 'after_init'
+        run_callback 'after_init'
       end
 
       def init!
       end
 
       def run
-        self.run_callback 'before_run'
+        run_callback 'before_run'
         data = self.run!
-        self.run_callback 'after_run'
+        run_callback 'after_run'
         [ 200, data ]
       end
 
@@ -55,26 +40,19 @@ module Sanford
         "#<#{self.class}:#{reference} @request=#{self.request.inspect}>"
       end
 
-      protected
+      private
 
       # Helpers
 
       def render(path, options = nil)
         options ||= {}
-        get_engine(path, options['source'] || Sanford.config.template_source).render(
-          path,
-          self,
-          options['locals'] || {}
-        )
-      end
-
-      def run_handler(handler_class, params = nil)
-        handler_class.run(params || {}, self.logger)
+        source = options['source'] || @sanford_runner.template_source
+        source.render(path, self, options['locals'] || {})
       end
 
       def halt(*args); @sanford_runner.halt(*args); end
       def request;     @sanford_runner.request;     end
-      def params;      self.request.params;         end
+      def params;      @sanford_runner.params;      end
       def logger;      @sanford_runner.logger;      end
 
       def run_callback(callback)
@@ -83,26 +61,10 @@ module Sanford
         end
       end
 
-      private
-
-      def get_engine(path, source)
-        source.engines[File.extname(get_template(path, source))[1..-1] || '']
-      end
-
-      def get_template(path, source)
-        files = Dir.glob("#{Pathname.new(source.path).join(path.to_s)}.*")
-        files = files.reject{ |p| DISALLOWED_TEMPLATE_EXTS.include?(File.extname(p)) }
-        files.first.to_s
-      end
-
     end
 
     module ClassMethods
 
-      def run(params = nil, logger = nil)
-        SanfordRunner.run(self, params || {}, logger)
-      end
-
       def before_callbacks;      @before_callbacks      ||= []; end
       def after_callbacks;       @after_callbacks       ||= []; end
       def before_init_callbacks; @before_init_callbacks ||= []; end

data/lib/sanford/template_source.rb

@@ -4,7 +4,7 @@ module Sanford
 
   class TemplateSource
 
-    DISALLOWED_ENGINE_EXTS = [ '.rb' ]
+    DISALLOWED_ENGINE_EXTS = [ 'rb' ]
 
     DisallowedEngineExtError = Class.new(ArgumentError)
 
@@ -17,7 +17,7 @@ module Sanford
     end
 
     def engine(input_ext, engine_class, registered_opts = nil)
-      if DISALLOWED_ENGINE_EXTS.include?(".#{input_ext}")
+      if DISALLOWED_ENGINE_EXTS.include?(input_ext)
         raise DisallowedEngineExtError, "`#{input_ext}` is disallowed as an"\
                                         " engine extension."
       end
@@ -25,6 +25,23 @@ module Sanford
       @engines[input_ext.to_s] = engine_class.new(engine_opts)
     end
 
+    def render(template_path, service_handler, locals)
+      engine = @engines[get_template_ext(template_path)]
+      engine.render(template_path, service_handler, locals)
+    end
+
+    private
+
+    def get_template_ext(template_path)
+      files = Dir.glob("#{File.join(@path, template_path.to_s)}.*")
+      files = files.reject{ |p| !@engines.keys.include?(parse_ext(p)) }
+      parse_ext(files.first.to_s || '')
+    end
+
+    def parse_ext(template_path)
+      File.extname(template_path)[1..-1]
+    end
+
   end
 
   class NullTemplateSource < TemplateSource

data/lib/sanford/test_runner.rb

@@ -1,53 +1,52 @@
 require 'sanford-protocol'
+require 'sanford/logger'
 require 'sanford/runner'
 require 'sanford/service_handler'
+require 'sanford/template_source'
 
 module Sanford
 
-  InvalidServiceHandlerError = Class.new(RuntimeError)
+  InvalidServiceHandlerError = Class.new(StandardError)
 
-  class TestRunner
-    include Sanford::Runner
+  class TestRunner < Sanford::Runner
 
     attr_reader :response
 
-    def initialize(handler_class, request_or_params, *args)
+    def initialize(handler_class, args = nil)
       if !handler_class.include?(Sanford::ServiceHandler)
         raise InvalidServiceHandlerError, "#{handler_class.inspect} is not a"\
                                           " Sanford::ServiceHandler"
       end
-
-      super handler_class, build_request(request_or_params), *args
-    end
-
-    def init!
-      @response = build_response catch(:halt){ @handler.init; nil }
+      args = (args || {}).dup
+      @request         = args.delete(:request)
+      @params          = args.delete(:params) || {}
+      @logger          = args.delete(:logger) || Sanford::NullLogger.new
+      @template_source = args.delete(:template_source) ||
+                         Sanford::NullTemplateSource.new
+
+      super(handler_class)
+      args.each{ |key, value| @handler.send("#{key}=", value) }
+
+      return_value = catch(:halt){ @handler.init; nil }
+      @response = build_and_serialize_response{ return_value } if return_value
     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.
+    # 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 run
-      @response ||= super.tap do |response|
-        # attempt to serialize (and then throw away) the response data
-        # this will error on the developer if BSON can't serialize their response
-        Sanford::Protocol::BsonBody.new.encode(response.to_hash)
-      end
-    end
-
-    def run!
-      self.handler.run
+      @response ||= build_and_serialize_response{ self.handler.run }
     end
 
     private
 
-    def build_request(req)
-      !req.kind_of?(Sanford::Protocol::Request) ? test_request(req) : req
-    end
-
-    def test_request(params)
-      Sanford::Protocol::Request.new('name', params || {})
+    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 BSON can't serialize their response
+        Sanford::Protocol::BsonBody.new.encode(response.to_hash) if response
+      end
     end
 
   end

data/lib/sanford/version.rb

@@ -1,3 +1,3 @@
 module Sanford
-  VERSION = "0.10.1"
+  VERSION = "0.11.0"
 end

data/lib/sanford.rb

@@ -1,29 +1,7 @@
 require 'sanford/version'
-require 'sanford/config'
-require 'sanford/hosts'
-require 'sanford/host'
+require 'sanford/server'
 require 'sanford/service_handler'
 
-ENV['SANFORD_SERVICES_FILE'] ||= 'config/services'
-
 module Sanford
 
-  def self.config; @config ||= Config.new; end
-  def self.configure(&block)
-    block.call(self.config)
-  end
-
-  def self.init
-    @hosts ||= Sanford::Hosts.new
-    require self.config.services_file
-  end
-
-  def self.register(host)
-    @hosts.add(host)
-  end
-
-  def self.hosts
-    @hosts
-  end
-
 end

data/sanford.gemspec

@@ -18,10 +18,9 @@ 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.4"])
-  gem.add_dependency("ns-options",        ["~> 1.1"])
-  gem.add_dependency("sanford-protocol",  ["~> 0.8"])
+  gem.add_dependency("dat-tcp",          ["~> 0.5"])
+  gem.add_dependency("ns-options",       ["~> 1.1"])
+  gem.add_dependency("sanford-protocol", ["~> 0.9"])
 
-  gem.add_development_dependency("assert",        ["~> 2.10"])
-  gem.add_development_dependency("assert-mocha",  ["~> 1.1"])
+  gem.add_development_dependency("assert", ["~> 2.11"])
 end

data/test/helper.rb

@@ -5,27 +5,10 @@
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
 require 'pry' # require pry for debugging (`binding.pry`)
-require 'assert-mocha' if defined?(Assert)
 
 ENV['SANFORD_PROTOCOL_DEBUG'] = 'yes'
 
-require 'sanford'
-ROOT = File.expand_path('../..', __FILE__)
+require 'pathname'
+ROOT_PATH = Pathname.new(File.expand_path('../..', __FILE__))
 
-MyTestEngine = Class.new(Sanford::TemplateEngine) do
-  def render(path, service_handler, locals)
-    [path.to_s, service_handler.class.to_s, locals]
-  end
-end
-Sanford.configure do |config|
-  config.services_file = File.join(ROOT, 'test/support/services')
-  config.set_template_source File.join(ROOT, 'test/support') do |s|
-    s.engine 'test', MyTestEngine
-  end
-end
-Sanford.init
-
-require 'test/support/fake_connection'
-require 'test/support/service_handlers'
-require 'test/support/simple_client'
-require 'test/support/helpers'
+require 'test/support/factory'

data/test/support/app_server.rb

@@ -0,0 +1,142 @@
+require 'pathname'
+require 'sanford'
+require 'sanford-protocol'
+
+if !defined?(ROOT_PATH)
+  ROOT_PATH = Pathname.new(File.expand_path('../../..', __FILE__))
+end
+
+class AppERBEngine < Sanford::TemplateEngine
+  RenderScope = Struct.new(:view)
+
+  def render(path, service_handler, locals)
+    require 'erb'
+    full_path = ROOT_PATH.join("test/support/#{path}.erb")
+    binding = RenderScope.new(service_handler).send(:binding)
+    ERB.new(File.read(full_path)).result(binding)
+  end
+end
+
+class AppServer
+  include Sanford::Server
+
+  name 'app'
+  ip   'localhost'
+  port 12000
+
+  receives_keep_alive true
+
+  logger Logger.new(ROOT_PATH.join('log/app_server.log').to_s)
+  verbose_logging true
+
+  router do
+    service_handler_ns 'AppHandlers'
+
+    service 'echo',         'Echo'
+    service 'raise',        'Raise'
+    service 'bad_response', 'BadResponse'
+    service 'template',     'Template'
+    service 'halt',         'Halt'
+    service 'custom_error', 'CustomError'
+  end
+
+  build_template_source ROOT_PATH.join('test/support').to_s do |s|
+    s.engine 'erb', AppERBEngine
+  end
+
+  error do |exception, server_data, request|
+    if request && request.name == 'custom_error'
+      data = "The server on #{server_data.ip}:#{server_data.port} " \
+             "threw a #{exception.class}."
+      Sanford::Protocol::Response.new(200, data)
+    end
+  end
+
+end
+
+module AppHandlers
+
+  class Echo
+    include Sanford::ServiceHandler
+
+    def run!
+      params['message']
+    end
+  end
+
+  class Raise
+    include Sanford::ServiceHandler
+
+    def run!
+      raise "hahaha"
+    end
+  end
+
+  class BadResponse
+    include Sanford::ServiceHandler
+
+    def run!
+      Class.new
+    end
+  end
+
+  class Template
+    include Sanford::ServiceHandler
+
+    attr_reader :message
+
+    def init!
+      @message = params['message']
+    end
+
+    def run!
+      render "template"
+    end
+  end
+
+  class Halt
+    include Sanford::ServiceHandler
+
+    before do
+      halt(200, :message => "in before") if params['when'] == 'before'
+    end
+
+    before_init do
+      halt(200, :message => "in before init") if params['when'] == 'before_init'
+    end
+
+    def init!
+      halt(200, :message => "in init") if params['when'] == 'init'
+    end
+
+    after_init do
+      halt(200, :message => "in after init") if params['when'] == 'after_init'
+    end
+
+    before_run do
+      halt(200, :message => "in before run") if params['when'] == 'before_run'
+    end
+
+    def run!
+      halt(200, :message => "in run") if params['when'] == 'run'
+      false
+    end
+
+    after_run do
+      halt(200, :message => "in after run") if params['when'] == 'after_run'
+    end
+
+    after do
+      halt(200, :message => "in after") if params['when'] == 'after'
+    end
+  end
+
+  class CustomError
+    include Sanford::ServiceHandler
+
+    def run!
+      raise StandardError
+    end
+  end
+
+end

data/test/support/config.sanford

@@ -0,0 +1,7 @@
+require 'test/support/app_server'
+
+if !defined?(TestConstant)
+  TestConstant = Class.new
+end
+
+run AppServer.new

data/test/support/config_invalid_run.sanford

@@ -0,0 +1,3 @@
+MyServer = Class.new
+
+run MyServer

data/test/support/fake_server_connection.rb

@@ -0,0 +1,58 @@
+require 'sanford-protocol'
+
+class FakeServerConnection
+
+  attr_reader :request, :response
+  attr_reader :write_closed
+  attr_accessor :raise_on_write, :write_exception
+  attr_writer :read_data
+
+  def self.with_request(name, params = nil)
+    self.new.tap{ |c| c.add_request(name, params) }
+  end
+
+  def initialize(read_data = nil)
+    @read_data = read_data
+    @raise_on_write = false
+    @write_closed = false
+
+    @write_exception = RuntimeError.new('oops')
+
+    @request = nil
+    @response = nil
+  end
+
+  def add_request(name, params = nil)
+    @request = Sanford::Protocol::Request.new(name, params || {})
+    @read_data = @request.to_hash
+  end
+
+  def read_data
+    @read_data || {}
+  end
+
+  def write_data(data = nil)
+    write_data!(data) if data
+    @write_data
+  end
+
+  def peek_data
+    @read_data ? @read_data[0] : ""
+  end
+
+  def close_write
+    @write_closed = true
+  end
+
+  private
+
+  def write_data!(data)
+    if @raise_on_write
+      @raise_on_write = false
+      raise @write_exception
+    end
+    @response = Sanford::Protocol::Response.parse(data) rescue nil
+    @write_data = data
+  end
+
+end

data/test/support/pid_file_spy.rb

@@ -0,0 +1,19 @@
+class PIDFileSpy
+
+  attr_reader :pid, :write_called, :remove_called
+
+  def initialize(pid)
+    @pid = pid
+    @write_called = false
+    @remove_called = false
+  end
+
+  def write
+    @write_called = true
+  end
+
+  def remove
+    @remove_called = true
+  end
+
+end

data/test/support/template.erb

@@ -0,0 +1 @@
+ERB Template Message: <%= view.message %>