olgen-god 0.8.0

data/lib/god/contacts/sms.rb

@@ -0,0 +1,96 @@
+require 'time'
+require 'net/smtp'
+require 'god/smtp_tls' #need this hack for tls in smtp
+
+module God
+  module Contacts
+    
+    class Sms < Contact
+      class << self
+        attr_accessor :message_settings, :delivery_method, :server_settings, :sendmail_settings, :format
+      end
+      
+      self.message_settings = {
+                                :from => 'god@example.com',
+                                :gateway_key=>'1234',
+                                :gateway_email=>'email2sms@sms77.de'}
+      
+      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 |phone, message, time, priority, category, host|
+<<-EOF
+From: god <#{self.message_settings[:from]}>
+To: sms-gateway #{self.message_settings[:gateway_email]}>
+Subject: [message from god] #{message}; Host: #{host}; Priority: #{priority}; Category: #{category}
+Date: #{Time.now.httpdate}
+Message-Id: <#{rand(1000000000).to_s(36)}.#{$$}.#{self.message_settings[:from]}>
+
+#{self.message_settings[:gateway_key]}##{phone}
+EOF
+      end
+      
+      attr_accessor :phone
+      
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'phone' must be specified", self) if self.phone.nil?
+        valid
+      end
+      
+      def notify(message, time, priority, category, host)
+        begin
+          body = Sms.format.call(self.phone, message, time, priority, category, host)
+
+          case Sms.delivery_method
+          when :smtp
+            notify_smtp(body)
+          when :sendmail
+            notify_sendmail(body)
+          else
+            raise "unknown delivery method: #{Sms.delivery_method}"
+          end
+          
+          self.info = "sent sms to #{self.name}:#{self.phone}"
+        rescue => e
+          applog(nil, :info, "failed to send sms to #{self.name}:#{self.phone}: #{e.message}")
+          applog(nil, :debug, e.backtrace.join("\n"))
+        end
+      end
+
+      # private
+
+      def notify_smtp(mail)
+        args = [Sms.server_settings[:address], Sms.server_settings[:port]]
+        if Sms.server_settings[:authentication]
+          args << Sms.server_settings[:domain]
+          args << Sms.server_settings[:user_name]
+          args << Sms.server_settings[:password]
+          args << Sms.server_settings[:authentication] 
+        end
+
+        Net::SMTP.start(*args) do |smtp|
+          smtp.send_message mail, Sms.message_settings[:from], Sms.message_settings[:gateway_email]
+        end
+      end
+
+      def notify_sendmail(mail)
+        IO.popen("#{Sms.sendmail_settings[:location]} #{Sms.sendmail_settings[:arguments]}","w+") do |sm|
+          sm.print(mail.gsub(/\r/, ''))
+          sm.flush
+        end
+      end
+    end
+
+  end
+end

data/lib/god/contacts/twitter.rb

@@ -0,0 +1,39 @@
+# For Twitter updates you need the 'twitter' gem
+#   (gem install twitter)
+#
+# Configure your watches like this:
+#
+#   God::Contacts::Twitter.settings = { :username => 'sender@example.com',
+#                                       :password  => 'secret' }
+#   God.contact(:twitter) do |c|
+#     c.name      = 'Tester'
+#     c.group     = 'developers'
+#   end
+
+require 'rubygems'
+require 'twitter'
+
+module God
+  module Contacts
+    class Twitter < Contact
+      class << self
+        attr_accessor :settings
+      end
+
+      def valid?
+        valid = true
+      end
+
+      def notify(message, time, priority, category, host)
+        begin
+          ::Twitter::Base.new(Twitter.settings[:username], 
+                              Twitter.settings[:password]).update(message)
+
+          self.info = "sent twitter update as #{Twitter.settings[:username]}"
+        rescue => e
+          self.info = "failed to send twitter update from #{self.twitter_id}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/god/contacts/webhook.rb

@@ -0,0 +1,47 @@
+# Configure your watches like this:
+#
+#   God.contact(:webhook) do |c|
+#     c.name      = 'Tester'
+#     c.hook_url  = 'http://hook/url'
+#   end
+
+require 'net/http'
+require 'uri'
+
+module God
+  module Contacts
+
+    class Webhook < Contact
+
+      attr_accessor :hook_url
+
+      def valid?
+        valid = true
+      end
+
+      def notify(message, time, priority, category, host)
+        begin
+          data = {
+            :message => message,
+            :time => time,
+            :priority => priority,
+            :category => category,
+            :host => host
+          }
+
+          uri = URI.parse(self.hook_url)
+          Net::HTTP.post_form(uri, data)
+
+          self.info = "sent webhook to #{self.hook_url}"
+        rescue => e
+          puts e.message
+          puts e.backtrace.join("\n")
+
+          self.info = "failed to send webhook to #{self.hook_url}: #{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,207 @@
+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
+            delay = @events.first.at - Time.now
+            sleep delay if delay > 0
+            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 Object => 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

