hawkular-client 0.2.2 → 1.0.0

data/lib/{metrics → hawkular/metrics}/metric_api.rb

@@ -113,6 +113,7 @@ module Hawkular::Metrics
       # @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 percentiles [String] optional percentiles to calculate
       # @param limit [Integer] optional limit the number of data points returned

data/lib/{metrics → hawkular/metrics}/metrics_client.rb

@@ -1,12 +1,12 @@
 
-require 'hawkular'
+require 'hawkular/base_client'
 require 'json'
 require 'rest-client'
 require 'English'
 
-require 'metrics/types'
-require 'metrics/tenant_api'
-require 'metrics/metric_api'
+require 'hawkular/metrics/types'
+require 'hawkular/metrics/tenant_api'
+require 'hawkular/metrics/metric_api'
 
 # Metrics module provides access to Hawkular Metrics REST API
 # @see http://www.hawkular.org/docs/rest/rest-metrics.html Hawkular Metrics REST API Documentation

data/lib/{operations → hawkular/operations}/operations_api.rb

@@ -1,4 +1,4 @@
-require 'hawkular'
+require 'hawkular/base_client'
 require 'websocket-client-simple'
 require 'json'
 
@@ -20,13 +20,13 @@ class Proc
   end
 end
 
-# Operations module allows invoking operation on the wildfly agent.
+# Operations module allows invoking operation on the WildFly agent.
 module Hawkular::Operations
   # Client class to interact with the agent via websockets
   class OperationsClient < Hawkular::BaseClient
     include WebSocket::Client
 
-    attr_accessor :ws
+    attr_accessor :ws, :session_id
 
     # helper for parsing the "OperationName=json_payload" messages
     class WebSocket::Frame::Data
@@ -46,13 +46,15 @@ module Hawkular::Operations
     # @param [Hash] args Arguments for client
     #
     # @option args [String]  :host base url of Hawkular - e.g http://localhost:8080
-    # @option args [Hash{String=>String}]  :credentials Hash of {username, password} or token
+    # @option args [Hash{String=>String}]  :credentials Hash of (username password) or token
+    # @option args [Fixnum]  :wait_time Time in seconds describing how long the constructor should block - handshake
     #
     # @example
     #   Hawkular::Operations::OperationsClient.new(credentials: {username: 'jdoe', password: 'password'})
     def initialize(args)
       args[:host] ||= 'localhost:8080'
       args[:credentials] ||= {}
+      args[:wait_time] ||= 0.5
       super(args[:host], args[:credentials])
       # note: if we start using the secured WS, change the protocol to wss://
       url = "ws://#{entrypoint}/hawkular/command-gateway/ui/ws"
@@ -66,7 +68,7 @@ module Hawkular::Operations
           end
         end
       end
-      sleep 1
+      sleep args[:wait_time]
     end
 
     # Closes the WebSocket connection
@@ -74,7 +76,7 @@ module Hawkular::Operations
       @ws.close
     end
 
-    # Invokes a generic operation on the Wildfly agent
+    # Invokes a generic operation on the WildFly agent
     # (the operation name must be specified in the hash)
     # Note: if success and failure callbacks are omitted, the client will not wait for the Response message
     # @param hash [Hash{String=>Object}] a hash containing: resourcePath [String] denoting the resource on
@@ -87,7 +89,7 @@ module Hawkular::Operations
       invoke_operation_helper(hash, &callback)
     end
 
-    # Invokes operation on the wildfly agent that has it's own message type
+    # Invokes operation on the WildFly agent that has it's own message type
     # @param operation_payload [Hash{String=>Object}] a hash containing: resourcePath [String] denoting
     # the resource on which the operation is about to run
     # @param operation_name [String] the name of the operation. This must correspond with the message type, they can be
@@ -202,6 +204,7 @@ module Hawkular::Operations
     end
 
     def handle_message(operation_name, operation_payload, &callback)
+      client = @ws
       # register a callback handler
       @ws.on :message do |msg|
         parsed = msg.data.to_msg_hash
@@ -233,7 +236,7 @@ module Hawkular::Operations
 
     def prepare_payload_hash(ignored_params, hash)
       # it filters out ignored params and convert keys from snake_case to camelCase
-      hash.select { |k, _| !ignored_params.include? k }.map { |k, v| [to_camel_case(k.to_s).to_sym, v] }.to_h
+      Hash[hash.select { |k, _| !ignored_params.include? k }.map { |k, v| [to_camel_case(k.to_s).to_sym, v] }]
     end
 
     def to_camel_case(str)

