katello 4.1.4 → 4.2.0.rc1

data/app/lib/actions/pulp3/repository/repair.rb

@@ -23,6 +23,10 @@ module Actions
         def presenter
           Presenters::RepairPresenter.new(self)
         end
+
+        def rescue_strategy_for_self
+          Dynflow::Action::Rescue::Skip
+        end
       end
     end
   end

data/app/lib/katello/errors.rb

@@ -106,6 +106,7 @@ module Katello
 
     class CandlepinNotRunning < StandardError; end
     class CandlepinPoolGone < CandlepinError; end
+    class CandlepinEnvironmentGone < CandlepinError; end
 
     class Pulp3Error < StandardError; end
     class Pulp3MigrationError < StandardError; end

data/app/lib/katello/http_resource.rb

@@ -34,8 +34,25 @@ module Katello
       @json[key] = value
     end
 
+    REQUEST_MAP = {
+      get: Net::HTTP::Get,
+      post: Net::HTTP::Post,
+      put: Net::HTTP::Put,
+      delete: Net::HTTP::Delete
+    }.freeze
+
     class << self
-      # children must redefine
+      REQUEST_MAP.keys.each do |key|
+        define_method(key) do |*args|
+          issue_request(
+            method: key,
+            path: args.first,
+            headers: args.length > 1 ? args.last : nil,
+            payload: args.length > 2 ? args[1] : nil # non-GET method signatures use payload as the second argument, keeping headers as the last element
+          )
+        end
+      end
+
       def logger
         fail NotImplementedError
       end
@@ -64,64 +81,19 @@ module Katello
         fail RestClientException, {:message => message, :service_code => service_code, :code => status_code}, caller
       end
 
-      def print_debug_info(_a_path, headers = {}, payload = {})
+      def issue_request(method:, path:, headers: {}, payload: nil)
+        logger.debug("Resource #{method.upcase} request: #{path}")
         logger.debug "Headers: #{headers.to_json}"
         logger.debug "Body: #{filter_sensitive_data(payload.to_json)}"
-      end
 
-      def get(a_path, headers = {})
-        logger.debug "Resource GET request: #{a_path}"
-        print_debug_info(a_path, headers)
-        a_path = URI.encode(a_path)
-        client = rest_client(Net::HTTP::Get, :get, a_path)
-        result = process_response(client.get(headers))
-        result
-      rescue RestClient::Exception => e
-        raise_rest_client_exception e, a_path, "GET"
-      rescue Errno::ECONNREFUSED
-        service = a_path.split("/").second
-        raise Errors::ConnectionRefusedException, _("A backend service [ %s ] is unreachable") % service.capitalize
-      end
-
-      def post(a_path, payload = {}, headers = {})
-        logger.debug "Resource POST request: #{a_path}, #{payload}"
-        print_debug_info(a_path, headers, payload)
-        a_path = URI.encode(a_path)
-        client = rest_client(Net::HTTP::Post, :post, a_path)
-        result = process_response(client.post(payload, headers))
-        result
-      rescue RestClient::Exception => e
-        raise_rest_client_exception e, a_path, "POST"
-      rescue Errno::ECONNREFUSED
-        service = a_path.split("/").second
-        raise Katello::Errors::ConnectionRefusedException, _("A backend service [ %s ] is unreachable") % service.capitalize
-      end
+        client = rest_client(REQUEST_MAP[method], method, path)
+        args = [method, payload, headers].compact
 
-      def put(a_path, payload = {}, headers = {})
-        logger.debug "Resource PUT request: #{a_path}, #{payload}"
-        print_debug_info(a_path, headers, payload)
-        a_path = URI.encode(a_path)
-        client = rest_client(Net::HTTP::Put, :put, a_path)
-        result = process_response(client.put(payload, headers))
-        result
+        process_response(client.send(*args))
       rescue RestClient::Exception => e
-        raise_rest_client_exception e, a_path, "PUT"
+        raise_rest_client_exception e, path, method.upcase
       rescue Errno::ECONNREFUSED
