katello 4.2.0.1 → 4.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 584f61c17131168930ed4c8e69fc57b3365790d54e0a213d863b8f51fc08886f
-  data.tar.gz: 314009b6f1ff799a12f311733c84e63418d35fbc8df5d88bdb3655ae256829eb
+  metadata.gz: 86442b066cfb028bec4edcd99bc079e29675037545b33af48336a8e176ffc43d
+  data.tar.gz: 9cbab83302f8791feafc1912bc7c81ea31d4d08169d1f554cfc1361f995941e2
 SHA512:
-  metadata.gz: 4b1a04cb53666ed27b91417aafa1a560ef60c6ba5a2867e920241f09c1a7d0848ef6066317746b24c88492426790f13ff3abfffadc9bd3da29719ad0190009ab
-  data.tar.gz: 5e633218d1dc29742b64649697b358637df14e57c249ef21ca2a7d3341b4fe4826ed4a7c505d3105ef810dec2368d40f484a3e07d869c1bba3068fb6e1ca2f08
+  metadata.gz: e4c1529274b2d229ac784ccdad9f3c9b90b67f92df7eca9d8228e79e675bbcfb9766c33b4af3bbad3b87524c4cee1cdb13e607cd9a39f5d3aa5d865d032bee02
+  data.tar.gz: 62a2813d45436694cce0f721d26d0ec2782f112e9154cfa051ed650b4aa2d86dd4624708a835f03adca3b65280ccbabccfa3d83d506224e8616eeedb6d8aec4c

data/app/controllers/katello/api/v2/content_uploads_controller.rb

@@ -15,9 +15,12 @@ module Katello
       fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Ansible collections.") if @repository.ansible_collection?
       content_type = params[:content_type] || ::Katello::RepositoryTypeManager.find(@repository.content_type)&.default_managed_content_type&.label
       RepositoryTypeManager.check_content_matches_repo_type!(@repository, content_type)
-
-      unit_type_id = SmartProxy.pulp_primary.content_service(content_type).content_type
-      render :json => @repository.backend_content_service(::SmartProxy.pulp_primary).create_upload(params[:size], params[:checksum], unit_type_id)
+      if ::Katello::RepositoryTypeManager.generic_content_type?(content_type)
+        unit_type_id = content_type
+      else
+        unit_type_id = SmartProxy.pulp_primary.content_service(content_type).content_type
+      end
+      render :json => @repository.backend_content_service(::SmartProxy.pulp_primary).create_upload(params[:size], params[:checksum], unit_type_id, @repository)
     end
 
     api :PUT, "/repositories/:repository_id/content_uploads/:id", N_("Upload a chunk of the file's content")

data/app/controllers/katello/api/v2/generic_content_units_controller.rb

@@ -0,0 +1,26 @@
+module Katello
+  class Api::V2::GenericContentUnitsController < Api::V2::ApiController
+    Katello::RepositoryTypeManager.generic_content_types(enabled_only: false).each do |type|
+      apipie_concern_subst(:a_resource => N_(type), :resource_id => type.pluralize)
+      resource_description do
+        name type.pluralize.titleize
+      end
+    end
+
+    include Katello::Concerns::Api::V2::RepositoryContentController
+
+    def default_sort
+      %w(name asc)
+    end
+
+    def resource_class
+      ::Katello::GenericContentUnit.where(content_type: params[:content_type].singularize)
+    end
+
+    private
+
+    def repo_association
+      :repository_id
+    end
+  end
+end

data/app/controllers/katello/api/v2/repositories_controller.rb

@@ -56,6 +56,7 @@ module Katello
       param :verify_ssl_on_sync, :bool, :desc => N_("if true, Katello will verify the upstream url's SSL certifcates are signed by a trusted CA")
       param :upstream_username, String, :desc => N_("Username of the upstream repository user used for authentication")
       param :upstream_password, String, :desc => N_("Password of the upstream repository user used for authentication")
+      param :upstream_authentication_token, String, :desc => N_("Password of the upstream authentication token.")
       param :ostree_upstream_sync_policy, ::Katello::RootRepository::OSTREE_UPSTREAM_SYNC_POLICIES, :desc => N_("policies for syncing upstream ostree repositories")
       param :ostree_upstream_sync_depth, :number, :desc => N_("if a custom sync policy is chosen for ostree repositories then a 'depth' value must be provided")
       param :deb_releases, String, :desc => N_("whitespace-separated list of releases to be synced from deb-archive")
