daemons 0.3.0 → 0.4.0

data/README

@@ -1,4 +1,4 @@
-= Daemons Version 0.3.0
+= Daemons Version 0.4.0
 
 (See Releases for release-specific information)
 
@@ -7,6 +7,9 @@
 Daemons provides an easy way to wrap existing ruby scripts (for example a self-written server) 
 to be <i>run as a daemon</i> and to be <i>controlled by simple start/stop/restart commands</i>.
 
+If you want, you can also use daemons to <i>run blocks of ruby code in a daemon process</i> and to control
+these processes from the main application.
+
 Besides this basic functionality, daemons offers many advanced features like <i>exception backtracing</i> 
 and logging (in case your ruby script crashes) and <i>monitoring</i> and automatic restarting of your processes
 if they crash.
@@ -16,6 +19,10 @@ process.
 
 == Basic Usage
 
+You can use Daemons in three differet ways:
+
+=== 1. Create wrapper scripts for your server scripts or applications
+
 Layout: suppose you have your self-written server <tt>myserver.rb</tt>:
 
   # this is myserver.rb
@@ -55,7 +62,66 @@ should be daemonized by seperating them by two _hyphens_:
   
   $ ruby myserver_control.rb start -- --file=anyfile --a_switch another_argument
   
-For further documentation, refer to the module documentation of Daemons.
+  
+=== 2. Control a bunch of daemons from another application
+
+Layout: you have an application <tt>my_app.rb</tt> that wants to run a bunch of 
+server tasks as daemon processes.
+
+  # this is my_app.rb
+  
+  require 'rubygems'        # if you use RubyGems
+  require 'daemons'
+  
+  task1 = Daemons.call(:multiple => true) do
+    # first server task
+    
+    loop {
+      conn = accept_conn()
+      serve(conn)
+    }
+  end
+  
+  task2 = Daemons.call do
+    # second server task
+    
+    loop {
+      something_different()
+    }
+  end
+  
+  # the parent process continues to run
+  
+  # we can even control your tasks, for example stop them
+  task1.stop
+  task2.stop
+  
+  exit
+  
+=== 3. Daemonize the currently running process
+
+Layout: you have an application <tt>my_daemon.rb</tt> that wants to run as a daemon
+(but without the ability to be controlled by daemons via start/stop commands)
+
+  # this is my_daemons.rb
+  
+  require 'rubygems'        # if you use RubyGems
+  require 'daemons'
+  
+  # Initialize the app while we're not a daemon
+  init()
+  
+  # Become a daemon
+  Daemons.daemonize
+  
+  # The server loop
+  loop {
+    conn = accept_conn()
+    serve(conn)
+  }
+
+  
+<b>For further documentation, refer to the module documentation of Daemons.</b>
 
   
 == Download and Installation

data/Rakefile

@@ -28,9 +28,22 @@ spec = Gem::Specification.new do |s|
   s.version = Daemons::VERSION
   s.author = "Thomas Uehlinger"
   s.email = "th.uehlinger@gmx.ch"
+  s.rubyforge_project = "daemons"
   s.homepage = "http://daemons.rubyforge.org"
   s.platform  = Gem::Platform::RUBY
-  s.summary = "A toolkit to convert your script to a controllable daemon"
+  s.summary = "A toolkit to create and control daemons in different ways"
+  s.description = <<-EOF
+    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.
+  EOF
+    
   #s.files = FileList["{test,lib}/**/*"].exclude("rdoc").to_a
   s.files = PKG_FILES
   s.require_path = "lib"

data/Releases

@@ -1,19 +1,17 @@
 = Daemons Release History
 
-== 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
+== Release 0.4.0: July 30, 2005
 
-== Release 0.2.1: Mar 21, 2005
+* Two completely new operation modes:
+  1. Call a block as a daemon (<tt>Daemons.call { my_daemon_code }</tt>)
+     and control it from the parent process.
+  2. Daemonize the currently running process (<tt>Daemons.daemonize</tt>)
+  plus the already existing mode to control your scripts (<tt>Daemons.run("script.rb")</tt>)
+* Improved documentation (for example "How does the daemonization process work?")
+* Improved "simulation mode" (<tt>:ontop</tt> option)
+* Some minor bugfixes
 
-* Bugfix for a problem with the 'status' command
 
 == Release 0.3.0: April 21, 2005
 
