rubix 0.3.1 → 0.4.0

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/lib/rubix/examples/simple_chef_monitor.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+RUBIX_ROOT = File.expand_path('../../../../lib', __FILE__)
+$: << RUBIX_ROOT unless $:.include?(RUBIX_ROOT)
+
+require 'rubix'
+require 'net/http'
+require 'timeout'
+
+class HttpAvailabilityMonitor < Rubix::Monitor
+
+  include Rubix::ChefMonitor
+
+  def chef_node
+    begin
+      @chef_node ||= chef_node_from_node_name(Chef::Config[:node_name])
+    rescue => e
+      puts "Could not find a Chef node named #{Chef::Config[:node_name]} -- are you sure your Chef settings are correct?"
+    end
+  end
+
+  def measure
+    begin
+      timeout(1) do
+        if Net::HTTP.get_response(URI.parse("http://#{chef_node['fqdn']}/")).code.to_i == 200
+          write [host.name, 'webserver.available', 1]
+          return
+        end
+      end
+    rescue => e
+      puts e.message
+    end
+    write [host.name, 'webserver.available', 0]
+  end
+end
+
+HttpAvailabilityMonitor.run if $0 == __FILE__

data/lib/rubix/examples/simple_cluster_monitor.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+RUBIX_ROOT = File.expand_path('../../../../lib', __FILE__)
+$: << RUBIX_ROOT unless $:.include?(RUBIX_ROOT)
+
+require 'rubix'
+require 'net/http'
+require 'timeout'
+
+class HttpAvailabilityMonitor < Rubix::Monitor
+
+  include Rubix::ZabbixMonitor
+  include Rubix::ClusterMonitor  
+
+  def host_group_name
+    'Zabbix servers'
+  end
+
+  def measure_cluster cluster_name
+    hosts_by_cluster[cluster_name].each do |host|
+      measure_host(host)
+    end
+    write [cluster_name, 'something', 1]
+  end
+  
+  def measure_host host
+    begin
+      timeout(1) do
+        if Net::HTTP.get_response(URI.parse("http://#{host.ip}/")).code.to_i == 200
+          write [host.name, 'webserver.available', 1]
+          return
+        end
+      end
+    rescue => e
+      puts e.message
+    end
+    write [host.name, 'webserver.available', 0]
+  end
+
+end
+
+HttpAvailabilityMonitor.run if $0 == __FILE__

data/lib/rubix/examples/simple_zabbix_monitor.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+RUBIX_ROOT = File.expand_path('../../../../lib', __FILE__)
+$: << RUBIX_ROOT unless $:.include?(RUBIX_ROOT)
+
+require 'rubix'
+require 'net/http'
+require 'timeout'
+
+class HttpAvailabilityMonitor < Rubix::Monitor
+
+  include Rubix::ZabbixMonitor
+
+  def host_group_name
+    'Zabbix servers'
+  end
+
+  def measure
+    hosts.each do |host|
+      measure_host(host)
+    end
+  end
+
+  def measure_host host
+    begin
+      timeout(1) do
+        if Net::HTTP.get_response(URI.parse("http://#{host.ip}/")).code.to_i == 200
+          write [host.name, 'webserver.available', 1]
+          return
+        end
+      end
+    rescue => e
+      puts e.message
+    end
+    write [host.name, 'webserver.available', 0]
+  end
+end
+
+HttpAvailabilityMonitor.run if $0 == __FILE__

data/lib/rubix/models/model.rb

@@ -362,5 +362,20 @@ module Rubix
       end
     end
 
+    def self.list ids
+      return [] if ids.nil? || ids.empty?
+      response = request("#{zabbix_name}.get", get_params.merge((id_field + 's') => ids))
+      case
+      when response.has_data?
+        response.result.map do |obj|
+          build(obj)
+        end
+      when response.success?
+        []
+      else
+        error("Error listing Zabbix #{resource_name}s: #{response.error_message}")
+      end
+    end
+    
   end
 end

data/lib/rubix/monitors.rb

@@ -1,5 +1,6 @@
 module Rubix
   autoload :Monitor,        'rubix/monitors/monitor'
   autoload :ChefMonitor,    'rubix/monitors/chef_monitor'
+  autoload :ZabbixMonitor,  'rubix/monitors/zabbix_monitor'
   autoload :ClusterMonitor, 'rubix/monitors/cluster_monitor'
 end

data/lib/rubix/monitors/chef_monitor.rb

@@ -1,6 +1,6 @@
 module Rubix
-  # A generic monitor class for constructing Zabbix monitors that need
-  # to talk to Chef servers.
+  
+  # A module that lets monitors talk to Chef servers.
   #
   # This class handles the low-level logic of connecting to Chef and
   # parsing results from searches.
@@ -15,8 +15,10 @@ module Rubix
   #   
   #   require 'net/http'
   #   
-  #   class WebserverMonitor < Rubix::ChefMonitor
+  #   class WebserverMonitor < Rubix::Monitor
   #   
+  #     include Rubix::ChefMonitor
+  #     
   #     def measure
   #       webserver = chef_node_from_node_name('webserver')
   #       begin
@@ -31,16 +33,13 @@ module Rubix
   #   end
   #   
   #   WebserverMonitor.run if $0 == __FILE__
-  #
-  # See documentation for Rubix::Monitor to understand how to run this
-  # script.
-  class ChefMonitor < Monitor
+  module ChefMonitor
 
