mcproc 2016.2.20

data/lib/god/conditions/process_exits.rb

@@ -0,0 +1,66 @@
+module God
+  module Conditions
+    # Trigger when a process exits.
+    #
+    #     +pid_file+ is the pid file of the process in question. Automatically
+    #                populated for Watches.
+    #
+    # Examples
+    #
+    #   # Trigger if process exits (from a Watch).
+    #   on.condition(:process_exits)
+    #
+    #   # Trigger if process exits (non-Watch).
+    #   on.condition(:process_exits) do |c|
+    #     c.pid_file = "/var/run/mongrel.3000.pid"
+    #   end
+    class ProcessExits < EventCondition
+      # The String PID file location of the process in question. Automatically
+      # populated for Watches.
+      attr_accessor :pid_file
+
+      def initialize
+        self.info = "process exited"
+      end
+
+      def valid?
+        true
+      end
+
+      def pid
+        self.pid_file ? File.read(self.pid_file).strip.to_i : self.watch.pid
+      end
+
+      def register
+        pid = self.pid
+
+        begin
+          EventHandler.register(pid, :proc_exit) do |extra|
+            formatted_extra = extra.size > 0 ? " #{extra.inspect}" : ""
+            self.info = "process #{pid} exited#{formatted_extra}"
+            self.watch.trigger(self)
+          end
+
+          msg = "#{self.watch.name} registered 'proc_exit' event for pid #{pid}"
+          applog(self.watch, :info, msg)
+        rescue StandardError
+          raise EventRegistrationFailedError.new
+        end
+      end
+
+      def deregister
+        pid = self.pid
+        if pid
+          EventHandler.deregister(pid, :proc_exit)
+
+          msg = "#{self.watch.name} deregistered 'proc_exit' event for pid #{pid}"
+          applog(self.watch, :info, msg)
+        else
+          pid_file_location = self.pid_file || self.watch.pid_file
+          applog(self.watch, :error, "#{self.watch.name} could not deregister: no cached PID or PID file #{pid_file_location} (#{self.base_name})")
+        end
+      end
+    end
+
+  end
+end

data/lib/god/conditions/process_running.rb

@@ -0,0 +1,63 @@
+module God
+  module Conditions
+    # Trigger when a process is running or not running depending on attributes.
+    #
+    # Examples
+    #
+    #   # Trigger if process IS NOT running.
+    #   on.condition(:process_running) do |c|
+    #     c.running = false
+    #   end
+    #
+    #   # Trigger if process IS running.
+    #   on.condition(:process_running) do |c|
+    #     c.running = true
+    #   end
+    #
+    #   # Non-Watch Tasks must specify a PID file.
+    #   on.condition(:process_running) do |c|
+    #     c.running = false
+    #     c.pid_file = "/var/run/mongrel.3000.pid"
+    #   end
+    class ProcessRunning < PollCondition
+      # Public: The Boolean specifying whether you want to trigger if the
+      # process is running (true) or if it is not running (false).
+      attr_accessor :running
+
+      # Public: The String PID file location of the process in question.
+      # Automatically populated for Watches.
+      attr_accessor :pid_file
+
+      def pid
+        self.pid_file ? File.read(self.pid_file).strip.to_i : self.watch.pid
+      end
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'pid_file' must be specified", self) if self.pid_file.nil? && self.watch.pid_file.nil?
+        valid &= complain("Attribute 'running' must be specified", self) if self.running.nil?
+        valid
+      end
+
+      def test
+        self.info = []
+
+        pid = self.pid
+        active = pid && System::Process.new(pid).exists?
+
+        if (self.running && active)
+          self.info.concat(["process is running"])
+          true
+        elsif (!self.running && !active)
+          self.info.concat(["process is not running"])
+          true
+        else
+          if self.running
+            self.info.concat(["process is not running"])
+          end
+          false
+        end
+      end
+    end
+  end
+end

data/lib/god/conditions/socket_responding.rb

