Merge pull request #3 from lucasponce/hawkular-1328

HAWKULAR-1275 Update new Hawkular Services

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

@@ -13,43 +13,75 @@ def resource_tree(resource_id)
     end
 
     def oss
-      resources_for('Platform_Operating System')
+      oss = []
+      Hawkular::MiddlewareManager::SUPPORTED_VERSIONS.each do |version|
+        oss.concat(resources_for("Platform_Operating System #{version}"))
+      end
+      oss
     end
 
     def agents
-      resources_for('Hawkular WildFly Agent')
+      agents = []
+      Hawkular::MiddlewareManager::SUPPORTED_VERSIONS.each do |version|
+        agents.concat(resources_for("Hawkular Java Agent #{version}"))
+      end
+      agents
     end
 
     def eaps
-      resources_for('WildFly Server')
+      eaps = []
+      Hawkular::MiddlewareManager::SUPPORTED_VERSIONS.each do |version|
+        eaps.concat(resources_for("WildFly Server #{version}"))
+      end
+      eaps
     end
 
     def domain_servers
-      resources_for('Domain WildFly Server')
+      domains = []
+      Hawkular::MiddlewareManager::SUPPORTED_VERSIONS.each do |version|
+        domains.concat(resources_for("Domain WildFly Server #{version}"))
+      end
+      domains
     end
 
     def deployments
-      resources_for('Deployment')
+      deployments = []
+      Hawkular::MiddlewareManager::SUPPORTED_VERSIONS.each do |version|
+        deployments.concat(resources_for("Deployment #{version}"))
+      end
+      deployments
     end
 
     def subdeployments
-      resources_for('SubDeployment')
+      subdeployments = []
+      Hawkular::MiddlewareManager::SUPPORTED_VERSIONS.each do |version|
+        subdeployments.concat(resources_for("SubDeployment #{version}"))
+      end
+      subdeployments
     end
 
     def host_controllers
-      resources_for('Host Controller')
+      host_controllers = []
+      Hawkular::MiddlewareManager::SUPPORTED_VERSIONS.each do |version|
+        host_controllers.concat(resources_for("Host Controller #{version}"))
+      end
+      host_controllers
     end
 
     def domains
-      resources_for('Domain Host').select(&:domain_controller?)
+      domains = []
+      Hawkular::MiddlewareManager::SUPPORTED_VERSIONS.each do |version|
+        domains.concat(resources_for("Domain Host #{version}"))
+      end
+      domains
     end
 
     def child_resources(resource_id, recursive = false)
       manager.child_resources(resource_id, recursive)
     end
 
-    def raw_availability_data(*args)
-      connection.metrics.avail.raw_data(*args)
+    def raw_availability_data(metrics, time)
+      connection.prometheus.query(:metrics => metrics, :time => time)
     end
 
     private

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

@@ -2,32 +2,26 @@ 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
+    def fetch_availabilities_for(inventory_entities, entities, metric_name)
+      inventory_entities.each do |inventory_entity|
+        entity = entities.find_by(:ems_ref => inventory_entity.id)
+        availability = nil
+        availability_metric = filter_metric(inventory_entity, metric_name)
+        if availability_metric
+          availability = collector.raw_availability_data([availability_metric.to_h], Time.now.to_i)
         end
+        yield(entity, availability)
       end
     end
 
-    def process_availability(availability, translation = {})
-      translation.fetch(availability.try(:[], 'value').try(:downcase), 'Unknown')
+    def filter_metric(inventory_item, metric_name)
+      selected_metric = nil
+      inventory_item.metrics.each do |metric|
+        next unless metric.name.eql?(metric_name)
+        selected_metric = metric
+        break
+      end
+      selected_metric
     end
   end
 end

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

@@ -35,12 +35,16 @@ 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))
+          process_domain_availability(availability)
       end
     end
 
     def process_domain_availability(availability = nil)
-      process_availability(availability, 'up' => 'Running', 'down' => 'Stopped')
+      if availability.first['value'] && availability.first['value'][1] == '1'
+        'Running'
+      else
+        'STOPPED'
+      end
     end
 
     def parse_middleware_domain(domain, inventory_object)

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

@@ -4,6 +4,21 @@ class MiddlewareServerEntities < ManagerRefresh::Inventory::Parser
     include ManageIQ::Providers::Hawkular::Inventory::Parser::AvailabilityMixin
     include ::Hawkular::ClientUtils
 
+    SUPPORTED_ENTITIES = ['Deployment', 'SubDeployment', 'Datasource', 'JMS Queue', 'JMS Topic'].freeze
+
+    def initialize
+      @supported_types = []
+      @supported_deployments = []
+      @supported_subdeployments = []
+      @supported_datasources = []
+      ManageIQ::Providers::Hawkular::MiddlewareManager::SUPPORTED_VERSIONS.each do |version|
+        SUPPORTED_ENTITIES.each { |entity| @supported_types << "#{entity} #{version}" }
+        %w(Deployment SubDeployment).each { |deployment| @supported_deployments << "#{deployment} #{version}" }
+        @supported_subdeployments << "SubDeployment #{version}"
+        @supported_datasources << "Datasource #{version}"
+      end
+    end
+
     def parse
       fetch_server_entities
       fetch_deployment_availabilities
