sanford 0.10.1 → 0.11.0

data/lib/sanford/host_data.rb

@@ -1,65 +0,0 @@
-require 'sanford/service_handler'
-require 'sanford/sanford_runner'
-
-module Sanford
-
-  class HostData
-
-    # When trying to run a server for a host, we need to build up the host's
-    # data to increase the performance of the server. This is done by
-    # constantizing a host's handlers and merging a host's configuration with
-    # optional overrides.
-
-    # 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_procs
-
-    def initialize(service_host, options = nil)
-      service_host.configuration.init_procs.each(&:call)
-
-      overrides = self.remove_nil_values(options || {})
-      configuration = service_host.configuration.to_hash.merge(overrides)
-
-      @name        = configuration[:name]
-      @logger      = configuration[:logger]
-      @verbose     = configuration[:verbose_logging]
-      @keep_alive  = configuration[:receives_keep_alive]
-      @error_procs = configuration[:error_procs]
-
-      @handlers = service_host.services.inject({}) do |h, (name, handler_class_name)|
-        h.merge({ name => self.constantize(handler_class_name) })
-      end
-    end
-
-    def handler_class_for(service)
-      @handlers[service] || raise(Sanford::NotFoundError)
-    end
-
-    def run(handler_class, request)
-      SanfordRunner.new(handler_class, request, self.logger).run
-    end
-
-    protected
-
-    def constantize(handler_class_name)
-      Sanford::ServiceHandler.constantize(handler_class_name) ||
-        raise(Sanford::NoHandlerClassError.new(handler_class_name))
-    end
-
-    def remove_nil_values(hash)
-      hash.inject({}){|h, (k, v)| !v.nil? ? h.merge({ k => v }) : h }
-    end
-
-  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/hosts.rb

@@ -1,38 +0,0 @@
-require 'set'
-require 'sanford/host'
-
-module Sanford
-
-  class Hosts
-
-    def initialize(values = [])
-      @set = Set.new(values)
-    end
-
-    def method_missing(method, *args, &block)
-      @set.send(method, *args, &block)
-    end
-
-    def respond_to?(method)
-      super || @set.respond_to?(method)
-    end
-
-    # We want class names to take precedence over a configured name, so that if
-    # a user specifies a specific class, they always get it
-    def find(name)
-      find_by_class_name(name) || find_by_name(name)
-    end
-
-    private
-
-    def find_by_class_name(class_name)
-      @set.detect{|host_class| host_class.to_s == class_name.to_s }
-    end
-
-    def find_by_name(name)
-      @set.detect{|host_class| host_class.name == name.to_s }
-    end
-
-  end
-
-end

data/lib/sanford/manager.rb

