daemons 1.1.9 → 1.4.1

data/lib/daemons/application_group.rb

@@ -1,65 +1,63 @@
 
 module Daemons
   class ApplicationGroup
-  
     attr_reader :app_name
     attr_reader :script
-    
+
     attr_reader :monitor
-    
-    #attr_reader :controller
-    
+
     attr_reader :options
-    
+
     attr_reader :applications
-    
+
     attr_accessor :controller_argv
     attr_accessor :app_argv
-    
+
     attr_accessor :dir_mode
     attr_accessor :dir
-    
+
     # true if the application is supposed to run in multiple instances
     attr_reader :multiple
-    
-    
+
     def initialize(app_name, options = {})
       @app_name = app_name
       @options = options
-      
-      if options[:script]
-        @script = File.expand_path(options[:script])
+
+      if @options[:script]
+        @script = File.expand_path(@options[:script])
       end
-      
-      #@controller = controller
+
       @monitor = nil
-      
-      #options = controller.options
-      
-      @multiple = options[:multiple] || false
-      
-      @dir_mode = options[:dir_mode] || :script
-      @dir = options[:dir] || ''
-      
-      @keep_pid_files = options[:keep_pid_files] || false
-      @no_pidfiles = options[:no_pidfiles] || false
-      
-      #@applications = find_applications(pidfile_dir())
+
+      @multiple = @options[:multiple] || false
+
+      @dir_mode = @options[:dir_mode] || :script
+      ['dir'].each do |k|
+        @options[k] = File.expand_path(@options[k]) if @options.key?(k)
+      end
+      @dir = @options[:dir] || ''
+
+      @keep_pid_files = @options[:keep_pid_files] || false
+
+      @no_pidfiles = @options[:no_pidfiles] || false
+
+      @pid_delimiter = @options[:pid_delimiter]
+
       @applications = []
     end
-    
+
     # Setup the application group.
     # Currently this functions calls <tt>find_applications</tt> which finds
     # all running instances of the application and populates the application array.
     #
     def setup
-      @applications = find_applications(pidfile_dir())
+      @applications = find_applications(pidfile_dir)
     end
-    
+
     def pidfile_dir
       PidFile.dir(@dir_mode, @dir, script)
-    end  
-    
+    end
+
     def find_applications(dir)
       if @no_pidfiles
         return find_applications_by_app_name(app_name)
@@ -67,128 +65,145 @@ module Daemons
         return find_applications_by_pidfiles(dir)
       end
     end
-    
+
     # TODO: identifiy the monitor process
     def find_applications_by_app_name(app_name)
       pids = []
-      
+
       begin
-      x = `ps auxw | grep -v grep | awk '{print $2, $11, $12}' | grep #{app_name}`
-      if x && x.chomp!
-        processes = x.split(/\n/).compact
-        processes = processes.delete_if do |p|
-          pid, name, add = p.split(/\s/)
-          # We want to make sure that the first part of the process name matches
-          # so that app_name matches app_name_22
-          
-          app_name != name[0..(app_name.length - 1)] and not add.include?(app_name)
+        x = `ps auxw | grep -v grep | awk '{print $2, $11, $12}' | grep #{app_name}`
+        if x && x.chomp!
+          processes = x.split(/\n/).compact
+          processes = processes.delete_if do |p|
+            _pid, name, add = p.split(/\s/)
+            # We want to make sure that the first part of the process name matches
+            # so that app_name matches app_name_22
+
+            app_name != name[0..(app_name.length - 1)] and not add.include?(app_name)
+          end
+          pids = processes.map { |p| p.split(/\s/)[0].to_i }
         end
-        pids = processes.map {|p| p.split(/\s/)[0].to_i}
-      end
       rescue ::Exception
       end
-      
-      return pids.map {|f|
+
+      pids.map do |f|
         app = Application.new(self, {}, PidMem.existing(f))
         setup_app(app)
         app
-      }
+      end
     end
-    
+
     def find_applications_by_pidfiles(dir)
-      pid_files = PidFile.find_files(dir, app_name, ! @keep_pid_files)
-      
-      #pp pid_files
-      
       @monitor = Monitor.find(dir, app_name + '_monitor')
-      
-      pid_files.reject! {|f| f =~ /_monitor.pid$/}
-      
-      return pid_files.map {|f|
+
+      reporter = Reporter.new(options)
+      pid_files = PidFile.find_files(dir, app_name, ! @keep_pid_files, @pid_delimiter) do |pid, file|
+        reporter.deleted_found_pidfile(pid, file)
+      end
+
+      pid_files.map do |f|
         app = Application.new(self, {}, PidFile.existing(f))
         setup_app(app)
         app
-      }
+      end
     end
