icinga2 0.7.0.1 → 0.8.1.2

data/lib/icinga2/hostgroups.rb

@@ -17,23 +17,23 @@ module Icinga2
     #
     # @return [Hash] result
     #
-    def add_hostgroup(params = {})
+    def add_hostgroup( params )
 
-      host_group = params.dig(:host_group)
+      raise ArgumentError.new('only Hash are allowed') unless( params.is_a?(Hash) )
+      raise ArgumentError.new('missing params') if( params.size.zero? )
+
+      host_group   = params.dig(:host_group)
       display_name = params.dig(:display_name)
 
-      if host_group.nil?
-        return {
-          status: 404,
-          message: 'no name for the hostgroup'
-        }
-      end
+      raise ArgumentError.new('Missing host_group') if( host_group.nil? )
+      raise ArgumentError.new('Missing display_name') if( display_name.nil? )
 
-      Network.put(url: format('%s/v1/objects/hostgroups/%s', @icinga_api_url_base, host_group),
+      Network.put(
+        url: format('%s/objects/hostgroups/%s', @icinga_api_url_base, host_group),
         headers: @headers,
         options: @options,
-        payload: { 'attrs' => { 'display_name' => display_name } })
-
+        payload: { 'attrs' => { 'display_name' => display_name } }
+      )
     end
 
     # delete a hostgroup
@@ -46,21 +46,20 @@ module Icinga2
     #
     # @return [Hash] result
     #
-    def delete_hostgroup(params = {})
+    def delete_hostgroup( params )
+
+      raise ArgumentError.new('only Hash are allowed') unless( params.is_a?(Hash) )
+      raise ArgumentError.new('missing params') if( params.size.zero? )
 
       host_group = params.dig(:host_group)
 
-      if host_group.nil?
-        return {
-          status: 404,
-          message: 'no name for the hostgroup'
-        }
-      end
+      raise ArgumentError.new('Missing host_group') if( host_group.nil? )
 
-      Network.delete(host: host_group,
-        url: format('%s/v1/objects/hostgroups/%s?cascade=1', @icinga_api_url_base, host_group),
+      Network.delete(
+        url: format('%s/objects/hostgroups/%s?cascade=1', @icinga_api_url_base, host_group),
         headers: @headers,
-        options: @options)
+        options: @options
+      )
     end
 
     # returns all usersgroups
@@ -72,36 +71,51 @@ module Icinga2
     #    @icinga.hostgroups
     #
     # @example to get one user
-    #    @icinga.hostgroups(name: 'linux-servers')
+    #    @icinga.hostgroups(host_group: 'linux-servers')
     #
     # @return [Hash] returns a hash with all hostgroups
     #
-    def hostgroups(params = {})
+    def hostgroups( params = {} )
 
       host_group = params.dig(:host_group)
 
-      Network.get(host: host_group,
-        url: format('%s/v1/objects/hostgroups/%s', @icinga_api_url_base, host_group),
+      url =
+      if( host_group.nil? )
+        format( '%s/objects/hostgroups'   , @icinga_api_url_base )
+      else
+        format( '%s/objects/hostgroups/%s', @icinga_api_url_base, host_group )
+      end
+
+      data = Network.api_data(
+        url: url,
         headers: @headers,
-        options: @options)
+        options: @options
+      )
+
+      return data.dig('results') if( data.dig(:status).nil? )
 
+      nil
     end
 
     # returns true if the hostgroup exists
     #
-    # @param [String] name the name of the hostgroup
+    # @param [String] host_group the name of the hostgroup
     #
     # @example
     #    @icinga.exists_hostgroup?('linux-servers')
     #
     # @return [Bool] returns true if the hostgroup exists
     #
-    def exists_hostgroup?(name)
-      result = hostgroups(host_group: name)
-      result = JSON.parse(result) if result.is_a?(String)
-      status = result.dig(:status)
+    def exists_hostgroup?( host_group )
+
+      raise ArgumentError.new('only String are allowed') unless( host_group.is_a?(String) )
+      raise ArgumentError.new('Missing host_group') if( host_group.size.zero? )
+
+      result = hostgroups(host_group: host_group)
+      result = JSON.parse( result ) if  result.is_a?( String )
+
+      return true if  !result.nil? && result.is_a?(Array)
 
-      return true if  !status.nil? && status == 200
       false
     end
 

data/lib/icinga2/hosts.rb

@@ -32,7 +32,10 @@ module Icinga2
     #
     # @return [Hash]
     #
-    def add_host( params = {} )
+    def add_host( params )
+
+      raise ArgumentError.new('only Hash are allowed') unless( params.is_a?(Hash) )
+      raise ArgumentError.new('missing params') if( params.size.zero? )
 
       host               = params.dig(:host)
       fqdn               = params.dig(:fqdn)
