zapix 0.0.9 → 0.1.0

data/lib/zapix/proxies/applications.rb

@@ -2,24 +2,24 @@ require_relative 'basic'
 
 class Applications < Basic
 
-def create(options)
-  @client.application_create(options) unless exists?(options)
-end
+  def create(options)
+    @client.application_create(options) unless exists?(options)
+  end
 
-def exists?(options)
-  @client.application_exists(options)
-end
+  def exists?(options)
+    @client.application_exists(options)
+  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 !"
+  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
-end
 
-class NonExistingApplication < StandardError; end
+  class NonExistingApplication < StandardError; end
 
 end

data/lib/zapix/proxies/hostgroups.rb

@@ -2,97 +2,95 @@ require_relative 'basic'
 
 class HostGroups < Basic
 
-def mass_create(*names)
-  names.each do |group_name|
-    create(group_name)
+  def mass_create(*names)
+    names.each do |group_name|
+      create(group_name)
+    end
   end
-end
 
-def create(name)
-  @client.hostgroup_create({'name' => name}) unless exists?(name)
-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)
+  def create_or_update(name)
+    if(exists?(name))
+      id = get_id(name)
+      @client.hostgroup_update({'groupid' => id,'name' => name})
+    else
+      create(name)
+    end
   end
-end
 
-def exists?(name)
-  @client.hostgroup_exists({'name' => name})
-end
+  def exists?(name)
+    @client.hostgroup_exists({'name' => name})
+  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 !"
+  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
-end
 
-def mass_delete(*names)
-  names.each do |group_name|
-    delete(group_name)
+  def mass_delete(*names)
+    names.each do |group_name|
+      delete(group_name)
+    end
   end
-end
 
-def get_host_ids_of(hostgroup)
-  result = @client.hostgroup_get('filter' => {'name' => [hostgroup]}, 'selectHosts' => 'refer')
-  extract_host_ids(result)
-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
-  if(result >= 1)
-    true
-  else
-    false
+  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
+    if(result >= 1)
+      true
+    else
+      false
+    end
   end
-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(['hostid' => id])
+  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(['hostid' => id])
+        end
+        # now it is ok to delete the group
+        @client.hostgroup_delete([get_id(name)])
+      else
+        @client.hostgroup_delete([get_id(name)])
       end
-      # now it is ok to delete the group
-      @client.hostgroup_delete([get_id(name)])
     else
-      @client.hostgroup_delete([get_id(name)])
+      raise NonExistingHostgroup, "Hostgroup #{name} does not exist !"
     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 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_groups(group_names_and_ids)
-  group_names_and_ids.map do |hostgroup|
-    hostgroup['name']
+  def extract_host_ids(query_result)
+    query_result.first['hosts'].map { |host| host['hostid'] }
   end
-end
 
-class NonExistingHostgroup < StandardError; 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,25 @@
+require_relative 'basic'
+
+class Hostinterfaces < Basic
+
+  def create(options)
+    @client.hostinterface_create(options) unless exists?(options)
+  end
+
+  def exists?(options)
+    if get(options).empty?
+      false
+    else
+      true
+    end
+  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

@@ -59,15 +59,14 @@ class Hosts < Basic
     end
   end
 
-  private
+  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
-
-class NonExistingHost < StandardError; end
-class EmptyHostname < StandardError; end
-
 end

data/lib/zapix/proxies/templates.rb

@@ -1,28 +1,22 @@
 require_relative 'basic'
 class Templates < Basic
 
-def exists?(name)
-  @client.template_exists({'name' => name})
-end
-
-def create(name)
-end
-
-def delete(name)
-end
+  def exists?(name)
+    @client.template_exists({'name' => name})
+  end
 
-def get_id(name)
-  if(exists?(name))
-    @client.template_get({'filter' => {'name' => name}}).first['templateid']
-  else
-    raise NonExistingTemplate, "Template #{name} does not exist !"
+  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
-end
 
-def get_templates_for_host(id)
-  @client.template_get({'hostids' => [id]}).map { |result_set| result_set['templateid'] }
-end
+  def get_templates_for_host(id)
+    @client.template_get({'hostids' => [id]}).map { |result_set| result_set['templateid'] }
+  end
 
-class NonExistingTemplate < StandardError; end
+  class NonExistingTemplate < StandardError; end
 
 end