@@ -21,3 +19,21 @@
 * 'restart' command fixed
 * '--force' command modifier (please refer to the documentation)
 * Some more bugfixes and improvements
+
+
+== Release 0.2.1: Mar 21, 2005
+
+* Bugfix for a problem with the 'status' command
+
+
+== Release 0.2.0: Mar 21, 2005
+
+* Exception backtrace functionality added
+* Exec functionality added
+* More examples added
+* New commands: status, zap
+
+
+== Release 0.0.1: Feb 8, 2005
+
+* Initial release

data/examples/call/call.rb

@@ -0,0 +1,56 @@
+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'
+
+testfile = File.expand_path(__FILE__) + '.log'
+
+
+# On the first call to <tt<call</tt>, an application group (accessible by <tt>Daemons.group</tt>)
+# will be created an the options will be kept within, so you only have to specify
+# <tt>:multiple</tt> once.
+#
+
+options = {
+#  :ontop => true,
+  :multiple => true
+}
+
+
+Daemons.call(options) do
+  File.open(testfile, 'w') {|f|
+    f.puts "test"
+  }
+
+  loop { puts "1"; sleep 5 }
+end
+puts "first task started"
+
+Daemons.call do
+  loop { puts "2"; sleep 4 }
+end
+puts "second task started"
+
+# NOTE: this process will exit after 5 seconds
+Daemons.call do
+  puts "3"
+  sleep 5
+end
+puts "third task started"
+
+puts "waiting 20 seconds..."
+sleep(20)
+
+# This call would result in an exception as it will try to kill the third process 
+# which has already terminated by that time; but using the 'true' parameter forces the
+# stop_all procedure.
+puts "trying to stop all tasks..."
+Daemons.group.stop_all(true)
+
+puts "done"

data/examples/call/call_monitor.rb

@@ -0,0 +1,55 @@
+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'
+
+testfile = File.expand_path(__FILE__) + '.log'
+
+
+# On the first call to <tt<call</tt>, an application group (accessible by <tt>Daemons.group</tt>)
+# will be created an the options will be kept within, so you only have to specify
+# <tt>:multiple</tt> once.
+#
+
+options = {
+#  :ontop => true,
+  :multiple => true,
+  :monitor => true
+}
+
+
+Daemons.call(options) do
+  loop { puts "1"; sleep 20 }
+end
+puts "first task started"
+
+
+# NOTE: this process will exit after 5 seconds
+Daemons.call do
+  File.open(testfile, 'a') {|f|
+    f.puts "started..."
+    puts "2"
+  
+    sleep 5
+
+    f.puts "...exit"
+  }
+end
+puts "second task started"
+
+puts "waiting 100 seconds..."
+sleep(100)
+
+# This call would result in an exception as it will try to kill the third process 
+# which has already terminated by that time; but using the 'true' parameter forces the
+# stop_all procedure.
+puts "trying to stop all tasks..."
+Daemons.group.stop_all(true)
+
+puts "done"

data/examples/daemonize/daemonize.rb

@@ -0,0 +1,20 @@
+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'
+
+
+testfile = File.expand_path(__FILE__) + '.log'
+
+Daemons.daemonize
+
+File.open(testfile, 'w') {|f|
+  f.write("test")
+}

data/examples/{ctrl_crash.rb → run/ctrl_crash.rb}

@@ -1,4 +1,4 @@
-lib_dir = File.expand_path(File.join(File.split(__FILE__)[0], '../lib'))
+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

data/examples/{ctrl_exec.rb → run/ctrl_exec.rb}

@@ -1,4 +1,4 @@
-lib_dir = File.expand_path(File.join(File.split(__FILE__)[0], '../lib'))
+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

data/examples/{ctrl_exit.rb → run/ctrl_exit.rb}

@@ -1,4 +1,4 @@
-lib_dir = File.expand_path(File.join(File.split(__FILE__)[0], '../lib'))
+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

data/examples/{ctrl_monitor.rb → run/ctrl_monitor.rb}

@@ -1,4 +1,4 @@
-lib_dir = File.expand_path(File.join(File.split(__FILE__)[0], '../lib'))
+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

data/examples/{ctrl_multiple.rb → run/ctrl_multiple.rb}

@@ -1,4 +1,4 @@
-lib_dir = File.expand_path(File.join(File.split(__FILE__)[0], '../lib'))
+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

