flapjack 1.2.1 → 1.2.2

data/lib/flapjack/processor.rb

@@ -226,7 +226,9 @@ module Flapjack
 
         entity_check.update_state(event.state, :timestamp => timestamp,
                                   :summary => event.summary, :count => event.counter,
-                                  :details => event.details, :perfdata => event.perfdata)
+                                  :details => event.details, :perfdata => event.perfdata,
+                                  :initial_failure_delay => event.initial_failure_delay,
+                                  :repeat_failure_delay => event.repeat_failure_delay)
 
         entity_check.update_current_scheduled_maintenance
 

data/lib/flapjack/redis_pool.rb

@@ -27,6 +27,8 @@ module Flapjack
           :logger => logger)
         Flapjack::Data::Migration.create_entity_ids_if_required(:redis => redis,
           :logger => logger)
+        Flapjack::Data::Migration.clear_orphaned_entity_ids(:redis => redis,
+          :logger => logger)
         Flapjack::Data::Migration.refresh_archive_index(:redis => redis)
         Flapjack::Data::Migration.validate_scheduled_maintenance_periods(:redis => redis,
           :logger => logger)

data/lib/flapjack/version.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
 module Flapjack
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end
 

data/spec/lib/flapjack/data/contact_spec.rb

@@ -22,8 +22,8 @@ describe Flapjack::Data::Contact, :redis => true do
      :tags               => Set.new([]),
      :time_restrictions  => [],
      :unknown_media      => [],
-     :warning_media      => ['email', 'sms', 'sms_twilio', 'jabber', 'pagerduty', 'sns'],
-     :critical_media     => ['email', 'sms', 'sms_twilio', 'jabber', 'pagerduty', 'sns'],
+     :warning_media      => ['email', 'sms', 'sms_twilio', 'sms_gammu', 'jabber', 'pagerduty', 'sns'],
+     :critical_media     => ['email', 'sms', 'sms_twilio', 'sms_gammu', 'jabber', 'pagerduty', 'sns'],
      :unknown_blackhole  => false,
      :warning_blackhole  => false,
      :critical_blackhole => false}

data/spec/lib/flapjack/data/entity_spec.rb

@@ -223,6 +223,8 @@ describe Flapjack::Data::Entity, :redis => true do
                                    :redis       => @redis)
     end
 
+    context 'check that rename and merge are called by add'
+
     context 'entity renaming on #add' do
 
       let(:time_i) { Time.now.to_i }
@@ -490,6 +492,19 @@ describe Flapjack::Data::Entity, :redis => true do
         add_name2
       end
 
+      it 'clears the old id when a name exists' do
+        expect(@redis.hget('all_entity_ids_by_name', 'name2')).to eq('5000')
+        expect(@redis.hget('all_entity_names_by_id', '5000')).to eq('name2')
+
+        Flapjack::Data::Entity.add({'id'   => '5001',
+                                    'name' => 'name2'},
+                                    :redis => @redis)
+
+        expect(@redis.hget('all_entity_ids_by_name', 'name2')).to eq('5001')
+        expect(@redis.hget('all_entity_names_by_id', '5000')).to be_nil
+        expect(@redis.hget('all_entity_names_by_id', '5001')).to eq('name2')
+      end
+
       it 'does not overwrite current state for a check' do
         add_state1
         data_2 = {'state' => 'critical', 'last_change' => time_2_i.to_s, 'last_update' => time_2_i.to_s}

data/spec/lib/flapjack/data/event_spec.rb

@@ -101,7 +101,7 @@ describe Flapjack::Data::Event do
       expect(result).to be_nil
     end
 
-    ['type', 'state', 'entity', 'check', 'summary'].each do |required_key|
+    ['type', 'state', 'entity', 'check'].each do |required_key|
 
       it "rejects an event with missing '#{required_key}' key (archiving)" do
         bad_event_data = event_data.clone
@@ -168,7 +168,7 @@ describe Flapjack::Data::Event do
       end
     end
 
-    ['time', 'details', 'perfdata', 'acknowledgement_id', 'duration', 'tags'].each do |optional_key|
+    ['time', 'summary', 'details', 'perfdata', 'acknowledgement_id', 'duration', 'tags'].each do |optional_key|
       it "rejects an event with invalid '#{optional_key}' key (archiving)" do
         bad_event_data = event_data.clone
         bad_event_data[optional_key] = {'hello' => 'there'}

