daemons 0.0.1 → 0.2.0

data/README

@@ -1,4 +1,4 @@
-= Daemons Version 0.0.1
+= Daemons Version 0.2.0
 
 (See Releases for release-specific information)
 

data/Rakefile

@@ -16,14 +16,15 @@ PKG_FILES = FileList[
   "Rakefile", "Releases", "TODO", "README", 
   "setup.rb",
   "lib/**/*.rb",
-  "test/**/*"
+  "test/**/*",
+  "examples/**/*"
 ]
-PKG_FILES.exclude(%r(^test/tmp/.+))
-
+#PKG_FILES.exclude(%r(^test/tmp/.+))
+PKG_FILES.exclude(%r(\.pid$))
+PKG_FILES.exclude(%r(\.log$))
 
 spec = Gem::Specification.new do |s|
   s.name = PKG_NAME
-  #s.version = "0.0.1"
   s.version = Daemons::VERSION
   s.author = "Thomas Uehlinger"
   s.email = "th.uehlinger@gmx.ch"

data/Releases

@@ -3,4 +3,11 @@
 == Release 0.0.1: Feb 8, 2005
 
 * Initial release
-  
+ 
+ 
+== Release 0.2.0: Mar 21, 2005
+
+* Exception backtrace functionality added
+* Exec functionality added
+* More examples added
+* New commands: status, zap

data/TODO

@@ -1,2 +1,3 @@
-* write the README (2005-02-07)
+* write the README (2005-02-07) *DONE*
 * write some real tests (2005-02-08)
+* document the new options (2005-03-14)

data/examples/ctrl_crash.rb

@@ -0,0 +1,16 @@
+lib_dir = File.expand_path(File.join(File.split(__FILE__)[0], '../lib'))
+
+if File.exists?(File.join(lib_dir, 'daemons.rb'))
+  $LOAD_PATH.unshift lib_dir
+else
+  require 'rubygems' rescue nil
+end
+
+require 'daemons'
+
+
+options = {
+  :backtrace => true
+}
+
+Daemons.run(File.join(File.split(__FILE__)[0], 'myserver_crashing.rb'), options)

data/examples/ctrl_exec.rb

@@ -0,0 +1,16 @@
+lib_dir = File.expand_path(File.join(File.split(__FILE__)[0], '../lib'))
+
+if File.exists?(File.join(lib_dir, 'daemons.rb'))
+  $LOAD_PATH.unshift lib_dir
+else
+  require 'rubygems' rescue nil
+end
+
+require 'daemons'
+
+
+options = {
+  :exec => true
+}
+
+Daemons.run(File.join(File.split(__FILE__)[0], 'myserver.rb'), options)

data/examples/ctrl_normal.rb

@@ -0,0 +1,12 @@
+lib_dir = File.expand_path(File.join(File.split(__FILE__)[0], '../lib'))
+
+if File.exists?(File.join(lib_dir, 'daemons.rb'))
+  $LOAD_PATH.unshift lib_dir
+else
+  require 'rubygems' rescue nil
+end
+
+require 'daemons'
+
+
+Daemons.run(File.join(File.split(__FILE__)[0], 'myserver.rb'))

data/examples/ctrl_ontop.rb

@@ -0,0 +1,16 @@
+lib_dir = File.expand_path(File.join(File.split(__FILE__)[0], '../lib'))
+
+if File.exists?(File.join(lib_dir, 'daemons.rb'))
+  $LOAD_PATH.unshift lib_dir
+else
+  require 'rubygems' rescue nil
+end
+
+require 'daemons'
+
+
+options = {
+  :ontop => true
+}
+
+Daemons.run(File.join(File.split(__FILE__)[0], 'myserver.rb'), options)

data/examples/myserver.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+
+# This is myserver.rb, an example server that is to be controlled by daemons
+# and that does nothing really useful at the moment.
+#
+# Don't run this script by yourself, it can be controlled by the ctrl*.rb scripts.
+
+loop do
+  puts 'ping from myserver.rb!'
+  sleep(3)
+end

data/examples/myserver_crashing.rb

@@ -0,0 +1,14 @@
+# This is myserver.rb, an example server that is to be controlled by daemons
+# and that does nothing really useful at the moment.
+#
+# Don't run this script by yourself, it can be controlled by the ctrl*.rb scripts.
+
+loop do
+  puts 'ping from myserver.rb!'
+  puts 'this example server will crash in 3 seconds...'
+  
+  sleep(3)
+  
+  puts 'CRASH!'
+  raise 'CRASH!'
+end

data/lib/daemons.rb

@@ -1,6 +1,5 @@
 require 'optparse'
 require 'optparse/time'
-#require 'ostruct'
 
 require 'daemons/pidfile'  
 require 'daemons/cmdline'
