zabbixapi 0.1.1

data/README.rdoc

@@ -0,0 +1,28 @@
+= Ruby Zabbix Api Module.
+
+Simple and lightweight ruby module for work with zabbix api version 1.8.2
+
+You can:
+* Create host/template/application/items/triggers and screens;
+* Get info about all zabbix essences;
+
+== Get Start.
+
+* Get hostid from zabbix api:
+
+    zbx = Zabbix::ZabbixApi.new('https://zabbix.example.com', 'login', 'password')
+    hostid = zbx.get_host_id('my.example.com')
+
+    p hostid
+
+== Dependencies
+
+* net/http
+* net/https
+* json
+
+== Zabbix documentation
+
+* Zabbix Project Homepage -> http://zabbix.com/
+* Zabbix Api Draft docs -> http://www.zabbix.com/documentation/1.8/api
+

data/lib/1.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require './base'
+require './host'
+
+
+zbx = ZabbixApi.new('', '', '')

data/lib/base.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/ruby
+
+require 'json'
+require 'net/http'
+require 'net/https'
+
+module ZabbixApi
+
+	class JsonMessage < RuntimeError
+	end
+
+	class ResponceCodeError < RuntimeError
+	end
+
+	class ResponceBodyHash < RuntimeError
+	end
+
+	class InvalidAnswerId < RuntimeError
+	end
+
+	class Error < RuntimeError
+	end
+
+	def initialize ( api_url, api_user, api_password )
+		@api_url = api_url
+		@api_user = api_user
+		@api_password = api_password
+	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)
+
+		# TODO сделать проверку невозможности подключения.
+		responce = http.request(request)
+
+		if ( responce.code != "200" ) then
+			raise Zabbix::ResponceCodeError.new("Responce code from [" + @api_url + "] is " + responce.code)
+		end
+
+		responce_body_hash = JSON.parse(responce.body)
+
+		#if not ( responce_body_hash['id'] == id ) then
+		#	raise Zabbix::InvalidAnswerId.new("Wrong ID in zabbix answer")
+		#end
+
+
+		# Check errors in zabbix answer. If error exist - raise exception Zabbix::Error
+		if ( error = responce_body_hash['error'] ) then
+			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 + "]."
+
+			raise Zabbix::Error.new(e_message)
+		end
+
+		result = responce_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
+
+	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

data/lib/graph.rb

@@ -0,0 +1,55 @@
+module Zabbix
+	class ZabbixApi
+
+		def get_graph_id(host_id, graph_name)
+			
+			message = {
+				'method' => 'graph.get',
+				'params' => {
+					'filter' => {
+						'name' => graph_name,
+						'hostid' => host_id
+					}
+				}
+			}
+
+			responce = send_request(message)
+
+			unless ( responce.empty? ) then
+				result = responce[0]['graphid']
+			else
+				result = nil
+			end
+		end
+
+		def get_graphs(host_id)
+
+			message = {
+				'method' => 'graph.get',
+				'params' => {
+					'extendoutput' => '1',
+					'filter' => {
+						'hostid' => host_id
+					}
+				}
+			}
+
+			responce = send_request(message)
+
+			unless ( responce.empty? ) then
+				result = {}
+
+				responce.each() do |graph|
+					graph_id = graph['graphid']
+					graph_name = graph['name']
+
+					result[graph_id] = graph_name
+				end
+			else
+				result = nil
+			end
+
+			return result
+		end
+	end
+end

data/lib/group.rb

@@ -0,0 +1,78 @@
+module Zabbix
+
+	class ZabbixApi
+		def get_group_id(pattern)
+			
+			message = {
+				'method' => 'hostgroup.get',
+				'params' => {
+					'filter' => {
+						'name' => pattern
+					}
+				}
+			}
+
+			responce = send_request(message)
+
+			if not ( responce.empty? ) then
+				result = responce[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 
+				}
+			}
+
+			responce = send_request(message)
+
+			if ( responce ) then
+				result = responce['groupids'] 
+			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 ]
+				}
+			}
+
+			responce = send_request(message)
+
+			if not ( responce.empty? ) then
+				result = true
+			else
+				result = false
+			end
+			
+			return result
+		end
+	end
+end

data/lib/host.rb

