hawkular-client 4.1.0 → 5.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d77d09316e981da7ac6e3b388086113d124edd8
-  data.tar.gz: b68cd6c87554d6277d2f3f58c2ed58d7af667b51
+  metadata.gz: 9ce43741f3e66c655f0d1c559576dad7296a8e32
+  data.tar.gz: 70e51c3bed465d9ce434b4eef252722c8afff244
 SHA512:
-  metadata.gz: 401153f15fb3a7fb00414e9febdb8499521338607dd473880ff66dfca8c742b7f613f4517126210d6991dbf4f91478c2ad3a111ea0629e680978755b94707d1b
-  data.tar.gz: f90f8cc4c20d36967403fca69d68c438b7166deb11637c0daf72e375712e6db1527b2bb9bda777f29db7f3f68308ebfbe0cdc75c4355408189e6f41847f28400
+  metadata.gz: 78e7755e7ecb8ec09c31c59758302a3cf5ce76d302fe7dadfb71f226a91ad81db7b7a33829c6edf7ebdecf7f346b03c31975725e86d424a160b23f70ce15dcab
+  data.tar.gz: 571f341fef1bff183163ecd58027d1e8cfc81b4c94e68cb2f21aaffbf877098c2d5e68728dd3f2b3b93a860255acf8502d2c1da0d7b34dd3859dc1ec1051c3b7

data/CHANGES.rdoc

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

data/lib/hawkular/base_client.rb

@@ -3,6 +3,7 @@ require 'addressable/uri'
 
 require 'hawkular/logger'
 require 'hawkular/client_utils'
+require 'erb'
 
 module Hawkular
   # This is the base functionality for all the clients,
@@ -40,6 +41,10 @@ module Hawkular
       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 = {})
       res = rest_client(suburl).get(http_headers(headers))
 

data/lib/hawkular/hawkular_client.rb

@@ -34,7 +34,7 @@ module Hawkular
     end
 
     def inventory
-      @inventory ||= Inventory::Client.new("#{@state[:entrypoint]}/hawkular/metrics",
+      @inventory ||= Inventory::Client.new("#{@state[:entrypoint]}/hawkular/inventory",
                                            @state[:credentials],
                                            @state[:options])
     end

data/lib/hawkular/inventory/entities.rb

@@ -1,308 +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] 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] Type of the metric
+    attr_reader :type
+    # @return [String] Unit of the metric
+    attr_reader :unit
+    # @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['name']
+      @type = hash['type']
+      @unit = hash['unit']
       @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
-    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
+    def hawkular_id
+      @properties.fetch('hawkular.metric.id')
     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']
+    def hawkular_type
+      @properties.fetch('hawkular.metric.type')
     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
+    def hawkular_type_id
+      @properties.fetch('hawkular.metric.typeId')
     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)
+      @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)
+      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 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
+    # @return [List<Metric>] Metrics associated to this resource
+    attr_reader :metrics
+    # @return [List<Resource>] List of children (present when the whole tree is loaded, else nil)
+    attr_reader :children
 
     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 Hawkular::ArgumentError, '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_type(type)
+      @metrics.select { |m| m.type == type }
     end
 
     def ==(other)
-      self.equal?(other) || other.class == self.class && other.state == state
+      self.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 Hawkular::ArgumentError, '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

data/lib/hawkular/inventory/inventory_api.rb

@@ -1,16 +1,8 @@
 require 'hawkular/base_client'
-require 'websocket-client-simple'
-require 'json'
-require 'zlib'
-require 'stringio'
 
 require 'hawkular/inventory/entities'
 
 # Inventory module provides access to the Hawkular Inventory REST API.
-# @see http://www.hawkular.org/docs/rest/rest-inventory.html
-#
-# @note While Inventory supports 'environments', they are not used currently
-#   and thus set to 'test' as default value.
 module Hawkular::Inventory
   # Client class to interact with Hawkular Inventory
   class Client < Hawkular::BaseClient
@@ -21,12 +13,13 @@ module Hawkular::Inventory
     #   http://localhost:8080/hawkular/inventory
     # @param credentials [Hash{String=>String}] Hash of username, password, token(optional)
     # @param options [Hash{String=>String}] Additional rest client options
-    def initialize(entrypoint = nil, credentials = {}, options = {})
-      entrypoint = normalize_entrypoint_url entrypoint, 'hawkular/metrics'
+    def initialize(entrypoint = nil, credentials = {}, options = {}, page_size = nil)
+      entrypoint = normalize_entrypoint_url entrypoint, 'hawkular/inventory'
       @entrypoint = entrypoint
       super(entrypoint, credentials, options)
       version = fetch_version_and_status['Implementation-Version']
       @version = version.scan(/\d+/).map(&:to_i)
+      @page_size = page_size || 100
     end
 
     # Creates a new Inventory Client
@@ -38,271 +31,64 @@ module Hawkular::Inventory
 
       hash[:credentials] ||= {}
       hash[:options] ||= {}