@@ -462,10 +463,11 @@ module Katello
 
     # rubocop:disable Metrics/CyclomaticComplexity
     def repository_params
-      keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password, :upstream_username, :download_concurrency,
+      keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password,
+              :upstream_username, :download_concurrency, :upstream_authentication_token,
               :ostree_upstream_sync_depth, :ostree_upstream_sync_policy, {:os_versions => []},
-              :deb_releases, :deb_components, :deb_architectures, :description, :http_proxy_policy, :http_proxy_id, :retain_package_versions_count,
-              {:ignorable_content => []}
+              :deb_releases, :deb_components, :deb_architectures, :description, :http_proxy_policy,
+              :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
              ]
 
       keys += [{:docker_tags_whitelist => []}, :docker_upstream_name] if params[:action] == 'create' || @repository&.docker?
@@ -512,6 +514,7 @@ module Katello
       root.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
       root.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
       root.upstream_password = repo_params[:upstream_password] if repo_params.key?(:upstream_password)
+      root.upstream_authentication_token = repo_params[:upstream_authentication_token] if repo_params.key?(:upstream_authentication_token)
       root.ignorable_content = repo_params[:ignorable_content] if root.yum? && repo_params.key?(:ignorable_content)
       root.http_proxy_policy = repo_params[:http_proxy_policy] if repo_params.key?(:http_proxy_policy)
       root.http_proxy_id = repo_params[:http_proxy_id] if repo_params.key?(:http_proxy_id)
@@ -563,12 +566,21 @@ module Katello
       content_type = params[:content_type]
 
       if content_type
+        RepositoryTypeManager.check_content_matches_repo_type!(@repository, params[:content_type]) if params[:content_type]
         @content = @repository.units_for_removal(params[:ids], content_type)
       else
         @content = @repository.units_for_removal(params[:ids])
       end
 
-      RepositoryTypeManager.check_content_matches_repo_type!(@repository, @content.first.class::CONTENT_TYPE)
+      if @repository.generic?
+        if content_type
+          RepositoryTypeManager.check_content_matches_repo_type!(@repository, @content.first.content_type)
+        else
+          RepositoryTypeManager.check_content_matches_repo_type!(@repository, @repository.repository_type.default_managed_content_type.label)
+        end
+      else
+        RepositoryTypeManager.check_content_matches_repo_type!(@repository, @content.first.class::CONTENT_TYPE)
+      end
     end
 
     def filter_by_content_view(query, content_view_id, environment_id, is_available_for)

data/app/lib/actions/katello/capsule_content/sync_capsule.rb

@@ -4,6 +4,7 @@ module Actions
       class SyncCapsule < ::Actions::EntryAction
         include Actions::Katello::PulpSelector
         def plan(smart_proxy, options = {})
+          plan_self(:smart_proxy_id => smart_proxy.id, :options => options)
           action_subject(smart_proxy)
           environment = options[:environment]
           content_view = options[:content_view]
@@ -37,53 +38,6 @@ module Actions
               end
             end
           end
-          sync_container_gateway(smart_proxy)
-        end
-
-        def sync_container_gateway(smart_proxy)
-          if smart_proxy.has_feature?(::SmartProxy::CONTAINER_GATEWAY_FEATURE)
-            update_container_repo_list(smart_proxy)
-            users = smart_proxy.container_gateway_users
-            update_user_container_repo_mapping(smart_proxy, users) if users.any?
-          end
-        end
-
-        def unauthenticated_container_repositories
-          ::Katello::Repository.joins(:environment).where("#{::Katello::KTEnvironment.table_name}.registry_unauthenticated_pull" => true).select(:id).pluck(:id)
-        end
-
-        def update_container_repo_list(smart_proxy)
-          # [{ repository: "repoA", auth_required: false }]
-          repo_list = []
-          ::Katello::SmartProxyHelper.new(smart_proxy).combined_repos_available_to_capsule.each do |repo|
-            if repo.docker? && !repo.container_repository_name.nil?
-              repo_list << { repository: repo.container_repository_name,
-                             auth_required: !unauthenticated_container_repositories.include?(repo.id) }
-            end
-          end
-          smart_proxy.update_container_repo_list(repo_list)
-        end
-
-        def update_user_container_repo_mapping(smart_proxy, users)
-          # Example user-repo mapping:
-          # { users:
-          #   [
-          #     'user a' => [{ repository: 'repo 1', auth_required: true }]
-          #   ]
-          # }
-
-          user_repo_map = { users: [] }
-          users.each do |user|
-            inner_repo_list = []
-            repositories = ::Katello::Repository.readable_docker_catalog_as(user)
-            repositories.each do |repo|
-              next if repo.container_repository_name.nil?
-              inner_repo_list << { repository: repo.container_repository_name,
-                                   auth_required: !unauthenticated_container_repositories.include?(repo.id) }
-            end
-            user_repo_map[:users] << { user.login => inner_repo_list }
-          end
-          smart_proxy.update_user_container_repo_mapping(user_repo_map)
         end
 
         def repos_to_sync(smart_proxy, environment, content_view, repository, skip_metatadata_check = false)
