katello 4.2.0.1 → 4.2.1

data/app/models/katello/erratum.rb

@@ -84,6 +84,19 @@ module Katello
       where("#{self.table_name}.id in (?) or #{self.table_name}.pulp_id in (?) or #{self.table_name}.errata_id in (?)", id_integers, ids, ids)
     end
 
+    def self.update_repo_association_records(new_ids, erratum_updated_ids, id_href_map_for_repository, repository)
+      if new_ids.any?
+        self.repository_association_class.import(db_columns_sync, db_values(new_ids, id_href_map_for_repository, repository), validate: false)
+      end
+      if erratum_updated_ids.present?
+        upserts = db_values(erratum_updated_ids, id_href_map_for_repository, repository).map do |upsert|
+          { erratum_id: upsert[0], erratum_pulp3_href: upsert[1], repository_id: upsert[2], created_at: upsert[3], updated_at: upsert[4] }
+        end
+        # PostgreSQL refuses to insert and update in the same command: https://github.com/rails/rails/issues/35519
+        self.repository_association_class.upsert_all(upserts, unique_by: [:erratum_id, :repository_id])
+      end
+    end
+
     def hosts_applicable(org_id = nil)
       if org_id.present?
         self.content_facets_applicable.joins(:host).where("#{::Host.table_name}.organization_id" => org_id)

data/app/models/katello/generic_content_unit.rb

@@ -3,7 +3,10 @@ module Katello
     self.table_name = 'katello_generic_content_units'
     include Concerns::PulpDatabaseUnit
 
-    CONTENT_TYPE = 'generic_content_unit'.freeze
+    CONTENT_TYPE = 'generic'.freeze
+
+    scoped_search :on => :name, :complete_value => true
+    scoped_search :on => :id, :complete_value => true
 
     def self.default_sort
       order(:name)

data/app/models/katello/repository.rb

@@ -177,10 +177,11 @@ module Katello
     delegate :name, :created_at, :updated_at, :major, :minor, :gpg_key_id, :gpg_key, :arch, :label, :url, :unprotected,
              :content_type, :product_id, :checksum_type, :docker_upstream_name, :mirror_on_sync, :"mirror_on_sync?",
              :download_policy, :verify_ssl_on_sync, :"verify_ssl_on_sync?", :upstream_username, :upstream_password,
-             :ostree_upstream_sync_policy, :ostree_upstream_sync_depth, :deb_releases, :deb_components, :deb_architectures,
-             :ssl_ca_cert_id, :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_id, :ssl_client_key_id, :os_versions,
-             :ssl_client_key, :ignorable_content, :description, :docker_tags_whitelist, :ansible_collection_requirements,
-             :ansible_collection_auth_url, :ansible_collection_auth_token, :http_proxy_policy, :http_proxy_id, :to => :root
+             :upstream_authentication_token, :ostree_upstream_sync_policy, :ostree_upstream_sync_depth, :deb_releases,
+             :deb_components, :deb_architectures, :ssl_ca_cert_id, :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_id,
+             :ssl_client_key_id, :os_versions, :ssl_client_key, :ignorable_content, :description, :docker_tags_whitelist,
+             :ansible_collection_requirements, :ansible_collection_auth_url, :ansible_collection_auth_token,
+             :http_proxy_policy, :http_proxy_id, :to => :root
 
     delegate :content_id, to: :root, allow_nil: true
     delegate :repository_type, to: :root
@@ -894,8 +895,15 @@ module Katello
     end
 
     def index_content(options = {})
+      # set full_index to true if you want to force fetch all data from pulp
+      # This is automatically done for library instance repos
+      # However for non-library instance as in those belonging to a version
+      # by default we fetch only ids and match them with the library instance
+      # some times we want to force fetch all data even for non-library repos.
+      # Use the full_index for those times
+
+      full_index = options.fetch(:full_index, false)
       source_repository = options.fetch(:source_repository, nil)
-
       if self.yum? && !self.primary?
         index_linked_repo
       elsif source_repository && !repository_type.unique_content_per_repo
@@ -904,9 +912,9 @@ module Katello
         repository_type.content_types_to_index.each do |type|
           Katello::Logging.time("CONTENT_INDEX", data: {type: type.model_class}) do
             if self.generic?
