katello 3.18.2.1 → 3.18.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c5ad1aaf8a0bb032cc1ffd42c4c070c77cc538044396af1cd40db8d00132e58
-  data.tar.gz: fd418dbd20507da2ca47e937df543ccf1f5a2c8d254f17623aec03f0d5d2767b
+  metadata.gz: 625ecabd197fcf1e9562afe5ab95076a78aad73960543c9804d0510f36bfc398
+  data.tar.gz: 0a6c82ff085f980e9d028a9734f3d071fa5324e6354b0c45b49406bf4400783c
 SHA512:
-  metadata.gz: b21464bd7f2341093cb31c47a6ee1792d508b8d16f6c9f47db4e8cffb3bc737f02aa1150e50cc05352c668db37eadc5fe708cd0d2705010fbd0072f46b887877
-  data.tar.gz: b67b69add02fae0357308a8301ac689814f2e32d835b5270c421d94cf46f6068b6398cd18cbb7da55913106deac0be816668939c605e7bf20d0a671740039402
+  metadata.gz: ff6a670562b076e29b4112e22b8575ae0fbc8a1864377ea538e642207a9b78e574e1bcffb9c611f61691303fb9f5b8a56e80dda96b6391d96ab836b8cfc5ab7c
+  data.tar.gz: f8b4a6bb32933ef5a12ebc1dab3e1e06b023c39834b9fd58dad920912ce84f25ac6974cad9611ae6d6cd87b4b2bbd45d38d71604bf42d5ebb8be72f5b93f3293

data/app/controllers/katello/api/registry/registry_proxies_controller.rb

@@ -167,11 +167,9 @@ module Katello
       end
 
       if (manifest_response = redirect_client { Resources::Registry::Proxy.get(@_request.fullpath, headers) })
-        #when pulp 2 is removed, this should no longer be needed, and all clients should be redirected
-        logger.debug filter_sensitive_data(manifest_response)
+        #for some requests, we get a redirect, but for others we get the actual manifest in response
         results = JSON.parse(manifest_response)
-
-        response.header['Docker-Content-Digest'] = "sha256:#{Digest::SHA256.hexdigest(manifest_response)}"
+        response.header['Docker-Content-Digest'] = manifest_response.headers[:docker_content_digest]
         # https://docs.docker.com/registry/spec/manifest-v2-2/
         # If its v2 schema 2 only the mediaType attribute will be present in the manifest
         media_type = results['mediaType']
@@ -184,8 +182,8 @@ module Katello
                          'application/vnd.docker.distribution.manifest.v1+prettyjws'
                        end
         end
-
-        render json: manifest_response, content_type: media_type
+        response.headers['Content-Type'] = media_type
+        render json: manifest_response
       end
     end
 

data/app/lib/actions/katello/orphan_cleanup/remove_orphans.rb

@@ -8,7 +8,7 @@ module Actions
         def plan(proxy)
           sequence do
             plan_action(Actions::Pulp::Orchestration::OrphanCleanup::RemoveOrphans, proxy)
-            if proxy.pulp3_enabled?
+            if proxy.pulp3_enabled? && ::Katello::Ping.pulpcore_enabled
               plan_action(
                 Actions::Pulp3::Orchestration::OrphanCleanup::RemoveOrphans,
                 proxy)

data/app/lib/actions/pulp3/content_guard/refresh_all_distributions.rb

@@ -6,7 +6,8 @@ module Actions
           sequence do
             plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy)
 
-            roots = ::Katello::RootRepository.where.not(:content_type => ::Katello::Repository::DOCKER_TYPE).where(:unprotected => false)
+            protected_types = [::Katello::Repository::YUM_TYPE, ::Katello::Repository::FILE_TYPE, ::Katello::Repository::DEB_TYPE]
+            roots = ::Katello::RootRepository.where(:content_type => protected_types).where(:unprotected => false)
             repositories = ::Katello::Repository.where(:root => roots)
             if repositories.any?
               plan_action(::Actions::BulkAction, Actions::Pulp3::Repository::RefreshDistribution, repositories, smart_proxy.id, assume_content_guard_exists: true)

data/app/lib/actions/pulp3/content_migration_presenter.rb

@@ -38,7 +38,9 @@ module Actions
         end
 
         def humanized_output
-          report = task_progress_reports.find { |current| current['state'] == 'running' && current['total'] != 0 }
+          #prefer running reports where the done and total do not match
+          report = task_progress_reports.find { |current| current['state'] == 'running' && current['total'] != 0 && current['done'] != current['total'] }
+          report ||= task_progress_reports.find { |current| current['state'] == 'running' && current['total'] != 0 }
           report ||= task_group_progress_reports.find { |current| current['total'] != 0 && current['done'] != current['total'] }
 
           if !report.blank? && report['total'] != 0
@@ -46,7 +48,8 @@ module Actions
           elsif report
             report['message']
           elsif task_progress_reports.empty?
-            "Content migration starting. "
+            "Content migration starting. These steps may take a while to complete. " \
+            "Refer to `foreman-maintain content migration-stats` for an estimate."
           else
             "Initial Migration steps complete."
           end

data/app/lib/katello/errors.rb

@@ -53,7 +53,7 @@ module Katello
 
     class PulpcoreMissingCapabilities < StandardError
       def message
-        _("A smart proxy seems to have been refreshed without pulpcore being running.  You may want to ")
+        _("A smart proxy seems to have been refreshed without pulpcore being running. Please refresh the smart proxy after ensuring that pulpcore services are running.")
       end
     end
 

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