@@ -109,6 +63,11 @@ module Actions
           :link
         end
 
+        def run
+          smart_proxy = ::SmartProxy.find(input[:smart_proxy_id])
+          smart_proxy.sync_container_gateway
+        end
+
         def rescue_strategy
           Dynflow::Action::Rescue::Skip
         end

data/app/lib/actions/katello/content_view/promote_to_environment.rb

@@ -45,17 +45,12 @@ module Actions
         end
 
         def finalize
-          # update errata applicability counts for all hosts in the CV & LE
-          ::Katello::Host::ContentFacet.where(:content_view_id => input[:content_view_id],
-                                              :lifecycle_environment_id => input[:environment_id]).each do |facet|
-            facet.update_applicability_counts
-            facet.update_errata_status
-          end
+          environment = ::Katello::KTEnvironment.find(input[:environment_id])
+          ::Katello::ContentView.find(input[:content_view_id]).update_host_statuses(environment)
 
           history = ::Katello::ContentViewHistory.find(input[:history_id])
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL
           history.save!
-          environment = ::Katello::KTEnvironment.find(input[:environment_id])
 
           if !input[:incremental_update] && sync_proxies?(environment)
             ForemanTasks.async_task(ContentView::CapsuleSync,

data/app/lib/actions/katello/content_view/publish.rb

@@ -193,12 +193,14 @@ module Actions
         def handle_import(version, path:, metadata:)
           sequence do
             plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path, metadata: metadata)
-            plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::CopyVersionUnitsToLibrary, version)
             concurrence do
               version.importable_repositories.pluck(:id).each do |id|
-                plan_action(Katello::Repository::IndexContent, id: id)
+                # need to force full_indexing for these version repositories
+                # on import. This will then help us correctly copy version units to the library
+                plan_action(Katello::Repository::IndexContent, id: id, full_index: true)
               end
             end
+            plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::CopyVersionUnitsToLibrary, version)
           end
         end
 

data/app/lib/actions/katello/repository/filtered_index_content.rb

@@ -13,6 +13,7 @@ module Actions
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/CyclomaticComplexity
         # rubocop:disable Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize
         def run
           repo = ::Katello::Repository.find(input[:id])
           if repo.docker?
@@ -21,6 +22,10 @@ module Actions
             ::Katello::DockerManifestList.import_for_repository(repo)
           elsif repo.file?
             ::Katello::FileUnit.import_for_repository(repo)
+          elsif repo.generic?
+            repo.repository_type.content_types_to_index.each do |type|
+              type.model_class.import_for_repository(repo, generic_content_type: type.content_type)
+            end
           elsif repo.deb?
             if input[:import_upload_task] && input[:import_upload_task][:content_unit_href]
               unit_ids = [input[:import_upload_task][:content_unit_href]]

data/app/lib/actions/katello/repository/import_upload.rb

@@ -16,7 +16,11 @@ module Actions
           generate_applicability = options.fetch(:generate_applicability, repository.yum?)
 
           options[:content_type] ||= ::Katello::RepositoryTypeManager.find(repository.content_type).default_managed_content_type.label
-          unit_type_id = SmartProxy.pulp_primary.content_service(options[:content_type])::CONTENT_TYPE
+          if ::Katello::RepositoryTypeManager.generic_content_type?(options[:content_type])
+            unit_type_id = options[:content_type]
+          else
+            unit_type_id = SmartProxy.pulp_primary.content_service(options[:content_type])::CONTENT_TYPE
+          end
 
           sequence do
             upload_results = concurrence do

data/app/lib/actions/katello/repository/index_content.rb

