hawkular-client 3.0.2 → 5.0.0

data/lib/hawkular/metrics/metric_api.rb

@@ -23,7 +23,8 @@ module Hawkular::Metrics
     # @param starts [Integer] optional timestamp (default now - 8h)
     # @param ends [Integer] optional timestamp (default now)
     # @return [Array[Hash]] datapoints
-    def data_by_tags(tags, buckets: nil, bucketDuration:nil, start:nil, ends: nil)
+    def data_by_tags(tags, buckets: nil, bucketDuration: nil, # rubocop:disable Naming/VariableName
+                     start: nil, ends: nil)
       data = {
         tags: tags_param(tags), buckets: buckets, bucketDuration: bucketDuration, start: start, end: ends
       }
@@ -56,7 +57,7 @@ module Hawkular::Metrics
       strings.each { |g| default_timestamp g[:data] }
       data = { gauges: gauges, counters: counters, availabilities: availabilities, strings: strings }
       path = '/metrics/'
-      @legacy_api ? path << 'data' : path << 'raw'
+      path << (@legacy_api ? 'data' : 'raw')
       http_post(path, data)
     end
 
@@ -84,7 +85,7 @@ module Hawkular::Metrics
       path = '/metrics/stats/query'
       metrics = { gauge: gauge_ids, counter: counter_ids, availability: avail_ids }
       data = { metrics: metrics, start: starts, end: ends, bucketDuration: bucket_duration }
-      data['types'] = %w(gauge gauge_rate counter counter_rate availability) if rates
+      data['types'] = %w[gauge gauge_rate counter counter_rate availability] if rates
       http_post(path, data)
     end
 
@@ -93,9 +94,11 @@ module Hawkular::Metrics
     def tags
       tags = []
       http_get('/metrics/').map do |g|
+        next if g['tags'].nil?
+
         g['tags'].map do |k, v|
           tags << { k => v }
-        end unless g['tags'].nil?
+        end
       end
       tags.uniq!
     end
@@ -171,7 +174,7 @@ module Hawkular::Metrics
       def push_data(id, data)
         data = [data] unless data.is_a?(Array)
         uri = "/#{@resource}/#{ERB::Util.url_encode(id)}/"
-        @legacy_api ? uri << 'data' : uri << 'raw'
+        uri << (@legacy_api ? 'data' : 'raw')
         @client.default_timestamp data
         @client.http_post(uri, data)
       end
@@ -187,8 +190,8 @@ module Hawkular::Metrics
       # @param order [String] optional Data point sort order, based on timestamp (ASC, DESC)
       # @return [Array[Hash]] datapoints
       # @see #push_data #push_data for datapoint detail
-      def get_data(id, starts: nil, ends: nil, bucketDuration: nil, buckets: nil, percentiles: nil, limit: nil,
-                   order: nil)
+      def get_data(id, starts: nil, ends: nil, bucketDuration: nil, # rubocop:disable Naming/VariableName
+                   buckets: nil, percentiles: nil, limit: nil, order: nil)
         params = { start: starts, end: ends, bucketDuration: bucketDuration, buckets: buckets,
                    percentiles: percentiles, limit: limit, order: order }
         get_data_helper(id, params)
@@ -214,28 +217,32 @@ module Hawkular::Metrics
       # @param buckets [Integer] optional number of buckets
       # @return [Array[Hash]] datapoints
       # @see #push_data #push_data for datapoint detail
-      def get_data_by_tags(tags, starts: nil, ends: nil, bucketDuration: nil, buckets:nil)
+      def get_data_by_tags(tags, starts: nil, ends: nil, bucketDuration: nil, # rubocop:disable Naming/VariableName
+                           buckets: nil)
         params = { tags: @client.tags_param(tags), start: starts,
                    end: ends, bucketDuration: bucketDuration, buckets: buckets }
         path = "/#{@resource}/"
-        @legacy_api ? path << 'data/?' : path << 'stats/?'
+        path << (@legacy_api ? 'data/?' : 'stats/?')
         resp = @client.http_get(path + encode_params(params))
         resp.is_a?(Array) ? resp : [] # API returns no content (empty Hash) instead of empty array
       end
 
       def encode_params(params)
