cloud-mu 3.6.9 → 3.6.11

data/cookbooks/nagios/libraries/serviceescalation.rb

@@ -0,0 +1,193 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook:: nagios
+# Library:: serviceescalation
+#
+# 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 serviceescalation options,
+  #  that are used within nagios configurations.
+  #
+  class Serviceescalation < Nagios::Base
+    attr_reader   :service_description,
+                  :host_name,
+                  :hostgroup_name,
+                  :servicegroup_name,
+                  :contacts,
+                  :contact_groups
+
+    attr_accessor :first_notification,
+                  :last_notification,
+                  :notification_interval,
+                  :escalation_options,
+                  :escalation_period
+
+    def initialize(name)
+      @service_description = name
+      @contacts            = {}
+      @contact_groups      = {}
+      @host_name           = {}
+      @hostgroup_name      = {}
+      @servicegroup_name   = {}
+      super()
+    end
+
+    def definition
+      configured = configured_options
+      unless blank?(servicegroup_name)
+        configured.delete('service_description')
+        configured.delete('host_name')
+      end
+      get_definition(configured, 'serviceescalation')
+    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 servicegroup_name_list
+      @servicegroup_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)
+      update_members(hash, '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::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.key?(obj.to_s)
+          pop_object(obj, @host_name)
+          pop(self, obj)
+        end
+      when Nagios::Hostgroup
+        if @hostgroup_name.key?(obj.to_s)
+          pop_object(obj, @hostgroup_name)
+          pop(self, obj)
+        end
+      when Nagios::Servicegroup
+        if @servicegroup_name.key?(obj.to_s)
+          pop_object(obj, @servicegroup_name)
+          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::Timeperiod
+        @escalation_period = nil if @escalation_period == obj
+      end
+    end
+
+    def to_s
+      service_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(w u c r), 'escalation_options')
+    end
+
+    private
+
+    def config_options
+      {
+        'name' => 'name',
+        'use' => 'use',
+        'service_description' => 'service_description',
+        'contacts_list' => 'contacts',
+        'contact_groups_list' => 'contact_groups',
+        'escalation_period' => 'escalation_period',
+        'host_name_list' => 'host_name',
+        'hostgroup_name_list' => 'hostgroup_name',
+        'servicegroup_name_list' => 'servicegroup_name',
+        'escalation_options' => 'escalation_options',
+        'first_notification' => 'first_notification',
+        'last_notification' => 'last_notification',
+        'notification_interval' => 'notification_interval',
+        'register' => 'register',
+      }
+    end
+
+    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) }
+      obj.servicegroup_name.each { |m| push(m) }
+    end
+  end
+end

data/cookbooks/nagios/libraries/servicegroup.rb

@@ -0,0 +1,142 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook:: nagios
+# Library:: servicegroup
+#
+# 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 servicegroup options,
+  #  that are used within nagios configurations.
+  #
+  class Servicegroup < Nagios::Base
+    attr_reader   :servicegroup_name,
+                  :members,
+                  :servicegroup_members
+
+    attr_accessor :alias,
+                  :notes,
+                  :notes_url,
+                  :action_url
+
+    def initialize(servicegroup_name)
+      @servicegroup_name = servicegroup_name
+      @members = {}
+      @servicegroup_members = {}
+      super()
+    end
+
+    def definition
+      get_definition(configured_options, 'servicegroup')
+    end
+
+    def import(hash)
+      update_options(hash)
+      update_members(hash, 'members', Nagios::Service, true)
+      update_members(hash, 'servicegroup_members', Nagios::Servicegroup, true)
+    end
+
+    def members_list
+      result = lookup_hostgroup_members
+      result.join(',')
+    end
+
+    def push(obj)
+      case obj
+      when Nagios::Service
+        push_object(obj, @members)
+      when Nagios::Servicegroup
+        push_object(obj, @servicegroup_members)
+      end
+    end
+
+    def pop(obj)
+      return if obj == self
+      case obj
+      when Nagios::Service
+        if @members.key?(obj.to_s)
+          pop_object(obj, @members)
+          pop(self, obj)
+        end
+      when Nagios::Servicegroup
+        if @servicegroup_members.key?(obj.to_s)
+          pop_object(obj, @servicegroup_members)
+          pop(self, obj)
+        end
+      end
+    end
+
+    def self.create(name)
+      Nagios.instance.find(Nagios::Servicegroup.new(name))
+    end
+
+    def servicegroup_members_list
+      @servicegroup_members.values.map(&:to_s).sort.join(',')
+    end
+
+    def to_s
+      servicegroup_name
+    end
+
+    private
+
+    def config_options
+      {
+        'servicegroup_name' => 'servicegroup_name',
+        'members_list' => 'members',
+        'servicegroup_members_list' => 'servicegroup_members',
+        'alias' => 'alias',
+        'notes' => 'notes',
+        'notes_url' => 'notes_url',
+        'action_url' => 'action_url',
+      }
+    end
+
+    def convert_hostgroup_hash(hash)
+      result = []
+      hash.sort.to_h.each do |group_name, group_members|
+        group_members.sort.each do |member|
+          result << member
+          result << group_name
+        end
+      end
+      result
+    end
+
+    def lookup_hostgroup_members
+      hostgroup_hash = {}
+      @members.each do |service_name, service_obj|
+        hostgroup_array = []
+        service_obj.hostgroups.each do |hostgroup_name, hostgroup_obj|
+          if service_obj.not_modifiers['hostgroup_name'][hostgroup_name] != '!'
+            hostgroup_array += hostgroup_obj.members.keys
+          else
+            hostgroup_array -= hostgroup_obj.members.keys
+          end
+        end
+        hostgroup_hash[service_name] = hostgroup_array
+      end
+      convert_hostgroup_hash(hostgroup_hash)
+    end
+
+    def merge_members(obj)
+      obj.members.each { |m| push(m) }
+      obj.servicegroup_members.each { |m| push(m) }
+    end
+  end
+end