-    
+
     def new_application(add_options = {})
-      if @applications.size > 0 and not @multiple
+      if @applications.size > 0 && !@multiple
         if options[:force]
-          @applications.delete_if {|a|
+          @applications.delete_if do |a|
             unless a.running?
               a.zap
               true
             end
-          }
+          end
         end
-        
-        raise RuntimeException.new('there is already one or more instance(s) of the program running') unless @applications.empty?
+
+        fail RuntimeException.new('there is already one or more instance(s) of the program running') unless @applications.empty?
       end
-      
+
       app = Application.new(self, add_options)
-      
+
       setup_app(app)
-      
+
       @applications << app
-      
-      return app
+
+      app
     end
-    
+
     def setup_app(app)
       app.controller_argv = @controller_argv
       app.app_argv = @app_argv
+      if @options[:show_status_callback]
+        app.show_status_callback = @options[:show_status_callback]
+      end
     end
     private :setup_app
-    
+
     def create_monitor(an_app)
-      return if @monitor
-      
-      if options[:monitor]
-        @monitor = Monitor.new(an_app)
+      if @monitor && options[:monitor]
+        @monitor.stop
+        @monitor = nil
+      end
 
-        @monitor.start(@applications)
+      if options[:monitor]
+        opt = {}
+        opt[:monitor_interval] = options[:monitor_interval] if options[:monitor_interval]
+        @monitor = Monitor.new(an_app, opt)
+        @monitor.start(self)
       end
     end
-    
+
     def start_all
       @monitor.stop if @monitor
       @monitor = nil
-      
-      @applications.each {|a| 
-        fork { 
-          a.start 
-        } 
-      }
+
+      pids = []
+      @applications.each do |a|
+        pids << fork do
+          a.start
+        end
+      end
+      pids.each { |pid| Process.waitpid(pid) }
     end
-    
+
     def stop_all(no_wait = false)
-      @monitor.stop if @monitor
-      
+      if @monitor
+        @monitor.stop
+        @monitor = nil
+        setup
+      end
+
       threads = []
-      
-      @applications.each {|a| 
+
+      @applications.each do |a|
         threads << Thread.new do
           a.stop(no_wait)
         end
-      }
-      
-      threads.each {|t| t.join}
+      end
+
+      threads.each { |t| t.join }
     end
-    
+
     def reload_all
-      @applications.each {|a| a.reload}
+      @applications.each { |a| a.reload }
     end
 
     def zap_all
       @monitor.stop if @monitor
-      
-      @applications.each {|a| a.zap}
+
+      @applications.each { |a| a.zap }
     end
-    
+
     def show_status
-      @applications.each {|a| a.show_status}
+      @applications.each { |a| a.show_status }
     end
-    
-  end
 
+    # Check whether at least one of the applications in the group is running. If yes, return true.
+    def running?
+      @applications.each { |a| return true if a.running? }
+      return false
+    end
+
+  end
 end

data/lib/daemons/change_privilege.rb

@@ -1,9 +1,7 @@
 require 'daemons/etc_extension'
 
 class CurrentProcess
-  def self.change_privilege(user, group=user)
-    puts "Changing process privilege to #{user}:#{group}"
-  
+  def self.change_privilege(user, group = user)
     uid, gid = Process.euid, Process.egid
     target_uid = Etc.getpwnam(user).uid
     target_gid = Etc.getgrnam(group).gid
@@ -16,4 +14,4 @@ class CurrentProcess
   rescue Errno::EPERM => e
     raise "Couldn't change user and group to #{user}:#{group}: #{e}"
   end
-end
+end

data/lib/daemons/cmdline.rb

@@ -1,56 +1,78 @@
-
 module Daemons
-
   class Optparse
-  
     attr_reader :usage
 
     def initialize(controller)
       @controller = controller
       @options = {}
-      
+
       @opts = OptionParser.new do |opts|
-        opts.banner = ""
-        
-#         opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
-#           @options[:verbose] = v
-#         end
-        
-        opts.on("-t", "--ontop", "Stay on top (does not daemonize)") do |t|
+        opts.banner = ''
+
+        opts.on('-t', '--ontop', 'Stay on top (does not daemonize)') do |t|
           @options[:ontop] = t
         end
-        
-        opts.on("-f", "--force", "Force operation") do |t|
+
+        opts.on('-s', '--shush', 'Silent mode (no output to the terminal)') do |t|
+          @options[:shush] = t
+        end
+
+        opts.on('-f', '--force', 'Force operation') do |t|
           @options[:force] = t
         end
-        
-        opts.on("-n", "--no_wait", "Do not wait for processes to stop") do |t|
+
+        opts.on('-n', '--no_wait', 'Do not wait for processes to stop') do |t|
           @options[:no_wait] = t
         end
