katello 4.4.2.2 → 4.5.0.rc1

data/app/services/katello/pulp3/repository/yum.rb

@@ -243,12 +243,16 @@ module Katello
           api.content_distribution_trees_api.list(options)
         end
 
-        def add_filter_content(source_repo_ids, filters, filter_list_map)
+        def add_filter_content(source_repo_ids, filters, filter_list_map, additional_included_errata)
           filters.each do |filter|
             if filter.inclusion
               source_repo_ids.each do |repo_id|
                 filter_list_map[:whitelist_ids] += filter.content_unit_pulp_ids(::Katello::Repository.find(repo_id))
               end
+            elsif filter.class == ContentViewErratumFilter
+              source_repo_ids.each do |repo_id|
+                filter_list_map[:blacklist_ids] += filter.content_unit_pulp_ids(::Katello::Repository.find(repo_id), additional_included_errata)
+              end
             else
               source_repo_ids.each do |repo_id|
                 filter_list_map[:blacklist_ids] += filter.content_unit_pulp_ids(::Katello::Repository.find(repo_id))
@@ -297,6 +301,7 @@ module Katello
           filter_list_map
         end
 
+        # rubocop:disable Metrics/MethodLength
         def copy_content_from_mapping(repo_id_map, options = {})
           repo_id_map.each do |source_repo_ids, dest_repo_map|
             filters = [ContentViewErratumFilter, ContentViewPackageGroupFilter, ContentViewPackageFilter].collect do |filter_class|
@@ -305,8 +310,20 @@ module Katello
             modular_filters = ContentViewModuleStreamFilter.where(:id => dest_repo_map[:filter_ids])
             filters.flatten!.compact!
 
+            errata_filters = ContentViewErratumFilter.where(:id => dest_repo_map[:filter_ids])
+
+            # Only filter out RPMs & modules via an erratum filter if they're not included in other allowed errata.
+            # Begin this by calculating all the errata that should be copied.
+            # If there are exclude filters, send the errata to the relevant methods to ensure their contents aren't excluded.
+            additional_included_errata = []
+            all_excluded_errata = []
+            unless errata_filters.blacklist.empty?
+              all_included_errata, all_excluded_errata = filtered_errata(errata_filters, source_repo_ids)
+              additional_included_errata = all_included_errata - all_excluded_errata
+            end
+
             filter_list_map = { whitelist_ids: [], blacklist_ids: [] }
-            filter_list_map = add_filter_content(source_repo_ids, filters, filter_list_map)
+            filter_list_map = add_filter_content(source_repo_ids, filters, filter_list_map, additional_included_errata)
             filter_list_map = add_un_modular_rpms(source_repo_ids, filters, filter_list_map)
             filter_list_map = add_modular_content(source_repo_ids, filters, modular_filters, filter_list_map)
 
@@ -320,7 +337,7 @@ module Katello
 
             if content_unit_hrefs.any?
               source_repo_ids.each do |source_repo_id|
-                content_unit_hrefs += additional_content_hrefs(::Katello::Repository.find(source_repo_id), content_unit_hrefs)
+                content_unit_hrefs += additional_content_hrefs(::Katello::Repository.find(source_repo_id), content_unit_hrefs, all_excluded_errata)
               end
             end
 
@@ -331,29 +348,68 @@ module Katello
 
           multi_copy_units(repo_id_map, dependency_solving)
         end
