katello 4.4.1 → 4.5.0

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

@@ -3,7 +3,7 @@ module Actions
     module ContentViewVersion
       class IncrementalUpdate < Actions::EntryAction
         include ::Katello::ContentViewHelper
-        attr_accessor :new_content_view_version
+        attr_accessor :new_content_view_version, :new_content_view_version_id
 
         HUMANIZED_TYPES = {
           ::Katello::Erratum::CONTENT_TYPE => "Errata",
@@ -18,6 +18,7 @@ module Actions
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/AbcSize
         # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
         def plan(old_version, environments, options = {})
           dep_solve = options.fetch(:resolve_dependencies, true)
           description = options.fetch(:description, '')
@@ -31,85 +32,93 @@ module Actions
           validate_environments(environments, old_version)
 
           new_minor = old_version.content_view.versions.where(:major => old_version.major).maximum(:minor) + 1
-          if SmartProxy.pulp_primary.pulp3_repository_type_support?("yum") && is_composite
+
+          if is_composite
             sequence do
               publish_action = plan_action(::Actions::Katello::ContentView::Publish, old_version.content_view, description,
                           :major => old_version.major, :minor => new_minor,
                           :override_components => new_components, :skip_promotion => true)
+
+              self.new_content_view_version_id = publish_action.content_view_version_id
+              plan_self(:is_composite => true, :content_view_id => old_version.content_view.id,
+                        :new_content_view_version_id => publish_action.content_view_version_id,
+                        :environment_ids => environments.map(&:id), :user_id => ::User.current.id,
+                        :history_id => publish_action.history_id,
+                        :old_version => old_version.id)
+
               if old_version.environments.present?
                 plan_action(::Actions::Katello::ContentView::Promote, publish_action.version,
                             old_version.environments, true, description)
               end
             end
-            return
-          end
-
-          self.new_content_view_version = old_version.content_view.create_new_version(old_version.major, new_minor, all_components)
-          history = ::Katello::ContentViewHistory.create!(:content_view_version => new_content_view_version, :user => ::User.current.login,
-                                                          :action => ::Katello::ContentViewHistory.actions[:publish],
-                                                          :status => ::Katello::ContentViewHistory::IN_PROGRESS, :task => self.task,
-                                                          :notes => description)
+          else
+            self.new_content_view_version = old_version.content_view.create_new_version(old_version.major, new_minor, all_components)
+            history = ::Katello::ContentViewHistory.create!(:content_view_version => new_content_view_version, :user => ::User.current.login,
+                                                            :action => ::Katello::ContentViewHistory.actions[:publish],
+                                                            :status => ::Katello::ContentViewHistory::IN_PROGRESS, :task => self.task,
+                                                            :notes => description)
 
-          copy_action_outputs = []
-          repos_to_clone = repos_to_copy(old_version, new_components)
+            copy_action_outputs = []
+            repos_to_clone = repos_to_copy(old_version, new_components)
 
-          sequence do
-            repository_mapping = plan_action(ContentViewVersion::CreateRepos, new_content_view_version, repos_to_clone).repository_mapping
-            separated_repo_map = separated_repo_mapping(repository_mapping, true)
-
-            repos_to_clone.each do |source_repos|
-              plan_action(Repository::CloneToVersion,
-                          source_repos,
-                          new_content_view_version,
-                          repository_mapping[source_repos],
-                          incremental: true)
-            end
+            sequence do
+              repository_mapping = plan_action(ContentViewVersion::CreateRepos, new_content_view_version, repos_to_clone).repository_mapping
+              separated_repo_map = separated_repo_mapping(repository_mapping, true)
+
+              repos_to_clone.each do |source_repos|
+                plan_action(Repository::CloneToVersion,
+                            source_repos,
+                            new_content_view_version,
+                            repository_mapping[source_repos],
+                            incremental: true)
+              end
 
-            concurrence do
-              if separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
-                extended_repo_mapping = pulp3_repo_mapping(separated_repo_map[:pulp3_yum_multicopy], old_version)
-                unit_map = pulp3_content_mapping(content)
-
-                unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
-                  sequence do
-                    # Pre-copy content if dest_repo is a soft copy of its library instance.
-                    # Don't use extended_repo_mapping because the source repositories are library instances.
-                    # We want the old CV snapshot repositories here so as to not pull in excess new content.
-                    separated_repo_map[:pulp3_yum_multicopy].each do |source_repos, dest_repo|
-                      if dest_repo.soft_copy_of_library?
-                        source_repos.each do |source_repo|
-                          # remove_all flag is set to cover the case of incrementally updating more than once with different content.
-                          # Without it, content from the previous incremental update will be copied as well due to how Pulp repo versions work.
-                          plan_action(Pulp3::Repository::CopyContent, source_repo, SmartProxy.pulp_primary, dest_repo, copy_all: true, remove_all: true)
+              concurrence do
+                if separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
+                  extended_repo_mapping = pulp3_repo_mapping(separated_repo_map[:pulp3_yum_multicopy], old_version)
+                  unit_map = pulp3_content_mapping(content)
+
+                  unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
+                    sequence do
+                      # Pre-copy content if dest_repo is a soft copy of its library instance.
+                      # Don't use extended_repo_mapping because the source repositories are library instances.
+                      # We want the old CV snapshot repositories here so as to not pull in excess new content.
+                      separated_repo_map[:pulp3_yum_multicopy].each do |source_repos, dest_repo|
+                        if dest_repo.soft_copy_of_library?
+                          source_repos.each do |source_repo|
+                            # remove_all flag is set to cover the case of incrementally updating more than once with different content.
+                            # Without it, content from the previous incremental update will be copied as well due to how Pulp repo versions work.
+                            plan_action(Pulp3::Repository::CopyContent, source_repo, SmartProxy.pulp_primary, dest_repo, copy_all: true, remove_all: true)
+                          end
                         end
                       end
-                    end
-                    copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
-                                                       dependency_solving: dep_solve).output
-                    repos_to_clone.each do |source_repos|
-                      if separated_repo_map[:pulp3_yum_multicopy].keys.include?(source_repos)
-                        copy_repos(repository_mapping[source_repos])
+                      copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
+                                                         dependency_solving: dep_solve).output
+                      repos_to_clone.each do |source_repos|
+                        if separated_repo_map[:pulp3_yum_multicopy].keys.include?(source_repos)
+                          copy_repos(repository_mapping[source_repos])
+                        end
                       end
                     end
                   end
                 end
