samhendley-god 0.7.13

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,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

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