@@ -1,275 +0,0 @@
-require 'sanford/cli'
-require 'sanford/server'
-
-module Sanford
-
-  module Manager
-
-    def self.call(action, options = nil)
-      get_handler_class(action).new(options).tap{ |manager| manager.send(action) }
-    end
-
-    def self.get_handler_class(action)
-      case action.to_sym
-      when :start, :run
-        ServerHandler
-      when :stop, :restart
-        SignalHandler
-      end
-    end
-
-    class Config
-      attr_reader :host_name, :host, :ip, :port, :pid, :pid_file, :restart_dir
-      attr_reader :file_descriptor, :client_file_descriptors
-
-      def initialize(opts = nil)
-        options = OpenStruct.new(opts || {})
-        @host_name = ENV['SANFORD_HOST'] || options.host
-
-        @host = @host_name ? Sanford.hosts.find(@host_name) : Sanford.hosts.first
-        @host ||= NullHost.new
-
-        @file_descriptor = ENV['SANFORD_SERVER_FD'] || options.file_descriptor
-        @file_descriptor = @file_descriptor.to_i if @file_descriptor
-        @ip   = ENV['SANFORD_IP']   || options.ip   || @host.ip
-        @port = ENV['SANFORD_PORT'] || options.port || @host.port
-        @port = @port.to_i if @port
-
-        client_fds_str = ENV['SANFORD_CLIENT_FDS'] || options.client_fds || ""
-        @client_file_descriptors = client_fds_str.split(',').map(&:to_i)
-
-        @pid_file = PIDFile.new(ENV['SANFORD_PID_FILE'] || options.pid_file || @host.pid_file)
-        @pid      = options.pid || @pid_file.pid
-
-        @restart_dir = ENV['SANFORD_RESTART_DIR'] || options.restart_dir
-      end
-
-      def listen_args
-        @file_descriptor ? [ @file_descriptor ] : [ @ip, @port ]
-      end
-
-      def has_listen_args?
-        !!@file_descriptor || !!(@ip && @port)
-      end
-
-      def found_host?
-        !@host.kind_of?(NullHost)
-      end
-
-      class NullHost
-        [ :ip, :port, :pid_file ].each do |method_name|
-          define_method(method_name){ }
-        end
-      end
-
-      class PIDFile
-        DEF_FILE = '/dev/null'
-
-        def initialize(path)
-          @path = (path || DEF_FILE).to_s
-        end
-
-        def pid
-          pid = File.read(@path).strip if File.exists?(@path)
-          pid.to_i if pid && !pid.empty?
-        end
-
-        def write
-          begin
-            File.open(@path, 'w'){|f| f.puts Process.pid }
-          rescue Errno::ENOENT => err
-            e = RuntimeError.new("Can't write pid to file `#{@path}`")
-            e.set_backtrace(err.backtrace)
-            raise e
-          end
-        end
-
-        def remove
-          FileUtils.rm_f(@path)
-        end
-
-        def to_s
-          @path
-        end
-      end
-
-    end
-
-    class ServerHandler
-
-      def initialize(options = nil)
-        @config = Config.new(options)
-        raise Sanford::NoHostError.new(@config.host_name) if !@config.found_host?
-        raise Sanford::InvalidHostError.new(@config.host) if !@config.has_listen_args?
-        @host   = @config.host
-        @logger = @host.logger
-
-        @server_options = {}
-        # FUTURE allow passing through dat-tcp options (min/max workers)
-        # FUTURE merge in host options for verbose / keep_alive
-
-        @restart_cmd = RestartCmd.new(@config)
-      end
-
-      def run
-        self.run! false
-      end
-
-      def start
-        self.run! true
-      end
-
-      protected
-
-      def run!(daemonize = false)
-        daemonize!(true) if daemonize && !ENV['SANFORD_SKIP_DAEMONIZE']
-        Sanford::Server.new(@host, @server_options).tap do |server|
-          log "Starting #{@host.name} server..."
-
-          server.listen(*@config.listen_args)
-          $0 = ProcessName.new(@host.name, server.ip, server.port)
-          log "Listening on #{server.ip}:#{server.port}"
-
-          @config.pid_file.write
-          log "PID: #{Process.pid}"
-
-          Signal.trap("TERM"){ self.stop!(server) }
-          Signal.trap("INT"){  self.halt!(server) }
-          Signal.trap("USR2"){ self.restart!(server) }
-
-          server_thread = server.run(@config.client_file_descriptors)
-          log "#{@host.name} server started and ready."
-          server_thread.join
-        end
-      rescue RuntimeError => err
-        log "Error: #{err.message}"
-        log "#{@host.name} server never started."
-      ensure
-        @config.pid_file.remove
-      end
-
-      def restart!(server)
-        log "Restarting #{@host.name} server..."
-        server.pause
-        log "server paused"
-
-        ENV['SANFORD_HOST']           = @host.name
-        ENV['SANFORD_SERVER_FD']      = server.file_descriptor.to_s
-        ENV['SANFORD_CLIENT_FDS']     = server.client_file_descriptors.join(',')
-        ENV['SANFORD_SKIP_DAEMONIZE'] = 'yes'
-
-        log "calling exec ..."
-        Dir.chdir @restart_cmd.dir
-        Kernel.exec(*@restart_cmd.argv)
-      end
-
-      def stop!(server)
-        log "Stopping #{@host.name} server..."
-        server.stop
-        log "#{@host.name} server stopped."
-      end
-
-      def halt!(server)
-        log "Halting #{@host.name} server..."
-        server.halt false
-        log "#{@host.name} server halted."
-      end
-
-      # Full explanation: http://www.steve.org.uk/Reference/Unix/faq_2.html#SEC16
-      def daemonize!(no_chdir = false, no_close = false)
-        exit if fork
-        Process.setsid
-        exit if fork
-        Dir.chdir "/" unless no_chdir
-        if !no_close
-          null = File.open "/dev/null", 'w'
-          STDIN.reopen null
-          STDOUT.reopen null
-          STDERR.reopen null
-        end
-        return 0
-      end
-
-      def log(message)
-        @logger.info "[Sanford] #{message}"
-      end
-
-      class ProcessName < String
-        def initialize(name, ip, port)
-          super "#{[ name, ip, port ].join('_')}"
-        end
-      end
-
-      class RestartCmd
-        attr_reader :argv, :dir
-
-        def initialize(config = nil)
-          require 'rubygems'
-          config ||= OpenStruct.new
-          @dir = config.restart_dir || get_pwd
-          @argv = [ Gem.ruby, $0, ARGV.dup ].flatten
-        end
-
-        protected
-
-        # Trick from puma/unicorn. Favor PWD because it contains an unresolved
-        # symlink. This is useful when restarting after deploying; the original
-        # directory may be removed, but the symlink is pointing to a new
-        # directory.
-        def get_pwd
-          env_stat = File.stat(ENV['PWD'])
-          pwd_stat = File.stat(Dir.pwd)
-          if env_stat.ino == pwd_stat.ino && env_stat.dev == pwd_stat.dev
-            ENV['PWD']
-          else
-            Dir.pwd
-          end
-        end
-
-      end
-
-    end
-
-    class SignalHandler
-
-      def initialize(options = nil)
-        @config = Config.new(options)
-        raise Sanford::NoPIDError.new if !@config.pid
-      end
-
-      def stop
-        Process.kill("TERM", @config.pid)
-      end
-
-      def restart
-        Process.kill("USR2", @config.pid)
-      end
-
-    end
-
-  end
-
-  class NoHostError < CLIRB::Error
-    def initialize(host_name)
-      message = if Sanford.hosts.empty?
-        "No hosts have been defined. Please define a host before trying to run Sanford."
-      else
-        "A host couldn't be found with the name #{host_name.inspect}. "
-      end
-      super message
-    end
-  end
-
-  class InvalidHostError < CLIRB::Error
-    def initialize(host)
-      super "A port must be configured or provided to run a server for '#{host}'"
-    end
-  end
-
-  class NoPIDError < CLIRB::Error
-    def initialize
-      super "A PID or PID file is required"
-    end
-  end
-
-end