+        # rubocop:enable Metrics/MethodLength
+
+        # Calculate errata that should be included and excluded.
+        # https://projects.theforeman.org/issues/34437
+        def filtered_errata(errata_filters, source_repository_ids)
+          if errata_filters.whitelist.empty?
+            all_included_errata = ::Katello::Erratum.joins("inner join katello_repository_errata on katello_errata.id = katello_repository_errata.erratum_id").
+              joins("inner join katello_repositories on katello_repositories.id = katello_repository_errata.repository_id").
+              where("katello_repositories.id in (?)", source_repository_ids)
+          else
+            all_included_errata = errata_filters.whitelist.collect do |filter|
+              ::Katello::Erratum.joins("inner join katello_repository_errata on katello_errata.id = katello_repository_errata.erratum_id").
+                where(filter.generate_clauses(nil)).where("katello_repository_errata.repository_id in (?)", source_repository_ids)
+            end
+            all_included_errata.flatten!
+          end
+          all_excluded_errata = errata_filters.blacklist.collect do |filter|
+            ::Katello::Erratum.joins("inner join katello_repository_errata on katello_errata.id = katello_repository_errata.erratum_id").
+              where(filter.generate_clauses(nil)).where("katello_repository_errata.repository_id in (?)", source_repository_ids)
+          end
+          all_excluded_errata.flatten!
+          return all_included_errata, all_excluded_errata
+        end
 
-        def copy_content_for_source(source_repository, options = {}) # rubocop:disable Metrics/CyclomaticComplexity
-          filters = [ContentViewErratumFilter, ContentViewPackageGroupFilter, ContentViewPackageFilter].collect do |filter_class|
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+        def copy_content_for_source(source_repository, options = {})
+          package_filters = [ContentViewPackageGroupFilter, ContentViewPackageFilter].collect do |filter_class|
             filter_class.where(:id => options[:filter_ids])
           end
+          package_filters.flatten!.compact!
+
+          errata_filters = ContentViewErratumFilter.where(:id => options[:filter_ids])
 
-          filters.flatten!.compact!
           whitelist_ids = []
           blacklist_ids = []
-          filters.each do |filter|
+
+          # Only filter out RPMs & modules via an erratum filter if they're not included in other allowed errata.
+          # Begin this by calculating all the errata that should be copied.
+          # If there are exclude filters, send the errata to the relevant methods to ensure their contents aren't excluded.
+          additional_included_errata = []
+          all_excluded_errata = []
+          unless errata_filters.blacklist.empty?
+            all_included_errata, all_excluded_errata = filtered_errata(errata_filters, [source_repository.id])
+            additional_included_errata = all_included_errata - all_excluded_errata
+          end
+
+          (errata_filters + package_filters).each do |filter|
             if filter.inclusion
               whitelist_ids += filter.content_unit_pulp_ids(source_repository)
+            elsif filter.class == ContentViewErratumFilter
+              blacklist_ids += filter.content_unit_pulp_ids(source_repository, additional_included_errata)
             else
               blacklist_ids += filter.content_unit_pulp_ids(source_repository)
             end
           end
 
-          whitelist_ids = source_repository.rpms.where(:modular => false).pluck(:pulp_id).sort if (whitelist_ids.empty? && filters.select { |filter| filter.inclusion }.empty?)
+          whitelist_ids = source_repository.rpms.where(:modular => false).pluck(:pulp_id).sort if (whitelist_ids.empty? && (errata_filters + package_filters).select { |filter| filter.inclusion }.empty?)
 
           modular_filters = ContentViewModuleStreamFilter.where(:id => options[:filter_ids])
           inclusion_modular_filters = modular_filters.select { |filter| filter.inclusion }
           exclusion_modular_filters = modular_filters - inclusion_modular_filters
-          if inclusion_modular_filters.empty? && !(filters.any? { |filter| filter.class == ContentViewErratumFilter && filter.inclusion })
+          if inclusion_modular_filters.empty? && errata_filters.whitelist.empty?
             whitelist_ids += source_repository.rpms.where(:modular => true).pluck(:pulp_id).sort
             whitelist_ids += source_repository.module_streams.pluck(:pulp_id).sort
           end
@@ -362,10 +418,11 @@ module Katello
           content_unit_hrefs = whitelist_ids - blacklist_ids
           content_unit_hrefs += source_repository.srpms.pluck(:pulp_id)
           if content_unit_hrefs.any?