-      Client.new(hash[:entrypoint], hash[:credentials], hash[:options])
+      Client.new(hash[:entrypoint], hash[:credentials], hash[:options], hash[:page_size])
     end
 
-    # List feeds in the system
-    # @return [Array<String>] List of feed ids
-    def list_feeds
-      ret = http_get('/strings/tags/module:inventory,feed:*')
-      return [] unless ret.key? 'feed'
-      ret['feed']
+    # Get single resource by id
+    # @return Resource the resource
+    def resource(id)
+      hash = http_get(url('/resources/%s', id))
+      Resource.new(hash)
     end
 
-    # List resource types for the given feed
-    # @param [String] feed_id The id of the feed the type lives under
-    # @return [Array<ResourceType>] List of types, that can be empty
-    def list_resource_types(feed_id)
-      fail Hawkular::ArgumentError, 'Feed id must be given' unless feed_id
-
-      feed_path = feed_cp(feed_id)
-      response = http_post(
-        '/strings/raw/query',
-        fromEarliest: true,
-        order: 'DESC',
-        tags: "#{feed_path.to_tags},type:rt")
-      structures = extract_structures_from_body(response)
-      structures.map do |rt|
-        root_hash = entity_json_to_hash(-> (id) { feed_path.resource_type(id) }, rt['inventoryStructure'], false)
-        ResourceType.new(root_hash)
-      end
+    # Get resource by id with its complete subtree
+    # @return Resource the resource
+    def resource_tree(id)
+      hash = http_get(url('/resources/%s/tree', id))
+      Resource.new(hash)
     end
 
-    # List metric types for the given feed
-    # @param [String] feed_id The id of the feed the type lives under
-    # @return [Array<MetricType>] List of types, that can be empty
-    def list_metric_types(feed_id)
-      fail Hawkular::ArgumentError, 'Feed id must be given' unless feed_id
-
-      feed_path = feed_cp(feed_id)
-      response = http_post(
-        '/strings/raw/query',
-        fromEarliest: true,
-        order: 'DESC',
-        tags: "#{feed_path.to_tags},type:mt")
-      structures = extract_structures_from_body(response)
-      structures.map do |mt|
-        root_hash = entity_json_to_hash(-> (id) { feed_path.metric_type(id) }, mt['inventoryStructure'], false)
-        MetricType.new(root_hash)
-      end
+    # Get childrens of a resource
+    # @return Children of a resource
+    def children_resources(parent_id)
+      http_get(url('/resources/%s/children', parent_id))['results'].map { |r| Resource.new(r) }
     end
 
-    # Return all resources for a feed
-    # @param [String] feed_id 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_id, fetch_properties = false, filter = {})
-      fail Hawkular::ArgumentError, 'Feed id must be given' unless feed_id
-
-      feed_path = feed_cp(feed_id)
-      response = http_post(
-        '/strings/raw/query',
-        fromEarliest: true,
-        order: 'DESC',
-        tags: "#{feed_path.to_tags},type:r")
-      structures = extract_structures_from_body(response)
-      to_filter = structures.map do |r|
-        root_hash = entity_json_to_hash(-> (id) { feed_path.down(id) }, r['inventoryStructure'], fetch_properties)
-        Resource.new(root_hash)
-      end
-      filter_entities(to_filter, filter)
+    # Get parent of a resource
+    # @return Resource the parent resource, or nil if the provided ID referred to a root resource
+    def parent(id)
+      hash = http_get(url('/resources/%s/parent', id))
+      Resource.new(hash) if hash
     end
 
-    # List the resources for the passed resource type. The representation for
-    # resources under a feed are sparse and additional data must be retrieved separately.
-    # It is possible though to also obtain runtime properties by setting #fetch_properties to true.
-    # @param [String] resource_type_path Canonical path of the resource type. Can be obtained from {ResourceType}.path.
-    #   Must not be nil. The tenant_id in the canonical path doesn't have to be there.
-    # @param [Boolean] fetch_properties Shall additional runtime properties be fetched?
-    # @return [Array<Resource>] List of resources. Can be empty
-    def list_resources_for_type(resource_type_path, fetch_properties = false)
-      path = CanonicalPath.parse_if_string(resource_type_path)
-
-      fail Hawkular::ArgumentError, 'Feed id must be given' unless path.feed_id
-      fail Hawkular::ArgumentError, 'Resource type must be given' unless path.resource_type_id
-
-      # Fetch metrics by tag
-      feed_path = feed_cp(URI.unescape(path.feed_id))
-      resource_type_id = URI.unescape(path.resource_type_id)
-      escaped_for_regex = Regexp.quote("|#{resource_type_id}|")
-      response = http_post(
-        '/strings/raw/query',
-        fromEarliest: true,
-        order: 'DESC',
-        tags: "#{feed_path.to_tags},type:r,restypes:.*#{escaped_for_regex}.*")
-      structures = extract_structures_from_body(response)
-      return [] if structures.empty?
-
-      # Now find each collected resource path in their belonging InventoryStructure
-      extract_resources_for_type(structures, feed_path, resource_type_id, fetch_properties)
+    # List root resources
+    # @return [Enumeration<Resource>] Lazy-loaded Enumeration of resources
+    def root_resources
+      resources root: 'true'
     end
 