-    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
+    def self.included klass
+      klass.default_settings.tap do |s|
+        s.define :chef_server_url, :description => "Chef server URL" ,                     :required => true, :default => 'http://localhost'
+        s.define :chef_node_name,  :description => "Node name to identify to Chef server", :required => true, :default => ENV["HOSTNAME"]
+        s.define :chef_client_key, :description => "Path to Chef client private key",      :required => true, :default => '/etc/chef/client.pem'
       end
     end
     
@@ -67,11 +66,16 @@ module Rubix
       results.first.first
     end
 
-    def chef_node_name_from_ip ip
+    def chef_node_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']
+      results.first.first
+    end
+
+    def chef_node_name_from_ip ip
+      node = chef_node_from_ip(ip)
+      return node['node_name'] if node
     end
     
   end

data/lib/rubix/monitors/cluster_monitor.rb

@@ -1,93 +1,85 @@
 module Rubix
   
-  # A generic monitor class for constructing Zabbix monitors that
-  # monitor whole clusters.
+  # A module for building monitors which measure items for several
+  # hosts in a cluster as well as items for the cluster itself.
   #
-  # This class handles the low-level logic of finding a set of nodes and
-  # then grouping them by cluster.
+  # This module assumes that an existing +hosts+ method returns an
+  # Array of Zabbix hosts that can be grouped into clusters.
   #
-  # 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.
+  # Here's an example:
   #
   #   #!/usr/bin/env ruby
-  #   # in cluster_uptime_monitor
-  #   
-  #   class ClusterUptimeMonitor < Rubix::ClusterMonitor
   #   
-  #     def node_query
-  #       'role:nginx'
-  #     end
-  #     
+  #   class ClusterPingMonitor < Rubix::Monitor
+  #
+  #     include Rubix::ClusterMonitor
+  #
   #     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]
+  #       total_ping = 0.0
+  #       num_hosts  = 0
+  #       hosts_by_cluster[cluster_name].each do |host|
+  #         total_ping += measure_host(host)
+  #         num_hosts  += 1
   #       end
+  #       write [cluster_name, 'average_ping', total_ping / num_hosts] unless num_hosts == 0
+  #     end
+  #
+  #     def measure_host host
+  #       ping = measure_ping_to(host.ip)
+  #       write [host.name, 'ping', ping]
+  #       ping # return this so the measure_cluster method can use it
   #     end
   #   end
   #   
-  #   ClusterUptimeMonitor.run if $0 == __FILE__
+  #   ClusterPingMonitor.run if $0 == __FILE__
   #
-  # See documentation for Rubix::Monitor to understand how to run this
-  # script.
-  class ClusterMonitor < ChefMonitor
+  # You may want to override the +cluster_name_from_host+ method.  By
+  # defaul it assumes that hosts in Zabbix are named
+  # 'cluster-facet-index', a la Ironfan.
+  module ClusterMonitor
+
+    # The name of the default cluster.
+    DEFAULT_CLUSTER = 'All Hosts'
+
+    attr_reader :hosts_by_cluster
 
-    attr_reader :all_private_ips_by_cluster, :private_ips_by_cluster, :all_nodes_by_cluster, :nodes_by_cluster
+    def default_cluster
+      ::Rubix::ClusterMonitor::DEFAULT_CLUSTER
+    end
 
     def initialize settings
       super(settings)
-      group_nodes_by_cluster
+      @hosts_by_cluster = {}
+      group_hosts_by_cluster
     end
 
-    def node_query
-      ''
+    def measure
+      clusters.each do |cluster_name|
+        measure_cluster(cluster_name)
+      end
     end
 
-    def matching_chef_nodes
-      search_nodes(node_query)
+    def group_hosts_by_cluster
+      hosts.each do |host|
+        cluster_name = cluster_name_from_host(host)
+        @hosts_by_cluster[cluster_name] ||= []
+        @hosts_by_cluster[cluster_name] << host
+      end
     end
 
-    def group_nodes_by_cluster
-      @all_private_ips_by_cluster = {}
-      @private_ips_by_cluster     = {}
-      @all_nodes_by_cluster       = {}
-      @nodes_by_cluster           = {}
-      matching_chef_nodes.first.each do |node|
-        @all_nodes_by_cluster[node['cluster_name']] ||= []
-        @nodes_by_cluster[node['cluster_name']]     ||= []
-        
-        @all_nodes_by_cluster[node['cluster_name']] << node
-        @nodes_by_cluster[node['cluster_name']]     << node unless %w[stopped].include?(node['state'])
-        
-        
-        @all_private_ips_by_cluster[node['cluster_name']] ||= []
-        @private_ips_by_cluster[node['cluster_name']]     ||= []
-        
-        @all_private_ips_by_cluster[node['cluster_name']] << node['ipaddress']
-        @private_ips_by_cluster[node['cluster_name']]     << node['ipaddress'] unless %w[stopped].include?(node['state'])
+    def cluster_name_from_host host
+      return default_cluster if host.name.nil? || host.name.empty?
+      parts = host.name.split("-")
+      if parts.size == 3
+        parts.first
+      else
+        default_cluster
       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.")
+      @hosts_by_cluster.keys
     end
     
   end
-
 end

data/lib/rubix/monitors/monitor.rb

@@ -55,7 +55,8 @@ module Rubix
     #
 
     def self.default_settings
