topological_inventory-providers-common 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 134e945b201072b8bdd7fc6af73b04a6f60698da831ef3989ab973453a1a5159
-  data.tar.gz: 20e4f260c411551572b557f4e4454fdc03c9e3b2ac9c8f5997e6600780298c1a
+  metadata.gz: aad209b97efea9bb19ce488782adb1dabfa8d650c12f8637e2b348ed4ec95a15
+  data.tar.gz: 69b9bbed6a2d725990206ab3bfc7b13ec25b10f7e0c1a979b48c61b67e53fd0d
 SHA512:
-  metadata.gz: 0a847566f6fb20e9518faef660c626788e6afd20d26cec28a5899e645c68cedd7c017974d0cb1c3c2524253007386b9728a1bb67a0f0a9101fe62bd388f03ccb
-  data.tar.gz: 6e786659b1bf913fe1e22d9c0618986d03dc4bc169d782e446ecd089b97a136b639f83be85c562006dccde83a8d025b102863b565aa571746767fa292e4dae89
+  metadata.gz: 45722b70f009a764d8cd804424157cc98b1a225b72326b8b8971fecd093fa6260446777db76bc3502e487d27dc82b2b4325959302f4a1abe13fbbf8c015c1d54
+  data.tar.gz: b1a6de8e2eb93b2b26d4b609f17a1a518cf4b318dbcf117c6225fe297bb3ec97f870b944e151786977ad90f42c16746eeeadf6a3d113b648921e278cb831aadd

data/.codeclimate.yml

@@ -0,0 +1,31 @@
+---
+version: '2'
+prepare:
+  fetch:
+  - url: https://raw.githubusercontent.com/RedHatInsights/insights-api-common-rails/master/.rubocop_base.yml
+    path: ".rubocop_base.yml"
+  - url: https://raw.githubusercontent.com/RedHatInsights/insights-api-common-rails/master/.rubocop_cc_base.yml
+    path: ".rubocop_cc_base.yml"
+checks:
+  argument-count:
+    enabled: false
+  complex-logic:
+    enabled: false
+  file-lines:
+    enabled: false
+  method-complexity:
+    config:
+      threshold: 11
+  method-count:
+    enabled: false
+  method-lines:
+    enabled: false
+  nested-control-flow:
+    enabled: false
+  return-statements:
+    enabled: false
+plugins:
+  rubocop:
+    enabled: true
+    config: ".rubocop_cc.yml"
+    channel: rubocop-1-0

data/.rubocop.yml

@@ -1,3 +1,3 @@
 inherit_from:
-- https://raw.githubusercontent.com/ManageIQ/guides/master/.rubocop_base.yml
+- https://raw.githubusercontent.com/RedHatInsights/insights-api-common-rails/master/.rubocop_base.yml
 - .rubocop_local.yml

data/.yamllint

@@ -0,0 +1,8 @@
+---
+ignore: |
+
+extends: relaxed
+
+rules:
+  line-length:
+    max: 120

data/CHANGELOG.md

@@ -4,7 +4,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2.0.0]
+## [2.1.0]
+Add Availability checks for sources via Kafka #54
+Common Metrics exporter #57
+Rubocop rules from insights-api-common + yamllint #59
+
+## [2.0.0] - 2020-10-20
 Operations/API clients refactoring
 
 ## [1.0.12] - 2020-10-01
@@ -62,7 +67,8 @@ manageiq-loggers to >= 0.4.2 #20
 ## [1.0.0] - 2020-03-19
 ### Initial release to rubygems.org
 
-[Unreleased]: https://github.com/RedHatInsights/topological_inventory-providers-common/compare/v2.0.0...HEAD
+[Unreleased]: https://github.com/RedHatInsights/topological_inventory-providers-common/compare/v2.1.0...HEAD
+[2.1.0]: https://github.com/RedHatInsights/topological_inventory-providers-common/compare/v2.0.0...v2.1.0
 [2.0.0]: https://github.com/RedHatInsights/topological_inventory-providers-common/compare/v1.0.12...v2.0.0
 [1.0.12]: https://github.com/RedHatInsights/topological_inventory-providers-common/compare/v1.0.11...v1.0.12
 [1.0.11]: https://github.com/RedHatInsights/topological_inventory-providers-common/compare/v1.0.10...v1.0.11

data/lib/topological_inventory/providers/common.rb

@@ -3,6 +3,7 @@ require "topological_inventory/providers/common/logging"
 require "topological_inventory/providers/common/operations/health_check"
 require "topological_inventory/providers/common/collectors_pool"
 require "topological_inventory/providers/common/collector"
+require "topological_inventory/providers/common/metrics"
 
 module TopologicalInventory
   module Providers

data/lib/topological_inventory/providers/common/messaging_client.rb

@@ -0,0 +1,40 @@
+require "more_core_extensions/core_ext/module/cache_with_timeout"
+require "manageiq-messaging"
+
+module TopologicalInventory
+  module Providers
+    module Common
+      class MessagingClient
+        # Kafka host name
+        attr_accessor :queue_host
+        # Kafka port
+        attr_accessor :queue_port
+
+        def initialize
+          @queue_host = ENV['QUEUE_HOST'] || 'localhost'
+          @queue_port = (ENV['QUEUE_PORT'] || 9092).to_i
+        end
+
+        def self.default
+          @@default ||= new
+        end
+
+        def self.configure
+          if block_given?
+            yield(default)
+          else
+            default
+          end
+        end
+
+        cache_with_timeout(:client) do
+          ManageIQ::Messaging::Client.open(:protocol => :Kafka, :host => @queue_host, :port => @queue_port)
+        end
+
+        def client
+          self.class.client
+        end
+      end
+    end
+  end
+end

