mlanett-daemons 1.0.13 → 1.1.10.2

data/lib/daemons/application_group.rb

@@ -42,6 +42,7 @@ module Daemons
       @dir = options[:dir] || ''
       
       @keep_pid_files = options[:keep_pid_files] || false
+      @no_pidfiles = options[:no_pidfiles] || false
       
       #@applications = find_applications(pidfile_dir())
       @applications = []
@@ -60,6 +61,41 @@ module Daemons
     end  
     
     def find_applications(dir)
+      if @no_pidfiles
+        return find_applications_by_app_name(app_name)
+      else
+        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)
+        end
+        pids = processes.map {|p| p.split(/\s/)[0].to_i}
+      end
+      rescue ::Exception
+      end
+      
+      return pids.map {|f|
+        app = Application.new(self, {}, PidMem.existing(f))
+        setup_app(app)
+        app
+      }
+    end
+    
+    def find_applications_by_pidfiles(dir)
       pid_files = PidFile.find_files(dir, app_name, ! @keep_pid_files)
       
       #pp pid_files
@@ -105,12 +141,14 @@ module Daemons
     private :setup_app
     
     def create_monitor(an_app)
-      return if @monitor
+      if @monitor and options[:monitor]
+        @monitor.stop
+        @monitor = nil
+      end
       
       if options[:monitor]
         @monitor = Monitor.new(an_app)
-
-        @monitor.start(@applications)
+        @monitor.start(self)
       end
     end
     
@@ -125,18 +163,28 @@ module Daemons
       }
     end
     
-    def stop_all(force = false)
-      @monitor.stop if @monitor
+    def stop_all(no_wait = false)
+      if @monitor
+        @monitor.stop 
+        @monitor = nil
+        setup
+      end
+      
+      threads = []
       
       @applications.each {|a| 
-        if force
-          begin; a.stop; rescue ::Exception; end
-        else
-          a.stop
+        threads << Thread.new do
+          a.stop(no_wait)
         end
       }
+      
+      threads.each {|t| t.join}
     end
     
+    def reload_all
+      @applications.each {|a| a.reload}
+    end
+
     def zap_all
       @monitor.stop if @monitor
       
@@ -149,4 +197,4 @@ module Daemons
     
   end
 
-end
+end

data/lib/daemons/change_privilege.rb

@@ -0,0 +1,19 @@
+require 'daemons/etc_extension'
+
+class CurrentProcess
+  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
+
+    if uid != target_uid || gid != target_gid
+      Process.initgroups(user, target_gid)
+      Process::GID.change_privilege(target_gid)
+      Process::UID.change_privilege(target_uid)
+    end
+  rescue Errno::EPERM => e
+    raise "Couldn't change user and group to #{user}:#{group}: #{e}"
+  end
+end

data/lib/daemons/cmdline.rb

@@ -10,10 +10,8 @@ module Daemons
       @options = {}
       
       @opts = OptionParser.new do |opts|
-        #opts.banner = "Usage: example.rb [options]"
         opts.banner = ""
         
-        # Boolean switch.
 #         opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
 #           @options[:verbose] = v
 #         end
@@ -26,6 +24,10 @@ module Daemons
           @options[:force] = t
         end
         
+        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:"
 
@@ -33,8 +35,7 @@ module Daemons
         opts.separator ""
         opts.separator "Common options:"
 
-        # No argument, shows at tail.  This will print an options summary.
-        # Try it and see!
+        # No argument, shows at tail.  This will print an options summary
         opts.on_tail("-h", "--help", "Show this message") do
           #puts opts
           #@usage = 
@@ -43,7 +44,7 @@ module Daemons
           exit
         end
 
-        # Another typical switch to print the version.
+        # Switch to print the version.
         opts.on_tail("--version", "Show version") do
           puts "daemons version #{Daemons::VERSION}"
           exit
@@ -56,6 +57,7 @@ module Daemons
         @usage = <<END
             -t, --ontop                      Stay on top (does not daemonize)
             -f, --force                      Force operation
+            -n, --no_wait                    Do not wait for processes to stop
 
         Common options:
             -h, --help                       Show this message
@@ -92,8 +94,10 @@ END
       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:"
       
@@ -114,4 +118,4 @@ END
     
   end
   
