firenxis-god 0.11.0

data/lib/god/contacts/jabber.rb

@@ -0,0 +1,75 @@
+# Send a notice to a Jabber address.
+#
+# host     - The String hostname of the Jabber server.
+# port     - The Integer port of the Jabber server (default: 5222).
+# from_jid - The String Jabber ID of the sender.
+# password - The String password of the sender.
+# to_jid   - The String Jabber ID of the recipient.
+# subject  - The String subject of the message (default: "God Notification").
+
+CONTACT_DEPS[:jabber] = ['xmpp4r']
+CONTACT_DEPS[:jabber].each do |d|
+  require d
+end
+
+module God
+  module Contacts
+
+    class Jabber < Contact
+      class << self
+        attr_accessor :host, :port, :from_jid, :password, :to_jid, :subject
+        attr_accessor :format
+      end
+
+      self.port = 5222
+      self.subject = 'God Notification'
+
+      self.format = lambda do |message, time, priority, category, host|
+        text  = "Message: #{message}\n"
+        text += "Host: #{host}\n"         if host
+        text += "Priority: #{priority}\n" if priority
+        text += "Category: #{category}\n" if category
+        text
+      end
+
+      attr_accessor :host, :port, :from_jid, :password, :to_jid, :subject
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'host' must be specified", self) unless arg(:host)
+        valid &= complain("Attribute 'port' must be specified", self) unless arg(:port)
+        valid &= complain("Attribute 'from_jid' must be specified", self) unless arg(:from_jid)
+        valid &= complain("Attribute 'to_jid' must be specified", self) unless arg(:to_jid)
+        valid &= complain("Attribute 'password' must be specified", self) unless arg(:password)
+        valid
+      end
+
+      def notify(message, time, priority, category, host)
+        body = Jabber.format.call(message, time, priority, category, host)
+
+        message = ::Jabber::Message.new(arg(:to_jid), body)
+        message.set_type(:normal)
+        message.set_id('1')
+        message.set_subject(arg(:subject))
+
+        jabber_id = ::Jabber::JID.new("#{arg(:from_jid)}/God")
+
+        client = ::Jabber::Client.new(jabber_id)
+        client.connect(arg(:host), arg(:port))
+        client.auth(arg(:password))
+        client.send(message)
+        client.close
+
+        self.info = "sent jabber message to #{self.to_jid}"
+      rescue Object => e
+        if e.respond_to?(:message)
+          applog(nil, :info, "failed to send jabber message to #{arg(:to_jid)}: #{e.message}")
+        else
+          applog(nil, :info, "failed to send jabber message to #{arg(:to_jid)}: #{e.class}")
+        end
+        applog(nil, :debug, e.backtrace.join("\n"))
+      end
+
+    end
+  end
+end

data/lib/god/contacts/prowl.rb

