katello 4.5.1 → 4.6.0.rc1

data/app/lib/katello/validators/alternate_content_source_products_validator.rb

@@ -0,0 +1,17 @@
+module Katello
+  module Validators
+    class AlternateContentSourceProductsValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if value
+          if attribute == :product_id
+            product = ::Katello::Product.find(value)
+            content_type = record.alternate_content_source.content_type
+            if product.repositories.with_type(content_type).has_url.empty?
+              record.errors[attribute] << N_("The product %{name} has no %{type} repositories with upstream URLs to add to the alternate content source.") % { name: product.name, type: content_type }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katello/alternate_content_source.rb

@@ -1,5 +1,7 @@
 module Katello
   class AlternateContentSource < Katello::Model
+    audited
+
     include Ext::LabelFromName
     include Encryptable
     include ::ScopedSearchExtensions
@@ -8,9 +10,9 @@ module Katello
 
     self.table_name = :katello_alternate_content_sources
 
-    # TODO: simplified, rhui
-    ACS_TYPES = %w(custom).freeze
+    ACS_TYPES = %w(custom simplified).freeze
     CONTENT_TYPES = [::Katello::Repository::YUM_TYPE, ::Katello::Repository::FILE_TYPE].freeze
+    AUDIT_REFRESH_ACTION = 'refresh'.freeze
 
     encrypts :upstream_password
 
@@ -18,18 +20,27 @@ module Katello
     belongs_to :ssl_client_cert, inverse_of: :ssl_client_alternate_content_sources, class_name: "Katello::ContentCredential"
     belongs_to :ssl_client_key, inverse_of: :ssl_key_alternate_content_sources, class_name: "Katello::ContentCredential"
     belongs_to :http_proxy, inverse_of: :alternate_content_sources
-    has_many :smart_proxy_alternate_content_sources, dependent: :destroy,
+
+    has_many :alternate_content_source_products, dependent: :delete_all, inverse_of: :alternate_content_source,
+             class_name: "Katello::AlternateContentSourceProduct"
+    has_many :products, through: :alternate_content_source_products, inverse_of: :alternate_content_sources,
+             class_name: "Katello::Product"
+
+    has_many :smart_proxy_alternate_content_sources, dependent: :delete_all,
              inverse_of: :alternate_content_source
-    has_many :smart_proxies, through: :smart_proxy_alternate_content_sources
+    has_many :smart_proxies, -> { distinct }, through: :smart_proxy_alternate_content_sources
 
+    validates :base_url, :subpaths, :verify_ssl, :upstream_username,
+              :upstream_password, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key, if: :simplified?, absence: true
     validates :base_url, if: :custom?, presence: true
+    validates :products, if: :custom?, absence: true
     validates :verify_ssl, if: :custom?, exclusion: [nil]
     validates :alternate_content_source_type, inclusion: {
       in: ->(_) { ACS_TYPES },
       allow_blank: false,
       message: ->(_, _) { _("is not a valid type. Must be one of the following: %s") % ACS_TYPES.join(',') }
     }
