sanford 0.10.1 → 0.11.0

data/lib/sanford/process.rb

@@ -0,0 +1,136 @@
+require 'sanford/pid_file'
+
+module Sanford
+
+  class Process
+
+    attr_reader :server, :name, :pid_file, :restart_cmd
+    attr_reader :server_ip, :server_port, :server_fd, :client_fds
+
+    def initialize(server, options = nil)
+      options ||= {}
+      @server = server
+      @logger = @server.logger
+      @name = "sanford-#{@server.name}"
+      @pid_file = PIDFile.new(@server.pid_file)
+      @restart_cmd = RestartCmd.new
+
+      @server_ip = ignore_if_blank(ENV['SANFORD_IP'])
+      @server_port = ignore_if_blank(ENV['SANFORD_PORT']){ |v| v.to_i }
+      @server_fd = ignore_if_blank(ENV['SANFORD_SERVER_FD']){ |v| v.to_i }
+      @listen_args = @server_fd ? [ @server_fd ] : [ @server_ip, @server_port ]
+      @listen_args.compact!
+
+      @client_fds = (ENV['SANFORD_CLIENT_FDS'] || "").split(',').map(&:to_i)
+
+      @daemonize = !!options[:daemonize]
+      @skip_daemonize = !!ignore_if_blank(ENV['SANFORD_SKIP_DAEMONIZE'])
+    end
+
+    def run
+      ::Process.daemon(true) if self.daemonize?
+      log "Starting Sanford server for #{@server.name}..."
+
+      @server.listen(*@listen_args)
+      log "Listening on #{@server.ip}:#{@server.port}"
+
+      $0 = @name
+      @pid_file.write
+      log "PID: #{@pid_file.pid}"
+
+      ::Signal.trap("TERM"){ @server.stop }
+      ::Signal.trap("INT"){ @server.halt }
+      ::Signal.trap("USR2"){ @server.pause }
+
+      thread = @server.start(@client_fds)
+      log "#{@server.name} server started and ready."
+      thread.join
+      exec_restart_cmd if @server.paused?
+    rescue StandardError => exception
+      log "Error: #{exception.message}"
+      log "#{@server.name} server never started."
+    ensure
+      @pid_file.remove
+    end
+
+    def daemonize?
+      @daemonize && !@skip_daemonize
+    end
+
+    private
+
+    def log(message)
+      @logger.info "[Sanford] #{message}"
+    end
+
+    def exec_restart_cmd
+      log "Restarting #{@server.name} daemon..."
+      ENV['SANFORD_SERVER_FD'] = @server.file_descriptor.to_s
+      ENV['SANFORD_CLIENT_FDS'] = @server.client_file_descriptors.join(',')
+      ENV['SANFORD_SKIP_DAEMONIZE'] = 'yes'
+      @restart_cmd.exec
+    end
+
+    def ignore_if_blank(value, default = nil, &block)
+      block ||= proc{ |v| v }
+      value && !value.empty? ? block.call(value) : default
+    end
+
+  end
+
+  class RestartCmd
+    attr_reader :argv, :dir
+
+    def initialize
+      require 'rubygems'
+      @dir  = get_pwd
+      @argv = [ Gem.ruby, $0, ARGV.dup ].flatten
+    end
+
+    def exec
+      Dir.chdir self.dir
+      Kernel.exec(*self.argv)
+    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
+
+  # This is from puma for 1.8 compatibility. Ruby 1.9+ defines a
+  # `Process.daemon` for daemonizing processes. This defines the method when it
+  # isn't provided, i.e. Ruby 1.8.
+  unless ::Process.respond_to?(:daemon)
+    ::Process.class_eval do
+
+      # Full explanation: http://www.steve.org.uk/Reference/Unix/faq_2.html#SEC16
+      def self.daemon(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
+
+    end
+  end
+
+end

data/lib/sanford/process_signal.rb

@@ -0,0 +1,20 @@
+require 'sanford/pid_file'
+
+module Sanford
+
+  class ProcessSignal
+
+    attr_reader :signal, :pid
+
+    def initialize(server, signal)
+      @signal = signal
+      @pid = PIDFile.new(server.pid_file).pid
+    end
+
+    def send
+      ::Process.kill(@signal, @pid)
+    end
+
+  end
+
+end

data/lib/sanford/route.rb

@@ -0,0 +1,48 @@
+require 'sanford/sanford_runner'
+
+module Sanford
+
+  class Route
+
+    attr_reader :name, :handler_class_name, :handler_class
+
+    def initialize(name, handler_class_name)
+      @name = name.to_s
+      @handler_class_name = handler_class_name
+      @handler_class = nil
+    end
+
+    def validate!
+      @handler_class = constantize_handler_class(@handler_class_name)
+    end
+
+    def run(request, server_data)
+      SanfordRunner.new(self.handler_class, request, server_data).run
+    end
+
+    private
+
+    def constantize_handler_class(handler_class_name)
+      constantize(handler_class_name).tap do |handler_class|
+        raise(NoHandlerClassError.new(handler_class_name)) if !handler_class
+      end
+    end
+
+    def constantize(class_name)
+      names = class_name.to_s.split('::').reject{ |name| name.empty? }
+      klass = names.inject(Object){ |constant, name| constant.const_get(name) }
+      klass == Object ? false : klass
+    rescue NameError
+      false
+    end
+
+  end
+
+  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/router.rb

@@ -0,0 +1,36 @@
+require 'sanford/route'
+
+module Sanford
+
+  class Router
+
+    attr_reader :routes
+
+    def initialize(&block)
+      @service_handler_ns = nil
+      @routes = []
+      self.instance_eval(&block) if !block.nil?
+    end
+
+    def service_handler_ns(value = nil)
+      @view_handler_ns = value if !value.nil?
+      @view_handler_ns
+    end
+
+    def service(name, handler_name)
+      if self.service_handler_ns && !(handler_name =~ /^::/)
+        handler_name = "#{self.service_handler_ns}::#{handler_name}"
+      end
+
+      @routes.push(Sanford::Route.new(name, handler_name))
+    end
+
+    def inspect
+      reference = '0x0%x' % (self.object_id << 1)
+      "#<#{self.class}:#{reference} " \
+        "@service_handler_ns=#{self.service_handler_ns.inspect}>"
+    end
+
+  end
+
+end

data/lib/sanford/runner.rb

@@ -1,75 +1,47 @@
-require 'ostruct'
 require 'sanford-protocol'
+require 'sanford/logger'
+require 'sanford/template_source'
 
 module Sanford
 
-  module Runner
+  class Runner
 
     ResponseArgs = Struct.new(:status, :data)
 
-    def self.included(klass)
-      klass.class_eval do
-        extend ClassMethods
-        include InstanceMethods
-      end
-    end
-
-    module InstanceMethods
-
-      attr_reader :handler_class, :request, :logger, :handler
-
-      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
-        build_response catch_halt{ self.run! }
-      end
+    attr_reader :handler_class, :handler
+    attr_reader :request, :params, :logger, :template_source
 
-      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.
-
-      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) }
-      end
-
-      protected
+    def initialize(handler_class)
+      @handler_class = handler_class
+      @handler = @handler_class.new(self)
+    end
 