@@ -46,12 +49,14 @@ module Icinga2
       action_url         = params.dig(:action_url)
       vars               = params.dig(:vars) || {}
 
-      if( host.nil? )
-        return {
-          status: 404,
-          message: 'missing host name'
-        }
-      end
+      raise ArgumentError.new('Missing host') if( host.nil? )
+      raise ArgumentError.new('only true or false for notifications are allowed') unless( notifications.is_a?(TrueClass) || notifications.is_a?(FalseClass) )
+      raise ArgumentError.new('only Integer for max_check_attempts are allowed') unless( max_check_attempts.is_a?(Integer) )
+      raise ArgumentError.new('only Integer for check_interval are allowed') unless( check_interval.is_a?(Integer) )
+      raise ArgumentError.new('only Integer for retry_interval are allowed') unless( retry_interval.is_a?(Integer) )
+      raise ArgumentError.new('only String for notes are allowed') unless( notes.is_a?(String) || notes.nil? )
+      raise ArgumentError.new('only String for notes_url are allowed') unless( notes_url.is_a?(String) || notes_url.nil? )
+      raise ArgumentError.new('only Hash for vars are allowed') unless( vars.is_a?(Hash) )
 
       if( fqdn.nil? )
         # build FQDN
@@ -79,14 +84,14 @@ module Icinga2
         payload['attrs']['zone'] = @icinga_satellite
       end
 
-      logger.debug( JSON.pretty_generate( payload ) )
+      # logger.debug( JSON.pretty_generate( payload ) )
 
-      Network.put(         host: host,
-        url: format( '%s/v1/objects/hosts/%s', @icinga_api_url_base, host ),
+      Network.put(
+        url: format( '%s/objects/hosts/%s', @icinga_api_url_base, host ),
         headers: @headers,
         options: @options,
-        payload: payload )
-
+        payload: payload
+      )
     end
 
     # delete a host
@@ -99,23 +104,20 @@ module Icinga2
     #
     # @return [Hash] result
     #
-    def delete_host( params = {} )
+    def delete_host( params )
 
-      host = params.dig(:host)
+      raise ArgumentError.new('only Hash are allowed') unless( params.is_a?(Hash) )
+      raise ArgumentError.new('missing params') if( params.size.zero? )
 
-      if( host.nil? )
+      host = params.dig(:host)
 
-        return {
-          status: 404,
-          message: 'missing host name'
-        }
-      end
+      raise ArgumentError.new('Missing host') if( host.nil? )
 
-      Network.delete(         host: host,
-        url: format( '%s/v1/objects/hosts/%s?cascade=1', @icinga_api_url_base, host ),
+      Network.delete(
+        url: format( '%s/objects/hosts/%s?cascade=1', @icinga_api_url_base, host ),
         headers: @headers,
-        options: @options )
-
+        options: @options
+      )
     end
 
     # return hosts
@@ -130,9 +132,9 @@ module Icinga2
     #    @icinga.hosts
     #
     # @example to get one host
-    #    @icinga.host(host: 'icinga2')
+    #    @icinga.hosts(host: 'icinga2')
     #
-    # @return [Hash]
+    # @return [Array]
     #
     def hosts( params = {} )
 
@@ -141,33 +143,40 @@ module Icinga2
       filter = params.dig(:filter)
       joins  = params.dig(:joins)
 
-      payload['attrs'] = attrs unless  attrs.nil?
-      payload['filter'] = filter unless  filter.nil?
-      payload['joins'] = joins unless  joins.nil?
+      payload['attrs']  = attrs  unless attrs.nil?
+      payload['filter'] = filter unless filter.nil?
+      payload['joins']  = joins  unless joins.nil?
 
-      Network.get(         host: host,
-        url: format( '%s/v1/objects/hosts/%s', @icinga_api_url_base, host ),
+      data = Network.api_data(
+        url: format( '%s/objects/hosts/%s', @icinga_api_url_base, host ),
         headers: @headers,
-        options: @options )
+        options: @options
+      )
 
+      return data.dig('results') if( data.dig(:status).nil? )
+
+      nil
     end
 
     # returns true if the host exists
     #
-    # @param [String] name
+    # @param [String] host_name
     #
     # @example
     #    @icinga.exists_host?('icinga2')
     #
     # @return [Bool]
     #
-    def exists_host?( name )
+    def exists_host?( host_name )
+
+      raise ArgumentError.new('only String are allowed') unless( host_name.is_a?(String) )
+      raise ArgumentError.new('Missing host_name') if( host_name.size.zero? )
 
-      result = hosts( name: name )
+      result = hosts( host: host_name )
       result = JSON.parse( result ) if  result.is_a?( String )
-      status = result.dig(:status)
 
-      return true if  !status.nil? && status == 200
+      return true if  !result.nil? && result.is_a?(Array)
+
       false
     end
 
