flapjack_configurator 1.0.0

data/lib/flapjack_configurator.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'flapjack-diner'
+require 'logger'
+require 'flapjack_configurator/flapjack_config'
+require 'flapjack_configurator/version'
+
+# Flapjack Configuration Module
+module FlapjackConfigurator
+  # Method to configure flapjack
+  def self.configure_flapjack(config, api_base_url = 'http://127.0.0.1:3081', logger = Logger.new(STDOUT), enable_all_entity = true)
+    ret_val = false
+    Flapjack::Diner.base_uri(api_base_url)
+
+    # The underlying classes treat the Flapjack::Diner module as if it is a class.
+    # This was done as it was fairly natural and will allow Flapjack::Diner to be
+    # replaced or wrapped very easily in the future.
+    config_obj = FlapjackConfig.new(config, Flapjack::Diner, logger)
+
+    if enable_all_entity
+      # Ensure the ALL entity is present
+      ret_val = true if config_obj.add_all_entity
+    end
+
+    # Update the contacts
+    # This will update media, PD creds, notification rules, and entity associations
+    #   as they're associated to the contact.
+    ret_val = true if config_obj.update_contacts
+
+    return ret_val
+  end
+end

data/lib/flapjack_configurator/entity_mapper.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+require 'deep_clone'
+
+module FlapjackConfigurator
+  # Walk though the entities and build the map of entities to contacts
+  # Built as a class for future proofing and because this is expected to
+  # be an expensive operation: so instantiate it once and pass it around.
+  class EntityMapper
+    attr_reader :entity_map
+
+    def initialize(config_obj, diner)
+      @entity_map = {}.tap { |em| config_obj.contact_ids.each { |cn| em[cn.to_sym] = [] } }
+      default_contacts = config_obj.default_contacts
+
+      # Walk the entities and compare each individually so that the whitelisting/blacklisting can be easily enforced
+      # This probably will need some optimization
+      diner.entities.each do |entity|
+        contact_defined = false
+        config_obj.contact_ids.each do |contact_id|
+          match_id = _check_entity(entity, config_obj.contact_config(contact_id))
+          if match_id
+            @entity_map[contact_id.to_sym].push(entity[:id])
+            contact_defined = true
+          end
+        end
+
+        # ALL is a special case entity, don't associate the default to it.
+        # Using next if per Rubocop :)
+        next if contact_defined || entity[:id] == 'ALL'
+        # No contacts match this entity, add it to the defaults
+        default_contacts.each do |contact_id|
+          @entity_map[contact_id.to_sym].push(entity[:id])
+        end
+      end
+
+      return @entity_map
+    end
+
+    # Check if entity should be included in contact
+    # Helper for _build_entity_map
+    # Returns the entity ID on match or nil on no match
+    def _check_entity(entity, contact)
+      # Priority 1: Exact Entries
+      return true if contact['entities']['exact'].include? entity[:name]
+
+      # Priority 2: Exact blacklist
+      return false if contact['entities_blacklist']['exact'].include? entity[:name]
+
+      # Priority 3: Regex blacklist
+      contact['entities_blacklist']['regex'].each do |bl_regex|
+        return false if /#{bl_regex}/.match(entity[:name])
+      end
+
+      # Priority 4: Match regex
+      contact['entities']['regex'].each do |m_regex|
+        return true if /#{m_regex}/.match(entity[:name])
+      end
+
+      # Fallthrough
+      return false
+    end
+
+    # Return the entities for the given contact
+    # Returns a clone so the returned object is modifyable
+    def entities_for_contact(id)
+      fail("ID #{id} not in entity map") unless @entity_map.key? id.to_sym
+      return DeepClone.clone @entity_map[id.to_sym]
+    end
+  end
+end