-              end
 
-              if separated_repo_map[:other].keys.flatten.present?
-                repos_to_clone.each do |source_repos|
-                  if separated_repo_map[:other].keys.include?(source_repos)
-                    copy_repos(repository_mapping[source_repos])
+                if separated_repo_map[:other].keys.flatten.present?
+                  repos_to_clone.each do |source_repos|
+                    if separated_repo_map[:other].keys.include?(source_repos)
+                      copy_repos(repository_mapping[source_repos])
+                    end
                   end
                 end
               end
-            end
 
-            plan_self(:content_view_id => old_version.content_view.id,
-                      :new_content_view_version_id => self.new_content_view_version.id,
-                      :environment_ids => environments.map(&:id), :user_id => ::User.current.id,
-                      :history_id => history.id, :copy_action_outputs => copy_action_outputs,
-                      :old_version => old_version.id)
-            promote(new_content_view_version, environments)
+              plan_self(:content_view_id => old_version.content_view.id,
+                        :new_content_view_version_id => self.new_content_view_version.id,
+                        :environment_ids => environments.map(&:id), :user_id => ::User.current.id,
+                        :history_id => history.id, :copy_action_outputs => copy_action_outputs,
+                        :old_version => old_version.id)
+              promote(new_content_view_version, environments)
+            end
           end
         end
 
@@ -203,7 +212,7 @@ module Actions
           end
         end
 