@@ -10,12 +10,13 @@ module Actions
           param :contents_changed
           param :matching_content
           param :source_repository_id
+          param :full_index
         end
 
         def run
           source_repository = ::Katello::Repository.find(input[:source_repository_id]) if input[:source_repository_id]
           repo = ::Katello::Repository.find(input[:id])
-          repo.index_content(source_repository: source_repository)
+          repo.index_content(source_repository: source_repository, full_index: input[:full_index].present?)
         end
       end
     end

data/app/lib/actions/katello/repository/remove_content.rb

@@ -16,7 +16,11 @@ module Actions
           action_subject(repository)
 
           content_unit_ids = content_units.map(&:id)
-          content_unit_type = options[:content_type] || content_units.first.class::CONTENT_TYPE
+          if repository.generic?
+            content_unit_type = options[:content_type] || content_units.first.content_type
+          else
+            content_unit_type = options[:content_type] || content_units.first.class::CONTENT_TYPE
+          end
           ::Katello::RepositoryTypeManager.check_content_matches_repo_type!(repository, content_unit_type)
 
           generate_applicability = options.fetch(:generate_applicability, repository.yum?)

data/app/lib/actions/katello/repository/upload_files.rb

@@ -15,7 +15,12 @@ module Actions
           content_type ||= ::Katello::RepositoryTypeManager.find(repository.content_type).default_managed_content_type.label
           ::Katello::RepositoryTypeManager.check_content_matches_repo_type!(repository, content_type)
 
-          unit_type_id = SmartProxy.pulp_primary.content_service(content_type)::CONTENT_TYPE
+          if ::Katello::RepositoryTypeManager.generic_content_type?(content_type)
+            unit_type_id = content_type
+          else
+            unit_type_id = SmartProxy.pulp_primary.content_service(content_type)::CONTENT_TYPE
+          end
+
           upload_actions = []
 
           generate_applicability = options.fetch(:generate_applicability, repository.yum?)

data/app/lib/actions/pulp3/orchestration/repository/import_upload.rb

@@ -11,11 +11,9 @@ module Actions
             docker_tag = (args.dig(:unit_type_id) == "docker_tag")
             sequence do
               if content_unit_href
-                content_backend_service = SmartProxy.pulp_primary.content_service(args.dig(:unit_type_id))
-                duplicate_sha_path_content_list = content_backend_service.content_api.list(
-                    "sha256": file[:sha256],
-                    "relative_path": file[:filename])
+                duplicate_sha_path_content_list = ::Katello::Pulp3::PulpContentUnit.find_duplicate_unit(repository, args.dig(:unit_type_id), file, file[:sha256])
                 duplicate_content_href = duplicate_sha_path_content_list&.results&.first&.pulp_href
+
                 if duplicate_content_href
                   plan_self(:commit_output => [], :content_unit_href => duplicate_content_href)
                   action_output = plan_action(Pulp3::Repository::ImportUpload, duplicate_content_href, repository, smart_proxy).output

data/app/lib/actions/pulp3/orchestration/repository/upload_content.rb

@@ -6,18 +6,13 @@ module Actions
           include Actions::Helpers::OutputPropagator
           def plan(repository, smart_proxy, file, unit_type_id)
             sequence do
-              content_backend_service = SmartProxy.pulp_primary.content_service(unit_type_id)
-              duplicate_sha_path_content_list = content_backend_service.content_api.list(
-                  "sha256": Digest::SHA256.hexdigest(File.read(file[:path])),
-                  "relative_path": file[:filename])
+              checksum = Digest::SHA256.hexdigest(File.read(file[:path]))
+              duplicate_sha_path_content_list = ::Katello::Pulp3::PulpContentUnit.find_duplicate_unit(repository, unit_type_id, file, checksum)
               duplicate_content_href = duplicate_sha_path_content_list&.results&.first&.pulp_href
 
               unless duplicate_content_href
                 duplicate_sha_artifact_list = ::Katello::Pulp3::Api::Core.new(smart_proxy).artifacts_api.list("sha256": Digest::SHA256.hexdigest(File.read(file[:path])))
                 duplicate_sha_artifact_href = duplicate_sha_artifact_list&.results&.first&.pulp_href
-              end
-
-              unless duplicate_content_href
                 if duplicate_sha_artifact_href
                   artifact_action_output = plan_action(Pulp3::Repository::SaveArtifact, file, repository, smart_proxy, nil, unit_type_id, artifact_href: duplicate_sha_artifact_href).output
                 else

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