@@ -0,0 +1,126 @@
+# Used exclusively by fix_hostgroup_facets.rake task
+module Katello
+  module Util
+    class HostgroupFacetsHelper
+      def initialize
+        @logger = Logger.new($stdout)
+      end
+
+      def interested_hostgroups
+        groups = ::Hostgroup.unscoped.where(
+                    id: Katello::Hostgroup::ContentFacet.
+                        where(content_source_id: nil,
+                              kickstart_repository_id: nil,
+                              content_view_id: nil,
+                              lifecycle_environment_id: nil).select(:hostgroup_id))
+        parents = groups.select { |group| group.parent.blank? }
+        children = groups.reject { |group| group.parent.blank? }
+        # we want the parents to get created before the children
+        # hence the order
+        parents + children
+      end
+
+      def pick_facet_values(hg)
+        # This call looks at the audit logs for a host group.
+        # Pries out information related to lce, ks, cv and content_source_id from the audit logs.
+        # The audit logs typically only contain updates.
+        # So if the user changed  just the content_view_id, then that is the only thing marked as audited_changes.
+        # Hence we need to go through all the audit logs until we have information on lce, ks, cv and cs.
+        # If there was only one audit log and that was during the creation of hostgroup
+        # the audited changes look like this
+        # ```ruby
+        # {
+        #  content_view_id: 10,
+        #  kickstart_repository_id: 1000
+        #  ......
+        # }
+        # ```
+        # However if you updated the hostgroup and set the kickstart_repository_id, or
+        # content_view_id then audited changes look like
+        # ```ruby
+        # {
+        #  content_view_id: [10, 11],
+        #  kickstart_repository_id: [1000, 1200]
+        #  ......
+        # }
+        # ```
+        # So the code says "if the attribute value is an array pick the last value else just keep the value as it is "
+
+        # Further along it is to be noted that `hostgroup.audits` returns the audits ordered by the version number in ascending order, so the latest audit will be `hostgroup.audits.last`
+
+        # We want to iterate though each audit from latest audit to start, and as soon as we find a  content_view_id key or kickstart_repository_id key or lifecycle environment_id key  or content_source_id key we want it to be set once.
+
+        # So if I had an audit history like
+        # ``` ruby
+        # {
+        #  content_view_id: 10,
+        #  kickstart_repository_id: 1000,
+        #  version:1
+        #  ......
+        # },
+        # {
+        #  content_view_id: [10, 11],
+        #  kickstart_repository_id: [1000, 1200],
+        #   version: 2
+        #  ......
+        # }
+        # ```
+
+        # The code would start at version 2, notice that cv_id and ks_repo were set there
+        # and keep them as the final.
+        # So when it goes to version 1 since cv_id and ks_repo are already set,
+        # it will ignore. It will finally
+        # return {content_view_id: 11, kickstart_repository_id: 1200}
+        facet_values = {}
+        hg.audits.reverse_each do |audit|
+          hg_changes = audit.audited_changes.slice("lifecycle_environment_id",
+                                                   "kickstart_repository_id",
+                                                   "content_view_id",
+                                                   "content_source_id")
+          facet_values = hg_changes.merge(facet_values)
+        end
+
+        values = facet_values.map do |k, v|
+          v = v[-1] if v.is_a? Array
+          [k, v]
+        end
+        values.to_h.with_indifferent_access
+      end
+
+      def main
+        bad_hgs = []
+        good_hgs = []
+
+        groups = interested_hostgroups.each do |hg|
+          facet = hg.content_facet
+          values = pick_facet_values(hg)
+          if !values.empty? && facet.update(values)
+            good_hgs << { hostgroup: hg, facet_values: values }
+          else
+            bad_hgs << { hostgroup: hg, facet_values: values }
+            facet.save(validate: false)
+          end
+        end
+
+        unless bad_hgs.empty?
+          @logger.warn "Some of the hostgroups reported a validation error. "\
+                        "The hostgroups have been updated. "\
+                        "Check via the Web UI."
+
+          bad_hgs.each do |bad_group|
+            @logger.warn "Hostgroup #{bad_group[:hostgroup]}"
+            @logger.warn "Facet Values #{bad_group[:facet_values]}"
+          end
+        end
+        unless good_hgs.empty?
+          @logger.info "Following hostgroups were succesfully updated."
+          good_hgs.each do |good_group|
+            @logger.info "Hostgroup #{good_group[:hostgroup]}"
+            @logger.info "Facet Values #{good_group[:facet_values]}"
+          end
+        end
+        @logger.info("#{groups.count} Hostgroup(s) were updated.")
+      end
+    end
+  end
+end

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

@@ -107,7 +107,9 @@ module Katello
         return true unless operatingsystem
 
         if operatingsystem.respond_to? :kickstart_repos
-          return operatingsystem.kickstart_repos(self).any? { |repo| repo[:id] == (content_facet&.kickstart_repository_id || content_facet&.kickstart_repository&.id) }
+          operatingsystem.kickstart_repos(self, content_facet: content_facet).any? do |repo|
+            repo[:id] == (content_facet&.kickstart_repository_id || content_facet&.kickstart_repository&.id)
+          end
         end
       end
 
@@ -126,7 +128,7 @@ module Katello
           facet_model = Facets.registered_facets[facet].hostgroup_configuration.model
           value = facet_model.where.not(attribute => nil).joins(:hostgroup).merge(
             ::Hostgroup.where(id: self.ancestor_ids).reorder(ancestry: :desc)
-          ).limit(1).pluck(attribute)
+          ).limit(1).pluck(attribute).first
         end
         value
       end

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

@@ -42,10 +42,11 @@ module Katello
         end
       end
 
-      def kickstart_repos(host)
-        distros = distribution_repositories(host).where(distribution_bootable: true)
-        if distros && host&.content_facet&.content_source
-          distros.map { |distro| distro.to_hash(host.content_facet.content_source) }
+      def kickstart_repos(host, content_facet: nil)
+        distros = distribution_repositories(host, content_facet: content_facet).where(distribution_bootable: true)
+        content_facet ||= host.content_facet
+        if distros && content_facet&.content_source
+          distros.map { |distro| distro.to_hash(content_facet.content_source) }
         else
           []
         end
@@ -65,10 +66,10 @@ module Katello
         end
       end
 
-      def distribution_repositories(host)
-        content_view = host.try(:content_facet).try(:content_view) || host.try(:content_view)
-        lifecycle_environment = host.try(:content_facet).try(:lifecycle_environment) || host.try(:lifecycle_environment)
-
+      def distribution_repositories(host, content_facet: nil)
+        content_facet ||= host.content_facet
+        content_view = content_facet.try(:content_view) || host.try(:content_view)
+        lifecycle_environment = content_facet.try(:lifecycle_environment) || host.try(:lifecycle_environment)
         if content_view && lifecycle_environment && host.os && host.architecture
           Katello::Repository.in_environment(lifecycle_environment).in_content_views([content_view]).
               where(:distribution_arch => host.architecture.name).

data/app/models/katello/ping.rb