data/lib/flapjack_configurator/flapjack_config.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require_relative 'user_configuration.rb'
+require_relative 'flapjack_media.rb'
+require_relative 'flapjack_pagerduty.rb'
+require_relative 'flapjack_notification_rule.rb'
+require_relative 'flapjack_contact.rb'
+
+module FlapjackConfigurator
+  # Class representing the overall Flapjack config
+  class FlapjackConfig
+    attr_reader :config_obj, :contacts
+
+    def initialize(config, diner, logger)
+      @config_obj = UserConfiguration.new(config, diner, logger)
+      @diner  = diner
+      @logger = logger
+
+      # Media will be tied in via the contacts, however pregenerate objects off a single API call for speed.
+      media = @diner.media.map { |api_media| FlapjackMedia.new(api_media, @diner, logger) }
+      # Also add PagerDuty creds into media.  PD creds are handled separately by the API but can be grouped thanks to our class handling.
+      media += @diner.pagerduty_credentials.map { |api_pd| FlapjackPagerduty.new(api_pd, @diner, logger) }
+
+      # Prebuild notification rules for the same reason
+      notification_rules = @diner.notification_rules.map { |api_nr| FlapjackNotificationRule.new(nil, api_nr, @diner, logger) }
+
+      @contacts = {}.tap { |ce| @diner.contacts.map { |api_contact| ce[api_contact[:id]] = FlapjackContact.new(nil, api_contact, @diner, logger, media, notification_rules) } }
+    end
+
+    # Loop over the contacts and call update/create/remove methods as needed
+    # Builds the @contacts hash
+    def update_contacts
+      config_contact_ids = @config_obj.contact_ids
+      ret_val = false
+
+      # Iterate over a list of keys to avoid the iterator being impacted by deletes
+      @contacts.keys.each do |id|
+        if config_contact_ids.include? id
+          ret_val = true if @contacts[id].update(@config_obj)
+
+          # Delete the ID from the id array
+          # This will result in config_contact_ids being a list of IDs that need to be created at the end of the loop
+          config_contact_ids.delete(id)
+        else
+          # Delete contact from Flapjack
+          @contacts[id].delete
+          @contacts.delete(id)
+          ret_val = true
+        end
+      end
+
+      # Add new contacts to Flapjack
+      config_contact_ids.each do |new_id|
+        contact_obj = FlapjackContact.new(new_id, nil, @diner, @logger)
+        contact_obj.update(@config_obj)
+        @contacts[new_id] = contact_obj
+      end
+
+      # Return true if changes made
+      return ret_val || config_contact_ids.length > 0
+    end
+
+    # Ensure the ALL entity is present
+    # http://flapjack.io/docs/1.0/usage/Howto-Dynamic-Entity-Contact-Linking/
+    def add_all_entity
+      return false if @diner.entities('ALL')
+      @logger.info('Creating the ALL magic entity')
+      fail('Failed to create ALL entity') unless @diner.create_entities(id: 'ALL', name: 'ALL')
+      return true
+    end
+  end
+end

