hawkular-client 2.8.0 → 2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc8f82c57d113d57a96488d3d5537e7e20449435
-  data.tar.gz: 365a613e0f23108b62d87fbb1bf78cc0ac7db08a
+  metadata.gz: f90b7acb9dd7b68be8eee6d0bb3de9dbf7741889
+  data.tar.gz: 6949105936e1945f288c7580ac79e12bfab21138
 SHA512:
-  metadata.gz: e072263ba50864dc2c3e7a5bdcd3e4bb4975f2dde4157fa31ddcb2498d5889ed83473c76186ba20b47cb80730e9d4f803ec1f2374b82d9ca9c49a16feb299f7a
-  data.tar.gz: acd1aef7ed3c8a2282a355efd8d9e1a06b4968c5a5e113e388dadd0d8bc5a5d24e309745beaf0078d4d0db121aeaf7b9dbd8ecb3ccb622c4d15da40bfd170fc2
+  metadata.gz: 4dda4fc49377010414493c0fd44ff4ff2fd26dfaa9bd8501abdc4a786f883cfaba563c1bfec1980238d6abd548289d33f56f071372d77619e4a665b0761cc032
+  data.tar.gz: 493b2e043dede0926bee0bb65ca09f51ae8913619ace6e3dbd07985fb895ec0cef661b8ba953b1ae39d17ed81b4e754df4d318004ea17a0edc618b2851b586cd

data/.travis.yml

@@ -17,7 +17,4 @@ env:
 services:
   - docker
 before_install:
-  - (test $RUN_ON_LIVE_SERVER = 1 && docker-compose up -d && ./.travis/wait_for_services.rb) || echo "Skipping live server"
-# Lets wait a bit for the agent to load everything it needs.
-before_script:
-  - (test $RUN_ON_LIVE_SERVER = 1 && sleep 20s) || true
+  - (test $RUN_ON_LIVE_SERVER = 1 && ./.travis/start_hawkular_services.sh -d && ./.travis/wait_for_services.rb) || echo "Skipping live server"

data/.travis/start_hawkular_services.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+docker-compose up -d myCassandra
+
+# Wait for Cassandra
+CASSANDRA_STATUS="undecided"
+TOTAL_WAIT=0;
+while [ "$CASSANDRA_STATUS" != "running" ] && [ $TOTAL_WAIT -lt 60 ]; do
+ CASSANDRA_STATUS=`docker-compose exec myCassandra nodetool statusbinary | tr -dc '[[:print:]]'`
+ echo "Cassandra server status: $CASSANDRA_STATUS."
+
+ sleep 3
+
+ TOTAL_WAIT=$((TOTAL_WAIT+3))
+ echo "Waited $TOTAL_WAIT seconds for Cassandra to start."
+done
+
+# Ensure the volume exists and has correct permissions.
+mkdir -p /tmp/opt/hawkular/server
+chown 1000:1000 -R /tmp/opt/hawkular
+docker-compose up -d hawkular

data/.travis/wait_for_services.rb

@@ -1,23 +1,39 @@
 #!/usr/bin/env ruby
 require 'net/http'
+require 'json'
 
-uris = [
-  'http://localhost:8080/hawkular/status',
-  'http://localhost:8080/hawkular/metrics/status',
-  'http://localhost:8080/hawkular/alerts/status',
-  'http://localhost:8080/hawkular/inventory/status'
-]
+services = {
+  'hawkular-services' => {
+    url: 'http://localhost:8080/hawkular/status',
+    is_ready: -> (response) { response.code == '200' }
+  },
+  'metrics' => {
+    url: 'http://localhost:8080/hawkular/metrics/status',
+    is_ready: -> (response) { response.code == '200' && JSON.parse(response.body)['MetricsService'] == 'STARTED' }
+  },
+  'alerts' => {
+    url: 'http://localhost:8080/hawkular/alerts/status',
+    is_ready: -> (response) { response.code == '200' && JSON.parse(response.body)['status'] == 'STARTED' }
+  },
+  'inventory' => {
+    url: 'http://localhost:8080/hawkular/inventory/status',
+    is_ready: -> (response) { response.code == '200' && JSON.parse(response.body)['Initialized'] == 'true' }
+  }
+}
 
-uris.each do |uri_string|
+services.each do |name, service|
   loop do