-      def build_response(args)
-        Sanford::Protocol::Response.new(args.status, args.data) if args
-      end
+    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.
+
+    def halt(status, options = nil)
+      options ||= {}
+      message = options[:message] || options['message']
+      response_status = [ status, message ]
+      response_data = options[:data] || options['data']
+      throw :halt, ResponseArgs.new(response_status, response_data)
     end
 
-    module ClassMethods
+    private
 
-      def run(handler_class, params = nil, logger = nil)
-        request = Sanford::Protocol::Request.new('name', params || {})
-        self.new(handler_class, request, logger).run
-      end
+    def catch_halt(&block)
+      catch(:halt){ ResponseArgs.new(*block.call) }
+    end
 
+    def build_response(&block)
+      args = catch_halt(&block)
+      Sanford::Protocol::Response.new(args.status, args.data)
     end
 
   end

data/lib/sanford/sanford_runner.rb

@@ -2,24 +2,34 @@ require 'sanford/runner'
 
 module Sanford
 
-  class SanfordRunner
-    include Sanford::Runner
+  class SanfordRunner < Sanford::Runner
+
+    def initialize(handler_class, request, server_data)
+      @request         = request
+      @params          = @request.params
+      @logger          = server_data.logger
+      @template_source = server_data.template_source
+
+      super(handler_class)
+    end
 
     # call the handler init and the handler run - if the init halts, run won't
     # be called.
 
