katello 4.18.1 → 4.19.0.rc2

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

@@ -1,5 +1,6 @@
 module Katello
   # this is Katello's host bulk actions controller, not to be confused with Foreman's
+  # rubocop:disable Metrics/ClassLength
   class Api::V2::HostsBulkActionsController < Api::V2::ApiController
     include ::Api::V2::BulkHostsExtension
     include Katello::Concerns::Api::V2::ContentOverridesController
@@ -13,11 +14,8 @@ module Katello
     before_action :find_deletable_hosts, only: [:destroy_hosts]
     before_action :find_readable_hosts, only: [:applicable_errata, :installable_errata, :available_incremental_updates]
     before_action :find_errata, only: [:available_incremental_updates]
-    before_action :find_organization, only: [:add_subscriptions]
     before_action :find_traces, only: [:resolve_traces]
 
-    before_action :validate_organization, only: [:add_subscriptions]
-
     # disable *_count fields on erratum rabl, since they perform N+1 queries
     before_action :disable_erratum_hosts_count
 
@@ -51,8 +49,14 @@ module Katello
           host_collection.save!
 
           final_count = host_collection.host_ids.count - pre_host_collection_count
-          display_messages << _("Successfully added %{count} content host(s) to host collection %{host_collection}.") %
-              {:count => final_count, :host_collection => host_collection.name }
+          msg = if final_count == 0
+                  _("All selected hosts were already members of host collection %{host_collection}.") %
+                              {:host_collection => host_collection.name }
+                else
+                  _("Added %{count} host(s) to host collection %{host_collection}.") %
+                              {:count => final_count, :host_collection => host_collection.name }
+                end
+          display_messages << msg
         end
       end
 
@@ -74,7 +78,7 @@ module Katello
           host_collection.save!
 
           final_count = pre_host_collection_count - host_collection.host_ids.count
-          display_messages << _("Successfully removed %{count} content host(s) from host collection %{host_collection}.") %
+          display_messages << _("Removed %{count} host(s) from host collection %{host_collection}.") %
               {:count => final_count, :host_collection => host_collection.name }
         end
       end
@@ -106,49 +110,6 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/remove_subscriptions", N_("Remove subscriptions from one or more hosts"), deprecated: true
-    param_group :bulk_params
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to remove") do
-      param :id, String, :desc => N_("Subscription Pool id"), :required => true
-      param :quantity, Integer, :desc => N_("Quantity of specified subscription to remove"), :required => false
-    end
-    def remove_subscriptions
-      #combine the quantities for duplicate pools into PoolWithQuantities objects
-      pool_id_quantities = params.require(:subscriptions).inject({}) do |new_hash, subscription|
-        new_hash[subscription['id']] ||= PoolWithQuantities.new(Pool.find(subscription['id']))
-        new_hash[subscription['id']].quantities << subscription['quantity']
-        new_hash
-      end
-      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::RemoveSubscriptions, @hosts, pool_id_quantities.values)
-      respond_for_async :resource => task
-    end
-
-    api :PUT, "/hosts/bulk/add_subscriptions", N_("Add subscriptions to one or more hosts"), deprecated: true
-    param_group :bulk_params
-    param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => true do
-      param :id, String, :desc => N_("Subscription Pool id"), :required => true
-      param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
-    end
-    def add_subscriptions
-      if @organization.simple_content_access?
-        fail HttpErrors::BadRequest, _("The specified organization is in Simple Content Access mode. Attaching subscriptions is disabled")
-      end
-
-      pools_with_quantities = params.require(:subscriptions).map do |sub_params|
-        PoolWithQuantities.new(Pool.find(sub_params['id']), sub_params['quantity'])
-      end
-
-      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::AttachSubscriptions, @hosts, pools_with_quantities)
-      respond_for_async :resource => task
-    end
-
-    api :PUT, "/hosts/bulk/auto_attach", N_("Trigger an auto-attach of subscriptions on one or more hosts"), deprecated: true
-    param_group :bulk_params
-    def auto_attach
-      task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::AutoAttachSubscriptions, @hosts)
-      respond_for_async :resource => task
-    end
-
     api :PUT, "/hosts/bulk/content_overrides", N_("Set content overrides to one or more hosts")
     param_group :bulk_params
     param :content_overrides, Array, :desc => N_("Array of Content override parameters") do
