fire_and_forget 0.3.2 → 0.3.3

data/vendor/daemons-1.1.0/Rakefile

@@ -1,88 +0,0 @@
-require 'rubygems'
-#Gem::manage_gems
-
-require 'rake/gempackagetask'
-#require 'rake/testtask'
-require 'rake/packagetask'
-require 'rake/rdoctask'
-
-$LOAD_PATH << './lib'
-require 'daemons'
-
-
-PKG_NAME = "daemons"
-
-PKG_FILES = FileList[
-  "Rakefile", "Releases", "TODO", "README", "LICENSE",
-  "setup.rb",
-  "lib/**/*.rb",
-  #"test/**/*",
-  "examples/**/*"
-]
-#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 = 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 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"
-  s.autorequire = "daemons"
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "Releases", "TODO"]
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_tar = true
-end
-
-
-#Rake::PackageTask.new("package") do |p|
-#  p.name = PKG_NAME
-#  p.version = Daemons::VERSION
-#  p.need_tar = true
-#  p.need_zip = true
-#  p.package_files = PKG_FILES
-#end
-
- 
-task :default => [:package]
-
-desc 'Show information about the gem.'
-task :debug_gem do
-  puts spec.to_ruby
-end
-
-task :upload do
-  sh "scp -r html/* uehli@rubyforge.org:/var/www/gforge-projects/daemons"
-end
-
-
-desc "Create the RDOC html files"
-rd = Rake::RDocTask.new("rdoc") { |rdoc|
-  rdoc.rdoc_dir = 'html'
-  rdoc.title    = "Daemons"
-  rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
-  rdoc.rdoc_files.include('README', 'TODO', 'Releases')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-}

data/vendor/daemons-1.1.0/Releases