@@ -0,0 +1,96 @@
+module Zabbix
+
+  # Examples:
+  # * Create host in zabbix
+  #   
+  #    zbx = Zabbix::ZabbixApi.new(url, user, password)
+  #    host_options => {
+  #      host => 'host.example.org',
+  #      ip => '127.0.0.1',
+  #      groups => [10001, 10002],
+  #    }
+  #    host_id = zbx.add_host(host_options)
+    
+    # Method for creation host in zabbix.
+    # * Input parameter - hash <tt>host_options</tt>. Available keys in hash:
+    #   - host - hostname. Type: string. Default: nil;
+    #   - port - zabbix agent pont. Type: int. Default: 10050;
+    #   - status - host status. Type: int. Possible values: 0 - monitored, 1 - not monitored. Default: 0; 
+    #   - useip - use ip or dns name for monitoring host. Possible values: 0 - don't use ip (use dns name), 1 - use ip (don't use dns name);
+    #   - ip - host's ip address. Used for monitoring host if useip set to 1. Default: '0.0.0.0';
+    #   - proxy_hostid - host_id of zabbix proxy (if necessary). See <tt>get_host_id</tt>. Default: 0 (don't use proxy server);
+    #   - groups - array of groups that belong host. Default: []. 
+    #   - useipmi - Use or not ipmi. Default: 0 (don't use ipmi);
+    #   - ipmi_ip - Default: '';
+    #   - ipmi_port - Default: 623;
+    #   - ipmi_authtype - Default: 0;
+    #   - ipmi_privilege - Default: 0;
+    #   - ipmi_username - Default: '';
+    #   - ipmi_password - Default: '';
+    def add_host(host_options)
+
+      host_default = {
+        'host' => nil,
+        'port' => 10050,
+        'status' => 0,
+        'useip' => 0,
+        'dns' => '',
+        'ip' => '0.0.0.0',
+        'proxy_hostid' => 0,
+        'groups' => [],
+        'useipmi' => 0,
+        'ipmi_ip' => '',
+        'ipmi_port' => 623,
+        'ipmi_authtype' => 0,
+        'ipmi_privilege' => 0,
+        'ipmi_username' => '',
+        'ipmi_password' => ''
+      }
+
+      host_options['groups'].map! { |group_id| {'groupid' => group_id} }
+
+      host = merge_opt(host_default, host_options)
+
+      message = {
+        'method' => 'host.create',
+        'params' => host
+      }
+
+      responce = send_request(message)
+
+      if not ( responce.empty? ) then
+        result = responce['hostids'][0].to_i
+      else
+        result = nil
+      end
+
+      return result
+    end
+
+    # Method for retrieving host id from zabbix by hostname.
+    # * Non optional input parameters:
+    #   - hostname - Type: String.
+    # * Return:
+    #   - host_id - Return finded host_id for passed hostname. If host not found in zabbix - return nil
+    def get_host_id(hostname)
+  
+      message = {
+        'method' => 'host.get',
+        'params' => {
+          'filter' => {
+            'host' => hostname
+          }
+        }
+      }
+
+      responce = send_request(message)
+
+      if not ( responce.empty? ) then
+        result = responce[0]['hostid'].to_i
+      else
+        result = nil
+      end
+
+      return result
+    end
+  end

data/lib/item.rb

