daemons 1.1.9 → 1.4.1

data/lib/daemons/daemonize.rb

@@ -1,5 +1,4 @@
 module Daemonize
-  
   # Try to fork if at all possible retrying every 5 sec if the
   # maximum process limit for the system has been reached
   def safefork
@@ -18,152 +17,152 @@ module Daemonize
     end
   end
   module_function :safefork
-  
-  
+
   # Simulate the daemonization process (:ontop mode)
-  # NOTE: STDOUT and STDERR will not be redirected to the logfile, 
+  # NOTE: $stdout and $stderr will not be redirected to the logfile,
   # because in :ontop mode, we normally want to see the output
-  def simulate(logfile_name = nil)
+  def simulate(logfile_name = nil, app_name = nil)
+    $0 = app_name if app_name
+
     # Release old working directory
-    Dir.chdir "/"   
+    Dir.chdir '/'
+
+    close_io
 
-    close_io()
+    # Free $stdin and point it to somewhere sensible
+    begin; $stdin.reopen '/dev/null'; rescue ::Exception; end
 
-    # Free STDIN and point them somewhere sensible
-    begin; STDIN.reopen "/dev/null"; rescue ::Exception; end       
+    # Split rand streams between spawning and daemonized process
+    srand
   end
   module_function :simulate
-  
-  
+
   # Call a given block as a daemon
   def call_as_daemon(block, logfile_name = nil, app_name = nil)
     # we use a pipe to return the PID of the daemon
     rd, wr = IO.pipe
-    
+
     if tmppid = safefork
       # in the parent
-      
+
       wr.close
       pid = rd.read.to_i
       rd.close
-      
+
       Process.waitpid(tmppid)
-      
+
       return pid
     else
       # in the child
-      
+
       rd.close
-      
+
       # Detach from the controlling terminal
-      unless sess_id = Process.setsid
-        raise Daemons.RuntimeException.new('cannot detach from controlling terminal')
+      unless Process.setsid
+        fail Daemons.RuntimeException.new('cannot detach from controlling terminal')
       end
-  
+
       # Prevent the possibility of acquiring a controlling terminal
       trap 'SIGHUP', 'IGNORE'
       exit if pid = safefork
-  
+
       wr.write Process.pid
       wr.close
-      
+
       $0 = app_name if app_name
-      
+
       # Release old working directory
-      Dir.chdir "/"   
-  
-      close_io()
+      Dir.chdir '/'
+
+      close_io
+
+      redirect_io(logfile_name)
 
-      redirect_io(logfile_name)  
-    
       # Split rand streams between spawning and daemonized process
       srand
-      
+
       block.call
-      
+
       exit
     end
   end
   module_function :call_as_daemon
-  
-  
+
   # Transform the current process into a daemon
   def daemonize(logfile_name = nil, app_name = nil)
     # Fork and exit from the parent
-    safefork and exit
+    safefork && exit
 
     # Detach from the controlling terminal
     unless sess_id = Process.setsid
-      raise Daemons.RuntimeException.new('cannot detach from controlling terminal')
+      fail Daemons.RuntimeException.new('cannot detach from controlling terminal')
     end
 
     # Prevent the possibility of acquiring a controlling terminal
     trap 'SIGHUP', 'IGNORE'
-    exit if pid = safefork
-    
+    exit if safefork
+
     $0 = app_name if app_name
-    
+
     # Release old working directory
-    Dir.chdir "/"  
+    Dir.chdir '/'
 
-    close_io()
+    close_io
 
     redirect_io(logfile_name)
-    
+
     # Split rand streams between spawning and daemonized process
     srand
-    
-    return sess_id
+
+    sess_id
   end
   module_function :daemonize
-  
-  
-  def close_io()
+
+  def close_io
     # Make sure all input/output streams are closed
-    # Part I: close all IO objects (except for STDIN/STDOUT/STDERR)
+    # Part I: close all IO objects (except for $stdin/$stdout/$stderr)
     ObjectSpace.each_object(IO) do |io|
