zapix3 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8aa4133a57fb5985c634605bbf7de7635d9c43e7
+  data.tar.gz: cec3c21554e7c9b9f35c97f795da6336c5e64da6
+SHA512:
+  metadata.gz: 7509a1b559da79453b163f57a956531bd14788f3bfd6de65b9b6326b262a60576d4fe53e07967ffdacf52007d56f844793a261ce52552d39821e0fd0703eb602
+  data.tar.gz: e323d830d53c6cb8d299ad77dc70b86826e89bc87ca2bfe96c2d1c4d01a9f7b4e66906d0a44ac9dfd610d6f3955cfcc6b67e4dda01e07cfa330720ae7808a402

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zapix.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    zapix3 (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.6)
+      activesupport (= 4.2.6)
+      builder (~> 3.1)
+    activerecord (4.2.6)
+      activemodel (= 4.2.6)
+      activesupport (= 4.2.6)
+      arel (~> 6.0)
+    activesupport (4.2.6)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.3)
+    builder (3.2.2)
+    diff-lcs (1.2.5)
+    i18n (0.7.0)
+    json (1.8.3)
+    minitest (5.9.0)
+    rake (11.1.2)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  bundler (~> 1.3)
+  json
+  rake
+  rspec
+  zapix3!

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Stoyan Stoyanov
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,383 @@
+# Zapix3
+
+Zapix is a tool which makes the communication with the zabbix's api simple.
+
+If you need a more detailed information of how to use zapix see the specs.
+
+This version of zappix is compatible with zabbix 3.0
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'zapix', '0.1.0'
+
+And then execute:
+
+    $ bundle install
+
+Or install it with gem:
+
+    $ gem install zapix3
+
+## Usage
+
+### Remote client
+First create a remote client. Feel free to
+disable the debug mode if you find it annoying.
+
+```ruby
+require 'zapix'
+zrc = ZabbixAPI.connect(
+  :service_url => 'https://zabbix-server.foo/api_jsonrpc.php',
+  :username => 'guybrush',
+  :password => 'threepwood',
+  :debug => true
+)
+```
+
+## Functionality
+
+### Hostgroup Operations
+#### Creating a hostgroup
+```ruby
+zrc.hostgroups.create('test_hostgroup')
+```
+
+#### Checking if a hostgroup exists
+```ruby
+zrc.hostgroups.exists?('test_hostgroup')
+```
+
+#### Checking if a hostgroup has any attached hosts
+```ruby
+zrc.hostgroups.any_hosts?('test_hostgroup')
+```
+
+#### Getting all host ids of hosts belonging to a hostgroup
+```ruby
+zrc.hostgroups.get_host_ids_of('test_hostgroup')
+```
+
+#### Deleting a hostgroup
+Note that deleting a hostgroups with attached hosts also deletes the hosts.
+
+```ruby
+zrc.hostgroups.delete('test_hostgroup')
+```
+
+#### Getting the id of a hostgroup
+```ruby
+zrc.hostgroups.get_id('test_hostgroup')
+```
+
+#### Getting all hostgroups names
+```ruby
+zrc.hostgroups.get_all
+```
+
+### Host Operations
+
+#### Getting the id of a host
+```ruby
+zrc.hosts.get_id('test_host')
+```
+
+#### Checking if a host exists
+```ruby
+zrc.hosts.exists?('test_host')
+```
+
+#### Getting all host names
+```ruby
+zrc.hosts.get_all
+```
+
+#### Creating a host
+Note that in zabbix host cannot exists on its own, it always needs a hostgroup.
+```ruby 
+hostgroup_id = zrc.hostgroups.get_id('test_hostgroup')
+
+zabbix_interface = Interface.new(
+  'ip'  => '127.0.0.1',
+  'dns' => 'abrakadabra.com'
+)
+
+jmx_interface = Interface.new(
+  'ip'  => '127.0.0.1',
+  'dns' => 'abrakadabra.com',
+  'type' => 4, # JMX
+  'main' => 1, # default jmx interface
+  'port' => 9003
+)
+
+template_1 = zrc.templates.get_id('example_template_1')
+template_2 = zrc.templates.get_id('example_template_2')
+
+example_host = Host.new
+example_host.add_name('test_host')
+example_host.add_interfaces(zabbix_interface.to_hash)
+example_host.add_interfaces(jmx_interface.to_hash)
+example_host.add_macros({'macro' => '{$TESTMACRO}', 'value' => 'test123'})
+example_host.add_group_ids(hostgroup_id)
+example_host.add_template_ids(template_1, template_2)
+zrc.hosts.create(example_host.to_hash)
+```
+
+#### Deleting a host
+```ruby
+zrc.hosts.delete('test_host')
+```
+
+### Template Operations
+
+#### Checking if a template exists
+```ruby
+zrc.templates.exists?('test_template')
+```
+
+#### Getting the id of a template
+```ruby
+zrc.templates.get_id('test_template')
+```
+
+#### Getting all templates for a host
+```ruby
+zrc.templates.get_templates_for_host(zrc.hosts.get_id('test_host'))
+```
+
+### Application Operations
+
+#### Getting the id of an application
+Note that an application always belogs to a host.
+```ruby
+zrc.applications.get_id({
+  'name'   => 'test_app',
+  'hostid' => zrc.hosts.get_id('test_name')
+})
+```
+
+#### Creating an application for host
+```ruby
+zrc.applications.create({
+  'name'   => 'test_application'
+  'hostid' => zrc.hosts.get_id('test_host')
+})
+```
+
+### Web Scenario Operations
+Note that a web scenario needs a host and an application in zabbix 2.0.6. This is
+going to change in the next versions of zabbix. When creating scenarios it also
+makes sense to create triggers for them.
+
+#### Checking if a scenario exists
+```ruby
+zrc.scenarios.exists?({
+  'name'   => 'test_scenario',
+  'hostid' => zrc.hosts.get_id('test_host')
+})
+```
+
+#### Getting the id of a scenario
+```ruby
+zrc.scenarios.get_id({
+  'name'   => 'test_scenario'
+  'hostid' => zrc.hosts.get_id('test_host')
+})
+```
+
+#### Creating a scenario
+```ruby
+
+zrc.applications.create({
+  'name'   => 'test_app',
+  'hostid' => zrc.hosts.get_id('test_name')
+})
+
+webcheck_options = Hash.new
+webcheck_options['hostid'] = zrc.hosts.get_id('host')
+webcheck_options['name'] = 'my first scenario'
+webcheck_options['applicationid'] = zrc.applications.get_id('test_app')
+webcheck_options['steps'] = [{'name' => 'Homepage', 'url' => 'm.test.de', 'status_codes' => 200, 'no' => 1}]
+zrc.scenarios.create(webcheck_options)
+```
+
+#### Deleting a scenario
+```ruby
+zrc.scenarios.delete({
+  'name'   => 'test_scenario',
+  'hostid' => zrc.hosts.get_id('test_host')
+})
+```
+
+### Trigger Operations
+
+#### Checking if a trigger exists
+```ruby
+zrc.triggers.exists?({
+  'expression' => "{test_host:web.test.fail[test_scenario].max(#3)}#0"
+})
+```
+
+### Getting the id of a trigger
+```ruby
+zrc.triggers.get_id({
+  'expression' => "{test_host:web.test.fail[test_scenario].max(#3)}#0"
+})
+```
+
+### Creating a trigger
+```ruby
+options = Hash.new
+options['description'] = 'Webpage failed on {HOST.NAME}'
+options['expression'] = "{test_host:web.test.fail[test_scenario].max(#3)}#0"
+options['priority'] = 2 # 2 means Warning
+zrc.triggers.create(options)
+```
+
+### Deleting a trigger
+```ruby
+trigger_id = zrc.triggers.get_id({
+  'expression' => "{test_host:web.test.fail[test_scenario].max(#3)}#0"
+})
+
+zrc.triggers.delete(trigger_id)
+```
+
+### Usergroups Operations
+
+#### Checking if a usergroup exists
+```ruby
+  zrc.usergroups.exists?({
+  'name' => 'test_usergroup'
+})
+```
+#### Geting the id of a usergroup
+```ruby
+zrc.usergroups.get_id({
+  'name' = 'test_usergroup'
+})
+```
+
+#### Creating a usergroup
+```ruby
+options = Hash.new
+options['name'] = 'test_usergroup'
+options['rights'] = {
+  'permission' => 3,
+  'id' => zrc.hostgroups.get_id('test_hostgroup')
+}
+zrc.usergroups.create(options)
+```
+
+#### Deleting a user group
+```ruby
+usergroup_id = zrc.usergroups.get_id({'name' => 'test_usergroup'})
+zrc.usergroups.delete(usergroup_id)
+```
+
+### User Operations
+#### Checking if a user exists
+```ruby
+zrc.users.exists?({'alias' => 'max'})
+```
+
+#### Getting the id of a user
+```ruby
+zrc.users.get_id({'alias' => 'max'})
+```
+
+#### Creating a user
+```ruby
+group_id = zrc.usergroups.get_id({'name' => 'test_usergroup'})
+user_options = Hash.new
+
+user_options['alias']   = 'igor'
+user_options['passwd']  = 'geheim'
+user_options['usrgrps'] = [{
+  'usrgrpid' => group_id
+}]
+
+user_options['user_medias'] = [{
+  'mediatypeid' => 1,
+  'sendto' => 'support@company.com',
+  'active' => 0,
+  'severity' => 63,
+  'period' => '1-7,00:00-24:00'
+}]
+
+zrc.users.create(user_options)
+```
+
+### Actions Operations
+
+#### Checking if an action exists
+```ruby
+  zrc.actions.exists?({'name' => 'Report problems to Zabbix administrators'})
+```
+
+#### Getting the id of an action
+```ruby
+  zrc.actions.get_id({'name' => 'Report problems to Zabbix administrators'})
+```
+
+#### Creating an action
+```ruby
+  usergroup_options = Hash.new({'name' = 'test_usergroup'})
+  action_options = Hash.new
+  action_options['name'] = 'Report problems to Zabbix administrators'
+  action_options['eventsource'] = 0
+  action_options['evaltype'] = 1 # AND
+  action_options['status'] = 1 # Disabled
+  action_options['esc_period'] = 3600
+  action_options['def_shortdata'] = '{TRIGGER.NAME}: {TRIGGER.STATUS}'
+  action_options['def_longdata'] = "{TRIGGER.NAME}: {TRIGGER.STATUS}\r\nLast value: {ITEM.LASTVALUE}\r\n\r\n{TRIGGER.URL}"
+  action_options['conditions'] = [{
+    'conditiontype' => 0, # Hostgroup
+    'operator'      => 0, # =
+    'value' => zrc.hostgroups.get_id('Templates')
+   },
+   # not in maintenance
+   {
+     'conditiontype' => 16, # Maintenance
+     'operator'      => 7,  # not in
+     'value'         => 'maintenance'
+   }]
+
+  action_options['operations'] = [{
+    'operationtype' => 0,
+    'esc_period'     => 0,
+    'esc_step_from'  => 1,
+    'esc_step_to'    => 1,
+    'evaltype'       => 0,
+    'opmessage_grp'  => [{
+      'usrgrpid' => zrc.usergroups.get_id(usergroup_options)
+    }],
+    'opmessage' => {
+      'default_msg' => 1,
+      'mediatypeid' => 1
+    }
+  }]
+  zrc.actions.create(action_options)
+```
+
+### Remote client and tests
+In order to run the rspec tests you need a running zabbix test server.
+
+These environment variables also need to be set:
+
+    ZABBIX_API_URL
+    ZABBIX_API_LOGIN
+    ZABBIX_API_PASSWORD
+
+### TODOs
+Open source the docker-compose setup of the whole zabbix installation.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Don't forget to write tests
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/zapix/proxies/actions.rb