@@ -310,10 +271,6 @@ module Katello
       find_bulk_hosts(:destroy_hosts, params)
     end
 
-    def validate_organization
-      fail HttpErrors::BadRequest, _("Organization ID is required") if @organization.blank?
-    end
-
     def validate_host_collection_membership_limit
       max_hosts_exceeded = []
       host_ids = @hosts.map(&:id)

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

@@ -676,7 +676,6 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
         root.deb_releases = repo_params[:deb_releases] if repo_params[:deb_releases]
         root.deb_components = repo_params[:deb_components] if repo_params[:deb_components]
         root.deb_architectures = repo_params[:deb_architectures] if repo_params[:deb_architectures]
-        root.content_id = 'INITIAL_DUMMY_VALUE' unless Setting['deb_enable_structured_apt']
       end
 
       if root.ansible_collection?

data/app/controllers/katello/concerns/api/v2/hosts_controller_extensions.rb

@@ -14,6 +14,16 @@ module Katello
             super
           end
         end
+
+        def resource_scope(options = {})
+          scope = super(options)
+          # Eager load host_collections for index action to avoid N+1 queries
+          # Using preload to force loading even if not accessed
+          if params[:action] == 'index' && scope.respond_to?(:preload)
+            scope = scope.preload(:host_collections)
+          end
+          scope
+        end
       end
 
       included do

data/app/controllers/katello/concerns/organizations_controller_extensions.rb

@@ -24,6 +24,9 @@ module Katello
           if taxonomy_class == Organization
             begin
               @taxonomy = Organization.new(resource_params)
+              # Raise validation error early if invalid
+              @taxonomy.validate!
+
               ::Katello::OrganizationCreator.new(@taxonomy).create!
               @taxonomy.reload
               switch_taxonomy

data/app/lib/actions/candlepin/activation_key/create.rb

@@ -3,7 +3,6 @@ module Actions
     class ActivationKey::Create < Candlepin::Abstract
       input_format do
         param :organization_label
-        param :auto_attach
         param :service_level
         param :release_version
         param :purpose_role
@@ -13,7 +12,6 @@ module Actions
       def run
         output[:response] = ::Katello::Resources::Candlepin::ActivationKey.create(::Katello::Util::Model.uuid,
                                                                                   input[:organization_label],
-                                                                                  input[:auto_attach],
                                                                                   input[:service_level],
                                                                                   input[:release_version],
                                                                                   input[:purpose_role],

data/app/lib/actions/candlepin/activation_key/update.rb

@@ -6,7 +6,6 @@ module Actions
           param :cp_id
           param :release_version
           param :service_level
-          param :auto_attach
           param :purpose_role
           param :purpose_usage
         end
@@ -16,7 +15,6 @@ module Actions
                                                                 input[:cp_id],
                                                                 input[:release_version],
                                                                 input[:service_level],
-                                                                input[:auto_attach],
                                                                 input[:purpose_role],
                                                                 input[:purpose_usage])
         end

data/app/lib/actions/candlepin/product/content_create.rb

@@ -16,12 +16,10 @@ module Actions
         def run
           content_url = input[:content_url]
           if input[:type] == ::Katello::Repository::DEB_TYPE
-            # We must retrieve the repository in the run phase, so the latest Pulp version_href is
-            # already set. This is needed to retrieve the latest repository.deb_content_url_options!
+            # We must retrieve the deb? repository in the run phase, so the latest Pulp version_href
+            # is set. This is needed to retrieve the latest repository.deb_content_url_options!
             repository = ::Katello::Repository.find(input[:repository_id])
-            if repository.deb_using_structured_apt?
-              content_url += repository.deb_content_url_options
-            end
+            content_url += repository.deb_content_url_options
           end
 
           output[:response] = ::Katello::Resources::Candlepin::Content.

data/app/lib/actions/candlepin/product/content_update.rb

@@ -16,11 +16,10 @@ module Actions
         end
 
         def finalize
+          # finalize, because Katello::Product::ContentCreate updates repository.content_id during finalize!
           content_url = input[:content_url]
-          # We must retrieve the repository in the finalize phase, because Katello::Product::ContentCreate
-          # only updates the repository.content_id in the finalize phase!
           repository = ::Katello::Repository.find(input[:repository_id])
-          if repository.deb_using_structured_apt?
+          if repository.deb?
             content_url += repository.deb_content_url_options
           end
 

data/app/lib/actions/helpers/rolling_cv_repos.rb