@@ -13,7 +13,10 @@ module Actions
           fail _("Content not uploaded to pulp") unless artifact_href
           content_type = input[:unit_type_id]
           content_backend_service = SmartProxy.pulp_primary.content_service(content_type)
-          output[:pulp_tasks] = [content_backend_service.content_api_create(relative_path: input[:options][:file_name], artifact: artifact_href)]
+          output[:pulp_tasks] = [content_backend_service.content_api_create(relative_path: input[:options][:file_name],
+                                                                            artifact: artifact_href,
+                                                                            repository_id: input[:repository_id],
+                                                                            content_type: content_type)]
         end
 
         def fetch_artifact_href

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -244,7 +244,7 @@ module Katello
 
           batch.each do |task|
             next if skip_task?(task)
-            next if !only_host_ids.nil? && only_host_ids.include?(task.input['host']['id'].to_i)
+            next unless only_host_ids.nil? || only_host_ids.include?(task.input['host']['id'].to_i)
             parse_errata(task).each do |erratum_id|
               current_erratum_errata_type = preloaded_errata.find { |k, _| k == erratum_id }.last
 

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

@@ -49,7 +49,9 @@ module Katello
       def filter_errata_by_pulp_href(errata, package_pulp_hrefs, source_repo_rpm_filenames)
         return [] if package_pulp_hrefs.empty?
         rpms = Katello::Rpm.where(:pulp_id => package_pulp_hrefs)
+        srpms = Katello::Srpm.where(:pulp_id => package_pulp_hrefs)
         rpm_filenames = rpms.map { |rpm| File.basename(rpm.filename) }
+        srpm_filenames = srpms.map { |srpm| File.basename(srpm.filename) }
         source_repo_rpm_filenames = source_repo_rpm_filenames.map { |rpm| File.basename(rpm) }
         matching_errata = []
         errata.each do |erratum|
@@ -57,7 +59,7 @@ module Katello
           next if erratum.packages.empty?
           rpms_in_erratum_and_source_repo = erratum.packages.pluck(:filename) & source_repo_rpm_filenames
           next if rpms_in_erratum_and_source_repo.empty?
-          if (rpms_in_erratum_and_source_repo - rpm_filenames).empty?
+          if (rpms_in_erratum_and_source_repo - rpm_filenames - srpm_filenames).empty?
             matching_errata << erratum
           end
         end

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

@@ -33,6 +33,8 @@ module Katello
       included do
         prepend Overrides
 
+        delegate :content_source_id, :content_view_id, :lifecycle_environment_id, :kickstart_repository_id, to: :content_facet, allow_nil: true
+
         has_many :dispatch_histories, :class_name => "::Katello::Agent::DispatchHistory", :foreign_key => :host_id, :dependent => :delete_all
 
         has_many :host_installed_packages, :class_name => "::Katello::HostInstalledPackage", :foreign_key => :host_id, :dependent => :delete_all
@@ -56,6 +58,9 @@ module Katello
         after_validation :queue_reset_content_host_status
         register_rebuild(:queue_reset_content_host_status, N_("Content_Host_Status"))
 
+        after_validation :queue_refresh_content_host_status
+        register_rebuild(:queue_refresh_content_host_status, N_("Refresh_Content_Host_Status"))
+
         scope :with_pools_expiring_in_days, ->(days) { joins(:pools).merge(Katello::Pool.expiring_in_days(days)).distinct }
 
         scoped_search :relation => :host_collections, :on => :id, :complete_value => false, :rename => :host_collection_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
@@ -99,6 +104,20 @@ module Katello
         end
       end
 
+      def refresh_content_host_status
+        self.host_statuses.where(type: ::Katello::HostStatusManager::STATUSES.map(&:name)).each do |status|
+          status.refresh!
+        end
+        refresh_global_status!
+      end
+
+      def queue_refresh_content_host_status
+        if !new_record? && !build && self.changes.key?('build')
+          queue.create(id: "refresh_content_host_status_#{id}", name: _("Refresh Content Host Statuses for %s") % self,
+            priority: 300, action: [self, :refresh_content_host_status])
+        end
+      end
+
       def reset_katello_status
         self.host_statuses.where(type: ::Katello::HostStatusManager::STATUSES.map(&:name)).each do |status|
           status.update!(:status => status.class.const_get(:UNKNOWN))

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