-    validates :content_type, if: :custom?, inclusion: {
+    validates :content_type, inclusion: {
       in: ->(_) { RepositoryTypeManager.defined_repository_types.keys & CONTENT_TYPES },
       allow_blank: false,
       message: ->(_, _) { _("is not allowed for ACS. Must be one of the following: %s") % (RepositoryTypeManager.defined_repository_types.keys & CONTENT_TYPES).join(',') }
@@ -44,16 +55,28 @@ module Katello
     scoped_search on: :content_type, complete_value: true
     scoped_search on: :alternate_content_source_type, complete_value: true
     scoped_search on: :upstream_username, complete_value: true
-    scoped_search on: :smart_proxy_id, relation: :smart_proxy_alternate_content_sources, validator: ScopedSearch::Validators::INTEGER, only_explicit: true
+    scoped_search on: :id, relation: :smart_proxies, rename: :smart_proxy_id, validator: ScopedSearch::Validators::INTEGER, only_explicit: true
+    scoped_search on: :name, relation: :smart_proxies, rename: :smart_proxy_name, complete_value: true
+    scoped_search on: :id, relation: :products, rename: :product_id, validator: ScopedSearch::Validators::INTEGER, only_explicit: true
+    scoped_search on: :name, relation: :products, rename: :product_name, complete_value: true
 
-    def backend_service(smart_proxy)
-      @service ||= ::Katello::Pulp3::AlternateContentSource.new(self, smart_proxy)
+    def backend_service(smart_proxy, repository = nil)
+      @service ||= ::Katello::Pulp3::AlternateContentSource.new(self, smart_proxy, repository)
     end
 
     def custom?
       alternate_content_source_type == 'custom'
     end
 
+    def simplified?
+      alternate_content_source_type == 'simplified'
+    end
+
+    def self.with_products(products)
+      products = [products] unless products.is_a?(Array)
+      joins(:alternate_content_source_products).where('katello_alternate_content_source_products.product_id in (:product_ids)', product_ids: products.pluck(:id))
+    end
+
     def self.with_type(content_type)
       where(content_type: content_type)
     end
@@ -67,5 +90,13 @@ module Katello
       @latest_dynflow_refresh_task ||= ForemanTasks::Task::DynflowTask.where(:label => Actions::Katello::AlternateContentSource::Refresh.name).
           for_resource(self).order(:started_at).last
     end
+
+    def audit_refresh
+      write_audit(action: AUDIT_REFRESH_ACTION, comment: _('Successfully refreshed.'), audited_changes: {})
+    end
+
+    def audit_updated_products(old_product_ids)
+      write_audit(action: 'update', comment: _('Products updated.'), audited_changes: { 'product_ids' => [old_product_ids, product_ids] })
+    end
   end
 end

data/app/models/katello/alternate_content_source_product.rb

@@ -0,0 +1,13 @@
+module Katello
+  class AlternateContentSourceProduct < Katello::Model
+    audited
+    # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
+    self.table_name = :katello_alternate_content_source_products
+    belongs_to :alternate_content_source, inverse_of: :alternate_content_source_products, class_name: 'Katello::AlternateContentSource'
+    belongs_to :product, inverse_of: :alternate_content_source_products, class_name: 'Katello::Product'
+    delegate :custom?, to: :alternate_content_source
+    delegate :simplified?, to: :alternate_content_source
+
+    validates_with Validators::AlternateContentSourceProductsValidator, :attributes => [:product_id], if: :simplified?
+  end
+end

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

@@ -204,7 +204,16 @@ module Katello
 
       def import_package_profile_in_bulk(simple_packages)
         nvreas = simple_packages.map { |sp| sp.nvrea }
-        found = InstalledPackage.where(:nvrea => nvreas).select(:id, :nvrea).to_a
+        found_nvrea = InstalledPackage.where(:nvrea => nvreas)
+        nil_vendor_installed_packages = found_nvrea.where(vendor: nil)
+        unless nil_vendor_installed_packages.blank?
+          packages_to_update = simple_packages.select { |sp| !sp.vendor.blank? && nil_vendor_installed_packages&.map(&:nvrea)&.include?(sp.nvrea) }
+          packages_to_update.each do |simple_package|
+            nil_vendor_installed_packages.where(nvrea: simple_package.nvrea).update(vendor: simple_package.vendor)
+          end
+        end
+
+        found = found_nvrea.select(:id, :nvrea).to_a
         found_nvreas = found.map(&:nvrea)
 
         new_packages = simple_packages.select { |sp| !found_nvreas.include?(sp.nvrea) }
@@ -217,7 +226,8 @@ module Katello
                                           :epoch => simple_package.epoch,
                                           :version => simple_package.version,
                                           :release => simple_package.release,
-                                          :arch => simple_package.arch)
+                                          :arch => simple_package.arch,
+                                          :vendor => simple_package.vendor)
         end
         InstalledPackage.import(installed_packages, validate: false, on_duplicate_key_ignore: true)
         #re-lookup all imported to pickup any duplicates/conflicts

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

@@ -156,8 +156,8 @@ module Katello
         end
 
         self.joins(repository_association_units).
-            where(repository_association_class.table_name => {:repository_id => facet_repos,
-                                                              content_unit_association_id => facet_content_units}).distinct
+          where(repository_association_class.table_name => { :repository_id => facet_repos,
+                                                             content_unit_association_id => facet_content_units }).distinct
       end
 
       def with_identifiers(ids)

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

@@ -57,6 +57,7 @@ module Katello
         has_many :hostgroup_content_facets, :class_name => "::Katello::Hostgroup::ContentFacet", :foreign_key => :content_source_id,
                               :inverse_of => :content_source, :dependent => :nullify
         has_many :hostgroups, :class_name => "::Hostgroup", :through => :hostgroup_content_facets
