textgoeshere-daemon-kit 0.1.8rc3

data/lib/daemon_kit/abstract_logger.rb

@@ -0,0 +1,249 @@
+require 'logger'
+
+module DaemonKit
+  # One of the key parts of succesful background processes is adequate
+  # logging. The AbstractLogger aims to simplify logging from inside
+  # daemon processes by providing additional useful information with
+  # each log line, including calling file name and line number and
+  # support for cleanly logging exceptions.
+  #
+  # The logger can be accessed through #DaemonKit.logger.
+  #
+  # AbstractLogger provides an interface that is fully compatible with
+  # the Logger class provided by Ruby's Standard Library, and is
+  # extended with some additional conveniences.
+  #
+  # The AbstractLogger supports different backends, by default it uses
+  # a Logger instance, but can by swapped out for a SysLogLogger
+  # logger as well.
+  class AbstractLogger
+
+    attr_accessor :copy_to_stdout
+
+    @severities = {
+      :debug   => Logger::DEBUG,
+      :info    => Logger::INFO,
+      :warn    => Logger::WARN,
+      :error   => Logger::ERROR,
+      :fatal   => Logger::FATAL,
+      :unknown => Logger::UNKNOWN
+    }
+
+    @silencer = true
+
+    class << self
+      attr_reader :severities
+      attr_accessor :silencer
+    end
+
+    # Optional log path, defaults to
+    # <em>DAEMON_ROOT/log/DAEMON_ENV.log</em>
+    def initialize( log_path = nil )
+      if log_path.to_s == "syslog"
+        @backend = :syslog
+      else
+        @logger_file = log_path || "#{DAEMON_ROOT}/log/#{DAEMON_ENV}.log"
+        @backend = :logger
+      end
+
+      @copy_to_stdout = false
+    end
+
+    # Silence the logger for the duration of the block.
+    def silence( temporary_level = :error )
+      if self.class.silencer
+        begin
+          old_level, self.level = self.level, temporary_level
+          yield self
+        ensure
+          self.level = old_level
+        end
+      else
+        yield self
+      end
+    end
+
+    # Write unformatted message to logging device, mostly useful for Logger interface
+    # compatibility and debugging soap4r (possibly others)
+    def <<( msg ) #:nodoc:
+      self.logger.write( msg ) if self.logger && self.logger.respond_to?( :write )
+    end
+
+    def debug( msg = nil, &block )
+      add( :debug, msg, &block )
+    end
+
+    def debug?
+      self.level == :debug
+    end
+
+    def info( msg = nil, &block )
+      add( :info, msg, &block )
+    end
+
+    def info?
+      self.level == :info
+    end
+
+    def warn( msg = nil, &block )
+      add( :warn, msg, &block )
+    end
+
+    def warn?
+      self.level == :warn
+    end
+
+    def error( msg = nil, &block )
+      add( :error, msg, &block )
+    end
+
+    def error?
+      self.level == :error
+    end
+
+    def fatal( msg = nil, &block )
+      add( :fatal, msg, &block )
+    end
+
+    def fatal?
+      self.level == :fatal
+    end
+
+    def unknown( msg = nil, &block )
+      add( :unknown, msg, &block )
+    end
+
+    def unknown?
+      self.level == :unknown
+    end
+
+    # Conveniently log an exception and the backtrace
+    def exception( e )
+      message = "EXCEPTION: #{e.message}: #{clean_trace( e.backtrace )}"
+      self.add( :error, message, true )
+    end
+
+    def add( severity, message = nil, skip_caller = false, &block )
+      message = yield if block_given?
+
+      message = "#{called(caller)}: #{message}" unless skip_caller
+
+      self.logger.add( self.class.severities[ severity ] ) { message }
+
+      STDOUT.puts( message ) if self.copy_to_stdout
+    end
+
+    def level
+      self.class.severities.invert[ @logger.level ]
+    end
+
+    def level=( level )
+      level = ( Symbol === level ? self.class.severities[ level ] : level )
+      self.logger.level = level
+    end
+
+    def logger
+      @logger ||= create_logger
+    end
+
+    def logger=( logger )
+      if logger.is_a?( Symbol )
+        @backend = logger
+        @logger.close rescue nil
+        @logger = create_logger
+      else
+        @logger.close rescue nil
+        @logger = logger
+      end
+    end
+
+    def clean_trace( trace )
+      trace = trace.map { |l| l.gsub(DAEMON_ROOT, '') }
+      trace = trace.reject { |l| l =~ /gems\/daemon[\-_]kit/ }
+      trace = trace.reject { |l| l =~ /vendor\/daemon[\-_]kit/ }
+      trace
+    end
+
+    def close
+      case @backend
+      when :logger
+        self.logger.close
+        @logger = nil
+      end
+    end
+
+    private
+
+    def called( trace )
+      l = trace.detect('unknown:0') { |l| l.index('abstract_logger.rb').nil? }
+      file, num, _ = l.split(':')
+
+      if file =~ /daemon[\-_]kit/
+        "[daemon-kit]"
+
+      else
+        [ File.basename(file), num ].join(':')
+      end
+    end
+
+    def create_logger
+      case @backend
+      when :logger
+        create_standard_logger
+      when :syslog
+        create_syslog_logger
+      end
+    end
+
+    def create_standard_logger
+      log_path = File.dirname( @logger_file )
+      unless File.directory?( log_path )
+        begin
+          FileUtils.mkdir_p( log_path )
+        rescue
+          STDERR.puts "#{log_path} not writable, using STDERR for logging"
+          @logger_file = STDERR
+        end
+      end
+
+      l = Logger.new( @logger_file )
+      l.formatter = Formatter.new
+      l.progname = if DaemonKit.configuration
+                     DaemonKit.configuration.daemon_name
+                   else
+                     File.basename($0)
+                   end
+      l
+    end
+
+    def create_syslog_logger
+      begin
+        require 'syslog_logger'
+        SyslogLogger.new( DaemonKit.configuration ? DaemonKit.configuration.daemon_name : File.basename($0) )
+      rescue LoadError
+        self.logger = :logger
+        self.error( "Couldn't load syslog_logger gem, reverting to standard logger" )
+      end
+    end
+
+    class Formatter
+
+      # YYYY:MM:DD HH:MM:SS.MS daemon_name(pid) level: message
+      @format = "%s %s(%d) [%s] %s\n"
+
+      class << self
+        attr_accessor :format
+      end
+
+      def call(severity, time, progname, msg)
+        self.class.format % [ format_time( time ), progname, $$, severity, msg.to_s ]
+      end
+
+      private
+
+      def format_time( time )
+        time.strftime( "%Y-%m-%d %H:%M:%S." ) + time.usec.to_s
+      end
+    end
+  end
+end

