katello 4.15.0 → 4.16.0.rc1

data/app/controllers/katello/concerns/api/v2/http_proxies_controller_extensions.rb

@@ -0,0 +1,17 @@
+module Katello
+  module Concerns
+    module Api
+      module V2
+        module HttpProxiesControllerExtensions
+          extend ::Apipie::DSL::Concern
+
+          update_api(:create, :show) do
+            param :http_proxy, Hash do
+              param :content_default_http_proxy, :bool, :required => false, :desc => N_('Set this HTTP proxy as the default content HTTP proxy')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/katello/concerns/http_proxies_controller_extensions.rb

@@ -0,0 +1,20 @@
+module Katello
+  module Concerns
+    module HttpProxiesControllerExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        after_action :update_content_default_http_proxy, only: :create
+      end
+
+      private
+
+      def update_content_default_http_proxy
+        return unless @http_proxy.persisted?
+        return unless ActiveRecord::Type::Boolean.new.deserialize(params.dig('http_proxy', 'content_default_http_proxy'))
+
+        Setting[:content_default_http_proxy] = @http_proxy.name
+      end
+    end
+  end
+end

data/app/controllers/katello/sync_management_controller.rb

@@ -32,8 +32,12 @@ module Katello
     end
 
     def sync
-      tasks = sync_repos(params[:repoids]) || []
-      render :json => tasks.as_json
+      begin
+        tasks = sync_repos(params[:repoids]) || []
+        render json: tasks.as_json
+      rescue StandardError => e
+        render json: { error: e.message }, status: :internal_server_error
+      end
     end
 
     def sync_status

data/app/helpers/katello/content_source_helper.rb

@@ -48,7 +48,14 @@ module Katello
 
       source = Foreman::Renderer.get_source(template: template, host: host)
       scope = Foreman::Renderer.get_scope(source: source, host: host)
-      Foreman::Renderer.render(source, scope)
+
+      <<~CMD
+        if [ -f /etc/yggdrasil/config.toml ]; then
+          cp /etc/yggdrasil/config.toml /etc/yggdrasil/config.toml.bak
+          export YGGDRASIL_RESTART_DELAY=10
+          #{Foreman::Renderer.render(source, scope)}
+        fi
+      CMD
     end
   end
 end

data/app/helpers/katello/content_view_helper.rb

@@ -1,10 +1,12 @@
 module Katello
   module ContentViewHelper
     def separated_repo_mapping(repo_mapping, use_multicopy_actions)
-      separated_mapping = { :pulp3_yum_multicopy => {}, :other => {} }
+      separated_mapping = { :pulp3_deb_multicopy => {}, :pulp3_yum_multicopy => {}, :other => {} }
       repo_mapping.each do |source_repos, dest_repo|
         if dest_repo.content_type == "yum" && SmartProxy.pulp_primary.pulp3_support?(dest_repo) && use_multicopy_actions
           separated_mapping[:pulp3_yum_multicopy][source_repos] = dest_repo
+        elsif dest_repo.content_type == "deb" && SmartProxy.pulp_primary.pulp3_support?(dest_repo) && use_multicopy_actions
+          separated_mapping[:pulp3_deb_multicopy][source_repos] = dest_repo
         else
           separated_mapping[:other][source_repos] = dest_repo
         end

data/app/lib/actions/candlepin/activation_key/create.rb

@@ -8,7 +8,6 @@ module Actions
         param :release_version
         param :purpose_role
         param :purpose_usage
-        param :purpse_addons
       end
 
       def run
@@ -18,8 +17,7 @@ module Actions
                                                                                   input[:service_level],
                                                                                   input[:release_version],
                                                                                   input[:purpose_role],
-                                                                                  input[:purpose_usage],
-                                                                                  input[:purpose_addons])
+                                                                                  input[:purpose_usage])
       end
     end
   end

data/app/lib/actions/candlepin/activation_key/update.rb