data/lib/zapix/proxies/triggers.rb

@@ -0,0 +1,44 @@
+require_relative 'basic'
+class Triggers < Basic
+
+  def exists?(options)
+    @client.trigger_exists(options)
+  end
+
+  def create(options)
+    @client.trigger_create(options) unless exists?(options)
+  end
+
+  def delete(*trigger_ids)
+    @client.trigger_delete(trigger_ids)
+  end
+
+  def get_id(options)
+    result = @client.trigger_get({'output' => 'extend',
+      'expandExpression' => true})
+    id = extract_id(result, options['expression'])
+    unless id.nil?
+      id
+    else
+      raise NonExistingTrigger, "Trigger with expression #{options['expression']} not found."
+    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
+
+

data/lib/zapix/version.rb

@@ -1,3 +1,3 @@
 module Zapix
-  VERSION = "0.0.9"
+  VERSION = "0.1.0"
 end

data/lib/zapix.rb

@@ -34,4 +34,12 @@ class ZabbixAPI
     @scenarios ||= Scenarios.new(@client)
   end
 
+  def triggers
+    @triggers ||= Triggers.new(@client)
+  end
+
+  def hostinterfaces
+    @hostinterfaces ||= Hostinterfaces.new(@client)
+  end
+
 end

data/spec/zapix_specs.rb

@@ -15,6 +15,9 @@ template_2 = 'Template App MySQL'
 application = 'web scenarios'
 host = 'hostname'
 scenario = 'scenario'
+trigger_description = 'Webpage failed on {HOST.NAME}'
+trigger_expression = "{#{host}:web.test.fail[#{scenario}].max(#3)}#0"
+non_existing_trigger_expression = '{vfs.file.cksum[/etc/passwd].diff(0)}>0'
 
 describe ZabbixAPI do
 
@@ -73,7 +76,7 @@ describe ZabbixAPI do
       hostgroup_id = zrc.hostgroups.get_id(hostgroup_with_hosts)
       example_host = Host.new
       example_host.add_name(host)
-      example_host.add_interfaces(create_interface)
+      example_host.add_interfaces(create_interface.to_hash)
       example_host.add_group_ids(hostgroup_id)
       example_host.add_template_ids(zrc.templates.get_id(template_1), zrc.templates.get_id(template_2))
       example_host.add_macros({'macro' => '{$TESTMACRO}', 'value' => 'test123'})
@@ -94,7 +97,7 @@ describe ZabbixAPI do
       hostgroup_id = zrc.hostgroups.get_id(hostgroup_with_hosts)
       example_host = Host.new
       example_host.add_name(host)
-      example_host.add_interfaces(create_interface)
+      example_host.add_interfaces(create_interface.to_hash)
       example_host.add_macros({'macro' => '{$TESTMACRO}', 'value' => 'test123'})
       example_host.add_group_ids(hostgroup_id)
       example_host.add_template_ids(zrc.templates.get_id(template_1), zrc.templates.get_id(template_2))
@@ -113,146 +116,230 @@ describe ZabbixAPI do
       webcheck_options['applicationid'] = zrc.applications.get_id(application_options)
       webcheck_options['steps'] = [{'name' => 'Homepage', 'url' => 'm.test.de', 'status_codes' => 200, 'no' => 1}]
       zrc.scenarios.create(webcheck_options)
