topological_inventory-providers-common 1.0.12 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b81c523169c3ca87e678e3e7d046b4daee863200cf4eadd695e9022d17a11e5a
-  data.tar.gz: 1fc2a47cedf6f8d3b41f0df728a5ac8ceceaea03b58d43ef67da90680861c0eb
+  metadata.gz: 134e945b201072b8bdd7fc6af73b04a6f60698da831ef3989ab973453a1a5159
+  data.tar.gz: 20e4f260c411551572b557f4e4454fdc03c9e3b2ac9c8f5997e6600780298c1a
 SHA512:
-  metadata.gz: 9afb8ba326d632ba59245d93837f32bd8edbcb34b3d82e029c351f904bb75f196592eb4724116a48caf0b7df8fc7f4101f5b59bd0e23b65d6fca25ada3ac4cb6
-  data.tar.gz: '00924d04d1fc4623cd4e0f0a719c5471dbd39635820375b4957278db1c6e3ecbdf2b58c25758bca22e91e979511286708279922919f6303118401e58ac9cc5c4'
+  metadata.gz: 0a847566f6fb20e9518faef660c626788e6afd20d26cec28a5899e645c68cedd7c017974d0cb1c3c2524253007386b9728a1bb67a0f0a9101fe62bd388f03ccb
+  data.tar.gz: 6e786659b1bf913fe1e22d9c0618986d03dc4bc169d782e446ecd089b97a136b639f83be85c562006dccde83a8d025b102863b565aa571746767fa292e4dae89

data/CHANGELOG.md

@@ -4,17 +4,20 @@ 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]
+Operations/API clients refactoring
+
 ## [1.0.12] - 2020-10-01
 Add Operations Async Worker class #55
 
-## [1.0.11]
+## [1.0.11] - 2020-09-04
 Make Collector Poll Time a parameter so we can tweak the collection interval #51
 
-## [1.0.10]
+## [1.0.10] - 2020-08-26
 Add HealthCheck class for operations workers #48
 Set the LOG_LEVEL if present #50
 
-## [1.0.9]
+## [1.0.9] - 2020-08-17
 Added refresh-type to save and sweep inventory #45
 
 ## [1.0.8] - 2020-08-12
