cloud-mu 2.1.0beta → 3.0.0beta

data/cookbooks/nagios/libraries/servicedependency.rb

@@ -1,215 +0,0 @@
-#
-# Author:: Sander Botman <sbotman@schubergphilis.com>
-# Cookbook Name:: 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.keys?(obj.to_s)
-          pop_object(obj, @host_name)
-          pop(self, obj)
-        end
-      when Nagios::Hostgroup
-        if @host_name.keys?(obj.to_s)
-          pop_object(obj, @hostgroup_name)
-          pop(self, obj)
-        end
-      when Nagios::Servicegroup
-        if @host_name.keys?(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.keys?(obj.to_s)
-          pop_object(obj, @dependent_host_name)
-          obj.pop(self)
-        end
-      when Nagios::Hostgroup
-        if @dependent_hostgroup_name.keys?(obj.to_s)
-          pop_object(obj, @dependent_hostgroup_name)
-          obj.pop(self)
-        end
-      when Nagios::Servicegroup
-        if @dependent_servicegroup_name.keys?(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

data/cookbooks/nagios/libraries/serviceescalation.rb

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

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