icinga2 0.7.0.1 → 0.8.1.2

data/lib/icinga2/statistics.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+#
+
+module Icinga2
+
+  # namespace for icinga2 statistics
+  module Statistics
+
+
+    # return statistic data for latency and execution_time
+    #
+    # @example
+    #    @icinga.cib_data
+    #    latency, execution_time = @icinga.average_statistics.values
+    #
+    #    h = @icinga.average_statistics
+    #    latency = h.dig(:latency)
+    #
+    # @return [Hash]
+    #    * latency (Float)
+    #    * execution_time (Float)
+    #
+    def average_statistics
+      avg_latency        = @avg_latency.nil?        ? 0 : @avg_latency
+      avg_execution_time = @avg_execution_time.nil? ? 0 : @avg_execution_time
+
+      {
+        latency: avg_latency.to_f,
+        execution_time: avg_execution_time.to_f
+      }
+    end
+
+    # return statistic data for intervall data
+    #
+    # @example
+    #    @icinga.cib_data
+    #    hosts_active_checks, hosts_passive_checks, services_active_checks, services_passive_checks = @icinga.interval_statistics.values
+    #
+    #    i = @icinga.interval_statistics
+    #    hosts_active_checks = i.dig(:hosts_active_checks)
+    #
+    # @return [Hash]
+    #    * hosts_active_checks (Float)
+    #    * hosts_passive_checks (Float)
+    #    * services_active_checks (Float)
+    #    * services_passive_checks (Float)
+    #
+    def interval_statistics
+
+      # take a look into https://github.com/Icinga/pkg-icinga2-debian/blob/master/lib/icinga/cib.cpp
+
+      hosts_active_checks     = @hosts_active_checks_1min.nil?     ? 0 : @hosts_active_checks_1min
+      hosts_passive_checks    = @hosts_passive_checks_1min.nil?    ? 0 : @hosts_passive_checks_1min
+      services_active_checks  = @services_active_checks_1min.nil?  ? 0 : @services_active_checks_1min
+      services_passive_checks = @services_passive_checks_1min.nil? ? 0 : @services_passive_checks_1min
+
+      {
+        hosts_active_checks: hosts_active_checks.to_f,
+        hosts_passive_checks: hosts_passive_checks.to_f,
+        services_active_checks: services_active_checks.to_f,
+        services_passive_checks: services_passive_checks.to_f
+      }
+    end
+
+    # return statistic data for services
+    #
+    # @example
+    #    @icinga.cib_data
+    #    ok, warning, critical, unknown, pending, in_downtime, ack = @icinga.service_statistics.values
+    #
+    #    s = @icinga.service_statistics
+    #    critical = s.dig(:critical)
+    #
+    # @return [Hash]
+    #    * ok (Integer)
+    #    * warning (Integer)
+    #    * critical (Integer)
+    #    * unknown (Integer)
+    #    * pending (Integer)
+    #    * in_downtime (Integer)
+    #    * acknowledged (Integer)
+    #
+    def service_statistics
+
+      services_ok           = @services_ok.nil?           ? 0 : @services_ok
+      services_warning      = @services_warning.nil?      ? 0 : @services_warning
+      services_critical     = @services_critical.nil?     ? 0 : @services_critical
+      services_unknown      = @services_unknown.nil?      ? 0 : @services_unknown
+      services_pending      = @services_pending.nil?      ? 0 : @services_pending
+      services_in_downtime  = @services_in_downtime.nil?  ? 0 : @services_in_downtime
+      services_acknowledged = @services_acknowledged.nil? ? 0 : @services_acknowledged
+
+      {
+        ok: services_ok.to_i,
+        warning: services_warning.to_i,
+        critical: services_critical.to_i,
+        unknown: services_unknown.to_i,
+        pending: services_pending.to_i,
+        in_downtime: services_in_downtime.to_i,
+        acknowledged: services_acknowledged.to_i
+      }
+    end
+
+    # return statistic data for hosts
+    #
+    # @example
+    #    @icinga.cib_data
+    #    up, down, pending, unreachable, in_downtime, ack = @icinga.host_statistics.values
+    #
+    #    h = @icinga.host_statistics
+    #    pending = h.dig(:pending)
+    #
+    # @return [Hash]
+    #    * up (Integer)
+    #    * down (Integer)
+    #    * pending (Integer)
+    #    * unreachable (Integer)
+    #    * in_downtime (Integer)
+    #    * acknowledged (Integer)
+    #
+    def host_statistics
+
+      hosts_up           = @hosts_up.nil?           ? 0 : @hosts_up
+      hosts_down         = @hosts_down.nil?         ? 0 : @hosts_down
+      hosts_pending      = @hosts_pending.nil?      ? 0 : @hosts_pending
+      hosts_unreachable  = @hosts_unreachable.nil?  ? 0 : @hosts_unreachable
+      hosts_in_downtime  = @hosts_in_downtime.nil?  ? 0 : @hosts_in_downtime
+      hosts_acknowledged = @hosts_acknowledged.nil? ? 0 : @hosts_acknowledged
+
+      {
+        up: hosts_up.to_i,
+        down: hosts_down.to_i,
+        pending: hosts_pending.to_i,
+        unreachable: hosts_unreachable.to_i,
+        in_downtime: hosts_in_downtime.to_i,
+        acknowledged: hosts_acknowledged.to_i
+      }
+    end
+
+
+    # return queue statistics from the api
+    #
+    # @example
+    #    @icinga.work_queue_statistics
+    #
+    # @return [Hash]
+    #
+    def work_queue_statistics
+
+      stats  = {}
+      data   = Network.api_data(
+        url: format( '%s/status', @icinga_api_url_base ),
+        headers: @headers,
+        options: @options
+      )
+
+      return stats if data.nil?
+
+      if( data.dig(:status).nil? )
+        results = data.dig('results')
+
+        json_rpc_data  = results.find { |k| k['name'] == 'ApiListener' }
+        graphite_data  = results.find { |k| k['name'] == 'GraphiteWriter' }
+        ido_mysql_data = results.find { |k| k['name'] == 'IdoMysqlConnection' }
+
+        json_rpc_data  = json_rpc_data.dig('status', 'api', 'json_rpc') unless( json_rpc_data.nil? )
+        graphite_data  = graphite_data.dig('status', 'graphitewriter', 'graphite')       unless( graphite_data.nil? )
+        ido_mysql_data = ido_mysql_data.dig('status', 'idomysqlconnection', 'ido-mysql') unless( ido_mysql_data.nil? )
+
+        a = {}
+        a['json_rpc']  = json_rpc_data  if(json_rpc_data.is_a?(Hash))
+        a['graphite']  = graphite_data  if(graphite_data.is_a?(Hash))
+        a['ido-mysql'] = ido_mysql_data if(ido_mysql_data.is_a?(Hash))
+
+        key_list = %w[work_queue_item_rate query_queue_item_rate]
+
+        a.each do |k,v|
+          key_list.each do |key|
+            if( v.include?( key ))
+              attr_name = format('%s queue rate', k)
+              stats[attr_name] = v[key].to_f.round(3)
+            end
+          end
+        end
+      end
+
+      stats
+    end
+
+  end
+end