-      Configliere::Param.new.tap do |s|
+      @default_settings ||= Configliere::Param.new.tap do |s|
+        
         s.use :commandline
         
         s.define :loop,   :description => "Run every this many seconds",                         :required => false, :type => Integer
@@ -63,10 +64,10 @@ module Rubix
         # The following options are only used when sending directly
         # with <tt>zabbix_sender</tt>
         s.define :server, :description => "IP of a Zabbix server",                               :required => false, :default => 'localhost'
-        s.define :port,   :description => "Port of a Zabbix server",                             :required => false, :type => Integer,  :default => 10051
-        s.define :host,   :description => "Name of a Zabbix host",                               :required => false
+        s.define :port,   :description => "Port of a Zabbix server",                             :required => false, :default => 10051, :type => Integer
+        s.define :host,   :description => "Name of a Zabbix host",                               :required => false, :default => ENV["HOSTNAME"]
         s.define :config, :description => "Local Zabbix agentd configuration file",              :required => false, :default => "/etc/zabbix/zabbix_agentd.conf"
-        s.define :send,   :description => "Send data directlyt to Zabbix using 'zabbix_sender'", :required => false, :type => :boolean, :default => false
+        s.define :send,   :description => "Send data directlyt to Zabbix using 'zabbix_sender'", :required => false, :default => false, :type => :boolean
       end
     end
 

data/lib/rubix/monitors/zabbix_monitor.rb

@@ -0,0 +1,71 @@
+module Rubix
+  
+  # A module for finding hosts for a monitor from Zabbix templates or
+  # host groups.
+  #
+  # Here's an example of a monitor which makes a measurement of all
+  # hosts with +Template_Foo+ by making a web request to the physical
+  # host.
+  #
+  #   #!/usr/bin/env ruby
+  #   # in cluster_uptime_monitor
+  #   
+  #   class FooMonitor < Rubix::Monitor
+  #
+  #     include Rubix::ZabbixMonitor
+  #
+  #     # Define either 'template' or 'host_group' to select hosts (or
+  #     # define 'hosts').
+  #     def template
+  #       'Template_Foo'
+  #     end
+  #     
+  #     def measure
+  #       self.hosts.each do |host|
+  #         measure_host(host)
+  #       end
+  #     end
+  #
+  #     def measure_host host
+  #       ...
+  #     end
+  #   
+  #   FooMonitor.run if $0 == __FILE__
+  module ZabbixMonitor
+
+    attr_accessor :template, :host_group, :hosts
+
+    def self.included klass
+      klass.default_settings.tap do |s|
+        s.define :zabbix_api_url, :description => "Zabbix API URL" ,         :required => true, :default => 'http://localhost/api_jsonrpc.php'
+        s.define :username,       :description => "Username for Zabbix API", :required => true, :default => 'admin'
+        s.define :password,       :description => "Password for Zabbix API", :required => true, :default => 'zabbix'
+      end
+    end
+    
+    def initialize settings
+      super(settings)
+      Rubix.connect(settings[:zabbix_api_url], settings[:username], settings[:password])
+      find_hosts
+    end
+    
+    def template_name
+    end
+
+    def host_group_name
+    end
+
+    def find_hosts
+      case
+      when template_name
+        self.template = Rubix::Template.find(:name => template_name)
+        self.hosts    = Rubix::Host.list(self.template.host_ids).find_all(&:monitored)
+      when host_group_name
+        self.host_group = Rubix::HostGroup.find(:name => host_group_name)
+        self.hosts      = Rubix::Host.list(self.host_group.host_ids).find_all(&:monitored)
+      else
+        raise Rubix::Error.new("Must define either a 'template_name' or a 'host_group_name' property for a Zabbix monitor.")
+      end
+    end
+  end
+end

data/spec/requests/host_request_spec.rb

@@ -5,7 +5,6 @@ describe "Hosts" do
   before do
     integration_test
     @host_group_1 = ensure_save(Rubix::HostGroup.new(:name => 'rubix_spec_host_group_1'))
-
   end
 
   after do
@@ -18,6 +17,14 @@ describe "Hosts" do
       Rubix::Host.find(:name => 'rubix_spec_host_1').should be_nil
     end
 
+    it "returns an empty array when listing without IDs" do
+      Rubix::Host.list([1,2,3]).should == []
+    end
+
+    it "returns an empty array when listing with IDs" do
+      Rubix::Host.list([1,2,3]).should == []
+    end
+    
     it "can be created" do
       host = Rubix::Host.new(:name => 'rubix_spec_host_1', :host_groups => [@host_group_1])
       host.save.should be_true
@@ -34,6 +41,13 @@ describe "Hosts" do
       @template_2   = ensure_save(Rubix::Template.new(:name => 'rubix_spec_template_2', :host_groups => [@host_group_2]))
     end
 
+    it "can be listed by ID" do
+      hosts = Rubix::Host.list([@host.id])
+      hosts.should_not be_nil
+      hosts.should_not be_empty
+      hosts.first.name.should == @host.name
+    end
+
     it "can have its name changed" do
       @host.name = 'rubix_spec_host_2'
       @host.save
@@ -78,4 +92,5 @@ describe "Hosts" do
     end
 
   end
+  
 end

data/spec/rubix/monitors/chef_monitor_spec.rb

@@ -2,10 +2,59 @@ require 'spec_helper'
 
 describe Rubix::ChefMonitor do
 