-              type.model_class.import_for_repository(self, type.content_type)
+              type.model_class.import_for_repository(self, generic_content_type: type.content_type, full_index: full_index)
             else
-              type.model_class.import_for_repository(self)
+              type.model_class.import_for_repository(self, full_index: full_index)
             end
           end
         end

data/app/models/katello/root_repository.rb

@@ -9,7 +9,7 @@ module Katello
     include Ext::LabelFromName
     include Encryptable
 
-    encrypts :upstream_password
+    encrypts :upstream_password, :upstream_authentication_token
 
     IGNORABLE_CONTENT_UNIT_TYPES = %w(srpm).freeze
     CHECKSUM_TYPES = %w(sha1 sha256).freeze
@@ -75,6 +75,7 @@ module Katello
     validate :ensure_valid_os_versions
     validate :ensure_content_attribute_restrictions
     validate :ensure_valid_upstream_authorization
+    validate :ensure_valid_authentication_token, :if => :yum?
     validate :ensure_no_checksum_on_demand
     validates :url, presence: true, if: :ostree?
     validates :checksum_type, :inclusion => {:in => CHECKSUM_TYPES}, :allow_blank => true
@@ -294,6 +295,12 @@ module Katello
       end
     end
 
+    def ensure_valid_authentication_token
+      if self.upstream_authentication_token.blank?
+        self.upstream_authentication_token = nil
+      end
+    end
+
     def custom_content_path
       parts = []
       # We generate repo path only for custom product content. We add this
@@ -338,7 +345,7 @@ module Katello
     end
 
     def generic?
-      Katello::RepositoryTypeManager.generic_repository_types(enabled_only: false).values.map(&:id).map(&:to_s).flatten.include? self.content_type
+      Katello::RepositoryTypeManager.generic_repository_types(false).values.map(&:id).map(&:to_s).flatten.include? self.content_type
     end
 
     def metadata_generate_needed?

data/app/models/katello/yum_metadata_file.rb

@@ -5,9 +5,9 @@ module Katello
     belongs_to :repository, :inverse_of => :yum_metadata_files, :class_name => "Katello::Repository"
     CONTENT_TYPE = "yum_repo_metadata_file".freeze
 
-    def self.import_for_repository(repository)
+    def self.import_for_repository(repository, options = {})
       ::Katello::YumMetadataFile.where(:repository_id => repository).destroy_all
-      super(repository)
+      super(repository, options)
     end
 
     # yum metadata file only has one repo

data/app/services/katello/applicability/applicable_content_helper.rb

@@ -136,9 +136,10 @@ module Katello
 
       def insert(applicable_ids)
         unless applicable_ids.empty?
-          inserts = applicable_ids.map { |applicable_id| "(#{applicable_id.to_i}, #{content_facet.id.to_i})" }
-          sql = "INSERT INTO #{content_facet_association_class.table_name} (#{content_unit_association_id}, content_facet_id) VALUES #{inserts.join(', ')}"
-          ActiveRecord::Base.connection.exec_insert(sql)
+          upserts = applicable_ids.collect do |applicable_id|
+            { content_unit_association_id => applicable_id, :content_facet_id => content_facet.id }
+          end
+          content_facet_association_class.upsert_all(upserts, unique_by: [content_unit_association_id, :content_facet_id])
         end
       end
 

data/app/services/katello/pulp/content.rb

@@ -3,7 +3,7 @@ module Katello
     class Content
       extend Katello::Abstract::Pulp::Content
       class << self
-        def create_upload(_size = 0, _checksum = nil, _content_type = nil)
+        def create_upload(_size = 0, _checksum = nil, _content_type = nil, _repository = nil)
           pulp_content.create_upload_request
         end
 

data/app/services/katello/pulp3/content.rb

@@ -4,11 +4,15 @@ module Katello
     class Content
       extend Katello::Abstract::Pulp::Content
       class << self
-        def create_upload(size = 0, checksum = nil, content_type = nil)
+        def create_upload(size = 0, checksum = nil, content_type = nil, repository = nil)
           content_unit_href = nil
           if checksum
             content_backend_service = SmartProxy.pulp_primary.content_service(content_type)
