katello 4.0.3 → 4.1.0.rc1

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

@@ -2,35 +2,33 @@ module Actions
   module Katello
     module ContentViewVersion
       class Export < Actions::EntryAction
-        def plan(content_view_version, export_to_iso, since, iso_size)
-          # assemble data to feed to Pulp
-          content_view = ::Katello::ContentView.find(content_view_version.content_view_id)
-          org_label = ::Organization.find_by(:id => content_view.organization_id).label
-          group_id = "#{org_label}-#{content_view.label}-"\
-                     "v#{content_view_version.major}.#{content_view_version.minor}"
-          action_subject(content_view_version)
+        output_format do
+          param :exported_file_checksum, Hash
+          param :export_path, String
+        end
 
-          repos = content_view_version.archived_repos.select { |r| r.content_type == 'yum' }
+        def plan(options)
+          action_subject(options.fetch(:content_view_version))
 
-          history = ::Katello::ContentViewHistory.create!(:content_view_version => content_view_version,
-                                                          :user => ::User.current.login,
-                                                          :status => ::Katello::ContentViewHistory::IN_PROGRESS,
-                                                          :action => ::Katello::ContentViewHistory.actions[:export],
-                                                          :task => self.task)
+          sequence do
+            export_output = plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Export, options).output
 
-          plan_action(Katello::Repository::Export, repos, export_to_iso, since, iso_size,
-                                                   group_id)
-          plan_self(:history_id => history.id)
+            plan_self(export_history_id: export_output[:export_history_id],
+                      exported_file_checksum: export_output[:exported_file_checksum],
+                      export_path: export_output[:export_path])
+          end
         end
 
-        def humanized_name
-          _("Export")
+        def run
+          output.update(
+            export_history_id: input[:export_history_id],
+            export_path: input[:export_path],
+            exported_file_checksum: input[:exported_file_checksum]
+          )
         end
 
-        def finalize
-          history = ::Katello::ContentViewHistory.find(input[:history_id])
-          history.status = ::Katello::ContentViewHistory::SUCCESSFUL
-          history.save!
+        def humanized_name
+          _("Export")
         end
 
         def rescue_strategy

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

@@ -2,24 +2,38 @@ module Actions
   module Katello
     module ContentViewVersion
       class Import < Actions::EntryAction
-        def plan(content_view, path:, metadata:)
+        def plan(organization:, path:, metadata:, library: false)
+          fail _("Content view not provided in the metadata") if metadata[:content_view].blank?
+          content_view = ::Katello::Pulp3::ContentViewVersion::Import.
+                                find_or_create_import_view(organization: organization,
+                                                           metadata: metadata[:content_view],
+                                                           library: library)
           content_view.check_ready_to_import!
-          unless SmartProxy.pulp_primary.pulp3_repository_type_support?(::Katello::Repository::YUM_TYPE)
-            fail _("This action will become available after the Pulp 3 content migration")
-          end
-
-          ::Katello::Pulp3::ContentViewVersion::Import.check!(content_view: content_view, metadata: metadata, path: path)
-          ::Katello::Pulp3::ContentViewVersion::Import.reset_content_view_repositories_from_metadata!(content_view: content_view, metadata: metadata)
+          ::Katello::Pulp3::ContentViewVersion::Import.check!(content_view: content_view,
+                                                              metadata: metadata,
+                                                              path: path,
+                                                              smart_proxy: SmartProxy.pulp_primary!)
 
           major = metadata[:content_view_version][:major]
           minor = metadata[:content_view_version][:minor]
+          description = metadata[:content_view_version][:description]
 
-          plan_action(::Actions::Katello::ContentView::Publish, content_view, '',
-                        path: path,
-                        metadata: metadata,
-                        importing: true,
-                        major: major,
-                        minor: minor)
+          gpg_helper = ::Katello::Pulp3::ContentViewVersion::ImportGpgKeys.
+                          new(organization: organization,
+                              metadata: metadata)
+          gpg_helper.import!
+
+          sequence do
+            plan_action(AutoCreateProducts, organization: content_view.organization, metadata: metadata)
+            plan_action(AutoCreateRepositories, organization: content_view.organization, metadata: metadata)
+            plan_action(ResetContentViewRepositoriesFromMetadata, content_view: content_view, metadata: metadata)
+            plan_action(::Actions::Katello::ContentView::Publish, content_view, description,
+                          path: path,
+                          metadata: metadata,
+                          importing: true,
+                          major: major,
+                          minor: minor)
+          end
         end
 
         def humanized_name

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

