zabbixapi 0.1.4 → 0.1.5a1

data/examples/zabbix_memory

@@ -0,0 +1,276 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'yaml'
+require 'getopt/std'
+require 'zabbixapi'
+
+opt = Getopt::Std.getopts("g:E:")
+
+group_name = opt["g"]
+zabbix_env = opt["E"]
+
+template_name = "TMPL_Memory"
+
+# read config
+config = YAML::load(open('./config.yml'))
+
+api_url = config[zabbix_env]["api_url"]
+api_login = config[zabbix_env]["api_login"]
+api_password = config[zabbix_env]["api_password"]
+
+# Esablish new connection
+zbx = Zabbix::ZabbixApi.new(api_url, api_login, api_password)
+
+# Create new template
+p " * Creating template #{template_name}."
+g_id = zbx.get_group_id(group_name)
+
+options = {
+  'groups' => [ g_id.to_i ],
+  'host' => template_name
+}
+
+t_id = zbx.add_template(options)
+
+# Create application #{app_name}
+app_name = "Memory"
+p " ** Create application #{app_name}."
+application = {
+  'hostid' => t_id.to_i,
+  'name' => app_name
+}
+a_id = zbx.add_application(application)
+
+# 'Buffers memory'
+options = {
+  'description' => "Buffers memory",
+  'key_' => "vm.memory.size[buffers]",
+  'hostid' => t_id.to_i,
+  'applications' => [ a_id.to_i ],
+  'units' => 'B',
+  'history' => 7,
+  'trends' => 30,
+  'value_type' => 0
+}
+p " ** Add 'Buffers memory' to #{template_name}."
+
+buffers_in_b_item_id = zbx.add_item(options)
+
+# 'Cached memory'
+options = {
+  'description' => "Cached memory",
+  'key_' => "vm.memory.size[cached]",
+  'hostid' => t_id.to_i,
+  'applications' => [ a_id.to_i ],
+  'units' => 'B',
+  'history' => 7,
+  'trends' => 30,
+  'value_type' => 0
+}
+p " ** Add 'Cached memory' to #{template_name}."
+
+cached_in_b_item_id = zbx.add_item(options)
+
+# 'Total memory'
+options = {
+  'description' => "Total memory",
+  'key_' => "vm.memory.size[total]",
+  'hostid' => t_id.to_i,
+  'applications' => [ a_id.to_i ],
+  'delay' => '300',
+  'units' => 'B',
+  'history' => 7,
+  'trends' => 30,
+  'value_type' => 0
+}
+p " ** Add 'Total memory' to #{template_name}."
+
+total_in_b_item_id = zbx.add_item(options)
+
+# 'Used memory with buffers and cache'
+options = {
+  'description' => "Used memory",
+  'key_' => "vm.memory.size[used]",
+  'hostid' => t_id.to_i,
+  'applications' => [ a_id.to_i ],
+  'delay' => '300',
+  'units' => 'B',
+  'history' => 7,
+  'trends' => 30,
+  'value_type' => 0
+}
+p " ** Add 'Used memory' to #{template_name}."
+
+used_in_b_item_id = zbx.add_item(options)
+
+# 'Free memory'
+options = {
+  'description' => "Free memory",
+  'key_' => "vm.memory.size[free]",
+  'hostid' => t_id.to_i,
+  'applications' => [ a_id.to_i ],
+  'units' => 'B',
+  'history' => 7,
+  'trends' => 30,
+  'value_type' => 0
+}
+p " ** Add 'Free memory' to #{template_name}."
+
+i_id = zbx.add_item(options)
+
+# 'Free mmeory with buffers and cache'
+options = {
+  'description' => "Free memory with buffers and cache",
+  'key_' => "vm.memory.size[free_with_buffer_cache]",
+  'params' => "last(\"vm.memory.size[free]\") + last(\"vm.memory.size[cached]\") + last(\"vm.memory.size[buffers]\")",
+  'hostid' => t_id.to_i,
+  'type' => '15', #calculated
+  'applications' => [ a_id.to_i ],
+  'units' => 'B',
+  'history' => 7,
+  'trends' => 30,
+  'value_type' => 0
+}
+p " ** Add 'Free memory with buffers and cache' to #{template_name}."
+
+i_id = zbx.add_item(options)
+
+# 'Swap in all'
+options = {
+  'description' => "Swap in all",
+  'key_' => "system.swap.in[]",
+  'hostid' => t_id.to_i,
+  'applications' => [ a_id.to_i ],
+  'multiplier' => 1,
+  'formula' => 512,
+  'units' => 'B',
+  'history' => 7,
+  'trends' => 30,
+  'value_type' => 0
+}
+p " ** Add 'Swap in all' to #{template_name}."
+
+i_id = zbx.add_item(options)
+
+# 'Swap out all'
+options = {
+  'description' => "Swap out all",
+  'key_' => "system.swap.out[]",
+  'hostid' => t_id.to_i,
+  'applications' => [ a_id.to_i ],
+  'multiplier' => 1,
+  'formula' => 512,
+  'units' => 'B',
+  'history' => 7,
+  'trends' => 30,
+  'value_type' => 0
+}
+p " ** Add 'Swap out all' to #{template_name}."
+
+i_id = zbx.add_item(options)
+
+# TRIGGERS
+options = {
+  'description' => "Free memory without cache, %",
+  'expression' => "{#{template_name}:vm.memory.size[free].last(0)}<15",
+  'priority' => 2, # warning
+  'templateid' => 0,
+  'comments' => "Free memory without cache, % warning trigger",
+  'type' => 0,
+  'status' => '0'
+}
+
+p " ** Add 'Free memory without cache, %'"
+tr_id = zbx.add_trigger(options)
+
+options = {
+  'description' => "Free memory without cache, %",
+  'expression' => "{#{template_name}:vm.memory.size[free].last(0)}<10",
+  'priority' => 5, # disaster
+  'templateid' => 0,
+  'commenty' => "Free memory without cache, %",
+  'type' => 0,
+  'status' => '0'
+}
+
+p " ** Add 'Free memory without cache, % disaster trigger'"
+tr_id = zbx.add_trigger(options)
+
+options = {
+  'description' => "Swap usage in, B",
+  'expression' => "{#{template_name}:system.swap.in[].last(0)}#0",
+  'priority' => 2, # warning
+  'templateid' => 0,
+  'comments' => "Swap usage in, B",
+  'type' => 0,
+  'status' => '0'
+}
+
+p " ** Add 'Swap usage in, B warning trigger'"
+tr_id = zbx.add_trigger(options)
+
+options = {
+  'description' => "Swap usage out, B",
+  'expression' => "{#{template_name}:system.swap.out[].last(0)}#0",
+  'priority' => 2, # warning
+  'templateid' => 0,
+  'comments' => "Swap usage out, B",
+  'type' => 0,
+  'status' => '0'
+}
+
+p " ** Add 'Swap usage out, B warning trigger'"
+tr_id = zbx.add_trigger(options)
+
+options = {
+    'gitems' => [
+    {   
+      "itemid" => total_in_b_item_id,
+      "drawtype" => "0",
+      "sortorder" => "0",
+      "color" => "AA0000",
+      "yaxisside" => "0",
+      "calc_fnc" => "2",
+      "type" => "0",
+      "periods_cnt" => "5" 
+    },  
+    {   
+      "itemid" => used_in_b_item_id,
+      "drawtype" => "0",
+      "sortorder" => "0",
+      "color" => "009900",
+      "yaxisside" => "0",
+      "calc_fnc" => "2",
+      "type" => "0",
+      "periods_cnt" => "5" 
+    },
+    {   
+      "itemid" => cached_in_b_item_id,
+      "drawtype" => "0",
+      "sortorder" => "0",
+      "color" => "0000AA",
+      "yaxisside" => "0",
+      "calc_fnc" => "2",
+      "type" => "0",
+      "periods_cnt" => "5" 
+    },
+    {   
+      "itemid" => buffers_in_b_item_id,
+      "drawtype" => "0",
+      "sortorder" => "0",
+      "color" => "AA00AA",
+      "yaxisside" => "0",
+      "calc_fnc" => "2",
+      "type" => "0",
+      "periods_cnt" => "5" 
+    }
+  ],  
+  "show_triggers" => "1",
+  "name" => "Memory usage",
+  "width" => "900",
+  "height" => "200",
+  "templateid" =>  "0" 
+}
+
+g_id = zbx.add_graph(options)