@@ -1,152 +0,0 @@
-= Daemons Release History
-
-== Release 1.1.0: June 20, 2010
-
-* Honour the options[:app_name] in Daemons.daemonize (thanks to Ryan Tecco).
-* Included a new option :stop_proc to specify a proc that will be called when a 
-  daemonized process receives a request to stop (thanks to Dave Dupre).
-* Only delete the pidfile if the current pid is the original pid (ghazel).
-* Start when restart but no application running (pcreux).
-* Silently continue if there is no pidfile (ghazel).
-* We now per default wait for processes to stop and
-  kill them automatically it if they do not stop within a given time 
-  (force_kill_waittime). Use the option --no_wait to not wait for processes to 
-  stop.
-* Set log files mode to 0644 (mikehale).
-* Set pid file permissions to 0644 (mikehale).
-* Added ability to change process uid/gid (mikehale).
-* Fix for: If you happen to start a daemon from a process that has open file 
-  descriptors these will stay open. As it is daemonize.rb only closes ruby IO 
-  objects (thanks to Han Holl).
-* New reload command (SIGHUP) (thanks to Michael Schuerig).
-
-== Release 1.0.10: March 21, 2008
-
-* By default, we now delete stray pid-files (i.e. pid-files which result for 
-  example from a killed daemon) automatically. This function can be deactivated 
-  by passing :keep_pid_files => true as an option.
-* All pid files of :multiple daemons new get deleted correctly upon exit of the 
-  daemons (reported by Han Holl).
-* Use the signal 'KILL' instead of 'TERM' on Windows platforms.
-* Use exit! in trap('TERM') instead of exit when option :hard_exit is given 
-  (thanks to Han Holl).
-* Did some clarification on the exception log.
-
-== Release 1.0.9: October 29, 2007
-
-* fixed a severe bug in the new Pid.running? function: function returned true if
-  the process did not exist (thanks to Jeremy Lawler).
-
-== Release 1.0.8: September 24, 2007
-
-* new Pid.running? function. Checking whether a process exists by sending 
-  signal '0' (thanks to Dru Nelson).
-
-== Release 1.0.7: July 7, 2007
-
-* Patch to fix wrong ARGV when using :exec (in def start_exec: 
-  Kernel.exec(script(), *(@app_argv || []))) (thanks to Alex McGuire).
-
-== Release 1.0.6: Mai 8, 2007
-
-* New option to pass an ARGV-style array to run and run_proc (thanks to Marc Evans).
-* Additional patches for '/var/log' (thanks to Marc Evans).
-
-== Release 1.0.5: February 24, 2007
-
-* Applied patch that makes daemons to use '/var/log' as logfile 
-  directory if you use :dir_mode = :system (thanks to Han Holl).
-* Daemons should now work with Ruby 1.9 (at least the basic features).
-
-== Release 1.0.4: January 17, 2007
-
-* Document the :log_output option (thanks to Andrew Kuklewicz).
-* Set STDOUT.sync = true when redirecting to a logfile (thanks to Andrew Kuklewicz).
-* Should now run also correctly when there is no working 'ps ax' on the system 
-  (thanks to Daniel Kehoe).
-
-== Release 1.0.3: November 1, 2006
-
-* Set the app_name correctly also for the monitor process (thanks to Ilya Novoselov).
-
-== Release 1.0.2: September 26, 2006
-
-* Changed the 'ps -ax' call back to 'ps ax'.
-* Fixed the documentation for the :normal :dir_mode.
-* As a default for Daemons.run_proc, the pid file is now saved in the current directory.
-* In :ontop mode for running a proc (this is equal to calling something like 'ruby ctrl_proc.rb run'), 
-  the proc now runs directly in the calling script, not in a forked process anymore (thanks to Paul Butcher).
-* Set $0 to app_name in the daemons (thanks to Ilya Novoselov).
-
-== Release 1.0.1: August 30, 2006
-
-* Fixed a regex for parsing the 'ps ax' system call. (thanks to Garance Alistair Drosehn)
-
-== Release 1.0.0: August 29, 2006
-
-* Fix the parsing of the 'ps ax' system call. (thanks to Garance Alistair Drosehn)
-
-== Release 0.4.4: February 14, 2006
-
-* Several fixes that allow us to use the Daemons::Controller 
-  with a proc instead of wrapping a script file. This gives us all the
-  PID file management, monitoring, command line options, etc. without having
-  to specify a path to our script which can be tricky, especially when using
-  RubyGems. (thanks to John-Mason Shackelford)
-
-== Release 0.4.3: November 29, 2005
-
-* New Option: You can specify the name of the application with :app_name
-  on calling Daemons.run. This will be used to contruct the name of the pid files
-  and log files. Defaults to the basename of the script. (thanks to Stephen R. Veit)
-
-* Bugfix: Handle the case where no controller options are given when calling Daemons, 
-  just options after "--". (thanks to Stephen R. Veit)
-
-
-== Release 0.4.2: November 15, 2005
-
-* Bugfix for problem with :normal pid-file directory mode (pid.rb), fixed (thanks to Stephen R. Veit)
-
-
-== Release 0.4.1: September 11, 2005
-
-* Bugfix for 'run' command line mode: didn't work anymore in 0.4.0, fixed
-
-
-== Release 0.4.0: July 30, 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
-
-
-== Release 0.3.0: April 21, 2005
-
-* New monitor functionality: automatic restarting of your applications if they crash
-* '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/vendor/daemons-1.1.0/TODO

@@ -1,2 +0,0 @@
-* put TODOS here
-

data/vendor/daemons-1.1.0/lib/daemons.rb