-        def run # rubocop:disable Metrics/CyclomaticComplexity
+        def run
           content = { ::Katello::Erratum::CONTENT_TYPE => [],
                       ::Katello::Rpm::CONTENT_TYPE => [],
                       ::Katello::ModuleStream::CONTENT_TYPE => [],
@@ -213,44 +222,23 @@ module Actions
           base_repos = ::Katello::ContentViewVersion.find(input[:old_version]).repositories
           new_repos = ::Katello::ContentViewVersion.find(input[:new_content_view_version_id]).repositories
 
-          if input[:copy_action_outputs].present? && input[:copy_action_outputs].last[:pulp_tasks].present?
-            if input[:copy_action_outputs].last[:pulp_tasks].last[:pulp_href]&.include?("/pulp/api/v3/")
-              new_repos.each do |new_repo|
-                matched_old_repo = base_repos.where(root_id: new_repo.root_id).first
+          if input[:is_composite] || input[:copy_action_outputs].present? && input[:copy_action_outputs].last[:pulp_tasks].present?
+            new_repos.each do |new_repo|
+              matched_old_repo = base_repos.where(root_id: new_repo.root_id).first
 
-                new_errata = new_repo.errata - matched_old_repo.errata
-                new_module_streams = new_repo.module_streams - matched_old_repo.module_streams
-                new_rpms = new_repo.rpms - matched_old_repo.rpms
+              new_errata = new_repo.errata - (matched_old_repo&.errata || [])
+              new_module_streams = new_repo.module_streams - (matched_old_repo&.module_streams || [])
+              new_rpms = new_repo.rpms - (matched_old_repo&.rpms || [])
 
-                new_errata.each do |erratum|
-                  content[::Katello::Erratum::CONTENT_TYPE] << erratum.errata_id
-                end
-                new_module_streams.each do |module_stream|
-                  content[::Katello::ModuleStream::CONTENT_TYPE] <<
-                    "#{module_stream.name}:#{module_stream.stream}:#{module_stream.version}"
-                end
-                new_rpms.each do |rpm|
-                  content[::Katello::Rpm::CONTENT_TYPE] << rpm.nvra
-                end
+              new_errata.each do |erratum|
+                content[::Katello::Erratum::CONTENT_TYPE] << erratum.errata_id
               end
-            else
-              input[:copy_action_outputs].each do |copy_output|
-                copy_output[:pulp_tasks].each do |pulp_task|
-                  pulp_task[:result][:units_successful].each do |unit|
-                    type = unit['type_id']
-                    unit = unit['unit_key']
-                    case type
-                    when ::Katello::Erratum::CONTENT_TYPE
-                      content[::Katello::Erratum::CONTENT_TYPE] << unit['id']
-                    when ::Katello::ModuleStream::CONTENT_TYPE
-                      content[::Katello::ModuleStream::CONTENT_TYPE] << "#{unit['name']}:#{unit['stream']}:#{unit['version']}"
-                    when ::Katello::Rpm::CONTENT_TYPE
-                      content[::Katello::Rpm::CONTENT_TYPE] << ::Katello::Util::Package.build_nvra(unit)
-                    when ::Katello::Deb::CONTENT_TYPE
-                      content[::Katello::Deb::CONTENT_TYPE] << "#{unit['name']}_#{unit['version']}_#{unit['architecture']}"
-                    end
-                  end
-                end
+              new_module_streams.each do |module_stream|
+                content[::Katello::ModuleStream::CONTENT_TYPE] <<
+                  "#{module_stream.name}:#{module_stream.stream}:#{module_stream.version}"
+              end
+              new_rpms.each do |rpm|
+                content[::Katello::Rpm::CONTENT_TYPE] << rpm.nvra
               end
             end
           end
@@ -274,6 +262,10 @@ module Actions
                 repo.pulp_id)
             end
           end
+
+          if version.latest? && !version.content_view.composite?
+            version.auto_publish_composites!
+          end
         end
 
         # given a composite version, and a list of new components, calculate the list of all components for the new version

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

@@ -2,8 +2,8 @@ module Actions
   module Katello
     module ContentViewVersion
       class ResetContentViewRepositoriesFromMetadata < Actions::Base
-        def plan(content_view:, metadata:)
-          ::Katello::Pulp3::ContentViewVersion::Import.reset_content_view_repositories_from_metadata!(content_view: content_view, metadata: metadata)
+        def plan(import:)
+          import.reset_content_view_repositories!
         end
       end
     end

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

@@ -9,7 +9,7 @@ module Actions
         def plan(organization)
           action_subject organization
           manifest_update = organization.products.redhat.any?
-          path = "/tmp/#{rand}.zip"
+          path = File.join(::Rails.root, "tmp", "#{rand}.zip")
           details = organization.owner_details
           upstream = details['upstreamConsumer'].blank? ? {} : details['upstreamConsumer']
 

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

@@ -44,16 +44,18 @@ module Actions
           root = ::Katello::RootRepository.find(input[:root_repository_id])
           root.update(:content_id => input[:content_id])
 
