katello 4.5.0.rc2 → 4.6.0.rc2

data/app/lib/actions/pulp3/alternate_content_source/update_remote.rb

@@ -2,14 +2,14 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class UpdateRemote < Pulp3::AbstractAsyncTask
-        def plan(acs, smart_proxy)
-          acs.backend_service(smart_proxy).create_test_remote
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          smart_proxy_acs.backend_service.create_test_remote
+          plan_self(smart_proxy_acs_id: smart_proxy_acs.id, smart_proxy_id: smart_proxy_acs.smart_proxy_id)
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).update_remote
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.update_remote
         end
       end
     end

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

@@ -12,6 +12,7 @@ module Actions
             end
             repository_hrefs = ::Katello::Pulp3::Api::Core.new(smart_proxy).core_repositories_list_all(fields: 'pulp_href').map(&:pulp_href)
           end
+          fail _('There is no downloaded content to clean.') if repository_hrefs.empty?
           plan_self(repository_hrefs: repository_hrefs, smart_proxy_id: smart_proxy.id)
         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/alternate_content_source/create.rb

@@ -3,10 +3,10 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Create < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs)
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::CreateRemote, acs, smart_proxy)
-              plan_action(Actions::Pulp3::AlternateContentSource::Create, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::CreateRemote, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::Create, smart_proxy_acs)
             end
           end
         end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/delete.rb

@@ -3,18 +3,17 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Delete < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs, options = {})
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::Delete, acs, smart_proxy)
-              plan_action(Actions::Pulp3::AlternateContentSource::DeleteRemote, acs, smart_proxy)
-              plan_self(acs_id: acs.id, smart_proxy_id: smart_proxy.id)
+              plan_action(Actions::Pulp3::AlternateContentSource::Delete, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::DeleteRemote, smart_proxy_acs, options)
+              plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
             end
           end
 
           def finalize
-            acs_id = input[:acs_id]
-            smart_proxy_id = input[:smart_proxy_id]
-            ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs_id, smart_proxy_id: smart_proxy_id).destroy
+            smart_proxy_acs_id = input[:smart_proxy_acs_id]
+            ::Katello::SmartProxyAlternateContentSource.find_by(id: smart_proxy_acs_id).destroy
           end
         end
       end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/refresh.rb

@@ -3,9 +3,9 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Refresh < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs)
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::Refresh, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::Refresh, smart_proxy_acs)
             end
           end
         end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/refresh_remote.rb

@@ -0,0 +1,18 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module AlternateContentSource
+        class RefreshRemote < Pulp3::AbstractAsyncTask
+          def plan(smart_proxy_acs)
+            plan_self(smart_proxy_acs_id: smart_proxy_acs.id, smart_proxy_id: smart_proxy_acs.smart_proxy_id)
+          end
+
+          def invoke_external_task
+            smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+            smart_proxy_acs.backend_service.update_remote
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/update.rb

@@ -3,10 +3,10 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Update < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs)
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::UpdateRemote, acs, smart_proxy)
-              plan_action(Actions::Pulp3::AlternateContentSource::Update, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::UpdateRemote, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::Update, smart_proxy_acs)
             end
           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,13 +6,14 @@ 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
-
             content_view = ::Katello::Pulp3::ContentViewVersion::Export.find_library_export_view(destination_server: destination_server,
                                                                            organization: organization,
-                                                                           create_by_default: true)
+                                                                           create_by_default: true,
+                                                                           format: format)
             repo_ids_in_library = organization.default_content_view_version.repositories.exportable.immediate_or_none.pluck(:id)
             content_view.update!(repository_ids: repo_ids_in_library)
 
@@ -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,13 +5,15 @@ 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)
 
             content_view = ::Katello::Pulp3::ContentViewVersion::Export.find_repository_export_view(
                                                                            repository: repository,
-                                                                           create_by_default: true)
+                                                                           create_by_default: true,
+                                                                           format: format)
             content_view.update!(repository_ids: [repository.library_instance_or_self.id])
 
             sequence do
@@ -19,7 +21,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/actions/pulp3/orchestration/repository/generate_metadata.rb

@@ -16,7 +16,7 @@ module Actions
                 plan_action(Actions::Pulp3::Repository::CreatePublication, repository, smart_proxy, options)
               end
               plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
-              plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if repository.environment
+              plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if Setting[:distribute_archived_cvv] || repository.environment
             end
           end
 

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

@@ -161,7 +161,7 @@ module Katello
         returns String, desc: 'Package version'
       end
       def host_latest_applicable_rpm_version(host, package)
-        host.applicable_rpms.where(name: package).order(:version_sortable).limit(1).pluck(:nvra).first
+        ::Katello::Rpm.latest(host.applicable_rpms.where(name: package)).first.nvra
       end
 
       apipie :method, 'Loads Pool objects' do
@@ -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/lib/katello/errors.rb

@@ -154,7 +154,7 @@ module Katello
 
     class NoManifestImported < StandardError
       def message
-        _("Current organization has no manifest imported.")
+        _("Current organization does not have a manifest imported.")
       end
     end
 

data/app/lib/katello/resources/candlepin/owner.rb

@@ -12,8 +12,14 @@ module Katello
 
           # Set the contentPrefix at creation time so that the client will get
           # content only for the org it has been subscribed to
-          def create(key, description)
-            attrs = {:key => key, :displayName => description, :contentPrefix => "/#{key}/$env"}
+          def create(key, description, content_access_mode: 'org_environment')
+            attrs = {
+              :key => key,
+              :displayName => description,
+              :contentPrefix => "/#{key}/$env",
+              :contentAccessMode => content_access_mode,
+              :contentAccessModeList => ['entitlement', 'org_environment'].join(',')
+            }
             owner_json = self.post(path, attrs.to_json, self.default_headers).body
             JSON.parse(owner_json).with_indifferent_access
           end
@@ -36,6 +42,7 @@ module Katello
           def update(key, attrs)
             owner = find(key)
             owner.merge!(attrs)
+            owner.merge!(:contentAccessModeList => ['entitlement', 'org_environment'].join(','))
             self.put(path(key), JSON.generate(owner), self.default_headers).body
           end
 

data/app/lib/katello/validators/alternate_content_source_products_validator.rb

@@ -0,0 +1,17 @@
+module Katello
+  module Validators
+    class AlternateContentSourceProductsValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if value
+          if attribute == :product_id
+            product = ::Katello::Product.find(value)
+            content_type = record.alternate_content_source.content_type
+            if product.repositories.with_type(content_type).has_url.empty?
+              record.errors[attribute] << N_("The product %{name} has no %{type} repositories with upstream URLs to add to the alternate content source.") % { name: product.name, type: content_type }
+            end
+          end
+        end
+      end
+    end
+  end
+end