katello 3.16.2 → 3.17.0.rc1

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

@@ -0,0 +1,36 @@
+module Actions
+  module Katello
+    module Organization
+      module SimpleContentAccess
+        class Toggle < Actions::AbstractAsyncTask
+          middleware.use Actions::Middleware::PropagateCandlepinErrors
+
+          SIMPLE_CONTENT_ACCESS_DISABLED_VALUE = "entitlement".freeze
+          SIMPLE_CONTENT_ACCESS_ENABLED_VALUE = "org_environment".freeze
+
+          attr_reader :organization
+
+          def plan(organization_id)
+            @organization = ::Organization.find(organization_id)
+
+            ::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)
+          end
+
+          private
+
+          def consumer
+            @consumer ||= ::Katello::Resources::Candlepin::UpstreamCandlepinResource.upstream_consumer
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,6 +13,19 @@ module Actions
                 Actions::Pulp3::Orchestration::OrphanCleanup::RemoveOrphans,
                 proxy)
             end
+            plan_self
+          end
+        end
+
+        def run
+          models = []
+          ::Katello::RepositoryTypeManager.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 }
+          end
+          models.each do |model|
+            model.joins("left join katello_#{model.repository_association} on #{model.table_name}.id = katello_#{model.repository_association}.#{model.unit_id_field}").where("katello_#{model.repository_association}.#{model.unit_id_field} IS NULL").destroy_all
           end
         end
       end

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

@@ -17,7 +17,8 @@ module Actions
               content_id = content_create.output[:response][:id]
               plan_action(Candlepin::Product::ContentAdd, owner: root.product.organization.label,
                                     product_id: root.product.cp_id,
-                                    content_id: content_id)
+                                    content_id: content_id,
+                                    enabled: root.auto_enabled?)
 
             else
               content_id = root.content_id
@@ -51,8 +52,7 @@ module Actions
                                                content_url: root.custom_content_path,
                                                vendor: ::Katello::Provider::CUSTOM)
 
-          #custom product content is always enabled by default
-          ::Katello::ProductContent.create!(product: root.product, content: content, enabled: true)
+          ::Katello::ProductContent.create!(product: root.product, content: content, enabled: root.auto_enabled?)
         end
       end
     end

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

@@ -5,8 +5,6 @@ module Actions
         # rubocop:disable Metrics/MethodLength
         def plan(product, options = {})
           organization_destroy = options.fetch(:organization_destroy, false)
-          skip_environment_update = options.fetch(:skip_environment_update, false) ||
-              options.fetch(:organization_destroy, false)
 
           unless organization_destroy || product.user_deletable?
             if product.redhat?
@@ -26,13 +24,11 @@ module Actions
 
           sequence do
             unless organization_destroy
-              sequence do
-                # ContentDestroy must be called sequentially due to Candlepin's
-                # issues with running multiple remove_content calls at the same time.
-                plan_content_destruction(product, skip_environment_update)
-              end
               concurrence do
-                plan_repo_destruction(product, options)
+                product.repositories.in_default_view.each do |repo|
+                  repo_options = options.clone
+                  plan_action(Katello::Repository::Destroy, repo, repo_options)
+                end
               end
               plan_action(Candlepin::Product::DeletePools,
                             cp_id: product.cp_id, organization_label: product.organization.label)
@@ -69,23 +65,6 @@ module Actions
           product.pool_products.delete_all
         end
 
-        def plan_content_destruction(product, skip_environment_update)
-          product.repositories.in_default_view.each do |repo|
-            if repo.root.repositories.where.not(id: repo.id).empty? &&
-                !repo.redhat? &&
-                !skip_environment_update
-              plan_action(::Actions::Katello::Product::ContentDestroy, repo.root)
-            end
-          end
-        end
-
-        def plan_repo_destruction(product, options)
-          product.repositories.in_default_view.each do |repo|
-            repo_options = options.clone
-            plan_action(Katello::Repository::Destroy, repo, repo_options.merge(destroy_content: false))
-          end
-        end
-
         def view_versions(product)
           cvvs = product.published_content_view_versions.uniq
           views = cvvs.inject({}) do |result, version|

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