-      unless [STDIN, STDOUT, STDERR].include?(io)
-        begin
-          unless io.closed?
-            io.close
-          end
-        rescue ::Exception
-        end
+      unless [$stdin, $stdout, $stderr].include?(io)
+        io.close rescue nil
       end
     end
-    
+
     # Make sure all input/output streams are closed
-    # Part II: close all file decriptors (except for STDIN/STDOUT/STDERR)
-    ios = Array.new(8192) {|i| IO.for_fd(i) rescue nil}.compact
-    ios.each do |io|
-      next if io.fileno < 3
-      io.close
+    # Part II: close all file decriptors (except for $stdin/$stdout/$stderr)
+    3.upto(8192) do |i|
+      IO.for_fd(i).close rescue nil
     end
   end
   module_function :close_io
-  
-  
-  # Free STDIN/STDOUT/STDERR file descriptors and
+
+  # Free $stdin/$stdout/$stderr file descriptors and
   # point them somewhere sensible
   def redirect_io(logfile_name)
-    begin; STDIN.reopen "/dev/null"; rescue ::Exception; end       
-     
-    if logfile_name
+    begin; $stdin.reopen '/dev/null'; rescue ::Exception; end
+
+    if logfile_name == 'SYSLOG'
+      # attempt to use syslog via syslogio
       begin
-        STDOUT.reopen logfile_name, "a" 
-        File.chmod(0644, logfile_name)
-        STDOUT.sync = true
+        require 'syslogio'
+        $stdout = ::Daemons::SyslogIO.new($0, :local0, :info, $stdout)
+        $stderr = ::Daemons::SyslogIO.new($0, :local0, :err, $stderr)
+        # error out early so we can fallback to null
+        $stdout.puts "no logfile provided, output redirected to syslog"
       rescue ::Exception
-        begin; STDOUT.reopen "/dev/null"; rescue ::Exception; end
+        # on unsupported platforms simply reopen /dev/null
+        begin; $stdout.reopen '/dev/null'; rescue ::Exception; end
+        begin; $stderr.reopen '/dev/null'; rescue ::Exception; end
       end
+    elsif logfile_name
+      $stdout.reopen logfile_name, 'a'
+      File.chmod(0644, logfile_name)
+      $stdout.sync = true
+      begin; $stderr.reopen $stdout; rescue ::Exception; end
+      $stderr.sync = true
     else
-      begin; STDOUT.reopen "/dev/null"; rescue ::Exception; end
+      begin; $stdout.reopen '/dev/null'; rescue ::Exception; end
+      begin; $stderr.reopen '/dev/null'; rescue ::Exception; end
     end
-    
-    begin; STDERR.reopen STDOUT; rescue ::Exception; end
-    STDERR.sync = true
   end
   module_function :redirect_io
-  
-  
 end

data/lib/daemons/etc_extension.rb

@@ -2,11 +2,10 @@ require 'etc'
 
 Etc.instance_eval do
   def groupname(gid)
-    Etc.group {|e| return e.name if gid == e.gid }
-    nil
+    Etc.group { |e| return e.name if gid == e.gid }
   end
+
   def username(uid)
-    Etc.passwd {|e| return e.name if uid == e.uid }
-    nil
+    Etc.passwd { |e| return e.name if uid == e.uid }
   end
 end

data/lib/daemons/exceptions.rb

@@ -1,28 +1,26 @@
-
 module Daemons
-
-  class Exception < ::RuntimeError
+  class Exception < RuntimeError
   end
-  
+
   class RuntimeException < Exception
   end
-  
+
   class CmdException < Exception
   end
-  
+
   class Error < Exception
   end
-  
+
   class SystemError < Error
-  
     attr_reader :system_error
-    
+
     def initialize(msg, system_error)
       super(msg)