@@ -9,7 +9,6 @@ module Actions
           param :auto_attach
           param :purpose_role
           param :purpose_usage
-          param :purpose_addons
         end
 
         def run
@@ -19,8 +18,7 @@ module Actions
                                                                 input[:service_level],
                                                                 input[:auto_attach],
                                                                 input[:purpose_role],
-                                                                input[:purpose_usage],
-                                                                input[:purpose_addons])
+                                                                input[:purpose_usage])
         end
       end
     end

data/app/lib/actions/candlepin/environment/set_content.rb

@@ -1,7 +1,11 @@
 module Actions
   module Candlepin
     module Environment
-      class SetContent < Candlepin::Abstract
+      class SetContent < Actions::Base
+        middleware.use ::Actions::Middleware::RemoteAction
+        middleware.use ::Actions::Middleware::CandlepinServicesCheck
+        middleware.use ::Actions::Middleware::KeepSessionId
+
         def plan(content_view, environment, content_view_environment, new_content_id = nil)
           plan_self(:content_view_id => content_view.id,
                     :environment_id => environment.id,
@@ -9,7 +13,7 @@ module Actions
                     :new_content_id => new_content_id)
         end
 
-        def finalize # rubocop:disable Metrics/AbcSize
+        def finalize # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
           content_view = ::Katello::ContentView.find(input[:content_view_id])
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
           content_ids = content_view.repos(environment).map(&:content_id).uniq.compact
@@ -32,6 +36,14 @@ module Actions
               # Since its a dup id refresh the existing ids list (which hopefully will not have the duplicate content)
               # and try again.
               output[:add_ids] = content_ids - existing_ids
+            rescue RestClient::ResourceNotFound => e
+              # Set a higher limit for retries just in case the missing content is not being parsed from the error body correctly.
+              # If the content is not found after the retries, assume it is gone and continue.
+              raise e if ((retries += 1) == 1_000)
+              # Parse the missing content from the Candlepin response and remove it from the add_ids list.
+              missing_content = JSON.parse(e.response.body)['displayMessage'].split(' ')[-1].gsub(/"(.+?)"\./, '\1')
+              Rails.logger.debug "Content #{missing_content} not found in the environment. Removing it from the add_ids list."
+              output[:add_ids].delete(missing_content)
             end
           end
           retries = 0
@@ -39,8 +51,9 @@ module Actions
             begin
               output[:delete_response] = ::Katello::Resources::Candlepin::Environment.delete_content(input[:cp_environment_id], output[:delete_ids])
               break
-            rescue RestClient::ResourceNotFound => e
-              raise e if ((retries += 1) == max_retries)
+            rescue RestClient::ResourceNotFound
+              # If the content is not found after the retries, assume it is gone and continue.
+              break if ((retries += 1) == max_retries)
               # Candlepin raises a 404 in case a content id is not found in this environment
               # If thats the case lets just refresh the existing ids list (which hopefully will not have the 404'd content)
               # and try again.

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

@@ -10,8 +10,7 @@ module Actions
                                   service_level: params[:service_level],
                                   release_version: activation_key.release_version,
                                   purpose_role: activation_key.purpose_role,
-                                  purpose_usage: activation_key.purpose_usage,
-                                  purpose_addons: activation_key.purpose_addons.pluck(:name))
+                                  purpose_usage: activation_key.purpose_usage)
           cp_id = cp_create.output[:response][:id]
           action_subject(activation_key, :cp_id => cp_id)
           plan_self

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

@@ -14,8 +14,7 @@ module Actions
                         service_level: activation_key.service_level,
                         auto_attach: activation_key.auto_attach,
                         purpose_role: activation_key.purpose_role,
-                        purpose_usage: activation_key.purpose_usage,
-                        purpose_addons: activation_key.purpose_addons.pluck(:name))
+                        purpose_usage: activation_key.purpose_usage)
           end
         end
 
