mojombo-god 0.7.7

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!
+      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,106 @@
+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
+    
+    # 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

data/lib/god/contacts/email.rb

@@ -0,0 +1,95 @@
+require 'time'
+require 'net/smtp'
+
+module God
+  module Contacts
+    
+    class Email < Contact
+      class << self
+        attr_accessor :message_settings, :delivery_method, :server_settings, :sendmail_settings, :format
+      end
+      
+      self.message_settings = {:from => 'god@example.com'}
+      
+      self.delivery_method = :smtp # or :sendmail
+      
+      self.server_settings = {:address => 'localhost',
+                              :port => 25}
+                            # :domain
+                            # :user_name
+                            # :password
+                            # :authentication
+
+      self.sendmail_settings = {:location  => '/usr/sbin/sendmail',
+                                :arguments => '-i -t'
+      }
+      
+      self.format = lambda do |name, email, message, time, priority, category, host|
+        <<-EOF
+From: god <#{self.message_settings[:from]}>
+To: #{name} <#{email}>
+Subject: [god] #{message}
+Date: #{Time.now.httpdate}
+Message-Id: <unique.message.id.string@example.com>
+
+Message: #{message}
+Host: #{host}
+Priority: #{priority}
+Category: #{category}
+        EOF
+      end
+      
+      attr_accessor :email
+      
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'email' must be specified", self) if self.email.nil?
+        valid
+      end
+      
+      def notify(message, time, priority, category, host)
+        begin
+          body = Email.format.call(self.name, self.email, message, time, priority, category, host)
+
+          case Email.delivery_method
+          when :smtp
+            notify_smtp(body)
+          when :sendmail
+            notify_sendmail(body)
+          else
+            raise "unknown delivery method: #{Email.delivery_method}"
+          end
+          
+          self.info = "sent email to #{self.email}"
+        rescue => e
+          applog(nil, :info, "failed to send email to #{self.email}: #{e.message}")
+          applog(nil, :debug, e.backtrace.join("\n"))
+        end
+      end
+
+      # private
+
+      def notify_smtp(mail)
+        args = [Email.server_settings[:address], Email.server_settings[:port]]
+        if Email.server_settings[:authentication]
+          args << Email.server_settings[:domain]
+          args << Email.server_settings[:user_name]
+          args << Email.server_settings[:password]
+          args << Email.server_settings[:authentication] 
+        end
+
+        Net::SMTP.start(*args) do |smtp|
+          smtp.send_message mail, Email.message_settings[:from], self.email
+        end
+      end
+
+      def notify_sendmail(mail)
+        IO.popen("#{Email.sendmail_settings[:location]} #{Email.sendmail_settings[:arguments]}","w+") do |sm|
+          sm.print(mail.gsub(/\r/, ''))
+          sm.flush
+        end
+      end
+    end
+
+  end
+end

data/lib/god/dependency_graph.rb

@@ -0,0 +1,41 @@
+module God
+  class DependencyGraph
+    attr_accessor :nodes
+    
+    def initialize
+      self.nodes = {}
+    end
+    
+    def add(a, b)
+      node_a = self.nodes[a] || Node.new(a)
+      node_b = self.nodes[b] || Node.new(b)
+      
+      node_a.add(node_b)
+      
+      self.nodes[a] ||= node_a
+      self.nodes[b] ||= node_b
+    end
+  end
+end
+
+module God
+  class DependencyGraph
+    class Node
+      attr_accessor :name
+      attr_accessor :dependencies
+      
+      def initialize(name)
+        self.name = name
+        self.dependencies = []
+      end
+      
+      def add(node)
+        self.dependencies << node unless self.dependencies.include?(node)
+      end
+      
+      def has_node?(node)
+        (self == node) || self.dependencies.any { |x| x.has_node?(node) }
+      end
+    end
+  end
+end

data/lib/god/diagnostics.rb

@@ -0,0 +1,37 @@
+def start_dike
+  require 'dike'
+  Thread.new do
+    Dike.logfactory File.join(File.dirname(__FILE__), *%w[.. .. logs])
+    loop do
+      Dike.finger
+      sleep(1)
+    end
+  end
+end
+
+class BleakHouseDiagnostic
+  LOG_FILE = File.join(File.dirname(__FILE__), *%w[.. .. logs bleak.log])
+  
+  class << self
+    attr_accessor :logger
+  end
+  
+  def self.install
+    require 'bleak_house'
+    self.logger = BleakHouse::Logger.new
+    File.delete(LOG_FILE) rescue nil
+  end
+  
+  def self.snapshot(name)
+    self.logger.snapshot(LOG_FILE, name, false) if self.logger
+  end
+  
+  def self.spin(delay = 1)
+    Thread.new do
+      loop do
+        self.snapshot
+        sleep(delay)
+      end
+    end
+  end
+end

data/lib/god/driver.rb

@@ -0,0 +1,108 @@
+module God
+  
+  class DriverEvent
+    attr_accessor :condition, :at
+    
+    # Instantiate a new TimerEvent that will be triggered after the specified delay
+    #   +condition+ is the Condition
+    #   +delay+ is the number of seconds from now at which to trigger
+    #
+    # Returns TimerEvent
+    def initialize(condition, delay)
+      self.condition = condition
+      self.at = Time.now + delay
+    end
+    
+    def due?
+      Time.now >= self.at
+    end
+  end # DriverEvent
+  
+  class Driver
+    attr_reader :thread
+    
+    INTERVAL = 0.25
+    
+    # Instantiate a new Driver and start the scheduler loop to handle events
+    #   +task+ is the Task this Driver belongs to
+    #
+    # Returns Driver
+    def initialize(task)
+      @task = task
+      @events = []
+      @ops = Queue.new
+      
+      @thread = Thread.new do
+        loop do
+          begin
+            if !@ops.empty?
+              self.handle_op
+            elsif !@events.empty?
+              self.handle_event
+            else
+              sleep INTERVAL
+            end
+          rescue Exception => e
+            message = format("Unhandled exception in driver loop - (%s): %s\n%s",
+                             e.class, e.message, e.backtrace.join("\n"))
+            applog(nil, :fatal, message)
+          end
+        end
+      end
+    end
+    
+    # Handle the next queued operation that was issued asynchronously
+    #
+    # Returns nothing
+    def handle_op
+      command = @ops.pop
+      @task.send(command[0], *command[1])
+    end
+    
+    # Handle the next event (poll condition) that is due
+    #
+    # Returns nothing
+    def handle_event
+      if @events.first.due?
+        event = @events.shift
+        @task.handle_poll(event.condition)
+      end
+      
+      # don't sleep if there is a pending event and it is due
+      unless @events.first && @events.first.due?
+        sleep INTERVAL
+      end
+    end
+    
+    # Clear all events for this Driver
+    #
+    # Returns nothing
+    def clear_events
+      @events.clear
+    end
+    
+    # Queue an asynchronous message
+    #   +name+ is the Symbol name of the operation
+    #   +args+ is an optional Array of arguments
+    #
+    # Returns nothing
+    def message(name, args = [])
+      @ops.push([name, args])
+    end
+    
+    # Create and schedule a new DriverEvent
+    #   +condition+ is the Condition
+    #   +delay+ is the number of seconds to delay (default: interval defined in condition)
+    #
+    # Returns nothing
+    def schedule(condition, delay = condition.interval)
+      applog(nil, :debug, "driver schedule #{condition} in #{delay} seconds")
+      
+      @events.concat([DriverEvent.new(condition, delay)])
+      
+      # sort events
+      @events.sort! { |x, y| x.at <=> y.at }
+    end
+  end # Driver
+  
+end # God