-    uri = URI(uri_string)
+    uri = URI(service[:url])
     begin
       response = Net::HTTP.get_response(uri)
-      break if response.code == '200'
-      puts "Waiting for: #{uri_string}"
+      break if service[:is_ready].call(response)
+      puts "Waiting for: #{name}"
     rescue
       puts 'Waiting for Hawkular-Services to accept connections'
     end
     sleep 5
   end
 end
+puts 'Waiting 2 minutes for agent to complete it\'s first round...'
+sleep 120
+puts 'Hawkular-services started successfully... '

data/CHANGES.rdoc

@@ -3,6 +3,32 @@
 This document describes the relevant changes between releases of the
 _hawkular-client_ project.
 
+=== V 2.9.0
+* Adding a way to update collection interval on the agent
+* Fixed <code>get_entity</code> method in the inventory client
+* Big improvements to the testing suite. Now we run the tests against live Hawkular server that runs as a Docker container
+* Fixed a bug in operations client where it was necessary to pass the operation name only as a string and it silently failed with symbol
+* Alert conditions now expose also the interval field
+* Added an option to query metrics based on tag only (regardless to type)
+* Improved passing of options to underlying Rest client
+* The API is now consistent when creating resource that already existed
+* Making sure the gem can work with Alerts 1.5.1
+* Now it's unable to add/remove datasources if the Hawkular Services are running in container
+* All the sub-clients are now lazily initiated with the first usage
+* Adds the ability to assign and remove tags to existing alerts
+* Uniform client names
+
+==== Deprecations
+* instead of <code>HawkularUtilsMixin</code> use <code>Hawkular::ClientUtils</code>
+* instead of <code>Hawkular::Operations::OperationsClient</code> use <code>Hawkular::Operations::Client</code>
+* instead of <code>Hawkular::Alerts::AlertsClient</code> use <code>Hawkular::Alerts::Client</code>
+* instead of <code>Hawkular::Token::TokenClient</code> use <code>Hawkular::Token::Client</code>
+* instead of <code>Hawkular::Inventory::InventoryClient</code> use <code>Hawkular::Inventory::Client</code>
+
+Warning: in the next major version we may remove the deprecated API
+
+Full list of changes can be found at https://github.com/hawkular/hawkular-client-ruby/milestone/14?closed=1
+
 === V 2.8.0
 
 * Allow to list tags in Hawkular-Metrics

data/README.rdoc

@@ -61,6 +61,18 @@ You can also access each subproject's API individually, if you would like to use
     options: { tenant: 'hawkular' }
   )
 
+=== HTTP and HTTPS options
+
+Will all client classes, the +:options+ hash can contain extra parameters passed through to +RestClient+ gem.  It can include a +:headers+ sub-hash to add custom headers:
+
+  require 'hawkular/hawkular_client'
+  client = Hawkular::Client.new(
+    entrypoint: 'http://localhost:8080',
+    credentials: { username: 'jdoe', password: 'password' },
+    options: { tenant: 'hawkular', proxy: 'proxy.example.com', ssl_ca_file: 'ca.pem',
+               headers: {'Max-Forwards': 5} }
+  )
+
 === Examples
 
 Suppose you will monitor the availability of two networks to later determine which one is the best.
@@ -147,4 +159,3 @@ variables:
 Client documentation can be generated using http://yardoc.org
 
     yardoc
-

data/docker-compose.yml

@@ -1,15 +1,17 @@
 hawkular:
-  image: "pilhuhn/hawkular-services:latest"
+  image: "hawkular/hawkular-services:latest"
   ports:
     - "8080:8080"
     - "8443:8443"
     - "9990:9990"
   links:
     - myCassandra
+  volumes:
+    - /tmp/opt/hawkular/server:/opt/data
   environment:
     - CASSANDRA_NODES=myCassandra
     - ADMIN_TOKEN
 myCassandra:
-  image: cassandra:3.7
+  image: cassandra:3.0.9
   environment:
     - CASSANDRA_START_RPC=true

data/hawkularclient.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency('addressable')
   gem.add_development_dependency('shoulda')
   gem.add_development_dependency('rspec-rails', '~> 3.1')
+  gem.add_development_dependency('actionpack',  '~> 4')
   gem.add_development_dependency('rake', '< 11')
   gem.add_development_dependency('simple-websocket-vcr', '= 0.0.7')
   gem.add_development_dependency('yard')
