ams-zapix3 0.2.6

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,27 @@
+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['applicationid']
+    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/graphs.rb

@@ -0,0 +1,18 @@
+require_relative 'base'
+
+class Graphs < Base
+  def get_all_graph_ids_for(options)
+    graphs_with_names_and_ids = []
+    graphs = client.graph_get(options)
+
+    graphs.each do |g|
+      graphs_with_names_and_ids <<
+        {
+          'name' => g['name'],
+          'id' => g['graphid']
+        }
+    end
+
+    graphs_with_names_and_ids
+  end
+end

data/lib/zapix/proxies/hostgroups.rb

@@ -0,0 +1,97 @@
+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,20 @@
+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

data/lib/zapix/proxies/hosts.rb

@@ -0,0 +1,80 @@
+require_relative 'base'
+class Hosts < Base
+  def get_id(name)
+    if exists?(name)
+      client.host_get('filter' => { 'host' => name }).first['hostid']
+    else
+      raise NonExistingHost, "Host #{name} does not exist !"
+    end
+  end
+
+  def get_hosts_for_hostgroup(group_id)
+    client.host_get('groupids' => [group_id])
+  end
+
+  def create(options = {})
+    client.host_create(options) unless exists?(options['host'])
+  end
+
+  def create_or_update(options = {})
+    raise EmptyHostname, 'Host name cannot be empty !' if options['host'].nil?
+    if exists?(options['host'])
+      id = get_id(options['host'])
+      options['hostid'] = id
+      client.host_update(options)
+    else
+      create(options)
+    end
+  end
+
+  def unlink_and_clear_templates(options = {})
+    template_ids = options['template_ids'].map { |id| { 'templateid' => id } }
+    client.host_update('hostid' => options['host_id'], 'templates_clear' => template_ids)
+  end
+
+  def update_templates(options = {})
+    template_ids = options['template_ids'].map { |id| { 'templateid' => id } }
+    client.host_update('hostid' => options['host_id'], 'templates' => template_ids)
+  end
+
+  def update_macros(options = {})
+    client.host_update('hostid' => options['host_id'], 'macros' => options['macros'])
+  end
+
+  def exists?(name)
+    result = client.host_get('filter' => { 'host' => name })
+    if result.nil? || result.empty?
+      false
+    else
+      true
+    end
+  end
+
+  def get_all
+    host_names_and_ids = client.host_get('output' => ['name'])
+
+    # the fucking api ALWAYS returns the ids and that's
+    # why we need to extract the names separately
+
+    extract_host_names(host_names_and_ids)
+  end
+
+  def delete(name)
+    if exists?(name)
+      client.host_delete([get_id(name)])
+    else
+      raise NonExistingHost, "Host #{name} cannot be deleted because it does not exist !"
+    end
+  end
+
+  class NonExistingHost < StandardError; end
+  class EmptyHostname < StandardError; end
+
+  private
+
+  def extract_host_names(hosts_and_ids)
+    hosts_and_ids.map do |current_host|
+      current_host['name']
+    end
+  end
+end

data/lib/zapix/proxies/proxies.rb

@@ -0,0 +1,9 @@
+require_relative 'base'
+
+class Proxies < Base
+  def get_id(proxy_name)
+    result = client.proxy_get('filter' => { 'host' => proxy_name })
+
+    result.first['proxyid']
+  end
+end

data/lib/zapix/proxies/scenarios.rb

@@ -0,0 +1,32 @@
+require_relative 'base'
+
+class Scenarios < Base
+  def create(options)
+    client.httptest_create(options) unless exists?(options)
+  end
+
+  def get_id(options)
+    client.httptest_get('filter' => { 'name' => options['name'], 'hostid' => options['hostid'] }).first['httptestid']
+  end
+
+  def delete(options)
+    client.httptest_delete(options)
+  end
+
+  def exists?(options)
+    result = client.httptest_get('countOutput' => true,
+                                 'filter' => { 'name' => options['name'],
+                                               'hostid' => options['hostid'] })
+
+    result.to_i >= 1 ? true : false
+  end
+
+  def get_all
+    scenarios = client.httptest_get('output' => 'extend')
+    names = extract_names(scenarios)
+  end
+
+  def extract_names(scenarios)
+    scenarios.map { |scenario| scenario['name'] }
+  end
+end

data/lib/zapix/proxies/screenitems.rb

@@ -0,0 +1,11 @@
+require_relative 'base'
+
+class ScreenItems < Base
+  def create(options)
+    client.screenitem_create(options)
+  end
+
+  def delete(*screen_items_ids)
+    client.screenitem_delete(screen_items_ids)
+  end
+end

data/lib/zapix/proxies/screens.rb

@@ -0,0 +1,26 @@
+require_relative 'base'
+
+class Screens < Base
+  def get_id(options)
+    result = client.screen_get('filter' => { 'name' => options['name'] })
+
+    result.first['screenid']
+  end
+
+  def create(options)
+    client.screen_create(options) unless exists?(options)
+  end
+
+  def delete(*screen_ids)
+    client.screen_delete(screen_ids)
+  end
+
+  def exists?(options)
+    result = client.screen_get('filter' => { 'name' => options['name'] })
+    if result.nil? || result.empty?
+      false
+    else
+      true
+    end
+  end
+end

data/lib/zapix/proxies/templates.rb

@@ -0,0 +1,29 @@
+require_relative 'base'
+class Templates < Base
+  def exists?(name)
+    result = client.template_get('filter' => { 'name' => name })
+    if result.nil? || result.empty?
+      false
+    else
+      true
+    end
+  end
+
+  def create(options)
+    client.template_create(options) unless exists?(options['host'])
+  end
+
+  def get_id(name)
+    if exists?(name)
+      client.template_get('filter' => { 'name' => name }).first['templateid']
+    else
+      raise NonExistingTemplate, "Template #{name} does not exist !"
+    end
+  end
+
+  def get_templates_for_host(id)
+    client.template_get('hostids' => [id]).map { |result_set| result_set['templateid'] }
+  end
+
+  class NonExistingTemplate < StandardError; end
+end

data/lib/zapix/proxies/triggers.rb

@@ -0,0 +1,50 @@
+require_relative 'base'
+class Triggers < Base
+  def create(options)
+    client.trigger_create(options) unless exists?(options)
+  end
+
+  def delete(*trigger_ids)
+    client.trigger_delete(trigger_ids)
+  end
+
+  # this is very unefficient
+  # but there is no other way to verify that a trigger exists..
+  def exists?(options)
+    result = client.trigger_get('output' => 'extend',
+                                'expandExpression' => true)
+
+    id = extract_id(result, options['expression'])
+    if id.nil?
+      false
+    else
+      true
+    end
+  end
+
+  def get_id(options)
+    result = client.trigger_get('output' => 'extend',
+                                'expandExpression' => true)
+    id = extract_id(result, options['expression'])
+    if id.nil?
+      raise NonExistingTrigger, "Trigger with expression #{options['expression']} not found."
+    else
+      id
+    end
+  end
+
+  class NonExistingTrigger < StandardError; end
+
+  private
+
+  def extract_id(triggers, expression)
+    result = nil
+    triggers.each do |trigger|
+      if trigger['expression'] == expression
+        result = trigger['triggerid']
+        break
+      end
+    end
+    result
+  end
+end