skaar-daemon-kit 0.1.7.10

data/lib/daemon_kit/em.rb

@@ -0,0 +1,43 @@
+module DaemonKit
+
+  # EventMachine forms a critical part of the daemon-kit toolset, and
+  # especially of daemon process developers.
+  #
+  # This class abstracts away the difficulties of managing multiple
+  # libraries that all utilize the event reactor.
+  class EM
+
+    class << self
+
+      # Start a reactor, just like classical EM.run. If the block is
+      # provided, the method will block and call the provided block
+      # argument inside the running reactor. If the block argument is
+      # not provided the reactor will be started in a separate thread
+      # and the program will continue to run after the method. All the
+      # signal traps are configured to shutdown the reactor when the
+      # daemon exists.
+      def run(&block)
+        if ::EM.reactor_running?
+          DaemonKit.logger.warn "EventMachine reactor already running"
+          block.call if block_given?
+
+        else
+          if block_given?
+            ::EM.run { block.call }
+          else
+            Thread.main[:_dk_reactor] = Thread.new { EM.run {} }
+            DaemonKit.trap( 'INT' ) { DaemonKit::EM.stop  }
+            DaemonKit.trap( 'TERM' ) { DaemonKit::EM.stop }
+          end
+        end
+      end
+
+      # Stop the reactor
+      def stop
+        ::EM.stop_event_loop if ::EM.reactor_running?
+        Thread.main[:_dk_reactor].join
+      end
+    end
+
+  end
+end

data/lib/daemon_kit/error_handlers/base.rb

@@ -0,0 +1,32 @@
+module DaemonKit
+  module ErrorHandlers
+    # Error handlers in DaemonKit are used by the #Safety class. Any
+    # error handler has to support the interface provided by this
+    # class. It's also required that safety handlers implement a
+    # singleton approach (handled by default by #Base).
+    class Base
+
+      class << self
+        
+        @instance = nil
+
+        def instance
+          @instance ||= new
+        end
+        private :new
+        
+        # When we're inherited, immediately register the handler with
+        # the safety net
+        def inherited( child ) #:nodoc:
+          Safety.register_error_handler( child )
+        end
+      end
+      
+      # Error handlers should overwrite this method and implement
+      # their own reporting method.
+      def handle_exception( exception )
+        raise NoMethodError, "Error handler doesn't support #handle_exception"
+      end
+    end
+  end
+end

data/lib/daemon_kit/error_handlers/hoptoad.rb

@@ -0,0 +1,61 @@
+require 'net/http'
+
+module DaemonKit
+  module ErrorHandlers
+    # Error reporting via Hoptoad.
+    class Hoptoad < Base
+
+      # Your hoptoad API key
+      @api_key = nil
+      attr_accessor :api_key
+
+      def handle_exception( exception )
+        headers = {
+          'Content-type' => 'application/x-yaml',
+          'Accept' => 'text/xml, application/xml'
+        }
+
+        http = Net::HTTP.new( url.host, url.port )
+        data = clean_exception( exception )
+
+        response = begin
+                     http.post( url.path, data.to_yaml, headers )
+                   rescue TimoutError => e
+                     DaemonKit.logger.error("Timeout while contacting the Hoptoad server.")
+                     nil
+                   end
+        case response
+        when Net::HTTPSuccess then
+          DaemonKit.logger.info "Hoptoad Success: #{response.class}"
+        else
+          DaemonKit.logger.error "Hoptoad Failure: #{response.class}\n#{response.body if response.respond_to? :body}"
+        end
+      end
+
+      def url
+        URI.parse("http://hoptoadapp.com/notices/")
+      end
+
+      def clean_exception( exception )
+        data = {
+          :api_key       => self.api_key,
+          :error_class   => exception.class.name,
+          :error_message => "#{exception.class.name}: #{exception.message}",
+          :backtrace     => exception.backtrace,
+          :environment   => ENV.to_hash,
+          :request       => [],
+          :session       => []
+        }
+
+        stringify_keys( data )
+      end
+
+      def stringify_keys(hash) #:nodoc:
+        hash.inject({}) do |h, pair|
+          h[pair.first.to_s] = pair.last.is_a?(Hash) ? stringify_keys(pair.last) : pair.last
+          h
+        end
+      end
+    end
+  end
+end

