icinga2 0.5.2 → 0.6.1

data/lib/icinga2.rb

@@ -1,4 +1,5 @@
-#!/usr/bin/ruby
+
+# frozen_string_literal: true
 #
 #
 #
@@ -48,85 +49,96 @@ module Icinga2
     include Icinga2::Users
     include Icinga2::Usergroups
 
-
+    # Returns a new instance of Client
+    #
+    # @param [Hash, #read] settings the settings for Icinga2
+    # @option settings [String] :icinga, :host the Icinga2 Hostname (default: 'localhost')
+    # @option settings [Integer] :icinga, :api, :port the Icinga2 API Port (default: 5665)
+    # @option settings [String] :icinga, :api, :user the Icinga2 API User
+    # @option settings [String] :icinga, :api, :password the Icinga2 API Password
+    # @option settings [Bool] :icinga, :cluster Icinga2 Cluster Mode
+    # @option settings [Bool] :icinga, :notifications enable Icinga2 Host Notifications (default: false)
+    #
+    # @example to create an new Instance
+    #    config = {
+    #      icinga: {
+    #        host: '192.168.33.5',
+    #        api: {
+    #          port: 5665,
+    #          user: 'root',
+    #          password: 'icinga'
+    #        },
+    #        cluster: false,
+    #        satellite: true
+    #      }
+    #    }
+    #
+    #    i = Icinga2::Client.new config
+    # @return [instance, #read]
     def initialize( settings = {} )
 
-      @icingaHost           = settings.dig(:icinga, :host)           || 'localhost'
-      @icingaApiPort        = settings.dig(:icinga, :api, :port)     || 5665
-      @icingaApiUser        = settings.dig(:icinga, :api, :user)
-      @icingaApiPass        = settings.dig(:icinga, :api, :password)
-      @icingaCluster        = settings.dig(:icinga, :cluster)        || false
-      @icingaSatellite      = settings.dig(:icinga, :satellite)
-      @icingaNotifications  = settings.dig(:icinga, :notifications)  || false
-
-      @icingaApiUrlBase     = sprintf( 'https://%s:%d', @icingaHost, @icingaApiPort )
-      @nodeName             = Socket.gethostbyname( Socket.gethostname ).first
-
-      date                 = '2017-06-08'
-
-      logger.info( '-----------------------------------------------------------------' )
-      logger.info( ' Icinga2 Management' )
-      logger.info( "  Version #{VERSION} (#{date})" )
-      logger.info( '  Copyright 2016-2017 Bodo Schulz' )
-      logger.info( "  Backendsystem #{@icingaApiUrlBase}" )
-      logger.info( sprintf( '    cluster enabled: %s', @icingaCluster ? 'true' : 'false' ) )
-      logger.info( sprintf( '    notifications enabled: %s', @icingaNotifications ? 'true' : 'false' ) )
-      if( @icingaCluster )
-        logger.info( sprintf( '    satellite endpoint: %s', @icingaSatellite ) )
-      end
-      logger.info( '-----------------------------------------------------------------' )
-      logger.info( '' )
-
-      logger.debug( sprintf( '  server   : %s', @icingaHost ) )
-      logger.debug( sprintf( '  port     : %s', @icingaApiPort ) )
-      logger.debug( sprintf( '  api url  : %s', @icingaApiUrlBase ) )
-      logger.debug( sprintf( '  api user : %s', @icingaApiUser ) )
-      logger.debug( sprintf( '  api pass : %s', @icingaApiPass ) )
-      logger.debug( sprintf( '  node name: %s', @nodeName ) )
+      @icinga_host           = settings.dig(:icinga, :host)           || 'localhost'
+      @icinga_api_port       = settings.dig(:icinga, :api, :port)     || 5665
+      @icinga_api_user       = settings.dig(:icinga, :api, :user)
+      @icinga_api_pass       = settings.dig(:icinga, :api, :password)
+      @icinga_cluster        = settings.dig(:icinga, :cluster)        || false
+      @icinga_satellite      = settings.dig(:icinga, :satellite)
+      @icinga_notifications  = settings.dig(:icinga, :notifications)  || false
 