data/lib/{tokens → hawkular/tokens}/tokens_api.rb

@@ -1,4 +1,4 @@
-require 'hawkular'
+require 'hawkular/base_client'
 
 # Token module provides access to the Secret Store REST API.
 module Hawkular::Token

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

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

data/spec/integration/alerts_spec.rb

@@ -166,6 +166,189 @@ module Hawkular::Alerts::RSpec
     end
   end
 
+  describe 'Alert/Groups', vcr: { decode_compressed_response: true } do
+    before(:each) do
+      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+    end
+
+    it 'Should operate a complex group trigger' do
+      # Create a group trigger
+      t = Hawkular::Alerts::Trigger.new({})
+      t.enabled = false
+      t.id = 'a-group-trigger'
+      t.name = 'A Group Trigger'
+      t.severity = :HIGH
+      t.description = 'A Group Trigger generated from test'
+
+      # Create a condition
+      c = Hawkular::Alerts::Trigger::Condition.new({})
+      c.trigger_mode = :FIRING
+      c.type = :THRESHOLD
+      c.data_id = 'my-metric-id'
+      c.operator = :LT
+      c.threshold = 5
+
+      # Create a group condition
+      # no members yet
+      gc = Hawkular::Alerts::Trigger::GroupConditionsInfo.new([c])
+
+      # Create a member
+      m1 = Hawkular::Alerts::Trigger::GroupMemberInfo.new
+      m1.group_id = 'a-group-trigger'
+      m1.member_id = 'member1'
+      m1.member_name = 'Member One'
+      m1.data_id_map = { 'my-metric-id' => 'my-metric-id-member1' }
+
+      # Create a second member
+      m2 = Hawkular::Alerts::Trigger::GroupMemberInfo.new
+      m2.group_id = 'a-group-trigger'
+      m2.member_id = 'member2'
+      m2.member_name = 'Member Two'
+      m2.data_id_map = { 'my-metric-id' => 'my-metric-id-member2' }
+
+      # Create a dampening for the group trigger
+      d = Hawkular::Alerts::Trigger::Dampening.new(
+        'triggerId'        => 'a-group-trigger',
+        'triggerMode'      => :FIRING,
+        'type'             => :STRICT,
+        'evalTrueSetting'  => 2,
+        'evalTotalSetting' => 2
+      )
+
+      # Create a second condition
+      c2 = Hawkular::Alerts::Trigger::Condition.new({})
+      c2.trigger_mode = :FIRING
+      c2.type = :THRESHOLD
+      c2.data_id = 'my-metric-id2'
+      c2.operator = :GT
+      c2.threshold = 50
+
+      # Create the second group condition
+      # member2 is an orphan so, no need to update it into the data_id_member_map
+      gc2 = Hawkular::Alerts::Trigger::GroupConditionsInfo.new([c, c2])
+      gc2.data_id_member_map = {
+        'my-metric-id'  => { 'member1' => 'my-metric-id-member1' },
+        'my-metric-id2' => { 'member1' => 'my-metric-id2-member1' }
+      }
+
+      # Create a third condition of type compare
+      c3 = Hawkular::Alerts::Trigger::Condition.new({})
+      c3.trigger_mode = :FIRING
+      c3.type = :COMPARE
+      c3.data_id = 'my-metric-id3'
+      c3.operator = :GT
+      c3.data2_id = 'my-metric-id4'
+      c3.data2_multiplier = 1
+
+      # Create the thrid group condition
+      # member 2 is still an orphan, no need to update it into the data_id_member_map
+      gc3 = Hawkular::Alerts::Trigger::GroupConditionsInfo.new([c, c2, c3])
+      gc3.data_id_member_map = {
+        'my-metric-id'  => { 'member1' => 'my-metric-id-member1' },
+        'my-metric-id2' => { 'member1' => 'my-metric-id2-member1' },
+        'my-metric-id3' => { 'member1' => 'my-metric-id3-member1' },
+        'my-metric-id4' => { 'member1' => 'my-metric-id4-member1' }
+      }
+
+      begin
+        group_trigger = @client.create_group_trigger t
+        expect(group_trigger).not_to be_nil
+        expect(group_trigger.type).to eq('GROUP')
+
+        created_conditions = @client.set_group_conditions t.id, :FIRING, gc
+        expect(created_conditions.size).to be(1)
+
+        member1 = @client.create_member_trigger m1
+        expect(member1.type).to eq('MEMBER')
+
+        full_member1 = @client.get_single_trigger member1.id, true
+        expect(full_member1).not_to be_nil
+        expect(full_member1.id).to eq('member1')
+        expect(full_member1.conditions.size).to be(1)
+        expect(full_member1.conditions[0].data_id).to eq('my-metric-id-member1')
+
+        members = @client.list_members t.id
+        expect(members.size).to be(1)
+
+        member2 = @client.create_member_trigger m2
+        expect(member2.type).to eq('MEMBER')
+
+        full_member2 = @client.get_single_trigger member2.id, true
+        expect(full_member2).not_to be_nil
+        expect(full_member2.id).to eq('member2')
+        expect(full_member2.conditions.size).to be(1)
+        expect(full_member2.conditions[0].data_id).to eq('my-metric-id-member2')
+
+        members = @client.list_members t.id
+        expect(members.size).to be(2)
+
+        member2 = @client.orphan_member member2.id
+        expect(member2.type).to eq('ORPHAN')
+
+        members = @client.list_members t.id
+        expect(members.size).to be(1)
+
+        orphans = @client.list_members t.id, true
+        expect(orphans.size).to be(2)
+
+        group_dampening = @client.create_group_dampening d
+        expect(group_dampening).not_to be_nil
+        expect(group_dampening.type).to eq('STRICT')
+
+        full_member1 = @client.get_single_trigger member1.id, true
+        expect(full_member1).not_to be_nil
+        expect(full_member1.id).to eq('member1')
+        expect(full_member1.dampenings.size).to be(1)
+        expect(full_member1.dampenings[0].eval_true_setting).to be(2)
+        expect(full_member1.dampenings[0].eval_total_setting).to be(2)
+
+        group_trigger.tags = { 'group-tname' => 'group-tvalue' }
+        group_trigger = @client.update_group_trigger group_trigger
+
+        full_member1 = @client.get_single_trigger member1.id, false
+        expect(full_member1).not_to be_nil
+        expect(full_member1.tags['group-tname']).to eq('group-tvalue')
+
+        created_conditions = @client.set_group_conditions t.id, :FIRING, gc2
+        expect(created_conditions.size).to be(2)
+
+        full_member1 = @client.get_single_trigger member1.id, true
+        expect(full_member1).not_to be_nil
+        expect(full_member1.conditions.size).to be(2)
+
+        group_dampening.type = :RELAXED_COUNT
+        group_dampening.eval_true_setting = 2
+        group_dampening.eval_total_setting = 4
+        group_dampening = @client.update_group_dampening group_dampening
+
+        group_trigger.context = { 'alert-profiles' => 'profile1' }
+        @client.update_group_trigger group_trigger
+
+        @client.delete_group_dampening group_dampening.trigger_id, group_dampening.dampening_id
+
+        full_member1 = @client.get_single_trigger member1.id, true
+        expect(full_member1).not_to be_nil
+        expect(full_member1.context['alert-profiles']).to eq('profile1')
+        expect(full_member1.dampenings.size).to be(0)
+
+        created_conditions = @client.set_group_conditions t.id, :FIRING, gc3
+        expect(created_conditions.size).to be(3)
+
+        full_member1 = @client.get_single_trigger member1.id, true
+        expect(full_member1).not_to be_nil
+        expect(full_member1.conditions.size).to be(3)
+      ensure
+        # rubocop:disable Lint/HandleExceptions
+        begin
+          @client.delete_group_trigger(t.id)
+        rescue
+          # I am not interested
+        end
+        # rubocop:enable Lint/HandleExceptions
+      end
+    end
+  end
+
   describe 'Alert/Alerts', :vcr do
     it 'Should list alerts' do
       client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
