katello 3.16.0.rc2 → 3.16.0.rc2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d597d3adc595085248321cc7335d3ade0a0d6633b391e7914e673610caafe440
-  data.tar.gz: e41d0dca5de9743da0db2fcc0eb0949db86ad30bfd90246fddac455a8778b173
+  metadata.gz: 07abcc2d0e780bd3bfee4cd44b73ef4183e0a50daebe6a32cd056e162e3fde52
+  data.tar.gz: 6c95fe44a013f6e74d36098c3e96f8e669f5670925620a9dc26e6ed674cc2abb
 SHA512:
-  metadata.gz: 132a3d704edfa1a85d55462b58e01e08429fe44f64f0ed4de35698fa20b3350036b4c32da9d59f6d80b201ed8039d54f03f005bf81960420235fca63857e6071
-  data.tar.gz: c45c05cc5b43fae7061bd985d551e27c5bd59072b41b38d90fe8f241654168c2280f4319d48de8e30cdc0a77e04be84a58e0f7b96342c582e551bf11dc4f790e
+  metadata.gz: 17dece7796e9c33d88970ed5eaba5d810db5b84c76ddc03d0767c8bf426013ac9c3e29f14a3bb3be6663e0233e8968551294f51000fb4161e348028add9ecb0b
+  data.tar.gz: c8b139917779fb48e642270141eb4418c4f668433307cb8097661b581985edc7163f67524328f13368c5cf80d7fc51ef2c856816eacb19ff9a720f40cef595d8

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

@@ -10,6 +10,8 @@ module Actions
           action_subject root.library_instance
 
           repo_params[:url] = nil if repo_params[:url] == ''
+          update_cv_cert_protected = (repo_params[:unprotected] != repository.unprotected)
+
           root.update!(repo_params)
 
           if root.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND
@@ -44,15 +46,24 @@ module Actions
                               ::Actions::Pulp3::Orchestration::Repository::Update],
                              repository,
                              SmartProxy.pulp_master)
-            plan_self(:repository_id => root.library_instance.id)
+            plan_self(:repository_id => root.library_instance.id, :update_cv_cert_protected => update_cv_cert_protected)
           end
         end
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])
+          output[:repository_id] = input[:repository_id]
+          output[:update_cv_cert_protected] = input[:update_cv_cert_protected]
           ForemanTasks.async_task(Katello::Repository::MetadataGenerate, repository)
         end
 
+        def finalize
+          repository = ::Katello::Repository.find(output[:repository_id])
+          if output[:update_cv_cert_protected]
+            ForemanTasks.async_task(::Actions::Katello::Repository::UpdateCVRepoCertGuard, repository, SmartProxy.pulp_master)
+          end
+        end
+
         private
 
         def update_content?(repository)

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

@@ -0,0 +1,17 @@
+module Actions
+  module Katello
+    module Repository
+      class UpdateCVRepoCertGuard < Actions::Base
+        include Actions::Katello::PulpSelector
+
+        def plan(repository, smart_proxy)
+          plan_optional_pulp_action([::Actions::Pulp3::Repository::UpdateCVRepositoryCertGuard], repository, smart_proxy)
+        end
+
+        def humanized_name
+          _("Updating repository authentication configuration")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/ContentGuard/refresh.rb

@@ -0,0 +1,19 @@
+module Actions
+  module Pulp3
+    module ContentGuard
+      class Refresh < Pulp3::Abstract
+        def plan(smart_proxy, options = {})
+          return if (::Katello::Pulp3::ContentGuard.count > 0 || options.try(:[], :update))
+          content_guard_api = ::Katello::Pulp3::Api::ContentGuard.new(smart_proxy)
+          if options.try(:[], :update)
+            content_guard_href = ::Katello::Pulp3::ContentGuard.first.href
+            content_guard_api.partial_update content_guard_href
+          else
+            content_guard_api.create
+            ::Katello::Pulp3::ContentGuard.import(smart_proxy)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,25 +13,23 @@ module Actions
             if filter_ids.present? || rpm_filenames.present? || source_repositories.length > 1
               sequence do
                 if filter_ids.present? || rpm_filenames.present?
-                  copy_action = plan_action(Actions::Pulp3::Repository::CopyContent,
-                                            source_repositories.first, smart_proxy, target_repo,
+                  copy_action = plan_action(Actions::Pulp3::Repository::CopyContent, source_repositories.first, smart_proxy, target_repo,
                                             filter_ids: filter_ids, solve_dependencies: solve_dependencies,
                                             rpm_filenames: rpm_filenames)
-
-                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: copy_action.output[:pulp_tasks])
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo,
+                              repository_details: { latest_version_href: copy_action.output[:latest_version_href] }, tasks: copy_action.output[:pulp_tasks])
                 else
                   #if we are not filtering, copy the version to the cv repository, and the units for each additional repo
                   action = plan_action(Actions::Pulp3::Repository::CopyVersion, source_repositories.first, smart_proxy, target_repo)
