Use inventory v4

app/models/manageiq/providers/hawkular/builder.rb

@@ -0,0 +1,23 @@
+module ManageIQ::Providers::Hawkular
+  class Builder
+    def self.build_inventory(ems, target)
+      case target
+      when ::ManageIQ::Providers::MiddlewareManager
+        collector = Inventory::Collector::MiddlewareManager.new(ems, target)
+        persister = Inventory::Persister::MiddlewareManager.new(ems, target)
+        parser = [
+          Inventory::Parser::MiddlewareServers.new,
+          Inventory::Parser::MiddlewareDomains.new,
+          Inventory::Parser::MiddlewareDomainServers.new,
+          Inventory::Parser::MiddlewareServerEntities.new
+        ]
+      when ::ManageIQ::Providers::Hawkular::Inventory::AvailabilityUpdates
+        collector = Inventory::Collector::AvailabilityUpdates.new(ems, target)
+        persister = Inventory::Persister::AvailabilityUpdates.new(ems, target)
+        parser = Inventory::Parser::AvailabilityUpdates.new
+      end
+
+      ManagerRefresh::Inventory.new(persister, collector, parser)
+    end
+  end
+end

app/models/manageiq/providers/hawkular/inventory/collector/middleware_manager.rb

@@ -8,48 +8,44 @@ def connection
       @connection ||= manager.connect
     end
 
-    def feeds
-      connection.inventory.list_feeds
+    def resource_tree(resource_id)
+      connection.inventory.resource_tree(resource_id)
     end
 
-    def eaps(feed)
-      resources_for(feed, 'WildFly Server')
+    def oss
+      resources_for('Platform_Operating System')
     end
 
-    def domains(feed)
-      resources_for(feed, 'Domain Host')
-        .select { |host| host.properties['Is Domain Controller'] == 'true' }
+    def agents
+      resources_for('Hawkular WildFly Agent')
     end
 
-    def server_groups(feed)
-      resources_for(feed, 'Domain Server Group')
+    def eaps
+      resources_for('WildFly Server')
     end
 
-    def domain_servers(feed)
-      resources_for(feed, 'Domain WildFly Server')
+    def domain_servers
+      resources_for('Domain WildFly Server')
     end
 
-    def child_resources(resource_path, recursive = false)
-      manager.child_resources(resource_path, recursive)
+    def deployments
+      resources_for('Deployment')
     end
 
-    def machine_id(feed)
-      os_property_for(feed, 'Machine Id')
+    def subdeployments
+      resources_for('SubDeployment')
     end
 
-    def container_id(feed)
-      os_property_for(feed, 'Container Id')
+    def host_controllers
+      resources_for('Host Controller')
     end
 
-    def config_data_for_resource(resource_path)
-      connection.inventory.get_config_data_for_resource(resource_path)
+    def domains
+      resources_for('Domain Host').select(&:domain_controller?)
     end
 
-    def metrics_for_metric_type(feed, metric_type_id)
-      metric_type_path = ::Hawkular::Inventory::CanonicalPath.new(
-        :metric_type_id => metric_type_id, :feed_id => feed
-      )
-      connection.inventory.list_metrics_for_metric_type(metric_type_path)
+    def child_resources(resource_id, recursive = false)
+      manager.child_resources(resource_id, recursive)
     end
 
     def raw_availability_data(*args)
@@ -58,32 +54,9 @@ def raw_availability_data(*args)
 
     private
 
-    def os_property_for(feed, property)
-      os_resource_for(feed)
-        .try(:properties)
-        .try { |prop| prop[property] }
+    def resources_for(resource_type)
+      connection.inventory.resources_for_type(resource_type)
     end
 
-    def os_resource_for(feed)
-      os_for(feed)
-        .try { |os| connection.inventory.list_resources_for_type(os.path, true) }
-        .presence
-        .try(:first)
-    end
-
-    def os_for(feed)
-      connection
-        .inventory
-        .list_resource_types(feed)
-        .find { |item| item.id.include? 'Operating System' }
-    end
-
-    def resources_for(feed, resource_type_path)
-      path = ::Hawkular::Inventory::CanonicalPath.new(
-        :feed_id          => hawk_escape_id(feed),
-        :resource_type_id => hawk_escape_id(resource_type_path)
-      )
-      connection.inventory.list_resources_for_type(path.to_s, :fetch_properties => true)
-    end
   end
 end

app/models/manageiq/providers/hawkular/inventory/parser/availability_mixin.rb

