katello 4.5.1 → 4.8.0.rc2

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

@@ -8,6 +8,7 @@ module Actions
         def plan(version, environments, is_force = false, description = nil, incremental_update = false)
           action_subject(version.content_view)
           version.check_ready_to_promote!(environments)
+          ::Katello::Util::CandlepinRepositoryChecker.check_repositories_for_promote!(version)
 
           fail ::Katello::HttpErrors::BadRequest, _("Cannot promote environment out of sequence. Use force to bypass restriction.") if !is_force && !version.promotable?(environments)
 

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

@@ -9,10 +9,13 @@ module Actions
         execution_plan_hooks.use :trigger_capsule_sync, :on => :success
 
         # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
-        def plan(content_view, description = "", options = {importing: false}) # rubocop:disable Metrics/PerceivedComplexity
+        def plan(content_view, description = "", options = {importing: false, syncable: false}) # rubocop:disable Metrics/PerceivedComplexity
           action_subject(content_view)
 
-          content_view.check_ready_to_publish!(importing: options[:importing])
+          content_view.check_ready_to_publish!(options.slice(:importing, :syncable))
+          unless options[:importing] || options[:syncable]
+            ::Katello::Util::CandlepinRepositoryChecker.check_repositories_for_publish!(content_view)
+          end
 
           if options[:repos_units].present?
             valid_labels_from_cv = content_view.repositories.map(&:label)
@@ -109,8 +112,12 @@ module Actions
           version.update_content_counts!
           # update errata applicability counts for all hosts in the CV & Library
           unless input[:skip_promotion]
-            ::Katello::Host::ContentFacet.where(:content_view_id => input[:content_view_id],
-                                                :lifecycle_environment_id => input[:environment_id]).each do |facet|
+            content_view = ::Katello::ContentView.find(input[:content_view_id])
+            lifecycle_environment = ::Katello::KTEnvironment.find(input[:environment_id])
+            ::Katello::Host::ContentFacet.in_content_views_and_environments(
+              content_views: [content_view],
+              lifecycle_environments: [lifecycle_environment]
+            ).each do |facet|
               facet.update_applicability_counts
               facet.update_errata_status
             end

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

@@ -71,12 +71,18 @@ module Actions
                       content_view_history_ids: cv_histories.map { |history| history.id })
 
             if organization_destroy
-              content_view.hostgroups.destroy_all
-              content_view.hosts.destroy_all
+              destroy_host_and_hostgroup_associations(content_view: content_view)
             end
           end
         end
 
+        def destroy_host_and_hostgroup_associations(content_view:)
+          content_view.hostgroups.destroy_all
+          host_ids = content_view.hosts.ids
+          ::Katello::Host::ContentFacet.where(:host_id => host_ids).destroy_all
+          ::Katello::Host::SubscriptionFacet.where(:host_id => host_ids).destroy_all
+        end
+
         def check_version_deletion(versions, cv_envs)
           versions.each do |version|
             version.environments.each do |env|

data/app/lib/actions/katello/content_view_version/auto_create_redhat_repositories.rb

@@ -2,16 +2,20 @@ module Actions
   module Katello
     module ContentViewVersion
       class AutoCreateRedhatRepositories < Actions::Base
-        def plan(import:)
+        def plan(import:, path:)
           helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.new(
             organization: import.organization,
-            metadata_repositories: import.metadata_map.repositories.select { |r| r.redhat }
+            metadata_repositories: import.metadata_map.repositories.select { |r| r.redhat },
+            syncable_format: import.metadata_map.syncable_format?,
+            path: path
           )
           helper.generate!
 
           sequence do
             helper.creatable.each do |root|
-              plan_action(::Actions::Katello::RepositorySet::EnableRepository, root[:product], root[:content], root[:substitutions])
+              plan_action(::Actions::Katello::RepositorySet::EnableRepository,
+                            root[:product], root[:content], root[:substitutions],
+                            override_url: root[:override_url])
             end
             helper.updatable.each do |root|
               plan_action(::Actions::Katello::Repository::Update, root[:repository], root[:options])