data/lib/icinga2/tools.rb

@@ -13,7 +13,7 @@ module Icinga2
     #
     # @return [Bool]
     #
-    def object_has_been_checked?(object)
+    def object_has_been_checked?( object )
       object.dig('attrs', 'last_check').positive?
     end
 
@@ -23,7 +23,7 @@ module Icinga2
     #
     # @return [String, String]
     #
-    def parse_version(version)
+    def parse_version( version )
 
       # version = "v2.4.10-504-gab4ba18"
       # version = "v2.4.10"
@@ -46,43 +46,48 @@ module Icinga2
     # return count of handled problems
     #
     # @param [Hash] objects
-    # @param [Integer] status
+    # @param [Integer] state (nil)
     #
     # @example for host objects
     #    h_objects = @icinga.host_objects
-    #    warning = @icinga.handled_problems(h_objects, Icinga2::HOSTS_DOWN)
+    #    all = @icinga.count_problems(h_objects)
+    #    down = @icinga.count_problems(h_objects, Icinga2::HOSTS_DOWN)
+    #    critical = @icinga.count_problems(h_objects, Icinga2::HOSTS_CRITICAL)
+    #    unknown = @icinga.count_problems(h_objects, Icinga2::HOSTS_UNKNOWN)
     #
     # @example for service objects
     #    s_objects = @icinga.service_objects
