hawkular-client 3.0.1 → 5.0.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f83e017f8509a6444e3be74eb62ff1aee1530779
-  data.tar.gz: 60046b96e3cc0450ec10da845122ecdb139fe8dc
+  metadata.gz: 125d32626ed72fe6dab9a3413b025002c3a1dda3
+  data.tar.gz: ae957eb3a34c40d273b1db2c3cb04edeae17639d
 SHA512:
-  metadata.gz: 827819fd051b896810082a8f83fa7a8ef98067fe6fec99feafbd43d043e863dd877a6358fd5726a21def0eda824ba2f4e91cb49bd982a6a5497fffa341b39266
-  data.tar.gz: ae796c19d656385a5482d348ff02b69bb7be967e6cb321df34e36211a27ec016025d9c1b1438fe2ed359936b6905f7e0c74bdd91b8b88334c47f7f52a2e8601b
+  metadata.gz: adc002be0c18fa0d666c076ab0d34e36571b7c9b6359f3c970850b74326292ecc661668699aa69b68f9358ffc4e8394ccc88fb36e272a60d931c01e263a6b6f7
+  data.tar.gz: a38704b444dd7b832eb9507acd25b1f398e949d10bf4f8705ed4154cd388ff63d56651f42df4da8c2080d555203446f61c658b3f4e1ec4b164392f7dd68c42f2

data/CHANGES.rdoc

@@ -3,6 +3,34 @@
 This document describes the relevant changes between releases of the
 _hawkular-client_ project.
 
+=== v 5.0.0.pre1
+* Hawkular services version 0.40.x and Hawkular Agent 1.x will be the last
+  versions to include support for _inventory-on-metrics_ and Hawkular Metrics.
+  The following versions won't be backwards compatible. Right now, a new API
+  for inventory is already implemented. This pre-release of the client is
+  adding support for this new inventory API and removing all support for the
+  previous implementation. See link:api_breaking_changes.rdoc for more details.
+* Because of the new inventory implementation, the _Operations_ client requires
+  the feed id to be sent on all operations. See link:api_breaking_changes.rdoc
+  for more details.
+* Support for a _sender_request_id_ has been added to the _Operations_ client.
+  This allows to match operation requests with their respective operation result
+  websocket messages.
+
+=== v 4.1.0
+* Fixed binary data handling when invoking <em>Export JDR</em> on operations API.
+* Added <em>delete_immediately</em> parameter to <em>Export JDR</em> operation.
+
+=== v 4.0.0
+* Standardized Exceptions under the Hawkular namespace, and the old names were deprecated, here is the list:
+  1. <code>Hawkular::BaseClient::HawkularException</code> -> <code>Hawkular::Exception</code>
+  2. <code>Hawkular::BaseClient::HawkularConnectionException</code> -> <code>Hawkular::ConnectionException</code>
+
+=== v 3.0.2
+* Adding <code>URI.unescape</code> in the <code>list_metrics_for_resource</code> method to fix the behavior of the method
+
+=== V 3.0.1
+* Fixed the issue in operations client when dealing with error handling
 
 === V 3.0.0
 * Starting this version the older Hawkular Services (prior version 0.36.0.Final, excluding) are not compatible
@@ -22,7 +50,7 @@ _hawkular-client_ project.
 11. <code>create_metric_for_resource</code> - removed
 12. <code>events</code> - removed
 13. <code>no_more_events!</code> - removed
-14. <code>list_metrics_for_resource_type
+14. <code>list_metrics_for_resource_type</code> - removed
 15. <code>list_resource_types(feed_id)</code> - now the feed_id parameter is mandatory
 
 Also the payload/parameters are now different:

data/README.rdoc

@@ -6,12 +6,12 @@
 
 A Ruby Hawkular Client.
 