@@ -59,7 +62,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/v1.0.12...HEAD
+[Unreleased]: https://github.com/RedHatInsights/topological_inventory-providers-common/compare/v2.0.0...HEAD
+[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
 [1.0.10]: https://github.com/RedHatInsights/topological_inventory-providers-common/compare/v1.0.9...v1.0.10

data/lib/topological_inventory/providers/common.rb

@@ -1,7 +1,5 @@
 require "topological_inventory/providers/common/version"
 require "topological_inventory/providers/common/logging"
-require "topological_inventory/providers/common/operations/processor"
-require "topological_inventory/providers/common/operations/endpoint_client"
 require "topological_inventory/providers/common/operations/health_check"
 require "topological_inventory/providers/common/collectors_pool"
 require "topological_inventory/providers/common/collector"

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

@@ -23,11 +23,14 @@ module TopologicalInventory
         end
 
         def availability_check(message, severity = :info)
-          log_with_prefix("Source#availability_check", message, severity)
+          send("#{severity}_ext", "Source#availability_check", message)
         end
 
-        def log_with_prefix(prefix, message, severity)
-          send(severity, "#{prefix} - #{message}") if respond_to?(severity)
+        %w[debug info warn error fatal].each do |severity|
+          define_method("#{severity}_ext".to_sym) do |prefix, message|
+            ext_message = [prefix, message].compact.join(' - ')
+            send(severity, ext_message)
+          end
         end
       end
 

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

@@ -0,0 +1,58 @@
+require "topological_inventory/providers/common/sources_api_client"
+
+module TopologicalInventory
+  module Providers
+    module Common
+      module Mixins
+        module SourcesApi
+          AUTH_NOT_NECESSARY = "n/a".freeze
+
+          def sources_api
+            @sources_api ||= TopologicalInventory::Providers::Common::SourcesApiClient.new(identity)
+          end
+
+          def endpoint
+            @endpoint ||= sources_api.fetch_default_endpoint(source_id)
+          rescue => e
+            logger.error_ext(operation, "Failed to fetch Endpoint for Source #{source_id}: #{e.message}")
+            nil
+          end
+
+          def authentication
+            @authentication ||= if endpoint.receptor_node.present?
+                                  AUTH_NOT_NECESSARY
+                                else
+                                  sources_api.fetch_authentication(source_id, endpoint)
+                                end
+          rescue => e
+            logger.error_ext(operation, "Failed to fetch Authentication for Source #{source_id}: #{e.message}")
+            nil
+          end
+
+          def application
+            @application ||= sources_api.fetch_application(source_id)
+          rescue => e
+            logger.error_ext(operation, "Failed to fetch Application for Source #{source_id}: #{e.message}")
+            nil
+          end
+
+          def on_premise?
+            @on_premise ||= endpoint&.receptor_node.to_s.strip.present?
+          end
+
+          def verify_ssl_mode
+            endpoint&.verify_ssl ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+          end
+
+          def full_hostname(endpoint)
+            if on_premise?
+              "receptor://#{endpoint.receptor_node}"
+            else
+              endpoint.host.tap { |host| host << ":#{endpoint.port}" if endpoint.port }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require "topological_inventory/providers/common/topology_api_client"
+
+module TopologicalInventory
+  module Providers
+    module Common
+      module Mixins
+        module TopologyApi
+          # @identity attr_reader is expected
+          def topology_api
+            @topology_api ||= TopologicalInventory::Providers::Common::TopologyApiClient.new(identity)
+          end
+
+          def update_task(task_id, source_id: nil, state:, status:, target_type: nil, target_source_ref: nil, context: nil)
+            topology_api.update_task(task_id,
+                                     :source_id         => source_id,
+                                     :state             => state,
+                                     :status            => status,
+                                     :target_type       => target_type,
+                                     :target_source_ref => target_source_ref,
+                                     :context           => context)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module TopologicalInventory
+  module Providers
+    module Common
+      module Mixins
+        module XRhHeaders
+          def account_number_by_identity(identity)
+            return @account_number if @account_number
+            return if identity.try(:[], 'x-rh-identity').nil?
+
+            identity_hash = JSON.parse(Base64.decode64(identity['x-rh-identity']))
+            @account_number = identity_hash.dig('identity', 'account_number')
+          rescue JSON::ParserError => e
+            logger.error_ext(operation, "Failed to parse identity header: #{e.message}")
+            nil
+          end
+
+          def identity_by_account_number(account_number)
+            @identity ||= {"x-rh-identity" => Base64.strict_encode64({"identity" => {"account_number" => account_number, "user" => {"is_org_admin" => true}}}.to_json)}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,194 +1,169 @@
 require "topological_inventory/providers/common/logging"
 require "active_support/core_ext/numeric/time"
-require "topological_inventory/providers/common/operations/sources_api_client"
+require "topological_inventory/providers/common/mixins/sources_api"
+require "topological_inventory/providers/common/mixins/x_rh_headers"
 
 module TopologicalInventory
   module Providers
-  module Common
-    module Operations
-      class Source
-        include Logging
+    module Common
+      module Operations
+        class Source
+          include Logging
+          include Mixins::SourcesApi
+          include Mixins::XRhHeaders
 
-        STATUS_AVAILABLE, STATUS_UNAVAILABLE = %w[available unavailable].freeze
+          STATUS_AVAILABLE, STATUS_UNAVAILABLE = %w[available unavailable].freeze
 
-        ERROR_MESSAGES = {
-          :authentication_not_found          => "Authentication not found in Sources API",
-          :endpoint_or_application_not_found => "Endpoint or Application not found in Sources API",
-        }.freeze
+          ERROR_MESSAGES = {
+            :authentication_not_found          => "Authentication not found in Sources API",
+            :endpoint_or_application_not_found => "Endpoint or Application not found in Sources API",
+          }.freeze
 
-        LAST_CHECKED_AT_THRESHOLD = 5.minutes.freeze
-        AUTH_NOT_NECESSARY = "n/a".freeze
+          LAST_CHECKED_AT_THRESHOLD = 5.minutes.freeze
+          AUTH_NOT_NECESSARY        = "n/a".freeze
 
-        attr_accessor :params, :request_context, :source_id, :account_number
+          attr_accessor :identity, :operation, :params, :request_context, :source_id, :account_number
 
-        def initialize(params = {}, request_context = nil)
-          self.params          = params
-          self.request_context = request_context
-          self.source_id       = params['source_id']
-          self.account_number  = params['external_tenant']
-        end
+          def initialize(params = {}, request_context = nil)
+            self.operation       = 'Source'
+            self.params          = params
+            self.request_context = request_context
+            self.source_id       = params['source_id']
 
-        def availability_check
-          return if params_missing?
+            self.account_number  = params['external_tenant']
+            self.identity        = identity_by_account_number(account_number)
+          end
 
-          return if checked_recently?
+          def availability_check
+            self.operation += '#availability_check'
 
-          status, error_message = connection_status
+            return if params_missing?
 
-          update_source_and_subresources(status, error_message)
+            return if checked_recently?
 
-          logger.availability_check("Completed: Source #{source_id} is #{status}")
-        end
+            status, error_message = connection_status
 
-        private
-
-        def required_params
-          %w[source_id]
-        end
+            update_source_and_subresources(status, error_message)
 
-        def params_missing?
-          is_missing = false
-          required_params.each do |attr|
-            if (is_missing = params[attr].blank?)
-              logger.availability_check("Missing #{attr} for the availability_check request [Source ID: #{source_id}]", :error)
-              break
-            end
+            logger.availability_check("Completed: Source #{source_id} is #{status}")
           end
 
-          is_missing
-        end
-
-        def checked_recently?
-          checked_recently = if endpoint.present?
-                               endpoint.last_checked_at.present? && endpoint.last_checked_at >= LAST_CHECKED_AT_THRESHOLD.ago
-                             elsif application.present?
-                               application.last_checked_at.present? && application.last_checked_at >= LAST_CHECKED_AT_THRESHOLD.ago
-                             end
+          private
 
-          logger.availability_check("Skipping, last check at #{endpoint.last_checked_at || application.last_checked_at} [Source ID: #{source_id}] ") if checked_recently
-
-          checked_recently
-        end
+          def required_params
+            %w[source_id]
+          end
 
-        def connection_status
-          # we need either an endpoint or application to check the source.
-          return [STATUS_UNAVAILABLE, ERROR_MESSAGES[:endpoint_or_application_not_found]] unless endpoint || application
+          def params_missing?
+            is_missing = false
+            required_params.each do |attr|
+              if (is_missing = params[attr].blank?)
+                logger.availability_check("Missing #{attr} for the availability_check request [Source ID: #{source_id}]", :error)
+                break
+              end
+            end
 
-          check_time
-          if endpoint
-            endpoint_connection_check
-          elsif application
-            application_connection_check
+            is_missing
           end
-        end
 
-        def endpoint_connection_check
-          return [STATUS_UNAVAILABLE, ERROR_MESSAGES[:authentication_not_found]] unless authentication
+          def checked_recently?
+            checked_recently = if endpoint.present?
+                                 endpoint.last_checked_at.present? && endpoint.last_checked_at >= LAST_CHECKED_AT_THRESHOLD.ago
+                               elsif application.present?
+                                 application.last_checked_at.present? && application.last_checked_at >= LAST_CHECKED_AT_THRESHOLD.ago
+                               end
 
-          # call down into the operations pod implementation of `Source#connection_check`
-          connection_check
-        end
+            logger.availability_check("Skipping, last check at #{endpoint.last_checked_at || application.last_checked_at} [Source ID: #{source_id}] ") if checked_recently
 
-        def application_connection_check
-          case application.availability_status
-          when "available"
-            [STATUS_AVAILABLE, nil]
-          when "unavailable"
-            [STATUS_UNAVAILABLE, "Application id #{application.id} unavailable"]
+            checked_recently
           end
-        end
 
-        # @return [Array<String, String|nil] - STATUS_[UN]AVAILABLE, error message
-        def connection_check
-          raise NotImplementedError, "#{__method__} must be implemented in a subclass"
-        end
-
-        def update_source_and_subresources(status, error_message = nil)
-          logger.availability_check("Updating source [#{source_id}] status [#{status}] message [#{error_message}]")
+          def connection_status
+            # we need either an endpoint or application to check the source.
+            return [STATUS_UNAVAILABLE, ERROR_MESSAGES[:endpoint_or_application_not_found]] unless endpoint || application
 
-          update_source(status)
+            check_time
+            if endpoint
+              endpoint_connection_check
+            elsif application
+              application_connection_check
+            end
+          end
 
-          update_endpoint(status, error_message) if endpoint
-          update_application(status) if application
-        end
+          def endpoint_connection_check
+            return [STATUS_UNAVAILABLE, ERROR_MESSAGES[:authentication_not_found]] unless authentication
 
-        def update_source(status)
-          source = ::SourcesApiClient::Source.new
-          source.availability_status = status
-          source.last_checked_at     = check_time
-          source.last_available_at   = check_time if status == STATUS_AVAILABLE
+            # call down into the operations pod implementation of `Source#connection_check`
+            connection_check
+          end
 
-          api_client.update_source(source_id, source)
-        rescue ::SourcesApiClient::ApiError => e
-          logger.availability_check("Failed to update Source id:#{source_id} - #{e.message}", :error)
-        end
+          def application_connection_check
+            case application.availability_status
+            when "available"
+              [STATUS_AVAILABLE, nil]
+            when "unavailable"
+              [STATUS_UNAVAILABLE, "Application id #{application.id} unavailable"]
+            end
+          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)
-            return
+          # @return [Array<String, String|nil] - STATUS_[UN]AVAILABLE, error message
+          def connection_check
+            raise NotImplementedError, "#{__method__} must be implemented in a subclass"
           end
 
