RubyGems - poolparty - Versions diffs - 1.3.15 → 1.4.0 - Mend

poolparty 1.3.15 → 1.4.0

Files changed (1171) hide show

data/vendor/gems/daemons/lib/daemons/application_group.rb DELETED Viewed

@@ -1,152 +0,0 @@
-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/vendor/gems/daemons/lib/daemons/cmdline.rb DELETED Viewed

@@ -1,117 +0,0 @@
-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/vendor/gems/daemons/lib/daemons/controller.rb DELETED Viewed

@@ -1,134 +0,0 @@
-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
-          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/vendor/gems/daemons/lib/daemons/daemonize.rb DELETED Viewed

@@ -1,263 +0,0 @@
-#--
-###############################################################################
-# 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

data/vendor/gems/daemons/lib/daemons/exceptions.rb DELETED Viewed

@@ -1,28 +0,0 @@
-module Daemons
-  class Exception < ::RuntimeError
-  end
-  class RuntimeException < Exception
-  end
-  class CmdException < Exception
-  end
-  class Error < Exception
-  end
-  class SystemError < Error
-    attr_reader :system_error
-    def initialize(msg, system_error)
-      super(msg)
-      @system_error = system_error
-    end
-  end
-end