-end
+end

data/lib/daemons/controller.rb

@@ -15,6 +15,7 @@ module Daemons
       'restart',
       'run',
       'zap',
+      'reload',
       'status'
     ]
     
@@ -71,16 +72,18 @@ module Daemons
           @options[:ontop] ||= true
           @group.new_application.start
         when 'stop'
-          @group.stop_all
+          @group.stop_all(@options[:no_wait])
         when 'restart'
           unless @group.applications.empty?
             @group.stop_all
-            sleep 1
+            sleep(1)
             @group.start_all
           else
             puts "Warning: no instances running. Starting..."
             @group.new_application.start
           end
+        when 'reload'
+          @group.reload_all
         when 'zap'
           @group.zap_all
         when 'status'

data/lib/daemons/daemonize.rb

@@ -1,97 +1,5 @@
-#--
-###############################################################################
-# daemonize.rb is a slightly modified version of daemonize.rb was             #
-# from the Daemonize Library written by Travis Whitton                        #
-# for details, read the notice below                                          #
-###############################################################################
-#++
-#
-#
-# =Daemonize Library
-# 
-# February. 4, 2005 Travis Whitton <whitton@atlantic.net>
-# 
-# Daemonize allows you to easily modify any existing Ruby program to run
-# as a daemon. See README.rdoc for more details.
-# 
-# == How to install
-# 1. su to root
-# 2. ruby install.rb
-# build the docs if you want to
-# 3. rdoc --main README.rdoc daemonize.rb README.rdoc
-# 
-# == Copying
-# The Daemonize extension module is copywrited free software by Travis Whitton
-# <whitton@atlantic.net>. You can redistribute it under the terms specified in
-# the COPYING file of the Ruby distribution.
-# 
-# == WARRANTY
-# THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
-# IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-# WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
-# PURPOSE.
-#
-#
-# ----
-#
-# == Purpose
-# 
-# Daemonize is a module derived from Perl's Proc::Daemon module. This module
-# allows you to easily modify any existing Ruby program to run as a daemon.
-# A daemon is a process that runs in the background with no controlling terminal.
-# Generally servers (like FTP and HTTP servers) run as daemon processes.
-# Note, do not make the mistake that a daemon == server. Converting a program
-# to a daemon by hand is a relatively simple process; however, this module will
-# save you the effort of repeatedly looking up the procedure, and it will also
-# insure that your programs are daemonized in the safest and most corrects
-# fashion possible.
-# 
-# == Procedure
-# 
-# The Daemonize module does the following:
-# 
-# Forks a child and exits the parent process.
-# 
-# Becomes a session leader (which detaches the program from
-# the controlling terminal).
-# 
-# Forks another child process and exits first child. This prevents
-# the potential of acquiring a controlling terminal.
-# 
-# Changes the current working directory to "/".
-# 
-# Clears the file creation mask.
-# 
-# Closes file descriptors.
-# 
-# == Example usage
-# 
-# Using the Daemonize module is extremely simple:
-# 
-#     require 'daemonize'
-# 
-#     class TestDaemon
-#       include Daemonize
-# 
-#       def initialize
-#         daemonize()
-#         loop do
-#           # do some work here
-#         end
-#       end
-#     end
-# 
-# == Credits
-# 
-# Daemonize was written by Travis Whitton and is based on Perl's
-# Proc::Daemonize, which was written by Earl Hood. The above documentation
-# is also partially borrowed from the Proc::Daemonize POD documentation.
-
-
-
 module Daemonize
-  VERSION = "0.1.1m"
-
+  
   # Try to fork if at all possible retrying every 5 sec if the
   # maximum process limit for the system has been reached
   def safefork
@@ -112,38 +20,37 @@ module Daemonize
   module_function :safefork
   
   
-  def simulate(logfile_name = nil)
-    # NOTE: STDOUT and STDERR will not be redirected to the logfile, because in :ontop mode, we normally want to see the output
+  # Simulate the daemonization process (:ontop mode)
+  # 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, app_name = nil)
+    $0 = app_name if app_name
     
-    Dir.chdir "/"   # Release old working directory
-    File.umask 0000 # Insure sensible umask
+    # Release old working directory
+    Dir.chdir "/"  
+    
+    # Release old working directory
+    Dir.chdir "/"   
 