-            content_unit_hrefs += additional_content_hrefs(source_repository, content_unit_hrefs)
+            content_unit_hrefs += additional_content_hrefs(source_repository, content_unit_hrefs, all_excluded_errata)
           end
           copy_units(source_repository, content_unit_hrefs.uniq, options[:remove_all])
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
 
         def modular_packages(source_repository, filters)
           list_ids = []
@@ -375,13 +432,14 @@ module Katello
           list_ids
         end
 
-        def additional_content_hrefs(source_repository, content_unit_hrefs)
+        def additional_content_hrefs(source_repository, content_unit_hrefs, all_excluded_errata)
           repo_service = source_repository.backend_service(SmartProxy.pulp_primary)
           options = { :repository_version => source_repository.version_href }
 
           errata_to_include = filter_errata_by_pulp_href(source_repository.errata, content_unit_hrefs,
                                                          source_repository.rpms.pluck(:filename) +
-                                                         source_repository.srpms.pluck(:filename))
+                                                         source_repository.srpms.pluck(:filename)) -
+                                                         all_excluded_errata
           content_unit_hrefs += errata_to_include.collect do |erratum|
             erratum.repository_errata.where(repository_id: source_repository.id).pluck(:erratum_pulp3_href)
           end

data/app/services/katello/pulp3/repository.rb

@@ -4,6 +4,7 @@ module Katello
   module Pulp3
     class Repository
       include Katello::Util::HttpProxy
+      include Katello::Pulp3::ServiceCommon
       attr_accessor :repo
       attr_accessor :smart_proxy
       delegate :root, to: :repo
@@ -49,13 +50,6 @@ module Katello
         @api ||= self.class.api(smart_proxy, repo.content_type)
       end
 
-      def ignore_404_exception(*)
-        yield
-      rescue api.api_exception_class => e
-        raise e unless e.code == 404
-        nil
-      end
-
       def published?
         !repo.publication_href.nil?
       end
@@ -74,56 +68,8 @@ module Katello
       end
 
       def create_remote
-        if remote_options[:url]&.start_with?('uln')
-          remote_file_data = api.class.remote_uln_class.new(remote_options)
-        else
-          remote_file_data = api.remote_class.new(remote_options)
-        end
-        reformat_api_exception do
-          if remote_options[:url]&.start_with?('uln')
-            response = api.remotes_uln_api.create(remote_file_data)
-          else
-            response = api.remotes_api.create(remote_file_data)
-          end
-          repo.update!(:remote_href => response.pulp_href)
-        end
-      end
-
-      # When updating a repository, we need to update the remote, but this is
-      # an async task.  If some validation occurs, we won't know about it until
-      # the task runs.  Errors during a repository update task are very difficult to
-      # handle once the task is in its run phase, so this creates a test remote
-      # with a random name in order to validate the remote's configuration
-      def create_test_remote
-        test_remote_options = remote_options
-        test_remote_options[:name] = test_remote_name
-        if remote_options[:url]&.start_with?('uln')
-          remote_file_data = api.class.remote_uln_class.new(test_remote_options)
-        else
-          remote_file_data = api.remote_class.new(test_remote_options)
-        end
-
-        reformat_api_exception do
-          if remote_options[:url]&.start_with?('uln')
-            response = api.remotes_uln_api.create(remote_file_data)
-          else
-            response = api.remotes_api.create(remote_file_data)
-          end
-          #delete is async, but if its not properly deleted, orphan cleanup will take care of it later
-          delete_remote(response.pulp_href)
-        end
-      end
-
-      def test_remote_name
-        "test_remote_#{SecureRandom.uuid}"
-      end
-
-      def reformat_api_exception
-        yield
-      rescue api.client_module::ApiError => exception
-        body = JSON.parse(exception.response_body) rescue body
-        body = body.values.join(',') if body.respond_to?(:values)
-        raise ::Katello::Errors::Pulp3Error, body
+        response = super
+        repo.update!(:remote_href => response.pulp_href)
       end
 
       def update_remote
@@ -285,17 +231,11 @@ module Katello
           return update_distribution
         end
 