-          content = ::Katello::Content.create!(name: root.name,
-                                               organization_id: root.product.organization_id,
-                                               cp_content_id: root.content_id,
-                                               content_type: root.content_type,
-                                               label: root.custom_content_label,
-                                               content_url: root.custom_content_path,
-                                               vendor: ::Katello::Provider::CUSTOM)
+          content = ::Katello::Content.where(organization_id: root.product.organization_id, cp_content_id: root.content_id).first_or_create do |new_content|
+            new_content.name = root.name
+            new_content.content_type = root.content_type
+            new_content.label = root.custom_content_label
+            new_content.content_url = root.custom_content_path
+            new_content.vendor = ::Katello::Provider::CUSTOM
+          end
 
           #custom product content is always enabled by default
-          ::Katello::ProductContent.create!(product: root.product, content: content, enabled: true)
+          ::Katello::ProductContent.where(product: root.product, content: content).first_or_create do |pc|
+            pc.enabled = true
+          end
         end
       end
     end

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

@@ -14,22 +14,16 @@ module Actions
           destroy_content = options.fetch(:destroy_content, true)
           remove_from_content_view_versions = options.fetch(:remove_from_content_view_versions, false)
           action_subject(repository)
+          check_destroyable!(repository, remove_from_content_view_versions)
+          remove_generated_content_views(repository)
 
-          unless repository.destroyable?(remove_from_content_view_versions)
-            # The repository is going to be deleted in finalize, but it cannot be deleted.
-            # Stop now and inform the user.
-            fail repository.errors.messages.values.join("\n")
-          end
+          remove_versions(repository, repository.content_views.generated_for_library, affected_cvv_ids)
 
           plan_action(Actions::Pulp3::Orchestration::Repository::Delete,
                            repository,
                            SmartProxy.pulp_primary)
 
-          if remove_from_content_view_versions
-            library_instances_inverse = repository.library_instances_inverse
-            affected_cvv_ids = library_instances_inverse.pluck(:content_view_version_id).uniq
-            plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::Destroy, library_instances_inverse)
-          end
+          remove_versions(repository, repository.content_views.generated_for_none, affected_cvv_ids) if remove_from_content_view_versions
 
           plan_self(:user_id => ::User.current.id, :affected_cvv_ids => affected_cvv_ids)
           sequence do
@@ -50,8 +44,9 @@ module Actions
             delete_record(repository, {docker_cleanup: docker_cleanup})
 
             if (affected_cvv_ids = input[:affected_cvv_ids]).any?
-              affected_cvv_ids.each do |cvv_id|
-                ::Katello::ContentViewVersion.find(cvv_id).update_content_counts!
+              cvvs = ::Katello::ContentViewVersion.where(id: affected_cvv_ids)
+              cvvs.each do |cvv|
+                cvv.update_content_counts!
               end
             end
           end
@@ -77,6 +72,35 @@ module Actions
           ::Katello::DockerMetaTag.cleanup_tags if options[:docker_cleanup]
         end
 
+        def remove_generated_content_views(repository)
+          # remove the content views generated for this repository (since we are deleting the repo)
+          content_views = repository.content_views.generated_for_repository
+          return if content_views.blank?
+          plan_action(::Actions::BulkAction, ::Actions::Katello::ContentView::Remove,
+                        content_views,
+                        skip_repo_destroy: true,
+                        destroy_content_view: true)
+        end
+
+        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)
+          plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::Destroy, interested_inverses)
+        end
+
+        def check_destroyable!(repository, remove_from_content_view_versions)
+          unless repository.destroyable?(remove_from_content_view_versions)
+            # The repository is going to be deleted in finalize, but it cannot be deleted.
+            # Stop now and inform the user.
+            fail repository.errors.messages.values.join("\n")
+          end
+        end
+
         def humanized_name
           _("Delete")
         end

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

@@ -7,9 +7,14 @@ module Actions
         end
 
         def plan(product, content, options)
-          repository = repository_mapper(product,
-                                         content,
-                                         options).find_repository
+          if options[:repository_id]
+            repository = ::Katello::Repository.find(options[:repository_id])
+          else
+            repository = repository_mapper(product,
+                                           content,
+                                           options).find_repository
+          end
+
           if repository
             action_subject(repository)
             plan_action(Repository::Destroy, repository)

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

