cloud-mu 2.1.0beta → 3.0.0beta

data/cookbooks/nagios/libraries/nagios.rb

@@ -1,282 +0,0 @@
-#
-# Author:: Sander Botman <sbotman@schubergphilis.com>
-# Cookbook Name:: nagios
-# Library:: nagios
-#
-# Copyright 2014, Sander Botman
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-#
-# This class holds all methods with regard to the nagios model.
-#
-class Nagios
-  attr_reader :commands,
-              :contactgroups,
-              :contacts,
-              :hostgroups,
-              :hosts,
-              :servicegroups,
-              :services,
-              :timeperiods,
-              :hostdependencies,
-              :hostescalations,
-              :servicedependencies,
-              :serviceescalations,
-              :resources
-
-  attr_accessor :host_name_attribute,
-                :normalize_hostname,
-                :default_command,
-                :default_contactgroup,
-                :default_contact,
-                :default_hostgroup,
-                :default_host,
-                :default_servicegroup,
-                :default_service,
-                :default_timeperiod
-
-  def initialize
-    @commands            = {}
-    @contactgroups       = {}
-    @contacts            = {}
-    @hostgroups          = {}
-    @hosts               = {}
-    @servicegroups       = {}
-    @services            = {}
-    @timeperiods         = {}
-    @hostdependencies    = {}
-    @hostescalations     = []
-    @servicedependencies = {}
-    @serviceescalations  = []
-    @resources           = {}
-    @host_name_attribute = 'hostname'
-    @normalize_hostname  = false
-  end
-  
-
-  def commands
-    Hash[@commands.sort]
-  end
-
-  def contactgroups
-    Hash[@contactgroups.sort]
-  end
-
-  def contacts
-    Hash[@contacts.sort]
-  end
-
-  def delete(hash, key)
-    case hash
-    when 'command'
-      @commands.delete(key)
-    when 'contactgroup'
-      @contactgroups.delete(key)
-    when 'contact'
-      @contacts.delete(key)
-    when 'hostgroup'
-      @hostgroups.delete(key)
-    when 'host'
-      @hosts.delete(key)
-    when 'servicegroup'
-      @servicegroups.delete(key)
-    when 'service'
-      @services.delete(key)
-    when 'timeperiod'
-      @timeperiods.delete(key)
-    when 'hostdependency'
-      @hostdependencies.delete(key)
-    when 'hostescalation'
-      @hostescalations.delete(key)
-    when 'servicedependency'
-      @servicedependencies.delete(key)
-    when 'serviceescalation'
-      @serviceescalations.delete(key)
-    when 'resource'
-      @resources.delete(key)
-    end
-  end
-  
-
-  def find(obj)
-    case obj
-    when Nagios::Command
-      find_object(obj, @commands)
-    when Nagios::Contact
-      find_object(obj, @contacts)
-    when Nagios::Contactgroup
-      find_object(obj, @contactgroups)
-    when Nagios::Host
-      find_object(obj, @hosts)
-    when Nagios::Hostgroup
-      find_object(obj, @hostgroups)
-    when Nagios::Service
-      find_object(obj, @services)
-    when Nagios::Servicegroup
-      find_object(obj, @servicegroups)
-    when Nagios::Timeperiod
-      find_object(obj, @timeperiods)
-    when Nagios::Hostdependency
-      find_object(obj, @hostdependencies)
-    when Nagios::Servicedependency
-      find_object(obj, @servicedependencies)
-    when Nagios::Resource
-      find_object(obj, @resources)
-    end
-  end
-  
-
-  def hosts
-    Hash[@hosts.sort]
-  end
-
-  def hostdependencies
-    Hash[@hostdependencies.sort]
-  end
-
-  def hostgroups
-    Hash[@hostgroups.sort]
-  end
-
-  def normalize_hostname=(expr)
-    @normalize_hostname = (expr == true || !(expr =~ /y|yes|true|1/).nil?)
-  end
-
-  def push(obj)
-    case obj
-    when Chef::Node
-      push_node(obj)
-    when Nagios::Command
-      push_object(obj)
-    when Nagios::Contact
-      push_object(obj)
-    when Nagios::Contactgroup
-      push_object(obj)
-    when Nagios::Host
-      push_object(obj)
-    when Nagios::Hostgroup
-      push_object(obj)
-    when Nagios::Service
-      push_object(obj)
-    when Nagios::Servicegroup
-      push_object(obj)
-    when Nagios::Timeperiod
-      push_object(obj)
-    when Nagios::Hostdependency
-      push_object(obj)
-    when Nagios::Hostescalation
-      @hostescalations.push(obj)
-    when Nagios::Servicedependency
-      push_object(obj)
-    when Nagios::Serviceescalation
-      @serviceescalations.push(obj)
-    when Nagios::Resource
-      push_object(obj)
-    else
-      Chef::Log.fail("Nagios error: Pushing unknown object: #{obj.class} into Nagios.instance")
-      raise
-    end
-  end
-  
-
-  def timeperiods
-    Hash[@timeperiods.sort]
-  end
-
-  def resources
-    Hash[@resources.sort]
-  end
-
-  def self.instance
-    @instance ||= Nagios.new
-  end
-
-  def services
-    Hash[@services.sort]
-  end
-
-  def servicedependencies
-    Hash[@servicedependencies.sort]
-  end
-
-  def servicegroups
-    Hash[@servicegroups.sort]
-  end
-
-  private
-
-  def blank?(expr)
-    return true if expr.nil?
-    case expr
-    when 'String', String
-      return true if expr == ''
-    when 'Array', 'Hash', Array, Hash
-      return true if expr.empty?
-    else
-      return false
-    end
-    false
-  end
-
-  def find_object(obj, hash)
-    current = hash[obj.to_s]
-    if current.nil?
-      Chef::Log.debug("Nagios debug: Creating entry for #{obj.class} with name: #{obj}")
-      hash[obj.to_s] = obj
-      obj
-    else
-      Chef::Log.debug("Nagios debug: Found entry for #{obj.class} with name: #{obj}")
-      current
-    end
-  end
-
-  def get_groups(obj)
-    groups = obj['roles'].nil? ? [] : obj['roles'].dup
-    groups += [obj['os']] unless blank?(obj['os'])
-    groups + [obj.chef_environment]
-  end
-
-  def get_hostname(obj)
-    return obj.name if @host_name_attribute == 'name'
-    return obj['nagios']['host_name'] unless blank?(obj['nagios']) || blank?(obj['nagios']['host_name'])
-    return obj[@host_name_attribute] unless blank?(obj[@host_name_attribute])
-    return obj['hostname'] unless blank?(obj['hostname'])
-    return obj.name unless blank?(obj.name)
-    nil
-  end
-
-  def push_node(obj)
-    groups = get_groups(obj)
-    hostname = get_hostname(obj)
-    return nil if hostname.nil?
-
-    host = find(Nagios::Host.new(hostname))
-    # TODO: merge the ip_to_monitor funtion into this logic here
-    host.address = obj['ipaddress']
-    host.import(obj['nagios']) unless obj['nagios'].nil?
-
-    groups.each do |r|
-      hg = find(Nagios::Hostgroup.new(r))
-      hg.push(host)
-      host.push(hg)
-    end
-  end
-  
-
-  def push_object(obj)
-    object = find(obj.class.new(obj.to_s))
-    object.merge!(obj)
-  end
-end

