katello 4.5.1 → 4.8.0.rc2

data/app/models/katello/package_group.rb

@@ -12,18 +12,6 @@ module Katello
       self.repositories.first
     end
 
-    def self.list_by_filter_clauses(clauses)
-      package_names = []
-      pulp_package_groups = Katello.pulp_server.extensions.package_group.search(Katello::PackageGroup::CONTENT_TYPE, :filters => clauses)
-      groupings = [:default_package_names, :conditional_package_names, :optional_package_names, :mandatory_package_names]
-      if pulp_package_groups.any?
-        pulp_package_groups.flat_map { |group| groupings.each { |grouping| package_names << group[grouping] } }
-        package_names.flatten!
-      else
-        []
-      end
-    end
-
     def package_names
       service_class = SmartProxy.pulp_primary!.content_service(CONTENT_TYPE)
       group = service_class.new(self.pulp_id)

data/app/models/katello/pool.rb

@@ -56,7 +56,10 @@ module Katello
     validate :subscription_matches_organization
 
     def subscription_matches_organization
-      errors.add(:base, _("A Pool and its Subscription cannot belong to different organizations")) unless subscription&.organization_id == self.organization_id
+      return if errors[:subscription].any? || errors[:organization].any? # let other validations catch this
+      unless subscription&.organization_id == self.organization_id
+        errors.add(:base, _("A Pool and its Subscription cannot belong to different organizations."))
+      end
     end
 
     DAYS_RECENTLY_EXPIRED = 30

data/app/models/katello/product.rb

@@ -28,8 +28,12 @@ module Katello
     has_many :pools, :through => :pool_products
     has_many :subscriptions, :through => :pools, :dependent => :destroy
 
+    has_many :alternate_content_source_products, dependent: :delete_all, inverse_of: :product, :class_name => "Katello::AlternateContentSourceProduct"
+    has_many :alternate_content_sources, :through => :alternate_content_source_products, :inverse_of => :products, :class_name => "Katello::AlternateContentSource"
+
     validates_lengths_from_database :except => [:label]
     validates :provider_id, :presence => true
+    validate :ensure_provider_type_matches_id
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
     validates_with Validators::KatelloLabelFormatValidator, :attributes => :label
     validates_with Validators::ProductUniqueAttributeValidator, :attributes => :name
@@ -233,7 +237,7 @@ module Katello
     end
 
     def self.unused_product_id
-      id = SecureRandom.random_number(999_999_999_999)
+      id = (SecureRandom.random_number * (10**12 - 10**11) + 10**11).to_i # guarantee that we get 12 digits
       if ::Katello::Product.find_by(:cp_id => id)
         unused_product_id
       else
@@ -250,5 +254,14 @@ module Katello
     class Jail < ::Safemode::Jail
       allow :name, :label
     end
+
+    private
+
+    def ensure_provider_type_matches_id
+      return if errors[:provider_id].any?
+      if provider.redhat_provider? && ::Katello::Glue::Candlepin::Product.custom_product_id?(cp_id)
+        errors.add(:base, _("Cannot associate a Red Hat provider with a custom product"))
+      end
+    end
   end
 end

data/app/models/katello/repository.rb

@@ -12,7 +12,6 @@ module Katello
 
     include ForemanTasks::Concerns::ActionSubject
     include Glue::Candlepin::Repository
-    include Glue::Pulp::Repo
 
     include Glue
     include Authorization::Repository
@@ -31,7 +30,7 @@ module Katello
     ANSIBLE_COLLECTION_TYPE = 'ansible_collection'.freeze
     GENERIC_TYPE = 'generic'.freeze
 
-    EXPORTABLE_TYPES = [YUM_TYPE, FILE_TYPE, ANSIBLE_COLLECTION_TYPE].freeze
+    EXPORTABLE_TYPES = [YUM_TYPE, FILE_TYPE, ANSIBLE_COLLECTION_TYPE, DOCKER_TYPE].freeze
 
     define_model_callbacks :sync, :only => :after
 
@@ -110,6 +109,8 @@ module Katello
 
     has_many :smart_proxy_sync_histories, :class_name => "::Katello::SmartProxySyncHistory", :inverse_of => :repository, :dependent => :delete_all
 