data/lib/topological_inventory/providers/common/metrics.rb

@@ -0,0 +1,84 @@
+require "benchmark"
+require "prometheus_exporter"
+require "prometheus_exporter/server"
+require "prometheus_exporter/client"
+require "prometheus_exporter/instrumentation"
+
+module TopologicalInventory
+  module Providers
+    module Common
+      class Metrics
+        ERROR_COUNTER_MESSAGE = "total number of errors".freeze
+
+        def initialize(port = 9394)
+          return if port == 0
+
+          configure_server(port)
+          configure_metrics
+        end
+
+        def stop_server
+          @server&.stop
+        end
+
+        def record_error(type = :general)
+          @error_counter&.observe(1, :type => type.to_s)
+        end
+
+        def record_operation(name, labels = {})
+          @status_counter&.observe(1, (labels || {}).merge(:name => name))
+        end
+
+        def record_operation_time(name, labels = {}, &block)
+          record_time(@duration_seconds, (labels || {}).merge(:name => name), &block)
+        end
+
+        # Common method for gauge
+        def record_gauge(metric, opt, value: nil, labels: {})
+          case opt
+          when :set then
+            metric&.observe(value.to_i, labels)
+          when :add then
+            metric&.increment(labels)
+          when :remove then
+            metric&.decrement(labels)
+          end
+        end
+
+        # Common method for histogram
+        def record_time(metric, labels = {})
+          result = nil
+          time = Benchmark.realtime { result = yield }
+          metric&.observe(time, labels)
+          result
+        end
+
+        private
+
+        def configure_server(port)
+          @server = PrometheusExporter::Server::WebServer.new(:port => port)
+          @server.start
+
+          PrometheusExporter::Client.default = PrometheusExporter::LocalClient.new(:collector => @server.collector)
+        end
+
+        def configure_metrics
+          PrometheusExporter::Instrumentation::Process.start
+          PrometheusExporter::Metric::Base.default_prefix = default_prefix
+
+          @duration_seconds = PrometheusExporter::Metric::Histogram.new('duration_seconds', 'Duration of processed operation')
+          @error_counter = PrometheusExporter::Metric::Counter.new("error", ERROR_COUNTER_MESSAGE)
+          @status_counter = PrometheusExporter::Metric::Counter.new('status_counter', 'number of processed operations')
+
+          [@duration_seconds, @error_counter, @status_counter].each do |metric|
+            @server.collector.register_metric(metric)
+          end
+        end
+
+        def default_prefix
+          raise NotImplementedError, "#{__method__} must be implemented in a subclass"
+        end
+      end
+    end
+  end
+end

data/lib/topological_inventory/providers/common/mixins/sources_api.rb

@@ -14,6 +14,7 @@ module TopologicalInventory
           def endpoint
             @endpoint ||= sources_api.fetch_default_endpoint(source_id)
           rescue => e
+            metrics&.record_error(:sources_api)
             logger.error_ext(operation, "Failed to fetch Endpoint for Source #{source_id}: #{e.message}")
             nil
           end
@@ -25,6 +26,7 @@ module TopologicalInventory
                                   sources_api.fetch_authentication(source_id, endpoint)
                                 end
           rescue => e
+            metrics&.record_error(:sources_api)
             logger.error_ext(operation, "Failed to fetch Authentication for Source #{source_id}: #{e.message}")
             nil
           end
@@ -32,6 +34,7 @@ module TopologicalInventory
           def application
             @application ||= sources_api.fetch_application(source_id)
           rescue => e
+            metrics&.record_error(:sources_api)
             logger.error_ext(operation, "Failed to fetch Application for Source #{source_id}: #{e.message}")
             nil
           end

data/lib/topological_inventory/providers/common/mixins/statuses.rb

@@ -0,0 +1,19 @@
+module TopologicalInventory
+  module Providers
+    module Common
+      module Mixins
+        module Statuses
+          def operation_status
+            return @statuses if @statuses.present?
+
+            @statuses = {}
+            %i[success error skipped not_implemented].each do |status|
+              @statuses[status] = status.to_s
+            end
+            @statuses
+          end
+        end
+      end
+    end
+  end
+end

data/lib/topological_inventory/providers/common/operations/processor.rb