-    end
-
-    after(:each) do
-      zrc.hostgroups.delete(hostgroup_with_hosts)
-    end
-
-    it 'returns true if a hostgroup has attached hosts' do
-      zrc.hostgroups.any_hosts?(hostgroup_with_hosts).should be_true
-    end
-
-    it 'returns all the host ids of a hosts belonging to a hostgroup' do
-      host_id = zrc.hosts.get_id(host)
-      zrc.hostgroups.get_host_ids_of(hostgroup_with_hosts).should include(host_id)
-    end
-
-    it 'gets the right template id for host' do
-      result = zrc.templates.get_templates_for_host(zrc.hosts.get_id(host))
-      result.should include(zrc.templates.get_id(template_1))
-      result.should include(zrc.templates.get_id(template_2))
-    end
-
-    it 'unlinks all templates for host' do
-      host_id = zrc.hosts.get_id(host)
-      options = {}
-      options['template_ids'] = zrc.templates.get_templates_for_host(host_id)
-      options['host_id'] = host_id
-      result = zrc.hosts.unlink_and_clear_templates(options)
-      result.should_not include(zrc.templates.get_id(template_1))
-      result.should_not include(zrc.templates.get_id(template_2))
-    end
-
-    it 'throws an exception if updating a host without specifying the hostname' do
-      example_host = Host.new
-      example_host.add_interfaces(create_interface)
-      expect { zrc.hosts.create_or_update(example_host.to_hash) }.to raise_error(Hosts::EmptyHostname)
-    end
-
-    it "updates host's interface after unlinking all belonging templates" do
-      # unlinking all items
-      host_id = zrc.hosts.get_id(host)
-      options = {}
-      zrc.templates.get_templates_for_host(host_id)
-      options['template_ids'] = zrc.templates.get_templates_for_host(host_id)
-      options['host_id'] = host_id
-      result = zrc.hosts.unlink_and_clear_templates(options)
-      #result = zrc.hosts.update_templates(options)
-      # now it should be safe to update the interface of the host
-      example_host = Host.new
-      example_host.add_interfaces(create_interface)
-      example_host.add_name(host)
-      zrc.hosts.create_or_update(example_host.to_hash)
-      # check
-    end
-
-    it "updates host's templates" do
-      host_id = zrc.hosts.get_id(host)
-      options = {}
-      options['host_id'] = host_id
-      template_id = zrc.templates.get_id('Template App Agentless')
-      options['template_ids'] = [template_id]
-      zrc.hosts.update_templates(options)
-      zrc.templates.get_templates_for_host(host_id).should include(template_id)
-    end
-
-    it "updates host's macro" do
-      host_id = zrc.hosts.get_id(host)
-      options = {}
-      options['host_id'] = host_id
-      options['macros'] = [{'macro' => '{$TESTMACRO}', 'value' => 'this is only a test macro'}]
-      zrc.hosts.update_macros(options)
-    end
-
-    it 'returns false if an application does not exist' do
-      options = {}
-      options['name'] = 'nonexisting'
-      options['hostid'] = zrc.hosts.get_id(host)
-      zrc.applications.exists?(options).should be_false
-    end
 
-    it 'returns true if an application exists' do
+      # creates a trigger
       options = {}
-      options['name'] = application
-      options['hostid'] = zrc.hosts.get_id(host)
-      zrc.applications.exists?(options).should be_true
+      options['description'] = trigger_description
+      options['expression'] = trigger_expression
+      options['priority'] = '2' # 2 means Warning
+      zrc.triggers.create(options)
+      
     end
 
-    it 'get an application id by application name and host' do
-      options = {}
-      options['name'] = application
-      options['hostid'] = zrc.hosts.get_id(host)
-      result = zrc.applications.get_id(options)
-      (result.to_i).should >= 0
-    end
-
-    it 'throws exception on non existing application' do
-      options = {}
-      options['name'] = "nonexisting"
-      options['hostid'] = zrc.hosts.get_id(host)
-      expect { zrc.applications.get_id(options) }.to raise_error(Applications::NonExistingApplication)
+    after(:each) do
+      zrc.hostgroups.delete(hostgroup_with_hosts)
     end
 