@@ -34,6 +35,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency('rubocop', '= 0.34.2')
   gem.add_development_dependency('coveralls')
   gem.add_development_dependency('rack', '~> 1.6.4')
+  gem.add_development_dependency('pry-byebug')
 
   gem.rdoc_options << '--title' << gem.name <<
     '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'

data/lib/hawkular/alerts/alerts_api.rb

@@ -13,7 +13,7 @@ module Hawkular::Alerts
   #   http://localhost:8080/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
+  class Client < Hawkular::BaseClient
     def initialize(entrypoint, credentials = {}, options = {})
       entrypoint = normalize_entrypoint_url entrypoint, 'hawkular/alerts'
       @entrypoint = entrypoint
@@ -322,6 +322,22 @@ module Hawkular::Alerts
     def delete_event(id)
       http_delete "/events/#{id}"
     end
+
+    # Add tags to existing Alerts.
+    # @param [Array<numeric>] alert_ids List of alert IDs
+    # @param [Array<String>] tags List of tags. Each tag of format 'name|value'.
+    def add_tags(alert_ids, tags)
+      query = generate_query_params(alertIds: alert_ids, tags: tags)
+      http_put('/tags' + query, {})
+    end
+
+    # Remove tags from existing Alerts.
+    # @param [Array<numeric>] alert_ids List of alert IDs
+    # @param [Array<String>] tag_names List of tag names.
+    def remove_tags(alert_ids, tag_names)
+      query = generate_query_params(alertIds: alert_ids, tagNames: tag_names)
+      http_delete('/tags' + query)
+    end
   end
 
   # Representation of one Trigger
@@ -406,6 +422,7 @@ module Hawkular::Alerts
         @data2_id = cond_hash['data2Id']
         @data2_multiplier = cond_hash['data2Multiplier']
         @trigger_id = cond_hash['triggerId']
+        @interval = cond_hash['interval']
       end
 
       def to_h
@@ -420,6 +437,7 @@ module Hawkular::Alerts
         cond_hash['data2Id'] = @data2_id
         cond_hash['data2Multiplier'] = @data2_multiplier
         cond_hash['triggerId'] = @trigger_id
+        cond_hash['interval'] = @interval
         cond_hash
       end
     end
@@ -557,4 +575,7 @@ module Hawkular::Alerts
       super(event_hash)
     end
   end
+
+  AlertsClient = Client
+  deprecate_constant :AlertsClient if self.respond_to? :deprecate_constant
 end

data/lib/hawkular/base_client.rb

@@ -1,16 +1,18 @@
 require 'base64'
 require 'addressable/uri'
-require 'hawkular/hawkular_client_utils'
+
+require 'hawkular/logger'
+require 'hawkular/client_utils'
 
 module Hawkular
   # This is the base functionality for all the clients,
   # that inherit from it. You should not directly use it,
   # but through the more specialized clients.
   class BaseClient
-    include HawkularUtilsMixin
+    include ClientUtils
 
     # @!visibility private
-    attr_reader :credentials, :entrypoint, :options
+    attr_reader :credentials, :entrypoint, :options, :logger
     # @return [Tenants] access tenants API
     attr_reader :tenants
 
@@ -24,22 +26,22 @@ module Hawkular
         token: nil
       }.merge(credentials)
       @options = {
-        tenant: nil,
-        admin_token: nil,
-        ssl_ca_file: nil,
         verify_ssl: OpenSSL::SSL::VERIFY_PEER,
-        ssl_client_cert: nil,
-        ssl_client_key: nil,
-        http_proxy_uri: nil,
         headers: {}
       }.merge(options)
+      @tenant = @options.delete(:tenant)
+      @admin_token = @options.delete(:admin_token)
+
+      @logger = Hawkular::Logger.new
 
       fail 'You need to provide an entrypoint' if entrypoint.nil?
     end
 
     def http_get(suburl, headers = {})
       res = rest_client(suburl).get(http_headers(headers))
-      puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
+
+      logger.log(res)
+
       res.empty? ? {} : JSON.parse(res)
     rescue
       handle_fault $ERROR_INFO
