mikehale-daemons 1.0.12.1

data/lib/daemons/application_group.rb

@@ -0,0 +1,226 @@
+
+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
+    
+    # Specify :force_kill_wait => (seconds to wait) and this method will
+    # block until the process is dead.  It first sends a TERM signal, then
+    # a KILL signal (-9) if the process hasn't died after the wait time.
+    # Note: The force argument is from the original daemons implementation.
+    def stop_all(force = false)
+      @monitor.stop if @monitor
+      
+      failed_to_kill = false
+      debug = options[:debug]
+      wait = options[:force_kill_wait].to_i
+      pids = unix_pids
+      if wait > 0 && pids.size > 0
+        puts "[daemons_ext]: Killing #{app_name} with force after #{wait} secs."
+        STDOUT.flush
+
+        # Send term first, don't delete PID files.
+        pids.each {|pid| Process.kill('TERM', pid) rescue Errno::ESRCH}
+
+        begin
+          Timeout::timeout(wait) {block_on_pids(wait, debug, options[:sleepy_time] || 1)}
+        rescue Timeout::Error
+          puts "[daemons_ext]: Time is up! Forcefully killing #{unix_pids.size} #{app_name}(s)..."
+          STDOUT.flush
+          unix_pids.each {|pid| `kill -9 #{pid}`}
+          begin
+            # Give it an extra 30 seconds to kill -9
+            Timeout::timeout(30) {block_on_pids(wait, debug, options[:sleepy_time] || 1)}
+          rescue Timeout::Error
+            failed_to_kill = true
+            puts "[daemons_ext]: #{unix_pids} #{app_name}(s) won't die! Giving up."
+            STDOUT.flush
+          end
+        ensure
+          # Delete Pidfiles
+          @applications.each {|a| a.zap!}
+        end
+
+        puts "[daemons_ext]: All #{app_name}s dead." unless failed_to_kill
+        STDOUT.flush
+      else
+        @applications.each {|a| 
+          if force
+            begin; a.stop; rescue ::Exception; end
+          else
+            a.stop
+          end
+        }
+      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
+    
+    private
+
+    # Block until all unix_pids are gone (should be wrapped in a timeout)
+    def block_on_pids(wait, debug, sleepy_time = 1)
+      started_at = Time.now
+      num_pids = unix_pids.size
+      while num_pids > 0
+        time_left = wait - (Time.now - started_at)
+        puts "[daemons_ext]: Waiting #{time_left.round} secs on " +
+              "#{num_pids} #{app_name}(s)..."
+        unix_pids.each {|pid| puts "\t#{pid}"} if debug
+        STDOUT.flush
+        sleep sleepy_time
+        num_pids = unix_pids.size
+      end 
+    end
+
+    # Find UNIX pids based on app_name.  CAUTION: This has only been tested on
+    # Mac OS X and CentOS.
+    def unix_pids
+      pids = []
+      x = `ps auxw | grep -v grep | awk '{print $2, $11}' | grep #{app_name}`
+      if x && x.chomp!
+        processes = x.split(/\n/).compact
+        processes = processes.delete_if do |p|
+          pid, name = 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)]
+        end
+        pids = processes.map {|p| p.split(/\s/)[0].to_i}
+      end
+
+      pids
+    end
+    
+  end
+
+end

data/lib/daemons/change_privilege.rb

@@ -0,0 +1,19 @@
+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/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,134 @@
+
+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