data/examples/{ctrl_normal.rb → run/ctrl_normal.rb}

@@ -1,4 +1,4 @@
-lib_dir = File.expand_path(File.join(File.split(__FILE__)[0], '../lib'))
+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

data/examples/{ctrl_ontop.rb → run/ctrl_ontop.rb}

@@ -1,4 +1,4 @@
-lib_dir = File.expand_path(File.join(File.split(__FILE__)[0], '../lib'))
+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

data/lib/daemons.rb

@@ -1,464 +1,74 @@
 require 'optparse'
 require 'optparse/time'
 
+
 require 'daemons/pidfile'  
 require 'daemons/cmdline'
 require 'daemons/exceptions'
 require 'daemons/monitor'
 
 
+require 'daemons/application'
+require 'daemons/application_group'
+require 'daemons/controller'
+
+
 # All functions and classes that Daemons provides reside in this module.
 #
-# The function you should me most interested in is Daemons#run, because it is
-# the only function you need to invoke directly from your scripts.
+# Daemons is normally invoked by on of the following three ways:
+#
+# 1.  <tt>Daemons.run(script, options)</tt>:
+#     This is used in wrapper-scripts that are supposed to control other ruby scripts or
+#     external applications. Control is completely passed to the daemons library.
+#     Such wrapper script should be invoked with command line options like 'start' or 'stop'
+#     to do anything useful.
+#
+# 2.  <tt>Daemons.call(options) { block }</tt>:
+#     Execute the block in a new daemon. <tt>Daemons.call</tt> will return immediately
+#     after spawning the daemon with the new Application object as a return value.
+#
+# 3.  <tt>Daemons.daemonize(options)</tt>:
+#     Daemonize the currently runnig process, i.e. the calling process will become a daemon.
+#
+# == What does daemons internally do with my daemons?
+# *or*:: why do my daemons crash when they try to open a file?
+# *or*:: why can I not see any output from the daemon on the console (when using for example +puts+?
+#
+# From a technical aspect of view, daemons does the following when creating a daemon:
+#
+# 1.  Forks a child (and exits the parent process, if needed)
+# 2.  Becomes a session leader (which detaches the program from
+#     the controlling terminal).
+# 3.  Forks another child process and exits first child. This prevents
+#     the potential of acquiring a controlling terminal.
+# 4.  Changes the current working directory to "/".
+# 5.  Clears the file creation mask (sets +umask+ to +0000+).
+# 6.  Closes file descriptors (reopens +STDOUT+ and +STDERR+ to point to a logfile if
+#     possible).
+#
+# So what does this mean for your daemons:
+# - the current directory is '/'
+# - you cannot receive any input from the console (for example no +gets+)
+# - you cannot output anything from the daemons with +puts+/+print+ unless a logfile is used
+#
+# == How do PidFiles work? Where are they stored?
 #
 # Also, you are maybe interested in reading the documentation for the class PidFile.
 # There you can find out about how Daemons works internally and how and where the so
-# called <i>Pid-Files</i> are stored.
+# called <i>PidFiles</i> are stored.
 #
 module Daemons
 
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
   
   require 'daemons/daemonize'