@@ -2,7 +2,7 @@ module Actions
   module Helpers
     module RollingCVRepos
       def find_related_rolling_repos(repo)
-        repo.root.repositories.in_environment(repo.environment).where(
+        repo.root.repositories.where(
           content_view_version: ::Katello::ContentViewVersion.where(content_view: ::Katello::ContentView.rolling)
         )
       end

data/app/lib/actions/katello/activation_key/create.rb

@@ -6,7 +6,6 @@ module Actions
           activation_key.save!
           cp_create = plan_action(Candlepin::ActivationKey::Create,
                                   organization_label: activation_key.organization.label,
-                                  auto_attach: activation_key.auto_attach,
                                   service_level: params[:service_level],
                                   release_version: activation_key.release_version,
                                   purpose_role: activation_key.purpose_role,

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

@@ -12,14 +12,12 @@ module Actions
                         cp_id: activation_key.cp_id,
                         release_version: activation_key.release_version,
                         service_level: activation_key.service_level,
-                        auto_attach: activation_key.auto_attach,
                         purpose_role: activation_key.purpose_role,
                         purpose_usage: activation_key.purpose_usage)
           end
         end
 
         def update_candlepin?(activation_key, activation_key_params)
-          cp_changed?(activation_key.auto_attach, activation_key_params[:auto_attach]) ||
           cp_changed?(activation_key.service_level, activation_key_params[:service_level]) ||
           cp_changed?(activation_key.release_version, activation_key_params[:release_version]) ||
           cp_changed?(activation_key.purpose_role, activation_key_params[:purpose_role]) ||

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

@@ -2,7 +2,6 @@ module Actions
   module Katello
     module CapsuleContent
       class SyncCapsule < ::Actions::EntryAction
-        include Helpers::RollingCVRepos
         # rubocop:disable Metrics/MethodLength
         execution_plan_hooks.use :update_content_counts, :on => :success
         def plan(smart_proxy, options = {})
@@ -59,11 +58,7 @@ module Actions
           smart_proxy_helper.lifecycle_environment_check(environment, repository)
           if repository
             if skip_metatadata_check || !repository.smart_proxy_sync_histories.where(:smart_proxy_id => smart_proxy).any? { |sph| !sph.finished_at.nil? }
-              if repository.library_instance?
-                [repository] + find_related_rolling_repos(repository)
-              else
-                [repository]
-              end
+              [repository]
             end
           else
             repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count

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

@@ -6,7 +6,7 @@ module Actions
           action_subject gpg_key
           gpg_key.update!(gpg_key_params)
           gpg_key.repositories.each do |repository|
-            if repository.content_type == ::Katello::Repository::DEB_TYPE
+            if repository.deb?
               plan_action(::Actions::Katello::Repository::RefreshRepository, repository)
             end
           end

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

@@ -2,36 +2,30 @@ module Actions
   module Katello
     module ContentView
       class AddRollingRepoClone < Actions::EntryAction
-        include Helpers::SmartProxySyncHelper
-
-        def plan(content_view, repository_ids)
-          library = content_view.organization.library
+        def plan(content_view, repository_ids, environment_ids)
           clone_ids = []
+          environments = ::Katello::KTEnvironment.where(id: environment_ids)
+          repositories = ::Katello::Repository.where(id: repository_ids)
 
-          concurrence do
-            ::Katello::Repository.where(id: repository_ids).each do |repository|
-              sequence do
-                clone = content_view.get_repo_clone(library, repository).first
-                if clone.nil?
-                  clone = repository.build_clone(content_view: content_view, environment: library)
-                  clone.save!
-                end
-                plan_action(RefreshRollingRepo, clone, false)
+          environments.each do |environment|
+            concurrence do
+              repositories.each do |repository|
+                sequence do
+                  clone = content_view.get_repo_clone(environment, repository).first
+                  if clone.nil?
+                    clone = repository.build_clone(content_view: content_view, environment: environment)
+                    clone.save!
+                  end
+                  plan_action(RefreshRollingRepo, clone, false)
 
-                view_env_cp_id = content_view.content_view_environment(library).cp_id
-                content_id = repository.content_id
-                plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env_cp_id, :content_id => content_id)
-                clone_ids << clone.id
+                  view_env_cp_id = content_view.content_view_environment(environment).cp_id
+                  content_id = repository.content_id
+                  plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env_cp_id, :content_id => content_id)
+                  clone_ids << clone.id
+                end
               end
             end
           end