data/app/lib/actions/katello/content_view_version/auto_create_repositories.rb

@@ -2,10 +2,12 @@ module Actions
   module Katello
     module ContentViewVersion
       class AutoCreateRepositories < Actions::Base
-        def plan(import:)
+        def plan(import:, path:)
           helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.new(
             organization: import.organization,
-            metadata_repositories: import.metadata_map.repositories.select { |r| !r.redhat }
+            metadata_repositories: import.metadata_map.repositories.select { |r| !r.redhat },
+            syncable_format: import.metadata_map.syncable_format?,
+            path: path
           )
           helper.generate!
 

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

@@ -3,7 +3,7 @@ module Actions
     module ContentViewVersion
       class Destroy < Actions::Base
         def plan(version, options = {})
-          version.validate_destroyable!(options[:skip_environment_check])
+          version.validate_destroyable!(skip_environment_check: options[:skip_environment_check])
 
           destroy_env_content = !options.fetch(:skip_destroy_env_content, false)
           repos = destroy_env_content ? version.repositories : version.archived_repos

data/app/lib/actions/katello/content_view_version/import.rb

@@ -21,16 +21,28 @@ module Actions
 
           sequence do
             plan_action(AutoCreateProducts, import: import)
-            plan_action(AutoCreateRepositories, import: import)
-            plan_action(AutoCreateRedhatRepositories, import: import)
-            plan_action(ResetContentViewRepositoriesFromMetadata, import: import)
-            plan_action(::Actions::Katello::ContentView::Publish, import.content_view, metadata_map.content_view_version.description,
-                          path: path,
-                          metadata: metadata,
-                          importing: true,
-                          major: metadata_map.content_view_version.major,
-                          minor: metadata_map.content_view_version.minor)
-            plan_self(content_view_id: import.content_view.id)
+            plan_action(AutoCreateRepositories, import: import, path: path)
+            plan_action(AutoCreateRedhatRepositories, import: import, path: path)
+
+            if metadata_map.syncable_format?
+              plan_action(::Actions::BulkAction,
+                    ::Actions::Katello::Repository::Sync,
+                    import.intersecting_repos_library_and_metadata.exportable(format: metadata_map.format),
+                    skip_candlepin_check: true
+                    )
+            end
+
+            if import.content_view
+              plan_action(ResetContentViewRepositoriesFromMetadata, import: import)
+              plan_action(::Actions::Katello::ContentView::Publish, import.content_view, metadata_map.content_view_version.description,
+                            path: path,
+                            metadata: metadata,
+                            importing: !metadata_map.syncable_format?,
+                            syncable: metadata_map.syncable_format?,
+                            major: metadata_map.content_view_version.major,
+                            minor: metadata_map.content_view_version.minor)
+              plan_self(content_view_id: import.content_view.id)
+            end
           end
         end
 

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

@@ -24,14 +24,20 @@ module Actions
             end
 
             if organization_destroy
-              env.hostgroups.clear
-              env.hosts.clear
+              delete_host_and_hostgroup_associations(environment: env)
             end
 
             plan_self
           end
         end
 
+        def delete_host_and_hostgroup_associations(environment:)
+          environment.hostgroups.delete_all
+          host_ids = environment.hosts.ids
+          ::Katello::Host::ContentFacet.where(:host_id => host_ids).delete_all
+          ::Katello::Host::SubscriptionFacet.where(:host_id => host_ids).delete_all
+        end
+
         def humanized_name
           _("Delete Lifecycle Environment")
         end

data/app/lib/actions/katello/host/reassign.rb

@@ -3,8 +3,10 @@ module Actions
     module Host
       class Reassign < Actions::Base
         def plan(host, content_view_id, environment_id)