data/examples/zabbix_net

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'getopt/std'
+require 'yaml'
+require 'zabbixapi'
+
+opt = Getopt::Std.getopts("g:i:E:")
+
+group_name = opt["g"]
+interface_name = opt["i"]
+zabbix_env = opt["E"]
+
+template_name = "TMPL_Net_#{interface_name}"
+app_name = "Net_#{interface_name}"
+
+
+# read config
+config = YAML::load(open('./config.yml'))
+
+api_url = config[zabbix_env]["api_url"]
+api_login = config[zabbix_env]["api_login"]
+api_password = config[zabbix_env]["api_password"]
+
+# Esablish new connection
+zbx = Zabbix::ZabbixApi.new(api_url, api_login, api_password)
+
+# Create new template
+p " * Creating template #{template_name}."
+g_id = zbx.get_group_id(group_name)
+
+options = {
+  'groups' => [ g_id.to_i ],
+  'host' => template_name
+}
+
+t_id = zbx.add_template(options)
+
+# Create application #{app_name}
+p " ** Create application #{app_name}."
+application = {
+  'hostid' => t_id.to_i,
+  'name' => app_name
+}
+a_id = zbx.add_application(application)
+
+# 'Net #{interface_name} incoming traffic'
+options = {
+  'description' => "Net #{interface_name} incoming, B",
+  'key_' => "net.if.in[#{interface_name}, bytes]",
+  'hostid' => t_id.to_i,
+  'applications' => [ a_id.to_i ],
+  'history' => 7,
+  'trends' => 30,
+  'delay' => 60,
+  'value_type' => 0,
+  'units' => 'Bps',
+  'value_type' => '3', # Numeric (unsigned)
+  'delta' => 1 # Store as delta (Speed per second)
+}
+p " ** Add 'Net #{interface_name} incoming, B' to #{template_name}."
+
+i_id = zbx.add_item(options)
+
+# 'Net #{interface_name} outgoing traffic'
+options = {
+  'description' => "Net #{interface_name} outgoing, B",
+  'key_' => "net.if.out[#{interface_name}, bytes]",
+  'hostid' => t_id.to_i,
+  'applications' => [ a_id.to_i ],
+  'history' => 7,
+  'trends' => 30,
+  'delay' => 60,
+  'value_type' => 0,
+  'units' => 'Bps',
+  'value_type' => '3', # Numeric (unsigned)
+  'delta' => 1 # Store as delta (Speed per second)
+
+}
+p " ** Add 'Net #{interface_name} outgoing, B' to #{template_name}."
+
+i_id = zbx.add_item(options)