-        service = a_path.split("/").second
-        raise Errors::ConnectionRefusedException, _("A backend service [ %s ] is unreachable") % service.capitalize
-      end
-
-      def delete(a_path = nil, headers = {})
-        logger.debug "Resource DELETE request: #{a_path}"
-        print_debug_info(a_path, headers)
-        a_path = URI.encode(a_path)
-        client = rest_client(Net::HTTP::Delete, :delete, a_path)
-        result = process_response(client.delete(headers))
-        result
-      rescue RestClient::Exception => e
-        raise_rest_client_exception e, a_path, "DELETE"
-      rescue Errno::ECONNREFUSED
-        service = a_path.split("/").second
+        service = path.split("/").second
         raise Errors::ConnectionRefusedException, _("A backend service [ %s ] is unreachable") % service.capitalize
       end
 
@@ -139,10 +111,6 @@ module Katello
         end
       end
 
-      def create_thing(request_type)
-        request_type.new
-      end
-
       # Creates a RestClient::Resource class with a signed OAuth style
       # Authentication header added to the request headers.
       def rest_client(http_type, method, path)
@@ -180,23 +148,8 @@ module Katello
         RestClient::Resource.new(url, options)
       end
 
-      # Encode url element if its not nil. This helper method is used mainly in resource path methods.
-      #
-      # @param [String] element to encode
-      # @return [String] encoded element or nil
-      def url_encode(element)
-        CGI.escape element.to_s unless element.nil?
-      end
-
       def hash_to_query(query_parameters)
-        query_parameters.inject("?") do |so_far, current|
-          so_far << "&" unless so_far == "?"
-          if current[1].is_a?(Array)
-            so_far << current[1].map { |attr| "#{current[0]}=#{attr}" }.join('&')
-          else
-            so_far << "#{current[0].to_s}=#{url_encode(current[1])}"
-          end
-        end
+        "?#{URI.encode_www_form(query_parameters)}"
       end
     end
   end

data/app/lib/katello/qpid/connection.rb

@@ -74,13 +74,11 @@ module Katello
       def initialize(url:, ssl_cert_file:, ssl_key_file:, ssl_ca_file:)
         @url = url
         ssl_domain = ::Qpid::Proton::SSLDomain.new(::Qpid::Proton::SSLDomain::MODE_CLIENT)
-        ssl_domain.peer_authentication(::Qpid::Proton::SSLDomain::VERIFY_PEER_NAME)
         ssl_domain.credentials(ssl_cert_file, ssl_key_file, nil) if ssl_cert_file && ssl_key_file
         ssl_domain.trusted_ca_db(ssl_ca_file) if ssl_ca_file
         @connection_options = {
           ssl_domain: ssl_domain,
-          sasl_allowed_mechs: 'external',
-          virtual_host: URI.parse(url).host
+          sasl_allowed_mechs: 'external'
         }
       end
 

data/app/lib/katello/resources/candlepin/consumer.rb

@@ -46,7 +46,7 @@ module Katello
 
           def create(env_id, parameters, activation_key_cp_ids)
             parameters['installedProducts'] ||= [] #if installed products is nil, candlepin won't attach custom products
-            url = "/candlepin/environments/#{url_encode(env_id)}/consumers/"
+            url = "/candlepin/environments/#{env_id}/consumers/"
             url += "?activation_keys=" + activation_key_cp_ids.join(",") if activation_key_cp_ids.length > 0
 
             response = self.post(url, parameters.to_json, self.default_headers).body

data/app/lib/katello/resources/candlepin/environment.rb

@@ -20,6 +20,8 @@ module Katello
 
           def destroy(id)
             self.delete(path(id), User.cp_oauth_header).code.to_i
+          rescue RestClient::NotFound => e
+            raise ::Katello::Errors::CandlepinEnvironmentGone, e.message
           end
 
           def path(id = '')

data/app/lib/katello/resources/registry.rb

@@ -23,30 +23,17 @@ module Katello
       class RegistryResource < HttpResource
         class << self
           def load_class
-            registry_url = nil
             pulp_primary = ::SmartProxy.pulp_primary
+            content_app_url = pulp_primary.setting(SmartProxy::PULP3_FEATURE, 'content_app_url')
 
-            # Pulp 3 has its own registry
-            if pulp_primary&.pulp3_repository_type_support?(::Katello::Repository::DOCKER_TYPE)
-              uri = URI(pulp_primary.setting(SmartProxy::PULP3_FEATURE, 'content_app_url'))
-              uri.path = "/pulpcore_registry/"
-              registry_url = uri.to_s
+            fail Errors::ContainerRegistryNotConfigured unless content_app_url
 
