strobemonkey-god 0.7.13

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

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

data/lib/god/logger.rb

@@ -0,0 +1,120 @@
+module God
+  
+  class Logger < SimpleLogger
+    SYSLOG_EQUIVALENTS = {:fatal => :crit,
+                          :error => :err,
+                          :warn => :debug,
+                          :info => :debug,
+                          :debug => :debug}
+    
+    attr_accessor :logs
+    
+    class << self
+      attr_accessor :syslog
+    end
+    
+    self.syslog ||= true
+    
+    # Instantiate a new Logger object
+    def initialize
+      super($stdout)
+      self.logs = {}
+      @mutex = Mutex.new
+      @capture = nil
+      @templogio = StringIO.new
+      @templog = SimpleLogger.new(@templogio)
+      @templog.level = Logger::INFO
+      load_syslog
+    end
+    
+    # If Logger.syslog is true then attempt to load the syslog bindings. If syslog
+    # cannot be loaded, then set Logger.syslog to false and continue.
+    #
+    # Returns nothing
+    def load_syslog
+      return unless Logger.syslog
+      
+      begin
+        require 'syslog'
+        
+        # Ensure that Syslog is open
+        begin
+          Syslog.open('god')
+        rescue RuntimeError
+          Syslog.reopen('god')
+        end
+      rescue Exception
+        Logger.syslog = false
+      end
+    end
+    
+    # Log a message
+    #   +watch+ is the String name of the Watch (may be nil if not Watch is applicable)
+    #   +level+ is the log level [:debug|:info|:warn|:error|:fatal]
+    #   +text+ is the String message
+    #
+    # Returns nothing
+    def log(watch, level, text)
+      # initialize watch log if necessary
+      self.logs[watch.name] ||= Timeline.new(God::LOG_BUFFER_SIZE_DEFAULT) if watch
+      
+      # push onto capture and timeline for the given watch
+      @templogio.truncate(0)
+      @templogio.rewind
+      @templog.send(level, text % [])
+      @mutex.synchronize do
+        @capture.puts(@templogio.string.dup) if @capture
+        self.logs[watch.name] << [Time.now, @templogio.string.dup] if watch
+      end
+      
+      # send to regular logger
+      self.send(level, text % [])
+      
+      # send to syslog
+      Syslog.send(SYSLOG_EQUIVALENTS[level], text) if Logger.syslog
+    end
+    
+    # Get all log output for a given Watch since a certain Time.
+    #   +watch_name+ is the String name of the Watch
+    #   +since+ is the Time since which to fetch log lines
+    #
+    # Returns String
+    def watch_log_since(watch_name, since)
+      # initialize watch log if necessary
+      self.logs[watch_name] ||= Timeline.new(God::LOG_BUFFER_SIZE_DEFAULT)
+      
+      # get and join lines since given time
+      @mutex.synchronize do
+        self.logs[watch_name].select do |x|
+          x.first > since
+        end.map do |x|
+          x[1]
+        end.join
+      end
+    end
+    
+    # private
+    
+    # Enable capturing of log
+    #
+    # Returns nothing
+    def start_capture
+      @mutex.synchronize do
+        @capture = StringIO.new
+      end
+    end
+    
+    # Disable capturing of log and return what was captured since
+    # capturing was enabled with Logger#start_capture
+    #
+    # Returns String
+    def finish_capture
+      @mutex.synchronize do
+        cap = @capture.string
+        @capture = nil
+        cap
+      end
+    end
+  end
+  
+end

data/lib/god/metric.rb

@@ -0,0 +1,59 @@
+module God
+  
+  class Metric
+    attr_accessor :watch, :destination, :conditions
+    
+    def initialize(watch, destination = nil)
+      self.watch = watch
+      self.destination = destination
+      self.conditions = []
+    end
+    
+    # Instantiate a Condition of type +kind+ and pass it into the optional
+    # block. Attributes of the condition must be set in the config file
+    def condition(kind)
+      # create the condition
+      begin
+        c = Condition.generate(kind, self.watch)
+      rescue NoSuchConditionError => e
+        abort e.message
+      end
+      
+      # send to block so config can set attributes
+      yield(c) if block_given?
+      
+      # call prepare on the condition
+      c.prepare
+      
+      # test generic and specific validity
+      unless Condition.valid?(c) && c.valid?
+        abort "Exiting on invalid condition"
+      end
+      
+      # inherit interval from watch if no poll condition specific interval was set
+      if c.kind_of?(PollCondition) && !c.interval
+        if self.watch.interval
+          c.interval = self.watch.interval
+        else
+          abort "No interval set for Condition '#{c.class.name}' in Watch '#{self.watch.name}', and no default Watch interval from which to inherit"
+        end
+      end
+      
+      # remember
+      self.conditions << c
+    end
+    
+    def enable
+      self.conditions.each do |c|
+        self.watch.attach(c)
+      end
+    end
+    
+    def disable
+      self.conditions.each do |c|
+        self.watch.detach(c)
+      end
+    end
+  end
+  
+end