data/lib/flapjack_configurator/flapjack_contact.rb

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+
+require_relative 'flapjack_object_base.rb'
+require_relative 'flapjack_media.rb'
+require_relative 'flapjack_pagerduty.rb'
+require_relative 'flapjack_notification_rule.rb'
+
+module FlapjackConfigurator
+  # Class representing a Flapjack contact
+  class FlapjackContact < FlapjackObjectBase
+    attr_reader :media
+
+    def initialize(my_id, current_config, diner, logger, current_media = [], current_notification_rules = [])
+      @diner = diner
+      @logger = logger
+      super(my_id, current_config, diner.method(:contacts), diner.method(:create_contacts), diner.method(:update_contacts), diner.method(:delete_contacts), logger, 'contact')
+
+      # Select our media out from a premade hash of all media built from a single API call
+      @media = current_media.select { |m| m.config[:links][:contacts].include? id }
+
+      # Select notification rules the same way.
+      @notification_rules = current_notification_rules.select { |m| m.config[:links][:contacts].include? id }
+    end
+
+    # Update all the things
+    def update(config_obj)
+      ret_val = false
+      ret_val = true if update_attributes(config_obj)
+      ret_val = true if update_entities(config_obj)
+      ret_val = true if update_media(config_obj)
+      ret_val = true if update_notification_rules(config_obj)
+      return ret_val
+    end
+
+    # Define our own _create as it doesn't use an ID
+    def _create(config)
+      fail("Object #{id} exists") if @obj_exists
+      # AFAIK there is not an easy way to convert hash keys to symbols outside of Rails
+      config.each { |k, v| @config[k.to_sym] = v }
+      @logger.info("Creating contact #{id} with config #{@config}")
+      fail "Failed to create contact #{id}" unless @create_method.call([@config])
+      _reload_config
+
+      # Creating an entity auto generates notification rules
+      # Regenerate the notification rules
+      @notification_rules = []
+      @config[:links][:notification_rules].each do |nr_id|
+        @notification_rules << FlapjackNotificationRule.new(nr_id, nil, @diner, @logger)
+      end
+    end
+
+    # Update attributes from the config, creating the contact if needed
+    # (Chef definition of "update")
+    # Does not handle entites or notifications
+    def update_attributes(config_obj)
+      @logger.debug("Updating attributes for contact #{id}")
+      if @obj_exists
+        return _update(config_obj.contact_config(id)['details'])
+      else
+        _create(config_obj.contact_config(id)['details'])
+        return true
+      end
+    end
+
+    # Update entities for the contact, creating or removing as needed
+    def update_entities(config_obj)
+      fail("Contact #{id} doesn't exist yet") unless @obj_exists
+      @logger.debug("Updating entities for contact #{id}")
+
+      wanted_entities = config_obj.entity_map.entities_for_contact(id)
+      current_entities = @config[:links][:entities]
+      ret_val = false
+
+      (wanted_entities - current_entities).each do |entity_id|
+        @logger.info("Associating entity #{entity_id} to contact #{id}")
+        fail("Failed to add entity #{entity_id} to contact #{id}") unless @diner.update_contacts(id, add_entity: entity_id)
+        ret_val = true
+      end
+
+      (current_entities - wanted_entities).each do |entity_id|
+        @logger.info("Removing entity #{entity_id} from contact #{id}")
+        fail("Failed to remove entity #{entity_id} from contact #{id}") unless @diner.update_contacts(id, remove_entity: entity_id)
+        ret_val = true
+      end
+
+      _reload_config
+      return ret_val
+    end
+
+    # Update the media for the contact
+    def update_media(config_obj)
+      @logger.debug("Updating media for contact #{id}")
+      media_config = config_obj.media(id)
+      ret_val = false
+
+      media_config_types = media_config.keys
+      @media.each do |media_obj|
+        if media_config_types.include? media_obj.type
+          ret_val = true if media_obj.update(media_config[media_obj.type])
+          # Delete the ID from the type array. This will result in media_config_types being a list of types that need to be created at the end of the loop
+          media_config_types.delete(media_obj.type)
+        else
+          media_obj.delete
+          ret_val = true
+        end
+      end
+
+      # Delete outside the loop as deleting inside the loop messes up the each iterator
+      @media.delete_if { |obj| !obj.obj_exists }
+
+      media_config_types.each do |type|
+        # Pagerduty special case again
+        # TODO: Push this back up so that the if isn't done here
+        if type == 'pagerduty'
+          media_obj = FlapjackPagerduty.new(nil, @diner, @logger)
+          media_obj.create(id, media_config[type])
+        else
+          media_obj = FlapjackMedia.new(nil, @diner, @logger)
+          media_obj.create(id, type, media_config[type])
+        end
+        @media << media_obj
+      end
+
+      return ret_val || media_config_types.length > 0
+    end
+
+    def update_notification_rules(config_obj)
+      @logger.debug("Updating notification rules for contact #{id}")
+      nr_config = config_obj.notification_rules(id)
+      nr_config_ids = nr_config.keys
+      ret_val = false
+
+      @notification_rules.each do |nr_obj|
+        if nr_config_ids.include? nr_obj.id
+          ret_val = true if nr_obj.update(nr_config[nr_obj.id])
+          # Delete the ID from the type array. This will result in nr_config_ids being a list of types that need to be created at the end of the loop
+          nr_config_ids.delete(nr_obj.id)
+        else
+          nr_obj.delete
+          ret_val = true
+        end
+      end
+
+      # Delete outside the loop as deleting inside the loop messes up the each iterator
+      @notification_rules.delete_if { |obj| !obj.obj_exists }
+
+      nr_config_ids.each do |nr_id|
+        nr_obj = FlapjackNotificationRule.new(nr_id, nil, @diner, @logger)
+        nr_obj.create(id, nr_config[nr_id])
+        @notification_rules << (nr_obj)
+      end
+
+      return ret_val || nr_config_ids.length > 0
+    end
+  end
+end