+        has_many :smart_proxy_alternate_content_sources, :class_name => "::Katello::SmartProxyAlternateContentSource", :inverse_of => :smart_proxy, :dependent => :delete_all
 
         validates :download_policy, inclusion: {
           :in => DOWNLOAD_POLICIES,
@@ -188,14 +189,12 @@ module Katello
       end
 
       def pulp3_ssl_configuration(config, connection_adapter = Faraday.default_adapter)
-        legacy_pulp_cert = !self.setting(PULP3_FEATURE, 'client_authentication')&.include?('client_certificate')
-
         if connection_adapter == :excon
-          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert_filename(use_admin_as_cn_cert: legacy_pulp_cert)
-          config.ssl_client_key = ::Cert::Certs.ssl_client_key_filename(use_admin_as_cn_cert: legacy_pulp_cert)
+          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert_filename
+          config.ssl_client_key = ::Cert::Certs.ssl_client_key_filename
         elsif connection_adapter == :net_http
-          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert(use_admin_as_cn_cert: legacy_pulp_cert)
-          config.ssl_client_key = ::Cert::Certs.ssl_client_key(use_admin_as_cn_cert: legacy_pulp_cert)
+          config.ssl_client_cert = ::Cert::Certs.ssl_client_cert
+          config.ssl_client_key = ::Cert::Certs.ssl_client_key
         else
           fail "Unexpected connection_adapter #{Faraday.default_adapter}!  Cannot continue, this is likely a bug."
         end

data/app/models/katello/content_view.rb

@@ -204,6 +204,10 @@ module Katello
         new_view.filters << new_filter
 
         case filter.type
+        when ContentViewDebFilter.name
+          filter.deb_rules.each do |rule|
+            new_filter.deb_rules << rule.dup
+          end
         when ContentViewPackageFilter.name
           filter.package_rules.each do |rule|
             new_filter.package_rules << rule.dup

data/app/models/katello/content_view_deb_filter.rb

@@ -0,0 +1,51 @@
+module Katello
+  class ContentViewDebFilter < ContentViewFilter
+    CONTENT_TYPE = Deb::CONTENT_TYPE
+
+    has_many :deb_rules, :dependent => :destroy, :foreign_key => :content_view_filter_id,
+                                   :class_name => "Katello::ContentViewDebFilterRule"
+    validates_lengths_from_database
+
+    def generate_clauses(repo)
+      package_filenames = []
+
+      self.deb_rules.each do |rule|
+        package_filenames.concat(query_debs(repo, rule))
+      end
+
+      ContentViewDebFilter.generate_deb_clauses(package_filenames)
+    end
+
+    def content_unit_pulp_ids(repo)
+      deb_filenames = []
+      self.deb_rules.each do |rule|
+        deb_filenames.concat(query_debs(repo, rule))
+      end
+      debs = Deb.in_repositories(repo)
+      debs.where(filename: deb_filenames).pluck(:pulp_id).flatten.uniq
+    end
+
+    def self.generate_deb_clauses(package_filenames = [])
+      { 'filename' => { "$in" => package_filenames } } unless package_filenames.empty?
+    end
+
+    def applicable_debs
+      Deb.in_repositories(self.applicable_repos)
+    end
+
+    def query_debs(repo, rule)
+      debs = Deb.in_repositories(repo)
+      query_debs_from_collection(debs, rule).pluck("#{Deb.table_name}.filename")
+    end
+
+    def query_debs_from_collection(collection, rule)
+      query_name = rule.name.tr("*", "%")
+      query = collection.where("#{Deb.table_name}.name ilike ?", query_name)
+      if rule.architecture.present?
+        query_arch = rule.architecture.tr("*", "%")
+        query = query.where("#{Deb.table_name}.architecture ilike ?", query_arch)
+      end
+      query.default_sort
+    end
+  end
+end

data/app/models/katello/content_view_deb_filter_rule.rb

@@ -0,0 +1,24 @@
+module Katello
+  class ContentViewDebFilterRule < Katello::Model
+    include ::Katello::Concerns::ContentViewFilterRuleCommon
+
+    belongs_to :filter,
+               :class_name => "Katello::ContentViewDebFilter",
+               :inverse_of => :deb_rules,
+               :foreign_key => :content_view_filter_id
+
+    validates :name, :presence => true
+    validate :ensure_unique_attributes
+    validates_with Validators::ContentViewFilterVersionValidator
+
+    def ensure_unique_attributes
+      other = self.class.where(:name => self.name,
+                               :content_view_filter_id => self.content_view_filter_id,
+                               :architecture => self.architecture)
+      other = other.where.not(:id => self.id) if self.id
+      if other.exists?
+        errors.add(:base, "This deb package filter rule already exists.")
+      end
+    end
+  end
+end

data/app/models/katello/content_view_filter.rb

@@ -9,7 +9,7 @@ module Katello
     MODULE_STREAM   = ModuleStream::CONTENT_TYPE
     DEB             = Deb::CONTENT_TYPE
     CONTENT_TYPES   = [RPM, PACKAGE_GROUP, ERRATA, DOCKER, DEB, MODULE_STREAM].freeze
-    CONTENT_OPTIONS = { _('Packages') => RPM, _('Module Streams') => ModuleStream, _('Package Groups') => PACKAGE_GROUP, _('Errata') => ERRATA, _('Container Images') => DOCKER, _('deb Packages') => DEB }.freeze
+    CONTENT_OPTIONS = { _('Packages') => RPM, _('Module Streams') => ModuleStream, _('Package Groups') => PACKAGE_GROUP, _('Errata') => ERRATA, _('Container Images') => DOCKER, _('Deb Packages') => DEB }.freeze
 
     belongs_to :content_view,
                :class_name => "Katello::ContentView",
@@ -31,6 +31,7 @@ module Katello
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :type, :rename => :content_type,
                   :complete_value => {Rpm::CONTENT_TYPE.to_sym => "Katello::ContentViewPackageFilter",
+                                      Deb::CONTENT_TYPE.to_sym => "Katello::ContentViewDebFilter",
                                       PackageGroup::CONTENT_TYPE.to_sym => "Katello::ContentViewPackageGroupFilter",
                                       Erratum::CONTENT_TYPE.to_sym => "Katello::ContentViewErratumFilter",
                                       DOCKER.to_sym => "Katello::ContentViewDockerFilter",
@@ -47,8 +48,7 @@ module Katello
     end
 
     def self.deb
-      # TODO
-      []
+      where(:type => ::Katello::ContentViewDebFilter.name)
     end
 
     def self.docker
@@ -69,6 +69,7 @@ module Katello
 
     def content_type
       {
+        ContentViewDebFilter => DEB,
         ContentViewPackageFilter => RPM,
         ContentViewErratumFilter => ERRATA,
         ContentViewPackageGroupFilter => PACKAGE_GROUP,
@@ -79,6 +80,8 @@ module Katello
 
     def self.class_for(content_type)
       case content_type
+      when DEB
+        ContentViewDebFilter
       when RPM
         ContentViewPackageFilter
       when PACKAGE_GROUP
@@ -97,6 +100,8 @@ module Katello
 
     def self.rule_class_for(filter)
       case filter.type
+      when ContentViewDebFilter.name
+        ContentViewDebFilterRule
       when ContentViewPackageFilter.name
         ContentViewPackageFilterRule
       when ContentViewPackageGroupFilter.name
@@ -115,6 +120,8 @@ module Katello
 
     def self.rule_ids_for(filter)
       case filter.type
+      when ContentViewDebFilter.name
+        filter.deb_rule_ids
       when ContentViewPackageFilter.name
         filter.package_rule_ids
       when ContentViewPackageGroupFilter.name

data/app/models/katello/glue/candlepin/owner.rb

@@ -30,7 +30,6 @@ module Katello
       def owner_details
         @owner_details ||= find_owner
         @owner_details['virt_who'] ||= self.subscriptions.using_virt_who.any?
-
         @owner_details
       end
 

data/app/models/katello/installed_package.rb

@@ -23,5 +23,6 @@ module Katello
     scoped_search :on => :version
     scoped_search :on => :release
     scoped_search :on => :arch
+    scoped_search :on => :vendor, :complete_value => true
   end
 end

data/app/models/katello/product.rb

@@ -28,6 +28,9 @@ 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
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name

data/app/models/katello/repository.rb

@@ -110,6 +110,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.") %

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/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/content_unit_indexer.rb

@@ -22,6 +22,7 @@ module Katello
     end
 
     def import_all(filtered_indexing = false)
+      additive = filtered_indexing || (@repository&.mirroring_policy == 'additive')
       association_tracker = RepoAssociationTracker.new(@content_type, @service_class, @repository)
       units_from_pulp.each do |units|
         units.each do |unit|
@@ -51,7 +52,7 @@ module Katello
       end
 
       if @model_class.many_repository_associations && @repository
-        sync_repository_associations(association_tracker, additive: filtered_indexing)
+        sync_repository_associations(association_tracker, additive: additive)
       end
     end
 

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/pulp/server.rb

@@ -17,8 +17,8 @@ module Katello
             :debug => true
           },
           :cert_auth => {
-            :ssl_client_cert => ::Cert::Certs.ssl_client_cert(use_admin_as_cn_pulp_cert: true),
-            :ssl_client_key => ::Cert::Certs.ssl_client_key(use_admin_as_cn_pulp_cert: true)
+            :ssl_client_cert => '/etc/pki/katello/certs/pulp-client.crt',
+            :ssl_client_key => '/etc/pki/katello/private/pulp-client.key'
           }
         }
 

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

@@ -5,10 +5,12 @@ module Katello
       include Katello::Pulp3::ServiceCommon
       attr_accessor :acs
       attr_accessor :smart_proxy
+      attr_accessor :repository
 
-      def initialize(acs, smart_proxy)
+      def initialize(acs, smart_proxy, repository = nil)
         @acs = acs
         @smart_proxy = smart_proxy
+        @repository = repository
       end
 
       def api
@@ -20,10 +22,23 @@ module Katello
       end
 
       def smart_proxy_acs
-        ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
+        if acs.alternate_content_source_type == 'custom'
+          ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
+        else
+          ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repository.id)
+        end
       end
 
       def remote_options