@@ -0,0 +1,26 @@
+require_relative 'base'
+
+class Actions < Base
+  def exists?(options)
+    result = client.action_get({'filter' => {'name' => options['name']}})
+    if (result == nil || result.empty?)
+      return false
+    else
+      return true
+    end
+  end
+
+  def create(options)
+    client.action_create(options) unless exists?(options)
+  end
+
+  def get_id(options)
+    result = client.action_get({
+      'filter' => {'name' => options['name']}})
+      result.first['actionid']
+  end
+
+  def delete(*action_ids)
+    client.action_delete(action_ids)
+  end
+end

data/lib/zapix/proxies/applications.rb

@@ -0,0 +1,30 @@
+require_relative 'base'
+
+class Applications < Base
+
+  def create(options)
+    client.application_create(options) unless exists?(options)
+  end
+
+  def exists?(options)
+    result = client.application_get({'filter' => {'name' => options['name']}})
+    if (result == nil || result.empty?)
+      false
+    else
+      true
+    end
+  end
+
+  def get_id(options)
+    if exists?(options)
+      client.application_get({
+        'filter' => {'name' => options['name'],
+        'hostid' => options['hostid']}}).first['applicationids']
+    else
+      raise NonExistingApplication, "Application #{options['name']} does not exist !"
+    end
+  end
+
+  class NonExistingApplication < StandardError; end
+
+end