-    # Retrieve runtime properties for the passed resource
-    # @param [String] resource_path Canonical path of the resource to read properties from.
-    # @return [Hash<String,Object] Hash with additional data
-    def get_config_data_for_resource(resource_path)
-      path = CanonicalPath.parse_if_string(resource_path)
-      raw_hash = get_raw_entity_hash(path)
-      return {} unless raw_hash
-      { 'value' => fetch_properties(raw_hash) }
-    end
+    # List resources
+    # @param [Hash] filter options to filter the resource list
+    # @option filter :root If truthy, only get root resources
+    # @option filter :feedId Filter by feed id
+    # @option filter :typeId Filter by type id
+    # @return [Enumeration<Resource>] Lazy-loaded Enumeration of resources
+    def resources(filter = {})
+      filter[:root] = !filter[:root].nil? if filter.key? :root
+      filter[:maxResults] = @page_size
 
-    # Obtain the child resources of the passed resource. In case of a WildFly server,
-    # those would be Datasources, Deployments and so on.
-    # @param [String] parent_res_path Canonical path of the 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_res_path, recursive = false)
-      path = CanonicalPath.parse_if_string(parent_res_path)
-      feed_id = path.feed_id
-
-      fail Hawkular::ArgumentError, 'Feed id must be given' unless feed_id
-
-      entity_hash = get_raw_entity_hash(path)
-      extract_child_resources([], path.to_s, entity_hash, recursive) if entity_hash
-    end
-
-    # List the metrics for the passed metric type. If feed is not passed in the path,
-    # all the metrics across all the feeds of a given type will be retrieved
-    # @param [String] metric_type_path Canonical path of the resource type to look for. Can be obtained from
-    #   {MetricType}.path. Must not be nil. The tenant_id in the canonical path doesn't have to be there.
-    # @return [Array<Metric>] List of metrics. Can be empty
-    def list_metrics_for_metric_type(metric_type_path)
-      path = CanonicalPath.parse_if_string(metric_type_path)
-
-      fail Hawkular::ArgumentError, 'Feed id must be given' unless path.feed_id
-      fail Hawkular::ArgumentError, 'Metric type id must be given' unless path.metric_type_id
-
-      feed_id = URI.unescape(path.feed_id)
-      metric_type_id = URI.unescape(path.metric_type_id)
-
-      feed_path = feed_cp(feed_id)
-      escaped_for_regex = Regexp.quote("|#{metric_type_id}|")
-      response = http_post(
-        '/strings/raw/query',
-        fromEarliest: true,
-        order: 'DESC',
-        tags: "#{feed_path.to_tags},type:r,mtypes:.*#{escaped_for_regex}.*")
-      structures = extract_structures_from_body(response)
-      return [] if structures.empty?
-
-      # Now find each collected resource path in their belonging InventoryStructure
-      metric_type = get_metric_type(path)
-      extract_metrics_for_type(structures, feed_path, metric_type)
-    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
-    # @param [String] resource_path Canonical path of the resource.
-    # @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 [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')
-    #    # Filter by type only
-    #    client.list_metrics_for_resource(wild_fly, type: 'COUNTER')
-    #    # Don't filter, return all metric definitions
-    #    client.list_metrics_for_resource(wild_fly)
-    def list_metrics_for_resource(resource_path, filter = {})
-      path = CanonicalPath.parse_if_string(resource_path)
-      raw_hash = get_raw_entity_hash(path)
-      return [] unless raw_hash
-      to_filter = []
-      if (raw_hash.key? 'children') && (raw_hash['children'].key? 'metric') && !raw_hash['children']['metric'].empty?
-        # Need to merge metric type info that we must grab from another place
-        metric_types = list_metric_types(URI.unescape(path.feed_id))
-        metric_types_index = {}
-        metric_types.each { |mt| metric_types_index[mt.path] = mt }
-        to_filter = raw_hash['children']['metric'].map do |m|
-          metric_data = m['data']
-          metric_data['path'] = "#{path}/m;#{metric_data['id']}"
-          metric_type = metric_types_index[metric_data['metricTypePath']]
-          Metric.new(metric_data, metric_type) if metric_type
-        end
-        to_filter = to_filter.select { |m| m }
-      end
-      filter_entities(to_filter, filter)
-    end
-
-    # Return the resource object for the passed path
-    # @param [String] resource_path Canonical path of the resource to fetch.
-    # @param [Boolean] fetch_properties Should the resource config data be fetched?
-    def get_resource(resource_path, fetch_properties = true)
-      path = CanonicalPath.parse_if_string(resource_path)
-      raw_hash = get_raw_entity_hash(path)
-
-      unless raw_hash
-        fail Hawkular::Exception, "Resource not found: #{resource_path}"
-      end
-
-      entity_hash = entity_json_to_hash(-> (_) { path }, raw_hash, fetch_properties)
-      Resource.new(entity_hash)
-    end
-
-    # Return the resource type object for the passed path
-    # @param [String] resource_type_path Canonical path of the resource type to fetch.
-    def get_resource_type(resource_type_path)
-      path = CanonicalPath.parse_if_string(resource_type_path)
-      raw_hash = get_raw_entity_hash(path)
-
-      unless raw_hash
-        fail Hawkular::Exception, "Resource type not found: #{resource_type_path}"
+      fetch_func = lambda do |offset|
+        filter[:startOffSet] = offset
+        filter_query = '?' + filter.keys.join('=%s&') + '=%s' unless filter.empty?
+        http_get(url("/resources#{filter_query}", *filter.values))
       end