@@ -0,0 +1,77 @@
+require "topological_inventory/providers/common/logging"
+require "topological_inventory/providers/common/mixins/statuses"
+require "topological_inventory/providers/common/mixins/topology_api"
+
+module TopologicalInventory
+  module Providers
+    module Common
+      module Operations
+        class Processor
+          include Logging
+          include Mixins::Statuses
+          include Mixins::TopologyApi
+
+          def self.process!(message, metrics)
+            new(message, metrics).process
+          end
+
+          def initialize(message, metrics)
+            self.message            = message
+            self.metrics            = metrics
+            self.model, self.method = message.message.split(".")
+
+            self.params   = message.payload["params"]
+            self.identity = message.payload["request_context"]
+          end
+
+          def process
+            logger.info(status_log_msg)
+            impl = operation_class&.new(params, identity, metrics)
+            if impl&.respond_to?(method)
+              with_time_measure do
+                result = impl.send(method)
+
+                logger.info(status_log_msg("Complete"))
+                result
+              end
+            else
+              logger.warn(status_log_msg("Not Implemented!"))
+              complete_task("not implemented") if params["task_id"]
+              operation_status[:not_implemented]
+            end
+          rescue StandardError, NotImplementedError => e
+            complete_task(e.message) if params["task_id"]
+            raise
+          end
+
+          private
+
+          attr_accessor :message, :identity, :model, :method, :metrics, :params
+
+          def operation_class
+            raise NotImplementedError, "#{__method__} must be implemented in a subclass"
+          end
+
+          def with_time_measure
+            if metrics.present?
+              metrics.record_operation_time(message.message) { yield }
+            else
+              yield
+            end
+          end
+
+          def complete_task(msg, status = "error")
+            update_task(params["task_id"],
+                        :state   => "completed",
+                        :status  => status,
+                        :context => {:error => "#{model}##{method} - #{msg}"})
+          end
+
+          def status_log_msg(status = nil)
+            "Processing #{model}##{method} [#{params}]...#{status}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/topological_inventory/providers/common/operations/source.rb

@@ -1,7 +1,9 @@
 require "topological_inventory/providers/common/logging"
 require "active_support/core_ext/numeric/time"
 require "topological_inventory/providers/common/mixins/sources_api"
+require "topological_inventory/providers/common/mixins/statuses"
 require "topological_inventory/providers/common/mixins/x_rh_headers"
+require "topological_inventory/providers/common/messaging_client"
 
 module TopologicalInventory
   module Providers
@@ -11,8 +13,11 @@ module TopologicalInventory
           include Logging
           include Mixins::SourcesApi
           include Mixins::XRhHeaders
+          include Mixins::Statuses
 
           STATUS_AVAILABLE, STATUS_UNAVAILABLE = %w[available unavailable].freeze
+          EVENT_AVAILABILITY_STATUS            = "availability_status".freeze
+          SERVICE_NAME                         = "platform.sources.status".freeze
 
           ERROR_MESSAGES = {
             :authentication_not_found          => "Authentication not found in Sources API",
@@ -20,36 +25,41 @@ module TopologicalInventory
           }.freeze
 
           LAST_CHECKED_AT_THRESHOLD = 5.minutes.freeze
-          AUTH_NOT_NECESSARY        = "n/a".freeze
+          AUTH_NOT_NECESSARY = "n/a".freeze
 
           attr_accessor :identity, :operation, :params, :request_context, :source_id, :account_number
 
-          def initialize(params = {}, request_context = nil)
-            self.operation       = 'Source'
-            self.params          = params
-            self.request_context = request_context
-            self.source_id       = params['source_id']
-
-            self.account_number  = params['external_tenant']
-            self.identity        = identity_by_account_number(account_number)
+          def initialize(params = {}, request_context = nil, metrics = nil)
+            self.metrics         = metrics
+            self.operation         = 'Source'
+            self.params            = params
+            self.request_context   = request_context
+            self.source_id         = params['source_id']
+            self.account_number    = params['external_tenant']
+            self.updates_via_kafka = ENV['UPDATE_SOURCES_VIA_API'].blank?
+            self.identity          = identity_by_account_number(account_number)
           end
 
           def availability_check
             self.operation += '#availability_check'
 
-            return if params_missing?
+            return operation_status[:error] if params_missing?
 
-            return if checked_recently?
+            return operation_status[:skipped] if checked_recently?
 
             status, error_message = connection_status
 
             update_source_and_subresources(status, error_message)
 
             logger.availability_check("Completed: Source #{source_id} is #{status}")
+
+            operation_status[:success]
           end
 
           private
 
+          attr_accessor :metrics, :updates_via_kafka
+
           def required_params
             %w[source_id]
           end
@@ -114,10 +124,15 @@ module TopologicalInventory
           def update_source_and_subresources(status, error_message = nil)
             logger.availability_check("Updating source [#{source_id}] status [#{status}] message [#{error_message}]")
 
-            update_source(status)
-
-            update_endpoint(status, error_message) if endpoint
-            update_application(status) if application
+            if updates_via_kafka
+              update_source_by_kafka(status)
+              update_endpoint_by_kafka(status, error_message) if endpoint
+              update_application_by_kafka(status) if application
+            else
+              update_source(status)
+              update_endpoint(status, error_message) if endpoint
+              update_application(status) if application
+            end
           end
 
           def update_source(status)
@@ -128,9 +143,18 @@ module TopologicalInventory
 
             sources_api.update_source(source_id, source)
           rescue ::SourcesApiClient::ApiError => e
+            metrics&.record_error(:sources_api)
             logger.availability_check("Failed to update Source id:#{source_id} - #{e.message}", :error)
           end
 
+          def update_source_by_kafka(status)
+            availability_status_message(
+              :resource_type => "Source",
+              :resource_id   => source_id,
+              :status        => status
+            )
+          end
+
           def update_endpoint(status, error_message)
             if endpoint.nil?
               logger.availability_check("Failed to update Endpoint for Source id:#{source_id}. Endpoint not found", :error)