@@ -1,288 +0,0 @@
-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'
-
-require 'timeout'
-
-# All functions and classes that Daemons provides reside in this module.
-#
-# Daemons is normally invoked by one of the following four 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 need to be invoked with command line options like 'start' or 'stop'
-#     to do anything useful.
-#
-# 2.  <tt>Daemons.run_proc(app_name, options) { (...) }</tt>:
-#     This is used in wrapper-scripts that are supposed to control a proc. 
-#     Control is completely passed to the daemons library.
-#     Such wrapper script need to be invoked with command line options like 'start' or 'stop'
-#     to do anything useful.
-#
-# 3.  <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.
-#
-# 4.  <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>PidFiles</i> are stored.
-#
-module Daemons
-
-  VERSION = "1.1.0"
-  
-  require 'daemons/daemonize'
-  
-  
-  # 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>.
-  #             Also note that Daemons cannot detect the directory in which the controlling
-  #             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 the options listed below
-  #
-  # === Options:
-  # <tt>:app_name</tt>::  The name of the application. This will be
-  #                       used to contruct the name of the pid files
-  #                       and log files. Defaults to the basename of
-  #                       the script.
-  # <tt>:ARGV</tt>::      An array of strings containing parameters and switches for Daemons.
-  #                       This includes both parameters for Daemons itself and the controlled scripted.
-  #                       These are assumed to be separated by an array element '--', .e.g.
-  #                       ['start', 'f', '--', 'param1_for_script', 'param2_for_script'].
-  #                       If not given, ARGV (the parameters given to the Ruby process) will be used.
-  # <tt>:dir_mode</tt>::  Either <tt>:script</tt> (the directory for writing the pid files to 
-  #                       given by <tt>:dir</tt> is interpreted relative
-  #                       to the script location given by +script+) or <tt>:normal</tt> (the directory given by 
-  #                       <tt>:dir</tt> is interpreted as a (absolute or relative) path) or <tt>:system</tt> 
-  #                       (<tt>/var/run</tt> is used as the pid file directory)
-  #
-  # <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 (i.e. set to true), stay on top, i.e. do not daemonize the application 
-  #                       (but the pid-file and other things are written as usual)
-  # <tt>:mode</tt>::      <tt>:load</tt> Load the script with <tt>Kernel.load</tt>;
-  #                       note that :stop_proc only works for the :load (and :proc) mode.
-  #                       <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
-  # <tt>:log_output</tt>:: When given (i.e. set to true), redirect both STDOUT and STDERR to a logfile named '[app_name].output' in the pid-file directory
-  # <tt>:keep_pid_files</tt>:: When given do not delete lingering pid-files (files for which the process is no longer running).
-  # <tt>:hard_exit</tt>:: When given use exit! to end a daemons instead of exit (this will for example
-  #                       not call at_exit handlers).
-  # <tt>:stop_proc</tt>:: A proc that will be called when the daemonized process receives a request to stop (works only for :load and :proc mode)
-  #
-  # -----
-  # 
-  # === Example:
-  #   options = {
-  #     :app_name   => "my_app",
-  #     :ARGV       => ['start', '-f', '--', 'param_for_myscript']
-  #     :dir_mode   => :script,
-  #     :dir        => 'pids',
-  #     :multiple   => true,
-  #     :ontop      => true,
-  #     :mode       => :exec,
-  #     :backtrace  => true,
-  #     :monitor    => true
-  #   }
-  #
-  #   Daemons.run(File.join(File.dirname(__FILE__), 'myscript.rb'), options)
-  #
-  def run(script, options = {})
-    options[:script] = script
-    @controller = Controller.new(options, options[:ARGV] || ARGV)
-    
-    @controller.catch_exceptions {
-      @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
-  
-  
-  # Passes control to Daemons.
-  # This function does the same as Daemons.run except that not a script but a proc
-  # will be run as a daemon while this script provides command line options like 'start' or 'stop'
-  # and the whole pid-file management to control the proc.
-  #
-  # +app_name+::  The name of the application. This will be
-  #               used to contruct the name of the pid files
-  #               and log files. Defaults to the basename of
-  #               the script.
-  # 
-  # +options+::   A hash that may contain one or more of the options listed in the documentation for Daemons.run
-  #
-  # A block must be given to this function. The block will be used as the :proc entry in the options hash.
-  #
-  # -----
-  # 
-  # === Example:
-  #
-  #   Daemons.run_proc('myproc.rb') do
-  #     loop do
-  #       accept_connection()
-  #       read_request()
-  #       send_response()
-  #       close_connection()
-  #     end
-  #   end
-  #
-  def run_proc(app_name, options = {}, &block)
-    options[:app_name] = app_name
-    options[:mode] = :proc
-    options[:proc] = block
-    
-    # we do not have a script location so the the :script :dir_mode cannot be used, change it to :normal
-    if [nil, :script].include? options[:dir_mode]
-      options[:dir_mode] = :normal
-      options[:dir] = File.expand_path('.')
-    end
-    
-    @controller = Controller.new(options, options[:ARGV] || ARGV)
-    
-    @controller.catch_exceptions {
-      @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_proc
-  
-  
-  # 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 = {})
-    @group ||= ApplicationGroup.new(options[:app_name] || '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