-                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: action.output[:pulp_tasks])
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo,
+                              repository_details: { latest_version_href: action.output[:latest_version_output] }, tasks: action.output[:pulp_tasks])
                   copy_actions = []
                   #since we're creating a new version from the first repo, start copying at the 2nd
                   source_repositories[1..-1].each do |source_repo|
-                    copy_actions << plan_action(Actions::Pulp3::Repository::CopyContent,
-                                                source_repo, smart_proxy, target_repo,
+                    copy_actions << plan_action(Actions::Pulp3::Repository::CopyContent, source_repo, smart_proxy, target_repo,
                                                 filter_ids: filter_ids, solve_dependencies: solve_dependencies,
                                                 rpm_filenames: rpm_filenames)
                   end
-
                   plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: copy_actions.last.output[:pulp_tasks])
                 end
               end

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

@@ -12,7 +12,7 @@ module Actions
               elsif publication_content_type
                 plan_action(Actions::Pulp3::Repository::CreatePublication, repository, smart_proxy, options)
               end
-
+              plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
               plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if repository.environment
             end
           end

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

@@ -11,6 +11,7 @@ module Actions
         def invoke_external_task
           source = ::Katello::Repository.find(input[:source_repository_id])
           target = ::Katello::Repository.find(input[:target_repository_id] || input[:target_repository])
+          output[:latest_version_href] = target.backend_service(smart_proxy).read.latest_version_href
           output[:pulp_tasks] = target.backend_service(smart_proxy).copy_content_for_source(source, input)
         end
       end

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

@@ -9,6 +9,7 @@ module Actions
           sequence do
             options = {:repository_id => repository.id, :smart_proxy_id => smart_proxy.id}
             options[:contents_changed] if options.key?(:contents_changed)