@@ -191,115 +200,219 @@ module Icinga2
       attrs   = params.dig(:attrs)
       filter  = params.dig(:filter)
       joins   = params.dig(:joins)
+
+#       raise ArgumentError.new('only Array for attrs are allowed') unless( attrs.is_a?(Hash) )
+#       raise ArgumentError.new('only Array for filter are allowed') unless( filter.is_a?(Hash) )
+#       raise ArgumentError.new('only Array for joins are allowed') unless( joins.is_a?(Hash) )
+
       payload = {}
+      results = nil
 
       if( attrs.nil? )
         attrs = %w[name state acknowledgement downtime_depth last_check]
       end
 
-      payload['attrs'] = attrs unless  attrs.nil?
-      payload['filter'] = filter unless  filter.nil?
-      payload['joins'] = joins unless  joins.nil?
+      payload['attrs']  = attrs  unless attrs.nil?
+      payload['filter'] = filter unless filter.nil?
+      payload['joins']  = joins  unless joins.nil?
 
-      Network.get(         host: nil,
-        url: format( '%s/v1/objects/hosts', @icinga_api_url_base ),
+      data = Network.api_data(
+        url: format( '%s/objects/hosts', @icinga_api_url_base ),
         headers: @headers,
         options: @options,
-        payload: payload )
+        payload: payload
+      )
+
+      status  = data.dig(:status)
+
+      if( status.nil? )
+
+        results = data.dig('results')
+
+        unless( results.nil? )
+
+          all_hosts = results.clone
 
+          unless( all_hosts.nil? )
+
+            # global var for count of all hosts
+            @hosts_all           = all_hosts.size
+            # global var for count of all host with a problem
+            @hosts_problems      = count_problems(results)
+            # global var for count of all gost with state HOSTS_DOWN
+            @hosts_problems_down     = count_problems(results, Icinga2::HOSTS_DOWN)
+            @hosts_problems_critical = count_problems(results, Icinga2::HOSTS_CRITICAL)
+            @hosts_problems_unknown  = count_problems(results, Icinga2::HOSTS_UNKNOWN)
+
+          end
+        end
+      end
+
+      results
     end
 
-    # return count of hosts with problems
+    # returns adjusted hosts state
     #
     # @example
-    #    @icinga.host_problems
+    #    @icinga.cib_data
+    #    @icinga.host_objects
+    #    handled, down = @icinga.hosts_adjusted.values
     #
-    # @return [Integer]
+    #    h = @icinga.hosts_adjusted
+    #    down = h.dig(:down_adjusted)
     #
-    def host_problems
+    # @return [Hash]
+    #    * handled_problems
+    #    * down_adjusted
+    #
+    def hosts_adjusted
 
-      data     = host_objects
-      problems = 0
+      raise ArgumentError.new('Integer for @hosts_problems_down needed') unless( @hosts_problems_down.is_a?(Integer) )
+      raise ArgumentError.new('Integer for @hosts_problems_critical needed') unless( @hosts_problems_critical.is_a?(Integer) )
+      raise ArgumentError.new('Integer for @hosts_problems_unknown needed') unless( @hosts_problems_unknown.is_a?(Integer) )
+      raise ArgumentError.new('Integer for @hosts_down needed') unless( @hosts_down.is_a?(Integer) )
 
-      data = JSON.parse(data) if  data.is_a?(String)
-      nodes = data.dig(:nodes)
+      # calculate host problems adjusted by handled problems
+      # count togther handled host problems
+      handled_problems = @hosts_problems_down + @hosts_problems_critical + @hosts_problems_unknown
+      down_adjusted    = @hosts_down - handled_problems
 
-      unless( nodes.nil? )
+      {
+        handled_problems: handled_problems.to_i,
+        down_adjusted: down_adjusted.to_i
+      }
+    end
 
-        nodes.each do |n|
+    # return count of hosts with problems
+    #
+    # @example
+    #    @icinga.count_hosts_with_problems
+    #
+    # @return [Integer]
+    #
+    def count_hosts_with_problems
 
-          attrs           = n.last.dig('attrs')
-          state           = attrs.dig('state')           || 0
-          downtime_depth  = attrs.dig('downtime_depth')  || 0
-          acknowledgement = attrs.dig('acknowledgement') || 0
+      host_data = host_objects
+      host_data = JSON.parse(host_data) if  host_data.is_a?(String)
 
-          if( state != 0 && downtime_depth.zero? && acknowledgement.zero? )
-            problems += 1
-          end
+      f = host_data.select { |t| t.dig('attrs','state') != 0 && t.dig('attrs','downtime_depth').zero? && t.dig('attrs','acknowledgement').zero? }
 
-        end
-      end
-      problems
+      f.size
     end
 
-    # return a list of host with problems
+    # return a list of hosts with problems
     #
     # @param [Integer] max_items numbers of list entries
     #
     # @example
