daemons 1.1.9 → 1.4.1

data/lib/daemons/application.rb

@@ -2,80 +2,110 @@ require 'daemons/pidfile'
 require 'daemons/pidmem'
 require 'daemons/change_privilege'
 require 'daemons/daemonize'
+require 'daemons/exceptions'
+require 'daemons/reporter'
 
 require 'timeout'
 
-
 module Daemons
-
   class Application
-  
     attr_accessor :app_argv
     attr_accessor :controller_argv
-    
+
     # the Pid instance belonging to this application
     attr_reader :pid
-    
+
     # the ApplicationGroup the application belongs to
     attr_reader :group
-    
+
     # my private options
     attr_reader :options
-    
-    
+
     SIGNAL = (RUBY_PLATFORM =~ /win32/ ? 'KILL' : 'TERM')
-    
-    
+
     def initialize(group, add_options = {}, pid = nil)
       @group = group
       @options = group.options.dup
       @options.update(add_options)
-      
+
+      ['dir', 'log_dir', 'logfilename', 'output_logfilename'].each do |k|
+        @options[k] = File.expand_path(@options[k]) if @options.key?(k)
+      end
+
       @dir_mode = @dir = @script = nil
-      
+
       @force_kill_waittime = @options[:force_kill_waittime] || 20
-      
+
+      @signals_and_waits = parse_signals_and_waits(@options[:signals_and_waits])
+
+      @show_status_callback = method(:default_show_status)
+
+      @report = Reporter.new(@options)
+
       unless @pid = pid
         if @options[:no_pidfiles]
           @pid = PidMem.new
         elsif dir = pidfile_dir
-          @pid = PidFile.new(dir, @group.app_name, @group.multiple)
+          @pid = PidFile.new(dir, @group.app_name, @group.multiple, @options[:pid_delimiter])
         else
           @pid = PidMem.new
         end
       end
     end
-    
+
+    def show_status_callback=(function)
+      @show_status_callback =
+        if function.respond_to?(:call)
+          function
+        else
+          method(function)
+        end
+    end
+
     def change_privilege
       user = options[:user]
       group = options[:group]
-      CurrentProcess.change_privilege(user, group) if user
+      if user
+        @report.changing_process_privilege(user, group)
+        CurrentProcess.change_privilege(user, group)
+      end
     end
-    
+
     def script
-      @script || @group.script
+      @script or group.script
     end
-    
+
     def pidfile_dir
-      Pid.dir(@dir_mode || @group.dir_mode, @dir || @group.dir, @script || @group.script)
+      Pid.dir dir_mode, dir, script
     end
-    
+
     def logdir
-      logdir = options[:log_dir]
-      unless logdir
-        logdir = options[:dir_mode] == :system ? '/var/log' : pidfile_dir
-      end
-      logdir
+      options[:log_dir] or
+        options[:dir_mode] == :system ? '/var/log' : pidfile_dir
     end
-    
+
+    def output_logfilename
+      options[:output_logfilename] or "#{@group.app_name}.output"
+    end
+
     def output_logfile
-      (options[:log_output] && logdir) ? File.join(logdir, @group.app_name + '.output') : nil
+      if log_output_syslog?
+        'SYSLOG'
+      elsif log_output?
+        File.join logdir, output_logfilename
+      end
+    end
+
+    def logfilename
+      options[:logfilename] or "#{@group.app_name}.log"
     end
-    
+
     def logfile
-      logdir ? File.join(logdir, @group.app_name + '.log') : nil
+      if logdir
+        File.join logdir, logfilename
+      end
     end
-    
+
     # this function is only used to daemonize the currently running process (Daemons.daemonize)
     def start_none
       unless options[:ontop]
@@ -83,163 +113,158 @@ module Daemons
       else
         Daemonize.simulate(output_logfile)
       end
-      
+
       @pid.pid = Process.pid
-      
-      
+
       # We need this to remove the pid-file if the applications exits by itself.
-      # Note that <tt>at_text</tt> will only be run if the applications exits by calling 
+      # Note that <tt>at_text</tt> will only be run if the applications exits by calling
       # <tt>exit</tt>, and not if it calls <tt>exit!</tt> (so please don't call <tt>exit!</tt>
       # in your application!
       #
-      at_exit {
+      at_exit do
         begin; @pid.cleanup; rescue ::Exception; end
-        
+
         # If the option <tt>:backtrace</tt> is used and the application did exit by itself
         # create a exception log.
-        if options[:backtrace] and not options[:ontop] and not $daemons_sigterm
-          begin; exception_log(); rescue ::Exception; end
+        if options[:backtrace] && !options[:ontop] && !$daemons_sigterm
+          begin; exception_log; rescue ::Exception; end
         end
-          
-      }
-      
-      # This part is needed to remove the pid-file if the application is killed by 
+
+      end
+
+      # This part is needed to remove the pid-file if the application is killed by
       # daemons or manually by the user.
       # Note that the applications is not supposed to overwrite the signal handler for
       # 'TERM'.
       #