@@ -0,0 +1,127 @@
+module Zabbix
+	class ZabbixApi
+		def add_item(item)
+				
+			item_options = {
+                    'description'           => nil,
+	                'key_'                  => nil,
+                    'hostid'                => nil,
+                    'delay'                 => 60,
+                    'history'               => 60,
+                    'status'                => 0,
+                    'type'                  => 7,
+                    'snmp_community'        => '',
+                    'snmp_oid'              => '',
+                    'value_type'            => 3,
+                    'data_type'             => 0,
+                    'trapper_hosts'         => 'localhost',
+                    'snmp_port'             => 161,
+                    'units'                 => '',
+                    'multiplier'            => 0,
+                    'delta'                 => 0,
+                    'snmpv3_securityname'   => '',
+                    'snmpv3_securitylevel'  => 0,
+                    'snmpv3_authpassphrase' => '',
+                    'snmpv3_privpassphrase' => '',
+                    'formula'               => 0,
+                    'trends'                => 365,
+                    'logtimefmt'            => '',
+                    'valuemapid'            => 0,
+                    'delay_flex'            => '',
+                    'authtype'              => 0,
+                    'username'              => '',
+                    'password'              => '',
+                    'publickey'             => '',
+                    'privatekey'            => '',
+                    'params'                => '',
+                    'ipmi_sensor'           => '',
+                    'applications'          => '',
+                    'templateid'            => 0
+				}
+
+
+				item_options.merge!(item)
+		
+				message = {
+					'method' => 'item.create',
+					'params' => [ item_options ]
+				}
+
+				responce = send_request(message)
+
+				unless ( responce.empty? ) then
+					result = responce['itemids'][0]
+				else
+					result = nil
+				end
+
+				return result
+		end
+
+
+		def get_webitem_id(host_id, item_name)
+			message = {
+				'method' => 'item.get',
+				'params' => {
+					'filter' => {
+						'hostid' => host_id,
+						'type' => 9,
+						'key_' => "web.test.time[eva.ru,Get main page,resp]"
+					},
+					'webitems' => 1
+				}
+			}
+
+			responce = send_request(message)
+		
+			p responce
+	
+			unless ( responce.empty? ) then
+				result = responce[0]['itemid']
+			else
+				result = nil
+			end
+
+			return result
+
+		end
+
+		def get_item_id(host_id, item_name)
+			message = {
+				'method' => 'item.get',
+				'params' => {
+					'filter' => {
+						'hostid' => host_id,
+						'description' => item_name
+					}
+				}
+			}
+
+			responce = send_request(message)
+			
+			unless ( responce.empty? ) then
+				result = responce[0]['itemid']
+			else
+				result = nil
+			end
+
+			return result
+
+		end
+
+		def update_item(item_id)
+
+			message = {
+				'method' => 'item.update',
+				'params' => {
+						'itemid' => item_id,
+						'status' => 0 
+				}
+			}
+
+			responce = send_request(message)
+
+			p responce
+		end
+	end
+end

data/lib/screen.rb

@@ -0,0 +1,169 @@
+module Zabbix
+	class ZabbixApi
+
+		def get_screen_id(screen_name)
+
+			message = {
+				'method' => 'screen.get',
+				'params' => {
+					'filter' => {
+						'name' => screen_name
+					}
+				}
+			}
+
+			responce = send_request(message)
+
+			if not ( responce.empty? ) then
+				result = responce[0]['screenid']
+			else
+				result = nil
+			end	
+		end
+
+		def get_screen_parameter(screen_name, param_name)
+
+			message = {
+				'method' => 'screen.get',
+				'params' => {
+					'extendoutput' => '1',
+					'filter' => {
+						'name' => screen_name
+					}
+				}
+			}
+
+
+			responce = send_request(message)
+
+			if not ( responce.empty? ) then
+				result = responce[0][param_name]
+			else
+				result nil
+			end
+		end
+
+		def get_screen_graph_ids(screen_id)
+
+			message = {
+				'method' => 'screen.get',
+				'params' => {
+					'extendoutput' => '1',
+					'select_screenitems' => '1',
+					'screenids' => [ screen_id ]
+				}
+			}
+
+			responce = send_request(message)
+
+			p responce
+
+			unless ( responce.empty?) then
+				result = []
+				screenitems = responce[0]['screenitems']
+				screenitems.each() do |item|
+					if ( item['resourcetype'].to_i == 0 ) then
+						result << item['resourceid']
+					end
+				end
+			else
+				result = nil
+			end
+
+			return result
+		end
+
+		def set_screen_parameter(screen_id, param_name, param_value)
+			
+			message = {
+				'method' => 'screen.update',
+				'params' => {
+					param_name => param_value,
+					'screenid' => screen_id
+				}
+			}
+
+			responce = send_request(message)
+
+			if not ( responce.empty? ) then
+				result = true
+			else
+				result = false
+			end
+
+			return result
+		end
+
+		def del_all_graphs_from_screen(screen_id)
+
+			message = {
+				'method' => 'screen.deleteItems',
+				'params' => {
+					'screenids' => [ screen_id ],
+				}
+			}
+
+			responce = send_request(message)
+
+			if ( responce ) then
+				return responce
+			else
+				return nil
+			end
+		end
+
+		def add_graph_to_screen(screen_id, graph_id, x, y)
+		
+			message = {
+				'method' => 'screen.addItems',
+				'params' => {
+					'screenids' => [ screen_id ],
+					'screenitems' => [
+							{
+								'resourcetype' => 'graph',
+								'resourceid' => graph_id,
+								'width' => '800',
+								'height' => '200',
+								'x' => x,
+								'y' => y,
+								'valign' => 'Middle',
+								'halign' => 'Centre',
+								'colspan' => '0',
+								'rowspan' => '0',
+								'elements' => '0',
+								'dynamic' => '0',
+								'url' => '0',
+								'style' => '0'
+							}
+					]
+				}
+			}
+
+			responce = send_request(message)
+
+			return responce
+		end
+
+		def add_screen(screen_name, hsize, vsize)
+
+			message = {
+				'method' => 'screen.create',
+				'params' => {
+					'name' => screen_name,
+					'hsize' => hsize,
+					'vsize' => vsize
+				}
+			}
+
+			responce = send_request(message)
+
+			if not ( responce.empty? ) then
+				result = responce['screenids'][0]
+			else
+				result = nil
+			end
+		
+			return result
+		end
+	end
+end

