flapjack 1.0.0rc3 → 1.0.0rc5

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

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'flapjack/gateways/aws_sns'
+
+describe Flapjack::Gateways::AwsSns, :logger => true do
+
+  let(:lock) { double(Monitor) }
+
+  let(:time) { Time.new(2013, 10, 31, 13, 45) }
+
+  let(:time_str) { Time.at(time).strftime('%-d %b %H:%M') }
+
+  let(:config) { {'region' => 'us-east-1',
+                  'access_key' => 'AKIAIOSFODNN7EXAMPLE',
+                  'secret_key' => 'secret'
+                 }
+               }
+
+  let(:message) { {'notification_type'  => 'recovery',
+                   'contact_first_name' => 'John',
+                   'contact_last_name'  => 'Smith',
+                   'state'              => 'ok',
+                   'summary'            => 'smile',
+                   'last_state'         => 'problem',
+                   'last_summary'       => 'frown',
+                   'time'               => time.to_i,
+                   'address'            => 'arn:aws:sns:us-east-1:698519295917:My-Topic',
+                   'event_id'           => 'example.com:ping',
+                   'id'                 => '123456789',
+                   'duration'           => 55,
+                   'state_duration'     => 23
+                  }
+                }
+
+  it "sends an SMS message" do
+    req = stub_request(:post, "http://sns.us-east-1.amazonaws.com/").
+      with(:query => hash_including({'Action'           => 'Publish',
+                                     'AWSAccessKeyId'   => config['access_key'],
+                                     'TopicArn'         => message['address'],
+                                     'SignatureVersion' => '2',
+                                     'SignatureMethod'  => 'HmacSHA256'})).
+      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)
+      EM.stop
+    end
+    expect(req).to have_been_requested
+  end
+
+  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)
+      EM.stop
+    end
+
+    expect(WebMock).not_to have_requested(:get, "http://sns.us-east-1.amazonaws.com/")
+  end
+
+  context "#string_to_sign" do
+
+    let(:method) { 'post' }
+
+    let(:host) { 'sns.us-east-1.AmazonAWS.com' }
+
+    let(:uri) { '/' }
+
+    let(:query) { {'TopicArn' => 'HelloWorld',
+                  'Action' => 'Publish'} }
+
+    let(:string_to_sign) { Flapjack::Gateways::AwsSns.string_to_sign(method, host, uri, query) }
+
+    let(:lines) { string_to_sign.split(/\n/) }
+
+    it 'should put the method on the first line' do
+      expect(lines[0]).to eq("POST")
+    end
+
+    it 'should put the downcased hostname on the second line' do
+      expect(lines[1]).to eq("sns.us-east-1.amazonaws.com")
+    end
+
+    it 'should put the URI on the third line' do
+      expect(lines[2]).to eq("/")
+    end
+
+    it 'should put the encoded, sorted query-string on the fourth line' do
+      expect(lines[3]).to eq("Action=Publish&TopicArn=HelloWorld")
+    end
+
+  end
+
+  context "#get_signature" do
+    let(:method) { 'GET' }
+
+    let(:host) { 'elasticmapreduce.amazonaws.com' }
+
+    let(:uri) { '/' }
+
+    let(:query) { {'AWSAccessKeyId' => 'AKIAIOSFODNN7EXAMPLE',
+                   'Action' => 'DescribeJobFlows',
+                   'SignatureMethod' => 'HmacSHA256',
+                   'SignatureVersion' => '2',
+                   'Timestamp' => '2011-10-03T15:19:30',
+                   'Version' => '2009-03-31'} }
+
+    let(:secret_key) { 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY' }
+
+    let(:string_to_sign) { Flapjack::Gateways::AwsSns.string_to_sign(method, host, uri, query) }
+
+    let(:signature) { Flapjack::Gateways::AwsSns.get_signature(secret_key, string_to_sign) }
+
+    it 'should HMAC-SHA256 and base64 encode the signature' do
+      expect(signature).to eq("i91nKc4PWAt0JJIdXwz9HxZCJDdiy6cf/Mj6vPxyYIs=")
+    end
+  end
+
+end

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

@@ -174,7 +174,7 @@ describe Flapjack::Gateways::Jabber, :logger => true do
 
     expect(EventMachine::Synchrony).to receive(:sleep).with(5).exactly(1).times
     expect(EventMachine::Synchrony).to receive(:sleep).with(2).exactly(3).times
-    expect(fj).to receive(:connect).exactly(4).times.and_return {
+    expect(fj).to receive(:connect).exactly(4).times {
       attempts +=1
       raise StandardError.new unless attempts > 3
     }

data/spec/lib/flapjack/gateways/jsonapi/check_methods_spec.rb

@@ -22,7 +22,7 @@ describe 'Flapjack::Gateways::JSONAPI::CheckMethods', :sinatra => true, :logger
     expect(entity_check).to receive(:entity).and_return(entity)
     expect(entity_check).to receive(:key).twice.and_return('PING')
     expect(entity_check).to receive(:to_jsonapi).and_return(check_data.to_json)
-    expect(Flapjack::Data::EntityCheck).to receive(:find_all).with(:redis => redis).
+    expect(Flapjack::Data::EntityCheck).to receive(:find_current).with(:redis => redis).
       and_return([entity_check])
 
     aget '/checks'

data/spec/lib/flapjack/gateways/jsonapi/entity_methods_spec.rb

@@ -22,7 +22,7 @@ describe 'Flapjack::Gateways::JSONAPI::EntityMethods', :sinatra => true, :logger
     expect(Flapjack::Data::Entity).to receive(:contact_ids_for).
       with([entity_core['id']], :redis => redis).and_return({})
     expect(entity).to receive(:to_jsonapi).and_return(entity_core.to_json)
-    expect(Flapjack::Data::Entity).to receive(:all).with(:redis => redis).
+    expect(Flapjack::Data::Entity).to receive(:all).with(:enabled => nil, :redis => redis).
       and_return([entity])
 
     aget '/entities'
@@ -38,7 +38,7 @@ describe 'Flapjack::Gateways::JSONAPI::EntityMethods', :sinatra => true, :logger
       with([entity_core['id']], :redis => redis).and_return({})
     expect(entity).to receive(:to_jsonapi).and_return(entity_core.to_json)
     expect(idless_entity).not_to receive(:to_jsonapi)
-    expect(Flapjack::Data::Entity).to receive(:all).with(:redis => redis).
+    expect(Flapjack::Data::Entity).to receive(:all).with(:enabled => nil, :redis => redis).
       and_return([entity, idless_entity])
 
     aget '/entities'

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

@@ -182,7 +182,7 @@ describe Flapjack::Gateways::Pagerduty, :logger => true do
 
     EM.synchrony do
       ret = fp.send(:send_pagerduty_event, evt)
-      expect { ret }.not_to be_nil
+      expect(ret).not_to be_nil
       expect(ret).to eq([200, nil])
       EM.stop
     end

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

@@ -7,7 +7,7 @@ describe Flapjack::Gateways::Web, :sinatra => true, :logger => true do
     Flapjack::Gateways::Web
   end
 
-  let(:entity_name)     { 'example.com'}
+  let(:entity_name)     { 'foo-app-01.example.com'}
   let(:entity_name_esc) { CGI.escape(entity_name) }
   let(:check)           { 'ping' }
 
@@ -30,20 +30,20 @@ describe Flapjack::Gateways::Web, :sinatra => true, :logger => true do
     expect(redis).to receive(:hgetall).twice.and_return({'all' => '8001', 'ok' => '8002'},
       {'all' => '9001', 'ok' => '9002'})
     expect(redis).to receive(:llen).with('events')
-    expect(redis).to receive(:zrange).with('current_entities', 0, -1).and_return(['foo-app-01.example.com'])
-    expect(redis).to receive(:zrange).with('current_checks:foo-app-01.example.com', 0, -1, {:withscores => true}).and_return([['ping', 1382329923.0]])
+    expect(Flapjack::Data::EntityCheck).to receive(:find_all_split_by_freshness).
+      and_return(30 => 3)
   end
 
   def expect_check_stats
-    expect(Flapjack::Data::EntityCheck).to receive(:count_all).
+    expect(Flapjack::Data::EntityCheck).to receive(:count_current).
       with(:redis => redis).and_return(1)
-    expect(Flapjack::Data::EntityCheck).to receive(:count_all_failing).
+    expect(Flapjack::Data::EntityCheck).to receive(:count_current_failing).
       with(:redis => redis).and_return(1)
   end
 
   def expect_entity_stats
-    expect(Flapjack::Data::Entity).to receive(:find_all_with_checks).
-      with(:redis => redis).and_return([entity_name])
+    expect(Flapjack::Data::Entity).to receive(:all).
+      with(:enabled => true, :redis => redis).and_return([entity_name])
     expect(Flapjack::Data::Entity).to receive(:find_all_with_failing_checks).
       with(:redis => redis).and_return([entity_name])
   end
@@ -87,7 +87,6 @@ describe Flapjack::Gateways::Web, :sinatra => true, :logger => true do
       logo_image_tag = '<img alt="Flapjack" class="logo" src="/img/branding.png">'
 
       aget '/self_stats'
-
       expect( last_response.body ).to include(logo_image_tag)
     end
 
@@ -121,14 +120,14 @@ describe Flapjack::Gateways::Web, :sinatra => true, :logger => true do
 
     it "shows a page listing all checks" do
       #redis.should_receive(:keys).with('*:*:states').and_return(["#{entity_name}:#{check}"])
-      expect(Flapjack::Data::EntityCheck).to receive(:find_all_by_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:find_current_by_entity).
         with(:redis => redis).and_return({entity_name => [check]})
       expect_check_stats
 
       expect_entity_check_status(entity_check)
 
       expect(Flapjack::Data::Entity).to receive(:find_by_name).
-        with(entity_name, :redis => redis).and_return(entity)
+        with(entity_name, hash_including(:redis => redis)).twice.and_return(entity)
 
       expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
         with(entity, 'ping', :redis => redis).and_return(entity_check)
@@ -147,7 +146,7 @@ describe Flapjack::Gateways::Web, :sinatra => true, :logger => true do
       expect(Flapjack::Data::Entity).to receive(:find_by_name).
         with(entity_name, :redis => redis).and_return(entity)
 
-      expect(Flapjack::Data::EntityCheck).to receive(:find_all_failing_by_entity).
+      expect(Flapjack::Data::EntityCheck).to receive(:find_current_failing_by_entity).
         with(:redis => redis).and_return({entity_name => [check]})
 
       expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
@@ -164,6 +163,7 @@ describe Flapjack::Gateways::Web, :sinatra => true, :logger => true do
       expect_entity_stats
 
       aget '/self_stats'
+      # p @logger.messages
       expect(last_response).to be_ok
     end
 

data/spec/support/profile_all_formatter.rb

@@ -2,32 +2,32 @@ require 'rspec/core/formatters/base_formatter'
 
 class ProfileAllFormatter < RSpec::Core::Formatters::BaseFormatter
 
+  RSpec::Core::Formatters.register self,
+    :example_started, :example_passed, :start_dump
+
   def initialize(output)
     super(output)
     @example_times = []
   end
 
-  def start(count)
-    super(count)
+  def start(notification)
+    super(notification)
     @output.puts "Profiling enabled."
   end
 
-  def example_started(example)
-    super(example)
+  def example_started(notification)
     @time = ((Time.respond_to?(:zone) && Time.zone) ? Time.zone.now : Time.now)
   end
 
-  def example_passed(example)
+  def example_passed(notification)
     @example_times << [
-      example_group.description,
-      example.description,
+      notification.example.example_group.description,
+      notification.example.description,
       ((Time.respond_to?(:zone) && Time.zone) ? Time.zone.now : Time.now) - @time
     ]
-    super(example)
   end
 
-  def start_dump
-    super
+  def start_dump(notification)
     @output.puts "\n\nExample times:\n"
 
     @example_times = @example_times.sort_by do |description, example, time|

data/spec/support/uncolored_doc_formatter.rb

@@ -1,9 +1,71 @@
-require 'rspec/core/formatters/documentation_formatter'
+require 'rspec/core/formatters/base_text_formatter'
 
-class UncoloredDocFormatter < RSpec::Core::Formatters::DocumentationFormatter
-
-  def color(text, color_code)
+module NoColorizer
+  def self.wrap(text, color)
     text
   end
+end
+
+class UncoloredDocFormatter < RSpec::Core::Formatters::BaseTextFormatter
+  RSpec::Core::Formatters.register self, :example_group_started, :example_group_finished,
+                                         :example_passed, :example_pending, :example_failed,
+                                         :dump_failures, :dump_pending, :dump_summary
+
+  def initialize(output)
+    super
+    @group_level = 0
+  end
+
+  def example_group_started(notification)
+    output.puts if @group_level == 0
+    output.puts "#{current_indentation}#{notification.group.description.strip}"
+
+    @group_level += 1
+  end
+
+  def example_group_finished(notification)
+    @group_level -= 1
+  end
+
+  def example_passed(passed)
+    output.puts "#{current_indentation}#{passed.example.description.strip}"
+  end
+
+  def example_pending(pending)
+    output.puts "#{current_indentation}#{pending.example.description.strip} (PENDING: #{pending.example.execution_result.pending_message})"
+  end
+
+  def example_failed(failure)
+    output.puts "#{current_indentation}#{failure.example.description.strip} (FAILED - #{next_failure_index})"
+  end
+
+  def dump_failures(notification)
+    return if notification.failure_notifications.empty?
+    output.puts notification.fully_formatted_failed_examples(NoColorizer)
+  end
+
+  def dump_pending(notification)
+    return if notification.pending_examples.empty?
+    output.puts notification.fully_formatted_pending_examples(NoColorizer)
+  end
+
+  def dump_summary(notification)
+    output.puts notification.fully_formatted(NoColorizer)
+  end
+
+private
+
+  def next_failure_index
+    @next_failure_index ||= 0
+    @next_failure_index += 1
+  end
+
+  def current_indentation
+    '  ' * @group_level
+  end
+
+  def example_group_chain
+    example_group.parent_groups.reverse
+  end
 
 end

data/src/flapjack/event.go

@@ -3,7 +3,7 @@ package flapjack
 import "errors"
 
 // Event is a basic representation of a Flapjack event.
-// Find more at https://github.com/flapjack/flapjack/wiki/DATA_STRUCTURES
+// Find more at http://flapjack.io/docs/1.0/development/DATA_STRUCTURES
 type Event struct {
 	Entity	string `json:"entity"`
 	Check	string `json:"check"`

data/tasks/benchmarks.rake

@@ -2,36 +2,40 @@ require 'redis'
 require 'oj'
 require 'time'
 
+# add lib to the default include path
+unless $:.include?(File.dirname(__FILE__) + '/../lib/')
+  $: << File.dirname(__FILE__) + '/../lib'
+end
+
+require 'flapjack/configuration'
+require 'flapjack/data/event'
+require 'flapjack/data/entity_check'
+require 'flapjack/version'
+
 namespace :benchmarks do
 
-  # add lib to the default include path
-  unless $:.include?(File.dirname(__FILE__) + '/../lib/')
-    $: << File.dirname(__FILE__) + '/../lib'
+  def redis
+    @redis ||= Redis.new(@redis_config)
   end
 
-  require 'flapjack/configuration'
-  require 'flapjack/data/event'
-  require 'flapjack/data/entity_check'
-  require 'flapjack/version'
+  task :setup do
+    FLAPJACK_ENV = 'test'
+    config_file = File.join('tasks', 'support', 'flapjack_config_benchmark.yaml')
 
-  FLAPJACK_ENV = 'test'
-  config_file = File.join('tasks', 'support', 'flapjack_config_benchmark.yaml')
+    config = Flapjack::Configuration.new
+    config.load( config_file )
 
-  config = Flapjack::Configuration.new
-  config.load( config_file )
+    @config_env = config.all
+    @redis_config = config.for_redis
 
-  @config_env = config.all
-  @redis_config = config.for_redis
-
-  if @config_env.nil? || @config_env.empty?
-    puts "No config data for environment '#{FLAPJACK_ENV}' found in '#{config_file}'"
-    exit(false)
+    if @config_env.nil? || @config_env.empty?
+      puts "No config data for environment '#{FLAPJACK_ENV}' found in '#{config_file}'"
+      exit(false)
+    end
   end
 
-  redis = Redis.new(@redis_config)
-
   desc "nukes the redis db, generates the events, runs and shuts down flapjack, generates perftools reports"
-  task :run => [:reset_redis, :benchmark, :run_flapjack, :reports] do
+  task :run => [:setup, :reset_redis, :benchmark, :run_flapjack, :reports] do
     puts Oj.dump(@benchmark_data, :indent => 2)
   end
 

data/tasks/entities.rake

@@ -0,0 +1,148 @@
+require 'csv'
+require 'securerandom'
+
+require 'redis'
+
+require 'flapjack/configuration'
+require 'flapjack/data/entity'
+
+FLAPJACK_ENV = ENV['FLAPJACK_ENV'] || 'production'
+
+namespace :entities do
+
+  def redis
+    @redis ||= Redis.new(@redis_config)
+  end
+
+  def orphaned_entity_names
+    current_names = Flapjack::Data::Entity.all(:redis => redis).map(&:name)
+
+    all_entity_names = redis.keys("check:*:*").inject([]) do |memo, ck|
+      if ck =~ /^check:([^:]+):.+$/
+        memo << $1
+      end
+
+      memo
+    end
+
+    all_entity_names - current_names
+  end
+
+  task :setup do
+    config_file = File.join('etc', 'flapjack_config.yaml')
+
+    config = Flapjack::Configuration.new
+    config.load( config_file )
+
+    @config_env = config.all
+    @redis_config = config.for_redis
+
+    if @config_env.nil? || @config_env.empty?
+      puts "No config data for environment '#{FLAPJACK_ENV}' found in '#{config_file}'"
+      exit(false)
+    end
+  end
+
+  desc "lists current entity names and their ids"
+  task :current => [:setup] do
+    puts CSV.generate(:headers => :first_row, :write_headers => true, :row_sep => "\r\n") {|csv|
+      csv << ['id', 'name']
+      Flapjack::Data::Entity.all(:redis => redis).each do |entity|
+        csv << [entity.id, entity.name]
+      end
+    }
+  end
+
+  desc "lists entities with data orphaned by entity renames, or created without ids, prior to v1.0"
+  task :orphaned => [:setup] do
+    orph = orphaned_entity_names
+
+    puts CSV.generate(:headers => :first_row, :write_headers => true, :row_sep => "\r\n") {|csv|
+      csv << ['name']
+      orph.each {|orp| csv << [orp]}
+    }
+  end
+
+  desc "reparent entity names from a CSV file on input"
+  task :reparent => [:setup] do
+
+    # The CSV should be in the form 'id', 'name', 'old_name'
+    # If more than one old name exists, another row should be used with
+    # the first two values repeated. The id is there as a sanity check
+    # against current data.
+
+    entities     = {}
+    old_entities = {}
+
+    CSV.new($stdin, :headers => :first_row, :return_headers => false) {|csv|
+      csv.each {|row|
+
+        id       = row['id']
+        name     = row['name']
+        old_name = row['old_name']
+
+        if entities.has_key?(id)
+          unless entities[id].eql?(name)
+            raise "Different names for entity id 'id': '#{name}', '#{old_name}'"
+          end
+        else
+          entities[id] = name
+        end
+
+        old_entities[id] ||= []
+        old_entities[id] << old_name
+      }
+
+      old_entities.each_pair do |id, old_entities_for_id|
+        old_entities_for_id.each do |old_entity|
+          puts "Re-parenting '#{old_entity}' data to '#{entities[id]}'"
+          Flapjack::Data::Entity.merge(old_entity, entities[id], :redis => redis)
+        end
+      end
+    }
+
+  end
+
+  # Checks sent by monitoring data before the related entity had been imported,
+  # before 1.0, had autogenerated entities saved without ids, and these entities
+  # were not re-integrated later. This task will detect and fix any such data.
+  desc "give an identity to entities that never had one"
+  task :repatriate => [:setup] do
+
+    orph = orphaned_entity_names
+
+    CSV.new($stdin, :headers => :first_row, :return_headers => false) {|csv|
+      csv.each {|row|
+
+        name     = row['name']
+        id       = row['id']
+
+        if !orph.include?(name)
+          puts "'#{name}' is not an orphaned entity."
+          next
+        end
+
+        entity = id.nil? ? nil : Flapjack::Data::Entity.find_by_id(id)
+
+        if id.nil? || entity.nil?
+          id ||= SecureRandom.uuid
+          redis.multi
+          redis.set("entity_id:#{name}", id)
+          redis.hset("entity:#{id}", 'name', name)
+          redis.exec
+          puts "Set id '#{id}' for entity #{name}'"
+        elsif entity.name.eql?(name)
+          puts "'#{name}' entity already exists with the provided id"
+        else
+          # entity exists, name doesn't match -- merge old data
+          Flapjack::Data::Entity.merge(name, entity.name, :redis => redis)
+          puts "Merged data for entity '#{name}' into entity #{entity.name}' with id '#{id}'"
+        end
+
+      }
+
+    }
+
+  end
+
+end