@@ -4,8 +4,10 @@ module Actions
       class ImportLibrary < Actions::EntryAction
         def plan(organization, path:, metadata:)
           action_subject(organization)
-          library_view = ::Katello::Pulp3::ContentViewVersion::Import.find_or_create_library_import_view(organization)
-          plan_action(::Actions::Katello::ContentViewVersion::Import, library_view, path: path, metadata: metadata)
+          plan_action(::Actions::Katello::ContentViewVersion::Import, organization: organization,
+                                                                      library: true,
+                                                                      path: path,
+                                                                      metadata: metadata)
         end
 
         def humanized_name

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

@@ -9,8 +9,7 @@ module Actions
         HUMANIZED_TYPES = {
           ::Katello::Erratum::CONTENT_TYPE => "Errata",
           ::Katello::Rpm::CONTENT_TYPE => "Packages",
-          ::Katello::Deb::CONTENT_TYPE => "Deb Packages",
-          ::Katello::PuppetModule::CONTENT_TYPE => "Puppet Modules"
+          ::Katello::Deb::CONTENT_TYPE => "Deb Packages"
         }.freeze
 
         def humanized_name
@@ -19,7 +18,6 @@ module Actions
 
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/CyclomaticComplexity
         def plan(old_version, environments, options = {})
           dep_solve = options.fetch(:resolve_dependencies, true)
           description = options.fetch(:description, '')
@@ -73,15 +71,8 @@ module Actions
                 unit_map = pulp3_content_mapping(content)
 
                 unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
-                  sequence do
-                    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].keys.include?(source_repos)
-                        copy_repos(repository_mapping[source_repos])
-                      end
-                    end
-                  end
+                  copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
+                                                     dependency_solving: dep_solve).output
                 end
               end
 
@@ -95,17 +86,6 @@ module Actions
                   end
                 end
               end
