katello 4.1.4 → 4.2.0.rc1

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

@@ -8,6 +8,8 @@ module Actions
 
         def run
           ::Katello::Resources::Candlepin::Environment.destroy(input['cp_id'])
+        rescue ::Katello::Errors::CandlepinEnvironmentGone
+          Rails.logger.info("Candlepin environment cp_id=#{input['cp_id']} was not found, continuing")
         end
       end
     end

data/app/lib/actions/katello/agent_action.rb

@@ -47,14 +47,14 @@ module Actions
 
             dispatch_message(history) unless input[:bulk]
 
-            schedule_timeout(timeout)
+            schedule_timeout(timeout, optional: true)
           end
         when Dynflow::Action::Skip
           # Do not fail and goto a paused state, instead skip and send the state to warning so we do not block other host actions
         when Dynflow::Action::Timeouts::Timeout
           process_timeout
         when 'accepted'
-          schedule_timeout(finish_timeout)
+          schedule_timeout(finish_timeout, optional: true)
           suspend
         else
           fail_on_errors

data/app/lib/actions/katello/capsule_content/sync_capsule.rb

@@ -15,8 +15,9 @@ module Actions
             repos.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
               concurrence do
                 repo_batch.each do |repo|
-                  plan_pulp_action([Actions::Pulp::Orchestration::Repository::SmartProxySync,
-                                    Actions::Pulp3::CapsuleContent::Sync],
+                  plan_pulp_action(
+                    [Actions::Pulp::Orchestration::Repository::SmartProxySync,
+                     Actions::Pulp3::CapsuleContent::Sync],
                                      repo, smart_proxy,
                                      skip_metadata_check: skip_metadata_check)
                 end

data/app/lib/actions/katello/{gpg_key → content_credential}/update.rb

@@ -1,6 +1,6 @@
 module Actions
   module Katello
-    module GpgKey
+    module ContentCredential
       class Update < Actions::EntryAction
         def plan(gpg_key, gpg_key_params)
           action_subject gpg_key

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

@@ -77,7 +77,7 @@ module Actions
             plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library)) unless options[:skip_promotion]
             plan_action(Katello::Foreman::ContentUpdate, library, content_view) unless options[:skip_promotion]
             plan_action(ContentView::ErrataMail, content_view, library) unless options[:skip_promotion]
-
+            plan_action(ContentView::Promote, version, find_environments(options[:environment_ids]), options[:is_force_promote]) if options[:environment_ids]&.any?
             plan_self(history_id: history.id, content_view_id: content_view.id,
                       auto_publish_composite_ids: auto_publish_composite_ids(content_view),
                       content_view_version_name: version.name,
@@ -186,6 +186,11 @@ module Actions
           end
         end
 
+        def find_environments(environment_ids)
+          return nil unless environment_ids&.any?
+          ::Katello::KTEnvironment.where(:id => environment_ids)
+        end
+
         def handle_import(version, path:, metadata:)
           sequence do
             plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path, metadata: metadata)

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

@@ -10,7 +10,7 @@ module Actions
             source_repositories.each do |repositories|
               new_repository = repositories.first.build_clone(content_view: version.content_view,
                                                              version: version)
-              plan_action(Repository::Create, new_repository, clone: true)
+              plan_action(Repository::Create, new_repository, true)
               repository_mapping[repositories] = new_repository
             end
           end

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

@@ -1,7 +1,6 @@
 module Actions
   module Katello
     module ContentViewVersion
-      # rubocop:disable Metrics/ClassLength
       class IncrementalUpdate < Actions::EntryAction
         include ::Katello::ContentViewHelper
         attr_accessor :new_content_view_version
@@ -325,52 +324,6 @@ module Actions
           plan_action(Katello::ContentView::Promote, new_version, environments, true, nil, true)
         end
 
