hawkular-client 3.0.2 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ab85ad134aa538531c4b1a49bd2719fa891e571
-  data.tar.gz: 3f6eac54b04032844df33902c440e34f6e08f674
+  metadata.gz: 29d98c76e5262c54b3c0949ebfd998051e3abb81
+  data.tar.gz: b7c63829113d7bd814d5a300f3e6d8da36b48195
 SHA512:
-  metadata.gz: 006e318a94934bf4c982cdee7cddd0c0e0d511a5162aa79cccd19a0a6d9c956f0a4fa3dbca75f2faf32d03f1b3c5eeebe770fa37d8e68e10961308bbf391700c
-  data.tar.gz: 1858d7ad7caac9a136f42419da8b7b9e990216f62cf4529dbdeaa45080a84d3e6f69fe55cdda8296b593f0aa6157f01718c3377ddb51547cd900e6e25ff840f2
+  metadata.gz: 5e3c7e6e3ccc5bdd7357dfa435046bf428f7f5a88800222d4dedddcd6e525a28a348a6af6d725096c49b71b8c724ceed0263948b2ec85b9a963b31f2761dd92a
+  data.tar.gz: 50aa5323c03caf2704e1d5848c7311ef7d9c640a7c73583aa911da9d8976262f75bc6139a385a8f541f58cdf1c1b5dd843e642ce4d9367523c5062370d2d214b

data/CHANGES.rdoc

@@ -4,6 +4,11 @@ This document describes the relevant changes between releases of the
 _hawkular-client_ project.
 
 
+=== 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
 

data/lib/hawkular/base_client.rb

@@ -9,6 +9,9 @@ module Hawkular
   # 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 +37,7 @@ 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 http_get(suburl, headers = {})
@@ -141,7 +144,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 +169,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 +190,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 +209,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

@@ -12,7 +12,9 @@ module Hawkular
     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
 
@@ -24,7 +26,7 @@ module Hawkular
                         when /^operations_/ then operations
                         when /^tokens_/ then tokens
                         else
-                          fail "unknown method prefix `#{name}`, allowed prefixes:"\
+                          fail Hawkular::ArgumentError, "unknown method prefix `#{name}`, allowed prefixes:"\
       '`inventory_`, `metrics_`,`alerts_`,`operations_`, `tokens_`'
                         end
       method = name.to_s.sub(/^[^_]+_/, '')

data/lib/hawkular/inventory/entities.rb

@@ -181,7 +181,8 @@ module Hawkular::Inventory
     end
 
     def self.parse(path)
-      fail 'CanonicalPath must not be nil or empty' if path.to_s.strip.length == 0
+      fail Hawkular::ArgumentError, 'CanonicalPath must not be nil or empty' if path.to_s.strip.length == 0
+
       CanonicalPath.new(path_to_h path)
     end
 
@@ -257,7 +258,8 @@ module Hawkular::Inventory
     end
 
     def to_tags
-      fail 'Missing feed_id' if @feed_id.nil?
+      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

data/lib/hawkular/inventory/inventory_api.rb

@@ -34,7 +34,8 @@ module Hawkular::Inventory
     #   entrypoint: http://localhost:8080/hawkular/inventory
     # and another sub-hash containing the hash with username[String], password[String], token(optional)
     def self.create(hash)
-      fail 'no parameter ":entrypoint" given' unless hash[:entrypoint]
+      fail Hawkular::ArgumentError, 'no parameter ":entrypoint" given' unless hash[:entrypoint]
+
       hash[:credentials] ||= {}
       hash[:options] ||= {}
       Client.new(hash[:entrypoint], hash[:credentials], hash[:options])
@@ -52,7 +53,8 @@ module Hawkular::Inventory
     # @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 'Feed id must be given' unless 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',
@@ -70,7 +72,8 @@ module Hawkular::Inventory
     # @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 'Feed id must be given' unless 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',
@@ -89,7 +92,8 @@ module Hawkular::Inventory
     # @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 'Feed id must be given' unless 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',
@@ -113,8 +117,9 @@ module Hawkular::Inventory
     # @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 'Feed id must be given' unless path.feed_id
