icinga_result 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6b3f8edc6cbfc3b679867e29752536699a43d51b30e0141dc02e9c660866cb47
+  data.tar.gz: 838553a21e4cf234e53037d8de27e3e822b4b547a67e873fa60846213af8fc13
+SHA512:
+  metadata.gz: 7ea6f742dff6c491ec246741b04f7968027597e1a3dd690327f01776060ecf0d1c8bc20c5c0bb23e3b7ff28d3df923bdbe1ec1e2ae37f1d9705371fa49addf1c
+  data.tar.gz: 4b87e0c120f07e5e3e1ce79c79b2020379f29fdd91989209f90f45dcd6f40baa56cfc6e12e3b0ed929ef7dce6408800c7fcc5181736e12967f79146a231bc415

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/README.md

@@ -0,0 +1,67 @@
+# Icinga Result Client
+
+This gem provides a library and executable to send passive check results via API to Icinga2.
+
+## Installation
+
+Require it in your Gemfile
+```bash
+gem 'icinga_result'
+```
+
+or install it directly via
+```bash
+gem install icinga_result
+```
+
+## Configuration
+
+To use the gem you need a configuration file with an Icinga API host and user.
+
+```yaml
+---
+username: your icinga username
+password: your super secred icinga password
+host: icinga.example.com
+port: 5665
+always_send_host_alive: false
+```
+
+"always_send_host_alive" sends the host alive signal every time a service result is delivered.
+
+## Usage
+
+### Command line client
+
+You can deliver status results simple by calling `icinga-result`. While it is sufficient to supply "name", "status" and "message" when the service exists, you should probably always give as much information as you can. The first time a check result is sent, it will probably fail (since the service does not exist yet). But it will automatically be created and when the check is run a second time, the result will be sent.
+
+```
+$ icinga-result --help
+Usage: --help [options]
+        --service [NAME]             Service name
+        --interval [INTERVAL]        Server check interval
+        --description [DESCRIPTION]  Service description
+        --status [STATUS]            Status code for the check
+        --message [MESSAGE]          Status message for the check
+        --performance-data [DATA]    Performance data for the check
+        --host-alive                 Send host alive signal
+```
+
+### Library
+
+When you implement your check in Ruby, you can call the library directly. A simple script might look like this:
+
+```ruby
+require 'icinga_result/client'
+
+client = IcingaResult::Client.new
+service = IcingaResult::Service.new('demo', interval: 3600, description: 'This is a demo check')
+
+if my_special_check
+  result = IcingaResult::CheckResult.new(0, 'Ok')
+else
+  result = IcingaResult::CheckResult.new(2, 'Special is borken!')
+end
+
+client.send(service, result)
+```