-    def run!
-      run_callbacks self.handler_class.before_callbacks
-      self.handler.init
-      response_args = self.handler.run
-      run_callbacks self.handler_class.after_callbacks
-      response_args
+    def run
+      build_response do
+        run_callbacks self.handler_class.before_callbacks
+        self.handler.init
+        return_value = self.handler.run
+        run_callbacks self.handler_class.after_callbacks
+        return_value
+      end
     end
 
     private
 
     def run_callbacks(callbacks)
-      callbacks.each{|proc| self.handler.instance_eval(&proc) }
+      callbacks.each{ |proc| self.handler.instance_eval(&proc) }
     end
 
   end

data/lib/sanford/server.rb

@@ -1,62 +1,181 @@
 require 'dat-tcp'
-require 'ostruct'
+require 'ns-options'
+require 'ns-options/boolean'
 require 'sanford-protocol'
-
-require 'sanford/host_data'
-require 'sanford/worker'
+require 'socket'
+require 'sanford/logger'
+require 'sanford/router'
+require 'sanford/server_data'
+require 'sanford/template_source'
+require 'sanford/connection_handler'
 
 module Sanford
 
-  class Server
-    include DatTCP::Server
-
-    attr_reader :sanford_host, :sanford_host_data, :sanford_host_options
+  module Server
 
-    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
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
     end
 
-    # 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
+    module InstanceMethods
 
-    def configure_tcp_server(tcp_server)
-      tcp_server.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
-    end
+      attr_reader :server_data, :dat_tcp_server
 
-    def on_run
-      @sanford_host_data = Sanford::HostData.new(@sanford_host, @sanford_host_options)
-    end
+      def initialize
+        self.class.configuration.validate!
+        @server_data = ServerData.new(self.class.configuration.to_hash)
+        @dat_tcp_server = DatTCP::Server.new{ |socket| serve(socket) }
+      rescue InvalidError => exception
+        exception.set_backtrace(caller)
+        raise exception
+      end
+
+      def name
+        @server_data.name
+      end
+
+      def ip
+        @dat_tcp_server.ip
+      end
+
+      def port
+        @dat_tcp_server.port
+      end
+
+      def file_descriptor
+        @dat_tcp_server.file_descriptor
+      end
+
+      def client_file_descriptors
+        @dat_tcp_server.client_file_descriptors
+      end
+
+      def pid_file
+        @server_data.pid_file
+      end
+
+      def logger
+        @server_data.logger
+      end
+
+      def listen(*args)
+        args = [ @server_data.ip, @server_data.port ] if args.empty?
+        @dat_tcp_server.listen(*args) do |server_socket|
+          configure_tcp_server(server_socket)
+        end
+      end
+
+      def start(*args)
+        @dat_tcp_server.start(*args)
+      end
+
+      def pause(*args)
+        @dat_tcp_server.pause(*args)
+      end
+
+      def stop(*args)
+        @dat_tcp_server.stop(*args)
+      end
+
+      def halt(*args)
+        @dat_tcp_server.halt(*args)
+      end
+
+      def paused?
+        @dat_tcp_server.listening? && !@dat_tcp_server.running?
+      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.
+      private
 
