mlanett-daemons 1.0.13 → 1.1.10.2

data/lib/daemons.rb

@@ -7,7 +7,6 @@ require 'daemons/cmdline'
 require 'daemons/exceptions'
 require 'daemons/monitor'
 
-
 require 'daemons/application'
 require 'daemons/application_group'
 require 'daemons/controller'
@@ -27,7 +26,7 @@ require "daemons/version"
 # 2.  <tt>Daemons.run_proc(app_name, options) { (...) }</tt>:
 #     This is used in wrapper-scripts that are supposed to control a proc. 
 #     Control is completely passed to the daemons library.
-#     Such wrapper script need to be invoked with command line options like 'start' or 'stop'
+#     Such wrapper scripts need to be invoked with command line options like 'start' or 'stop'
 #     to do anything useful.
 #
 # 3.  <tt>Daemons.call(options) { block }</tt>:
@@ -66,8 +65,6 @@ require "daemons/version"
 #
 module Daemons
 
-  VERSION = "1.0.11"
-  
   require 'daemons/daemonize'
   
   
@@ -81,7 +78,9 @@ module Daemons
   #             Please note that Daemons runs this script with <tt>load <script></tt>.
   #             Also note that Daemons cannot detect the directory in which the controlling
   #             script resides, so this has to be either an absolute path or you have to run
-  #             the controlling script from the appropriate directory.
+  #             the controlling script from the appropriate directory. Your script name should not
+  #             end with _monitor because that name is reserved for a monitor process which is 
+  #             there to restart your daemon if it crashes.
   #
   # +options+:: A hash that may contain one or more of the options listed below
   #
@@ -97,7 +96,7 @@ module Daemons
   #                       If not given, ARGV (the parameters given to the Ruby process) will be used.
   # <tt>:dir_mode</tt>::  Either <tt>:script</tt> (the directory for writing the pid files to 
   #                       given by <tt>:dir</tt> is interpreted relative
-  #                       to the script location given by +script+) or <tt>:normal</tt> (the directory given by 
+  #                       to the script location given by +script+, the default) or <tt>:normal</tt> (the directory given by 
   #                       <tt>:dir</tt> is interpreted as a (absolute or relative) path) or <tt>:system</tt> 
   #                       (<tt>/var/run</tt> is used as the pid file directory)
   #
@@ -107,14 +106,19 @@ module Daemons
   # <tt>:ontop</tt>::     When given (i.e. set to true), stay on top, i.e. do not daemonize the application 
   #                       (but the pid-file and other things are written as usual)
   # <tt>:mode</tt>::      <tt>:load</tt> Load the script with <tt>Kernel.load</tt>;
+  #                       note that :stop_proc only works for the :load (and :proc) mode.
   #                       <tt>:exec</tt> Execute the script file with <tt>Kernel.exec</tt>
   # <tt>:backtrace</tt>:: Write a backtrace of the last exceptions to the file '[app_name].log' in the 
   #                       pid-file directory if the application exits due to an uncaught exception
   # <tt>:monitor</tt>::   Monitor the programs and restart crashed instances
+  # <tt>:log_dir</tt>::   A specific directory to put the log files into (when not given, resort to the default
+  #                       location as derived from the :dir_mode and :dir options
   # <tt>:log_output</tt>:: When given (i.e. set to true), redirect both STDOUT and STDERR to a logfile named '[app_name].output' in the pid-file directory
   # <tt>:keep_pid_files</tt>:: When given do not delete lingering pid-files (files for which the process is no longer running).
   # <tt>:hard_exit</tt>:: When given use exit! to end a daemons instead of exit (this will for example
   #                       not call at_exit handlers).
+  # <tt>:stop_proc</tt>:: A proc that will be called when the daemonized process receives a request to stop (works only for :load and :proc mode)
+  #
   # -----
   # 
   # === Example:
@@ -159,6 +163,7 @@ module Daemons
   # +options+::   A hash that may contain one or more of the options listed in the documentation for Daemons.run
   #
   # A block must be given to this function. The block will be used as the :proc entry in the options hash.
+  #
   # -----
   # 
   # === Example:
@@ -180,7 +185,7 @@ module Daemons
     # we do not have a script location so the the :script :dir_mode cannot be used, change it to :normal
     if [nil, :script].include? options[:dir_mode]
       options[:dir_mode] = :normal
-      options[:dir] = File.expand_path('.')
+      options[:dir] ||= File.expand_path('.')
     end
     
     @controller = Controller.new(options, options[:ARGV] || ARGV)
@@ -198,6 +203,8 @@ module Daemons
   # Execute the block in a new daemon. <tt>Daemons.call</tt> will return immediately
   # after spawning the daemon with the new Application object as a return value.
   #
