icinga_api 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db65239b18017d516c94d9557964cd7d05deb9fc
-  data.tar.gz: 83566207d187452e28f7b0fa2a675a71cbd31b70
+  metadata.gz: 0153d5f474c808802e38b9c00130ccec7292bdfd
+  data.tar.gz: 8a3c89757f2fa0a0edca40427109437aa8b1baa2
 SHA512:
-  metadata.gz: c52d9d352a987f591fadc951ddc638608b7d9a4b1888f3b3903c485781b1415b547f1ad193da305673353578f497be4deab472d7a24c0b29d738fc8397973473
-  data.tar.gz: 0f66f89e8c1254abb2e3d8ea0ae645d6531c6121af820ff0889c6fad8db485bb901eafc0f217a2df7ac0fcbc01ee015a992781f65d006a375d0a21bea58eaca1
+  metadata.gz: 9684ab8be64d04cc6588bbabf95f8214a0fee92ba4372faa49376b75ba3e95081d0a32757d3e70f207f0d642fb2af6919aa1656831dc5cadd7bb06a56ef26683
+  data.tar.gz: 8dd51da1d9fc0de0d2f5ee7aaa9fdbc2a2aff7fc11eb0f246764043ca6bc8def942473fbacbbc8faf4282b8be0600f8b36f4e894723cd3fab8db04774f25b586

data/README.md

@@ -20,7 +20,9 @@ Or install it yourself as:
 
 ## Usage
 
-### create connection
+### simple expamples
+
+#### create connection
 ```ruby
 require 'icinga_api'
 
@@ -30,24 +32,24 @@ icinga = IcingaApi.new(
 )
 ```
 
-### some sample host API calls
+#### host API
 ```ruby
 host = icinga.host("my-monitored-host")
 
 # is the host up?
-host.up?
+up = host.up?
 
 # what is the state of the host?
-host.current_state
+state = host.current_state
 
 # when was the last check of the host
-host.last_check
+t = host.last_check
 
 # has the host problem been acknowledged?
-host.problem_has_been_acknowledged
+ack = host.problem_has_been_acknowledged
 
 # get a list of services of the host
-host.services
+services = host.services
 
 # get a specific service by name on a host
 service = host.service("Time")
@@ -55,23 +57,45 @@ service = host.service("Time")
 etc.
 ```
 
-### some sample service API calls
+### service API
 ```ruby
 # is the service ok?
-service.ok?
+is_ok = service.ok?
 
 # since when is the service in the current state?
-service.last_state_change
+t = service.last_state_change
 
 # what is the display name of the service?
-service.display_name
+str = service.display_name
 
 # when will the service be checked the next time?
-service.next_check
+t = service.next_check
 
 etc.
 ```
 
+## more advanced examples
+
+IcingaApi understands predefined or manual filters, which make it possible to
+query any parameters
+
+### host api
+```ruby
+# find all hosts which are down
+hosts = icinga.hosts(IcingaApi::Host::F_DOWN)
+
+# find all hosts which are down and not acknowledged the easy_way
+hosts = icinga.hosts_down
+
+# or with filters:
+hosts = icinga.hosts(IcingaApi::Host::F_DOWN & IcingaApi::Host::F_NACK)
+
+# or with manually defined filters:
+filter_host_down = IcingaApi::Filter.new('HOST_CURRENT_STATE', '=', 1)
+filter_host_not_ack = IcingaApi::Filter.new('HOST_PROBLEM_HAS_BEEN_ACKNOWLEDGET', '=', 0)
+hosts = icinga.hosts(filter_host_down & filter_host_not_ack)
+```
+
 
 ## Contributing
 

data/lib/icinga_api.rb

@@ -5,7 +5,9 @@ require 'time'
 require 'ipaddress'
 
 require "icinga_api/version"
+require "icinga_api/filter"
 require "icinga_api/request"
+require "icinga_api/host_group"
 require "icinga_api/host"
 require "icinga_api/service"
 
@@ -21,4 +23,26 @@ class IcingaApi
     Host.new(self, name)
   end
 
+
+  def hosts(filter=nil)
+    rc = Request::request(self, Host::TARGET, filter, [:HOST_NAME])
+    rc[:result].map do |host_hash|
+      Host.new(self, host_hash[:HOST_NAME])
+    end
+  end
+
+
+  def hosts_up(filter=nil)
+    hosts(filter ? (Host::F_UP & filter) : Host::F_UP)
+  end
+
+
+  def host_group(name)
+    HostGroup.new(self, name)
+  end
+
+
+  def host_groups(filter)
+    # TODO
+  end
 end