data/cookbooks/nagios/libraries/timeperiod.rb

@@ -0,0 +1,159 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook:: nagios
+# Library:: timeperiod
+#
+# 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 timeperiodentries,
+  #  that are used within the timeperiod nagios configurations.
+  #
+  class Timeperiodentry
+    attr_reader :moment,
+                :period
+
+    def initialize(moment, period)
+      @moment = moment
+      @period = check_period(period)
+    end
+
+    def to_s
+      moment
+    end
+
+    private
+
+    def check_period(period)
+      return period if period =~ /^(([01]?[0-9]|2[0-3])\:[0-5][0-9]-([01]?[0-9]|2[0-4])\:[0-5][0-9],?)*$/
+      nil
+    end
+  end
+
+  #
+  # This class holds all methods with regard to timeperiod options,
+  # that are used within nagios configurations.
+  #
+  class Timeperiod < Nagios::Base
+    attr_reader   :timeperiod_name
+
+    attr_accessor :alias,
+                  :periods,
+                  :exclude
+
+    def initialize(timeperiod_name)
+      @timeperiod_name = timeperiod_name
+      @periods = {}
+      @exclude = {}
+      super()
+    end
+
+    def self.create(name)
+      Nagios.instance.find(Nagios::Timeperiod.new(name))
+    end
+
+    def definition
+      configured = configured_options
+      periods.each_value { |v| configured[v.moment] = v.period }
+      get_definition(configured, 'timeperiod')
+    end
+
+    # exclude
+    # This directive is used to specify the short names of other timeperiod definitions
+    # whose time ranges should be excluded from this timeperiod.
+    # Multiple timeperiod names should be separated with a comma.
+
+    def exclude
+      @exclude.values.map(&:to_s).sort.join(',')
+    end
+
+    def import(hash)
+      update_options(hash)
+      if hash['times'].respond_to?('each_pair')
+        hash['times'].each { |k, v| push(Nagios::Timeperiodentry.new(k, v)) }
+      end
+      update_members(hash, 'exclude', Nagios::Timeperiod)
+    end
+
+    def push(obj)
+      case obj
+      when Nagios::Timeperiod
+        push_object(obj, @exclude)
+      when Nagios::Timeperiodentry
+        push_object(obj, @periods) unless obj.period.nil?
+      end
+    end
+
+    def pop(obj)
+      return if obj == self
+      case obj
+      when Nagios::Timeperiod
+        if @exclude.key?(obj.to_s)
+          pop_object(obj, @exclude)
+          pop(self, obj)
+        end
+      when Nagios::Timeperiodentry
+        if @periods.key?(obj.to_s)
+          pop_object(obj, @periods)
+          pop(self, obj)
+        end
+      end
+    end
+
+    def to_s
+      timeperiod_name
+    end
+
+    # [weekday]
+    # The weekday directives ("sunday" through "saturday")are comma-delimited
+    # lists of time ranges that are "valid" times for a particular day of the week.
+    # Notice that there are seven different days for which you can define time
+    # ranges (Sunday through Saturday). Each time range is in the form of
+    # HH:MM-HH:MM, where hours are specified on a 24 hour clock.
+    # For example, 00:15-24:00 means 12:15am in the morning for this day until
+    # 12:00am midnight (a 23 hour, 45 minute total time range).
+    # If you wish to exclude an entire day from the timeperiod, simply do not include
+    # it in the timeperiod definition.
+
+    # [exception]
+    # You can specify several different types of exceptions to the standard rotating
+    # weekday schedule. Exceptions can take a number of different forms including single
+    # days of a specific or generic month, single weekdays in a month, or single calendar
+    # dates. You can also specify a range of days/dates and even specify skip intervals
+    # to obtain functionality described by "every 3 days between these dates".
+    # Rather than list all the possible formats for exception strings, I'll let you look
+    # at the example timeperiod definitions above to see what's possible.
+    # Weekdays and different types of exceptions all have different levels of precedence,
+    # so its important to understand how they can affect each other.
+
+    private
+
+    def config_options
+      {
+        'timeperiod_name' => 'timeperiod_name',
+        'alias' => 'alias',
+        'exclude' => 'exclude',
+      }
+    end
+
+    def merge_members(obj)
+      obj.periods.each { |m| push(m) }
+      obj.exclude.each { |m| push(m) }
+    end
+  end
+end