-          host.content_facet.content_view = ::Katello::ContentView.find(content_view_id)
-          host.content_facet.lifecycle_environment = ::Katello::KTEnvironment.find(environment_id)
+          host.content_facet.assign_single_environment(
+            content_view: ::Katello::ContentView.find(content_view_id),
+            lifecycle_environment: ::Katello::KTEnvironment.find(environment_id)
+          )
           host.update_candlepin_associations
         end
       end

data/app/lib/actions/katello/organization/manifest_refresh.rb

@@ -14,18 +14,28 @@ module Actions
           upstream = details['upstreamConsumer'].blank? ? {} : details['upstreamConsumer']
 
           sequence do
+            plan_self(
+              :organization_id => organization.id,
+              :organization_name => organization.name
+            )
             upstream_update = plan_action(Candlepin::Owner::UpstreamUpdate,
                         :organization_id => organization.id,
                         :upstream => upstream)
-            export_action = plan_action(Candlepin::Owner::UpstreamExport,
+            export_action = plan_action(Candlepin::Owner::StartUpstreamExport,
                         :organization_id => organization.id,
                         :upstream => upstream,
                         :path => path,
                         :dependency => upstream_update.output)
+            retrieved_export = plan_action(Candlepin::Owner::RetrieveUpstreamExport,
+                        :export_id => export_action.output[:task]['resultData']['exportId'],
+                        :organization_id => organization.id,
+                        :upstream => upstream,
+                        :path => path,
+                        :dependency => export_action.output)
             owner_import = plan_action(Candlepin::Owner::Import,
                         :label => organization.label,
                         :path => path,
-                        :dependency => export_action.output)
+                        :dependency => retrieved_export.output)
             import_products = plan_action(Candlepin::Owner::ImportProducts,
               :organization_id => organization.id,
               :dependency => owner_import.output)
@@ -34,20 +44,19 @@ module Actions
             if manifest_update
               plan_refresh_repos(import_products, organization)
             end
-
-            plan_self(
-              :organization_id => organization.id,
-              :organization_name => organization.name
-            )
           end
         end
 
         def plan_refresh_repos(import_products_action, org)
           repositories = ::Katello::Repository.in_default_view.in_product(::Katello::Product.redhat.in_org(org))
-          repositories.each do |repo|
-            plan_action(Katello::Repository::RefreshRepository,
-              repo,
-              :dependency => import_products_action.output)
+          repositories.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
+            concurrence do
+              repo_batch.each do |repo|
+                plan_action(Katello::Repository::RefreshRepository,
+                  repo,
+                  :dependency => import_products_action.output)
+              end
+            end
           end
         end
 

data/app/lib/actions/katello/organization/simple_content_access/toggle.rb

@@ -14,15 +14,7 @@ module Actions
           def plan(organization_id)
             @organization = ::Organization.find(organization_id)
             action_subject organization
-            ::Katello::Resources::Candlepin::UpstreamConsumer.update(
-              "#{consumer['apiUrl']}#{consumer['uuid']}",
-              consumer['idCert']['cert'],
-              consumer['idCert']['key'],
-              nil,
-              {contentAccessMode: content_access_mode_value}
-            )
-
-            plan_action(::Actions::Katello::Organization::ManifestRefresh, organization)
+            ::Katello::Resources::Candlepin::Owner.update(@organization.label, contentAccessMode: content_access_mode_value)
           end
 
           def failure_notification(plan)

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

@@ -7,7 +7,6 @@ module Actions
         end
         def plan(proxy)
           sequence do