-    # Make sure all file descriptors are closed
-    ObjectSpace.each_object(IO) do |io|
-      unless [STDIN, STDOUT, STDERR].include?(io)
-        begin
-          unless io.closed?
-            io.close
-          end
-        rescue ::Exception
-        end
-      end
-    end
+    close_io()
 
-    # Free file descriptors and
-    # point them somewhere sensible
-    # STDOUT/STDERR should go to a logfile
+    # Free STDIN and point it to somewhere sensible
+    begin; STDIN.reopen "/dev/null"; rescue ::Exception; end  
     
-    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
-      # parent
+      # in the parent
+      
       wr.close
       pid = rd.read.to_i
       rd.close
@@ -152,7 +59,7 @@ module Daemonize
       
       return pid
     else
-      # child
+      # in the child
       
       rd.close
       
@@ -162,33 +69,24 @@ module Daemonize
       end
   
       # Prevent the possibility of acquiring a controlling terminal
-      #if oldmode.zero?
-        trap 'SIGHUP', 'IGNORE'
-        exit if pid = safefork
-      #end
+      trap 'SIGHUP', 'IGNORE'
+      exit if pid = safefork
   
       wr.write Process.pid
       wr.close
       
       $0 = app_name if app_name
       
-      Dir.chdir "/"   # Release old working directory
-      File.umask 0000 # Insure sensible umask
-  
-      # Make sure all file descriptors are closed
-      ObjectSpace.each_object(IO) do |io|
-        unless [STDIN, STDOUT, STDERR].include?(io)
-          begin
-            unless io.closed?
-              io.close
-            end
-          rescue ::Exception
-          end
-        end
-      end
+      # Release old working directory
+      Dir.chdir "/"   
   
+      close_io()
+
       redirect_io(logfile_name)  
     
+      # Split rand streams between spawning and daemonized process
+      srand
+      
       block.call
       
       exit
@@ -197,10 +95,10 @@ module Daemonize
   module_function :call_as_daemon
   
   
-  # This method causes the current running process to become a daemon
+  # Transform the current process into a daemon
   def daemonize(logfile_name = nil, app_name = nil)
-    srand # Split rand streams between spawning and daemonized process
-    safefork and exit # Fork and exit from the parent
+    # Fork and exit from the parent
+    safefork and exit
 
     # Detach from the controlling terminal
     unless sess_id = Process.setsid
@@ -208,17 +106,29 @@ module Daemonize
     end
 
     # Prevent the possibility of acquiring a controlling terminal
-    #if oldmode.zero?
-      trap 'SIGHUP', 'IGNORE'
-      exit if pid = safefork
-    #end
-
+    trap 'SIGHUP', 'IGNORE'
+    exit if pid = safefork
+    
     $0 = app_name if app_name
     
-    Dir.chdir "/"   # Release old working directory
-    File.umask 0000 # Insure sensible umask
+    # Release old working directory
+    Dir.chdir "/"  
+
+    close_io()
 
-    # Make sure all file descriptors are closed
+    redirect_io(logfile_name)
+    
+    # Split rand streams between spawning and daemonized process
+    srand
+    
+    return sess_id
+  end
+  module_function :daemonize
+  
+  
+  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
@@ -229,24 +139,27 @@ module Daemonize
         end
       end
     end
-
-    redirect_io(logfile_name)
     
-    #return oldmode ? sess_id : 0   # Return value is mostly irrelevant
-    return sess_id
+    # 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
+    end
   end
-  module_function :daemonize
+  module_function :close_io
   
   
-  # Free file descriptors and
+  # Free STDIN/STDOUT/STDERR file descriptors and
   # point them somewhere sensible
-  # STDOUT/STDERR should go to a logfile
   def redirect_io(logfile_name)
     begin; STDIN.reopen "/dev/null"; rescue ::Exception; end       
      
     if logfile_name
       begin
         STDOUT.reopen logfile_name, "a" 
+        File.chmod(0644, logfile_name)
         STDOUT.sync = true
       rescue ::Exception
         begin; STDOUT.reopen "/dev/null"; rescue ::Exception; end
@@ -260,4 +173,5 @@ module Daemonize
   end
   module_function :redirect_io
   
+  
 end