-
-              if SmartProxy.pulp_primary.has_feature?(SmartProxy::PULP_FEATURE) && SETTINGS[:katello][:content_types][:puppet]
-                sequence do
-                  new_puppet_environment = plan_action(Katello::ContentViewPuppetEnvironment::Clone, old_version,
-                                                     :new_version => new_content_view_version).new_puppet_environment
-                  check_puppet_module_duplicates(content[:puppet_module_ids])
-                  unless content[:puppet_module_ids].blank?
-                    copy_action_outputs += copy_puppet_content(new_puppet_environment, content[:puppet_module_ids], old_version)
-                  end
-                end
-              end
             end
 
             plan_self(:content_view_id => old_version.content_view.id,
@@ -158,9 +138,15 @@ module Actions
           end
         end
 
-        def copy_repos(new_repo, _new_version = nil, _content = nil, _dep_solve = nil)
+        def copy_repos(new_repo, new_version, content, dep_solve)
           copy_output = []
           sequence do
+            solve_dependencies = new_version.content_view.solve_dependencies || dep_solve
+            copy_output += copy_deb_content(new_repo, solve_dependencies, content[:deb_ids])
+            copy_output += copy_yum_content(new_repo, solve_dependencies,
+                                            content[:package_ids],
+                                            content[:errata_ids])
+
             plan_action(Katello::Repository::MetadataGenerate, new_repo)
             plan_action(Katello::Repository::IndexContent, id: new_repo.id)
           end
@@ -211,8 +197,7 @@ module Actions
           content = { ::Katello::Erratum::CONTENT_TYPE => [],
                       ::Katello::Rpm::CONTENT_TYPE => [],
                       ::Katello::ModuleStream::CONTENT_TYPE => [],
-                      ::Katello::Deb::CONTENT_TYPE => [],
-                      ::Katello::PuppetModule::CONTENT_TYPE => []
+                      ::Katello::Deb::CONTENT_TYPE => []
                     }
 
           base_repos = ::Katello::ContentViewVersion.find(input[:old_version]).repositories
@@ -253,8 +238,6 @@ module Actions
                       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']}"
-                    when ::Katello::PuppetModule::CONTENT_TYPE
-                      content[::Katello::PuppetModule::CONTENT_TYPE] << "#{unit['author']}-#{unit['name']}-#{unit['version']}"
                     end
                   end
                 end
@@ -295,7 +278,7 @@ module Actions
 
         def generate_description(version, content)
           humanized_lines = []
-          [::Katello::Erratum, ::Katello::Rpm, ::Katello::PuppetModule].each do |content_type|
+          [::Katello::Erratum, ::Katello::Rpm].each do |content_type|
             unless content[content_type::CONTENT_TYPE].blank?
               humanized_lines << "#{HUMANIZED_TYPES[content_type::CONTENT_TYPE]}:"
               humanized_lines += content[content_type::CONTENT_TYPE].sort.map { |unit| "    #{unit}" }
@@ -391,44 +374,6 @@ module Actions
           copy_outputs
         end
 
-        def check_puppet_module_duplicates(puppet_module_ids)
-          puppet_module_dup_counts = ::Katello::PuppetModule.where(id: puppet_module_ids).
-            select(:name, :author).group(:name, :author).having("count(*) > 1").size
-          if puppet_module_dup_counts.present?
-            offending_puppet_modules = puppet_module_dup_counts.keys.collect do |dup|
-              "#{dup[0]}-#{dup[1]}"
-            end
-            fail _("Adding multiple versions of the same Puppet Module is not supported by incremental update.  The following Puppet Modules have duplicate versions in the incremental update content list: %{dup_list}" % {:dup_list => offending_puppet_modules})
-          end
-        end
-
-        def remove_puppet_modules(repo, puppet_module_ids)
-          plan_action(Pulp::Repository::RemoveUnits, :content_view_puppet_environment_id => repo.id, :contents => puppet_module_ids, :content_unit_type => ::Katello::PuppetModule::CONTENT_TYPE)
-        end
-
-        def copy_puppet_content(new_repo, puppet_module_ids, old_version)
-          copy_outputs = []
-          # Remove older versions
-          query = 'SELECT a.* FROM katello_puppet_modules a LEFT JOIN katello_puppet_modules b ON a.name = b.name AND a.author = b.author AND a.sortable_version < b.sortable_version WHERE b.sortable_version IS NOT NULL AND a.id IN (:old_version_puppet_module_ids)'
-          old_puppet_module_ids = ::Katello::PuppetModule.find_by_sql([query, :old_version_puppet_module_ids => old_version.puppet_modules.map(&:id)]).map(&:id)
-          unless puppet_module_ids.blank?
-            remove_puppet_modules(new_repo, (old_puppet_module_ids + puppet_module_ids).uniq)
-            copy_outputs = puppet_module_ids.map { |module_id| copy_puppet_module(new_repo, module_id).output }
-            plan_action(Pulp::ContentViewPuppetEnvironment::IndexContent, id: new_repo.id)
-          end
-          copy_outputs
-        end
-
-        def find_puppet_modules(ids)
-          ::Katello::PuppetModule.with_identifiers(ids)
-        end
-
-        def copy_puppet_module(new_repo, module_id)
-          puppet_module = find_puppet_modules([module_id]).first
-          possible_repos = puppet_module.repositories.in_organization(new_repo.organization).in_default_view
-          plan_action(Pulp::ContentViewPuppetEnvironment::CopyContents, new_repo, source_repository_id: possible_repos.first.id, puppet_modules: [puppet_module])
-        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/content_view_version/republish_repositories.rb

@@ -6,10 +6,6 @@ module Actions
           action_subject(content_view_version.content_view)
           plan_self(:version_id => content_view_version.id)
           plan_action(::Actions::Katello::Repository::BulkMetadataGenerate, content_view_version.repositories, :force => true)
-
-          content_view_version.content_view_puppet_environments.each do |repo|
-            plan_action(::Actions::Katello::Repository::MetadataGenerate, repo, :force => true)
-          end
         end
 
         def run

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

@@ -0,0 +1,11 @@
+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)
+        end
+      end
+    end
+  end
+end

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

