flapjack_configurator 1.0.0

data/lib/flapjack_configurator/flapjack_pagerduty.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require_relative 'flapjack_sub_object_base.rb'
+
+module FlapjackConfigurator
+  # Class representing Pagerduty credentials
+  # In Flapjack 1.x Pagerduty is somewhat duct-taped to the side of the thing and not handled as media.
+  # However, to make our lives easier, make this class look like FlapjackMedia so that it can be handled like a media entry
+  class FlapjackPagerduty < FlapjackSubObjectBase
+    def initialize(current_config, diner, logger)
+      # The contact ID is essentially the pagerduty credentials ID; 1-1
+      # Pull the ID from the config.  Contacts is an array but in practice it only appears to ever be single-element.
+      conf_id = current_config.nil? ? nil : current_config[:links][:contacts][0]
+      super(conf_id, current_config, diner.method(:pagerduty_credentials), diner.method(:create_contact_pagerduty_credentials),
+            diner.method(:update_pagerduty_credentials), diner.method(:delete_pagerduty_credentials), logger, 'pagerduty')
+      @allowed_config_keys = [:subdomain, :token, :service_key]
+    end
+
+    def create(contact_id, config)
+      _create(contact_id, _filter_config(config))
+    end
+
+    # Type helper to match FlapjackMedia
+    def type
+      return 'pagerduty'
+    end
+  end
+end

data/lib/flapjack_configurator/flapjack_sub_object_base.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require_relative 'flapjack_object_base.rb'
+
+module FlapjackConfigurator
+  # Class representing a Flapjack sub-object (media, pagerduty creds, etc...)
+  class FlapjackSubObjectBase < FlapjackObjectBase
+    # Create the object
+    def _create(contact_id, config)
+      fail("Object #{id} exists") if @obj_exists
+      # AFAIK there is not an easy way to convert hash keys to symbols outside of Rails
+      sym_config = {}
+      config.each { |k, v| sym_config[k.to_sym] = v }
+
+      msg_id = id.nil? ? sym_config[:type] : id
+      @logger.info("Creating #{@log_name} #{msg_id} for contact #{contact_id}")
+      @logger.debug("#{@log_name} #{id} config: #{sym_config}")
+      fail "Failed to create #{@log_name} #{id}" unless @create_method.call(contact_id, sym_config)
+      _reload_config
+    end
+
+    def _filter_config(config)
+      filtered_config = config.select { |k, _| @allowed_config_keys.include? k.to_sym }
+      @logger.debug("#{@log_name} #{id}: Config keys filtered out: #{config.keys - filtered_config.keys}")
+      return filtered_config
+    end
+
+    # Update the media from a config hash of updated values
+    def update(config)
+      return _update(_filter_config(config))
+    end
+  end
+end