-            content_list = content_backend_service.content_api.list("sha256": checksum)
+            if repository&.generic?
+              content_list = content_backend_service.content_api(repository.repository_type, content_type).list("sha256": checksum)
+            else
+              content_list = content_backend_service.content_api.list("sha256": checksum)
+            end
             content_unit_href = content_list.results.first.pulp_href unless content_list.results.empty?
             return {"content_unit_href" => content_unit_href} if content_unit_href
           end

data/app/services/katello/pulp3/erratum.rb

@@ -25,7 +25,9 @@ module Katello
         repo_content_list.map { |content| content.try(:pulp_href) }
       end
 
+      # rubocop:disable Metrics/AbcSize
       def update_model(model)
+        updated = false
         keys = %w(title id severity issued_date type description reboot_suggested solution updated_date summary)
         custom_json = backend_data.slice(*keys)
         custom_json["issued"] = custom_json.delete("issued_date")
@@ -35,12 +37,15 @@ module Katello
         custom_json["issued"] = convert_date_if_epoch(custom_json["issued"])
         custom_json["updated"] = convert_date_if_epoch(custom_json["updated"]) unless custom_json["updated"].blank?
 
+        custom_json['errata_id'] = custom_json.delete('id')
+        custom_json['errata_type'] = custom_json.delete('type')
+        custom_json['issued'] = custom_json['issued'].to_datetime.strftime('%Y-%m-%d').to_datetime
+        custom_json['updated'] = custom_json['updated'].blank? ? custom_json['issued'] : custom_json['updated'].to_datetime.strftime('%Y-%m-%d').to_datetime
+
         if model.updated.blank? ||
-            (custom_json['updated'] && (custom_json['updated'].to_datetime != model.updated.to_datetime))
-          custom_json['errata_id'] = custom_json.delete('id')
-          custom_json['errata_type'] = custom_json.delete('type')
-          custom_json['updated'] = custom_json['updated'].blank? ? custom_json['issued'] : custom_json['updated']
+          model.attributes.excluding(model.attributes.keys - custom_json.keys) != custom_json
           model.update!(custom_json)
+          updated = true
 
           unless backend_data['references'].blank?
             update_bugzillas(model, backend_data['references'])
@@ -49,7 +54,10 @@ module Katello
         end
         update_packages(model, backend_data['pkglist']) unless backend_data['pkglist'].blank?
         update_modules(model, backend_data['pkglist']) unless backend_data['pkglist'].blank?
+
+        return model.id if updated
       end
+      # rubocop:enable Metrics/AbcSize
 
       def update_bugzillas(model, ref_list)
         ref_list.select { |r| r[:type] == "bugzilla" }.each do |bugzilla|

data/app/services/katello/pulp3/generic_content_unit.rb

@@ -2,7 +2,7 @@ module Katello
   module Pulp3
     class GenericContentUnit < PulpContentUnit
       include LazyAccessor
-      CONTENT_TYPE = "generic_content_unit".freeze
+      CONTENT_TYPE = "generic".freeze
 
       def self.fetch_content_list(page_opts, repository_type, content_type)
         content_unit_list page_opts, repository_type, content_type

data/app/services/katello/pulp3/pulp_content_unit.rb

@@ -13,7 +13,13 @@ module Katello
 
       def self.content_api_create(opts = {})
         relative_path = opts.delete(:relative_path)
-        self.content_api.create(relative_path, opts)
+        if Katello::RepositoryTypeManager.generic_content_type?(opts[:content_type])
+          repository_type = Katello::Repository.find(opts[:repository_id]).repository_type
+          content_type = opts[:content_type]
+          self.content_api(repository_type, content_type).create(relative_path, opts)
+        else
+          self.content_api.create(relative_path, opts)
+        end
       end
 
       def self.create_content
@@ -109,6 +115,25 @@ module Katello
       def self.fetch_content_list(page_opts)
         content_unit_list page_opts
       end