-        if dist && dist_ref
-          # If the saved distribution reference is wrong, delete it and use the existing distribution
-          if dist.pulp_href != dist_ref.href
-            dist_ref.destroy
-            save_distribution_references([dist.pulp_href])
-          end
+        if dist_ref
           return update_distribution
         end
 
         # Since we got this far, we need to create a new distribution
-        # Note: the distribution reference can't be saved yet because distribution creation is async
         begin
           create_distribution(relative_path)
         rescue api.client_module::ApiError => e
@@ -313,9 +253,6 @@ module Katello
 
       def create_distribution(path)
         distribution_data = api.distribution_class.new(secure_distribution_options(path))
-        unless ::Katello::RepositoryTypeManager.find(repo.content_type).pulp3_skip_publication
-          fail_missing_publication(distribution_data.publication)
-        end
         api.distributions_api.create(distribution_data)
       end
 
@@ -323,16 +260,9 @@ module Katello
         api.distributions_api.list(args).results
       end
 
-      def read_distribution(href = distribution_reference.href)
-        ignore_404_exception { api.distributions_api.read(href) }
-      end
-
       def update_distribution
         if distribution_reference
           options = secure_distribution_options(relative_path).except(:name)
-          unless ::Katello::RepositoryTypeManager.find(repo.content_type).pulp3_skip_publication
-            fail_missing_publication(options[:publication])
-          end
           distribution_reference.update(:content_guard_href => options[:content_guard])
           api.distributions_api.partial_update(distribution_reference.href, options)
         end
@@ -391,12 +321,6 @@ module Katello
         hrefs.each do |href|
           pulp3_distribution_data = api.get_distribution(href)
           path, content_guard_href = pulp3_distribution_data&.base_path, pulp3_distribution_data&.content_guard
-          if distribution_reference
-            found_distribution = read_distribution(distribution_reference.href)
-            unless found_distribution
-              distribution_reference.destroy
-            end
-          end
           unless distribution_reference
             # Ensure that duplicates won't be created in the case of a race condition
             DistributionReference.where(path: path, href: href, repository_id: repo.id, content_guard_href: content_guard_href).first_or_create!
@@ -436,10 +360,8 @@ module Katello
         }
         remote_options[:url] = root.url unless root.url.blank?
         remote_options[:download_concurrency] = root.download_concurrency unless root.download_concurrency.blank?
-        if !root.upstream_username.blank? && !root.upstream_password.blank?
-          remote_options.merge!(username: root.upstream_username,
-                               password: root.upstream_password)
-        end
+        remote_options.merge!(username: root&.upstream_username,
+                              password: root&.upstream_password)
         remote_options.merge!(ssl_remote_options)
       end
 
@@ -479,7 +401,7 @@ module Katello
             client_key: root.product.key,
             ca_cert: Katello::Repository.feed_ca_cert(root.url)
           }