-    it 'deletes an applications for host' do
-      pending 'Not implemented'
+    describe 'hosts' do
+
+      it 'returns true if a hostgroup has attached hosts' do
+        zrc.hostgroups.any_hosts?(hostgroup_with_hosts).should be_true
+      end
+
+      it 'returns all the host ids of a hosts belonging to a hostgroup' do
+        host_id = zrc.hosts.get_id(host)
+        zrc.hostgroups.get_host_ids_of(hostgroup_with_hosts).should include(host_id)
+      end
+
+      it 'gets the right template id for host' do
+        result = zrc.templates.get_templates_for_host(zrc.hosts.get_id(host))
+        result.should include(zrc.templates.get_id(template_1))
+        result.should include(zrc.templates.get_id(template_2))
+      end
+
+      it 'unlinks all templates for host' do
+        host_id = zrc.hosts.get_id(host)
+        options = {}
+        options['template_ids'] = zrc.templates.get_templates_for_host(host_id)
+        options['host_id'] = host_id
+        result = zrc.hosts.unlink_and_clear_templates(options)
+        result.should_not include(zrc.templates.get_id(template_1))
+        result.should_not include(zrc.templates.get_id(template_2))
+      end
+
+      it 'throws an exception if updating a host without specifying the hostname' do
+        example_host = Host.new
+        example_host.add_interfaces(create_interface.to_hash)
+        expect { zrc.hosts.create_or_update(example_host.to_hash) }.to raise_error(Hosts::EmptyHostname)
+      end
+
+      it "updates host's interface after unlinking all belonging templates" do
+        # unlinking all items
+        host_id = zrc.hosts.get_id(host)
+        options = {}
+        zrc.templates.get_templates_for_host(host_id)
+        options['template_ids'] = zrc.templates.get_templates_for_host(host_id)
+        options['host_id'] = host_id
+        result = zrc.hosts.unlink_and_clear_templates(options)
+        # now it should be safe to update the interface of the host
+        example_host = Host.new
+        example_host.add_interfaces(create_interface.to_hash)
+        example_host.add_name(host)
+        zrc.hosts.create_or_update(example_host.to_hash)
+      end
+
+      it "updates host's templates" do
+        host_id = zrc.hosts.get_id(host)
+        options = {}
+        options['host_id'] = host_id
+        template_id = zrc.templates.get_id('Template App Agentless')
+        options['template_ids'] = [template_id]
+        zrc.hosts.update_templates(options)
+        zrc.templates.get_templates_for_host(host_id).should include(template_id)
+      end
+
+      it "updates host's macro" do
+        host_id = zrc.hosts.get_id(host)
+        options = {}
+        options['host_id'] = host_id
+        options['macros'] = [{'macro' => '{$TESTMACRO}', 'value' => 'this is only a test macro'}]
+        zrc.hosts.update_macros(options)
+      end
     end
 
-    it 'returns true if web scenarios exists' do
-      options = {}
-      options['name'] = scenario
-      options['hostid'] = zrc.hosts.get_id(host)
-      zrc.scenarios.exists?(options).should be_true
+    describe 'applications' do
+      it 'returns false if an application does not exist' do
+        options = {}
+        options['name'] = 'nonexisting'
+        options['hostid'] = zrc.hosts.get_id(host)
+        zrc.applications.exists?(options).should be_false
+      end
+
+      it 'returns true if an application exists' do
+        options = {}
+        options['name'] = application
+        options['hostid'] = zrc.hosts.get_id(host)
+        zrc.applications.exists?(options).should be_true
+      end
+
+      it 'get an application id by application name and host' do
+        options = {}
+        options['name'] = application
+        options['hostid'] = zrc.hosts.get_id(host)
+        result = zrc.applications.get_id(options)
+        (result.to_i).should >= 0
+      end
+
+      it 'throws exception on non existing application' do
+        options = {}
+        options['name'] = "nonexisting"
+        options['hostid'] = zrc.hosts.get_id(host)
+        expect { zrc.applications.get_id(options) }.to raise_error(Applications::NonExistingApplication)
+      end
     end
 
-    it 'gets the id of a web scenario' do
-      options = {}
-      options['name'] = scenario
-      options['hostid'] = zrc.hosts.get_id(host)
-      zrc.scenarios.exists?(options).should be_true
-      zrc.scenarios.get_id(options)
+    describe 'web scenarios' do
+      it 'returns true if web scenarios exists' do
+        options = {}
+        options['name'] = scenario
+        options['hostid'] = zrc.hosts.get_id(host)
+        zrc.scenarios.exists?(options).should be_true
+      end
+
+      it 'gets the id of a web scenario' do
+        options = {}
+        options['name'] = scenario
+        options['hostid'] = zrc.hosts.get_id(host)
+        zrc.scenarios.exists?(options).should be_true
+        zrc.scenarios.get_id(options)
+      end
+
+      it 'returns false if a web scenario does not exist' do
+        options = {}
+        options['name'] = "nonexisting"
+        options['hostid'] = zrc.hosts.get_id(host)
+        zrc.scenarios.exists?(options).should be_false
+      end
+
+      it 'deletes a web scenario' do
+        pending 'Not ready'
+        options = {}
+        options['name'] = scenario
+        options['hostid'] = zrc.hosts.get_id(host)
+        zrc.scenarios.delete(options)
+        zrc.scenarios.exists?(options).should be_false
+      end
     end
 
