cloud-mu 3.6.10 → 3.6.11

data/cookbooks/nagios/libraries/service.rb

@@ -0,0 +1,449 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook:: 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.key?(obj.to_s)
+          pop_object(obj, @servicegroups)
+          pop(self, obj)
+        end
+      when Nagios::Hostgroup
+        if @hostgroups.key?(obj.to_s)
+          pop_object(obj, @hostgroups)
+          pop(self, obj)
+        end
+      when Nagios::Host
+        if @hosts.key?(obj.to_s)
+          pop_object(obj, @hosts)
+          pop(self, obj)
+        end
+      when Nagios::Contact
+        if @contacts.key?(obj.to_s)
+          pop_object(obj, @contacts)
+          pop(self, obj)
+        end
+      when Nagios::Contactgroup
+        if @contact_groups.key?(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.key?(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
+    def is_volatile=(arg)
+      @is_volatile = check_bool(arg)
+    end
+
+    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

data/cookbooks/nagios/libraries/servicedependency.rb

@@ -0,0 +1,213 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook:: nagios
+# Library:: servicedependency
+#
+# 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 Servicedependency < Nagios::Base
+    attr_reader   :service_description,
+                  :dependency_period,
+                  :dependent_host_name,
+                  :dependent_hostgroup_name,
+                  :dependent_servicegroup_name,
+                  :host_name,
+                  :hostgroup_name,
+                  :servicegroup_name
+
+    attr_accessor :dependent_service_description,
+                  :inherits_parent,
+                  :execution_failure_criteria,
+                  :notification_failure_criteria
+
+    def initialize(name)
+      @service_description         = name
+      @host_name                   = {}
+      @hostgroup_name              = {}
+      @servicegroup_name           = {}
+      @dependent_host_name         = {}
+      @dependent_hostgroup_name    = {}
+      @dependent_servicegroup_name = {}
+      super()
+    end
+
+    def definition
+      get_definition(configured_options, 'servicedependency')
+    end
+
+    def dependent_host_name_list
+      @dependent_host_name.values.map(&:to_s).sort.join(',')
+    end
+
+    def dependent_hostgroup_name_list
+      @dependent_hostgroup_name.values.map(&:to_s).sort.join(',')
+    end
+
+    def dependent_servicegroup_name_list
+      @dependent_servicegroup_name.values.map(&:to_s).sort.join(',')
+    end
+
+    def host_name_list
+      @host_name.values.map(&:to_s).sort.join(',')
+    end
+
+    def hostgroup_name_list
+      @hostgroup_name.values.map(&:to_s).sort.join(',')
+    end
+
+    def servicegroup_name_list
+      @servicegroup_name.values.map(&:to_s).sort.join(',')
+    end
+
+    def import(hash)
+      update_options(hash)
+      update_members(hash, 'host_name', Nagios::Host)
+      update_members(hash, 'hostgroup_name', Nagios::Hostgroup)
+      update_members(hash, 'servicegroup_name', Nagios::Servicegroup)
+      update_dependency_members(hash, 'dependent_host_name', Nagios::Host)
+      update_dependency_members(hash, 'dependent_hostgroup_name', Nagios::Hostgroup)
+      update_dependency_members(hash, 'dependent_servicegroup_name', Nagios::Servicegroup)
+    end
+
+    def push(obj)
+      case obj
+      when Nagios::Host
+        push_object(obj, @host_name)
+      when Nagios::Hostgroup
+        push_object(obj, @hostgroup_name)
+      when Nagios::Servicegroup
+        push_object(obj, @servicegroup_name)
+      when Nagios::Timeperiod
+        @dependency_period = obj
+      end
+    end
+
+    def pop(obj)
+      return if obj == self
+      case obj
+      when Nagios::Host
+        if @host_name.key?(obj.to_s)
+          pop_object(obj, @host_name)
+          pop(self, obj)
+        end
+      when Nagios::Hostgroup
+        if @host_name.key?(obj.to_s)
+          pop_object(obj, @hostgroup_name)
+          pop(self, obj)
+        end
+      when Nagios::Servicegroup
+        if @host_name.key?(obj.to_s)
+          pop_object(obj, @servicegroup_name)
+          pop(self, obj)
+        end
+      when Nagios::Timeperiod
+        @dependency_period = nil if @dependency_period == obj
+      end
+    end
+
+    def pop_dependency(obj)
+      return if obj == self
+      case obj
+      when Nagios::Host
+        if @dependent_host_name.key?(obj.to_s)
+          pop_object(obj, @dependent_host_name)
+          obj.pop(self)
+        end
+      when Nagios::Hostgroup
+        if @dependent_hostgroup_name.key?(obj.to_s)
+          pop_object(obj, @dependent_hostgroup_name)
+          obj.pop(self)
+        end
+      when Nagios::Servicegroup
+        if @dependent_servicegroup_name.key?(obj.to_s)
+          pop_object(obj, @dependent_servicegroup_name)
+          obj.pop(self)
+        end
+      end
+    end
+
+    def push_dependency(obj)
+      case obj
+      when Nagios::Host
+        push_object(obj, @dependent_host_name)
+      when Nagios::Hostgroup
+        push_object(obj, @dependent_hostgroup_name)
+      when Nagios::Servicegroup
+        push_object(obj, @dependent_servicegroup_name)
+      end
+    end
+
+    def self.create(name)
+      Nagios.instance.find(Nagios::Servicedependency.new(name))
+    end
+
+    def to_s
+      service_description
+    end
+
+    # check the True/False options
+    # default = nil
+
+    def inherits_parent=(arg)
+      @inherits_parent = check_bool(arg)
+    end
+
+    # check other options
+
+    def execution_failure_criteria=(arg)
+      @execution_failure_criteria = check_state_options(arg, %w(o w u c p n), 'execution_failure_criteria')
+    end
+
+    def notification_failure_criteria=(arg)
+      @notification_failure_criteria = check_state_options(arg, %w(o w u c p n), 'notification_failure_criteria')
+    end
+
+    private
+
+    def config_options
+      {
+        'dependency_period' => 'dependency_period',
+        'dependent_host_name_list' => 'dependent_host_name',
+        'dependent_hostgroup_name_list' => 'dependent_hostgroup_name',
+        'dependent_servicegroup_name_list' => 'dependent_servicegroup_name',
+        'service_description' => 'service_description',
+        'servicegroup_name_list' => 'servicegroup_name',
+        'dependent_service_description' => 'dependent_service_description',
+        'host_name_list' => 'host_name',
+        'hostgroup_name_list' => 'hostgroup_name',
+        'inherits_parent' => 'inherits_parent',
+        'execution_failure_criteria' => 'execution_failure_criteria',
+        'notification_failure_criteria' => 'notification_failure_criteria',
+      }
+    end
+
+    def merge_members(obj)
+      obj.host_name.each { |m| push(m) }
+      obj.hostgroup_name.each { |m| push(m) }
+      obj.servicegroup_name.each { |m| push(m) }
+      obj.dependent_host_name.each { |m| push_dependency(m) }
+      obj.dependent_hostgroup_name.each { |m| push_dependency(m) }
+      obj.dependent_servicegroup_name.each { |m| dependent_servicegroup_name(m) }
+    end
+  end
+end