+            plan_action(::Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
             action = plan_self(options)
             plan_action(SaveDistributionReferences, repository, smart_proxy,
                         action.output, :contents_changed => options[:contents_changed])

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

@@ -12,9 +12,11 @@ module Actions
           if input[:tasks] && input[:tasks][:pulp_tasks] && input[:tasks][:pulp_tasks].first
             distribution_hrefs = input[:tasks][:pulp_tasks].map { |task| task[:created_resources].first }
             distribution_hrefs.compact!
+            repo = ::Katello::Repository.find(input[:repository_id])
             if distribution_hrefs.any?
-              repo = ::Katello::Repository.find(input[:repository_id])
               repo.backend_service(smart_proxy).save_distribution_references(distribution_hrefs)
+            else
+              repo.backend_service(smart_proxy).update_distribution
             end
           end
         end

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

@@ -11,7 +11,9 @@ module Actions
 
           if input[:tasks]
             version_href = input[:tasks].last[:created_resources].first
-          elsif input[:repository_details]
+          end
+
+          if !version_href && input[:repository_details]
             version_href = input[:repository_details][:latest_version_href]
           end
 

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

@@ -0,0 +1,15 @@
+module Actions
+  module Pulp3
+    module Repository
+      class UpdateCVRepositoryCertGuard < Pulp3::Abstract
+        def plan(repository, _smart_proxy)
+          root = repository.root
+          cv_repositories = root.repositories - [root.library_instance]
+          cv_repositories.each do |repo|
+            plan_action(::Actions::Pulp3::Repository::RefreshDistribution, repo, SmartProxy.pulp_master)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -45,6 +45,19 @@ module Katello
           return errata_list
         end
       end
+
+      def filter_errata_by_pulp_href(errata, package_pulp_hrefs)
+        return [] if package_pulp_hrefs.empty?
+        rpms = Katello::Rpm.where(:pulp_id => package_pulp_hrefs)
+        rpm_filenames = rpms.map { |rpm| File.basename(rpm.filename) }
+        matching_errata = []
+        errata.each do |erratum|
+          if erratum.packages.any? && (erratum.packages.pluck(:filename) - rpm_filenames).empty?
+            matching_errata << erratum
+          end
+        end
+        matching_errata
+      end
     end
   end
 end

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

@@ -0,0 +1,32 @@
+module Katello
+  module Util
+    module PulpcoreContentFilters
+      def filter_distribution_trees_by_pulp_hrefs(distributiontree_results, _content_pulp_hrefs)
+        distributiontree_results.collect { |result| result.pulp_href }.flatten.uniq
+      end
+
+      def filter_package_groups_by_pulp_href(package_groups, package_pulp_hrefs)
+        rpms = Katello::Rpm.where(:pulp_id => package_pulp_hrefs)
+        package_groups.reject do |package_group|
+          (package_group.package_names & rpms.pluck(:name)).empty?
+        end
+      end
+
+      def filter_package_environments_by_pulp_hrefs(packageenvironment_results, package_pulp_hrefs)
+        matching_package_env_groups = []
+
+        packageenvironment_results.each do |result|
+          if (result.packagegroups & package_pulp_hrefs).any?
+            matching_package_env_groups << result.pulp_href
+          end
+        end
+
+        matching_package_env_groups.flatten.uniq
+      end
+
+      def filter_metadatafiles_by_pulp_hrefs(metadatafiles_results, _package_pulp_hrefs)
+        metadatafiles_results.collect { |result| result.pulp_href }.flatten.uniq
+      end
+    end
+  end
+end

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

@@ -44,7 +44,6 @@ module Katello
       end
 
       def backend_identifier_field
-        nil
       end
 
       def content_unit_class
@@ -108,7 +107,8 @@ module Katello
         pulp_id_href_map = {}
         service_class = SmartProxy.pulp_master!.content_service(content_type)
         fetch_only_ids = !repository.content_view.default? &&
-                         !repository.repository_type.unique_content_per_repo
+                         !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|
           units.each do |unit|

data/app/models/katello/content_view_erratum_filter.rb

@@ -26,8 +26,37 @@ module Katello
       end
     end
 
+    def content_unit_pulp_ids(repo)
+      if filter_by_id?
+        errata_ids = erratum_rules.map(&:errata_id)
+        errata_pulp_ids = errata_package_pulp_ids_from_errata_ids(repo, errata_ids)
+      else
+        clauses = []
+        clauses << errata_from
+        clauses << errata_to
+        clauses << types_clause
+        package_filenames = Erratum.list_filenames_by_clauses(repo, clauses.compact)
+        errata_pulp_ids = errata_package_pulp_ids_from_package_filenames(repo, package_filenames)
+      end
+      errata_pulp_ids
+    end
+
     private
 
+    def rpms_by_filename(repo, package_filenames)
+      query_params = package_filenames.map { |filename| "%#{filename}" }
+      repo.rpms.where("filename ILIKE ANY ( array[?] )", query_params)
+    end
+
+    def errata_package_pulp_ids_from_package_filenames(repo, package_filenames)
+      rpms_by_filename(repo, package_filenames).pluck(:pulp_id)
+    end
+
+    def errata_package_pulp_ids_from_errata_ids(repo, errata_ids)
+      package_filenames = Katello::ErratumPackage.joins(:erratum).where("#{Erratum.table_name}.errata_id" => errata_ids).pluck(:filename)
+      rpms_by_filename(repo, package_filenames).pluck(:pulp_id)
+    end
+
     def erratum_arel
       ::Katello::Erratum.arel_table
     end

data/app/models/katello/content_view_package_filter.rb

@@ -7,7 +7,11 @@ module Katello
     validates_lengths_from_database
 
     # Returns a set of Pulp/MongoDB conditions to filter out packages in the
-    # repo repository that match parameters
+    # repo repository that match parameters if the repository content type
+    # is managed by pulp2.
+    #
+    # Returns a set of pulpcore hrefs (pulp_ids) if the repository content
+    # type is managed by pulpcore.
     #
     # @param repo [Repository] a repository containing packages to filter
     # @return [Array] an array of hashes with MongoDB conditions
@@ -20,6 +24,7 @@ module Katello
       if self.original_packages
         package_filenames.concat(repo.packages_without_errata.map(&:filename))
       end
+
       ContentViewPackageFilter.generate_rpm_clauses(package_filenames)
     end
 
@@ -27,6 +32,16 @@ module Katello
       self[:original_packages] = value
     end
 
+    def content_unit_pulp_ids(repo)
+      package_filenames = []
+      self.package_rules.each do |rule|
+        package_filenames.concat(query_rpms(repo, rule))
+      end
+
+      rpms = Rpm.in_repositories(repo)
+      rpms.where(filename: package_filenames).where(:modular => false).pluck(:pulp_id).flatten.uniq
+    end
+
     def self.generate_rpm_clauses(package_filenames = [])
       { 'filename' => { "$in" => package_filenames } } unless package_filenames.empty?
     end

data/app/models/katello/content_view_package_group_filter.rb

@@ -10,5 +10,12 @@ module Katello
       package_group_ids = package_group_rules.reject { |rule| rule.uuid.blank? }.flat_map.map(&:uuid)
       { "_id" => { "$in" => package_group_ids } } unless package_group_ids.empty?
     end
+
+    def content_unit_pulp_ids(repo)
+      package_group_hrefs = package_group_rules.reject { |rule| rule.uuid.blank? }.flat_map.map(&:uuid)
+      package_group_names = repo.package_groups.
+        where(:pulp_id => package_group_hrefs).collect { |package_group| package_group.package_names }.flatten.uniq
+      repo.rpms.where(:name => package_group_names).pluck(:pulp_id).compact
+    end
   end
 end

data/app/models/katello/package_group.rb

@@ -25,7 +25,8 @@ module Katello
     end
 
     def package_names
-      group = Pulp::PackageGroup.new(self.pulp_id)
+      service_class = SmartProxy.pulp_master!.content_service(CONTENT_TYPE)
+      group = service_class.new(self.pulp_id)
       group.default_package_names + group.conditional_package_names + group.optional_package_names + group.mandatory_package_names
     end
   end

data/app/models/katello/pulp3/content_guard.rb

@@ -0,0 +1,14 @@
+module Katello
+  module Pulp3
+    class ContentGuard < Katello::Model
+      def self.import(smart_proxy = SmartProxy.pulp_master!, force = false)
+        return unless (count == 0 || force)
+        content_guard_api = Katello::Pulp3::Api::ContentGuard.new(smart_proxy)
+        content_guard = content_guard_api.list&.results&.first
+        fail _("No Content Guard configured!") unless content_guard
+        katello_content_guard = self.new(name: content_guard.name, pulp_href: content_guard.pulp_href)
+        katello_content_guard.save!
+      end
+    end
+  end
+end

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

@@ -34,6 +34,10 @@ module Katello
         nil
       end
 
+      def self.supports_id_fetch?
+        true
+      end
+
       def self.content_type
         self::CONTENT_TYPE
       end

data/app/services/katello/pulp3/api/content_guard.rb

@@ -0,0 +1,45 @@
+require 'pulp_certguard_client'
+
+module Katello
+  module Pulp3
+    module Api
+      class ContentGuard < Core
+        def self.client_module
+          PulpCertguardClient
+        end
+
+        def self.api_exception_class
+          PulpCertguardClient::ApiError
+        end
+
+        def api_client
+          PulpCertguardClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpCertguardClient::Configuration))
+        end
+
+        def rhsm_api_client
+          PulpCertguardClient::ContentguardsRhsmApi.new(api_client)
+        end
+
+        def create(name = "RHSMCertGuard", ca_certificate = Cert::Certs.ca_cert)
+          data = PulpCertguardClient::CertguardRHSMCertGuard.new(name: name, ca_certificate: ca_certificate)
+          rhsm_api_client.create(data)
+        rescue self.class.api_exception_class => e
+          raise e unless list&.results&.first
+        end
+
+        def list(options = {})
+          rhsm_api_client.list options
+        end
+
+        def partial_update(href, ca_certificate = Cert::Certs.ca_cert)
+          data = PulpCertguardClient::CertguardRHSMCertGuard.new(ca_certificate: ca_certificate)
+          rhsm_api_client.partial_update(href, data)
+        end
+
+        def delete(href)
+          rhsm_api_client.delete(href) if href
+        end
+      end
+    end
+  end
+end

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