-
-      entity_hash = entity_json_to_hash(-> (_) { path }, raw_hash, false)
-      ResourceType.new(entity_hash)
+      ResultFetcher.new(fetch_func).map { |r| Resource.new(r) }
     end
 
-    # Return the metric type object for the passed path
-    # @param [String] metric_type_path Canonical path of the metric type to fetch.
-    def get_metric_type(metric_type_path)
-      path = CanonicalPath.parse_if_string(metric_type_path)
-      raw_hash = get_raw_entity_hash(path)
-
-      unless raw_hash
-        fail Hawkular::Exception, "Metric type not found: #{metric_type_path}"
-      end
-
-      entity_hash = entity_json_to_hash(-> (_) { path }, raw_hash, false)
-      MetricType.new(entity_hash)
-    end
-
-    # List operation definitions (types) for a given resource type
-    # @param [String] resource_type_path canonical path of the resource type entity
-    # @return [Array<String>] List of operation type ids
-    def list_operation_definitions(resource_type_path)
-      path = CanonicalPath.parse_if_string(resource_type_path)
-
-      fail Hawkular::ArgumentError, 'Missing feed_id in resource_type_path' unless path.feed_id
-      fail Hawkular::ArgumentError, 'Missing resource_type_id in resource_type_path' unless path.resource_type_id
-
-      response = http_post(
-        '/strings/raw/query',
-        fromEarliest: true,
-        order: 'DESC',
-        tags: path.to_tags)
-      structures = extract_structures_from_body(response)
-      res = {}
-      structures.map { |rt| rt['inventoryStructure'] }
-        .select { |rt| rt['children'] && rt['children']['operationType'] }
-        .flat_map { |rt| rt['children']['operationType'] }
-        .each do |ot|
-        hash = optype_json_to_hash(ot)
-        od = OperationDefinition.new hash
-        res[od.name] = od
-      end
-      res
-    end
-
-    # List operation definitions (types) for a given resource
-    # @param [String] resource_path canonical path of the resource entity
-    # @return [Array<String>] List of operation type ids
-    def list_operation_definitions_for_resource(resource_path)
-      resource = get_resource(resource_path, false)
-      list_operation_definitions(resource.type_path)
+    # List resources for type
+    # @return [Enumeration<Resource>] Lazy-loaded Enumeration of resources
+    def resources_for_type(type)
+      resources typeId: type
     end
 
     # Return version and status information for the used version of Hawkular-Inventory
@@ -311,184 +97,25 @@ module Hawkular::Inventory
     def fetch_version_and_status
       http_get('/status')
     end
+  end
 