@@ -9,7 +9,7 @@ module Katello
         SETTINGS[:katello][:use_pulp_2_for_content_type].nil? || (!SETTINGS[:katello][:use_pulp_2_for_content_type][:yum] &&
         !SETTINGS[:katello][:use_pulp_2_for_content_type][:docker] &&
         !SETTINGS[:katello][:use_pulp_2_for_content_type][:file]) ||
-        system('systemctl is-enabled pulpcore-api.service')
+        File.exist?('/etc/systemd/system/multi-user.target.wants/pulpcore-api.service')
       end
 
       def services(capsule_id = nil)

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

@@ -122,20 +122,22 @@ module Katello
       end
 
       def applicable_differences
-        consumer_ids = content_facet.send(applicable_units).pluck("#{content_unit_class.table_name}.id")
-        content_ids = fetch_content_ids
+        ActiveRecord::Base.connection.uncached do
+          consumer_ids = content_facet.send(applicable_units).pluck("#{content_unit_class.table_name}.id")
+          content_ids = fetch_content_ids
 
-        to_remove = consumer_ids - content_ids
-        to_add = content_ids - consumer_ids
+          to_remove = consumer_ids - content_ids
+          to_add = content_ids - consumer_ids
 
-        [to_add, to_remove]
+          [to_add, to_remove]
+        end
       end
 
       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.execute(sql)
+          ActiveRecord::Base.connection.exec_insert(sql)
         end
       end
 

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

@@ -296,11 +296,13 @@ module Katello
 
         if proxy
           uri = URI(proxy.url)
+          username = CGI.escape(proxy.username) if proxy.username
+          password = CGI.escape(proxy.password) if proxy.password
           proxy_options = {
             proxy_host: uri.scheme + '://' + uri.host,
             proxy_port: uri.port,
-            proxy_username: proxy.username,
-            proxy_password: proxy.password
+            proxy_username: username,
+            proxy_password: password
           }
           return proxy_options
         end

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

@@ -58,6 +58,20 @@ module Katello
           fail NotImplementedError
         end
 
+        def self.ignore_409_exception(*)
+          yield
+        rescue => e
+          raise e unless e&.code == 409
+          nil
+        end
+
+        def cancel_task(task_href)
+          data = PulpcoreClient::TaskResponse.new(state: 'canceled')
+          self.class.ignore_409_exception do
+            tasks_api.tasks_cancel(task_href, data)
+          end
+        end
+
         def exporter_api
           PulpcoreClient::ExportersPulpApi.new(core_api_client)
         end

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

@@ -4,6 +4,8 @@ module Katello
   module Pulp3
     class Migration
       attr_accessor :smart_proxy, :reimport_all, :task_id
+      attr_reader :repository_types
+
       GET_QUERY_ID_LENGTH = 90
 
       MUTABLE_CONTENT_TYPES = [
@@ -16,7 +18,9 @@ module Katello
       ].freeze
 
       CORRUPTABLE_CONTENT_TYPES = [
-        Katello::Rpm, Katello::FileUnit
+        Katello::Rpm,
+        Katello::FileUnit,
+        Katello::Deb
       ].freeze
 
       def self.repository_types_for_migration
@@ -70,7 +74,9 @@ module Katello
 
       def last_successful_migration_time
         task = ForemanTasks::Task.where(:label => Actions::Pulp3::ContentMigration.to_s, :result => 'success').order("started_at desc").first
-        if reimport_all || task.nil?
+        reset_task = ForemanTasks::Task.where(:label => Actions::Pulp3::ContentMigrationReset.to_s).order("started_at desc").first
+        reset_more_recent = reset_task && task && reset_task.started_at > task.started_at
+        if reimport_all || task.nil? || reset_more_recent
           0
         else
           task.started_at.to_i
@@ -131,35 +137,36 @@ module Katello
         end
         plan = { plugins: plugins }
 
-        # TODO: Don't provide the plan as a string once this is resolved: https://pulp.plan.io/issues/8211
-        migration_plan_api.reset(migration_plan_api.create(plan: plan).pulp_href, plan.to_json)
+        pulp3_task = migration_plan_api.reset(migration_plan_api.create(plan: plan).pulp_href)
 
         content_types_for_migration.each do |content_type|
           if content_type.model_class == ::Katello::Erratum
             ::Katello::RepositoryErratum.update_all(erratum_pulp3_href: nil)
           else
-            content_type.model_class.update_all(migrated_pulp3_href: nil)
+            content_type.model_class.update_all(migrated_pulp3_href: nil, missing_from_migration: false, ignore_missing_from_migration: false)
           end
         end
 
         @repository_types.each do |repo_type|
           if repo_type == "file"
-            ::Katello::Repository.file_type.update(remote_href: nil, publication_href: nil, version_href: nil)
+            ::Katello::Repository.file_type.update_all(remote_href: nil, publication_href: nil, version_href: nil)
           elsif repo_type == "docker"
-            ::Katello::Repository.docker_type.update(remote_href: nil, publication_href: nil, version_href: nil)
+            ::Katello::Repository.docker_type.update_all(remote_href: nil, publication_href: nil, version_href: nil)
           elsif repo_type == "yum"
-            ::Katello::Repository.yum_type.update(remote_href: nil, publication_href: nil, version_href: nil)
+            ::Katello::Repository.yum_type.update_all(remote_href: nil, publication_href: nil, version_href: nil)
           end
         end
 
         ::Katello::Pulp3::RepositoryReference.destroy_all
         ::Katello::Pulp3::DistributionReference.destroy_all
         ::Katello::Pulp3::ContentGuard.destroy_all
+
+        pulp3_task
       end
 
       def create_migrations
         plan = migration_plan
-        Rails.logger.info("Migration Plan: #{plan}")
+        Rails.logger.info("Migration Plan: #{plan.to_yaml}")
 
         if plan['plugins'].empty?
           Rails.logger.error("No Repositories to migrate")
@@ -209,7 +216,7 @@ module Katello
 
           if to_find
             found = migrated_repo_items.find { |migrated_repo| migrated_repo.pulp2_repo_id == to_find.pulp_id }
-            import_repo(yum_repo, found)
+            import_repo(yum_repo, found) if found
           end
         end
       end
@@ -298,10 +305,29 @@ module Katello
               to_import[[errata_id, repo_id]] ||= {erratum_id: errata_id, erratum_pulp3_href: pulp3_href, repository_id: repo_id}
             end
           end