+  # +app_name+::  The name of the application.
+  #
   # +options+:: A hash that may contain one or more of the options listed below
   #
   # +block+::   The block to call in the daemon.
@@ -212,6 +219,7 @@ module Daemons
   # 
   # === Example:
   #   options = {
+  #     :app_name   => "myproc",
   #     :backtrace  => true,
   #     :monitor    => true,
   #     :ontop      => true
@@ -233,7 +241,9 @@ module Daemons
     options[:proc] = block
     options[:mode] = :proc
     
-    @group ||= ApplicationGroup.new('proc', options)
+    options[:app_name] ||= 'proc'
+    
+    @group ||= ApplicationGroup.new(options[:app_name], options)
     
     new_app = @group.new_application(options)
     new_app.start
@@ -251,12 +261,27 @@ module Daemons
   # <tt>:ontop</tt>::     When given, stay on top, i.e. do not daemonize the application 
   # <tt>:backtrace</tt>:: Write a backtrace of the last exceptions to the file '[app_name].log' in the 
   #                       pid-file directory if the application exits due to an uncaught exception
+  # <tt>:app_name</tt>::  The name of the application. This will be
+  #                       used to contruct the name of the pid files
+  #                       and log files. Defaults to the basename of
+  #                       the script.
+  # <tt>:dir_mode</tt>::  Either <tt>:script</tt> (the directory for writing files to 
+  #                       given by <tt>:dir</tt> is interpreted relative
+  #                       to the script location given by +script+, the default) or <tt>:normal</tt> (the directory given by 
+  #                       <tt>:dir</tt> is interpreted as a (absolute or relative) path) or <tt>:system</tt> 
+  #                       (<tt>/var/run</tt> is used as the file directory)
+  #
+  # <tt>:dir</tt>::       Used in combination with <tt>:dir_mode</tt> (description above)
+  # <tt>:log_dir</tt>::   A specific directory to put the log files into (when not given, resort to the default
+  #                       location as derived from the :dir_mode and :dir options
+  # <tt>:log_output</tt>:: When given (i.e. set to true), redirect both STDOUT and STDERR to a logfile named '[app_name].output' in the pid-file directory
   # -----
   # 
   # === Example:
   #   options = {
   #     :backtrace  => true,
-  #     :ontop      => true
+  #     :ontop      => true,
+  #     :log_output => true
   #   }
   #
   #   Daemons.daemonize(options)
@@ -264,11 +289,14 @@ module Daemons
   #   # Server loop:
   #   loop {
   #     conn = accept_conn()
+  #     puts "some text which goes to the output logfile"
   #     serve(conn)
   #   }
   #
   def daemonize(options = {})
-    @group ||= ApplicationGroup.new('self', options)
+    options[:script] ||= File.basename(__FILE__)
+    
+    @group ||= ApplicationGroup.new(options[:app_name] || options[:script], options)
     
     @group.new_application(:mode => :none).start
   end

data/lib/daemons/application.rb

@@ -1,5 +1,10 @@
 require 'daemons/pidfile'
 require 'daemons/pidmem'
+require 'daemons/change_privilege'
+require 'daemons/daemonize'
+require 'daemons/exceptions'
+
+require 'timeout'
 
 
 module Daemons
@@ -29,8 +34,12 @@ module Daemons
       
       @dir_mode = @dir = @script = nil
       
+      @force_kill_waittime = @options[:force_kill_waittime] || 20
+      
       unless @pid = pid
-        if dir = pidfile_dir
+        if @options[:no_pidfiles]
+          @pid = PidMem.new
+        elsif dir = pidfile_dir
           @pid = PidFile.new(dir, @group.app_name, @group.multiple)
         else
           @pid = PidMem.new
@@ -38,6 +47,12 @@ module Daemons
       end
     end
     
+    def change_privilege
+      user = options[:user]
+      group = options[:group]
+      CurrentProcess.change_privilege(user, group) if user
+    end
+    
     def script
       @script || @group.script
     end
@@ -46,22 +61,28 @@ module Daemons
       Pid.dir(@dir_mode || @group.dir_mode, @dir || @group.dir, @script || @group.script)
     end
     
+    def logdir
+      logdir = options[:log_dir]
+      unless logdir
+        logdir = options[:dir_mode] == :system ? '/var/log' : pidfile_dir
+      end
+      logdir
+    end
+    
     def output_logfile
-      logdir = options[:dir_mode] == :system ? '/var/log' : pidfile_dir
       (options[:log_output] && logdir) ? File.join(logdir, @group.app_name + '.output') : nil
     end
     
     def logfile
-      logdir = options[:dir_mode] == :system ? '/var/log' : pidfile_dir
       logdir ? File.join(logdir, @group.app_name + '.log') : nil
     end
     
     # this function is only used to daemonize the currently running process (Daemons.daemonize)
     def start_none
       unless options[:ontop]