data/spec/lib/flapjack/data/migration_spec.rb

@@ -4,6 +4,17 @@ require 'flapjack/data/notification_rule'
 
 describe Flapjack::Data::Migration, :redis => true do
 
+  it 'removes an orphaned entity id' do
+    @redis.hset('all_entity_ids_by_name', 'name_1', 'id_2')
+    @redis.hset('all_entity_names_by_id', 'id_1', 'name_1')
+    @redis.hset('all_entity_names_by_id', 'id_2', 'name_1')
+
+    Flapjack::Data::Migration.clear_orphaned_entity_ids(:redis => @redis)
+
+    expect(@redis.hgetall('all_entity_ids_by_name')).to eq('name_1' => 'id_2')
+    expect(@redis.hgetall('all_entity_names_by_id')).to eq('id_2' => 'name_1')
+  end
+
   it "fixes a notification rule wih no contact association" do
     contact = Flapjack::Data::Contact.add( {
         'id'         => 'c362',

data/spec/lib/flapjack/gateways/aws_sns_spec.rb

@@ -5,6 +5,8 @@ describe Flapjack::Gateways::AwsSns, :logger => true do
 
   let(:lock) { double(Monitor) }
 
+  let(:redis) { double('redis') }
+
   let(:time) { Time.new(2013, 10, 31, 13, 45) }
 
   let(:time_str) { Time.at(time).strftime('%-d %b %H:%M') }
@@ -41,10 +43,11 @@ describe Flapjack::Gateways::AwsSns, :logger => true do
       to_return(:status => 200)
 
     EM.synchrony do
-      Flapjack::Gateways::AwsSns.instance_variable_set('@config', config)
-      Flapjack::Gateways::AwsSns.instance_variable_set('@logger', @logger)
-      Flapjack::Gateways::AwsSns.start
-      Flapjack::Gateways::AwsSns.perform(message)
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
+      aws_sns = Flapjack::Gateways::AwsSns.new(:config => config, :logger => @logger)
+      aws_sns.deliver(alert)
       EM.stop
     end
     expect(req).to have_been_requested
@@ -52,10 +55,11 @@ describe Flapjack::Gateways::AwsSns, :logger => true do
 
   it "does not send an SMS message with an invalid config" do
     EM.synchrony do
-      Flapjack::Gateways::AwsSns.instance_variable_set('@config', config.reject {|k, v| k == 'secret_key'})
-      Flapjack::Gateways::AwsSns.instance_variable_set('@logger', @logger)
-      Flapjack::Gateways::AwsSns.start
-      Flapjack::Gateways::AwsSns.perform(message)
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
+      aws_sns = Flapjack::Gateways::AwsSns.new(:config => config.reject {|k, v| k == 'secret_key'}, :logger => @logger)
+      aws_sns.deliver(alert)
       EM.stop
     end
 

data/spec/lib/flapjack/gateways/email_spec.rb

@@ -3,21 +3,21 @@ require 'flapjack/gateways/email'
 
 describe Flapjack::Gateways::Email, :logger => true do
 
-  it "can have a custom from email address" do
-    email = double('email')
-    redis = double('redis')
+  let(:client) { double('client') }
+  let(:redis) { double('redis') }
 
+  it "can have a custom from email address" do
     expect(EM::P::SmtpClient).to receive(:send).with(
       hash_including(host: 'localhost',
                      port: 25,
                      from: "from@example.org")
-    ).and_return(email)
+    ).and_return(client)
 
     response = double(response)
     expect(response).to receive(:"respond_to?").with(:code).and_return(true)
     expect(response).to receive(:code).and_return(250)
 
-    expect(EM::Synchrony).to receive(:sync).with(email).and_return(response)
+    expect(EM::Synchrony).to receive(:sync).with(client).and_return(response)
 
     notification = {'notification_type'   => 'recovery',
                     'contact_first_name'  => 'John',
@@ -31,28 +31,29 @@ describe Flapjack::Gateways::Email, :logger => true do
                     'event_id'            => 'example.com:ping'}
 
     config = {"smtp_config" => {'from' => 'from@example.org'}}
-    Flapjack::Gateways::Email.instance_variable_set('@config', config)
-    Flapjack::Gateways::Email.instance_variable_set('@redis', redis)
-    Flapjack::Gateways::Email.instance_variable_set('@logger', @logger)
-    Flapjack::Gateways::Email.start
-    Flapjack::Gateways::Email.perform(notification)
+
+    EM.synchrony do
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(notification, :logger => @logger)
+      email = Flapjack::Gateways::Email.new(:config => config, :logger => @logger)
+      email.deliver(alert)
+      EM.stop
+    end
   end
 
   it "can have a full name in custom from email address" do
-    email = double('email')
-    redis = double('redis')
-
     expect(EM::P::SmtpClient).to receive(:send).with(
       hash_including(host: 'localhost',
                      port: 25,
                      from: "from@example.org")
-    ).and_return(email)
+    ).and_return(client)
 
     response = double(response)
     expect(response).to receive(:"respond_to?").with(:code).and_return(true)
     expect(response).to receive(:code).and_return(250)
 
