katello 3.18.5 → 4.0.0.rc1

data/app/models/katello/pool.rb

@@ -22,6 +22,7 @@ module Katello
       where(["end_date < ?", days.to_i.days.from_now.end_of_day])
     end
     scope :upstream, -> { where.not(upstream_pool_id: nil) }
+    scope :redhat, -> { joins(:products).merge(Katello::Product.redhat).distinct }
 
     include Glue::Candlepin::Pool
     include Glue::Candlepin::CandlepinObject
@@ -51,6 +52,10 @@ module Katello
 
     DAYS_RECENTLY_EXPIRED = 30
 
+    def redhat?
+      self.class.redhat.where(:id => self.id).exists?
+    end
+
     def active?
       active
     end

data/app/models/katello/product.rb

@@ -3,9 +3,9 @@ module Katello
     audited
 
     include ForemanTasks::Concerns::ActionSubject
-    include Glue::Candlepin::Product if SETTINGS[:katello][:use_cp]
-    include Glue::Pulp::Repos if SETTINGS[:katello][:use_pulp]
-    include Glue if SETTINGS[:katello][:use_cp] || SETTINGS[:katello][:use_pulp]
+    include Glue::Candlepin::Product
+    include Glue::Pulp::Repos
+    include Glue
 
     include Katello::Authorization::Product
 

data/app/models/katello/repository.rb

@@ -12,9 +12,9 @@ module Katello
 
     include ForemanTasks::Concerns::ActionSubject
     include Glue::Candlepin::Repository
-    include Glue::Pulp::Repo if SETTINGS[:katello][:use_pulp]
+    include Glue::Pulp::Repo
 
-    include Glue if (SETTINGS[:katello][:use_cp] || SETTINGS[:katello][:use_pulp])
+    include Glue
     include Authorization::Repository
     include Katello::Engine.routes.url_helpers
 
@@ -145,7 +145,7 @@ module Katello
     scoped_search :rename => :product, :on => :name, :relation => :product, :complete_value => true
     scoped_search :rename => :product_id, :on => :id, :relation => :product
     scoped_search :on => :content_type, :relation => :root, :complete_value => -> do
-      Katello::RepositoryTypeManager.repository_types.keys.each_with_object({}) { |value, hash| hash[value.to_sym] = value }
+      Katello::RepositoryTypeManager.repository_types.keys.index_by { |value| value.to_sym }
     end
     scoped_search :on => :content_view_id, :relation => :content_view_repositories, :validator => ScopedSearch::Validators::INTEGER, :only_explicit => true
     scoped_search :on => :distribution_version, :complete_value => true

data/app/presenters/katello/host_subscription_presenter.rb

@@ -1,11 +1,10 @@
 module Katello
   class HostSubscriptionPresenter < SimpleDelegator
-    attr_accessor :quantity_consumed
+    attr_reader :quantity_consumed
 
-    def initialize(entitlement)
-      @subscription = Katello::Pool.find_by(:cp_id => entitlement['pool']['id'])
+    def initialize(pool:, entitlement:)
       @quantity_consumed = entitlement.try(:[], :quantity)
-      super(@subscription)
+      super(pool)
     end
   end
 end

data/app/presenters/katello/host_subscriptions_presenter.rb

@@ -0,0 +1,24 @@
+module Katello
+  class HostSubscriptionsPresenter
+    attr_reader :subscriptions
+
+    def initialize(host)
+      pools = host.subscription_facet&.pools || []
+      @pools = pools.group_by(&:cp_id)
+
+      entitlements = host.subscription_facet.candlepin_consumer.entitlements if @pools.any?
+      entitlements ||= []
+
+      @subscriptions = entitlements.map do |e|
+        HostSubscriptionPresenter.new(pool: pool_for_entitlement(e), entitlement: e)
+      end
+    end
+
+    private
+
+    def pool_for_entitlement(entitlement)
+      pool_cp_id = entitlement['pool']['id']
+      @pools[pool_cp_id]&.first
+    end
+  end
+end

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

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

data/app/services/katello/candlepin_event_listener.rb

@@ -1,7 +1,5 @@
 module Katello
   class CandlepinEventListener