-        elsif root.redhat? && root.cdn_configuration.upstream_server?
+        elsif root.redhat? && root.cdn_configuration.network_sync?
           {
             client_cert: root.cdn_configuration.ssl_cert,
             client_key: root.cdn_configuration.ssl_key,
@@ -551,12 +473,6 @@ module Katello
         return 0 if root.retain_package_versions_count.nil? || root.using_mirrored_content?
         root.retain_package_versions_count.to_i
       end
-
-      def fail_missing_publication(publication_href)
-        unless lookup_publication(publication_href)
-          fail _("The repository's publication is missing. Please run a 'complete sync' on %s." % repo.name)
-        end
-      end
     end
   end
 end

data/app/services/katello/pulp3/service_common.rb

@@ -0,0 +1,66 @@
+module Katello
+  module Pulp3
+    module ServiceCommon
+      def create_remote
+        response = nil
+        if remote_options[:url]&.start_with?('uln')
+          remote_file_data = api.class.remote_uln_class.new(remote_options)
+        else
+          remote_file_data = api.remote_class.new(remote_options)
+        end
+        reformat_api_exception do
+          if remote_options[:url]&.start_with?('uln')
+            response = api.remotes_uln_api.create(remote_file_data)
+          else
+            response = api.remotes_api.create(remote_file_data)
+          end
+        end
+        response
+      end
+
+      def test_remote_name
+        "test_remote_#{SecureRandom.uuid}"
+      end
+
+      # When updating a repository, we need to update the remote, but this is
+      # an async task.  If some validation occurs, we won't know about it until
+      # the task runs.  Errors during a repository update task are very difficult to
+      # handle once the task is in its run phase, so this creates a test remote
+      # with a random name in order to validate the remote's configuration
+      def create_test_remote
+        test_remote_options = remote_options
+        test_remote_options[:name] = test_remote_name
+        if remote_options[:url]&.start_with?('uln')
+          remote_file_data = api.class.remote_uln_class.new(test_remote_options)
+        else
+          remote_file_data = api.remote_class.new(test_remote_options)
+        end
+
+        reformat_api_exception do
+          if remote_options[:url]&.start_with?('uln')
+            response = api.remotes_uln_api.create(remote_file_data)
+          else
+            response = api.remotes_api.create(remote_file_data)
+          end
+          #delete is async, but if its not properly deleted, orphan cleanup will take care of it later
+          delete_remote(response.pulp_href)
+        end
+      end
+
+      def ignore_404_exception(*)
+        yield
+      rescue api.api_exception_class => e
+        raise e unless e.code == 404
+        nil
+      end
+
+      def reformat_api_exception
+        yield
+      rescue api.client_module::ApiError => exception
+        body = JSON.parse(exception.response_body) rescue body
+        body = body.values.join(',') if body.respond_to?(:values)
+        raise ::Katello::Errors::Pulp3Error, body
+      end
+    end
+  end
+end

data/app/services/katello/pulp3/smart_proxy_mirror_repository.rb

@@ -76,12 +76,15 @@ module Katello
       def delete_orphan_remotes
         tasks = []
         repo_names = Katello::Repository.pluck(:pulp_id)
+        acs_remotes = Katello::SmartProxyAlternateContentSource.pluck(:remote_href)
         pulp3_enabled_repo_types.each do |repo_type|
           api = repo_type.pulp3_api(smart_proxy)
           remotes = api.remotes_list
 
           remotes.each do |remote|
-            tasks << api.delete_remote(remote.pulp_href) unless repo_names.include?(remote.name)
+            if !repo_names.include?(remote.name) && !acs_remotes.include?(remote.pulp_href)
+              tasks << api.delete_remote(remote.pulp_href)
+            end
           end
         end
         tasks

data/app/services/katello/ui_notifications/content_view/delete_latest_version_failure.rb

@@ -0,0 +1,22 @@
+module Katello
+  module UINotifications
+    module ContentView
+      class DelelteLatestVersionFailure < ::UINotifications::Base
+        private
+
+        def create
+          Notification.create!(
+            subject: subject,
+            initiator: initiator,
+            audience: ::Notification::AUDIENCE_ADMIN,
+            notification_blueprint: blueprint
+          )
+        end
+
+        def blueprint
+          @blueprint ||= NotificationBlueprint.find_by(name: 'content_view_auto_publish_error')
+        end
+      end
+    end
+  end
+end

data/app/views/foreman/job_templates/change_content_source.erb

@@ -3,7 +3,7 @@ kind: job_template
 name: Change content source
 job_category: Katello
 model: JobTemplate
-provider_type: SSH
+provider_type: script
 description_format: Configure subscription manager to new content source
 feature: katello_change_content_source
 %>

data/app/views/foreman/job_templates/install_errata.erb

@@ -1,23 +1,23 @@
 <%#
 kind: job_template
-name: Install Errata - Katello SSH Default
+name: Install Errata - Katello Script Default
 job_category: Katello
 description_format: 'Install errata %{errata}'
 feature: katello_errata_install
-provider_type: SSH
+provider_type: script
 template_inputs:
 - name: errata
   description: A comma-separated list of errata to install
   input_type: user
   required: true
 foreign_input_sets:
-- template: Package Action - SSH Default
+- template: Package Action - Script Default
   exclude: action,package
 %>
 <% if @host.operatingsystem.family == 'Suse' -%>
     <% advisories = input(:errata).split(',').join(' ') %>
-    <%= render_template('Package Action - SSH Default', :action => 'install -n -t patch', :package => advisories) %>
+    <%= render_template('Package Action - Script Default', :action => 'install -n -t patch', :package => advisories) %>
 <% else %>
     <% advisories = input(:errata).split(',').map { |e| "--advisory=#{e}" }.join(' ') %>
-    <%= render_template('Package Action - SSH Default', :action => 'update-minimal', :package => advisories) %>
+    <%= render_template('Package Action - Script Default', :action => 'update-minimal', :package => advisories) %>
 <% end %>

data/app/views/foreman/job_templates/install_errata_by_search_query.erb

@@ -1,26 +1,27 @@
 <%#
 kind: job_template
-name: Install errata by search query - Katello SSH Default
+name: Install errata by search query - Katello Script Default
 job_category: Katello
 description_format: 'Install errata %{Errata search query}'
 feature: katello_errata_install_by_search
-provider_type: SSH
+provider_type: script
 template_inputs:
 - name: Errata search query
   description: Filter criteria for errata to be installed.
   input_type: user
   required: false
 foreign_input_sets:
-- template: Package Action - SSH Default
+- template: Package Action - Script Default
   exclude: action,package
 %>
 
 <% if @host.operatingsystem.family == 'Suse' -%>
     <% advisories = @host.advisory_ids(search: input("Errata search query")).join(' ') %>
-    <%= render_template('Package Action - SSH Default', :action => 'install -n -t patch', :package => advisories) %>
+    <%= render_template('Package Action - Script Default', :action => 'install -n -t patch', :package => advisories) %>
 <% else %>
     <% advisory_ids = @host.advisory_ids(search: input("Errata search query")) %>
+    <% raise "No errata matching given search query" if !input("Errata search query").blank? && advisory_ids.empty? %>
 
     <% advisories = advisory_ids.map { |e| "--advisory=#{e}" }.join(' ') %>
-    <%= render_template('Package Action - SSH Default', :action => 'update-minimal', :package => advisories) %>
-<% end %>
+    <%= render_template('Package Action - Script Default', :action => 'update-minimal', :package => advisories) %>
+<% end %>

data/app/views/foreman/job_templates/install_group.erb

@@ -1,13 +1,13 @@
 <%#
 kind: job_template
-name: Install Group - Katello SSH Default
+name: Install Group - Katello Script Default
 job_category: Katello
 description_format: 'Install package group(s) %{package}'
 feature: katello_group_install
-provider_type: SSH
+provider_type: script
 foreign_input_sets:
-- template: Package Action - SSH Default
+- template: Package Action - Script Default
   exclude: action
 %>
 
-<%= render_template('Package Action - SSH Default', :action => 'group install') %>
+<%= render_template('Package Action - Script Default', :action => 'group install') %>

data/app/views/foreman/job_templates/install_package.erb

@@ -1,13 +1,13 @@
 <%#
 kind: job_template
-name: Install Package - Katello SSH Default
+name: Install Package - Katello Script Default
 job_category: Katello
 description_format: 'Install package(s) %{package}'
 feature: katello_package_install
-provider_type: SSH
+provider_type: script
 foreign_input_sets:
-- template: Package Action - SSH Default
+- template: Package Action - Script Default
   exclude: action
 %>
 
-<%= render_template('Package Action - SSH Default', :action => 'install') %>
+<%= render_template('Package Action - Script Default', :action => 'install') %>

data/app/views/foreman/job_templates/install_packages_by_search_query.erb

@@ -1,10 +1,10 @@
 <%#
 kind: job_template
-name: Install packages by search query - Katello SSH Default
+name: Install packages by search query - Katello Script Default
 job_category: Katello
 description_format: 'Install package(s) %{Package search query}'
 feature: katello_package_install_by_search
-provider_type: SSH
+provider_type: script
 template_inputs:
 - name: Package search query
   description: Filter criteria for packages to be installed. IMPORTANT- If left blank, the job will attempt to install all possible packages.
@@ -16,4 +16,4 @@ template_inputs:
   search: input('Package search query')
 ) -%>
 
