topological_inventory-providers-common 1.0.9 → 2.1.0

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

@@ -0,0 +1,92 @@
+require "sources-api-client"
+
+module TopologicalInventory
+  module Providers
+    module Common
+      class SourcesApiClient < ::SourcesApiClient::ApiClient
+        delegate :update_source, :update_endpoint, :update_application, :to => :api
+
+        INTERNAL_API_PATH = '//internal/v1.0'.freeze
+
+        def initialize(identity = nil)
+          super(::SourcesApiClient::Configuration.default)
+          self.identity = identity
+          self.api      = init_default_api
+        end
+
+        def init_default_api
+          default_headers.merge!(identity) if identity.present?
+          ::SourcesApiClient::DefaultApi.new(self)
+        end
+
+        def fetch_default_endpoint(source_id)
+          endpoints = api.list_source_endpoints(source_id)&.data || []
+          endpoints.find(&:default)
+        end
+
+        def fetch_application(source_id)
+          applications = api.list_source_applications(source_id)&.data || []
+          applications.first
+        end
+
+        def fetch_authentication(source_id, default_endpoint = nil, authtype = nil)
+          endpoint = default_endpoint || fetch_default_endpoint(source_id)
+          return if endpoint.nil?
+
+          endpoint_authentications = api.list_endpoint_authentications(endpoint.id.to_s).data || []
+          return if endpoint_authentications.empty?
+
+          auth_id = if authtype.nil?
+                      endpoint_authentications.first&.id
+                    else
+                      endpoint_authentications.detect { |a| a.authtype = authtype }&.id
+                    end
+          return if auth_id.nil?
+
+          fetch_authentication_with_password(auth_id)
+        end
+
+        private
+
+        attr_accessor :identity, :api, :custom_base_path
+
+        def fetch_authentication_with_password(auth_id)
+          on_internal_api do
+            local_var_path = "/authentications/#{auth_id}"
+
+            query_params = "expose_encrypted_attribute[]=password"
+
+            header_params = {'Accept' => select_header_accept(['application/json'])}
+            return_type   = 'Authentication'
+            data, _, _    = call_api(:GET, local_var_path,
+                                     :header_params => header_params,
+                                     :query_params  => query_params,
+                                     :auth_names    => ['UserSecurity'],
+                                     :return_type   => return_type)
+            data
+          end
+        end
+
+        def build_request_url(path)
+          # Add leading and trailing slashes to path
+          path = "/#{path}".gsub(/\/+/, '/')
+          URI.encode((custom_base_url || @config.base_url) + path)
+        end
+
+        def custom_base_url
+          return nil if custom_base_path.nil?
+
+          url = "#{@config.scheme}://#{[@config.host, custom_base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '')
+          URI.encode(url)
+        end
+
+        def on_internal_api
+          self.custom_base_path = INTERNAL_API_PATH
+          yield
+        ensure
+          self.custom_base_path = nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require "topological_inventory-api-client"
+
+module TopologicalInventory
+  module Providers
+    module Common
+      class TopologyApiClient < ::TopologicalInventoryApiClient::ApiClient
+        attr_accessor :api
+
+        def initialize(identity = nil)
+          super(::TopologicalInventoryApiClient::Configuration.default)
+
+          self.identity = identity
+          self.api      = init_default_api
+        end
+
+        def init_default_api
+          default_headers.merge!(identity) if identity.present?
+          ::TopologicalInventoryApiClient::DefaultApi.new(self)
+        end
+
+        def update_task(task_id, source_id: nil, state:, status:, target_type: nil, target_source_ref: nil, context: nil)
+          params                      = {'state'  => state,
+                                         'status' => status}
+          params['context']           = context if context
+          params['source_id']         = source_id if source_id
+          params['target_type']       = target_type if target_type
+          params['target_source_ref'] = target_source_ref if target_source_ref
+          task                        = TopologicalInventoryApiClient::Task.new(params)
+          api.update_task(task_id, task)
+        end
+
+        def svc_instance_url(service_instance)
+          rest_api_path = '/service_instances/{id}'.sub('{' + 'id' + '}', service_instance&.id.to_s)
+          build_request(:GET, rest_api_path).url
+        end
+
+        private
+
+        attr_accessor :identity
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 module TopologicalInventory
   module Providers
     module Common
-      VERSION = "1.0.9"
+      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(:api_client)
-      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