katello 4.5.0.rc2 → 4.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5922047abc1b1bd8649e30bbaaf5eaf2e09f09bc9abb5e1b61920c0b84b1b57b
-  data.tar.gz: 8105c45f9d16ca034430e89224f9bb81fa95c02d38ca638268864e34a9d57e2b
+  metadata.gz: 668ae7f77ea1cb1924c60b96931b249de9198b20caa055ee5142422ee5e72d44
+  data.tar.gz: 746ebbe54eb3ad9f4208b344b4bb671143a21489e19a16720c2987a2ffa6719e
 SHA512:
-  metadata.gz: '069335f24169763ce80081693498c668a115893acb4e9c7b2a1486d54d5394f53b9d21cb6442acd6cba990f07d58e6b75f7ec0d9e32515165226fb833874a311'
-  data.tar.gz: 22cda386e45a6d989daff56fe3897d07a75205282b2aa1e901bf7c333fd38d72869ab3dd808641a5535d8f72063c2961aa575c2420dfa51c2f98a3ab4152b28c
+  metadata.gz: 41d0ed1bfd6b88b4414a79c3f8479b3a6ad2c170f055fb707434b7ba72b6e51c83d7582c03bef5bb6a297583a2553776cf324d945311c66442d8c54a40fe7e6a
+  data.tar.gz: 35a1df76e4d090c8628d9c9d22fc623f12ab436fa229c6a55142e3fc53b3a82b6bd5e42e56d0e9282e9efa0fb6d925f378eedcc9c49cdb65335f146842dcbbae

data/app/controllers/katello/api/v2/content_exports_controller.rb

@@ -34,12 +34,18 @@ module Katello
                                                "no greater than the specified size in gigabytes."), :required => false
     param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this version"\
                                                          " are unexportable. False by default."), :required => false
+    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
+                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
+                               "Choose importable if content is to be imported via hammer content-import.
+                                Defaults to importable."),
+                   :required => false
     def version
       tasks = async_task(::Actions::Katello::ContentViewVersion::Export,
                           content_view_version: @version,
                           destination_server: params[:destination_server],
                           chunk_size: params[:chunk_size_gb],
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
+                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]),
+                          format: find_export_format)
       respond_for_async :resource => tasks
     end
 
@@ -50,12 +56,18 @@ module Katello
                                                "no greater than the specified size in gigabytes."), :required => false
     param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this organization"\
                                                          " are unexportable. False by default."), :required => false
+    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
+                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
+                               "Choose importable if content is to be imported via hammer content-import.
+                                Defaults to importable."),
+                   :required => false
     def library
       tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportLibrary,
                           @organization,
                           destination_server: params[:destination_server],
                           chunk_size: params[:chunk_size_gb],
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
+                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]),
+                          format: find_export_format)
       respond_for_async :resource => tasks
     end
 
@@ -63,10 +75,16 @@ module Katello
     param :id, :number, :desc => N_("Repository identifier"), :required => true
     param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
                                                "no greater than the specified size in gigabytes."), :required => false
+    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
+                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
+                               "Choose importable if content is to be imported via hammer content-import.
+                                Defaults to importable."),
+                   :required => false
     def repository
       tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportRepository,
                           @repository,
-                          chunk_size: params[:chunk_size_gb])
+                          chunk_size: params[:chunk_size_gb],
+                          format: find_export_format)
       respond_for_async :resource => tasks
     end
 
@@ -90,5 +108,17 @@ module Katello
         throw_resource_not_found(name: 'organization', id: params[:organization_id])
       end
     end
+
+    def find_export_format
+      if params[:format]
+        unless ::Katello::Pulp3::ContentViewVersion::Export::FORMATS.include?(params[:format])
+          fail HttpErrors::UnprocessableEntity, _('Invalid export format provided. Format must be one of  %s ') %
+                                            ::Katello::Pulp3::ContentViewVersion::Export::FORMATS.join(',')
+        end
+        params[:format]
+      else
+        ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
+      end
+    end
   end
 end

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

