resurrected_god 0.14.0 → 1.0.0

data/lib/god.rb

@@ -8,15 +8,6 @@ if $load_god
   require 'stringio'
   require 'fileutils'
 
-  begin
-    require 'fastthread'
-  rescue LoadError
-  ensure
-    require 'thread'
-  end
-
-  # stdlib
-
   # internal requires
   require 'god/errors'
   require 'god/simple_logger'
@@ -65,14 +56,10 @@ if $load_god
   require 'god/registry'
   require 'god/process'
 
+  require 'god/version'
   require 'god/cli/version'
   require 'god/cli/command'
 
-  # ruby 1.8 specific configuration
-  if RUBY_VERSION < '1.9'
-    $KCODE = 'u'
-  end
-
   CONTACT_DEPS = {}
   CONTACT_LOAD_SUCCESS = {}
 
@@ -85,9 +72,7 @@ if $load_god
 
   require 'god/contact'
   load_contact(:campfire)
-  load_contact(:hipchat)
   load_contact(:email)
-  load_contact(:jabber)
   load_contact(:prowl)
   load_contact(:scout)
   load_contact(:statsd)
@@ -97,7 +82,7 @@ if $load_god
   load_contact(:slack)
   load_contact(:sensu)
 
-  $:.unshift File.join(File.dirname(__FILE__), *%w[.. ext god])
+  $LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w[.. ext god])
 
   # App wide logging system
   LOG = God::Logger.new
@@ -120,7 +105,7 @@ if $load_god
   end
 
   module Kernel
-    alias_method :abort_orig, :abort
+    alias abort_orig abort
 
     def abort(text = nil)
       $run = false
@@ -128,7 +113,7 @@ if $load_god
       exit(1)
     end
 
-    alias_method :exit_orig, :exit
+    alias exit_orig exit
 
     def exit(code = 0)
       $run = false
@@ -139,43 +124,38 @@ if $load_god
   class Module
     def safe_attr_accessor(*args)
       args.each do |arg|
-        define_method((arg.to_s + "=").intern) do |other|
-          if !self.running && self.inited
-            abort "God.#{arg} must be set before any Tasks are defined"
-          end
+        define_method("#{arg}=".intern) do |other|
+          abort "God.#{arg} must be set before any Tasks are defined" if !running && inited
 
-          if self.running && self.inited
+          if running && inited
             applog(nil, :warn, "God.#{arg} can't be set while god is running")
             return
           end
 
-          instance_variable_set(('@' + arg.to_s).intern, other)
+          instance_variable_set("@#{arg}".intern, other)
         end
 
         define_method(arg) do
-          instance_variable_get(('@' + arg.to_s).intern)
+          instance_variable_get("@#{arg}".intern)
         end
       end
     end
   end
 
-module God
-  # The String version number for this package.
-  VERSION = '0.14.0'
-
+  module God
     # The Integer number of lines of backlog to keep for the logger.
     LOG_BUFFER_SIZE_DEFAULT = 100
 
     # An Array of directory paths to be used as the default PID file directory.
     # This list will be searched in order and the first one that has write
     # permissions will be used.
-    PID_FILE_DIRECTORY_DEFAULTS = ['/var/run/god', '~/.god/pids']
+    PID_FILE_DIRECTORY_DEFAULTS = ['/var/run/god', '~/.god/pids'].freeze
 
-    # The default Integer port number for the DRb communcations channel.
+    # The default Integer port number for the DRb communications channel.
     DRB_PORT_DEFAULT = 17165
 
     # The default Array of String IPs that will allow DRb communication access.
-    DRB_ALLOW_DEFAULT = ['127.0.0.1']
+    DRB_ALLOW_DEFAULT = ['127.0.0.1'].freeze
 
     # The default Symbol log level.
     LOG_LEVEL_DEFAULT = :info
@@ -188,7 +168,7 @@ module God
     STOP_TIMEOUT_DEFAULT = 10
 
     # The default String signal to send for the stop command.