-          endpoint_update = ::SourcesApiClient::Endpoint.new
+          def update_source_and_subresources(status, error_message = nil)
+            logger.availability_check("Updating source [#{source_id}] status [#{status}] message [#{error_message}]")
 
-          endpoint_update.availability_status       = status
-          endpoint_update.availability_status_error = error_message.to_s
-          endpoint_update.last_checked_at           = check_time
-          endpoint_update.last_available_at         = check_time if status == STATUS_AVAILABLE
+            update_source(status)
 
-          api_client.update_endpoint(endpoint.id, endpoint_update)
-        rescue ::SourcesApiClient::ApiError => e
-          logger.availability_check("Failed to update Endpoint(ID: #{endpoint.id}) - #{e.message}", :error)
-        end
+            update_endpoint(status, error_message) if endpoint
+            update_application(status) if application
+          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
+          def update_source(status)
+            source                     = ::SourcesApiClient::Source.new
+            source.availability_status = status
+            source.last_checked_at     = check_time
+            source.last_available_at   = check_time if status == STATUS_AVAILABLE
 
-          api_client.update_application(application.id, application_update)
-        rescue ::SourcesApiClient::ApiError => e
-          logger.availability_check("Failed to update Application id: #{application.id} - #{e.message}", :error)
-        end
+            sources_api.update_source(source_id, source)
+          rescue ::SourcesApiClient::ApiError => e
+            logger.availability_check("Failed to update Source id:#{source_id} - #{e.message}", :error)
+          end
 
