daemons 0.3.0 → 0.4.0

data/lib/daemons/daemonize.rb

@@ -112,6 +112,103 @@ module Daemonize
   module_function :safefork
   
   
+  def simulate(logfile_name = nil)
+    # NOTE: STDOUT and STDERR will not be redirected to the logfile!
+    
+    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
+
+    # Free file descriptors and
+    # point them somewhere sensible
+    # STDOUT/STDERR should go to a logfile
+    
+    STDIN.reopen "/dev/null" rescue nil       
+  end
+  module_function :simulate
+  
+  
+  def call_as_daemon(block, logfile_name = nil, oldmode = 0)
+    rd, wr = IO.pipe
+    
+    if tmppid = safefork
+      # parent
+      wr.close
+      pid = rd.read.to_i
+      rd.close
+      
+      Process.waitpid(tmppid)
+      
+      return pid
+    else
+      rd.close
+      
+      # Detach from the controlling terminal
+      unless sess_id = Process.setsid
+        raise Daemons.RuntimeException.new('cannot detach from controlling terminal')
+      end
+  
+      # Prevent the possibility of acquiring a controlling terminal
+      if oldmode.zero?
+        trap 'SIGHUP', 'IGNORE'
+        exit if pid = safefork
+      end
+  
+      wr.write Process.pid
+      wr.close
+      
+      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
+  
+      # Free file descriptors and
+      # point them somewhere sensible
+      # STDOUT/STDERR should go to a logfile
+      
+      STDIN.reopen "/dev/null" rescue nil       
+      
+      if logfile_name
+        begin
+          STDOUT.reopen logfile_name, "a" 
+        rescue ::Exception
+          STDOUT.reopen "/dev/null" rescue nil
+        end
+      else
+        STDOUT.reopen "/dev/null" rescue nil
+      end
+      
+      STDERR.reopen STDOUT rescue nil    
+    
+      block.call
+      
+      exit
+    end
+  end
+  module_function :call_as_daemon
+  
+  
   # This method causes the current running process to become a daemon
   def daemonize(logfile_name = nil, oldmode=0)
     srand # Split rand streams between spawning and daemonized process
@@ -119,7 +216,7 @@ module Daemonize
 
     # Detach from the controlling terminal
     unless sess_id = Process.setsid
-      raise Daemons.RuntimeException.new('cannot detach from controlled terminal')
+      raise Daemons.RuntimeException.new('cannot detach from controlling terminal')
     end
 
     # Prevent the possibility of acquiring a controlling terminal
@@ -161,7 +258,6 @@ module Daemonize
      
     STDERR.reopen STDOUT rescue nil           
     
-    
     return oldmode ? sess_id : 0   # Return value is mostly irrelevant
   end
   module_function :daemonize

data/lib/daemons/monitor.rb

@@ -6,19 +6,19 @@ module Daemons
   class Monitor
     
     def self.find(dir, app_name)
-      pid_file = PidFile.find_files(dir, app_name)[0]
+      pid = PidFile.find_files(dir, app_name)[0]
       
-      if pid_file
-        pid_file = PidFile.existing(pid_file)
+      if pid
+        pid = PidFile.existing(pid)
         
-        unless PidFile.running?(pid_file.read)
-          pid_file.remove rescue nil
+        unless PidFile.running?(pid.pid)
+          pid.cleanup rescue nil
           return
         end
         
         monitor = self.allocate
       
-        monitor.instance_variable_set(:@pid_file, pid_file)
+        monitor.instance_variable_set(:@pid, pid)
         
         return monitor
       end
@@ -28,20 +28,44 @@ module Daemons
     
     
     def initialize(an_app)
-      @pid_file = PidFile.new(an_app.pidfile_dir, an_app.group.app_name + '_monitor', false)
+      if an_app.pidfile_dir
+        @pid = PidFile.new(an_app.pidfile_dir, an_app.group.app_name + '_monitor', false)
+      else
+        @pid = PidMem.new
+      end
     end
     
-    def start(applications)
-      return if applications.empty?
+    def watch(applications)
+      sleep(30)
       
+      loop do
+        applications.each {|a|
+          sleep(10)
+          
+          unless a.running?
+            a.zap!
+            
+            Process.detach(fork { a.start })
+            
+            sleep(10)
+          end
+        }
+        
+        sleep(30)
+      end
+    end
+    private :watch
+    
+    
+    def start_with_pidfile(applications)
       fork do
         Daemonize.daemonize
         
         begin  