-              # Assume the registry uses the same CA as the Smart Proxy
-              ca_cert_file = Setting[:ssl_ca_file]
-            elsif (container_config = SETTINGS.dig(:katello, :container_image_registry))
-              registry_url = container_config[:crane_url]
-              ca_cert_file = container_config[:registry_ca_cert_file]
-            end
-
-            fail Errors::ContainerRegistryNotConfigured unless registry_url
-
-            uri = URI.parse(registry_url)
-            self.prefix = uri.path
+            uri = URI.parse(content_app_url)
+            self.prefix = "/pulpcore_registry/"
             self.site = "#{uri.scheme}://#{uri.host}:#{uri.port}"
-            self.ssl_client_cert = ::Cert::Certs.ssl_client_cert
-            self.ssl_client_key = ::Cert::Certs.ssl_client_key
-            self.ca_cert_file = ca_cert_file
+            self.ca_cert_file = Setting[:ssl_ca_file]
+            pulp_primary.pulp3_ssl_configuration(self)
+
             self
           end
 

data/app/lib/katello/util/http_proxy.rb

@@ -1,11 +1,8 @@
-require 'katello/util/proxy_uri'
-
 module Katello
   module Util
     module HttpProxy
       def proxy_uri
         #Reset the scheme to proxy(s) based on http or https to handle cgi unescaping in rest-client
-        # this relies on katello/util/proxy_uri
         if proxy
           scheme = 'proxy' if proxy_scheme == 'http'
           scheme = 'proxys' if proxy_scheme == 'https'

data/app/lib/katello/validators/gpg_key_content_validator.rb

@@ -33,7 +33,7 @@ module Katello
 
       def self.validate_line_length(record, attribute, value)
         value.each_line do |line|
-          record.errors[attribute] << _("must contain valid  Public GPG Key") if line.length > GpgKey::MAX_CONTENT_LINE_LENGTH
+          record.errors[attribute] << _("must contain valid  Public GPG Key") if line.length > ContentCredential::MAX_CONTENT_LINE_LENGTH
         end
       end
     end

data/app/models/katello/authorization/{gpg_key.rb → content_credential.rb}

@@ -1,5 +1,5 @@
 module Katello
-  module Authorization::GpgKey
+  module Authorization::ContentCredential
     extend ActiveSupport::Concern
 
     include Authorizable

data/app/models/katello/authorization/product.rb

@@ -31,10 +31,6 @@ module Katello
           authorized(:edit_products)
         end
 
-        def exportable
-          authorized(:export_products)
-        end
-
         def deletable
           authorized(:destroy_products)
         end

data/app/models/katello/concerns/host_managed_extensions.rb

@@ -85,7 +85,6 @@ module Katello
           property :subscription_manager_configuration_url, String, desc: 'Returns URL for subscription manager configuration'
           property :rhsm_organization_label, String, desc: 'Returns label of the Red Hat Subscription Manager organization'
           property :host_collections, array_of: 'HostCollection', desc: 'Returns list of the host collections the host belongs to'
-          property :comment, String, desc: 'Returns comment given to the host'
           property :pools, array_of: 'Pool', desc: 'Returns subscription pool objects associated with the host'
           property :hypervisor_host, 'Host', desc: 'Returns hypervisor host object of this host'
           property :lifecycle_environment, 'KTEnvironment', desc: 'Returns lifecycle environment object associated with the host'
@@ -215,15 +214,10 @@ module Katello
         new_ids = new_available_module_streams.keys - old_associated_ids
         new_ids.each do |new_id|
           module_stream = new_available_module_streams[new_id]
-          status = module_stream["status"]
-          # Set status to "unknown" only if the active field is in use and set to false and the module is enabled
-          if enabled_module_stream_inactive?(module_stream)
-            status = "unknown"
-          end
           self.host_available_module_streams.create!(host_id: self.id,
                                                      available_module_stream_id: new_id,
                                                      installed_profiles: module_stream["installed_profiles"],
-                                                     status: status)
+                                                     status: module_stream["status"])
         end
 
         upgradable_streams.each do |hams|
@@ -233,10 +227,6 @@ module Katello
           if hams.attributes.slice(*shared_keys) != module_stream_data
             hams.update!(module_stream_data)
           end