@@ -286,6 +469,23 @@ module Hawkular::Alerts::RSpec
       expect(events).to_not be_nil
       expect(events.size).to be(0)
     end
+
+    it 'Should create an event' do
+      the_id = "test-event@#{Time.new.to_i}"
+      VCR.use_cassette('Alert/Events/Should_create_an_event',
+                       erb: { id: the_id }, record: :none,
+                       decode_compressed_response: true
+                      ) do
+        client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+
+        the_event = client.create_event(the_id, 'MyCategory', 'Li la lu',
+                                        context: { message: 'This is a test' },
+                                        tags: { tag_name: 'tag-value' })
+
+        expect(the_event['id']).to eql(the_id)
+        expect(the_event['category']).to eql('MyCategory')
+      end
+    end
   end
 
   describe 'Alert/EndToEnd', vcr: { decode_compressed_response: true } do

data/spec/integration/hawkular_client_spec.rb

@@ -0,0 +1,228 @@
+require "#{File.dirname(__FILE__)}/../vcr/vcr_setup"
+require "#{File.dirname(__FILE__)}/../spec_helper"
+require 'securerandom'
+
+# examples that tests the main client which delegates all the calls to Hawkular component clients
+module Hawkular::Client::RSpec
+  describe 'HawkularClient' do
+    before(:all) do
+      @creds = {
+        username: 'jdoe',
+        password: 'password'
+      }
+      @hawkular_client = Hawkular::Client.new(credentials: @creds)
+      @state = {
+        hostname: 'localhost.localdomain',
+        feed: nil
+      }
+    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)
+    end
+
+    it 'Should fail when calling unknown method with known client prefix' do
+      expect { @hawkular_client.inventory_lyst_feeds }.to raise_error(NoMethodError)
+    end
+
+    context 'and Inventory client', vcr: { decode_compressed_response: true } do
+      before(:all) do
+        @client = Hawkular::Inventory::InventoryClient.create(credentials: @creds)
+      end
+
+      it 'Should list the same feeds' do
+        feeds1 = @client.list_feeds
+        feeds2 = @hawkular_client.inventory_list_feeds
+
+        expect(feeds1).to match_array(feeds2)
+        @state[:feed] = feeds1[0] unless feeds1[0].nil?
+      end
+
+      it 'Should list the same resource types' do
+        types1 = @client.list_resource_types
+        types2 = @hawkular_client.inventory_list_resource_types
+
+        expect(types1).to match_array(types2)
+      end
+
+      it 'Should list same types when param is given' do
+        types1 = @client.list_resource_types(@state[:feed])
+        types2 = @hawkular_client.inventory_list_resource_types(@state[:feed])
+
+        expect(types1).to match_array(types2)
+      end
+
+      it 'Should both list types with bad feed' do
+        type = 'does not exist'
+        types1 = @client.list_resource_types(type)
+        types2 = @hawkular_client.inventory_list_resource_types(type)
+
+        expect(types1).to match_array(types2)
+      end
+
+      it 'Should both list WildFlys' do
+        path = Hawkular::Inventory::CanonicalPath.new(feed_id: @state[:feed],
+                                                      resource_type_id: hawk_escape_id('WildFly Server'))
+        resources1 = @client.list_resources_for_type(path.to_s)
+        resources2 = @hawkular_client.inventory_list_resources_for_type(path)
+
+        expect(resources1).to match_array(resources2)
+      end
+
+      it 'Should both create and delete feed' do
+        feed_id1 = 'feed_1123sdn'
+        feed_id2 = 'feed_1124sdn'
+        @client.create_feed feed_id1
+        @hawkular_client.inventory_create_feed feed_id2
+
+        feed_list = @client.list_feeds
+        expect(feed_list).to include(feed_id1)
+        expect(feed_list).to include(feed_id2)
+
+        @client.delete_feed feed_id2
+        @hawkular_client.inventory.delete_feed feed_id1
+
+        feed_list = @hawkular_client.inventory_list_feeds
+        expect(feed_list).not_to include(feed_id1)
+        expect(feed_list).not_to include(feed_id2)
+      end
+    end
+
+    context 'and Metrics client' do
+      include Hawkular::Metrics::RSpec
+
+      before(:all) do
+        @client = Hawkular::Metrics::Client.new('http://localhost:8080/hawkular/metrics', @creds)
+      end
+
+      it 'Should both work the same way when pushing metric data to non-existing counter' do
+        id = SecureRandom.uuid
+
+        VCR.use_cassette('HawkularClient/and_Metrics_client/Should both work the same way when' \
+                             ' pushing metric data to non-existing counter',
+                         erb: { id: id }, record: :none, decode_compressed_response: true
+                        ) do
+          @client.counters.push_data(id, value: 4)
+
+          data = @hawkular_client.metrics.counters.get_data(id)
+          expect(data.size).to be 1
+          counter = @hawkular_client.metrics.counters.get(id)
+          expect(counter.id).to eql(id)
+        end
+      end
+
+      it 'Should both create and return Availability using Hash parameter' do
+        id1 = SecureRandom.uuid
+        id2 = SecureRandom.uuid
+        VCR.use_cassette(
+          'HawkularClient/and_Metrics_client/Should both create and return Availability using Hash parameter',
+          erb: { id1: id1, id2: id2 }, record: :none, decode_compressed_response: true
+        ) do
+          @client.avail.create(id: id1, dataRetention: 123, tags: { some: 'value' })
+          metric = @hawkular_client.metrics.avail.get(id1)
+          expect(metric.id).to eql(id1)
+          expect(metric.data_retention).to eql(123)
+
+          @hawkular_client.metrics.avail.create(id: id2, dataRetention: 321, tags: { some: 'value' })
+          metric = @client.avail.get(id2)
+          expect(metric.id).to eql(id2)
+          expect(metric.data_retention).to eql(321)
+        end
+      end
+
+      it 'Should both update tags for Availability' do
+        id1 = SecureRandom.uuid
+        id2 = SecureRandom.uuid
+
+        VCR.use_cassette('HawkularClient/and_Metrics_client/Should both create and retrieve tags for Availability',
+                         erb: { id1: id1, id2: id2 }, record: :none, decode_compressed_response: true
+                        ) do
+          @client.avail.create(id: id1, tags: { myTag: id1 })
+          metric = @hawkular_client.metrics.avail.get(id1)
+          expect(metric.id).to eql(id1)
+
+          @hawkular_client.metrics.avail.create(id: id2, tags: { myTag: id2 })
+          metric = @client.avail.get(id2)
+          expect(metric.id).to eql(id2)
+        end
+      end
+
+      it 'Should both return the version' do
+        VCR.use_cassette('HawkularClient/and_Metrics_client/Should both return the version') do
+          data1 = @client.fetch_version_and_status
+          data2 = @hawkular_client.metrics.fetch_version_and_status
+          expect(data1).to eql(data2)
+        end
+      end
+    end
+
+    context 'and Operations client', vcr: { decode_compressed_response: true } do
+      include Hawkular::Operations::RSpec
+
+      WebSocketVCR.configure do |c|
+        c.hook_uris = ['localhost:8080']
+      end
+
+      let(:example) do |e|
+        e
+      end
+
+      it 'Should both work the same way', :websocket do
+        tenant_id = @hawkular_client.inventory_get_tenant
+        tenant_id2 = @hawkular_client.inventory.get_tenant
+        expect(tenant_id).to eql(tenant_id2)
+
+        feed_id = @hawkular_client.inventory.list_feeds.first
+        wf_server_resource_id = 'Local~~'
+        alerts_war_resource_id = 'Local~%2Fdeployment%3Dhawkular-alerts-actions-email.war'
+
+        WebSocketVCR.record(example, self) do
+          path = Hawkular::Inventory::CanonicalPath.new(tenant_id: tenant_id,
+                                                        feed_id: feed_id,
+                                                        resource_ids: [wf_server_resource_id, alerts_war_resource_id])
+
+          redeploy = {
+            operationName: 'Redeploy',
+            resourcePath: path.to_s
+          }
+
+          actual_data = {}
+          client = Hawkular::Operations::OperationsClient.new(credentials: @creds)
+          client.invoke_generic_operation(redeploy) do |on|
+            on.success do |data|
+              actual_data[:data] = data
+            end
+            on.failure do |error|
+              actual_data[:data] = {}
+              puts 'error callback was called, reason: ' + error.to_s
+            end
+          end
+
+          actual_data = wait_for actual_data
+          expect(actual_data['status']).to eq('OK')
+
+          # now do the same on the main client
+          actual_data = {}
+          @hawkular_client.operations_invoke_generic_operation(redeploy) do |on|
+            on.success do |data|
+              actual_data[:data] = data
+            end
+            on.failure do |error|
+              actual_data[:data] = {}
+              puts 'error callback was called, reason: ' + error.to_s
+            end
+          end
+
+          actual_data = wait_for actual_data
+          expect(actual_data['status']).to eq('OK')
+        end
+      end
+
+      xit 'Should both reuse the websocket connection', :websocket do
+        WebSocketVCR.record(example, self) do
+        end
+      end
+    end
+  end
+end