+    has_many :smart_proxy_alternate_content_sources, :class_name => 'Katello::SmartProxyAlternateContentSource', :inverse_of => :repository, :dependent => :nullify
+
     validates_with Validators::ContainerImageNameValidator, :attributes => :container_repository_name, :allow_blank => false, :if => :docker?
     validates :container_repository_name, :if => :docker?, :uniqueness => {message: ->(object, _data) do
       _("for repository '%{name}' is not unique and cannot be created in '%{env}'. Its Container Repository Name (%{container_name}) conflicts with an existing repository.  Consider changing the Lifecycle Environment's Registry Name Pattern to something more specific.") %
@@ -138,7 +139,6 @@ module Katello
     scope :order_by_root, ->(attr) { joins(:root).order("#{Katello::RootRepository.table_name}.#{attr}") }
     scope :with_content, ->(content) { joins(Katello::RepositoryTypeManager.find_content_type(content).model_class.repository_association_class.name.demodulize.underscore.pluralize.to_sym).distinct }
     scope :by_rpm_count, -> { left_joins(:repository_rpms).group(:id).order("count(katello_repository_rpms.id) ASC") } # smallest count first
-    scope :exportable, -> { with_type(EXPORTABLE_TYPES) }
     scope :immediate_or_none, -> do
       immediate.or(where("#{RootRepository.table_name}.download_policy" => nil)).
         or(where("#{RootRepository.table_name}.download_policy" => ""))
@@ -184,6 +184,15 @@ module Katello
     delegate :content_id, to: :root, allow_nil: true
     delegate :repository_type, to: :root
 
+    def self.exportable_types(format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
+      return [YUM_TYPE, FILE_TYPE] if format == ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
+      EXPORTABLE_TYPES
+    end
+
+    def self.exportable(format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
+      with_type(exportable_types(format: format))
+    end
+
     def self.with_type(content_type)
       joins(:root).where("#{RootRepository.table_name}.content_type" => content_type)
     end
@@ -196,12 +205,10 @@ module Katello
       name
     end
 
-    def backend_service(smart_proxy, force_pulp3 = false)
-      if force_pulp3 || smart_proxy.pulp3_support?(self)
-        @service ||= Katello::Pulp3::Repository.instance_for_type(self, smart_proxy)
-      else
-        @service ||= Katello::Pulp::Repository.instance_for_type(self, smart_proxy)
-      end
+    def backend_service(smart_proxy)
+      fail('Pulp 3 not supported') unless smart_proxy.pulp3_support?(self)
+
+      @service ||= Katello::Pulp3::Repository.instance_for_type(self, smart_proxy)
     end
 
     def backend_content_service(smart_proxy)
@@ -339,7 +346,7 @@ module Katello
 
     def published_in_versions
       Katello::ContentViewVersion.with_repositories(self.library_instances_inverse)
-                                 .where(content_view_id: Katello::ContentView.not_generated_for_repository).distinct
+                                 .where(content_view_id: Katello::ContentView.ignore_generated).distinct
     end
 
     def self.errata_with_package_counts(repo)
@@ -574,7 +581,7 @@ module Katello
 
       if self.yum?
         if self.library_instance?
-          checksum_type = root.checksum_type || pulp_scratchpad_checksum_type
+          checksum_type = root.checksum_type
         else
           checksum_type = self.saved_checksum_type
         end
@@ -666,7 +673,7 @@ module Katello
 
     def self.smart_proxy_syncable
       joins(:content_view_version => :content_view).
-        merge(ContentView.not_generated_for_repository).
+        merge(ContentView.ignore_generated).
         where.not(environment_id: nil)
     end
 
@@ -753,6 +760,15 @@ module Katello
       return true
     end
 
+    def content_views_all(include_composite: false)
+      if include_composite
+        cv_ids = library_instances_inverse&.joins(:content_view_version)&.map { |cvv| cvv&.content_view&.id }
+        return ContentView.where(id: cv_ids.uniq)
+      else
+        return self.content_views
+      end
+    end
+
     def sync_hook
       run_callbacks :sync do
         logger.debug "custom hook after_sync on #{name} will be executed if defined."

data/app/models/katello/root_repository.rb

@@ -21,6 +21,7 @@ module Katello
     CHECKSUM_TYPES = %w(sha1 sha256).freeze
 
     SUBSCRIBABLE_TYPES = [Repository::YUM_TYPE, Repository::OSTREE_TYPE, Repository::DEB_TYPE].freeze
+    SKIPABLE_METADATA_TYPES = [Repository::YUM_TYPE, Repository::DEB_TYPE].freeze
 
     CONTENT_ATTRIBUTE_RESTRICTIONS = {
       :download_policy => [Repository::YUM_TYPE, Repository::DEB_TYPE, Repository::DOCKER_TYPE]
@@ -101,6 +102,7 @@ module Katello
       :message => _("must be one of the following: %s") % HTTP_PROXY_POLICIES.join(', ')
     }
     scope :subscribable, -> { where(content_type: RootRepository::SUBSCRIBABLE_TYPES) }
+    scope :skipable_metadata_check, -> { where(content_type: RootRepository::SKIPABLE_METADATA_TYPES) }
     scope :has_url, -> { where.not(:url => nil) }
     scope :with_repository_attribute, ->(attr, value) { joins(:repositories).where("#{Katello::Repository.table_name}.#{attr}" => value) }
     scope :in_content_view_version, ->(version) { with_repository_attribute(:content_view_version_id, version) }
@@ -225,6 +227,8 @@ module Katello
         errors.add(:ignorable_content, N_("Invalid value specified for ignorable content."))
       elsif ignorable_content.any? { |item| !IGNORABLE_CONTENT_UNIT_TYPES.include?(item) }
         errors.add(:ignorable_content, N_("Invalid value specified for ignorable content. Permissible values %s") % IGNORABLE_CONTENT_UNIT_TYPES.join(","))
+      elsif self.mirroring_policy == MIRRORING_POLICY_COMPLETE
+        errors.add(:ignorable_content, N_("Ignore %s can not be set in combination with 'Complete Mirroring' mirroring policy.") % IGNORABLE_CONTENT_UNIT_TYPES.join(","))
       end
     end
 
@@ -413,9 +417,10 @@ module Katello
     end
 
     def http_proxy
-      if http_proxy_policy == NO_DEFAULT_HTTP_PROXY
+      case http_proxy_policy
+      when NO_DEFAULT_HTTP_PROXY
         return nil
-      elsif http_proxy_policy == GLOBAL_DEFAULT_HTTP_PROXY
+      when GLOBAL_DEFAULT_HTTP_PROXY
         return HttpProxy.default_global_content_proxy
       end
       super
@@ -423,7 +428,7 @@ module Katello
 
     def format_arches
       if content_type == ::Katello::Repository::DEB_TYPE
-        self.deb_architectures
+        self.deb_architectures&.gsub(" ", ",")
       else
         self.arch == "noarch" ? nil : self.arch
       end

data/app/models/katello/rpm.rb

@@ -17,6 +17,7 @@ module Katello
     scoped_search :on => :evr, :ext_method => :scoped_search_evr, :only_explicit => true
     scoped_search :on => :filename, :complete_value => true
     scoped_search :on => :sourcerpm, :complete_value => true
+    scoped_search :on => :nvra, :complete_value => true
     scoped_search :on => :modular, :complete_value => true, :only_explicit => true
     scoped_search :on => :checksum
 

data/app/models/katello/smart_proxy_alternate_content_source.rb

@@ -1,8 +1,14 @@
 module Katello
   class SmartProxyAlternateContentSource < Katello::Model
+    audited
     # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
     self.table_name = :katello_smart_proxy_alternate_content_sources
     belongs_to :smart_proxy, :inverse_of => :smart_proxy_alternate_content_sources, :class_name => 'SmartProxy'
     belongs_to :alternate_content_source, :inverse_of => :smart_proxy_alternate_content_sources, :class_name => 'Katello::AlternateContentSource'
+    belongs_to :repository, :inverse_of => :smart_proxy_alternate_content_sources, :class_name => 'Katello::Repository'
+
+    def backend_service
+      @service ||= ::Katello::Pulp3::AlternateContentSource.new(alternate_content_source, smart_proxy, repository)
+    end
   end
 end

data/app/models/katello/task_status.rb

@@ -97,14 +97,6 @@ module Katello
       self
     end
 
-    def merge_pulp_task!(pulp_task)
-      PulpTaskStatus.dump_state(pulp_task, self)
-    end
-
-    def refresh_pulp
-      PulpTaskStatus.refresh(self)
-    end
-
     def human_readable_message
       task_template = TaskStatus::TYPES[self.task_type]
       return '' if task_template.nil?
@@ -276,16 +268,6 @@ module Katello
       end
     end
 
-    def self.refresh(ids)
-      unless ids.blank?
-        uuids = TaskStatus.where(:id => ids).pluck(:uuid)
-        ret = Katello.pulp_server.resources.task.poll_all(uuids)
-        ret.each do |pulp_task|
-          PulpTaskStatus.dump_state(pulp_task, TaskStatus.find_by(:uuid => pulp_task[:task_id]))
-        end
-      end
-    end
-
     protected
 
     def setup_task_type

data/app/overrides/add_smart_proxy_form.rb

@@ -12,3 +12,8 @@ Deface::Override.new(:virtual_path => "smart_proxies/_form",
                      :name => "add_smart_proxies_download_policy",
                      :insert_bottom => '#primary',
                      :partial => 'overrides/smart_proxies/download_policy')
+
+Deface::Override.new(:virtual_path => "smart_proxies/_form",
+                     :name => "add_smart_proxies_acs_http_proxy",
+                     :insert_bottom => '#primary',
+                     :partial => 'overrides/smart_proxies/acs_http_proxy')

data/app/presenters/katello/content_view_version_compare_presenter.rb

@@ -13,6 +13,11 @@ module Katello
       item_repos.map(&:content_view_version_id) & @versions.map(&:id)
     end
 
+    def comparison_repositories
+      repo = @item
+      @versions.map(&:id) & repo&.published_in_versions&.pluck(:id)
+    end
+
     def respond_to?(method)
       return method.to_s == 'comparison' || @item.respond_to?(method)
     end

data/app/presenters/katello/host_package_presenter.rb

@@ -1,10 +1,10 @@
 module Katello
   class HostPackagePresenter < SimpleDelegator
-    attr_accessor :installed_package, :upgradable_version, :rpm_id
+    attr_accessor :installed_package, :upgradable_versions, :rpm_id
 
-    def initialize(installed_package, upgradable_version, rpm_id)
+    def initialize(installed_package, upgradable_versions, rpm_id)
       @installed_package = installed_package
-      @upgradable_version = upgradable_version
+      @upgradable_versions = upgradable_versions
       @rpm_id = rpm_id
       super(@installed_package)
     end
@@ -14,7 +14,7 @@ module Katello
       installed_packages_map = ::Katello::Rpm.where(nvra: packages.map(&:nvra)).select(:id, :name).group_by(&:name)
 
       packages.map do |p|
-        HostPackagePresenter.new(p, upgradable_packages_map[p.name]&.first&.nvra, installed_packages_map[p.name]&.first&.id)
+        HostPackagePresenter.new(p, upgradable_packages_map[p.name]&.pluck(:nvra), installed_packages_map[p.name]&.first&.id)
       end
     end
   end

data/app/services/cert/certs.rb

@@ -12,28 +12,20 @@ module Cert
       File.read(SETTINGS[:katello][:candlepin][:ca_cert_file])
     end
 
-    def self.ssl_client_cert(use_admin_as_cn_cert: false)
-      @ssl_client_cert ||= OpenSSL::X509::Certificate.new(File.read(ssl_client_cert_filename(use_admin_as_cn_cert: use_admin_as_cn_cert)))
+    def self.ssl_client_cert
+      @ssl_client_cert ||= OpenSSL::X509::Certificate.new(File.read(ssl_client_cert_filename))
     end
 
-    def self.ssl_client_cert_filename(use_admin_as_cn_cert: false)
-      if use_admin_as_cn_cert
-        Setting[:pulp_client_cert]
-      else
-        Setting[:ssl_certificate]
-      end
+    def self.ssl_client_cert_filename
+      Setting[:ssl_certificate]
     end
 
-    def self.ssl_client_key(use_admin_as_cn_cert: false)
-      @ssl_client_key ||= OpenSSL::PKey::RSA.new(File.read(ssl_client_key_filename(use_admin_as_cn_cert: use_admin_as_cn_cert)))
+    def self.ssl_client_key
+      @ssl_client_key ||= OpenSSL::PKey::RSA.new(File.read(ssl_client_key_filename))
     end
 
-    def self.ssl_client_key_filename(use_admin_as_cn_cert: false)
-      if use_admin_as_cn_cert
-        Setting[:pulp_client_key]
-      else
-        Setting[:ssl_priv_key]
-      end
+    def self.ssl_client_key_filename
+      Setting[:ssl_priv_key]
     end
 
     def self.verify_ueber_cert(organization)

data/app/services/katello/bulk_items_helper.rb

@@ -20,12 +20,12 @@ module Katello
       params[:excluded] ||= {}
 
       items = model_scope
-      if params[:included][:ids]
+      if params[:included][:ids].present?
         items = model_scope.where(key => params[:included][:ids])
-      elsif params[:included][:search]
+      elsif params[:included][:search].present?
         items = model_scope.search_for(params[:included][:search])
       end
-      if params[:excluded][:ids]
+      if params[:excluded][:ids].present?
         items = items.where.not(key => params[:excluded][:ids])
       end
 

data/app/services/katello/candlepin/consumer.rb

@@ -16,8 +16,8 @@ module Katello
       lazy_accessor :entitlements, :initializer => lambda { |_s| Resources::Candlepin::Consumer.entitlements(uuid) }
       lazy_accessor :consumer_attributes, :initializer => lambda { |_s| Resources::Candlepin::Consumer.get(uuid) }
       lazy_accessor :installed_products, :initializer => lambda { |_s| consumer_attributes['installedProducts'] }
-      lazy_accessor :available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(owner_label, uuid, false) }
-      lazy_accessor :all_available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(owner_label, uuid, true) }
+      lazy_accessor :available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(owner_label, uuid, listall: false) }
+      lazy_accessor :all_available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(owner_label, uuid, listall: true) }
       lazy_accessor :content_overrides, :initializer => (lambda do |_s|
                                                            Resources::Candlepin::Consumer.content_overrides(uuid).map do |override|
                                                              ::Katello::ContentOverride.from_entitlement_hash(override)

data/app/services/katello/host/package_profile_uploader.rb

@@ -29,7 +29,7 @@ module Katello
           Rails.logger.warn("Host with ID %s has no content facet; continuing" % host_id)
         else
           begin
-            simple_packages = profile.map { |item| ::Katello::Pulp::SimplePackage.new(item) }
+            simple_packages = profile.map { |item| ::Katello::SimplePackage.new(item) }
             host.import_package_profile(simple_packages)
           rescue ActiveRecord::InvalidForeignKey # this happens if the host gets deleted in between the "find_by" and "import_package_profile"
             Rails.logger.warn("Host installed package list with ID %s was not able to be written to the DB (host likely is deleted); continuing" % host_id)

data/app/services/katello/organization_creator.rb

@@ -27,15 +27,16 @@ module Katello
       end
     end
 
-    def initialize(organization)
+    def initialize(organization, sca: true)
       @organization = organization
+      @content_access_mode = sca ? 'org_environment' : 'entitlement'
     end
 
     def seed!
       ActiveRecord::Base.transaction do
         @organization.setup_label_from_name
 
-        # existing validation errors are not resolvable here, so don't validatate
+        # existing validation errors are not resolvable here, so don't validate
         @organization.save(validate: false)
 
         create_library_environment
@@ -66,9 +67,8 @@ module Katello
 
     def create_backend_objects!
       Katello::Ping.ping!(services: [:candlepin])
-
       if needs_candlepin_organization?
-        ::Katello::Resources::Candlepin::Owner.create(@organization.label, @organization.name)
+        ::Katello::Resources::Candlepin::Owner.create(@organization.label, @organization.name, content_access_mode: @content_access_mode)
       end
 
       ::Katello::ContentViewManager.create_candlepin_environment(

data/app/services/katello/product_content_finder.rb

@@ -2,9 +2,8 @@ module Katello
   class ProductContentFinder
     attr_accessor :match_environment, :match_subscription, :consumable
 
-    #consumable must implement:
-    #  content_view
-    #  lifecycle_environment
+    # consumable must implement:
+    #  content_view_environments
     #  organization
     #  products
     def initialize(params = {})
@@ -16,16 +15,20 @@ module Katello
 
     def product_content
       if match_environment
-        environment = consumable.lifecycle_environment
-        view = consumable.content_view
-        return ProductContent.none unless environment && view
-        version = ContentViewVersion.in_environment(environment).where(:content_view_id => view).first
+        if consumable.is_a?(::Katello::ActivationKey) # TODO: remove this when AKs are refactored for multi CV
+          environment = consumable.lifecycle_environment
+          view = consumable.content_view
+          return ProductContent.none unless environment && view
+          versions = ContentViewVersion.in_environment(environment).where(:content_view_id => view).first
+        else # consumable is a SubscriptionFacet
+          versions = consumable.content_view_environments.select(:content_view_version_id).map(&:content_view_version_id)
+        end
       end
 
       considered_products = match_subscription ? consumable.products : consumable.organization.products.enabled.uniq
 
       roots = Katello::RootRepository.where(:product_id => considered_products).subscribable
-      roots = roots.in_content_view_version(version) if version
+      roots = roots.in_content_view_version(versions) if versions.present?
 
       consumable.organization.enabled_product_content_for(roots)
     end

data/app/services/katello/product_content_importer.rb

@@ -22,32 +22,75 @@ module Katello
     # }
     attr_reader :content_url_updated
 
-    def initialize
+    def initialize(cp_products = [])
       @contents_to_create = []
       @product_contents_to_create = []
       @product_mapping = {}
       @content_url_updated = []
+      @cp_products = cp_products
     end
 
     def add_product_content(product, product_content_json)
       @product_mapping[product] = product_content_json.map(&:with_indifferent_access)
     end
 
+    def find_product_for_content(content_id)
+      prod = @cp_products.find do |prod_json|
+        prod_json['productContent'].any? do |product_content_json|
+          product_content_json["content"]["id"] == content_id
+        end
+      end
+      ::Katello::Product.find_by(cp_id: prod["id"]) if prod
+    end
+
+    def fetch_product_contents_to_move(product, prod_contents_json)
+      content_ids = prod_contents_json.map { |pc| pc[:content][:id] }
+      # Identify if there are any product_content that should not be
+      # part of this product.
+      product_contents_to_delete_or_move = product.
+                                      product_contents.
+                                      joins(:content).
+                                      where.not(content: { cp_content_id: content_ids })
+      # Identify if product content actually moved between 2 different products
+      product_contents_to_delete_or_move.select do |pc|
+        content_exists?(product.organization, pc.content)
+      end
+    end
+
+    def handle_product_moves(product, prod_contents_json)
+      product_contents_to_move = fetch_product_contents_to_move(product, prod_contents_json)
+      moved_product_contents = []
+      product_contents_to_move.each do |pc|
+        content = pc.content
+        root_repo = product.root_repositories.find_by(content_id: content.cp_content_id)
+        actual_product = find_product_for_content(content.cp_content_id)
+        if actual_product.present? && root_repo.present? && root_repo.product != actual_product
+          root_repo.update!(product_id: actual_product.id)
+          pc.update!(product_id: actual_product.id)
+          moved_product_contents << pc
+        else
+          pc.destroy!
+        end
+      end
+      product.reload unless product_contents_to_move.blank?
+
+      moved_product_contents
+    end
+
     def import
       return if @product_mapping.blank?
-
+      moved_product_contents = []
       @product_mapping.each do |product, prod_contents_json|
+        moved_product_contents += handle_product_moves(product, prod_contents_json)
         existing_product_contents = product.product_contents.to_a
-
         prod_contents_json.each do |prod_content_json|
           content = create_or_update_content(product, prod_content_json)
           existing_content_map[content.cp_content_id] = content if content.new_record?
           create_or_update_product_content(product, existing_product_contents, content, prod_content_json[:enabled])
         end
       end
-
       ::Katello::Content.import(@contents_to_create, recursive: true)
-      ::Katello::ProductContent.import(@product_contents_to_create)
+      ::Katello::ProductContent.import(fetch_product_contents_to_create(moved_product_contents))
     end
 
     private def existing_content_map
@@ -60,6 +103,19 @@ module Katello
       @existing_content_map
     end
 
+    private def content_exists?(org, content)
+      Resources::Candlepin::Content.get(org.label, content.cp_content_id)
+      true
+    rescue RestClient::NotFound
+      false
+    end
+
+    private def fetch_product_contents_to_create(moved_product_contents)
+      @product_contents_to_create.select do |pc|
+        moved_product_contents.none? { |mpc| mpc.content_id == pc.content_id && mpc.product_id == pc.product_id }
+      end
+    end
+
     private def create_or_update_content(product, prod_content_json)
       content = existing_content_map[prod_content_json[:content][:id].to_s]
       if content