-    STATUS_CACHE_KEY = 'candlepin_events_status'.freeze
-
     Event = Struct.new(:subject, :content)
 
     cattr_accessor :client_factory
@@ -14,22 +12,20 @@ module Katello
     end
 
     def self.running?
-      @running == true && @client&.running?
+      @client&.running? || false
     end
 
     def self.close
-      return unless running?
-
-      logger.info("Closing candlepin event listener")
-      @client&.close
+      if @client&.close
+        logger.info("Closed candlepin event listener")
+      end
       reset
     end
 
     def self.reset
       @processed_count = 0
       @failed_count = 0
-      @running = false
-      Rails.cache.delete(STATUS_CACHE_KEY)
+      @client = nil
     end
 
     def self.run
@@ -37,18 +33,14 @@ module Katello
       @client.subscribe do |message|
         handle_message(message)
       end
-
-      @running = true
     end
 
-    def self.status(refresh: true)
-      Rails.cache.fetch(STATUS_CACHE_KEY, force: refresh) do
-        {
-          processed_count: @processed_count,
-          failed_count: @failed_count,
-          running: running?
-        }
-      end
+    def self.status
+      {
+        processed_count: @processed_count,
+        failed_count: @failed_count,
+        running: running?
+      }
     end
 
     def self.handle_message(message)

data/app/services/katello/event_monitor/poller_thread.rb

@@ -2,7 +2,6 @@ module Katello
   module EventMonitor
     class PollerThread
       SLEEP_INTERVAL = 3
-      STATUS_CACHE_KEY = 'katello_events_status'.freeze
 
       cattr_accessor :instance
 
@@ -15,7 +14,6 @@ module Katello
           self.instance.close
           self.instance = nil
         end
-        reset_status
       end
 
       def self.run
@@ -24,14 +22,8 @@ module Katello
         instance.poll_for_events
       end
 
-      def self.status(refresh: true)
-        Rails.cache.fetch(STATUS_CACHE_KEY, force: refresh) do
-          instance&.status
-        end
-      end
-
-      def self.reset_status
-        Rails.cache.delete(STATUS_CACHE_KEY)
+      def self.status
+        instance&.status
       end
 
       def initialize(logger = nil)
@@ -85,7 +77,6 @@ module Katello
       end
 
       def poll_for_events
-        @thread&.kill
         @thread = Thread.new do
           @logger.info("Polling Katello Event Queue")
           loop do

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

@@ -296,13 +296,11 @@ 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: username,
-            proxy_password: password
+            proxy_username: proxy.username,
+            proxy_password: proxy.password
           }
           return proxy_options
         end

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

@@ -42,21 +42,6 @@ module Katello
         puppet_repos.where(:pulp_id => pulp_repos.map { |pulp_repo| pulp_repo['id'] })
       end
 
-      def current_repositories_data(environment = nil, content_view = nil)
-        @pulp_repositories ||= smart_proxy.pulp_repositories
-
-        repos = Katello::Repository
-        repos = repos.in_environment(environment) if environment
-        repos = repos.in_content_views([content_view]) if content_view
-        puppet_envs = Katello::ContentViewPuppetEnvironment
-        puppet_envs = puppet_envs.in_environment(environment) if environment
-        puppet_envs = puppet_envs.in_content_view(content_view) if content_view
-
-        repo_ids = repos.pluck(:pulp_id) + puppet_envs.pluck(:pulp_id)
-
-        @pulp_repositories.select { |r| repo_ids.include?(r['id']) }
-      end
-
       def orphaned_repos
         @smart_proxy.pulp_repositories.map { |x| x["id"] } - repos_available_to_capsule.map { |x| x.pulp_id }
       end

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

@@ -58,20 +58,6 @@ 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/erratum.rb

@@ -35,8 +35,7 @@ module Katello
         custom_json["issued"] = convert_date_if_epoch(custom_json["issued"])
         custom_json["updated"] = convert_date_if_epoch(custom_json["updated"]) unless custom_json["updated"].blank?
 