-          plan_self(repository_ids: clone_ids)
-        end
-
-        def run
-          ::Katello::Repository.where(id: input[:repository_ids]).each do |repository|
-            schedule_async_repository_proxy_sync(repository)
-          end
         end
       end
     end

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

@@ -2,20 +2,25 @@ module Actions
   module Katello
     module ContentView
       class Create < Actions::Base
-        def plan(content_view)
+        def plan(content_view, environment_ids = [])
           content_view.save!
           if content_view.rolling?
-            plan_action(AddToEnvironment, content_view.create_new_version, content_view.organization.library)
+            new_version = content_view.create_new_version
+            if environment_ids&.any?
+              ::Katello::KTEnvironment.where(id: environment_ids).each do |environment|
+                plan_action(AddToEnvironment, new_version, environment)
+              end
+            end
             repository_ids = content_view.repository_ids
             if repository_ids.any?
               content_view.reload
-              plan_action(AddRollingRepoClone, content_view, repository_ids)
+              plan_action(AddRollingRepoClone, content_view, repository_ids, environment_ids)
             end
           end
         end
 
         def humanized_name
-          _("Create")
+          _("Create content view")
         end
       end
     end

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

@@ -2,6 +2,8 @@ module Actions
   module Katello
     module ContentView
       class RefreshRollingRepo < Actions::EntryAction
+        include Helpers::SmartProxySyncHelper
+
         def plan(repository, contents_changed)
           action_subject repository
           sequence do
@@ -23,8 +25,10 @@ module Actions
           repository.last_contents_changed = DateTime.now if repository.version_href != library_instance.version_href
 
           repository.version_href = library_instance.version_href
+          repository.version_prn = library_instance.version_prn
           repository.publication_href = library_instance.publication_href
-          if repository.deb_using_structured_apt?
+          repository.publication_prn = library_instance.publication_prn
+          if repository.deb?
             repository.content_id = library_instance.content_id
           end
           repository.save!
@@ -33,6 +37,7 @@ module Actions
         def finalize
           repository = ::Katello::Repository.find(input[:repository_id])
           repository.clear_smart_proxy_sync_histories if input[:contents_changed]
+          schedule_async_repository_proxy_sync(repository)
         end
       end
     end

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

@@ -2,21 +2,26 @@ module Actions
   module Katello
     module ContentView
       class RemoveRollingRepoClone < Actions::EntryAction
-        def plan(content_view, repository_ids)
-          library = content_view.organization.library
+        def plan(content_view, repository_ids, environment_ids)
+          clone_ids = []
+          environments = ::Katello::KTEnvironment.where(id: environment_ids)
+          repositories = ::Katello::Repository.where(id: repository_ids)
 
-          clone_repo_ids = []
-          concurrence do
-            ::Katello::Repository.where(id: repository_ids).each do |repository|
-              clone_repo = content_view.get_repo_clone(library, repository).first
-              next if clone_repo.nil?
+          sequence do
+            environments.each do |environment|
+              concurrence do
+                repositories.each do |repository|
+                  clone_repo = content_view.get_repo_clone(environment, repository).first
+                  next if clone_repo.nil?
 
-              clone_repo_ids << clone_repo.id
-              plan_action(Actions::Pulp3::Repository::DeleteDistributions, clone_repo.id, SmartProxy.pulp_primary)
+                  clone_ids << clone_repo.id
+                  plan_action(Actions::Pulp3::Repository::DeleteDistributions, clone_repo.id, SmartProxy.pulp_primary)
+                end
+                plan_action(Candlepin::Environment::SetContent, content_view, environment, content_view.content_view_environment(environment))
+              end
             end
-            plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library))
+            plan_self(repository_ids: clone_ids)
           end
-          plan_self(repository_ids: clone_repo_ids)
         end
 
         def run

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

@@ -2,7 +2,7 @@ module Actions
   module Katello
     module ContentView
       class Update < Actions::EntryAction
-        def plan(content_view, content_view_params)
+        def plan(content_view, content_view_params, environment_ids)
           action_subject content_view
           content_view_params = content_view_params.with_indifferent_access
 
@@ -28,15 +28,42 @@ module Actions
             end
           end
 