-        def copy_deb_content(new_repo, dep_solve, deb_ids)
-          copy_outputs = []
-          if new_repo.content_type == ::Katello::Repository::DEB_TYPE
-            unless deb_ids.blank?
-              copy_outputs << plan_action(Pulp::Repository::CopyUnits, new_repo.library_instance, new_repo,
-                                          ::Katello::Deb.with_identifiers(deb_ids),
-                                          incremental_update: dep_solve).output
-            end
-          end
-          copy_outputs
-        end
-
-        def copy_yum_content(new_repo, dep_solve, package_ids, errata_ids)
-          return [] unless new_repo.content_type == ::Katello::Repository::YUM_TYPE
-
-          copy_outputs = []
-
-          unless errata_ids.blank?
-            content_present_in_this_repo = new_repo
-                                            .library_instance
-                                            .errata
-                                            .with_identifiers(errata_ids)
-                                            .exists?
-            if content_present_in_this_repo
-              copy_outputs << plan_action(Pulp::Repository::CopyUnits, new_repo.library_instance, new_repo,
-                                          ::Katello::Erratum.with_identifiers(errata_ids),
-                                          incremental_update: dep_solve).output
-            end
-          end
-
-          unless package_ids.blank?
-            content_present_in_this_repo = new_repo
-                                            .library_instance
-                                            .rpms
-                                            .with_identifiers(package_ids)
-                                            .exists?
-            if content_present_in_this_repo
-              copy_outputs << plan_action(Pulp::Repository::CopyUnits, new_repo.library_instance, new_repo,
-                                          ::Katello::Rpm.with_identifiers(package_ids),
-                                          incremental_update: dep_solve).output
-            end
-          end
-
-          copy_outputs
-        end
-
         def plan_copy(action_class, source_repo, target_repo, clauses = nil, override_config = nil)
           plan_action(action_class,
                       :source_pulp_id => source_repo.pulp_id,

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

@@ -19,7 +19,7 @@ module Actions
 
         def run
           models = []
-          ::Katello::RepositoryTypeManager.repository_types.each_value do |repo_type|
+          ::Katello::RepositoryTypeManager.enabled_repository_types.each_value do |repo_type|
             indexable_types = repo_type.content_types_to_index
             models += indexable_types&.map(&:model_class)
             models.select! { |model| model.many_repository_associations }

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

@@ -2,20 +2,18 @@ module Actions
   module Katello
     module Repository
       class CloneContents < Actions::Base
-        include Actions::Katello::PulpSelector
         include Actions::Katello::CheckMatchingContent
 
         def plan(source_repositories, new_repository, options)
           filters = options.fetch(:filters, nil)
           rpm_filenames = options.fetch(:rpm_filenames, nil)
           generate_metadata = options.fetch(:generate_metadata, true)
-          purge_empty_contents = options.fetch(:purge_empty_contents, false)
           copy_contents = options.fetch(:copy_contents, true)
           solve_dependencies = options.fetch(:solve_dependencies, false)
 
           sequence do
             if copy_contents
-              plan_pulp_action([Pulp3::Orchestration::Repository::CopyAllUnits, Pulp::Orchestration::Repository::CopyAllUnits],
+              plan_action(Pulp3::Orchestration::Repository::CopyAllUnits,
                           new_repository,
                           SmartProxy.pulp_primary,
                           source_repositories,
@@ -29,10 +27,6 @@ module Actions
             index_options[:source_repository_id] = source_repositories.first.id if source_repositories.count == 1 && filters.empty? && rpm_filenames.nil?
             index_options[:matching_content] = matching_content
             plan_action(Katello::Repository::IndexContent, index_options)
-
-            if purge_empty_contents && new_repository.backend_service(SmartProxy.pulp_primary).should_purge_empty_contents?
-              plan_action(Katello::Repository::PurgeEmptyContent, id: new_repository.id)
-            end
           end
         end
 

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

@@ -4,18 +4,12 @@ module Actions
       # Clones the contnet of the repository into the environment
       # effectively promotion the repository to the environment
       class CloneToEnvironment < Actions::Base
-        include Actions::Katello::PulpSelector
         def plan(repository, environment)
           clone = find_or_build_environment_clone(repository, environment)
 
           sequence do
             if clone.new_record?
-              plan_action(Repository::Create, clone, clone: true)
-            else
-              #only clear if it should be empty, but its not
-              plan_optional_pulp_action([Actions::Pulp::Repository::Clear], clone, SmartProxy.pulp_primary)
-              # Do we need to refresh distributors here?
-              plan_optional_pulp_action([Actions::Pulp::Orchestration::Repository::RefreshIfNeeded], clone, SmartProxy.pulp_primary)
+              plan_action(Repository::Create, clone, true)
             end
 
             plan_action(::Actions::Katello::Repository::CloneContents, [repository], clone, :copy_contents => !clone.yum?)

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

@@ -2,9 +2,7 @@ module Actions
   module Katello
     module Repository
       class Create < Actions::EntryAction
-        def plan(repository, args = {})
-          clone = args[:clone] || false
-          force_repo_create = args[:force_repo_create] || false
+        def plan(repository, clone = false)
           repository.save!
           root = repository.root
 
@@ -13,7 +11,7 @@ module Actions
           org = repository.organization
           sequence do
             create_action = plan_action(Pulp3::Orchestration::Repository::Create,
-                                        repository, SmartProxy.pulp_primary, force_repo_create)
+                                        repository, SmartProxy.pulp_primary)
 
             return if create_action.error
 
@@ -24,10 +22,8 @@ module Actions
               if repository.product.redhat?
                 plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env.cp_id, :content_id => repository.content_id)
               else
-                unless root.content
-                  content_create = plan_action(Katello::Product::ContentCreate, root)
-                  plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env.cp_id, :content_id => content_create.input[:content_id])
-                end
+                content_create = plan_action(Katello::Product::ContentCreate, root)
+                plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env.cp_id, :content_id => content_create.input[:content_id])
               end
             end
 

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