@@ -0,0 +1,41 @@
+module Actions
+  module Katello
+    module Repository
+      class ContentUpdate < Actions::Base
+        def plan(repository, update_auto_enabled: false)
+          root = repository.root
+          content = root.content
+          plan_action(::Actions::Candlepin::Product::ContentUpdate,
+                      :owner => repository.organization.label,
+                      :content_id => root.content_id,
+                      :name => root.name,
+                      :content_url => root.custom_content_path,
+                      :gpg_key_url => repository.yum_gpg_key_url,
+                      :label => content.label,
+                      :type => root.content_type,
+                      :arches => root.format_arches)
+
+          if update_auto_enabled
+            plan_action(::Actions::Candlepin::Product::ContentUpdateEnablement,
+                        :owner => repository.organization.label,
+                        :product_id => root.product.cp_id,
+                        :content_enablements => root.content_enablements)
+            plan_self(:repository_id => repository.id)
+          end
+
+          content.update!(name: root.name,
+                                     content_url: root.custom_content_path,
+                                     content_type: repository.content_type,
+                                     label: content.label,
+                                     gpg_url: repository.yum_gpg_key_url)
+        end
+
+        def run
+          repository = ::Katello::Repository.find(input[:repository_id])
+          ::Katello::ProductContent.where(:product => repository.product, :content => repository.content)
+                                 .update(:enabled => repository.root.auto_enabled?)
+        end
+      end
+    end
+  end
+end

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

@@ -7,11 +7,9 @@ module Actions
 
         # options:
         #   skip_environment_update - defaults to false. skips updating the CP environment
-        #   destroy_content - can be disabled to skip Candlepin remove_content
         def plan(repository, options = {})
           skip_environment_update = options.fetch(:skip_environment_update, false) ||
               options.fetch(:organization_destroy, false)
-          destroy_content = options.fetch(:destroy_content, true)
           action_subject(repository)
 
           unless repository.destroyable?
@@ -31,9 +29,7 @@ module Actions
             if repository.redhat?
               handle_redhat_content(repository) unless skip_environment_update
             else
-              if destroy_content && !skip_environment_update
-                handle_custom_content(repository)
-              end
+              handle_custom_content(repository) unless skip_environment_update
             end
           end
         end

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

@@ -69,7 +69,7 @@ module Actions
               sequence do
                 if repo.link?
                   plan_action(Pulp::Repository::Clear, repo, SmartProxy.pulp_master!)
-                  plan_action(Pulp::Repository::CopyAllUnits, repo.target_repository, repo)
+                  plan_action(Pulp::Repository::CopyAllUnits, repo, ::SmartProxy.pulp_master, repo.target_repository)
                 end
               end
             end

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

@@ -16,16 +16,14 @@ module Actions
                           solve_dependencies: solve_dependencies)
             end
 
-            concurrence do
-              extended_repo_mapping.each do |source_repos, dest_repo_map|
-                if generate_metadata
-                  metadata_generate(source_repos, dest_repo_map[:dest_repo], dest_repo_map[:filters])
-                end
+            extended_repo_mapping.each do |source_repos, dest_repo_map|
+              if generate_metadata
+                metadata_generate(source_repos, dest_repo_map[:dest_repo], dest_repo_map[:filters])
               end
+            end
 
-              extended_repo_mapping.values.each do |dest_repo_map|
-                plan_action(Katello::Repository::IndexContent, id: dest_repo_map[:dest_repo].id)
-              end
+            extended_repo_mapping.values.each do |dest_repo_map|
+              plan_action(Katello::Repository::IndexContent, id: dest_repo_map[:dest_repo].id)
             end
           end
         end
@@ -48,15 +46,19 @@ module Actions
 
           plan_action(Katello::Repository::MetadataGenerate, new_repository, metadata_options)
           unless source_repositories.first.saved_checksum_type == new_repository.saved_checksum_type