-      trap(SIGNAL) {
+      trap(SIGNAL) do
         begin; @pid.cleanup; rescue ::Exception; end
         $daemons_sigterm = true
-        
+
         if options[:hard_exit]
           exit!
         else
           exit
         end
-      }
+      end
     end
-    
+
     def start_exec
       if options[:backtrace]
-        puts "option :backtrace is not supported with :mode => :exec, ignoring"
+        @report.backtrace_not_supported
       end
-      
+
       unless options[:ontop]
         Daemonize.daemonize(output_logfile, @group.app_name)
       else
         Daemonize.simulate(output_logfile)
       end
-      
+
       # note that we cannot remove the pid file if we run in :ontop mode (i.e. 'ruby ctrl_exec.rb run')
       @pid.pid = Process.pid
-      
-      ENV['DAEMONS_ARGV'] = @controller_argv.join(' ')      
-      # haven't tested yet if this is really passed to the exec'd process...
-      
-      started()
-      Kernel.exec(script(), *(@app_argv || []))
+
+      ENV['DAEMONS_ARGV'] = @controller_argv.join(' ')
+
+      started
+      Kernel.exec(script, *(@app_argv || []))
     end
-    
+
     def start_load
       unless options[:ontop]
         Daemonize.daemonize(output_logfile, @group.app_name)
       else
         Daemonize.simulate(output_logfile)
       end
-      
+
       @pid.pid = Process.pid
-      
-      
+
       # We need this to remove the pid-file if the applications exits by itself.
-      # Note that <tt>at_exit</tt> will only be run if the applications exits by calling 
+      # Note that <tt>at_exit</tt> will only be run if the applications exits by calling
       # <tt>exit</tt>, and not if it calls <tt>exit!</tt> (so please don't call <tt>exit!</tt>
       # in your application!
       #
-      at_exit {
+      at_exit do
         begin; @pid.cleanup; rescue ::Exception; end
-        
+
         # If the option <tt>:backtrace</tt> is used and the application did exit by itself
         # create a exception log.
-        if options[:backtrace] and not options[:ontop] and not $daemons_sigterm
-          begin; exception_log(); rescue ::Exception; end
+        if options[:backtrace] && !options[:ontop] && !$daemons_sigterm
+          begin; exception_log; rescue ::Exception; end
         end
-          
-      }
-      
-      # This part is needed to remove the pid-file if the application is killed by 
+
+      end
+
+      # This part is needed to remove the pid-file if the application is killed by
       # daemons or manually by the user.
       # Note that the applications is not supposed to overwrite the signal handler for
       # 'TERM'.
       #
       $daemons_stop_proc = options[:stop_proc]
-      trap(SIGNAL) {
+      trap(SIGNAL) do
         begin
-        if $daemons_stop_proc
-          $daemons_stop_proc.call
-        end
+          if $daemons_stop_proc
+            $daemons_stop_proc.call
+          end
         rescue ::Exception
         end
-        
+
         begin; @pid.cleanup; rescue ::Exception; end
         $daemons_sigterm = true
-        
+
         if options[:hard_exit]
           exit!
         else
           exit
         end
-      }
-      
+      end
+
       # Now we really start the script...
       $DAEMONS_ARGV = @controller_argv
       ENV['DAEMONS_ARGV'] = @controller_argv.join(' ')
-      
+
       ARGV.clear
       ARGV.concat @app_argv if @app_argv
-      
-      started()
-      # TODO: begin - rescue - end around this and exception logging
-      load script()
+
+      started
+      # TODO: exception logging
+      load script
     end
-    
+
     def start_proc
       return unless p = options[:proc]
-    
-      myproc = proc do 
-        
-        @pid.pid = Process.pid
-        
+
+      myproc = proc do
+
         # We need this to remove the pid-file if the applications exits by itself.
-        # Note that <tt>at_text</tt> will only be run if the applications exits by calling 
+        # Note that <tt>at_text</tt> will only be run if the applications exits by calling
         # <tt>exit</tt>, and not if it calls <tt>exit!</tt> (so please don't call <tt>exit!</tt>
         # in your application!
         #
-        at_exit {
+        at_exit do
           begin; @pid.cleanup; rescue ::Exception; end
 
           # If the option <tt>:backtrace</tt> is used and the application did exit by itself
           # create a exception log.
-          if options[:backtrace] and not options[:ontop] and not $daemons_sigterm
-            begin; exception_log(); rescue ::Exception; end
+          if options[:backtrace] && !options[:ontop] && !$daemons_sigterm
+            begin; exception_log; rescue ::Exception; end
           end
 
-        }
+        end
 