-          if content_view.rolling? && content_view_params.key?(:repository_ids)
-            repo_ids_to_add = content_view_params[:repository_ids] - content_view.repository_ids
-            repo_ids_to_remove = content_view.repository_ids - content_view_params[:repository_ids]
+          handle_rolling_content_view(content_view, content_view_params[:repository_ids], environment_ids)
+          content_view.update!(content_view_params)
+        end
 
-            plan_action(AddRollingRepoClone, content_view, repo_ids_to_add) if repo_ids_to_add.any?
-            plan_action(RemoveRollingRepoClone, content_view, repo_ids_to_remove) if repo_ids_to_remove.any?
+        def handle_rolling_content_view(content_view, target_repo_ids, target_env_ids)
+          return unless content_view.rolling?
+
+          add_repo_ids, remove_repo_ids, retain_repo_ids = translate_id_lists(content_view.repository_ids, target_repo_ids)
+
+          if target_env_ids.nil?
+            target_env_ids = retain_env_ids = content_view.environment_ids
+          else
+            add_env_ids, remove_env_ids, retain_env_ids = translate_id_lists(content_view.environment_ids, target_env_ids)
+            ::Katello::KTEnvironment.where(id: add_env_ids).each do |environment|
+              plan_action(AddToEnvironment, content_view.versions[0], environment)
+            end
+            plan_action(AddRollingRepoClone, content_view, retain_repo_ids, add_env_ids) if retain_repo_ids.any? && add_env_ids.any?
+            ::Katello::KTEnvironment.where(id: remove_env_ids).each do |environment|
+              plan_action(RemoveFromEnvironment, content_view, environment)
+            end
           end
 
-          content_view.update!(content_view_params)
+          plan_action(AddRollingRepoClone, content_view, add_repo_ids, target_env_ids) if add_repo_ids.any?
+          plan_action(RemoveRollingRepoClone, content_view, remove_repo_ids, retain_env_ids) if remove_repo_ids.any?
+        end
+
+        def translate_id_lists(current_ids, target_ids)
+          if target_ids.nil?
+            add_ids = remove_ids = []
+            retain_ids = current_ids
+          else
+            add_ids = target_ids - current_ids
+            remove_ids = current_ids - target_ids
+            retain_ids = current_ids - remove_ids
+          end
+          return add_ids, remove_ids, retain_ids
         end
       end
     end

data/app/lib/actions/katello/product/content_create.rb

@@ -7,7 +7,7 @@ module Actions
         def plan(repository)
           root = repository.root
           sequence do