-    #    warning = @icinga.handled_problems(s_objects, Icinga2::SERVICE_STATE_WARNING)
-    #    critical = @icinga.handled_problems(s_objects, Icinga2::SERVICE_STATE_CRITICAL)
-    #    unknown = @icinga.handled_problems(s_objects, Icinga2::SERVICE_STATE_UNKNOWN)
+    #    all = @icinga.count_problems(s_objects)
+    #    warning = @icinga.count_problems(s_objects, Icinga2::SERVICE_STATE_WARNING)
+    #    critical = @icinga.count_problems(s_objects, Icinga2::SERVICE_STATE_CRITICAL)
+    #    unknown = @icinga.count_problems(s_objects, Icinga2::SERVICE_STATE_UNKNOWN)
     #
     # @return [Integer]
     #
-    def handled_problems(objects, status)
+    def count_problems( objects, state = nil )
 
-      problems = 0
+      compare_states = []
 
-      objects = JSON.parse(objects) if  objects.is_a?(String)
-      nodes   = objects.dig(:nodes)
+      unless( state.nil? )
 
-      unless( nodes.nil? )
-
-        nodes.each do |n|
+        # 0 = "Up"   or "OK"
+        # 1 = "Down" or "Warning"
+        # 2 = "Critical"
+        # 3 = "Unknown"
+        compare_states = [1, 2, 3]
+      end
 
-          attrs           = n.last.dig('attrs')
-          state           = attrs.dig('state')           || 0
-          downtime_depth  = attrs.dig('downtime_depth')  || 0
-          acknowledgement = attrs.dig('acknowledgement') || 0
+      compare_states.push(state) if( state.is_a?(Integer) )
 
-          if( state == status && downtime_depth.zero? && acknowledgement.zero? )
-            problems += 1
-          end
+      objects = JSON.parse(objects) if objects.is_a?(String)
 
-        end
+      f = objects.select do |t|
+        t.dig('attrs','state') == state && \
+            ( !t.dig('attrs','downtime_depth').nil? && t.dig('attrs','downtime_depth').zero?) && \
+            ( !t.dig('attrs','acknowledgement').nil? && t.dig('attrs','acknowledgement').zero? )
       end
-      problems
+
+      f.size
     end
 
   end

data/lib/icinga2/usergroups.rb

@@ -9,25 +9,23 @@ module Icinga2
     # add a usergroup
     #
     # @param [Hash] params
-    # @option params [String] :name usergroup to create
+    # @option params [String] :user_group usergroup to create
     # @option params [String] :display_name the displayed name
     #
     # @example
-    #   @icinga.add_usergroup(name: 'foo', display_name: 'FOO')
+    #   @icinga.add_usergroup(user_group: 'foo', display_name: 'FOO')
     #
     # @return [Hash] result
     #
-    def add_usergroup( params = {} )
+    def add_usergroup( params )
 
-      name     = params.dig(:name)
+      raise ArgumentError.new('only Hash are allowed') unless( params.is_a?(Hash) )
+      raise ArgumentError.new('missing params') if( params.size.zero? )
+
+      user_group   = params.dig(:user_group)
       display_name = params.dig(:display_name)
 
-      if( name.nil? )
-        return {
-          status: 404,
-          message: 'missing usergroup name'
-        }
-      end
+      raise ArgumentError.new('Missing user_group') if( user_group.nil? )
 
       payload = {
         'attrs' => {
@@ -35,82 +33,94 @@ module Icinga2
         }
       }
 
-      Network.put(         host: name,
-        url: format( '%s/v1/objects/usergroups/%s', @icinga_api_url_base, name ),
+      Network.put(
+        url: format( '%s/objects/usergroups/%s', @icinga_api_url_base, user_group ),
         headers: @headers,
         options: @options,
-        payload: payload )
-
+        payload: payload
+      )
     end
 
     # delete a usergroup
     #
     # @param [Hash] params
-    # @option params [String] :name usergroup to delete
+    # @option params [String] :user_group usergroup to delete
     #
     # @example
-    #   @icinga.delete_usergroup(name: 'foo')
+    #   @icinga.delete_usergroup(user_group: 'foo')
     #
     # @return [Hash] result
     #
-    def delete_usergroup( params = {} )
+    def delete_usergroup( params )
 
-      name = params.dig(:name)
+      raise ArgumentError.new('only Hash are allowed') unless( params.is_a?(Hash) )
+      raise ArgumentError.new('missing params') if( params.size.zero? )
 