-            plan_action(Actions::Pulp::Orchestration::OrphanCleanup::RemoveOrphans, proxy) if (proxy.has_feature?(SmartProxy::PULP_FEATURE) || proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE))
             if proxy.pulp3_enabled?
               plan_action(
                 Actions::Pulp3::Orchestration::OrphanCleanup::RemoveOrphans,

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

@@ -11,7 +11,7 @@ module Actions
           unless organization_destroy || product.user_deletable?
             if product.redhat?
               fail _("Cannot delete Red Hat product: %{product}") % { :product => product.name }
-            elsif !product.published_content_view_versions.empty?
+            elsif !product.published_content_view_versions.not_ignorable.empty?
               fail _("Cannot delete product with repositories published in a content view.  Product: %{product}, %{view_versions}") %
                        { :product => product.name, :view_versions => view_versions(product) }
             end
@@ -46,8 +46,9 @@ module Actions
                               product_id: product.cp_id,
                               content_id: pc.content.cp_content_id)
                 end
-                plan_action(Candlepin::Product::Destroy, cp_id: product.cp_id, :owner => product.organization.label)
               end
+
+              plan_action(Candlepin::Product::Destroy, cp_id: product.cp_id, :owner => product.organization.label)
             end
 
             clear_pool_associations(product)

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

@@ -2,6 +2,7 @@ module Actions
   module Katello
     module Repository
       class Create < Actions::EntryAction
+        # rubocop:disable Metrics/MethodLength
         def plan(repository, args = {})
           clone = args[:clone] || false
           force_repo_create = args[:force_repo_create] || false
@@ -33,6 +34,14 @@ module Actions
 
             concurrence do
               plan_self(:repository_id => repository.id, :clone => clone)
+              if !clone && repository.url.present?
+                repository.product.alternate_content_sources.with_type(repository.content_type).each do |acs|
+                  acs.smart_proxies.each do |smart_proxy|
+                    smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repository.id)
+                    plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+                  end
+                end
+              end
             end
           end
         end

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

@@ -23,7 +23,9 @@ module Actions
                            repository,
                            SmartProxy.pulp_primary)
 
-          remove_versions(repository, repository.content_views.generated_for_none, affected_cvv_ids) if remove_from_content_view_versions
+          remove_versions(repository, repository.content_views_all(include_composite: true)&.generated_for_none, affected_cvv_ids) if remove_from_content_view_versions
+
+          handle_alternate_content_sources(repository)
 
           plan_self(:user_id => ::User.current.id, :affected_cvv_ids => affected_cvv_ids)
           sequence do
@@ -52,6 +54,25 @@ module Actions
           end
         end
 
+        def handle_alternate_content_sources(repository)
+          product = repository.product
+          content_type = repository.content_type
+          repository.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+            plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
+          end
+
+          # Remove the product from the ACS if it's empty.
+          # An ACS with only an empty product will not function correctly
+          ## because there will be no smart_proxy_alternate_content_sources.
+          if product.repositories.with_type(content_type).count == 1
+            ::Katello::AlternateContentSource.with_products(product).each do |acs|
+              acs.products = acs.products - [product]
+              Rails.logger.info _('Removing product %{prod_name} with ID %{prod_id} from ACS %{acs_name} with ID %{acs_id}') %
+                { prod_name: product.name, prod_id: product.id, acs_name: acs.name, acs_id: acs.id }
+            end
+          end
+        end
+
         def handle_custom_content(repository, remove_from_content_view_versions)
           #if this is the last instance of a custom repo, destroy the content
           if remove_from_content_view_versions || repository.root.repositories.where.not(id: repository.id).empty?
@@ -84,12 +105,12 @@ module Actions
 
         def remove_versions(repository, content_views, affected_cvv_ids)
           return if content_views.blank?
-
           interested_inverses = repository.
                                   library_instances_inverse.
                                   joins(:content_view_version => :content_view).
                                   merge(content_views)
-          affected_cvv_ids.concat(interested_inverses.pluck(:content_view_version_id).uniq)
+          return if interested_inverses.blank?
+          affected_cvv_ids.concat(interested_inverses.pluck(:content_view_version_id)&.uniq)
           plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::Destroy, interested_inverses)
         end
 

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

@@ -2,18 +2,21 @@ module Actions
   module Katello
     module Repository
       class ErrataMail < Actions::EntryAction