data/lib/zapix/proxies/base.rb

@@ -0,0 +1,7 @@
+class Base
+  attr_reader :client
+
+  def initialize(client)
+    @client = client
+  end
+end

data/lib/zapix/proxies/hostgroups.rb

@@ -0,0 +1,98 @@
+require_relative 'base'
+
+class HostGroups < Base
+
+  def mass_create(*names)
+    names.each do |group_name|
+      create(group_name)
+    end
+  end
+
+  def create(name)
+    client.hostgroup_create({'name' => name}) unless exists?(name)
+  end
+
+  def create_or_update(name)
+    if(exists?(name))
+      id = get_id(name)
+      client.hostgroup_update({'groupid' => id,'name' => name})
+    else
+      create(name)
+    end
+  end
+
+  def exists?(name)
+    result = client.hostgroup_get({'filter' => {'name' => [name]}})
+    if (result == nil || result.empty?)
+      return false
+    else
+      return true
+    end
+  end
+
+  def get_id(name)
+    if(exists?(name))
+      result = client.hostgroup_get({'filter' => {'name' => [name]}})
+      result[0]['groupid']
+    else
+      raise NonExistingHostgroup, "Hostgroup #{name} does not exist !"
+    end
+  end
+
+  def mass_delete(*names)
+    names.each do |group_name|
+      delete(group_name)
+    end
+  end
+
+  def get_host_ids_of(hostgroup)
+    result = client.hostgroup_get('filter' => {'name' => [hostgroup]}, 'selectHosts' => 'refer')
+    extract_host_ids(result)
+  end
+
+  def any_hosts?(hostgroup)
+    raise NonExistingHostgroup, "Hostgroup #{hostgroup} does not exist !" unless exists?(hostgroup)
+    result = client.hostgroup_get('filter' => {'name' => [hostgroup]}, 'selectHosts' => 'count').first['hosts'].to_i
+    #result = client.hostgroup_get('countOutput' => 'true', 'filter' => {'name' => [hostgroup]}, 'selectHosts' => 'count').to_i
+    result >= 1 ? true : false
+  end
+
+  def delete(name)
+    if(exists?(name))
+      # host cannot exist without a hostgroup, so we need to delete 
+      # the attached hosts also
+      if(any_hosts?(name))
+        # delete all hosts attached to a hostgroup
+        host_ids = get_host_ids_of(name)
+        host_ids.each do |id|
+          client.host_delete([id])
+        end
+        # now it is ok to delete the group
+        client.hostgroup_delete([get_id(name)])
+      else
+        client.hostgroup_delete([get_id(name)])
+      end
+    else
+      raise NonExistingHostgroup, "Hostgroup #{name} does not exist !"
+    end
+  end
+
+  def get_all
+    # the fucking API also returns the ids and that's
+    # why we need to extract the names
+    host_groups_with_ids = client.hostgroup_get({'output' => ['name']})
+    extract_host_groups(host_groups_with_ids)
+  end
+
+  def extract_host_ids(query_result)
+    query_result.first['hosts'].map { |host| host['hostid'] }
+  end
+
+  def extract_host_groups(group_names_and_ids)
+    group_names_and_ids.map do |hostgroup|
+      hostgroup['name']
+    end
+  end
+
+  class NonExistingHostgroup < StandardError; end
+end

data/lib/zapix/proxies/hostinterfaces.rb

@@ -0,0 +1,21 @@
+require_relative 'base'
+
+class Hostinterfaces < Base
+
+  def create(options)
+    client.hostinterface_create(options) unless exists?(options)
+  end
+
+  def exists?(options)
+    get(options).empty? ? false : true
+  end
+
+  def get(options)
+    client.hostinterface_get(
+      {'filter' => {'hostid' => options['hostid'],
+      'port' => options['port'],
+      'type' => options['type']},
+      'output' => 'extend'})
+  end
+
+end