-            plan_self(:source_checksum_type => source_repositories.first.saved_checksum_type,
-                      :target_repo_id => new_repository.id)
+            checksum_mapping = {}
+            repository_mapping.each do |source_repos, dest_repo|
+              checksum_mapping[dest_repo.id] = source_repos.first.saved_checksum_type
+            end
+            plan_self(:checksum_mapping => checksum_mapping)
           end
         end
 
         def finalize
-          repository = ::Katello::Repository.find(input[:target_repo_id])
-          source_checksum_type = input[:source_checksum_type]
-          repository.update!(saved_checksum_type: source_checksum_type) if (repository && source_checksum_type)
+          input[:checksum_mapping].each do |repo_id, checksum_type|
+            repository = ::Katello::Repository.find(repo_id)
+            repository.update!(saved_checksum_type: checksum_type) if (repository && checksum_type)
+          end
         end
       end
     end

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

@@ -34,47 +34,38 @@ 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_master.pulp3_support?(repo) && 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_master,
-                                             pulp_sync_options)
-              output = sync_action.output
-
-              contents_changed = skip_metadata_check || output[:contents_changed]
-
-              plan_action(Katello::Repository::IndexContent, :id => repo.id, :contents_changed => contents_changed)
-              plan_action(Katello::Foreman::ContentUpdate, repo.environment, repo.content_view, repo)
-              plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
-              plan_action(Katello::Repository::CorrectChecksum, repo)
-              concurrence do
-                plan_action(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)
-                if generate_applicability
-                  regenerate_applicability(repo, contents_changed)
-                end
+            plan_action(Pulp::Repository::RemoveUnits, :repo_id => repo.id, :content_unit_type => ::Katello::YumMetadataFile::CONTENT_TYPE) if validate_contents && repo.yum?
+            sync_args = {:smart_proxy_id => SmartProxy.pulp_master.id, :repo_id => repo.id, :source_url => source_url, :options => pulp_sync_options}
+            sync_action = plan_pulp_action([Actions::Pulp::Orchestration::Repository::Sync,
+                                            Actions::Pulp3::Orchestration::Repository::Sync],
+                                           repo,
+                                           SmartProxy.pulp_master,
+                                           sync_args)
+            output = sync_action.output
+
+            contents_changed = skip_metadata_check || output[:contents_changed]
+
+            plan_action(Katello::Repository::IndexContent, :id => repo.id, :contents_changed => contents_changed)
+            plan_action(Katello::Foreman::ContentUpdate, repo.environment, repo.content_view, repo)
+            plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
+            plan_action(Katello::Repository::CorrectChecksum, repo)
+            concurrence do
+              plan_action(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)
+              if generate_applicability
+                regenerate_applicability(repo, contents_changed)
               end
-              plan_self(:id => repo.id, :sync_result => output, :skip_metadata_check => skip_metadata_check, :validate_contents => validate_contents,
-                        :contents_changed => contents_changed)
-              plan_action(Katello::Repository::ImportApplicability, :repo_id => repo.id, :contents_changed => contents_changed) if generate_applicability
-              plan_action(Katello::Repository::SyncHook, :id => repo.id)
             end
+            plan_self(:id => repo.id, :sync_result => output, :skip_metadata_check => skip_metadata_check, :validate_contents => validate_contents,
+                      :contents_changed => contents_changed)
+            plan_action(Katello::Repository::ImportApplicability, :repo_id => repo.id, :contents_changed => contents_changed) if generate_applicability
+            plan_action(Katello::Repository::SyncHook, :id => repo.id)
           end
         end
 
@@ -100,7 +91,6 @@ module Actions
         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
 

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

@@ -3,14 +3,13 @@ module Actions
     module Repository
       class Update < Actions::EntryAction
         include Actions::Katello::PulpSelector
-
-        # rubocop:disable Metrics/MethodLength
         def plan(root, repo_params)
           repository = root.library_instance
           action_subject root.library_instance
 
           repo_params[:url] = nil if repo_params[:url] == ''
