daemons 1.1.9 → 1.2.1

data/lib/daemons/controller.rb

@@ -1,70 +1,57 @@
 
 module Daemons
   class Controller
-    
     attr_reader :app_name
-    
+
     attr_reader :group
-    
+
     attr_reader :options
-    
-    
-    COMMANDS = [
-      'start',
-      'stop',
-      'restart',
-      'run',
-      'zap',
-      'reload',
-      'status'
-    ]
-    
+
+    COMMANDS = %w(start stop restart run zap reload status)
+
     def initialize(options = {}, argv = [])
       @options = options
       @argv = argv
-      
+
       # Allow an app_name to be specified. If not specified use the
       # basename of the script.
       @app_name = options[:app_name]
-      
+
       if options[:script]
         @script = File.expand_path(options[:script])
-    
+
         @app_name ||= File.split(@script)[1]
       end
-    
+
       @app_name ||= 'unknown_application'
-      
+
       @command, @controller_part, @app_part = Controller.split_argv(argv)
-    
-      #@options[:dir_mode] ||= :script
-    
+
+      # @options[:dir_mode] ||= :script
+
       @optparse = Optparse.new(self)
     end
-    
-    
+
     # This function is used to do a final update of the options passed to the application
     # before they are really used.
     #
     # Note that this function should only update <tt>@options</tt> and no other variables.
     #
     def setup_options
-      #@options[:ontop] ||= true
+      # @options[:ontop] ||= true
     end
-    
+
     def run
-      @options.update @optparse.parse(@controller_part).delete_if {|k,v| !v}
-      
-      setup_options()
-      
-      #pp @options
+      @options.update @optparse.parse(@controller_part).delete_if { |k, v| !v }
+
+      setup_options
 
       @group = ApplicationGroup.new(@app_name, @options)
       @group.controller_argv = @controller_part
       @group.app_argv = @app_part
-      
+
       @group.setup
-      
+
       case @command
         when 'start'
           @group.new_application.start
@@ -79,7 +66,7 @@ module Daemons
             sleep(1)
             @group.start_all
           else
-            puts "Warning: no instances running. Starting..."
+            $stderr.puts "#{@group.app_name}: warning: no instances running. Starting..."
             @group.new_application.start
           end
         when 'reload'
@@ -89,21 +76,18 @@ module Daemons
         when 'status'
           unless @group.applications.empty?
             @group.show_status
+            exit 3 if not @group.running?   # exit with status 3 to indicate that no apps are running
           else
-            puts "#{@group.app_name}: no instances running"
+            $stderr.puts "#{@group.app_name}: no instances running"
+            exit 3                          # exit with status 3 to indicate that no apps are running
           end
         when nil
-          raise CmdException.new('no command given')
-          #puts "ERROR: No command given"; puts
-          
-          #print_usage()
-          #raise('usage function not implemented')
+          fail CmdException.new('no command given')
         else
-          raise Error.new("command '#{@command}' not implemented")
+          fail Error.new("command '#{@command}' not implemented")
       end
     end
-    
-    
+
     # Split an _argv_ array.
     # +argv+ is assumed to be in the following format:
     #   ['command', 'controller option 1', 'controller option 2', ..., '--', 'app option 1', ...]
@@ -113,28 +97,27 @@ module Daemons
     # *Returns*: the command as a string, the controller options as an array, the appliation options
     # as an array
     #
-    def Controller.split_argv(argv)
+    def self.split_argv(argv)
       argv = argv.dup
-      
+
       command = nil
       controller_part = []
       app_part = []
-       
+
       if COMMANDS.include? argv[0]
         command = argv.shift
       end
-      
+
       if i = argv.index('--')
         # Handle the case where no controller options are given, just
         # options after "--" as well (i == 0)
-        controller_part = (i == 0 ? [] : argv[0..i-1])
-        app_part = argv[i+1..-1]
+        controller_part = (i == 0 ? [] : argv[0..i - 1])
+        app_part = argv[i + 1..-1]
       else
         controller_part = argv[0..-1]
       end
-       
-      return command, controller_part, app_part
+
+      [command, controller_part, app_part]
     end
   end
-
 end

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,143 @@ 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')
+        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
-    
+
     $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)
     ObjectSpace.each_object(IO) do |io|
       unless [STDIN, STDOUT, STDERR].include?(io)
-        begin
-          unless io.closed?
-            io.close
-          end
-        rescue ::Exception
-        end
+        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
+    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
   # point them somewhere sensible
   def redirect_io(logfile_name)
-    begin; STDIN.reopen "/dev/null"; rescue ::Exception; end       
-     
+    begin; STDIN.reopen '/dev/null'; rescue ::Exception; end
+
     if logfile_name
       begin
-        STDOUT.reopen logfile_name, "a" 
+        STDOUT.reopen logfile_name, 'a'
         File.chmod(0644, logfile_name)
         STDOUT.sync = true
       rescue ::Exception
-        begin; STDOUT.reopen "/dev/null"; rescue ::Exception; end
+        begin; STDOUT.reopen '/dev/null'; rescue ::Exception; end
       end
     else
-      begin; STDOUT.reopen "/dev/null"; rescue ::Exception; end
+      begin; STDOUT.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,12 @@ require 'etc'
 
 Etc.instance_eval do
   def groupname(gid)
-    Etc.group {|e| return e.name if gid == e.gid }
+    Etc.group { |e| return e.name if gid == e.gid }
     nil
   end
+
   def username(uid)
-    Etc.passwd {|e| return e.name if uid == e.uid }
+    Etc.passwd { |e| return e.name if uid == e.uid }
     nil
   end
 end

data/lib/daemons/exceptions.rb

@@ -1,28 +1,27 @@
 
 module Daemons
-
   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,77 +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)
       @app = an_app
       @app_name = an_app.group.app_name + '_monitor'
-      
+
       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(restart = true) })
+
+            sleep(5)
+
+            # application_group.setup
           end
-        }
-        
-        sleep(30)
+        end
+
+        # sleep(5)
+        # application_group.setup
+        # sleep(30)
       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 
+
+          # 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'.
@@ -80,16 +81,16 @@ module Daemons
   # 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 +98,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."
+        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
     end
-    
-  end 
-end
+  end
+end