-        URI.encode_www_form(params.select { |_k, v| !v.nil? })
+        URI.encode_www_form(params.reject { |_k, v| v.nil? })
       end
 
       private
 
       def get_data_helper(id, params)
         path = "/#{@resource}/#{ERB::Util.url_encode(id)}/"
-        if @legacy_api
-          path << 'data/?'
-        else
-          (params[:bucketDuration].nil? && params[:buckets].nil?) ? path << 'raw/?' : path << 'stats/?'
-        end
+        path << if @legacy_api
+                  'data/?'
+                elsif params[:bucketDuration].nil? && params[:buckets].nil?
+                  'raw/?'
+                else
+                  'stats/?'
+                end
+
         path << encode_params(params)
         resp = @client.http_get(path)
         resp.is_a?(Array) ? resp : [] # API returns no content (empty Hash) instead of empty array
@@ -329,8 +336,8 @@ module Hawkular::Metrics
       # @param order [String] optional Data point sort order, based on timestamp (ASC, DESC)
       # @return [Array[Hash]] datapoints
       # @see #push_data #push_data for datapoint detail
-      def get_data(id, starts: nil, ends: nil, bucketDuration: nil, buckets: nil, distinct: nil, limit: nil,
-        order: nil)
+      def get_data(id, starts: nil, ends: nil, bucketDuration: nil, # rubocop:disable Naming/VariableName
+                   buckets: nil, distinct: nil, limit: nil, order: nil)
         params = { start: starts, end: ends, bucketDuration: bucketDuration, buckets: buckets,
                    distinct: distinct, limit: limit, order: order }
         get_data_helper(id, params)

data/lib/hawkular/metrics/metrics_client.rb

@@ -35,12 +35,13 @@ module Hawkular::Metrics
 
     def check_version
       version_status_hash = fetch_version_and_status
+
       fail_version_msg = 'Unable to determine implementation version for metrics'
-      fail fail_version_msg if version_status_hash['Implementation-Version'].nil?
+      fail Hawkular::Exception, fail_version_msg if version_status_hash['Implementation-Version'].nil?
       version = version_status_hash['Implementation-Version']
       major, minor = version.scan(/\d+/).map(&:to_i)
-      fail fail_version_msg if major.nil? || minor.nil?
-      @legacy_api = (major == 0 && minor < 16)
+      fail Hawkular::Exception, fail_version_msg if major.nil? || minor.nil?
+      @legacy_api = (major.zero? && minor < 16)
     end
 
     # Construct a new Hawkular Metrics client class.

data/lib/hawkular/operations/operations_api.rb

@@ -1,3 +1,6 @@
+require 'timeout'
+require 'monitor'
+
 require 'hawkular/base_client'
 require 'websocket-client-simple'
 require 'json'
@@ -13,14 +16,7 @@ class Proc
       method_name = callable.to_sym
       define_method(method_name) { |&block| block.nil? ? true : block.call(result) }
       define_method("#{method_name}?") { true }
-
-      # method_missing is here because we are not forcing the client to provide both success and error callbacks
-      # rubocop:disable Lint/NestedMethodDefinition
-      # https://github.com/bbatsov/rubocop/issues/2704
-      def method_missing(_method_name, *_args, &_block)
-        PerformMethodMissing
-      end
-      # rubocop:enable Lint/NestedMethodDefinition
+      define_method(:method_missing) { |*| PerformMethodMissing }
     end.new)
   end
 end
@@ -30,15 +26,42 @@ module Hawkular::Operations
   # Client class to interact with the agent via websockets
   class Client < Hawkular::BaseClient
     include WebSocket::Client
+    include MonitorMixin
 
-    attr_accessor :ws, :session_id, :logger
+    attr_accessor :ws, :logger
 
     # helper for parsing the "OperationName=json_payload" messages
     class WebSocket::Frame::Data
       def to_msg_hash