@@ -127,9 +127,13 @@ module Katello
         "#{self.name.demodulize.underscore}_id"
       end
 
-      def import_all(pulp_ids = nil, repository = nil, content_type_name = nil)
+      def import_all(pulp_ids = nil, repository = nil, generic_content_type = nil)
         ids_to_associate = []
-        service_class = SmartProxy.pulp_primary!.content_service(content_type)
+        if generic_content_type
+          service_class = SmartProxy.pulp_primary!.content_service(generic_content_type)
+        else
+          service_class = SmartProxy.pulp_primary!.content_service(content_type)
+        end
         service_class.pulp_units_batch_all(pulp_ids).each do |units|
           units.each do |unit|
             unit = unit.with_indifferent_access
@@ -146,7 +150,7 @@ module Katello
             service = service_class.new(model.pulp_id)
             service.backend_data = unit
             if repository&.generic?
-              service.update_model(model, repository.repository_type, content_type_name)
+              service.update_model(model, repository.repository_type, generic_content_type)
             else
               service.update_model(model)
             end
@@ -156,14 +160,21 @@ module Katello
         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, content_type_name = nil)
+      # rubocop:disable Metrics/MethodLength
+      def import_for_repository(repository, generic_content_type: nil, full_index: false)
         pulp_id_href_map = {}
-        service_class = SmartProxy.pulp_primary!.content_service(content_type)
-        fetch_only_ids = !repository.content_view.default? &&
+        if generic_content_type
+          service_class = SmartProxy.pulp_primary!.content_service(generic_content_type)
+        else
+          service_class = SmartProxy.pulp_primary!.content_service(content_type)
+        end
+        fetch_only_ids = !full_index &&
+                         !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, content_type: content_type_name).each do |units|
+        erratum_updated_ids = []
+        service_class.pulp_units_batch_for_repo(repository, fetch_identifiers: fetch_only_ids, content_type: generic_content_type).each do |units|
           units.each do |unit|
             unit = unit.with_indifferent_access
             pulp_id = unit[service_class.unit_identifier]
@@ -176,7 +187,10 @@ module Katello
               service.backend_data = unit
               model.repository_id = repository.id unless many_repository_associations
               if repository.generic?
-                service.update_model(model, repository.repository_type, content_type_name)
+                service.update_model(model, repository.repository_type, generic_content_type)
+              elsif self == ::Katello::Erratum
+                # Errata will change pulp_hrefs if the upstream repo updates them
+                erratum_updated_ids << service.update_model(model)
               else
                 service.update_model(model)
               end
@@ -184,7 +198,7 @@ module Katello
             pulp_id_href_map[pulp_id] = backend_identifier
           end
         end
-        sync_repository_associations(repository, :pulp_id_href_map => pulp_id_href_map) if self.many_repository_associations
+        sync_repository_associations(repository, :pulp_id_href_map => pulp_id_href_map, generic_content_type: generic_content_type, erratum_updated_ids: erratum_updated_ids.uniq) if self.many_repository_associations
       end
 
       def sync_repository_associations(repository, options = {})
@@ -196,21 +210,28 @@ module Katello
         id_href_map_for_repository = {}
         ids_for_repository.each { |id_href| id_href_map_for_repository[id_href[0]] = id_href[1] }
         id_href_map_for_repository.each_pair { |k, v| id_href_map_for_repository[k] = pulp_id_href_map[v] }
+        erratum_updated_ids = options.fetch(:erratum_updated_ids, []).flatten.compact
 
         existing_ids = self.repository_association_class.uncached do
           self.repository_association_class.where(:repository_id => repository).pluck(unit_id_field)
         end
 
+        new_ids = associated_ids - existing_ids
         ActiveRecord::Base.transaction do
           if !additive && (delete_ids = existing_ids - associated_ids).any?
             query = "DELETE FROM #{self.repository_association_class.table_name} WHERE repository_id=#{repository.id} AND #{unit_id_field} IN (#{delete_ids.join(', ')})"
             ActiveRecord::Base.connection.execute(query)
           end
-          unless (new_ids = associated_ids - existing_ids).empty?
-            self.repository_association_class.import(db_columns_sync, db_values(new_ids, id_href_map_for_repository, repository), validate: false)
+          if self == ::Katello::Erratum
+            self.update_repo_association_records(new_ids, erratum_updated_ids, id_href_map_for_repository, repository)
+          else
+            unless new_ids.empty?
+              self.repository_association_class.import(db_columns_sync, db_values(new_ids, id_href_map_for_repository, repository), validate: false)
+            end
           end
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       def copy_repository_associations(source_repo, dest_repo)
         if many_repository_associations

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

