fire_and_forget 0.3.2 → 0.3.3

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

@@ -1,194 +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
-      @no_pidfiles = options[:no_pidfiles] || 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)
-      if @no_pidfiles
-        return find_applications_by_app_name(app_name)
-      else
-        return find_applications_by_pidfiles(dir)
-      end
-    end
-    
-    # TODO: identifiy the monitor process
-    def find_applications_by_app_name(app_name)
-      pids = []
-      
-      begin
-      x = `ps auxw | grep -v grep | awk '{print $2, $11, $12}' | grep #{app_name}`
-      if x && x.chomp!
-        processes = x.split(/\n/).compact
-        processes = processes.delete_if do |p|
-          pid, name, add = p.split(/\s/)
-          # We want to make sure that the first part of the process name matches
-          # so that app_name matches app_name_22
-          
-          app_name != name[0..(app_name.length - 1)] and not add.include?(app_name)
-        end
-        pids = processes.map {|p| p.split(/\s/)[0].to_i}
-      end
-      rescue ::Exception
-      end
-      
-      return pids.map {|f|
-        app = Application.new(self, {}, PidMem.existing(f))
-        setup_app(app)
-        app
-      }
-    end
-    
-    def find_applications_by_pidfiles(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(no_wait = false)
-      @monitor.stop if @monitor
-      
-      threads = []
-      
-      @applications.each {|a| 
-        threads << Thread.new do
-          a.stop(no_wait)
-        end
-      }
-      
-      threads.each {|t| t.join}
-    end
-    
-    def reload_all
-      @applications.each {|a| a.reload}
-    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/daemons-1.1.0/lib/daemons/change_privilege.rb

@@ -1,19 +0,0 @@
-require 'daemons/etc_extension'
-
-class CurrentProcess
-  def self.change_privilege(user, group=user)
-    puts "Changing process privilege to #{user}:#{group}"
-  
-    uid, gid = Process.euid, Process.egid
-    target_uid = Etc.getpwnam(user).uid
-    target_gid = Etc.getgrnam(group).gid
-
-    if uid != target_uid || gid != target_gid
-      Process.initgroups(user, target_gid)
-      Process::GID.change_privilege(target_gid)
-      Process::UID.change_privilege(target_uid)
-    end
-  rescue Errno::EPERM => e
-    raise "Couldn't change user and group to #{user}:#{group}: #{e}"
-  end
-end

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

@@ -1,124 +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.on("-n", "--no_wait", "Do not wait for processes to stop") do |t|
-          @options[:no_wait] = 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
-            -n, --no_wait                    Do not wait for processes to stop
-
-        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 "  reload        send a SIGHUP to all instances of the application"
-      puts "  run           start the application and stay on top"
-      puts "  zap           set the application to a stopped state"
-      puts "  status        show status (PID) of application instances"
-      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/daemons-1.1.0/lib/daemons/controller.rb

@@ -1,140 +0,0 @@
-
-module Daemons
-  class Controller
-    
-    attr_reader :app_name
-    
-    attr_reader :group
-    
-    attr_reader :options
-    
-    
-    COMMANDS = [
-      'start',
-      'stop',
-      'restart',
-      'run',
-      'zap',
-      'reload',
-      '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(@options[:no_wait])
-        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 'reload'
-          @group.reload_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
-          
-          #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