data/cookbooks/nagios/libraries/resource.rb

@@ -1,59 +0,0 @@
-#
-# Author:: Sander Botman <sbotman@schubergphilis.com>
-# Cookbook Name:: nagios
-# Library:: resource
-#
-# Copyright 2015, Sander Botman
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require_relative 'base'
-
-class Nagios
-  #
-  # This class holds all methods with regard to resource options,
-  # that are used within nagios configurations.
-  #
-  class Resource < Nagios::Base
-    attr_reader   :key
-    attr_accessor :value
-
-    def initialize(key, value = nil)
-      @key = key
-      @value = value
-      super()
-    end
-
-    def definition
-      if blank?(value)
-        "# Skipping #{key} because the value is missing."
-      elsif key =~ /^USER([1-9]|[1-9][0-9]|[1-2][0-4][0-9]|25[0-6])$/
-        "$#{@key}$=#{@value}"
-      else
-        "# Skipping #{key} because the it's not valid. Use USER[1-256] as your key."
-      end
-    end
-
-    def self.create(name)
-      Nagios.instance.find(Nagios::Resource.new(name))
-    end
-
-    def import(hash)
-      update_options(hash)
-    end
-
-    def to_s
-      key
-    end
-  end
-end

data/cookbooks/nagios/libraries/service.rb