-      
+
       @system_error = system_error
     end
-    
   end
-  
-end
+
+  class TimeoutError < Error
+  end
+end

data/lib/daemons/monitor.rb

@@ -1,95 +1,78 @@
+require 'daemons/exceptions'
 
 module Daemons
-
   require 'daemons/daemonize'
-   
+
   class Monitor
-    
     def self.find(dir, app_name)
       pid = PidFile.find_files(dir, app_name, false)[0]
-      
+
       if pid
         pid = PidFile.existing(pid)
-        
+
         unless PidFile.running?(pid.pid)
           begin; pid.cleanup; rescue ::Exception; end
           return
         end
-        
-        monitor = self.allocate
-      
+
+        monitor = allocate
+
         monitor.instance_variable_set(:@pid, pid)
-        
+
         return monitor
       end
-      
-      return nil
+
+      nil
     end
-    
-    
-    def initialize(an_app)
+
+    def initialize(an_app, options = {})
       @app = an_app
       @app_name = an_app.group.app_name + '_monitor'
-      
+      @monitor_interval = options[:monitor_interval] || 30
+
       if an_app.pidfile_dir
         @pid = PidFile.new(an_app.pidfile_dir, @app_name, false)
       else
         @pid = PidMem.new
       end
     end
-    
-    def watch(applications)
-      sleep(30)
-      
+
+    def watch(application_group)
+      sleep(5)
+
       loop do
-        applications.each {|a|
-          sleep(10)
-          
+        application_group.applications.each do |a|
           unless a.running?
             a.zap!
-            
-            Process.detach(fork { a.start })
-            
-            sleep(10)
+
+            sleep(1)
+
+            Process.detach(fork { a.start(true) })
+
+            sleep(5)
           end
-        }
-        
-        sleep(30)
+        end
+
+        sleep(@monitor_interval)
       end
     end
     private :watch
-    
-    
-    def start_with_pidfile(applications)
+
+    def start_with_pidfile(application_group)
       fork do
         Daemonize.daemonize(nil, @app_name)
-        
-        begin  
+
+        begin
           @pid.pid = Process.pid
-          
-  #         at_exit {
-  # begin; @pid.cleanup; rescue ::Exception; 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('TERM') {
-  # begin; @pid.cleanup; rescue ::Exception; end
-  #           exit
-  #         }
-          
-          watch(applications)
+          watch(application_group)
         rescue ::Exception => e
           begin
-            File.open(@app.logfile, 'a') {|f|
+            File.open(@app.logfile, 'a') do |f|
               f.puts Time.now
               f.puts e
               f.puts e.backtrace.inspect
-            }
-          ensure 
+            end
+          ensure
             begin; @pid.cleanup; rescue ::Exception; end
             exit!
           end
@@ -97,42 +80,39 @@ module Daemons
       end
     end
     private :start_with_pidfile
-    
-    def start_without_pidfile(applications)
-      Thread.new { watch(applications) }
+
+    def start_without_pidfile(application_group)
+      Thread.new { watch(application_group) }
     end
     private :start_without_pidfile
-    
-    
-    def start(applications)
-      return if applications.empty?
-      
+
+    def start(application_group)
+      return if application_group.applications.empty?
+
       if @pid.kind_of?(PidFile)
-        start_with_pidfile(applications)
+        start_with_pidfile(application_group)
       else
-        start_without_pidfile(applications)
+        start_without_pidfile(application_group)
       end
     end
-    
-    
+
     def stop
       begin
         pid = @pid.pid
         Process.kill(Application::SIGNAL, pid)
-		Timeout::timeout(5) {      
-          while Pid.running?(pid)
-            sleep(0.1)
+		      Timeout.timeout(5, TimeoutError) do
+            while Pid.running?(pid)
+              sleep(0.1)
+            end
           end
-        }
       rescue ::Exception => e