@@ -1,8 +1,8 @@
-# rubocop:disable Lint/SuppressedException
 module Actions
   module Katello
     module ContentView
       class PromoteToEnvironment < Actions::EntryAction
+        execution_plan_hooks.use :trigger_capsule_sync, :on => :success
         def plan(version, environment, description, incremental_update = false)
           history = ::Katello::ContentViewHistory.create!(:content_view_version => version, :user => ::User.current.login,
                                                           :environment => environment, :task => self.task,
@@ -51,13 +51,15 @@ module Actions
           history = ::Katello::ContentViewHistory.find(input[:history_id])
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL
           history.save!
+        end
 
+        def trigger_capsule_sync(_execution_plan)
+          environment = ::Katello::KTEnvironment.find(input[:environment_id])
           if !input[:incremental_update] && sync_proxies?(environment)
             ForemanTasks.async_task(ContentView::CapsuleSync,
                                     ::Katello::ContentView.find(input[:content_view_id]),
                                     environment)
           end
-        rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 
         private

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

@@ -1,4 +1,3 @@
-# rubocop:disable Lint/SuppressedException
 module Actions
   module Katello
     module ContentView
@@ -7,6 +6,8 @@ module Actions
         include ::Katello::ContentViewHelper
         include ::Actions::ObservableAction
         attr_accessor :version
+        execution_plan_hooks.use :trigger_capsule_sync, :on => :success
+
         # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
         def plan(content_view, description = "", options = {importing: false}) # rubocop:disable Metrics/PerceivedComplexity
           action_subject(content_view)
@@ -118,6 +119,9 @@ module Actions
           history = ::Katello::ContentViewHistory.find(input[:history_id])
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL
           history.save!
+        end
+
+        def trigger_capsule_sync(_execution_plan)
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
           view = ::Katello::ContentView.find(input[:content_view_id])
           if SmartProxy.sync_needed?(environment) && !input[:skip_promotion]
@@ -125,7 +129,6 @@ module Actions
                                     view,
                                     environment)
           end
-        rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 
         def content_view_version_id

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

@@ -0,0 +1,20 @@
+module Actions
+  module Katello
+    module Organization
+      class EnvironmentContentsRefresh < Actions::AbstractAsyncTask
+        middleware.use Actions::Middleware::PropagateCandlepinErrors
+
+        def plan(organization)
+          organization.content_view_environments.each do |cve|
+            plan_action(
+              Actions::Candlepin::Environment::SetContent,
+              cve.content_view,
+              cve.owner,
+              cve
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -29,6 +29,8 @@ module Actions
             import_products = plan_action(Candlepin::Owner::ImportProducts,
               :organization_id => organization.id,
               :dependency => owner_import.output)
+            plan_action(Katello::Organization::EnvironmentContentsRefresh,
+              organization)
             if manifest_update
               plan_refresh_repos(import_products, organization)
             end

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

@@ -27,9 +27,10 @@ module Actions
           cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
           from_cvv = ::Katello::ContentViewVersion.find(input[:from_content_view_version_id]) unless input[:from_content_view_version_id].blank?
 
-          export_metadata = ::Katello::Pulp3::ContentViewVersion::Export.new(
+          export_metadata = ::Katello::Pulp3::ContentViewVersion::Export.create(
                                                      content_view_version: cvv,
                                                      smart_proxy: smart_proxy,
+                                                     format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE,
                                                      from_content_view_version: from_cvv).generate_metadata
 
           toc_path_info = output[:exported_file_checksum].find { |item| item.first.end_with?("toc.json") }
@@ -46,6 +47,7 @@ module Actions
                                                                                              metadata: export_metadata)
           )
           output[:export_history_id] = history.id
+          output[:format] = ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
         end
 
         def humanized_name

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

@@ -6,13 +6,20 @@ module Actions
           param :smart_proxy_id, Integer
           param :content_view_version_id, Integer
           param :destination_server, String
