cloud-mu 3.6.10 → 3.6.11

data/cookbooks/nagios/libraries/base.rb

@@ -0,0 +1,311 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook:: nagios
+# Library:: base
+#
+# 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.
+#
+
+class Nagios
+  # This class it the base for all other Nagios classes.
+  # It provides common methods to prevent code duplication.
+  class Base
+    attr_accessor :register,
+                  :name,
+                  :use,
+                  :not_modifiers
+
+    def initialize
+      @add_modifiers = {}
+      @not_modifiers = Hash.new { |h, k| h[k] = {} }
+    end
+
+    def merge!(obj)
+      merge_members(obj)
+      merge_attributes(obj)
+    end
+
+    def merge_members!(obj)
+      merge_members(obj)
+    end
+
+    def register
+      return @register if blank?(@name)
+      0
+    end
+
+    def register=(arg)
+      @register = check_bool(arg)
+    end
+
+    def use
+      default_template
+    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
+        false
+      end
+      false
+    end
+
+    def check_bool(arg)
+      return 1 if arg.class == TrueClass
+      return 1 if arg.to_s =~ /^y|yes|true|on|1$/i
+      0
+    end
+
+    def check_integer(int)
+      return int.to_i if int.class == String
+      int
+    end
+
+    def check_state_option(arg, options, entry)
+      if options.include?(arg)
+        Chef::Log.debug("#{self.class} #{self} adding option #{arg} for entry #{entry}")
+      else
+        Chef::Log.fail("#{self.class} #{self} object error: Unknown option #{arg} for entry #{entry}")
+        raise 'Unknown option'
+      end
+    end
+
+    def check_state_options(arg, options, entry)
+      if arg.class == String
+        check_state_options(arg.split(','), options, entry)
+      elsif arg.class == Array
+        arg.each { |a| check_state_option(a.strip, options, entry) }.join(',')
+      else
+        arg
+      end
+    end
+
+    def check_use_and_name(default)
+      return if default.nil?
+      return if to_s == default.to_s
+      default
+    end
+
+    def default_template
+      return @use unless @use.nil?
+      return if @name
+      case self
+      when Nagios::Command
+        check_use_and_name(Nagios.instance.default_command)
+      when Nagios::Contactgroup
+        check_use_and_name(Nagios.instance.default_contactgroup)
+      when Nagios::Contact
+        check_use_and_name(Nagios.instance.default_contact)
+      when Nagios::Hostgroup
+        check_use_and_name(Nagios.instance.default_hostgroup)
+      when Nagios::Host
+        check_use_and_name(Nagios.instance.default_host)
+      when Nagios::Servicegroup
+        check_use_and_name(Nagios.instance.default_servicegroup)
+      when Nagios::Service
+        check_use_and_name(Nagios.instance.default_service)
+      when Nagios::Timeperiod
+        check_use_and_name(Nagios.instance.default_timeperiod)
+      end
+    end
+
+    def get_commands(obj)
+      obj.map(&:to_s).join(',')
+    end
+
+    def configured_option(method, option)
+      value = send(method)
+      return if blank?(value)
+      value = value.split(',') if value.is_a? String
+      value = value.map do |e|
+        (@not_modifiers[option][e] || '') + e
+      end.join(',') if value.is_a? Array
+      value
+    end
+
+    def configured_options
+      configured = {}
+      config_options.each do |m, o|
+        next if o.nil?
+        value = configured_option(m, o)
+        next if value.nil?
+        configured[o] = value
+      end
+      configured
+    end
+
+    def get_definition(options, group)
+      return if to_s == '*'
+      return if to_s == 'null'
+      return if to_s.start_with? '!'
+      d = ["define #{group} {"]
+      d += get_definition_options(options)
+      d += ['}']
+      d.join("\n")
+    end
+
+    def get_definition_options(options)
+      r = []
+      longest = get_longest_option(options)
+      options.each do |k, v|
+        k = k.to_s
+        v = (@add_modifiers[k] || '') + v.to_s
+        diff = longest - k.length
+        r.push(k.rjust(k.length + 2) + v.rjust(v.length + diff + 2))
+      end
+      r
+    end
+
+    def get_longest_option(options)
+      longest = 0
+      options.each do |k, _|
+        longest = k.length if longest < k.length
+      end
+      longest
+    end
+
+    def get_members(option, object)
+      members = []
+      case option
+      when String
+        members = object == Nagios::Command ? [option] : option.split(',')
+        members.map(&:strip!)
+      when Array
+        members = option
+      else
+        Chef::Log.fail("Nagios fail: Use an Array or comma seperated String for option: #{option} within #{self.class}")
+        raise 'Use an Array or comma seperated String for option'
+      end
+      members
+    end
+
+    def get_timeperiod(obj)
+      return if obj.nil?
+      return obj.to_s if obj.class == Nagios::Timeperiod
+      obj
+    end
+
+    def merge_attributes(obj)
+      config_options.each do |m, _|
+        n = obj.send(m)
+        next if n.nil?
+        m += '='
+        send(m, n) if respond_to?(m)
+      end
+    end
+
+    def merge_members(obj)
+      Chef::Log.debug("Nagios debug: The method merge_members is not supported by #{obj.class}")
+    end
+
+    def push(obj)
+      Chef::Log.debug("Nagios debug: Cannot push #{obj} into #{self.class}")
+    end
+
+    def push_object(obj, hash)
+      return if hash.key?('null')
+      if obj.to_s == 'null'
+        hash.clear
+        hash[obj.to_s] = obj
+      elsif hash[obj.to_s].nil?
+        hash[obj.to_s] = obj
+      else
+        Chef::Log.debug("Nagios debug: #{self.class} already contains #{obj.class} with name: #{obj}")
+      end
+    end
+
+    def pop_object(obj, hash)
+      if hash.key?(obj.to_s)
+        hash.delete(obj.to_s)
+      else
+        Chef::Log.debug("Nagios debug: #{self.class} does not contain #{obj.class} with name: #{obj}")
+      end
+    end
+
+    def notification_commands(obj)
+      commands = []
+      case obj
+      when Nagios::Command
+        commands.push(obj)
+      when Array
+        obj.each { |o| commands += notification_commands(o) }
+      when String
+        obj.split(',').each do |o|
+          c = Nagios::Command.new(o.strip)
+          n = Nagios.instance.find(c)
+          if c == n
+            Chef::Log.fail("#{self.class} fail: Cannot find command #{o} please define it first.")
+            raise "#{self.class} fail: Cannot find command #{o} please define it first."
+          else
+            commands.push(n)
+          end
+        end
+      end
+      commands
+    end
+
+    def hostname(name)
+      if Nagios.instance.normalize_hostname
+        name.downcase
+      else
+        name
+      end
+    end
+
+    def update_options(hash)
+      return if blank?(hash)
+      update_hash_options(hash) if hash.respond_to?('each_pair')
+    end
+
+    def update_hash_options(hash)
+      hash.each do |k, v|
+        push(Nagios::CustomOption.new(k.upcase, v)) if k.to_s.start_with?('_')
+        m = k.to_s + '='
+        send(m, v) if respond_to?(m)
+      end
+    end
+
+    def update_members(hash, option, object, remote = false)
+      return if blank?(hash) || hash[option].nil?
+      if hash[option].is_a?(String) && hash[option].to_s.start_with?('+')
+        @add_modifiers[option] = '+'
+        hash[option] = hash[option][1..-1]
+      end
+      get_members(hash[option], object).each do |member|
+        if member.start_with?('!')
+          member = member[1..-1]
+          @not_modifiers[option][member] = '!'
+        end
+        n = Nagios.instance.find(object.new(member))
+        push(n)
+        n.push(self) if remote
+      end
+    end
+
+    def update_dependency_members(hash, option, object)
+      return if blank?(hash) || hash[option].nil?
+      get_members(hash[option], object).each do |member|
+        push_dependency(Nagios.instance.find(object.new(member)))
+      end
+    end
+  end
+end