data/lib/flapjack_configurator/user_configuration.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+require 'deep_merge'
+require_relative 'entity_mapper.rb'
+
+module FlapjackConfigurator
+  # User Configuration: Class representing the desired configuration as passed into the utility
+  class UserConfiguration
+    attr_reader :config, :entity_map
+
+    def initialize(config, diner, logger)
+      @config = config
+      @logger = logger
+      @media_config = {}
+
+      _sanity_check
+
+      @entity_map = EntityMapper.new(self, diner)
+    end
+
+    def _sanity_check
+      # Check that required keys are present
+      fail('Config missing contacts block') unless @config.key? 'contacts'
+      @config['contacts'].each do |contact_id, contact_val|
+        %w(details notification_media notification_rules).each do |contact_opt|
+          fail("#{contact_id} contact config missing #{contact_opt} block") unless contact_val.key? contact_opt
+        end
+      end
+    end
+
+    def contact_ids
+      @config['contacts'].keys
+    end
+
+    def contact_config(contact_id)
+      return nil unless @config['contacts'].key? contact_id
+
+      # Merge in defaults for keys which may be omitted
+      return {
+        'entities' => { 'exact' => [], 'regex' => [] },
+        'entities_blacklist' => { 'exact' => [], 'regex' => [] }
+      }.deep_merge(@config['contacts'][contact_id])
+    end
+
+    # Return a list of contacts with the default bit set
+    # This is pretty entitymapper centric, but it makes more sense here due to current layout.
+    def default_contacts
+      @config['contacts'].select { |_, contact| contact.key? 'entities' }.select { |_, c| c['entities']['default'] }.keys
+    end
+
+    def baseline_config
+      if @config.key? 'baseline_options'
+        return @config['baseline_options']
+      else
+        return {}
+      end
+    end
+
+    def _complete_config_merge(contact_id, config_key)
+      contact_settings = contact_config(contact_id)[config_key]
+      fail("Missing #{config_key} settings for contact #{contact_id}") if contact_settings.nil?
+
+      baseline_opts = baseline_config.key?(config_key) ? baseline_config[config_key] : {}
+      contact_defaults = contact_settings.key?('defaults') ? contact_settings['defaults'] : {}
+
+      merged_config = {}
+      (contact_settings.keys - %w(defaults)).each do |key|
+        # Only merge baseline/defaults if the contact has the setting defined
+        # This is to prevent errors from partial configs built from only partial defaults.
+        if baseline_opts.key? key
+          merged_config[key] = baseline_opts[key].merge(contact_defaults.merge(contact_settings[key]))
+        else
+          merged_config[key] = contact_defaults.merge(contact_settings[key])
+        end
+      end
+
+      @logger.debug("#{contact_id} #{config_key} complete config: #{merged_config}")
+      return merged_config
+    end
+
+    def media(contact_id)
+      if @media_config[contact_id].nil?
+        @media_config[contact_id] = _complete_config_merge(contact_id, 'notification_media')
+      end
+      return @media_config[contact_id]
+    end
+
+    def notification_rules(contact_id)
+      notification_rules = _complete_config_merge(contact_id, 'notification_rules')
+
+      # Double check that the defined rules call for media which exists
+      notification_rules.each do |nr_id, nr_val|
+        %w(warning_media critical_media unknown_media).each do |alert_type|
+          next unless nr_val.key? alert_type
+          nr_val[alert_type].each do |alert_media|
+            unless media(contact_id).keys.include? alert_media
+              @logger.warn("Notification rule #{nr_id} for contact #{contact_id} calls for media #{alert_media} in #{alert_type} which isn't defined for #{contact_id}")
+            end
+          end
+        end
+      end
+
+      # The notification rules need to have unique IDs contianing the contact id
+      return {}.tap { |rv| notification_rules.each { |nr_id, nr_val| rv["#{contact_id}_#{nr_id}"] = nr_val } }
+    end
+  end
+end

data/lib/flapjack_configurator/version.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+# Define the gem version
+module FlapjackConfigurator
+  VERSION = '1.0.0'
+end

data/spec/docker_test_wrapper.rb

@@ -0,0 +1,52 @@
+# Class to create Flapjack in Docker for testing
+require 'docker'
+require 'flapjack-diner'
+
+# Class which starts a Flapjack instance in Docker for testing
+# Container is removed by the grabage collector
+class FlapjackTestContainer
+  attr_reader :container
+
+  def initialize
+    image = 'flapjack/flapjack:latest'
+
+    # Ensure the image is pulled down
+    Docker::Image.create(fromImage: image)
+
+    # Start the container, binding the API to a random port
+    @container = Docker::Container.create(Image: image)
+    @container.start(PortBindings: { '3081/tcp' => [{ HostPort: '' }] })
+
+    # Define the destructor
+    ObjectSpace.define_finalizer(self, self.class.finalize(@container))
+
+    # TODO: Properly detect if Flapjack is up
+    sleep(2)
+  end
+
+  # Destructor
+  def self.finalize(container)
+    proc do
+      container.stop
+      container.delete
+    end
+  end
+
+  def api_port
+    return @container.json['NetworkSettings']['Ports']['3081/tcp'][0]['HostPort']
+  end
+
+  def api_url
+    return "http://127.0.0.1:#{api_port}"
+  end
+end
+
+# Class which sets up Flapjack::Diner against the test container
+class FlapjackTestDiner
+  attr_reader :diner
+
+  def initialize(test_container)
+    @diner = Flapjack::Diner
+    @diner.base_uri(test_container.api_url)
+  end
+end

