rubix 0.0.1

data/lib/rubix/models/template.rb

@@ -0,0 +1,81 @@
+module Rubix
+  
+  class Template < Model
+
+    attr_accessor :name, :host_ids
+
+    def initialize properties={}
+      super(properties)
+      @name = properties[:name]
+    end
+
+    def log_name
+      "TEMPLATE #{name || id}"
+    end
+
+    def register
+      exists? ? update : create
+    end
+
+    def unregister
+      destroy if exists?
+    end
+    
+    def load
+      response = request('template.get', 'filter' => {'templateid' => id, 'name' => name}, 'select_hosts' => 'refer', 'output' => 'extend')
+      case
+      when response.has_data?
+        @id       = response.first['templateid'].to_i
+        @name     = response.first['name']
+        @host_ids = response.first['hosts'].map { |host_info| host_info['hostid'].to_i }
+        @loaded   = true
+        @exists   = true
+      when response.success?
+        @exists = false
+        @loaded = true
+      else
+        error("Could not load: #{response.error_messaage}")
+      end
+    end
+
+    def create
+      response = request('template.create', [{'name' => name}])
+      if response.has_data?
+        @id     = response['templateids'].first.to_i
+        @exists = true
+        info("Created")
+      else
+        error("Could not create: #{response.error_message}.")
+      end
+    end
+
+    def update
+      # noop
+      info("Updated")
+    end
+
+    def destroy
+      response = request('template.delete', [{'templateid' => id}])
+      case
+      when response.has_data? && response['templateids'].first.to_i == id
+        info("Deleted")
+      when response.zabbix_error? && response.error_message =~ /does not exist/i
+        # was never there...
+      else
+        error("Could not delete: #{response.error_message}")
+      end
+    end
+
+    def contains? host
+      return unless exists?
+      host_ids.include?(host.id)
+    end
+
+    def self.find_or_create_by_name name
+      new(:name => name).tap do |group|
+        group.create unless group.exists?
+      end
+    end
+    
+  end
+end

data/lib/rubix/monitor.rb

@@ -0,0 +1,167 @@
+require 'configliere'
+require 'json'
+
+module Rubix
+
+  # A generic monitor class for constructing Zabbix monitors.
+  #
+  # This class handles the low-level logic of sleeping, waking up, and
+  # sending data to Zabbix.
+  #
+  # It's up to a subclass to determine how to make a measurement.
+  #
+  # Here's an example of a script which measures the uptime of the
+  # current machine.
+  #
+  #   #!/usr/bin/env ruby
+  #   # in uptime_monitor
+  #   class UptimeMonitor < Rubix::Monitor
+  #
+  #     def measure
+  #       return unless `uptime`.chomp =~ /(\d+) days/
+  #       write do |data|
+  #         data << ([['uptime', $1.to_i]])
+  #       end
+  #     end
+  #   end
+  #
+  #   UptimeMonitor.run if $0 == __FILE__
+  #
+  # See what the script measures by running it directly.
+  #
+  #   $ ./uptime_monitor
+  #
+  # Or have it send its output to another file or FIFO
+  #
+  #   $ ./uptime_monitor /path/to/some/file
+  #
+  # Or have it loop every 30 seconds
+  #
+  #   $ ./uptime_monitor --loop=30 /path/to/some/file &
+  class Monitor
+
+    #
+    # Class-level settings and a function to run a monito
+    #
+
+    def self.default_settings
+      Configliere::Param.new.tap do |s|
+        s.use :commandline
+        
+        s.define :loop,            :description => "Run every this many seconds",          :required => false, :type => Integer
+      end
+    end
+
+    def self.run
+      settings = default_settings
+      begin
+        settings.resolve!
+      rescue => e
+        puts e.message
+        exit(1)
+      end
+      new(settings).run
+    end
+
+    #
+    # Instance-level settings that provide logic for running once or
+    # looping.
+    #
+
+    attr_reader :settings
+
+    def initialize settings
+      @settings = settings
+    end
+    
+    def loop?
+      loop_period > 0
+    end
+
+    def loop_period
+      settings[:loop].to_i
+    end
+
+    def run
+      begin
+        if loop?
+          while true
+            measure
+            output.flush if output
+            sleep loop_period
+          end
+        else
+          measure
+        end
+      ensure
+        close
+      end
+    end
+
+    def measure
+      raise NotImplementedError.new("Override the 'measure' method in a subclass to conduct a measurement.")
+    end
+
+    #
+    # Methods for writing data to Zabbix.
+    #
+    
+    def write options={}, &block
+      return unless output
+      data = []
+      block.call(data) if block_given?
+      text = {
+        :data => data.map do |measurement|
+          key, value = measurement
+          { :key => key, :value => value }
+        end
+      }.merge(options).to_json
+
+      begin
+        output.puts(text)
+      rescue Errno::ENXIO
+        # FIFO's reader isn't alive...
+      end
+    end
+
+    def output_path
+      settings.rest.first
+    end
+
+    def stdout?
+      output_path.nil?
+    end
+
+    def file?
+      !stdout? && (!File.exist?(output_path) || File.ftype(output_path) == 'file')
+    end
+
+    def fifo?
+      !stdout? && File.exist?(output_path) && File.ftype(output_path) == 'fifo'
+    end
+    
+    def output
+      return @output if @output
+      case
+      when stdout?
+        @output = $stdout
+      when fifo?
+        begin
+          @output = open(output_path, (File::WRONLY | File::NONBLOCK))
+        rescue Errno::ENXIO
+          # FIFO's reader isn't alive...
+        end
+      else
+        @output = File.open(output_path, 'a')
+      end
+    end
+
+    def close
+      return unless output
+      output.flush
+      return if stdout?
+      output.close
+    end
+
+  end
+end

