hawkular-client 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c23ea869e11663cc37756be45e49485350ecc024
-  data.tar.gz: 1e236ca10f3b38f3c564bd1578dffa86dfe7b707
+  metadata.gz: ed7c1be5e375b0389cf9a4849fb45c78641becd0
+  data.tar.gz: 03c792250b1ba9ed81c25f9ecda174b983c843e2
 SHA512:
-  metadata.gz: a285669dc4d93f4960c5ffddc54b8636a792022c191b571723442acd905300288807342accd267fbaab701461942e070365fd2a4611dae52165a377c52a44e0e
-  data.tar.gz: ab8cec50610495c531c5e99c987a88df56cc36b71c1b02eb4922b533c347de364343e97faf410e1c56895d3f778e9a8a8e547eae05892f243d979a7418e50b6d
+  metadata.gz: b5b8f44790e31b63e0574a4d09b510de537275f121d88e93712e24fc33c1e7543ace9e9539f1beb410ff70f1fce8148edee7b4b7431601d7341407f820d4c05c
+  data.tar.gz: b77f46b103e59f10d7568dd1c96de81399192a01fe1fef2038d0f3635fbb8d1a545bcedc785b52bf60cbfea0d29a94eaa2a92f39b7e20f7c6e166057d770bd97

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
 rvm:
-  - 2.0.0
-#  - 1.9.3
-#  - jruby-19mode
+  - 2.0
+  - 2.1
+  - 2.2

data/CHANGES.rdoc

@@ -3,6 +3,14 @@
 This document describes the relevant changes beween releases of the
 _hawkular-client_ project.
 
+=== V 0.2.0
+
+* Add support for Hawkular-Inventory and Hawkular-Alerts
+* Reshuffeling of inner classes
+* The sub-url that is passed to `http_*` methods is escaped via
+  `Addressable::URI.escape()`
+
+
 === V 0.1.2
 
 * Fix exception handling - this was missing `require 'English'`

data/README.rdoc

@@ -10,14 +10,21 @@ A Ruby Hawkular Client.
 * 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.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+* 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
+  otherwise necessary, that is fine, but please isolate to its own commit so we can cherry-pick around it.
 
 == Running the tests
 
