mlanett-daemons 1.0.13

data/lib/daemons/application_group.rb

@@ -0,0 +1,152 @@
+
+module Daemons
+  class ApplicationGroup
+  
+    attr_reader :app_name
+    attr_reader :script
+    
+    attr_reader :monitor
+    
+    #attr_reader :controller
+    
+    attr_reader :options
+    
+    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, options = {})
+      @app_name = app_name
+      @options = options
+      
+      if options[:script]
+        @script = File.expand_path(options[:script])
+      end
+      
+      #@controller = controller
+      @monitor = nil
+      
+      #options = controller.options
+      
+      @multiple = options[:multiple] || false
+      
+      @dir_mode = options[:dir_mode] || :script
+      @dir = options[:dir] || ''
+      
+      @keep_pid_files = options[:keep_pid_files] || false
+      
+      #@applications = find_applications(pidfile_dir())
+      @applications = []
+    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, ! @keep_pid_files)
+      
+      #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(add_options = {})
+      if @applications.size > 0 and not @multiple
+        if 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, add_options)
+      
+      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 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(force = false)
+      @monitor.stop if @monitor
+      
+      @applications.each {|a| 
+        if force
+          begin; a.stop; rescue ::Exception; end
+        else
+          a.stop
+        end
+      }
+    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
+
+end

data/lib/daemons/cmdline.rb

@@ -0,0 +1,117 @@
+
+module Daemons
+
+  class Optparse
+  
+    attr_reader :usage
+
+    def initialize(controller)
+      @controller = controller
+      @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
+        
+        opts.on("-t", "--ontop", "Stay on top (does not daemonize)") do |t|
+          @options[:ontop] = t
+        end
+        
+        opts.on("-f", "--force", "Force operation") do |t|
+          @options[:force] = t
+        end
+        
+        #opts.separator ""
+        #opts.separator "Specific options:"
+
+        
+        opts.separator ""
+        opts.separator "Common options:"
+
+        # No argument, shows at tail.  This will print an options summary.
+        # Try it and see!
+        opts.on_tail("-h", "--help", "Show this message") do
+          #puts opts
+          #@usage = 
+          controller.print_usage()
+          
+          exit
+        end
+
+        # Another typical switch to print the version.
+        opts.on_tail("--version", "Show version") do
+          puts "daemons version #{Daemons::VERSION}"
+          exit
+        end
+      end  
+      
+      begin
+        @usage = @opts.to_s
+      rescue ::Exception # work around a bug in ruby 1.9
+        @usage = <<END
+            -t, --ontop                      Stay on top (does not daemonize)
+            -f, --force                      Force operation
+
+        Common options:
+            -h, --help                       Show this message
+                --version                    Show version
+END
+      end
+    end
+    
+    
+    #
+    # Return a hash describing the options.
+    #
+    def parse(args)
+      # The options specified on the command line will be collected in *options*.
+      # We set default values here.
+      #options = {}
+      
+      
+      ##pp args
+      @opts.parse(args)
+      
+      return @options
+    end
+
+  end
+  
+  
+  class Controller
+  
+    def print_usage
+      puts "Usage: #{@app_name} <command> <options> -- <application options>"
+      puts
+      puts "* where <command> is one of:"
+      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 "  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:"
+      
+      puts @optparse.usage
+    end
+    
+    def catch_exceptions(&block)
+      begin
+        block.call
+      rescue CmdException, OptionParser::ParseError => e
+        puts "ERROR: #{e.to_s}"
+        puts
+        print_usage()
+      rescue RuntimeException => e
+        puts "ERROR: #{e.to_s}"
+      end
+    end
+    
+  end
+  
+end

data/lib/daemons/controller.rb

@@ -0,0 +1,137 @@
+
+module Daemons
+  class Controller
+    
+    attr_reader :app_name
+    
+    attr_reader :group
+    
+    attr_reader :options
+    
+    
+    COMMANDS = [
+      'start',
+      'stop',
+      'restart',
+      'run',
+      'zap',
+      'status'
+    ]
+    
+    def initialize(options = {}, argv = [])
+      @options = options
+      @argv = argv
+      
+      # Allow an app_name to be specified. If not specified use the
+      # basename of the script.
+      @app_name = options[:app_name]
+      
+      if options[:script]
+        @script = File.expand_path(options[:script])
+    
+        @app_name ||= File.split(@script)[1]
+      end
+    
+      @app_name ||= 'unknown_application'
+      
+      @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.update @optparse.parse(@controller_part).delete_if {|k,v| !v}
+      
+      setup_options()
+      
+      #pp @options
+
+      @group = ApplicationGroup.new(@app_name, @options)
+      @group.controller_argv = @controller_part
+      @group.app_argv = @app_part
+      
+      @group.setup
+      
+      case @command
+        when 'start'
+          @group.new_application.start
+        when 'run'
+          @options[:ontop] ||= true
+          @group.new_application.start
+        when 'stop'
+          @group.stop_all
+        when 'restart'
+          unless @group.applications.empty?
+            @group.stop_all
+            sleep 1
+            @group.start_all
+          else
+            puts "Warning: no instances running. Starting..."
+            @group.new_application.start
+          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('--')
+        # Handle the case where no controller options are given, just
+        # options after "--" as well (i == 0)
+        controller_part = (i == 0 ? [] : 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
+
+end

data/lib/daemons/daemonize.rb

@@ -0,0 +1,263 @@
+#--
+###############################################################################
+# 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
+    tryagain = true
+
+    while tryagain
+      tryagain = false
+      begin
+        if pid = fork
+          return pid
+        end
+      rescue Errno::EWOULDBLOCK
+        sleep 5
+        tryagain = true
+      end
+    end
+  end
+  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
+    
+    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
+    
+    begin; STDIN.reopen "/dev/null"; rescue ::Exception; end       
+  end
+  module_function :simulate
+  
+  
+  def call_as_daemon(block, logfile_name = nil, app_name = nil)
+    rd, wr = IO.pipe
+    
+    if tmppid = safefork
+      # parent
+      wr.close
+      pid = rd.read.to_i
+      rd.close
+      
+      Process.waitpid(tmppid)
+      
+      return pid
+    else
+      # child
+      
+      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
+      
+      $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
+  
+      redirect_io(logfile_name)  
+    
+      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, app_name = nil)
+    srand # Split rand streams between spawning and daemonized process
+    safefork and exit # Fork and exit from the parent
+
+    # 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
+
+    $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
+
+    redirect_io(logfile_name)
+    
+    #return oldmode ? sess_id : 0   # Return value is mostly irrelevant
+    return sess_id
+  end
+  module_function :daemonize
+  
+  
+  # Free 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" 
+        STDOUT.sync = true
+      rescue ::Exception
+        begin; STDOUT.reopen "/dev/null"; rescue ::Exception; end
+      end
+    else
+      begin; STDOUT.reopen "/dev/null"; rescue ::Exception; end
+    end
+    
+    begin; STDERR.reopen STDOUT; rescue ::Exception; end
+    STDERR.sync = true
+  end
+  module_function :redirect_io
+  
+end