@@ -28,6 +28,10 @@ module Katello
           PulpRpmClient::RpmRepositorySyncURL
         end
 
+        def self.rpm_package_group_class
+          PulpRpmClient::RpmPackageGroup
+        end
+
         def api_client
           PulpRpmClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpRpmClient::Configuration))
         end
@@ -51,6 +55,26 @@ module Katello
         def distributions_api
           PulpRpmClient::DistributionsRpmApi.new(api_client)
         end
+
+        def copy_api
+          PulpRpmClient::RpmCopyApi.new(api_client)
+        end
+
+        def content_package_groups_api
+          PulpRpmClient::ContentPackagegroupsApi.new(api_client)
+        end
+
+        def content_package_environments_api
+          PulpRpmClient::ContentPackageenvironmentsApi.new(api_client)
+        end
+
+        def content_repo_metadata_files_api
+          PulpRpmClient::ContentRepoMetadataFilesApi.new(api_client)
+        end
+
+        def content_distribution_trees_api
+          PulpRpmClient::ContentDistributionTreesApi.new(api_client)
+        end
       end
     end
   end

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

@@ -15,6 +15,10 @@ module Katello
         "pulp_href"
       end
 
+      def self.supports_id_fetch?
+        false
+      end
+
       def self.ids_for_repository(repo_id)
         repo = Katello::Pulp3::Repository::Yum.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
         repo_content_list = repo.content_list

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

@@ -19,6 +19,10 @@ module Katello
         nil
       end
 
+      def self.supports_id_fetch?
+        true
+      end
+
       def update_model
         fail NotImplementedError
       end

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

@@ -143,7 +143,7 @@ module Katello
 
       def distribution_needs_update?
         if distribution_reference
-          expected = distribution_options(relative_path).except(:name).compact
+          expected = secure_distribution_options(relative_path).except(:name).compact
           actual = get_distribution.to_hash
           expected != actual.slice(*expected.keys)
         elsif repo.environment
@@ -180,6 +180,10 @@ module Katello
         api.repositories_api.list(options).results
       end
 
+      def read
+        api.repositories_api.read(repository_reference.try(:repository_href))
+      end
+
       def delete(href = repository_reference.try(:repository_href))
         repository_reference.try(:destroy)
         ignore_404_exception { api.repositories_api.delete(href) } if href
@@ -209,7 +213,7 @@ module Katello
       end
 
       def create_distribution(path)
-        distribution_data = api.class.distribution_class.new(distribution_options(path))
+        distribution_data = api.class.distribution_class.new(secure_distribution_options(path))
         api.distributions_api.create(distribution_data)
       end
 
@@ -219,7 +223,8 @@ module Katello
 
       def update_distribution
         if distribution_reference
-          options = distribution_options(relative_path).except(:name)
+          options = secure_distribution_options(relative_path).except(:name)
+          distribution_reference.update(:content_guard_href => options[:content_guard])
           api.distributions_api.partial_update(distribution_reference.href, options)
         end
       end