-    expect(EM::Synchrony).to receive(:sync).with(email).and_return(response)
+    expect(EM::Synchrony).to receive(:sync).with(client).and_return(response)
 
     notification = {'notification_type'   => 'recovery',
                     'contact_first_name'  => 'John',
@@ -66,17 +67,18 @@ describe Flapjack::Gateways::Email, :logger => true do
                     'event_id'            => 'example.com:ping'}
 
     config = {"smtp_config" => {'from' => 'Full Name <from@example.org>'}}
-    Flapjack::Gateways::Email.instance_variable_set('@config', config)
-    Flapjack::Gateways::Email.instance_variable_set('@redis', redis)
-    Flapjack::Gateways::Email.instance_variable_set('@logger', @logger)
-    Flapjack::Gateways::Email.start
-    Flapjack::Gateways::Email.perform(notification)
+
+    EM.synchrony do
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(notification, :logger => @logger)
+      email = Flapjack::Gateways::Email.new(:config => config, :logger => @logger)
+      email.deliver(alert)
+      EM.stop
+    end
   end
 
   it "can have a custom reply-to address" do
-    email = double('email')
-    redis = double('redis')
-
     expect(EM::P::SmtpClient).to receive(:send) { |message|
       # NOTE No access to headers directly. Must be determined from message content
       expect( message[:content] ).to include("Reply-To: reply-to@example.com")
@@ -84,13 +86,13 @@ describe Flapjack::Gateways::Email, :logger => true do
       expect( message[:host] ).to eql('localhost')
       expect( message[:port] ).to eql(25)
       expect( message[:from] ).to eql('from@example.org')
-    }.and_return(email)
+    }.and_return(client)
 
     response = double(response)
     expect(response).to receive(:"respond_to?").with(:code).and_return(true)
     expect(response).to receive(:code).and_return(250)
 
-    expect(EM::Synchrony).to receive(:sync).with(email).and_return(response)
+    expect(EM::Synchrony).to receive(:sync).with(client).and_return(response)
 
     notification = {'notification_type'   => 'recovery',
                     'contact_first_name'  => 'John',
@@ -105,27 +107,27 @@ describe Flapjack::Gateways::Email, :logger => true do
 
     config = {"smtp_config" => {'from' => 'from@example.org', 'reply_to' => 'reply-to@example.com'}}
 
-    Flapjack::Gateways::Email.instance_variable_set('@config', config)
-    Flapjack::Gateways::Email.instance_variable_set('@redis', redis)
-    Flapjack::Gateways::Email.instance_variable_set('@logger', @logger)
-    Flapjack::Gateways::Email.start
-    Flapjack::Gateways::Email.perform(notification)
+    EM.synchrony do
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(notification, :logger => @logger)
+      email = Flapjack::Gateways::Email.new(:config => config, :logger => @logger)
+      email.deliver(alert)
+      EM.stop
+    end
   end
 
   it "must default to from address if no reply-to given" do
-    email = double('email')
-    redis = double('redis')
-
     expect(EM::P::SmtpClient).to receive(:send) { |message|
       # NOTE No access to headers directly. Must be determined from message content
       expect( message[:content] ).to include("Reply-To: from@example.org")
-    }.and_return(email)
+    }.and_return(client)
 
     response = double(response)
     expect(response).to receive(:"respond_to?").with(:code).and_return(true)
     expect(response).to receive(:code).and_return(250)
 