-        chunks = split('=', 2)
+        operation_name, json = split('=', 2)
+
+        # Check if there is a zip file following JSON.
+        # This check is done only in the first 100KB, hoping it's unlikely to
+        # have such large amount of JSON before a zip file is attached.
+        magic_bits = [
+          "\x50\x4B\x03\x04", # "PK" + 0x03 + 0x04 = Regular ZIP file
+          "\x50\x4B\x05\x06", # "PK" + 0x05 + 0x06 = Empty ZIP
+          "\x50\x4B\x07\x08"  # "PK" + 0x07 + 0x08 = Spanned ZIP
+        ]
+        search_chunk = json[0, 102_400]
+        zip_file = nil
+
+        magic_bits.each do |bits|
+          idx = search_chunk.index(bits)
+
+          next unless idx
+
+          zip_file = json[idx..-1]
+          json = json[0, idx]
+          break
+        end
+
+        # Parse JSON and, if received, attach zip file
+        json = JSON.parse(json)
+        json[:attachments] = zip_file
 
-        { operationName: chunks[0], data: JSON.parse(chunks[1]) }
+        # Return processed data
+        { operationName: operation_name, data: json }
       rescue
         {}
       end
@@ -72,72 +95,80 @@ module Hawkular::Operations
       if args[:entrypoint]
         uri = URI.parse(args[:entrypoint].to_s)
         args[:host] = "#{uri.host}:#{uri.port}"
-        args[:use_secure_connection] = %w(https wss).include?(uri.scheme) ? true : false
+        args[:use_secure_connection] = %w[https wss].include?(uri.scheme) ? true : false
       end
 
-      fail 'no parameter ":host" or ":entrypoint" given' if args[:host].nil?
+      fail Hawkular::ArgumentError, 'no parameter ":host" or ":entrypoint" given' if args[:host].nil?
 
       super(args[:host], args[:credentials], args[:options])
 
-      url = "ws#{args[:use_secure_connection] ? 's' : ''}://#{args[:host]}/hawkular/command-gateway/ui/ws"
+      @logger = Hawkular::Logger.new
+
+      @url = "ws#{args[:use_secure_connection] ? 's' : ''}://#{args[:host]}/hawkular/command-gateway/ui/ws"
+      @credentials = args[:credentials]
+      @tenant = args[:options][:tenant]
+      @wait_time = args[:wait_time]
+    end
+
+    def base64_credentials
+      ["#{@credentials[:username]}:#{@credentials[:password]}"].pack('m').delete("\r\n")
+    end
+
+    def connect
+      return if @connecting || (@ws && @ws.open?)
 
-      creds = args[:credentials]
-      base64_creds = ["#{creds[:username]}:#{creds[:password]}"].pack('m').delete("\r\n")
+      @connecting = true
 
       ws_options = {
         headers:  {
-          'Authorization' => 'Basic ' + base64_creds,
-          'Hawkular-Tenant' => args[:options][:tenant],
+          'Authorization' => 'Basic ' + base64_credentials,
+          'Hawkular-Tenant' => @tenant,
           'Accept' => 'application/json'
         }
       }
 
-      @logger = Hawkular::Logger.new
-
-      @ws = Simple.connect url, ws_options do |client|
+      @ws = Simple.connect @url, ws_options do |client|
         client.on(:message, once: true) do |msg|
           parsed_message = msg.data.to_msg_hash
 
+          logger = Hawkular::Logger.new
           logger.log("Sent WebSocket message: #{parsed_message}")
-
-          case parsed_message[:operationName]
-          when 'WelcomeResponse'
-            @session_id = parsed_message[:data]['sessionId']
-          end
         end
       end
 
-      sleep args[:wait_time]
+      Timeout.timeout(@wait_time) { sleep 0.1 until @ws.open? }
+    ensure
+      @connecting = false
     end
 
     # Closes the WebSocket connection
     def close_connection!
-      @ws.close
+      @ws && @ws.close
     end
 
     # 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 = %i[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 'Operation must be specified' if operation_name.nil?