@@ -24,8 +23,7 @@ module Actions
           cp_changed?(activation_key.service_level, activation_key_params[:service_level]) ||
           cp_changed?(activation_key.release_version, activation_key_params[:release_version]) ||
           cp_changed?(activation_key.purpose_role, activation_key_params[:purpose_role]) ||
-          cp_changed?(activation_key.purpose_usage, activation_key_params[:purpose_usage]) ||
-          cp_changed?(activation_key.purpose_addon_ids, activation_key_params[:purpose_addon_ids])
+          cp_changed?(activation_key.purpose_usage, activation_key_params[:purpose_usage])
         end
 
         def cp_changed?(activation_key, activation_key_params)

data/app/lib/actions/katello/capsule_content/refresh_repos.rb

@@ -45,9 +45,15 @@ module Actions
 
             pulp_repo = repo.backend_service(smart_proxy)
             if !current_repos_on_capsule_ids.include?(repo.id)
+              # create_mirror_entities does not apply to the primary smart proxy
               pulp_repo.create_mirror_entities
             else
-              tasks += pulp_repo.refresh_mirror_entities
+              if smart_proxy.pulp_primary?
+                # The primary smart proxy has extra remote options, like proxy_url
+                tasks += pulp_repo.refresh_entities
+              else
+                tasks += pulp_repo.refresh_mirror_entities
+              end
             end
           end
           tasks

data/app/lib/actions/katello/content_view/presenters/incremental_updates_presenter.rb

@@ -6,7 +6,8 @@ module Actions
           HUMANIZED_TYPES = {
             ::Katello::Erratum::CONTENT_TYPE => "Errata",
             ::Katello::ModuleStream::CONTENT_TYPE => "Module Streams",
-            ::Katello::Rpm::CONTENT_TYPE => "Packages",
+            ::Katello::Rpm::CONTENT_TYPE => "RPM Packages",
+            ::Katello::Deb::CONTENT_TYPE => "Deb Packages",
           }.freeze
 
           def humanized_output
@@ -25,7 +26,7 @@ module Actions
               if cvv
                 humanized_lines << "Content View: #{cvv.content_view.name} version #{cvv.version}"
                 humanized_lines << _("Added Content:")
-                [::Katello::Erratum, ::Katello::ModuleStream, ::Katello::Rpm].each do |content_type|
+                [::Katello::Erratum, ::Katello::ModuleStream, ::Katello::Rpm, ::Katello::Deb].each do |content_type|
                   unless output[:added_units][content_type::CONTENT_TYPE].blank?
                     humanized_lines << "  #{HUMANIZED_TYPES[content_type::CONTENT_TYPE]}:"
                     humanized_lines += output[:added_units][content_type::CONTENT_TYPE].sort.map { |unit| "        #{unit}" }

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

@@ -59,8 +59,13 @@ module Actions
 
             if options[:importing]
               handle_import(version, **options.slice(:path, :metadata))
-            elsif separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
-              plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum_multicopy], version)
+            else
+              if separated_repo_map[:pulp3_deb_multicopy].keys.flatten.present?
+                plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_deb_multicopy], version)
+              end
+              if separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
+                plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum_multicopy], version)
+              end
             end
 
             concurrence do

data/app/lib/actions/katello/content_view_environment/reassign_objects.rb

@@ -5,11 +5,20 @@ module Actions
         def plan(content_view_environment, options)
           concurrence do
             content_view_environment.hosts.each do |host|
-              plan_action(Host::Reassign, host, options[:system_content_view_id], options[:system_environment_id])
+              content_facet_attributes = host.content_facet
+              if content_facet_attributes.multi_content_view_environment?
+                content_facet_attributes.content_view_environments -= [content_view_environment]
+              else
+                plan_action(Host::Reassign, host, options[:system_content_view_id], options[:system_environment_id])
+              end
             end
 
             content_view_environment.activation_keys.each do |key|