-Documentation[http://www.hawkular.org/hawkular-client-ruby/docs/]
+Documentation[http://www.hawkular.org/hawkular-client-ruby/]
 
 == Changelog
 
 See {CHANGELOG}[http://www.hawkular.org/hawkular-client-ruby/docs/latest/file.CHANGES.html] for a list of changes and
-{API-Breaking-Changes}[link:http://www.hawkular.org/hawkular-client-ruby/docs/latest/file.api_breaking_changes.html] for a list of api-breaking changes.
+{API-Breaking-Changes}[http://www.hawkular.org/hawkular-client-ruby/docs/latest/file.api_breaking_changes.html] for a list of api-breaking changes.
 
 == Overview
 
@@ -107,15 +107,15 @@ You can get more info on the other parameters by checking the metrics API get_da
 === More info
 
 Check each resource API for a detailed description of what methods are available.
-* Alerts[http://www.hawkular.org/hawkular-client-ruby/docs/latest/Hawkular/Alerts/AlertsClient.html]
-* Inventory[http://www.hawkular.org/hawkular-client-ruby/docs/latest/Hawkular/Inventory/InventoryClient.html]
+* Alerts[http://www.hawkular.org/hawkular-client-ruby/docs/latest/Hawkular/Alerts/Client.html]
+* Inventory[http://www.hawkular.org/hawkular-client-ruby/docs/latest/Hawkular/Inventory/Client.html]
 * Metrics:
   * Mixed[http://www.hawkular.org/hawkular-client-ruby/docs/latest/Hawkular/Metrics/Client.html]
   * Availability[http://www.hawkular.org/hawkular-client-ruby/docs/latest/Hawkular/Metrics/Client/Availability.html]
   * Counters[http://www.hawkular.org/hawkular-client-ruby/docs/latest/Hawkular/Metrics/Client/Counters.html]
   * Gauges[http://www.hawkular.org/hawkular-client-ruby/docs/latest/Hawkular/Metrics/Client/Gauges.html]
   * Tenants[http://www.hawkular.org/hawkular-client-ruby/docs/latest/Hawkular/Metrics/Client/Tenants.html]
-* Operations[http://www.hawkular.org/hawkular-client-ruby/docs/latest/Hawkular/Operations/OperationsClient.html]
+* Operations[http://www.hawkular.org/hawkular-client-ruby/docs/latest/Hawkular/Operations/Client.html]
 
 == Contributing to hawkular-client-ruby
 
@@ -135,7 +135,6 @@ Check each resource API for a detailed description of what methods are available
 Integration tests are recorded and played against cassettes recorded with VCR
 (http://www.relishapp.com/vcr/vcr/docs)
 
-* Edit the endpoint properties in the file +spec/endpoint.yml+ (user, password and host name) if needed
 * From command line run
     rake spec
 * To run the tests against a live server, set +VCR_OFF+ to +1+ as in
@@ -145,7 +144,7 @@ Integration tests are recorded and played against cassettes recorded with VCR
 * Currently, we support two posible metrics contexts: <code>hawkular-metrics 0.8.0.Final</code> and <code>hawkular-services</code> that contain metrics. If you want to run/re-record the tests only for services, you can skip the other context by <code>SKIP_V8_METRICS=1</code>, or similarly <code>SKIP_SERVICES_METRICS=1</code>. So for instance updating the VCR templates only for hawkular-services would require command:
     VCR_UPDATE=1 SKIP_V8_METRICS=1 rspec ./spec/integration/metric_spec.rb
 
-For more details consult the {spec readme}[link:http://www.hawkular.org/hawkular-client-ruby/docs/latest/file.README.html].
+For more details consult the {spec readme}[http://www.hawkular.org/hawkular-client-ruby/docs/latest/file.README.html].
 
 == Logging
 

data/lib/hawkular/alerts/alerts_api.rb

@@ -182,11 +182,7 @@ module Hawkular::Alerts
     # Obtains action definition/plugin from the server.
     # @param [String] action_plugin Id of the action plugin to fetch. If nil, all the plugins are fetched
     def get_action_definition(action_plugin = nil)
-      if action_plugin.nil?
-        plugins = http_get('plugins')
-      else
-        plugins = [action_plugin]
-      end
+      plugins = action_plugin.nil? ? http_get('plugins') : [action_plugin]
       ret = {}
       plugins.each do |p|
         ret[p] = http_get("/plugins/#{p}")
@@ -232,7 +228,8 @@ module Hawkular::Alerts
     # Obtain the alerts for the Trigger with the passed id
     # @param [String] trigger_id Id of the trigger that has fired the alerts
     # @return [Array<Alert>] List of alerts for the trigger. Can be empty
-    def get_alerts_for_trigger(trigger_id) # TODO: add additional filters
+    def get_alerts_for_trigger(trigger_id)
+      # TODO: add additional filters
       return [] unless trigger_id
 
       url = '/?triggerIds=' + trigger_id
@@ -254,7 +251,7 @@ module Hawkular::Alerts
     # @param [Array] tenants optional list of tenants. The elements of the array can be any object
     #   convertible to a string
     # @return [Array<Alert>] List of alerts in the system. Can be empty
-    def alerts(criteria: {}, tenants:nil)
+    def alerts(criteria: {}, tenants: nil)
       query = generate_query_params(criteria)
       uri = tenants ? '/admin/alerts/' : '/'
       ret = http_get(uri + query, multi_tenants_header(tenants))
@@ -389,7 +386,7 @@ module Hawkular::Alerts
     attr_accessor :auto_resolve, :auto_resolve_alerts, :tags, :type
     attr_accessor :tenant, :description, :group, :severity, :event_type, :event_category, :member_of, :data_id_map
     attr_reader :conditions, :dampenings
-    attr_accessor :enabled, :actions, :firing_match, :auto_resolve_match
+    attr_accessor :enabled, :firing_match, :auto_resolve_match
 
     def initialize(trigger_hash)
       return if trigger_hash.nil?
@@ -427,9 +424,10 @@ module Hawkular::Alerts
         ret = x.to_s.split('_').collect(&:capitalize).join
         ret[0, 1].downcase + ret[1..-1]
       end
-      fields = [:id, :name, :enabled, :severity, :auto_resolve, :auto_resolve_alerts, :event_type, :event_category,
-                :description, :auto_enable, :auto_disable, :context, :type, :tags, :member_of, :data_id_map,
-                :firing_match, :auto_resolve_match]
+      fields = %i[id name enabled severity auto_resolve auto_resolve_alerts
+                  event_type event_category description auto_enable auto_disable
+                  context type tags member_of data_id_map firing_match
+                  auto_resolve_match]
 
       fields.each do |field|
         camelized_field = to_camel.call(field)
@@ -448,6 +446,7 @@ module Hawkular::Alerts
     class Condition
       attr_accessor :condition_id, :type, :operator, :threshold
       attr_accessor :trigger_mode, :data_id, :data2_id, :data2_multiplier
+      attr_accessor :alerter_id, :expression
       attr_reader :condition_set_size, :condition_set_index, :trigger_id
 
       def initialize(cond_hash)
@@ -461,7 +460,8 @@ module Hawkular::Alerts
         @data2_id = cond_hash['data2Id']
         @data2_multiplier = cond_hash['data2Multiplier']
         @trigger_id = cond_hash['triggerId']
-        @interval = cond_hash['interval']
+        @alerter_id = cond_hash['alerterId']
+        @expression = cond_hash['expression']
       end
 
       def to_h
@@ -476,7 +476,8 @@ module Hawkular::Alerts
         cond_hash['data2Id'] = @data2_id
         cond_hash['data2Multiplier'] = @data2_multiplier
         cond_hash['triggerId'] = @trigger_id
-        cond_hash['interval'] = @interval
+        cond_hash['alerterId'] = @alerter_id
+        cond_hash['expression'] = @expression
         cond_hash
       end
     end
@@ -601,8 +602,8 @@ module Hawkular::Alerts
     end
 
     # for some API back compatibility
-    alias_method :ackBy, :ack_by
-    alias_method :resolvedBy, :resolved_by
+    alias ackBy ack_by
+    alias resolvedBy resolved_by
   end
 
   # Representation of one event.

data/lib/hawkular/base_client.rb

@@ -3,12 +3,16 @@ require 'addressable/uri'
 
 require 'hawkular/logger'
 require 'hawkular/client_utils'
+require 'erb'
 
 module Hawkular
   # This is the base functionality for all the clients,
   # that inherit from it. You should not directly use it,
   # but through the more specialized clients.
   class BaseClient
+    HawkularException = Hawkular::Exception
+    HawkularConnectionException = Hawkular::ConnectionException
+
     include ClientUtils
 
     # @!visibility private
@@ -34,7 +38,11 @@ module Hawkular
 
       @logger = Hawkular::Logger.new
 
-      fail 'You need to provide an entrypoint' if entrypoint.nil?
+      fail Hawkular::ArgumentError, 'You need to provide an entrypoint' if entrypoint.nil?
+    end
+
+    def url(url_format, *params)
+      url_format % params.map { |p| ERB::Util.url_encode(p) }
     end
 
     def http_get(suburl, headers = {})
@@ -87,7 +95,7 @@ module Hawkular
       opts[:user] = @credentials[:username]
       opts[:password] = @credentials[:password]
       # strip @endpoint in case suburl is absolute
-      suburl = suburl[@entrypoint.length, suburl.length] if suburl.match(/^http/)
+      suburl = suburl[@entrypoint.length, suburl.length] if suburl =~ /^http/
       RestClient::Resource.new(@entrypoint, opts)[suburl]
     end
 
@@ -123,12 +131,12 @@ module Hawkular
     # @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?)) }
+      params = params.reject { |_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}"
+        part = v.instance_of?(Array) ? "#{k}=#{v.join(',')}" : "#{k}=#{v}"
         ret + hawk_escape(part)
       end
     end
@@ -141,7 +149,8 @@ module Hawkular
     # @param suffix_path [String] sufix path to be added if it doesn't exist
     # @return [String] URL with path attached to it at the end
     def normalize_entrypoint_url(entrypoint, suffix_path)
-      fail ArgumentError, 'suffix_path must not be empty' if suffix_path.empty?
+      fail Hawkular::ArgumentError, 'suffix_path must not be empty' if suffix_path.empty?
+
       strip_path = suffix_path.gsub(%r{/$}, '')
       strip_path.nil? || suffix_path = strip_path
       strip_path = suffix_path.gsub(%r{^/}, '')
@@ -165,21 +174,6 @@ module Hawkular
       url.to_s.sub(/^http(s?)/, 'ws\1')
     end
 
-    # 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
-
-      attr_reader :message, :status_code
-    end
-
-    class HawkularConnectionException < HawkularException
-    end
-
     def admin_header
       headers = {}
       headers[:'Hawkular-Admin-Token'] = @admin_token unless @admin_token.nil?
@@ -201,17 +195,18 @@ module Hawkular
     # @!visibility private
     def connect_error(fault)
       if fault.is_a?(SocketError)
-        HawkularConnectionException.new(fault.to_s)
+        Hawkular::ConnectionException.new(fault.to_s)
       elsif [Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH,
              Errno::EADDRNOTAVAIL, Errno::ENETDOWN, Errno::ENETUNREACH,
              Errno::ETIMEDOUT].include?(fault.class)
-        HawkularConnectionException.new(fault.to_s, fault.class::Errno)
+        Hawkular::ConnectionException.new(fault.to_s, fault.class::Errno)
       end
     end
 
     def handle_fault(f)
       http_code = (f.respond_to?(:http_code) ? f.http_code : 0)
-      fail HawkularException.new('Unauthorized', http_code) if f.instance_of? RestClient::Unauthorized
+      fail Hawkular::Exception.new('Unauthorized', http_code) if f.instance_of? RestClient::Unauthorized
+
       if f.respond_to?(:http_body) && !f.http_body.nil?
         begin
           json_body = JSON.parse(f.http_body)
@@ -219,11 +214,12 @@ module Hawkular
         rescue JSON::ParserError
           fault_message = f.http_body
         end
-        fail HawkularException.new(fault_message, http_code)
+
+        fail Hawkular::Exception.new(fault_message, http_code)
       elsif (connect_error_exception = connect_error(f))
-        fail connect_error_exception
+        fail Hawkular::ConnectionException, connect_error_exception
       else
-        fail f
+        fail Hawkular::Exception, f
       end
     end
   end

data/lib/hawkular/client_utils.rb

@@ -1,4 +1,22 @@
 module Hawkular
+  # Specialized exception to be thrown
+  # when the interaction with Hawkular fails
+  class Exception < StandardError
+    def initialize(message, status_code = 0)
+      @message = message
+      @status_code = status_code
+      super(message)
+    end
+
+    attr_reader :message, :status_code
+  end
+
+  class ConnectionException < Hawkular::Exception
+  end
+
+  class ArgumentError < Hawkular::Exception
+  end
+
   module ClientUtils
     # Escapes the passed url part. This is necessary,
     # as many ids inside Hawkular can contain characters

data/lib/hawkular/hawkular_client.rb

@@ -1,48 +1,42 @@
 require 'hawkular/inventory/inventory_api'
-require 'hawkular/metrics/metrics_client'
 require 'hawkular/alerts/alerts_api'
 require 'hawkular/tokens/tokens_api'
 require 'hawkular/operations/operations_api'
+require 'hawkular/prometheus/prometheus_api'
 require 'hawkular/base_client'
 
 module Hawkular
   class Client
-    attr_reader :inventory, :metrics, :alerts, :operations, :tokens, :state
-
     def initialize(hash)
       hash[:credentials] ||= {}
       hash[:options] ||= {}
-      fail 'no parameter ":entrypoint" given' if hash[:entrypoint].nil?
+
+      fail Hawkular::ArgumentError, 'no parameter ":entrypoint" given' if hash[:entrypoint].nil?
+
       @state = hash
     end
 
+    def respond_to_missing?(method_name, include_private = false)
+      delegate_client = client_for_method(method_name)
+      return super if delegate_client.nil?
+
+      method = submethod_name_for(method_name)
+      return super unless delegate_client.respond_to?(method)
+
+      true
+    end
+
     def method_missing(name, *args, &block)
-      delegate_client = case name
-                        when /^inventory_/ then inventory
-                        when /^metrics_/ then metrics
-                        when /^alerts_/ then alerts
-                        when /^operations_/ then operations
-                        when /^tokens_/ then tokens
-                        else
-                          fail "unknown method prefix `#{name}`, allowed prefixes:"\
-      '`inventory_`, `metrics_`,`alerts_`,`operations_`, `tokens_`'
-                        end
-      method = name.to_s.sub(/^[^_]+_/, '')
-      delegate_client.__send__(method, *args, &block)
+      super unless respond_to?(name)
+      client_for_method(name).__send__(submethod_name_for(name), *args, &block)
     end
 
     def inventory
-      @inventory ||= Inventory::Client.new("#{@state[:entrypoint]}/hawkular/metrics",
+      @inventory ||= Inventory::Client.new("#{@state[:entrypoint]}/hawkular/inventory",
                                            @state[:credentials],
                                            @state[:options])
     end
 
-    def metrics
-      @metrics ||= Metrics::Client.new("#{@state[:entrypoint]}/hawkular/metrics",
-                                       @state[:credentials],
-                                       @state[:options])
-    end
-
     def alerts
       @alerts ||= Alerts::Client.new("#{@state[:entrypoint]}/hawkular/alerts",
                                      @state[:credentials],
@@ -62,6 +56,12 @@ module Hawkular
                                     @state[:options])
     end
 
+    def prometheus
+      @prometheus ||= Prometheus::Client.new(@state[:entrypoint],
+                                             @state[:credentials],
+                                             @state[:options])
+    end
+
     private
 
     # this is in a dedicated method, because constructor opens the websocket connection to make the handshake
@@ -70,5 +70,19 @@ module Hawkular
                              credentials: @state[:credentials],
                              options: @state[:options])
     end
+
+    def client_for_method(method_name)
+      case method_name
+      when /^inventory_/ then inventory
+      when /^alerts_/ then alerts
+      when /^operations_/ then operations
+      when /^tokens_/ then tokens
+      when /^prometheus_/ then prometheus
+      end
+    end
+
+    def submethod_name_for(method_name)
+      method_name.to_s.sub(/^[^_]+_/, '')
+    end
   end
 end

data/lib/hawkular/inventory/entities.rb

@@ -1,306 +1,134 @@
 # It contains class definitions that are used by the inventory REST client
 module Hawkular::Inventory
-  # 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 entity
+  class Metric
+    # @return [String] Provider Name of the metric
     attr_reader :name
-    # @return [String] Id of the entity
-    attr_reader :id
-    # @return [String] Feed this entity belongs to (or nil in case of a feedless entity)
-    attr_reader :feed
-    # @return [String] Name of the environment for this entity
-    attr_reader :env
-    # @return [String] Properties of this entity
+    # @return [String] Display Name of the metric
+    attr_reader :display_name
+    # @return [String] Family of the metric (Prometheus family name)
+    attr_reader :family
+    # @return [String] Promql expression for fetching the  time series
+    attr_reader :expression
+    # @return [String] Unit of the metric
+    attr_reader :unit
+    # @return [Hash<String,String>] Labels of this metric (Prometheus labels)
+    attr_reader :labels
+    # @return [Hash<String,String>] Properties of this metric
     attr_reader :properties
 
     def initialize(hash)
-      @id = hash['id']
-      @path = hash['path']
-      @name = hash['name'] || @id
+      @name = hash['displayName']
+      @display_name = hash['displayName']
+      @family = hash['family']
+      @expression = hash['expression']
+      @unit = hash['unit']
+      @labels = hash['labels'] || {}
       @properties = hash['properties'] || {}
       @_hash = hash.dup
-
-      return if @path.nil?
-
-      tmp = @path.split('/')
-      tmp.each do |pair|
-        (key, val) = pair.split(';')
-        case key
-        when 'f'
-          @feed = val
-        when 'e'
-          @env = val
-        end
-      end
     end
 
-    def ==(other)
-      self.equal?(other) || other.class == self.class && other.id == @id
-    end
-
-    # Returns a hash representation of the resource type
-    # @return [Hash<String,Object>] hash of the type
+    # Returns a hash representation of the metric type
+    # @return [Hash<String,Object>] hash of the metric type
     def to_h
       @_hash.dup
     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 < BaseEntity
-    # @return [String] Full path of the {ResourceType}
-    attr_reader :type_path
-
-    def initialize(res_hash)
-      super(res_hash)
-      if res_hash.key? :resourceTypePath
-        @type_path = res_hash[:resourceTypePath]
-      elsif res_hash.key? 'resourceTypePath'
-        @type_path = res_hash['resourceTypePath']
-      else
-        @type = res_hash['type']
-        @type_path = res_hash['type']['path']
-      end
-    end
-  end
-
-  # Fields that are common for MetricType and Metric
-  module MetricFields
-    # @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, it has different semantics for MetricType and for Metric
-    #                for MetricType it's a default that will be applied to all the metric of that type,
-    #                in the Metric this can be overridden
-    attr_reader :collection_interval
-  end
-
-  # Definition of a Metric Type inside the inventory.
-  class MetricType < BaseEntity
-    include MetricFields
-
-    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 < BaseEntity
-    include MetricFields
-
-    attr_reader :type_id
-    # @return [String] metric id used in Hawkular Metrics
-    attr_reader :hawkular_metric_id
-
-    def initialize(metric_hash, metric_type)
-      super(metric_hash)
-      @type = metric_type.type
-      @type_path = metric_hash['metricTypePath']
-      @type_id = metric_type.id
-      @unit = metric_type.unit
-      @collection_interval = metric_hash['collectionInterval'] || metric_type.collection_interval
-      @hawkular_metric_id = @properties.key?('hawkular-metric-id') ? @properties['hawkular-metric-id'] : @id
-    end
-  end
-
-  class OperationDefinition < BaseEntity
+  class Operation
+    # @return [String] Name of the operation
+    attr_reader :name
     attr_reader :params
 
     def initialize(op_hash)
-      super(op_hash)
-      @params = (op_hash.key? 'parameters') ? op_hash['parameters'] : {}
+      @name = op_hash['name']
+      @params = op_hash.key?('parameters') ? op_hash['parameters'] : {}
     end
   end
 
-  # Definition of a Relationship between two entities in Inventory
-  class Relationship
-    attr_accessor :source_id
-    attr_reader :target_id
-    attr_reader :properties
-    attr_reader :name
+  class ResourceType
+    # @return [String] Id of the resource type
     attr_reader :id
+    # @return [Hash<String,String>] Properties of this resource type
+    attr_reader :properties
+    # @return [List<Operation>] Operations associated with this type
+    attr_reader :operations
 
-    def initialize(hash = {})
-      if hash.empty?
-        @properties = {}
-        return
-      end
-
-      @source_id = hash['source']
-      @target_id = hash['target']
-      @properties = hash['properties']
-      @name = hash['name']
+    def initialize(hash)
       @id = hash['id']
+      @properties = hash['properties'] || {}
+      @operations = (hash['operations'] || []).map { |op| Operation.new(op) }
+      @_hash = hash.dup
+    end
+
+    def ==(other)
+      equal?(other) || other.class == self.class && other.id == @id
     end
 
+    # Returns a hash representation of the resource type
+    # @return [Hash<String,Object>] hash of the resource type
     def to_h
-      hash = {}
-      hash['source'] = @source_id
-      hash['target'] = @target_id
-      hash['properties'] = @properties
-      hash['name'] = @name
-      hash['id'] = @id
-      hash
+      @_hash.dup
     end
   end
 
-  class CanonicalPath
-    include Hawkular::ClientUtils
-
-    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
+  class Resource
+    # @return [String] Id of the entity
+    attr_reader :id
+    # @return [String] Name of the entity
+    attr_reader :name
+    # @return [String] Feed this entity belongs to
+    attr_reader :feed
+    # @return [ResourceType] Type of this resource
+    attr_reader :type
+    # @return [String] Parent ID of this entity (nil if it's a root resource)
+    attr_reader :parent_id
+    # @return [Hash<String,String>] Properties of this resource
+    attr_reader :properties
+    # @return [Hash<String,String>] Config map of this resource
+    attr_reader :config
 
     def initialize(hash)
-      @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
-
-    def self.parse(path)
-      fail 'CanonicalPath must not be nil or empty' if path.to_s.strip.length == 0
-      CanonicalPath.new(path_to_h path)
-    end
-
-    def self.parse_if_string(path)
-      path.is_a?(CanonicalPath) ? path : CanonicalPath.parse(path)
-    end
-
-    def copy_hash
-      hash = to_h
-      hash[:resource_ids] = hash[:resource_ids].clone unless hash[:resource_ids].nil?
-      hash
+      @id = hash['id']
+      @name = hash['name']
+      @feed = hash['feedId']
+      @type = ResourceType.new(hash['type'])
+      @parent_id = hash['parentId']
+      @properties = hash['properties'] || {}
+      @config = hash['config'] || {}
+      @metrics = (hash['metrics'] || []).map { |m| Metric.new(m) }
+      @children = hash['children'].map { |r| Resource.new(r) } if hash.key? 'children'
+      @_hash = hash.dup
     end
 
-    # Move up to the parent path of the resource. resource_ids set to empty array when there is no parent.
-    # @return CanonicalPath corresponding to the direct ancestor of the resource represented by this path object.
-    def up
-      hash = copy_hash
-      res = hash[:resource_ids] || []
-      res = res.take(res.length - 1) unless res.empty?
-      hash[:resource_ids] = res
-      CanonicalPath.new(hash)
+    def children(recursive = false)
+      return @children unless recursive == true
+      fail Hawkular::ArgumentError 'Resource tree not loaded, load it by calling resource_tree' if @children.nil?
+      @children.flat_map do |child|
+        [child, *child.children(recursive)]
+      end
     end
 
-    # Add resource down to the current path
-    # @return a new CanonicalPath based on the current one
-    def down(resource)
-      hash = copy_hash
-      hash[:resource_ids] = (hash[:resource_ids] || []) << hawk_escape_id(resource)
-      CanonicalPath.new(hash)
+    def children_by_type(type, recursive = false)
+      children(recursive).select { |c| c.type.id == type }
     end
 
-    # Set resource type to the current path
-    # @return a new CanonicalPath based on the current one
-    def resource_type(resource_type)
-      hash = copy_hash
-      hash[:resource_type_id] = hawk_escape_id(resource_type)
-      CanonicalPath.new(hash)
+    def metrics(recursive = false)
+      return @metrics unless recursive == true
+      children(recursive).collect(&:metrics).flat_map(&:itself).concat(@metrics)
     end
 
-    # Set metric type to the current path
-    # @return a new CanonicalPath based on the current one
-    def metric_type(metric_type)
-      hash = copy_hash
-      hash[:metric_type_id] = hawk_escape_id(metric_type)
-      CanonicalPath.new(hash)
+    def metrics_by_family(family)
+      @metrics.select { |m| m.family == family }
     end
 
     def ==(other)
-      self.equal?(other) || other.class == self.class && other.state == state
+      equal?(other) || other.class == self.class && other.id == @id
     end
 
+    # Returns a hash representation of the resource
+    # @return [Hash<String,Object>] hash of the resource
     def to_h
-      {
-        tenant_id: @tenant_id,
-        feed_id: @feed_id,
-        environment_id: environment_id,
-        resource_type_id: resource_type_id,
-        metric_type_id: metric_type_id,
-        resource_ids: resource_ids,
-        metric_id: @metric_id
-      }
-    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 += resources_chunk.to_s
-      ret += "/m;#{@metric_id}" unless @metric_id.nil?
-      ret
-    end
-
-    def to_tags
-      fail 'Missing feed_id' if @feed_id.nil?
-      tags = "module:inventory,feed:#{Regexp.quote(@feed_id)}"
-      tags += ",type:rt,id:#{Regexp.quote(@resource_type_id)}" if @resource_type_id
-      tags += ",type:mt,id:#{Regexp.quote(@metric_type_id)}" if @metric_type_id
-      tags += ",type:r,id:#{Regexp.quote(@resource_ids[0])}" if @resource_ids && (!@resource_ids.empty?)
-      tags
-    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
-
-    def self.path_to_h(path)
-      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
-      hash
+      @_hash.dup
     end
   end
 end