-    def serve!(socket)
-      connection = Connection.new(socket)
-      if !self.keep_alive_connection?(connection)
-        Sanford::Worker.new(@sanford_host_data, connection).run
+      def serve(socket)
+        connection = Connection.new(socket)
+        if !keep_alive_connection?(connection)
+          Sanford::ConnectionHandler.new(@server_data, connection).run
+        end
+      end
+
+      def keep_alive_connection?(connection)
+        @server_data.receives_keep_alive && connection.peek_data.empty?
+      end
+
+      # 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
+
     end
 
-    protected
+    module ClassMethods
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def name(*args)
+        self.configuration.name *args
+      end
+
+      def ip(*args)
+        self.configuration.ip *args
+      end
+
+      def port(*args)
+        self.configuration.port *args
+      end
+
+      def pid_file(*args)
+        self.configuration.pid_file *args
+      end
+
+      def receives_keep_alive(*args)
+        self.configuration.receives_keep_alive *args
+      end
+
+      def verbose_logging(*args)
+        self.configuration.verbose_logging *args
+      end
+
+      def logger(*args)
+        self.configuration.logger *args
+      end
+
+      def init(&block)
+        self.configuration.init_procs << block
+      end
+
+      def error(&block)
+        self.configuration.error_procs << block
+      end
+
+      def router(value = nil, &block)
+        self.configuration.router = value if !value.nil?
+        self.configuration.router.instance_eval(&block) if block
+        self.configuration.router
+      end
+
+      def template_source(*args)
+        self.configuration.template_source(*args)
+      end
+
+      def build_template_source(path, &block)
+        block ||= proc{ }
+        self.template_source TemplateSource.new(path).tap(&block)
+      end
 
-    def keep_alive_connection?(connection)
-      @sanford_host_data.keep_alive && connection.peek_data.empty?
     end
 
     class Connection
-
       DEFAULT_TIMEOUT = 1
 
+      attr_reader :timeout
+
       def initialize(socket)
         @socket     = socket
         @connection = Sanford::Protocol::Connection.new(@socket)
@@ -80,11 +199,9 @@ module Sanford
       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
@@ -96,11 +213,11 @@ module Sanford
       if RUBY_PLATFORM =~ /linux/
         # 3 == TCP_CORK
         def self.apply(socket)
-          socket.setsockopt(Socket::IPPROTO_TCP, 3, true)
+          socket.setsockopt(::Socket::IPPROTO_TCP, 3, true)
         end
 
         def self.remove(socket)
-          socket.setsockopt(Socket::IPPROTO_TCP, 3, false)
+          socket.setsockopt(::Socket::IPPROTO_TCP, 3, false)
         end
       else
         def self.apply(socket)
@@ -109,9 +226,61 @@ module Sanford
         def self.remove(socket)
         end
       end
+    end
+
+    class Configuration
+      include NsOptions::Proxy
 
+      option :name,     String,  :required => true
+      option :ip,       String,  :required => true, :default => '0.0.0.0'
+      option :port,     Integer, :required => true
+      option :pid_file, Pathname
+
+      option :receives_keep_alive, NsOptions::Boolean, :default => false
+
+      option :verbose_logging, :default => true
+      option :logger,          :default => proc{ NullLogger.new }
+      option :template_source, :default => proc{ NullTemplateSource.new }
+
+      attr_accessor :init_procs, :error_procs
+      attr_accessor :router
+
+      def initialize(values = nil)
+        super(values)
+        @init_procs, @error_procs = [], []
+        @router = Sanford::Router.new
+        @valid = nil
+      end
+
+      def routes
+        @router.routes
+      end
+
+      def to_hash
+        super.merge({
+          :error_procs => self.error_procs,
+          :routes => self.routes,
+          :template_source => self.template_source
+        })
+      end
+
+      def valid?
+        !!@valid
+      end
+
+      def validate!
+        return @valid if !@valid.nil?
+        self.init_procs.each(&:call)
+        if !self.required_set?
+          raise InvalidError, "a name, ip and port must be configured"
+        end
+        self.routes.each(&:validate!)
+        @valid = true
+      end
     end
 
+    InvalidError = Class.new(RuntimeError)
+
   end
 
 end