hawkular-client 2.2.1 → 2.3.0

data/lib/hawkular/metrics/metric_api.rb

@@ -34,9 +34,10 @@ module Hawkular::Metrics
       gauges.each { |g| default_timestamp g[:data] }
       counters.each { |g| default_timestamp g[:data] }
       availabilities.each { |g| default_timestamp g[:data] }
-
       data = { gauges: gauges, counters: counters, availabilities: availabilities }
-      http_post('/metrics/data', data)
+      path = '/metrics/'
+      @legacy_api ? path << 'data' : path << 'raw'
+      http_post(path, data)
     end
 
     # Base class for accessing metric definition and data of all
@@ -50,6 +51,7 @@ module Hawkular::Metrics
         @client = client
         @type = metric_type
         @resource = resource
+        @legacy_api = client.legacy_api
       end
 
       # Create new  metric definition
@@ -79,14 +81,15 @@ module Hawkular::Metrics
       # @param id [String]
       # @return [MetricDefinition]
       def get(id)
-        the_id = @client.hawk_escape id
+        the_id = ERB::Util.url_encode id
         Hawkular::Metrics::MetricDefinition.new(@client.http_get("/#{@resource}/#{the_id}"))
       end
 
       # update tags for given metric definition
       # @param metric_definition [MetricDefinition]
       def update_tags(metric_definition)
-        @client.http_put("/#{@resource}/#{metric_definition.id}/tags", metric_definition.hash[:tags])
+        metric_definition_id = ERB::Util.url_encode metric_definition.id
+        @client.http_put("/#{@resource}/#{metric_definition_id}/tags", metric_definition.hash[:tags])
       end
 
       # Push metric data
@@ -104,9 +107,10 @@ module Hawkular::Metrics
       #                                        {:value => 99.9, :tags => {:tagName => "myMax"}}])
       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'
         @client.default_timestamp data
-        @client.http_post("/#{@resource}/#{id}/data", data)
+        @client.http_post(uri, data)
       end
 
       # Retrieve metric datapoints
@@ -149,7 +153,9 @@ module Hawkular::Metrics
       def get_data_by_tags(tags, starts: nil, ends: nil, bucketDuration: nil)
         params = { tags: tags_param(tags), start: starts,
                    end: ends, bucketDuration: bucketDuration }
-        resp = @client.http_get("/#{@resource}/data/?" + encode_params(params))
+        path = "/#{@resource}/"
+        @legacy_api ? path << 'data/?' : path << '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
 
@@ -164,8 +170,14 @@ module Hawkular::Metrics
       private
 
       def get_data_helper(id, params)
-        resp = @client.http_get("/#{@resource}/#{ERB::Util.url_encode(id)}/data/?" +
-          encode_params(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 << encode_params(params)
+        resp = @client.http_get(path)
         resp.is_a?(Array) ? resp : [] # API returns no content (empty Hash) instead of empty array
       end
     end
@@ -189,7 +201,7 @@ module Hawkular::Metrics
       #   client.gauges.get_periods("gauge1", starts: before4h, threshold: 10, operation: "lte")
       def get_periods(id, starts: nil, ends: nil, threshold: nil, operation: nil)
         params = { start: starts, end: ends, threshold: threshold, op: operation }
-        @client.http_get("/#{@resource}/#{id}/periods?" + encode_params(params))
+        @client.http_get("/#{@resource}/#{ERB::Util.url_encode(id)}/periods?" + encode_params(params))
       end
     end
 
@@ -209,6 +221,7 @@ module Hawkular::Metrics
       # @return [Array[Hash]] rate points
       def get_rate(id, starts: nil, ends: nil, bucket_duration: nil)
         path = "/#{@resource}/#{ERB::Util.url_encode(id)}/rate"
+        path << '/stats' unless bucket_duration.nil? && @legacy_api
         params = { start: starts, end: ends, bucketDuration: bucket_duration }
         resp = @client.http_get(path + '?' + encode_params(params))
         # API returns no content (empty Hash) instead of empty array

data/lib/hawkular/metrics/metrics_client.rb

@@ -28,6 +28,19 @@ module Hawkular::Metrics
     # @return [Availability] access counters API
     attr_reader :avail
 
+    # @return [boolean] if it's using the legacy API or not
+    attr_reader :legacy_api
+
+    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?
+      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)
+    end
+
     # Construct a new Hawkular Metrics client class.
     # optional parameters
     # @param entrypoint [String] Base url of the Hawkular (metrics) server
@@ -43,6 +56,7 @@ module Hawkular::Metrics
                    options = {})
       entrypoint = normalize_entrypoint_url entrypoint, 'hawkular/metrics'
       super(entrypoint, credentials, options)