data/cookbooks/nagios/libraries/command.rb

@@ -0,0 +1,68 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook:: nagios
+# Library:: command
+#
+# 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 command options,
+  # that are used within nagios configurations.
+  #
+  class Command < Nagios::Base
+    attr_reader   :command_name
+    attr_accessor :command_line
+
+    def initialize(command_name)
+      cmd = command_name.split('!')
+      @command_name = cmd.shift
+      super()
+    end
+
+    def definition
+      if blank?(command_line)
+        "# Skipping #{command_name} because command_line is missing."
+      else
+        get_definition(configured_options, 'command')
+      end
+    end
+
+    def self.create(name)
+      Nagios.instance.find(Nagios::Command.new(name))
+    end
+
+    def import(hash)
+      @command_line = hash if hash.class == String
+      hash['command_line'] == hash['command'] unless hash['command'].nil?
+      update_options(hash)
+    end
+
+    def to_s
+      command_name
+    end
+
+    private
+
+    def config_options
+      {
+        'command_name' => 'command_name',
+        'command_line' => 'command_line',
+      }
+    end
+  end
+end

data/cookbooks/nagios/libraries/contact.rb

@@ -0,0 +1,229 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook:: nagios
+# Library:: contact
+#
+# 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 contact options,
+  # that are used within nagios configurations.
+  #
+  class Contact < Nagios::Base
+    attr_reader   :contact_name,
+                  :contactgroups,
+                  :custom_options
+
+    attr_accessor :alias,
+                  :host_notifications_enabled,
+                  :service_notifications_enabled,
+                  :host_notification_period,
+                  :service_notification_period,
+                  :host_notification_options,
+                  :service_notification_options,
+                  :host_notification_commands,
+                  :service_notification_commands,
+                  :email,
+                  :pager,
+                  :addressx,
+                  :can_submit_commands,
+                  :retain_status_information,
+                  :retain_nonstatus_information
+
+    def initialize(contact_name)
+      @contact_name = contact_name
+      @contactgroups = {}
+      @host_notification_commands = []
+      @service_notification_commands = []
+      @custom_options = {}
+      super()
+    end
+
+    def contactgroups_list
+      @contactgroups.values.map(&:to_s).sort.join(',')
+    end
+
+    def definition
+      if email.nil? && name.nil? && pager.nil?
+        "# Skipping #{contact_name} because missing email/pager."
+      else
+        configured = configured_options
+        custom_options.each { |_, v| configured[v.to_s] = v.value }
+        get_definition(configured, 'contact')
+      end
+    end
+
+    def self.create(name)
+      Nagios.instance.find(Nagios::Contact.new(name))
+    end
+
+    def host_notification_commands
+      get_commands(@host_notification_commands)
+    end
+
+    def host_notification_commands=(obj)
+      @host_notification_commands = notification_commands(obj)
+    end
+
+    def host_notification_period
+      get_timeperiod(@host_notification_period)
+    end
+
+    def import(hash)
+      update_options(hash)
+      update_members(hash, 'contactgroups', Nagios::Contactgroup, true)
+    end
+
+    def push(obj)
+      case obj
+      when Nagios::Contactgroup
+        push_object(obj, @contactgroups)
+      when Nagios::Timeperiod
+        @host_notification_period = obj
+        @service_notification_period = obj
+      when Nagios::CustomOption
+        push_object(obj, @custom_options)
+      end
+    end
+
+    def pop(obj)
+      return if obj == self
+      case obj
+      when Nagios::Contactgroup
+        if @contactgroups.key?(obj.to_s)
+          pop_object(obj, @contactgroups)
+          pop(self, obj)
+        end
+      when Nagios::Timeperiod
+        @host_notification_period = nil if obj == @host_notification_period
+        @service_notification_period = nil if obj == @service_notification_period
+      when Nagios::CustomOption
+        if @custom_options.key?(obj.to_s)
+          pop_object(obj, @custom_options)
+          pop(self, obj)
+        end
+      end
+    end
+
+    def service_notification_commands
+      get_commands(@service_notification_commands)
+    end
+
+    def service_notification_commands=(obj)
+      @service_notification_commands = notification_commands(obj)
+    end
+
+    def service_notification_period
+      get_timeperiod(@service_notification_period)
+    end
+
+    def to_s
+      contact_name
+    end
+
+    # check the True/False options
+    # default = nil
+    def host_notifications_enabled=(arg)
+      @host_notifications_enabled = check_bool(arg)
+    end
+
+    def service_notifications_enabled=(arg)
+      @service_notifications_enabled = check_bool(arg)
+    end
+
+    def can_submit_commands=(arg)
+      @can_submit_commands = 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
+
+    # check other options
+    #
+    # host_notification_options
+    # This directive is used to define the host states for which notifications
+    # can be sent out to this contact.
+    # Valid options are a combination of one or more of the following:
+    #   d = notify on DOWN host states,
+    #   u = notify on UNREACHABLE host states,
+    #   r = notify on host recoveries (UP states),
+    #   f = notify when the host starts and stops flapping,
+    #   s = send notifications when host or service scheduled downtime starts and ends.
+    #
+    # If you specify n (none) as an option, the contact will not receive any type of
+    # host notifications.
+    def host_notification_options=(arg)
+      @host_notification_options = check_state_options(
+        arg, %w(d u r f s n), 'host_notification_options')
+    end
+
+    # service_notification_options
+    # This directive is used to define the service states for which notifications
+    # can be sent out to this contact.
+    # Valid options are a combination of one or more of the following:
+    #   w = notify on WARNING service states,
+    #   u = notify on UNKNOWN service states,
+    #   c = notify on CRITICAL service states,
+    #   r = notify on service recoveries (OK states),
+    #   f = notify when the service starts and stops flapping.
+    #
+    # If you specify n (none) as an option, the contact will not receive any type of
+    # service notifications.
+    def service_notification_options=(arg)
+      @service_notification_options = check_state_options(
+        arg, %w(w u c r f n), 'service_notification_options')
+    end
+
+    private
+
+    def config_options
+      {
+        'name' => 'name',
+        'use' => 'use',
+        'contact_name' => 'contact_name',
+        'contactgroups_list' => 'contactgroups',
+        'alias' => 'alias',
+        'host_notifications_enabled' => 'host_notifications_enabled',
+        'service_notifications_enabled' => 'service_notifications_enabled',
+        'host_notification_period' => 'host_notification_period',
+        'service_notification_period' => 'service_notification_period',
+        'host_notification_options' => 'host_notification_options',
+        'service_notification_options' => 'service_notification_options',
+        'host_notification_commands' => 'host_notification_commands',
+        'service_notification_commands' => 'service_notification_commands',
+        'email' => 'email',
+        'pager' => 'pager',
+        'addressx' => 'addressx',
+        'can_submit_commands' => 'can_submit_commands',
+        'retain_status_information' => 'retain_status_information',
+        'retain_nonstatus_information' => 'retain_nonstatus_information',
+        'register' => 'register',
+      }
+    end
+
+    def merge_members(obj)
+      obj.contactgroups.each { |m| push(m) }
+      obj.custom_options.each { |_, m| push(m) }
+    end
+  end
+end