+        if repository.present?
+          options = repository.backend_service(smart_proxy).remote_options
+          options[:policy] = 'on_demand'
+          options[:proxy_url] = acs.http_proxy&.url
+          options[:proxy_username] = acs.http_proxy&.username
+          options[:proxy_password] = acs.http_proxy&.password
+          return options
+        end
+
         remote_options = {
           tls_validation: acs.verify_ssl,
           name: generate_backend_object_name,
@@ -66,8 +81,11 @@ module Katello
         api.remotes_api.partial_update(smart_proxy_acs.remote_href, remote_options)
       end
 
-      def delete_remote(href = smart_proxy_acs.remote_href)
-        ignore_404_exception { remote_options[:url]&.start_with?('uln') ? api.remotes_uln_api.delete(href) : api.remotes_api.delete(href) } if href
+      # The old repo URL is needed to determine which remote API to use.
+      def delete_remote(options = {})
+        options[:href] ||= smart_proxy_acs.remote_href
+        options[:old_url] ||= remote_options[:url]
+        ignore_404_exception { options[:old_url]&.start_with?('uln') ? api.remotes_uln_api.delete(options[:href]) : api.remotes_api.delete(options[:href]) } if options[:href]
       end
 
       def create

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

@@ -11,6 +11,18 @@ module Katello
         def publications_verbatim_api
           PulpDebClient::PublicationsVerbatimApi.new(api_client)
         end
+
+        def self.copy_class
+          PulpDebClient::Copy
+        end
+
+        def self.add_remove_content_class
+          PulpDebClient::RepositoryAddRemoveContent
+        end
+
+        def copy_api
+          PulpDebClient::CopyApi.new(api_client)
+        end
       end
     end
   end

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

@@ -55,15 +55,12 @@ module Katello
           bugzillas += build_bugzillas(katello_id, unit['references'])
           cves += build_cves(katello_id, unit['references'])
           packages += build_packages(katello_id, unit['pkglist'])
+          modules += build_modules(katello_id, unit['pkglist'])
         end
 
         Katello::ErratumBugzilla.insert_all(bugzillas, unique_by: [:erratum_id, :bug_id, :href]) if bugzillas.any?
         Katello::ErratumCve.insert_all(cves, unique_by: [:erratum_id, :cve_id, :href]) if cves.any?
         Katello::ErratumPackage.insert_all(packages, unique_by: [:erratum_id, :nvrea, :name, :filename]) if packages.any?
-        units.each do |unit|
-          katello_id = pulp_id_to_id[unit['id']]
-          modules += build_modules(katello_id, unit['pkglist'])
-        end
         ModuleStreamErratumPackage.insert_all(modules, unique_by: [:module_stream_id, :erratum_package_id]) if modules.any?
         nil
       end