-          # Set status to "unknown" only if the active field is in use and set to false and the module is enabled
-          if enabled_module_stream_inactive?(module_stream)
-            hams.update!(status: "unknown")
-          end
         end
       end
 
@@ -356,17 +346,13 @@ module Katello
         self.get_status(::Katello::TraceStatus).refresh!
         self.refresh_global_status!
       end
-
-      def enabled_module_stream_inactive?(module_stream)
-        !module_stream["active"].nil? && module_stream["active"] == false && module_stream["status"] == "enabled"
-      end
     end
   end
 end
 
 class ::Host::Managed::Jail < Safemode::Jail
   allow :content_source, :subscription_manager_configuration_url, :rhsm_organization_label,
-        :host_collections, :comment, :pools, :hypervisor_host, :lifecycle_environment, :content_view,
+        :host_collections, :pools, :hypervisor_host, :lifecycle_environment, :content_view,
         :installed_packages
 end
 

data/app/models/katello/concerns/organization_extensions.rb

@@ -21,7 +21,7 @@ module Katello
         # has_many :environments is already defined in Foreman taxonomy.rb
         has_many :kt_environments, :class_name => "Katello::KTEnvironment", :dependent => :restrict_with_exception, :inverse_of => :organization
         has_one :library, lambda { where(:library => true) }, :class_name => "Katello::KTEnvironment", :dependent => :destroy
-        has_many :gpg_keys, :class_name => "Katello::GpgKey", :dependent => :destroy, :inverse_of => :organization
+        has_many :gpg_keys, :class_name => "Katello::ContentCredential", :dependent => :destroy, :inverse_of => :organization
         has_many :sync_plans, :class_name => "Katello::SyncPlan", :dependent => :destroy, :inverse_of => :organization
         has_many :host_collections, :class_name => "Katello::HostCollection", :dependent => :destroy, :inverse_of => :organization
         has_many :contents, :class_name => "Katello::Content", :dependent => :destroy, :inverse_of => :organization

data/app/models/katello/concerns/pulp_database_unit.rb

@@ -127,7 +127,7 @@ module Katello
         "#{self.name.demodulize.underscore}_id"
       end
 
-      def import_all(pulp_ids = nil, repository = nil)
+      def import_all(pulp_ids = nil, repository = nil, content_type_name = nil)
         ids_to_associate = []
         service_class = SmartProxy.pulp_primary!.content_service(content_type)
         service_class.pulp_units_batch_all(pulp_ids).each do |units|
@@ -145,21 +145,25 @@ module Katello
             end
             service = service_class.new(model.pulp_id)
             service.backend_data = unit
-            service.update_model(model)
+            if repository&.generic?
+              service.update_model(model, repository.repository_type, content_type_name)
+            else
+              service.update_model(model)
+            end
             ids_to_associate << model.pulp_id
           end
         end
         sync_repository_associations(repository, :pulp_ids => ids_to_associate, :additive => true) if self.many_repository_associations && repository && ids_to_associate.present?
       end
 
-      def import_for_repository(repository)
+      def import_for_repository(repository, content_type_name = nil)
         pulp_id_href_map = {}
         service_class = SmartProxy.pulp_primary!.content_service(content_type)
         fetch_only_ids = !repository.content_view.default? &&
                          !repository.repository_type.unique_content_per_repo &&
                          service_class.supports_id_fetch?
 
-        service_class.pulp_units_batch_for_repo(repository, fetch_identifiers: fetch_only_ids).each do |units|
+        service_class.pulp_units_batch_for_repo(repository, fetch_identifiers: fetch_only_ids, content_type: content_type_name).each do |units|
           units.each do |unit|
             unit = unit.with_indifferent_access
             pulp_id = unit[service_class.unit_identifier]
@@ -171,7 +175,11 @@ module Katello
               service = service_class.new(model.pulp_id)
               service.backend_data = unit
               model.repository_id = repository.id unless many_repository_associations
-              service.update_model(model)
+              if repository.generic?
+                service.update_model(model, repository.repository_type, content_type_name)
+              else
+                service.update_model(model)
+              end
             end
             pulp_id_href_map[pulp_id] = backend_identifier
           end

data/app/models/katello/concerns/smart_proxy_extensions.rb

@@ -150,12 +150,14 @@ module Katello
       end
 
       def pulp3_ssl_configuration(config)