-    #    @icinga.problem_hosts
+    #    @icinga.list_hosts_with_problems
     #
     # @return [Hash]
     #
-    def problem_hosts( max_items = 5 )
+    def list_hosts_with_problems( max_items = 5 )
 
-      @host_problems = {}
-      @host_problems_severity = {}
+      raise ArgumentError.new('only Integer for max_items are allowed') unless( max_items.is_a?(Integer) )
 
-      host_data = host_objects
+      host_problems = {}
+      host_problems_severity = {}
 
-      host_data = JSON.parse( host_data ) if  host_data.is_a?(String)
-      host_data = host_data.dig(:nodes)
+      host_data = host_objects
+      host_data = JSON.parse( host_data ) if host_data.is_a?(String)
 
       unless( host_data.nil? )
 
-        host_data.each do |_host,v|
-
-          name  = v.dig('name')
-          state = v.dig('attrs','state')
+        host_data.each do |h,_v|
+          name  = h.dig('name')
+          state = h.dig('attrs','state')
 
-          next if  state.zero?
+          next if state.to_i.zero?
 
-          @host_problems[name] = host_severity(v)
+          host_problems[name] = host_severity(h)
         end
+      end
 
-        # get the count of problems
-        #
-        if( @host_problems.count != 0 )
-          @host_problems.keys[1..max_items].each { |k,_v| @host_problems_severity[k] = @host_problems[k] }
-        end
+      # get the count of problems
+      #
+      if( host_problems.count != 0 )
+        host_problems.keys[1..max_items].each { |k,_v| host_problems_severity[k] = host_problems[k] }
       end
-      @host_problems_severity
 
+      host_problems_severity
+    end
+
+    # returns a counter of all hosts
+    #
+    # @example
+    #    @icinga.host_objects
+    #    @icinga.hosts_all
+    #
+    # @return [Integer]
+    #
+    def hosts_all
+      @hosts_all
+    end
+
+    # returns data with host problems
+    #
+    # @example
+    #    @icinga.host_objects
+    #    all, down, critical, unknown = @icinga.host_problems.values
+    #
+    #    p = @icinga.host_problems
+    #    down = h.dig(:down)
+    #
+    # @return [Hash]
+    #    * all
+    #    * down
+    #    * critical
+    #    * unknown
+    #
+    def host_problems
+
+      problems_all      = @hosts_problems.nil?           ? 0 : @hosts_problems
+      problems_down     = @hosts_problems_down.nil?      ? 0 : @hosts_problems_down
+      problems_critical = @hosts_problems_critical.nil?  ? 0 : @hosts_problems_critical
+      problems_unknown  = @hosts_problems_unknown.nil?   ? 0 : @hosts_problems_unknown
+
+      {
+        all: problems_all.to_i,
+        down: problems_down.to_i,
+        critical: problems_critical.to_i,
+        unknown: problems_unknown.to_i
+      }
     end
 
+    protected
     # calculate a host severity
     #
     # stolen from Icinga Web 2
     # ./modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php
     #
-    # @param [Hash] host
+    # @param [Hash] params
+    # @option params [hash] attrs ()
+    #   * state [Float]
+    #   * acknowledgement [Float] (default: 0)
+    #   * downtime_depth [Float] (default: 0)
     #
-    # @private
+    # @api protected
     #
-    # @return [Hash]
+    # @example
+    #   host_severity( {'attrs' => { 'state' => 0.0, 'acknowledgement' => 0.0, 'downtime_depth' => 0.0 } } )
     #
-    def host_severity( host )
+    # @return [Integer]
+    #
+    def host_severity( params )
+
+      raise ArgumentError.new('only Hash are allowed') unless( params.is_a?(Hash) )
+      raise ArgumentError.new('missing params') if( params.size.zero? )
+
+      state           = params.dig('attrs','state')
+      acknowledgement = params.dig('attrs','acknowledgement') || 0
+      downtime_depth  = params.dig('attrs','downtime_depth')  || 0
 
-      attrs           = host.dig('attrs')
-      state           = attrs.dig('state')
-      acknowledgement = attrs.dig('acknowledgement') || 0
-      downtime_depth  = attrs.dig('downtime_depth')  || 0
+      raise ArgumentError.new('only Float for state are allowed') unless( state.is_a?(Float) )
+      raise ArgumentError.new('only Float for acknowledgement are allowed') unless( acknowledgement.is_a?(Float) )
+      raise ArgumentError.new('only Float for downtime_depth are allowed') unless( downtime_depth.is_a?(Float) )
 
       severity = 0
 
@@ -312,7 +425,7 @@ module Icinga2
           4
         end
 
-      severity += 16 if object_has_been_checked?(host)
+      severity += 16 if object_has_been_checked?(params)
 
       unless state.zero?