+          param :format, String
+          param :base_path, String
+          param :repository_id, Integer
         end
 
         def run
           cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
-          output[:exporter_data] = ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy,
+          repository = ::Katello::Repository.find(input[:repository_id]) unless input[:repository_id].blank?
+          output[:exporter_data] = ::Katello::Pulp3::ContentViewVersion::Export.create(smart_proxy: smart_proxy,
                                                                             content_view_version: cvv,
-                                                                            destination_server: input[:destination_server]).create_exporter
+                                                                            destination_server: input[:destination_server],
+                                                                            format: input[:format],
+                                                                            base_path: input[:base_path],
+                                                                            repository: repository).create_exporter
         end
       end
     end

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

@@ -0,0 +1,45 @@
+module Actions
+  module Pulp3
+    module ContentViewVersion
+      class CreateSyncableExportHistory < Actions::EntryAction
+        input_format do
+          param :smart_proxy_id, Integer
+          param :base_path, String
+          param :content_view_version_id, Integer
+          param :destination_server, String
+        end
+
+        output_format do
+          param :export_history_id, Integer
+          param :path, String
+        end
+
+        def run
+          smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
+          output[:path] = input[:base_path]
+          cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          export_metadata = ::Katello::Pulp3::ContentViewVersion::Export.create(
+                                                     content_view_version: cvv,
+                                                     smart_proxy: smart_proxy,
+                                                     format: input[:format]).generate_metadata
+
+          history = ::Katello::ContentViewVersionExportHistory.create!(
+            content_view_version_id: input[:content_view_version_id],
+            destination_server: input[:destination_server],
+            path: input[:base_path],
+            metadata: export_metadata,
+            audit_comment: ::Katello::ContentViewVersionExportHistory.generate_audit_comment(content_view_version: cvv,
+                                                                                             user: User.current,
+                                                                                             metadata: export_metadata)
+          )
+          output[:export_history_id] = history.id
+          output[:format] = ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
+        end
+
+        def humanized_name
+          _("Create Syncable Export History")
+        end
+      end
+    end
+  end
+end

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

@@ -5,10 +5,15 @@ module Actions
         input_format do
           param :smart_proxy_id, Integer
           param :exporter_data, Hash
+          param :format, String
+          param :repository_id, Integer
         end
 
         def invoke_external_task
-          ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy).destroy_exporter(input[:exporter_data][:pulp_href])
+          repository = ::Katello::Repository.find(input[:repository_id]) unless input[:repository_id].blank?
+          ::Katello::Pulp3::ContentViewVersion::Export.create(smart_proxy: smart_proxy,
+                                                              format: input[:format],
+                                                              repository: repository).destroy_exporter(input[:exporter_data])
         end
       end
     end

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

@@ -7,16 +7,21 @@ module Actions
           param :from_content_view_version_id, Integer
           param :smart_proxy_id, Integer
           param :exporter_data, Hash
+          param :format, String
           param :chunk_size, Integer
+          param :repository_id, Integer
         end
 
         def invoke_external_task
+          repository = ::Katello::Repository.find(input[:repository_id]) unless input[:repository_id].blank?
           cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
           from_cvv = ::Katello::ContentViewVersion.find(input[:from_content_view_version_id]) unless input[:from_content_view_version_id].blank?
-          ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy,
+          ::Katello::Pulp3::ContentViewVersion::Export.create(smart_proxy: smart_proxy,
                                                    content_view_version: cvv,
-                                                   from_content_view_version: from_cvv)
-                                                   .create_export(input[:exporter_data][:pulp_href],
+                                                   from_content_view_version: from_cvv,
+                                                   format: input[:format],
+                                                   repository: repository)
+                                                   .create_export(input[:exporter_data],
                                                                         chunk_size: input[:chunk_size])
         end
       end

data/app/lib/actions/pulp3/orchestration/content_view_version/export.rb

@@ -10,6 +10,7 @@ module Actions
             param :export_history_id, Integer
             param :exporter_data, Hash
             param :destination_server, String