-    def feed_cp(feed_id)
-      CanonicalPath.new(tenant_id: @tenant, feed_id: hawk_escape_id(feed_id))
-    end
-
-    private
-
-    def filter_entities(entities, filter)
-      entities.select do |entity|
-        found = true
-        if filter.empty?
-          found = true
-        else
-          found = false unless filter[:type] == (entity.type) || filter[:type].nil?
-          found = false unless filter[:match].nil? || entity.id.include?(filter[:match])
-        end
-        found
-      end
-    end
-
-    def entity_json_to_hash(path_getter, json, fetch_properties)
-      data = json['data']
-      data['path'] = path_getter.call(data['id']).to_s
-      if fetch_properties
-        props = fetch_properties(json)
-        data['properties'].merge! props if props
-      end
-      data
-    end
-
-    def fetch_properties(json)
-      return unless (json.key? 'children') && (json['children'].key? 'dataEntity')
-      config = json['children']['dataEntity'].find { |d| d['data']['id'] == 'configuration' }
-      config['data']['value'] if config
-    end
-
-    def optype_json_to_hash(json)
-      data = json['data']
-      # Fetch parameterTypes
-      if (json.key? 'children') && (json['children'].key? 'dataEntity')
-        param_types = json['children']['dataEntity'].find { |d| d['data']['id'] == 'parameterTypes' }
-        data['parameters'] = param_types['data']['value'] if param_types
-      end
-      data
-    end
-
-    def get_raw_entity_hash(path)
-      c_path = CanonicalPath.parse_if_string(path)
-      raw = http_post(
-        '/strings/raw/query',
-        fromEarliest: true,
-        order: 'DESC',
-        tags: c_path.to_tags
-      )
-      structure = extract_structure_from_body(raw)
-      find_entity_in_tree(c_path, structure)
-    end
-
-    def find_entity_in_tree(fullpath, inventory_structure)
-      entity = inventory_structure
-      if fullpath.resource_ids
-        relative = fullpath.resource_ids.drop(1)
-        relative.each do |child|
-          if (entity.key? 'children') && (entity['children'].key? 'resource')
-            unescaped = URI.unescape(child)
-            entity = entity['children']['resource'].find { |r| r['data']['id'] == unescaped }
-          else
-            entity = nil
-            break
-          end
-        end
-      end
-      if fullpath.metric_id
-        if (entity.key? 'children') && (entity['children'].key? 'metric')
-          unescaped = URI.unescape(fullpath.metric_id)
-          entity = entity['children']['metric'].find { |r| r['data']['id'] == unescaped }
-        else
-          entity = nil
-        end
-      end
-      entity
-    end
-
-    def extract_child_resources(arr, path, parent_hash, recursive)
-      c_path = CanonicalPath.parse_if_string(path)
-      if (parent_hash.key? 'children') && (parent_hash['children'].key? 'resource')
-        parent_hash['children']['resource'].each do |r|
-          entity = entity_json_to_hash(-> (id) { c_path.down(id) }, r, false)
-          arr.push(Resource.new(entity))
-          extract_child_resources(arr, entity['path'], r, true) if recursive
-        end
-      end
-      arr
-    end
-
-    def extract_resources_for_type(structures, feed_path, resource_type_id, fetch_properties)
-      matching_resources = []
-      structures.each do |full_struct|
-        next unless full_struct.key? 'typesIndex'
-        next unless full_struct['typesIndex'].key? resource_type_id
-        inventory_structure = full_struct['inventoryStructure']
-        root_path = feed_path.down(inventory_structure['data']['id'])
-        full_struct['typesIndex'][resource_type_id].each do |relative_path|
-          if relative_path.empty?
-            # Root resource
-            resource = entity_json_to_hash(-> (id) { feed_path.down(id) }, inventory_structure, fetch_properties)
-            matching_resources.push(Resource.new(resource))
-          else
-            # Search for child
-            fullpath = CanonicalPath.parse("#{root_path}/#{relative_path}")
-            resource_json = find_entity_in_tree(fullpath, inventory_structure)
-            if resource_json
-              resource = entity_json_to_hash(-> (_) { fullpath }, resource_json, fetch_properties)
-              matching_resources.push(Resource.new(resource))
-            end
-          end
-        end
-      end
-      matching_resources
-    end
-
-    def extract_metrics_for_type(structures, feed_path, metric_type)
-      matching_metrics = []
-      structures.each do |full_struct|
-        next unless full_struct.key? 'metricTypesIndex'
-        next unless full_struct['metricTypesIndex'].key? metric_type.id
-        inventory_structure = full_struct['inventoryStructure']
-        root_path = feed_path.down(inventory_structure['data']['id'])
-        full_struct['metricTypesIndex'][metric_type.id].each do |relative_path|
-          # Search for child
-          fullpath = CanonicalPath.parse("#{root_path}/#{relative_path}")
-          metric_json = find_entity_in_tree(fullpath, inventory_structure)
-          if metric_json
-            metric_hash = entity_json_to_hash(-> (_) { fullpath }, metric_json, false)
-            matching_metrics.push(Metric.new(metric_hash, metric_type))
-          end
-        end
-      end
-      matching_metrics
-    end
-
-    def extract_structure_from_body(response_body_array)
-      # Expecting only 1 structure (but may have several chunks)
-      structures = extract_structures_from_body(response_body_array)
-      structures[0]['inventoryStructure'] unless structures.empty?
-    end
+  # Lazy fetching results, based on Inventory "ResultSet" model
+  class ResultFetcher
+    include Enumerable
 
-    def extract_structures_from_body(response_body_array)
-      response_body_array.map { |element| Client.rebuild_from_chunks(element['data']) }
-        .select { |full| full } # evict nil
-        .map { |full| Client.decompress(full) }
+    def initialize(fetcher)
+      @fetcher = fetcher
     end
 
-    def self.rebuild_from_chunks(data_node)
-      return if data_node.empty?
-      master_data = data_node[0]
-      return Base64.decode64(master_data['value']) unless (master_data.key? 'tags') &&
-                                                          (master_data['tags'].key? 'chunks')
-      master_timestamp = master_data['timestamp']
-      last_chunk = master_data['tags']['chunks'].to_i - 1
-      all = Base64.decode64(master_data['value'])
-      return if all.empty?
-      (1..last_chunk).inject(all) do |full, chunk_id|
-        slave_data = data_node[chunk_id]
-        # Race condition: slave_data might be nil if not all chunks have been written yet on DB
-        # Consider the object is not there yet
-        return nil unless slave_data
-        # The same race condition could give us an expirated slave_data; do sanity check to cover that
-        # Timestamps are useful here, they're in consecutive, decreasing order
-        slave_timestamp = slave_data['timestamp']
-        return nil unless slave_timestamp == master_timestamp - chunk_id
-        full.concat(Base64.decode64(slave_data['value']))
+    def each
+      offset = 0
+      loop do
+        result_set = @fetcher.call(offset)
+        results = result_set['results']
+        results.each { |r| yield(r) }
+        offset += results.length
+        break if offset >= result_set['resultSize']
       end
     end