-        middleware.use Actions::Middleware::ExecuteIfContentsChanged
-
-        def plan(repo, contents_changed = nil)
-          plan_self(:repo => repo.id, :contents_changed => contents_changed)
+        def plan(repo)
+          plan_self(:repo => repo.id, :associated_errata_before_syncing => repo.repository_errata.pluck(:erratum_id).uniq.sort.reverse, :new_associated_errata => [])
         end
 
         def run
           ::User.current = ::User.anonymous_admin
           repo = ::Katello::Repository.find(input[:repo])
-          last_updated = repo.repository_errata.order('updated_at ASC').last.try(:updated_at) || Time.now
+          input[:new_associated_errata] = repo.repository_errata.pluck(:erratum_id).uniq.sort.reverse - input[:associated_errata_before_syncing]
+
           users = ::User.select { |user| user.receives?(:sync_errata) && user.organization_ids.include?(repo.organization.id) && user.can?(:view_products, repo.product) }.compact
-          errata = ::Katello::Erratum.where(:id => repo.repository_errata.where('katello_repository_errata.updated_at > ?', last_updated).pluck(:erratum_id))
+          errata = ::Katello::Erratum.where(:id => input[:new_associated_errata])
+
+          [:associated_errata_before_syncing, :new_associated_errata].each do |key|
+            input[key] = "Trimmed list... (#{input[key].length} #{key.to_s.gsub('_', ' ')})" if input[key].length > 3
+          end
 
           begin
             MailNotification[:sync_errata].deliver(:users => users, :repo => repo, :errata => errata) unless (users.blank? || errata.blank?)

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

@@ -34,7 +34,7 @@ module Actions
               input[:upload_actions].each { |action| uploaded_content_unit_hrefs << action.try(:[], "content_unit_href") }
               unit_ids = uploaded_content_unit_hrefs.compact
             else
-              unit_ids = search_units(repo)
+              unit_ids = []
             end
             ::Katello::Deb.import_all(unit_ids, repo, {filtered_indexing: true})
           elsif repo.yum?
@@ -45,7 +45,7 @@ module Actions
               input[:upload_actions].each { |action| uploaded_content_unit_hrefs << action.try(:[], "content_unit_href") }
               unit_ids = uploaded_content_unit_hrefs.compact
             else
-              unit_ids = search_units(repo)
+              unit_ids = []
             end
             if input[:content_type] == ::Katello::Srpm::CONTENT_TYPE
               ::Katello::Srpm.import_all(unit_ids, repo, {filtered_indexing: true})
@@ -54,14 +54,6 @@ module Actions
             end
           end
         end
-
-        private
-
-        def search_units(repo)
-          found = repo.unit_search(:type_ids => [input[:content_type]],
-                                   :filters => input[:filter])
-          found.map { |result| result.try(:[], :unit_id) }.compact
-        end
       end
     end
   end

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

@@ -3,7 +3,6 @@ module Actions
   module Katello
     module Repository
       class ImportUpload < Actions::EntryAction
-        include Actions::Katello::PulpSelector
         # rubocop:disable Metrics/MethodLength
         def plan(repository, uploads, options = {})
           action_subject(repository)

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

@@ -7,6 +7,9 @@ module Actions
             repo = ::Katello::Repository.find(repo.id)
             plan_action(Actions::Pulp3::Orchestration::Repository::RefreshIfNeeded,
                              repo, SmartProxy.default_capsule!, :dependency => options[:dependency])
+            repo.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(::Actions::Pulp3::AlternateContentSource::RefreshRemote, smart_proxy_acs)
+            end
             plan_self(:name => repo.name, :dependency => options[:dependency])
           end
         end

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

@@ -16,25 +16,25 @@ module Actions
         # @param repo
         # @param pulp_sync_task_id in case the sync was triggered outside
         #   of Katello and we just need to finish the rest of the orchestration