@@ -10,7 +10,7 @@ module Actions
           repository.relative_path = repository.custom_repo_path
           repository.save!
           action_subject(repository)
-          plan_action(::Actions::Katello::Repository::Create, repository)
+          plan_action(::Actions::Katello::Repository::Create, repository, false)
         end
 
         def humanized_name

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

@@ -2,7 +2,6 @@ module Actions
   module Katello
     module Repository
       class Destroy < Actions::EntryAction
-        include Actions::Katello::PulpSelector
         middleware.use ::Actions::Middleware::RemoteAction
 
         # options:
@@ -20,8 +19,7 @@ module Actions
             fail repository.errors.messages.values.join("\n")
           end
 
-          plan_pulp_action([Actions::Pulp::Orchestration::Repository::Delete,
-                            Actions::Pulp3::Orchestration::Repository::Delete],
+          plan_action(Actions::Pulp3::Orchestration::Repository::Delete,
                            repository,
                            SmartProxy.pulp_primary)
 

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

@@ -13,6 +13,7 @@ module Actions
           unit_keys = repo_service.unit_keys(uploads)
           generate_metadata = options.fetch(:generate_metadata, true)
           sync_capsule = options.fetch(:sync_capsule, true)
+          generate_applicability = options.fetch(:generate_applicability, repository.yum?)
 
           options[:content_type] ||= ::Katello::RepositoryTypeManager.find(repository.content_type).default_managed_content_type.label
           unit_type_id = SmartProxy.pulp_primary.content_service(options[:content_type])::CONTENT_TYPE
@@ -29,8 +30,7 @@ module Actions
                   unit_metadata: unit_metadata
                 }
 
-                import_upload = plan_pulp_action([Actions::Pulp::Repository::ImportUpload,
-                                                  Actions::Pulp3::Orchestration::Repository::ImportUpload],
+                import_upload = plan_action(Actions::Pulp3::Orchestration::Repository::ImportUpload,
                                   repository, SmartProxy.pulp_primary, import_upload_args)
                 plan_action(FinishUpload, repository, :import_upload_task => import_upload.output,
                             generate_metadata: false, content_type: options[:content_type])
@@ -38,6 +38,7 @@ module Actions
               end
             end
             plan_action(Katello::Repository::MetadataGenerate, repository) if generate_metadata
+            plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repository.id]) if generate_applicability
             plan_self(repository_id: repository.id, sync_capsule: sync_capsule, upload_results: upload_results)
           end
         end

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

@@ -7,7 +7,7 @@ module Actions
         def plan(repository)
           action_subject repository
           repository.save!
-          plan_action(::Actions::Pulp::Repository::Refresh, repository)
+          plan_action(::Actions::Pulp3::Orchestration::Repository::RefreshIfNeeded, repository)
           plan_self(:repository_id => repository.id)
         end
 

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

@@ -2,22 +2,16 @@ module Actions
   module Katello
     module Repository
       class MetadataGenerate < Actions::Base
-        include Actions::Katello::PulpSelector
-
         def plan(repository, options = {})