+        legacy_pulp_cert = !self.setting(PULP3_FEATURE, 'client_authentication')&.include?('client_certificates')
+
         if Faraday.default_adapter == :excon
-          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert_filename
-          config.ssl_client_key = ::Cert::Certs.ssl_client_key_filename
+          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert_filename(use_admin_as_cn_cert: legacy_pulp_cert)
+          config.ssl_client_key = ::Cert::Certs.ssl_client_key_filename(use_admin_as_cn_cert: legacy_pulp_cert)
         elsif Faraday.default_adapter == :net_http
-          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert
-          config.ssl_client_key = ::Cert::Certs.ssl_client_key
+          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert(use_admin_as_cn_cert: legacy_pulp_cert)
+          config.ssl_client_key = ::Cert::Certs.ssl_client_key(use_admin_as_cn_cert: legacy_pulp_cert)
         else
           fail "Unexpected faraday default_adapter #{Faraday.default_adapter}!  Cannot continue, this is likely a bug."
         end
@@ -205,23 +207,18 @@ module Katello
         repository ? pulp3_repository_type_support?(repository.try(:content_type)) : false
       end
 
-      def pulp2_preferred_for_type?(repository_type)
-        if SETTINGS[:katello][:use_pulp_2_for_content_type].nil? ||
-            SETTINGS[:katello][:use_pulp_2_for_content_type][repository_type.to_sym].nil?
-          return false
-        else
-          return SETTINGS[:katello][:use_pulp_2_for_content_type][repository_type.to_sym]
-        end
-      end
-
       def missing_pulp3_capabilities?
         pulp3_enabled? && self.capabilities(PULP3_FEATURE).empty?
       end
 
       def fix_pulp3_capabilities(type)
-        repository_type_obj = type.is_a?(String) ||  type.is_a?(Symbol) ? Katello::RepositoryTypeManager.repository_types[type] : type
+        if type.is_a?(String) ||  type.is_a?(Symbol)
+          repository_type_obj = Katello::RepositoryTypeManager.defined_repository_types[type]
+        else
+          repository_type_obj = type
+        end
 
-        if missing_pulp3_capabilities? && repository_type_obj.pulp3_plugin && !pulp2_preferred_for_type?(repository_type_obj.id)
+        if missing_pulp3_capabilities? && repository_type_obj.pulp3_plugin
           self.refresh
           if self.capabilities(::SmartProxy::PULP3_FEATURE).empty?
             fail Katello::Errors::PulpcoreMissingCapabilities
@@ -229,23 +226,22 @@ module Katello
         end
       end
 
-      def pulp3_repository_type_support?(repository_type, check_pulp2_preferred = true)
-        repository_type_obj = repository_type.is_a?(String) ? Katello::RepositoryTypeManager.repository_types[repository_type] : repository_type
+      def pulp3_repository_type_support?(repository_type)
+        repository_type_obj = repository_type.is_a?(String) ? Katello::RepositoryTypeManager.find(repository_type) : repository_type
         fail "Cannot find repository type #{repository_type}, is it enabled?" unless repository_type_obj
 
-        pulp3_supported = repository_type_obj.pulp3_plugin.present? &&
-                          pulp3_enabled? &&
-                          (self.capabilities(PULP3_FEATURE).try(:include?, repository_type_obj.pulp3_plugin) ||
-                           self.capabilities(PULP3_FEATURE).try(:include?, 'pulp_' + repository_type_obj.pulp3_plugin))
-
-        check_pulp2_preferred ? pulp3_supported && !pulp2_preferred_for_type?(repository_type_obj.id) : pulp3_supported
+        repository_type_obj.pulp3_plugin.present? &&
+          pulp3_enabled? &&
+          (self.capabilities(PULP3_FEATURE).try(:include?, repository_type_obj.pulp3_plugin) ||
+           self.capabilities(PULP3_FEATURE).try(:include?, 'pulp_' + repository_type_obj.pulp3_plugin))
       end
 
       def pulp3_content_support?(content_type)
         content_type_obj = content_type.is_a?(String) ? Katello::RepositoryTypeManager.find_content_type(content_type) : content_type