-        def endpoint
-          @endpoint ||= api_client.fetch_default_endpoint(source_id)
-        rescue => e
-          logger.availability_check("Failed to fetch Endpoint for Source #{source_id}: #{e.message}", :error)
-          nil
-        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)
+              return
+            end
 
-        def authentication
-          @authentication ||= if endpoint.receptor_node.present?
-                                AUTH_NOT_NECESSARY
-                              else
-                                api_client.fetch_authentication(source_id, endpoint)
-                              end
-        rescue => e
-          logger.availability_check("Failed to fetch Authentication for Source #{source_id}: #{e.message}", :error)
-          nil
-        end
+            endpoint_update = ::SourcesApiClient::Endpoint.new
 
-        def application
-          @application ||= api_client.fetch_application(source_id)
-        rescue => e
-          logger.availability_check("Failed to fetch Application for Source #{source_id}: #{e.message}", :error)
-          nil
-        end
+            endpoint_update.availability_status       = status
+            endpoint_update.availability_status_error = error_message.to_s
+            endpoint_update.last_checked_at           = check_time
+            endpoint_update.last_available_at         = check_time if status == STATUS_AVAILABLE
 
-        def check_time
-          @check_time ||= Time.now.utc
-        end
+            sources_api.update_endpoint(endpoint.id, endpoint_update)
+          rescue ::SourcesApiClient::ApiError => e
+            logger.availability_check("Failed to update Endpoint(ID: #{endpoint.id}) - #{e.message}", :error)
+          end
 