-  before do
-    @wrapper = Class.new(Rubix::ChefMonitor)
+  def mock_query query, nodes=[]
+    require 'chef'
+    chef_query = mock("Chef::Search::Query")
+    ::Chef::Search::Query.should_receive(:new).and_return(chef_query)
+    chef_query.should_receive(:search).with('node', query).and_return([nodes, nodes.length])
   end
   
+  before do
+    @wrapper = Class.new(Rubix::Monitor)
+    @wrapper.send(:include, Rubix::ChefMonitor)
+  end
+
+  it "has options for talking to Chef" do
+    @wrapper.default_settings.should include(:chef_server_url)
+    @wrapper.default_settings.should include(:chef_node_name)
+    @wrapper.default_settings.should include(:chef_client_key)
+  end
+
+  describe "finding nodes in Chef" do
 
+    describe 'when a node exists' do
+      before do
+        @node = { 'node_name' => 'foobar', 'ipaddress' => '123', 'fdqn' => '456' }
+      end
+
+      it "can find it based on its node name" do
+        mock_query('name:foobar', [@node])
+        @wrapper.new(@wrapper.default_settings).chef_node_from_node_name('foobar').should == @node
+      end
+
+      it "can find it based on its IP" do
+        mock_query('ipaddress:123 OR fqdn:123', [@node])
+        @wrapper.new(@wrapper.default_settings).chef_node_from_ip('123').should == @node
+      end
+
+      it "can find it based on its FQDN" do
+        mock_query('ipaddress:456 OR fqdn:456', [@node])
+        @wrapper.new(@wrapper.default_settings).chef_node_from_ip('456').should == @node
+      end
+    end
+
+    describe "when a node doesn't exist" do
+      
+      it "returns nil when searching by node name" do
+        mock_query('name:foobar')
+        @wrapper.new(@wrapper.default_settings).chef_node_from_node_name('foobar').should be_nil
+      end
+
+      it "returns nil when searching by IP" do
+        mock_query('ipaddress:123 OR fqdn:123')
+        @wrapper.new(@wrapper.default_settings).chef_node_from_ip('123').should be_nil
+      end
+    end
+  end
 end
   

data/spec/rubix/monitors/cluster_monitor_spec.rb

@@ -2,32 +2,34 @@ require 'spec_helper'
 
 describe Rubix::ClusterMonitor do
 
-  def mock_chef_query nodes
-    query = mock("Chef::Search::Query")
-    require 'chef'
-    ::Chef::Search::Query.should_receive(:new).and_return(query)
-    query.should_receive(:search).and_return([nodes, nodes.size])
-  end
-  
-  it "should correctly carve up a group of nodes into clusters" do
-    mock_chef_query([
-                     { 'cluster_name' => 'foo', 'state' => 'started', 'ipaddress' => '123' },
-                     { 'cluster_name' => 'foo', 'state' => 'stopped', 'ipaddress' => '456' },
-                     { 'cluster_name' => 'bar', 'state' => 'started', 'ipaddress' => '789' },
-                     { 'cluster_name' => 'bar', 'state' => 'stopped', 'ipaddress' => '321' }
-                    ])
-    cm = Rubix::ClusterMonitor.new({})
-    cm.clusters.should include('foo', 'bar')
-    cm.private_ips_by_cluster.should == { 'foo' => ['123'], 'bar' => ['789'] }
-    cm.all_private_ips_by_cluster.should == { 'foo' => ['123', '456'], 'bar' => ['789', '321'] }
+  before do
+    @wrapper = Class.new(Rubix::Monitor)
+    @wrapper.class_eval do
+      include Rubix::ClusterMonitor
+      def hosts
+        [
+         Rubix::Host.new(:name => 'cluster1-facet1-host1'),
+         Rubix::Host.new(:name => 'cluster1-facet1-host2'),
+         Rubix::Host.new(:name => 'cluster1-facet2-host3'),
+         
+         Rubix::Host.new(:name => 'cluster2-facet1-host1'),
+         Rubix::Host.new(:name => 'cluster2-facet1-host2'),
+         Rubix::Host.new(:name => 'cluster2-facet2-host3'),
 
-    cm.nodes_by_cluster['foo'].size.should == 1
-    cm.nodes_by_cluster['bar'].size.should == 1
+         Rubix::Host.new(:name => 'malformed')
+        ]
+      end
+    end
+  end
 
-    cm.all_nodes_by_cluster['foo'].size.should == 2
-    cm.all_nodes_by_cluster['bar'].size.should == 2
-    
+  it "should be able to filter hosts into clusters" do
+    monitor = @wrapper.new(@wrapper.default_settings)
+    monitor.clusters.should include('cluster1', 'cluster2', Rubix::ClusterMonitor::DEFAULT_CLUSTER)
+    monitor.hosts_by_cluster['cluster1'].map(&:name).should include('cluster1-facet1-host1', 'cluster1-facet1-host2', 'cluster1-facet2-host3')
+    monitor.hosts_by_cluster['cluster2'].map(&:name).should include('cluster2-facet1-host1', 'cluster2-facet1-host2', 'cluster2-facet2-host3')
+    monitor.hosts_by_cluster[Rubix::ClusterMonitor::DEFAULT_CLUSTER].map(&:name).should include('malformed')
   end
+
   
   
 end

