hawkular-client 3.0.2 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ab85ad134aa538531c4b1a49bd2719fa891e571
-  data.tar.gz: 3f6eac54b04032844df33902c440e34f6e08f674
+  metadata.gz: e41fdf0699f44cfc71f223daa51bd936be6b6db7
+  data.tar.gz: 504979a3d89220826149247458d30d50fdbd783c
 SHA512:
-  metadata.gz: 006e318a94934bf4c982cdee7cddd0c0e0d511a5162aa79cccd19a0a6d9c956f0a4fa3dbca75f2faf32d03f1b3c5eeebe770fa37d8e68e10961308bbf391700c
-  data.tar.gz: 1858d7ad7caac9a136f42419da8b7b9e990216f62cf4529dbdeaa45080a84d3e6f69fe55cdda8296b593f0aa6157f01718c3377ddb51547cd900e6e25ff840f2
+  metadata.gz: 1e75e32352cf4981d90ac6bf55cf177d489fe9e62fc3274a6ffbbc44500ed71c2a3fd702bc3e88fcab7a0c06ea1a7ba62dfa85636ee8a3fe0a532d35371d2dfd
+  data.tar.gz: c8d1e5fac46c5bacbdce0c007ff387545a23154ca4294ab6b277ab7865bfeefe10def5b86df63e6b35d64e0c0acbfdffe806102ae52f2004d49c59d0518b929a

data/CHANGES.rdoc

@@ -3,6 +3,28 @@
 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

data/README.rdoc

@@ -6,7 +6,7 @@
 
 A Ruby Hawkular Client.
 
-Documentation[http://www.hawkular.org/hawkular-client-ruby/docs/]
+Documentation[http://www.hawkular.org/hawkular-client-ruby/]
 
 == Changelog
 
@@ -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

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