@@ -4,6 +4,7 @@ require 'proxy_api/pulp_node'
 
 module Katello
   module Concerns
+    # rubocop:disable Metrics/ModuleLength
     module SmartProxyExtensions
       extend ActiveSupport::Concern
 
@@ -110,18 +111,52 @@ module Katello
         end
       end
 
-      def update_unauthenticated_repo_list(repo_names)
-        ProxyAPI::ContainerGateway.new(url: self.url).unauthenticated_repository_list("repositories": repo_names)
+      def sync_container_gateway
+        if has_feature?(::SmartProxy::CONTAINER_GATEWAY_FEATURE)
+          update_container_repo_list
+          users = container_gateway_users
+          update_user_container_repo_mapping(users) if users.any?
+        end
       end
 
-      def update_container_repo_list(repo_list)
+      def update_container_repo_list
+        # [{ repository: "repoA", auth_required: false }]
+        repo_list = []
+        ::Katello::SmartProxyHelper.new(self).combined_repos_available_to_capsule.each do |repo|
+          if repo.docker? && !repo.container_repository_name.nil?
+            repo_list << { repository: repo.container_repository_name,
+                           auth_required: !unauthenticated_container_repositories.include?(repo.id) }
+          end
+        end
         ProxyAPI::ContainerGateway.new(url: self.url).repository_list({ repositories: repo_list })
       end
 
-      def update_user_container_repo_mapping(user_repo_map)
+      def update_user_container_repo_mapping(users)
+        # Example user-repo mapping:
+        # { users:
+        #   [
+        #     'user a' => [{ repository: 'repo 1', auth_required: true }]
+        #   ]
+        # }
+
+        user_repo_map = { users: [] }
+        users.each do |user|
+          inner_repo_list = []
+          repositories = ::Katello::Repository.readable_docker_catalog_as(user)
+          repositories.each do |repo|
+            next if repo.container_repository_name.nil?
+            inner_repo_list << { repository: repo.container_repository_name,
+                                 auth_required: !unauthenticated_container_repositories.include?(repo.id) }
+          end
+          user_repo_map[:users] << { user.login => inner_repo_list }
+        end
         ProxyAPI::ContainerGateway.new(url: self.url).user_repository_mapping(user_repo_map)
       end
 
+      def unauthenticated_container_repositories
+        ::Katello::Repository.joins(:environment).where("#{::Katello::KTEnvironment.table_name}.registry_unauthenticated_pull" => true).select(:id).pluck(:id)
+      end
+
       def container_gateway_users
         usernames = ProxyAPI::ContainerGateway.new(url: self.url).users
         ::User.where(login: usernames['users'])

data/app/models/katello/content_view.rb

@@ -370,6 +370,19 @@ module Katello
       end
     end
 
+    def update_host_statuses(environment)
+      # update errata applicability counts for all hosts in the CV & LE
+      Location.no_taxonomy_scope do
+        User.as_anonymous_admin do
+          ::Katello::Host::ContentFacet.where(:content_view_id => self,
+                                              :lifecycle_environment_id => environment).each do |facet|
+            facet.update_applicability_counts
+            facet.update_errata_status
+          end
+        end
+      end
+    end
+
     def component_repositories
       components.map(&:archived_repos).flatten
     end

data/app/models/katello/content_view_repository.rb

@@ -6,7 +6,7 @@ module Katello
                                 Repository::FILE_TYPE,
                                 Repository::DEB_TYPE,
                                 Repository::ANSIBLE_COLLECTION_TYPE,
-                                Katello::RepositoryTypeManager.generic_repository_types(enabled_only: false).keys.flatten
+                                Katello::RepositoryTypeManager.generic_repository_types(false).keys.flatten
                                ].flatten.freeze
 
     ALLOWED_IMPORT_REPOSITORY_TYPES = Repository::EXPORTABLE_TYPES

data/app/models/katello/docker_tag.rb

@@ -58,8 +58,8 @@ module Katello
       docker_taggable_id
     end
 
-    def self.import_for_repository(repository)
-      super(repository)
+    def self.import_for_repository(repository, options = {})
+      super(repository, options)
       ::Katello::DockerMetaTag.import_meta_tags([repository])
     end