-          dependency = options.fetch(:dependency, nil)
-          force = options.fetch(:force, false)
           source_repository = options.fetch(:source_repository, nil)
           source_repository ||= repository.target_repository if repository.link?
           smart_proxy = options.fetch(:smart_proxy, SmartProxy.pulp_primary)
           matching_content = options.fetch(:matching_content, false)
 
-          plan_pulp_action([Pulp::Repository::DistributorPublish, Pulp3::Orchestration::Repository::GenerateMetadata],
+          plan_action(Pulp3::Orchestration::Repository::GenerateMetadata,
                         repository, smart_proxy,
-                        :force => force,
                         :source_repository => source_repository,
-                        :matching_content => matching_content,
-                        :dependency => dependency)
+                        :matching_content => matching_content)
         end
       end
     end

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

@@ -2,7 +2,6 @@ module Actions
   module Katello
     module Repository
       class MultiCloneContents < Actions::Base
-        include Actions::Katello::PulpSelector
         include Actions::Katello::CheckMatchingContent
 
         def plan(extended_repo_mapping, options)

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

@@ -2,13 +2,10 @@ module Actions
   module Katello
     module Repository
       class RefreshRepository < Actions::Base
-        include Actions::Katello::PulpSelector
-
         def plan(repo, options = {})
           User.as_anonymous_admin do
             repo = ::Katello::Repository.find(repo.id)
-            plan_pulp_action([Actions::Pulp3::Orchestration::Repository::RefreshIfNeeded,
-                              Actions::Pulp::Orchestration::Repository::RefreshIfNeeded],
+            plan_action(Actions::Pulp3::Orchestration::Repository::RefreshIfNeeded,
                              repo, SmartProxy.default_capsule!, :dependency => options[:dependency])
             plan_self(:name => repo.name, :dependency => options[:dependency])
           end

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

@@ -3,7 +3,6 @@ module Actions
     module Repository
       class RemoveContent < Actions::EntryAction
         include Dynflow::Action::WithSubPlans
-        include Actions::Katello::PulpSelector
 
         def plan(repository, content_units, options = {})
           sync_capsule = options.fetch(:sync_capsule, true)
@@ -18,19 +17,22 @@ module Actions
 
           content_unit_ids = content_units.map(&:id)
           content_unit_type = options[:content_type] || content_units.first.class::CONTENT_TYPE
+          ::Katello::RepositoryTypeManager.check_content_matches_repo_type!(repository, content_unit_type)
+
+          generate_applicability = options.fetch(:generate_applicability, repository.yum?)
 
           sequence do
             remove_content_args = {
               :contents => content_unit_ids,
               :content_unit_type => content_unit_type}
             repository.clear_smart_proxy_sync_histories
-            pulp_action = plan_pulp_action(
-              [Pulp::Orchestration::Repository::RemoveUnits,
-               Pulp3::Orchestration::Repository::RemoveUnits],
+            pulp_action = plan_action(
+              Pulp3::Orchestration::Repository::RemoveUnits,
               repository, SmartProxy.pulp_primary, remove_content_args)
             return if pulp_action.error
             plan_self(:content_unit_class => content_units.first.class.name, :content_unit_ids => content_unit_ids)
             plan_action(CapsuleSync, repository) if sync_capsule
+            plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repository.id]) if generate_applicability
           end
         end
 

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

@@ -5,7 +5,6 @@ module Actions
       class Sync < Actions::EntryAction
         extend ApipieDSL::Class
         include Helpers::Presenter
-        include Actions::Katello::PulpSelector
         include ::Actions::ObservableAction
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
@@ -20,12 +19,10 @@ module Actions
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/CyclomaticComplexity
         # rubocop:disable Metrics/PerceivedComplexity
-        # rubocop:disable Metrics/AbcSize
         def plan(repo, options = {})
           action_subject(repo)
 
           source_url = options.fetch(:source_url, nil)
-          incremental = options.fetch(:incremental, false)
           validate_contents = options.fetch(:validate_contents, false)
           skip_metadata_check = options.fetch(:skip_metadata_check, false) || (validate_contents && repo.yum?)
           generate_applicability =  options.fetch(:generate_applicability, repo.yum?)
@@ -37,25 +34,17 @@ module Actions
           pulp_sync_options = {}
           pulp_sync_options[:download_policy] = ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND if validate_contents && repo.yum?
 