data/lib/flapjack_configurator/flapjack_media.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require_relative 'flapjack_sub_object_base.rb'
+
+module FlapjackConfigurator
+  # Class representing Flapjack media
+  class FlapjackMedia < FlapjackSubObjectBase
+    def initialize(current_config, diner, logger)
+      super(nil, current_config, diner.method(:media), diner.method(:create_contact_media), diner.method(:update_media), diner.method(:delete_media), logger, 'media')
+      @allowed_config_keys = [:address, :interval, :rollup_threshold]
+    end
+
+    # Create a new entry
+    def create(contact_id, type, config)
+      _create(contact_id, _filter_config(config).merge(type: type))
+    end
+
+    # Helper to return the type
+    def type
+      return @config[:type]
+    end
+  end
+end

data/lib/flapjack_configurator/flapjack_notification_rule.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require_relative 'flapjack_sub_object_base.rb'
+
+module FlapjackConfigurator
+  # Class representing notification rules
+  class FlapjackNotificationRule < FlapjackSubObjectBase
+    def initialize(conf_id, current_config, diner, logger)
+      super(conf_id, current_config, diner.method(:notification_rules), diner.method(:create_contact_notification_rules), diner.method(:update_notification_rules),
+            diner.method(:delete_notification_rules), logger, 'notification rule')
+    end
+
+    def create(contact_id, config)
+      # Flapjack will let you create a notification rule object with no attributes, but that sets nils whereas
+      # the default it creates has empty arrays.
+      # Set up a baseline config that matches what Flapjack creates by default
+      full_config = {
+        id: id,
+        tags: [],
+        regex_tags: [],
+        entities: [],
+        regex_entities: [],
+        time_restrictions: [],
+        warning_media: nil,
+        critical_media: nil,
+        unknown_media: nil,
+        unknown_blackhole: false,
+        warning_blackhole: false,
+        critical_blackhole: false
+      }.merge(config)
+
+      _create(contact_id, full_config)
+    end
+
+    def update(config)
+      return _update(config)
+    end
+  end
+end

data/lib/flapjack_configurator/flapjack_object_base.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+module FlapjackConfigurator
+  # Baseline class representing a Flapjack object
+  class FlapjackObjectBase
+    attr_reader :config, :obj_exists
+
+    def initialize(my_id, current_config, getter_method, create_method, update_method, delete_method, logger, log_name)
+      @config = {}
+      @logger = logger
+      @log_name = log_name # A user friendly name for log entries
+
+      @getter_method = getter_method
+      @create_method = create_method
+      @update_method = update_method
+      @delete_method = delete_method
+
+      # Load the object from the API if needed
+      # The current config from Flapjack is passable to avoid polling the API for each individual contact
+      if my_id
+        @config[:id] = my_id
+        current_config = _load_from_api(my_id) unless current_config
+      end
+
+      if current_config
+        @config.merge! current_config
+        @obj_exists = true
+      else
+        @obj_exists = false
+      end
+    end
+
+    # Load the config from the API
+    def _load_from_api(my_id)
+      api_data = @getter_method.call(my_id)
+      return nil unless api_data
+
+      fail "Unexpected number of responses for #{@log_name} #{my_id}" unless api_data.length == 1
+      return api_data[0]
+    end
+
+    # Simple helper to return the ID
+    def id
+      return @config[:id]
+    end
+
+    def _reload_config
+      my_id = id
+      api_obj = @getter_method.call(my_id)
+      fail "Config reload failed for config ID #{my_id}: not found" unless api_obj
+      @config = api_obj[0]
+      fail "Config reload failed for config ID #{my_id}: parse error" unless @config
+      @obj_exists = true
+    end
+
+    # No base create object as the method arguments differ too much.
+
+    # Update the object
+    def _update(config)
+      fail("Object #{id} doesn't exist") unless @obj_exists
+      change_list = {}
+      config.each do |k, v|
+        k_sym = k.to_sym
+        if @config[k_sym] != v
+          change_list[k_sym] = v
+        end
+      end
+
+      return false if change_list.empty?
+
+      @logger.info("Updating #{@log_name} #{id}")
+      @logger.debug("#{@log_name} #{id} changes: #{change_list}")
+      fail "Failed to update #{id}" unless @update_method.call(id, change_list)
+      _reload_config
+      return true
+    end
+
+    # Delete the object
+    def delete
+      fail("Object #{id} doesn't exist") unless @obj_exists
+      @logger.info("Deleting #{@log_name} #{id}")
+      fail "Failed to delete #{id}" unless @delete_method.call(id)
+      @obj_exists = false
+    end
+  end
+end