data/spec/rubix/monitors/zabbix_monitor_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Rubix::ZabbixMonitor do
+
+  before do
+    @wrapper = Class.new(Rubix::Monitor)
+    @wrapper.class_eval do
+      include Rubix::ZabbixMonitor
+    end
+    @hosts = [Rubix::Host.new(:name => 'host1'), Rubix::Host.new(:name => 'host2'), Rubix::Host.new(:name => 'host3', :monitored => false)]
+  end
+
+  it "will raise an error when no template name or host group is defined" do
+    lambda { @wrapper.new(@wrapper.default_settings) }.should raise_error(Rubix::Error)
+  end
+
+  it "can find hosts based on a template" do
+    @wrapper.class_eval do
+      def template_name
+        'Template_Foo'
+      end
+    end
+    @template = Rubix::Template.new(:name => 'Template_Foo')
+    Rubix::Template.should_receive(:find).with(:name => 'Template_Foo').and_return(@template)
+    @template.should_receive(:host_ids).and_return([1,2,3])
+    Rubix::Host.should_receive(:list).with([1,2,3]).and_return(@hosts)
+    @wrapper.new(@wrapper.default_settings).hosts.should == @hosts[0..1]
+  end
+
+  it "can find hosts based on a host group" do
+    @wrapper.class_eval do
+      def host_group_name
+        'Foos'
+      end
+    end
+    @host_group = Rubix::HostGroup.new(:name => 'Foos')
+    Rubix::HostGroup.should_receive(:find).with(:name => 'Foos').and_return(@host_group)
+    @host_group.should_receive(:host_ids).and_return([1,2,3])
+    Rubix::Host.should_receive(:list).with([1,2,3]).and_return(@hosts)
+    @wrapper.new(@wrapper.default_settings).hosts.should == @hosts[0..1]
+  end
+  
+end
+
+  
+

data/spec/support/integration_helper.rb

@@ -1,8 +1,12 @@
 module Rubix
   module IntegrationHelper
-    
+
     def integration_test
-      pending("A live Zabbix API to test against") unless $RUBIX_INTEGRATION_TEST
+      if $RUBIX_INTEGRATION_TEST
+        Rubix.connect($RUBIX_INTEGRATION_TEST['url'], $RUBIX_INTEGRATION_TEST['username'], $RUBIX_INTEGRATION_TEST['password'])
+      else
+        pending("A live Zabbix API to test against")
+      end
     end
 
     def ensure_save(obj)
@@ -61,7 +65,7 @@ module Rubix
 
       truncate_all_tables
 
-      $RUBIX_INTEGRATION_TEST = true
+      $RUBIX_INTEGRATION_TEST = api_connection
     end
 
     RUBIX_TABLES_TO_TRUNCATE = %w[applications groups hostmacro hosts hosts_groups hosts_profiles hosts_profiles_ext hosts_templates items items_applications profiles triggers trigger_depends]

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Dhruv Bansal
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-10 00:00:00 -06:00
+date: 2012-02-13 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -96,10 +96,10 @@ files:
 - lib/rubix/models/model.rb
 - lib/rubix/models/time_series.rb
 - lib/rubix/models/application.rb
-- lib/rubix/examples/es_monitor.rb
-- lib/rubix/examples/mongo_monitor.rb
-- lib/rubix/examples/uptime_monitor.rb
-- lib/rubix/examples/hbase_monitor.rb
+- lib/rubix/examples/simple_zabbix_monitor.rb
+- lib/rubix/examples/simple_uptime_monitor.rb
+- lib/rubix/examples/simple_cluster_monitor.rb
+- lib/rubix/examples/simple_chef_monitor.rb
 - lib/rubix/auto_sender.rb
 - lib/rubix/sender.rb
 - lib/rubix/log.rb
@@ -117,6 +117,7 @@ files:
 - lib/rubix/associations/has_many_user_macros.rb
 - lib/rubix/monitors/chef_monitor.rb
 - lib/rubix/monitors/cluster_monitor.rb
+- lib/rubix/monitors/zabbix_monitor.rb
 - lib/rubix/monitors/monitor.rb
 - lib/rubix/connection.rb
 - lib/rubix/associations.rb
@@ -124,6 +125,7 @@ files:
 - spec/rubix/auto_sender_spec.rb
 - spec/rubix/monitors/monitor_spec.rb
 - spec/rubix/monitors/chef_monitor_spec.rb
+- spec/rubix/monitors/zabbix_monitor_spec.rb
 - spec/rubix/monitors/cluster_monitor_spec.rb
 - spec/rubix/response_spec.rb
 - spec/rubix/sender_spec.rb

data/lib/rubix/examples/es_monitor.rb