data/spec/functional/all_entity_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../spec_helper.rb'
+require_relative 'config_test_common.rb'
+
+TestCommon.setup_test(:each) do |rspec_obj|
+  dummy_config = { 'contacts' => {} }
+  rspec_obj.describe 'All Magic Entity' do
+    it 'is not created when enable_all_entity is false' do
+      ret_val = FlapjackConfigurator.configure_flapjack(dummy_config, @test_container.api_url, @logger, false)
+      expect(ret_val).to eq(false)
+      expect(@test_diner.diner.entities('ALL')).to be_nil
+    end
+
+    it 'is created when enable_all_entity is true' do
+      ret_val = FlapjackConfigurator.configure_flapjack(dummy_config, @test_container.api_url, @logger, true)
+      expect(ret_val).to eq(true)
+      expect(@test_diner.diner.entities('ALL')).to eq([{ id: 'ALL', name: 'ALL', links: { contacts: [], checks: [] } }])
+    end
+  end
+end

data/spec/functional/config_test_common.rb

@@ -0,0 +1,58 @@
+require_relative '../spec_helper.rb'
+require 'yaml'
+require 'pathname'
+
+# Common support methods for testing the gem
+module TestCommon
+  # Set up the test baseline
+  def self.setup_test(before_when = :all)
+    describe 'FlapjackConfigurator gem' do
+      before before_when do
+        @test_container = FlapjackTestContainer.new
+        @test_diner = FlapjackTestDiner.new(@test_container)
+
+        # Silence the logger
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::FATAL
+      end
+
+      yield(self)
+    end
+  end
+
+  def self.load_config(name, subdir = nil)
+    path_obj = Pathname.new('spec/functional/test_configs')
+    path_obj += subdir if subdir
+    path_obj += "#{name}.yaml"
+    config = YAML.load_file(path_obj)
+    fail "Failed to load test config from #{filename}" unless config
+    return config
+  end
+
+  def self.setup_config_test(name)
+    setup_test do |rspec_obj|
+      rspec_obj.describe 'Config hash' do
+        # Update passes
+        { 'initial data'   => { subdir: 'initial', retval: true },
+          'inital update'  => { subdir: 'initial', retval: false },
+          'changed data'   => { subdir: 'changes', retval: true },
+          'changed update' => { subdir: 'changes', retval: false }
+        }.each do |test_name, test_data|
+          test_config = TestCommon.load_config(name, test_data[:subdir])
+
+          describe "Contact #{name} #{test_name}" do
+            before :all do
+              @config_output = FlapjackConfigurator.configure_flapjack(test_config, @test_container.api_url, @logger, true)
+            end
+
+            it 'returns true if changes are made' do
+              expect(@config_output).to eq(test_data[:retval])
+            end
+
+            yield(self, test_config)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/functional/configuration_contact_attributes_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../spec_helper.rb'
+require_relative 'config_test_common.rb'
+
+TestCommon.setup_config_test('attributes') do |rspec_obj, test_config|
+  test_config['contacts'].each do |test_contact, test_contact_settings|
+    rspec_obj.describe "#{test_contact} config attributes" do
+      before :all do
+        @api_contact = @test_diner.diner.contacts(test_contact)[0]
+      end
+
+      test_contact_settings['details'].each do |name, value|
+        it "#{name} set to #{value}" do
+          expect(@api_contact[name.to_sym]).to eq(value)
+        end
+      end
+    end
+  end
+end

data/spec/functional/configuration_contact_entities_spec.rb