-        fail "Cannot find content type #{content_type}." unless content_type_obj
+        content_type_string = content_type_obj&.label || content_type
+        fail "Content type #{content_type_string} does not belong to an enabled repo type." unless content_type_obj
 
-        found_type = Katello::RepositoryTypeManager.repository_types.values.find { |repo_type| repo_type.content_types.include?(content_type_obj) }
+        found_type = Katello::RepositoryTypeManager.enabled_repository_types.values.find { |repo_type| repo_type.content_types.include?(content_type_obj) }
         fail "Cannot find repository type for content_type #{content_type}, is it enabled?" unless found_type
         pulp3_repository_type_support?(found_type)
       end
@@ -274,24 +270,15 @@ module Katello
       end
 
       def supported_pulp_types
-        supported_map = {
-          pulp2: { supported_types: [] },
-          pulp3: { supported_types: [], overriden_to_pulp2: [] }
-        }
+        supported_types = []
 
-        ::Katello::RepositoryTypeManager.repository_types.keys.each do |type|
-          if pulp3_repository_type_support?(type, false)
-            if pulp2_preferred_for_type?(type)
-              supported_map[:pulp3][:overriden_to_pulp2] << type
-            else
-              supported_map[:pulp3][:supported_types] << type
-            end
-          else
-            supported_map[:pulp2][:supported_types] << type
+        ::Katello::RepositoryTypeManager.enabled_repository_types.keys.each do |type|
+          if pulp3_repository_type_support?(type)
+            supported_types << type
           end
         end
 
-        supported_map
+        supported_types
       end
 
       #deprecated methods
@@ -312,8 +299,17 @@ module Katello
       end
 
       def content_service(content_type)
-        content_type = RepositoryTypeManager.find_content_type(content_type) if content_type.is_a?(String)
-        pulp3_content_support?(content_type) ? content_type.pulp3_service_class : content_type.pulp2_service_class
+        if content_type.is_a?(String)
+          content_type_obj = RepositoryTypeManager.find_content_type(content_type)
+        else
+          content_type_obj = content_type
+        end
+        content_type_string = content_type_obj&.label || content_type
+        unless content_type_obj
+          fail _("Content type %{content_type_string} does not belong to an enabled repo type.") %
+                { content_type_string: content_type_string }
+        end
+        pulp3_content_support?(content_type_obj) ? content_type_obj.pulp3_service_class : content_type_obj.pulp2_service_class
       end
 
       def set_default_download_policy
@@ -410,6 +406,14 @@ module Katello
       def smart_proxy_service
         @smart_proxy_service ||= Pulp::SmartProxyRepository.new(self)
       end
+
+      def rhsm_url
+        if pulp_primary?
+          "https://#{URI.parse(url).host}/rhsm"
+        elsif pulp_mirror?
+          "https://#{URI.parse(url).host}:8443/rhsm"
+        end
+      end
     end
   end
 end

data/app/models/katello/{gpg_key.rb → content_credential.rb}

@@ -1,18 +1,18 @@
 module Katello
-  class GpgKey < Katello::Model
+  class ContentCredential < Katello::Model
     audited :associations => [:products]
 
     include ForemanTasks::Concerns::ActionSubject
-    include Katello::Authorization::GpgKey
+    include Katello::Authorization::ContentCredential
     MAX_CONTENT_LINE_LENGTH = 65
 
     GPG_KEY_TYPE = 'gpg_key'.freeze
     CERT_TYPE = 'cert'.freeze
 
-    has_many :root_repositories, :class_name => "Katello::RootRepository", :inverse_of => :gpg_key, :dependent => :nullify
+    has_many :root_repositories, :class_name => "Katello::RootRepository", :inverse_of => :gpg_key, :dependent => :nullify, :foreign_key => 'gpg_key_id'
     has_many :repositories, :through => :root_repositories
 
-    has_many :products, :class_name => "Katello::Product", :inverse_of => :gpg_key, :dependent => :nullify
+    has_many :products, :class_name => "Katello::Product", :inverse_of => :gpg_key, :dependent => :nullify, :foreign_key => 'gpg_key_id'
     has_many :ssl_ca_products, :class_name => "Katello::Product", :foreign_key => "ssl_ca_cert_id",
                                :inverse_of => :ssl_ca_cert, :dependent => :nullify
     has_many :ssl_client_products, :class_name => "Katello::Product", :foreign_key => "ssl_client_cert_id",