-    it 'returns false if a web scenario does not exist' do
-      options = {}
-      options['name'] = "nonexisting"
-      options['hostid'] = zrc.hosts.get_id(host)
-      zrc.scenarios.exists?(options).should be_false
+    describe 'triggers' do
+      it 'deletes a trigger' do
+        options = {}
+        options['expression'] = trigger_expression
+        zrc.triggers.exists?(options).should be_true
+        id = zrc.triggers.get_id(options)
+        zrc.triggers.delete(id)
+        zrc.triggers.exists?(options).should be_false
+      end
+
+      it 'gets an id of a trigger' do
+        options = {}
+        options['expression'] = trigger_expression
+        (zrc.triggers.get_id(options)).to_i.should >= 0
+      end
+
+      it 'throws exception if trying to get id of a non-existing trigger' do
+        options = {}
+        options['expression'] = non_existing_trigger_expression
+        expect { zrc.triggers.get_id(options) }.to raise_error(Triggers::NonExistingTrigger)
+      end
+
+      it 'returns true if a trigger exists' do
+        options = {}
+        options['expression'] = trigger_expression
+        zrc.triggers.exists?(options).should be_true
+      end
+
+      it 'returns false if a trigger does not exist' do
+        options = {}
+        options['expression'] = non_existing_trigger_expression
+        zrc.triggers.exists?(options).should be_false
+      end
     end
 
-    it 'deletes a web scenario' do
-      options = {}
-      options['name'] = scenario
-      options['hostid'] = zrc.hosts.get_id(host)
-      zrc.scenarios.delete(options)
-      zrc.scenarios.exists?(options).should be_false
+    describe 'hostinterfaces' do
+      it 'creates jmx interface for host' do
+        jmx_iface = create_jmx_interface
+        jmx_iface_hash = jmx_iface.to_hash
+        jmx_iface_hash['hostid'] = zrc.hosts.get_id(host)
+        zrc.hostinterfaces.create(jmx_iface_hash)
+        zrc.hostinterfaces.exists?(jmx_iface_hash).should be_true
+      end
+
+      it 'check if interface exists for host' do
+        options = {}
+        options['hostid'] = zrc.hosts.get_id(host)
+        options['port'] = 10050
+        options['type'] = 1
+        zrc.hostinterfaces.exists?(options).should be_true
+
+        options['port'] = 9003
+        options['type'] = 4
+        zrc.hostinterfaces.exists?(options).should be_false
+      end
+
+      it 'gets interface id' do
+        pending 'Not implemented'
+      end
+
+      it 'deletes an interface' do
+        pending 'Not implemented'
+      end
     end
   end
 
   def create_interface
     Interface.new(
-      'ip' => "127.0.0.#{random_int}",
-      'dns' => "#{random_string}.our-cloud.de").to_hash
+      'ip'  => random_local_ip,
+      'dns' => random_domain)
+  end
+
+  def create_jmx_interface
+    Interface.new(
+      'ip'  => random_local_ip,
+      'dns' => random_domain,
+      'type' => 4, # JMX
+      'main' => 1, # not default
+      'port' => 9003)
   end
 
   def random_string
@@ -263,4 +350,12 @@ describe ZabbixAPI do
     rand(64)
   end
 
+  def random_local_ip
+    "127.0.0.#{random_int}"
+  end
+
+  def random_domain
+    "#{random_string}.our-cloud.de"
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zapix
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-02 00:00:00.000000000 Z
+date: 2013-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,9 +108,11 @@ files:
 - lib/zapix/proxies/applications.rb
 - lib/zapix/proxies/basic.rb
 - lib/zapix/proxies/hostgroups.rb
+- lib/zapix/proxies/hostinterfaces.rb
 - lib/zapix/proxies/hosts.rb
 - lib/zapix/proxies/scenarios.rb
 - lib/zapix/proxies/templates.rb
+- lib/zapix/proxies/triggers.rb
 - lib/zapix/version.rb
 - lib/zapix/zabbix_classes/host.rb
 - lib/zapix/zabbix_classes/interface.rb
@@ -133,7 +135,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1026072512535608840
+      hash: 463225029197809156
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -142,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1026072512535608840
+      hash: 463225029197809156
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24