data/lib/daemon_kit/amqp.rb

@@ -0,0 +1,39 @@
+require 'yaml'
+require 'mq'
+
+module DaemonKit
+  # Thin wrapper around the amqp gem, specifically designed to ease
+  # configuration of a AMQP consumer daemon and provide some added
+  # simplicity
+  class AMQP
+
+    @@instance = nil
+
+    class << self
+
+      def instance
+        @instance ||= new
+      end
+
+      private :new
+
+      def run(&block)
+        instance.run(&block)
+      end
+    end
+
+    def initialize( config = {} )
+      @config = DaemonKit::Config.load('amqp').to_h( true )
+    end
+
+    def run(&block)
+      # Ensure graceful shutdown of the connection to the broker
+      DaemonKit.trap('INT') { ::AMQP.stop { ::EM.stop } }
+      DaemonKit.trap('TERM') { ::AMQP.stop { ::EM.stop } }
+
+      # Start our event loop and AMQP client
+      DaemonKit.logger.debug("AMQP.start(#{@config.inspect})")
+      ::AMQP.start(@config, &block)
+    end
+  end
+end

data/lib/daemon_kit/application.rb

@@ -0,0 +1,230 @@
+require 'timeout'
+
+module DaemonKit
+
+  # Class responsible for making the daemons run and keep them running.
+  class Application
+
+    class << self
+
+      # Run the specified file as a daemon process.
+      def exec( file )
+        raise DaemonNotFound.new( file ) unless File.exist?( file )
+
+        DaemonKit.configuration.daemon_name ||= File.basename( file )
+
+        command, configs, args = Arguments.parse( ARGV )
+
+        case command
+        when :run
+          parse_arguments( args )
+          run( file )
+        when :start
+          parse_arguments( args )
+          start( file )
+        when :stop
+          stop
+        end
+      end
+
+      # Run the daemon in the foreground without daemonizing
+      def run( file )
+        self.chroot
+        self.clean_fd
+        self.redirect_io( true )
+
+        DaemonKit.configuration.log_stdout = true
+
+        require file
+      end
+
+      # Run our file properly
+      def start( file )
+        self.drop_privileges
+        self.daemonize
+        self.chroot
+        self.clean_fd
+        self.redirect_io
+
+        require file
+      end
+
+      def stop
+        @pid_file = PidFile.new( DaemonKit.configuration.pid_file )
+
+        unless @pid_file.running?
+          @pid_file.cleanup
+          puts "Nothing to stop"
+          exit
+        end
+
+        target_pid = @pid_file.pid
+
+        puts "Sending TERM to #{target_pid}"
+        Process.kill( 'TERM', target_pid )
+
+        if seconds = DaemonKit.configuration.force_kill_wait
+          begin
+            Timeout::timeout( seconds ) do
+              loop do
+                puts "Waiting #{seconds} seconds for #{target_pid} before sending KILL"
+
+                break unless @pid_file.running?
+
+                seconds -= 1
+                sleep 1
+              end
+            end
+          rescue Timeout::Error
+            Process.kill( 'KILL', target_pid )
+          end
+        end
+
+        if @pid_file.running?
+          puts "Process still running, leaving pidfile behind! Consider using configuration.force_kill_wait."
+        else
+          @pid_file.cleanup
+        end
+      end
+
+      # Call this from inside a daemonized process to complete the
+      # initialization process
+      def running!
+        Initializer.continue!
+
+        yield DaemonKit.configuration if block_given?
+      end
+
+      # Exit the daemon
+      # TODO: Make configurable callback chain
+      # TODO: Hook into at_exit()
+      def exit!( code = 0 )
+      end
+
+      # http://gist.github.com/304739
+      #
+      # Stolen from Unicorn::Util
+      #
+      # This reopens ALL logfiles in the process that have been rotated
+      # using logrotate(8) (without copytruncate) or similar tools.
+      # A +File+ object is considered for reopening if it is:
+      #   1) opened with the O_APPEND and O_WRONLY flags
+      #   2) opened with an absolute path (starts with "/")
+      #   3) the current open file handle does not match its original open path
+      #   4) unbuffered (as far as userspace buffering goes, not O_SYNC)
+      # Returns the number of files reopened
+      def reopen_logs
+        nr = 0
+        append_flags = File::WRONLY | File::APPEND
+        DaemonKit.logger.info "Rotating logs" if DaemonKit.logger
+
+        #logs = [STDOUT, STDERR]
+        #logs.each do |fp|
+        ObjectSpace.each_object(File) do |fp|
+          next if fp.closed?
+          next unless (fp.sync && fp.path[0..0] == "/")
+          next unless (fp.fcntl(Fcntl::F_GETFL) & append_flags) == append_flags
+
+          begin
+            a, b = fp.stat, File.stat(fp.path)
+            next if a.ino == b.ino && a.dev == b.dev
+          rescue Errno::ENOENT
+          end
+
+          open_arg = 'a'
+          if fp.respond_to?(:external_encoding) && enc = fp.external_encoding
+            open_arg << ":#{enc.to_s}"
+            enc = fp.internal_encoding and open_arg << ":#{enc.to_s}"
+          end
+          DaemonKit.logger.info "Rotating path: #{fp.path}" if DaemonKit.logger
+          fp.reopen(fp.path, open_arg)
+          fp.sync = true
+          nr += 1
+        end # each_object
+        nr
+      end
+
+      protected
+
+      def parse_arguments( args )
+        DaemonKit.arguments = Arguments.new
+        DaemonKit.arguments.parse( args )
+      end
+
+      # Daemonize the process
+      def daemonize
+        @pid_file = PidFile.new( DaemonKit.configuration.pid_file )
+        @pid_file.ensure_stopped!
+
+        if RUBY_VERSION < "1.9"
+          exit if fork
+          Process.setsid
+          exit if fork
+        else
+          Process.daemon( true, true )
+        end
+
+        @pid_file.write!
+
+        # TODO: Convert into shutdown hook
+        at_exit { @pid_file.cleanup }
+      end
+
+      # Release the old working directory and insure a sensible umask
+      # TODO: Make chroot directory configurable
+      def chroot
+        Dir.chdir '/'
+        File.umask 0000
+      end
+
+      # Make sure all file descriptors are closed (with the exception
+      # of STDIN, STDOUT & STDERR)
+      def clean_fd
+        ObjectSpace.each_object(IO) do |io|
+          unless [STDIN, STDOUT, STDERR].include?(io)
+            begin
+              unless io.closed?
+                io.close
+              end
+            rescue ::Exception
+            end
+          end
+        end
+      end
+
+      # Redirect our IO
+      # TODO: make this configurable
+      def redirect_io( simulate = false )
+        begin
+          STDIN.reopen '/dev/null'
+        rescue ::Exception
+        end
+
+        unless simulate
+          STDOUT.reopen '/dev/null', 'a'
+          STDERR.reopen '/dev/null', 'a'
+        end
+      end
+
+      def drop_privileges
+        if DaemonKit.configuration.group
+          begin
+            group = Etc.getgrnam( DaemonKit.configuration.group )
+            Process::Sys.setgid( group.gid.to_i )
+          rescue => e
+            $stderr.puts "Caught exception while trying to drop group privileges: #{e.message}"
+          end
+        end
+        if DaemonKit.configuration.user
+          begin
+            user = Etc.getpwnam( DaemonKit.configuration.user )
+            Process::Sys.setuid( user.uid.to_i )
+          rescue => e
+            $stderr.puts "Caught exception while trying to drop user privileges: #{e.message}"
+          end
+        end
+      end
+    end
+
+  end
+end