@@ -0,0 +1,57 @@
+# Send a notice to Prowl (http://prowl.weks.net/).
+#
+# apikey - The String API key.
+
+CONTACT_DEPS[:prowl] = ['prowly']
+CONTACT_DEPS[:prowl].each do |d|
+  require d
+end
+
+module God
+  module Contacts
+    class Prowl < Contact
+
+      class << self
+        attr_accessor :apikey
+      end
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'apikey' must be specified", self) if self.apikey.nil?
+        valid
+      end
+
+      attr_accessor :apikey
+
+      def notify(message, time, priority, category, host)
+        result = Prowly.notify do |n|
+          n.apikey      = arg(:apikey)
+          n.priority    = map_priority(priority.to_i)
+          n.application = category || "God"
+          n.event       = "on " + host.to_s
+          n.description = message.to_s + " at " + time.to_s
+        end
+
+        if result.succeeded?
+          self.info = "sent prowl notification to #{self.name}"
+        else
+          self.info = "failed to send prowl notification to #{self.name}: #{result.message}"
+        end
+      rescue Object => e
+        applog(nil, :info, "failed to send prowl notification to #{self.name}: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
+      end
+
+      def map_priority(priority)
+        case priority
+           when 1 then Prowly::Notification::Priority::EMERGENCY
+           when 2 then Prowly::Notification::Priority::HIGH
+           when 3 then Prowly::Notification::Priority::NORMAL
+           when 4 then Prowly::Notification::Priority::MODERATE
+           when 5 then Prowly::Notification::Priority::VERY_LOW
+           else Prowly::Notification::Priority::NORMAL
+        end
+      end
+    end
+  end
+end

data/lib/god/contacts/scout.rb

@@ -0,0 +1,55 @@
+# Send a notice to Scout (http://scoutapp.com/).
+#
+# client_key - The String client key.
+# plugin_id  - The String plugin id.
+
+require 'net/http'
+require 'uri'
+
+module God
+  module Contacts
+
+    class Scout < Contact
+      class << self
+        attr_accessor :client_key, :plugin_id
+        attr_accessor :format
+      end
+
+      self.format = lambda do |message, priority, category, host|
+        text  = "Message: #{message}\n"
+        text += "Host: #{host}\n"         if host
+        text += "Priority: #{priority}\n" if priority
+        text += "Category: #{category}\n" if category
+        return text
+      end
+
+      attr_accessor :client_key, :plugin_id
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'client_key' must be specified", self) unless arg(:client_key)
+        valid &= complain("Attribute 'plugin_id' must be specified", self) unless arg(:plugin_id)
+        valid
+      end
+
+      def notify(message, time, priority, category, host)
+        data = {
+          :client_key => arg(:client_key),
+          :plugin_id => arg(:plugin_id),
+          :format => 'xml',
+          'alert[subject]' => message,
+          'alert[body]' => Scout.format.call(message, priority, category, host)
+        }
+
+        uri = URI.parse('http://scoutapp.com/alerts/create')
+        Net::HTTP.post_form(uri, data)
+
+        self.info = "sent scout alert to plugin ##{plugin_id}"
+      rescue => e
+        applog(nil, :info, "failed to send scout alert to plugin ##{plugin_id}: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
+      end
+    end
+
+  end
+end

data/lib/god/contacts/twitter.rb

@@ -0,0 +1,51 @@
+# Send a notice to a Twitter account (http://twitter.com/).
+#
+# consumer_token  - The String OAuth consumer token (defaults to God's
+#                   existing consumer token).
+# consumer_secret - The String OAuth consumer secret (defaults to God's
+#                   existing consumer secret).
+# access_token    - The String OAuth access token.
+# access_secret   - The String OAuth access secret.
+
+CONTACT_DEPS[:twitter] = ['twitter']
+CONTACT_DEPS[:twitter].each do |d|
+  require d
+end
+
+module God
+  module Contacts
+    class Twitter < Contact
+      class << self
+        attr_accessor :consumer_token, :consumer_secret,
+                      :access_token, :access_secret
+      end
+
+      self.consumer_token = 'gOhjax6s0L3mLeaTtBWPw'
+      self.consumer_secret = 'yz4gpAVXJHKxvsGK85tEyzQJ7o2FEy27H1KEWL75jfA'
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'consumer_token' must be specified", self) unless arg(:consumer_token)
+        valid &= complain("Attribute 'consumer_secret' must be specified", self) unless arg(:consumer_secret)
+        valid &= complain("Attribute 'access_token' must be specified", self) unless arg(:access_token)
+        valid &= complain("Attribute 'access_secret' must be specified", self) unless arg(:access_secret)
+        valid
+      end
+
+      attr_accessor :consumer_token, :consumer_secret,
+                    :access_token, :access_secret
+
+      def notify(message, time, priority, category, host)
+        oauth = ::Twitter::OAuth.new(arg(:consumer_token), arg(:consumer_secret))
+        oauth.authorize_from_access(arg(:access_token), arg(:access_secret))
+
+        ::Twitter::Base.new(oauth).update(message)
+
+        self.info = "sent twitter update"
+      rescue => e
+        applog(nil, :info, "failed to send twitter update: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
+      end
+    end
+  end
+end

data/lib/god/contacts/webhook.rb

@@ -0,0 +1,73 @@
+# 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)
+
+        req = nil
+        res = nil
+
+        case arg(:format)
+          when :form
+            req = Net::HTTP::Post.new(uri.path)
+            req.set_form_data(data)
+          when :json
+            req = Net::HTTP::Post.new(uri.path)
+            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 email to #{arg(:url)}: #{e.message}")
+        applog(nil, :debug, e.backtrace.join("\n"))
+      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])
+  
+  def self.install
+    require 'snapshot'
+    self.spin
+  end
+  
+  def self.snapshot
+    @count ||= 0
+    filename = "/tmp/god-bleak-%s-%03i.dump" % [Process.pid,@count]
+    STDERR.puts "** BleakHouse: working..."
+    BleakHouse.ext_snapshot(filename, 3)
+    STDERR.puts "** BleakHouse: complete\n** Bleakhouse: Run 'bleak #{filename}' to analyze."
+    @count += 1
+  end
+  
+  def self.spin(delay = 60)
+    Thread.new do
+      loop do
+        sleep(delay)
+        self.snapshot
+      end
+    end
+  end
+end

data/lib/god/driver.rb

@@ -0,0 +1,206 @@
+require 'monitor'
+
+# ruby 1.9 specific fixes
+unless RUBY_VERSION < '1.9'
+  require 'god/compat19'
+end
+
+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
+      @events = []
+      @monitor = Monitor.new
+      @resource = @monitor.new_cond
+      @events.taint
+      self.taint
+    end
+
+    #
+    # Wake any sleeping threads after setting the sentinel
+    #
+    def shutdown
+      @shutdown = true
+      @monitor.synchronize do
+        @resource.broadcast
+      end
+    end
+
+    #
+    # Sleep until the queue has something due
+    #
+    def pop
+      @monitor.synchronize do
+        if @events.empty?
+          raise ThreadError, "queue empty" if @shutdown
+          @resource.wait
+        else !@events.first.due?
+          delay = @events.first.at - Time.now
+          @resource.wait(delay) if delay > 0
+        end
+
+        @events.shift
+      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)
+      @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
+
+    alias << push
+    alias enq push
+
+    def empty?
+      @events.empty?
+    end
+
+    def clear
+      @events.clear
+    end
+
+    def length
+      @events.length
+    end
+
+    alias size length
+  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
+    
+    # Check if we're in the driver context
+    #
+    # Returns true if in driver thread
+    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+ 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