+
+      def self.find_duplicate_unit(repository, unit_type_id, file, checksum)
+        content_backend_service = SmartProxy.pulp_primary.content_service(unit_type_id)
+        duplicates_allowed = ::Katello::RepositoryTypeManager.find_content_type(unit_type_id).try(:duplicates_allowed)
+        if repository.generic? && duplicates_allowed
+          filename_key = ::Katello::RepositoryTypeManager.find_content_type(unit_type_id).filename_key
+          duplicate_sha_path_content_list = content_backend_service.content_api(repository.repository_type, unit_type_id).list(
+            "sha256": checksum,
+            filename_key => file[:filename])
+        elsif repository.generic?
+          duplicate_sha_path_content_list = content_backend_service.content_api(repository.repository_type, unit_type_id).list(
+            "sha256": checksum)
+        else
+          duplicate_sha_path_content_list = content_backend_service.content_api.list(
+            "sha256": checksum,
+            "relative_path": file[:filename])
+        end
+        duplicate_sha_path_content_list
+      end
     end
   end
 end

data/app/services/katello/pulp3/repository/apt.rb

@@ -22,6 +22,12 @@ module Katello
           common_remote_options.merge(deb_remote_options)
         end
 
+        def mirror_remote_options
+          {
+            distributions: repo.deb_releases + "#{' default' unless repo.deb_releases.include? 'default'}"
+          }
+        end
+
         def publication_options(repository_version)
           ss = api.signing_services_api.list(name: SIGNING_SERVICE_NAME).results
           popts = super(repository_version)
@@ -35,6 +41,16 @@ module Katello
           popts
         end
 
+        def mirror_publication_options
+          {
+            # Since we are synchronizing the "default" distribution from the simple publisher on the server,
+            # it will be included in the structured publish. Therefore, we MUST NOT use the simple publisher
+            # on the proxy, since this would collide!
+            #simple: true,
+            structured: true # publish real suites (e.g. 'stable')
+          }
+        end
+
         def distribution_options(path)
           {
             base_path: path,

data/app/services/katello/pulp3/repository/yum.rb

@@ -11,24 +11,18 @@ module Katello
         UNIT_LIMIT = 10_000
 
         def remote_options
-          url, sles_token = extract_sles_token
           options = common_remote_options
-          options.merge!(sles_auth_token: sles_token) if sles_token
-          options.merge!(url: url, policy: root.download_policy)
+          uri = URI(root.url)
+          unless root.upstream_authentication_token.blank?
+            options.merge!(sles_auth_token: root.upstream_authentication_token)
+          end
+          options.merge!(url: uri.to_s, policy: root.download_policy)
         end
 
         def specific_create_options
           { retain_package_versions: retain_package_versions_count }
         end
 
-        def extract_sles_token
-          return [nil, nil] if root.url.blank?
-          uri = URI(root.url)
-          query = uri.query
-          uri.query = nil
-          [uri.to_s, query]
-        end
-
         def skip_types
           skip_types = []
           if root.ignorable_content.try(:include?, "srpm")
@@ -303,14 +297,15 @@ module Katello
             blacklist_ids = filter_list_map[:blacklist_ids].flatten&.uniq
             content_unit_hrefs = whitelist_ids - blacklist_ids
 
+            source_repo_ids.each do |source_repo_id|
+              content_unit_hrefs += ::Katello::Repository.find(source_repo_id).srpms.pluck(:pulp_id)
+            end
+
             if content_unit_hrefs.any?
               source_repo_ids.each do |source_repo_id|
                 content_unit_hrefs += additional_content_hrefs(::Katello::Repository.find(source_repo_id), content_unit_hrefs)
               end
             end
-            source_repo_ids.each do |source_repo_id|
-              content_unit_hrefs += ::Katello::Repository.find(source_repo_id).srpms.pluck(:pulp_id)
-            end
 
             dest_repo_map[:content_unit_hrefs] = content_unit_hrefs.uniq.sort
           end
@@ -348,10 +343,10 @@ module Katello
           whitelist_ids += modular_packages(source_repository, inclusion_modular_filters) unless inclusion_modular_filters.empty?
           blacklist_ids += modular_packages(source_repository, exclusion_modular_filters) unless exclusion_modular_filters.empty?
           content_unit_hrefs = whitelist_ids - blacklist_ids
+          content_unit_hrefs += source_repository.srpms.pluck(:pulp_id)
           if content_unit_hrefs.any?
             content_unit_hrefs += additional_content_hrefs(source_repository, content_unit_hrefs)
           end
-          content_unit_hrefs += source_repository.srpms.pluck(:pulp_id)
           copy_units(source_repository, content_unit_hrefs.uniq, options[:remove_all])
         end
 
@@ -368,18 +363,22 @@ module Katello
           options = { :repository_version => source_repository.version_href }
 
           errata_to_include = filter_errata_by_pulp_href(source_repository.errata, content_unit_hrefs,
-                                                         source_repository.rpms.pluck(:filename))
-          content_unit_hrefs += errata_to_include.collect { |erratum| erratum.repository_errata.pluck(:erratum_pulp3_href) }.flatten
+                                                         source_repository.rpms.pluck(:filename) +
+                                                         source_repository.srpms.pluck(:filename))
+          content_unit_hrefs += errata_to_include.collect do |erratum|
+            erratum.repository_errata.where(repository_id: source_repository.id).pluck(:erratum_pulp3_href)
+          end
+          content_unit_hrefs.flatten!
 
           package_groups_to_include = filter_package_groups_by_pulp_href(source_repository.package_groups, content_unit_hrefs)
           content_unit_hrefs += package_groups_to_include.pluck(:pulp_id)
 
           metadata_file_hrefs_to_include = filter_metadatafiles_by_pulp_hrefs(
-            repo_service.metadatafiles(options).results, content_unit_hrefs)
+            repo_service.metadatafiles(options)&.results, content_unit_hrefs)
           content_unit_hrefs += metadata_file_hrefs_to_include
 
           distribution_tree_hrefs_to_include = filter_distribution_trees_by_pulp_hrefs(
-            repo_service.distributiontrees(options).results, content_unit_hrefs)
+            repo_service.distributiontrees(options)&.results, content_unit_hrefs)
           content_unit_hrefs + distribution_tree_hrefs_to_include
         end
       end

