hawkular-client 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a881d3c60a017681d81648d65397217c78f5c30f
-  data.tar.gz: 4ab68c65b422bcc0eaa5075c4ce8ac873af54d03
+  metadata.gz: b9461b58571db98a5be62adf87a4b0eecb7e817f
+  data.tar.gz: 3aa940779ef467732f5d1176a06be0194341f1d7
 SHA512:
-  metadata.gz: 2b463dbb1267dd39f7701e09491f85f5341baa29f72b492a5df090461b12a4ac8e2a934f13dcc18fa65cedae37f0f7de3d5c8b022fc13bda9c6b54adf0734996
-  data.tar.gz: 780f5436eebc3149df30ed2329b4a7ee7d1245163e10fd8078e112b266be8f43758a3f3e1cd0d636525f1f197160c201bffd187fdd2a77000bbd3a3818268a17
+  metadata.gz: 07a86f9b9b326c22dabfa8dc746a45bf5db6c3483643b85bac616bf904e07bca3f256cf97c4c8a8b2ecedbe709b1e8d2e7c62f5727ebd37633377378f614eca0
+  data.tar.gz: 0582a5844edf3bc3657f8a6e56d133b2704fa8c4b5446aceb0372b1a5852b3aeb766e4e9628d46bc5018dff3d0f283bbeaa8aaf1edc09ba9d0f476a0297d153f

data/.rubocop.yml

@@ -28,3 +28,5 @@ ModuleLength:
   Enabled: false
 Style/ClassAndModuleChildren:
   Enabled: false
+Style/BracesAroundHashParameters:
+  EnforcedStyle: context_dependent

data/CHANGES.rdoc

@@ -3,6 +3,19 @@
 This document describes the relevant changes between releases of the
 _hawkular-client_ project.
 
+=== V 2.2.0
+
+This release is needed to work with hawkular-services v0.0.5+
+
+* Support the changed api endpoint (/deprecated) for Hawkular-inventory 0.17+ along the old version
+* Add two missing fields (firing_match and auto_resolve) on Alert-triggers
+* Add distinct parameter when getting availability data points
+* Remove all defaulting/fallback to localhost:8080 in the APIs
+* Allow to fetch multiple raw data items from Hawkular-metrics in one call. Requires Metrics v0.17+
+* Corectly use the enabled flag for deployment operations
+
+Full list of items can be found at https://github.com/hawkular/hawkular-client-ruby/issues?q=milestone%3A2.2.0+is%3Aclosed
+
 === V 2.1.0
 * Fix an issue where the operations endpoint constructor expected a host to be passed, which was not.
 * Add authentication to the websocket setup in Operations sub-client.

data/README.rdoc

