hawkular-client 0.2.0 → 0.2.1

data/lib/hawkular.rb

@@ -21,7 +21,7 @@ module Hawkular
       @credentials = {
         username: nil,
         password: nil,
-        token:    nil
+        token: nil
       }.merge(credentials)
       @options = {
         tenant: nil,
@@ -50,7 +50,13 @@ module Hawkular
     # @param [String] url_part Part of an url to be escaped
     # @return [String] escaped url_part as new string
     def hawk_escape(url_part)
-      sub_url = url_part.dup
+      return url_part.to_s if url_part.is_a?(Numeric)
+
+      if url_part.is_a? Symbol
+        sub_url = url_part.to_s
+      else
+        sub_url = url_part.dup
+      end
       sub_url.gsub!('%', '%25')
       sub_url.gsub!(' ', '%20')
       sub_url.gsub!('[', '%5b')
@@ -91,28 +97,17 @@ module Hawkular
     # @!visibility private
     def rest_client(suburl)
       options[:timeout] = ENV['HAWKULARCLIENT_REST_TIMEOUT'] if ENV['HAWKULARCLIENT_REST_TIMEOUT']
-      options[:ssl_ca_file]     = @options[:ssl_ca_file]
-      options[:verify_ssl]      = @options[:verify_ssl]
+      options[:ssl_ca_file] = @options[:ssl_ca_file]
+      options[:verify_ssl] = @options[:verify_ssl]
       options[:ssl_client_cert] = @options[:ssl_client_cert]
-      options[:ssl_client_key]  = @options[:ssl_client_key]
-      options[:user]            = @credentials[:username]
-      options[:password]        = @credentials[:password]
+      options[:ssl_client_key] = @options[:ssl_client_key]
+      options[:user] = @credentials[:username]
+      options[:password] = @credentials[:password]
       # strip @endpoint in case suburl is absolute
       suburl = suburl[@entrypoint.length, suburl.length] if suburl.match(/^http/)
       RestClient::Resource.new(@entrypoint, options)[suburl]
     end
 
-    # @!visibility private
-    def base_url
-      url = URI.parse(@entrypoint)
-      "#{url.scheme}://#{url.host}:#{url.port}"
-    end
-
-    # @!visibility private
-    def self.parse_response(response)
-      JSON.parse(response)
-    end
-
     # @!visibility private
     def http_headers(headers = {})
       {}.merge(tenant_header)
@@ -140,50 +135,34 @@ module Hawkular
       encoded.rstrip!
     end
 
-    # Generate a query string from the passed hash.
-    # This string starts with a `?` if the hash is
-    # not empty.
+    # Generate a query string from the passed hash, starting with '?'
     # Values may be an array, in which case the array values are joined together by `,`.
-    # @param param_hash [Hash] key-values pairs
-    # @return [String] complete query string to append to a base url
-    def generate_query_params(param_hash = {})
-      return '' if param_hash.size == 0
-
-      num = count_non_nil_values(param_hash)
-
-      i = 0
-      ret = ''
-      ret = '?' if num > 0
-      param_hash.each  do |k, v|
-        next if not_suitable?(v)
-
-        if v.instance_of? Array
-          part = "#{k}=#{v.join(',')}"
-        else
-          part = "#{k}=#{v}"
-        end
-
-        ret += hawk_escape part
-
-        i += 1
-        ret += '&' if i < num
+    # @param params [Hash] key-values pairs
+    # @return [String] complete query string to append to a base url, '' if no valid params
+    def generate_query_params(params = {})
+      params = params.select { |_k, v| !(v.nil? || ((v.instance_of? Array) && v.empty?)) }
+      return '' if params.empty?
+
+      params.inject('?') do |ret, (k, v)|
+        ret += '&' unless ret == '?'
+        part = (v.instance_of? Array) ? "#{k}=#{v.join(',')}" : "#{k}=#{v}"
+        ret + hawk_escape(part)
       end
-      ret
     end
 
-    private
+    # Specialized exception to be thrown
+    # when the interaction with Hawkular fails
+    class HawkularException < StandardError
+      def initialize(message, status_code = 0)
+        @message = message
+        @status_code = status_code
+        super(message)
+      end
 
-    def not_suitable?(v)
-      v.nil? || (v.instance_of? Array) && v.size == 0
+      attr_reader :message, :status_code
     end
 
-    def count_non_nil_values(param_hash)
-      num = 0
-      param_hash.each do |_k, v|
-        num += 1 unless not_suitable?(v)
-      end
-      num
-    end
+    private
 
     def token_header
       @credentials[:token].nil? ? {} : { 'Authorization' => "Bearer #{@credentials[:token]}" }
@@ -202,21 +181,10 @@ module Hawkular
         rescue JSON::ParserError
           fault_message = f.http_body
         end
-        fail HawkularException, fault_message
+        fail HawkularException.new(fault_message, (f.respond_to?(:http_code) ? f.http_code : 0))
       else
         fail f
       end
     end
   end
-
-  # Specialized exception to be thrown
-  # when the interction with Hawkular fails
-  class HawkularException < StandardError
-    def initialize(message)
-      @message = message
-      super
-    end
-
-    attr_reader :message
-  end
 end

data/lib/hawkular_all.rb

@@ -1,6 +1,8 @@
 require 'inventory/inventory_api'
 require 'metrics/metrics_client.rb'
 require 'alerts/alerts_api'
+require 'tokens/tokens_api'
+require 'operations/operations_api'
 require 'hawkular'
 
 module Hawkular

data/lib/inventory/inventory_api.rb

@@ -1,4 +1,6 @@
 require 'hawkular'
+require 'websocket-client-simple'
+require 'json'
 
 # Inventory module provides access to the Hawkular Inventory REST API.
 # @see http://www.hawkular.org/docs/rest/rest-inventory.html
@@ -14,10 +16,19 @@ module Hawkular::Inventory
     # @param credentials [Hash{String=>String}] Hash of username, password, token(optional)
     def initialize(entrypoint = nil, credentials = {})
       @entrypoint = entrypoint
-
       super(entrypoint, credentials)
     end
 
+    # Creates a new Inventory Client
+    # @param hash [Hash{String=>Object}] a hash containing base url of Hawkular-inventory - e.g
+    #   entrypoint: http://localhost:8080/hawkular/inventory
+    # and another sub-hash containing the hash with username[String], password[String], token(optional)
+    def self.create(hash)
+      hash[:entrypoint] ||= 'http://localhost:8080/hawkular/inventory'
+      hash[:credentials] ||= {}
+      InventoryClient.new(hash[:entrypoint], hash[:credentials])
+    end
+
     # Retrieve the tenant id for the passed credentials.
     # If no credentials are passed, the ones from the constructor are used
     # @param credentials [Hash{String=>String}] Hash of username, password, token(optional)
@@ -32,7 +43,7 @@ module Hawkular::Inventory
     end
 
     # TODO: revisit and potentially move to Base ?
-    def impersonate(credentials = {})
+    def impersonate!(credentials = {})
       @tenant = get_tenant(credentials)
       @options[:tenant] = @tenant
     end
@@ -41,9 +52,7 @@ module Hawkular::Inventory
     # @return [Array<String>] List of feed ids
     def list_feeds(_environment = 'test')
       ret = http_get('feeds')
-      val = []
-      ret.each { |f| val.push(f['id']) }
-      val
+      ret.map { |f| f['id'] }
     end
 
     # List resource types. If no need is given all types are listed
@@ -54,17 +63,32 @@ module Hawkular::Inventory
         ret = http_get('/resourceTypes')
       else
         the_feed = hawk_escape feed
-        ret = http_get('/feeds/' + the_feed + '/resourceTypes')
+        ret = http_get("/feeds/#{the_feed}/resourceTypes")
+      end
+      ret.map { |rt| ResourceType.new(rt) }
+    end
+
+    # Return all resources for a feed
+    # @param [String] feed Id of the feed that hosts the resources
+    # @param [Boolean] fetch_properties Should the config data be fetched too
+    # @return [Array<Resource>] List of resources, which can be empty.
+    def list_resources_for_feed(feed, fetch_properties = false)
+      fail 'Feed must be given' unless feed
+      the_feed = hawk_escape feed
+      ret = http_get("/feeds/#{the_feed}/resources")
+      ret.map do |r|
+        if fetch_properties
+          p = get_config_data_for_resource(r['id'], feed)
+          r['properties'] = p['value']
+        end
+        Resource.new(r)
       end
-      val = []
-      ret.each { |rt| val.push(ResourceType.new(rt)) }
-      val
     end
 
     # List the resources for the passed feed and resource type. The representation for
     # resources under a feed are sparse and additional data must be retrived separately.
     # It is possible though to also obtain runtime properties by setting #fetch_properties to true.
-    # @param [String] feed The id of the feed the type lives under. Can be nil for feedless types
+    # @param [String] feed The id of the feed the type lives under. Can be nil for all feeds
     # @param [String] type Name of the type to look for. Can be obtained from {ResourceType}.id.
     #   Must not be nil
     # @param [Boolean] fetch_properties Shall additional runtime properties be fetched?
@@ -73,21 +97,19 @@ module Hawkular::Inventory
       fail 'Type must not be nil' unless type
       the_type = hawk_escape type
       if feed.nil?
-        ret = http_get('resourceTypes/' + the_type + '/resources')
+        ret = http_get("resourceTypes/#{the_type}/resources")
       else
 
         the_feed = hawk_escape feed
-        ret = http_get('/feeds/' + the_feed + '/resourceTypes/' + the_type + '/resources')
+        ret = http_get("/feeds/#{the_feed}/resourceTypes/#{the_type}/resources")
       end
-      val = []
-      ret.each do |r|
+      ret.map do |r|
         if fetch_properties && !feed.nil?
           p = get_config_data_for_resource(r['id'], feed)
           r['properties'] = p['value']
         end
-        val.push(Resource.new(r))
+        Resource.new(r)
       end
-      val
     end
 
     # Retrieve runtime properties for the passed resource
@@ -97,7 +119,8 @@ module Hawkular::Inventory
     def get_config_data_for_resource(resource_id, feed)
       the_id = hawk_escape resource_id
       the_feed = hawk_escape feed
-      http_get('feeds/' + the_feed + '/resources/' + the_id + '/data?dataType=configuration')
+      query = generate_query_params dataType: 'configuration'
+      http_get("feeds/#{the_feed}/resources/#{the_id}/data#{query}")
     rescue
       {}
     end
@@ -105,47 +128,48 @@ module Hawkular::Inventory
     # Obtain the child resources of the passed resource. In case of a WildFly server,
     # those would be Datasources, Deployments and so on.
     # @param [Resource] parent_resource Resource to obtain children from
+    # @param [Boolean] recursive Whether to fetch also all the children of children of ...
     # @return [Array<Resource>] List of resources that are children of the given parent resource.
     #   Can be empty
-    def list_child_resources(parent_resource)
+    def list_child_resources(parent_resource, recursive = false)
       the_feed = hawk_escape parent_resource.feed
       the_id = hawk_escape parent_resource.id
 
-      ret = http_get('/feeds/' + the_feed +
-                     '/resources/' + the_id + '/children')
-      val = []
-      ret.each { |r| val.push(Resource.new(r)) }
-      val
+      which_children = (recursive ? '/recursiveChildren' : '/children')
+      ret = http_get("/feeds/#{the_feed}/resources/#{the_id}#{which_children}")
+      ret.map { |r| Resource.new(r) }
     end
 
     # Obtain a list of relationships starting at the passed resource
     # @param [Resource] resource One end of the relationship
+    # @param [String] named Name of the relationship
     # @return [Array<Relationship>] List of relationships
-    def list_relationships(resource)
-      the_feed = hawk_escape resource.feed
-      the_id = hawk_escape resource.id
-
-      ret = http_get('/feeds/' + the_feed + '/resources/' + the_id + '/relationships')
-      val = []
-      ret.each { |r| val.push(Relationship.new(r)) }
-      val
-    rescue
-      []
+    def list_relationships(resource, named = nil)
+      query = named.nil? ? '' : (generate_query_params named: named)
+      ret = http_get("/path#{resource.path}/relationships#{query}")
+      ret.map { |r| Relationship.new(r) }
     end
 
     # Obtain a list of relationships for the passed feed
     # @param [String] feed_id Id of the feed
+    # @param [String] named Name of the relationship
     # @return [Array<Relationship>] List of relationships
-    def list_relationships_for_feed(feed_id)
+    def list_relationships_for_feed(feed_id, named = nil)
       the_feed = hawk_escape feed_id
-      ret = http_get('/feeds/' + the_feed + '/relationships')
-      val = []
-      ret.each { |r| val.push(Relationship.new(r)) }
-      val
+      query = named.nil? ? '' : (generate_query_params named: named)
+      ret = http_get("/feeds/#{the_feed}/relationships#{query}")
+      ret.map { |r| Relationship.new(r) }
     rescue
       []
     end
 
+    # Retrieve a single entity from inventory by its canonical path
+    # @param [CanonicalPath] path canonical path of the entity
+    # @return inventory entity
+    def get_entity(path)
+      http_get("path#{path}")
+    end
+
     # [15:01:51]  <jkremser>	pilhuhn, this works for me curl -XPOST
     #   -H "Content-Type: application/json"
     #   -u jdoe:password -d
@@ -166,9 +190,59 @@ module Hawkular::Inventory
     #             rel.to_h)
     # end
 
-    # def list_metrics_for_resource_type
-    #   # TODO implement me
-    # end
+    # List the metrics for the passed feed and metric type. If feed is not passed,
+    # all the metrics across all the feeds of a given type will be retrieved
+    # This method may perform multiple REST calls.
+    # @param [String] feed The id of the feed the type lives under. Can be nil for all feeds
+    # @param [String] type Name of the metric type to look for. Can be obtained from {MetricType}.id.
+    #   Must not be nil
+    # @return [Array<Metric>] List of metrics. Can be empty
+    def list_metrics_for_metric_type(feed, type)
+      fail 'Type must not be nil' unless type
+      the_type = hawk_escape type
+      if feed.nil?
+        type_hash = http_get("metricTypes/#{the_type}")
+      else
+        the_feed = hawk_escape feed
+        type_hash = http_get("/feeds/#{the_feed}/metricTypes/#{the_type}")
+      end
+
+      rels = list_relationships(ResourceType.new(type_hash), 'defines')
+      rels.map do |rel|
+        path = CanonicalPath.parse(rel.target_id.to_s)
+        metric_hash = get_entity path
+        Metric.new(metric_hash)
+      end
+    rescue
+      []
+    end
+
+    # List the metrics for the passed feed and all the resources of given resource type.
+    # If feed is not passed, all the metrics across all the feeds of a resource type will be retrieved
+    # This method may perform multiple REST calls.
+    # @param [String] feed The id of the feed the type lives under. Can be nil for all feeds
+    # @param [String] type Name of the resource type to look for. Can be obtained from {ResourceType}.id.
+    #   Must not be nil
+    # @return [Array<Metric>] List of metrics. Can be empty
+    def list_metrics_for_resource_type(feed, type)
+      fail 'Type must not be nil' unless type
+      the_type = hawk_escape type
+      if feed.nil?
+        ret = http_get("resourceTypes/#{the_type}/resources")
+      else
+        the_feed = hawk_escape feed
+        ret = http_get("feeds/#{the_feed}/resourceTypes/#{the_type}/resources")
+      end
+      ret.flat_map do |r|
+        path = CanonicalPath.parse(r['path'])
+        if !path.feed_id.nil?
+          nested_ret = http_get("feeds/#{path.feed_id}/resources/#{path.resource_ids.join('/')}/metrics")
+        else
+          nested_ret = http_get("#{path.environment_id}/resources/#{path.resource_ids.join('/')}/metrics")
+        end
+        nested_ret.map { |m| Metric.new(m) }
+      end
+    end
 
     # List metric (definitions) for the passed resource. It is possible to filter down the
     #   result by a filter to only return a subset. The
@@ -176,7 +250,7 @@ module Hawkular::Inventory
     # @param [Hash{Symbol=>String}] filter for 'type' and 'match'
     #   Metric type can be one of 'GAUGE', 'COUNTER', 'AVAILABILITY'. If a key is missing
     #   it will not be used for filtering
-    # @return [Aray<Metric>] List of metrics that can be empty.
+    # @return [Array<Metric>] List of metrics that can be empty.
     # @example
     #    # Filter by type and match on metrics id
     #    client.list_metrics_for_resource(wild_fly, type: 'GAUGE', match: 'Metrics~Heap')
@@ -188,20 +262,229 @@ module Hawkular::Inventory
       the_feed = hawk_escape resource.feed
       the_id = hawk_escape resource.id
 
-      ret = http_get('/feeds/' +
-                           the_feed + '/resources/' +
-                           the_id + '/metrics')
-      val = []
-      ret.each do |m|
+      ret = http_get("/feeds/#{the_feed}/resources/#{the_id}/metrics")
+      with_nils = ret.map do |m|
         metric_new = Metric.new(m)
         found = should_include?(metric_new, filter)
-        val.push(metric_new) if found
+        metric_new if found
+      end
+      with_nils.compact
+    end
+
+    # Create a new feed
+    # @param [String] feed_id  Id of a feed - required
+    # @param [String] feed_name A display name for the feed
+    # @return [Object]
+    def create_feed(feed_id, feed_name = nil)
+      feed = create_blueprint
+      feed[:id] = feed_id
+      feed[:name] = feed_name
+
+      begin
+        return http_post('/feeds/', feed)
+      rescue HawkularException  => error
+        # 409 We already exist -> that is ok
+        if error.status_code == 409
+          the_feed = hawk_escape feed_id
+          http_get("/feeds/#{the_feed}")
+        else
+          raise
+        end
+      end
+    end
+
+    # Delete the feed with the passed feed id.
+    # @param feed Id of the feed to be deleted.
+    def delete_feed(feed)
+      the_feed = hawk_escape feed
+      http_delete("/feeds/#{the_feed}")
+    end
+
+    # Create a new resource type
+    # @param [String] feed_id Id of the feed to add the type to
+    # @param [String] type_id Id of the new type
+    # @param [String] type_name Name of the type
+    # @return [ResourceType] ResourceType object just created
+    def create_resource_type(feed_id, type_id, type_name)
+      the_feed = hawk_escape feed_id
+
+      type = create_blueprint
+      type[:id] = type_id
+      type[:name] = type_name
+
+      begin
+        http_post("/feeds/#{the_feed}/resourceTypes", type)
+      rescue HawkularException => error
+        # 409 We already exist -> that is ok
+        raise unless error.status_code == 409
+      ensure
+        the_type = hawk_escape type_id
+        res = http_get("/feeds/#{the_feed}/resourceTypes/#{the_type}")
       end
-      val
+      ResourceType.new(res)
+    end
+
+    # Create a resource of a given type under a given feed. To retrieve that resource
+    # you need to call {#get_resource}
+    # @param [String] feed_id Id of the feed to add the resource to
+    # @param [String] type_path Path of the resource type of this resource
+    # @param [String] resource_id Id of the resource
+    # @param [String] resource_name Name of the resource
+    # @param [Hash<String,Object>] properties Additional properties. Those are not the config-properties
+    # TODO allow to create this as child of another resource
+    def create_resource(feed_id, type_path, resource_id, resource_name = nil, properties = {})
+      the_feed = hawk_escape feed_id
+
+      res = create_blueprint
+      res[:properties] = properties
+      res[:id] = resource_id
+      res[:name] = resource_name
+      res[:resourceTypePath] = type_path
+
+      begin
+        http_post("/feeds/#{the_feed}/resources", res)
+      rescue HawkularException => error
+        # 409 We already exist -> that is ok
+        raise unless error.status_code == 409
+      end
+
+      get_resource feed_id, resource_id, false
+    end
+
+    # Return the resource object for the passed id
+    # @param [String] feed_id Id of the feed this resource belongs to
+    # @param [String] res_id Id of the resource to fetch
+    # @param [Boolean] fetch_resource_config Should the resource config data be fetched?
+    def get_resource(feed_id, res_id, fetch_resource_config = true)
+      the_feed = hawk_escape feed_id
+      the_resource = hawk_escape res_id
+
+      res = http_get("/feeds/#{the_feed}/resources/#{the_resource}")
+      if fetch_resource_config
+        p = get_config_data_for_resource(res_id, feed_id)
+        res['properties'].merge p['value'] unless p['value'].nil?
+      end
+      Resource.new(res)
+    end
+
+    # Create a new metric type for a feed
+    # @param [String] feed_id Id of the feed
+    # @param [String] metric_type_id Id of the metric type to create
+    # @param [String] type Type of the Metric. Allowed are GAUGE,COUNTER, AVAILABILITY
+    # @param [String] unit Unit of the metric
+    # @param [Numeric] collection_interval
+    # @return [MetricType] Type just created or the one from the server if it already existed.
+    def create_metric_type(feed_id, metric_type_id, type = 'GAUGE', unit = 'NONE', collection_interval = 60)
+      the_feed = hawk_escape feed_id
+
+      metric_kind = type.nil? ? 'GAUGE' : type.upcase
+      fail "Unknown type #{metric_kind}" unless %w(GAUGE COUNTER AVAILABILITY').include?(metric_kind)
+
+      mt = build_metric_type_hash(collection_interval, metric_kind, metric_type_id, unit)
+
+      begin
+        http_post("/feeds/#{the_feed}/metricTypes", mt)
+      rescue HawkularException => error
+        # 409 We already exist -> that is ok
+        raise unless error.status_code == 409
+      end
+
+      new_mt = http_get("/feeds/#{the_feed}/metricTypes/#{metric_type_id}")
+
+      MetricType.new(new_mt)
+    end
+
+    # Create a Metric and associate it with a resource.
+    # @param [String] feed_id Id of the feed
+    # @param [String] metric_id Id of the metric
+    # @param [String] type_path Full path of the MetricType
+    # @param [String] resource_id Id of the resource to associate the metric with
+    # @param [String] metric_name a (display) name for the metric. If nil, #metric_id is used.
+    # @return [Metric] The metric created or if it already existed the version from the server
+    def create_metric_for_resource(feed_id, metric_id, type_path, resource_id, metric_name = nil)
+      the_feed = hawk_escape feed_id
+      the_resource = hawk_escape resource_id
+
+      m = {}
+      m['id'] = metric_id
+      m['name'] = (metric_name.nil?) ? metric_id : metric_name
+      m['metricTypePath'] = type_path
+
+      begin
+        http_post("/feeds/#{the_feed}/metrics", m)
+      rescue HawkularException => error
+        # 409 We already exist -> that is ok
+        raise unless error.status_code == 409
+      end
+
+      ret = http_get("/feeds/#{the_feed}/metrics/#{metric_id}")
+      the_metric = Metric.new(ret)
+
+      begin
+        http_post("/feeds/#{the_feed}/resources/#{the_resource}/metrics", [the_metric.path])
+      rescue HawkularException => error
+        # 409 We already exist -> that is ok
+        raise unless error.status_code == 409
+      end
+      the_metric
+    end
+
+    # Listen on inventory changes
+    # @param [String] type Type of entity for which we want the events.
+    # Allowed values: resource, metric, resourcetype, metrictype, feed, environment, operationtype, metadatapack
+    # @param [String] action What types of events are we interested in.
+    # Allowed values: created, updated, deleted, copied, registered
+    def events(type = 'resource', action = 'created')
+      tenant_id = get_tenant
+      url = "#{entrypoint.gsub(/https?/, 'ws')}/ws/events?tenantId=#{tenant_id}&type=#{type}&action=#{action}"
+      @ws = WebSocket::Client::Simple.connect url do |client|
+        client.on :message do |msg|
+          parsed_message = JSON.parse(msg.data)
+          entity = case type
+                   when 'resource'
+                     Resource.new(parsed_message)
+                   when 'resourcetype'
+                     ResourceType.new(parsed_message)
+                   when 'metric'
+                     Metric.new(parsed_message)
+                   when 'metrictype'
+                     MetricType.new(parsed_message)
+                   else
+                     BaseEntity.new(parsed_message)
+                   end
+          yield entity
+        end
+      end
+    end
+
+    # Stop listening on inventory events.
+    # this method closes the web socket connection
+    def no_more_events!
+      @ws.close
     end
 
     private
 
+    # Creates a hash with the fields required by the Blueprint api in Hawkular-Inventory
+    def create_blueprint
+      res = {}
+      res[:properties] = {}
+      res[:id] = nil
+      res[:name] = nil
+      res[:outgoing] = {}
+      res[:incoming] = {}
+      res
+    end
+
+    def build_metric_type_hash(collection_interval, metric_kind, metric_type_id, unit)
+      mt = {}
+      mt['id'] = metric_type_id
+      mt['type'] = metric_kind
+      mt['unit'] = unit.nil? ? 'NONE' : unit.upcase
+      mt['collectionInterval'] = collection_interval.nil? ? 60 : collection_interval
+      mt
+    end
+
     def should_include?(metric_new, filter)
       found = true
       if filter.empty?
@@ -214,32 +497,31 @@ module Hawkular::Inventory
     end
   end
 
-  # A ResourceType is like a class definition for {Resource}s
-  # ResourceTypes are currently unique per feed, but one can assume
-  # that a two types with the same name of two different feeds are
-  # (more or less) the same.
-  class ResourceType
-    # @return [String] Full path of the type
+  # A Basic inventory entity with id, name, path and optional properties
+  class BaseEntity
+    # @return [String] Full path of the entity
     attr_reader :path
-    # @return [String] Name of the type
+    # @return [String] Name of the entity
     attr_reader :name
-    # @return [String] Name of the type
+    # @return [String] Name of the entity
     attr_reader :id
-    # @return [String] Feed this type belongs to
+    # @return [String] Feed this entity belongs to (or nil in case of a feedless entity)
     attr_reader :feed
-    # @return [String] Environment this Type belongs to - currently unused
+    # @return [String] Name of the environment for this entity
     attr_reader :env
-    # @return [String] Properties of this type
+    # @return [String] Properties of this entity
     attr_reader :properties
 
-    def initialize(rt_hash)
-      @id = rt_hash['id']
-      @path = rt_hash['path']
-      @name = rt_hash['name'] || rt_hash['id']
-      @properties = rt_hash['properties']
-      @_hash = rt_hash.dup
+    def initialize(hash)
+      @id = hash['id']
+      @path = hash['path']
+      @name = hash['name'] || @id
+      @properties = hash['properties'] || {}
+      @_hash = hash.dup
 
-      tmp = path.split('/')
+      return if @path.nil?
+
+      tmp = @path.split('/')
       tmp.each do |pair|
         (key, val) = pair.split(';')
         case key
@@ -258,89 +540,59 @@ module Hawkular::Inventory
     end
   end
 
+  # A ResourceType is like a class definition for {Resource}s
+  # ResourceTypes are currently unique per feed, but one can assume
+  # that a two types with the same name of two different feeds are
+  # (more or less) the same.
+  class ResourceType < BaseEntity
+    def initialize(rt_hash)
+      super(rt_hash)
+    end
+  end
+
   # A Resource is an instantiation of a {ResourceType}
-  class Resource
-    # @return [String] Full path of the resource including feed id
-    attr_reader :path
-    # @return [String] Name of the resource
-    attr_reader :name
-    # @return [String] Name of the resource
-    attr_reader :id
-    # @return [String] Name of the feed for this resource
-    attr_reader :feed
-    # @return [String] Name of the environment for this resource -- currently unused
-    attr_reader :env
+  class Resource < BaseEntity
     # @return [String] Full path of the {ResourceType}
     attr_reader :type_path
-    # @return [Hash<String,Object>] Hash with additional, resource specific properties
-    attr_reader :properties
 
     def initialize(res_hash)
-      @id = res_hash['id']
-      @path = res_hash['path']
-      @properties = res_hash['properties'] || {}
+      super(res_hash)
+      @type = res_hash['type']
       @type_path = res_hash['type']['path']
-      @_hash = res_hash
-
-      tmp = @path.split('/')
-      tmp.each do |pair|
-        (key, val) = pair.split(';')
-        case key
-        when 'f'
-          @feed = val
-        when 'e'
-          @env = val
-        when 'n'
-          @name = val.nil? ? id : val
-        end
-      end
-      self
     end
+  end
 
-    def to_h
-      @_hash.deep_dup
+  class MetricType < BaseEntity
+    # @return [String] GAUGE, COUNTER, etc.
+    attr_reader :type
+    # @return [String] metric unit such as NONE, BYTES, etc.
+    attr_reader :unit
+    # @return [Long] collection interval in seconds
+    attr_reader :collection_interval
+
+    def initialize(type_hash)
+      super(type_hash)
+      @type = type_hash['type']
+      @unit = type_hash['unit']
+      @collection_interval = type_hash['collectionInterval']
     end
   end
 
   # Definition of a Metric inside the inventory.
-  class Metric
-    # @return [String] Full path of the metric (definition)
-    attr_reader :path
-    # @return [String] Name of the metric
-    attr_reader :name
-    attr_reader :id
-    attr_reader :feed
-    attr_reader :env
+  class Metric < BaseEntity
+    # @return [String] GAUGE, COUNTER, etc.
     attr_reader :type
+    # @return [String] metric unit such as NONE, BYTES, etc.
     attr_reader :unit
     # @return [Long] collection interval in seconds
     attr_reader :collection_interval
 
     def initialize(metric_hash)
-      @id = metric_hash['id']
-      @path = metric_hash['path']
-      @name = metric_hash['name'] || @id
-      @_hash = metric_hash.dup
-
-      tmp = path.split('/')
-      tmp.each do |pair|
-        (key, val) = pair.split(';')
-        case key
-        when 'f'
-          @feed = val
-        when 'e'
-          @env = val
-        when 'n'
-          @name = val.nil? ? id : val
-        end
-      end
+      super(metric_hash)
       @type = metric_hash['type']['type']
+      @type_path = metric_hash['type']['path']
       @unit = metric_hash['type']['unit']
-      @collection_interval = metric_hash['collectionInterval']
-    end
-
-    def to_h
-      @_hash.dup
+      @collection_interval = metric_hash['type']['collectionInterval']
     end
   end
 
@@ -375,4 +627,81 @@ module Hawkular::Inventory
       hash
     end
   end
+
+  class CanonicalPath
+    attr_reader :tenant_id
+    attr_reader :feed_id
+    attr_reader :environment_id
+    attr_reader :resource_ids
+    attr_reader :metric_id
+    attr_reader :resource_type_id
+    attr_reader :metric_type_id
+
+    def initialize(hash)
+      fail 'At least tenant_id must be specified' if hash[:tenant_id].to_s.strip.length == 0
+      @tenant_id = hash[:tenant_id]
+      @feed_id = hash[:feed_id]
+      @environment_id = hash[:environment_id]
+      @resource_type_id = hash[:resource_type_id]
+      @metric_type_id = hash[:metric_type_id]
+      @resource_ids = hash[:resource_ids]
+      @metric_id = hash[:metric_id]
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def self.parse(path)
+      fail 'CanonicalPath must not be nil or emtpy' if path.to_s.strip.length == 0
+      tmp = path.split('/')
+      hash = {}
+      tmp.each do |pair|
+        (key, val) = pair.split(';')
+        case key
+        when 't'
+          hash[:tenant_id] = val
+        when 'f'
+          hash[:feed_id] = val
+        when 'e'
+          hash[:environment_id] = val
+        when 'm'
+          hash[:metric_id] = val
+        when 'r'
+          hash[:resource_ids] = [] if hash[:resource_ids].nil?
+          hash[:resource_ids].push(val)
+        when 'mt'
+          hash[:metric_type_id] = val
+        when 'rt'
+          hash[:resource_type_id] = val
+        end
+      end
+      CanonicalPath.new(hash)
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    def ==(other)
+      self.eql?(other) || other.class == self.class && other.state == state
+    end
+
+    def to_s
+      ret = "/t;#{@tenant_id}"
+      ret += "/f;#{@feed_id}" unless @feed_id.nil?
+      ret += "/e;#{@environment_id}" unless @environment_id.nil?
+      ret += "/rt;#{@resource_type_id}" unless @resource_type_id.nil?
+      ret += "/mt;#{@metric_type_id}" unless @metric_type_id.nil?
+      ret += "/m;#{@metric_id}" unless @metric_id.nil?
+      ret += resources_chunk.to_s
+      ret
+    end
+
+    protected
+
+    def state
+      [@tenant_id, @feed_id, @environment_id, @resource_ids, @metric_id, @metric_type_id, @resource_type_id]
+    end
+
+    private
+
+    def resources_chunk
+      @resource_ids.map { |r| "/r;#{r}" }.join unless @resource_ids.nil?
+    end
+  end
 end