data/app/services/katello/pulp3/repository_mirror.rb

@@ -143,9 +143,17 @@ module Katello
         uri.to_s
       end
 
+      def publication_options(repository_version)
+        popts = {repository_version: repository_version}
+        if (type_specific_options = repo_service.try(:mirror_publication_options))
+          popts.merge!(type_specific_options)
+        end
+        popts
+      end
+
       def create_publication
         if (href = version_href)
-          publication_data = api.class.publication_class.new(repository_version: href)
+          publication_data = api.class.publication_class.new(publication_options(href))
           api.publications_api.create(publication_data)
         end
       end

data/app/services/katello/repository_type.rb

@@ -50,11 +50,11 @@ module Katello
       end
     end
 
-    def default_managed_content_type(model_class = nil)
-      if model_class
-        @default_managed_content_type_class = model_class
+    def default_managed_content_type(label = nil)
+      if label
+        @default_managed_content_type_label = label.to_s
       else
-        @content_types.find { |content_type| content_type.model_class == @default_managed_content_type_class }
+        @content_types.find { |content_type| content_type.label == @default_managed_content_type_label }
       end
     end
 
@@ -122,7 +122,7 @@ module Katello
     end
 
     class GenericContentType < ContentType
-      attr_accessor :pulp3_api, :pulp3_model, :content_type
+      attr_accessor :pulp3_api, :pulp3_model, :content_type, :filename_key, :duplicates_allowed
 
       def initialize(options)
         self.model_class = options[:model_class]
@@ -135,10 +135,12 @@ module Katello
         self.pulp3_api = options[:pulp3_api]
         self.pulp3_model = options[:pulp3_model]
         self.content_type = options[:content_type]
+        self.filename_key = options[:filename_key]
+        self.duplicates_allowed = options[:duplicates_allowed]
       end
 
       def label
-        self.model_class::CONTENT_TYPE
+        self.content_type
       end
     end
 

data/app/services/katello/repository_type_manager.rb

@@ -4,40 +4,37 @@ module Katello
 
     @defined_repository_types = {}
     @enabled_repository_types = {}