data/lib/{application.rb → zabbixapi/application.rb}

@@ -1,5 +1,3 @@
-require 'base'
-
 module Zabbix
   class ZabbixApi
     def add_application(app_options)
@@ -17,13 +15,36 @@ module Zabbix
 
       responce = send_request(message)
 
-      if not ( responce.empty? ) then
+      unless responce.empty? then
         result = responce['applicationids'][0].to_i
       else
-        result = nil 
+        result = nil
       end 
 
       return result
     end
   end
+
+  def get_app_id(host_id, app_name)
+
+    message = {
+      'method' => 'application.get',
+      'params' => {
+        'filter' => {
+          'name' => app_name,
+          'hostid' => host_id
+        }
+      }
+    }
+
+    responce = send_request(message)
+
+    unless responce.empty? then
+      result = responce[0]['applicationid']
+    else
+      result = nil 
+    end 
+
+    return result
+  end 
 end

data/lib/zabbixapi/base.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/ruby
+
+require 'json'
+require 'net/http'
+require 'net/https'
+
+module Zabbix
+
+  class SocketError < RuntimeError
+  end
+
+  class ResponseCodeError < RuntimeError
+  end
+
+  class ResponseError < RuntimeError
+  end
+
+  class AlreadyExist < RuntimeError
+  end
+
+  class ArgumentError < RuntimeError
+  end
+
+  class ZabbixApi
+
+    attr_accessor :debug
+
+    def initialize ( api_url, api_user, api_password )
+      @api_url = api_url
+      @api_user = api_user
+      @api_password = api_password
+
+      @debug = false # Disable debug by default
+    end
+
+    def do_request(message)
+
+      id = rand 100_000
+
+      message['id'] = id
+      message['jsonrpc'] = '2.0'
+
+      message_json = JSON.generate(message)
+
+      uri = URI.parse(@api_url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      if ( uri.scheme == "https" ) then
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.add_field('Content-Type', 'application/json-rpc')
+      request.body=(message_json)
+
+      begin
+        puts "[ZBXAPI] : INFO : Do request. Body => #{request.body}" if @debug
+        response = http.request(request)
+      rescue ::SocketError => e
+        puts "[ZBXAPI] : ERROR : SocketError => #{e.message}" if @debug
+        raise Zabbix::SocketError.new(e.message)
+      end
+
+      if @debug
+        puts "[ZBXAPI] : INFO : Response start"
+        puts response
+        puts "[ZBXAPI] : INFO : Response end"
+      end
+
+      if response.code != "200"
+        raise Zabbix::ResponseCodeError.new("Responce code from [" + @api_url + "] is #{response.code}")
+      end
+
+      response_body_hash = JSON.parse(response.body)
+
+      if error = response_body_hash['error']
+        error_message = error['message']
+        error_data = error['data']
+        error_code = error['code']
+
+        e_message = "Code: [" + error_code.to_s + "]. Message: [" + error_message +\
+              "]. Data: [" + error_data + "]."
+
+        case error_code.to_s 
+        when '-32602'
+          raise Zabbix::AlreadyExist.new(e_message)
+        else
+          raise Zabbix::ResponseError.new(e_message)
+        end
+      end
+
+      result = response_body_hash['result']
+
+      return result
+    end
+
+    def send_request(message)
+      message['auth'] = auth()
+      do_request(message)
+    end
+
+    def auth()
+
+      auth_message = {
+        'auth' =>  nil,
+        'method' =>  'user.authenticate',
+        'params' =>  {
+          'user' => @api_user,
+          'password' => @api_password,
+          '0' => '0'
+        }
+      }
+
+      auth_id = do_request(auth_message)
+
+      return auth_id
+    end
+
+# Utils. 
+    def merge_opt(a, b)
+      c = {}
+
+      b.each_pair do |key, value|
+        if a.has_key?(key) then
+          c[key] = value
+        end
+     end
+
+      return a.merge(c)
+    end
+  end
+end

data/lib/{graph.rb → zabbixapi/graph.rb}

@@ -7,15 +7,13 @@ module Zabbix
         'params' => graph
       }
 