-        Daemonize.daemonize(nil, @group.app_name) #(logfile)
+        Daemonize.daemonize(output_logfile, @group.app_name)
       else
-        Daemonize.simulate
+        Daemonize.simulate(output_logfile)
       end
       
       @pid.pid = Process.pid
@@ -113,14 +134,12 @@ module Daemons
       
       # 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 || []))
-      #Kernel.exec(script(), *ARGV)
     end
     
     def start_load
@@ -134,7 +153,7 @@ module Daemons
       
       
       # 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_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!
       #
@@ -154,7 +173,15 @@ module Daemons
       # Note that the applications is not supposed to overwrite the signal handler for
       # 'TERM'.
       #
+      $daemons_stop_proc = options[:stop_proc]
       trap(SIGNAL) {
+        begin
+        if $daemons_stop_proc
+          $daemons_stop_proc.call
+        end
+        rescue ::Exception
+        end
+        
         begin; @pid.cleanup; rescue ::Exception; end
         $daemons_sigterm = true
         
@@ -172,6 +199,7 @@ module Daemons
       ARGV.clear
       ARGV.concat @app_argv if @app_argv
       
+      started()
       # TODO: begin - rescue - end around this and exception logging
       load script()
     end
@@ -180,6 +208,9 @@ module Daemons
       return unless p = options[:proc]
     
       myproc = proc do 
+        
+        @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 
         # <tt>exit</tt>, and not if it calls <tt>exit!</tt> (so please don't call <tt>exit!</tt>
@@ -201,7 +232,15 @@ module Daemons
         # Note that the applications is not supposed to overwrite the signal handler for
         # 'TERM'.
         #
+        $daemons_stop_proc = options[:stop_proc]
         trap(SIGNAL) {
+          begin
+          if $daemons_stop_proc
+            $daemons_stop_proc.call
+          end
+          rescue ::Exception
+          end
+          
           begin; @pid.cleanup; rescue ::Exception; end
           $daemons_sigterm = true
 
@@ -212,16 +251,17 @@ module Daemons
           end
         }
         
+        started()
+        
         p.call()
       end
       
       unless options[:ontop]
-        @pid.pid = Daemonize.call_as_daemon(myproc, output_logfile, @group.app_name)
+        Daemonize.call_as_daemon(myproc, output_logfile, @group.app_name)
+        
       else
         Daemonize.simulate(output_logfile)
         
-        @pid.pid = Process.pid
-        
         myproc.call
         
 # why did we use this??
@@ -237,12 +277,17 @@ module Daemons
         #   Process.detach(@pid.pid)
         # end
       end
+      
     end
     
     
-    def start
-      @group.create_monitor(@group.applications[0] || self) unless options[:ontop]  # we don't monitor applications in the foreground
+    def start(restart = false)
+      change_privilege
       
+      if not 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
@@ -258,6 +303,14 @@ module Daemons
       end
     end
     
+    def started
+      if pid = @pid.pid
+        puts "#{self.group.app_name}: process with pid #{pid} started."
+        STDOUT.flush
+      end
+    end
+    
+    
 #     def run
 #       if @group.controller.options[:exec]
 #         run_via_exec()
@@ -274,6 +327,18 @@ module Daemons
 #       
 #     end
 
+	  def reload
+      if @pid.pid == 0
+        zap
+        start
+      else
+        begin
+          Process.kill('HUP', @pid.pid)
+        rescue
+          # ignore
+        end
+      end
+    end
 
     # This is a nice little function for debugging purposes:
     # In case a multi-threaded ruby script exits due to an uncaught exception
@@ -316,30 +381,70 @@ module Daemons
     end
     
     
-    def stop
-      if options[:force] and not running?
+    def stop(no_wait = false)
+      if not running?
         self.zap
         return
       end
       
+      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.
-      pid = @pid.pid
       begin
         Process.kill(SIGNAL, pid)
-        while Pid.running?(pid)
-          sleep 0.1
-        end
       rescue Errno::ESRCH => e
-        puts "#{e} #{@pid.pid}"
+        puts "#{e} #{pid}"
         puts "deleting pid-file."
       end
       
-      # We try to remove the pid-files by ourselves, in case the application
-      # didn't clean it up.
-      begin; @pid.cleanup; rescue ::Exception; 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, TimeoutError) {
+              while Pid.running?(pid)
+                sleep(0.2)
+              end
+            }
+          rescue TimeoutError
+            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, TimeoutError) {
+                while Pid.running?(pid)
+                  sleep(1)
+                end
+              }
+            rescue TimeoutError
+              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
+      end
       
     end
     
@@ -373,4 +478,4 @@ module Daemons
     end
   end
   
-end
+end