data/lib/template.rb

@@ -0,0 +1,162 @@
+module Zabbix
+
+  class ZabbixApi
+
+    def add_template(template_options)
+
+      template_default = {
+        'host' => nil,
+        'groups' => [],
+      }
+
+      template_options['groups'].map! { |group_id| {'groupid' => group_id} }
+
+      template = merge_opt(template_default, template_options)
+
+      message = {
+        'method' => 'template.create',
+        'params' => template
+      }
+
+      responce = send_request(message)
+
+      if not ( responce.empty? ) then
+        result = responce['templateids'][0].to_i
+      else
+        result = nil
+      end
+
+      return result
+    end
+
+    def get_template_ids_by_host(host_id)
+
+      message = {
+        'method' => 'template.get',
+        'params' => {
+          'hostids' => [ host_id ]
+        }
+      }
+
+      responce = send_request(message)
+
+      unless ( responce.empty? ) then
+        result = []
+        responce.each_key() do |template_id|
+          result << template_id
+        end
+      else
+        result = nil
+      end
+
+      return result
+    end
+
+    def get_templates()
+  
+      message = {
+        'method' => 'template.get',
+        'params' => {
+          'extendoutput' => '0'
+        }
+      }
+
+      responce = send_request(message)
+
+
+      unless ( responce.empty? ) then
+
+        template_ids = responce.keys()
+
+        result = {}
+
+        template_ids.each() do |template_id|
+          template_name = responce[template_id]['host']
+          result[template_id] = template_name
+        end
+      else
+        result = nil
+      end
+
+      return result
+    end
+
+    def get_template_id(template_name)
+
+      message = {
+        'method' => 'template.get',
+        'params' => {
+          'filter' => {
+            'host' => template_name
+          }
+        }
+      }
+
+      responce = send_request(message)
+
+      if not ( responce.empty? ) then
+        result = responce.keys[0]
+      else
+        result = nil
+      end
+
+      return result
+
+    end
+
+    def link_templates_with_hosts(templates_id, hosts_id)
+
+      if ( templates_id.class == Array ) then
+        message_templates_id = templates_id
+      else
+        message_templates_id = [ templates_id ]
+      end
+
+      if ( hosts_id == Array ) then
+        message_hosts_id = hosts_id
+      else
+        message_hosts_id = [ hosts_id ]
+      end
+
+      message = {
+        'method' => 'template.massAdd',
+        'params' => {
+          'hosts' => message_hosts_id,
+          'templates' => message_templates_id
+        }
+      }
+
+      responce = send_request(message)
+
+      return responce
+    end
+
+    def unlink_templates_from_hosts(templates_id, hosts_id)
+
+      if ( templates_id.class == Array ) then
+        message_templates_id = templates_id
+      else
+        message_templates_id = [ templates_id ]
+      end
+
+      if ( hosts_id == Array ) then
+        message_hosts_id = hosts_id
+      else
+        message_hosts_id = [ hosts_id ]
+      end
+
+      message = {
+        'method' => 'template.massRemove',
+        'params' => {
+          'hosts' => message_hosts_id,
+          'templates' => message_templates_id,
+          'force' => '1'
+        }
+      }
+
+      responce = send_request(message)
+
+      return responce
+    end
+  end
+end

data/lib/trigger.rb