@@ -1,134 +0,0 @@
-#!/usr/bin/env ruby
-
-RUBIX_ROOT = File.expand_path('../../../../lib', __FILE__)
-$: << RUBIX_ROOT unless $:.include?(RUBIX_ROOT)
-
-require 'rubix'
-require 'open-uri'
-
-class ESMonitor < Rubix::ClusterMonitor
-
-  # Hostgroup for any hosts that needs to be created.
-  CLUSTER_HOSTGROUPS = 'Elasticsearch clusters'
-
-  # Templates for any hosts that need to be created.
-  CLUSTER_TEMPLATES = 'Template_Elasticsearch_Cluster'
-  NODE_TEMPLATES    = 'Template_Elasticsearch_Node'
-  
-  # Applications for new items
-  CLUSTER_APPLICATIONS = '_cluster'
-  NODE_APPLICATIONS    = 'Elasticsearch'
-
-  def node_query
-    'provides_service:*-elasticsearch'
-  end
-
-  def es_url private_ip, *args
-    "http://" + File.join(private_ip + ":9200", *args)
-  end
-  
-  def measure_cluster cluster_name
-    measured_cluster_health  = false
-    measured_cluster_indices = false
-    measured_cluster_nodes   = false
-    private_ips_by_cluster[cluster_name].each do |private_ip|
-      measured_cluster_health  = measure_cluster_health(cluster_name, private_ip)  unless measured_cluster_health
-      measured_cluster_indices = measure_cluster_indices(cluster_name, private_ip) unless measured_cluster_indices
-      measured_cluster_nodes   = measure_cluster_nodes(cluster_name, private_ip)   unless measured_cluster_nodes
-      break if measured_cluster_health && measured_cluster_indices && measured_cluster_nodes
-    end
-  end
-
-  # Measure the cluster health metrics -- /_cluster/health
-  def measure_cluster_health cluster_name, private_ip
-    begin
-      cluster_health = JSON.parse(open(es_url(private_ip, '_cluster', 'health')).read)
-    rescue SocketError, OpenURI::HTTPError, JSON::ParserError, Errno::ECONNREFUSED => e
-      # This node may not be running a webnode...
-      return false
-    end
-    write({
-            :hostname    => "#{cluster_name}-elasticsearch",
-            :hostgroup   => self.class::CLUSTER_HOSTGROUPS,
-            :templates   => self.class::CLUSTER_TEMPLATES,
-            :application => self.class::CLUSTER_APPLICATIONS
-          }) do |d|
-      d << ['status',              cluster_health['status']               ]
-      d << ['nodes.total',         cluster_health['number_of_nodes']      ]
-      d << ['nodes.data',          cluster_health['number_of_data_nodes'] ]
-      d << ['shards.active',       cluster_health['active_shards']        ]
-      d << ['shards.relocating',   cluster_health['relocating_shards']    ]
-      d << ['shards.unassigned',   cluster_health['unassigned_shards']    ]
-      d << ['shards.initializing', cluster_health['initializing_shards']  ]
-    end
-    true
-  end
-
-  def measure_cluster_indices cluster_name, private_ip
-    begin
-      index_data = JSON.parse(open(es_url(private_ip, '_status')).read)
-    rescue SocketError, OpenURI::HTTPError, JSON::ParserError, Errno::ECONNREFUSED => e
-      # This node may not be running a webnode...
-      return false
-    end
-    index_data['indices'].each_pair do |index_name, index_data|
-      write({
-              :hostname   => "#{cluster_name}-elasticsearch",
-              :hostgroup  => self.class::CLUSTER_HOSTGROUPS,
-              :templates  => self.class::CLUSTER_TEMPLATES,
-              :appliation => index_name
-            }) do |d|
-        d << ["#{index_name}.size",           index_data["index"]["size_in_bytes"] ]
-        d << ["#{index_name}.docs.num",       index_data["docs"]["num_docs"]       ]
-        d << ["#{index_name}.docs.max",       index_data["docs"]["max_doc"]        ]
-        d << ["#{index_name}.docs.deleted",   index_data["docs"]["deleted_docs"]   ]
-        d << ["#{index_name}.operations",     index_data["translog"]["operations"] ]
-        d << ["#{index_name}.merges.total",   index_data["merges"]["total"]        ]
-        d << ["#{index_name}.merges.current", index_data["merges"]["current"]      ]
-      end
-    end
-    true
-  end
-
-  def measure_cluster_nodes cluster_name, private_ip
-    begin
-      nodes_data       = JSON.parse(open(es_url(private_ip, '_cluster', 'nodes')).read)
-      nodes_stats_data = JSON.parse(open(es_url(private_ip, '_cluster', 'nodes', 'stats')).read)
-    rescue SocketError, OpenURI::HTTPError, JSON::ParserError, Errno::ECONNREFUSED => e
-      # This node may not be running a webnode...
-      return false
-    end
-
-    nodes_stats_data['nodes'].each_pair do |id, stats|
-
-      ip        = nodes_data['nodes'][id]['network']['primary_interface']['address']
-      node_name = chef_node_name_from_ip(ip)
-      next unless node_name
-      write({
-              :hostname    => node_name,
-              :templates   => self.class::NODE_TEMPLATES,
-              :application => self.class::NODE_APPLICATIONS
-            }) do |d|
-        # concurrency
-        d << ['es.jvm.threads.count',     stats['jvm']['threads']['count']                   ]
-
-        # garbage collection
-        d << ['es.jvm.gc.coll_time',      stats['jvm']['gc']['collection_time_in_millis']    ]
-        d << ['es.jvm.gc.coll_count',     stats['jvm']['gc']['collection_count']             ]
-
-        # memory
-        d << ['es.jvm.mem.heap_used',     stats['jvm']['mem']['heap_used_in_bytes']          ]
-        d << ['es.jvm.mem.non_heap_used', stats['jvm']['mem']['non_heap_used_in_bytes']      ]
-        d << ['es.jvm.mem.heap_comm',     stats['jvm']['mem']['heap_committed_in_bytes']     ]
-        d << ['es.jvm.mem.non_heap_comm', stats['jvm']['mem']['non_heap_committed_in_bytes'] ]
-
-        # indices
-        d << ['es.indices.size',          stats['indices']['size_in_bytes']                  ]
-      end
-    end
-    true
-  end
-
-end
-
-ESMonitor.run if $0 == __FILE__

