mcproc 2016.2.20

data/lib/god/driver.rb

@@ -0,0 +1,238 @@
+require 'monitor'
+
+# Ruby 1.9.1 specific fixes.
+if RUBY_VERSION.between?('1.9', '1.9.1')
+  require 'god/compat19'
+end
+
+module God
+  # The TimedEvent class represents an event in the future. This class is used
+  # by the drivers to schedule upcoming conditional tests and other scheduled
+  # events.
+  class TimedEvent
+    include Comparable
+
+    # The Time at which this event is due.
+    attr_accessor :at
+
+    # Instantiate a new TimedEvent that will be triggered after the specified
+    # delay.
+    #
+    # delay - The optional Numeric number of seconds from now at which to
+    #         trigger (default: 0).
+    def initialize(delay = 0)
+      self.at = Time.now + delay
+    end
+
+    # Is the current event due (current time >= event time)?
+    #
+    # Returns true if the event is due, false if not.
+    def due?
+      Time.now >= self.at
+    end
+
+    # Compare this event to another.
+    #
+    # other - The other TimedEvent.
+    #
+    # Returns -1 if this event is before the other, 0 if the two events are
+    #   due at the same time, 1 if the other event is later.
+    def <=>(other)
+      self.at <=> other.at
+    end
+  end
+
+  # A DriverEvent is a TimedEvent with an associated Task and Condition. This
+  # is the primary mechanism for poll conditions to be scheduled.
+  class DriverEvent < TimedEvent
+    # Initialize a new DriverEvent.
+    #
+    # delay     - The Numeric delay for this event.
+    # task      - The Task associated with this event.
+    # condition - The Condition associated with this event.
+    def initialize(delay, task, condition)
+      super(delay)
+      @task = task
+      @condition = condition
+    end
+
+    # Handle this event by invoking the underlying condition on the associated
+    # task.
+    #
+    # Returns nothing.
+    def handle_event
+      @task.handle_poll(@condition)
+    end
+  end
+
+  # A DriverOperation is a TimedEvent that is due as soon as possible. It is
+  # used to execute an arbitrary method on the associated Task.
+  class DriverOperation < TimedEvent
+    # Initialize a new DriverOperation.
+    #
+    # task - The Task upon which to operate.
+    # name - The Symbol name of the method to call.
+    # args - The Array of arguments to send to the method.
+    def initialize(task, name, args)
+      super(0)
+      @task = task
+      @name = name
+      @args = args
+    end
+
+    # Handle the operation that was issued asynchronously.
+    #
+    # Returns nothing.
+    def handle_event
+      @task.send(@name, *@args)
+    end
+  end
+
+  # The DriverEventQueue is a simple queue that holds TimedEvent instances in
+  # order to maintain the schedule of upcoming events.
+  class DriverEventQueue
+    # Initialize a DriverEventQueue.
+    def initialize
+      @shutdown = false
+      @events = []
+      @monitor = Monitor.new
+      @resource = @monitor.new_cond
+    end
+
+    # Wake any sleeping threads after setting the sentinel.
+    #
+    # Returns nothing.
+    def shutdown
+      @shutdown = true
+      @monitor.synchronize do
+        @resource.broadcast
+      end
+    end
+
+    # Wait until the queue has something due, pop it off the queue, and return
+    # it.
+    #
+    # Returns the popped event.
+    def pop
+      @monitor.synchronize do
+        if @events.empty?
+          raise ThreadError, "queue empty" if @shutdown
+          @resource.wait
+        else
+          delay = @events.first.at - Time.now
+          @resource.wait(delay) if delay > 0
+        end
+
+        @events.shift
+      end
+    end
+
+    # Add an event to the queue, wake any waiters if what we added needs to
+    # happen sooner than the next pending event.
+    #
+    # Returns nothing.
+    def push(event)
+      @monitor.synchronize do
+        @events << event
+        @events.sort!
+
+        # If we've sorted the events and found the one we're adding is at
+        # the front, it will likely need to run before the next due date.
+        @resource.signal if @events.first == event
+      end
+    end
+
+    # Returns true if the queue is empty, false if not.
+    def empty?
+      @events.empty?
+    end
+
+    # Clear the queue.
+    #
+    # Returns nothing.
+    def clear
+      @events.clear
+    end
+
+    # Returns the Integer length of the queue.
+    def length
+      @events.length
+    end
+
+    alias size length
+  end
+
+  # The Driver class is responsible for scheduling all of the events for a
+  # given Task.
+  class Driver
+    # The Thread running the driver loop.
+    attr_reader :thread
+
+    # Instantiate a new Driver and start the scheduler loop to handle events.
+    #
+    # task - The Task this Driver belongs to.
+    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
+
+    # Check if we're in the driver context.
+    #
+    # Returns true if in driver thread, false if not.
+    def in_driver_context?
+      Thread.current == @thread
+    end
+
+    # Clear all events for this Driver.
+    #
+    # Returns nothing.
+    def clear_events
+      @events.clear
+    end
+
+    # Shutdown the DriverEventQueue threads.
+    #
+    # Returns nothing.
+    def shutdown
+      @events.shutdown
+    end
+
+    # Queue an asynchronous message.
+    #
+    # name - The Symbol name of the operation.
+    # args - 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 - The Condition.
+    # delay     - The Numeric 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
+end

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,112 @@
+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)
+      if watching_pid? pid
+        running = ::Process.kill(0, pid.to_i) rescue false
+        @@actions[pid].delete(event)
+        @@handler.register_process(pid, @@actions[pid].keys) if running
+        @@actions.delete(pid) if @@actions[pid].empty?
+      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 = 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.stop
+      @@thread.kill if @@thread
+    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)
+          ::Process.waitpid(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(pid, events)
+      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,109 @@
+module God
+
+  class Logger < SimpleLogger
+
+    attr_accessor :logs
+
+    class << self
+      attr_accessor :syslog
+    end
+
+    self.syslog = defined?(Syslog)
+
+    # Instantiate a new Logger object
+    def initialize(io = $stdout)
+      super(io)
+      self.logs = {}
+      @mutex = Mutex.new
+      @capture = nil
+      @spool = Time.now - 10
+      @templogio = StringIO.new
+      @templog = SimpleLogger.new(@templogio)
+      @templog.level = Logger::INFO
+    end
+
+
+    def level=(lev)
+      SysLogger.level = SimpleLogger::CONSTANT_TO_SYMBOL[lev] if Logger.syslog
+      super(lev)
+    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
+      if @capture || (watch && (Time.now - @spool < 2))
+        @mutex.synchronize do
+          @templogio.truncate(0)
+          @templogio.rewind
+          @templog.send(level, text)
+
+          message = @templogio.string.dup
+
+          if @capture
+            @capture.puts(message)
+          else
+            self.logs[watch.name] << [Time.now, message]
+          end
+        end
+      end
+
+      # send to regular logger
+      self.send(level, text)
+
+      # send to syslog
+      SysLogger.log(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
+        @spool = Time.now
+        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 if @capture
+        @capture = nil
+        cap
+      end
+    end
+  end
+
+end