rrd-grapher 1.0.0

data/spec/unit/alarm_manager_spec.rb

@@ -0,0 +1,252 @@
+
+require 'eventmachine'
+
+require File.expand_path('../../common', __FILE__)
+require File.expand_path('../../../lib/rrd-grapher/notifier/alarm_manager', __FILE__)
+
+
+describe 'AlarmManager' do
+  before do
+    @manager = RRDNotifier::AlarmManager.new
+  end
+  
+  should 'create the manager' do
+    @manager.should.not == nil
+  end
+  
+  describe 'with a user notification handler' do
+    before do
+      @handler_class = Class.new do
+        def dispatch_notification(notification); end
+        def alarm_started(alarm); end
+        def alarm_stopped(alarm); end
+      end
+      
+      @handler = @handler_class.new
+      
+      @manager = RRDNotifier::AlarmManager.new(:notification_handler => @handler)
+    end
+    
+    should 'dispatch notification as is' do
+      notif = Factory(:notification)
+      @handler.expects(:dispatch_notification).with(notif)
+      @manager.packet_received(notif)
+    end
+    
+    should 'notify the user handler when an alarm is raised' do
+      packet = Factory(:data_point)
+      alarm = RRDNotifier::AlarmTooLow.new(packet, 10)
+      
+      @handler.expects(:alarm_started).with(alarm)
+      @manager.raise_alarm(packet.measure_id, alarm)
+    end
+  
+    should 'notify the user handler when an alarm is stopped' do
+      p = Factory(:data_point)
+      alarm = RRDNotifier::AlarmTooLow.new(p, 10)
+      
+      @handler.expects(:alarm_stopped).with(alarm)
+      @manager.stop_specific_alarm(p.measure_id, alarm)
+    end
+  end
+  
+  describe 'a trigger on low value' do
+    before do
+      @manager.register_alarm('*', "memory/*", "memory/active", :min => 10)
+    end
+    
+    should 'raise an alarm for a value below the threshold' do
+      p = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+    
+      @manager.expects(:raise_alarm).with(p.measure_id, kind_of(RRDNotifier::AlarmTooLow) )
+    
+      @manager.packet_received(p)
+    end
+    
+    should 'not raise an alarm for a value above the threshold' do
+      p = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [81])
+    
+      @manager.expects(:raise_alarm).never
+    
+      @manager.packet_received(p)
+    end
+    
+    should 'not reraise another alarm if the value stays below the threshold' do
+      p_alarm = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+      p_alarm2 = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [5])
+      
+      @manager.expects(:active_alarms_for).with(p_alarm.measure_id).returns( [RRDNotifier::AlarmTooLow.new(p_alarm, 10)] )
+      @manager.expects(:raise_alarm).never
+      
+      @manager.packet_received(p_alarm2)
+    end
+    
+    should 'stop the alarm when the value comes back above the threshold' do
+      p_alarm = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+      p_normal = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [81])
+      
+      @manager.expects(:active_alarms_for).with(p_alarm.measure_id).returns( [RRDNotifier::AlarmTooLow.new(p_alarm, 10)] )
+      
+      @manager.expects(:raise_alarm).never
+      @manager.expects(:stop_specific_alarm).with( p_normal.measure_id, kind_of(RRDNotifier::AlarmTooLow) )
+    
+      @manager.packet_received(p_normal)
+    end
+    
+  end
+  
+  describe 'a trigger on high value' do
+    before do
+      @manager.register_alarm('*', "memory/*", "memory/active", :max => 10)
+    end
+    
+    should 'raise an alarm for a value above the threshold' do
+      p = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [81])
+    
+      @manager.expects(:raise_alarm).with(p.measure_id,  kind_of(RRDNotifier::AlarmTooHigh) )
+    
+      @manager.packet_received(p)
+    end
+    
+    should 'not raise an alarm for a value below the threshold' do
+      p = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+    
+      @manager.expects(:raise_alarm).never
+    
+      @manager.packet_received(p)
+    end
+    
+    should 'not reraise another alarm if the value stays above the threshold' do
+      p_alarm = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [81])
+      p_alarm2 = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [81])
+      
+      @manager.expects(:active_alarms_for).with(p_alarm.measure_id).returns( [RRDNotifier::AlarmTooLow.new(p_alarm, 10)] )
+      @manager.expects(:raise_alarm).never
+      
+      @manager.packet_received(p_alarm2)
+    end
+    
+    should 'stop the alarm when the value comes back below the threshold' do
+      p_alarm = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [81])
+      p_normal = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+      
+      @manager.expects(:active_alarms_for).with(p_alarm.measure_id).returns( [RRDNotifier::AlarmTooHigh.new(p_alarm, 10)] )
+      
+      @manager.expects(:raise_alarm).never
+      @manager.expects(:stop_specific_alarm).with( p_normal.measure_id, kind_of(RRDNotifier::AlarmTooHigh) )
+    
+      @manager.packet_received(p_normal)
+    end
+  end
+  
+  describe 'a trigger on clock drift' do
+    before do
+      @manager.stubs(:send_gauge)
+      @manager.register_alarm('*', "memory/*", "memory/active",
+          :monitor_drift => 30 # allow 30s of drift
+        )
+    end
+    
+    should 'raise an alarm if time difference is higher than threshold' do
+      p = Factory(:data_point, :time => Time.now - 60, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+      @manager.expects(:raise_alarm).with(p.measure_id,  kind_of(RRDNotifier::AlarmClockDrift) )
+    
+      @manager.packet_received(p)
+      
+      p = Factory(:data_point, :time => Time.now + 60, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+      @manager.expects(:raise_alarm).with(p.measure_id,  kind_of(RRDNotifier::AlarmClockDrift) )
+    
+      @manager.packet_received(p)
+    end
+    
+    should 'not raise an alarm if time difference is below the threshold' do
+      p = Factory(:data_point, :time => Time.now - 20, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+      @manager.expects(:raise_alarm).never
+    
+      @manager.packet_received(p)
+      
+      p = Factory(:data_point, :time => Time.now + 20, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+      @manager.expects(:raise_alarm).never
+    
+      @manager.packet_received(p)
+    end
+    
+    should 'not reraise another alarm if time difference stays above the threshold' do
+      p_alarm = Factory(:data_point, :time => Time.now - 60, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [81])
+      p_alarm2 = Factory(:data_point, :time => Time.now - 50, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [81])
+      
+      @manager.expects(:active_alarms_for).with(p_alarm.measure_id).returns( [RRDNotifier::AlarmClockDrift.new(p_alarm, 30)] )
+      @manager.expects(:raise_alarm).never
+      
+      @manager.packet_received(p_alarm2)
+    end
+    
+    should 'stop the alarm if time difference moves below the threshold' do
+      p_alarm = Factory(:data_point, :time => Time.now - 60, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [81])
+      p_normal = Factory(:data_point, :time => Time.now - 10, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [81])
+      
+      @manager.expects(:active_alarms_for).with(p_alarm.measure_id).returns( [RRDNotifier::AlarmClockDrift.new(p_alarm, 30)] )
+      
+      @manager.expects(:raise_alarm).never
+      @manager.expects(:stop_specific_alarm).with( p_normal.measure_id, kind_of(RRDNotifier::AlarmClockDrift) )
+    
+      @manager.packet_received(p_normal)
+    end
+    
+  end
+  
+  describe 'a trigger on presence' do
+    before do
+      @interval = 0.5 # seconds
+      @manager.register_alarm('*', "memory/*", "memory/active",
+          :monitor_presence => @interval
+        )
+    end
+    
+    should 'raise an alarm if value is missing for more than the threshold' do
+      p = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+      
+      # force the timer to be called
+      EM::expects(:add_timer).with(@interval).yields()
+      
+      @manager.expects(:raise_alarm).with(p.measure_id, kind_of(RRDNotifier::AlarmMissingData) )
+      @manager.packet_received(p)
+    end
+    
+    should 'not raise an alarm is value missing for less than the threshold' do
+      p = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+      
+      # catch the timer creation but do not execute its callback
+      EM::expects(:add_timer).with(@interval)
+      
+      @manager.expects(:raise_alarm).never
+      @manager.packet_received(p)
+    end
+    
+    should 'stop the alarm when a value is received' do
+      p_alarm = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+      p_normal = Factory(:data_point, :plugin => "memory", :type => "memory", :type_instance => "active", :values => [8])
+      
+      alarm_time = Time.now - 60
+      @manager.stubs(:last_update_for).with(p_alarm.measure_id).returns(alarm_time)
+      
+      
+      # catch the timer creation and execute the calback to raise an alarm
+      timer_id = stub()
+      EM::expects(:add_timer).with(@interval).yields.returns(timer_id).once
+      @manager.expects(:raise_alarm).with(p_alarm.measure_id, kind_of(RRDNotifier::AlarmMissingData) )
+      @manager.packet_received(p_alarm)
+      
+      
+      EM::expects(:cancel_timer).with(timer_id)
+      EM::expects(:add_timer).with(@interval)
+      @manager.expects(:active_alarms_for).with(p_alarm.measure_id).returns( [RRDNotifier::AlarmMissingData.new(p_alarm, @interval, alarm_time)] )
+      @manager.expects(:stop_specific_alarm).with( p_normal.measure_id, kind_of(RRDNotifier::AlarmMissingData) )
+      @manager.expects(:raise_alarm).never
+          
+      @manager.packet_received(p_normal)
+    end
+    
+  end
+  
+end

data/spec/unit/alarm_trigger_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../common', __FILE__)
+require File.expand_path('../../../lib/rrd-grapher/notifier/alarm_trigger', __FILE__)
+
+describe 'AlarmTrigger' do
+  it 'can can parse initialize parameters' do
+    RRDNotifier::AlarmTrigger.load_param("*").should == nil
+    RRDNotifier::AlarmTrigger.load_param("memory").should == "memory"
+    RRDNotifier::AlarmTrigger.load_param("memory/*").should == ["memory", nil]
+    RRDNotifier::AlarmTrigger.load_param("*/*").should == [nil, nil]
+    RRDNotifier::AlarmTrigger.load_param("*/memory").should == [nil, "memory"]
+  end
+  
+  it 'can handle packets with multiple counters' do
+    manager = stub('manager', :active_alarm? => nil)
+    trigger = RRDNotifier::AlarmTrigger.new(manager, "*", "*/*", "*/*", :max => 10, :index => 1)
+    
+    # we are not testing matching code, bypass
+    trigger.expects(:match?).returns(true)
+    p = Factory(:data_point, :values => [1, 45, 5])
+    
+    manager.expects(:raise_alarm).with(p.measure_id, kind_of(RRDNotifier::Alarm))
+    trigger.check_alarms(p)
+  end
+end
+
+

data/spec/unit/data_struct_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path('../../common', __FILE__)
+require File.expand_path('../../../lib/rrd-grapher/notifier/data_struct', __FILE__)
+
+describe 'DataStruct' do
+  before do
+    @s1 = Class.new(DataStruct) do
+      properties :one, :two
+    end
+    
+    @s2 = Class.new(DataStruct) do
+      properties :name, :host
+    end
+  end
+  
+  should 'have disctinct attributes set for each child class' do
+    @s1.attributes.should == [:one, :two]
+    @s2.attributes.should == [:name, :host]
+  end
+  
+  it "can merge data from multiple Hash sources" do
+    obj = @s1.new(:one => 12)
+    obj.merge_data_from(:two => 34, :one => nil)
+    
+    obj.one.should == 12
+    obj.two.should == 34
+  end
+  
+  it "can merge data from multiple Object sources" do
+    dummy_class = Struct.new(:one, :two)
+    
+    d1 = dummy_class.new(23)
+    d2 = dummy_class.new(nil, 56)
+    
+    obj = @s1.new(d1)
+    obj.merge_data_from(d2)
+    
+    obj.one.should == 23
+    obj.two.should == 56
+  end
+  
+  it "can merge data selectively from multiple Object sources" do
+    dummy_class = Struct.new(:one, :two)
+    
+    d1 = dummy_class.new(23)
+    d2 = dummy_class.new(67, 56)
+    
+    obj = @s1.new(d1)
+    obj.merge_data_from(d2, [:two])
+    
+    obj.one.should == 23
+    obj.two.should == 56
+  end
+  
+end
+

data/spec/unit/notifier_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../../common', __FILE__)
+require File.expand_path('../../../lib/rrd-grapher/notifier', __FILE__)
+
+# require 'eventmachine'
+
+describe 'Notifier::Server' do
+  should 'bind an udp socket on start' do
+    EM::expects(:open_datagram_socket).with('local', 7777, RRDNotifier::Server, kind_of(RRDNotifier::AlarmManager), nil, nil)
+    RRDNotifier::Server.start(:host => 'local', :port => 7777)
+  end
+  
+  should 'raise an error on unknown constructor option' do
+    err = proc{
+      RRDNotifier::Server.start(:i_am_invalid => "yes really !")
+    }.should.raise()
+    err.message.should.include?("Unknown arguments")
+  end
+  
+  describe 'an existing notifier' do
+    before do
+      @alarm_manager = stub('alarm_manager')
+      
+      EM::stubs(:open_datagram_socket)
+      @notifier = RRDNotifier::Server.new(nil, @alarm_manager)
+    end
+    
+    should "delegate register_alarm to the alarm manager" do
+      @alarm_manager.expects(:register_alarm).with(12, "a useless message")
+      @notifier.register_alarm(12, "a useless message")
+    end
+    
+    should 'dispatch parsed packets when data is received' do
+      data = ""
+      packets = [ Factory(:data_point), Factory(:data_point), Factory(:notification) ]
+      
+      @alarm_manager.expects(:packet_received).with(packets[0])
+      @alarm_manager.expects(:packet_received).with(packets[1])
+      @alarm_manager.expects(:packet_received).with(packets[2])
+      
+      RRDNotifier::RubyParser::expects(:parse).with(data).returns(packets)
+      @notifier.receive_data(data)
+    end
+  end
+  
+end

data/spec/unit/parsers/bindata_parser_spec.rb

@@ -0,0 +1,184 @@
+require File.expand_path('../../../common', __FILE__)
+require File.expand_path('../../../../lib/rrd-grapher/notifier/parsers/bindata_parser', __FILE__)
+
+# as helper to build packets
+require File.expand_path('../../../helpers/collectdrb', __FILE__)
+
+describe 'Collectd Bindata parser' do
+  describe 'Simple packets' do
+    before do
+      @parser = RRDNotifier::BindataParser::Part.new
+    end
+    
+    it 'can parse numbers' do
+      data = @parser.read( Collectd::number(1, 122) )
+      data.get_value.should == 122
+      
+      data = @parser.read( Collectd::number(1, -2500) )
+      data.get_value.should == -2500
+      
+      data = @parser.read( Collectd::number(1, 356798) )
+      data.get_value.should == 356798
+    end
+    
+    should 'parse strings' do
+      data = @parser.read( Collectd::string(0, "hostname1") )
+      data.get_value.should == 'hostname1'
+      
+      data = @parser.read( Collectd::string(0, "string with spaces") )
+      data.get_value.should == 'string with spaces'
+      
+      data = @parser.read( Collectd::string(0, "a really long string with many words in it") )
+      data.get_value.should == 'a really long string with many words in it'
+    end
+  end
+  
+  describe 'One notification in buffer' do
+    before do
+      @now = Time.new.to_i
+      
+      @pkt = ""
+      @pkt << Collectd.number(1, @now)
+      @pkt << Collectd.string(0, 'hostname')
+         
+      @pkt << Collectd.string(2, 'plugin')
+      @pkt << Collectd.string(3, 'plugin_inst')
+      @pkt << Collectd.string(4, 'type')
+      @pkt << Collectd.string(5, 'type_inst')
+      @pkt << Collectd.number(257, 2) # severity
+      @pkt << Collectd.string(256, 'a message')
+    end
+    
+    should 'parse the notification' do
+      data = RRDNotifier::BindataParser.parse(@pkt)
+      
+      data.size.should == 1
+      
+      data[0].class.should            == RRDNotifier::Packet
+      data[0].host.should             == 'hostname'
+      data[0].time.should             == @now
+      data[0].plugin.should           == 'plugin'
+      data[0].plugin_instance.should  == 'plugin_inst'
+      data[0].type.should             == 'type'
+      data[0].type_instance.should    == 'type_inst'
+      data[0].message.should          == 'a message'
+      data[0].severity.should         == 2
+      
+    end
+  end
+  
+  describe 'One packet in buffer' do
+    before do
+      @now = Time.new.to_i
+      @interval = 10
+      @pkt = ""
+      @pkt << Collectd.number(1, @now)
+      @pkt << Collectd.string(0, 'hostname')
+      @pkt << Collectd.number(7, @interval)
+         
+      @pkt << Collectd.string(2, 'plugin')
+      @pkt << Collectd.string(3, 'plugin_inst')
+      @pkt << Collectd.string(4, 'type')
+      @pkt << Collectd.string(5, 'type_inst')
+      
+      @pkt << Collectd.values([[:counter, 1034], [:gauge, 3.45]])
+    end
+    
+    should 'parse it' do
+      data = nil
+      # BinData::trace_reading do
+        data = RRDNotifier::BindataParser.parse(@pkt)
+      # end
+      
+      data.size.should == 1
+      
+      data[0].class.should            == RRDNotifier::Packet
+      data[0].host.should             == 'hostname'
+      data[0].time.should             == @now
+      data[0].interval.should         == @interval
+      data[0].plugin.should           == 'plugin'
+      data[0].plugin_instance.should  == 'plugin_inst'
+      data[0].type.should             == 'type'
+      data[0].type_instance.should    == 'type_inst'
+      
+      data[0].values.size.should      == 2
+      data[0].values[0].should        == 1034
+      data[0].values[1].should        == 3.45
+    end
+  end
+  
+  describe "Multiple packets in buffer" do
+     before do
+       @now = Time.new.to_i
+       @interval = 10
+   
+       @pkt = Collectd.string(0, 'hostname')
+       @pkt << Collectd.number(1, @now)
+       @pkt << Collectd.number(7, @interval)
+          
+       @pkt << Collectd.string(2, 'plugin')
+       @pkt << Collectd.string(3, 'plugin_inst')
+       @pkt << Collectd.string(4, 'type')
+       @pkt << Collectd.string(5, 'type_inst')
+       
+       @pkt << Collectd.values([[:counter, 1034], [:gauge, 3.45]])
+       
+       @pkt << Collectd.string(2, 'plugin2')
+       @pkt << Collectd.string(3, 'plugin2_inst')
+       @pkt << Collectd.string(4, 'type2')
+       @pkt << Collectd.string(5, 'type2_inst')
+       
+       @pkt << Collectd.values([[:counter, 42]])
+  
+       
+       @pkt << Collectd.string(5, 'type21_inst')
+       @pkt << Collectd.values([[:gauge, 3.1415927]])
+     end
+     
+     should 'parse it' do
+       data = nil
+       # BinData::trace_reading do
+         data = RRDNotifier::BindataParser.parse(@pkt)
+       # end
+       
+       data.size.should == 3
+       
+       data[0].class.should == RRDNotifier::Packet
+       
+       # data.packets.size.should == 8
+       
+       data[0].host.should              == 'hostname'
+       data[0].time.should              == @now
+       data[0].interval.should          == @interval
+       data[0].plugin.should            == 'plugin'
+       data[0].plugin_instance.should   == 'plugin_inst'
+       data[0].type.should              == 'type'
+       data[0].type_instance.should     == 'type_inst'
+       data[0].values.size.should       == 2
+       data[0].values[0].should         == 1034
+       data[0].values[1].should         == 3.45
+       
+       data[1].host.should              == 'hostname'
+       data[1].time.should              == @now
+       data[1].interval.should          == @interval
+       data[1].plugin.should            == 'plugin2'
+       data[1].plugin_instance.should   == 'plugin2_inst'
+       data[1].type.should              == 'type2'
+       data[1].type_instance.should     == 'type2_inst'
+       data[1].values.size.should       == 1
+       data[1].values[0].should         == 42
+       
+       data[2].host.should              == 'hostname'
+       data[2].time.should              == @now
+       data[2].interval.should          == @interval
+       data[2].plugin.should            == 'plugin2'
+       data[2].plugin_instance.should   == 'plugin2_inst'
+       data[2].type.should              == 'type2'
+       data[2].type_instance.should     == 'type21_inst'
+       data[2].values.size.should       == 1
+       data[2].values[0].should         == 3.1415927
+       
+     end
+   end
+  
+end