-        # rubocop:disable Metrics/MethodLength
-        # rubocop:disable Metrics/CyclomaticComplexity
         def plan(repo, options = {})
           action_subject(repo)
 
           source_url = options.fetch(:source_url, nil)
           validate_contents = options.fetch(:validate_contents, false)
-          skip_metadata_check = options.fetch(:skip_metadata_check, false) || (validate_contents && repo.yum?)
+          skip_metadata_check = options.fetch(:skip_metadata_check, false) || (validate_contents && (repo.yum? || repo.deb?))
           generate_applicability =  options.fetch(:generate_applicability, repo.yum? || repo.deb?)
 
-          fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank? && source_url.blank?
-          fail ::Katello::Errors::InvalidActionOptionError, _("Cannot validate contents on non-yum/deb repositories.") if validate_contents && !repo.yum? && !repo.deb?
-          fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum repositories.") if skip_metadata_check && !repo.yum?
+          validate_repo!(repo: repo,
+                        source_url: source_url,
+                        validate_contents: validate_contents,
+                        skip_metadata_check: skip_metadata_check,
+                        skip_candlepin_check: options.fetch(:skip_candlepin_check, false))
 
           pulp_sync_options = {}
           pulp_sync_options[:download_policy] = ::Katello::RootRepository::DOWNLOAD_ON_DEMAND if validate_contents && repo.yum?
 
           #pulp3 options
-          pulp_sync_options[:optimize] = false if skip_metadata_check && repo.yum?
+          pulp_sync_options[:optimize] = false if skip_metadata_check && (repo.yum? || repo.deb?)
 
           sequence do
             if validate_contents
@@ -49,9 +49,8 @@ module Actions
               plan_action(Katello::Repository::IndexContent, :id => repo.id, :force_index => skip_metadata_check)
               plan_action(Katello::Foreman::ContentUpdate, repo.environment, repo.content_view, repo)
               plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
-              plan_action(Katello::Repository::CorrectChecksum, repo)
               concurrence do
-                plan_action(Katello::Repository::ErrataMail, repo, output[:contents_changed])
+                plan_action(Katello::Repository::ErrataMail, repo)
                 plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repo.id]) if generate_applicability
               end
               plan_self(:id => repo.id, :sync_result => output, :skip_metadata_check => skip_metadata_check, :validate_contents => validate_contents,
@@ -82,6 +81,13 @@ module Actions
           end
         end
 
+        def validate_repo!(repo:, source_url:, validate_contents:, skip_metadata_check:, skip_candlepin_check:)
+          fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank? && source_url.blank?
+          fail ::Katello::Errors::InvalidActionOptionError, _("Cannot validate contents on non-yum/deb repositories.") if validate_contents && !repo.yum? && !repo.deb?
+          fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum/deb repositories.") if skip_metadata_check && !repo.yum? && !repo.deb?
+          ::Katello::Util::CandlepinRepositoryChecker.check_repository_for_sync!(repo) if repo.yum? && !skip_candlepin_check
+        end
+
         def presenter
           found = all_planned_actions(Pulp3::Repository::Sync) if found.empty?
           found = all_planned_actions(Pulp3::Repository::Repair) if found.empty?

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

@@ -2,15 +2,19 @@ module Actions
   module Katello
     module Repository
       class Update < Actions::EntryAction
-        include Actions::Katello::PulpSelector
-
+        # rubocop:disable Metrics/MethodLength
         def plan(root, repo_params)
           repository = root.library_instance
           action_subject root.library_instance
 
           repo_params[:url] = nil if repo_params[:url] == ''
+          repo_params[:checksum_type] = nil if repo_params[:download_policy] == ::Katello::RootRepository::DOWNLOAD_ON_DEMAND
           update_cv_cert_protected = repo_params.key?(:unprotected) && (repo_params[:unprotected] != repository.unprotected)
+          create_acs = create_acs?(repository.url, repo_params[:url])
+          delete_acs = delete_acs?(repository.url, repo_params[:url])
 
+          # Keep the old URL for RPM vs ULN remote cleanup
+          old_url = root.url
           root.update!(repo_params)
 
           if update_content?(repository)
@@ -41,8 +45,13 @@ module Actions
                                SmartProxy.pulp_primary)
               plan_self(:repository_id => root.library_instance.id)
               if update_cv_cert_protected