-    expect(EM::Synchrony).to receive(:sync).with(email).and_return(response)
+    expect(EM::Synchrony).to receive(:sync).with(client).and_return(response)
 
     notification = {'notification_type'   => 'recovery',
                     'contact_first_name'  => 'John',
@@ -140,31 +142,31 @@ describe Flapjack::Gateways::Email, :logger => true do
 
     config = {"smtp_config" => {'from' => 'from@example.org'}}
 
-    Flapjack::Gateways::Email.instance_variable_set('@config', config)
-    Flapjack::Gateways::Email.instance_variable_set('@redis', redis)
-    Flapjack::Gateways::Email.instance_variable_set('@logger', @logger)
-    Flapjack::Gateways::Email.start
-    Flapjack::Gateways::Email.perform(notification)
+    EM.synchrony do
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(notification, :logger => @logger)
+      email = Flapjack::Gateways::Email.new(:config => config, :logger => @logger)
+      email.deliver(alert)
+      EM.stop
+    end
   end
 
   it "sends a mail with text, html parts and default from address" do
-    email = double('email')
-
     entity_check = double(Flapjack::Data::EntityCheck)
-    redis = double('redis')
 
     # TODO better checking of what gets passed here
     expect(EM::P::SmtpClient).to receive(:send).with(
       hash_including(:host    => 'localhost',
                      :port    => 25,
                      :from    => "flapjack@example.com"
-                    )).and_return(email)
+                    )).and_return(client)
 
     response = double(response)
     expect(response).to receive(:"respond_to?").with(:code).and_return(true)
     expect(response).to receive(:code).and_return(250)
 
-    expect(EM::Synchrony).to receive(:sync).with(email).and_return(response)
+    expect(EM::Synchrony).to receive(:sync).with(client).and_return(response)
 
     notification = {'notification_type'   => 'recovery',
                     'contact_first_name'  => 'John',
@@ -177,12 +179,15 @@ describe Flapjack::Gateways::Email, :logger => true do
                     'time'                => Time.now.to_i,
                     'event_id'            => 'example.com:ping'}
 
-    Flapjack::Gateways::Email.instance_variable_set('@config', {})
-    Flapjack::Gateways::Email.instance_variable_set('@redis', redis)
-    Flapjack::Gateways::Email.instance_variable_set('@logger', @logger)
-    Flapjack::Gateways::Email.start
-    Flapjack::Gateways::Email.instance_variable_set('@fqdn', "example.com")
-    Flapjack::Gateways::Email.perform(notification)
+    EM.synchrony do
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(notification, :logger => @logger)
+      email = Flapjack::Gateways::Email.new(:config => {}, :logger => @logger)
+      email.instance_variable_set('@fqdn', "example.com")
+      email.deliver(alert)
+      EM.stop
+    end
   end
 
 end

data/spec/lib/flapjack/gateways/sms_messagenet_spec.rb

@@ -5,6 +5,8 @@ describe Flapjack::Gateways::SmsMessagenet, :logger => true do
 
   let(:lock) { double(Monitor) }
 