@@ -1,455 +0,0 @@
-#
-# Author:: Sander Botman <sbotman@schubergphilis.com>
-# Cookbook Name:: nagios
-# Library:: service
-#
-# Copyright 2014, Sander Botman
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require_relative 'base'
-
-class Nagios
-  #
-  #  This class holds all methods with regard to servicedependency options,
-  #  that are used within nagios configurations.
-  #
-  class Service < Nagios::Base
-    attr_reader   :service_description,
-                  :host_name,
-                  :hostgroup_name,
-                  :contacts,
-                  :contact_groups,
-                  :check_command,
-                  :servicegroups,
-                  :hostgroups,
-                  :custom_options
-
-    attr_accessor :display_name,
-                  :is_volatile,
-                  :initial_state,
-                  :max_check_attempts,
-                  :check_interval,
-                  :retry_interval,
-                  :active_checks_enabled,
-                  :passive_checks_enabled,
-                  :check_period,
-                  :obsess_over_service,
-                  :check_freshness,
-                  :freshness_threshold,
-                  :event_handler,
-                  :event_handler_enabled,
-                  :low_flap_threshold,
-                  :high_flap_threshold,
-                  :flap_detection_enabled,
-                  :flap_detection_options,
-                  :process_perf_data,
-                  :retain_status_information,
-                  :retain_nonstatus_information,
-                  :notification_interval,
-                  :first_notification_delay,
-                  :notification_period,
-                  :notification_options,
-                  :notifications_enabled,
-                  :parallelize_check,
-                  :stalking_options,
-                  :notes,
-                  :notes_url,
-                  :action_url,
-                  :icon_image,
-                  :icon_image_alt
-
-    def initialize(service_description)
-      @service_description = service_description
-      srv = service_description.split('!')
-      @check_command       = srv.shift
-      @arguments           = srv
-      @servicegroups       = {}
-      @contacts            = {}
-      @contact_groups      = {}
-      @hostgroups          = {}
-      @hosts               = {}
-      @custom_options      = {}
-      super()
-    end
-    
-
-    def check_command
-      if blank?(@arguments)
-        @check_command.to_s
-      else
-        @check_command.to_s + '!' + @arguments.join('!')
-      end
-    end
-
-    def check_command=(cmd)
-      cmd = cmd.split('!')
-      cmd.shift
-      @arguments = cmd
-    end
-
-    def check_period
-      get_timeperiod(@check_period)
-    end
-
-    # contacts
-    # This is a list of the short names of the contacts that should be notified
-    # whenever there are problems (or recoveries) with this host.
-    # Multiple contacts should be separated by commas.
-    # Useful if you want notifications to go to just a few people and don't want
-    # to configure contact groups.
-    # You must specify at least one contact or contact group in each host definition.
-    def contacts_list
-      @contacts.values.map(&:to_s).sort.join(',')
-    end
-
-    # contact_groups
-    # This is a list of the short names of the contact groups that should be notified
-    # whenever there are problems (or recoveries) with this host.
-    # Multiple contact groups should be separated by commas.
-    # You must specify at least one contact or contact group in each host definition.
-    def contact_groups_list
-      @contact_groups.values.map(&:to_s).sort.join(',')
-    end
-
-    def definition
-      if blank?(hostgroup_name_list) && blank?(host_name_list) && name.nil?
-        "# Skipping #{service_description} because host_name and hostgroup_name are missing."
-      else
-        configured = configured_options
-        custom_options.each { |_, v| configured[v.to_s] = v.value }
-        get_definition(configured, 'service')
-      end
-    end
-
-    # host_name
-    # This directive is used to return all host objects
-    def host_name
-      @hosts
-    end
-
-    # host_name_list
-    # This directive is used to specify the short name(s) of the host(s) that the service
-    # "runs" on or is associated with. Multiple hosts should be separated by commas.
-    def host_name_list
-      @hosts.values.map(&:to_s).sort.join(',')
-    end
-
-    # hostgroup_name
-    # This directive is used to return all hostgroup objects
-    def hostgroup_name
-      @hostgroups
-    end
-
-    # hostgroup_name_list
-    # This directive is used to specify the short name(s) of the hostgroup(s) that the
-    # service "runs" on or is associated with. Multiple hostgroups should be separated by commas.
-    # The hostgroup_name may be used instead of, or in addition to, the host_name directive.
-    def hostgroup_name_list
-      @hostgroups.values.map(&:to_s).sort.join(',')
-    end
-
-    def import(hash)
-      update_options(hash)
-      update_members(hash, 'contacts', Nagios::Contact)
-      update_members(hash, 'contact_groups', Nagios::Contactgroup)
-      update_members(hash, 'host_name', Nagios::Host)
-      update_members(hash, 'hostgroup_name', Nagios::Hostgroup)
-      update_members(hash, 'servicegroups', Nagios::Servicegroup, true)
-      update_members(hash, 'check_command', Nagios::Command)
-    end
-
-    def notification_period
-      get_timeperiod(@notification_period)
-    end
-
-    def push(obj)
-      case obj
-      when Nagios::Servicegroup
-        push_object(obj, @servicegroups)
-      when Nagios::Hostgroup
-        push_object(obj, @hostgroups)
-      when Nagios::Host
-        push_object(obj, @hosts)
-      when Nagios::Contact
-        push_object(obj, @contacts)
-      when Nagios::Contactgroup
-        push_object(obj, @contact_groups)
-      when Nagios::Command
-        @check_command = obj
-      when Nagios::Timeperiod
-        @check_period = obj
-        @notification_period = obj
-      when Nagios::CustomOption
-        push_object(obj, @custom_options)
-      end
-    end
-
-    def pop(obj)
-      return if obj == self
-      case obj
-      when Nagios::Servicegroup
-        if @servicegroups.keys?(obj.to_s)
-          pop_object(obj, @servicegroups)
-          pop(self, obj)
-        end
-      when Nagios::Hostgroup
-        if @hostgroups.keys?(obj.to_s)
-          pop_object(obj, @hostgroups)
-          pop(self, obj)
-        end
-      when Nagios::Host
-        if @hosts.keys?(obj.to_s)
-          pop_object(obj, @hosts)
-          pop(self, obj)
-        end
-      when Nagios::Contact
-        if @contacts.keys?(obj.to_s)
-          pop_object(obj, @contacts)
-          pop(self, obj)
-        end
-      when Nagios::Contactgroup
-        if @contact_groups.keys?(obj.to_s)
-          pop_object(obj, @contact_groups)
-          pop(self, obj)
-        end
-      when Nagios::Command
-        @check_command = nil if @check_command == obj
-      when Nagios::Timeperiod
-        @check_period = nil if @check_command == obj
-        @notification_period = nil if @check_command == obj
-      when Nagios::CustomOption
-        if @custom_options.keys?(obj.to_s)
-          pop_object(obj, @custom_options)
-          pop(self, obj)
-        end
-      end
-    end
-    
-
-    # servicegroups
-    # This directive is used to define the description of the service, which may contain spaces,
-    # dashes, and colons (semicolons, apostrophes, and quotation marks should be avoided).
-    # No two services associated with the same host can have the same description.
-    # Services are uniquely identified with their host_name and service_description directives.
-    def servicegroups_list
-      @servicegroups.values.map(&:to_s).sort.join(',')
-    end
-
-    def self.create(name)
-      Nagios.instance.find(Nagios::Service.new(name))
-    end
-
-    def to_s
-      service_description
-    end
-
-    # check the integer options
-    # default = nil
-
-    def max_check_attempts=(int)
-      @max_check_attempts = check_integer(int)
-    end
-
-    def check_interval=(int)
-      @check_interval = check_integer(int)
-    end
-
-    def retry_interval=(int)
-      @retry_interval = check_integer(int)
-    end
-
-    def freshness_threshold=(int)
-      @freshness_threshold = check_integer(int)
-    end
-
-    def low_flap_threshold=(int)
-      @low_flap_threshold = check_integer(int)
-    end
-
-    def high_flap_threshold=(int)
-      @high_flap_threshold = check_integer(int)
-    end
-
-    def notification_interval=(int)
-      @notification_interval = check_integer(int)
-    end
-
-    def first_notification_delay=(int)
-      @first_notification_delay = check_integer(int)
-    end
-
-    # check the True/False options
-    # default = nil
-
-    # rubocop:disable Style/PredicateName
-    def is_volatile=(arg)
-      @is_volatile = check_bool(arg)
-    end
-    # rubocop:enable Style/PredicateName
-
-    def active_checks_enabled=(arg)
-      @active_checks_enabled = check_bool(arg)
-    end
-
-    def passive_checks_enabled=(arg)
-      @passive_checks_enabled = check_bool(arg)
-    end
-
-    def obsess_over_service=(arg)
-      @obsess_over_service = check_bool(arg)
-    end
-
-    def check_freshness=(arg)
-      @check_freshness = check_bool(arg)
-    end
-
-    def event_handler_enabled=(arg)
-      @event_handler_enabled = check_bool(arg)
-    end
-
-    def flap_detection_enabled=(arg)
-      @flap_detection_enabled = check_bool(arg)
-    end
-
-    def process_perf_data=(arg)
-      @process_perf_data = check_bool(arg)
-    end
-
-    def retain_status_information=(arg)
-      @retain_status_information = check_bool(arg)
-    end
-
-    def retain_nonstatus_information=(arg)
-      @retain_nonstatus_information = check_bool(arg)
-    end
-
-    def notifications_enabled=(arg)
-      @notifications_enabled = check_bool(arg)
-    end
-
-    def parallelize_check=(arg)
-      @parallelize_check = check_bool(arg)
-    end
-
-    # check other options
-
-    # flap_detection_options
-    # This directive is used to determine what service states the flap detection logic will use for this service.
-    # Valid options are a combination of one or more of the following:
-    #   o = OK states,
-    #   w = WARNING states,
-    #   c = CRITICAL states,
-    #   u = UNKNOWN states.
-
-    def flap_detection_options=(arg)
-      @flap_detection_options = check_state_options(arg, %w(o w u c), 'flap_detection_options')
-    end
-
-    # notification_options
-    # This directive is used to determine when notifications for the service should be sent out.
-    # Valid options are a combination of one or more of the following:
-    #   w = send notifications on a WARNING state,
-    #   u = send notifications on an UNKNOWN state,
-    #   c = send notifications on a CRITICAL state,
-    #   r = send notifications on recoveries (OK state),
-    #   f = send notifications when the service starts and stops flapping,
-    #   s = send notifications when scheduled downtime starts and ends.
-    #
-    # If you specify n (none) as an option, no service notifications will be sent out.
-    # If you do not specify any notification options, Nagios will assume that you want
-    # notifications to be sent out for all possible states.
-    #
-    # Example: If you specify w,r in this field, notifications will only be sent out when
-    # the service goes into a WARNING state and when it recovers from a WARNING state.
-
-    def notification_options=(arg)
-      @notification_options = check_state_options(arg, %w(w u c r f s n), 'notification_options')
-    end
-
-    # stalking_options
-    # This directive determines which service states "stalking" is enabled for.
-    # Valid options are a combination of one or more of the following:
-    #   o = stalk on OK states,
-    #   w = stalk on WARNING states,
-    #   u = stalk on UNKNOWN states,
-    #   c = stalk on CRITICAL states.
-    #
-    # More information on state stalking can be found here.
-
-    def stalking_options=(arg)
-      @stalking_options = check_state_options(arg, %w(o w u c), 'stalking_options')
-    end
-
-    private
-
-    def config_options
-      {
-        'name'                         => 'name',
-        'use'                          => 'use',
-        'service_description'          => 'service_description',
-        'host_name_list'               => 'host_name',
-        'hostgroup_name_list'          => 'hostgroup_name',
-        'servicegroups_list'           => 'servicegroups',
-        'display_name'                 => 'display_name',
-        'is_volatile'                  => 'is_volatile',
-        'check_command'                => 'check_command',
-        'initial_state'                => 'initial_state',
-        'max_check_attempts'           => 'max_check_attempts',
-        'check_interval'               => 'check_interval',
-        'retry_interval'               => 'retry_interval',
-        'active_checks_enabled'        => 'active_checks_enabled',
-        'passive_checks_enabled'       => 'passive_checks_enabled',
-        'check_period'                 => 'check_period',
-        'obsess_over_service'          => 'obsess_over_service',
-        'check_freshness'              => 'check_freshness',
-        'freshness_threshold'          => 'freshness_threshold',
-        'event_handler'                => 'event_handler',
-        'event_handler_enabled'        => 'event_handler_enabled',
-        'low_flap_threshold'           => 'low_flap_threshold',
-        'high_flap_threshold'          => 'high_flap_threshold',
-        'flap_detection_enabled'       => 'flap_detection_enabled',
-        'flap_detection_options'       => 'flap_detection_options',
-        'process_perf_data'            => 'process_perf_data',
-        'retain_status_information'    => 'retain_status_information',
-        'retain_nonstatus_information' => 'retain_nonstatus_information',
-        'notification_interval'        => 'notification_interval',
-        'first_notification_delay'     => 'first_notification_delay',
-        'notification_period'          => 'notification_period',
-        'notification_options'         => 'notification_options',
-        'notifications_enabled'        => 'notifications_enabled',
-        'parallelize_check'            => 'parallelize_check',
-        'contacts_list'                => 'contacts',
-        'contact_groups_list'          => 'contact_groups',
-        'stalking_options'             => 'stalking_options',
-        'notes'                        => 'notes',
-        'notes_url'                    => 'notes_url',
-        'action_url'                   => 'action_url',
-        'icon_image'                   => 'icon_image',
-        'icon_image_alt'               => 'icon_image_alt',
-        'register'                     => 'register',
-      }
-    end
-    
-
-    def merge_members(obj)
-      obj.contacts.each { |m| push(m) }
-      obj.host_name.each { |m| push(m) }
-      obj.servicegroups.each { |m| push(m) }
-      obj.hostgroup_name.each { |m| push(m) }
-      obj.contact_groups.each { |m| push(m) }
-      obj.custom_options.each { |_, m| push(m) }
-    end
-  end
-end