@@ -0,0 +1,142 @@
+require 'socket'
+include Socket::Constants
+
+module God
+  module Conditions
+    # Condition Symbol :socket_running
+    # Type: Poll
+    #
+    # Trigger when a TCP or UNIX socket is running or not
+    #
+    # Parameters
+    # Required
+    #   +family+ is the family of socket: either 'tcp' or 'unix'
+    #   --one of port or path--
+    #   +port+ is the port (required if +family+ is 'tcp')
+    #   +path+ is the path (required if +family+ is 'unix')
+    #
+    # Optional
+    #   +responding+ is the boolean specifying whether you want to trigger if the socket is responding (true)
+    #                or if it is not responding (false) (default false)
+    #
+    # Examples
+    #
+    # Trigger if the TCP socket on port 80 is not responding or the connection is refused
+    #
+    # on.condition(:socket_responding) do |c|
+    #   c.family = 'tcp'
+    #   c.port = '80'
+    # end
+    #
+    # Trigger if the socket is not responding or the connection is refused (use alternate compact +socket+ interface)
+    #
+    # on.condition(:socket_responding) do |c|
+    #   c.socket = 'tcp:80'
+    # end
+    #
+    # Trigger if the socket is responding
+    #
+    # on.condition(:socket_responding) do |c|
+    #   c.socket = 'tcp:80'
+    #   c.responding = true
+    # end
+    #
+    # Trigger if the socket is not responding or the connection is refused 5 times in a row
+    #
+    # on.condition(:socket_responding) do |c|
+    #   c.socket = 'tcp:80'
+    #   c.times = 5
+    # end
+    #
+    # Trigger if the Unix socket on path '/tmp/sock' is not responding or non-existent
+    #
+    # on.condition(:socket_responding) do |c|
+    #   c.family = 'unix'
+    #   c.path = '/tmp/sock'
+    # end
+    #
+    class SocketResponding < PollCondition
+      attr_accessor :family, :addr, :port, :path, :times, :responding
+
+      def initialize
+        super
+        # default to tcp on the localhost
+        self.family = 'tcp'
+        self.addr = '127.0.0.1'
+        # Set these to nil/0 values
+        self.port = 0
+        self.path = nil
+        self.responding = false
+
+        self.times = [1, 1]
+      end
+
+      def prepare
+        if self.times.kind_of?(Integer)
+          self.times = [self.times, self.times]
+        end
+
+        @timeline = Timeline.new(self.times[1])
+        @history = Timeline.new(self.times[1])
+      end
+
+      def reset
+        @timeline.clear
+        @history.clear
+      end
+
+      def socket=(s)
+        components = s.split(':')
+        if components.size == 3
+          @family,@addr,@port = components
+          @port = @port.to_i
+        elsif components[0] =~ /^tcp$/
+          @family = components[0]
+          @port = components[1].to_i
+        elsif components[0] =~ /^unix$/
+          @family = components[0]
+          @path = components[1]
+        end
+      end
+
+      def valid?
+        valid = true
+        if self.family == 'tcp' and @port == 0
+          valid &= complain("Attribute 'port' must be specified for tcp sockets", self)
+        end
+        if self.family == 'unix' and self.path.nil?
+          valid &= complain("Attribute 'path' must be specified for unix sockets", self)
+        end
+        valid = false unless %w{tcp unix}.member?(self.family)
+        valid
+      end
+
+      def test
+        self.info = []
+        if self.family == 'tcp'
+          begin
+            s = TCPSocket.new(self.addr, self.port)
+          rescue SystemCallError
+          end
+          status = self.responding == !s.nil?
+        elsif self.family == 'unix'
+          begin
+            s = UNIXSocket.new(self.path)
+          rescue SystemCallError
+          end
+          status = self.responding == !s.nil?
+        else
+          status = false
+        end
+        @timeline.push(status)
+        history = "[" + @timeline.map {|t| t ? '*' : ''}.join(',') + "]"
+        if @timeline.select { |x| x }.size >= self.times.first
+          self.info = "socket out of bounds #{history}"
+          return true
+        else
+          return false
+        end
+      end
+    end
+  end
+end

data/lib/god/conditions/tries.rb

@@ -0,0 +1,44 @@
+module God
+  module Conditions
+
+    class Tries < PollCondition
+      attr_accessor :times, :within
+
+      def prepare
+        @timeline = Timeline.new(self.times)
+      end
+
+      def reset
+        @timeline.clear
+      end
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'times' must be specified", self) if self.times.nil?
+        valid
+      end
+
+      def test
+        @timeline << Time.now
+
+        concensus = (@timeline.size == self.times)
+        duration = self.within.nil? || (@timeline.last - @timeline.first) < self.within
+
+        if within
+          history = "[#{@timeline.size}/#{self.times} within #{(@timeline.last - @timeline.first).to_i}s]"
+        else
+          history = "[#{@timeline.size}/#{self.times}]"
+        end
+
+        if concensus && duration
+          self.info = "tries exceeded #{history}"
+          return true
+        else
+          self.info = "tries within bounds #{history}"
+          return false
+        end
+      end
+    end
+
+  end
+end

data/lib/god/configurable.rb