-<%= render_template('Package Action - SSH Default', :action => 'install', :package => package_names.join(' ')) %>
+<%= render_template('Package Action - Script Default', :action => 'install', :package => package_names.join(' ')) %>

data/app/views/foreman/job_templates/remove_group.erb

@@ -1,13 +1,13 @@
 <%#
 kind: job_template
-name: Remove Group - Katello SSH Default
+name: Remove Group - Katello Script Default
 job_category: Katello
 description_format: 'Remove package group(s) %{package}'
 feature: katello_group_remove
-provider_type: SSH
+provider_type: script
 foreign_input_sets:
-- template: Package Action - SSH Default
+- template: Package Action - Script Default
   exclude: action
 %>
 
-<%= render_template('Package Action - SSH Default', :action => 'group remove') %>
+<%= render_template('Package Action - Script Default', :action => 'group remove') %>

data/app/views/foreman/job_templates/remove_package.erb

@@ -1,13 +1,13 @@
 <%#
 kind: job_template
-name: Remove Package - Katello SSH Default
+name: Remove Package - Katello Script Default
 job_category: Katello
 description_format: 'Remove package(s) %{package}'
 feature: katello_package_remove
-provider_type: SSH
+provider_type: script
 foreign_input_sets:
-- template: Package Action - SSH Default
+- template: Package Action - Script Default
   exclude: action
 %>
 