data/lib/rubix/monitors/chef_monitor.rb

@@ -0,0 +1,82 @@
+module Rubix
+  # A generic monitor class for constructing Zabbix monitors that need
+  # to talk to Chef servers.
+  #
+  # This class handles the low-level logic of connecting to Chef and
+  # parsing results from searches.
+  #
+  # It's still up to a subclass to determine how to make a measurement.
+  #
+  # Here's an example of a script which checks the availibility of a web
+  # server at the EC2 public hostname of the Chef node 'webserver'.
+  #
+  #   #!/usr/bin/env ruby
+  #   # in webserver_monitor
+  #   
+  #   require 'net/http'
+  #   
+  #   class WebserverMonitor < Rubix::ChefMonitor
+  #   
+  #     def measure
+  #       webserver = chef_node_from_node_name('webserver')
+  #       begin
+  #         if Net::HTTP.get_response(URI.parse("http://#{webserver['ec2']['public_hostname']}")).code.to_i == 200
+  #           write do |data|
+  #             data << ['webserver.available', 1]
+  #           end
+  #           return
+  #         end
+  #       rescue => e
+  #       end
+  #       write do |data|
+  #         data << ([['webserver.available', 0]])
+  #       end
+  #     end
+  #   end
+  #   
+  #   WebserverMonitor.run if $0 == __FILE__
+  #
+  # See documentation for Rubix::Monitor to understand how to run this
+  # script.
+  class ChefMonitor < Monitor
+
+    def self.default_settings
+      super().tap do |s|
+        s.define :chef_server_url, :description => "Chef server URL" ,                     :required => true
+        s.define :chef_node_name,  :description => "Node name to identify to Chef server", :required => true
+        s.define :chef_client_key, :description => "Path to Chef client private key",      :required => true
+      end
+    end
+    
+    def initialize settings
+      super(settings)
+      set_chef_credentials
+    end
+
+    def set_chef_credentials
+      require 'chef'
+      Chef::Config[:chef_server_url] = settings[:chef_server_url]
+      Chef::Config[:node_name]       = settings[:chef_node_name]
+      Chef::Config[:client_key]      = settings[:chef_client_key]
+    end
+
+    def search_nodes *args
+      Chef::Search::Query.new.search('node', *args)
+    end
+
+    def chef_node_from_node_name node_name
+      return if node_name.nil? || node_name.empty?
+      results = search_nodes("name:#{node_name}")
+      return unless results.first.size > 0
+      results.first.first
+    end
+
+    def chef_node_name_from_ip ip
+      return if ip.nil? || ip.empty?
+      results = search_nodes("ipaddress:#{ip} OR fqdn:#{ip}")
+      return unless results.first.size > 0
+      results.first.first['node_name']
+    end
+    
+  end
+end

data/lib/rubix/monitors/cluster_monitor.rb