+            param :format, String
           end
 
           output_format do
@@ -19,16 +20,30 @@ module Actions
           def plan(content_view_version:, destination_server: nil,
                    chunk_size: nil, from_history: nil,
                    validate_incremental: true,
-                   fail_on_missing_content: false)
+                   fail_on_missing_content: false,
+                   format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
+            smart_proxy = SmartProxy.pulp_primary!
+
+            if format == ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
+              sequence do
+                export_output = plan_action(SyncableExport,
+                          content_view_version: content_view_version,
+                          smart_proxy: smart_proxy,
+                          destination_server: destination_server).output
+                plan_self(export_history_id: export_output[:export_history_id],
+                          export_path: export_output[:export_path])
+              end
+              return
+            end
 
             sequence do
-              smart_proxy = SmartProxy.pulp_primary!
               from_content_view_version = from_history&.content_view_version
-              export_service = ::Katello::Pulp3::ContentViewVersion::Export.new(
+              export_service = ::Katello::Pulp3::ContentViewVersion::Export.create(
                   smart_proxy: smart_proxy,
                   content_view_version: content_view_version,
                   destination_server: destination_server,
-                  from_content_view_version: from_content_view_version)
+                  from_content_view_version: from_content_view_version,
+                  format: format)
               export_service.validate!(fail_on_missing_content: fail_on_missing_content,
                                        validate_incremental: validate_incremental,
                                        chunk_size: chunk_size)
@@ -36,14 +51,16 @@ module Actions
               action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
                                           content_view_version_id: content_view_version.id,
                                           smart_proxy_id: smart_proxy.id,
-                                          destination_server: destination_server).output
+                                          destination_server: destination_server,
+                                          format: format).output
 
               plan_action(::Actions::Pulp3::ContentViewVersion::Export,
                           content_view_version_id: content_view_version.id,
                           smart_proxy_id: smart_proxy.id,
                           exporter_data: action_output[:exporter_data],
                           chunk_size: chunk_size,
-                          from_content_view_version_id: from_content_view_version&.id)
+                          from_content_view_version_id: from_content_view_version&.id,
+                          format: format)
 
               history_output = plan_action(
                   ::Actions::Pulp3::ContentViewVersion::CreateExportHistory,
@@ -52,18 +69,16 @@ module Actions
                   pulp_href: action_output[:exporter_data][:pulp_href],
                   content_view_version_id: content_view_version.id,
                   from_content_view_version_id: from_content_view_version&.id,
-                  destination_server: destination_server
+                  destination_server: destination_server,
+                  format: format
               ).output
 
               plan_action(::Actions::Pulp3::ContentViewVersion::DestroyExporter,
                           smart_proxy_id: smart_proxy.id,
-                          exporter_data: action_output[:exporter_data])
+                          exporter_data: action_output[:exporter_data],
+                          format: format)
 
-              plan_self(exporter_data: action_output[:exporter_data], smart_proxy_id: smart_proxy.id,
-                        destination_server: destination_server,
-                        content_view_version_id: content_view_version.id,
-                        from_content_view_version_id: from_content_view_version&.id,
-                        export_history_id: history_output[:export_history_id],
+              plan_self(export_history_id: history_output[:export_history_id],
                         exported_file_checksum: history_output[:exported_file_checksum],
                         export_path: history_output[:path])
             end

data/app/lib/actions/pulp3/orchestration/content_view_version/export_library.rb

@@ -6,7 +6,8 @@ module Actions
           def plan(organization, destination_server: nil,
                                  chunk_size: nil,
                                  from_history: nil,
-                                 fail_on_missing_content: false)
+                                 fail_on_missing_content: false,
+                                 format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
             action_subject(organization)
             validate_repositories_immediate!(organization) if fail_on_missing_content
 
@@ -24,7 +25,8 @@ module Actions
                                           chunk_size: chunk_size,
                                           from_history: from_history,
                                           validate_incremental: false,
-                                          fail_on_missing_content: fail_on_missing_content)
+                                          fail_on_missing_content: fail_on_missing_content,
+                                          format: format)
               plan_self(export_action_output: export_action.output)
             end
           end