@@ -146,19 +170,59 @@ module TopologicalInventory
 
             sources_api.update_endpoint(endpoint.id, endpoint_update)
           rescue ::SourcesApiClient::ApiError => e
+            metrics&.record_error(:sources_api)
             logger.availability_check("Failed to update Endpoint(ID: #{endpoint.id}) - #{e.message}", :error)
           end
 
+          def update_endpoint_by_kafka(status, error_message)
+            if endpoint.nil?
+              logger.availability_check("Failed to update Endpoint for Source id:#{source_id}. Endpoint not found", :error)
+              return
+            end
+
+            availability_status_message(
+              :resource_type => "Endpoint",
+              :resource_id   => endpoint.id,
+              :status        => status,
+              :error         => error_message
+            )
+          end
+
           def update_application(status)
-            application_update                   = ::SourcesApiClient::Application.new
-            application_update.last_checked_at   = check_time
-            application_update.last_available_at = check_time if status == STATUS_AVAILABLE
+            application_update                     = ::SourcesApiClient::Application.new
+            application_update.last_checked_at     = check_time
+            application_update.last_available_at   = check_time if status == STATUS_AVAILABLE
 
             sources_api.update_application(application.id, application_update)
           rescue ::SourcesApiClient::ApiError => e
+            metrics&.record_error(:sources_api)
             logger.availability_check("Failed to update Application id: #{application.id} - #{e.message}", :error)
           end
 
+          def update_application_by_kafka(status)
+            availability_status_message(
+              :resource_type => "Application",
+              :resource_id   => application.id,
+              :status        => status
+            )
+          end
+
+          def availability_status_message(payload)
+            messaging_client.publish_message(
+              :service => SERVICE_NAME,
+              :message => EVENT_AVAILABILITY_STATUS,
+              :payload => payload.to_json
+            )
+          rescue => err
+            logger.availability_check("Failed to update Application id: #{application.id} - #{err.message}", :error)
+          ensure
+            messaging_client&.close
+          end
+
+          def messaging_client
+            TopologicalInventory::Providers::Common::MessagingClient.default.client
+          end
+
           def check_time
             @check_time ||= Time.now.utc
           end

data/lib/topological_inventory/providers/common/version.rb

@@ -1,7 +1,7 @@
 module TopologicalInventory
   module Providers
     module Common
-      VERSION = "2.0.0".freeze
+      VERSION = "2.1.0".freeze
     end
   end
 end

data/spec/support/shared/availability_check.rb

@@ -7,8 +7,12 @@ RSpec.shared_examples "availability_check" do
   let(:sources_api_url) { "#{host_url}#{sources_api_path}" }
 
   let(:external_tenant) { '11001' }
+  let(:kafka_client) { TopologicalInventory::Providers::Common::MessagingClient.default.client }
   let(:identity) { {'x-rh-identity' => Base64.strict_encode64({'identity' => {'account_number' => external_tenant, 'user' => {'is_org_admin' => true}}}.to_json)} }
   let(:headers) { {'Content-Type' => 'application/json'}.merge(identity) }
+  let(:status_available) { described_class::STATUS_AVAILABLE }
+  let(:status_unavailable) { described_class::STATUS_UNAVAILABLE }
+  let(:error_message) { 'error_message' }
   let(:source_id) { '123' }
   let(:endpoint_id) { '234' }
   let(:application_id) { '345' }
@@ -32,101 +36,208 @@ RSpec.shared_examples "availability_check" do
 
   subject { described_class.new(payload["params"]) }
 
+  def kafka_message(resource_type, resource_id, status, error_message = nil)
+    res = {
+      :service => described_class::SERVICE_NAME,
+      :message => described_class::EVENT_AVAILABILITY_STATUS,
+      :payload => {
+        :resource_type => resource_type,
+        :resource_id   => resource_id,
+        :status        => status
+      }
+    }
+    res[:payload][:error] = error_message if error_message
+    res[:payload] = res[:payload].to_json
+    res
+  end
+
+  before do
+    allow(subject).to receive(:messaging_client).and_return(kafka_client)
+  end
+
   context "when not checked recently" do
     before do
       allow(subject).to receive(:checked_recently?).and_return(false)
     end
 
-    it "updates Source and Endpoint when available" do
-      # GET
-      stub_get(:endpoint, list_endpoints_response)
-      stub_get(:authentication, list_endpoint_authentications_response)
-      stub_get(:password, internal_api_authentication_response)
-      stub_not_found(:application)
+    context 'kafka' do
+      it 'updates Source and Endpoint when available' do
+        stub_get(:endpoint, list_endpoints_response)
+        stub_get(:application, list_applications_response)
 
-      # PATCH
-      source_patch_body   = {'availability_status' => described_class::STATUS_AVAILABLE, 'last_available_at' => subject.send(:check_time), 'last_checked_at' => subject.send(:check_time)}.to_json
-      endpoint_patch_body = {'availability_status' => described_class::STATUS_AVAILABLE, 'availability_status_error' => '', 'last_available_at' => subject.send(:check_time), 'last_checked_at' => subject.send(:check_time)}.to_json
+        expect(subject).to receive(:connection_status).and_return([status_available, ''])
 