@@ -0,0 +1,20 @@
+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)
+        end
+
+        def run
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).create
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+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)
+        end
+
+        def run
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).create_remote
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+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)
+        end
+
+        def invoke_external_task
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).delete_alternate_content_source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+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)
+        end
+
+        def invoke_external_task
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).delete_remote
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+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)
+        end
+
+        def invoke_external_task
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).refresh
+        end
+
+        def rescue_strategy_for_self
+          # There are various reasons why refreshing fails, but not all of them are
+          # fatal. When failing to refresh, we continue with the task ending up
+          # in the warning state, but don't lock further refreshing
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+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)
+        end
+
+        def invoke_external_task
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).update
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Actions
+  module Pulp3
+    module AlternateContentSource
+      class UpdateRemote < Pulp3::AbstractAsyncTask
+        def plan(acs, smart_proxy)
+          acs.backend_service(smart_proxy).create_test_remote
+          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def invoke_external_task
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).update_remote
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/content_view_version/{import.rb → create_import.rb}

@@ -1,9 +1,9 @@
 module Actions
   module Pulp3
     module ContentViewVersion
-      class Import < Pulp3::AbstractAsyncTask
+      class CreateImport < Pulp3::AbstractAsyncTask
         input_format do
-          param :content_view_version_id, Integer
+          param :organization_id, Integer
           param :smart_proxy_id, Integer
           param :importer_data, Hash
           param :path, String
@@ -11,12 +11,12 @@ module Actions
         end
 
         def invoke_external_task
-          cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          metadata_map = ::Katello::Pulp3::ContentViewVersion::MetadataMap.new(metadata: input[:metadata])
           output[:pulp_tasks] = ::Katello::Pulp3::ContentViewVersion::Import.new(
+            organization: ::Organization.find(input[:organization_id]),
             smart_proxy: smart_proxy,
-            content_view_version: cvv,
             path: input[:path],
-            metadata: input[:metadata]
+            metadata_map: metadata_map
           ).create_import(input[:importer_data][:pulp_href])
         end
 

data/app/lib/actions/pulp3/content_view_version/create_importer.rb

@@ -11,12 +11,13 @@ module Actions
 
         def run
           cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          metadata_map = ::Katello::Pulp3::ContentViewVersion::MetadataMap.new(metadata: input[:metadata])
           output[:importer_data] = ::Katello::Pulp3::ContentViewVersion::Import.new(
+            organization: cvv.content_view.organization,
             smart_proxy: smart_proxy,
-            content_view_version: cvv,
             path: input[:path],
-            metadata: input[:metadata]
-          ).create_importer
+            metadata_map: metadata_map
+          ).create_importer(cvv)
         end
       end
     end

data/app/lib/actions/pulp3/content_view_version/destroy_importer.rb

@@ -5,10 +5,21 @@ module Actions
         input_format do
           param :smart_proxy_id, Integer
           param :importer_data, Hash
+          param :organization_id, Integer
+          param :importer_data, Hash
+          param :path, String
+          param :metadata, Hash
         end
 
         def run
-          ::Katello::Pulp3::ContentViewVersion::Import.new(smart_proxy: smart_proxy).destroy_importer(input[:importer_data][:pulp_href])
+          metadata_map = ::Katello::Pulp3::ContentViewVersion::MetadataMap.new(metadata: input[:metadata])
+          import = ::Katello::Pulp3::ContentViewVersion::Import.new(
+            organization: ::Organization.find(input[:organization_id]),
+            smart_proxy: smart_proxy,
+            path: input[:path],
+            metadata_map: metadata_map
+          )
+          import.destroy_importer(input[:importer_data][:pulp_href])
         end
       end
     end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/create.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module AlternateContentSource
+        class Create < Pulp3::Abstract
+          def plan(acs, smart_proxy)
+            sequence do
+              plan_action(Actions::Pulp3::AlternateContentSource::CreateRemote, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::Create, acs, smart_proxy)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module AlternateContentSource
+        class Delete < Pulp3::Abstract
+          def plan(acs, smart_proxy)
+            sequence do
+              plan_action(Actions::Pulp3::AlternateContentSource::Delete, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::DeleteRemote, acs, smart_proxy)
+              plan_self(acs_id: acs.id, smart_proxy_id: smart_proxy.id)
+            end
+          end
+
+          def finalize
+            acs_id = input[:acs_id]
+            smart_proxy_id = input[:smart_proxy_id]
+            ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs_id, smart_proxy_id: smart_proxy_id).destroy
+          end
+        end
+      end
+    end
+  end
+end