data/lib/god/errors.rb

@@ -0,0 +1,24 @@
+module God
+  
+  class AbstractMethodNotOverriddenError < StandardError
+  end
+  
+  class NoSuchWatchError < StandardError
+  end
+  
+  class NoSuchConditionError < StandardError
+  end
+  
+  class NoSuchBehaviorError < StandardError
+  end
+  
+  class NoSuchContactError < StandardError
+  end
+  
+  class InvalidCommandError < StandardError
+  end
+  
+  class EventRegistrationFailedError < StandardError
+  end
+  
+end

data/lib/god/event_handler.rb

@@ -0,0 +1,111 @@
+module God
+  class EventHandler
+    @@actions = {}
+    @@handler = nil
+    @@loaded = false
+    
+    def self.loaded?
+      @@loaded
+    end
+    
+    def self.event_system
+      @@handler::EVENT_SYSTEM
+    end
+    
+    def self.load
+      begin
+        case RUBY_PLATFORM
+        when /darwin/i, /bsd/i
+          require 'god/event_handlers/kqueue_handler'
+          @@handler = KQueueHandler
+        when /linux/i
+          require 'god/event_handlers/netlink_handler'
+          @@handler = NetlinkHandler
+        else
+          raise NotImplementedError, "Platform not supported for EventHandler"
+        end
+        @@loaded = true
+      rescue Exception
+        require 'god/event_handlers/dummy_handler'
+        @@handler = DummyHandler
+        @@loaded = false
+      end
+    end
+    
+    def self.register(pid, event, &block)
+      @@actions[pid] ||= {}
+      @@actions[pid][event] = block
+      @@handler.register_process(pid, @@actions[pid].keys)
+    end
+    
+    def self.deregister(pid, event=nil)
+      if watching_pid? pid
+        running = ::Process.kill(0, pid.to_i) rescue false
+        if event.nil?
+          @@actions.delete(pid)
+          @@handler.register_process(pid, []) if running
+        else
+          @@actions[pid].delete(event)
+          @@handler.register_process(pid, @@actions[pid].keys) if running
+        end
+      end
+    end
+    
+    def self.call(pid, event, extra_data = {})
+      @@actions[pid][event].call(extra_data) if watching_pid?(pid) && @@actions[pid][event]
+    end
+    
+    def self.watching_pid?(pid)
+      @@actions[pid]
+    end
+    
+    def self.start
+      Thread.new do
+        loop do
+          begin
+            @@handler.handle_events
+          rescue Exception => e
+            message = format("Unhandled exception (%s): %s\n%s",
+                             e.class, e.message, e.backtrace.join("\n"))
+            applog(nil, :fatal, message)
+          end
+        end
+      end
+      
+      # do a real test to make sure events are working properly
+      @@loaded = self.operational?
+    end
+    
+    def self.operational?
+      com = [false]
+      
+      Thread.new do
+        begin
+          event_system = God::EventHandler.event_system
+          
+          pid = fork do
+            loop { sleep(1) }
+          end
+          
+          self.register(pid, :proc_exit) do
+            com[0] = true
+          end
+          
+          ::Process.kill('KILL', pid)
+          
+          sleep(0.1)
+          
+          self.deregister(pid, :proc_exit) rescue nil
+        rescue => e
+          puts e.message
+          puts e.backtrace.join("\n")
+        end
+      end.join
+      
+      sleep(0.1)
+      
+      com.first
+    end
+    
+  end
+end

data/lib/god/event_handlers/dummy_handler.rb

@@ -0,0 +1,13 @@
+module God
+  class DummyHandler
+    EVENT_SYSTEM = "none"
+    
+    def self.register_process
+      raise NotImplementedError
+    end
+    
+    def self.handle_events
+      raise NotImplementedError
+    end
+  end
+end

data/lib/god/event_handlers/kqueue_handler.rb

@@ -0,0 +1,17 @@
+require 'kqueue_handler_ext'
+
+module God
+  class KQueueHandler
+    EVENT_SYSTEM = "kqueue"
+    
+    def self.register_process(pid, events)
+      monitor_process(pid, events_mask(events))
+    end
+  
+    def self.events_mask(events)
+      events.inject(0) do |mask, event|
+        mask |= event_mask(event)
+      end
+    end
+  end
+end

data/lib/god/event_handlers/netlink_handler.rb

@@ -0,0 +1,13 @@
+require 'netlink_handler_ext'
+
+module God
+  class NetlinkHandler
+    EVENT_SYSTEM = "netlink"
+    
+    def self.register_process(pid, events)
+      # netlink doesn't need to do this
+      # it just reads from the eventhandler actions to see if the pid
+      # matches the list we're looking for -- Kev
+    end
+  end
+end