@@ -48,7 +50,9 @@ module Hawkular
     def http_post(suburl, hash, headers = {})
       body = JSON.generate(hash)
       res = rest_client(suburl).post(body, http_headers(headers))
-      puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
+
+      logger.log(res)
+
       res.empty? ? {} : JSON.parse(res)
     rescue
       handle_fault $ERROR_INFO
@@ -57,7 +61,9 @@ module Hawkular
     def http_put(suburl, hash, headers = {})
       body = JSON.generate(hash)
       res = rest_client(suburl).put(body, http_headers(headers))
-      puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
+
+      logger.log(res)
+
       res.empty? ? {} : JSON.parse(res)
     rescue
       handle_fault $ERROR_INFO
@@ -65,7 +71,9 @@ module Hawkular
 
     def http_delete(suburl, headers = {})
       res = rest_client(suburl).delete(http_headers(headers))
-      puts "#{res}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
+
+      logger.log(res)
+
       res.empty? ? {} : JSON.parse(res)
     rescue
       handle_fault $ERROR_INFO
@@ -73,17 +81,14 @@ module Hawkular
 
     # @!visibility private
     def rest_client(suburl)
-      options[:timeout] = ENV['HAWKULARCLIENT_REST_TIMEOUT'] if ENV['HAWKULARCLIENT_REST_TIMEOUT']
-      options[:ssl_ca_file] = @options[:ssl_ca_file]
-      options[:verify_ssl] = @options[:verify_ssl]
-      options[:ssl_client_cert] = @options[:ssl_client_cert]
-      options[:ssl_client_key] = @options[:ssl_client_key]
-      options[:proxy] = @options[:http_proxy_uri]
-      options[:user] = @credentials[:username]
-      options[:password] = @credentials[:password]
+      opts = @options.dup
+      opts[:timeout] ||= ENV['HAWKULARCLIENT_REST_TIMEOUT'] if ENV['HAWKULARCLIENT_REST_TIMEOUT']
+      opts[:proxy] ||= opts.delete(:http_proxy_uri)
+      opts[:user] = @credentials[:username]
+      opts[:password] = @credentials[:password]
       # strip @endpoint in case suburl is absolute
       suburl = suburl[@entrypoint.length, suburl.length] if suburl.match(/^http/)
-      RestClient::Resource.new(@entrypoint, options)[suburl]
+      RestClient::Resource.new(@entrypoint, opts)[suburl]
     end
 
     # @!visibility private
@@ -177,7 +182,7 @@ module Hawkular
 
     def admin_header
       headers = {}
-      headers[:'Hawkular-Admin-Token'] = @options[:admin_token] unless @options[:admin_token].nil?
+      headers[:'Hawkular-Admin-Token'] = @admin_token unless @admin_token.nil?
       headers
     end
 
@@ -189,7 +194,7 @@ module Hawkular
 
     def tenant_header
       headers = {}
-      headers[:'Hawkular-Tenant'] = @options[:tenant] unless @options[:tenant].nil?
+      headers[:'Hawkular-Tenant'] = @tenant unless @tenant.nil?
       headers
     end
 

data/lib/hawkular/client_utils.rb

@@ -0,0 +1,42 @@
+module Hawkular
+  module ClientUtils
+    # Escapes the passed url part. This is necessary,
+    # as many ids inside Hawkular can contain characters
+    # that are invalid for an url/uri.
+    # The passed value is duplicated
+    # Does not escape the = character
+    # @param [String] url_part Part of an url to be escaped
+    # @return [String] escaped url_part as new string
+    def hawk_escape(url_part)
+      return url_part.to_s if url_part.is_a?(Numeric)
+
+      url_part
+        .to_s
+        .dup
+        .gsub('%', '%25')
+        .gsub(' ', '%20')
+        .gsub('[', '%5b')
+        .gsub(']', '%5d')
+        .gsub('|', '%7c')
+        .gsub('(', '%28')
+        .gsub(')', '%29')
+        .gsub('/', '%2f')
+    end
+
+    # Escapes the passed url part. This is necessary,
+    # as many ids inside Hawkular can contain characters
+    # that are invalid for an url/uri.
+    # The passed value is duplicated
+    # Does escape the = character
+    # @param [String] url_part Part of an url to be escaped
+    # @return [String] escaped url_part as new string
+    def hawk_escape_id(url_part)
+      hawk_escape(url_part)
+        .gsub('=', '%3d')
+        .gsub(';', '%3b')
+    end
+  end
+end
+
+HawkularUtilsMixin = Hawkular::ClientUtils
+deprecate_constant(:HawkularUtilsMixin) if self.respond_to?(:deprecate_constant)