-      required = [:resourcePath]
+      fail Hawkular::ArgumentError, 'Operation must be specified' if operation_name.nil?
+      required = %i[resourceId feedId]
       check_pre_conditions operation_payload, required, &callback
 
       invoke_operation_helper(operation_payload, operation_name, &callback)
@@ -146,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)
@@ -158,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 = %i[resource_id feed_id destination_file_name binary_content]
       check_pre_conditions hash, required, &callback
 
       operation_payload = prepare_payload_hash([:binary_content], hash)
@@ -168,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)
@@ -176,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 = %i[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)
@@ -191,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 = %i[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)
@@ -212,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 = %i[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)
@@ -233,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 = %i[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)
@@ -254,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
@@ -267,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 = %i[resourceId feedId xaDatasource datasourceName jndiName
+                    driverName driverClass connectionUrl]
       check_pre_conditions hash, required, &callback
 
       invoke_specific_operation(hash, 'AddDatasource', &callback)
@@ -276,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'
@@ -285,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 = %i[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)
@@ -294,19 +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, &callback)
-      fail '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 }, 'ExportJdr', &callback)
+      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).
@@ -314,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 = %i[resourceId feedId metricTypes availTypes]
       check_pre_conditions hash, required, &callback
       invoke_specific_operation(hash, 'UpdateCollectionIntervals', &callback)
     end
@@ -322,29 +359,38 @@ module Hawkular::Operations
     private
 
     def invoke_operation_helper(operation_payload, operation_name = nil, binary_content = nil, &callback)
+      synchronize { connect }
+
       # fallback to generic 'ExecuteOperation' if nothing is specified
       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
       payload = "#{operation_name}Request=#{operation_payload.to_json}"
       payload += binary_content unless binary_content.nil?
       @ws.send payload, type: binary_content.nil? ? :text : :binary
+    rescue => e
+      callback.perform(:failure, "#{e.class} - #{e.message}")
     end
 
     def check_pre_conditions(hash = {}, params = [], &callback)
-      fail 'Handshake with server has not been done.' unless @ws.open?
-      fail 'Hash cannot be nil.' if hash.nil?
-      fail 'callback must have the perform method defined. include Hawkular::Operations' unless
+      fail Hawkular::ArgumentError, 'Hash cannot be nil.' if hash.nil?
+      fail Hawkular::ArgumentError, 'callback must have the perform method defined. include Hawkular::Operations' unless
           callback.nil? || callback.respond_to?('perform')
+
       params.each do |property|
         next unless hash[property].nil?
         err_callback = 'You need to specify error callback'
         err_message = "Hash property #{property} must be specified"
-        fail(ArgumentError, err_callback) if callback.nil?
-        fail(ArgumentError, err_callback) if callback.perform(:failure, err_message).equal? Proc::PerformMethodMissing
+
+        if !callback || callback.perform(:failure, err_message) == Proc::PerformMethodMissing
+          fail(Hawkular::ArgumentError, err_callback)
+        end
       end
     end
 
@@ -363,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
@@ -382,15 +424,18 @@ module Hawkular::Operations
     def self.handle_error(parsed_message, &callback)
       callback.perform(:failure, parsed_message == {} ? 'error' : parsed_message[:data]['errorMessage'])
     end
+    private_class_method :handle_error
 
     def prepare_payload_hash(ignored_params, hash)
       # it filters out ignored params and convert keys from snake_case to camelCase
-      Hash[hash.select { |k, _| !ignored_params.include? k }.map { |k, v| [to_camel_case(k.to_s).to_sym, v] }]
+      Hash[hash.reject { |k, _| ignored_params.include? k }.map { |k, v| [to_camel_case(k.to_s).to_sym, v] }]
     end
 
     def to_camel_case(str)
-      ret = str.split('_').collect(&:capitalize).join
-      ret[0, 1].downcase + ret[1..-1]
+      subs = str.split('_')
+      ret = subs.length > 1 ? subs.collect(&:capitalize).join : subs[0]
+      ret[0] = ret[0].downcase
+      ret
     end
   end
 end