icinga2 0.5.2

data/lib/icinga2.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/ruby
+#
+#
+#
+#
+
+require 'rest-client'
+require 'openssl'
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+require_relative 'logging'
+require_relative 'icinga2/version'
+require_relative 'icinga2/network'
+require_relative 'icinga2/status'
+require_relative 'icinga2/converts'
+require_relative 'icinga2/tools'
+require_relative 'icinga2/downtimes'
+require_relative 'icinga2/notifications'
+require_relative 'icinga2/hosts'
+require_relative 'icinga2/hostgroups'
+require_relative 'icinga2/services'
+require_relative 'icinga2/servicegroups'
+require_relative 'icinga2/users'
+require_relative 'icinga2/usergroups'
+
+# -------------------------------------------------------------------------------------------------------------------
+
+module Icinga2
+
+  class Client
+
+    include Logging
+
+    include Icinga2::Version
+    include Icinga2::Network
+    include Icinga2::Status
+    include Icinga2::Converts
+    include Icinga2::Tools
+    include Icinga2::Downtimes
+    include Icinga2::Notifications
+    include Icinga2::Hosts
+    include Icinga2::Hostgroups
+    include Icinga2::Services
+    include Icinga2::Servicegroups
+    include Icinga2::Users
+    include Icinga2::Usergroups
+
+
+    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 ) )
+
+      @hasCert   = self.checkCert( { :user => @icingaApiUser, :password =>  @icingaApiPass } )
+      @headers   = { "Content-Type" => "application/json", "Accept" => "application/json" }
+
+      return self
+
+    end
+
+
+    def checkCert( params = {} )
+
+      nodeName     = params.dig(:nodeName) || 'localhost'
+
+      user         = params.dig(:user)     || 'admin'
+      password     = params.dig(:password) || ''
+
+      # check whether pki files are there, otherwise use basic auth
+      if File.file?( sprintf( 'pki/%s.crt', nodeName ) )
+
+        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' )
+
+        cert      = OpenSSL::X509::Certificate.new( sslCertFile )
+        key       = OpenSSL::PKey::RSA.new( sslKeyFile )
+
+        @options   = {
+          :ssl_client_cert => cert,
+          :ssl_client_key  => key,
+          :ssl_ca_file     => sslCAFile,
+          :verify_ssl      => OpenSSL::SSL::VERIFY_NONE
+        }
+
+        return true
+      else
+
+        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
+        }
+
+        return false
+      end
+
+    end
+
+  end
+end
+
+# EOF

data/lib/icinga2/converts.rb

@@ -0,0 +1,77 @@
+
+
+module Icinga2
+
+  module Converts
+
+    def self.stateToString( state, is_host = false )
+
+      if( is_host == true )
+
+        state = 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
+      end
+
+      return state
+
+    end
+
+    def self.stateToColor( state, is_host = false )
+
+      if( is_host == true )
+
+        state = 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
+      end
+
+      return state
+    end
+
+    def self.formatService( name )
+      service_map = name.split('!', 2)
+      service_map.join( ' - ' )
+    end
+
+  end
+
+end

data/lib/icinga2/downtimes.rb