@@ -0,0 +1,94 @@
+module Zabbix
+	class ZabbixApi
+
+		def add_trigger(trigger)
+
+			message = {
+				'method' => 'trigger.create',
+				'params' => [ trigger ]
+			}
+
+			responce = send_request(message)
+
+			unless ( responce.empty? ) then
+				result = responce['triggerids'][0]
+			else
+				result = nil
+			end
+
+			return result
+		end
+
+		def get_trigger_id(host_id, trigger_name)
+
+			message = {
+				'method' => 'trigger.get',
+				'params' => {
+					'filter' => {
+						'hostid' => host_id,
+						'description' => trigger_name
+					}
+				}
+			}
+
+			responce = send_request(message)
+
+			unless ( responce.empty? ) then
+				result = responce[0]['triggerid']
+			else
+				result = nil
+			end
+		
+			return result
+		end
+
+		def get_triggers_by_host(host_id)
+
+			message = {
+				'method' => 'trigger.get',
+				'params' => {
+					'filter' => {
+						'hostid' => host_id,
+					},
+					'extendoutput' => '1'
+				}
+			}
+
+			responce = send_request(message)
+
+			unless ( responce.empty? ) then
+				result = {}
+				responce.each do |trigger|
+					trigger_id = trigger['triggerid']
+					description = trigger['description']
+					result[trigger_id] = description
+				end
+			else
+				result = {}
+			end
+
+			return result
+		end
+
+		def update_trigger_status(trigger_id, status)
+
+			message = {
+				'method' => 'trigger.update_status',
+				'params' => {
+					'triggerid' => trigger_id,
+					'status' => status
+				}
+			}
+
+			responce = send_request(message)
+
+			unless ( responce.empty? ) then
+				result = responce['triggerids'][0]
+			else
+				result = nil
+			end
+
+			return result
+		end
+	end
+end

data/lib/usermacro.rb

@@ -0,0 +1,75 @@
+module Zabbix
+
+	class ZabbixApi
+		def add_macro(host_id, macro_name, macro_value)
+
+			message = {
+				'method' => 'Usermacro.create',
+				'params' => {
+					'hostid' => host_id,
+					'macro' => macro_name,
+					'value'=> macro_value
+				}
+			}
+
+			responce = send_request(message)
+
+			if ( hostmacroids = responce['hostmacroids'] ) then
+				result = hostmacroids
+			else
+				result = nil
+			end
+
+			return result
+		end
+
+		def get_macro(host_id, macro_name)
+		
+			message = {
+				'method' => 'Usermacro.get',
+				'params' => {
+					'hostids' => host_id,
+					'macros' => macro_name,
+					'extendoutput' => '1'
+				}
+			}
+
+			responce = send_request(message)
+
+			if not ( responce.empty?) then
+				if ( hostmacroid =  responce[0]['hostmacroid'] ) then
+					macro_id = hostmacroid
+					macro_value = responce[0]['value']
+
+					result = {
+						'id' => macro_id,
+						'value'=> macro_value
+					}
+				else
+					result = nil
+				end
+			else
+				result = nil
+			end
+
+			return result
+		end
+
+		def set_macro_value(host_id, macro_name, macro_value)
+			
+			message = {
+				'method' => 'usermacro.updateValue',
+				'params' => {
+					'hostid' => host_id,
+					'macro' => macro_name,
+					'value' => macro_value
+				}
+			}
+
+			responce = send_request(message)
+
+			# Проверять ответ бесполезно. В ответ всегда возвращается запрос.
+			return true
+		end
+	end
+end

data/lib/zabbixapi.rb

@@ -0,0 +1,9 @@
+require 'base'
+require 'graph'
+require 'group'
+require 'host'
+require 'item'
+require 'screen'
+require 'template'
+require 'trigger'
+require 'usermacro'

data/zabbixapi.gemspec

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Gem::Specification.new do |spec|
+
+  spec.version = '0.1.1'
+  spec.name = 'zabbixapi'
+  spec.summary = 'Ruby module for work with zabbix api.'
+
+  spec.email = 'verm666@gmail.com'
+  spec.author = 'Eduard Snesarev'
+  spec.homepage = 'http://github.com/verm666/zabbixapi'
+  spec.description = 'Ruby module for work with zabbix api. '
+
+  spec.has_rdoc = true
+  spec.extra_rdoc_files  = 'README.rdoc'
+
+
+  spec.files = FileList["lib/*.rb", "bin/*", "spec/*", 'zabbixapi.gemspec', 'README.rdoc'].to_a
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: zabbixapi
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Eduard Snesarev
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-09 00:00:00 +04:00
+default_executable: 
+dependencies: []
+
+description: "Ruby module for work with zabbix api. "
+email: verm666@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/trigger.rb
+- lib/screen.rb
+- lib/1.rb
+- lib/host.rb
+- lib/usermacro.rb
+- lib/template.rb
+- lib/item.rb
+- lib/zabbixapi.rb
+- lib/base.rb
+- lib/group.rb
+- lib/graph.rb
+- zabbixapi.gemspec
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/verm666/zabbixapi
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby module for work with zabbix api.
+test_files: []
+