data/bin/icinga-result

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'icinga_result/client'
+
+@options = {
+  service: '',
+  interval: 3600,
+  description: '',
+  status: 0,
+  message: '',
+  performance_data: '',
+  host_alive: false
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{ARGV[0]} [options]"
+
+  opts.on('--service [NAME]', 'Service name') do |name|
+    @options[:service] = name
+  end
+  opts.on('--interval [INTERVAL]', 'Server check interval') do |interval|
+    @options[:interval] = interval
+  end
+  opts.on('--description [DESCRIPTION]', 'Service description') do |description|
+    @options[:description] = description
+  end
+  opts.on('--status [STATUS]', 'Status code for the check') do |status|
+    @options[:status] = status
+  end
+  opts.on('--message [MESSAGE]', 'Status message for the check') do |message|
+    @options[:message] = message
+  end
+  opts.on('--performance-data [DATA]', 'Performance data for the check') do |data|
+    @options[:performance_data] = data
+  end
+  opts.on('--host-alive', 'Send host alive signal') do
+    @options[:host_alive] = true
+  end
+end.parse!
+
+client = IcingaResult::Client.new
+
+client.send_host_alive if @options[:host_alive]
+
+unless @options[:service].empty?
+  service = IcingaResult::Service.new(@options[:service], interval: @options[:interval], description: @options[:description])
+  result = IcingaResult::CheckResult.new(@options[:status], @status[:description])
+  client.send(service, result)
+end

data/icinga_result.gemspec

@@ -0,0 +1,20 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'icinga_result'
+  spec.version       = '1.0.0'
+  spec.authors       = ['Gerrit Visscher']
+  spec.email         = ['gerrit@visscher.de']
+  spec.summary       = 'A library to send passive check results to icinga via the API'
+  spec.description   = 'This library send checks result to Icinga2 via the http api. It provides an executable to send result from shell scripts'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+end

data/lib/icinga_result/check_result.rb

@@ -0,0 +1,21 @@
+module IcingaResult
+  # Contains the result of a check
+  class CheckResult
+    attr_accessor :status, :message, :performance_data
+
+    def initialize(status, message, performance_data = '')
+      @status = status
+      @message = message
+      @performance_data = performance_data
+    end
+
+    def data
+      data = {
+        'exit_status': @status,
+        'plugin_output': @message
+      }
+      data['performance_data'] = @performance_data if @performance_data && !@performance_data.empty?
+      data
+    end
+  end
+end

data/lib/icinga_result/client.rb

@@ -0,0 +1,94 @@
+require 'yaml'
+require 'net/http'
+require 'uri'
+require 'json'
+require 'icinga_result/host'
+require 'icinga_result/service'
+require 'icinga_result/check_result'
+
+module IcingaResult
+  # The Icinga2 API client
+  class Client
+    CONFIG_FILE = "#{ENV['HOME']}/.icinga_result.config.yml".freeze
+
+    attr_reader :username, :password, :host, :port
+
+    def initialize
+      load_config
+    end
+
+    def load_config
+      File.open(CONFIG_FILE, 'r') do |file|
+        data = YAML.safe_load(file.read)
+        @username = data['username']
+        @password = data['password']
+        @host = data['host']
+        @port = data['port']
+        @always_send = data['always_send_host_alive']
+      end
+    end
+
+    def send(service, check_result)
+      host = Host.new
+      send_result(host, service, check_result)
+    end
+
+    def send_result(host, service, check_result)
+      response = api_post("/actions/process-check-result?service=#{host.name}!#{service.name}", check_result.data)
+      register_service(host, service) if response.code.to_i == 404
+      send_host_alive(host)
+
+      handle_errors(response)
+    end
+
+    def send_host_alive(host = Host.new)
+      path = "/actions/process-check-result?host=#{host.name}"
+      data = { 'exit_status' => 0, 'plugin_output' => 'Host alive' }
+      response = api_post(path, data)
+      register_host(host) if response.code.to_i == 404
+      handle_errors(response)
+      response
+    end
+
+    def register_host(host)
+      response = api_put("/objects/hosts/#{host.name}", host.data)
+      handle_errors(response)
+      response
+    end
+
+    def register_service(host, service)
+      response = api_put("/objects/services/#{host.name}!#{service.name}", service.data)
+      register_host(host) if response.code.to_i == 404
+      handle_errors(response)
+      response
+    end
+
+    def handle_errors(response)
+      return if response.code.to_i >= 200 && response.code.to_i < 299
+
+      raise "Cannot send results to Icinga server: #{response.code} - #{response.message}: #{response.body}"
+    end
+
+    def api_post(path, data)
+      http = Net::HTTP.new(@host, @port)
+      http.use_ssl = true
+      request = Net::HTTP::Post.new("/v1#{path}", {})
+      request.basic_auth @username, @password
+      request['Accept'] = 'application/json'
+      request.body = data.to_json
+      puts "Sending POST '#{request.body}' to /v1#{path}"
+      http.request(request)
+    end
+
+    def api_put(path, data)
+      http = Net::HTTP.new(@host, @port)
+      http.use_ssl = true
+      request = Net::HTTP::Put.new("/v1#{path}", {})
+      request['Accept'] = 'application/json'
+      request.basic_auth @username, @password
+      request.body = data.to_json
+      puts "Sending PUT '#{request.body}' to /v1#{path}"
+      http.request(request)
+    end
+  end
+end

data/lib/icinga_result/host.rb

@@ -0,0 +1,31 @@
+module IcingaResult
+  # Represents the current host (client)
+  class Host
+    DESCRIPTION_FILE = '/etc/description'.freeze
+
+    def name
+      @name ||= `hostname -f`.strip
+    end
+
+    def description
+      @description ||= read_description
+    end
+
+    def read_description
+      return '' unless File.exist?(DESCRIPTION_FILE)
+
+      File.read(DESCRIPTION_FILE)
+    end
+
+    def data
+      {
+        'templates': ['generic-host'],
+        'attrs': {
+          'check_command': 'passive',
+          'enable_active_checks': true,
+          'vars.description' => description
+        }
+      }
+    end
+  end
+end

data/lib/icinga_result/service.rb

@@ -0,0 +1,32 @@
+module IcingaResult
+  # Represents an Icinga2 service object
+  class Service
+    attr_accessor :name, :interval, :description, :groups
+
+    DEFAULT_OPTONS = { interval: 3600, description: '', groups: [] }.freeze
+
+    def initialize(name, options = DEFAULT_OPTONS)
+      @name = name
+      @interval = options[:interval] || DEFAULT_OPTONS[:interval]
+      @description = options[:description] || DEFAULT_OPTONS[:description]
+      @groups = options[:groups] || DEFAULT_OPTONS[:groups]
+    end
+
+    def timeout
+      3 * @interval + 120
+    end
+
+    def data
+      {
+        'templates' => ['generic-service'],
+        'attrs' => {
+          'check_command' => 'passive',
+          'enable_active_checks' => true,
+          'check_interval' => timeout,
+          'vars.description' => @description,
+          'groups' => @groups
+        }
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: icinga_result
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Gerrit Visscher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: This library send checks result to Icinga2 via the http api. It provides
+  an executable to send result from shell scripts
+email:
+- gerrit@visscher.de
+executables:
+- icinga-result
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- README.md
+- bin/icinga-result
+- icinga_result.gemspec
+- lib/icinga_result/check_result.rb
+- lib/icinga_result/client.rb
+- lib/icinga_result/host.rb
+- lib/icinga_result/service.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A library to send passive check results to icinga via the API
+test_files: []