-   
-  
-  class Application
-  
-    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
-      
-      @pid_file = (pid_file || PidFile.new(pidfile_dir(), @group.app_name, @group.multiple))
-    end
-    
-    def script
-      @script || @group.script
-    end
-    
-    def pidfile_dir
-      PidFile.dir(@dir_mode || @group.dir_mode, @dir || @group.dir, @script || @group.script)
-    end
-    
-    def real_start
-      opts = @group.controller.options
-      
-      unless opts[:ontop]
-        Daemonize.daemonize(opts[:log_output] ? File.join(pidfile_dir(), @group.app_name + '.output') : nil)
-      end
-      
-      @pid_file.write
-      
-      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
-    private :real_start
-    
-    def start
-      @group.create_monitor(@group.applications[0] || self)
-      
-      real_start
-    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
-      
-      # 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
-      if @group.controller.options[:force] and not running?
-        self.zap
-        return
-      end
-      
-      Process.kill('TERM', @pid_file.read)
-      
-      # 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 zap!
-      @pid_file.remove rescue nil
-    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 PidFile.running?(@pid_file.read)
-      end
-      
-      return false
-    end
-  end
-  
-  
-  class ApplicationGroup
-  
-    attr_reader :app_name
-    attr_reader :script
-    
-    attr_reader :monitor
-    attr_reader :controller
-    
-    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, script, controller) #multiple = false)
-      @app_name = app_name
-      @script = script
-      @controller = controller
-      @monitor = nil
-      
-      options = controller.options
-      
-      @multiple = options[:multiple] || false
-      
-      @dir_mode = options[:dir_mode] || :script
-      @dir = options[:dir] || ''
-      
-      #@applications = find_applications(pidfile_dir())
-    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())
-    end
-    
-    def pidfile_dir
-      PidFile.dir(@dir_mode, @dir, script)
-    end  
-    
-    def find_applications(dir)
-      pid_files = PidFile.find_files(dir, app_name)
-      
-      #pp pid_files
-      
-      @monitor = Monitor.find(dir, app_name + '_monitor')
-      
-      pid_files.reject! {|f| f =~ /_monitor.pid$/}
-      
-      return pid_files.map {|f|
-        app = Application.new(self, PidFile.existing(f))
-        setup_app(app)
-        app
-      }
-    end
-    
-    def new_application(script = nil)
-      if @applications.size > 0 and not @multiple
-        if @controller.options[:force]
-          @applications.delete_if {|a|
-            unless a.running?
-              a.zap
-              true
-            end
-          }
-        end
-        
-        raise RuntimeException.new('there is already one or more instance(s) of the program running') unless @applications.empty?
-      end
-      
-      app = Application.new(self)
-      
-      setup_app(app)
-      
-      @applications << app
-      
-      return app
-    end
-    
-    def setup_app(app)
-      app.controller_argv = @controller_argv
-      app.app_argv = @app_argv
-    end
-    private :setup_app
-    
-    def create_monitor(an_app)
-      return if @monitor
-      
-      if @controller.options[:monitor]
-        @monitor = Monitor.new(an_app)
-
-        @monitor.start(@applications)
-      end
-    end
-    
-    def start_all
-      @monitor.stop if @monitor
-      @monitor = nil
-      
-      @applications.each {|a| 
-        fork { 
-          a.start 
-        } 
-      }
-    end
-    
-    def stop_all
-      @monitor.stop if @monitor
-      
-      @applications.each {|a| a.stop}
-    end
-    
-    def zap_all
-      @monitor.stop if @monitor
-      
-      @applications.each {|a| a.zap}
-    end
-    
-    def show_status
-      @applications.each {|a| a.show_status}
-    end
-    
-  end
-
-  
-  class Controller
-    
-    attr_reader :app_name
-    attr_reader :options
-    
-    
-    COMMANDS = [
-      'start',
-      'stop',
-      'restart',
-      'run',
-      'zap',
-      'status'
-    ]
-    
-    def initialize(script, argv = [])
-      @argv = argv
-      @script = File.expand_path(script)
-      
-      @app_name = File.split(@script)[1]
-      
-      @command, @controller_part, @app_part = Controller.split_argv(argv)
-      
-      #@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 = {})
-      @options = options
-      
-      @options.update @optparse.parse(@controller_part).delete_if {|k,v| !v}
-      
-      setup_options()
-      
-      #pp @options
-
-      @group = ApplicationGroup.new(@app_name, @script, self) #options)
-      @group.controller_argv = @controller_part
-      @group.app_argv = @app_part
-      
-      @group.setup
-      
-      case @command
-        when 'start'
-          @group.new_application.start
-        when 'run'
-          @group.new_application.run
-        when 'stop'
-          @group.stop_all
-        when 'restart'
-          unless @group.applications.empty?
-            @group.stop_all
-            sleep 1
-            @group.start_all
-          end
-        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
-          
-          #print_usage()
-          #raise('usage function not implemented')
-        else
-          raise 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', ...]
-    #
-    # <tt>command</tt> must be one of the commands listed in <tt>COMMANDS</tt>
-    #
-    # *Returns*: the command as a string, the controller options as an array, the appliation options
-    # as an array
-    #
-    def Controller.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('--')
-        controller_part = argv[0..i-1]
-        app_part = argv[i+1..-1]
-      else
-        controller_part = argv[0..-1]
-      end
-       
-      return command, controller_part, app_part
-    end
-  end
   
   
   # Passes control to Daemons.