-        def identity
-          @identity ||= {"x-rh-identity" => Base64.strict_encode64({"identity" => {"account_number" => account_number, "user" => {"is_org_admin" => true}}}.to_json)}
-        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
 
-        def api_client
-          @api_client ||= TopologicalInventory::Providers::Common::Operations::SourcesApiClient.new(identity)
+            sources_api.update_application(application.id, application_update)
+          rescue ::SourcesApiClient::ApiError => e
+            logger.availability_check("Failed to update Application id: #{application.id} - #{e.message}", :error)
+          end
+
+          def check_time
+            @check_time ||= Time.now.utc
+          end
         end
       end
     end
   end
-  end
 end

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.12"
+      VERSION = "2.0.0".freeze
     end
   end
 end

data/spec/support/shared/availability_check.rb

@@ -94,7 +94,7 @@ RSpec.shared_examples "availability_check" do
       stub_patch(:source, source_patch_body)
 
       # Check
-      api_client = subject.send(:api_client)
+      api_client = subject.send(:sources_api)
       expect(api_client).not_to receive(:update_endpoint)
 
       subject.availability_check

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: topological_inventory-providers-common
 version: !ruby/object:Gem::Version
-  version: 1.0.12
+  version: 2.0.0
 platform: ruby
 authors:
 - Martin Slemr
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-05 00:00:00.000000000 Z
+date: 2020-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -252,15 +252,16 @@ 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/mixins/sources_api.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/endpoint_client.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/operations/sources_api_client.rb
-- lib/topological_inventory/providers/common/operations/topology_api_client.rb
 - lib/topological_inventory/providers/common/save_inventory/exception.rb
 - lib/topological_inventory/providers/common/save_inventory/saver.rb
+- lib/topological_inventory/providers/common/sources_api_client.rb
+- lib/topological_inventory/providers/common/topology_api_client.rb
 - lib/topological_inventory/providers/common/version.rb
 - spec/spec_helper.rb
 - spec/support/inventory_helper.rb
@@ -271,7 +272,6 @@ 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

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