+      check_version
       @tenants = Client::Tenants.new self
       @counters = Client::Counters.new self
       @gauges = Client::Gauges.new self

data/lib/hawkular/operations/operations_api.rb

@@ -4,6 +4,8 @@ require 'json'
 
 # Adding a method `perform` for each block so that we can write nice callbacks for this client
 class Proc
+  class PerformMethodMissing
+  end
   def perform(callable, result)
     call(Class.new do
       method_name = callable.to_sym
@@ -13,7 +15,7 @@ class Proc
       # rubocop:disable Lint/NestedMethodDefinition
       # https://github.com/bbatsov/rubocop/issues/2704
       def method_missing(_method_name, *_args, &_block)
-        false
+        PerformMethodMissing
       end
       # rubocop:enable Lint/NestedMethodDefinition
     end.new)
@@ -215,7 +217,11 @@ module Hawkular::Operations
       fail 'callback must have the perform method defined. include Hawkular::Operations' unless
           callback.nil? || callback.respond_to?('perform')
       params.each do |property|
-        fail "Hash property #{property} must be specified" if hash[property].nil?
+        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
       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 = '2.2.1'
+  VERSION = '2.3.0'.freeze
 end

data/spec/README.rdoc

@@ -0,0 +1,62 @@
+= Test suite
+Read me if you want more information about the test suite and VCR cassettes.
+
+== Running all the tests
+
+   bundle exec rake test
+or shorter
+   rspec 
+
+== Running individual tests
+
+Run all the tests for metrics
+   rspec ./spec/integration/metric_spec.rb
+   
+Run one particular test:
+that starts on line 74
+   rspec ./spec/integration/metric_spec.rb:74
+   
+that contains a description 'push metric data to existing counter'
+   rspec -e 'push metric data to existing counter' ./spec/integration/metric_spec.rb:74
+
+== VCRs
+By default, all the interaction over HTTP is done via the VCR testing suite. So no real calls to the server side are made, but the communication is read from +.yml+ files, called cassettes. This allows the whole testsuite to run very quickly, whitout the need for the server to be up. Obviously, the drawback is that the data may be stale. To re-record the VCR cassettes, one can run the +rspec+ with environment property <code>VCR_UPDATE=1</code>.
+
+For inventory and metrics specs, there is a support for templating the VCR cassettes. This means that some data that vary in different hawkular-services server starts may be parametrized, because there is no point in checking if the +feed_id+ is really the desired uuid or the timestamp is really the xyz. Good thing about it is that when re-recording the cassette and the api is the same, it'll remain the same up to the minor stuff like +recorded_at:+ fields. An example of the VCR template can be seen {here}[link:https://git.io/vKm99]. This is all done under the hood by using the around interceptors ({here}[link:https://git.io/vKmHE] and {here}[link:https://git.io/vKmH7]) and the helper methods in +spec_helper.rb+.
+
+Parametrization of the cassette is basically replacing the raw data in it by its reference, so for instance following pseudo-code:
+
+   parametrize('Hello, asdfasdf', {id: 'asdfasdf'})
+
+would provide
+   Hello, <%= id%>
+in the resulting cassette.
+
+For inventory, the data that is parametrized in the VCR cassettes needs to be in the +@state+ hash, while for the metrics it's only the +@random_id+ field that's an random (for each test case) uuid. This will be probably unified in the future and will be the same across all the components.
+
+ If you need to override the default behavior and use your own data during the parametrization, this can be done the following way (https://git.io/vKmQF): 
+ 
+   it 'Should push metric data to existing gauge', :skip_auto_vcr do
+     now = @client.now
+     ends = now - t4h
+     starts = now - (2 * t4h)
+     ...
+     bindings = { id: @random_id, ends: ends, starts: starts, ... }
+     example = proc do
+       # do all the asserts
+     end
+     record("Metrics/#{metrics_context}", bindings, cassette_name, example: example)
+   end
+
+In the example above, whenever the values of +starts+, +ends+ or +@random_id+ appear in the cassette, it'll be replaced by its reference => parametrized. This process is done only if the <code>VCR_UPDATE=1</code> is passed to the +rspec+. Otherwise, the templates will be just used (not created). This allows the fact that one template can be used for whole set of different calls if we abstract from the (volatile) data that doesn't matter, like generated ids or timestamps.
+
+=== Metrics VCRs
+Currently, the metrics sub-client is special, because we keep the VCR cassettes for +hawkular-metrics+ in version <code>0.8.0.Final</code> as well as for metrics that are part of the hawkular-services. Thus, there is a support for so called "metric contexts" in the {spec file}[https://git.io/vKmBa]. By default, all the test-suite is run for all the metric contexts. Some tests can have a tag on them that they make sense only for certain context. This is done by using the <code>run_for: [services_context] </code> tag (see {example}[https://git.io/vKm5M]). If it's omitted, the test case is meant to run in all the contexts.
+
+When re-recording the templates, it's handy to update only one metrics context. To do that, you can use the env variables:
+   SKIP_V8_METRICS=1
+or
+   SKIP_SERVICES_METRICS=1
+To skip the suite for v8 metrics or the services one, respectively.
+
+Good thing about this approach is that we can store the historical data in its own directories and not override over and over the some methods and end up with an inconsistent state, where some methods are captured in state +t+ and some in state <code>t+1</code>. Here is how it looks like: https://git.io/vKmdb In the future, we will be fixing also the version of the hawkular-services.

data/spec/integration/alerts_spec.rb

@@ -208,7 +208,7 @@ module Hawkular::Alerts::RSpec
 
   describe 'Alert/Groups', vcr: { decode_compressed_response: true } do
     before(:each) do
-      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
     end
 
     it 'Should operate a complex group trigger' do
@@ -391,7 +391,7 @@ module Hawkular::Alerts::RSpec
 
   describe 'Alert/Alerts', :vcr do
     it 'Should list alerts' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
 
       alerts = client.list_alerts
 
@@ -400,7 +400,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should list alerts for trigger' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
 
       alerts = client.get_alerts_for_trigger '75bfdd05-d03d-481e-bf32-c724c7719d8b~Local_jvm_pheap'
 
@@ -409,7 +409,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should list alerts for unknown trigger' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
 
       alerts = client.get_alerts_for_trigger 'does-not-exist'
 
@@ -418,7 +418,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should fetch single alert' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
 
       alert = client.get_single_alert(
         '28026b36-8fe4-4332-84c8-524e173a68bf-snert~Local_jvm_garba-1446977734134')
@@ -429,7 +429,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should resolve an alert' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
 
       alert_id = '28026b36-8fe4-4332-84c8-524e173a68bf-snert~Local_jvm_garba-1446977734134'
       alert = client.get_single_alert alert_id
@@ -452,7 +452,7 @@ module Hawkular::Alerts::RSpec
     #     end
 
     it 'Should acknowledge an alert' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
 
       alert_id = '28026b36-8fe4-4332-84c8-524e173a68bf-snert~Local_jvm_garba-1446977734134'
       client.get_single_alert alert_id
@@ -483,7 +483,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should list events' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
 
       events = client.list_events('thin' => true)
 
@@ -496,7 +496,7 @@ module Hawkular::Alerts::RSpec
       start_time = (now - 7_200) * 1000
       end_time = now * 1000
 
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
 
       events = client.list_events('startTime' => start_time, 'endTime' => end_time)
 
@@ -505,7 +505,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should not list events using criteria' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
 
       events = client.list_events('startTime' => 0, 'endTime' => 1000)
 
@@ -519,7 +519,7 @@ module Hawkular::Alerts::RSpec
                        erb: { id: the_id }, record: :none,
                        decode_compressed_response: true
                       ) do
-        client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+        client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
 
         the_event = client.create_event(the_id, 'MyCategory', 'Li la lu',
                                         context: { message: 'This is a test' },
@@ -533,7 +533,7 @@ module Hawkular::Alerts::RSpec
 
   describe 'Alert/EndToEnd', vcr: { decode_compressed_response: true } do
     before(:each) do
-      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
     end
 
     it 'Should create and fire a trigger' do
@@ -598,8 +598,12 @@ module Hawkular::Alerts::RSpec
         expect(trigger.dampenings.size).to be(0)
 
         # Trigger is set up - send a metric value to trigger it.
-        metric_client = Hawkular::Metrics::Client.new('http://localhost:8080/hawkular/metrics',
-                                                      creds)
+        metric_client = nil
+        ::RSpec::Mocks.with_temporary_scope do
+          mock_metrics_version
+          metric_client = Hawkular::Metrics::Client.new('http://localhost:8080/hawkular/metrics',
+                                                        creds, options)
+        end
 
         data_point = { timestamp: Time.now.to_i * 1000, value: 42 }
         data = [{ id: 'my-metric-id1', data: [data_point] }]

data/spec/integration/hawkular_client_spec.rb

@@ -13,8 +13,9 @@ module Hawkular::Client::RSpec
         password: 'password'
       }
       ::RSpec::Mocks.with_temporary_scope do
-        mock_inventory_client
-        @hawkular_client = Hawkular::Client.new(entrypoint: HOST, credentials: @creds)
+        mock_inventory_client '0.17.2.Final'
+        mock_metrics_version
+        @hawkular_client = Hawkular::Client.new(entrypoint: HOST, credentials: @creds, options: { tenant: 'hawkular' })
       end
       @state = {
         hostname: 'localhost.localdomain',
@@ -22,6 +23,18 @@ module Hawkular::Client::RSpec
       }
     end
 
+    it 'Should err on bad credentials' do
+      VCR.use_cassette('HawkularClient/Should err on bad credentials') do
+        @creds = {
+          username: '-XX-X-jdoe-X',
+          password: 'password'
+        }
+        expect do
+          Hawkular::Client.new(entrypoint: HOST, credentials: @creds)
+        end.to raise_error(Hawkular::BaseClient::HawkularException, 'Unauthorized')
+      end
+    end
+
     it 'Should fail when calling method with unknown prefix' do
       expect { @hawkular_client.ynventori_list_feeds }.to raise_error(RuntimeError)
       expect { @hawkular_client.list_feeds }.to raise_error(RuntimeError)
@@ -29,39 +42,50 @@ module Hawkular::Client::RSpec
 
     it 'Should fail when calling unknown method with known client prefix' do
       expect { @hawkular_client.inventory_lyst_feeds }.to raise_error(NoMethodError)
+      expect { @hawkular_client.metrics_lyst_feeds }.to raise_error(NoMethodError)
+      expect { @hawkular_client.alerts_lyst_feeds }.to raise_error(NoMethodError)
+      expect { @hawkular_client.tokens_lyst_feeds }.to raise_error(NoMethodError)
     end
 
     context 'and URIs as input', vcr: { decode_compressed_response: true } do
       it 'Should work with URI' do
         uri = URI.parse HOST
         opts = { tenant: 'hawkular' }
-
-        the_client = Hawkular::Client.new(entrypoint: uri, credentials: @creds, options: opts)
-        expect { the_client.inventory.list_feeds }.to_not raise_error
+        ::RSpec::Mocks.with_temporary_scope do
+          mock_metrics_version
+          the_client = Hawkular::Client.new(entrypoint: uri, credentials: @creds, options: opts)
+          expect { the_client.inventory.list_feeds }.to_not raise_error
+        end
       end
 
       it 'Should work with URI on metrics client' do
         uri = URI.parse HOST
         opts = { tenant: 'hawkular' }
-
-        the_client = Hawkular::Metrics::Client.new(uri, @creds, opts)
-        expect { the_client.http_get '/status' }.to_not raise_error
+        ::RSpec::Mocks.with_temporary_scope do
+          mock_metrics_version
+          the_client = Hawkular::Metrics::Client.new(uri, @creds, opts)
+          expect { the_client.http_get '/status' }.to_not raise_error
+        end
       end
 
       it 'Should work with https URI on metrics client' do
         uri = URI.parse 'https://localhost:8080'
         opts = { tenant: 'hawkular' }
-
-        the_client = Hawkular::Metrics::Client.new(uri, @creds, opts)
-        expect !the_client.nil?
+        ::RSpec::Mocks.with_temporary_scope do
+          mock_metrics_version
+          the_client = Hawkular::Metrics::Client.new(uri, @creds, opts)
+          expect !the_client.nil?
+        end
       end
     end
 
     context 'and Inventory client', vcr: { decode_compressed_response: true } do
       before(:all) do
         ::RSpec::Mocks.with_temporary_scope do
-          mock_inventory_client
-          @client = Hawkular::Inventory::InventoryClient.create(entrypoint: HOST, credentials: @creds)
+          mock_inventory_client '0.17.2.Final'
+          @client = Hawkular::Inventory::InventoryClient.create(entrypoint: HOST,
+                                                                credentials: @creds,
+                                                                options: { tenant: 'hawkular' })
         end
       end
 
@@ -127,7 +151,10 @@ module Hawkular::Client::RSpec
       include Hawkular::Metrics::RSpec
 
       before(:all) do
-        @client = Hawkular::Metrics::Client.new(HOST, @creds)
+        ::RSpec::Mocks.with_temporary_scope do
+          mock_metrics_version
+          @client = Hawkular::Metrics::Client.new(HOST, @creds)
+        end
       end
 
       it 'Should both work the same way when pushing metric data to non-existing counter' do
@@ -253,6 +280,18 @@ module Hawkular::Client::RSpec
         end
       end
 
+      it 'Should work initializing with URI' do
+        uri = URI.parse HOST
+        opts = { tenant: 'hawkular' }
+        WebSocketVCR.record(example, self) do
+          ::RSpec::Mocks.with_temporary_scope do
+            mock_metrics_version
+            the_client = Hawkular::Client.new(entrypoint: uri, credentials: @creds, options: opts)
+            expect { the_client.operations }.to_not raise_error
+          end
+        end
+      end
+
       xit 'Should both reuse the websocket connection', :websocket do
         WebSocketVCR.record(example, self) do
         end