-      fail 'Resource type must be given' unless path.resource_type_id
+
+      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))
@@ -151,7 +156,9 @@ module Hawkular::Inventory
     def list_child_resources(parent_res_path, recursive = false)
       path = CanonicalPath.parse_if_string(parent_res_path)
       feed_id = path.feed_id
-      fail 'Feed id must be given' unless 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
@@ -163,8 +170,10 @@ module Hawkular::Inventory
     # @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 'Feed id must be given' unless path.feed_id
-      fail 'Metric type id must be given' unless path.metric_type_id
+
+      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)
 
@@ -224,10 +233,11 @@ module Hawkular::Inventory
     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
-        exception = HawkularException.new("Resource not found: #{resource_path}")
-        fail exception
+        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
@@ -237,10 +247,11 @@ module Hawkular::Inventory
     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
-        exception = HawkularException.new("Resource type not found: #{resource_type_path}")
-        fail exception
+        fail Hawkular::Exception, "Resource type not found: #{resource_type_path}"
       end
+
       entity_hash = entity_json_to_hash(-> (_) { path }, raw_hash, false)
       ResourceType.new(entity_hash)
     end
@@ -250,10 +261,11 @@ module Hawkular::Inventory
     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
-        exception = HawkularException.new("Metric type not found: #{metric_type_path}")
-        fail exception
+        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
@@ -263,8 +275,10 @@ module Hawkular::Inventory
     # @return [Array<String>] List of operation type ids
     def list_operation_definitions(resource_type_path)
       path = CanonicalPath.parse_if_string(resource_type_path)
-      fail 'Missing feed_id in resource_type_path' unless path.feed_id
-      fail 'Missing resource_type_id in resource_type_path' unless path.resource_type_id
+
+      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,
@@ -445,26 +459,34 @@ module Hawkular::Inventory
     end
 
     def extract_structures_from_body(response_body_array)
-      response_body_array.map { |element| rebuild_from_chunks(element['data']) }
+      response_body_array.map { |element| Client.rebuild_from_chunks(element['data']) }
         .select { |full| full } # evict nil
-        .map { |full| decompress(full) }
+        .map { |full| Client.decompress(full) }
     end
 
-    def rebuild_from_chunks(data_node)
+    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']))
       end
     end
 
-    def decompress(raw)
+    def self.decompress(raw)
       gz = Zlib::GzipReader.new(StringIO.new(raw))
       JSON.parse(gz.read)
     end

data/lib/hawkular/metrics/metrics_client.rb

@@ -35,11 +35,12 @@ 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?
+      fail Hawkular::Exception, fail_version_msg if major.nil? || minor.nil?
       @legacy_api = (major == 0 && minor < 16)
     end
 

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,6 +26,7 @@ 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
 
@@ -75,26 +72,36 @@ module Hawkular::Operations
         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
 
-      creds = args[:credentials]
-      base64_creds = ["#{creds[:username]}:#{creds[:password]}"].pack('m').delete("\r\n")
+    def connect
+      return if @connecting || (@ws && @ws.open?)
+
+      @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
 
@@ -107,12 +114,14 @@ module Hawkular::Operations
         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
@@ -136,7 +145,7 @@ module Hawkular::Operations
     # 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?
+      fail Hawkular::ArgumentError, 'Operation must be specified' if operation_name.nil?
       required = [:resourcePath]
       check_pre_conditions operation_payload, required, &callback
 
@@ -297,7 +306,7 @@ module Hawkular::Operations
     # @param [String] resource_path canonical path of the WildFly server
     # @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?
+      fail Hawkular::ArgumentError, 'resource_path must be specified' if resource_path.nil?
       check_pre_conditions(&callback)
 
       invoke_specific_operation({ resourcePath: resource_path }, 'ExportJdr', &callback)
@@ -322,6 +331,8 @@ 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
@@ -332,19 +343,23 @@ module Hawkular::Operations
       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
 

data/lib/hawkular/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hawkular-client
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 4.0.0
 platform: ruby
 authors:
 - Libor Zoubek
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-04 00:00:00.000000000 Z
+date: 2017-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -145,14 +145,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.24.0
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.24.0
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: vcr
   requirement: !ruby/object:Gem::Requirement