@@ -10,9 +10,101 @@ Documentation[http://www.hawkular.org/hawkular-client-ruby/]
 
 == Changelog
 
-See {CHANGELOG}[link:file.CHANGES.html] for a list of changes and 
+See {CHANGELOG}[link:file.CHANGES.html] for a list of changes and
 {API-Breaking-Changes}[link:file.api_breaking_changes.html] for a list of api-breaking changes.
 
+== Overview
+
+Ruby Hawkular Client provides a Ruby API to communicate with the following Hawkular subprojects:
+* {Hawkular Alerts}[https://github.com/hawkular/hawkular-alerts]
+* {Hawkular Inventory}[https://github.com/hawkular/hawkular-inventory]
+* {Hawkular Metrics}[https://github.com/hawkular/hawkular-metrics]
+* Invoking operations on {Hawkular Wildfly Agent}[https://github.com/hawkular/hawkular-agent].
+
+
+== Usage
+
+You must initialize the Hawkular Client with the server url, your username, password and tenant.
+
+  require 'hawkular/hawkular_client'
+  client = Hawkular::Client.new(
+    entrypoint: 'http://localhost:8080',
+    credentials: { username: 'jdoe', password: 'password' },
+    options: { tenant: 'hawkular' }
+  )
+
+Each subproject API is packed in its own class, which you can access through the client object.
+
+  client.alerts # Alerts API
+  client.inventory # Inventory API
+  client.metrics # Metrics API
+  client.operations # Operations API
+
+Metrics API is also subdivided to: Mixed, Availability, Counters, Gauges and Tenants.
+
+  client.metrics # Mixed API
+  client.metrics.avail # Availability
+  client.metrics.counters # Counters
+  client.metrics.gauges # Gauges
+  client.metrics.tenants # Tenants
+
+The Mixed API is capable of handling multiple types of metrics, like the
+push_data[Hawkular/Metrics/Client.html#push_data-instance_method] method, which pushes data
+for multiple metrics of all supported data.
+
+You can also access each subproject's API individually, if you would like to use only the metrics API you could do
+
+  require 'hawkular/metrics/metrics_client'
+  metrics_client = Hawkular::Metrics::Client.new(
+    entrypoint: 'http://localhost:8080/hawkular/metrics',
+    credentials: { username: 'jdoe', password: 'password' },
+    options: { tenant: 'hawkular' }
+  )
+
+=== Examples
+
+Suppose you will monitor the availability of two networks to later determine which one is the best.
+Every certain time, you would get the availability of each network and push them to Hawkular Metrics.
+
+  # ... Initialize client ...
+  is_network01_available = true
+  is_network02_available = false
+  client.metrics.push_data(availabilities: [
+    { id: 'network-01', data: [{ value: is_network01_available ?  'up' : 'down' }] },
+    { id: 'network-02', data: [{ value: is_network02_available ?  'up' : 'down' }] }
+  ])
+
+At some other point you might want to access that data to analyze it
+
+  # ... Initialize client ...
+  # Fetches the 5 last availabilities reported in the last 8 hours.
+  network01_avail = client.metrics.avail.get_data('network-01', limit: 5, order: 'DESC')
+  network02_avail = client.metrics.avail.get_data('network-02', limit: 5, order: 'DESC')
+  # ... Do something with the availabilities ...
+
+Each network01_avail will be an array like:
+
+  [
+    { "timestamp" => 1467312571473, "value" => "up" },
+    { "timestamp" => 1467312492650, "value" => "up" },
+    # ...
+  ]
+
+You can get more info on the other parameters by checking the metrics API get_data[Hawkular/Metrics/Client/Metrics#get_data-instance_method]
+
+=== More info
+
+Check each resource API for a detailed description of what methods are available.
+* Alerts[Hawkular/Alerts/AlertsClient.html]
+* Inventory[Hawkular/Inventory/InventoryClient.html]
+* Metrics:
+  * Mixed[Hawkular/Metrics/Client.html]
+  * Availability[Hawkular/Metrics/Client/Availability.html]
+  * Counters[Hawkular/Metrics/Client/Counters.html]
+  * Gauges[Hawkular/Metrics/Client/Gauges.html]
+  * Tenants[Hawkular/Metrics/Client/Tenants.html]
+* Operations[Hawkular/Operations/OperationsClient.html]
+
 == Contributing to hawkular-client-ruby
 
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
@@ -20,7 +112,7 @@ See {CHANGELOG}[link:file.CHANGES.html] for a list of changes and
 * Fork the project
 * Start a feature/bugfix branch
 * Commit and push until you are happy with your contribution
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Make sure to add tests for it. This is important so it won't break in a future version unintentionally.
 * Run your code through RuboCop (which is default when running +rake+) and fix complaints.
 * When you open a pull request, watch out for failures on Travis.
 * Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is

data/hawkularclient.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency('vcr')
   gem.add_development_dependency('rubocop', '= 0.34.2')
   gem.add_development_dependency('coveralls')
+  gem.add_development_dependency('rack', '~> 1.6.4')
 
   gem.rdoc_options << '--title' << gem.name <<
     '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'

data/lib/hawkular/alerts/alerts_api.rb

@@ -14,7 +14,8 @@ module Hawkular::Alerts
   # @param credentials [Hash{String=>String}] Hash of username, password, token(optional)
   # @param options [Hash{String=>String}] Additional rest client options
   class AlertsClient < Hawkular::BaseClient
-    def initialize(entrypoint = 'http://localhost:8080/hawkular/alerts', credentials = {}, options = {})
+    def initialize(entrypoint, credentials = {}, options = {})
+      entrypoint = normalize_entrypoint_url entrypoint, 'hawkular/alerts'
       @entrypoint = entrypoint
 
       super(entrypoint, credentials, options)
@@ -329,7 +330,7 @@ module Hawkular::Alerts
     attr_accessor :auto_resolve, :auto_resolve_alerts, :tags, :type
     attr_accessor :tenant, :description, :group, :severity, :event_type, :event_category, :member_of, :data_id_map
     attr_reader :conditions, :dampenings
-    attr_accessor :enabled, :actions
+    attr_accessor :enabled, :actions, :firing_match, :auto_resolve_match
 
     def initialize(trigger_hash)
       return if trigger_hash.nil?
@@ -355,6 +356,8 @@ module Hawkular::Alerts
       @context = trigger_hash['context']
       @type = trigger_hash['type']
       @tags = trigger_hash['tags']
+      @firing_match = trigger_hash['firingMatch']
+      @auto_resolve_match = trigger_hash['autoResolveMatch']
       # acts = trigger_hash['actions']
       # acts.each { |a| @actions.push(Action.new(a)) } unless acts.nil?
     end
@@ -366,7 +369,8 @@ module Hawkular::Alerts
         ret[0, 1].downcase + ret[1..-1]
       end
       fields = [:id, :name, :enabled, :severity, :auto_resolve, :auto_resolve_alerts, :event_type, :event_category,
-                :description, :auto_enable, :auto_disable, :context, :type, :tags, :member_of, :data_id_map]
+                :description, :auto_enable, :auto_disable, :context, :type, :tags, :member_of, :data_id_map,
+                :firing_match, :auto_resolve_match]
 
       fields.each do |field|
         camelized_field = to_camel.call(field)

data/lib/hawkular/base_client.rb

@@ -127,6 +127,28 @@ module Hawkular
       end
     end
 
+    # Generate a new url with the passed sufix path if the path is not already added
+    # also, this function always remove the slash at the end of the URL, so if your entrypoint is
+    # http://localhost/hawkular/inventory/ this function will return http://localhost/hawkular/inventory
+    # to the URL
+    # @param entrypoint [String] base path
+    # @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)
+      strip_path = suffix_path.gsub(%r{/$}, '')
+      strip_path.nil? || suffix_path = strip_path
+      strip_path = suffix_path.gsub(%r{^/}, '')
+      strip_path.nil? || suffix_path = strip_path
+      strip_entrypoint = entrypoint.gsub(%r{/$}, '')
+      strip_path.nil? && strip_entrypoint = entrypoint
+      relative_path_rgx = Regexp.new("\/#{Regexp.quote(suffix_path)}(\/)*$")
+      if relative_path_rgx.match(entrypoint)
+        strip_entrypoint
+      else
+        "#{strip_entrypoint}/#{suffix_path}"
+      end
+    end
+
     # Specialized exception to be thrown
     # when the interaction with Hawkular fails
     class HawkularException < StandardError

data/lib/hawkular/hawkular_client.rb

@@ -10,9 +10,9 @@ module Hawkular
     attr_reader :inventory, :metrics, :alerts, :operations, :tokens, :state
 
     def initialize(hash)
-      hash[:entrypoint] ||= 'http://localhost:8080'
       hash[:credentials] ||= {}
       hash[:options] ||= {}
+      fail 'no parameter ":entrypoint" given' if hash[:entrypoint].nil?
       @state = hash
 
       @inventory = Inventory::InventoryClient.create(entrypoint: "#{hash[:entrypoint]}/hawkular/inventory",

data/lib/hawkular/inventory/inventory_api.rb

@@ -16,8 +16,25 @@ module 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/inventory'
       @entrypoint = entrypoint
       super(entrypoint, credentials, options)
+      version = fetch_version_and_status['Implementation-Version']
+      major, minor = version.scan(/\d+/).map(&:to_i)
+      @entrypoint << '/deprecated' unless major == 0 && minor < 17
+    end
+
+    def fetch_version_and_status
+      if @entrypoint.end_with? '/deprecated'
+        begin
+          backup_entrypoint = @entrypoint
+          @entrypoint = @entrypoint[0...-'/deprecated'.size]
+          return http_get('/status')
+        ensure
+          @entrypoint = backup_entrypoint
+        end
+      end
+      http_get('/status')
     end
 
     # Creates a new Inventory Client
@@ -25,7 +42,7 @@ 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)
-      hash[:entrypoint] ||= 'http://localhost:8080/hawkular/inventory'
+      fail 'no parameter ":entrypoint" given' if hash[:entrypoint].nil?
       hash[:credentials] ||= {}
       hash[:options] ||= {}
       InventoryClient.new(hash[:entrypoint], hash[:credentials], hash[:options])

data/lib/hawkular/metrics/metric_api.rb

@@ -124,9 +124,19 @@ module Hawkular::Metrics
                    order: nil)
         params = { start: starts, end: ends, bucketDuration: bucketDuration, buckets: buckets,
                    percentiles: percentiles, limit: limit, order: order }
-        resp = @client.http_get("/#{@resource}/#{ERB::Util.url_encode(id)}/data/?" +
-                 encode_params(params))
-        resp.is_a?(Array) ? resp : [] # API returns no content (empty Hash) instead of empty array
+        get_data_helper(id, params)
+      end
+
+      # Retrieve raw data for multiple metrics.
+      # @param ids [Array[String]] metric definition ids
+      # @param starts [Integer] optional timestamp (default now - 8h)
+      # @param ends [Integer] optional timestamp (default now)
+      # @param limit [Integer] optional limit the number of data points returned
+      # @param order [String] optional Data point sort order, based on timestamp (ASC, DESC)
+      # @return [Array[Hash]] named datapoints
+      def raw_data(ids, starts: nil, ends: nil, limit: nil, order: nil)
+        params = { ids: ids, start: starts, end: ends, limit: limit, order: order }
+        @client.http_post("/#{@resource}/raw/query", params)
       end
 
       # Retrieve metric datapoints by tags
@@ -150,6 +160,14 @@ module Hawkular::Metrics
       def encode_params(params)
         URI.encode_www_form(params.select { |_k, v| !v.nil? })
       end
+
+      private
+
+      def get_data_helper(id, params)
+        resp = @client.http_get("/#{@resource}/#{ERB::Util.url_encode(id)}/data/?" +
+          encode_params(params))
+        resp.is_a?(Array) ? resp : [] # API returns no content (empty Hash) instead of empty array
+      end
     end
 
     # Class that interacts with "gauge" metric types
@@ -204,6 +222,24 @@ module Hawkular::Metrics
       def initialize(client)
         super(client, 'availability', 'availability')
       end
+
+      # Retrieve metric datapoints
+      # @param id [String] metric definition id
+      # @param starts [Integer] optional timestamp (default now - 8h)
+      # @param ends [Integer] optional timestamp (default now)
+      # @param buckets [Integer] optional desired number of buckets over the specified timerange
+      # @param bucketDuration [String] optional interval (default no aggregation)
+      # @param distinct [String] optional set to true to return only distinct, contiguous values
+      # @param limit [Integer] optional limit the number of data points returned
+      # @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)
+        params = { start: starts, end: ends, bucketDuration: bucketDuration, buckets: buckets,
+                   distinct: distinct, limit: limit, order: order }
+        get_data_helper(id, params)
+      end
     end
   end
 end

data/lib/hawkular/metrics/metrics_client.rb

@@ -38,10 +38,10 @@ module Hawkular::Metrics
     #     {username:"username",password:"password"},
     #                          {"tenant" => "your tenant ID"})
     #
-    def initialize(entrypoint = 'http://localhost:8080/hawkular/metrics',
+    def initialize(entrypoint,
                    credentials = {},
                    options = {})
-
+      entrypoint = normalize_entrypoint_url entrypoint, 'hawkular/metrics'
       super(entrypoint, credentials, options)
       @tenants = Client::Tenants.new self
       @counters = Client::Counters.new self

data/lib/hawkular/operations/operations_api.rb

@@ -134,7 +134,7 @@ module Hawkular::Operations
     #
     # @param callback [Block] callback that is run after the operation is done
     def add_deployment(hash, &callback)
-      hash[:enabled] ||= true
+      hash[:enabled] = hash.key?(:enabled) ? hash[:enabled] : true
       required = [:resource_path, :destination_file_name, :binary_content]
       check_pre_conditions hash, required, &callback
 

data/lib/hawkular/tokens/tokens_api.rb

@@ -8,7 +8,7 @@ module Hawkular::Token
     # @param entrypoint [String] base url of Hawkular - e.g http://localhost:8080
     # @param credentials [Hash{String=>String}] Hash of username, password
     # @param options [Hash{String=>String}] Additional rest client options
-    def initialize(entrypoint = 'http://localhost:8080', credentials = {}, options = {})
+    def initialize(entrypoint, credentials = {}, options = {})
       super(entrypoint, credentials, options)
     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.1.0'
+  VERSION = '2.2.0'
 end

data/spec/integration/alerts_spec.rb

@@ -4,10 +4,11 @@ require "#{File.dirname(__FILE__)}/../spec_helper"
 module Hawkular::Alerts::RSpec
   ALERTS_BASE = 'http://localhost:8080/hawkular/alerts'
   creds = { username: 'jdoe', password: 'password' }
+  options = { tenant: 'hawkular' }
 
   describe 'Alert/Triggers', 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 List Triggers' do
@@ -115,6 +116,45 @@ module Hawkular::Alerts::RSpec
       end
     end
 
+    it 'Should create a firing ALL_ANY trigger' do
+      # Create the trigger
+      t = Hawkular::Alerts::Trigger.new({})
+      t.enabled = true
+      t.id = 'my-cool-trigger'
+      t.name = 'Just a trigger'
+      t.severity = :HIGH
+      t.description = 'Just a test trigger'
+
+      begin
+        ft = @client.create_trigger t, [], nil
+        expect(ft).not_to be_nil
+
+        trigger = @client.get_single_trigger t.id, true
+        expect(trigger.firing_match).to eq('ALL')
+        expect(trigger.auto_resolve_match).to eq('ALL')
+
+        @client.delete_trigger(t.id)
+
+        t.firing_match = :ANY
+        t.auto_resolve_match = :ANY
+
+        ft = @client.create_trigger t, [], nil
+        expect(ft).not_to be_nil
+
+        trigger = @client.get_single_trigger t.id, true
+        expect(trigger.firing_match).to eq('ANY')
+        expect(trigger.auto_resolve_match).to eq('ANY')
+      ensure
+        # rubocop:disable Lint/HandleExceptions
+        begin
+          @client.delete_trigger(t.id)
+        rescue
+          # I am not interested
+        end
+        # rubocop:enable Lint/HandleExceptions
+      end
+    end
+
     it 'Should get the action definitions' do
       ret = @client.get_action_definition
       expect(ret.size).to be(2)

data/spec/integration/hawkular_client_spec.rb

@@ -4,13 +4,18 @@ require 'securerandom'
 
 # examples that tests the main client which delegates all the calls to Hawkular component clients
 module Hawkular::Client::RSpec
+  HOST = 'http://localhost:8080'
+
   describe 'HawkularClient' do
     before(:all) do
       @creds = {
         username: 'jdoe',
         password: 'password'
       }
-      @hawkular_client = Hawkular::Client.new(credentials: @creds)
+      ::RSpec::Mocks.with_temporary_scope do
+        mock_inventory_client
+        @hawkular_client = Hawkular::Client.new(entrypoint: HOST, credentials: @creds)
+      end
       @state = {
         hostname: 'localhost.localdomain',
         feed: nil
@@ -28,7 +33,10 @@ module Hawkular::Client::RSpec
 
     context 'and Inventory client', vcr: { decode_compressed_response: true } do
       before(:all) do
-        @client = Hawkular::Inventory::InventoryClient.create(credentials: @creds)
+        ::RSpec::Mocks.with_temporary_scope do
+          mock_inventory_client
+          @client = Hawkular::Inventory::InventoryClient.create(entrypoint: HOST, credentials: @creds)
+        end
       end
 
       it 'Should list the same feeds' do
@@ -93,7 +101,7 @@ module Hawkular::Client::RSpec
       include Hawkular::Metrics::RSpec
 
       before(:all) do
-        @client = Hawkular::Metrics::Client.new('http://localhost:8080/hawkular/metrics', @creds)
+        @client = Hawkular::Metrics::Client.new(HOST, @creds)
       end
 
       it 'Should both work the same way when pushing metric data to non-existing counter' do
@@ -188,7 +196,7 @@ module Hawkular::Client::RSpec
           }
 
           actual_data = {}
-          client = Hawkular::Operations::OperationsClient.new(entrypoint: 'http://localhost:8080', credentials: @creds)
+          client = Hawkular::Operations::OperationsClient.new(entrypoint: HOST, credentials: @creds)
           client.invoke_generic_operation(redeploy) do |on|
             on.success do |data|
               actual_data[:data] = data