-    STOP_SIGNAL_DEFAULT = 'TERM'
+    STOP_SIGNAL_DEFAULT = 'TERM'.freeze
 
     class << self
       # user configurable
@@ -237,7 +217,7 @@ module God
     # Returns nothing.
     def self.internal_init
       # Only do this once.
-      return if self.inited
+      return if inited
 
       # Variable init.
       self.watches = {}
@@ -255,14 +235,14 @@ module God
       self.terminate_timeout ||= TERMINATE_TIMEOUT_DEFAULT
 
       # Additional setup.
-      self.setup
+      setup
 
       # Log level.
-      log_level_map = { :debug => Logger::DEBUG,
-                        :info => Logger::INFO,
-                        :warn => Logger::WARN,
-                        :error => Logger::ERROR,
-                        :fatal => Logger::FATAL }
+      log_level_map = { debug: Logger::DEBUG,
+                        info: Logger::INFO,
+                        warn: Logger::WARN,
+                        error: Logger::ERROR,
+                        fatal: Logger::FATAL }
       LOG.level = log_level_map[self.log_level]
 
       # Init has been executed.
@@ -278,7 +258,7 @@ module God
     #
     # Returns nothing.
     def self.watch(&block)
-      self.task(Watch, &block)
+      task(Watch, &block)
     end
 
     # Instantiate a new, empty Task object and yield it to the mandatory block.
@@ -288,7 +268,7 @@ module God
     # Returns nothing.
     def self.task(klass = Task)
       # Ensure internal init has run.
-      self.internal_init
+      internal_init
 
       t = klass.new
       yield(t)
@@ -298,44 +278,40 @@ module God
 
       # If running, completely remove the watch (if necessary) to prepare for
       # the reload
-      existing_watch = self.watches[t.name]
-      if self.running && existing_watch
-        self.pending_watch_states[existing_watch.name] = existing_watch.state
-        self.unwatch(existing_watch)
+      existing_watch = watches[t.name]
+      if running && existing_watch
+        pending_watch_states[existing_watch.name] = existing_watch.state
+        unwatch(existing_watch)
       end
 
       # Ensure the new watch has a unique name.
-      if self.watches[t.name] || self.groups[t.name]
-        abort "Task name '#{t.name}' already used for a Task or Group"
-      end
+      abort "Task name '#{t.name}' already used for a Task or Group" if watches[t.name] || groups[t.name]
 
       # Ensure watch is internally valid.
       t.valid? || abort("Task '#{t.name}' is not valid (see above)")
 
       # Add to list of watches.
-      self.watches[t.name] = t
+      watches[t.name] = t
 
       # Add to pending watches.
-      self.pending_watches << t
+      pending_watches << t
 
       # Add to group if specified.
       if t.group
         # Ensure group name hasn't been used for a watch already.
-        if self.watches[t.group]
-          abort "Group name '#{t.group}' already used for a Task"
-        end
+        abort "Group name '#{t.group}' already used for a Task" if watches[t.group]
 
-        self.groups[t.group] ||= []
-        self.groups[t.group] << t
+        groups[t.group] ||= []
+        groups[t.group] << t
       end
 
       # Register watch.
       t.register!
 
       # Log.
-      if self.running && existing_watch
+      if running && existing_watch
         applog(t, :info, "#{t.name} Reloaded config")
-      elsif self.running
+      elsif running
         applog(t, :info, "#{t.name} Loaded config")
       end
     end
@@ -353,12 +329,10 @@ module God
       watch.unregister!
 
       # Remove from watches.
-      self.watches.delete(watch.name)
+      watches.delete(watch.name)
 
       # Remove from groups.
-      if watch.group
-        self.groups[watch.group].delete(watch)
-      end
+      groups[watch.group].delete(watch) if watch.group
 
       applog(watch, :info, "#{watch.name} unwatched")
     end
@@ -372,12 +346,12 @@ module God
     # Returns nothing.
     def self.contact(kind)
       # Ensure internal init has run.