data/lib/daemon_kit/error_handlers/mail.rb

@@ -0,0 +1,85 @@
+require DaemonKit.framework_root + '/vendor/tmail'
+require 'net/smtp'
+
+module DaemonKit
+  module ErrorHandlers
+    # Send an email notification of the exception via SMTP.
+    class Mail < Base
+
+      # SMTP hostname
+      @host = 'localhost'
+
+      # SMTP port
+      @port = 25
+
+      # Recipients of the notification
+      @recipients = []
+
+      # Subject prefix
+      @prefix = '[DAEMON-KIT]'
+
+      # Sender address
+      @sender = 'daemon-kit'
+
+      # SMTP username
+      @username = nil
+
+      # SMTP password
+      @password = nil
+
+      # Authentication mechanism (:plain, :login, or :cram_md5)
+      @authentication = nil
+
+      # Use TLS?
+      @tls = false
+
+      # Domain used when talking to SMTP server
+      @domain = 'localhost.localdomain'
+
+      class << self
+        attr_accessor :host, :port, :recipients, :prefix, :sender, :username,
+        :password, :authentication, :tls, :domain
+      end
+
+      [ :host, :port, :recipients, :prefix, :sender, :username, :password,
+        :authentication, :tls, :domain ].each do |cm|
+        class_eval(<<-EOM, __FILE__, __LINE__)
+          def #{cm}=( val )
+            self.class.#{cm} = val
+          end
+        EOM
+      end
+
+      def handle_exception( exception )
+
+        mail = TMail::Mail.new
+        mail.to = self.class.recipients
+        mail.from = self.class.sender
+        mail.subject = "#{self.class.prefix} #{exception.message}"
+        mail.set_content_type 'text', 'plain'
+        mail.mime_version = '1.0'
+        mail.date = Time.now
+
+        mail.body = <<EOF
+DaemonKit caught an exception inside #{DaemonKit.configuration.daemon_name}.
+
+Message: #{exception.message}
+Backtrace:
+#{exception.backtrace.join("\n  ")}
+
+Environment: #{ENV.inspect}
+EOF
+        begin
+          smtp = Net::SMTP.new( self.class.host, self.class.port )
+          smtp.enable_starttls_auto if self.class.tls && smtp.respond_to?(:enable_starttls_auto)
+          smtp.start( self.class.domain, self.class.username, self.class.password,
+                      self.class.authentication ) do |smtp|
+            smtp.sendmail( mail.to_s, mail.from, mail.to )
+          end
+        rescue => e
+          DaemonKit.logger.error "Failed to send exception mail: #{e.message}" if DaemonKit.logger
+        end
+      end
+    end
+  end
+end

data/lib/daemon_kit/exceptions.rb

@@ -0,0 +1,15 @@
+module DaemonKit
+  # The core of daemon-kit exceptions
+  class Exception < ::StandardError
+  end
+
+  # Raised when no class is registered to process a ruote workitem
+  class MissingParticipant < Exception; end
+
+  # Raised when the daemon itself cannot be found.
+  class DaemonNotFound < Exception
+    def initialize( file )
+      super "No daemon found at the path '#{file}'"
+    end
+  end
+end

data/lib/daemon_kit/initializer.rb