-    begin
-      @pulp_primary = ::SmartProxy.unscoped.detect { |proxy| !proxy.setting(PULP3_FEATURE, 'mirror') }
-    rescue ActiveRecord::StatementInvalid
-      @pulp_primary = nil
-    end
+
     class << self
       private :new
       attr_reader :defined_repository_types
 
+      def pulp_primary
+        ::SmartProxy.pulp_primary
+      end
+
       # Plugin constructor
       def register(id, &block)
-        if @pulp_primary&.has_feature?(PULP3_FEATURE) && @pulp_primary&.capabilities(PULP3_FEATURE)&.empty?
-          fix_pulp3_capabilities
-        end
         defined_repo_type = find_defined(id)
         if defined_repo_type.blank?
           defined_repo_type = ::Katello::RepositoryType.new(id)
           defined_repo_type.instance_eval(&block) if block_given?
           @defined_repository_types[id.to_s] = defined_repo_type
         end
-        if find(id).blank? && defined_repo_type.present?
-          enabled_repository_types[id.to_s] = defined_repo_type if pulp3_plugin_installed?(id)
-        end
       end
 
       def fix_pulp3_capabilities
-        save_pulp_primary if @pulp_primary.nil?
-        @pulp_primary&.refresh
-        if @pulp_primary&.capabilities(PULP3_FEATURE)&.empty?
+        pulp_primary&.refresh
+        if pulp_primary&.capabilities(PULP3_FEATURE)&.empty?
           fail Katello::Errors::PulpcoreMissingCapabilities
         end
       end
 
       def enabled_repository_types(update = true)
+        if update && pulp_primary&.has_feature?(PULP3_FEATURE) && pulp_primary&.capabilities(PULP3_FEATURE)&.empty?
+          fix_pulp3_capabilities
+        end
+
         disabled_types = @defined_repository_types.keys - @enabled_repository_types.keys
         if update && disabled_types.present?
           disabled_types.each { |repo_type| update_enabled_repository_type(repo_type.to_s) }
@@ -60,8 +57,7 @@ module Katello
       end
 
       def pulp3_plugin_installed?(repository_type)
-        save_pulp_primary
-        @pulp_primary&.capabilities(PULP3_FEATURE)&.include?(@defined_repository_types[repository_type].pulp3_plugin)
+        pulp_primary&.capabilities(PULP3_FEATURE)&.include?(@defined_repository_types[repository_type].pulp3_plugin)
       end
 
       def enabled_content_types(enabled_only = true)
@@ -79,6 +75,19 @@ module Katello
                   flatten
       end
 
+      def generic_content_types(enabled_only = true)
+        repo_types = enabled_only ? enabled_repository_types : defined_repository_types
+        list = repo_types.values.map do |type|
+          type.content_types.select { |ct| ct.model_class::CONTENT_TYPE == Katello::GenericContentUnit::CONTENT_TYPE }
+        end
+        list.flatten.map(&:content_type)
+      end
+
+      def generic_content_type?(content_type, enabled_only = true)
+        types = generic_content_types(enabled_only)
+        types.include?(content_type)
+      end
+
       def creatable_by_user?(repository_type, enabled_only = true)
         type = enabled_only ? find(repository_type) : find_defined(repository_type)
         return false unless type
@@ -181,12 +190,6 @@ module Katello
           @enabled_repository_types[repository_type.to_s] = defined_repo_type
         end
       end
-
-      def save_pulp_primary
-        @pulp_primary = ::SmartProxy.unscoped.detect { |proxy| !proxy.setting(PULP3_FEATURE, 'mirror') }
-      rescue ActiveRecord::StatementInvalid
-        @pulp_primary = nil
-      end
     end
   end
 end

data/app/views/katello/api/v2/generic_content_units/base.json.rabl

@@ -0,0 +1,7 @@
+object @resource
+
+attributes :id
+attributes :name
+attributes :pulp_id
+attributes :version
+attributes :content_type

data/app/views/katello/api/v2/generic_content_units/compare.json.rabl

@@ -0,0 +1,10 @@
+object false
+
+extends "katello/api/v2/common/metadata"
+
+child @collection[:results] => :results do
+  extends 'katello/api/v2/generic_content_units/base'
+  node :comparison do |result|
+    result.comparison
+  end
+end