-              plan_action(ActivationKey::Reassign, key, options[:key_content_view_id], options[:key_environment_id])
+              if key.multi_content_view_environment?
+                key.content_view_environments = key.content_view_environments - [content_view_environment]
+              else
+                plan_action(ActivationKey::Reassign, key, options[:key_content_view_id], options[:key_environment_id])
+              end
             end
           end
         end

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

@@ -74,29 +74,31 @@ module Actions
               end
 
               concurrence do
-                if separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
-                  extended_repo_mapping = pulp3_repo_mapping(separated_repo_map[:pulp3_yum_multicopy], old_version)
-                  unit_map = pulp3_content_mapping(content)
-
-                  unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
-                    sequence do
-                      # Pre-copy content if dest_repo is a soft copy of its library instance.
-                      # Don't use extended_repo_mapping because the source repositories are library instances.
-                      # We want the old CV snapshot repositories here so as to not pull in excess new content.
-                      separated_repo_map[:pulp3_yum_multicopy].each do |source_repos, dest_repo|
-                        if dest_repo.soft_copy_of_library?
-                          source_repos.each do |source_repo|
-                            # remove_all flag is set to cover the case of incrementally updating more than once with different content.
-                            # Without it, content from the previous incremental update will be copied as well due to how Pulp repo versions work.
-                            plan_action(Pulp3::Repository::CopyContent, source_repo, SmartProxy.pulp_primary, dest_repo, copy_all: true, remove_all: true)
+                [:pulp3_deb_multicopy, :pulp3_yum_multicopy].each do |mapping|
+                  if separated_repo_map[mapping].keys.flatten.present?
+                    extended_repo_mapping = pulp3_repo_mapping(separated_repo_map[mapping], old_version)
+                    unit_map = pulp3_content_mapping(content)
+
+                    unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
+                      sequence do
+                        # Pre-copy content if dest_repo is a soft copy of its library instance.
+                        # Don't use extended_repo_mapping because the source repositories are library instances.
+                        # We want the old CV snapshot repositories here so as to not pull in excess new content.
+                        separated_repo_map[mapping].each do |source_repos, dest_repo|
+                          if dest_repo.soft_copy_of_library?
+                            source_repos.each do |source_repo|
+                              # remove_all flag is set to cover the case of incrementally updating more than once with different content.
+                              # Without it, content from the previous incremental update will be copied as well due to how Pulp repo versions work.
+                              plan_action(Pulp3::Repository::CopyContent, source_repo, SmartProxy.pulp_primary, dest_repo, copy_all: true, remove_all: true)
+                            end
                           end
                         end
-                      end
-                      copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
-                                                         dependency_solving: dep_solve).output
-                      repos_to_clone.each do |source_repos|
-                        if separated_repo_map[:pulp3_yum_multicopy].keys.include?(source_repos)
-                          copy_repos(repository_mapping[source_repos])
+                        copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
+                                                           dependency_solving: dep_solve).output
+                        repos_to_clone.each do |source_repos|
+                          if separated_repo_map[mapping].keys.include?(source_repos)
+                            copy_repos(repository_mapping[source_repos])
+                          end
                         end
                       end
                     end
@@ -124,12 +126,15 @@ module Actions
 
         def pulp3_content_mapping(content)
           units = ::Katello::Erratum.with_identifiers(content[:errata_ids]) +
+            ::Katello::Deb.with_identifiers(content[:deb_ids]) +
             ::Katello::Rpm.with_identifiers(content[:package_ids])
-          unit_map = { :errata => [], :rpms => [] }
+          unit_map = { :errata => [], :debs => [], :rpms => [] }
           units.each do |unit|
             case unit.class.name
             when "Katello::Erratum"
               unit_map[:errata] << unit.id
+            when "Katello::Deb"
+              unit_map[:debs] << unit.id
             when "Katello::Rpm"
               unit_map[:rpms] << unit.id
             end