-        # This part is needed to remove the pid-file if the application is killed by 
+        # This part is needed to remove the pid-file if the application is killed by
         # daemons or manually by the user.
         # Note that the applications is not supposed to overwrite the signal handler for
         # 'TERM'.
         #
         $daemons_stop_proc = options[:stop_proc]
-        trap(SIGNAL) {
+        trap(SIGNAL) do
           begin
-          if $daemons_stop_proc
-            $daemons_stop_proc.call
-          end
+            if $daemons_stop_proc
+              $daemons_stop_proc.call
+            end
           rescue ::Exception
           end
-          
+
           begin; @pid.cleanup; rescue ::Exception; end
           $daemons_sigterm = true
 
@@ -248,42 +273,28 @@ module Daemons
           else
             exit
           end
-        }
-        
-        started()
-        
-        p.call()
+        end
+        p.call
       end
-      
+
       unless options[:ontop]
-        Daemonize.call_as_daemon(myproc, output_logfile, @group.app_name)
-        
+        @pid.pid = Daemonize.call_as_daemon(myproc, output_logfile, @group.app_name)
+
       else
         Daemonize.simulate(output_logfile)
-        
+
         myproc.call
-        
-# why did we use this??
-#         Thread.new(&options[:proc])
-
-# why did we use the code below??
-        # unless pid = Process.fork
-        #   @pid.pid = pid
-        #   Daemonize.simulate(logfile)
-        #   options[:proc].call
-        #   exit
-        # else
-        #   Process.detach(@pid.pid)
-        # end
       end
-      
+      started
     end
-    
-    
-    def start
+
+    def start(restart = false)
       change_privilege
-      @group.create_monitor(@group.applications[0] || self) unless options[:ontop]  # we don't monitor applications in the foreground
-      
+
+      unless restart
+        @group.create_monitor(self) unless options[:ontop]  # we don't monitor applications in the foreground
+      end
+
       case options[:mode]
         when :none
           # this is only used to daemonize the currently running process
@@ -298,32 +309,14 @@ module Daemons
           start_load
       end
     end
-    
+
     def started
       if pid = @pid.pid
-        puts "#{self.group.app_name}: process with pid #{pid} started."
-        STDOUT.flush
+        @report.process_started(group.app_name, pid)
       end
     end
-    
-    
-#     def run
-#       if @group.controller.options[:exec]
-#         run_via_exec()
-#       else
-#         run_via_load()
-#       end
-#     end
-#      
-#     def run_via_exec
-#       
-#     end
-#     
-#     def run_via_load
-#       
-#     end
-
-	  def reload
+
+    def reload
       if @pid.pid == 0
         zap
         start
@@ -342,122 +335,112 @@ module Daemons
     # one cannot catch exceptions that are thrown in threads other than the main
     # thread.
     #
-    # This function searches for all exceptions in memory and outputs them to STDERR
+    # This function searches for all exceptions in memory and outputs them to $stderr
     # (if it is connected) and to a log file in the pid-file directory.
     #
     def exception_log
       return unless logfile
-      
+
       require 'logger'
-      
+
       l_file = Logger.new(logfile)
-      
+
       # the code below finds the last exception
       e = nil
-      
-      ObjectSpace.each_object {|o|
+
+      ObjectSpace.each_object do |o|
         if ::Exception === o
           e = o
         end
-      }
-     
-      l_file.info "*** below you find the most recent exception thrown, this will be likely (but not certainly) the exception that made the application exit abnormally ***"
+      end
+
+      l_file.info '*** below you find the most recent exception thrown, this will be likely (but not certainly) the exception that made the application exit abnormally ***'
       l_file.error e
-      
-      l_file.info "*** below you find all exception objects found in memory, some of them may have been thrown in your application, others may just be in memory because they are standard exceptions ***"
-      
+
+      l_file.info '*** below you find all exception objects found in memory, some of them may have been thrown in your application, others may just be in memory because they are standard exceptions ***'
+
       # this code logs every exception found in memory
-      ObjectSpace.each_object {|o|
+      ObjectSpace.each_object do |o|
         if ::Exception === o
           l_file.error o
         end
-      }
-      
+      end
+
       l_file.close
     end
-    
-    
+
     def stop(no_wait = false)
-      if not running?
-        self.zap
+      unless running?
+        zap
         return
       end
-      
+
+      # confusing: pid is also a attribute_reader
       pid = @pid.pid