+  let(:redis) { double('redis') }
+
   let(:config) { {'username'  => 'user',
                   'password'  => 'password'
                  }
@@ -39,10 +41,11 @@ describe Flapjack::Gateways::SmsMessagenet, :logger => true do
       to_return(:status => 200)
 
     EM.synchrony do
-      Flapjack::Gateways::SmsMessagenet.instance_variable_set('@config', config)
-      Flapjack::Gateways::SmsMessagenet.instance_variable_set('@logger', @logger)
-      Flapjack::Gateways::SmsMessagenet.start
-      Flapjack::Gateways::SmsMessagenet.perform(message)
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
+      sms_messagenet = Flapjack::Gateways::SmsMessagenet.new(:config => config, :logger => @logger)
+      sms_messagenet.deliver(alert)
       EM.stop
     end
     expect(req).to have_been_requested
@@ -64,10 +67,11 @@ describe Flapjack::Gateways::SmsMessagenet, :logger => true do
       to_return(:status => 200)
 
     EM.synchrony do
-      Flapjack::Gateways::SmsMessagenet.instance_variable_set('@config', config)
-      Flapjack::Gateways::SmsMessagenet.instance_variable_set('@logger', @logger)
-      Flapjack::Gateways::SmsMessagenet.start
-      Flapjack::Gateways::SmsMessagenet.perform(long_msg)
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(long_msg, :logger => @logger)
+      sms_messagenet = Flapjack::Gateways::SmsMessagenet.new(:config => config, :logger => @logger)
+      sms_messagenet.deliver(alert)
       EM.stop
     end
     expect(req).to have_been_requested
@@ -75,10 +79,11 @@ describe Flapjack::Gateways::SmsMessagenet, :logger => true do
 
   it "does not send an SMS message with an invalid config" do
     EM.synchrony do
-      Flapjack::Gateways::SmsMessagenet.instance_variable_set('@config', config.reject {|k, v| k == 'password'})
-      Flapjack::Gateways::SmsMessagenet.instance_variable_set('@logger', @logger)
-      Flapjack::Gateways::SmsMessagenet.start
-      Flapjack::Gateways::SmsMessagenet.perform(message)
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
+      sms_messagenet = Flapjack::Gateways::SmsMessagenet.new(:config => config.reject {|k, v| k == 'password'}, :logger => @logger)
+      sms_messagenet.deliver(alert)
       EM.stop
     end
 

data/spec/lib/flapjack/gateways/sms_twilio_spec.rb

@@ -5,6 +5,8 @@ describe Flapjack::Gateways::SmsTwilio, :logger => true do
 
   let(:lock) { double(Monitor) }
 
+  let(:redis) { double('redis') }
+
   let(:config) { {'account_sid'  => 'the_account_sid',
                   'auth_token'   => 'the_auth_token',
                   'from'         => 'the_from_address'
@@ -36,10 +38,11 @@ describe Flapjack::Gateways::SmsTwilio, :logger => true do
       to_return(:status => 201)
 
     EM.synchrony do
-      Flapjack::Gateways::SmsTwilio.instance_variable_set('@config', config)
-      Flapjack::Gateways::SmsTwilio.instance_variable_set('@logger', @logger)
-      Flapjack::Gateways::SmsTwilio.start
-      Flapjack::Gateways::SmsTwilio.perform(message)
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
+      sms_twilio = Flapjack::Gateways::SmsTwilio.new(:config => config, :logger => @logger)
+      sms_twilio.deliver(alert)
       EM.stop
     end
     expect(req).to have_been_requested
@@ -63,10 +66,11 @@ describe Flapjack::Gateways::SmsTwilio, :logger => true do
       to_return(:status => 200)
 
     EM.synchrony do
-      Flapjack::Gateways::SmsTwilio.instance_variable_set('@config', config)
-      Flapjack::Gateways::SmsTwilio.instance_variable_set('@logger', @logger)
-      Flapjack::Gateways::SmsTwilio.start
-      Flapjack::Gateways::SmsTwilio.perform(long_msg)
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(long_msg, :logger => @logger)
+      sms_twilio = Flapjack::Gateways::SmsTwilio.new(:config => config, :logger => @logger)
+      sms_twilio.deliver(alert)
       EM.stop
     end
     expect(req).to have_been_requested
@@ -74,10 +78,11 @@ describe Flapjack::Gateways::SmsTwilio, :logger => true do
 
   it "does not send an SMS message with an invalid config" do
     EM.synchrony do
-      Flapjack::Gateways::SmsTwilio.instance_variable_set('@config', config.reject {|k, v| k == 'auth_token'})
-      Flapjack::Gateways::SmsTwilio.instance_variable_set('@logger', @logger)
-      Flapjack::Gateways::SmsTwilio.start
-      Flapjack::Gateways::SmsTwilio.perform(message)
+      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
+      sms_twilio = Flapjack::Gateways::SmsTwilio.new(:config => config.reject {|k, v| k == 'auth_token'}, :logger => @logger)
+      sms_twilio.deliver(alert)
       EM.stop
     end