@@ -0,0 +1,438 @@
+require 'pathname'
+
+DAEMON_ENV = (ENV['DAEMON_ENV'] || 'development').dup unless defined?(DAEMON_ENV)
+
+# Absolute paths to the daemon_kit libraries added to $:
+incdir = ( File.dirname(__FILE__) + '/..' )
+absincdir = if RUBY_PLATFORM =~ /(:?mswin|mingw)/
+              File.expand_path( incdir )
+            else
+              File.expand_path( Pathname.new( incdir ).realpath.to_s )
+            end
+$:.unshift absincdir unless $:.include?( absincdir )
+
+require 'daemon_kit'
+
+module DaemonKit
+
+  class << self
+
+    def configuration
+      @configuration
+    end
+
+    def configuration=( configuration )
+      @configuration = configuration
+    end
+
+    def arguments
+      @arguments
+    end
+
+    def arguments=( args )
+      @arguments = args
+    end
+
+    def trap( *args, &block )
+      self.configuration.trap( *args, &block )
+    end
+
+    def at_shutdown( &block )
+      self.configuration.at_shutdown( &block )
+    end
+
+  end
+
+
+  # This class does all the nightmare work of setting up a working
+  # environment for your daemon.
+  class Initializer
+
+    attr_reader :configuration
+
+    def self.run
+      configuration = DaemonKit.configuration || Configuration.new
+
+      yield configuration if block_given?
+      initializer = new configuration
+      initializer.before_daemonize
+      initializer
+    end
+
+    def self.continue!
+      initializer = new DaemonKit.configuration
+      initializer.after_daemonize
+    end
+
+    def self.shutdown( clean = false )
+      return unless $daemon_kit_shutdown_hooks_ran.nil?
+      $daemon_kit_shutdown_hooks_ran = true
+
+      DaemonKit.logger.info "Running shutdown hooks"
+
+      DaemonKit.configuration.shutdown_hooks.each do |hook|
+        begin
+          hook.call
+        rescue => e
+          DaemonKit.logger.exception( e )
+        end
+      end
+
+      log_exceptions if DaemonKit.configuration.backtraces && !clean
+
+      DaemonKit.logger.warn "Shutting down #{DaemonKit.configuration.daemon_name}"
+      exit
+    end
+
+    def initialize( configuration )
+      @configuration = configuration
+    end
+
+    def before_daemonize
+      DaemonKit.configuration = @configuration
+
+      set_load_path
+      load_gems
+      load_patches
+      load_environment
+      load_predaemonize_configs
+    end
+
+    def after_daemonize
+      set_umask
+
+      initialize_logger
+      initialize_signal_traps
+
+      include_core_lib
+      load_postdaemonize_configs
+      configure_backtraces
+
+      set_process_name
+
+      DaemonKit.logger.info( "DaemonKit (#{DaemonKit::VERSION}) booted, now running #{DaemonKit.configuration.daemon_name}" )
+
+      if DaemonKit.configuration.user || DaemonKit.configuration.group
+        euid = Process.euid
+	egid = Process.egid
+	uid = Process.uid
+	gid = Process.gid
+      	DaemonKit.logger.info( "DaemonKit dropped privileges to: #{euid} (EUID), #{egid} (EGID), #{uid} (UID), #{gid} (GID)"  )
+      end
+    end
+
+    def set_load_path
+      configuration.load_paths.each do |d|
+        $:.unshift( "#{DAEMON_ROOT}/#{d}" ) if File.directory?( "#{DAEMON_ROOT}/#{d}" )
+      end
+    end
+
+    def load_gems
+
+    end
+
+    def load_patches
+
+    end
+
+    def load_environment
+      return if @environment_loaded
+      @environment_loaded = true
+
+      config = configuration
+
+      eval(IO.read(configuration.environment_path), binding, configuration.environment_path)
+
+      eval(IO.read(configuration.daemon_initializer), binding, configuration.daemon_initializer) if File.exist?( configuration.daemon_initializer )
+    end
+
+    def load_predaemonize_configs
+      Dir[ File.join( DAEMON_ROOT, 'config', 'pre-daemonize', '*.rb' ) ].each do |f|
+        next if File.basename( f ) == File.basename( configuration.daemon_initializer )
+
+        require f
+      end
+    end
+
+    def load_postdaemonize_configs
+      Dir[ File.join( DAEMON_ROOT, 'config', 'post-daemonize', '*.rb' ) ].each do |f|
+        require f
+      end
+    end
+
+    def set_umask
+      File.umask configuration.umask
+    end
+
+    def initialize_logger
+      return if DaemonKit.logger
+
+      unless logger = configuration.logger
+        logger = AbstractLogger.new( configuration.log_path )
+        logger.level = configuration.log_level
+        logger.copy_to_stdout = configuration.log_stdout
+      end
+
+      DaemonKit.logger = logger
+
+      DaemonKit.logger.info "DaemonKit (#{DaemonKit::VERSION}) booting in #{DAEMON_ENV} mode"
+
+      configuration.trap("USR1") {
+        DaemonKit.logger.level = DaemonKit.logger.debug? ? :info : :debug
+        DaemonKit.logger.info "Log level changed to #{DaemonKit.logger.debug? ? 'DEBUG' : 'INFO' }"
+      }
+      configuration.trap("USR2") {
+        DaemonKit.logger.level = :debug
+        DaemonKit.logger.info "Log level changed to DEBUG"
+      }
+      configuration.trap("HUP") {
+        DaemonKit.logger.close
+      }
+    end
+
+    def initialize_signal_traps
+      term_proc = Proc.new { DaemonKit::Initializer.shutdown( true ) }
+      configuration.trap( 'INT', term_proc )
+      configuration.trap( 'TERM', term_proc )
+      at_exit { DaemonKit::Initializer.shutdown }
+    end
+
+    def include_core_lib
+      if File.exists?( core_lib = File.join( DAEMON_ROOT, 'lib', configuration.daemon_name + '.rb' ) )
+        require core_lib
+      end
+    end
+
+    def configure_backtraces
+      Thread.abort_on_exception = configuration.backtraces
+    end
+
+    def set_process_name
+      $0 = configuration.daemon_name
+    end
+
+    def self.log_exceptions
+      trace_file = File.join( DaemonKit.root, "backtrace-#{Time.now.strftime('%Y%m%d%H%M%S')}-#{Process.pid}.log" )
+      trace_log = Logger.new( trace_file )
+
+      # Find the last exception
+      e = nil
+      ObjectSpace.each_object {|o|
+        if ::Exception === o
+          e = o
+        end
+      }
+
+      trace_log.info "*** Below you'll find the most recent exception thrown, this will likely (but not certainly) be the exception that made #{DaemonKit.configuration.daemon_name} exit abnormally ***"
+      trace_log.error e
+
+      trace_log.info "*** Below you'll find all the exception objects in memory, some of them may have been thrown in your application, others may just be in memory because they are standard exceptions ***"
+      ObjectSpace.each_object {|o|
+        if ::Exception === o
+          trace_log.error o
+        end
+      }
+
+      trace_log.close
+    end
+  end
+
+  # Holds our various configuration values
+  class Configuration
+
+    include Configurable
+
+    # Root to the daemon
+    attr_reader :root_path
+
+    # List of load paths
+    attr_accessor :load_paths
+
+    # Custom logger instance to use
+    attr_accessor :logger
+
+    # The log level to use, defaults to DEBUG
+    attr_accessor :log_level
+
+    # Path to the log file, defaults to 'log/<environment>.log'
+    configurable :log_path
+
+    # Duplicate log data to stdout
+    attr_accessor :log_stdout
+
+    # Path to the pid file, defaults to 'log/<daemon_name>.pid'
+    attr_accessor :pid_file
+
+    # The application name
+    configurable :daemon_name, :locked => true
+
+    # Use the force kill patch? Give the number of seconds
+    configurable :force_kill_wait
+
+    # Should be log backtraces
+    configurable :backtraces, false
+
+    # Configurable umask
+    configurable :umask, 0022
+
+    # Configurable user
+    configurable :user, :locked => true
+
+    # Confgiruable group
+    configurable :group, :locked => true
+
+    # Collection of signal traps
+    attr_reader :signal_traps
+
+    # Our safety net (#Safety) instance
+    attr_accessor :safety_net
+    
+    # :nodoc: Shutdown hooks
+    attr_reader :shutdown_hooks
+
+    def initialize
+      parse_arguments!
+
+      set_root_path!
+      set_daemon_defaults!
+
+      self.load_paths = default_load_paths
+      self.log_level  ||= default_log_level
+      self.log_path   ||= default_log_path
+
+      self.force_kill_wait = false
+
+      self.safety_net = DaemonKit::Safety.instance
+
+      @signal_traps = {}
+      @shutdown_hooks = []
+    end
+
+    def environment
+      ::DAEMON_ENV
+    end
+
+    # The path to the current environment's file (<tt>development.rb</tt>, etc.). By
+    # default the file is at <tt>config/environments/#{environment}.rb</tt>.
+    def environment_path
+      "#{root_path}/config/environments/#{environment}.rb"
+    end
+
+    def daemon_initializer
+      "#{root_path}/config/initializers/#{self.daemon_name}.rb"
+    end
+
+    # Add a trap for the specified signal, can be code block or a proc
+    def trap( signal, proc = nil, &block )
+      return if proc.nil? && !block_given?
+
+      unless @signal_traps.has_key?( signal )
+        set_trap( signal )
+      end
+
+      @signal_traps[signal].unshift( proc || block )
+    end
+
+    # Add a block or proc to be called during shutdown
+    def at_shutdown( proc = nil, &block )
+      return if proc.nil? && !block_given?
+
+      @shutdown_hooks << ( proc || block )
+    end
+
+    def pid_file
+      @pid_file ||= "#{File.dirname(self.log_path)}/#{self.daemon_name}.pid"
+    end
+
+    protected
+
+    def run_traps( signal )
+      DaemonKit.logger.info "Running signal traps for #{signal}"
+      self.signal_traps[ signal ].each { |trap| trap.call }
+    end
+
+    private
+
+    def set_trap( signal )
+      DaemonKit.logger.info "Setting up trap for #{signal}"
+      @signal_traps[ signal ] = []
+      Signal.trap( signal, Proc.new { self.run_traps( signal ) } )
+    end
+
+    def parse_arguments!
+      return unless own_args?
+
+      configs = Arguments.configuration( ARGV ).first
+      @unused_arguments = {}
+
+      configs.each do |c|
+        k,v = c.split('=')
+
+        if v.nil?
+          error( "#{k} has no value" )
+          next
+        end
+
+        begin
+          if self.respond_to?( k )
+            self.send( "#{k}=", v ) # pid_file = /var/run/foo.pid
+          else
+            @unused_arguments[ k ] = v
+          end
+        rescue => e
+          error( "Couldn't set `#{k}' to `#{v}': #{e.message}" )
+        end
+      end
+    end
+
+    # DANGEROUS: Change the value of DAEMON_ENV
+    def environment=( env )
+      ::DAEMON_ENV.replace( env )
+    end
+
+    def set_root_path!
+      raise "DAEMON_ROOT is not set" unless defined?(::DAEMON_ROOT)
+      raise "DAEMON_ROOT is not a directory" unless File.directory?(::DAEMON_ROOT)
+
+      @root_path = ::DAEMON_ROOT.to_absolute_path
+
+      Object.const_set(:RELATIVE_DAEMON_ROOT, ::DAEMON_ROOT.dup) unless defined?(::RELATIVE_DAEMON_ROOT)
+      ::DAEMON_ROOT.replace @root_path
+    end
+
+    def set_daemon_defaults!
+      self.log_stdout = false
+    end
+
+    def default_load_paths
+      [ 'lib' ]
+    end
+
+    def default_log_path
+      File.join(root_path, 'log', "#{environment}.log")
+    end
+
+    def default_log_level
+      environment == 'production' ? :info : :debug
+    end
+
+    def error( msg )
+      msg = "[E] Configuration: #{msg}"
+
+      if DaemonKit.logger
+        DaemonKit.logger.error( msg )
+      else
+        STDERR.puts msg
+      end
+    end
+
+    # If we are executed with any of these commands, don't allow
+    # arguments to be parsed cause they will interfere with the
+    # script encapsulating DaemonKit, like capistrano
+    def own_args?
+      ![ 'cap' ].include?( File.basename( $0 ) )
+    end
+  end
+
+
+end