-* Copy the file spec/endpoint.yml.example to spec/endpoint.yml
-* Edit the endpoint properties in the file `spec/endpoint.yml`(user, password and host
- name)
-* From command line run => rake spec
+Integration tests are recorded and played against cassettes recorded with VCR
+(http://www.relishapp.com/vcr/vcr/docs)
+
+* Edit the endpoint properties in the file `spec/endpoint.yml`(user, password and host name) if needed
+* From command line run
+    rake spec
+* To run the tests against a live server, set VCR_OFF to 1 as in
+    VCR_OFF=1 rake spec
 
 == Logging
 

data/hawkularclient.gemspec

@@ -1,11 +1,11 @@
 # -*- encoding: utf-8 -*-
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'metrics/version'
+require 'version'
 
 Gem::Specification.new do |gem|
   gem.name          = 'hawkular-client'
-  gem.version       = Hawkular::Metrics::VERSION
+  gem.version       = Hawkular::VERSION
   gem.authors       = ['Libor Zoubek', 'Heiko W. Rupp', 'Federico Simoncelli']
   gem.email         = %w(lzoubek@redhat.com hrupp@redhat.com)
   gem.homepage      = 'https://github.com/hawkular/hawkular-client-ruby'

data/lib/alerts/alerts_api.rb

@@ -0,0 +1,193 @@
+require 'hawkular'
+require 'ostruct'
+
+# Alerts module provides access to Hawkular-Alerts.
+# There are two main parts here: Triggers, that define alertable conditions
+# and Alerts that represent a fired trigger.
+# @see http://www.hawkular.org/docs/rest/rest-alerts.html
+module Hawkular::Alerts
+  # Interface to use to talk to the Hawkular-Alerts component.
+  # @param entrypoint [String] base url of Hawkular-Alerts - e.g
+  #   http://localhost:8080/hawkular/alerts
+  # @param credentials [Hash{String=>String}] Hash of username, password, token(optional)
+  class AlertsClient < Hawkular::BaseClient
+    def initialize(entrypoint = nil, credentials = {})
+      @entrypoint = entrypoint
+
+      super(entrypoint, credentials)
+    end
+
+    # Lists defined triggers in the system
+    # @param [Array] ids List of trigger ids. If provided, limits to the given triggers
+    # @param [Array] tags List of tags. If provided, limits to the given tags. Individual
+    # tags are of the format # key|value. Tags are OR'd together. If a tag-key shows up
+    # more than once, only the last one is accepted
+    # @return [Array<Trigger>] Triggers found
+    def list_triggers(ids = [], tags = [])
+      query = generate_query_params 'triggerIds' => ids, 'tags' => tags
+      sub_url = '/triggers' + query
+
+      ret = http_get(sub_url)
+
+      val = []
+      ret.each { |t| val.push(Trigger.new(t)) }
+      val
+    end
+
+    # Obtains one Trigger definition from the server.
+    # @param [String] trigger_id Id of the trigger to fetch
+    # @param full If true then conditions and dampenings for the trigger are also fetched
+    # @return [Trigger] the selected trigger
+    def get_single_trigger(trigger_id, full = false)
+      the_trigger = '/triggers/' + trigger_id
+      ret = http_get(the_trigger)
+      trigger = Trigger.new(ret)
+
+      if full
+        ret = http_get(the_trigger + '/conditions')
+        ret.each { |c| trigger.conditions.push(Trigger::Condition.new(c)) }
+        ret = http_get(the_trigger + '/dampenings')
+        ret.each { |c| trigger.dampenings.push(Trigger::Dampening.new(c)) }
+      end
+
+      trigger
+    end
+
+    # Obtain the alerts for the Trigger with the passed id
+    # @param [String] trigger_id Id of the trigger that has fired the alerts
+    # @return [Array<Alert>] List of alerts for the trigger. Can be empty
+    def get_alerts_for_trigger(trigger_id) # TODO: add additional filters
+      return [] unless trigger_id
+
+      url = '/?triggerIds=' + trigger_id
+      ret = http_get(url)
+      val = []
+      ret.each { |a| val.push(Alert.new(a)) }
+      val
+    end
+
+    # List fired alerts
+    # @return [Array<Alert>] List of alerts in the system. Can be empty
+    def list_alerts
+      ret = http_get('/')
+      val = []
+      ret.each { |a| val.push(Alert.new(a)) }
+      val
+    end
+
+    # Retrieve a single Alert by its id
+    # @param [String] alert_id id of the alert to fetch
+    # @return [Alert] Alert object retrieved
+    def get_single_alert(alert_id)
+      ret = http_get('/alert/' + alert_id)
+      val = Alert.new(ret)
+      val
+    end
+
+    # Mark one alert as resolved
+    # @param [String] alert_id Id of the alert to resolve
+    # @param [String] by name of the user resolving the alert
+    # @param [String] comment A comment on the resolution
+    def resolve_alert(alert_id, by = nil, comment = nil)
+      sub_url = "/resolve/#{alert_id}"
+      query = generate_query_params 'resolvedBy' => by, 'resolvedNotes' => comment
+      sub_url += query
+      http_put(sub_url, {})
+
+      true
+    end
+
+    # Mark one alert as acknowledged
+    # @param [String] alert_id Id of the alert to ack
+    # @param [String] by name of the user acknowledging the alert
+    # @param [String] comment A comment on the acknowledge
+    def acknowledge_alert(alert_id, by = nil, comment = nil)
+      sub_url = "/ack/#{alert_id}"
+      query = generate_query_params 'ackBy' => by, 'ackNotes' => comment
+      sub_url += query
+      http_put(sub_url, {})
+
+      true
+    end
+  end
+
+  # Representation of one Trigger
+  class Trigger
+    attr_reader :id, :name, :context, :actions, :auto_disable, :auto_enable
+    attr_reader :auto_resolve, :auto_resolve_alerts
+    attr_reader :tenant, :description, :group, :severity
+    attr_reader :conditions, :dampenings, :event_type
+    attr_accessor :enabled
+
+    def initialize(trigger_hash)
+      @_hash = trigger_hash
+      @conditions = []
+      @dampenings = []
+      @id = trigger_hash['id']
+      @name = trigger_hash['name']
+      @enabled = trigger_hash['enabled']
+      @severity = trigger_hash['severity']
+      @auto_resolve = trigger_hash['autoResolve']
+      @auto_resolve_alerts = trigger_hash['autoResolveAlerts']
+      @event_type = trigger_hash['eventType']
+      @tenant = trigger_hash['tenantId']
+      @description = trigger_hash['description']
+      @auto_enable = trigger_hash['autoEnable']
+      @auto_disable = trigger_hash['autoDisable']
+    end
+
+    #     def enable
+    #       @enabled = true
+    #       @_hash['enabled'] = true
+    #       url = '/triggers/' + @id
+    #       Hawkular::BaseClient.http_put(url, @_hash)
+    #     end
+    #
+    #     def disable
+    #       @enabled = false
+    #       url = '/triggers/' + @id
+    #       AlertsClient.http_put(url, self)
+    #     end
+
+    # Representing of one Condition
+    class Condition
+      attr_reader :condition_id, :type, :operator_low, :operator_high, :threshold_low
+      attr_reader :in_range, :threshold_high
+
+      def initialize(cond_hash)
+        @condition_id = cond_hash['conditionId']
+        @type = cond_hash['type']
+        @operator_low = cond_hash['operatorLow']
+        @operator_high = cond_hash['operatorHigh']
+        @threshold_low = cond_hash['thresholdLow']
+        @threshold_high = cond_hash['thresholdHigh']
+        @in_range = cond_hash['inRange']
+      end
+    end
+
+    # Representation of one Dampening setting
+    class Dampening
+      attr_reader :dampening_id, :type, :eval_true_setting, :eval_total_setting, :eval_time_setting
+      attr_reader :current_evals
+
+      def initialize(damp_hash)
+        @current_evals = {}
+        @dampening_id = damp_hash['dampeningId']
+        @type = damp_hash['type']
+        @eval_true_setting = damp_hash['evalTrueSetting']
+        @eval_total_setting = damp_hash['evalTotalSetting']
+        @eval_time_setting = damp_hash['evalTimeSetting']
+      end
+    end
+  end
+
+  # Representation of one alert.
+  # The name of the members are literally what they are in the JSON sent from the
+  # server and not 'rubyfied'. So 'alertId' and not 'alert_ic'
+  # Check http://www.hawkular.org/docs/rest/rest-alerts.html#Alert for details
+  class Alert < OpenStruct
+    def initialize(alert_hash)
+      super(alert_hash)
+    end
+  end
+end

data/lib/{hawkularclient.rb → hawkular.rb}

@@ -1,60 +1,20 @@
-
-
-require 'json'
-require 'rest-client'
-require 'English'
+require 'base64'
+require 'addressable/uri'
 
 module Hawkular
-  # Metrics module provides access to Hawkular Metrics REST API
-  # @see http://www.hawkular.org/docs/rest/rest-metrics.html Hawkular Metrics REST API Documentation
-  # @example Create Hawkular-Metrics client and start pushing some metric data
-  #  # create client instance
-  #  client = Hawkular::Metrics::Client::new("http://server","username",
-  #                "password",{"tenant" => "your tenant ID"})
-  #  # push gauge metric data for metric called "myGauge" (no need to create metric definition
-  #  # unless you wish to specify data retention)
-  #  client.gauges.push_data("myGauge", {:value => 3.1415925})
   module Metrics
   end
-end
-
-require 'metrics/types'
-require 'metrics/tenant_api'
-require 'metrics/metric_api'
-
-module Hawkular::Metrics
-  class HawkularException < StandardError
-    def initialize(message)
-      @message = message
-      super
-    end
-
-    attr_reader :message
-  end
 
-  class Client
+  # 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
     # @!visibility private
     attr_reader :credentials, :entrypoint, :options
     # @return [Tenants] access tenants API
     attr_reader :tenants
-    # @return [Counters] access counters API
-    attr_reader :counters
-    # @return [Gauges] access gauges API
-    attr_reader :gauges
-    # @return [Availability] access counters API
-    attr_reader :avail
-
-    # Construct a new Hawkular Metrics client class.
-    # optional parameters
-    # @param entrypoint [String] Base url of the Hawkular (metrics) server
-    # @param credentials Hash of username, password, token(optional)
-    # @param options [Hash{String=>String}] client options
-    # @example initialize with Hawkular-tenant option
-    #   Hawkular::Metrics::Client::new("http://server",
-    #     {username:"username",password:"password"},
-    #                          {"tenant" => "your tenant ID"})
-    #
-    def initialize(entrypoint = 'http://localhost:8080/hawkular/metrics',
+
+    def initialize(entrypoint = nil,
                    credentials = {},
                    options = {})
       @entrypoint = entrypoint
@@ -72,10 +32,7 @@ module Hawkular::Metrics
         headers: {}
       }.merge(options)
 
-      @tenants = Client::Tenants.new self
-      @counters = Client::Counters.new self
-      @gauges = Client::Gauges.new self
-      @avail = Client::Availability.new self
+      fail 'You need to provide an entrypoint' if entrypoint.nil?
     end
 
     def http_get(suburl, headers = {})
@@ -86,6 +43,25 @@ module Hawkular::Metrics
       handle_fault $ERROR_INFO
     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
+    # @param [String] url_part Part of an url to be escaped
+    # @return [String] escaped url_part as new string
+    def hawk_escape(url_part)
+      sub_url = url_part.dup
+      sub_url.gsub!('%', '%25')
+      sub_url.gsub!(' ', '%20')
+      sub_url.gsub!('[', '%5b')
+      sub_url.gsub!(']', '%5d')
+      sub_url.gsub!('|', '%7c')
+      sub_url.gsub!('(', '%28')
+      sub_url.gsub!(')', '%29')
+      sub_url.gsub!('/', '%2f')
+      sub_url
+    end
+
     def http_post(suburl, hash, headers = {})
       body = JSON.generate(hash)
       res = rest_client(suburl).post(body, http_headers(headers))
@@ -153,8 +129,62 @@ module Hawkular::Metrics
       Integer(Time.now.to_f * 1000)
     end
 
+    # Encode the passed credentials (username/password) into a base64
+    # representation that can be used to generate a Http-Authentication header
+    # @param credentials [Hash{:username,:password}]
+    # @return [String] Base64 encoded result
+    def base_64_credentials(credentials = {})
+      creds = credentials.empty? ? @credentials : credentials
+
+      encoded = Base64.encode64(creds[:username] + ':' + creds[:password])
+      encoded.rstrip!
+    end
+
+    # Generate a query string from the passed hash.
+    # This string starts with a `?` if the hash is
+    # not empty.
+    # Values may be an array, in which case the array values are joined together by `,`.
+    # @param param_hash [Hash] key-values pairs
+    # @return [String] complete query string to append to a base url
+    def generate_query_params(param_hash = {})
+      return '' if param_hash.size == 0
+
+      num = count_non_nil_values(param_hash)
+
+      i = 0
+      ret = ''
+      ret = '?' if num > 0
+      param_hash.each  do |k, v|
+        next if not_suitable?(v)
+
+        if v.instance_of? Array
+          part = "#{k}=#{v.join(',')}"
+        else
+          part = "#{k}=#{v}"
+        end
+
+        ret += hawk_escape part
+
+        i += 1
+        ret += '&' if i < num
+      end
+      ret
+    end
+
     private
 
+    def not_suitable?(v)
+      v.nil? || (v.instance_of? Array) && v.size == 0
+    end
+
+    def count_non_nil_values(param_hash)
+      num = 0
+      param_hash.each do |_k, v|
+        num += 1 unless not_suitable?(v)
+      end
+      num
+    end
+
     def token_header
       @credentials[:token].nil? ? {} : { 'Authorization' => "Bearer #{@credentials[:token]}" }
     end
@@ -178,4 +208,15 @@ module Hawkular::Metrics
       end
     end
   end
+
+  # Specialized exception to be thrown
+  # when the interction with Hawkular fails
+  class HawkularException < StandardError
+    def initialize(message)
+      @message = message
+      super
+    end
+
+    attr_reader :message
+  end
 end