data/app/views/katello/api/v2/generic_content_units/index.json.rabl

@@ -0,0 +1,7 @@
+object false
+
+extends "katello/api/v2/common/metadata"
+
+child @collection[:results] => :results do
+  extends "katello/api/v2/generic_content_units/base"
+end

data/app/views/katello/api/v2/generic_content_units/show.json.rabl

@@ -0,0 +1,3 @@
+object @resource
+
+extends "katello/api/v2/generic_content_units/base"

data/app/views/katello/api/v2/repositories/show.json.rabl

@@ -80,7 +80,8 @@ node :upstream_password_exists do |repo|
 end
 
 node :upstream_auth_exists do |repo|
-  repo.upstream_username.present? && repo.upstream_password.present?
+  (repo.upstream_username.present? && repo.upstream_password.present?) ||
+  repo.upstream_authentication_token.present?
 end
 
 if @object && @object.library_instance_id.nil?

data/config/initializers/filter_parameters.rb

@@ -0,0 +1 @@
+Rails.application.config.filter_parameters += [:upstream_authentication_token]

data/config/routes/api/v2.rb

@@ -275,6 +275,15 @@ Katello::Engine.routes.draw do
           end
         end
 
+        Katello::RepositoryTypeManager.generic_content_types(false).each do |type|
+          api_resources type.pluralize.to_sym, :only => [:index, :show], :controller => 'generic_content_units', :content_type => type do
+            collection do
+              get :auto_complete_search
+              get :compare
+            end
+          end
+        end
+
         match "/ping" => "katello_ping#index", :via => :get
         match "/status" => "katello_ping#server_status", :via => :get
 
@@ -392,7 +401,9 @@ Katello::Engine.routes.draw do
           api_resources :debs, :only => [:index, :show]
           api_resources :module_streams, :only => [:index, :show]
           api_resources :ansible_collections, :only => [:index, :show]
-
+          Katello::RepositoryTypeManager.generic_content_types(false).each do |type|
+            api_resources type.pluralize.to_sym, :only => [:index, :show], :controller => 'generic_content_units', :content_type => type
+          end
           api_resources :ostree_branches, :only => [:index, :show]
 
           api_resources :content_uploads, :controller => :content_uploads, :only => [:create, :destroy, :update]

data/db/migrate/20210512192745_fix_red_hat_root_repository_arch.rb

@@ -2,7 +2,7 @@ class FixRedHatRootRepositoryArch < ActiveRecord::Migration[6.0]
   def up
     ::Katello::RootRepository.
       joins("INNER JOIN katello_contents ON katello_contents.cp_content_id = katello_root_repositories.content_id").
-      where.not(arch: 'noarch').where.not("katello_contents.content_url ILIKE '%$basearch%'").update(arch: 'noarch')
+      where.not(arch: 'noarch').where.not("katello_contents.content_url ILIKE '%$basearch%'").update_all(arch: 'noarch')
   end
 
   def down

data/db/migrate/20210831161843_add_upstream_auth_token_to_root_repository.rb

@@ -0,0 +1,5 @@
+class AddUpstreamAuthTokenToRootRepository < ActiveRecord::Migration[6.0]
+  def change
+    add_column :katello_root_repositories, :upstream_authentication_token, :string, limit: 1024
+  end
+end

data/db/seeds.d/111-upgrade_tasks.rb

@@ -4,6 +4,8 @@ UpgradeTask.define_tasks(:katello) do
     {:name => 'katello:clean_backend_objects', :long_running => true, :skip_failure => true, :always_run => true},
     {:name => 'katello:upgrades:4.0:remove_ostree_puppet_content'},
     {:name => 'katello:upgrades:4.1:sync_noarch_content'},
-    {:name => 'katello:upgrades:4.1:fix_invalid_pools'}
+    {:name => 'katello:upgrades:4.1:fix_invalid_pools'},
+    {:name => 'katello:upgrades:4.1:reupdate_content_import_export_perms'},
+    {:name => 'katello:upgrades:4.2:remove_checksum_values'}
   ]
 end