-      stub_patch(:source, source_patch_body)
-      stub_patch(:endpoint, endpoint_patch_body)
+        expect(kafka_client).to receive(:publish_message).with(
+          kafka_message("Source", source_id, status_available)
+        )
 
-      # Check ---
-      expect(subject).to receive(:connection_check).and_return([described_class::STATUS_AVAILABLE, nil])
+        expect(kafka_client).to receive(:publish_message).with(
+          kafka_message("Endpoint", endpoint_id, status_available, '')
+        )
 
-      subject.availability_check
+        expect(kafka_client).to receive(:publish_message).with(
+          kafka_message("Application", application_id, status_available)
+        )
 
-      assert_patch(:source, source_patch_body)
-      assert_patch(:endpoint, endpoint_patch_body)
-    end
+        subject.availability_check
+      end
 
-    it "updates Source and Endpoint when unavailable" do
-      # GET
-      stub_get(:endpoint, list_endpoints_response)
-      stub_get(:authentication, list_endpoint_authentications_response)
-      stub_get(:password, internal_api_authentication_response)
-      stub_not_found(:application)
 
-      # PATCH
-      connection_error_message = "Some connection error"
-      source_patch_body        = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'last_checked_at' => subject.send(:check_time)}.to_json
-      endpoint_patch_body      = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'availability_status_error' => connection_error_message, 'last_checked_at' => subject.send(:check_time)}.to_json
+      it "updates Source and Endpoint when unavailable" do
+        stub_get(:endpoint, list_endpoints_response)
+        stub_get(:application, list_applications_response)
 
-      stub_patch(:source, source_patch_body)
-      stub_patch(:endpoint, endpoint_patch_body)
+        expect(subject).to receive(:connection_status).and_return([status_unavailable, error_message])
 
-      # Check ---
-      expect(subject).to receive(:connection_check).and_return([described_class::STATUS_UNAVAILABLE, connection_error_message])
+        expect(kafka_client).to receive(:publish_message).with(
+          kafka_message("Source", source_id, status_unavailable)
+        )
 
-      subject.availability_check
+        expect(kafka_client).to receive(:publish_message).with(
+          kafka_message("Endpoint", endpoint_id, status_unavailable, error_message)
+        )
 
-      assert_patch(:source, source_patch_body)
-      assert_patch(:endpoint, endpoint_patch_body)
-    end
+        expect(kafka_client).to receive(:publish_message).with(
+          kafka_message("Application", application_id, status_unavailable)
+        )
 
-    it "updates only Source to 'unavailable' status if Endpoint not found" do
-      # GET
-      stub_not_found(:endpoint)
-      stub_not_found(:application)
+        subject.availability_check
+      end
 
-      # PATCH
-      source_patch_body = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'last_checked_at' => subject.send(:check_time)}.to_json
-      stub_patch(:source, source_patch_body)
+      it "updates only Source to 'unavailable' status if Endpoint not found" do
+        stub_not_found(:endpoint)
+        stub_not_found(:application)
 
-      # Check
-      api_client = subject.send(:sources_api)
-      expect(api_client).not_to receive(:update_endpoint)
+        expect(subject).to receive(:connection_status).and_return([status_unavailable, error_message])
 
-      subject.availability_check
+        expect(kafka_client).to receive(:publish_message).with(
+          kafka_message("Source", source_id, status_unavailable)
+        )
+
+        expect(subject.logger).to receive(:availability_check).with("Updating source [#{source_id}] status [#{status_unavailable}] message [#{error_message}]")
+        expect(subject.logger).to receive(:availability_check).with("Completed: Source #{source_id} is #{status_unavailable}")
+
+        subject.availability_check
+      end
+
+      it "updates Source and Endpoint to 'unavailable' if Authentication not found" do
+        stub_get(:endpoint, list_endpoints_response)
+        stub_not_found(:application)
+
+        expect(subject).to receive(:connection_status).and_return([status_unavailable, error_message])
+
+        expect(kafka_client).to receive(:publish_message).with(
+          kafka_message("Source", source_id, status_unavailable)
+        )
+
+        expect(kafka_client).to receive(:publish_message).with(
+          kafka_message("Endpoint", endpoint_id, status_unavailable, error_message)
+        )
 
-      assert_patch(:source, source_patch_body)
+        expect(subject.logger).to receive(:availability_check).with("Updating source [#{source_id}] status [#{status_unavailable}] message [#{error_message}]")
+        expect(subject.logger).to receive(:availability_check).with("Completed: Source #{source_id} is #{status_unavailable}")
+
+        subject.availability_check
+      end
     end
 
-    it "updates Source and Endpoint to 'unavailable' if Authentication not found" do
-      # GET
-      stub_get(:endpoint, list_endpoints_response)
-      stub_get(:authentication, list_endpoint_authentications_response_empty)
-      stub_not_found(:application)
+    context 'sources_api' do
+      before do
+        subject.send(:updates_via_kafka=, false)
+      end
 
-      # PATCH
-      source_patch_body   = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'last_checked_at' => subject.send(:check_time)}.to_json
-      endpoint_patch_body = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'availability_status_error' => described_class::ERROR_MESSAGES[:authentication_not_found], 'last_checked_at' => subject.send(:check_time)}.to_json
+      it "updates Source and Endpoint when available" do
+        # GET
+        stub_get(:endpoint, list_endpoints_response)
+        stub_get(:authentication, list_endpoint_authentications_response)
+        stub_get(:password, internal_api_authentication_response)
+        stub_not_found(:application)
 