data/lib/rubix/examples/hbase_monitor.rb

@@ -1,94 +0,0 @@
-#!/usr/bin/env ruby
-
-RUBIX_ROOT = File.expand_path('../../../../lib', __FILE__)
-$: << RUBIX_ROOT unless $:.include?(RUBIX_ROOT)
-
-require 'rubix'
-require 'net/http'
-require 'crack'
-
-class HBaseMonitor < Rubix::ClusterMonitor
-
-  # Hostgroups for clusters & hosts that need to be created.
-  CLUSTER_HOSTGROUPS = 'HBase clusters'
-
-  # Templates for any hosts that need to be created.
-  CLUSTER_TEMPLATES = 'Template_HBase_Cluster'
-  NODE_TEMPLATES    = 'Template_HBase_Node'
-
-  # Applications for items that are written
-  CLUSTER_APPLICATIONS = '_cluster'
-  NODE_APPLICATIONS    = "Hbase"
-
-  def matching_chef_nodes
-    Chef::Search::Query.new.search('node', 'provides_service:*hbase-stargate AND facet_name:alpha')
-  end
-  
-  def measure_cluster cluster_name
-    measured_cluster_status  = false
-    private_ips_by_cluster[cluster_name].each do |private_ip|
-      measured_cluster_status  = measure_cluster_status(cluster_name, private_ip)  unless measured_cluster_status
-      break if measured_cluster_status
-    end
-  end
-
-  # Measure the cluster health metrics -- /status/cluster
-  def measure_cluster_status cluster_name, private_ip
-    begin
-      connection = Net::HTTP.new(private_ip, 8080) # FIXME port
-      request    = Net::HTTP::Get.new('/status/cluster', 'Accept' => 'text/xml')
-      response   = connection.request(request)
-      return false unless response.code.to_i == 200
-      
-      data           = Crack::XML.parse(response.body)
-      cluster_status = data['ClusterStatus']
-      dead_nodes     = cluster_status['DeadNodes'] ? cluster_status['DeadNodes']['Node'] : []
-      live_nodes     = cluster_status['LiveNodes']['Node']
-    rescue NoMethodError, SocketError, REXML::ParseException, Errno::ECONNREFUSED => e
-      # puts "#{e.class} -- #{e.message}"
-      # puts e.backtrace
-      return false
-    end
-
-    write({
-            :hostname    => "#{cluster_name}-hbase",
-            :hostgroup   => self.class::CLUSTER_HOSTGROUPS,
-            :application => self.class::CLUSTER_APPLICATIONS,
-            :templates   => self.class::CLUSTER_TEMPLATES
-          }) do |d|
-      d << ['requests',    cluster_status['requests']]
-      d << ['regions',     cluster_status['regions']]
-      d << ['load',        cluster_status['averageLoad']]
-      d << ['nodes.dead',  dead_nodes.size]
-      d << ['nodes.alive', live_nodes.size]
-    end
-    measure_cluster_tables(cluster_name, data)
-    measure_cluster_nodes(cluster_name, live_nodes)
-    true
-  end
-
-  def measure_cluster_tables cluster_name, data
-    # FIXME...not sure how best to get information about "tables" in HBase...
-  end
-
-  def measure_cluster_nodes cluster_name, live_nodes
-    live_nodes.each do |live_node|
-      next unless live_node
-      ip        = (live_node['name'] || '').split(':').first
-      node_name = chef_node_name_from_ip(ip)
-      next unless node_name
-      write({
-              :hostname    => node_name,
-              :application => self.class::NODE_APPLICATIONS,
-              :templates   => self.class::NODE_TEMPLATES
-            }) do |d|
-        d << ['hbase.regions',   (live_node['Region'] || []).size]
-        d << ['hbase.heap_size', live_node['heapSizeMB']]
-        d << ['hbase.requests',  live_node['requests']]
-      end
-    end
-  end
-
-end
-
-HBaseMonitor.run if $0 == __FILE__

data/lib/rubix/examples/mongo_monitor.rb