-          update_cv_cert_protected = repo_params.key?(:unprotected) && (repo_params[:unprotected] != repository.unprotected)
+          update_cv_cert_protected = (repo_params[:unprotected] != repository.unprotected)
+          update_auto_enabled = repo_params.key?(:auto_enabled) && (repo_params[:auto_enabled] != root.auto_enabled)
           root.update!(repo_params)
 
           if root.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND
@@ -22,43 +21,33 @@ module Actions
           end
 
           if update_content?(repository)
-            content = root.content
-
-            plan_action(::Actions::Candlepin::Product::ContentUpdate,
-                        :owner => repository.organization.label,
-                        :content_id => root.content_id,
-                        :name => root.name,
-                        :content_url => root.custom_content_path,
-                        :gpg_key_url => repository.yum_gpg_key_url,
-                        :label => content.label,
-                        :type => root.content_type,
-                        :arches => root.format_arches)
-
-            content.update!(name: root.name,
-                                       content_url: root.custom_content_path,
-                                       content_type: repository.content_type,
-                                       label: content.label,
-                                       gpg_url: repository.yum_gpg_key_url)
+            plan_action(Katello::Repository::ContentUpdate, repository,
+                        update_auto_enabled: update_auto_enabled)
           end
+
           if root.pulp_update_needed?
-            sequence do
-              plan_pulp_action([::Actions::Pulp::Orchestration::Repository::Refresh,
-                                ::Actions::Pulp3::Orchestration::Repository::Update],
-                               repository,
-                               SmartProxy.pulp_master)
-              plan_self(:repository_id => root.library_instance.id)
-              if update_cv_cert_protected
-                plan_optional_pulp_action([::Actions::Pulp3::Orchestration::Repository::TriggerUpdateRepoCertGuard], repository, ::SmartProxy.pulp_master)
-              end
-            end
+            plan_pulp_action([::Actions::Pulp::Orchestration::Repository::Refresh,
+                              ::Actions::Pulp3::Orchestration::Repository::Update],
+                             repository,
+                             SmartProxy.pulp_master)
+            plan_self(:repository_id => root.library_instance.id, :update_cv_cert_protected => update_cv_cert_protected)
           end
         end
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])
+          output[:repository_id] = input[:repository_id]
+          output[:update_cv_cert_protected] = input[:update_cv_cert_protected]
           ForemanTasks.async_task(Katello::Repository::MetadataGenerate, repository)
         end
 
+        def finalize
+          repository = ::Katello::Repository.find(output[:repository_id])
+          if output[:update_cv_cert_protected]
+            ForemanTasks.async_task(::Actions::Katello::Repository::UpdateCVRepoCertGuard, repository, SmartProxy.pulp_master)
+          end
+        end
+
         private
 
         def update_content?(repository)

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

@@ -0,0 +1,17 @@
+module Actions
+  module Katello
+    module Repository
+      class UpdateCVRepoCertGuard < Actions::Base
+        include Actions::Katello::PulpSelector
+
+        def plan(repository, smart_proxy)
+          plan_optional_pulp_action([::Actions::Pulp3::Repository::UpdateCVRepositoryCertGuard], repository, smart_proxy)
+        end
+
+        def humanized_name
+          _("Updating repository authentication configuration")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp/orchestration/repository/smart_proxy_sync.rb

@@ -15,6 +15,7 @@ module Actions
               end
               pulp_options = { remove_missing: repository && ["deb", "puppet", "yum"].include?(repository.content_type) }
               pulp_options[:force_full] = true if skip_metadata_check && repository.content_type == "yum"
+              pulp_options[:repair_sync] = true if skip_metadata_check && repository.content_type == "deb"
 
               plan_action(Pulp::Consumer::SyncCapsule,
                                repository, smart_proxy, pulp_options)

data/app/lib/actions/pulp/orchestration/repository/sync.rb

@@ -4,9 +4,8 @@ module Actions
       module Repository
         class Sync < Pulp::Abstract
           include Actions::Helpers::OutputPropagator
