katello 4.5.0 → 4.6.0.rc1

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

@@ -6,12 +6,6 @@ module Katello
       include Foreman::Controller::Flash
 
       module Overrides
-        def edit
-          @can_toggle_sca = Katello::UpstreamConnectionChecker.new(@taxonomy).can_connect? &&
-            (@taxonomy.upstream_consumer.simple_content_access_eligible? || @taxonomy.simple_content_access?)
-          super
-        end
-
         def destroy
           if @taxonomy.is_a?(Organization)
             begin
@@ -30,7 +24,8 @@ module Katello
           if taxonomy_class == Organization
             begin
               @taxonomy = Organization.new(resource_params)
-              ::Katello::OrganizationCreator.new(@taxonomy).create!
+              sca = ::Foreman::Cast.to_bool(params[:simple_content_access])
+              ::Katello::OrganizationCreator.new(@taxonomy, sca: sca).create!
               @taxonomy.reload
               switch_taxonomy
               if @count_nil_hosts > 0
@@ -50,20 +45,16 @@ module Katello
       end
 
       def update
-        super # we run super first here so that flash messages won't be in a confusing order
         return if params[:simple_content_access].nil?
         sca_param = ::Foreman::Cast.to_bool(params[:simple_content_access])
-        if sca_param && !@taxonomy.simple_content_access?
+        if sca_param && !@taxonomy.simple_content_access?(cached: false)
           # user has requested SCA enable
-          task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:id])
-          info "Enabling Simple Content Access for organization #{@taxonomy.name}.",
-            link: { text: "View progress on the Tasks page", href: "/foreman_tasks/tasks/#{task&.id}" }
-        elsif !sca_param && @taxonomy.simple_content_access?
+          sync_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:id])
+        elsif !sca_param && @taxonomy.simple_content_access?(cached: false)
           # user has requested SCA disable
-          task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:id])
-          info "Disabling Simple Content Access for organization #{@taxonomy.name}.",
-            link: { text: "View progress on the Tasks page", href: "/foreman_tasks/tasks/#{task&.id}" }
+          sync_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:id])
         end
+        super
       end
 
       included do

data/app/lib/actions/katello/alternate_content_source/alternate_content_source_common.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Katello
+    module AlternateContentSource
+      module AlternateContentSourceCommon
+        def create_simplified_acs(acs, smart_proxy)
+          acs.products.each do |product|
+            product.repositories.has_url.library.with_type(acs.content_type).each do |repo|
+              smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repo.id)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,15 +2,21 @@ module Actions
   module Katello
     module AlternateContentSource
       class Create < Actions::EntryAction
-        def plan(acs, smart_proxies)
+        include Actions::Katello::AlternateContentSource::AlternateContentSourceCommon
+
+        def plan(acs, smart_proxies, products = nil)
           acs.save!
           action_subject(acs)
-          smart_proxies = smart_proxies.uniq
+          acs.products << products if products.present?
+          smart_proxies = smart_proxies.present? ? smart_proxies.uniq : []
           concurrence do
             smart_proxies.each do |smart_proxy|
-              ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Create,
-                          acs, smart_proxy)
+              if acs.custom?
+                smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
+                plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+              elsif acs.simplified?
+                create_simplified_acs(acs, smart_proxy)
+              end
             end
           end
         end

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

@@ -5,11 +5,10 @@ module Actions
         def plan(acs)
           action_subject(acs)
           sequence do
-            acs.smart_proxies.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete,
-                          acs, smart_proxy)
+            acs.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
             end
-            plan_self(:acs_id => acs.id)
+            plan_self(acs_id: acs.id)
           end
         end
 

data/app/lib/actions/katello/alternate_content_source/refresh.rb

@@ -5,17 +5,15 @@ module Actions
         def plan(acs)
           action_subject(acs)
           concurrence do
-            acs.smart_proxies.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Refresh,
-                          acs, smart_proxy)
+            acs.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Refresh, smart_proxy_acs)
             end
           end
           plan_self(acs_id: acs.id)
         end
 
         def finalize
-          acs = ::Katello::AlternateContentSource.find_by(id: input[:acs_id])
-          acs.update(last_refreshed: ::DateTime.now)
+          ::Katello::AlternateContentSource.find_by(id: input[:acs_id])&.audit_refresh
         end
 
         def humanized_name

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

@@ -2,32 +2,76 @@ module Actions
   module Katello
     module AlternateContentSource
       class Update < Actions::EntryAction
+        include Actions::Katello::AlternateContentSource::AlternateContentSourceCommon
         # smart_proxies ALWAYS represents the smart proxies to remain associated
         # after the action runs.  If smart_proxies == [], there will be none afterwards.