+
+          Katello::RepositoryErratum.import([:erratum_id, :erratum_pulp3_href, :repository_id], to_import.values, :validate => false,
+                                            on_duplicate_key_update: {conflict_target: [:erratum_id, :repository_id], columns: [:erratum_pulp3_href]})
+          to_import = {}
         end
+        correct_missing_errata
+      end
 
-        Katello::RepositoryErratum.import([:erratum_id, :erratum_pulp3_href, :repository_id], to_import.values, :validate => false,
-                                          on_duplicate_key_update: {conflict_target: [:erratum_id, :repository_id], columns: [:erratum_pulp3_href]})
+      def correct_missing_errata
+        Katello::RepositoryErratum.where(:erratum_pulp3_href => nil).pluck(:repository_id).uniq.each do |repo_id|
+          repo = Katello::Repository.find(repo_id)
+          if repo.link?
+            target = repo.target_repository
+            to_import = []
+            target.repository_errata.each do |repo_errata|
+              to_import << {erratum_id: repo_errata.erratum_id, erratum_pulp3_href: repo_errata.erratum_pulp3_href, repository_id: repo_id}
+            end
+            Katello::RepositoryErratum.import([:erratum_id, :erratum_pulp3_href, :repository_id], to_import, :validate => false,
+                                            on_duplicate_key_update: {conflict_target: [:erratum_id, :repository_id], columns: [:erratum_pulp3_href]})
+          else
+            Rails.logger.error("Unexpectedly found target repo (ID=#{repo_id}) with missing migrated errata!")
+          end
+        end
       end
 
       def mark_missing_content(content_type)
@@ -327,7 +353,7 @@ module Katello
           unmigrated_units.select(:id, :pulp_id).find_in_batches(batch_size: GET_QUERY_ID_LENGTH) do |needing_hrefs|
             current_count += needing_hrefs.count
             update_import_status("Importing migrated content type #{content_type.label}: #{current_count}/#{total_count}")
-            migrated_units = pulp2_content_api.list(pulp2_id__in: needing_hrefs.map { |unit| unit.pulp_id }.join(','))
+            migrated_units = pulp2_content_api.list(pulp2_id__in: needing_hrefs.map(&:pulp_id))
             migrated_units.results.each do |migrated_unit|
               content_type.model_class.where(pulp_id: migrated_unit.pulp2_id).update_all(migrated_pulp3_href: migrated_unit.pulp3_content)
             end

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

@@ -14,7 +14,6 @@ module Katello
         Katello::Logging.time("CONTENT_MIGRATION - Generating Migration plan") do
           plan[:plugins] = generate_plugins
         end
-        Rails.logger.error("Migration Plan: #{plan.to_json}")
         plan
       end
 
@@ -39,6 +38,7 @@ module Katello
         roots = Katello::RootRepository.where(:content_type => repo_type).order(:label)
         plans = []
         roots.each do |root|
+          next unless root.library_instance
           plans << library_migration_for(root)
           plans += content_view_migrations_for(root)
         end
@@ -64,6 +64,8 @@ module Katello
       def library_migration_for(root)
         repo = root.library_instance
 