-
-    def self.decompress(raw)
-      gz = Zlib::GzipReader.new(StringIO.new(raw))
-      JSON.parse(gz.read)
-    end
   end
 end

data/lib/hawkular/operations/operations_api.rb

@@ -149,26 +149,26 @@ module Hawkular::Operations
     # Invokes a generic operation on the WildFly agent
     # (the operation name must be specified in the hash)
     # Note: if success and failure callbacks are omitted, the client will not wait for the Response message
-    # @param hash [Hash{String=>Object}] a hash containing: resourcePath [String] denoting the resource on
-    # which the operation is about to run, operationName [String]
+    # @param hash [Hash{String=>Object}] a hash containing: resourceId [String] denoting the resource on
+    # which the operation is about to run, feedId [String], operationName [String]
     # @param callback [Block] callback that is run after the operation is done
     def invoke_generic_operation(hash, &callback)
-      required = [:resourcePath, :operationName]
+      required = [:resourceId, :feedId, :operationName]
       check_pre_conditions hash, required, &callback
 
       invoke_operation_helper(hash, &callback)
     end
 
     # Invokes operation on the WildFly agent that has it's own message type
-    # @param operation_payload [Hash{String=>Object}] a hash containing: resourcePath [String] denoting
-    # the resource on which the operation is about to run
+    # @param operation_payload [Hash{String=>Object}] a hash containing: resourceId [String] denoting
+    # the resource on which the operation is about to run, feedId [String]
     # @param operation_name [String] the name of the operation. This must correspond with the message type, they can be
     # found here https://git.io/v2h1a (Use only the first part of the name without the Request/Response suffix), e.g.
     # RemoveDatasource (and not RemoveDatasourceRequest)
     # @param callback [Block] callback that is run after the operation is done
     def invoke_specific_operation(operation_payload, operation_name, &callback)
       fail Hawkular::ArgumentError, 'Operation must be specified' if operation_name.nil?
-      required = [:resourcePath]
+      required = [:resourceId, :feedId]
       check_pre_conditions operation_payload, required, &callback
 
       invoke_operation_helper(operation_payload, operation_name, &callback)
@@ -177,8 +177,9 @@ module Hawkular::Operations
     # Deploys an archive file into WildFly
     #
     # @param [Hash] hash Arguments for deployment
-    # @option hash [String]  :resource_path canonical path of the WildFly server into which we deploy
+    # @option hash [String]  :resource_id ID of the WildFly server into which we deploy
     #                        or of the domain controller if we deploy into a server group (in case of domain mode)
+    # @option hash [String]  :feed_id feed containing this resource
     # @option hash [String]  :destination_file_name resulting file name
     # @option hash [String]  :binary_content binary content representing the war file
     # @option hash [String]  :enabled whether the deployment should be enabled immediately, or not (default = true)
@@ -189,7 +190,7 @@ module Hawkular::Operations
     def add_deployment(hash, &callback)
       hash[:enabled] = hash.key?(:enabled) ? hash[:enabled] : true
       hash[:force_deploy] = hash.key?(:force_deploy) ? hash[:force_deploy] : false
-      required = [:resource_path, :destination_file_name, :binary_content]
+      required = [:resource_id, :feed_id, :destination_file_name, :binary_content]
       check_pre_conditions hash, required, &callback
 
       operation_payload = prepare_payload_hash([:binary_content], hash)
@@ -199,7 +200,8 @@ module Hawkular::Operations
     # Undeploy a WildFly deployment
     #
     # @param [Hash] hash Arguments for deployment removal
-    # @option hash [String]  :resource_path canonical path of the WildFly server from which to undeploy the deployment
+    # @option hash [String]  :resource_id ID of the WildFly server from which to undeploy the deployment
+    # @option hash [String]  :feed_id feed containing this resource
     # @option hash [String]  :deployment_name name of deployment to undeploy
     # @option hash [String]  :remove_content whether to remove the deployment content or not (default = true)
     # @option hash [String]  :server_groups comma-separated list of server groups for the operation (default = ignored)
@@ -207,12 +209,9 @@ module Hawkular::Operations
     # @param callback [Block] callback that is run after the operation is done
     def undeploy(hash, &callback)
       hash[:remove_content] = hash.key?(:remove_content) ? hash[:remove_content] : true
-      required = [:resource_path, :deployment_name]
+      required = [:resource_id, :feed_id, :deployment_name]
       check_pre_conditions hash, required, &callback
 