-      self.internal_init
+      internal_init
 
       # Verify contact has been loaded.
       if CONTACT_LOAD_SUCCESS[kind] == false
         applog(nil, :error, "A required dependency for the #{kind} contact is unavailable.")
-        applog(nil, :error, "Run the following commands to install the dependencies:")
+        applog(nil, :error, 'Run the following commands to install the dependencies:')
         CONTACT_DEPS[kind].each do |d|
           applog(nil, :error, "  [sudo] gem install #{d}")
         end
@@ -398,36 +372,30 @@ module God
       c.prepare
 
       # Remove existing contacts of same name.
-      existing_contact = self.contacts[c.name]
-      if self.running && existing_contact
-        self.uncontact(existing_contact)
-      end
+      existing_contact = contacts[c.name]
+      uncontact(existing_contact) if running && existing_contact
 
       # Warn and noop if the contact has been defined before.
-      if self.contacts[c.name] || self.contact_groups[c.name]
+      if contacts[c.name] || contact_groups[c.name]
         applog(nil, :warn, "Contact name '#{c.name}' already used for a Contact or Contact Group")
         return
       end
 
       # Abort if the Contact is invalid, the Contact will have printed out its
       # own error messages by now.
-      unless Contact.valid?(c) && c.valid?
-        abort "Exiting on invalid contact"
-      end
+      abort 'Exiting on invalid contact' unless Contact.valid?(c) && c.valid?
 
       # Add to list of contacts.
-      self.contacts[c.name] = c
+      contacts[c.name] = c
 
       # Add to contact group if specified.
-      if c.group
-        # Ensure group name hasn't been used for a contact already.
-        if self.contacts[c.group]
-          abort "Contact Group name '#{c.group}' already used for a Contact"
-        end
+      return unless c.group
 
-        self.contact_groups[c.group] ||= []
-        self.contact_groups[c.group] << c
-      end
+      # Ensure group name hasn't been used for a contact already.
+      abort "Contact Group name '#{c.group}' already used for a Contact" if contacts[c.group]
+
+      contact_groups[c.group] ||= []
+      contact_groups[c.group] << c
     end
 
     # Remove the given contact from god.
@@ -436,16 +404,16 @@ module God
     #
     # Returns nothing.
     def self.uncontact(contact)
-      self.contacts.delete(contact.name)
-      if contact.group
-        self.contact_groups[contact.group].delete(contact)
-      end
+      contacts.delete(contact.name)
+      return unless contact.group
+
+      contact_groups[contact.group].delete(contact)
     end
 
     def self.watches_by_name(name)
       case name
-      when "", nil then self.watches.values.dup
-      else Array(self.watches[name] || self.groups[name]).dup
+      when '', nil then watches.values.dup
+      else Array(watches[name] || groups[name]).dup
       end
     end
 
@@ -458,29 +426,34 @@ module God
     # Returns an Array of String task names affected by the command.
     def self.control(name, command)
       # Get the list of items.
-      items = self.watches_by_name(name)
+      items = watches_by_name(name)
 
       jobs = []
 
       # Do the command.
       case command
-      when "start", "monitor"
+      when 'start', 'monitor'
         items.each { |w| jobs << Thread.new { w.monitor if w.state != :up } }
-      when "restart"
+      when 'restart'
         items.each { |w| jobs << Thread.new { w.move(:restart) } }
-      when "stop"
-        items.each { |w| jobs << Thread.new { w.action(:stop); w.unmonitor if w.state != :unmonitored } }
-      when "unmonitor"
+      when 'stop'
+        items.each do |w|
+          jobs << Thread.new do
+            w.action(:stop)
+            w.unmonitor if w.state != :unmonitored
+          end
+        end
+      when 'unmonitor'
         items.each { |w| jobs << Thread.new { w.unmonitor if w.state != :unmonitored } }
-      when "remove"
-        items.each { |w| self.unwatch(w) }
+      when 'remove'
+        items.each { |w| unwatch(w) }
       else