@@ -0,0 +1,57 @@
+module God
+
+  module Configurable
+    # Override this method in your Configurable (optional)
+    #
+    # Called once after the Configurable has been sent to the block and attributes have been
+    # set. Do any post-processing on attributes here
+    def prepare
+
+    end
+
+    def reset
+
+    end
+
+    # Override this method in your Configurable (optional)
+    #
+    # Called once during evaluation of the config file. Return true if valid, false otherwise
+    #
+    # A convenience method 'complain' is available that will print out a message and return false,
+    # making it easy to report multiple validation errors:
+    #
+    #   def valid?
+    #     valid = true
+    #     valid &= complain("You must specify the 'pid_file' attribute for :memory_usage") if self.pid_file.nil?
+    #     valid &= complain("You must specify the 'above' attribute for :memory_usage") if self.above.nil?
+    #     valid
+    #   end
+    def valid?
+      true
+    end
+
+    def base_name
+      x = 1 # fix for MRI's local scope optimization bug DO NOT REMOVE!
+      @base_name ||= self.class.name.split('::').last
+    end
+
+    def friendly_name
+      base_name
+    end
+
+    def self.complain(text, c = nil)
+      watch = c.watch rescue nil
+      msg = ""
+      msg += "#{watch.name}: " if watch
+      msg += text
+      msg += " for #{c.friendly_name}" if c
+      applog(watch, :error, msg)
+      false
+    end
+
+    def complain(text, c = nil)
+      Configurable.complain(text, c)
+    end
+  end
+
+end

data/lib/god/contact.rb

@@ -0,0 +1,114 @@
+module God
+
+  class Contact
+    include Configurable
+
+    attr_accessor :name, :group, :info
+
+    def self.generate(kind)
+      sym = kind.to_s.capitalize.gsub(/_(.)/){$1.upcase}.intern
+      c = God::Contacts.const_get(sym).new
+
+      unless c.kind_of?(Contact)
+        abort "Contact '#{c.class.name}' must subclass God::Contact"
+      end
+
+      c
+    rescue NameError
+      raise NoSuchContactError.new("No Contact found with the class name God::Contacts::#{sym}")
+    end
+
+    def self.valid?(contact)
+      valid = true
+      valid &= Configurable.complain("Attribute 'name' must be specified", contact) if contact.name.nil?
+      valid
+    end
+
+    def self.defaults
+      yield self
+    end
+
+    def arg(name)
+      self.instance_variable_get("@#{name}") || self.class.instance_variable_get("@#{name}")
+    end
+
+    # Normalize the given notify specification into canonical form.
+    #   +spec+ is the notify spec as a String, Array of Strings, or Hash
+    #
+    # Canonical form looks like:
+    # {:contacts => ['fred', 'john'], :priority => '1', :category => 'awesome'}
+    # Where :contacts will be present and point to an Array of Strings. Both
+    # :priority and :category may not be present but if they are, they will each
+    # contain a single String.
+    #
+    # Returns normalized notify spec
+    # Raises ArgumentError on invalid spec (message contains details)
+    def self.normalize(spec)
+      case spec
+        when String
+          {:contacts => Array(spec)}
+        when Array
+          unless spec.select { |x| !x.instance_of?(String) }.empty?
+            raise ArgumentError.new("contains non-String elements")
+          end
+          {:contacts => spec}
+        when Hash
+          copy = spec.dup
+
+          # check :contacts
+          if contacts = copy.delete(:contacts)
+            case contacts
+              when String
+                # valid
+              when Array
+                unless contacts.select { |x| !x.instance_of?(String) }.empty?
+                  raise ArgumentError.new("has a :contacts key containing non-String elements")
+                end
+                # valid
+              else
+                raise ArgumentError.new("must have a :contacts key pointing to a String or Array of Strings")
+            end
+          else
+            raise ArgumentError.new("must have a :contacts key")
+          end
+
+          # remove priority and category
+          copy.delete(:priority)
+          copy.delete(:category)
+
+          # check for invalid keys
+          unless copy.empty?
+            raise ArgumentError.new("contains extra elements: #{copy.inspect}")
+          end
+
+          # normalize
+          spec[:contacts] &&= Array(spec[:contacts])
+          spec[:priority] &&= spec[:priority].to_s
+          spec[:category] &&= spec[:category].to_s
+
+          spec
+        else
+          raise ArgumentError.new("must be a String (contact name), Array (of contact names), or Hash (contact specification)")
+      end
+    end
+
+    # Abstract
+    # Send the message to the external source
+    #   +message+ is the message body returned from the condition
+    #   +time+ is the Time at which the notification was made
+    #   +priority+ is the arbitrary priority String
+    #   +category+ is the arbitrary category String
+    #   +host+ is the hostname of the server
+    def notify(message, time, priority, category, host)
+      raise AbstractMethodNotOverriddenError.new("Contact#notify must be overridden in subclasses")
+    end
+
+    # Construct the friendly name of this Contact, looks like:
+    #
+    # Contact FooBar
+    def friendly_name
+      super + " Contact '#{self.name}'"
+    end
+  end
+
+end