@@ -246,9 +251,10 @@ module Katello
 
       def save_distribution_references(hrefs)
         hrefs.each do |href|
-          path = api.get_distribution(href)&.base_path
+          pulp3_distribution_data = api.get_distribution(href)
+          path, content_guard_href = pulp3_distribution_data&.base_path, pulp3_distribution_data&.content_guard
           unless distribution_reference
-            DistributionReference.create!(path: path, href: href, repository_id: repo.id)
+            DistributionReference.create!(path: path, href: href, repository_id: repo.id, content_guard_href: content_guard_href)
           end
         end
       end
@@ -284,6 +290,16 @@ module Katello
         remote_options.merge!(ssl_remote_options)
       end
 
+      def secure_distribution_options(path)
+        secured_distribution_options = {}
+        if root.unprotected
+          secured_distribution_options[:content_guard] = nil
+        else
+          secured_distribution_options[:content_guard] = ::Katello::Pulp3::ContentGuard.first.pulp_href
+        end
+        secured_distribution_options.merge!(distribution_options(path))
+      end
+
       def ssl_remote_options
         if root.redhat? && Katello::Resources::CDN::CdnResource.redhat_cdn?(root.url)
           {

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

@@ -4,6 +4,9 @@ module Katello
   module Pulp3
     class Repository
       class Yum < ::Katello::Pulp3::Repository
+        include Katello::Util::Errata
+        include Katello::Util::PulpcoreContentFilters
+
         def remote_options
           if root.url.blank?
             common_remote_options.merge(url: nil, policy: root.download_policy)
@@ -59,9 +62,93 @@ module Katello
           "/pulp/repos/#{repo.relative_path}/".sub('//', '/')
         end
 
-        def copy_content_for_source
-          # TODO
-          fail NotImplementedError
+        def copy_units(source_repository_version_href, content_unit_hrefs, dependency_solving)
+          tasks = []
+
+          if content_unit_hrefs.any?
+            data = PulpRpmClient::Copy.new
+            data.config = [
+              source_repo_version: source_repository_version_href,
+              dest_repo: repository_reference.repository_href,
+              dest_base_version: 0,
+              content: content_unit_hrefs.sort
+            ]
+            data.dependency_solving = dependency_solving
+            tasks << api.copy_api.copy_content(data)
+          else
+            data = PulpRpmClient::RepositoryAddRemoveContent.new(
+              remove_content_units: ['*'])
+            tasks << api.repositories_api.modify(repository_reference.repository_href, data)
+          end
+
+          tasks
+        end
+
+        def packageenvironments(options = {})
+          api.content_package_environments_api.list(options)
+        end
+
+        def metadatafiles(options = {})
+          api.content_repo_metadata_files_api.list(options)
+        end
+
+        def distributiontrees(options = {})
+          api.content_distribution_trees_api.list(options)
+        end
+
+        def copy_content_for_source(source_repository, options = {})
+          filters = [ContentViewErratumFilter, ContentViewPackageGroupFilter, ContentViewPackageFilter].collect do |filter_class|
+            filter_class.where(:id => options[:filter_ids])
+          end
+
+          filters.flatten!.compact!
+
+          whitelist_ids = []
+          blacklist_ids = []
+          filters.each do |filter|
+            if filter.inclusion
+              whitelist_ids += filter.content_unit_pulp_ids(source_repository)
+            else
+              blacklist_ids += filter.content_unit_pulp_ids(source_repository)
+            end
+          end
+
+          if whitelist_ids.empty? && filters.select { |filter| filter.inclusion }.empty?
+            whitelist_ids = source_repository.rpms.where(:modular => false).pluck(:pulp_id).sort
+          end
+
+          content_unit_hrefs = whitelist_ids - blacklist_ids
+
+          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)
+
+          dependency_solving = options[:solve_dependencies] || false
+          copy_units(source_repository.version_href, content_unit_hrefs.uniq, dependency_solving)
+        end
+
+        def additional_content_hrefs(source_repository, content_unit_hrefs)
+          repo_service = source_repository.backend_service(SmartProxy.pulp_master)
+          options = { :repository_version => source_repository.version_href }
+
+          errata_to_include = filter_errata_by_pulp_href(source_repository.errata, content_unit_hrefs)
+          content_unit_hrefs += errata_to_include.collect { |erratum| erratum.repository_errata.pluck(:erratum_pulp3_href) }.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)
+
+          package_environment_hrefs_to_include = filter_package_environments_by_pulp_hrefs(
+            repo_service.packageenvironments(options).results, package_groups_to_include.pluck(:pulp_id))
+          content_unit_hrefs += package_environment_hrefs_to_include
+
+          metadata_file_hrefs_to_include = filter_metadatafiles_by_pulp_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)
+          content_unit_hrefs + distribution_tree_hrefs_to_include
         end
 
         def regenerate_applicability

data/db/migrate/20200407171926_create_content_guard.rb