@@ -18,7 +17,7 @@ require 'daemons/exceptions'
 #
 module Daemons
 
-  VERSION = "0.0.1"
+  VERSION = "0.2.0"
   
   require 'daemons/daemonize'
    
@@ -28,8 +27,12 @@ module Daemons
     attr_accessor :app_argv
     attr_accessor :controller_argv
     
+    # the PidFile instance belonging to this application
     attr_reader :pid_file
     
+    # the ApplicationGroup the application belongs to
+    attr_reader :group
+    
     
     def initialize(group, pid_file = nil)
       @group = group
@@ -46,42 +49,145 @@ module Daemons
     end
     
     def start
-      #puts "starting..."
+      opts = @group.controller.options
       
-      unless @group.controller.options[:ontop]
+      unless opts[:ontop]
         Daemonize.daemonize()
       end
       
       @pid_file.write
       
-      at_exit {
-        @pid_file.remove rescue nil
-      }
-      
-      trap('TERM') {
-        @pid_file.remove rescue nil
-        exit
-      }
-      
-      run()
+      if opts[:exec]
+        run_via_exec()
+      else
+        # We need this to remove the pid-file if the applications exits by itself.
+        # Note that <tt>at_text</tt> will only be run if the applications exits by calling 
+        # <tt>exit</tt>, and not if it calls <tt>exit!</tt>.
+        #
+        at_exit {
+          @pid_file.remove rescue nil
+          
+          # If the option <tt>:backtrace</tt> is used and the application did exit by itself
+          # create a exception log.
+          if opts[:backtrace] and not opts[:ontop] and not $daemons_sigterm
+            exception_log() rescue nil
+          end
+            
+        }
+        
+        # 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'.
+        #
+        trap('TERM') {
+          @pid_file.remove rescue nil
+          $daemons_sigterm = true
+          
+          exit
+        }
+        
+        run_via_load()
+      end
     end
     
     def run
+      if @group.controller.options[:exec]
+        run_via_exec()
+      else
+        run_via_load()
+      end
+    end
+     
+    def run_via_exec
+      ENV['DAEMONS_ARGV'] = @controller_argv.join(' ')      # haven't tested yet if this is really passed to the exec'd process...
+      
+      Kernel.exec(script(), *ARGV)
+    end
+    
+    def run_via_load
       $DAEMONS_ARGV = @controller_argv
+      ENV['DAEMONS_ARGV'] = @controller_argv.join(' ')
       
       ARGV.clear
       ARGV.concat @app_argv if @app_argv
       
+      # TODO: begin - rescue - end around this and exception logging
       load script()
     end
     
+    # This is a nice little function for debugging purposes:
+    # In case a multi-threaded ruby script exits due to an uncaught exception
+    # it may be difficult to find out where the exception came from because
+    # one cannot catch exceptions that are thrown in threads other than the main
+    # thread.
+    #
+    # This function searches for all exceptions in memory and outputs them to STDERR
+    # (if it is connected) and to a log file in the pid-file directory.
+    #
+    def exception_log
+      require 'logger'
+      
+      l_file = Logger.new(File.join(pidfile_dir(), @group.app_name + '.log'))
+      
+      
+      # the code below only logs the last exception
+      e = nil
+      
+      ObjectSpace.each_object {|o|
+        if ::Exception === o
+          e = o
+        end
+      }
+      
+      l_file.error e
+      l_file.close
+      
+      e = nil
+      
+      # this code logs every exception found in memory
+#       ObjectSpace.each_object {|o|
+#         if ::Exception === o
+#           l_file.error o
+#         end
+#       }
+#       
+#       l_file.close
+    end
+    
+    
     def stop
       Process.kill('TERM', @pid_file.read)
       
-#       begin
-#         @pidfile.remove
-#       rescue ::Exception
-#       end
+      # We try to remove the pid-files by ourselves, in case the application
+      # didn't clean it up.
+      @pid_file.remove rescue nil
+      
+    end
+    
+    def zap
+      @pid_file.remove
+    end
+    
+    def show_status
+      running = self.running?
+      
+      puts "#{self.group.app_name}: #{running ? '' : 'not'} running#{(running and @pid_file.exists?) ? ' [pid ' + @pid_file.read.to_s + ']' : ''}#{(@pid_file.exists? and not running) ? ' (but pid-file exists: ' + @pid_file.read.to_s + ')' : ''}"
+    end
+    
+    # This function implements a (probably too simle) method to detect
+    # whether the program with the pid found in the pid-file is still running.
+    # It just searches for the pid in the output of <tt>ps ax</tt>, which
+    # is probably not a good idea in some cases.
+    # Alternatives would be to use a direct access method the unix process control
+    # system.
+    #
+    def running?
+      if @pid_file.exists?
+        return / #{@pid_file.read} / =~ `ps ax`
+      end
+      
+      return false
     end
   end
   