data/app/models/katello/content_view.rb

@@ -107,6 +107,10 @@ module Katello
       joins(:content_view_versions => :repositories).where("katello_repositories.root_id" => root_repository.id).uniq
     end
 
+    def self.in_organization(org)
+      where(organization_id: org.id)
+    end
+
     def to_s
       name
     end
@@ -265,7 +269,8 @@ module Katello
     end
 
     def last_task
-      history.order(:created_at).last
+      last_task_id = history.order(:created_at)&.last&.task_id
+      last_task_id ? ForemanTasks::Task.find(last_task_id) : nil
     end
 
     def history

data/app/models/katello/generic_content_unit.rb

@@ -0,0 +1,16 @@
+module Katello
+  class GenericContentUnit < Katello::Model
+    self.table_name = 'katello_generic_content_units'
+    include Concerns::PulpDatabaseUnit
+
+    CONTENT_TYPE = 'generic_content_unit'.freeze
+
+    def self.default_sort
+      order(:name)
+    end
+
+    def self.total_for_repositories(repos)
+      self.in_repositories(repos).count
+    end
+  end
+end

data/app/models/katello/glue/pulp/repos.rb

@@ -42,7 +42,7 @@ module Katello
       def sync_status
         all_repos = repos(self.library, nil, false)
         task = last_repo_sync_task
-        last_synced_repo = task ? all_repos.find { |repo| task.links.where(:resource_type => ::Katello::Repository.name).pluck(:resource_id).map(&:to_s).include?(repo.id.to_s) } : nil
+        last_synced_repo = task ? all_repos.find { |repo| task.locks.where(:resource_type => ::Katello::Repository.name).pluck(:resource_id).map(&:to_s).include?(repo.id.to_s) } : nil
         ::Katello::SyncStatusPresenter.new(last_synced_repo, task).sync_progress
       end
 
@@ -68,11 +68,10 @@ module Katello
       end
 
       def last_repo_sync_tasks
-        all_repos = repos(self.library, nil, false)
-        ForemanTasks::Task::DynflowTask
-          .select("#{ForemanTasks::Task::DynflowTask.table_name}.*")
-          .where(:label => ::Actions::Katello::Repository::Sync.name)
-          .joins(:locks).where("foreman_tasks_locks.resource_id in (?) and foreman_tasks_locks.resource_type = ?", all_repos.pluck(:id), ::Katello::Repository.name)
+        ids = repos(self.library, nil, false).pluck(:id).join(',')
+        label = ::Actions::Katello::Repository::Sync.name
+        type = ::Katello::Repository.name
+        ForemanTasks::Task.search_for("label = #{label} and resource_type = #{type} and resource_id ^ (#{ids})")
           .order("started_at desc")
       end
 
@@ -86,25 +85,10 @@ module Katello
       end
 
       def last_repo_sync_task_by_repoid
-        all_repos = repos(self.library, nil, false)
-        base_combined_table = ForemanTasks::Task::DynflowTask
-          .where(:label => ::Actions::Katello::Repository::Sync.name)
-          .joins(:locks)
-          .where("foreman_tasks_locks.resource_id in (?) and foreman_tasks_locks.resource_type = ?", all_repos.pluck(:id), ::Katello::Repository.name)
-
-        max_per_repoid = ForemanTasks::Task::DynflowTask
-          .joins(:locks)
-          .select("#{ForemanTasks::Task::DynflowTask.table_name}.*, inner_select.resource_id")
-          .joins(
-            "INNER JOIN (#{base_combined_table
-              .select("MAX(foreman_tasks_tasks.started_at) AS started_at", "foreman_tasks_locks.resource_id AS resource_id")
-              .group("foreman_tasks_locks.resource_id")
-              .to_sql}) inner_select
-            ON inner_select.started_at = #{ForemanTasks::Task::DynflowTask.table_name}.started_at
-            AND inner_select.resource_id = locks_foreman_tasks_tasks.resource_id")
-          .distinct
-
-        max_per_repoid.index_by { |x| [x.resource_id, x] }
+        ForemanTasks::Task.latest_tasks_by_resource_ids(
+          ::Actions::Katello::Repository::Sync.name,
+          Katello::Repository.name,
+          repos(self.library, nil, false).pluck(:id))
       end
 
       def sync_state_aggregated