-<%= render_template('Package Action - SSH Default', :action => 'remove') %>
+<%= render_template('Package Action - Script Default', :action => 'remove') %>

data/app/views/foreman/job_templates/remove_packages_by_search_query.erb

@@ -1,10 +1,10 @@
 <%#
 kind: job_template
-name: Remove Packages by search query - Katello SSH Default
+name: Remove Packages by search query - Katello Script Default
 job_category: Katello
 description_format: 'Remove packages %{Packages search query}'
 feature: katello_packages_remove_by_search
-provider_type: SSH
+provider_type: script
 template_inputs:
 - name: Packages search query
   description: Filter criteria for packages to be removed.
@@ -16,4 +16,4 @@ template_inputs:
   search: input('Packages search query')
 ) -%>
 
-<%= render_template('Package Action - SSH Default', :action => 'remove', :package => package_names.join(' ')) %> 
+<%= render_template('Package Action - Script Default', :action => 'remove', :package => package_names.join(' ')) %>

data/app/views/foreman/job_templates/resolve_traces.erb

@@ -1,10 +1,10 @@
 <%#
 kind: job_template
-name: Resolve Traces - Katello SSH Default
+name: Resolve Traces - Katello Script Default
 job_category: Katello
 description_format: 'Resolve Traces'
 feature: katello_host_tracer_resolve
-provider_type: SSH
+provider_type: script
 template_inputs:
 - name: Traces search query
   description: Search query to provide traces to resolve

data/app/views/foreman/job_templates/restart_services.erb

@@ -1,10 +1,10 @@
 <%#
 kind: job_template
-name: Restart Services - Katello SSH Default
+name: Restart Services - Katello Script Default
 job_category: Katello
 description_format: 'Restart Services'
 feature: katello_service_restart
-provider_type: SSH
+provider_type: script
 template_inputs:
 - name: helper
   description: A comma separated list of commands to run to restart services
@@ -19,5 +19,5 @@ reboot = commands.delete('reboot')
 <%= commands.join("\n") %>
 katello-tracer-upload
 <% if reboot -%>
-<%= render_template('Power Action - SSH Default', action: 'restart') %>
+<%= render_template('Power Action - Script Default', action: 'restart') %>
 <% end %>