@@ -15,7 +30,7 @@ def fetch_server_entities
       persister.middleware_servers.each do |eap|
         eap_tree = collector.resource_tree(eap.ems_ref)
         eap_tree.children(true).each do |child|
-          next unless ['Deployment', 'SubDeployment', 'Datasource', 'JMS Queue', 'JMS Topic'].include?(child.type.id)
+          next unless @supported_types.include?(child.type.id)
           process_server_entity(eap, child)
         end
       end
@@ -24,7 +39,7 @@ def fetch_server_entities
     def fetch_deployment_availabilities
       collection = persister.middleware_deployments
       fetch_availabilities_for(collector.deployments, collection, collection.model_class::AVAIL_TYPE_ID) do |deployment, availability|
-        deployment.status = process_deployment_availability(availability.try(:[], 'data').try(:first))
+        deployment.status = process_deployment_availability(availability)
       end
       subdeployments_by_deployment_id = collector.subdeployments.group_by(&:parent_id)
       subdeployments_by_deployment_id.keys.each do |parent_id|
@@ -37,10 +52,10 @@ def fetch_deployment_availabilities
     end
 
     def process_server_entity(server, entity)
-      if %w(Deployment SubDeployment).include?(entity.type.id)
+      if @supported_deployments.include?(entity.type.id)
         inventory_object = persister.middleware_deployments.find_or_build(entity.id)
         parse_deployment(entity, inventory_object)
-      elsif entity.type.id == 'Datasource'
+      elsif @supported_datasources.include?(entity.type.id)
         inventory_object = persister.middleware_datasources.find_or_build(entity.id)
         parse_datasource(entity, inventory_object)
       else
@@ -55,7 +70,7 @@ def process_server_entity(server, entity)
     def parse_deployment(deployment, inventory_object)
       parse_base_item(deployment, inventory_object)
       inventory_object.name = deployment.name
-      if deployment.type.id == 'SubDeployment'
+      if @supported_subdeployments.include?(deployment.type.id)
         inventory_object.properties[inventory_object.model_class::PARENT_DEPLOYMENT_ID_PROPERTY] = deployment.parent_id
       end
     end
@@ -76,7 +91,11 @@ def parse_datasource(datasource, inventory_object)
     end
 
     def process_deployment_availability(availability = nil)
-      process_availability(availability, 'up' => 'Enabled', 'down' => 'Disabled')
+      if availability.first['value'] && availability.first['value'][1] == '1'
+        'Enabled'
+      else
+        'Disabled'
+      end
     end
   end
 end

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

@@ -50,7 +50,7 @@ def fetch_server_availabilities
                                collection.model_class::AVAIL_TYPE_ID) do |server, availability|
         props = server.properties
         props['Availability'], props['Calculated Server State'] =
-          process_server_availability(props['Server State'], availability.try(:[], 'data').try(:first))
+          process_server_availability(props['Server State'], availability)
       end
     end
 
@@ -185,8 +185,12 @@ def swap_part(part)
     end
 
     def process_server_availability(server_state, availability = nil)
-      avail = availability.try(:[], 'value') || 'unknown'
-      [avail, avail == 'up' ? server_state : avail]
+      avail = if availability.first['value'] && availability.first['value'][1] == '1'
+                'Running'
+              else
+                'STOPPED'
+              end
+      [avail, avail == 'Running' ? server_state : avail]
     end
 
     def machine_id_by_feed(feed)

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

@@ -23,6 +23,8 @@ class Hawkular::MiddlewareManager < ManageIQ::Providers::MiddlewareManager
     DEFAULT_PORT = 80
     default_value_for :port, DEFAULT_PORT
 
+    SUPPORTED_VERSIONS = %w(WF10 EAP6).freeze
+
     has_many :middleware_domains, :foreign_key => :ems_id, :dependent => :destroy
     has_many :middleware_servers, :foreign_key => :ems_id, :dependent => :destroy
     has_many :middleware_deployments, :foreign_key => :ems_id, :dependent => :destroy
@@ -152,8 +154,8 @@ def metrics_resource(resource_id)
       end
     end
 
-    def metrics_client
-      with_provider_connection(&:metrics)
+    def prometheus_client
+      with_provider_connection(&:prometheus)
     end
 
     def inventory_client

app/models/manageiq/providers/hawkular/middleware_manager/event_catcher/stream.rb

@@ -2,7 +2,6 @@ class ManageIQ::Providers::Hawkular::MiddlewareManager::EventCatcher::Stream
   def initialize(ems)
     @ems               = ems
     @alerts_client     = ems.alerts_client
-    @metrics_client    = ems.metrics_client
     @inventory_client  = ems.inventory_client
     @collecting_events = false
   end
@@ -134,9 +133,8 @@ def fetch_entities_availabilities(inventory_entities, parser, entities)
 
     # Get availabilities
     avails = {}
-    parser.send(:fetch_availabilities_for, inventory_entities, entities, entities.first.class::AVAIL_TYPE_ID) do |item, avail|
-      avail_data = avail.try(:[], 'data').try(:first)
-      avails[item.id] = yield(item, avail_data)
+    parser.send(:fetch_availabilities_for, inventory_entities, entities, entities.first.class::AVAIL_TYPE_ID) do |item, availability|
+      avails[item.id] = yield(item, availability)
 
       # Filter out if availability is unchanged. This way, no refresh is triggered if unnecessary.
       avails.delete(item.id) unless avails[item.id]