data/app/lib/actions/pulp3/orchestration/content_view_version/export_repository.rb

@@ -5,7 +5,8 @@ module Actions
         class ExportRepository < Actions::EntryAction
           def plan(repository,
                     chunk_size: nil,
-                    from_history: nil)
+                    from_history: nil,
+                    format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
             action_subject(repository)
             validate_repositories_immediate!(repository)
 
@@ -19,7 +20,8 @@ module Actions
               export_action = plan_action(Actions::Katello::ContentViewVersion::Export,
                                           content_view_version: publish_action.version,
                                           chunk_size: chunk_size,
-                                          from_history: from_history)
+                                          from_history: from_history,
+                                          format: format)
               plan_self(export_action_output: export_action.output)
             end
           end

data/app/lib/actions/pulp3/orchestration/content_view_version/syncable_export.rb

@@ -0,0 +1,82 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module ContentViewVersion
+        class SyncableExport < Actions::EntryAction
+          input_format do
+            param :smart_proxy_id, Integer
+            param :content_view_version_id, Integer
+            param :export_history_id, Integer
+            param :export_path, String
+          end
+
+          output_format do
+            param :export_path, String
+            param :export_history_id, Integer
+          end
+
+          def plan(content_view_version:,
+                   smart_proxy:,
+                   fail_on_missing_content: false,
+                   destination_server:)
+            format = ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
+            sequence do
+              export_service = ::Katello::Pulp3::ContentViewVersion::Export.create(
+                  smart_proxy: smart_proxy,
+                  content_view_version: content_view_version,
+                  format: format,
+                  destination_server: destination_server)
+              export_service.validate!(fail_on_missing_content: fail_on_missing_content)
+              base_path = export_service.generate_exporter_path
+              export_service.repositories.each do |repository|
+                action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
+                                            content_view_version_id: content_view_version.id,
+                                            smart_proxy_id: smart_proxy.id,
+                                            format: format,
+                                            base_path: base_path,
+                                            repository_id: repository.id,
+                                            destination_server: destination_server).output
+
+                plan_action(::Actions::Pulp3::ContentViewVersion::Export,
+                            content_view_version_id: content_view_version.id,
+                            smart_proxy_id: smart_proxy.id,
+                            exporter_data: action_output[:exporter_data],
+                            format: format,
+                            repository_id: repository.id)
+
+                plan_action(::Actions::Pulp3::ContentViewVersion::DestroyExporter,
+                          smart_proxy_id: smart_proxy.id,
+                          exporter_data: action_output[:exporter_data],
+                          format: format,
+                          repository_id: repository.id)
+              end
+
+              history_output = plan_action(
+                  ::Actions::Pulp3::ContentViewVersion::CreateSyncableExportHistory,
+                  smart_proxy_id: smart_proxy.id,
+                  content_view_version_id: content_view_version.id,
+                  destination_server: destination_server,
+                  format: format,
+                  base_path: base_path
+              ).output
+
+              plan_self(export_history_id: history_output[:export_history_id],
+                        export_path: base_path)
+            end
+          end
+
+          def run
+            output.update(
+                export_history_id: input[:export_history_id],
+                export_path: input[:export_path]
+            )
+          end
+
+          def rescue_strategy
+            Dynflow::Action::Rescue::Skip
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -206,21 +206,22 @@ module Katello
         search_up_to = up_to.present? ? "ended_at < \"#{up_to}\"" : nil
         search_since = since.present? ? "ended_at > \"#{since}\"" : nil
         search_result = status.present? && status != 'all' ? "result = #{status}" : nil
-        search = [search_up_to, search_since, search_result].compact.join(' and ')
+        labels = 'label ^ (Actions::Katello::Host::Erratum::Install, Actions::Katello::Host::Erratum::ApplicableErrataInstall)'
+        select = 'foreman_tasks_tasks.*'
 
         if Katello.with_remote_execution?