@@ -1,130 +0,0 @@
-#!/usr/bin/env ruby
-
-RUBIX_ROOT = File.expand_path('../../../../lib', __FILE__)
-$: << RUBIX_ROOT unless $:.include?(RUBIX_ROOT)
-
-require 'rubix'
-require 'open-uri'
-require 'set'
-require 'mongo'
-
-class MongoMonitor < Rubix::ClusterMonitor
-  
-  # Hostgroup for any hosts that needs to be created.
-  CLUSTER_HOSTGROUPS = 'MongoDB clusters'
-
-  # Templates for any hosts that need to be created.
-  CLUSTER_TEMPLATES = 'Template_MongoDB'
-
-  # Applications
-  CLUSTER_APPLICATIONS = '_cluster'
-
-  # Names of database to ignore when we find them.
-  IGNORED_DATABASES = %w[db test admin local].to_set
-
-  def matching_chef_nodes
-    Chef::Search::Query.new.search('node', 'provides_service:*-mongodb-server')
-  end
-  
-  def measure_cluster cluster_name
-    measured_mongo_server    = false
-    measured_mongo_databases = false
-    private_ips_by_cluster[cluster_name].each do |private_ip|
-      begin
-        connection = Mongo::Connection.new(private_ip)
-      rescue Mongo::ConnectionFailure => e
-        next
-      end
-      measured_mongo_server    = measure_mongo_server(cluster_name, connection)    unless measured_mongo_server
-      measured_mongo_databases = measure_mongo_databases(cluster_name, connection) unless measured_mongo_databases
-      break if measured_mongo_server && measured_mongo_databases
-    end
-  end
-
-  def measure_mongo_server cluster_name, connection
-    initial = nil, final = nil
-    db       = connection.db('system') # the name of this db doesn't matter?
-    command = {:serverStatus => true}  # the value of the 'serverStatus' key doesn't matter?
-
-    # gather metrics with a 1.0 second gap
-    initial = db.command(command) ; sleep 1.0 ; final = db.command(command)
-    return false unless initial && final
-    dt = final['localTime'].to_f - initial['localTime'].to_f
-    write({
-            :hostname    => "#{cluster_name}-mongodb",
-            :hostgroup   => self.class::CLUSTER_HOSTGROUPS,
-            :templates   => self.class::CLUSTER_TEMPLATES,
-            :application => self.class::CLUSTER_APPLICATIONS
-           }) do |d|
-      
-      # operations
-      d << ['inserts',       (final['opcounters']['insert']  - initial['opcounters']['insert'])  / dt]
-      d << ['queries',       (final['opcounters']['query']   - initial['opcounters']['query'])   / dt]
-      d << ['updates',       (final['opcounters']['update']  - initial['opcounters']['update'])  / dt]
-      d << ['deletes',       (final['opcounters']['delete']  - initial['opcounters']['delete'])  / dt]
-      d << ['getmores',      (final['opcounters']['getmore'] - initial['opcounters']['getmore']) / dt]
-      d << ['commands',      (final['opcounters']['command'] - initial['opcounters']['command']) / dt]
-
-      # memory
-      d << ['mem.resident',  final['mem']['resident']]
-      d << ['mem.virtual',   final['mem']['virtual']]
-      d << ['mem.mapped',    final['mem']['mapped']]
-
-      # disk
-      d << ['flushes',       (final['backgroundFlushing']['flushes']  - initial['backgroundFlushing']['flushes'])  / dt]
-      d << ['flush_time',    (final['backgroundFlushing']['total_ms'] - initial['backgroundFlushing']['total_ms'])     ]
-      d << ['faults',        (final['extra_info']['page_faults']      - initial['extra_info']['page_faults'])      / dt]
-
-      # index
-      d << ['accesses',        (final['indexCounters']['btree']['accesses'] - initial['indexCounters']['btree']['accesses']) / dt]
-      d << ['hits',            (final['indexCounters']['btree']['hits']     - initial['indexCounters']['btree']['hits'])     / dt]
-      d << ['misses',          (final['indexCounters']['btree']['misses']   - initial['indexCounters']['btree']['misses'])   / dt]
-      d << ['resets',          (final['indexCounters']['btree']['resets']   - initial['indexCounters']['btree']['resets'])   / dt]
-
-      # read/write load
-      d << ['queue.total',   final['globalLock']['currentQueue']['total']]
-      d << ['queue.read',    final['globalLock']['currentQueue']['readers']]
-      d << ['queue.write',   final['globalLock']['currentQueue']['writers']]
-      d << ['clients.total', final['globalLock']['activeClients']['total']]
-      d << ['clients.read',  final['globalLock']['activeClients']['readers']]
-      d << ['clients.write', final['globalLock']['activeClients']['writers']]
-
-      # network
-      d << ['net.in',        (final['network']['bytesIn']     - initial['network']['bytesIn'])     / dt]
-      d << ['net.out',       (final['network']['bytesOut']    - initial['network']['bytesOut'])    / dt]
-      d << ['requests',      (final['network']['numRequests'] - initial['network']['numRequests']) / dt]
-      d << ['connections',   final['connections']['current']]
-    end
-    true
-  end
-
-  def measure_mongo_databases cluster_name, connection
-    dbs = connection.database_names
-    return true if dbs.size == 0 # nothing to do here
-
-    dbs.each do |database_name|
-      next if self.class::IGNORED_DATABASES.include?(database_name.downcase)
-      stats = connection.db(database_name).stats()
-
-      write({
-              :hostname    => "#{cluster_name}-mongodb",
-              :hostgroup   => self.class::CLUSTER_HOSTGROUPS,
-              :templates   => self.class::CLUSTER_TEMPLATES,
-              :application => database_name
-             }) do |d|
-        d << ["#{database_name}.collections",      stats["collections"] ]
-        d << ["#{database_name}.objects.count",    stats["objects"]     ]
-        d << ["#{database_name}.objects.avg_size", stats["avgObjSize"]  ]
-        d << ["#{database_name}.size.data",        stats["dataSize"]    ]
-        d << ["#{database_name}.size.disk",        stats["storageSize"] ]
-        d << ["#{database_name}.size.indexes",     stats["indexSize"]   ]
-        d << ["#{database_name}.size.file",        stats["fileSize"]    ]
-        d << ["#{database_name}.extents",          stats["numExtents"]  ]
-        d << ["#{database_name}.indexes",          stats["indexes"]     ]
-      end
-    end
-    true
-  end
-end
-
-MongoMonitor.run if $0 == __FILE__