@@ -93,11 +199,6 @@ module Daemons
     
     attr_reader :controller
     
-    # True if one can start multiple instances of the application
-    #attr_reader :multiple
-    
-    #attr_reader :options
-    
     attr_reader :applications
     
     attr_accessor :controller_argv
@@ -106,8 +207,10 @@ module Daemons
     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, script, controller) #multiple = false)
       @app_name = app_name
       @script = script
@@ -120,8 +223,6 @@ module Daemons
       @dir_mode = options[:dir_mode] || :script
       @dir = options[:dir] || ''
       
-      #@multiple = multiple
-      
       @applications = find_applications(pidfile_dir())
     end
     
@@ -159,10 +260,18 @@ module Daemons
     def stop_all
       @applications.each {|a| a.stop}
     end
+    
+    def zap_all
+      @applications.each {|a| a.zap}
+    end
+    
+    def show_status
+      @applications.each {|a| a.show_status}
+    end
+    
   end
 
   
-  
   class Controller
     
     attr_reader :app_name
@@ -173,7 +282,9 @@ module Daemons
       'start',
       'stop',
       'restart',
-      'run'
+      'run',
+      'zap',
+      'status'
     ]
     
     def initialize(script, argv = [])
@@ -190,6 +301,11 @@ module Daemons
     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
@@ -218,6 +334,14 @@ module Daemons
           @group.stop_all
           sleep 1
           @group.start_all
+        when 'zap'
+          @group.zap_all
+        when 'status'
+          unless @group.applications.empty?
+            @group.show_status
+          else
+            puts "#{@group.app_name}: no instances running"
+          end
         when nil
           raise CmdException.new('no command given')
           #puts "ERROR: No command given"; puts
@@ -225,7 +349,7 @@ module Daemons
           #print_usage()
           #raise('usage function not implemented')
         else
-          raise Error.new("not implemented command '#{@command}'")
+          raise Error.new("command '#{@command}' not implemented")
       end
     end
     
@@ -282,6 +406,12 @@ module Daemons
   # <tt>:dir</tt>::       Used in combination with <tt>:dir_mode</tt> (description above)
   # <tt>:multiple</tt>::  Specifies whether multiple instances of the same script are allowed to run at the
   #                       same time
+  # <tt>:ontop</tt>::     When given, stay on top, i.e. do not daemonize the application 
+  #                       (but the pid-file and other things are written as usual)
+  # <tt>:exec</tt>::      When given, do not start the application by <tt>load</tt>-ing the script file,
+  #                       but by exec'ing the script file
+  # <tt>:backtrace</tt>:: Write a backtrace of the last exceptions to the file '[app_name].log' in the 
+  #                       pid-file directory if the application exits due to an uncaught exception
   #
   # -----
   # 
@@ -289,7 +419,10 @@ module Daemons
   #   options = {
   #     :dir_mode   => :script,
   #     :dir        => 'pids',
-  #     :multiple   => true
+  #     :multiple   => true,
+  #     :ontop      => true,
+  #     :exec       => true,
+  #     :backtrace  => true
   #   }
   #
   #   Daemons.run(File.join(File.split(__FILE__)[0], 'myscript.rb'), options)

data/lib/daemons/cmdline.rb

@@ -78,6 +78,7 @@ module Daemons
       puts "  stop          stop all instances of the application"
       puts "  restart       stop all instances and restart them afterwards"
       puts "  run           start the application and stay on top"
+      puts "  zap           set the application to a stopped state"
       puts
       puts "* and where <options> may contain several of the following:"
       

data/lib/daemons/daemonize.rb

@@ -1,10 +1,12 @@
+#--
 ###############################################################################
 # 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>
@@ -132,7 +134,9 @@ module Daemonize
     # Make sure all file descriptors are closed
     ObjectSpace.each_object(IO) do |io|
       unless [STDIN, STDOUT, STDERR].include?(io)
-        io.close rescue nil
+        unless io.closed?
+          io.close rescue nil
+        end
       end
     end
 

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.4
+rubygems_version: 0.8.8
 specification_version: 1
 name: daemons
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2005-02-08
+  version: 0.2.0
+date: 2005-03-21
 summary: A toolkit to convert your script to a controllable daemon
 require_paths: 
   - lib
@@ -41,6 +41,12 @@ files:
   - test/tc_main.rb
   - test/test1.rb
   - test/tmp
+  - examples/myserver.rb
+  - examples/myserver_crashing.rb
+  - examples/ctrl_crash.rb
+  - examples/ctrl_ontop.rb
+  - examples/ctrl_exec.rb
+  - examples/ctrl_normal.rb
 test_files: 
   - test/tc_main.rb
 rdoc_options: []