-      responce = send_request(message)
-
-      puts "DEBUG: #{responce.inspect}"
+      response = send_request(message)
 
       return 0
     end
 
     def get_graph_id(host_id, graph_name)
-      
+
       message = {
         'method' => 'graph.get',
         'params' => {
@@ -26,10 +24,10 @@ module Zabbix
         }
       }
 
-      responce = send_request(message)
+      response = send_request(message)
 
-      unless ( responce.empty? ) then
-        result = responce[0]['graphid']
+      unless ( response.empty? ) then
+        result = response[0]['graphid']
       else
         result = nil
       end
@@ -47,12 +45,12 @@ module Zabbix
         }
       }
 
-      responce = send_request(message)
+      response = send_request(message)
 
-      unless ( responce.empty? ) then
+      unless ( response.empty? ) then
         result = {}
 
-        responce.each() do |graph|
+        response.each() do |graph|
           graph_id = graph['graphid']
           graph_name = graph['name']
 

data/lib/zabbixapi/group.rb

@@ -0,0 +1,78 @@
+module Zabbix
+
+  class ZabbixApi
+    def get_group_id(pattern)
+
+      message = {
+        'method' => 'hostgroup.get',
+        'params' => {
+          'filter' => {
+            'name' => pattern
+          }
+        }
+      }
+
+      response = send_request(message)
+
+      if not ( response.empty? ) then
+        result = response[0]['groupid']
+      else
+        result = nil
+      end
+
+      return result
+    end
+
+    def group_exist?(pattern)
+
+      group_id = get_groups_id(pattern)
+
+      if ( group_id ) then
+        return true
+      else
+        return false
+      end
+    end
+
+    def add_group(groupname)
+
+      message = {
+        'method' => 'hostgroup.create',
+        'params' => {
+          'name' => groupname
+        }
+      }
+
+      response = send_request(message)
+
+      if ( response ) then
+        result = response['groupids'][0].to_i
+      else
+        result = nil
+      end
+
+      return result
+    end
+
+    def add_host_to_group(host_id, group_id)
+      
+      message = {
+        'method' => 'hostgroup.massAdd',
+        'params' => {
+          'groups' => [ group_id ],
+          'hosts' => [ host_id ]
+        }
+      }
+
+      response = send_request(message)
+
+      if not ( response.empty? ) then
+        result = true
+      else
+        result = false
+      end
+      
+      return result
+    end
+  end
+end