-        puts "#{e} #{pid}"
-        puts "deleting pid-file."
+        $stderr.puts "exception while trying to stop monitor process #{pid}: #{e}"
+        $stderr.puts "deleting pid-file."
       end
-      
-      # We try to remove the pid-files by ourselves, in case the application
+
+      # We try to remove the pid-files by ourselves, in case the monitor
       # didn't clean it up.
-      begin; @pid.cleanup; rescue ::Exception; end
+      begin; @pid.zap; rescue ::Exception; end
     end
-    
-  end 
-end
+  end
+end

data/lib/daemons/pid.rb

@@ -1,12 +1,10 @@
-
+require 'daemons/exceptions'
 
 module Daemons
-
   class Pid
-  
-    def Pid.running?(pid)
+    def self.running?(pid)
       return false unless pid
-      
+
       # Check if process is in existence
       # The simplest way to do this is to send signal '0'
       # (which is a single system call) that doesn't actually
@@ -14,95 +12,67 @@ module Daemons
       begin
         Process.kill(0, pid)
         return true
+      rescue TimeoutError
+        raise
       rescue Errno::ESRCH
         return false
       rescue ::Exception   # for example on EPERM (process exists but does not belong to us)
         return true
-      #rescue Errno::EPERM
-      #  return false
       end
     end
-    
-  #  def Pid.running?(pid, additional = nil)
-  #    match_pid = Regexp.new("^\\s*#{pid}\\s")
-  #    got_match = false
-  #
-  #    #ps_all = IO.popen('ps ax') # the correct syntax is without a dash (-) !
-  #    ps_in, ps_out, ps_err = Open3.popen3('ps ax') # the correct syntax is without a dash (-) !
-  #    
-  #    return true unless ps_out.gets
-  #    
-  #    begin
-  #      ps_out.each { |psline|
-  #        next unless psline =~ match_pid
-  #        got_match = true
-  #        got_match = false if additional and psline !~ /#{additional}/
-  #        break
-  #      }
-  #    ensure
-  #      begin; begin; ps_in.close; rescue ::Exception; end; begin; ps_out.close; rescue ::Exception; end; ps_err.close; rescue ::Exception; end
-  #    end
-  #    
-  #    # an alternative would be to use the code below, but I don't know whether this is portable
-  #    # `ps axo pid=`.split.include? pid.to_s
-  #     
-  #    return got_match
-  #  end
-    
-    
-    
+
     # Returns the directory that should be used to write the pid file to
     # depending on the given mode.
-    # 
-    # Some modes may require an additionaly hint, others may determine 
+    #
+    # Some modes may require an additionaly hint, others may determine
     # the directory automatically.
     #
     # If no valid directory is found, returns nil.
     #
-    def Pid.dir(dir_mode, dir, script)
+    def self.dir(dir_mode, dir, script)
       # nil script parameter is allowed as long as dir_mode is not :script
-      return nil if dir_mode == :script && script.nil?                         
-      
+      return nil if dir_mode == :script && script.nil?
+
       case dir_mode
         when :normal
           return File.expand_path(dir)
         when :script
-          return File.expand_path(File.join(File.dirname(script),dir))
-        when :system  
+          return File.expand_path(File.join(File.dirname(script), dir))
+        when :system
           return '/var/run'
         else
-          raise Error.new("pid file mode '#{dir_mode}' not implemented")
+          fail Error.new("pid file mode '#{dir_mode}' not implemented")
       end
     end
-    
+
     # Initialization method
     def initialize
     end
-    
-    
+
     # Get method
     def pid
     end
-    
+
     # Set method
     def pid=(p)
     end
-    
+
     # Check whether the process is running
     def running?
-      return Pid.running?(pid())
+      Pid.running?(pid)
     end
-    
+
     # Cleanup method
     def cleanup
     end
     
+    # Zap method
+    def zap
+    end
+
     # Exist? method
     def exist?
       true
     end
-    
-  end  
-  
-  
-end
+  end
+end