-        raise InvalidCommandError.new
+        raise InvalidCommandError
       end
 
-      jobs.each { |j| j.join }
+      jobs.each(&:join)
 
-      items.map { |x| x.name }
+      items.map(&:name)
     end
 
     # Unmonitor and stop all tasks.
@@ -488,7 +461,7 @@ module God
     # Returns true on success, false if all tasks could not be stopped within 10
     # seconds
     def self.stop_all
-      self.watches.sort.each do |name, w|
+      watches.sort.each do |_name, w|
         Thread.new do
           w.action(:stop)
           w.unmonitor if w.state != :unmonitored
@@ -496,11 +469,12 @@ module God
       end
 
       terminate_timeout.times do
-        return true unless self.watches.map { |name, w| w.alive? }.any?
+        return true if watches.none? { |_name, w| w.alive? }
+
         sleep 1
       end
 
-      return false
+      false
     end
 
     # Force the termination of god.
@@ -510,8 +484,8 @@ module God
     #
     # Never returns because the process will no longer exist!
     def self.terminate
-      FileUtils.rm_f(self.pid) if self.pid
-      self.server.stop if self.server
+      FileUtils.rm_f(pid) if pid
+      server&.stop
       exit!(0)
     end
 
@@ -526,8 +500,8 @@ module God
     #   Symbol status.
     def self.status
       info = {}
-      self.watches.map do |name, w|
-        info[name] = { :state => w.state, :group => w.group }
+      watches.map do |name, w|
+        info[name] = { state: w.state, group: w.group }
       end
       info
     end
@@ -542,8 +516,8 @@ module God
       items = watches_by_name(name)
       jobs = []
       items.each { |w| jobs << Thread.new { w.signal(signal) } }
-      jobs.each { |j| j.join }
-      items.map { |x| x.name }
+      jobs.each(&:join)
+      items.map(&:name)
     end
 
     # Log lines for the given task since the specified time.
@@ -554,11 +528,9 @@ module God
     # Raises God::NoSuchWatchError if no tasks matched.
     # Returns the String of newline separated log lines.
     def self.running_log(watch_name, since)
-      matches = pattern_match(watch_name, self.watches.keys)
+      matches = pattern_match(watch_name, watches.keys)
 
-      unless matches.first
-        raise NoSuchWatchError.new
-      end
+      raise NoSuchWatchError unless matches.first
 
       LOG.watch_log_since(matches.first, since)
     end
@@ -581,7 +553,7 @@ module God
     #                          from the system (if 'remove' or 'stop' was
     #                          specified as the action).
     def self.running_load(code, filename, action = nil)
-      errors = ""
+      errors = ''
       loaded_watches = []
       unloaded_watches = []
       jobs = []
@@ -590,27 +562,30 @@ module God
         LOG.start_capture
 
         Gem.clear_paths
-        eval(code, root_binding, filename)
-        self.pending_watches.each do |w|
-          if previous_state = self.pending_watch_states[w.name]
+        eval(code, root_binding, filename) # rubocop:disable Security/Eval
+        pending_watches.each do |w|
+          if (previous_state = pending_watch_states[w.name])
             w.monitor unless previous_state == :unmonitored
-          else
-            w.monitor if w.autostart?
+          elsif w.autostart?
+            w.monitor
           end
         end
-        loaded_watches = self.pending_watches.map { |w| w.name }
-        self.pending_watches.clear
-        self.pending_watch_states.clear
+        loaded_watches = pending_watches.map(&:name)
+        pending_watches.clear
+        pending_watch_states.clear
 
-        self.watches.each do |name, watch|
+        watches.each do |name, watch|
           next if loaded_watches.include?(name)
 
           case action
           when 'stop'
-            jobs << Thread.new(watch) { |w| w.action(:stop); self.unwatch(w) }
+            jobs << Thread.new(watch) do |w|
+              w.action(:stop)
+              unwatch(w)
+            end
             unloaded_watches << name
           when 'remove'