-      stub_patch(:source, source_patch_body)
-      stub_patch(:endpoint, endpoint_patch_body)
+        # PATCH
+        source_patch_body   = {'availability_status' => described_class::STATUS_AVAILABLE, 'last_available_at' => subject.send(:check_time), 'last_checked_at' => subject.send(:check_time)}.to_json
+        endpoint_patch_body = {'availability_status' => described_class::STATUS_AVAILABLE, 'availability_status_error' => '', 'last_available_at' => subject.send(:check_time), 'last_checked_at' => subject.send(:check_time)}.to_json
 
-      # Check
-      expect(subject).not_to receive(:connection_check)
-      subject.availability_check
+        stub_patch(:source, source_patch_body)
+        stub_patch(:endpoint, endpoint_patch_body)
+
+        # Check ---
+        expect(subject).to receive(:connection_check).and_return([described_class::STATUS_AVAILABLE, nil])
+
+        subject.availability_check
+
+        assert_patch(:source, source_patch_body)
+        assert_patch(:endpoint, endpoint_patch_body)
+      end
+
+      it "updates Source and Endpoint when unavailable" do
+        # GET
+        stub_get(:endpoint, list_endpoints_response)
+        stub_get(:authentication, list_endpoint_authentications_response)
+        stub_get(:password, internal_api_authentication_response)
+        stub_not_found(:application)
+
+        # PATCH
+        connection_error_message = "Some connection error"
+        source_patch_body        = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'last_checked_at' => subject.send(:check_time)}.to_json
+        endpoint_patch_body      = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'availability_status_error' => connection_error_message, 'last_checked_at' => subject.send(:check_time)}.to_json
+
+        stub_patch(:source, source_patch_body)
+        stub_patch(:endpoint, endpoint_patch_body)
+
+        # Check ---
+        expect(subject).to receive(:connection_check).and_return([described_class::STATUS_UNAVAILABLE, connection_error_message])
+
+        subject.availability_check
+
+        assert_patch(:source, source_patch_body)
+        assert_patch(:endpoint, endpoint_patch_body)
+      end
+
+      it "updates only Source to 'unavailable' status if Endpoint not found" do
+        # GET
+        stub_not_found(:endpoint)
+        stub_not_found(:application)
+
+        # PATCH
+        source_patch_body = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'last_checked_at' => subject.send(:check_time)}.to_json
+        stub_patch(:source, source_patch_body)
+
+        # Check
+        api_client = subject.send(:sources_api)
+        expect(api_client).not_to receive(:update_endpoint)
+
+        subject.availability_check
+
+        assert_patch(:source, source_patch_body)
+      end
+
+      it "updates Source and Endpoint to 'unavailable' if Authentication not found" do
+        # GET
+        stub_get(:endpoint, list_endpoints_response)
+        stub_get(:authentication, list_endpoint_authentications_response_empty)
+        stub_not_found(:application)
 
-      assert_patch(:source, source_patch_body)
-      assert_patch(:endpoint, endpoint_patch_body)
+        # PATCH
+        source_patch_body   = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'last_checked_at' => subject.send(:check_time)}.to_json
+        endpoint_patch_body = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'availability_status_error' => described_class::ERROR_MESSAGES[:authentication_not_found], 'last_checked_at' => subject.send(:check_time)}.to_json
+
+        stub_patch(:source, source_patch_body)
+        stub_patch(:endpoint, endpoint_patch_body)
+
+        # Check
+        expect(subject).not_to receive(:connection_check)
+        subject.availability_check
+
+        assert_patch(:source, source_patch_body)
+        assert_patch(:endpoint, endpoint_patch_body)
+      end
     end
   end
 
   context "when checked recently" do
     before do
       allow(subject).to receive(:checked_recently?).and_return(true)
+      subject.send(:updates_via_kafka=, false)
     end
 
     it "doesn't do connection check" do
@@ -140,44 +251,97 @@ RSpec.shared_examples "availability_check" do
 
   context "when there is an application" do
     context "when it is available" do
-      it "updates the availability status to available" do
-        # GET
-        stub_not_found(:endpoint)
-        stub_get(:application, list_applications_response)
-        # PATCH
-        application_patch_body = {'last_available_at' => subject.send(:check_time), 'last_checked_at' => subject.send(:check_time)}.to_json
-        source_patch_body = {'availability_status' => described_class::STATUS_AVAILABLE, 'last_available_at' => subject.send(:check_time), 'last_checked_at' => subject.send(:check_time)}.to_json
+      context 'kafka' do
+        it "updates the availability status to available" do
+          stub_not_found(:endpoint)
+          stub_get(:application, list_applications_response)
 
-        stub_patch(:source, source_patch_body)
-        stub_patch(:application, application_patch_body)
+          expect(subject).to receive(:connection_status).and_return([status_available, ''])
 
-        # Check
-        expect(subject).not_to receive(:connection_check)
-        subject.availability_check
+          expect(kafka_client).to receive(:publish_message).with(
+            kafka_message("Source", source_id, status_available)
+          )
 
