Merge pull request #591 from syseleven/feature/upstream_zabbix_host_self.prefetch

Implement self.prefetch for zabbix_host

Author: bastelfreak

lib/puppet/provider/zabbix.rb

@@ -3,7 +3,7 @@ class Puppet::Provider::Zabbix < Puppet::Provider
   # This method is vendored from the AWS SDK, rather than including an
   # extra library just to parse an ini file
   # Copied from https://github.com/puppetlabs/puppetlabs-aws/blob/2d34b1602bdd564b3f882f683dc000878f539343/lib/puppet_x/puppetlabs/aws.rb#L120
-  def ini_parse(file)
+  def self.ini_parse(file)
     current_section = {}
     map = {}
     file.rewind
@@ -23,16 +23,28 @@ def ini_parse(file)
     map
   end
 
-  def api_config
+  def ini_parse(file)
+    self.class.ini_parse(file)
+  end
+
+  def self.api_config
     @api_config ||= ini_parse(File.new('/etc/zabbix/api.conf'))
   end
 
-  def zbx
+  def api_config
+    self.class.api_config
+  end
+
+  def self.zbx
     @zbx ||= create_connection
   end
 
+  def zbx
+    self.class.zbx
+  end
+
   # Create the api connection
-  def create_connection
+  def self.create_connection
     protocol = api_config['default']['apache_use_ssl'] == 'true' ? 'https' : 'http'
     zbx = ZabbixApi.connect(
       url: "#{protocol}://#{api_config['default']['zabbix_url']}/api_jsonrpc.php",
@@ -44,6 +56,10 @@ def create_connection
     zbx
   end
 
+  def create_connection
+    self.class.create_connection
+  end
+
   # Check if host exists. When error raised, return false.
   def check_host(host)
     zbx.query(
@@ -80,6 +96,10 @@ def check_template_in_host(host)
     template_array.include?(template_id.to_s)
   end
 
+  def transform_to_array_hash(key, value_array)
+    value_array.map { |a| { key => a } }
+  end
+
   # Is it a number?
   def a_number?(s)
     s.to_s.match(%r{\A[+-]?\d+?(\.\d+)?\Z}).nil? ? false : true

lib/puppet/provider/zabbix_host/ruby.rb

@@ -2,97 +2,182 @@
 Puppet::Type.type(:zabbix_host).provide(:ruby, parent: Puppet::Provider::Zabbix) do
   confine feature: :zabbixapi
 
-  def create
-    # Set some vars
-    host = @resource[:hostname]
-    ipaddress = @resource[:ipaddress]
-    use_ip = @resource[:use_ip]
-    port = @resource[:port]
-    hostgroup = @resource[:group]
-    hostgroup_create = @resource[:group_create]
-    templates = @resource[:templates]
-    proxy = @resource[:proxy]
-
-    # Get the template ids.
-    template_array = []
-    if templates.is_a?(Array)
-      templates.each do |template|
-        template_id = get_template_id(zbx, template)
-        template_array.push template_id
-      end
-    else
-      template_array.push get_template_id(zbx, templates)
+  def self.instances
+    proxies = zbx.proxies.all
+    api_hosts = zbx.query(
+      method: 'host.get',
+      params: {
+        selectParentTemplates: ['host'],
+        selectInterfaces: %w[interfaceid type main ip port useip],
+        selectGroups: ['name'],
+        output: %w[host proxy_hostid]
+      }
+    )
+
+    api_hosts.map do |h|
+      interface = h['interfaces'].select { |i| i['type'].to_i == 1 && i['main'].to_i == 1 }.first
+      use_ip = !interface['useip'].to_i.zero?
+      new(
+        ensure: :present,
+        id: h['hostid'].to_i,
+        name: h['host'],
+        interfaceid: interface['interfaceid'].to_i,
+        ipaddress: interface['ip'],
+        use_ip: use_ip,
+        port: interface['port'].to_i,
+        groups: h['groups'].map { |g| g['name'] },
+        group_create: nil,
+        templates: h['parentTemplates'].map { |x| x['host'] },
+        proxy: proxies.select { |_name, id| id == h['proxy_hostid'] }.keys.first
+      )
     end
+  end
 
-    # Check if we need to connect via ip or fqdn
-    use_ip = use_ip ? 1 : 0
+  def self.prefetch(resources)
+    instances.each do |prov|
+      if (resource = resources[prov.name])
+        resource.provider = prov
+      end
+    end
+  end
 
-    # When using DNS you still have to send a value for ip
-    ipaddress = '' if ipaddress.nil? && use_ip.zero?
+  def create
+    template_ids = get_templateids(@resource[:templates])
+    templates = transform_to_array_hash('templateid', template_ids)
 
-    hostgroup_create = hostgroup_create ? 1 : 0
+    gids = get_groupids(@resource[:groups], @resource[:group_create])
+    groups = transform_to_array_hash('groupid', gids)
 
-    # First check if we have an correct hostgroup and if not, we raise an error.
-    search_hostgroup = zbx.hostgroups.get_id(name: hostgroup)
-    if search_hostgroup.nil? && hostgroup_create == 1
-      zbx.hostgroups.create(name: hostgroup)
-      search_hostgroup = zbx.hostgroups.get_id(name: hostgroup)
-    elsif search_hostgroup.nil? && hostgroup_create.zero?
-      raise Puppet::Error, 'The hostgroup (' + hostgroup + ') does not exist in zabbix. Please use the correct one.'
-    end
+    proxy_hostid = @resource[:proxy].nil? || @resource[:proxy].empty? ? nil : zbx.proxies.get_id(host: @resource[:proxy])
 
     # Now we create the host
-    hostid = zbx.hosts.create_or_update(
-      host: host,
+    zbx.hosts.create(
+      host: @resource[:hostname],
+      proxy_hostid: proxy_hostid,
       interfaces: [
         {
           type: 1,
           main: 1,
-          ip: ipaddress,
-          dns: host,
-          port: port,
-          useip: use_ip
+          ip: @resource[:ipaddress],
+          dns: @resource[:hostname],
+          port: @resource[:port],
+          useip: @resource[:use_ip] ? 1 : 0
         }
       ],
-      templates: template_array,
-      groups: [groupid: search_hostgroup]
+      templates: templates,
+      groups: groups
     )
+  end
 
-    zbx.templates.mass_add(hosts_id: [hostid], templates_id: template_array)
+  def exists?
+    @property_hash[:ensure] == :present
+  end
 
-    return if proxy.nil? || proxy.empty?
-    zbx.hosts.update(
-      hostid: zbx.hosts.get_id(host: host),
-      proxy_hostid: zbx.proxies.get_id(host: proxy)
-    )
+  def destroy
+    zbx.hosts.delete(zbx.hosts.get_id(host: @resource[:hostname]))
   end
 
-  def exists?
-    host = @resource[:hostname]
-    templates = @resource[:templates]
-
-    templates = [templates] unless templates.is_a?(Array)
-
-    host = check_host(host)
-    if host.any?
-      template_ids   = host[0]['parentTemplates'].map { |x| x['templateid'] }
-      template_names = host[0]['parentTemplates'].map { |x| x['host'] }
-      res = []
-      templates.each do |template|
-        if a_number?(template)
-          res.push(template_ids.include?(template))
-        else
-          res.push(template_names.include?(template))
-        end
+  #
+  # Helper methods
+  #
+  def get_groupids(group_array, create)
+    groupids = []
+    group_array.each do |g|
+      id = zbx.hostgroups.get_id(name: g)
+      if id.nil?
+        raise Puppet::Error, 'The hostgroup (' + g + ') does not exist in zabbix. Please use the correct one or set group_create => true.' unless create
+        groupids << zbx.hostgroups.create(name: g)
+      else
+        groupids << id
       end
-      res.all?
-    else
-      false
     end
+    groupids
   end
 
-  def destroy
-    host = @resource[:hostname]
-    zbx.hosts.delete(zbx.hosts.get_id(host: host))
+  def get_templateids(template_array)
+    templateids = []
+    template_array.each do |t|
+      template_id = zbx.templates.get_id(host: t)
+      raise Puppet::Error, "The template #{t} does not exist in Zabbix. Please use a correct one." if template_id.nil?
+      templateids << template_id
+    end
+    templateids
+  end
+
+  #
+  # zabbix_host properties
+  #
+  mk_resource_methods
+
+  def ipaddress=(string)
+    zbx.query(
+      method: 'hostinterface.update',
+      params: {
+        interfaceid: @property_hash[:interfaceid],
+        ip: string
+      }
+    )
+  end
+
+  def use_ip=(boolean)
+    zbx.query(
+      method: 'hostinterface.update',
+      params: {
+        interfaceid: @property_hash[:interfaceid],
+        useip: boolean ? 1 : 0,
+        dns: @resource[:hostname]
+      }
+    )
+  end
+
+  def port=(int)
+    zbx.query(
+      method: 'hostinterface.update',
+      params: {
+        interfaceid: @property_hash[:interfaceid],
+        port: int
+      }
+    )
+  end
+
+  def groups=(hostgroups)
+    gids = get_groupids(hostgroups, @resource[:group_create])
+    groups = transform_to_array_hash('groupid', gids)
+
+    zbx.hosts.create_or_update(
+      host: @resource[:hostname],
+      groups: groups
+    )
+  end
+
+  def templates=(array)
+    should_template_ids = get_templateids(array)
+
+    # Get templates we have to clear. Unlinking only isn't really helpful.
+    is_template_ids = zbx.query(
+      method: 'host.get',
+      params: {
+        hostids: @property_hash[:id],
+        selectParentTemplates: ['templateid'],
+        output: ['host']
+      }
+    ).first['parentTemplates'].map { |t| t['templateid'].to_i }
+    templates_clear = is_template_ids - should_template_ids
+
+    zbx.query(
+      method: 'host.update',
+      params: {
+        hostid: @property_hash[:id],
+        templates: transform_to_array_hash('templateid', should_template_ids),
+        templates_clear: transform_to_array_hash('templateid', templates_clear)
+      }
+    )
+  end
+
+  def proxy=(string)
+    zbx.hosts.create_or_update(
+      host: @resource[:hostname],
+      proxy_hostid: zbx.proxies.get_id(host: string)
+    )
   end
 end