-        def plan(acs, smart_proxies, acs_params)
+        # The same rule applies to products.
+        def plan(acs, smart_proxies, products, acs_params)
           action_subject(acs)
           acs.update!(acs_params)
 
           smart_proxies = smart_proxies.uniq
-          smart_proxies_to_add = smart_proxies - acs.smart_proxies
-          smart_proxies_to_delete = acs.smart_proxies - smart_proxies
+          smart_proxies_to_associate = smart_proxies - acs.smart_proxies
+          smart_proxies_to_disassociate = acs.smart_proxies - smart_proxies
           smart_proxies_to_update = smart_proxies & acs.smart_proxies
 
+          products ||= []
+          products_to_associate = []
+          products_to_disassociate = []
+
+          if acs.simplified?
+            products = products.uniq
+            products_to_associate = products - acs.products
+            products_to_disassociate = acs.products - products
+            old_product_ids = acs.products.pluck(:id)
+            acs.products = products
+            acs.audit_updated_products(old_product_ids) unless products_to_associate.empty? && products_to_disassociate.empty?
+          end
+
           concurrence do
-            smart_proxies_to_add&.each do |smart_proxy|
-              ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Create,
-                          acs, smart_proxy)
+            create_acss(acs, smart_proxies_to_associate)
+            delete_acss(acs, smart_proxies_to_disassociate)
+            update_acss(acs, smart_proxies_to_update, products_to_associate, products_to_disassociate)
+          end
+        end
+
+        def create_acss(acs, smart_proxies_to_associate)
+          smart_proxies_to_associate&.each do |smart_proxy|
+            if acs.custom?
+              smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+            elsif acs.simplified?
+              create_simplified_acs(acs, smart_proxy)
             end
+          end
+        end
 
-            smart_proxies_to_delete&.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete,
-                          acs, smart_proxy)
+        def delete_acss(acs, smart_proxies_to_disassociate)
+          smart_proxies_to_disassociate&.each do |smart_proxy|
+            acs.smart_proxy_alternate_content_sources.where(smart_proxy_id: smart_proxy.id).each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
             end
+          end
+        end
 
-            smart_proxies_to_update&.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Update,
-                          acs, smart_proxy)
+        def update_acss(acs, smart_proxies_to_update, products_to_associate, products_to_disassociate)
+          smart_proxies_to_update&.each do |smart_proxy|
+            if acs.custom?
+              smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: nil)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Update, smart_proxy_acs)
+            elsif acs.simplified?
+              products_to_associate.each do |product|
+                product.repositories.library.with_type(acs.content_type).each do |repo|
+                  smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repo.id)
+                  plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+                end
+              end
+              products_to_disassociate.each do |product|
+                product.repositories.library.with_type(acs.content_type).each do |repo|
+                  smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repo.id)
+                  plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
+                end
+              end
             end
           end
         end

data/app/lib/actions/katello/applicability/hosts/bulk_generate.rb

@@ -32,8 +32,8 @@ module Actions
           end
 
           def humanized_name
-            if input[:host_ids]&.length == 1
-              _("Bulk generate applicability for host %s" % hostname(input[:host_ids].first))
+            if input && input[:host_ids]&.length == 1
+              _("Bulk generate applicability for host %s" % hostname(input[:host_ids]&.first))
             else
               _("Bulk generate applicability for hosts")
             end

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

@@ -1,8 +1,8 @@
-# rubocop:disable Lint/SuppressedException
 module Actions
   module Katello
     module ContentView
       class PromoteToEnvironment < Actions::EntryAction
+        execution_plan_hooks.use :trigger_capsule_sync, :on => :success
         def plan(version, environment, description, incremental_update = false)
           history = ::Katello::ContentViewHistory.create!(:content_view_version => version, :user => ::User.current.login,
                                                           :environment => environment, :task => self.task,
@@ -51,13 +51,15 @@ module Actions
           history = ::Katello::ContentViewHistory.find(input[:history_id])
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL
           history.save!
+        end
 
+        def trigger_capsule_sync(_execution_plan)
+          environment = ::Katello::KTEnvironment.find(input[:environment_id])
           if !input[:incremental_update] && sync_proxies?(environment)
             ForemanTasks.async_task(ContentView::CapsuleSync,
                                     ::Katello::ContentView.find(input[:content_view_id]),
                                     environment)
           end
-        rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 
         private

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

@@ -1,4 +1,3 @@
-# rubocop:disable Lint/SuppressedException
 module Actions
   module Katello
     module ContentView
@@ -7,6 +6,8 @@ module Actions
         include ::Katello::ContentViewHelper
         include ::Actions::ObservableAction
         attr_accessor :version
+        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
           action_subject(content_view)
@@ -118,6 +119,9 @@ module Actions
           history = ::Katello::ContentViewHistory.find(input[:history_id])
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL
           history.save!
+        end
+
+        def trigger_capsule_sync(_execution_plan)
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
           view = ::Katello::ContentView.find(input[:content_view_id])
           if SmartProxy.sync_needed?(environment) && !input[:skip_promotion]
@@ -125,7 +129,6 @@ module Actions
                                     view,
                                     environment)
           end