-            jobs << Thread.new(watch) { |w| self.unwatch(w) }
+            jobs << Thread.new(watch) { |w| unwatch(w) }
             unloaded_watches << name
           when 'leave', '', nil
             # Do nothing
@@ -631,7 +606,7 @@ module God
         end
       end
 
-      jobs.each { |t| t.join }
+      jobs.each(&:join)
 
       [loaded_watches, errors, unloaded_watches]
     end
@@ -651,19 +626,19 @@ module God
     #
     # Returns nothing.
     def self.setup
-      if self.pid_file_directory
+      if pid_file_directory
+        dir = File.expand_path(pid_file_directory)
         # Pid file dir was specified, ensure it is created and writable.
-        unless File.exist?(self.pid_file_directory)
+        unless File.exist?(dir)
           begin
-            FileUtils.mkdir_p(self.pid_file_directory)
-          rescue Errno::EACCES => e
+            FileUtils.mkdir_p(dir)
+          rescue Errno::EACCES => e # rubocop:disable Metrics/BlockNesting
             abort "Failed to create pid file directory: #{e.message}"
           end
         end
+        abort "The pid file directory (#{dir}) is not writable by #{Etc.getlogin}" unless File.writable?(dir)
 
-        unless File.writable?(self.pid_file_directory)
-          abort "The pid file directory (#{self.pid_file_directory}) is not writable by #{Etc.getlogin}"
-        end
+        self.pid_file_directory = dir
       else
         # No pid file dir specified, try defaults.
         PID_FILE_DIRECTORY_DEFAULTS.each do |idir|
@@ -674,39 +649,40 @@ module God
               self.pid_file_directory = dir
               break
             end
-          rescue Errno::EACCES => e
+          rescue Errno::EACCES
+            # Ignore errors on directory creation failure here.
           end
         end
 
-        unless self.pid_file_directory
+        unless pid_file_directory
           dirs = PID_FILE_DIRECTORY_DEFAULTS.map { |x| File.expand_path(x) }
           abort "No pid file directory exists, could be created, or is writable at any of #{dirs.join(', ')}"
         end
       end
 
       if God::Logger.syslog
-        LOG.info("Syslog enabled.")
+        LOG.info('Syslog enabled.')
       else
-        LOG.info("Syslog disabled.")
+        LOG.info('Syslog disabled.')
       end
 
-      applog(nil, :info, "Using pid file directory: #{self.pid_file_directory}")
+      applog(nil, :info, "Using pid file directory: #{pid_file_directory}")
     end
 
     # Initialize and startup the machinery that makes god work.
     #
     # Returns nothing.
     def self.start
-      self.internal_init
+      internal_init
 
       # Instantiate server.
-      self.server = Socket.new(self.port, self.socket_user, self.socket_group, self.socket_perms)
+      self.server = Socket.new(self.port, socket_user, socket_group, socket_perms)
 
       # Start monitoring any watches set to autostart.
-      self.watches.values.each { |w| w.monitor if w.autostart? }
+      watches.each_value { |w| w.monitor if w.autostart? }
 
       # Clear pending watches.
-      self.pending_watches.clear
+      pending_watches.clear
 
       # Mark as running.
       self.running = true
@@ -724,7 +700,7 @@ module God
     #
     # Returns nothing.
     def self.join
-      self.main.join if self.main
+      main&.join
     end
 
     # Returns the version String.
@@ -736,8 +712,8 @@ module God
     #
     # Returns nothing.
     def self.at_exit
-      self.start
-      self.join
+      start
+      join
     end
 
     # private
@@ -758,11 +734,9 @@ module God
     #
     # Returns the Array of matching name Strings.
     def self.pattern_match(pattern, list)
-      regex = pattern.split('').join('.*')
+      regex = pattern.chars.join('.*')
 
-      list.select do |item|
-        item =~ Regexp.new(regex)
-      end.sort_by { |x| x.size }
+      list.grep(Regexp.new(regex)).sort_by(&:size)
     end
   end