cloud-mu 1.9.0.pre.beta

data/cookbooks/nagios/libraries/serviceescalation.rb

@@ -0,0 +1,195 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook Name:: 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.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::Servicegroup
+        if @servicegroup_name.keys?(obj.to_s)
+          pop_object(obj, @servicegroup_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
+      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
+    # 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) }
+      obj.servicegroup_name.each { |m| push(m) }
+    end
+  end
+end

data/cookbooks/nagios/libraries/servicegroup.rb

@@ -0,0 +1,144 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook Name:: 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.keys?(obj.to_s)
+          pop_object(obj, @members)
+          pop(self, obj)
+        end
+      when Nagios::Servicegroup
+        if @servicegroup_members.keys?(obj.to_s)
+          pop_object(obj, @servicegroup_members)
+          pop(self, obj)
+        end
+      end
+    end
+    # rubocop:enable MethodLength
+
+    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
+    # rubocop:enable MethodLength
+
+    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,160 @@
+#
+# Author:: Sander Botman <sbotman@schubergphilis.com>
+# Cookbook Name:: 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.values.each { |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.keys?(obj.to_s)
+          pop_object(obj, @exclude)
+          pop(self, obj)
+        end
+      when Nagios::Timeperiodentry
+        if @periods.keys?(obj.to_s)
+          pop_object(obj, @periods)
+          pop(self, obj)
+        end
+      end
+    end
+    # rubocop:enable MethodLength
+
+    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)
+    Chef::DataBag.load(user_databag).each do |u, _|
+      d = Chef::EncryptedDataBagItem.load(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.rb

@@ -0,0 +1,25 @@
+name              'nagios'
+maintainer 'Mu'
+maintainer_email 'mu-developers@googlegroups.com'
+license           'BSD-3-Clause'
+description       'Installs and configures Nagios server'
+long_description  IO.read(File.join(File.dirname(__FILE__), 'README.md'))
+version           '7.2.7'
+source_url 'https://github.com/cloudamatic/mu'
+issues_url 'https://github.com/cloudamatic/mu/issues'
+chef_version     '>= 14.0' if respond_to?(:chef_version)
+
+recipe 'default', 'Installs Nagios server.'
+recipe 'nagios::pagerduty', 'Integrates contacts w/ PagerDuty API'
+
+depends 'apache2', '< 4.0'
+depends 'php', '< 6.0'
+depends 'zap', '>= 0.6.0'
+
+%w(chef_nginx nginx_simplecgi yum-epel nrpe ).each do |cb|
+  depends cb
+end
+
+%w( debian ubuntu redhat centos fedora scientific amazon oracle).each do |os|
+  supports os
+end