data/lib/hawkular/env_config.rb

@@ -0,0 +1,15 @@
+require 'logger'
+
+module Hawkular
+  module EnvConfig
+    module_function
+
+    def log_response?
+      ENV['HAWKULARCLIENT_LOG_RESPONSE']
+    end
+
+    def rest_timeout
+      ENV['HAWKULARCLIENT_REST_TIMEOUT']
+    end
+  end
+end

data/lib/hawkular/hawkular_client.rb

@@ -1,5 +1,5 @@
 require 'hawkular/inventory/inventory_api'
-require 'hawkular/metrics/metrics_client.rb'
+require 'hawkular/metrics/metrics_client'
 require 'hawkular/alerts/alerts_api'
 require 'hawkular/tokens/tokens_api'
 require 'hawkular/operations/operations_api'
@@ -14,31 +14,15 @@ module Hawkular
       hash[:options] ||= {}
       fail 'no parameter ":entrypoint" given' if hash[:entrypoint].nil?
       @state = hash
-
-      @inventory = Inventory::InventoryClient.create(entrypoint: "#{hash[:entrypoint]}/hawkular/inventory",
-                                                     credentials: hash[:credentials],
-                                                     options: hash[:options])
-
-      @metrics = Metrics::Client.new("#{hash[:entrypoint]}/hawkular/metrics",
-                                     hash[:credentials],
-                                     hash[:options])
-
-      @alerts = Alerts::AlertsClient.new("#{hash[:entrypoint]}/hawkular/alerts",
-                                         hash[:credentials],
-                                         hash[:options])
-
-      @tokens = Token::TokenClient.new(hash[:entrypoint],
-                                       hash[:credentials],
-                                       hash[:options])
     end
 
     def method_missing(name, *args, &block)
       delegate_client = case name
-                        when /^inventory_/ then @inventory
-                        when /^metrics_/ then @metrics
-                        when /^alerts_/ then @alerts
-                        when /^operations_/ then @operations ||= init_operations_client
-                        when /^tokens_/ then @tokens
+                        when /^inventory_/ then inventory
+                        when /^metrics_/ then metrics
+                        when /^alerts_/ then alerts
+                        when /^operations_/ then operations
+                        when /^tokens_/ then tokens
                         else
                           fail "unknown method prefix `#{name}`, allowed prefixes:"\
       '`inventory_`, `metrics_`,`alerts_`,`operations_`, `tokens_`'
@@ -47,6 +31,24 @@ module Hawkular
       delegate_client.__send__(method, *args, &block)
     end
 
+    def inventory
+      @inventory ||= Inventory::Client.new("#{@state[:entrypoint]}/hawkular/inventory",
+                                           @state[:credentials],
+                                           @state[:options])
+    end
+
+    def metrics
+      @metrics ||= Metrics::Client.new("#{@state[:entrypoint]}/hawkular/metrics",
+                                       @state[:credentials],
+                                       @state[:options])
+    end
+
+    def alerts
+      @alerts ||= Alerts::Client.new("#{@state[:entrypoint]}/hawkular/alerts",
+                                     @state[:credentials],
+                                     @state[:options])
+    end
+
     # adds a way to explicitly open the new web socket connection (the default is to recycle it)
     # @param open_new [Boolean] if true, opens the new websocket connection
     def operations(open_new = false)
@@ -54,13 +56,19 @@ module Hawkular
       @operations ||= init_operations_client
     end
 
+    def tokens
+      @tokens ||= Token::Client.new(@state[:entrypoint],
+                                    @state[:credentials],
+                                    @state[:options])
+    end
+
     private
 
     # this is in a dedicated method, because constructor opens the websocket connection to make the handshake
     def init_operations_client
-      Operations::OperationsClient.new(entrypoint: @state[:entrypoint],
-                                       credentials: @state[:credentials],
-                                       options: @state[:options])
+      Operations::Client.new(entrypoint: @state[:entrypoint],
+                             credentials: @state[:credentials],
+                             options: @state[:options])
     end
   end
 end