-        if model.updated.blank? ||
-            (custom_json['updated'] && (custom_json['updated'].to_datetime != model.updated.to_datetime))
+        if model.updated.blank? || (custom_json['updated'].to_datetime != model.updated.to_datetime)
           custom_json['errata_id'] = custom_json.delete('id')
           custom_json['errata_type'] = custom_json.delete('type')
           custom_json['updated'] = custom_json['updated'].blank? ? custom_json['issued'] : custom_json['updated']

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

@@ -4,8 +4,6 @@ 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 = [
@@ -17,12 +15,6 @@ module Katello
         Katello::Erratum
       ].freeze
 
-      CORRUPTABLE_CONTENT_TYPES = [
-        Katello::Rpm,
-        Katello::FileUnit,
-        Katello::Deb
-      ].freeze
-
       def self.repository_types_for_migration
         #we can migrate types that pulp3 supports, but are overridden to pulp2.  These are in 'migration mode'
         overridden = (SETTINGS[:katello][:use_pulp_2_for_content_type] || {}).keys.select { |key| SETTINGS[:katello][:use_pulp_2_for_content_type][key] }
@@ -74,9 +66,7 @@ module Katello
 
       def last_successful_migration_time
         task = ForemanTasks::Task.where(:label => Actions::Pulp3::ContentMigration.to_s, :result => 'success').order("started_at desc").first
-        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
+        if reimport_all || task.nil?
           0
         else
           task.started_at.to_i
@@ -114,7 +104,6 @@ module Katello
             Katello::RepositoryTypeManager.repository_types[repository_type_label].content_types_to_index.each do |content_type|
               Katello::Logging.time("CONTENT_MIGRATION - Importing Content", data: {type: content_type.label}) do
                 import_content_type(content_type)
-                mark_missing_content(content_type)
               end
             end
           end
@@ -125,48 +114,9 @@ module Katello
         Katello::Pulp3::MigrationPlan.new(@repository_types).generate.as_json
       end
 
-      def reset
-        if @repository_types.empty?
-          fail ::Katello::Errors::Pulp3MigrationError, 'There are no Pulp 3 content types to reset'
-        end
-
-        plugins = @repository_types.sort.map do |repository_type|
-          {
-            type: ::Katello::Pulp3::MigrationPlan.pulp2_repository_type(repository_type)
-          }
-        end
-        plan = { plugins: plugins }
-
-        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, 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_all(remote_href: nil, publication_href: nil, version_href: nil)
-          elsif repo_type == "docker"
-            ::Katello::Repository.docker_type.update_all(remote_href: nil, publication_href: nil, version_href: nil)
-          elsif repo_type == "yum"
-            ::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.to_yaml}")
+        Rails.logger.info("Migration Plan: #{plan}")
 
         if plan['plugins'].empty?
           Rails.logger.error("No Repositories to migrate")
@@ -177,7 +127,7 @@ module Katello
       end
 
       def start_migration(plan_href)
-        migration_plan_api.run(plan_href, dry_run: false, validate: true, skip_corrupted: true)
+        migration_plan_api.run(plan_href, dry_run: false, validate: true)
       end
 
       def import_repositories(repository_type_label)
@@ -216,7 +166,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) if found
+            import_repo(yum_repo, found)
           end
         end
       end
@@ -305,35 +255,10 @@ 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
-
-      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)
-        unless [Katello::DockerTag, Katello::DockerManifest, Katello::Erratum].include?(content_type.model_class)
-          content_type.model_class.where(:migrated_pulp3_href => nil).update_all(:missing_from_migration => true)
-        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]})
       end
 
       def import_content_type(content_type)
@@ -353,9 +278,10 @@ 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(&:pulp_id))
+            migrated_units = pulp2_content_api.list(pulp2_id__in: needing_hrefs.map { |unit| unit.pulp_id }.join(','))
             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)
+              matching_record = needing_hrefs.find { |db_unit| db_unit.pulp_id == migrated_unit.pulp2_id }
+              matching_record&.update_column(:migrated_pulp3_href, migrated_unit.pulp3_content)
             end
           end
         end

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