+  # This is used in wrapper-scripts that are supposed to control other ruby scripts or
+  # external applications. Control is completely passed to the daemons library.
+  # Such wrapper script should be invoked with command line options like 'start' or 'stop'
+  # to do anything useful.
   #
   # +script+::  This is the path to the script that should be run as a daemon.
   #             Please note that Daemons runs this script with <tt>load <script></tt>.
@@ -466,7 +76,7 @@ module Daemons
   #             script resides, so this has to be either an absolute path or you have to run
   #             the controlling script from the appropriate directory.
   #
-  # +options+:: A hash that may contain one or more of options listed below
+  # +options+:: A hash that may contain one or more of the options listed below
   #
   # === Options:
   # <tt>:dir_mode</tt>::  Either <tt>:script</tt> (the directory for writing the pid files to 
@@ -480,8 +90,8 @@ module Daemons
   #                       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>:mode</tt>::      <tt>:load</tt> Load the script with <tt>Kernel.load</tt>;
+  #                       <tt>:exec</tt> Execute the script file with <tt>Kernel.exec</tt>
   # <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
   # <tt>:monitor</tt>::   Monitor the programs and restart crashed instances
@@ -493,22 +103,117 @@ module Daemons
   #     :dir        => 'pids',
   #     :multiple   => true,
   #     :ontop      => true,
-  #     :exec       => true,
+  #     :mode       => :exec,
   #     :backtrace  => true,
-  #     :monitor    => true
+  #     :monitor    => true,
+  #     :script     => "path/to/script.rb"
   #   }
   #
   #   Daemons.run(File.join(File.split(__FILE__)[0], 'myscript.rb'), options)
   #
   def run(script, options = {})
-    @controller = Controller.new(script, ARGV)
+    options[:script] = script
+    @controller = Controller.new(options, ARGV)
     
     #pp @controller
     
     @controller.catch_exceptions {
-      @controller.run(options)
+      @controller.run
     }
+    
+    # I don't think anybody will ever use @group, as this location should not be reached under non-error conditions
+    @group = @controller.group
   end
   module_function :run
   
+  
+  # Execute the block in a new daemon. <tt>Daemons.call</tt> will return immediately
+  # after spawning the daemon with the new Application object as a return value.
+  #
+  # +options+:: A hash that may contain one or more of the options listed below
+  #
+  # +block+::   The block to call in the daemon.
+  #
+  # === Options:
+  # <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 
+  # <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
+  # -----
+  # 
+  # === Example:
+  #   options = {
+  #     :backtrace  => true,
+  #     :monitor    => true,
+  #     :ontop      => true
+  #   }
+  #
+  #   Daemons.call(options) begin
+  #     # Server loop:
+  #     loop {
+  #       conn = accept_conn()
+  #       serve(conn)
+  #     }
+  #   end
+  #
+  def call(options = {}, &block)
+    unless block_given?
+      raise "Daemons.call: no block given"
+    end
+    
+    options[:proc] = block
+    options[:mode] = :proc
+    
+    @group ||= ApplicationGroup.new('proc', options)
+    
+    new_app = @group.new_application(options)
+    new_app.start
+
+    return new_app
+  end
+  module_function :call
+  
+  
+  # Daemonize the currently runnig process, i.e. the calling process will become a daemon.
+  #
+  # +options+:: A hash that may contain one or more of the options listed below
+  #
+  # === Options:
+  # <tt>:ontop</tt>::     When given, stay on top, i.e. do not daemonize the application 
+  # <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
+  # -----
+  # 
+  # === Example:
+  #   options = {
+  #     :backtrace  => true,
+  #     :ontop      => true
+  #   }
+  #
+  #   Daemons.daemonize(options)
+  #
+  #   # Server loop:
+  #   loop {
+  #     conn = accept_conn()
+  #     serve(conn)
+  #   }
+  #
+  def daemonize(options = {})
+    #Daemonize::daemonize
+    
+    @group ||= ApplicationGroup.new('self', options)
+    
+    @group.new_application(:mode => :none).start
+    
+  end
+  module_function :daemonize
+  
+  # Return the internal ApplicationGroup instance.
+  def group; @group; end
+  module_function :group
+  
+  # Return the internal Controller instance.
+  def controller; @controller; end
+  module_function :controller
 end