@@ -17,7 +17,6 @@ module Actions
 
         def finalize
           User.as_anonymous_admin do
-            environment  = ::Katello::KTEnvironment.find(input[:environment_id])
             content_view = ::Katello::ContentView.find(input[:content_view_id])
             repository = ::Katello::Repository.find(input[:repository_id]) if input[:repository_id]
 
@@ -27,8 +26,6 @@ module Actions
                 arch = Architecture.where(:name => repository.distribution_arch).first_or_create!
                 os.architectures << arch unless os.architectures.include?(arch)
               end
-            else
-              ::Katello::Foreman.update_puppet_environment(content_view, environment)
             end
           end
         end

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

@@ -13,10 +13,6 @@ module Actions
           plan_action(::Actions::Candlepin::Consumer::AutoAttachSubscriptions, :uuid => host.subscription_facet.uuid)
         end
 
-        def finalize
-          ::Katello::Pool.import_all
-        end
-
         def resource_locks
           :link
         end

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

@@ -23,7 +23,7 @@ module Actions
                 plan_action(Katello::Repository::RefreshRepository, repo)
               end
             end
-            plan_self
+            plan_self(:organization_name => organization.name)
           end
         end
 
@@ -44,6 +44,12 @@ module Actions
           _("Import Manifest")
         end
 
+        # results in correct grammar on Tasks page,
+        # e.g. "Import manifest for organization Default Organization"
+        def humanized_input
+          "for organization '#{input[:organization_name]}'"
+        end
+
         def finalize
           subject_organization.clear_manifest_expired_notifications
           subject_organization.audit_manifest_action(_('Manifest imported'))

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

@@ -26,15 +26,26 @@ module Actions
                         :label => organization.label,
                         :path => path,
                         :dependency => export_action.output)
-            import_products = plan_action(Candlepin::Owner::ImportProducts, :organization_id => organization.id, :dependency => owner_import.output)
-
+            import_products = plan_action(Candlepin::Owner::ImportProducts,
+              :organization_id => organization.id,
+              :dependency => owner_import.output)
             if manifest_update
-              repositories = ::Katello::Repository.in_default_view.in_product(::Katello::Product.redhat.in_org(organization))
-              repositories.each do |repo|
-                plan_action(Katello::Repository::RefreshRepository, repo, :dependency => import_products.output)
-              end
+              plan_refresh_repos(import_products, organization)
             end
-            plan_self(:organization_id => organization.id)
+
+            plan_self(
+              :organization_id => organization.id,
+              :organization_name => organization.name
+            )
+          end
+        end
+
+        def plan_refresh_repos(import_products_action, org)
+          repositories = ::Katello::Repository.in_default_view.in_product(::Katello::Product.redhat.in_org(org))
+          repositories.each do |repo|
+            plan_action(Katello::Repository::RefreshRepository,
+              repo,
+              :dependency => import_products_action.output)
           end
         end
 
@@ -59,6 +70,16 @@ module Actions
           _("Refresh Manifest")
         end
 
+        # results in correct grammar on Tasks page,
+        # e.g. "Refresh manifest for organization Default Organization"
+        def humanized_input
+          "for organization '#{input[:organization_name]}'"
+        end
+
+        def humanized_output
+          all_planned_actions(Candlepin::Owner::Import).first.humanized_output
+        end
+
         def finalize
           org = ::Organization.find(input[:organization_id])
           org.clear_manifest_expired_notifications

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

@@ -1,13 +1,13 @@
 module Actions
   module Katello
     module OrphanCleanup
-      class RemoveOrphans < Actions::Base
+      class RemoveOrphans < Pulp::Abstract
         input_format do
           param :capsule_id
         end
         def plan(proxy)
           sequence do