@@ -0,0 +1,116 @@
+require_relative '../spec_helper.rb'
+require_relative 'config_test_common.rb'
+
+# Class representing a set of identities
+# Used to build sets of entities for testing
+class TestEntityIDs
+  attr_reader :idlist
+
+  def initialize(idlist)
+    @idlist = idlist
+  end
+
+  def -(other)
+    return TestEntityIDs.new(@idlist - other.idlist)
+  end
+
+  def id_name(id)
+    fail 'Bad ID' unless id
+    return "testentity-#{id}"
+  end
+
+  def entity_create_list
+    # Returns a list in the format needed by Flapjack::Diner.create_entities
+    return @idlist.map { |id| { name: id_name(id), id: id_name(id) } }
+  end
+
+  def names
+    return @idlist.map { |id| id_name(id) }
+  end
+end
+
+TestCommon.setup_test do |rspec_obj|
+  rspec_obj.describe 'contact entities' do
+    before :all do
+      # Load flapjack with test entities
+      @remaining_entities = TestEntityIDs.new(Array.new(100) { |c| c })
+      fail 'Failed to create test entities' unless @test_diner.diner.create_entities(@remaining_entities.entity_create_list)
+    end
+
+    it 'Returns true as the config is updated' do
+      expect(FlapjackConfigurator.configure_flapjack(TestCommon.load_config('entities'), @test_container.api_url, @logger, true)).to eq(true)
+    end
+
+    describe 'matchers' do
+      before :all do
+        @contact_entities = @test_diner.diner.contacts('search_test')[0][:links][:entities]
+
+        # Generate the lists for the tests here to only define the IDs once.
+        # popping magic doesn't work due to rspec test independence.
+        @whitelist_exact_entities = TestEntityIDs.new([1, 3, 31, 71])
+
+        @blacklist_exact_entities = TestEntityIDs.new([21, 23, 61, 63])
+        # Blacklist regex ranges minus the two whitelist pins
+        @blacklist_regex_entities = TestEntityIDs.new((Array.new(10) { |c| c + 30 } + Array.new(10) { |c| c + 70 }) - [31, 71])
+
+        @whitelist_regex_entities = TestEntityIDs.new(Array.new(30) { |c| c + 20 } + Array.new(30) { |c| c + 60 })
+        @whitelist_regex_entities -= @blacklist_exact_entities
+        @whitelist_regex_entities -= @blacklist_regex_entities
+
+        @remaining_entities -= @whitelist_exact_entities
+        @remaining_entities -= @whitelist_regex_entities
+      end
+
+      describe 'entities/exact' do
+        it 'whitelists specified entities' do
+          @whitelist_exact_entities.names.each do |ename|
+            expect(@contact_entities).to include(ename)
+          end
+        end
+      end
+
+      describe 'entities_blacklist/exact' do
+        it 'blacklists specified regexes' do
+          @blacklist_exact_entities.names.each do |ename|
+            expect(@contact_entities).not_to include(ename)
+          end
+        end
+      end
+
+      describe 'entities_blacklist/regex' do
+        it 'blacklists specified regexes' do
+          @blacklist_regex_entities.names.each do |ename|
+            expect(@contact_entities).not_to include(ename)
+          end
+        end
+      end
+
+      describe 'entities/regex' do
+        it 'whitelists specified regexes minus blacklists' do
+          @whitelist_regex_entities.names.each do |ename|
+            expect(@contact_entities).to include(ename)
+          end
+        end
+      end
+
+      describe 'non-specified entities' do
+        it 'are not present' do
+          @remaining_entities.names.each do |ename|
+            expect(@contact_entities).not_to include(ename)
+          end
+        end
+      end
+
+      describe 'entities/default' do
+        it 'matches anything orphaned' do
+          expect(@test_diner.diner.contacts('default_test')[0][:links][:entities].sort).to eq(@remaining_entities.names.sort)
+        end
+
+        # Redundant, as the above will catch this, but I like having the explicit test.
+        it "doesn't match the magic ALL entitiy" do
+          expect(@test_diner.diner.contacts('default_test')[0][:links][:entities]).not_to include('ALL')
+        end
+      end
+    end
+  end
+end