@@ -1,65 +0,0 @@
-require "topological_inventory/providers/common/operations/topology_api_client"
-require "topological_inventory/providers/common/operations/sources_api_client"
-
-module TopologicalInventory
-  module Providers
-    module Common
-      module Operations
-        class EndpointClient
-          include TopologyApiClient
-
-          def initialize(source_id, task_id, identity = nil)
-            self.identity   = identity
-            self.source_id  = source_id
-            self.task_id    = task_id
-          end
-
-          def order_service(service_offering, service_plan, order_params)
-            raise NotImplementedError, "#{__method__} must be implemented in a subclass"
-          end
-
-          def source_ref_of(endpoint_svc_instance)
-            raise NotImplementedError, "#{__method__} must be implemented in a subclass"
-          end
-
-          def wait_for_provision_complete(source_id, endpoint_svc_instance, context = {})
-            raise NotImplementedError, "#{__method__} must be implemented in a subclass"
-          end
-
-          def provisioned_successfully?(endpoint_svc_instance)
-            raise NotImplementedError, "#{__method__} must be implemented in a subclass"
-          end
-
-          # Endpoint for conversion of provisioned service's status to
-          # TopologicalInventory Task's status
-          def task_status_for(endpoint_svc_instance)
-            raise NotImplementedError, "#{__method__} must be implemented in a subclass"
-          end
-
-          private
-
-          attr_accessor :identity, :task_id, :source_id
-
-          def sources_api
-            @sources_api ||= SourcesApiClient.new(identity)
-          end
-
-          def default_endpoint
-            @default_endpoint ||= sources_api.fetch_default_endpoint(source_id)
-            raise "Sources API: Endpoint not found! (source id: #{source_id})" if @default_endpoint.nil?
-
-            @default_endpoint
-          end
-
-          def authentication
-            @authentication ||= sources_api.fetch_authentication(source_id, default_endpoint)
-          end
-
-          def verify_ssl_mode
-            default_endpoint.verify_ssl ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-require "topological_inventory/providers/common/operations/topology_api_client"
-
-module TopologicalInventory
-  module Providers
-    module Common
-      module Operations
-        class Processor
-          include Logging
-          include TopologyApiClient
-
-          SLEEP_POLL = 10
-          POLL_TIMEOUT = 1800
-
-          def self.process!(message)
-            model, method = message.headers['message_type'].to_s.split(".")
-            new(model, method, message.payload).process
-          end
-
-          # @param payload [Hash] https://github.com/ManageIQ/topological_inventory-api/blob/master/app/controllers/api/v0/service_plans_controller.rb#L32-L41
-          def initialize(model, method, payload, metrics = nil)
-            self.model           = model
-            self.method          = method
-            self.params          = payload["params"]
-            self.identity        = payload["request_context"]
-            self.metrics         = metrics
-          end
-
-          def process
-            logger.info("Processing #{model}##{method} [#{params}]...")
-            result = order_service(params)
-            logger.info("Processing #{model}##{method} [#{params}]...Complete")
-
-            result
-          end
-
-          private
-
-          attr_accessor :identity, :model, :method, :metrics, :params
-
-          def endpoint_client(source_id, task_id, identity)
-            raise NotImplementedError, "#{__method__} must be implemented in a subclass as kind of TopologicalInventory::Providers::Common::EndpointClient class"
-          end
-
-          def order_service(params)
-            task_id, service_offering_id, service_plan_id, order_params = params.values_at("task_id", "service_offering_id", "service_plan_id", "order_params")
-
-            service_plan     = topology_api_client.show_service_plan(service_plan_id) if service_plan_id.present?
-            service_offering_id = service_plan.service_offering_id if service_offering_id.nil? && service_plan.present?
-            service_offering = topology_api_client.show_service_offering(service_offering_id)
-
-            source_id        = service_offering.source_id
-            client = endpoint_client(source_id, task_id, identity)
-
-            logger.info("Ordering #{service_offering.name}...")
-            remote_service_instance = client.order_service(service_offering, service_plan.presence, order_params)
-            logger.info("Ordering #{service_offering.name}...Complete")
-
-            poll_order_complete_thread(task_id, source_id, remote_service_instance)
-          rescue StandardError => err
-            metrics&.record_error
-            logger.error("[Task #{task_id}] Ordering error: #{err}\n#{err.backtrace.join("\n")}")
-            update_task(task_id, :state => "completed", :status => "error", :context => {:error => err.to_s})
-          end
-
-          def poll_order_complete_thread(task_id, source_id, remote_svc_instance)
-            Thread.new do
-              begin
-                poll_order_complete(task_id, source_id, remote_svc_instance)
-              rescue StandardError => err
-                logger.error("[Task #{task_id}] Waiting for complete: #{err}\n#{err.backtrace.join("\n")}")
-                update_task(task_id, :state => "completed", :status => "warn", :context => {:error => err.to_s})
-              end
-            end
-          end
-
-          def poll_order_complete(task_id, source_id, remote_svc_instance)
-            client = endpoint_client(source_id, task_id, identity)
-
-            context = {
-              :service_instance => {
-                :source_id  => source_id,
-                :source_ref => client.source_ref_of(remote_svc_instance)
-              }
-            }
-
-            remote_svc_instance = client.wait_for_provision_complete(task_id, remote_svc_instance, context)
-
-            if client.provisioned_successfully?(remote_svc_instance)
-              if (service_instance = load_topological_svc_instance(source_id, client.source_ref_of(remote_svc_instance))).present?
-                context[:service_instance][:id] = service_instance.id
-                context[:service_instance][:url] = svc_instance_url(service_instance)
-              else
-                logger.warn("Failed to get service_instance API URL (endpoint's service instance: #{remote_svc_instance.inspect})")
-              end
-            end
-            update_task(task_id, :state => "completed", :status => client.task_status_for(remote_svc_instance), :context => context)
-          end
-
-          def load_topological_svc_instance(source_id, source_ref)
-            api = topology_api_client.api_client
-
-            count = 0
-            timeout_count = POLL_TIMEOUT / SLEEP_POLL
-
-            header_params = { 'Accept' => api.select_header_accept(['application/json']) }
-            query_params = { :'source_id' => source_id, :'source_ref' => source_ref }
-            return_type = 'ServiceInstancesCollection'
-
-            service_instance = nil
-            loop do
-              data, _status_code, _headers = api.call_api(:GET, "/service_instances",
-                                                          :header_params => header_params,
-                                                          :query_params  => query_params,
-                                                          :auth_names    => ['UserSecurity'],
-                                                          :return_type   => return_type)
-
-              service_instance = data.data&.first if data.meta.count > 0
-              break if service_instance.present?
-
-              break if (count += 1) >= timeout_count
-
-              sleep(SLEEP_POLL) # seconds
-            end
-
-            if service_instance.nil?
-              logger.error("Failed to find service_instance by source_id [#{source_id}] source_ref [#{source_ref}]")
-            end
-
-            service_instance
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,94 +0,0 @@
-require "sources-api-client"
-
-module TopologicalInventory
-  module Providers
-    module Common
-      module Operations
-        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
-end

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