-            plan_action(Actions::Pulp::Orchestration::OrphanCleanup::RemoveOrphans, proxy) if (proxy.has_feature?(SmartProxy::PULP_FEATURE) || proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE))
+            plan_action(Actions::Pulp::Orchestration::OrphanCleanup::RemoveOrphans, proxy)
             if proxy.pulp3_enabled?
               plan_action(
                 Actions::Pulp3::Orchestration::OrphanCleanup::RemoveOrphans,

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

@@ -9,7 +9,6 @@ module Actions
             product.setup_label_from_name
             product.cp_id = ::Katello::Product.unused_product_id
             product.save!
-
             plan_action(::Actions::Candlepin::Product::Create,
                         :owner => product.organization.label,
                         :name => product.name,

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

@@ -13,7 +13,6 @@ module Actions
         def run
           source_repo = ::Katello::Repository.find(input[:source_repo_id])
           target_repo = ::Katello::Repository.find(input[:target_repo_id])
-          target_repo_published = target_repo.backend_service(SmartProxy.pulp_primary).published?
 
           if source_repo.content_type == ::Katello::Repository::YUM_TYPE
             srpms_match = srpms_match?(source_repo, target_repo)
@@ -24,14 +23,16 @@ module Actions
             yum_metadata_files = yum_metadata_files_match?(source_repo, target_repo)
             checksum_match = (target_repo.saved_checksum_type == source_repo.saved_checksum_type)
 
+            published = target_repo.backend_service(SmartProxy.pulp_primary).published?
+
             output[:checksum_match] = checksum_match
-            output[:matching_content] = yum_metadata_files && srpms_match && rpms && errata && package_groups && distributions && target_repo_published && checksum_match
+            output[:matching_content] = yum_metadata_files && srpms_match && rpms && errata && package_groups && distributions && published && checksum_match
           end
 
           if source_repo.content_type == ::Katello::Repository::DEB_TYPE
             debs = debs_match?(source_repo, target_repo)
 
-            output[:matching_content] = debs && target_repo_published
+            output[:matching_content] = debs && target_repo.published?
           end
         end
 

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

@@ -20,7 +20,6 @@ module Actions
             fail repository.errors.messages.values.join("\n")
           end
 
-          plan_action(ContentViewPuppetModule::Destroy, repository) if repository.puppet?
           plan_pulp_action([Actions::Pulp::Orchestration::Repository::Delete,
                             Actions::Pulp3::Orchestration::Repository::Delete],
                            repository,
@@ -58,6 +57,7 @@ module Actions
         end
 
         def delete_record(repository, options = {})
+          ::Katello::SyncPlan.remove_disabled_product(repository) if repository.redhat?
           repository.destroy!
           repository.root.destroy! if repository.root.repositories.empty?
           ::Katello::DockerMetaTag.cleanup_tags if options[:docker_cleanup]

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

@@ -54,7 +54,7 @@ module Actions
           proxy_details = {}
           if (proxy = ::HttpProxy.default_global_content_proxy)
             uri = URI(proxy.url)
-            proxy_details[:proxy_host] = "#{uri.host}#{uri.path}"
+            proxy_details[:proxy_host] = "#{uri.scheme}://#{uri.host}#{uri.path}"
             proxy_details[:proxy_port] = uri.port
             proxy_details[:proxy_user] = proxy.username
             proxy_details[:proxy_password] = proxy.password

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

@@ -12,13 +12,10 @@ module Actions
 
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/AbcSize
         # rubocop:disable Metrics/PerceivedComplexity
         def run
           repo = ::Katello::Repository.find(input[:id])
-          if repo.puppet?
-            ::Katello::PuppetModule.import_for_repository(repo)
-          elsif repo.docker?
+          if repo.docker?
             ::Katello::DockerManifest.import_for_repository(repo)
             ::Katello::DockerTag.import_for_repository(repo)
             ::Katello::DockerManifestList.import_for_repository(repo)

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

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

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

@@ -4,7 +4,6 @@ module Actions
       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

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

@@ -8,11 +8,6 @@ module Actions
           smart_proxy_id = action.input[:smart_proxy_id] || action.input[:capsule_id]
           smart_proxy = ::SmartProxy.find_by(id: smart_proxy_id)
 
-          #skip pulp2 puppet syncs
-          if (repo_pulp_id = action.input[:repo_pulp_id])
-            return if ::Katello::ContentViewPuppetEnvironment.find_by(pulp_id: repo_pulp_id)
-          end
-
           if repo && smart_proxy
             self.action.output[:smart_proxy_history_id] = repo.create_smart_proxy_sync_history(smart_proxy)
           else

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

@@ -10,18 +10,12 @@ module Actions
         end
 
         def plan(repository, smart_proxy = SmartProxy.pulp_primary!)
-          if repository.is_a?(::Katello::ContentViewPuppetEnvironment)
-            plan_self(:content_view_puppet_environment_id => repository.id, :capsule_id => smart_proxy.id)
-          else
-            plan_self(:repository_id => repository.id, :capsule_id => smart_proxy.id)
-          end
+          plan_self(:repository_id => repository.id, :capsule_id => smart_proxy.id)
         end
 
         def run
           if input[:repository_id]
             repo = ::Katello::Repository.find(input[:repository_id])
-          else
-            repo = ::Katello::ContentViewPuppetEnvironment.find(input[:content_view_puppet_environment_id]).nonpersisted_repository
           end
           output[:response] = repo.backend_service(smart_proxy(input[:capsule_id])).create
         rescue RestClient::Conflict

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

@@ -6,20 +6,12 @@ module Actions
 
         def plan(repository, smart_proxy, options)
           options = {:smart_proxy_id => smart_proxy.id, :options => options, :dependency => options[:dependency]}
-          if repository.is_a?(::Katello::ContentViewPuppetEnvironment)
-            options[:content_view_puppet_environment_id] = repository.id
-          else
-            options[:repository_id] = repository.id
-          end
+          options[:repository_id] = repository.id
           plan_self(options)
         end
 
         def invoke_external_task
-          if input[:repository_id]
-            repo = ::Katello::Repository.find_by(:id => input[:repository_id])
-          else
-            repo = ::Katello::ContentViewPuppetEnvironment.find_by(:id => input[:content_view_puppet_environment_id]).nonpersisted_repository
-          end
+          repo = ::Katello::Repository.find_by(:id => input[:repository_id])
           repo.clear_smart_proxy_sync_histories if smart_proxy(input[:smart_proxy_id]).pulp_primary?
           repo.backend_service(smart_proxy(input[:smart_proxy_id])).distributor_publish(input[:options])
         end

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

@@ -71,9 +71,7 @@ module Actions
           # For repo sync tasks older than katello 3.14, we only have pulp_id available in input.
           repo ||= ::Katello::Repository.where(:pulp_id => input['pulp_id']).first if input['pulp_id']
 
-          if repo.try(:puppet?)
-            Presenters::PuppetPresenter.new(self)
-          elsif repo.try(:yum?)
+          if repo.try(:yum?)
             Presenters::YumPresenter.new(self)
           elsif repo.try(:file?)
             Presenters::FileUnitPresenter.new(self)

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

@@ -0,0 +1,17 @@
+module Actions
+  module Pulp3
+    module CapsuleContent
+      class RefreshContentGuard < Pulp3::AbstractAsyncTask
+        def plan(smart_proxy, options = {})
+          content_guard_api = ::Katello::Pulp3::Api::ContentGuard.new(smart_proxy)
+          content_guard_href = content_guard_api.list&.results&.first&.pulp_href
+          if content_guard_href && options.try(:[], :update)
+            content_guard_api.partial_update content_guard_href
+          else
+            content_guard_api.create
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,12 +2,16 @@ module Actions
   module Pulp3
     module ContentGuard
       class Refresh < Pulp3::Abstract
-        def plan(smart_proxy)
-          plan_self(smart_proxy_id: smart_proxy.id)
-        end
-
-        def run
-          ::Katello::Pulp3::Api::ContentGuard.new(smart_proxy).refresh
+        def plan(smart_proxy, options = {})
+          return if (::Katello::Pulp3::ContentGuard.count > 0 || options.try(:[], :update))
+          content_guard_api = ::Katello::Pulp3::Api::ContentGuard.new(smart_proxy)
+          if options.try(:[], :update)
+            content_guard_href = ::Katello::Pulp3::ContentGuard.first.href
+            content_guard_api.partial_update content_guard_href
+          else
+            content_guard_api.create
+            ::Katello::Pulp3::ContentGuard.import(smart_proxy)
+          end
         end
       end
     end