-          def plan(repository, smart_proxy, options)
+          def plan(_repository, _smart_proxy, options)
             sequence do
-              options.merge!(:repo_id => repository.id, :smart_proxy_id => smart_proxy.id)
               action_output = plan_action(Actions::Pulp::Repository::Sync, options).output
               plan_self(:subaction_output => action_output)
             end

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

@@ -14,9 +14,8 @@ module Actions
           overrides = {}
           overrides[:feed] = input[:source_url] if input[:source_url]
           overrides[:validate] = !(SETTINGS[:katello][:pulp][:skip_checksum_validation])
-          overrides.merge(input[:options]) if input[:options]
+          overrides[:options] = input[:options] if input[:options]
           repo = ::Katello::Repository.find(input[:repo_id])
-
           output[:pulp_tasks] = repo.backend_service(::SmartProxy.pulp_master).sync(overrides)
         end
 

data/app/lib/actions/pulp3/abstract_async_task.rb

@@ -74,7 +74,6 @@ module Actions
 
       def cancel
         pulp_tasks.each { |task| task.cancel }
-        task_groups.each { |task_group| task_group.cancel }
       end
 
       def rescue_external_task(error)

data/app/lib/actions/pulp3/capsule_content/sync.rb

@@ -11,9 +11,7 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repository_id])
-          sync_options = {}
-          sync_options[:optimize] = false if sync_options[:skip_metadata_check]
-          output[:pulp_tasks] = repo.backend_service(smart_proxy).with_mirror_adapter.sync(sync_options)
+          output[:pulp_tasks] = repo.backend_service(smart_proxy).with_mirror_adapter.sync
         end
 
         def rescue_strategy_for_self

data/app/lib/actions/pulp3/content_view/delete_repository_references.rb

@@ -14,7 +14,7 @@ module Actions
           content_view.repository_references.each do |repository_reference|
             repo = repository_reference.root_repository.library_instance
             #force pulp3 in case we've done migrations, but haven't switched over yet
-            tasks << repo.backend_service(smart_proxy, true).delete_repository(repository_reference)
+            tasks << repo.backend_service(smart_proxy, true).delete(repository_reference.repository_href)
           end
           content_view.repository_references.destroy_all
 

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

@@ -16,7 +16,8 @@ module Actions
                   copy_action = plan_action(Actions::Pulp3::Repository::CopyContent, source_repositories.first, smart_proxy, target_repo,
                                             filter_ids: filter_ids, solve_dependencies: solve_dependencies,
                                             rpm_filenames: rpm_filenames)
-                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: copy_action.output[:pulp_tasks])
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo,
+                              repository_details: { latest_version_href: copy_action.output[:latest_version_href] }, tasks: copy_action.output[:pulp_tasks])
                 else
                   #if we are not filtering, copy the version to the cv repository, and the units for each additional repo
                   action = plan_action(Actions::Pulp3::Repository::CopyVersion, source_repositories.first, smart_proxy, target_repo)

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

@@ -7,9 +7,7 @@ module Actions
           def plan(repository, smart_proxy, options)
             sequence do
               action_output = plan_action(Actions::Pulp3::Repository::Sync, repository, smart_proxy, options).output
-
-              force_fetch_version = true if options[:optimize] == false
-              version_output = plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks], :force_fetch_version => force_fetch_version).output
+              version_output = plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks]).output
               plan_action(Pulp3::Orchestration::Repository::GenerateMetadata, repository, smart_proxy, :contents_changed => version_output[:contents_changed])
               plan_self(:subaction_output => version_output)
             end

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

@@ -11,6 +11,7 @@ module Actions
         def invoke_external_task
           source = ::Katello::Repository.find(input[:source_repository_id])
           target = ::Katello::Repository.find(input[:target_repository_id] || input[:target_repository])
+          output[:latest_version_href] = target.backend_service(smart_proxy).read.latest_version_href
           output[:pulp_tasks] = target.backend_service(smart_proxy).copy_content_for_source(source, input)
         end
       end

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