@@ -230,6 +235,7 @@ module Actions
               new_errata = new_repo.errata - (matched_old_repo&.errata || [])
               new_module_streams = new_repo.module_streams - (matched_old_repo&.module_streams || [])
               new_rpms = new_repo.rpms - (matched_old_repo&.rpms || [])
+              new_debs = new_repo.debs - (matched_old_repo&.debs || [])
 
               new_errata.each do |erratum|
                 content[::Katello::Erratum::CONTENT_TYPE] << erratum.errata_id
@@ -241,6 +247,9 @@ module Actions
               new_rpms.each do |rpm|
                 content[::Katello::Rpm::CONTENT_TYPE] << rpm.nvra
               end
+              new_debs.each do |deb|
+                content[::Katello::Deb::CONTENT_TYPE] << deb.nva
+              end
             end
           end
           output[:added_units] = content

data/app/lib/actions/katello/flatpak/mirror_remote_repository.rb

@@ -0,0 +1,30 @@
+module Actions
+  module Katello
+    module Flatpak
+      class MirrorRemoteRepository < Actions::EntryAction
+        def plan(remote_repository, product)
+          repo_params = {
+            name: remote_repository.name,
+            label: remote_repository.label,
+            url: remote_repository.flatpak_remote&.registry_url,
+            description: 'Mirrored from: ' + remote_repository.flatpak_remote.name,
+            product_id: product.id,
+            content_type: 'docker',
+            docker_upstream_name: remote_repository.name,
+            include_tags: ["latest"],
+            upstream_username: remote_repository.flatpak_remote.username,
+            upstream_password: remote_repository.flatpak_remote.token,
+            unprotected: true,
+            mirroring_policy: ::Katello::RootRepository::MIRRORING_POLICY_CONTENT,
+          }
+          root = product.add_repo(repo_params)
+          plan_action(::Actions::Katello::Repository::CreateRoot, root)
+        end
+
+        def humanized_name
+          _("Mirror Remote Repository")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/flatpak/scan_remote.rb

@@ -5,25 +5,16 @@ module Actions
     module Flatpak
       class ScanRemote < Actions::EntryAction
         def plan(remote, _args = {})
-          url = format_url(remote.url)
-          plan_self({:remote_id => remote.id, :url => url})
+          plan_self({:remote_id => remote.id, :url => format_url(remote.url)})
         end
 
         def run
           remote = ::Katello::FlatpakRemote.find(input[:remote_id])
-          url = input[:url]
-          request_params = {
-            method: :get,
-            headers: { accept: :json },
-            url: url,
-          }
-          results = RestClient::Request.execute(request_params)
-          results = JSON.parse(results)
+          results = fetch_results(input[:url])
+          remote.update!(registry_url: results['Registry']) unless remote.registry_url
           repositories = results['Results']
           repositories.each do |repository|
             remote_repository = remote.remote_repositories.find_or_initialize_by(name: repository['Name'])
-            remote_repository.label = remote.name + '-' + repository['Name']
-            remote_repository.flatpak_remote = remote
             remote_repository.save!
             repository['Images'].each do |image|
               remote_repository_manifest = remote_repository.manifests.find_or_initialize_by(digest: image['Digest'])
@@ -38,8 +29,22 @@ module Actions
           end
         end
 
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+
         private
 
+        def fetch_results(url)
+          request_params = {
+            method: :get,
+            headers: { accept: :json },
+            url: url,
+          }
+          response = RestClient::Request.execute(request_params)
+          JSON.parse(response)
+        end
+
         def extract_runtime_from_metadata(metadata)
           match = metadata.match(/^runtime=(.*)$/)
           match ? "runtime/" + match[1] : nil

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

@@ -2,18 +2,13 @@ module Actions
   module Katello
     module Host
       class UpdateSystemPurpose < Actions::EntryAction
-        def plan(host, service_level, purpose_role, purpose_usage, purpose_addons)
+        def plan(host, service_level, purpose_role, purpose_usage)
           fail _("Host %s has not been registered with subscription-manager.") % host.name unless host.subscription_facet
 
           host.subscription_facet.service_level = service_level unless service_level.nil?
           host.subscription_facet.purpose_role = purpose_role unless purpose_role.nil?
           host.subscription_facet.purpose_usage = purpose_usage unless purpose_usage.nil?
 