-      
+
       # Catch errors when trying to kill a process that doesn't
       # exist. This happens when the process quits and hasn't been
       # restarted by the monitor yet. By catching the error, we allow the
       # pid file clean-up to occur.
       begin
-        Process.kill(SIGNAL, pid)
+        wait_and_retry_kill_harder(pid, @signals_and_waits, no_wait)
       rescue Errno::ESRCH => e
-        puts "#{e} #{pid}"
-        puts "deleting pid-file."
+        @report.output_message("#{e} #{pid}")
+        @report.output_message('deleting pid-file.')
       end
-      
-      if not no_wait
-        if @force_kill_waittime > 0
-          puts "#{self.group.app_name}: trying to stop process with pid #{pid}..."
-          STDOUT.flush
-          
-          begin
-            Timeout::timeout(@force_kill_waittime) {
-              while Pid.running?(pid)
-                sleep(0.2)
-              end
-            }
-          rescue Timeout::Error
-            puts "#{self.group.app_name}: process with pid #{pid} won't stop, we forcefully kill it..."
-            STDOUT.flush
-            
-            begin
-              Process.kill('KILL', pid)
-            rescue Errno::ESRCH
-            end
-            
-            begin
-              Timeout::timeout(20) {
-                while Pid.running?(pid)
-                  sleep(1)
-                end
-              }
-            rescue Timeout::Error
-              puts "#{self.group.app_name}: unable to forcefully kill process with pid #{pid}."
-              STDOUT.flush
-            end
-          end
-        end
-        
-        
-      end
-      
+
       sleep(0.1)
       unless Pid.running?(pid)
         # We try to remove the pid-files by ourselves, in case the application
         # didn't clean it up.
-        begin; @pid.cleanup; rescue ::Exception; end
-        
-        puts "#{self.group.app_name}: process with pid #{pid} successfully stopped."
-        STDOUT.flush
+        zap!
+
+        @report.stopped_process(group.app_name, pid)
       end
-      
     end
-    
+
+    # @param Hash remaing_signals
+    # @param Boolean no_wait Send first Signal and return
+    def wait_and_retry_kill_harder(pid, remaining_signals, no_wait = false)
+      sig_wait = remaining_signals.shift
+      sig      = sig_wait[:sig]
+      wait     = sig_wait[:wait]
+      Process.kill(sig, pid)
+      return if no_wait || !wait.positive?
+
+      @report.stopping_process(group.app_name, pid, sig, wait)
+
+      begin
+        Timeout.timeout(wait, TimeoutError) do
+          sleep(0.2) while Pid.running?(pid)
+        end
+      rescue TimeoutError
+        if remaining_signals.any?
+          wait_and_retry_kill_harder(pid, remaining_signals)
+        else
+          @report.cannot_stop_process(group.app_name, pid)
+        end
+      end
+    end
+
     def zap
-      @pid.cleanup
+      @pid.zap
     end
-    
+
     def zap!
-      begin; @pid.cleanup; rescue ::Exception; end
+      begin; @pid.zap; rescue ::Exception; end
     end
-    
+
     def show_status
-      running = self.running?
-      
-      puts "#{self.group.app_name}: #{running ? '' : 'not '}running#{(running and @pid.exist?) ? ' [pid ' + @pid.pid.to_s + ']' : ''}#{(@pid.exist? and not running) ? ' (but pid-file exists: ' + @pid.pid.to_s + ')' : ''}"
+      @show_status_callback.call(self)
+    end
+
+    def default_show_status(daemon = self)
+      running = daemon.running?
+
+      @report.status(group.app_name, running, daemon.pid.exist?, daemon.pid.pid.to_s)
     end
-    
+
     # This function implements a (probably too simle) method to detect
     # whether the program with the pid found in the pid-file is still running.
     # It just searches for the pid in the output of <tt>ps ax</tt>, which
@@ -466,12 +449,35 @@ module Daemons
     # system.
     #
     def running?
-      if @pid.exist?
-        return Pid.running?(@pid.pid)
+      @pid.exist? and Pid.running? @pid.pid
+    end
+
+    private
+
+    def log_output?
+      options[:log_output] && logdir
+    end
+
+    def log_output_syslog?
+      options[:log_output_syslog]
+    end
+
+    def dir_mode
+      @dir_mode or group.dir_mode
+    end
+
+    def dir
+      @dir or group.dir
+    end
+
+    def parse_signals_and_waits(argv)
+      unless argv
+        return [
+          { sig: 'TERM', wait: @force_kill_waittime },
+          { sig: 'KILL', wait: 20 }
+        ]
       end
-      
-      return false
+      argv.split('|').collect{ |part| splitted = part.split(':'); {sig: splitted[0], wait: splitted[1].to_i}}
     end
   end
-  
 end