-      if( name.nil? )
-        return {
-          status: 404,
-          message: 'missing usergroup name'
-        }
-      end
+      user_group = params.dig(:user_group)
 
-      Network.delete(         host: name,
-        url: format( '%s/v1/objects/usergroups/%s?cascade=1', @icinga_api_url_base, name ),
-        headers: @headers,
-        options: @options )
+      raise ArgumentError.new('Missing user_group') if( user_group.nil? )
 
+      Network.delete(
+        url: format( '%s/objects/usergroups/%s?cascade=1', @icinga_api_url_base, user_group ),
+        headers: @headers,
+        options: @options
+      )
     end
 
     # returns all usersgroups
     #
     # @param [Hash] params
-    # @option params [String] :name ('') optional for a single usergroup
+    # @option params [String] :user_group ('') optional for a single usergroup
     #
     # @example to get all users
     #    @icinga.usergroups
     #
     # @example to get one user
-    #    @icinga.usergroups(name: 'icingaadmins')
+    #    @icinga.usergroups(user_group: 'icingaadmins')
     #
     # @return [Hash] returns a hash with all usergroups
     #
     def usergroups( params = {} )
 
-      name = params.dig(:name)
+      user_group = params.dig(:user_group)
+
+      url =
+      if( user_group.nil? )
+        format( '%s/objects/usergroups'   , @icinga_api_url_base )
+      else
+        format( '%s/objects/usergroups/%s', @icinga_api_url_base, user_group )
+      end
 