@@ -0,0 +1,10 @@
+class CreateContentGuard < ActiveRecord::Migration[5.2]
+  def change
+    create_table :katello_content_guards do |t|
+      t.string :pulp_href, :null => false
+      t.string :name, :null => false, :unique => true
+    end
+
+    add_column :katello_distribution_references, :content_guard_href, :string
+  end
+end

data/lib/katello/version.rb

@@ -1,3 +1,3 @@
 module Katello
-  VERSION = "3.16.0.rc2".freeze
+  VERSION = "3.16.0.rc2.1".freeze
 end

data/webpack/scenes/Subscriptions/SubscriptionActions.js

@@ -38,7 +38,7 @@ import {
   stopPollingTasks,
   toastTaskFinished,
 } from '../Tasks/TaskActions';
-import { selectIsPollingTasks, selectIsPollingTask } from '../Tasks/TaskSelectors';
+import { selectIsPollingTasks } from '../Tasks/TaskSelectors';
 
 export const createSubscriptionParams = (extendedParams = {}) => ({
   ...{
@@ -104,19 +104,17 @@ export const resetTasks = () => (dispatch) => {
   });
 };
 
-export const handleTask = task => async (dispatch, getState) => {
-  if (selectIsPollingTask(getState(), SUBSCRIPTIONS)) {
-    if (!task.pending) {
-      dispatch(stopPollingTask(SUBSCRIPTIONS));
-      dispatch(toastTaskFinished(task));
-      dispatch(resetTasks());
-      dispatch(pollTasks());
-      dispatch(loadSubscriptions());
-    }
-  } else {
-    dispatch(cancelPollTasks());
-    dispatch(startPollingTask(SUBSCRIPTIONS, task));
-  }
+export const handleFinishedTask = task => (dispatch) => {
+  dispatch(stopPollingTask(SUBSCRIPTIONS));
+  dispatch(toastTaskFinished(task));
+  dispatch(resetTasks());
+  dispatch(pollTasks());
+  dispatch(loadSubscriptions());
+};
+
+export const handleStartTask = task => (dispatch) => {
+  dispatch(cancelPollTasks());
+  dispatch(startPollingTask(SUBSCRIPTIONS, task));
 };
 
 export const updateQuantity = (quantities = {}) => async (dispatch) => {

data/webpack/scenes/Subscriptions/SubscriptionsPage.js

@@ -39,11 +39,16 @@ class SubscriptionsPage extends Component {
 
   componentDidUpdate(prevProps) {
     const {
-      organization, task, handleTask,
+      organization, task, handleStartTask, handleFinishedTask, isTaskPending, isPollingTask,
     } = this.props;
-
     if (task) {
-      handleTask(task);
+      if (isPollingTask) {
+        if (prevProps.isTaskPending && !isTaskPending) {
+          handleFinishedTask(task);
+        }
+      } else {
+        handleStartTask(task);
+      }
     }
 
     if (organization) {
@@ -291,9 +296,12 @@ SubscriptionsPage.propTypes = {
     }),
     pending: PropTypes.bool,
   }),
+  isTaskPending: PropTypes.bool,
+  isPollingTask: PropTypes.bool,
   pollTasks: PropTypes.func.isRequired,
   cancelPollTasks: PropTypes.func.isRequired,
-  handleTask: PropTypes.func.isRequired,
+  handleStartTask: PropTypes.func.isRequired,
+  handleFinishedTask: PropTypes.func.isRequired,
   loadSetting: PropTypes.func.isRequired,
   loadTables: PropTypes.func.isRequired,
   createColumns: PropTypes.func.isRequired,
@@ -314,6 +322,8 @@ SubscriptionsPage.propTypes = {
 
 SubscriptionsPage.defaultProps = {
   task: undefined,
+  isTaskPending: undefined,
+  isPollingTask: undefined,
   organization: undefined,
   searchQuery: '',
   deleteModalOpened: false,

data/webpack/scenes/Subscriptions/SubscriptionsSelectors.js

@@ -16,5 +16,13 @@ export const selectActivePermissions = state =>
 export const selectSubscriptionsTask = state =>
   selectSubscriptionsState(state).task;
 
+export const selectIsTaskPending = (state) => {
+  const task = selectSubscriptionsTask(state);
+  if (task) {
+    return task.pending || task.result === 'pending';
+  }
+  return false;
+};
+
 export const selectTableSettings = (state, tableName) =>
   state.katello.settings.tables[tableName] || undefined;

data/webpack/scenes/Subscriptions/__tests__/SubscriptionsActions.test.js

@@ -18,7 +18,8 @@ import {
   loadTableColumnsSuccessAction,
 } from './subscriptions.fixtures';
 import {
-  handleTask,
+  handleFinishedTask,
+  handleStartTask,
   pollTasks,
   cancelPollTasks,
   resetTasks,
@@ -33,7 +34,7 @@ import {
   enableDeleteButton,
 } from '../SubscriptionActions';
 
-import { getTaskPendingResponse, getTaskSuccessResponse } from '../../Tasks/__tests__/task.fixtures';
+import { getTaskSuccessResponse } from '../../Tasks/__tests__/task.fixtures';
 
 const mockStore = configureMockStore([thunk]);
 const store = mockStore(Immutable({
@@ -159,27 +160,15 @@ describe('subscription actions', () => {
     );
   });
 
-  describe('handleTask', () => {
-    describe('when not polling a task', () => {
-      it('starts polling the task', async () => {
-        await store.dispatch(handleTask(getTaskSuccessResponse));
+  describe('handleStartTask', () => {
+    it('starts polling the task', async () => {
+      await store.dispatch(handleStartTask(getTaskSuccessResponse));
 
-        expect(store.getActions()).toMatchSnapshot();
-      });
-    });
-
-    it('does nothing if already polling and task is pending', async () => {
-      const pollStore = configureMockStore([thunk])({
-        intervals: {
-          SUBSCRIPTIONS_POLL_TASK: 5,
-        },
-      });
-
-      await pollStore.dispatch(handleTask(getTaskPendingResponse));
-
-      expect(pollStore.getActions()).toMatchSnapshot();
+      expect(store.getActions()).toMatchSnapshot();
     });
+  });
 
+  describe('handleFinishedTask', () => {
     it('handles a finished task', async () => {
       const pollStore = configureMockStore([thunk])({
         intervals: {
@@ -187,7 +176,7 @@ describe('subscription actions', () => {
         },
       });
 
-      await pollStore.dispatch(handleTask(getTaskSuccessResponse));
+      await pollStore.dispatch(handleFinishedTask(getTaskSuccessResponse));
 
       expect(pollStore.getActions()).toMatchSnapshot();
     });

data/webpack/scenes/Subscriptions/__tests__/SubscriptionsPage.test.js

@@ -16,11 +16,13 @@ const loadTables = () => new Promise((resolve) => {
 });
 
 const pollTasks = jest.fn();
-const handleTask = jest.fn();
+const handleStartTask = jest.fn();
+const handleFinishedTask = jest.fn();
 
 afterEach(() => {
   pollTasks.mockClear();
-  handleTask.mockClear();
+  handleStartTask.mockClear();
+  handleFinishedTask.mockClear();
 });
 
 describe('subscriptions page', () => {
@@ -39,7 +41,8 @@ describe('subscriptions page', () => {
     updateColumns={updateColumns}
     loadSubscriptions={loadSubscriptions}
     updateQuantity={updateQuantity}
-    handleTask={handleTask}
+    handleStartTask={handleStartTask}
+    handleFinishedTask={handleFinishedTask}
     pollTaskUntilDone={noop}
     pollBulkSearch={noop}
     pollTasks={pollTasks}
@@ -71,7 +74,8 @@ describe('subscriptions page', () => {
     updateColumns={updateColumns}
     loadSubscriptions={loadSubscriptions}
     updateQuantity={updateQuantity}
-    handleTask={handleTask}
+    handleStartTask={handleStartTask}
+    handleFinishedTask={handleFinishedTask}
     pollTaskUntilDone={noop}
     pollBulkSearch={noop}
     pollTasks={pollTasks}
@@ -118,8 +122,9 @@ describe('subscriptions page', () => {
       },
     };
 
-    page.setProps({ task: mockTask });
+    page.setProps({ isTaskPending: true, isPollingTask: true });
+    page.setProps({ task: mockTask, isPollingTask: true, isTaskPending: false });
 
-    expect(handleTask).toHaveBeenCalledWith(mockTask);
+    expect(handleFinishedTask).toHaveBeenCalledWith(mockTask);
   });
 });

data/webpack/scenes/Subscriptions/__tests__/__snapshots__/SubscriptionsActions.test.js.snap

@@ -35,9 +35,7 @@ Object {
 }
 `;
 
-exports[`subscription actions handleTask does nothing if already polling and task is pending 1`] = `Array []`;
-
-exports[`subscription actions handleTask handles a finished task 1`] = `
+exports[`subscription actions handleFinishedTask handles a finished task 1`] = `
 Array [
   Object {
     "key": "SUBSCRIPTIONS_POLL_TASK",
@@ -77,7 +75,7 @@ Array [
 ]
 `;
 
-exports[`subscription actions handleTask when not polling a task starts polling the task 1`] = `
+exports[`subscription actions handleStartTask starts polling the task 1`] = `
 Array [
   Object {
     "key": "SUBSCRIPTIONS_TASK_SEARCH",

data/webpack/scenes/Subscriptions/index.js

@@ -15,11 +15,13 @@ import {
   selectSubscriptionsTask,
   selectActivePermissions,
   selectTableSettings,
+  selectIsTaskPending,
 } from './SubscriptionsSelectors';
+import { selectIsPollingTask } from '../Tasks/TaskSelectors';
 import { selectSimpleContentAccessEnabled } from '../Organizations/OrganizationSelectors';
 
 import reducer from './SubscriptionReducer';
-import { SUBSCRIPTION_TABLE_NAME } from './SubscriptionConstants';
+import { SUBSCRIPTION_TABLE_NAME, SUBSCRIPTIONS } from './SubscriptionConstants';
 import SubscriptionsPage from './SubscriptionsPage';
 
 // map state to props
@@ -33,6 +35,8 @@ const mapStateToProps = (state) => {
     activePermissions: selectActivePermissions(state),
     simpleContentAccess: selectSimpleContentAccessEnabled(state),
     task: selectSubscriptionsTask(state),
+    isTaskPending: selectIsTaskPending(state),
+    isPollingTask: selectIsPollingTask(state, SUBSCRIPTIONS),
     searchQuery: selectSearchQuery(state),
     deleteModalOpened: selectDeleteModalOpened(state),
     deleteButtonDisabled: selectDeleteButtonDisabled(state),

data/webpack/scenes/Tasks/TaskActions.js

@@ -5,8 +5,9 @@ import { stopInterval, withInterval } from 'foremanReact/redux/middlewares/Inter
 import { foremanTasksApi } from '../../services/api';
 import { bulkSearchKey, pollTaskKey, taskFinishedToast } from './helpers';
 
-export const toastTaskFinished = task => async dispatch =>
+export const toastTaskFinished = task => async (dispatch) => {
   dispatch(addToast(taskFinishedToast(task)));
+};
 
 const taskBulkSearchParams = params => ({
   search: Object.entries(propsToSnakeCase(params))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katello
 version: !ruby/object:Gem::Version
-  version: 3.16.0.rc2
+  version: 3.16.0.rc2.1
 platform: ruby
 authors:
 - N/A
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-01 00:00:00.000000000 Z
+date: 2020-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -332,6 +332,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: pulp_certguard_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: deface
   requirement: !ruby/object:Gem::Requirement
@@ -874,6 +888,7 @@ files:
 - app/lib/actions/katello/repository/sync_hook.rb
 - app/lib/actions/katello/repository/update.rb
 - app/lib/actions/katello/repository/update_content_urls.rb
+- app/lib/actions/katello/repository/update_cv_repo_cert_guard.rb
 - app/lib/actions/katello/repository/update_http_proxy_details.rb
 - app/lib/actions/katello/repository/update_metadata_sync.rb
 - app/lib/actions/katello/repository/update_redhat_repository.rb
@@ -961,6 +976,7 @@ files:
 - app/lib/actions/pulp/repository_group/create.rb
 - app/lib/actions/pulp/repository_group/delete.rb
 - app/lib/actions/pulp/repository_group/export.rb
+- app/lib/actions/pulp3/ContentGuard/refresh.rb
 - app/lib/actions/pulp3/abstract.rb
 - app/lib/actions/pulp3/abstract_async_task.rb
 - app/lib/actions/pulp3/capsule_content/generate_metadata.rb
@@ -1007,6 +1023,7 @@ files:
 - app/lib/actions/pulp3/repository/save_publication.rb
 - app/lib/actions/pulp3/repository/save_version.rb
 - app/lib/actions/pulp3/repository/sync.rb
+- app/lib/actions/pulp3/repository/update_cv_repository_cert_guard.rb
 - app/lib/actions/pulp3/repository/update_distributions.rb
 - app/lib/actions/pulp3/repository/update_remote.rb
 - app/lib/actions/pulp3/repository/update_repository.rb
@@ -1063,6 +1080,7 @@ files:
 - app/lib/katello/util/package_filter.rb
 - app/lib/katello/util/path_with_substitutions.rb
 - app/lib/katello/util/proxy_uri.rb
+- app/lib/katello/util/pulpcore_content_filters.rb
 - app/lib/katello/util/report_table.rb
 - app/lib/katello/util/search.rb
 - app/lib/katello/util/support.rb
@@ -1236,6 +1254,7 @@ files:
 - app/models/katello/product_content.rb
 - app/models/katello/provider.rb
 - app/models/katello/proxy_association_owner.rb
+- app/models/katello/pulp3/content_guard.rb
 - app/models/katello/pulp3/distribution_reference.rb
 - app/models/katello/pulp3/repository_reference.rb
 - app/models/katello/pulp_sync_status.rb
@@ -1350,6 +1369,7 @@ files:
 - app/services/katello/pulp/yum_metadata_file.rb
 - app/services/katello/pulp3/ansible_collection.rb
 - app/services/katello/pulp3/api/ansible_collection.rb
+- app/services/katello/pulp3/api/content_guard.rb
 - app/services/katello/pulp3/api/core.rb
 - app/services/katello/pulp3/api/docker.rb
 - app/services/katello/pulp3/api/file.rb
@@ -1954,6 +1974,7 @@ files:
 - db/migrate/20200213184848_create_evr_type.rb
 - db/migrate/20200304201026_create_katello_module_stream_rpms.rb
 - db/migrate/20200402130013_add_repsoitory_docker_meta_tag_f_key.rb
+- db/migrate/20200407171926_create_content_guard.rb
 - db/migrate/20200429153103_installed_package_bad_nvrea.rb
 - db/migrate/20200501155054_installed_package_unique_nvrea.rb
 - db/migrate/20200506163345_add_applicability_indicesto_katello_host_available_module_streams.rb
@@ -4850,7 +4871,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Content and Subscription Management plugin for Foreman