data/test/support/fake_connection.rb

@@ -1,36 +0,0 @@
-class FakeConnection
-
-  attr_reader :read_data, :response, :write_stream_closed
-
-  def self.with_request(name, params = {}, raise_on_write = false)
-    request = Sanford::Protocol::Request.new(name, params)
-    self.new(request.to_hash, raise_on_write)
-  end
-
-  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)
-    if @raise_on_write
-      @raise_on_write = false
-      raise 'test fail'
-    end
-    @response = Sanford::Protocol::Response.parse(data)
-  end
-
-  def close_write
-    @write_stream_closed = true
-  end
-
-end

data/test/support/helpers.rb

@@ -1,17 +0,0 @@
-module Test
-  module SpawnServerHelper
-
-    def start_server(host, &block)
-      begin
-        server = Sanford::Server.new(host, { :ready_timeout => 0.1 })
-        server.listen(host.ip, host.port)
-        thread = server.run
-        yield
-      ensure
-        server.halt if server
-        thread.join if thread
-      end
-    end
-
-  end
-end

data/test/support/service_handlers.rb

@@ -1,154 +0,0 @@
-class BasicServiceHandler
-  include Sanford::ServiceHandler
-
-  def run!
-    { 'name' => 'Joe Test', 'email' => "joe.test@example.com" }
-  end
-
-end
-
-class SerializeErrorServiceHandler
-  include Sanford::ServiceHandler
-
-  # return data that fails BSON serialization
-  # BSON errors if it is sent date/datetime values
-  def run!
-    { 'date' => Date.today,
-      'datetime' => DateTime.now
-    }
-  end
-
-end
-
-module CallbackServiceHandler
-
-  def self.included(receiver)
-    receiver.class_eval do
-      attr_reader :before_called, :after_called
-      attr_reader :before_init_called, :init_bang_called, :after_init_called
-      attr_reader :before_run_called, :run_bang_called, :after_run_called
-      attr_reader :second_before_init_called, :second_after_run_called
-
-      before do
-        @before_called = true
-      end
-      after do
-        @after_called = true
-      end
-
-      before_init do
-        @before_init_called = true
-      end
-      before_init do
-        @second_before_init_called = true
-      end
-
-      after_init do
-        @after_init_called = true
-      end
-
-      before_run do
-        @before_run_called = true
-      end
-
-      after_run do
-        @after_run_called = true
-      end
-      after_run do
-        @second_after_run_called = true
-      end
-
-    end
-
-  end
-
-  def init!
-    @init_bang_called = true
-  end
-
-  def run!
-    @run_bang_called = true
-  end
-
-end
-
-class FlagServiceHandler
-  include Sanford::ServiceHandler
-  include CallbackServiceHandler
-
-end
-
-class HaltingBehaviorServiceHandler
-  include Sanford::ServiceHandler
-  include CallbackServiceHandler
-
-  before_init do
-    halt_when('before_init')
-  end
-
-  def init!
-    super
-    halt_when('init!')
-  end
-
-  after_init do
-    halt_when('after_init')
-  end
-
-  before_run do
-    halt_when('before_run')
-  end
-
-  def run!
-    super
-    halt_when('run!')
-  end
-
-  after_run do
-    halt_when('after_run')
-  end
-
-  def halt_when(method_name)
-    return if ![*params['when']].include?(method_name)
-    halt(200, {
-      :message  => "#{method_name} halting",
-      :data     => {
-        :before_init_called => @before_init_called,
-        :init_bang_called   => @init_bang_called,
-        :after_init_called  => @after_init_called,
-        :before_run_called  => @before_run_called,
-        :run_bang_called    => @run_bang_called,
-        :after_run_called   => @after_run_called
-      }
-    })
-  end
-
-end
-
-class RenderHandler
-  include Sanford::ServiceHandler
-
-  def run!
-    render params['template_name']
-  end
-end
-
-class RunOtherHandler
-  include Sanford::ServiceHandler
-
-  def run!
-    response = run_handler(HaltServiceHandler, 'code' => 200, 'data' => 'RunOtherHandler')
-    response.data
-  end
-end
-
-class HaltServiceHandler
-  include Sanford::ServiceHandler
-
-  def run!
-    halt params['code'], :message => params['message'], :data => params['data']
-  end
-
-end
-
-class InvalidServiceHandler; end