data/lib/icinga_api/filter.rb

@@ -0,0 +1,38 @@
+class IcingaApi
+  class Filter
+    require 'json'
+
+    attr_reader :data
+
+    def initialize(field=nil, operator=nil, value=nil)
+      @multi = false
+      if field.class == Hash
+        # only for internal use
+        @data = field
+        @multi = true
+      else
+        # normal use
+        @data = { type: "atom", field: [ field ], method: [ operator ], value:  [ value ] }
+      end
+    end
+
+
+    def &(other)
+      other = Marshal.load(Marshal.dump(other)) 
+      self.class.new ({ type: 'AND', field: [@data, other.data] })
+    end
+
+
+    def |(other)
+      other = Marshal.load(Marshal.dump(other)) 
+      self.class.new ({ type: 'OR', field: [@data, other.data] })
+    end
+
+
+    def to_json
+      # icinga always wants a AND or OR construct, the hell knows why
+      return (self & self).to_json unless @multi
+      @data.to_json
+    end
+  end # of class Filter
+end # of class IcingaApi

data/lib/icinga_api/host.rb

@@ -3,6 +3,14 @@ class IcingaApi
     TARGET="host"
     attr_reader :name, :host_filter
 
+    # some popular filter definitions
+    F_UP = Filter.new("HOST_CURRENT_STATE", "=", 0)
+    F_DOWN = Filter.new("HOST_CURRENT_STATE", "=", 1)
+    F_ACK = Filter.new("HOST_PROBLEM_HAS_BEEN_ACKNOWLEDGED", "=", 1)
+    F_NACK = Filter.new("HOST_PROBLEM_HAS_BEEN_ACKNOWLEDGED", "=", 0)
+    F_DOWN_ACK = F_DOWN & F_ACK
+    F_DOWN_NACK = F_DOWN & F_NACK
+
     CHECKS = {
       integer: %i(
         HOST_ID
@@ -37,8 +45,8 @@ class IcingaApi
         HOST_SHOULD_BE_SCHEDULED
         HOST_PROCESS_PERFORMANCE_DATA
       ),
+      #HOST_NAME
       string: %i(
-        HOST_NAME
         HOST_ALIAS
         HOST_DISPLAY_NAME
         HOST_NOTES
@@ -75,7 +83,7 @@ class IcingaApi
     def initialize(connection, name)
        @connection = connection
        @name = name
-       @host_filter = filter("HOST_NAME", "=", name)
+       @host_filter = Filter.new("HOST_NAME", "=", name)
     end
 
 
@@ -124,7 +132,6 @@ class IcingaApi
 
     def services
       rc = request(Service::TARGET, @host_filter, [:SERVICE_NAME])
-      # TODO: langsam, und keine Ahnung, warum
       rc[:result].map do |service_hash|
         Service.new(@connection, self, service_hash[:SERVICE_NAME])
       end

data/lib/icinga_api/host_group.rb

@@ -0,0 +1,68 @@
+class IcingaApi
+  class HostGroup < Request
+    TARGET="hostgroup"
+    attr_reader :name, :host_group_filter
+
+    CHECKS = {
+      integer: %i(
+        HOSTGROUP_ID
+        HOSTGROUP_OBJECT_ID
+        HOSTGROUP_INSTANCE_ID
+      ),
+      #float: %i(
+      #),
+      #boolean: %i(
+      #),
+      string: %i(
+        HOSTGROUP_NAME
+        HOSTGROUP_ALIAS
+      ),
+      #time: %i(
+      #)
+    }
+
+    CHECKS.each do |check_type, arr|
+      request_name = "#{check_type.to_s}_request"
+      arr.each do |method_symbol|
+        method_name = method_symbol.to_s.gsub(/^\w+?_/, "").downcase
+        define_method(method_name) do
+          send(request_name, TARGET, @host_group_filter, method_symbol)
+        end
+      end
+    end
+
+
+    def initialize(connection, name)
+       @connection = connection
+       @name = name
+       @host_group_filter = Filter.new("HOSTGROUP_NAME", "=", name)
+    end
+
+
+    def fetch(method)
+      string_request(TARGET, @host_group_filter, method)
+    end
+
+
+    def hosts(filter=nil)
+      filter = filter ? (@host_group_filter & filter) : @host_group_filter
+      rc = request(Host::TARGET, filter, [:HOST_NAME])
+      rc[:result].map do |host_hash|
+        Host.new(@connection, host_hash[:HOST_NAME])
+      end
+    end
+
+
+    def hosts_down
+      hosts(Host::F_DOWN)
+    end
+
+
+    def hosts_up
+      hosts(Host::F_UP)
+    end
+
+
+    # TODO: implement further
+  end # of class HostGroup
+end

data/lib/icinga_api/request.rb

@@ -2,36 +2,18 @@ class IcingaApi
   class Request
     attr_accessor :connection
 
-    protected
-    
-    def and_filters(a, b)
-      { type: "AND", field: [a, b] }
-    end
-
-
-    def or_filters(a, b)
-      { type: "OR", field: [a, b] }
-    end
-
-
-    def filter(field, operator, value)
-      { type: "atom", field: [ field ], method: [ operator ], value:  [ value ] }
-    end
-
-
-    def request(target, filters, columns)
+    def self.request(connection, target, filter, columns)
       # prepare post data
       data = Hash.new
-      data[:authkey] = @connection.data[:authkey]
+      data[:authkey] = connection.data[:authkey]
       data[:target] = target
-      filters = and_filters(filters, filters) # the hell knows why, but the api always wants an AND- or OR-construct on the top level
-      data[:filters_json] = filters.to_json if filters
+      data[:filters_json] = filter.to_json if filter
       columns.each_with_index do |col, i|
         data["columns[#{i}]".to_sym] = col
       end
 
       # post data
-      url = @connection.data[:url]
+      url = connection.data[:url]
       uri = URI("#{url}/web/api/authkey=#{data[:authkey]}/json")
       res = Net::HTTP.post_form(uri, data)
       raise "error on API query" unless res.code.to_i == 200
@@ -39,29 +21,62 @@ class IcingaApi
     end
 
 
-    def string_request(target, filter, field)
-      rc = request(target, filter, [ field ])
+    def self.string_request(connection, target, filter, field)
+      rc = request(connection, target, filter, [ field ])
       rc[:result][0][field]
     end
 
 
+    def self.integer_request(connection, target, filter, field)
+      string_request(connection, target, filter, field).to_i
+    end
+
+
+    def self.float_request(connection, target, filter, field)
+      string_request(connection, target, filter, field).to_f
+    end
+
+
+    def self.boolean_request(connection, target, filter, field)
+      integer_request(connection, target, filter, field) == 1
+    end
+
+
+    def self.time_request(connection, target, filter, field)
+      Time.parse(string_request(connection, target, filter, field))
+    end
+
+
+    protected
+   
+
+    def request(target, filters, columns)
+      self.class.request(@connection, target, filters, columns)
+    end
+
+
+    def string_request(target, filter, field)
+      self.class.string_request(@connection, target, filter, field)
+    end
+
+
     def integer_request(target, filter, field)
-      rc = string_request(target, filter, field).to_i
+      self.class.integer_request(@connection, target, filter, field)
     end
 
 
     def float_request(target, filter, field)
-      rc = string_request(target, filter, field).to_f
+      self.class.float_request(@connection, target, filter, field)
     end
 
 
     def boolean_request(target, filter, field)
-      integer_request(target, filter, field) == 1
+      self.class.boolean_request(@connection, target, filter, field)
     end
 
 
     def time_request(target, filter, field)
-      Time.parse(string_request(target, filter, field))
+      self.class.time_request(@connection, target, filter, field)
     end
   end # of class Request
 end

data/lib/icinga_api/service.rb

@@ -72,7 +72,7 @@ class IcingaApi
       @connection = connection
       @host = host
       @name = name
-      @service_filter = and_filters(@host.host_filter, filter("SERVICE_NAME", "=", name))
+      @service_filter = (@host.host_filter & Filter.new("SERVICE_NAME", "=", name))
     end
 
 
@@ -83,7 +83,7 @@ class IcingaApi
 
     def perfdata
       rc = request(TARGET, @service_filter, [:SERVICE_PERFDATA])
-      # TODO: parsen
+      # TODO: parsing
     end
 
 

data/lib/icinga_api/version.rb

@@ -1,3 +1,3 @@
 class IcingaApi
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: icinga_api
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Lothar Handl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-30 00:00:00.000000000 Z
+date: 2014-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ipaddress
@@ -66,7 +66,9 @@ files:
 - Rakefile
 - icinga_api.gemspec
 - lib/icinga_api.rb
+- lib/icinga_api/filter.rb
 - lib/icinga_api/host.rb
+- lib/icinga_api/host_group.rb
 - lib/icinga_api/request.rb
 - lib/icinga_api/service.rb
 - lib/icinga_api/version.rb