-      @hasCert   = self.checkCert( { :user => @icingaApiUser, :password =>  @icingaApiPass } )
-      @headers   = { "Content-Type" => "application/json", "Accept" => "application/json" }
+      @icinga_api_url_base   = format( 'https://%s:%d', @icinga_host, @icinga_api_port )
+      @node_name             = Socket.gethostbyname( Socket.gethostname ).first
 
-      return self
+      @has_cert   = cert?( user: @icinga_api_user, password: @icinga_api_pass )
+      @headers    = { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
 
+      self
     end
 
-
-    def checkCert( params = {} )
-
-      nodeName     = params.dig(:nodeName) || 'localhost'
-
-      user         = params.dig(:user)     || 'admin'
-      password     = params.dig(:password) || ''
+    # @param [Hash, #read] params create a HTTP Header based on a Icinga2 Certificate or an User PAI Login
+    # @option params [String] :node_name the Icinga2 Hostname (default: 'localhost')
+    # @option params [Integer] :user the Icinga2 API User
+    # @option params [Integer] :password the Icinga2 API Password
+    # @example with Certificate
+    #    cert? name_name: 'icinga2-dashing'
+    #
+    # @example with User
+    #    cert? user: 'root' password: 'icinga'
+    #
+    # @return [Bool, #read]
+    def cert?( params = {} )
+
+      node_name    = params.dig(:node_name) || 'localhost'
+      user         = params.dig(:user)
+      password     = params.dig(:password)
 
       # check whether pki files are there, otherwise use basic auth
-      if File.file?( sprintf( 'pki/%s.crt', nodeName ) )
+      if File.file?( format( 'pki/%s.crt', node_name ) )
 
-        logger.debug( "PKI found, using client certificates for connection to Icinga 2 API" )
+        logger.debug( 'PKI found, using client certificates for connection to Icinga 2 API' )
 
-        sslCertFile = File.read( sprintf( 'pki/%s.crt', nodeName ) )
-        sslKeyFile  = File.read( sprintf( 'pki/%s.key', nodeName ) )
-        sslCAFile   = File.read( 'pki/ca.crt' )
+        ssl_cert_file = File.read( format( 'pki/%s.crt', node_name ) )
+        ssl_key_file  = File.read( format( 'pki/%s.key', node_name ) )
+        ssl_ca_file   = File.read( 'pki/ca.crt' )
 
-        cert      = OpenSSL::X509::Certificate.new( sslCertFile )
-        key       = OpenSSL::PKey::RSA.new( sslKeyFile )
+        cert      = OpenSSL::X509::Certificate.new( ssl_cert_file )
+        key       = OpenSSL::PKey::RSA.new( ssl_key_file )
 
         @options   = {
-          :ssl_client_cert => cert,
-          :ssl_client_key  => key,
-          :ssl_ca_file     => sslCAFile,
-          :verify_ssl      => OpenSSL::SSL::VERIFY_NONE
+          ssl_client_cert: cert,
+          ssl_client_key: key,
+          ssl_ca_file: ssl_ca_file,
+          verify_ssl: OpenSSL::SSL::VERIFY_NONE
         }
 
         return true
       else
 
-        logger.debug( "PKI not found, using basic auth for connection to Icinga 2 API" )
+        logger.debug( 'PKI not found, using basic auth for connection to Icinga 2 API' )
 
         @options = {
-          :user       => user,
-          :password   => password,
-          :verify_ssl => OpenSSL::SSL::VERIFY_NONE
+          user: user,
+          password: password,
+          verify_ssl: OpenSSL::SSL::VERIFY_NONE
         }
 
         return false
@@ -136,5 +148,3 @@ module Icinga2
 
   end
 end
-
-# EOF

data/lib/icinga2/converts.rb

@@ -1,77 +1,92 @@
 
+# frozen_string_literal: true
 
 module Icinga2
 
+  # many convert functions
+  #
+  #
   module Converts
 
-    def self.stateToString( state, is_host = false )
+    # convert a Icinga2 state into a human readable state
+    #
+    # @param [String, #read] state the Icinga2 State
+    # @param [Bool, #read] is_host if this a Host or a Service Check
+    #
+    # @return [String, #read]
+    def self.state_to_string( state, is_host = false )
 
+      state =
       if( is_host == true )
-
-        state = case state
-          when 0
-            'Up'
-          when 1
-            'Down'
-          else
-            'Undefined'
-          end
+        case state
+        when 0
+          'Up'
+        when 1
+          'Down'
+        else
+          'Undefined'
+        end
       else
-
-        state = case state
-          when 0
-            'OK'
-          when 1
-            'Warning'
-          when 2
-            'Critical'
-          when 3
-            'Unknown'
-          else
-            'Undefined'
-          end
+        case state
+        when 0
+          'OK'
+        when 1
+          'Warning'
+        when 2
+          'Critical'
+        when 3
+          'Unknown'
+        else
+          'Undefined'
+        end
       end
-
-      return state
-
+      state
     end
 
-    def self.stateToColor( state, is_host = false )
+    # convert a Icinga2 state into a named color
+    #
+    # @param [String, #read] state the Icinga2 State
+    # @param [Bool, #read] is_host if this a Host or a Service Check
+    #
+    # @return [String, #read]
+    def self.state_to_color( state, is_host = false )
 
+      state =
       if( is_host == true )
-
-        state = case state
-          when 0
-            'green'
-          when 1
-            'red'
-          else
-            'blue'
-          end
+        case state
+        when 0
+          'green'
+        when 1
+          'red'
+        else
+          'blue'
+        end
       else
-
-        state = case state
-          when 0
-            'green'
-          when 1
-            'yellow'
-          when 2
-            'red'
-          when 3
-            'purple'
-          else
-            'blue'
-          end
+        case state
+        when 0
+          'green'
+        when 1
+          'yellow'
+        when 2
+          'red'
+        when 3
+          'purple'
+        else
+          'blue'
+        end
       end
-
-      return state
+      state
     end
 
-    def self.formatService( name )
+    # reformat a service check name
+    #
+    # @param [String, #read] name
+    #
+    # @return [String, #read]
+    def self.format_service( name )
       service_map = name.split('!', 2)
       service_map.join( ' - ' )
     end
 
   end
-
 end

data/lib/icinga2/downtimes.rb

@@ -1,17 +1,23 @@
 
+# frozen_string_literal: true
+
 module Icinga2
 
+  #
+  #
+  #
   module Downtimes
 
-
-    def addDowntime( params = {} )
+    #
+    #
+    #
+    def add_downtime( params = {} )
 
       name            = params.dig(:name)
-      hostName        = params.dig(:host)
-#      serviceName     = params.dig(:service)
-      hostGroup       = params.dig(:host_group)
-      startTime       = params.dig(:start_time) || Time.now.to_i
-      endTime         = params.dig(:end_time)
+      host_name       = params.dig(:host)
+      host_group      = params.dig(:host_group)
+      start_time      = params.dig(:start_time) || Time.now.to_i
+      end_time        = params.dig(:end_time)
       author          = params.dig(:author)
       comment         = params.dig(:comment)
       type            = params.dig(:type)
@@ -19,120 +25,99 @@ module Icinga2
 
       # sanitychecks
       #
-      if( name == nil )
-
+      if( name.nil? )
         return {
-          :status  => 404,
-          :message => 'missing downtime name'
+          status: 404,
+          message: 'missing downtime name'
         }
       end
 
-      if( ['host','service'].include?(type.downcase) == false )
-
+      if( %w[host service].include?(type.downcase) == false )
         return {
-          :status  => 404,
-          :message => "wrong downtype type. only 'host' or' service' allowed ('#{type}' giving"
+          status: 404,
+          message: "wrong downtype type. only 'host' or' service' allowed ('#{type}' giving"
         }
       else
         # we need the first char as Uppercase
-        type.capitalize!
+        type = type.capitalize
       end
 
-      if( hostGroup != nil && hostName != nil )
-
+      if( !host_group.nil? && !host_name.nil? )
         return {
-          :status  => 404,
-          :message => 'choose host or host_group, not both'
+          status: 404,
+          message: 'choose host or host_group, not both'
         }
-
       end
 
-      if( hostName != nil )
+      if( !host_name.nil? )
 
-        filter = sprintf( 'host.name=="%s"', hostName )
-      elsif( hostGroup != nil )
+        filter = format( 'host.name=="%s"', host_name )
+      elsif( !host_group.nil? )
 
         # check if hostgroup available ?
         #
-        filter = sprintf( '"%s" in host.groups', hostGroup )
+        filter = format( '"%s" in host.groups', host_group )
       else
 
         return {
-          :status  => 404,
-          :message => 'missing host or host_group for downtime'
+          status: 404,
+          message: 'missing host or host_group for downtime'
         }
       end
 
-      if( comment == nil )
-
+      if( comment.nil? )
         return {
-          :status  => 404,
-          :message => 'missing downtime comment'
+          status: 404,
+          message: 'missing downtime comment'
         }
       end
 
-      if( author == nil )
-
+      if( author.nil? )
         return {
-          :status  => 404,
-          :message => 'missing downtime author'
+          status: 404,
+          message: 'missing downtime author'
+        }
+      elsif( exists_user?( author ) == false )
+        return {
+          status: 404,
+          message: "these author ar not exists: #{author}"
         }
-      else
-
-        if( self.existsUser?( author ) == false )
-
-          return {
-            :status  => 404,
-            :message => "these author ar not exists: #{author}"
-          }
-        end
       end
 
 
-      if( endTime == nil )
-
+      if( end_time.nil? )
         return {
-          :status  => 404,
-          :message => 'missing end_time'
+          status: 404,
+          message: 'missing end_time'
+        }
+      elsif( end_time.to_i <= start_time )
+        return {
+          status: 404,
+          message: 'end_time are equal or smaller then start_time'
         }
-      else
-
-        if( endTime.to_i <= startTime )
-
-          return {
-            :status  => 404,
-            :message => 'end_time are equal or smaller then start_time'
-          }
-        end
       end
 
-#       logger.debug( Time.at( startTime ).strftime( '%Y-%m-%d %H:%M:%S' ) )
-#       logger.debug( Time.at( endTime ).strftime( '%Y-%m-%d %H:%M:%S' ) )
+#       logger.debug( Time.at( start_time ).strftime( '%Y-%m-%d %H:%M:%S' ) )
+#       logger.debug( Time.at( end_time ).strftime( '%Y-%m-%d %H:%M:%S' ) )
 
       payload = {
-        "type"        => type,
-        "start_time"  => startTime,
-        "end_time"    => endTime,
-        "author"      => author,
-        "comment"     => comment,
-        "fixed"       => true,
-        "duration"    => 30,
-        "filter"      => filter
+        'type'        => type,
+        'start_time'  => start_time,
+        'end_time'    => end_time,
+        'author'      => author,
+        'comment'     => comment,
+        'fixed'       => true,
+        'duration'    => 30,
+        'filter'      => filter
       }
 
 #       logger.debug( JSON.pretty_generate( payload ) )
 
-      result = Network.post( {
-        :host    => name,
-        :url     => sprintf( '%s/v1/actions/schedule-downtime', @icingaApiUrlBase ),
-        :headers => @headers,
-        :options => @options,
-        :payload => payload
-      } )
-
-      logger.debug( result.class.to_s )
-
-      return JSON.pretty_generate( result )
+      result = Network.post(         host: name,
+        url: format( '%s/v1/actions/schedule-downtime', @icinga_api_url_base ),
+        headers: @headers,
+        options: @options,
+        payload: payload )
 
 
       # schedule downtime for a host
@@ -146,28 +131,26 @@ module Icinga2
 
       #  --data '{ "type": "Service", "filter": "\"api_dummy_hostgroup\" in host.groups)", ... }'
 
-
+      JSON.pretty_generate( result )
 
     end
 
-
-    def listDowntimes( params = {} )
+    #
+    #
+    #
+    def downtimes( params = {} )
 
       name = params.dig(:name)
 
-      result = Network.get( {
-        :host     => name,
-        :url      => sprintf( '%s/v1/objects/downtimes/%s', @icingaApiUrlBase, name ),
-        :headers  => @headers,
-        :options  => @options
-      } )
+      result = Network.get(         host: name,
+        url: format( '%s/v1/objects/downtimes/%s', @icinga_api_url_base, name ),
+        headers: @headers,
+        options: @options )
 
-      return JSON.pretty_generate( result )
+      JSON.pretty_generate( result )
 
 
     end
 
-
   end
-
 end