@@ -1,28 +0,0 @@
-module TopologicalInventory
-  module Providers
-    module Common
-      module Operations
-        module TopologyApiClient
-          def topology_api_client
-            @topology_api_client ||=
-              begin
-                api_client = TopologicalInventoryApiClient::ApiClient.new
-                api_client.default_headers.merge!(identity) if identity.present?
-                TopologicalInventoryApiClient::DefaultApi.new(api_client)
-              end
-          end
-
-          def update_task(task_id, state:, status:, context:)
-            task = TopologicalInventoryApiClient::Task.new("state" => state, "status" => status, "context" => context)
-            topology_api_client.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)
-            topology_api_client.api_client.build_request(:GET, rest_api_path).url
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,102 +0,0 @@
-require "topological_inventory/providers/common/operations/processor"
-
-RSpec.describe TopologicalInventory::Providers::Common::Operations::Processor do
-  let(:topology_api_client) { double }
-  let(:source_id) { 1 }
-  let(:source_ref) { 1000 }
-  let(:service_plan) { double("TopologicalInventoryApiClient::ServicePlan") }
-  let(:service_offering) { double("TopologicalInventoryApiClient::ServiceOffering") }
-
-  # Overriden in contexts
-  let(:payload) { {} }
-
-  before do
-    @processor = described_class.new(nil, nil, payload)
-    allow(@processor).to receive(:logger).and_return(double('null_object').as_null_object)
-
-    allow(service_plan).to receive(:service_offering_id).and_return(1)
-    allow(service_plan).to receive(:name).and_return(double)
-
-    allow(service_offering).to receive(:name).and_return(double)
-    allow(service_offering).to receive(:source_ref).and_return(source_ref)
-    allow(service_offering).to receive(:extra).and_return({:type => 'job_template'})
-    allow(service_offering).to receive(:source_id).and_return(source_id)
-
-    @endpoint_client = double
-    allow(@endpoint_client).to receive(:order_service)
-
-    allow(@processor).to receive(:endpoint_client).and_return(@endpoint_client)
-    allow(@processor).to receive(:topology_api_client).and_return(topology_api_client)
-    allow(topology_api_client).to receive(:update_task)
-    allow(topology_api_client).to receive(:show_service_plan).and_return(service_plan)
-    allow(topology_api_client).to receive(:show_service_offering).and_return(service_offering)
-  end
-
-  context "Order by ServicePlan" do
-    let(:payload) do
-      {
-        'request_context' => {"x-rh-identity" => 'abcd'},
-        'params'          => {
-          'order_params'    => {
-            'service_plan_id'             => 1,
-            'service_parameters'          => { :name   => "Job 1",
-                                               :param1 => "Test Topology",
-                                               :param2 => 50 },
-            'provider_control_parameters' => {}
-          },
-          'service_plan_id' => 1,
-          'task_id'         => 1 # in tp-inv api (Task)
-        }
-      }
-    end
-
-    describe "#order_service" do
-      it "orders job" do
-        allow(@processor).to receive(:poll_order_complete_thread).and_return(double)
-
-        expect(@endpoint_client).to receive(:order_service).with(service_offering, service_plan, payload['params']['order_params'])
-        @processor.send(:order_service, payload['params'])
-      end
-
-      it "updates task on error" do
-        err_message = "Sample error"
-
-        allow(@processor).to receive(:poll_order_complete_thread).and_return(double)
-        allow(@processor).to receive(:update_task).and_return(double)
-        allow(@endpoint_client).to receive(:order_service).and_raise(err_message)
-
-        expect(@processor).to receive(:update_task).with(payload['params']['task_id'], :state => "completed", :status => "error", :context => { :error => err_message })
-
-        @processor.send(:order_service, payload['params'])
-      end
-    end
-  end
-
-  context "Order by ServiceOffering" do
-    let(:payload) do
-      {
-        'request_context' => {"x-rh-identity" => 'abcd'},
-        'params'          => {
-          'order_params'    => {
-            'service_offering_id'             => 1,
-            'service_parameters'          => { :name   => "Job 1",
-                                               :param1 => "Test Topology",
-                                               :param2 => 50 },
-            'provider_control_parameters' => {}
-          },
-          'service_offering_id' => 1,
-          'task_id'         => 1 # in tp-inv api (Task)
-        }
-      }
-    end
-
-    describe "#order_service" do
-      it "orders job" do
-        allow(@processor).to receive(:poll_order_complete_thread).and_return(double)
-
-        expect(@endpoint_client).to receive(:order_service).with(service_offering, nil, payload['params']['order_params'])
-        @processor.send(:order_service, payload['params'])
-      end
-    end
-  end
-end