@@ -14,19 +14,20 @@ 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
 
       def generate_plugins
         @repository_types.sort.map do |repository_type|
           {
-            type: self.class.pulp2_repository_type(repository_type),
+            type: pulp2_repository_type(repository_type),
             repositories: repository_migrations(repository_type)
           }
         end
       end
 
-      def self.pulp2_repository_type(repository_type)
+      def pulp2_repository_type(repository_type)
         if repository_type == 'yum'
           return 'rpm' #migration plugin uses rpm
         else
@@ -38,7 +39,6 @@ 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,8 +64,6 @@ 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: [
@@ -79,49 +77,10 @@ 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|
-          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
+          plans << content_view_migration(cv, root)
         end
         plans
       end
@@ -146,15 +105,7 @@ module Katello
       end
 
       def name_for_content_view(content_view, root_repo)
-        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
+        "#{content_view.label}-#{root_repo.label}"
       end
 
       def content_view_migration(content_view, root)

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

@@ -21,20 +21,6 @@ module Katello
           Katello::Logging.time("CONTENT_SWITCHOVER - combine_duplicate_content_types") { combine_duplicate_content_types }
           Katello::Logging.time("CONTENT_SWITCHOVER - combine_duplicate_docker_tags") { combine_duplicate_docker_tags } if docker_migration?
           Katello::Logging.time("CONTENT_SWITCHOVER - migrate_pulp3_hrefs") { migrate_pulp3_hrefs }
-          Katello::Logging.time("CONTENT_SWITCHOVER - remove_missing_content") { remove_missing_content }
-        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
 
@@ -120,29 +106,12 @@ module Katello
         end
       end
 
-      def remove_missing_content
-        content_types.each do |content_type|
-          if Migration::CORRUPTABLE_CONTENT_TYPES.include?(content_type.model_class)
-            content_type.model_class.ignored_missing_migrated_content.destroy_all
-          elsif content_type.model_class == Katello::Erratum
-            Katello::RepositoryErratum.where(:erratum_pulp3_href => nil).delete_all
-          else
-            content_type.model_class.unmigrated_content.destroy_all
-          end
-        end
-      end
-
       def migrated_content_type_check
-        content_classes = content_types.map(&:model_class)
-        migrated_errata_check if content_classes.include?(Katello::Erratum)
-
-        (content_classes & Migration::CORRUPTABLE_CONTENT_TYPES).each do |content_type|
-          if content_type.missing_migrated_content.any?
-            fail SwitchOverError, "ERROR: at least one #{content_type.table_name} record has been detected as corrupt or missing. Run 'foreman-rake katello:pulp3_migration_stats' for more information.\n"
-          end
-
-          if content_type.unmigrated_content.any?
-            fail SwitchOverError, "ERROR: at least one #{content_type.table_name} record was not able to be migrated\n"
+        content_types.each do |content_type|
+          if content_type.model_class == Katello::Erratum
+            migrated_errata_check
+          elsif content_type.model_class.where(migrated_pulp3_href: nil).any?
+            fail SwitchOverError, "ERROR: at least one #{content_type.model_class.table_name} record has migrated_pulp3_href NULL value\n"
           end
         end
       end

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

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

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

@@ -14,16 +14,7 @@ module Katello
           url, sles_token = extract_sles_token
           options = common_remote_options
           options.merge!(sles_auth_token: sles_token) if sles_token
-
-          options.merge!(url: url, policy: translated_download_policy)
-        end
-
-        def translated_download_policy
-          if root.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND
-            ::Runcible::Models::YumImporter::DOWNLOAD_IMMEDIATE
-          else
-            root.download_policy
-          end
+          options.merge!(url: url, policy: root.download_policy)
         end
 
         def extract_sles_token
@@ -349,7 +340,7 @@ module Katello
           multi_copy_units(repo_id_map, dependency_solving)
         end
 
-        def copy_content_for_source(source_repository, options = {})
+        def copy_content_for_source(source_repository, options = {}) # rubocop:disable Metrics/CyclomaticComplexity
           filters = [ContentViewErratumFilter, ContentViewPackageGroupFilter, ContentViewPackageFilter].collect do |filter_class|
             filter_class.where(:id => options[:filter_ids])
           end