-        assert_patch(:source, source_patch_body)
-        assert_patch(:application, application_patch_body)
+          expect(kafka_client).to receive(:publish_message).with(
+            kafka_message("Application", application_id, status_available)
+          )
+
+          expect(subject.logger).to receive(:availability_check).with("Updating source [#{source_id}] status [#{status_available}] message []")
+          expect(subject.logger).to receive(:availability_check).with("Completed: Source #{source_id} is #{status_available}")
+
+          subject.availability_check
+        end
+      end
+
+      context 'sources_api' do
+        before do
+          subject.send(:updates_via_kafka=, false)
+        end
+
+        it "updates the availability status to available" do
+          # GET
+          stub_not_found(:endpoint)
+          stub_get(:application, list_applications_response)
+          # PATCH
+          application_patch_body = {'last_available_at' => subject.send(:check_time), 'last_checked_at' => subject.send(:check_time)}.to_json
+          source_patch_body = {'availability_status' => described_class::STATUS_AVAILABLE, 'last_available_at' => subject.send(:check_time), 'last_checked_at' => subject.send(:check_time)}.to_json
+
+          stub_patch(:source, source_patch_body)
+          stub_patch(:application, application_patch_body)
+
+          # Check
+          expect(subject).not_to receive(:connection_check)
+          subject.availability_check
+
+          assert_patch(:source, source_patch_body)
+          assert_patch(:application, application_patch_body)
+        end
       end
     end
 
     context "when it is unavailable" do
-      it "updates the availability status to unavailable" do
-        # GET
-        stub_not_found(:endpoint)
-        stub_get(:application, list_applications_unavailable_response)
-        # PATCH
-        application_patch_body = {'last_checked_at' => subject.send(:check_time)}.to_json
-        source_patch_body = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'last_checked_at' => subject.send(:check_time)}.to_json
+      context 'kafka' do
+        it "updates the availability status to unavailable" do
+          stub_not_found(:endpoint)
+          stub_get(:application, list_applications_unavailable_response)
 
-        stub_patch(:source, source_patch_body)
-        stub_patch(:application, application_patch_body)
+          expect(subject).to receive(:connection_status).and_return([status_unavailable, error_message])
 
-        # Check
-        expect(subject).not_to receive(:connection_check)
-        subject.availability_check
+          expect(kafka_client).to receive(:publish_message).with(
+            kafka_message("Source", source_id, status_unavailable)
+          )
 
-        assert_patch(:source, source_patch_body)
-        assert_patch(:application, application_patch_body)
+          expect(kafka_client).to receive(:publish_message).with(
+            kafka_message("Application", application_id, status_unavailable)
+          )
+
+          subject.availability_check
+        end
+      end
+
+      context 'sources_api' do
+        before do
+          subject.send(:updates_via_kafka=, false)
+        end
+
+        it "updates the availability status to unavailable" do
+          # GET
+          stub_not_found(:endpoint)
+          stub_get(:application, list_applications_unavailable_response)
+          # PATCH
+          application_patch_body = {'last_checked_at' => subject.send(:check_time)}.to_json
+          source_patch_body = {'availability_status' => described_class::STATUS_UNAVAILABLE, 'last_checked_at' => subject.send(:check_time)}.to_json
+
+          stub_patch(:source, source_patch_body)
+          stub_patch(:application, application_patch_body)
+
+          # Check
+          expect(subject).not_to receive(:connection_check)
+          subject.availability_check
+
+          assert_patch(:source, source_patch_body)
+          assert_patch(:application, application_patch_body)
+        end
       end
     end
   end

data/spec/topological_inventory/providers/common/operations/processor_spec.rb

@@ -0,0 +1,71 @@
+require "topological_inventory/providers/common/operations/processor"
+
+RSpec.describe TopologicalInventory::Providers::Common::Operations::Processor do
+  let(:operation_name) { 'Source.availability_check' }
+  let(:params) { {'source_id' => 1, 'external_tenant' => '12345'} }
+  let(:payload) { {"params" => params, "request_context" => double('request_context')} }
+  let(:message) { double("ManageIQ::Messaging::ReceivedMessage", :message => operation_name, :payload => payload) }
+
+  subject { described_class.new(message, nil) }
+
+  describe "#process" do
+    it "starts the operation if class and method exists" do
+      result = double('result')
+
+      klass = TopologicalInventory::Providers::Common::Operations::Source
+      allow(subject).to receive(:operation_class).and_return(klass)
+
+      source = klass.new(params, payload['request_context'], nil)
+      expect(klass).to receive(:new).with(params, payload['request_context'], nil).and_return(source)
+      expect(source).to receive(:availability_check).and_return(result)
+
+      expect(subject.process).to eq(result)
+    end
+
+    it "returns 'not_implemented' if class of method doesn't exist" do
+      allow(subject).to receive(:operation_class).and_return(nil)
+      allow(subject).to receive(:method).and_return('awesome')
+
+      expect(subject.process).to eq(subject.operation_status[:not_implemented])
+    end
+
+    it "updates task if not_implemented" do
+      allow(subject).to receive(:operation_class).and_return(nil)
+      allow(subject).to receive(:method).and_return('awesome')
+
+      subject.send(:params)['task_id'] = '1'
+      expect(subject).to(receive(:update_task).with('1',
+                                                    :state   => "completed",
+                                                    :status  => "error",
+                                                    :context => anything))
+      subject.process
+    end
+
+    it "updates task if exception raised" do
+      subject.send(:params)['task_id'] = '1'
+      expect(subject).to(receive(:update_task).with('1',
+                                                    :state   => "completed",
+                                                    :status  => "error",
+                                                    :context => anything))
+      expect { subject.process }.to raise_exception(NotImplementedError)
+    end
+  end
+
+  describe "#with_time_measure" do
+    let(:metrics) { double("Metrics") }
+
+    it "records time and yields if metrics provided" do
+      allow(subject).to receive(:metrics).and_return(metrics)
+
+      expect(metrics).to receive(:record_operation_time).with(operation_name).and_yield
+
+      expect(subject.send(:with_time_measure) { 42 }).to eq(42)
+    end
+
+    it "only yields if metrics not present" do
+      expect(metrics).not_to receive(:record_operation_time)
+
+      expect(subject.send(:with_time_measure) { 42 }).to eq(42)
+    end
+  end
+end

