daemons 1.1.9 → 1.2.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 :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])
       end
-      
-      #@controller = controller
+
+      # @controller = controller
       @monitor = nil
-      
-      #options = controller.options
-      
+
+      # 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())
+
+      # @applications = find_applications(pidfile_dir())
       @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,137 @@ 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}
+        rescue ::Exception
       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|
+
+      pid_files = PidFile.find_files(dir, app_name, ! @keep_pid_files)
+      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 @monitor && options[:monitor]
+        @monitor.stop
+        @monitor = nil
+      end
+
       if options[:monitor]
         @monitor = Monitor.new(an_app)
-
-        @monitor.start(@applications)
+        @monitor.start(self)
       end
     end
-    
+
     def start_all
       @monitor.stop if @monitor
       @monitor = nil
-      
-      @applications.each {|a| 
-        fork { 
-          a.start 
-        } 
-      }
+
+      @applications.each do |a|
+        fork do
+          a.start
+        end
+      end
     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
+    
+    # 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,9 @@
 require 'daemons/etc_extension'
 
 class CurrentProcess
-  def self.change_privilege(user, group=user)
+  def self.change_privilege(user, group = user)
     puts "Changing process privilege to #{user}:#{group}"
-  
+
     uid, gid = Process.euid, Process.egid
     target_uid = Etc.getpwnam(user).uid
     target_gid = Etc.getgrnam(group).gid
@@ -16,4 +16,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,52 @@
-
 module Daemons
-
   class Optparse
-  
     attr_reader :usage
 
     def initialize(controller)
       @controller = controller
       @options = {}
-      
+
       @opts = OptionParser.new do |opts|
-        opts.banner = ""
-        
+        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.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('-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.separator ""
+        # opts.separator "Specific options:"
+
+        opts.separator ''
+        opts.separator 'Common options:'
 
         # 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
+          # puts opts
+          # @usage =
+          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 +61,50 @@ 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
+      # 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 '* 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 '* and where <options> may contain several of the following:'
+
       puts @optparse.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