-            if repository.content_id.nil? || repository.content_id == 'INITIAL_DUMMY_VALUE'
+            if repository.content_id.nil?
               content_create = plan_action(Candlepin::Product::ContentCreate,
                                            repository_id: repository.id,
                                            owner:         root.organization.label,
@@ -45,7 +45,7 @@ module Actions
         def finalize
           root = ::Katello::RootRepository.find(input[:root_repository_id])
           content_url = root.custom_content_path
-          if root.deb_using_structured_apt?
+          if root.deb?
             repository = ::Katello::Repository.find(input[:repository_id])
             content_url += repository.deb_content_url_options
             repository.update(:content_id => input[:content_id])

data/app/lib/actions/katello/product/content_destroy.rb

@@ -15,7 +15,7 @@ module Actions
             ::Katello::ProductContent.where(product_id: root_repository.product_id,
                                             content_id: katello_content_id).destroy_all
 
-            if root_repository.repositories.count <= 1 || repository.deb_using_structured_apt?
+            if root_repository.repositories.count <= 1 || repository.deb?
               plan_action(Candlepin::Product::ContentDestroy,
                           owner: root_repository.product.organization.label,
                           content_id: repository.content_id)

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

@@ -27,7 +27,7 @@ module Actions
             output[:matching_content] = srpms_match && rpms && errata && package_groups && distributions && target_repo_published && checksum_match
           end
 
-          if source_repo.content_type == ::Katello::Repository::DEB_TYPE
+          if source_repo.deb?
             debs = debs_match?(source_repo, target_repo)
 
             output[:matching_content] = debs && target_repo_published

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

@@ -26,7 +26,7 @@ module Actions
             index_options = {id: new_repository.id, force_index: true}
             index_options[:source_repository_id] = source_repositories.first.id if source_repositories.count == 1 && filters.empty? && rpm_filenames.nil?
 
-            if new_repository.deb_using_structured_apt? && generate_metadata
+            if new_repository.deb? && generate_metadata
               plan_action(Candlepin::Product::ContentUpdate,
                           owner:           new_repository.organization.label,
                           repository_id:   new_repository.id,

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

@@ -64,7 +64,7 @@ module Actions
         end
 
         def create_content?(repository, clone)
-          if repository.deb_using_structured_apt?
+          if repository.deb?
             return true
           elsif clone || repository.content
             return false

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

@@ -86,10 +86,10 @@ module Actions
         end
 
         def handle_custom_content(repository, remove_from_content_view_versions)
-          #if this is the last instance of a custom repo or a deb repo using structured APT, destroy the content
-          if remove_from_content_view_versions || repository.root.repositories.where.not(id: repository.id).empty? || repository.deb_using_structured_apt?
-            # Never destroy content for structured apt rolling repo clones, because it belongs to the library instance
-            return if repository.deb_using_structured_apt? && repository.content_view.rolling?
+          # If this is the last instance of a custom repo or a deb repo, then destroy the content
+          if remove_from_content_view_versions || repository.root.repositories.where.not(id: repository.id).empty? || repository.deb?
+            # Never destroy content for deb rolling repo clones, it belongs to the library instance!
+            return if repository.deb? && repository.content_view.rolling?
 
             plan_action(::Actions::Katello::Product::ContentDestroy, repository)
           end

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

@@ -15,7 +15,7 @@ module Actions
           generate_metadata = options.fetch(:generate_metadata, true)
           plan_action(Katello::Repository::MetadataGenerate, repository, :dependency => import_upload_task, :force_publication => true) if generate_metadata
 
-          if repository.deb_using_structured_apt? && generate_metadata
+          if repository.deb? && generate_metadata
             plan_action(::Actions::Candlepin::Product::ContentUpdate,
                         owner:           repository.organization.label,
                         repository_id:   repository.id,

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

@@ -101,7 +101,7 @@ module Actions
         end
 
         def update_deb_content(repo)
-          return unless repo.deb_using_structured_apt?
+          return unless repo.deb?
 
           plan_action(::Actions::Candlepin::Product::ContentUpdate,
                       owner:           repo.organization.label,

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

@@ -39,7 +39,7 @@ module Actions
             else
               plan_self(source_version_repo_id: source_repositories.first.id,
                         target_repo_id: target_repo.id)
-              target_repo.update!(version_href: source_repositories.first.version_href)
+              target_repo.update!(version_href: source_repositories.first.version_href, version_prn: source_repositories.first.version_prn)
             end
           end
 
@@ -47,7 +47,7 @@ module Actions
             #this is a 'simple' copy, so just reference version_href
             target_repo = ::Katello::Repository.find(input[:target_repo_id])
             source_repo = ::Katello::Repository.find(input[:source_version_repo_id])
-            target_repo.update!(version_href: source_repo.version_href)
+            target_repo.update!(version_href: source_repo.version_href, version_prn: source_repo.version_prn)
           end
         end
       end

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

@@ -33,7 +33,7 @@ module Actions
               if (target_repo.publication_href != source_repo.publication_href && smart_proxy.pulp_primary?)
                 target_repo.clear_smart_proxy_sync_histories
               end
-              target_repo.update!(publication_href: source_repo.publication_href)
+              target_repo.update!(publication_href: source_repo.publication_href, publication_prn: source_repo.publication_prn)
             end
           end
         end

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

@@ -31,7 +31,7 @@ module Actions
             input[:repo_id_map].each do |source_repo_id, dest_repo_id|
               dest_repo = ::Katello::Repository.find(dest_repo_id)
               source_repo = ::Katello::Repository.find(source_repo_id)
-              dest_repo.update!(version_href: source_repo.version_href)
+              dest_repo.update!(version_href: source_repo.version_href, version_prn: source_repo.version_prn)
             end
           end
         end

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

@@ -12,7 +12,9 @@ module Actions
             publication_href = input[:tasks][:pulp_tasks].first[:created_resources].first
             if publication_href
               repo = ::Katello::Repository.find(input[:repository_id])
-              repo.update(:publication_href => publication_href)
+              repo_backend_service = repo.backend_service(SmartProxy.pulp_primary)
+              publication = repo_backend_service.api.publications_api.read(publication_href, {fields: 'prn'})
+              repo.update(:publication_href => publication_href, :publication_prn => publication.prn)
             end
           end
         end