+        return nil unless library_repo_safe_to_migrate?(repo)
+
         migration = {
           name: repo.pulp_id,
           repository_versions: [
@@ -77,10 +79,49 @@ module Katello
         migration
       end
 
+      def library_repo_safe_to_migrate?(repo)
+        publish_tasks = ForemanTasks::Task.where(label: 'Actions::Katello::ContentView::Publish')
+        publishing_repo_ids = publish_tasks.where(state: ['scheduled', 'running']).collect do |task|
+          ::Katello::ContentViewVersion.find(task.input[:content_view_version_id]).library_repos.pluck(:id)
+        end
+        publishing_repo_ids = publishing_repo_ids.flatten
+
+        if publishing_repo_ids.include?(repo.id)
+          warn_string = "Library repository with ID #{repo.id} and name #{repo.name} unmigrated due to being "\
+            "associated with an actively-publishing content view.  The migration will need to be run again."
+          Rails.logger.warn(warn_string)
+          return false
+        end
+
+        create_root_tasks = ForemanTasks::Task.where(label: 'Actions::Katello::Repository::CreateRoot')
+        active_creation_task = create_root_tasks.where(state: ['scheduled', 'running']).detect do |task|
+          task.input[:repository][:id] == repo.id
+        end
+
+        if active_creation_task.present?
+          warn_string = "Repository with ID #{repo.id} and name #{repo.name} unmigrated due to being "\
+            "created during the Pulp 3 migration.  The migration will need to be run again."
+          Rails.logger.warn(warn_string)
+          return false
+        end
+        true
+      end
+
       def content_view_migrations_for(root)
+        publish_tasks = ForemanTasks::Task.where(label: 'Actions::Katello::ContentView::Publish')
+        publishing_cv_ids = publish_tasks.where(state: ['scheduled', 'running']).collect do |task|
+          task.input[:content_view_id]
+        end
+
         plans = []
         ContentView.non_default.published_with_repositories(root).sort_by(&:label).each do |cv|
-          plans << content_view_migration(cv, root)
+          if publishing_cv_ids.include?(cv.id)
+            warn_string = "Repositories belonging to Content View with ID #{cv.id} and name #{cv.name} unmigrated "\
+              "due to being created during the Pulp 3 migration.  The migration will need to be run again."
+            Rails.logger.warn(warn_string)
+          else
+            plans << content_view_migration(cv, root)
+          end
         end
         plans
       end
@@ -105,7 +146,15 @@ module Katello
       end
 
       def name_for_content_view(content_view, root_repo)
-        "#{content_view.label}-#{root_repo.label}"
+        name = "#{content_view.label}-#{root_repo.label}"
+
+        if Katello::RootRepository.where(:label => root_repo.label).group(:label).count(:label)[root_repo.label] > 1
+          repo_query = Katello::Repository.joins(:root, :content_view_version => :content_view).
+              where("#{::Katello::RootRepository.table_name}.id != #{root_repo.id}").
+              where("#{::Katello::RootRepository.table_name}.label" => root_repo.label, "#{::Katello::ContentView.table_name}.label" => content_view.label)
+          name += "-#{root_repo.id}" if repo_query.any?
+        end
+        name
       end
 
       def content_view_migration(content_view, root)

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

@@ -25,6 +25,19 @@ module Katello
         end
       end
 
+      def remove_orphaned_content
+        models = []
+        @migration.repository_types.each do |repo_type_label|
+          repo_type = ::Katello::RepositoryTypeManager.repository_types[repo_type_label]
+          indexable_types = repo_type.content_types_to_index
+          models += indexable_types&.map(&:model_class)
+          models.select! { |model| model.many_repository_associations }
+        end
+        models.each do |model|
+          model.joins("left join katello_#{model.repository_association} on #{model.table_name}.id = katello_#{model.repository_association}.#{model.unit_id_field}").where("katello_#{model.repository_association}.#{model.unit_id_field} IS NULL").destroy_all
+        end
+      end
+
       def deduplicated_content_types
         #even though YumMetatadataFile is de-depulicated, we're not indexing it in pulp3
         [Katello::PackageGroup]

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

@@ -27,8 +27,7 @@ module Katello
           popts = super(repository_version)
           popts.merge!(
             {
-              # structured is not necessary for subscription-manager
-              #structured: true, # publish real suites (e.g. 'stable')
+              structured: true, # publish real suites (e.g. 'stable')
               simple: true # publish all into 'default'-suite
             }
           )

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

@@ -1,7 +1,7 @@
+# rubocop:disable Metrics/ClassLength
 require "pulpcore_client"
 module Katello
   module Pulp3
-    # rubocop:disable Metrics/ClassLength
     class Repository
       include Katello::Util::HttpProxy
       attr_accessor :repo
@@ -158,10 +158,7 @@ module Katello
       end
 
       def compute_remote_options(computed_options = remote_options)
-        [:client_cert, :client_key, :ca_cert].each do |key|
-          computed_options[key] = Digest::SHA256.hexdigest(computed_options[key].chomp) if computed_options[key]
-        end
-        computed_options.except(:name)
+        computed_options.except(:name, :client_key)
       end
 
       def create
@@ -221,11 +218,38 @@ module Katello
       end
 
       def refresh_distributions
-        dist_ref = distribution_reference
-        if dist_ref
-          update_distribution
+        if repo.docker?
+          dist = lookup_distributions(base_path: repo.container_repository_name).first
         else
+          dist = lookup_distributions(base_path: repo.relative_path).first
+        end
+
+        # First check if the distribution exists
+        if dist
+          dist_ref = distribution_reference
+          # If we have a DistributionReference, update the distribution
+          if dist_ref
+            return update_distribution
+          # If no DistributionReference, create a DistributionReference and return
+          else
+            save_distribution_references([dist.pulp_href])
+            return []
+          end
+        end
+
+        # So far, it looks like there is no distribution. Try to create one.
+        begin
           create_distribution(relative_path)
+        rescue api.class.client_module::ApiError => e
+          # Now it seems there is a distribution. Fetch it and save the reference.
+          if e.message.include?("\"base_path\":[\"This field must be unique.\"]") ||
+              e.message.include?("\"base_path\":[\"Overlaps with existing distribution\"")
+            dist = lookup_distributions(base_path: repo.relative_path).first
+            save_distribution_references([dist.pulp_href])
+            return []
+          else
+            raise e
+          end
         end
       end
 
@@ -275,7 +299,8 @@ module Katello
           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, content_guard_href: content_guard_href)
+            # Ensure that duplicates won't be created in the case of a race condition
+            DistributionReference.where(path: path, href: href, repository_id: repo.id, content_guard_href: content_guard_href).first_or_create!
           end
         end
       end

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

@@ -56,8 +56,10 @@ module Katello
         @pulp_data ||= tasks_api.read(@href).as_json.with_indifferent_access
       end
 
-      def tasks_api
-        ::Katello::Pulp3::Api::Core.new(@smart_proxy).tasks_api
+      delegate :tasks_api, to: :core_api
+
+      def core_api
+        ::Katello::Pulp3::Api::Core.new(@smart_proxy)
       end
 
       def task_group_href
@@ -94,10 +96,11 @@ module Katello
       end
 
       def cancel
-        data = PulpcoreClient::TaskResponse.new(state: 'canceled')
-        tasks_api.tasks_cancel(task_data['pulp_href'], data)
+        core_api.cancel_task(task_data['pulp_href'])
         #the main task may have completed, so cancel spawned tasks too
-        task_data['spawned_tasks']&.each { |spawned| tasks_api.tasks_cancel(spawned['pulp_href'], data) }
+        task_data['spawned_tasks']&.each do |spawned|
+          core_api.cancel_task(spawned['pulp_href'])
+        end
       end
     end
   end

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

@@ -71,17 +71,25 @@ module Katello
       end
 
       def error
+        return if task_group_data[WAITING] > 0 || task_group_data[RUNNING] > 0
         if task_group_data[FAILED] > 0
           "#{task_group_data[FAILED]} subtask(s) failed for task group #{@href}."
+        elsif task_group_data[CANCELLED] > 0
+          "#{task_group_data[CANCELLED]} subtask(s) cancelled for task group #{@href}."
         end
       end
 
+      def core_api
+        ::Katello::Pulp3::Api::Core.new(@smart_proxy)
+      end
+
       def cancel
-        tasks_api = ::Katello::Pulp3::Api::Core.new(@smart_proxy).tasks_api
-        tasks_response = tasks_api.list(task_group: task_group_data['pulp_href'])
-        data = PulpcoreClient::TaskResponse.new(state: 'canceled')
-        tasks_response.results.collect do |result|
-          tasks_api.tasks_cancel(result.pulp_href, data)
+        tasks_api = core_api.tasks_api
+        tasks_response = core_api.class.fetch_from_list do |page_opts|
+          tasks_api.list(page_opts.merge(task_group: task_group_data['pulp_href'], state__in: 'running,waiting'))
+        end
+        tasks_response.collect do |result|
+          ::Katello::Pulp3::Api::Core.new(@smart_proxy).cancel_task(result.pulp_href)
         end
       end
     end

data/db/migrate/20200514092553_move_katello_fields_from_hostgroups.katello.rb

@@ -46,7 +46,7 @@ class MoveKatelloFieldsFromHostgroups < ActiveRecord::Migration[6.0]
         content_facet.kickstart_repository_id = kickstart_repository_id
         content_facet.content_view_id = content_view_id
         content_facet.lifecycle_environment_id = lifecycle_environment_id
-        unless content_facet.save
+        unless content_facet.save(validate: false)
           Rails.logger.warn("Unable to save content facet hostgroup for #{content_facet.inspect} ")
           Rails.logger.warn(content_facet.errors.full_messages.join("\n"))
         end

data/db/migrate/20210420140050_add_pulp3_hrefs_to_content_types_deb.rb

@@ -0,0 +1,5 @@
+class AddPulp3HrefsToContentTypesDeb < ActiveRecord::Migration[6.0]
+  def change
+    add_column Katello::Deb.table_name, :migrated_pulp3_href, :string, :default => nil, :null => true
+  end
+end

data/lib/katello/engine.rb

@@ -75,7 +75,7 @@ module Katello
 
     # make sure the Katello plugin is initialized before `after_initialize`
     # hook so that the resumed Dynflow tasks can rely on everything ready.
-    initializer 'katello.register_plugin', :before => :finisher_hook do
+    initializer 'katello.register_plugin', :before => :finisher_hook, :after => 'foreman_remote_execution.register_plugin' do
       ::Foreman::AccessControl::Permission.prepend ::Katello::Concerns::PermissionExtensions
       require 'katello/plugin'
 

data/lib/katello/tasks/check_config.rake

@@ -0,0 +1,11 @@
+namespace :katello do
+  task :check_config => ['environment'] do
+    desc "Task that can be run before a content migration to check that the configuration valid"
+    fail_msg = _("The system appears to already be using pulp3 with all content migrated.")
+
+    puts "Checking for valid Katello configuraton."
+    if SETTINGS[:katello][:use_pulp_2_for_content_type].nil?
+      fail fail_msg
+    end
+  end
+end

data/lib/katello/tasks/fix_hostgroup_facets.rake

@@ -0,0 +1,8 @@
+namespace :katello do
+  desc "This task collates hostgroup content facts that were missed during the upgrade from audit.\
+        It then updates the hostgroup content_facet accordingly."
+  task :fix_hostgroup_facets => :environment do
+    User.current = User.anonymous_admin
+    ::Katello::Util::HostgroupFacetsHelper.new.main
+  end
+end

data/lib/katello/tasks/pulp3_content_switchover.rake

@@ -3,32 +3,41 @@ require "#{Katello::Engine.root}/app/services/katello/pulp3/migration_switchover
 
 namespace :katello do
   desc "Runs a Pulp 3 migration of pulp3 hrefs to pulp ids for supported content types."
-  task :pulp3_content_switchover => ["dynflow:client"] do
+  task :pulp3_content_switchover => ["dynflow:client", "check_config"] do
     dryrun = ENV['DRYRUN']
-    begin
-      User.current = User.anonymous_admin
 
-      ActiveRecord::Base.transaction do
+    if !SETTINGS[:katello][:use_pulp_2_for_content_type][:docker] &&
+        !SETTINGS[:katello][:use_pulp_2_for_content_type][:file] &&
+        !SETTINGS[:katello][:use_pulp_2_for_content_type][:yum] &&
+        !SETTINGS[:katello][:use_pulp_2_for_content_type][:deb]
+      puts "Switchover is already complete, skipping switchover task."
+    else
+      begin
+        User.current = User.anonymous_admin
+
         switchover_service = Katello::Pulp3::MigrationSwitchover.new(SmartProxy.pulp_primary)
-        switchover_service.run
-        fail "Dryrun completed without error, aborting and rolling back" if dryrun
+        switchover_service.remove_orphaned_content #run out of transaction for easier re-run
+        ActiveRecord::Base.transaction do
+          switchover_service.run
+          fail "Dryrun completed without error, aborting and rolling back" if dryrun
+        end
+      rescue Katello::Pulp3::SwitchOverError => e
+        $stderr.print(e.message)
+        exit 1
       end
-    rescue Katello::Pulp3::SwitchOverError => e
-      $stderr.print(e.message)
-      exit 1
-    end
 
-    task = ForemanTasks.sync_task(Actions::Pulp3::ContentGuard::RefreshAllDistributions, SmartProxy.pulp_primary)
-    until !task.pending? || task.paused?
-      sleep(10)
-      task = ForemanTasks::Task.find(task.id)
-    end
-    if task.result == 'error' || task.result == 'pending'
-      msg _("Content Guard Configuration failed, switchover aborted.  Switchover continuing, but after completion, you will want to investigate: https://#{Socket.gethostname}/foreman_tasks/tasks/#{task.id}")
-      Rails.logger.error(msg)
-      $stderr.print(msg)
-    else
-      puts _("Content Switchover completed successfully")
+      task = ForemanTasks.async_task(Actions::Pulp3::ContentGuard::RefreshAllDistributions, SmartProxy.pulp_primary)
+      until !task.pending? || task.paused?
+        sleep(10)
+        task = ForemanTasks::Task.find(task.id)
+      end
+      if task.result == 'error' || task.result == 'pending'
+        msg _("Content Guard Configuration failed, switchover aborted.  Switchover continuing, but after completion, you will want to investigate: https://#{Socket.gethostname}/foreman_tasks/tasks/#{task.id}")
+        Rails.logger.error(msg)
+        $stderr.print(msg)
+      else
+        puts _("Content Switchover completed successfully")
+      end
     end
   end
 end

data/lib/katello/tasks/pulp3_migration.rake

@@ -1,48 +1,57 @@
 namespace :katello do
   desc "Runs a Pulp 2 to 3 Content Migration for supported types.  May be run multiple times.  Use wait=false to immediately return with a task url."
-  task :pulp3_migration => ["dynflow:client"] do
-    services = [:candlepin, :foreman_tasks, :pulp3, :pulp, :pulp_auth]
-    Katello::Ping.ping!(services: services)
+  task :pulp3_migration => ["dynflow:client", 'check_config'] do
+    if !SETTINGS[:katello][:use_pulp_2_for_content_type][:docker] &&
+        !SETTINGS[:katello][:use_pulp_2_for_content_type][:file] &&
+        !SETTINGS[:katello][:use_pulp_2_for_content_type][:yum] &&
+        !SETTINGS[:katello][:use_pulp_2_for_content_type][:deb]
+      puts "Switchover is already complete, skipping migration work."
+    else
+      services = [:candlepin, :foreman_tasks, :pulp3, :pulp, :pulp_auth]
+      Katello::Ping.ping!(services: services)
 
-    puts "Starting task."
-    SmartProxy.pulp_primary.refresh
+      puts "Starting task."
+      SmartProxy.pulp_primary.refresh
 
-    reimport_all = ::Foreman::Cast.to_bool(ENV['reimport_all'])
-    wait = ::Foreman::Cast.to_bool(ENV['wait'] || 'true')
-    preserve_output = ::Foreman::Cast.to_bool(ENV['preserve_output'])
+      reimport_all = ::Foreman::Cast.to_bool(ENV['reimport_all'])
+      wait = ::Foreman::Cast.to_bool(ENV['wait'] || 'true')
+      preserve_output = ::Foreman::Cast.to_bool(ENV['preserve_output'])
 
-    User.current = User.anonymous_api_admin
-    task = ForemanTasks.async_task(Actions::Pulp3::ContentMigration, SmartProxy.pulp_primary, reimport_all: reimport_all)
+      User.current = User.anonymous_api_admin
+      Katello::Pulp3::MigrationSwitchover.new(SmartProxy.pulp_primary).remove_orphaned_content
+      task = ForemanTasks.async_task(Actions::Pulp3::ContentMigration, SmartProxy.pulp_primary, reimport_all: reimport_all)
 
-    if wait
-      clear_count = nil
-      until !task.pending? || task.paused?
-        $stdout.print("\r#{' ' * clear_count}\r") if clear_count && !preserve_output #clear the line before printing
-        $stdout.print("\n") if preserve_output
-        message = "#{Time.now.to_s}: #{task.humanized[:output]}"
-        clear_count = message.length + 1
-        $stdout.print(message)
+      if wait
+        clear_count = nil
+        until !task.pending? || task.paused?
+          $stdout.print("\r#{' ' * clear_count}\r") if clear_count && !preserve_output #clear the line before printing
+          $stdout.print("\n") if preserve_output
+          message = "#{Time.now.to_s}: #{task.humanized[:output]}"
+          clear_count = message.length + 1
+          $stdout.print(message)
+          $stdout.flush
 
-        sleep(10)
-        task = ForemanTasks::Task.find(task.id)
-      end
+          sleep(10)
+          task = ForemanTasks::Task.find(task.id)
+        end
 
-      if task.result == 'warning' || task.result == 'pending'
-        msg = _("Migration failed, You will want to investigate: https://#{Socket.gethostname}/foreman_tasks/tasks/#{task.id}\n")
-        $stderr.print(msg)
-        fail ForemanTasks::TaskError, task
-      else
-        puts
-        Katello::Pulp3::Migration::CORRUPTABLE_CONTENT_TYPES.each do |type|
-          if type.missing_migrated_content.any?
-            puts "Some corrupted or missing content found, run 'foreman-maintain content migration-stats' for more information."
-            exit(-1)
+        if task.result == 'warning' || task.result == 'pending'
+          msg = _("Migration failed, You will want to investigate: https://#{Socket.gethostname}/foreman_tasks/tasks/#{task.id}\n")
+          $stderr.print(msg)
+          fail ForemanTasks::TaskError, task
+        else
+          puts
+          Katello::Pulp3::Migration::CORRUPTABLE_CONTENT_TYPES.each do |type|
+            if type.missing_migrated_content.any?
+              puts "Some corrupted or missing content found, run 'foreman-maintain content migration-stats' for more information."
+              exit(-1)
+            end
           end
+          puts _("Content Migration completed successfully")
         end
-        puts _("Content Migration completed successfully")
+      else
+        puts "Migration started, you may monitor it at: https://#{Socket.gethostname}/foreman_tasks/tasks/#{task.id}"
       end
-    else
-      puts "Migration started, you may monitor it at: https://#{Socket.gethostname}/foreman_tasks/tasks/#{task.id}"
     end
   end
 end

data/lib/katello/tasks/pulp3_migration_abort.rake

@@ -17,6 +17,14 @@ namespace :katello do
       cancelled_tasks_count += 1 if cancelled_task
     end
 
+    api = Katello::Pulp3::Api::Core.new(SmartProxy.pulp_primary)
+    %w(pulp_2to3_migration.app.tasks.migrate.migrate_from_pulp2 pulp_2to3_migration.app.migration.complex_repo_migration).each do |task_label|
+      api.tasks_api.list(:state__in => 'running,waiting', :name => task_label).results.each do |task|
+        api.cancel_task(task.pulp_href)
+        cancelled_tasks_count += 1
+      end
+    end
+
     puts _("\e[33mCancelled #{cancelled_tasks_count} tasks.\e[0m")
   end
 end

data/lib/katello/tasks/pulp3_migration_approve_corrupted.rake

@@ -1,13 +1,18 @@
 namespace :katello do
   desc "Marks corrupted or missing content as approved to be ignored during the migration"
-  task :approve_corrupted_migration_content => ["dynflow:client", "check_ping"] do
+  task :approve_corrupted_migration_content => ["dynflow:client"] do
+    services = [:candlepin, :foreman_tasks, :pulp3, :pulp, :pulp_auth]
+    Katello::Ping.ping!(services: services)
+
     Katello::Pulp3::Migration::CORRUPTABLE_CONTENT_TYPES.each do |type|
       type.missing_migrated_content.update_all(:ignore_missing_from_migration => true)
     end
     puts "Any missing or corrupt content will be ignored on migration to Pulp 3.  This can be undone with 'foreman-rake katello:unapprove_corrupted_migration_content'"
   end
 
-  task :unapprove_corrupted_migration_content => ["dynflow:client", "check_ping"] do
+  task :unapprove_corrupted_migration_content => ["dynflow:client"] do
+    services = [:candlepin, :foreman_tasks, :pulp3, :pulp, :pulp_auth]
+    Katello::Ping.ping!(services: services)
     Katello::Pulp3::Migration::CORRUPTABLE_CONTENT_TYPES.each do |type|
       type.ignored_missing_migrated_content.update_all(:ignore_missing_from_migration => false)
     end

data/lib/katello/tasks/pulp3_migration_stats.rake

@@ -10,7 +10,8 @@ namespace :katello do
     migratable_repo_count = ::Katello::Repository.count - ::Katello::Repository.puppet_type.count -
       ::Katello::Repository.ostree_type.count - ::Katello::Repository.deb_type.count
 
-    on_demand_rpm_count = Katello::RepositoryRpm.where(:repository_id => Katello::Repository.yum_type.on_demand).distinct.count
+    on_demand_rpm_count = Katello::RepositoryRpm.where(:repository_id => Katello::Repository.yum_type.on_demand).
+      select(:rpm_id).distinct.count
     on_demand_unmigrated_rpm_count = on_demand_rpm_count - migrated_rpm_count
     immediate_unmigrated_rpm_count = ::Katello::Rpm.count - migrated_rpm_count - on_demand_unmigrated_rpm_count
 
@@ -27,10 +28,14 @@ namespace :katello do
     puts "Migrated/Total RPMs: #{migrated_rpm_count}/#{::Katello::Rpm.count}"
     puts "Migrated/Total errata: #{migrated_erratum_count}/#{::Katello::RepositoryErratum.count}"
     puts "Migrated/Total repositories: #{migrated_repo_count}/#{migratable_repo_count}"
-    puts
+
     # The timing formulas go negative if the amount of content is negligibly small
     if migration_minutes >= 5
       puts "Estimated migration time based on yum content: #{hours} hours, #{minutes} minutes"
+    elsif migrated_rpm_count == ::Katello::Rpm.count &&
+      migrated_erratum_count == ::Katello::RepositoryErratum.count &&
+      migrated_repo_count == migratable_repo_count
+      puts "All content has been migrated."
     else
       puts "Estimated migration time based on yum content: fewer than 5 minutes"
     end
@@ -39,6 +44,11 @@ namespace :katello do
     puts "\e[33mNote:\e[0m ensure there is sufficient storage space for /var/lib/pulp/published to triple in size before starting the migration process."
     puts "Check the size of /var/lib/pulp/published with 'du -sh /var/lib/pulp/published/'"
 
+    puts
+    puts "\e[33mNote:\e[0m ensure there is sufficient storage space for postgresql."
+    puts "You will need additional space for your postgresql database.  The partition holding '/var/opt/rh/rh-postgresql12/lib/pgsql/data/'"
+    puts "   will need additional free space equivalent to the size of your Mongo db database (/var/lib/mongodb/)."
+
     displayed_warning = false
     found_missing = false
     path = Dir.mktmpdir('unmigratable_content-')

data/lib/katello/tasks/reimport.rake

@@ -2,7 +2,7 @@ require File.expand_path("../engine", File.dirname(__FILE__))
 
 namespace :katello do
   desc "Runs a katello ping and prints out the statuses of each service"
-  task :check_ping => :environment do
+  task :check_ping => [:environment, "dynflow:client"] do
     ::User.current = ::User.anonymous_admin
     ping_results = Katello::Ping.ping
     if ping_results[:status] != "ok"

data/lib/katello/version.rb

@@ -1,3 +1,3 @@
 module Katello
-  VERSION = "3.18.2.1".freeze
+  VERSION = "3.18.5".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katello
 version: !ruby/object:Gem::Version
-  version: 3.18.2.1
+  version: 3.18.5
 platform: ruby
 authors:
 - N/A
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-16 00:00:00.000000000 Z
+date: 2021-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -100,6 +100,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: foreman-tasks-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: foreman_remote_execution
   requirement: !ruby/object:Gem::Requirement
@@ -269,7 +283,7 @@ dependencies:
         version: 3.6.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: 3.7.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -279,7 +293,7 @@ dependencies:
         version: 3.6.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 3.8.0
+        version: 3.7.7
 - !ruby/object:Gem::Dependency
   name: pulp_file_client
   requirement: !ruby/object:Gem::Requirement
@@ -346,60 +360,60 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.6.0
+        version: 2.9.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 2.8.0
+        version: 2.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.6.0
+        version: 2.9.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 2.8.0
+        version: 2.10.0
 - !ruby/object:Gem::Dependency
   name: pulp_rpm_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.9.0
+        version: 3.10.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 3.10.0
+        version: 3.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.9.0
+        version: 3.10.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 3.10.0
+        version: 3.11.0
 - !ruby/object:Gem::Dependency
   name: pulp_2to3_migration_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: pulp_certguard_client
   requirement: !ruby/object:Gem::Requirement
@@ -1182,6 +1196,7 @@ files:
 - app/lib/katello/util/docker_manifest_clause_generator.rb
 - app/lib/katello/util/errata.rb
 - app/lib/katello/util/filter_clause_generator.rb
+- app/lib/katello/util/hostgroup_facets_helper.rb
 - app/lib/katello/util/http_proxy.rb
 - app/lib/katello/util/model.rb
 - app/lib/katello/util/module_stream_clause_generator.rb
@@ -2142,6 +2157,7 @@ files:
 - db/migrate/20201021150008_add_import_only_to_katello_content_view.rb
 - db/migrate/20201119211133_pulp3_migration_progress.rb
 - db/migrate/20210201165835_add_migration_missing_content.rb
+- db/migrate/20210420140050_add_pulp3_hrefs_to_content_types_deb.rb
 - db/seeds.d/101-locations.rb
 - db/seeds.d/102-organizations.rb
 - db/seeds.d/104-proxy.rb
@@ -4484,10 +4500,12 @@ files:
 - lib/katello/repository_types/puppet.rb
 - lib/katello/repository_types/yum.rb
 - lib/katello/scheduled_jobs.rb
+- lib/katello/tasks/check_config.rake
 - lib/katello/tasks/clean_backend_objects.rake
 - lib/katello/tasks/clean_old_file_repos.rake
 - lib/katello/tasks/clean_published_repo_directories.rake
 - lib/katello/tasks/delete_orphaned_content.rake
+- lib/katello/tasks/fix_hostgroup_facets.rake
 - lib/katello/tasks/import_applicability.rake
 - lib/katello/tasks/import_subscriptions.rake
 - lib/katello/tasks/jenkins.rake
@@ -5062,7 +5080,7 @@ homepage: http://www.katello.org
 licenses:
 - GPL-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -5077,8 +5095,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Content and Subscription Management plugin for Foreman
 test_files: []