-                plan_optional_pulp_action([::Actions::Pulp3::Orchestration::Repository::TriggerUpdateRepoCertGuard], repository, ::SmartProxy.pulp_primary)
+                smart_proxy = ::SmartProxy.pulp_primary
+                if smart_proxy.pulp3_support?(repository)
+                  plan_action(::Actions::Pulp3::Orchestration::Repository::TriggerUpdateRepoCertGuard, repository, smart_proxy)
+                end
               end
+
+              handle_alternate_content_sources(repository, create_acs, delete_acs, old_url)
             end
           end
         end
@@ -55,9 +64,36 @@ module Actions
 
         private
 
+        def handle_alternate_content_sources(repository, create_acs, delete_acs, old_url)
+          if create_acs
+            repository.product.alternate_content_sources.each do |acs|
+              acs.smart_proxies.each do |smart_proxy|
+                smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repository.id)
+                plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+              end
+            end
+          elsif delete_acs
+            repository.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs, old_url: old_url)
+            end
+          else
+            repository.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Update, smart_proxy_acs)
+            end
+          end
+        end
+
         def update_content?(repository)
           repository.library_instance? && !repository.product.redhat?
         end
+
+        def create_acs?(old_url, new_url)
+          old_url.nil? && new_url.present?
+        end
+
+        def delete_acs?(old_url, new_url)
+          old_url.present? && new_url.nil?
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module Actions
           action_subject repo
           repo.root.update!(:url => upstream_url(repo)) if repo.library_instance?
           repo.update!(relative_path: relative_path(repo))
-          plan_action(::Actions::Pulp3::Orchestration::Repository::RefreshIfNeeded, repo)
+          plan_action(::Actions::Katello::Repository::RefreshRepository, repo)
           plan_self(:repository_id => repo.id)
         end
 

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

@@ -6,7 +6,6 @@ module Actions
   module Katello
     module Repository
       class UploadFiles < Actions::EntryAction
-        include Actions::Katello::PulpSelector
         def plan(repository, files, content_type = nil, options = {})
           action_subject(repository)
           repository.clear_smart_proxy_sync_histories

data/app/lib/actions/katello/repository_set/enable_repository.rb

@@ -6,15 +6,19 @@ module Actions
           _("Enable")
         end
 
-        def plan(product, content, options)
+        def plan(product, content, substitutions, override_url: nil)
           mapper = ::Katello::Candlepin::RepositoryMapper.new(product,
                                                                content,
-                                                               options)
+                                                               substitutions)
           mapper.validate!
           if mapper.find_repository
             fail ::Katello::Errors::ConflictException, _("The repository is already enabled")
           end
           repository = mapper.build_repository
+          if override_url
+            repository.root.url = override_url
+            repository.root.download_policy = ::Katello::RootRepository::DOWNLOAD_IMMEDIATE if URI(override_url).scheme == 'file'
+          end
           plan_action(Repository::Create, repository, clone: false)
           action_subject(repository)
           plan_self

data/app/lib/actions/middleware/propagate_candlepin_errors.rb

@@ -18,7 +18,12 @@ module Actions
       def propagate_candlepin_errors
         yield
       rescue RestClient::ExceptionWithResponse => e
-        raise(::Katello::Errors::CandlepinError.from_exception(e) || e)
+        error_class = if e.response.request.url.include?('/candlepin')
+                        ::Katello::Errors::CandlepinError
+                      else
+                        ::Katello::Errors::UpstreamCandlepinError
+                      end
+        raise(error_class.from_exception(e) || e)
       end
     end
   end