-      cp = ::Hawkular::Inventory::CanonicalPath.parse hash[:resource_path]
-      server_path = cp.up.to_s
-      hash[:resource_path] = server_path
       hash[:destination_file_name] = hash[:deployment_name]
 
       operation_payload = prepare_payload_hash([:deployment_name], hash)
@@ -222,18 +221,16 @@ module Hawkular::Operations
     # Enable a WildFly deployment
     #
     # @param [Hash] hash Arguments for enable deployment
-    # @option hash [String]  :resource_path canonical path of the WildFly server from which to enable the deployment
+    # @option hash [String]  :resource_id ID of the WildFly server from which to enable the deployment
+    # @option hash [String]  :feed_id feed containing this resource
     # @option hash [String]  :deployment_name name of deployment to enable
     # @option hash [String]  :server_groups comma-separated list of server groups for the operation (default = ignored)
     #
     # @param callback [Block] callback that is run after the operation is done
     def enable_deployment(hash, &callback)
-      required = [:resource_path, :deployment_name]
+      required = [:resource_id, :feed_id, :deployment_name]
       check_pre_conditions hash, required, &callback
 
-      cp = ::Hawkular::Inventory::CanonicalPath.parse hash[:resource_path]
-      server_path = cp.up.to_s
-      hash[:resource_path] = server_path
       hash[:destination_file_name] = hash[:deployment_name]
 
       operation_payload = prepare_payload_hash([:deployment_name], hash)
@@ -243,18 +240,16 @@ module Hawkular::Operations
     # Disable a WildFly deployment
     #
     # @param [Hash] hash Arguments for disable deployment
-    # @option hash [String]  :resource_path canonical path of the WildFly server from which to disable the deployment
+    # @option hash [String]  :resource_id ID of the WildFly server from which to disable the deployment
+    # @option hash [String]  :feed_id feed containing this resource
     # @option hash [String]  :deployment_name name of deployment to disable
     # @option hash [String]  :server_groups comma-separated list of server groups for the operation (default = ignored)
     #
     # @param callback [Block] callback that is run after the operation is done
     def disable_deployment(hash, &callback)
-      required = [:resource_path, :deployment_name]
+      required = [:resource_id, :feed_id, :deployment_name]
       check_pre_conditions hash, required, &callback
 
-      cp = ::Hawkular::Inventory::CanonicalPath.parse hash[:resource_path]
-      server_path = cp.up.to_s
-      hash[:resource_path] = server_path
       hash[:destination_file_name] = hash[:deployment_name]
 
       operation_payload = prepare_payload_hash([:deployment_name], hash)
@@ -264,18 +259,16 @@ module Hawkular::Operations
     # Restart a WildFly deployment
     #
     # @param [Hash] hash Arguments for restart deployment
-    # @option hash [String]  :resource_path canonical path of the WildFly server from which to restart the deployment
+    # @option hash [String]  :resource_id ID of the WildFly server from which to restart the deployment
+    # @option hash [String]  :feed_id feed containing this resource
     # @option hash [String]  :deployment_name name of deployment to restart
     # @option hash [String]  :server_groups comma-separated list of server groups for the operation (default = ignored)
     #
     # @param callback [Block] callback that is run after the operation is done
     def restart_deployment(hash, &callback)
-      required = [:resource_path, :deployment_name]
+      required = [:resource_id, :feed_id, :deployment_name]
       check_pre_conditions hash, required, &callback
 
-      cp = ::Hawkular::Inventory::CanonicalPath.parse hash[:resource_path]
-      server_path = cp.up.to_s
-      hash[:resource_path] = server_path
       hash[:destination_file_name] = hash[:deployment_name]
 
       operation_payload = prepare_payload_hash([:deployment_name], hash)
@@ -285,7 +278,8 @@ module Hawkular::Operations
     # Adds a new datasource
     #
     # @param [Hash] hash Arguments for the datasource
-    # @option hash [String]  :resourcePath canonical path of the WildFly server into which we add datasource
+    # @option hash [String]  :resourceId ID of the WildFly server into which we add datasource
+    # @option hash [String]  :feedId ID of the feed containing the WildFly server
     # @option hash [String]  :xaDatasource XA DS or normal
     # @option hash [String]  :datasourceName name of the datasource
     # @option hash [String]  :jndiName JNDI name
@@ -298,7 +292,8 @@ module Hawkular::Operations
     #
     # @param callback [Block] callback that is run after the operation is done
     def add_datasource(hash, &callback)
-      required = [:resourcePath, :xaDatasource, :datasourceName, :jndiName, :driverName, :driverClass, :connectionUrl]
+      required = [:resourceId, :feedId, :xaDatasource, :datasourceName, :jndiName, :driverName,
+                  :driverClass, :connectionUrl]
       check_pre_conditions hash, required, &callback
 
       invoke_specific_operation(hash, 'AddDatasource', &callback)
@@ -307,7 +302,8 @@ module Hawkular::Operations
     # Adds a new datasource
     #
     # @param [Hash] hash Arguments for the datasource
