saimonmoore-god 0.7.9

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/contacts/jabber.rb

@@ -0,0 +1,65 @@
+# To add Jabber notifications you must have xmpp4r gem installed.
+# Configure your watches like this:
+#
+#   God::Contacts::Jabber.settings = { :jabber_id => 'sender@example.com',
+#                                      :password  => 'secret' }
+#   God.contact(:jabber) do |c|
+#     c.name      = 'Tester'
+#     c.jabber_id = 'receiver@example.com'
+#     c.group     = 'developers'
+#   end
+
+module XMPP4R
+  require 'rubygems'
+  require 'xmpp4r'
+  include Jabber
+end
+
+module God
+  module Contacts
+    class Jabber < Contact      
+      class << self
+        attr_accessor :settings, :format
+      end
+      
+      self.format = lambda do |message, priority, category, host|
+        text  = "Message: #{message}\n"
+        text += "Host: #{host}\n"         if host
+        text += "Priority: #{priority}\n" if priority
+        text += "Category: #{category}\n" if category
+        return text
+      end
+      
+      attr_accessor :jabber_id
+      
+      def valid?
+        valid = true
+      end
+      
+      def notify(message, time, priority, category, host)
+        begin
+          jabber_id = XMPP4R::JID::new "#{Jabber.settings[:jabber_id]}/God"
+          jabber_client = XMPP4R::Client::new jabber_id
+          jabber_client.connect
+          jabber_client.auth Jabber.settings[:password]
+
+          body = Jabber.format.call message, priority, category, host
+          
+          message = XMPP4R::Message::new self.jabber_id, body
+          message.set_type :normal
+          message.set_id '1'
+          message.set_subject 'God'
+          jabber_client.send message
+
+          self.info = "sent jabber message to #{self.jabber_id}"
+        rescue => e
+          puts e.message
+          puts e.backtrace.join("\n")
+          
+          self.info = "failed to send jabber message to #{self.jabber_id}: #{e.message}"
+        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,206 @@
+module God
+  class TimedEvent
+    include Comparable
+
+    attr_accessor :at
+    
+    # Instantiate a new TimedEvent that will be triggered after the specified delay
+    #   +delay+ is the number of seconds from now at which to trigger
+    #
+    # Returns TimedEvent
+    def initialize(delay = 0)
+      self.at = Time.now + delay
+    end
+
+    def due?
+      Time.now >= self.at
+    end
+
+    def <=>(other)
+      self.at <=> other.at
+    end
+  end # DriverEvent
+
+  class DriverEvent < TimedEvent
+    attr_accessor :condition, :task
+    
+    def initialize(delay, task, condition)
+      super delay
+      self.task = task
+      self.condition = condition
+    end
+    
+    def handle_event
+      @task.handle_poll(@condition)
+    end
+  end # DriverEvent
+
+  class DriverOperation < TimedEvent
+    attr_accessor :task, :name, :args
+
+    def initialize(task, name, args)
+      super(0)
+      self.task = task
+      self.name = name
+      self.args = args
+    end
+    
+    # Handle the next queued operation that was issued asynchronously
+    #
+    # Returns nothing
+    def handle_event
+      @task.send(@name, *@args)
+    end
+  end
+  
+  class DriverEventQueue 
+    def initialize
+      @shutdown = false
+      @waiting = []
+      @events = []
+      @waiting.taint
+      @events.taint
+      self.taint
+    end
+
+    # 
+    # Wake any sleeping threads after setting the sentinel
+    # 
+    def shutdown
+      @shutdown = true
+      begin
+        Thread.critical = true
+        @waiting.each do |t|
+          t.run
+        end
+      ensure
+        Thread.critical = false
+      end
+    end
+
+    #
+    # Sleep until the queue has something due
+    #
+    def pop
+      begin
+        while (Thread.critical = true; @events.empty? or !@events.first.due?)
+          @waiting.push Thread.current
+          if @events.empty?
+            raise ThreadError, "queue empty" if @shutdown
+            Thread.stop
+          else
+            Thread.critical = false
+            sleep @events.first.at - Time.now
+            Thread.critical = true
+          end
+        end
+        @events.shift
+      ensure
+        Thread.critical = false
+      end
+    end
+
+    alias shift pop
+    alias deq pop
+
+    # 
+    # Add an event to the queue, wake any waiters if what we added needs to 
+    # happen sooner than the next pending event
+    #
+    def push(event)
+      Thread.critical = true
+      @events << event
+      @events.sort!
+      begin
+        t = @waiting.shift if @events.first == event
+        t.wakeup if t
+      rescue ThreadError
+        retry
+      ensure
+        Thread.critical = false
+      end
+      begin
+        t.run if t
+      rescue ThreadError
+      end
+    end
+
+    alias << push
+    alias enq push
+
+    def empty?
+      @que.empty?
+    end
+
+    def clear
+      @events.clear
+    end
+
+    def length
+      @events.length
+    end
+
+    alias size length
+
+    def num_waiting
+      @waiting.size
+    end
+  end
+
+
+  class Driver
+    attr_reader :thread
+    
+    # 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 = God::DriverEventQueue.new
+      
+      @thread = Thread.new do
+        loop do
+          begin
+            @events.pop.handle_event
+          rescue ThreadError => e
+            # queue is empty
+            break
+          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
+    
+    # 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 = [])
+      @events.push(DriverOperation.new(@task, 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.push(DriverEvent.new(delay, @task, condition))
+    end
+  end # Driver
+  
+end # God