-          @pid_file.write
+          @pid.pid = Process.pid
           
   #         at_exit {
-  #           @pid_file.remove rescue nil
+  #           @pid.cleanup rescue nil
   #         }
           
           # This part is needed to remove the pid-file if the application is killed by 
@@ -50,50 +74,51 @@ module Daemons
           # 'TERM'.
           #
   #         trap('TERM') {
-  #           @pid_file.remove rescue nil
+  #           @pid.cleanup rescue nil
   #           exit
   #         }
           
-          sleep(60)
-          
-          loop do
-            applications.each {|a|
-              sleep(10)
-              
-              unless a.running?
-                a.zap!
-                
-                Process.detach(fork { a.start })
-                
-                sleep(10)
-              end
-            }
-            
-            sleep(30)
-          end
+          watch(applications)
         rescue ::Exception => e
           begin
-            File.open(File.join(@pid_file.dir, @pid_file.progname + '.log'), 'a') {|f|
+            File.open(File.join(@pid.dir, @pid.progname + '.log'), 'a') {|f|
               f.puts Time.now
               f.puts e
               f.puts e.backtrace.inspect
             }
           ensure 
-            @pid_file.remove rescue nil
+            @pid.cleanup rescue nil
             exit!
           end
         end
       end
+    end
+    private :start_with_pidfile
+    
+    def start_without_pidfile(applications)
+      Thread.new { watch(applications) }
+    end
+    private :start_without_pidfile
+    
+    
+    
+    def start(applications)
+      return if applications.empty?
       
+      if @pid.kind_of?(PidFile)
+        start_with_pidfile(applications)
+      else
+        start_without_pidfile(applications)
+      end
     end
     
     
     def stop
-      Process.kill('TERM', @pid_file.read) rescue nil
+      Process.kill('TERM', @pid.pid) rescue nil
       
       # We try to remove the pid-files by ourselves, in case the application
       # didn't clean it up.
-      @pid_file.remove rescue nil
+      @pid.cleanup rescue nil
     end
     
   end

data/lib/daemons/pid.rb

@@ -0,0 +1,60 @@
+
+module Daemons
+
+  class Pid
+  
+    def Pid.running?(pid, additional = nil)
+      output = `ps ax`
+      return (/#{pid} / =~ output and (additional ? /#{additional}/ =~ output : true))
+    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 
+    # the directory automatically.
+    #
+    # If no valid directory is found, returns nil.
+    #
+    def Pid.dir(dir_mode, dir, script)
+      return nil unless script
+      
+      case dir_mode
+        when :normal
+          return File.expand_path(dir_mode)
+        when :script
+          return File.expand_path(File.join(File.split(script)[0],dir))
+        when :system  
+          return '/var/run'
+        else
+          raise Error.new("pid file mode '#{mode}' not implemented")
+      end
+    end
+    
+    # Initialization method
+    def initialize
+    end
+    
+    
+    # Get method
+    def pid
+    end
+    
+    # Set method
+    def pid=(p)
+    end
+    
+    # Cleanup method
+    def cleanup
+    end
+    
+    # Exists? method
+    def exists?
+      true
+    end
+    
+  end  
+  
+  
+end

data/lib/daemons/pidfile.rb

@@ -1,3 +1,5 @@
+require 'daemons/pid'
+
 
 module Daemons
 
@@ -27,7 +29,7 @@ module Daemons
   # 2.  in a directory relative to the current directory or the filesystem root
   # 3.  in the preconfigured directory <tt>/var/run</tt>
   #
-  class PidFile
+  class PidFile < Pid
 
     attr_reader :dir, :progname, :multiple, :number
 
@@ -39,35 +41,6 @@ module Daemons
       return files
     end
     
-
-    def PidFile.running?(pid, additional = nil)
-      output = `ps ax`
-      return (/#{pid} / =~ output and (additional ? /#{additional}/ =~ output : true))
-    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 
-    # the directory automatically.
-    #
-    # If no valid directory is found, returns nil.
-    #
-    def PidFile.dir(dir_mode, dir, script)
-      case dir_mode
-        when :normal
-          return File.expand_path(dir_mode)
-        when :script
-          return File.expand_path(File.join(File.split(script)[0],dir))
-        when :system  
-          return '/var/run'
-        else
-          raise Error.new("pid file mode '#{mode}' not implemented")
-      end
-    end
-    
-    
     def PidFile.existing(path)
       new_instance = PidFile.allocate
       
@@ -95,7 +68,7 @@ module Daemons
       File.exists? filename
     end
     
-    def write
+    def pid=(p)
       if multiple
         while File.exists?(filename) and @number < 1024
           @number += 1
@@ -107,15 +80,15 @@ module Daemons
       end
       
       File.open(filename, 'w') {|f|
-        f.puts Process.pid
+        f.puts p   #Process.pid
       }
     end
 
-    def remove
+    def cleanup
       File.delete(filename)
     end
 
-    def read
+    def pid
       File.open(filename) {|f|
         return f.gets.to_i
       }

data/lib/daemons/pidmem.rb

@@ -0,0 +1,10 @@
+require 'daemons/pid'
+
+
+module Daemons
+
+  class PidMem < Pid
+    attr_accessor :pid
+  end
+
+end

data/test/call_as_daemon.rb

@@ -0,0 +1,12 @@
+SCRIPT_DIR = File.split(File.expand_path(__FILE__))[0]
+
+$LOAD_PATH << File.join(SCRIPT_DIR, '../lib')
+
+
+require 'pp'
+
+require 'daemons'
+
+print Daemonize::call_as_daemon(File.join(SCRIPT_DIR, 'tmp/call_as_daemon.log')) {
+  print "hello"
+}

metadata

@@ -1,17 +1,23 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.8
+rubygems_version: 0.8.11
 specification_version: 1
 name: daemons
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
-date: 2005-04-21
-summary: A toolkit to convert your script to a controllable daemon
+  version: 0.4.0
+date: 2005-07-30 00:00:00 +02:00
+summary: A toolkit to create and control daemons in different ways
 require_paths: 
   - lib
 email: th.uehlinger@gmx.ch
 homepage: http://daemons.rubyforge.org
-rubyforge_project: 
-description: 
+rubyforge_project: daemons
+description: "Daemons provides an easy way to wrap existing ruby scripts (for example a
+  self-written server)  to be run as a daemon and to be controlled by simple
+  start/stop/restart commands.  You can also call blocks as daemons and control
+  them from the parent or just daemonize the current process.  Besides this basic
+  functionality, daemons offers many advanced features like exception  backtracing
+  and logging (in case your ruby script crashes) and monitoring and automatic
+  restarting of your processes if they crash."
 autorequire: daemons
 default_executable: 
 bindir: bin
@@ -24,6 +30,8 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
         version: 0.0.0
   version: 
 platform: ruby
+signing_key: 
+cert_chain: 
 authors: 
   - Thomas Uehlinger
 files: 
@@ -33,26 +41,38 @@ files:
   - README
   - setup.rb
   - lib/daemons.rb
-  - lib/daemons/daemonize.rb
-  - lib/daemons/exceptions.rb
   - lib/daemons/cmdline.rb
+  - lib/daemons/exceptions.rb
+  - lib/daemons/daemonize.rb
   - lib/daemons/pidfile.rb
   - lib/daemons/monitor.rb
+  - lib/daemons/application_group.rb
+  - lib/daemons/controller.rb
+  - lib/daemons/pid.rb
+  - lib/daemons/pidmem.rb
+  - lib/daemons/application.rb
   - test/tmp
   - test/testapp.rb
-  - test/tc_main.rb
   - test/test1.rb
-  - examples/myserver.rb
-  - examples/myserver_crashing.rb
-  - examples/ctrl_crash.rb
-  - examples/ctrl_ontop.rb
-  - examples/ctrl_exec.rb
-  - examples/ctrl_normal.rb
-  - examples/ctrl_multiple.rb
-  - examples/myserver_exiting.rb
-  - examples/ctrl_exit.rb
-  - examples/myserver_crashing.rb.output
-  - examples/ctrl_monitor.rb
+  - test/call_as_daemon.rb
+  - test/tc_main.rb
+  - examples/run
+  - examples/call
+  - examples/daemonize
+  - examples/run/ctrl_exec.rb
+  - examples/run/ctrl_exit.rb
+  - examples/run/ctrl_multiple.rb
+  - examples/run/myserver_crashing.rb.output
+  - examples/run/ctrl_normal.rb
+  - examples/run/ctrl_monitor.rb
+  - examples/run/myserver.rb
+  - examples/run/myserver_crashing.rb
+  - examples/run/ctrl_ontop.rb
+  - examples/run/myserver_exiting.rb
+  - examples/run/ctrl_crash.rb
+  - examples/call/call_monitor.rb
+  - examples/call/call.rb
+  - examples/daemonize/daemonize.rb
 test_files: 
   - test/tc_main.rb
 rdoc_options: []