-        
-        #opts.separator ""
-        #opts.separator "Specific options:"
 
-        
-        opts.separator ""
-        opts.separator "Common options:"
+        opts.on('-w', '--force_kill_waittime SECONDS', Integer, 'Maximum time to wait for processes to stop before force-killing') do |t|
+          @options[:force_kill_waittime] = t
+        end
+        opts.on('--signals_and_waits STRING', String, 'which signal to use to stop and how long to wait e.g. TERM:20|KILL:20') do |t|
+          @options[:signals_and_waits] = t
+        end
+
+        opts.on('--pid_delimiter STRING', 'Text used to separate process number in full process name and pid-file name') do |value|
+          @options[:pid_delimiter] = value
+        end
+
+        opts.separator ''
+        opts.separator 'Common options:'
+
+        opts.on('-l', '--log_output', 'Enable input/output stream redirection') do |value|
+          @options[:log_output] = value
+        end
+
+        opts.on('--logfilename FILE', String, 'Custom log file name for exceptions') do |value|
+          @options[:logfilename] = value
+        end
+
+        opts.on('--output_logfilename FILE', String, 'Custom file name for input/output stream redirection log') do |value|
+          @options[:output_logfilename] = value
+        end
+
+        opts.on('--log_dir DIR', String, 'Directory for log files') do |value|
+          @options[:log_dir] = value
+        end
+
+        opts.on('--syslog', 'Enable output redirction into SYSLOG instead of a file') do |value|
+          @options[:log_output_syslog] = value
+        end
 
         # No argument, shows at tail.  This will print an options summary
-        opts.on_tail("-h", "--help", "Show this message") do
-          #puts opts
-          #@usage = 
-          controller.print_usage()
-          
+        opts.on_tail('-h', '--help', 'Show this message') do
+          controller.print_usage
+
           exit
         end
 
         # Switch to print the version.
-        opts.on_tail("--version", "Show version") do
+        opts.on_tail('--version', 'Show version') do
           puts "daemons version #{Daemons::VERSION}"
           exit
         end
-      end  
-      
+      end
+
       begin
         @usage = @opts.to_s
       rescue ::Exception # work around a bug in ruby 1.9
@@ -65,57 +87,48 @@ module Daemons
 END
       end
     end
-    
-    
-    #
+
     # Return a hash describing the options.
     #
     def parse(args)
       # The options specified on the command line will be collected in *options*.
       # We set default values here.
-      #options = {}
-      
-      
-      ##pp args
+
       @opts.parse(args)
-      
-      return @options
-    end
 
+      @options
+    end
   end
-  
-  
+
   class Controller
-  
     def print_usage
-      puts "Usage: #{@app_name} <command> <options> -- <application options>"
-      puts
-      puts "* where <command> is one of:"
-      puts "  start         start an instance of the application"
-      puts "  stop          stop all instances of the application"
-      puts "  restart       stop all instances and restart them afterwards"
-      puts "  reload        send a SIGHUP to all instances of the application"
-      puts "  run           start the application and stay on top"
-      puts "  zap           set the application to a stopped state"
-      puts "  status        show status (PID) of application instances"
-      puts
-      puts "* and where <options> may contain several of the following:"
-      
-      puts @optparse.usage
+      puts <<-USAGE.gsub(/^ {6}/, '')
+      Usage: #{@app_name} <command> <options> -- <application options>
+
+      * where <command> is one of:
+        start         start an instance of the application
+        stop          stop all instances of the application
+        restart       stop all instances and restart them afterwards
+        reload        send a SIGHUP to all instances of the application
+        run           run the application in the foreground (same as start -t)
+        zap           set the application to a stopped state
+        status        show status (PID) of application instances
+
+      * and where <options> may contain several of the following:
+      #{@optparse.usage}
+      USAGE
     end
-    
+
     def catch_exceptions(&block)
       begin
         block.call
       rescue CmdException, OptionParser::ParseError => e
-        puts "ERROR: #{e.to_s}"
+        puts "ERROR: #{e}"
         puts
-        print_usage()
+        print_usage
       rescue RuntimeException => e
-        puts "ERROR: #{e.to_s}"
+        puts "ERROR: #{e}"
       end
     end
-    
   end
-  
 end

data/lib/daemons/controller.rb

@@ -1,70 +1,56 @@
 
 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
     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
@@ -75,11 +61,11 @@ module Daemons
           @group.stop_all(@options[:no_wait])
         when 'restart'
           unless @group.applications.empty?
-            @group.stop_all
+            @group.stop_all(@options[:no_wait])
             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 +75,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 +96,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