-          if purpose_addons
-            purpose_addon_objects = purpose_addons.delete_if(&:blank?).uniq.map { |x| ::Katello::PurposeAddon.find_or_create_by(name: x) }
-            host.subscription_facet.purpose_addons = purpose_addon_objects
-          end
-
           host.save!
           plan_self(:hostname => host.name)
         end

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

@@ -19,8 +19,22 @@ module Actions
                 plan_action(Pulp3::Repository::SaveVersion, repository, {force_fetch_version: true, tasks: tag_manifest_output[:pulp_tasks]})
               else
                 if content_unit_href
-                  artifact_output = { :content_unit_href => content_unit_href }
                   commit_output = {}
+                  if repository.deb?
+                    # find artifact-href
+                    content_backend_service = smart_proxy.content_service('deb')
+                    artifact_href = content_backend_service.content_api.read(content_unit_href).artifact
+
+                    artifact_output = plan_action(Pulp3::Repository::SaveArtifact,
+                                                  file,
+                                                  repository,
+                                                  smart_proxy,
+                                                  nil,
+                                                  args.dig(:unit_type_id),
+                                                  args.merge({artifact_href: artifact_href})).output
+                  else
+                    artifact_output = { :content_unit_href => content_unit_href }
+                  end
                 else
                   commit_output = plan_action(Pulp3::Repository::CommitUpload,
                                               repository,
@@ -48,7 +62,9 @@ module Actions
             if input[:content_unit_href]
               output[:content_unit_href] = input[:content_unit_href]
             elsif input[:artifact_output]
-              output[:content_unit_href] = input[:artifact_output][:content_unit_href] || input[:artifact_output][:pulp_tasks].last[:created_resources].first
+              output[:content_unit_href] = input[:artifact_output][:content_unit_href] ||
+                input[:artifact_output][:pulp_tasks].last[:created_resources].find { |href| href.include?("/deb/packages") } ||
+                input[:artifact_output][:pulp_tasks].last[:created_resources].first
             else
               output[:content_unit_href] = nil
             end

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

@@ -35,6 +35,10 @@ module Actions
                     katello_errata.id in (#{input[:unit_map][:errata].join(",")})").map(&:erratum_pulp3_href)
           end
 
+          if input[:unit_map][:debs].any?
+            unit_hrefs << ::Katello::Deb.where(:id => input[:unit_map][:debs]).map(&:pulp_id)
+          end
+
           if input[:unit_map][:rpms].any?
             unit_hrefs << ::Katello::Rpm.where(:id => input[:unit_map][:rpms]).map(&:pulp_id)
           end

data/app/lib/katello/api/v2/rendering.rb

@@ -41,8 +41,9 @@ module Katello
         def respond_with_template(action, resource_name, options = {}, &_block)
           yield if block_given?
           status = options[:status] || 200
+          template = options[:full_template] || "katello/api/v2/#{resource_name}/#{action}"
 
-          render :template => "katello/api/v2/#{resource_name}/#{action}",
+          render :template => template,
                  :status => status,
                  :locals => options.slice(:object_name, :root_name, :locals),
                  :layout => "katello/api/v2/layouts/#{options[:layout]}"

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

@@ -257,17 +257,16 @@ module Katello
         search_since = since.present? ? "ended_at > \"#{since}\"" : nil
         search_result = status.present? && status != 'all' ? "result = #{status}" : nil
         labels = 'label ^ (Actions::Katello::Host::Erratum::Install, Actions::Katello::Host::Erratum::ApplicableErrataInstall)'
-        select = 'foreman_tasks_tasks.*'
 
         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'
 
         search = [search_up_to, search_since, search_result, "state = stopped", labels].compact.join(' and ')
 
         tasks = load_resource(klass: ForemanTasks::Task,
                               permission: 'view_foreman_tasks',
-                              select: select,
+                              joins: [:template_invocation],
+                              preload: [:template_invocation],
                               search: search)
         only_host_ids = ::Host.search_for(host_filter).pluck(:id) if host_filter
 
@@ -383,7 +382,7 @@ module Katello
           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')
+          TemplateInvocationInputValue.joins(:template_input).where("template_invocation_id = ? AND template_inputs.name = ?", task.template_invocation.id, 'errata')
             .first&.value&.split(',') || []
         end
       end

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

@@ -0,0 +1,13 @@
+module Katello
+  module Concerns
+    module BookmarkControllerValidatorExtensions
+      extend ActiveSupport::Concern
+
+      def valid_controllers_list
+        @valid_controllers_list ||= (["dashboard", "common_parameters", "/katello/api/v2/host_bootc_images"] +
+          ActiveRecord::Base.connection.tables.map(&:to_s) +
+          Permission.resources.map(&:tableize)).uniq
+      end
+    end
+  end
+end

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

@@ -10,8 +10,7 @@ module Katello
             ::Katello::Util::Data.array_with_indifferent_access akeys
           end
 
-          # rubocop:disable Metrics/ParameterLists
-          def create(name, owner_key, auto_attach, service_level, release_version, purpose_role, purpose_usage, purpose_addons)
+          def create(name, owner_key, auto_attach, service_level, release_version, purpose_role, purpose_usage)
             url = "/candlepin/owners/#{owner_key}/activation_keys"
             params = {
               name: name,
@@ -20,14 +19,13 @@ module Katello
               releaseVer: release_version,
               role: purpose_role,
               usage: purpose_usage,
-              addOns: purpose_addons,
             }
             response = self.post(url, params.to_json, self.default_headers)
             JSON.parse(response.body).with_indifferent_access
           end
 
-          def update(id, release_version, service_level, auto_attach, purpose_role, purpose_usage, purpose_addons)
-            attrs = { :releaseVer => release_version, :serviceLevel => service_level, :autoAttach => auto_attach, :role => purpose_role, :usage => purpose_usage, :addOns => purpose_addons }.delete_if { |_k, v| v.nil? }
+          def update(id, release_version, service_level, auto_attach, purpose_role, purpose_usage)
+            attrs = { :releaseVer => release_version, :serviceLevel => service_level, :autoAttach => auto_attach, :role => purpose_role, :usage => purpose_usage }.delete_if { |_k, v| v.nil? }
             JSON.parse(self.put(path(id), attrs.to_json, self.default_headers).body).with_indifferent_access
           end
 

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

@@ -4,7 +4,8 @@ module Katello
       class Product < CandlepinResource
         class << self
           def all(owner_label, included = [])
-            products = JSON.parse(Candlepin::CandlepinResource.get(path(owner_label) + "?#{included_list(included)}", self.default_headers).body)
+            url = path(owner_label) + "?active=include" + "&#{included_list(included)}"
+            products = JSON.parse(Candlepin::CandlepinResource.get(url, self.default_headers).body)
             ::Katello::Util::Data.array_with_indifferent_access products
           end
 

data/app/lib/katello/util/cveak_migrator.rb

@@ -27,8 +27,9 @@ module Katello
           Rails.logger.info "You may want to change the content view / lifecycle environment for these activation keys manually."
         end
         (aks_with_no_cve + aks_with_missing_cve).each do |ak|
-          default_content_view = ak.organization.default_content_view
-          library = ak.organization.library
+          ak_organization = ::Organization.find_by(id: ak.organization_id)
+          default_content_view = ak_organization.default_content_view
+          library = ak_organization.library
           Rails.logger.info "Updating activation key #{ak.name} with default content_view_id and lifecycle_environment_id"
           ak&.update_columns(content_view_id: default_content_view&.id, environment_id: library&.id)
         end