@@ -0,0 +1,173 @@
+
+module Icinga2
+
+  module Downtimes
+
+
+    def addDowntime( 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)
+      author          = params.dig(:author)
+      comment         = params.dig(:comment)
+      type            = params.dig(:type)
+      filter          = nil
+
+      # sanitychecks
+      #
+      if( name == nil )
+
+        return {
+          :status  => 404,
+          :message => 'missing downtime name'
+        }
+      end
+
+      if( ['host','service'].include?(type.downcase) == false )
+
+        return {
+          :status  => 404,
+          :message => "wrong downtype type. only 'host' or' service' allowed ('#{type}' giving"
+        }
+      else
+        # we need the first char as Uppercase
+        type.capitalize!
+      end
+
+      if( hostGroup != nil && hostName != nil )
+
+        return {
+          :status  => 404,
+          :message => 'choose host or host_group, not both'
+        }
+
+      end
+
+      if( hostName != nil )
+
+        filter = sprintf( 'host.name=="%s"', hostName )
+      elsif( hostGroup != nil )
+
+        # check if hostgroup available ?
+        #
+        filter = sprintf( '"%s" in host.groups', hostGroup )
+      else
+
+        return {
+          :status  => 404,
+          :message => 'missing host or host_group for downtime'
+        }
+      end
+
+      if( comment == nil )
+
+        return {
+          :status  => 404,
+          :message => 'missing downtime comment'
+        }
+      end
+
+      if( author == nil )
+
+        return {
+          :status  => 404,
+          :message => 'missing downtime author'
+        }
+      else
+
+        if( self.existsUser?( author ) == false )
+
+          return {
+            :status  => 404,
+            :message => "these author ar not exists: #{author}"
+          }
+        end
+      end
+
+
+      if( endTime == nil )
+
+        return {
+          :status  => 404,
+          :message => 'missing end_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' ) )
+
+      payload = {
+        "type"        => type,
+        "start_time"  => startTime,
+        "end_time"    => endTime,
+        "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 )
+
+
+      # schedule downtime for a host
+      #  --data '{ "type": "Host", "filter": "host.name==\"api_dummy_host_1\"", ... }'
+
+      # schedule downtime for all services of a host
+      #  --data '{ "type": "Service", "filter": "host.name==\"api_dummy_host_1\"", ... }'
+
+      # schedule downtime for all hosts and services in a hostgroup
+      #  --data '{ "type": "Host", "filter": "\"api_dummy_hostgroup\" in host.groups", ... }'
+
+      #  --data '{ "type": "Service", "filter": "\"api_dummy_hostgroup\" in host.groups)", ... }'
+
+
+
+    end
+
+
+    def listDowntimes( params = {} )
+
+      name = params.dig(:name)
+
+      result = Network.get( {
+        :host     => name,
+        :url      => sprintf( '%s/v1/objects/downtimes/%s', @icingaApiUrlBase, name ),
+        :headers  => @headers,
+        :options  => @options
+      } )
+
+      return JSON.pretty_generate( result )
+
+
+    end
+
+
+  end
+
+end

data/lib/icinga2/hostgroups.rb

@@ -0,0 +1,98 @@
+
+module Icinga2
+
+  module Hostgroups
+
+    def addHostgroup( params = {} )
+
+      name        = params.dig(:name)
+      displayName = params.dig(:display_name)
+
+      if( name == nil )
+
+        return {
+          :status  => 404,
+          :message => 'no name for the hostgroup'
+        }
+      end
+
+      payload = {
+        "attrs" => {
+          "display_name"         => displayName
+        }
+      }
+
+      result = Network.put( {
+        :url     => sprintf( '%s/v1/objects/hostgroups/%s', @icingaApiUrlBase, name ),
+        :headers => @headers,
+        :options => @options,
+        :payload => payload
+      } )
+
+      return JSON.pretty_generate( result )
+
+    end
+
+
+    def deleteHostgroup( params = {} )
+
+      name = params.dig(:name)
+
+      if( name == nil )
+
+        return {
+          :status  => 404,
+          :message => 'no name for the hostgroup'
+        }
+      end
+
+      result = Network.delete( {
+        :host    => name,
+        :url     => sprintf( '%s/v1/objects/hostgroups/%s?cascade=1', @icingaApiUrlBase, name ),
+        :headers => @headers,
+        :options => @options
+      } )
+
+      return JSON.pretty_generate( result )
+
+    end
+
+
+    def listHostgroups( params = {} )
+
+      name = params.dig(:name)
+
+      result = Network.get( {
+        :host     => name,
+        :url      => sprintf( '%s/v1/objects/hostgroups/%s', @icingaApiUrlBase, name ),
+        :headers  => @headers,
+        :options  => @options
+      } )
+
+      return JSON.pretty_generate( result )
+
+    end
+
+
+    def existsHostgroup?( name )
+
+      result = self.listHostgroups( { :name => name } )
+
+      if( result.is_a?( String ) )
+        result = JSON.parse( result )
+      end
+
+      status = result.dig('status')
+
+      if( status != nil && status == 200 )
+        return true
+      end
+
+      return false
+
+    end
+
+
+  end
+
+end