-    # @option hash [String]  :resource_path canonical path of the WildFly server into which we add driver
+    # @option hash [String]  :resource_id ID of the WildFly server into which we add driver
+    # @option hash [String]  :feed_id ID of the feed containing the WildFly server
     # @option hash [String]  :driver_jar_name name of the jar file
     # @option hash [String]  :driver_name name of the jdbc driver (when adding datasource, this is the driverName)
     # @option hash [String]  :module_name name of the JBoss module into which the driver will be installed - 'foo.bar'
@@ -316,7 +312,8 @@ module Hawkular::Operations
     #
     # @param callback [Block] callback that is run after the operation is done
     def add_jdbc_driver(hash, &callback)
-      required = [:resource_path, :driver_jar_name, :driver_name, :module_name, :driver_class, :binary_content]
+      required = [:resource_id, :feed_id, :driver_jar_name, :driver_name, :module_name,
+                  :driver_class, :binary_content]
       check_pre_conditions hash, required, &callback
 
       operation_payload = prepare_payload_hash([:binary_content], hash)
@@ -325,23 +322,28 @@ module Hawkular::Operations
 
     # Exports the JDR report
     #
-    # @param [String] resource_path canonical path of the WildFly server
+    # @param [String] resource_id ID of the WildFly server
+    # @param [String] feed_id ID of the feed containing the WildFly server
     # @param [Boolean] delete_immediately specifies whether the temporary file at the remote
     # server should be deleted. False, by default.
     # @param callback [Block] callback that is run after the operation is done
-    def export_jdr(resource_path, delete_immediately = false, &callback)
-      fail Hawkular::ArgumentError, 'resource_path must be specified' if resource_path.nil?
+    def export_jdr(resource_id, feed_id, delete_immediately = false, sender_request_id = nil, &callback)
+      fail Hawkular::ArgumentError, 'resource_id must be specified' if resource_id.nil?
+      fail Hawkular::ArgumentError, 'feed_id must be specified' if feed_id.nil?
       check_pre_conditions(&callback)
 
-      invoke_specific_operation({ resourcePath: resource_path,
-                                  deleteImmediately: delete_immediately },
+      invoke_specific_operation({ resourceId: resource_id,
+                                  feedId: feed_id,
+                                  deleteImmediately: delete_immediately,
+                                  senderRequestId: sender_request_id },
                                 'ExportJdr', &callback)
     end
 
     # Updates the collection intervals.
     #
     # @param [Hash] hash Arguments for update collection intervals
-    # @option hash {resourcePath} a resource managed by the target agent
+    # @option hash {resourceId} a resource managed by the target agent
+    # @option hash {feedId} the related feed ID
     # @option hash {metricTypes} A map with key=MetricTypeId, value=interval (seconds).
     # MetricTypeId must be of form MetricTypeSet~MetricTypeName
     # @option hash {availTypes} A map with key=AvailTypeId, value=interval (seconds).
@@ -349,7 +351,7 @@ module Hawkular::Operations
     #
     # @param callback [Block] callback that is run after the operation is done
     def update_collection_intervals(hash, &callback)
-      required = [:resourcePath, :metricTypes, :availTypes]
+      required = [:resourceId, :feedId, :metricTypes, :availTypes]
       check_pre_conditions hash, required, &callback
       invoke_specific_operation(hash, 'UpdateCollectionIntervals', &callback)
     end
@@ -363,6 +365,9 @@ module Hawkular::Operations
       operation_name ||= 'ExecuteOperation'
       add_credentials! operation_payload
 
+      # if unset, set the :senderRequestId
+      operation_payload[:senderRequestId] = SecureRandom.uuid unless operation_payload[:senderRequestId]
+
       handle_message(operation_name, operation_payload, &callback) unless callback.nil?
 
       # sends a message that will actually run the operation
@@ -404,12 +409,8 @@ module Hawkular::Operations
 
         case parsed[:operationName]
         when "#{operation_name}Response"
-          same_path = parsed[:data]['resourcePath'] == operation_payload[:resourcePath]
-          # failed operations don't return the operation name from some strange reason
-          same_name = operation_payload[:operationName].nil? ||
-                      parsed[:data]['operationName'] == operation_payload[:operationName].to_s
-          if same_path # using the resource path as a correlation id
-            success = same_name && parsed[:data]['status'] == 'OK'
+          if parsed[:data]['senderRequestId'] == operation_payload[:senderRequestId]
+            success = parsed[:data]['status'] == 'OK'
             success ? callback.perform(:success, parsed[:data]) : callback.perform(:failure, parsed[:data]['message'])
             client.remove_listener :message
           end

data/lib/hawkular/version.rb

@@ -4,5 +4,5 @@
 # @see https://github.com/hawkular
 module Hawkular
   # Version of the Hawkular Ruby Gem
-  VERSION = '4.1.0'.freeze
+  VERSION = '5.0.0.pre1'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hawkular-client
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 5.0.0.pre1
 platform: ruby
 authors:
 - Libor Zoubek
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-09 00:00:00.000000000 Z
+date: 2017-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -271,12 +271,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.11