-          condition = ["state = 'stopped' AND ((label = 'Actions::RemoteExecution::RunHostJob' AND templates.id = ?) " \
-                       "OR label = 'Actions::Katello::Host::Erratum::Install' OR label = 'Actions::Katello::Host::Erratum::ApplicableErrataInstall')",
-                       RemoteExecutionFeature.feature('katello_errata_install').job_template_id]
+          new_labels = 'label = Actions::RemoteExecution::RunHostJob AND remote_execution_feature.label ^ (katello_errata_install, katello_errata_install_by_search)'
+          labels = [labels, new_labels].map { |label| "(#{label})" }.join(' OR ')
+          select += ',template_invocations.id AS template_invocation_id'
         else
-          condition = "state = 'stopped' AND (label = 'Actions::Katello::Host::Erratum::Install' OR label = 'Actions::Katello::Host::Erratum::ApplicableErrataInstall')"
+          select += ',NULL AS template_invocation_id'
         end
 
+        search = [search_up_to, search_since, search_result, "state = stopped", labels].compact.join(' and ')
+
         tasks = load_resource(klass: ForemanTasks::Task,
-                              where: condition,
                               permission: 'view_foreman_tasks',
-                              joins: 'LEFT OUTER JOIN template_invocations ON foreman_tasks_tasks.id = template_invocations.run_host_job_task_id LEFT OUTER JOIN templates ON template_invocations.template_id = templates.id',
-                              select: 'foreman_tasks_tasks.*,template_invocations.id AS template_invocation_id',
+                              select: select,
                               search: search)
         only_host_ids = ::Host.search_for(host_filter).pluck(:id) if host_filter
 
@@ -325,9 +326,21 @@ module Katello
         # Pick katello agent errata if present
         # Otherwise pick rex errata. There are multiple template inputs, such as errata, pre_script and post_script we only need the
         # errata input here.
-        @_tasks_errata_cache[task.id] ||= agent_input.presence || TemplateInvocationInputValue.joins(:template_input)
-                                            .where("template_invocation_id = ? AND template_inputs.name = ?", task.template_invocation_id, 'errata')
-                                            .first.value.split(',')
+        @_tasks_errata_cache[task.id] ||= agent_input.presence || errata_ids_from_template_invocation(task, task_input)
+      end
+
+      def errata_ids_from_template_invocation(task, task_input)
+        if task_input.key?('job_features') && task_input['job_features'].include?('katello_errata_install_by_search')
+          # This may give wrong results if the template is not rendered yet
+          # This also will not work for jobs run before we started storing
+          #   resolved ids in the template
+          script = task.execution_plan.actions[1].try(:input).try(:[], 'script') || ''
+          found = script.lines.find { |line| line.start_with? '# RESOLVED_ERRATA_IDS=' } || ''
+          (found.chomp.split('=', 2).last || '').split(',')
+        else
+          TemplateInvocationInputValue.joins(:template_input).where("template_invocation_id = ? AND template_inputs.name = ?", task.template_invocation_id, 'errata')
+            .first.value.split(',')
+        end
       end
     end
   end

data/app/models/katello/authorization/repository.rb

@@ -5,11 +5,13 @@ module Katello
     delegate :editable?, to: :product
 
     def deletable?(remove_from_content_view_versions = true)
-      product.editable? && (remove_from_content_view_versions || !promoted? || !self.content_views.generated_for_none.exists?)
+      return false unless product.editable?
+      remove_from_content_view_versions || !promoted? || (self.content_views.exists? && !self.content_views.generated_for_none.exists?)
     end
 
     def redhat_deletable?(remove_from_content_view_versions = false)
-      (remove_from_content_view_versions || !self.promoted? || !self.content_views.generated_for_none.exists?) && self.product.editable?
+      return false unless product.editable?
+      remove_from_content_view_versions || !self.promoted? || (self.content_views.exists? && !self.content_views.generated_for_none.exists?)
     end
 
     def readable?