-      Network.get(         host: name,
-        url: format( '%s/v1/objects/usergroups/%s', @icinga_api_url_base, name ),
+      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 usergroup exists
     #
-    # @param [String] name the name of the usergroups
+    # @param [String] user_group the name of the usergroups
     #
     # @example
     #    @icinga.exists_usergroup?('icingaadmins')
     #
     # @return [Bool] returns true if the usergroup exists
     #
-    def exists_usergroup?( name )
+    def exists_usergroup?( user_group )
+
+      raise ArgumentError.new('only String are allowed') unless( user_group.is_a?(String) )
+      raise ArgumentError.new('Missing user_group') if( user_group.size.zero? )
 
-      result = usergroups( name: name )
+      result = usergroups( user_group: user_group )
       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
 

data/lib/icinga2/users.rb

@@ -9,41 +9,32 @@ module Icinga2
     # add a user
     #
     # @param [Hash] params
-    # @option params [String] :name user to create
-    # @option params [String] :display_name the displayed name
+    # @option params [String] :user_name ('') user to create
+    # @option params [String] :display_name ('') the displayed name
     # @option params [String] :email ('') the user email
     # @option params [String] :pager ('') optional a pager
     # @option params [Bool] :enable_notifications (false) enable notifications for this user
     # @option params [Array] :groups ([]) a hash with groups
     #
     # @example
-    #   @icinga.add_user(name: 'foo', display_name: 'FOO', email: 'foo@bar.com', pager: '0000', groups: ['icingaadmins'])
+    #   @icinga.add_user(user_name: 'foo', display_name: 'FOO', email: 'foo@bar.com', pager: '0000', groups: ['icingaadmins'])
     #
     # @return [Hash] result
     #
-    def add_user( params = {} )
+    def add_user( params )
 
-      name          = params.dig(:name)
+      raise ArgumentError.new('only Hash are allowed') unless( params.is_a?(Hash) )
+      raise ArgumentError.new('missing params') if( params.size.zero? )
+
+      user_name     = params.dig(:user_name)
       display_name  = params.dig(:display_name)
       email         = params.dig(:email)
       pager         = params.dig(:pager)
       notifications = params.dig(:enable_notifications) || false
       groups        = params.dig(:groups) || []
 
-      if( name.nil? )
-        return {
-          status: 404,
-          message: 'missing user name'
-        }
-      end
-
-      unless( groups.is_a?( Array ) )
-        return {
-          status: 404,
-          message: 'groups must be an array',
-          data: params
-        }
-      end
+      raise ArgumentError.new('Missing user_name') if( user_name.nil? )
+      raise ArgumentError.new('groups must be an array') unless( groups.is_a?( Array ) )
 
       payload = {
         'attrs' => {
@@ -73,90 +64,94 @@ module Icinga2
         }
       end
 
-      Network.put(         host: name,
-        url: format( '%s/v1/objects/users/%s', @icinga_api_url_base, name ),
+      Network.put(
+        url: format( '%s/objects/users/%s', @icinga_api_url_base, user_name ),
         headers: @headers,
         options: @options,
-        payload: payload )
-
-      # result:
-      #   {:status=>200, :name=>nil, :message=>"Object was created"}
+        payload: payload
+      )
     end
 
     # delete a user
     #
     # @param [Hash] params
-    # @option params [String] :name user to delete
+    # @option params [String] :user_name user to delete
     #
     # @example
-    #   @icinga.delete_user(name: 'foo')
+    #   @icinga.delete_user(user_name: 'foo')
     #
     # @return [Hash] result
     #
-    def delete_user( params = {} )
+    def delete_user( params )
 
-      name = params.dig(:name)
+      raise ArgumentError.new('only Hash are allowed') unless( params.is_a?(Hash) )
+      raise ArgumentError.new('missing params') if( params.size.zero? )
 
-      if( name.nil? )
-        return {
-          status: 404,
-          message: 'missing user name'
-        }
-      end
+      user_name = params.dig(:user_name)
 
-      Network.delete(         host: name,
-        url: format( '%s/v1/objects/users/%s?cascade=1', @icinga_api_url_base, name ),
-        headers: @headers,
-        options: @options )
+      raise ArgumentError.new('Missing user_name') if( user_name.nil? )
 
-      # result:
-      #   {:status=>200, :name=>"foo", :message=>"Object was deleted."}
+      Network.delete(
+        url: format( '%s/objects/users/%s?cascade=1', @icinga_api_url_base, user_name ),
+        headers: @headers,
+        options: @options
+      )
     end
 
-    # returns all users
+    # returns a named or all users
     #
     # @param [Hash] params
-    # @option params [String] :name ('') optional for a single user
+    # @option params [String] :user_name ('') optional for a single user
     #
     # @example to get all users
     #    @icinga.users
     #
     # @example to get one user
-    #    @icinga.users(name: 'icingaadmin')
+    #    @icinga.users(user_name: 'icingaadmin')
     #
-    # @return [Hash] returns a hash with all users
+    # @return [Hash] returns a hash
     #
     def users( params = {} )
 
-      name = params.dig(:name)
+      user_name = params.dig(:user_name)
 
-      Network.get(         host: name,
-        url: format( '%s/v1/objects/users/%s', @icinga_api_url_base, name ),
+      url =
+      if( user_name.nil? )
+        format( '%s/objects/users'   , @icinga_api_url_base )
+      else
+        format( '%s/objects/users/%s', @icinga_api_url_base, user_name )
+      end
+
+      data = Network.api_data(
+        url: url,
         headers: @headers,
-        options: @options )
+        options: @options
+      )
+
+      return data.dig('results') if( data.dig(:status).nil? )
 
-      # result:
-      #  - named user:
-      #   {:status=>200, :data=>{"icingaadmin"=>{:name=>"icingaadmin", :display_name=>"Icinga 2 Admin", :type=>"User"}}}
-      #  - all users:
-      #   {:status=>200, :data=>{"icingaadmin"=>{:name=>"icingaadmin", :display_name=>"Icinga 2 Admin", :type=>"User"}, "foo"=>{:name=>"foo", :display_name=>"FOO", :type=>"User"}}}
+      nil
     end
 
-    # returns true if the user exists
+    # checks if the user exists
     #
-    # @param [String] name the name of the user
+    # @param [String] user_name the name of the user
     #
     # @example
     #    @icinga.exists_user?('icingaadmin')
     #
     # @return [Bool] returns true if the user exists
-    def exists_user?( name )
+    #
+    def exists_user?( user_name )
+
+      raise ArgumentError.new('only String are allowed') unless( user_name.is_a?(String) )
+      raise ArgumentError.new('Missing user_name') if( user_name.size.zero? )
+
+      result = users( user_name: user_name )
+      result = JSON.parse( result ) if( result.is_a?(String) )
 
-      result = users( name: name )
-      result = JSON.parse( result ) if  result.is_a?( String )
-      status = result.dig(:status)
+      return true if( !result.nil? && result.is_a?(Array) )
 
-      return true if  !status.nil? && status == 200
       false
     end