-          #pulp2 options
-          pulp_sync_options[:force_full] = true if skip_metadata_check && repo.yum?
-          pulp_sync_options[:repair_sync] = true if validate_contents && repo.deb?
-          pulp_sync_options[:remove_missing] = false if incremental
-          pulp_sync_options[:source_url] = source_url
-
           #pulp3 options
           pulp_sync_options[:optimize] = false if skip_metadata_check && repo.yum?
 
           sequence do
-            if SmartProxy.pulp_primary.pulp3_support?(repo) && validate_contents
+            if validate_contents
               plan_action(Katello::Repository::VerifyChecksum, repo)
             else
-              plan_action(Pulp::Repository::RemoveUnits, :repo_id => repo.id, :content_unit_type => ::Katello::YumMetadataFile::CONTENT_TYPE) if validate_contents && repo.yum?
-              sync_action = plan_pulp_action([Actions::Pulp::Orchestration::Repository::Sync,
-                                              Actions::Pulp3::Orchestration::Repository::Sync],
-                                             repo,
-                                             SmartProxy.pulp_primary,
-                                             pulp_sync_options)
+              sync_action = plan_action(Actions::Pulp3::Orchestration::Repository::Sync,
+                                        repo,
+                                        SmartProxy.pulp_primary,
+                                        pulp_sync_options)
               output = sync_action.output
 
               contents_changed = skip_metadata_check || output[:contents_changed]
@@ -65,7 +54,6 @@ module Actions
               plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
               plan_action(Katello::Repository::CorrectChecksum, repo)
               concurrence do
-                plan_action(Pulp::Repository::Download, :pulp_id => repo.pulp_id, :options => {:verify_all_units => true}) if validate_contents && repo.yum?
                 plan_action(Katello::Repository::MetadataGenerate, repo, :force => true) if skip_metadata_check && repo.yum?
                 plan_action(Katello::Repository::ErrataMail, repo, nil, contents_changed)
                 plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repo.id]) if generate_applicability
@@ -99,19 +87,11 @@ module Actions
         end
 
         def presenter
-          found = all_planned_actions(Pulp::Repository::Sync)
           found = all_planned_actions(Pulp3::Repository::Sync) if found.empty?
           found = all_planned_actions(Pulp3::Repository::Repair) if found.empty?
           Helpers::Presenter::Delegated.new(self, found)
         end
 
-        def pulp_task_id
-          pulp_action = planned_actions(Pulp::Repository::Sync).first
-          if (pulp_task = Array(pulp_action.external_task).first)
-            pulp_task.fetch(:task_id)
-          end
-        end
-
         def rescue_strategy
           Dynflow::Action::Rescue::Skip
         end

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

@@ -36,8 +36,7 @@ module Actions
           end
           if root.pulp_update_needed?
             sequence do
-              plan_pulp_action([::Actions::Pulp::Orchestration::Repository::Refresh,
-                                ::Actions::Pulp3::Orchestration::Repository::Update],
+              plan_action(::Actions::Pulp3::Orchestration::Repository::Update,
                                repository,
                                SmartProxy.pulp_primary)
               plan_self(:repository_id => root.library_instance.id)

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

@@ -2,12 +2,9 @@ module Actions
   module Katello
     module Repository
       class UpdateHttpProxyDetails < Actions::EntryAction
-        include Actions::Katello::PulpSelector
-
         def plan(repository)
-          plan_pulp_action(
-            [Actions::Pulp::Orchestration::Repository::Refresh,
-             Actions::Pulp3::Repository::UpdateRemote],
+          plan_action(
+            Actions::Pulp3::Repository::UpdateRemote,
             repository,
             SmartProxy.pulp_primary)
         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::Pulp::Repository::Refresh, repo)
+          plan_action(::Actions::Pulp3::Orchestration::Repository::RefreshIfNeeded, repo)
           plan_self(:repository_id => repo.id)
         end
 

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

@@ -7,20 +7,24 @@ module Actions
     module Repository
       class UploadFiles < Actions::EntryAction
         include Actions::Katello::PulpSelector
-        def plan(repository, files, content_type = nil)
+        def plan(repository, files, content_type = nil, options = {})
           action_subject(repository)
           repository.clear_smart_proxy_sync_histories
           tmp_files = prepare_tmp_files(files)
 
           content_type ||= ::Katello::RepositoryTypeManager.find(repository.content_type).default_managed_content_type.label
+          ::Katello::RepositoryTypeManager.check_content_matches_repo_type!(repository, content_type)
+
           unit_type_id = SmartProxy.pulp_primary.content_service(content_type)::CONTENT_TYPE
           upload_actions = []
+
+          generate_applicability = options.fetch(:generate_applicability, repository.yum?)
+
           sequence do
             concurrence do
               tmp_files.each do |file|
                 sequence do
-                  upload_action = plan_pulp_action([Pulp::Orchestration::Repository::UploadContent,
-                                                    Pulp3::Orchestration::Repository::UploadContent],
+                  upload_action = plan_action(Pulp3::Orchestration::Repository::UploadContent,
                                                    repository, SmartProxy.pulp_primary!, file, unit_type_id)
 
                   upload_actions << upload_action.output
@@ -30,6 +34,7 @@ module Actions
 
             plan_action(FinishUpload, repository, content_type: content_type, upload_actions: upload_actions)
             plan_self(tmp_files: tmp_files)
+            plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repository.id]) if generate_applicability
           end
         ensure
           # Delete tmp files when some exception occurred. Would be

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

