cloud-mu 1.9.0.pre.beta

data/cookbooks/nagios/libraries/hostescalation.rb

@@ -0,0 +1,173 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook Name:: nagios
+# Library:: hostescalation
+#
+# 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 hostescalation options,
+  # that are used within nagios configurations.
+  #
+  class Hostescalation < Nagios::Base
+    attr_reader   :host_description,
+                  :host_name,
+                  :hostgroup_name,
+                  :contacts,
+                  :contact_groups
+
+    attr_accessor :first_notification,
+                  :last_notification,
+                  :notification_interval,
+                  :escalation_options,
+                  :escalation_period
+
+    def initialize(name)
+      @host_description = name
+      @contacts         = {}
+      @contact_groups   = {}
+      @host_name        = {}
+      @hostgroup_name   = {}
+      super()
+    end
+
+    def definition
+      get_definition(configured_options, 'hostescalation')
+    end
+
+    def contacts_list
+      @contacts.values.map(&:to_s).sort.join(',')
+    end
+
+    def contact_groups_list
+      @contact_groups.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 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)
+    end
+
+    def push(obj)
+      case obj
+      when Nagios::Host
+        push_object(obj, @host_name)
+      when Nagios::Hostgroup
+        push_object(obj, @hostgroup_name)
+      when Nagios::Contact
+        push_object(obj, @contacts)
+      when Nagios::Contactgroup
+        push_object(obj, @contact_groups)
+      when Nagios::Timeperiod
+        @escalation_period = obj
+      end
+    end
+
+    def pop(obj)
+      return if obj == self
+      case obj
+      when Nagios::Host
+        if @host_name.keys?(obj.to_s)
+          pop_object(obj, @host_name)
+          pop(self, obj)
+        end
+      when Nagios::Hostgroup
+        if @hostgroup_name.keys?(obj.to_s)
+          pop_object(obj, @hostgroup_name)
+          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::Timeperiod
+        @escalation_period = nil if @escalation_period == obj
+      end
+    end
+    # rubocop:enable MethodLength
+
+    def to_s
+      host_description
+    end
+
+    # check the integer options
+    # default = nil
+    def first_notification=(int)
+      @first_notification = check_integer(int)
+    end
+
+    def last_notification=(int)
+      @last_notification = check_integer(int)
+    end
+
+    def notification_interval=(int)
+      @notification_interval = check_integer(int)
+    end
+
+    # check other options
+    def escalation_options=(arg)
+      @escalation_options = check_state_options(arg, %w(d u r), 'escalation_options')
+    end
+
+    private
+
+    def config_options
+      {
+        'name'                  => 'name',
+        'use'                   => 'use',
+        'host_description'      => nil,
+        'contacts_list'         => 'contacts',
+        'contact_groups_list'   => 'contact_groups',
+        'escalation_period'     => 'escalation_period',
+        'host_name_list'        => 'host_name',
+        'hostgroup_name_list'   => 'hostgroup_name',
+        'escalation_options'    => 'escalation_options',
+        'first_notification'    => 'first_notification',
+        'last_notification'     => 'last_notification',
+        'notification_interval' => 'notification_interval',
+        'register'              => 'register',
+      }
+    end
+    # rubocop:enable MethodLength
+
+    def merge_members(obj)
+      obj.contacts.each { |m| push(m) }
+      obj.host_name.each { |m| push(m) }
+      obj.contact_groups.each { |m| push(m) }
+      obj.hostgroup_name.each { |m| push(m) }
+    end
+  end
+end
+# rubocop:enable ClassLength

data/cookbooks/nagios/libraries/hostgroup.rb

@@ -0,0 +1,119 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook Name:: nagios
+# Library:: hostgroup
+#
+# 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 hostgroup options,
+  # that are used within nagios configurations.
+  #
+  class Hostgroup < Nagios::Base
+    attr_reader   :hostgroup_name,
+                  :members,
+                  :hostgroup_members
+
+    attr_accessor :alias,
+                  :notes,
+                  :notes_url,
+                  :action_url
+
+    def initialize(hostgroup_name)
+      @hostgroup_name = hostgroup_name
+      @members = {}
+      @hostgroup_members = {}
+      super()
+    end
+
+    def definition
+      get_definition(configured_options, 'hostgroup')
+    end
+
+    def hostgroup_members_list
+      @hostgroup_members.values.map(&:to_s).sort.join(',')
+    end
+
+    def import(hash)
+      update_options(hash)
+      update_members(hash, 'members', Nagios::Host, true)
+      update_members(hash, 'hostgroups_members', Nagios::Hostgroup, true)
+    end
+
+    def members_list
+      @members.values.map(&:to_s).sort.join(',')
+    end
+
+    def push(obj)
+      case obj
+      when Nagios::Host
+        push_object(obj, @members)
+      when Nagios::Hostgroup
+        push_object(obj, @hostgroup_members)
+      end
+    end
+
+    def pop(obj)
+      return if obj == self
+      case obj
+      when Nagios::Host
+        if @members.key?(obj.to_s)
+          pop_object(obj, @members)
+          obj.pop(obj)
+        end
+      when Nagios::Hostgroup
+        if @hostgroups_members.key?(obj.to_s)
+          pop_object(obj, @hostgroup_members)
+          obj.pop(obj)
+        end
+      end
+    end
+    # rubocop:enable MethodLength
+
+    def self.create(name)
+      Nagios.instance.find(Nagios::Hostgroup.new(name))
+    end
+
+    def to_s
+      hostgroup_name
+    end
+
+    private
+
+    def config_options
+      {
+        'name'                   => 'name',
+        'use'                    => 'use',
+        'hostgroup_name'         => 'hostgroup_name',
+        'members_list'           => 'members',
+        'hostgroup_members_list' => 'hostgroup_members',
+        'alias'                  => 'alias',
+        'notes'                  => 'notes',
+        'notes_url'              => 'notes_url',
+        'action_url'             => 'action_url',
+        'register'               => 'register',
+      }
+    end
+    # rubocop:enable MethodLength
+
+    def merge_members(obj)
+      obj.members.each { |m| push(m) }
+      obj.hostgroup_members.each { |m| push(m) }
+    end
+  end
+end

data/cookbooks/nagios/libraries/nagios.rb

@@ -0,0 +1,282 @@
+#
+# 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
+  # rubocop:enable MethodLength
+
+  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
+  # rubocop:enable MethodLength
+
+  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
+  # rubocop:enable MethodLength
+
+  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
+  # rubocop:enable MethodLength
+
+  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
+  # rubocop:enable MethodLength
+
+  def push_object(obj)
+    object = find(obj.class.new(obj.to_s))
+    object.merge!(obj)
+  end
+end

data/cookbooks/nagios/libraries/resource.rb

@@ -0,0 +1,59 @@
+#
+# 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