Class: Daemons::ApplicationGroup

### Home Classes Methods

### In Files

- lib/daemons/application_group.rb

### Parent

Object

### Methods

- ::new
- #create_monitor
- #find_applications
- #find_applications_by_app_name
- #find_applications_by_pidfiles
- #new_application
- #pidfile_dir
- #reload_all
- #setup
- #show_status
- #start_all
- #stop_all
- #zap_all

### Files

- README
- Releases
- TODO

### Class/Module Index

Quicksearch

- Daemons
- Daemons::Application
- Daemons::ApplicationGroup
- Daemons::CmdException
- Daemons::Controller
- Daemons::Error
- Daemons::Exception
- Daemons::Monitor
- Daemons::Optparse
- Daemons::Pid
- Daemons::PidFile
- Daemons::PidMem
- Daemons::RuntimeException
- Daemons::SystemError
- CurrentProcess
- Daemonize
- Object

No matching classes.

# Daemons::ApplicationGroup

### Attributes

app_argv[RW]
app_name[R]
applications[R]
controller_argv[RW]
dir[RW]
dir_mode[RW]
monitor[R]
multiple[R]

true if the application is supposed to run in multiple instances

options[R]

attr_reader :controller

script[R]

### Public Class Methods

new(app_name, options = {}) click to toggle source

    # File lib/daemons/application_group.rb, line 26
    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

### Public Instance Methods

create_monitor(an_app) click to toggle source

    # File lib/daemons/application_group.rb, line 143
    def create_monitor(an_app)
      return if @monitor

      if options[:monitor]
        @monitor = Monitor.new(an_app)

        @monitor.start(@applications)
      end
    end

find_applications(dir) click to toggle source

    # File lib/daemons/application_group.rb, line 63
    def find_applications(dir)
      if @no_pidfiles
        return find_applications_by_app_name(app_name)
      else
        return find_applications_by_pidfiles(dir)
      end
    end

find_applications_by_app_name(app_name) click to toggle source

TODO: identifiy the monitor process

    # File lib/daemons/application_group.rb, line 72
    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

find_applications_by_pidfiles(dir) click to toggle source

    # File lib/daemons/application_group.rb, line 98
    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

new_application(add_options = {}) click to toggle source

    # File lib/daemons/application_group.rb, line 114
    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

pidfile_dir() click to toggle source

    # File lib/daemons/application_group.rb, line 59
    def pidfile_dir
      PidFile.dir(@dir_mode, @dir, script)
    end

reload_all() click to toggle source

    # File lib/daemons/application_group.rb, line 178
    def reload_all
      @applications.each {|a| a.reload}
    end

setup() click to toggle source

Setup the application group. Currently this functions calls `find_applications` which finds all running instances of the application and populates the application array.

    # File lib/daemons/application_group.rb, line 55
    def setup
      @applications = find_applications(pidfile_dir())
    end

show_status() click to toggle source

    # File lib/daemons/application_group.rb, line 188
    def show_status
      @applications.each {|a| a.show_status}
    end

start_all() click to toggle source

    # File lib/daemons/application_group.rb, line 153
    def start_all
      @monitor.stop if @monitor
      @monitor = nil

      @applications.each {|a|
        fork {
          a.start
        }
      }
    end

stop_all(no_wait = false) click to toggle source

    # File lib/daemons/application_group.rb, line 164
    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

zap_all() click to toggle source

    # File lib/daemons/application_group.rb, line 182
    def zap_all
      @monitor.stop if @monitor

      @applications.each {|a| a.zap}
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.