resurrected_god 0.14.0

data/lib/god/contacts/webhook.rb

@@ -0,0 +1,74 @@
+# Send a notice to a webhook.
+#
+# url    - The String webhook URL.
+# format - The Symbol format [ :form | :json ] (default: :form).
+
+require 'net/http'
+require 'uri'
+
+CONTACT_DEPS[:webhook] = ['json']
+CONTACT_DEPS[:webhook].each do |d|
+  require d
+end
+
+module God
+  module Contacts
+
+    class Webhook < Contact
+      class << self
+        attr_accessor :url, :format
+      end
+
+      self.format = :form
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'url' must be specified", self) unless arg(:url)
+        valid &= complain("Attribute 'format' must be one of [ :form | :json ]", self) unless [:form, :json].include?(arg(:format))
+        valid
+      end
+
+      attr_accessor :url, :format
+
+      def notify(message, time, priority, category, host)
+        data = {
+          :message => message,
+          :time => time,
+          :priority => priority,
+          :category => category,
+          :host => host
+        }
+
+        uri = URI.parse(arg(:url))
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == "https"
+
+        req = nil
+        res = nil
+
+        case arg(:format)
+          when :form
+            req = Net::HTTP::Post.new(uri.request_uri)
+            req.set_form_data(data)
+          when :json
+            req = Net::HTTP::Post.new(uri.request_uri)
+            req.body = data.to_json
+        end
+
+        res = http.request(req)
+
+        case res
+          when Net::HTTPSuccess
+            self.info = "sent webhook to #{arg(:url)}"
+          else
+            self.info = "failed to send webhook to #{arg(:url)}: #{res.error!}"
+        end
+      rescue Object => e
+        applog(nil, :info, "failed to send webhook to #{arg(:url)}: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
+      end
+
+    end
+
+  end
+end

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

data/lib/god/metric.rb

@@ -0,0 +1,87 @@
+module God
+  # Metrics are responsible for holding watch conditions. An instance of
+  # Metric is yielded to blocks in the start_if, restart_if, stop_if, and
+  # transition methods.
+  class Metric
+    # The Watch.
+    attr_accessor :watch
+
+    # The destination Hash in canonical hash form. Example:
+    # { true => :up, false => :restart}
+    attr_accessor :destination
+
+    # The Array of Condition instances.
+    attr_accessor :conditions
+
+    # Initialize a new Metric.
+    #
+    # watch       - The Watch.
+    # destination - The optional destination Hash in canonical hash form.
+    def initialize(watch, destination = nil)
+      self.watch = watch
+      self.destination = destination
+      self.conditions = []
+    end
+
+    # Public: Instantiate the given Condition and pass it into the optional
+    # block. Attributes of the condition must be set in the config file.
+    #
+    # kind - The Symbol name of the condition.
+    #
+    # Returns nothing.
+    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?
+
+      # Prepare 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
+
+      # Add the condition to the list.
+      self.conditions << c
+    end
+
+    # Enable all of this Metric's conditions. Poll conditions will be
+    # scheduled and event/trigger conditions will be registered.
+    #
+    # Returns nothing.
+    def enable
+      self.conditions.each do |c|
+        self.watch.attach(c)
+      end
+    end
+
+    # Disable all of this Metric's conditions. Poll conditions will be
+    # halted and event/trigger conditions will be deregistered.
+    #
+    # Returns nothing.
+    def disable
+      self.conditions.each do |c|
+        self.watch.detach(c)
+      end
+    end
+  end
+end