data/cookbooks/nagios/libraries/users_helper.rb

@@ -0,0 +1,54 @@
+require 'chef/log'
+require 'chef/search/query'
+
+# Simplify access to list of all valid Nagios users
+class NagiosUsers
+  attr_accessor :users
+
+  def initialize(node)
+    @node = node
+    @users = []
+
+    user_databag = node['nagios']['users_databag'].to_sym
+    group = node['nagios']['users_databag_group']
+
+    if node['nagios']['server']['use_encrypted_data_bags']
+      load_encrypted_databag(user_databag)
+    else
+      search_databag(user_databag, group)
+    end
+  end
+
+  def return_user_contacts
+    contacts = []
+    # add base contacts from nagios_users data bag
+    @users.each do |s|
+      contacts << s['id']
+    end
+    contacts
+  end
+
+  private
+
+  def fail_search(user_databag)
+    Chef::Log.fatal("\"#{user_databag}\" databag could not be found.")
+    raise "\"#{user_databag}\" databag could not be found."
+  end
+
+  def load_encrypted_databag(user_databag)
+    data_bag(user_databag).each do |u, _|
+      d = data_bag_item(user_databag, u)
+      @users << d unless d['nagios'].nil? || d['nagios']['email'].nil?
+    end
+  rescue Net::HTTPServerException
+    fail_search(user_databag)
+  end
+
+  def search_databag(user_databag, group)
+    Chef::Search::Query.new.search(user_databag, "groups:#{group} NOT action:remove") do |d|
+      @users << d unless d['nagios'].nil? || d['nagios']['email'].nil?
+    end
+  rescue Net::HTTPServerException
+    fail_search(user_databag)
+  end
+end

data/cookbooks/nagios/metadata.json

@@ -0,0 +1,44 @@
+{
+  "name": "nagios",
+  "description": "Installs and configures Nagios server",
+  "long_description": "",
+  "maintainer": "Sous Chefs",
+  "maintainer_email": "help@sous-chefs.org",
+  "license": "Apache-2.0",
+  "platforms": {
+    "oracle": ">= 8.0",
+    "redhat": ">= 8.0",
+    "debian": ">= 11.0",
+    "ubuntu": ">= 20.04"
+  },
+  "dependencies": {
+    "apache2": ">= 9.0",
+    "nginx": ">= 11.2",
+    "nrpe": ">= 0.0.0",
+    "php": ">= 10.0",
+    "yum-epel": ">= 0.0.0",
+    "zap": ">= 0.6.0"
+  },
+  "providing": {
+
+  },
+  "recipes": {
+
+  },
+  "version": "12.1.201",
+  "source_url": "https://github.com/sous-chefs/nagios",
+  "issues_url": "https://github.com/sous-chefs/nagios/issues",
+  "privacy": false,
+  "chef_versions": [
+    [
+      ">= 15.3"
+    ]
+  ],
+  "ohai_versions": [
+
+  ],
+  "gems": [
+
+  ],
+  "eager_load_libraries": true
+}

data/cookbooks/nagios/metadata.rb

@@ -0,0 +1,22 @@
+name             'nagios'
+maintainer       'Sous Chefs'
+maintainer_email 'help@sous-chefs.org'
+license          'Apache-2.0'
+description      'Installs and configures Nagios server. Forked so I can install the correct version of PHP.'
+version          '12.1.201'
+issues_url       'https://github.com/sous-chefs/nagios/issues'
+source_url       'https://github.com/sous-chefs/nagios'
+chef_version     '>= 15.3'
+
+depends 'apache2', '>= 9.0'
+depends 'nginx', '>= 11.2'
+depends 'nrpe'
+depends 'php', '>= 10.0'
+depends 'yum-epel'
+depends 'zap', '>= 0.6.0'
+
+suports 'centos', '>= 8.0'
+supports 'oracle', '>= 8.0'
+supports 'redhat', '>= 8.0'
+supports 'debian', '>= 11.0'
+supports 'ubuntu', '>= 20.04'