data/cookbooks/nagios/libraries/contactgroup.rb

@@ -0,0 +1,111 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook:: nagios
+# Library:: contactgroup
+#
+# 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 'nagios'
+
+class Nagios
+  #
+  # This class holds all methods with regard to contactgroup options,
+  # that are used within nagios configurations.
+  #
+  class Contactgroup < Nagios::Base
+    attr_reader   :contactgroup_name,
+                  :members,
+                  :contactgroup_members
+
+    attr_accessor :alias
+
+    def initialize(contactgroup_name)
+      @contactgroup_name = contactgroup_name
+      @members = {}
+      @contactgroup_members = {}
+      super()
+    end
+
+    def contactgroup_members_list
+      @contactgroup_members.values.map(&:to_s).sort.join(',')
+    end
+
+    def self.create(name)
+      Nagios.instance.find(Nagios::Contactgroup.new(name))
+    end
+
+    def definition
+      get_definition(configured_options, 'contactgroup')
+    end
+
+    def import(hash)
+      update_options(hash)
+      update_members(hash, 'members', Nagios::Contact, true)
+      update_members(hash, 'contactgroups_members', Nagios::Contactgroup, true)
+    end
+
+    def members_list
+      @members.values.map(&:to_s).sort.join(',')
+    end
+
+    def push(obj)
+      case obj
+      when Nagios::Contact
+        push_object(obj, @members)
+      when Nagios::Contactgroup
+        push_object(obj, @contactgroup_members)
+      end
+    end
+
+    def pop(obj)
+      return if obj == self
+      case obj
+      when Nagios::Contact
+        if @members.key?(obj.to_s)
+          pop_object(obj, @members)
+          pop(self, obj)
+        end
+      when Nagios::Contactgroup
+        if @contactgroups_members.key?(obj.to_s)
+          pop_object(obj, @contactgroup_members)
+          pop(self, obj)
+        end
+      end
+    end
+
+    def to_s
+      contactgroup_name
+    end
+
+    private
+
+    def config_options
+      {
+        'name' => 'name',
+        'use' => 'use',
+        'contactgroup_name' => 'contactgroup_name',
+        'members_list' => 'members',
+        'contactgroup_members_list' => 'contactgroup_members',
+        'alias' => 'alias',
+        'register' => 'register',
+      }
+    end
+
+    def merge_members(obj)
+      obj.members.each { |m| push(m) }
+      obj.contactgroup_members.each { |m| push(m) }
+    end
+  end
+end