data/test/support/services.rb

@@ -1,123 +0,0 @@
-require 'logger'
-
-class TestHost
-  include Sanford::Host
-
-  attr_accessor :init_has_been_called
-
-  init do
-    self.init_has_been_called = true
-  end
-
-  ip       'localhost'
-  port     12000
-  pid_file File.expand_path('../../../tmp/test_host.pid', __FILE__)
-
-  logger(Logger.new(File.expand_path("../../../log/test.log", __FILE__)).tap do |logger|
-    logger.level = Logger::DEBUG
-  end)
-  verbose_logging false
-
-  error do |exception, host_data, request|
-    if exception.kind_of?(::MyCustomError)
-      Sanford::Protocol::Response.new([ 987, 'custom error!' ])
-    end
-  end
-
-  service_handler_ns 'TestHost'
-
-  service :echo,          'Echo'
-  service 'bad',          'Bad'
-  service 'multiply',     'Multiply'
-  service 'halt_it',      '::TestHost::HaltIt'
-  service 'authorized',   'Authorized'
-  service 'custom_error', 'CustomError'
-
-  class Echo
-    include Sanford::ServiceHandler
-
-    def run!
-      params['message']
-    end
-
-  end
-
-  class Bad
-    include Sanford::ServiceHandler
-
-    def run!
-      raise "hahaha"
-    end
-  end
-
-  class Multiply
-    include Sanford::ServiceHandler
-
-    def init!
-      @number = params['number'] || 1
-    end
-
-    def run!
-      @number * 2
-    end
-  end
-
-  class HaltIt
-    include Sanford::ServiceHandler
-
-    def run!
-      halt 728, {
-        :message  => "I do what I want",
-        :data     => [ 1, true, 'yes' ]
-      }
-    end
-  end
-
-  class Authorized
-    include Sanford::ServiceHandler
-
-    before_run do
-      halt 401, :message => "Not authorized"
-    end
-
-  end
-
-  ::MyCustomError = Class.new(RuntimeError)
-
-  class CustomError
-    include Sanford::ServiceHandler
-
-    def run!
-      raise ::MyCustomError
-    end
-
-  end
-
-end
-
-class MyHost
-  include Sanford::Host
-
-  name     'my_host'
-  ip       'my.local'
-  pid_file File.expand_path('../../../tmp/my_host.pid', __FILE__)
-end
-
-class InvalidHost
-  include Sanford::Host
-
-  name 'invalid_host'
-end
-
-class UndefinedHandlersHost
-  include Sanford::Host
-
-  port 12345
-
-  service 'undefined', 'ThisIsNotDefined'
-
-end
-
-class EmptyHost
-  include Sanford::Host
-end