@@ -2,21 +2,12 @@ module Actions
   module Katello
     module Repository
       class UploadPackageGroup < Actions::EntryAction
-        def plan(repository, params)
+        def plan(repository, _params)
           action_subject(repository)
-          unit_key = {"repo_id": repository.pulp_id, "id": params[:name].parameterize.underscore}
 
           sequence do
-            upload_request = plan_action(Pulp::Repository::CreateUploadRequest)
-            pkg_group_upload = plan_action(Pulp::Repository::ImportUpload,
-                                           pulp_id: repository.pulp_id,
-                                           unit_type_id: 'package_group',
-                                           unit_key: unit_key,
-                                           upload_id: upload_request.output[:upload_id],
-                                           unit_metadata: params)
-
             plan_action(IndexPackageGroups, repository)
-            plan_action(FinishUpload, repository, :dependency => pkg_group_upload.output, :generate_metadata => true)
+            plan_action(FinishUpload, repository, :generate_metadata => true)
           end
         end
 

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

@@ -3,7 +3,6 @@ module Actions
     module Repository
       class VerifyChecksum < Actions::EntryAction
         include Helpers::Presenter
-        include Actions::Katello::PulpSelector
 
         def plan(repo)
           action_subject(repo)

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

@@ -15,7 +15,7 @@ module Actions
             fail ::Katello::Errors::ConflictException, _("The repository is already enabled")
           end
           repository = mapper.build_repository
-          plan_action(Repository::Create, repository, clone: false)
+          plan_action(Repository::Create, repository, false)
           action_subject(repository)
           plan_self
         end

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

@@ -3,9 +3,9 @@ module Actions
     module Orchestration
       module Repository
         class Create < Pulp3::Abstract
-          def plan(repository, smart_proxy, force = false)
+          def plan(repository, smart_proxy)
             sequence do
-              create_action = plan_action(Actions::Pulp3::Repository::Create, repository, smart_proxy, force)
+              create_action = plan_action(Actions::Pulp3::Repository::Create, repository, smart_proxy)
               plan_action(Actions::Pulp3::Repository::SaveVersion, repository, repository_details: create_action.output[:response])
 
               if repository.content_view.default? || !smart_proxy.pulp_primary?

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

@@ -2,14 +2,13 @@ module Actions
   module Pulp3
     module Repository
       class Create < Pulp3::Abstract
-        def plan(repository, smart_proxy, force = false)
-          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :force => force)
+        def plan(repository, smart_proxy)
+          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id)
         end
 
         def run
           repo = ::Katello::Repository.find(input[:repository_id])
-          force = input[:force] || false
-          output[:response] = repo.backend_service(smart_proxy).with_mirror_adapter.create(force)
+          output[:response] = repo.backend_service(smart_proxy).with_mirror_adapter.create
         end
       end
     end

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

@@ -3,12 +3,7 @@ module Actions
     module Repository
       class CreateRemote < Pulp3::Abstract
         def plan(repository, smart_proxy)
-          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id) if repository.root.url?
-        end
-
-        def run
-          repo = ::Katello::Repository.find(input[:repository_id])
-          output[:response] = repo.backend_service(smart_proxy).create_remote
+          repository.backend_service(smart_proxy).create_remote if repository.root.url?
         end
 
         def rescue_strategy