data/topological_inventory-providers-common.gemspec

@@ -26,16 +26,20 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'activesupport', '~> 5.2.4.3'
   spec.add_runtime_dependency 'config', '~> 1.7', '>= 1.7.2'
   spec.add_runtime_dependency 'json', '~> 2.3'
-  spec.add_runtime_dependency "manageiq-loggers", ">= 0.4.2"
-  spec.add_runtime_dependency "sources-api-client", "~> 3.0"
-  spec.add_runtime_dependency "topological_inventory-api-client", "~> 3.0", ">= 3.0.1"
-  spec.add_runtime_dependency "topological_inventory-ingress_api-client", "~> 1.0", ">= 1.0.3"
+  spec.add_runtime_dependency 'manageiq-loggers', '>= 0.4.2'
+  spec.add_runtime_dependency 'manageiq-messaging', '~> 1.0.0'
+  spec.add_runtime_dependency 'more_core_extensions'
+  spec.add_runtime_dependency 'prometheus_exporter', '~> 0.4.17'
+  spec.add_runtime_dependency 'sources-api-client', '~> 3.0'
+  spec.add_runtime_dependency 'topological_inventory-api-client', '~> 3.0', '>= 3.0.1'
+  spec.add_runtime_dependency 'topological_inventory-ingress_api-client', '~> 1.0', '>= 1.0.3'
 
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", ">= 12.3.3"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency 'rubocop', '~>0.69.0'
-  spec.add_development_dependency 'rubocop-performance', '~>1.3'
-  spec.add_development_dependency "simplecov", "~> 0.17.1"
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 1.0.0'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.8'
+  spec.add_development_dependency 'rubocop-rails', '~> 2.8'
+  spec.add_development_dependency 'simplecov', '~> 0.17.1'
   spec.add_development_dependency 'webmock'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: topological_inventory-providers-common
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Martin Slemr
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-20 00:00:00.000000000 Z
+date: 2020-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -72,6 +72,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.4.2
+- !ruby/object:Gem::Dependency
+  name: manageiq-messaging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: more_core_extensions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: prometheus_exporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.17
 - !ruby/object:Gem::Dependency
   name: sources-api-client
   requirement: !ruby/object:Gem::Requirement
@@ -174,28 +216,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.69.0
+        version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.69.0
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '2.8'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -231,6 +287,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".github/workflows/gem-push.yml"
 - ".gitignore"
 - ".rspec"
@@ -238,6 +295,7 @@ files:
 - ".rubocop_cc.yml"
 - ".rubocop_local.yml"
 - ".travis.yml"
+- ".yamllint"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -252,11 +310,15 @@ files:
 - lib/topological_inventory/providers/common/collector/parser.rb
 - lib/topological_inventory/providers/common/collectors_pool.rb
 - lib/topological_inventory/providers/common/logging.rb
+- lib/topological_inventory/providers/common/messaging_client.rb
+- lib/topological_inventory/providers/common/metrics.rb
 - lib/topological_inventory/providers/common/mixins/sources_api.rb
+- lib/topological_inventory/providers/common/mixins/statuses.rb
 - lib/topological_inventory/providers/common/mixins/topology_api.rb
 - lib/topological_inventory/providers/common/mixins/x_rh_headers.rb
 - lib/topological_inventory/providers/common/operations/async_worker.rb
 - lib/topological_inventory/providers/common/operations/health_check.rb
+- lib/topological_inventory/providers/common/operations/processor.rb
 - lib/topological_inventory/providers/common/operations/source.rb
 - lib/topological_inventory/providers/common/save_inventory/exception.rb
 - lib/topological_inventory/providers/common/save_inventory/saver.rb
@@ -272,6 +334,7 @@ files:
 - spec/topological_inventory/providers/common/collectors_pool_spec.rb
 - spec/topological_inventory/providers/common/logger_spec.rb
 - spec/topological_inventory/providers/common/operations/async_worker_spec.rb
+- spec/topological_inventory/providers/common/operations/processor_spec.rb
 - spec/topological_inventory/providers/common/operations/source_spec.rb
 - spec/topological_inventory/providers/common/save_inventory/saver_spec.rb
 - spec/topological_inventory/providers/common_spec.rb