@@ -8,7 +8,7 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repository_id])
-          output[:response] = repo.backend_service(smart_proxy).delete_repository
+          output[:response] = repo.backend_service(smart_proxy).delete
         end
       end
     end

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

@@ -17,7 +17,7 @@ module Actions
           repo_id_map = {}
 
           input[:repo_id_map].each do |source_repo_ids, dest_repo_map|
-            repo_id_map[JSON.parse(source_repo_ids)] = dest_repo_map.deep_dup
+            repo_id_map[JSON.parse(source_repo_ids)] = dest_repo_map
           end
 
           output[:pulp_tasks] = ::Katello::Repository.find(repo_id_map.values.first[:dest_repo]).backend_service(smart_proxy).copy_content_from_mapping(repo_id_map, input)

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

@@ -3,39 +3,35 @@ module Actions
     module Repository
       class SaveVersion < Pulp3::Abstract
         def plan(repository, options)
-          fail "Cannot accept tasks and repository_details into Save Version." if options[:tasks].present? && options[:repository_details].present?
-          plan_self(:repository_id => repository.id, :tasks => options[:tasks], :repository_details => options[:repository_details], :force_fetch_version => options.fetch(:force_fetch_version, false))
+          plan_self(:repository_id => repository.id, :tasks => options[:tasks], :repository_details => options[:repository_details])
         end
 
         def run
           repo = ::Katello::Repository.find(input[:repository_id])
 
-          if input[:force_fetch_version]
-            version_href = fetch_version_href(repo)
-          elsif input[:repository_details].present?
-            version_href = input[:repository_details][:latest_version_href]
-          elsif input[:tasks].present?
+          if input[:tasks].present?
             version_href = input[:tasks].last[:created_resources].first
-          else
-            version_href = fetch_version_href(repo)
           end
 
-          if version_href
-            if repo.version_href != version_href || input[:force_fetch_version]
-              output[:contents_changed] = true
-              repo.update(:version_href => version_href)
+          unless version_href
+            if input[:repository_details]
+              version_href = input[:repository_details][:latest_version_href]
+            elsif repo.version_href.nil?
+              # Fetch latest Pulp 3 repo version
+              repo_backend_service = repo.backend_service(SmartProxy.pulp_master)
+              version_href ||= repo_backend_service.api.
+                repositories_api.read(repo_backend_service.
+                repository_reference.repository_href).latest_version_href
             end
+          end
+
+          if version_href
+            repo.update(:version_href => version_href)
+            output[:contents_changed] = true
           else
             output[:contents_changed] = false
           end
         end
-
-        def fetch_version_href(repo)
-          # Fetch latest Pulp 3 repo version
-          repo_backend_service = repo.backend_service(SmartProxy.pulp_master)
-          repo_href = repo_backend_service.repository_reference.repository_href
-          repo_backend_service.api.repositories_api.read(repo_href).latest_version_href
-        end
       end
     end
   end

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

@@ -10,7 +10,7 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repo_id])
-          output[:pulp_tasks] = repo.backend_service(::SmartProxy.unscoped.find(input[:smart_proxy_id])).sync(input[:options])
+          output[:pulp_tasks] = repo.backend_service(::SmartProxy.unscoped.find(input[:smart_proxy_id])).sync
         end
 
         def external_task=(tasks)

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

@@ -2,17 +2,13 @@ module Actions
   module Pulp3
     module Repository
       class UpdateCVRepositoryCertGuard < Pulp3::Abstract
-        def plan(repository, smart_proxy)
+        def plan(repository, _smart_proxy)
           root = repository.root
           cv_repositories = root.repositories - [root.library_instance]
           cv_repositories.each do |repo|
-            plan_action(::Actions::Pulp3::Repository::RefreshDistribution, repo, smart_proxy)
+            plan_action(::Actions::Pulp3::Repository::RefreshDistribution, repo, SmartProxy.pulp_master)
           end
         end
-
-        def humanized_name
-          _("Updating repository authentication configuration")
-        end
       end
     end
   end