-        rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 
         def content_view_version_id

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

@@ -0,0 +1,20 @@
+module Actions
+  module Katello
+    module Organization
+      class EnvironmentContentsRefresh < Actions::AbstractAsyncTask
+        middleware.use Actions::Middleware::PropagateCandlepinErrors
+
+        def plan(organization)
+          organization.content_view_environments.each do |cve|
+            plan_action(
+              Actions::Candlepin::Environment::SetContent,
+              cve.content_view,
+              cve.owner,
+              cve
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -29,6 +29,8 @@ module Actions
             import_products = plan_action(Candlepin::Owner::ImportProducts,
               :organization_id => organization.id,
               :dependency => owner_import.output)
+            plan_action(Katello::Organization::EnvironmentContentsRefresh,
+              organization)
             if manifest_update
               plan_refresh_repos(import_products, organization)
             end
@@ -42,10 +44,14 @@ module Actions
 
         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/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 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

@@ -25,6 +25,8 @@ module Actions
 
           remove_versions(repository, repository.content_views.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
             if repository.redhat?
@@ -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?

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

@@ -5,15 +5,15 @@ module Actions
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
         def plan(repo, contents_changed = nil)
-          plan_self(:repo => repo.id, :contents_changed => contents_changed)
+          last_updated = repo.repository_errata.order('updated_at ASC').last.try(:updated_at) || Time.now
+          plan_self(:repo => repo.id, :contents_changed => contents_changed, :last_updated => last_updated.to_s)
         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
           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 => repo.repository_errata.where('katello_repository_errata.updated_at > ?', input['last_updated'].to_datetime).pluck(:erratum_id))
 
           begin
             MailNotification[:sync_errata].deliver(:users => users, :repo => repo, :errata => errata) unless (users.blank? || errata.blank?)

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::Orchestration::AlternateContentSource::RefreshRemote, smart_proxy_acs)
+            end
             plan_self(:name => repo.name, :dependency => options[:dependency])
           end
         end

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

@@ -10,7 +10,11 @@ module Actions
 
           repo_params[:url] = nil if repo_params[:url] == ''
           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)
@@ -43,6 +47,8 @@ module Actions
               if update_cv_cert_protected
                 plan_optional_pulp_action([::Actions::Pulp3::Orchestration::Repository::TriggerUpdateRepoCertGuard], repository, ::SmartProxy.pulp_primary)
               end
+
+              handle_alternate_content_sources(repository, create_acs, delete_acs, old_url)
             end
           end
         end
@@ -55,9 +61,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/pulp3/alternate_content_source/create.rb

@@ -2,13 +2,14 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class Create < Pulp3::Abstract
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
         end
 
         def run
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).create
+          smart_proxy_acs_id = input[:smart_proxy_acs_id]
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(smart_proxy_acs_id)
+          output[:response] = smart_proxy_acs.backend_service.create
         end
 
         def rescue_strategy

data/app/lib/actions/pulp3/alternate_content_source/create_remote.rb

@@ -2,13 +2,14 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class CreateRemote < Pulp3::Abstract
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
         end
 
         def run
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).create_remote
+          smart_proxy_acs_id = input[:smart_proxy_acs_id]
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(smart_proxy_acs_id)
+          output[:response] = smart_proxy_acs.backend_service.create_remote
         end
 
         def rescue_strategy

data/app/lib/actions/pulp3/alternate_content_source/delete.rb

@@ -2,13 +2,13 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class Delete < Pulp3::AbstractAsyncTask
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).delete_alternate_content_source
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.delete_alternate_content_source
         end
       end
     end

data/app/lib/actions/pulp3/alternate_content_source/delete_remote.rb

@@ -2,13 +2,13 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class DeleteRemote < Pulp3::AbstractAsyncTask
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs, options = {})
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id, old_url: options[:old_url])
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).delete_remote
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.delete_remote(old_url: input[:old_url])
         end
       end
     end

data/app/lib/actions/pulp3/alternate_content_source/refresh.rb

@@ -2,13 +2,13 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class Refresh < Pulp3::AbstractAsyncTask
-        def plan(acs, smart_proxy)
-          plan_self(acs_id: acs.id, smart_proxy_id: smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).refresh
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.refresh
         end
 
         def rescue_strategy_for_self

data/app/lib/actions/pulp3/alternate_content_source/update.rb

@@ -2,13 +2,13 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class Update < Pulp3::AbstractAsyncTask
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_acs_id: smart_proxy_acs.id, smart_proxy_id: smart_proxy_acs.smart_proxy_id)
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).update
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.update
         end
       end
     end