@@ -0,0 +1,84 @@
+module Rubix
+  
+  # A generic monitor class for constructing Zabbix monitors that
+  # monitor whole clusters.
+  #
+  # This class handles the low-level logic of finding a set of nodes and
+  # then grouping them by cluster.
+  #
+  # It's still up to a subclass to determine how to make a measurement
+  # on the cluster.
+  #
+  # Here's an example of a script which finds the average uptime of
+  # nodes a value of 'bar' set for property 'foo', grouped by cluster.
+  #
+  #   #!/usr/bin/env ruby
+  #   # in cluster_uptime_monitor
+  #   
+  #   class ClusterUptimeMonitor < Rubix::ClusterMonitor
+  #   
+  #     def node_query
+  #       'role:nginx'
+  #     end
+  #     
+  #     def measure_cluster cluster_name
+  #       total_seconds = nodes_by_cluster[cluster_name].inject(0.0) do |sum, node|
+  #         sum += node['uptime_seconds']
+  #       end
+  #       average_uptime = total_seconds.to_f / nodes_by_cluster[cluster_name].size.to_f
+  #       write(:hostname => 'cluster_name') do |data|
+  #         data << ['uptime.average', average_uptime]
+  #       end
+  #     end
+  #   end
+  #   
+  #   ClusterUptimeMonitor.run if $0 == __FILE__
+  #
+  # See documentation for Rubix::Monitor to understand how to run this
+  # script.
+  class ClusterMonitor < ChefMonitor
+
+    attr_reader :private_ips_by_cluster, :nodes_by_cluster
+
+    def initialize settings
+      super(settings)
+      group_nodes_by_cluster
+    end
+
+    def node_query
+      ''
+    end
+
+    def matching_chef_nodes
+      search_nodes(node_query)
+    end
+
+    def group_nodes_by_cluster
+      @private_ips_by_cluster = {}
+      @nodes_by_cluster       = {}
+      matching_chef_nodes.first.each do |node|
+        @nodes_by_cluster[node['cluster_name']] ||= []
+        @nodes_by_cluster[node['cluster_name']] << node
+        
+        @private_ips_by_cluster[node['cluster_name']] ||= []
+        @private_ips_by_cluster[node['cluster_name']] << node['ipaddress']
+      end
+    end
+    
+    def clusters
+      private_ips_by_cluster.keys
+    end
+    
+    def measure
+      clusters.each do |cluster_name|
+        measure_cluster(cluster_name)
+      end
+    end
+
+    def measure_cluster cluster_name
+      raise NotImplementedError.new("Override the 'measure_cluster' method to make measurements of a given cluster.")
+    end
+    
+  end
+
+end

data/lib/rubix/response.rb

@@ -0,0 +1,124 @@
+require 'json'
+
+module Rubix
+
+  class Response
+
+    attr_reader :http_response, :code, :body
+
+    def initialize(http_response)
+      @http_response = http_response
+      @body          = http_response.body
+      @code          = http_response.code.to_i
+    end
+
+    #
+    # Parsing
+    #
+    
+    def parsed
+      return @parsed if @parsed
+      if non_200?
+        @parsed = {}
+      else
+        begin
+          @parsed = JSON.parse(@body) if @code == 200
+        rescue JSON::ParserError => e
+          @parsed = {}
+        end
+      end
+    end
+
+    #
+    # Error Handling
+    #
+
+    def non_200?
+      code != 200
+    end
+    
+    def error?
+      non_200? || (parsed.is_a?(Hash) && parsed['error'])
+    end
+
+    def zabbix_error?
+      code == 200 && error?
+    end
+
+    def error_code
+      return unless error?
+      (non_200? ? code : parsed['error']['code'].to_i) rescue 0
+    end
+    
+    def error_type
+      return unless error?
+      (non_200? ? "Non-200 Error" : parsed['error']['message']) rescue 'Unknown Error'
+    end
+
+    def error_message
+      return unless error?
+      begin
+        if non_200?
+          "Could not get a 200 response from the Zabbix API.  Further details are unavailable."
+        else
+          stripped_message = (parsed['error']['message'] || '').gsub(/\.$/, '')
+          stripped_data = (parsed['error']['data'] || '').gsub(/^\[.*?\] /, '')
+          [stripped_message, stripped_data].map(&:strip).reject(&:empty?).join(', ')
+        end
+      rescue => e
+        "No details available."
+      end
+    end
+
+    def success?
+      !error?
+    end
+
+    #
+    # Inspecting contents
+    #
+
+    def result
+      parsed['result']
+    end
+    
+    def [] key
+      return if error?
+      result[key]
+    end
+
+    def first
+      return if error?
+      result.first
+    end
+
+    def empty?
+      result.empty?
+    end
+
+    def has_data?
+      success? && (!empty?)
+    end
+    
+    def hash?
+      return false if error?
+      result.is_a?(Hash) && result.size > 0 && result.first.last
+    end
+
+    def array?
+      return false if error?
+      result.is_a?(Array) && result.size > 0 && result.first
+    end
+
+    def string?
+      return false if error?
+      result.is_a?(String) && result.size > 0
+    end
+
+    def boolean?
+      return false if error?
+      result == true || result == false
+    end
+    
+  end
+end