@@ -0,0 +1,33 @@
+module ManageIQ::Providers::Hawkular::Inventory::Parser
+  module AvailabilityMixin
+    protected
+
+    def fetch_availabilities_for(resources, collection, metric_type_id)
+      metric_id_to_resources = resources.reject { |r| r.metrics_by_type(metric_type_id).empty? }.group_by do |resource|
+        resource.metrics_by_type(metric_type_id).first.hawkular_id
+      end
+      unless metric_id_to_resources.empty?
+        found_availabilities = []
+        collector.raw_availability_data(metric_id_to_resources.keys, :limit => 1, :order => 'DESC').each do |availability|
+          next unless metric_id_to_resources.key?(availability['id'])
+          found_availabilities << availability['id']
+          metric_id_to_resources.fetch(availability['id']).each do |hawkular_resource|
+            resource = collection.find_by(:ems_ref => hawkular_resource.id)
+            yield(resource, availability)
+          end
+        end
+        # Provide means to notify if there is a resource without the avail metric
+        ems_ref_of_unknown_avail = metric_id_to_resources.keys.to_set.subtract(found_availabilities).to_a
+        ems_ref_of_unknown_avail.each do |availability_id|
+          metric_id_to_resources.fetch(availability_id).each do |hawkular_resource|
+            yield(collection.find_by(:ems_ref => hawkular_resource.id), nil)
+          end
+        end
+      end
+    end
+
+    def process_availability(availability, translation = {})
+      translation.fetch(availability.try(:[], 'value').try(:downcase), 'Unknown')
+    end
+  end
+end

app/models/manageiq/providers/hawkular/inventory/parser/helpers_mixin.rb

@@ -0,0 +1,11 @@
+module ManageIQ::Providers::Hawkular::Inventory::Parser
+  module HelpersMixin
+    protected
+
+    def parse_base_item(item, inventory_object)
+      inventory_object.nativeid = item.id
+      inventory_object[:properties] = item.config if item.respond_to?(:config)
+      inventory_object[:feed] = item.feed if item.respond_to?(:feed)
+    end
+  end
+end

app/models/manageiq/providers/hawkular/inventory/parser/middleware_domain_servers.rb

@@ -0,0 +1,37 @@
+module ManageIQ::Providers::Hawkular::Inventory::Parser
+  class MiddlewareDomainServers < ::ManageIQ::Providers::Hawkular::Inventory::Parser::MiddlewareServers
+    protected
+
+    def fetch_middleware_servers
+      collector.host_controllers.each do |host_controller|
+        host_controller = collector.resource_tree(host_controller.id)
+        host_controller.children_domain_servers(true).each do |domain_server|
+          yield(domain_server)
+        end
+      end
+    end
+
+    def collected_resources
+      collector.domain_servers
+    end
+
+    def parse_middleware_server(server, inventory_object)
+      super
+      parse_server_group(server, inventory_object)
+    end
+
+    def parse_server_group(server, inventory_object)
+      # Add the association to server group. The information about what server is in which server group is under
+      # the server-config resource's configuration
+      server_group_name = server.config['Server Group']
+      unless server_group_name.nil?
+        inventory_object.middleware_server_group =
+          persister.find_server_group_by_feed_and_name(server.feed, server_group_name)
+      end
+    end
+
+    def parse_started_state(server)
+      server.config['Server State'] != 'STOPPED'
+    end
+  end
+end

app/models/manageiq/providers/hawkular/inventory/parser/middleware_domains.rb

@@ -0,0 +1,61 @@
+module ManageIQ::Providers::Hawkular::Inventory::Parser
+  class MiddlewareDomains < ManagerRefresh::Inventory::Parser
+    include ManageIQ::Providers::Hawkular::Inventory::Parser::HelpersMixin
+    include ManageIQ::Providers::Hawkular::Inventory::Parser::AvailabilityMixin
+
+    def parse
+      fetch_domains_and_groups
+      fetch_domain_availabilities
+    end
+
+    protected
+
+    def fetch_domains_and_groups
+      collector.host_controllers.each do |host_controller|
+        host_controller = collector.resource_tree(host_controller.id)
+        host_controller.children_domain_hosts.each do |domain|
+          parsed_domain = persister.middleware_domains.find_or_build(domain.id)
+          parse_middleware_domain(domain, parsed_domain)
+
+          # add the server groups to the domain
+          fetch_server_groups(parsed_domain, host_controller)
+        end
+      end
+    end
+
+    def fetch_server_groups(parsed_domain, host_controller)
+      host_controller.children_server_groups.map do |group|
+        parsed_group = persister.middleware_server_groups.find_or_build(group.id)
+        parse_middleware_server_group(group, parsed_group)
+        parsed_group.middleware_domain = persister.middleware_domains.lazy_find(parsed_domain[:ems_ref])
+      end
+    end
+
+    def fetch_domain_availabilities
+      collection = persister.middleware_domains
+      fetch_availabilities_for(collector.domains, collection, collection.model_class::AVAIL_TYPE_ID) do |domain, availability|
+        domain.properties['Availability'] =
+          process_domain_availability(availability.try(:[], 'data').try(:first))
+      end
+    end
+
+    def process_domain_availability(availability = nil)
+      process_availability(availability, 'up' => 'Running', 'down' => 'Stopped')
+    end
+
+    def parse_middleware_domain(domain, inventory_object)
+      parse_base_item(domain, inventory_object)
+      inventory_object.name = domain.name
+      inventory_object.type_path = domain.type.id
+    end
+
+    def parse_middleware_server_group(group, inventory_object)
+      parse_base_item(group, inventory_object)
+      inventory_object.assign_attributes(
+        :name      => group.name,
+        :type_path => group.type.id,
+        :profile   => group.config['Profile']
+      )
+    end
+  end
+end