katello 4.17.1 → 4.18.0.rc1

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

@@ -9,6 +9,7 @@ module Katello
         begin
           options = resource_class.respond_to?(:completer_scope_options) ? resource_class.completer_scope_options(params[:search]) : {}
           items = resource_class.where(:id => self.index_relation).complete_for(params[:search], options)
+          items = filter_autocomplete_items(items)
           items = items.map do |item|
             category = ['and', 'or', 'not', 'has'].include?(item.to_s.sub(/^.*\s+/, '')) ? _('Operators') : ''
             part = item.to_s.sub(/^.*\b(and|or)\b/i) { |match| match.sub(/^.*\s+/, '') }
@@ -20,6 +21,22 @@ module Katello
         end
         render :json => items
       end
+
+      protected
+
+      def filter_autocomplete_items(items)
+        rejected_patterns = rejected_autocomplete_items
+        return items if rejected_patterns.empty?
+
+        items.reject do |item|
+          item_string = item.to_s.downcase
+          rejected_patterns.any? { |pattern| item_string.include?(pattern.downcase) }
+        end
+      end
+
+      def rejected_autocomplete_items
+        []
+      end
     end
   end
 end

data/app/lib/actions/helpers/smart_proxy_sync_helper.rb

@@ -0,0 +1,12 @@
+module Actions
+  module Helpers
+    module SmartProxySyncHelper
+      def schedule_async_repository_proxy_sync(repository)
+        return unless Setting[:foreman_proxy_content_auto_sync]
+        if SmartProxy.unscoped.pulpcore_proxies_with_environment(repository.environment).exists?
+          ForemanTasks.async_task(::Actions::Katello::Repository::CapsuleSync, repository)
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,8 @@ module Actions
   module Katello
     module ContentView
       class AddRollingRepoClone < Actions::EntryAction
+        include Helpers::SmartProxySyncHelper
+
         def plan(content_view, repository_ids)
           library = content_view.organization.library
           clone_ids = []
@@ -27,10 +29,8 @@ module Actions
         end
 
         def run
-          if Setting[:foreman_proxy_content_auto_sync]
-            ::Katello::Repository.where(id: input[:repository_ids]).each do |repo|
-              ForemanTasks.async_task(::Actions::Katello::Repository::CapsuleSync, repo)
-            end
+          ::Katello::Repository.where(id: input[:repository_ids]).each do |repository|
+            schedule_async_repository_proxy_sync(repository)
           end
         end
       end

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

@@ -7,22 +7,27 @@ module Actions
         end
 
         def plan(content_view, environment)
+          env_smart_proxies = SmartProxy.unscoped.with_environment(environment)
+          smart_proxies = env_smart_proxies.select { |sp| sp.authorized?(:manage_capsule_content) && sp.authorized?(:view_capsule_content) }
           sequence do
             concurrence do
-              smart_proxies = SmartProxy.unscoped.with_environment(environment).select { |sp| sp.authorized?(:manage_capsule_content) && sp.authorized?(:view_capsule_content) }
               unless smart_proxies.blank?
                 plan_action(::Actions::BulkAction, ::Actions::Katello::CapsuleContent::Sync, smart_proxies.sort,
                             :content_view_id => content_view.id, :environment_id => environment.id, :skip_content_counts_update => true)
               end
             end
             #For Content view triggered capsule sync, we need to update content counts in one action in finalize, instead of one action per CV, per env, per smart proxy
-            plan_self(:content_view_id => content_view.id, :environment_id => environment.id)
+            plan_self(:content_view_id => content_view.id, :environment_id => environment.id, skipped_capsules: (env_smart_proxies - smart_proxies).any?)
           end
         end
 
         def finalize
+          environment = ::Katello::KTEnvironment.find(input[:environment_id])
+          if input[:skipped_capsules]
+            output[:warning] = "Some smart proxies are not authorized for capsule content management or viewing in environment '#{environment.name}'. Skipping sync for those smart proxies."
+            Rails.logger.warn output[:warning]
+          end
           if Setting[:automatic_content_count_updates]
-            environment = ::Katello::KTEnvironment.find(input[:environment_id])
             smart_proxies = SmartProxy.unscoped.with_environment(environment).select { |sp| sp.authorized?(:manage_capsule_content) && sp.authorized?(:view_capsule_content) }
             options = {environment_id: input[:environment_id], content_view_id: input[:content_view_id]}
             smart_proxies.each do |smart_proxy|

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

@@ -10,8 +10,8 @@ module Actions
         execution_plan_hooks.use :trigger_capsule_sync, :on => :success
         execution_plan_hooks.use :notify_on_failure, :on => [:failure, :paused]
 
-        # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
-        def plan(content_view, description = "", options = {importing: false, syncable: false}) # rubocop:disable Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def plan(content_view, description = "", options = {importing: false, syncable: false})
           action_subject(content_view)
 
           content_view.check_ready_to_publish!(**options.slice(:importing, :syncable))
@@ -32,8 +32,7 @@ module Actions
             end
           end
 
-          # Add non-override components back in
-          options[:override_components] = include_other_components(options[:override_components], content_view)
+          options[:override_components] = include_other_components(content_view, options[:override_components], options[:major], options[:minor])
 
           version = version_for_publish(content_view, options)
           self.version = version
@@ -58,13 +57,24 @@ module Actions
             separated_repo_map = separated_repo_mapping(repository_mapping, content_view.solve_dependencies)
 
             if options[:importing]
-              handle_import(version, **options.slice(:path, :metadata))
-            else
+              handle_importing_content(version, options[:path], options[:metadata])
+            elsif options[:syncable]
               if separated_repo_map[:pulp3_deb_multicopy].keys.flatten.present?
-                plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_deb_multicopy], version)
+                plan_action(::Actions::Katello::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)
+                plan_action(::Actions::Katello::Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum_multicopy], version)
+              end
+
+              # Create import history for syncable imports so they display under hammer's content-import list command.
+              if options[:path] && options[:metadata]
+                plan_action(
+                  ::Actions::Pulp3::ContentViewVersion::CreateImportHistory,
+                  content_view_version_id: version.id,
+                  path: options[:path],
+                  metadata: options[:metadata],
+                  content_view_name: version.content_view.name
+                )
               end
             end
 
@@ -95,6 +105,7 @@ module Actions
                       environment_id: library.id, user_id: ::User.current.id, skip_promotion: options[:skip_promotion])
           end
         end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def humanized_name
           _("Publish")
@@ -161,9 +172,25 @@ module Actions
 
         private
 
-        def include_other_components(override_components, content_view)
+        # On an upgrade with component overrides, include components from the old content view version that
+        # wouldn't have been carried over otherwise.
+        def include_other_components(content_view, override_components, major, minor)
           if override_components.present?
-            content_view.components.each do |component|
+            # For incremental updates, we need to get components from the content view version immediately prior to this
+            # version. We do not upgrade components to the latest version on incremental updates.
+            if major.present? && minor.to_i > 0
+              prev_minor_version = content_view.versions.find_by(major: major, minor: (minor - 1))
+              unless prev_minor_version
+                fail _("During incremental update, the previous content view version '%s' could not be found.") % "#{content_view.name} #{major}.#{minor - 1}"
+              end
+              components_to_test = prev_minor_version.components
+
+            # For major versions, fetch the latest component versions from the content view.
+            else
+              components_to_test = content_view.components
+            end
+
+            components_to_test.each do |component|
               component_has_override = override_components.detect do |override_component|
                 component.content_view_id == override_component.content_view_id
               end
@@ -207,14 +234,14 @@ module Actions
           ::Katello::KTEnvironment.where(:id => environment_ids)
         end
 
-        def handle_import(version, path:, metadata:)
+        def handle_importing_content(version, path = nil, metadata = nil)
           sequence do
             plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, { path: path, metadata: metadata })
             concurrence do
               version.importable_repositories.pluck(:id).each do |id|
                 # need to force full_indexing for these version repositories
                 # on import. This will then help us correctly copy version units to the library
-                plan_action(Katello::Repository::IndexContent, id: id, full_index: true)
+                plan_action(::Actions::Katello::Repository::IndexContent, id: id, full_index: true)
               end
             end
             concurrence do

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

@@ -3,6 +3,7 @@ module Actions
     module Flatpak
       class MirrorRemoteRepository < Actions::EntryAction
         def plan(remote_repository, product)
+          action_subject(remote_repository)
           repo_params = {
             name: remote_repository.name,
             label: remote_repository.label,
@@ -15,7 +16,7 @@ module Actions
             upstream_username: remote_repository.flatpak_remote.username,
             upstream_password: remote_repository.flatpak_remote.token,
             unprotected: true,
-            mirroring_policy: ::Katello::RootRepository::MIRRORING_POLICY_CONTENT,
+            mirroring_policy: Setting[:default_non_yum_mirroring_policy],
           }
           root = product.add_repo(repo_params)
           plan_action(::Actions::Katello::Repository::CreateRoot, root)

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

@@ -9,14 +9,24 @@ module Actions
         def plan(repo)
           if repo.node_syncable?
             concurrence do
-              smart_proxies = ::SmartProxy.unscoped.with_environment(repo.environment).select { |sp| sp.authorized?(:manage_capsule_content) && sp.authorized?(:view_capsule_content) }
+              env_smart_proxies = SmartProxy.unscoped.with_environment(repo.environment)
+              smart_proxies = env_smart_proxies.select { |sp| sp.authorized?(:manage_capsule_content) && sp.authorized?(:view_capsule_content) }
               unless smart_proxies.blank?
                 plan_action(::Actions::BulkAction, ::Actions::Katello::CapsuleContent::Sync, smart_proxies,
                             :repository_id => repo.id)
               end
+              plan_self(environment_id: repo.environment.id, skipped_capsules: (env_smart_proxies - smart_proxies).any?)
             end
           end
         end
+
+        def finalize
+          environment = ::Katello::KTEnvironment.find(input[:environment_id])
+          if input[:skipped_capsules]
+            output[:warning] = "Some smart proxies are not authorized for capsule content management or viewing in environment '#{environment.name}'. Skipping sync for those smart proxies."
+            Rails.logger.warn output[:warning]
+          end
+        end
       end
     end
   end

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

@@ -4,6 +4,7 @@ module Actions
     module Repository
       class ImportUpload < Actions::EntryAction
         include Helpers::RollingCVRepos
+        include Helpers::SmartProxySyncHelper
 
         # rubocop:disable Metrics/MethodLength
         def plan(repository, uploads, options = {})
@@ -63,9 +64,7 @@ module Actions
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])
-          if input[:sync_capsule] && (Setting[:foreman_proxy_content_auto_sync])
-            ForemanTasks.async_task(Katello::Repository::CapsuleSync, repository)
-          end
+          schedule_async_repository_proxy_sync(repository) if input[:sync_capsule]
           output[:upload_results] = results_to_json(input[:upload_results])
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end

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

@@ -6,6 +6,7 @@ module Actions
         extend ApipieDSL::Class
         include Helpers::Presenter
         include Helpers::RollingCVRepos
+        include Helpers::SmartProxySyncHelper
         include ::Actions::ObservableAction
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
@@ -72,7 +73,7 @@ module Actions
             update_rolling_content_views_async(repo, input[:contents_changed])
           end
           repo.clear_smart_proxy_sync_histories if input[:contents_changed]
-          ForemanTasks.async_task(Repository::CapsuleSync, repo) if Setting[:foreman_proxy_content_auto_sync]
+          schedule_async_repository_proxy_sync(repo)
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 

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

@@ -7,6 +7,7 @@ module Actions
     module Repository
       class UploadFiles < Actions::EntryAction
         include Helpers::RollingCVRepos
+        include Helpers::SmartProxySyncHelper
 
         def plan(repository, files, content_type = nil, options = {})
           action_subject(repository)
@@ -52,7 +53,7 @@ module Actions
 
         def run
           repository = ::Katello::Repository.find(input[:repository][:id])
-          ForemanTasks.async_task(Repository::CapsuleSync, repository) if Setting[:foreman_proxy_content_auto_sync]
+          schedule_async_repository_proxy_sync(repository)
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 

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

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

data/app/lib/katello/resources/cdn.rb

@@ -187,7 +187,7 @@ module Katello
         def net_http_class
           if proxy
             uri = URI(proxy.url) #Net::HTTP::Proxy ignores port as part of the url
-            Net::HTTP::Proxy("#{uri.host}", uri.port, proxy.username, proxy.password)
+            Net::HTTP::Proxy(uri.hostname, uri.port, proxy.username, proxy.password)
           else
             Net::HTTP
           end

data/app/models/katello/concerns/smart_proxy_extensions.rb

@@ -234,7 +234,21 @@ module Katello
           update_container_repo_list
           users = container_gateway_users
           update_user_container_repo_mapping(users) if users.any?
+          if content_facets.any?
+            update_container_gateway_hosts
+            update_host_container_repo_mapping(content_facets)
+          end
+        end
+      end
+
+      def update_container_gateway_hosts
+        # This method updates the hosts that are registered with the container gateway.
+        hosts = self.content_facets.map do |facet|
+          {
+            uuid: facet.uuid,
+          }
         end
+        ProxyAPI::ContainerGateway.new(url: self.url).update_hosts({ hosts: hosts })
       end
 
       def update_container_repo_list
@@ -271,6 +285,31 @@ module Katello
         ProxyAPI::ContainerGateway.new(url: self.url).user_repository_mapping(user_repo_map)
       end
 
+      def update_host_container_repo_mapping(content_facets)
+        host_repo_map = { hosts: [] }
+        content_facets.each do |facet|
+          repositories = ::Katello::Repository.readable_docker_catalog(facet.host)
+          host_repo_map[:hosts] << { facet.uuid => build_repo_list(repositories) }
+        end
+        ProxyAPI::ContainerGateway.new(url: self.url).host_repository_mapping(host_repo_map)
+      end
+
+      def update_host_repositories(host)
+        return unless host&.content_facet&.uuid
+        host_repos = { hosts: [] }
+        repositories = ::Katello::Repository.readable_docker_catalog(host)
+        host_repos[:hosts] << { host.content_facet.uuid => build_repo_list(repositories) }
+        ProxyAPI::ContainerGateway.new(url: self.url).update_host_repositories(host_repos)
+      end
+
+      def build_repo_list(repositories)
+        unauthenticated_repositories = unauthenticated_container_repositories
+        repositories.filter_map do |repo|
+          next if repo.container_repository_name.nil? || unauthenticated_repositories.include?(repo.id)
+          { repository: repo.container_repository_name, auth_required: true }
+        end
+      end
+
       def unauthenticated_container_repositories
         ::Katello::Repository.joins(:environment).where("#{::Katello::KTEnvironment.table_name}.registry_unauthenticated_pull" => true).select(:id).pluck(:id)
       end
@@ -611,14 +650,13 @@ module Katello
       end
 
       def rhsm_url
-        # Since Foreman 3.1 this setting is set
-        if (rhsm_url = setting(SmartProxy::PULP3_FEATURE, 'rhsm_url'))
-          URI(rhsm_url)
-          # Compatibility fall back
-        elsif pulp_primary?
-          URI("https://#{URI.parse(url).host}/rhsm")
-        elsif pulp_mirror?
-          URI("https://#{URI.parse(url).host}:8443/rhsm")
+        if (rhsm_url_setting = setting(SmartProxy::PULP3_FEATURE, 'rhsm_url').presence)
+          URI(rhsm_url_setting)
+        else
+          # TODO: get this from routes
+          uri = URI.parse(Setting[:foreman_url])
+          uri.path = '/rhsm'
+          uri
         end
       end
 

data/app/models/katello/content_view_environment.rb

@@ -42,7 +42,7 @@ module Katello
 
     def self.for_content_facets(content_facets)
       joins(:content_facets).
-        where("#{Katello::ContentViewEnvironmentContentFacet.table_name}.content_facet_id" => content_facets)
+        where("#{Katello::ContentViewEnvironmentContentFacet.table_name}.content_facet_id" => content_facets).distinct
     end
 
     def self.with_label_and_org(label, organization: Organization.current)

data/app/models/katello/erratum.rb

@@ -31,7 +31,16 @@ module Katello
     scoped_search :on => :title, :rename => :synopsis, :complete_value => true, :only_explicit => true
     scoped_search :on => :severity, :complete_value => true
     scoped_search :on => :errata_type, :only_explicit => true
-    scoped_search :on => :errata_type, :rename => :type, :complete_value => true
+    scoped_search :on => :errata_type,
+                  :rename => :type,
+                  :operators => ['=', '!='],
+                  :complete_value => {
+                    'security' => 'security',
+                    'bugfix' => 'bugfix',
+                    'enhancement' => 'enhancement',
+                    'other' => 'other',
+                  },
+                  :ext_method => :filter_errata_type
     scoped_search :on => :issued, :complete_value => true
     scoped_search :on => :updated, :complete_value => true
     scoped_search :on => :reboot_suggested, :complete_value => true
@@ -58,6 +67,22 @@ module Katello
       end
     end
 
+    def self.filter_errata_type(_key, operator, value)
+      if value.downcase == "other"
+        if ['!=', '<>'].include?(operator)
+          { conditions: sanitize_sql_for_conditions(["errata_type IN (?)", TYPES]) }
+        else
+          { conditions: sanitize_sql_for_conditions(["errata_type NOT IN (?)", TYPES]) }
+        end
+      else
+        if ['!=', '<>'].include?(operator)
+          { conditions: sanitize_sql_for_conditions(["errata_type != ?", value]) }
+        else
+          { conditions: sanitize_sql_for_conditions(["errata_type = ?", value]) }
+        end
+      end
+    end
+
     scope :security, -> { of_type(Erratum::SECURITY) }
     scope :bugfix, -> { of_type(Erratum::BUGZILLA) }
     scope :enhancement, -> { of_type(Erratum::ENHANCEMENT) }

data/app/models/katello/flatpak_remote.rb

@@ -17,7 +17,6 @@ module Katello
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :organization_id, :complete_value => true, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
     scoped_search :on => :url, :complete_value => true
-    scoped_search :on => :seeded, :complete_value => true
     scoped_search :on => :registry_url, :complete_value => true
 
     def self.humanize_class_name(_name = nil)

data/app/models/katello/flatpak_remote_repository.rb

@@ -1,6 +1,7 @@
 module Katello
   class FlatpakRemoteRepository < Katello::Model
     include Ext::LabelFromName
+    include ForemanTasks::Concerns::ActionSubject
 
     belongs_to :flatpak_remote, inverse_of: :remote_repositories
     has_many :remote_repository_manifests, dependent: :destroy, class_name: 'Katello::FlatpakRemoteRepositoryManifest'
@@ -12,6 +13,7 @@ module Katello
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :label, :complete_value => true
     scoped_search :on => :flatpak_remote_id, :complete_value => true, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
+    scoped_search :on => :id, :complete_value => true
 
     alias_attribute :manifests, :remote_repository_manifests
 
@@ -26,5 +28,27 @@ module Katello
     def repository_dependencies
       manifest_dependencies&.map(&:remote_repository)
     end
+
+    def last_mirrored_task
+      label = ::Actions::Katello::Flatpak::MirrorRemoteRepository.name
+      type = ::Katello::FlatpakRemoteRepository.name
+      ForemanTasks::Task.search_for("label = #{label} and resource_type = #{type} and resource_id = #{self.id}")
+        .order("started_at desc")
+        .first
+    end
+
+    def last_mirrored_status
+      task = last_mirrored_task
+      presenter = Katello::FlatpakRemoteMirrorStatusPresenter.new(self, task)
+      presenter.mirror_progress.slice(:mirror_id, :result, :started_at, :last_mirror_words)
+    end
+
+    def application_name
+      ref = self.manifests.first&.flatpak_ref
+      return nil if ref.blank?
+
+      match = ref.match(%r{\b(?:app|runtime)/([a-zA-Z0-9_.]+)})
+      match ? match[1] : nil
+    end
   end
 end

data/app/models/katello/glue/pulp/repos.rb

@@ -142,7 +142,7 @@ module Katello
           repo_param[:download_policy] = Setting[:default_download_policy]
         end
 
-        repo_param[:mirroring_policy] = Katello::RootRepository::MIRRORING_POLICY_ADDITIVE if repo_param[:mirroring_policy].blank?
+        repo_param[:mirroring_policy] ||= Katello::Repository::YUM_TYPE == repo_param[:content_type] ? Setting[:default_yum_mirroring_policy] : Setting[:default_non_yum_mirroring_policy]
 
         repo_param = repo_param.merge(:product_id => self.id)
 

data/app/models/katello/root_repository.rb

@@ -46,6 +46,7 @@ module Katello
     MIRRORING_POLICY_CONTENT = 'mirror_content_only'.freeze
     MIRRORING_POLICY_COMPLETE = 'mirror_complete'.freeze
     MIRRORING_POLICIES = [MIRRORING_POLICY_ADDITIVE, MIRRORING_POLICY_COMPLETE, MIRRORING_POLICY_CONTENT].freeze
+    NON_YUM_MIRRORING_POLICIES = [MIRRORING_POLICY_ADDITIVE, MIRRORING_POLICY_CONTENT].freeze
 
     ALLOWED_UPDATE_FIELDS = ['updated_at', 'content_id'].freeze
 

data/app/presenters/katello/flatpak_remote_mirror_status_presenter.rb

@@ -0,0 +1,41 @@
+module Katello
+  class FlatpakRemoteMirrorStatusPresenter
+    include ::ActionView::Helpers::DateHelper
+    include ::Katello::TranslationHelper
+
+    def initialize(remote_repository, task)
+      @remote_repository = remote_repository
+      @task = task
+    end
+
+    def mirror_progress
+      return { state: nil } unless @remote_repository
+      return empty_task(@remote_repository) unless @task
+
+      {
+        id: @remote_repository.id,
+        mirror_id: @task.id,
+        state: format_state(@task),
+        raw_state: raw_state(@task),
+        result: @task.result,
+        started_at: @task.started_at,
+        last_mirror_words: time_ago_in_words(@task.started_at),
+      }
+    end
+
+    private
+
+    def empty_task(remote_repository)
+      { id: remote_repository.id, progress: {}, state: "Never mirrored or task cleaned up", raw_state: "never_mirrored" }
+    end
+
+    def raw_state(task)
+      return 'error' if task.result == 'error' || task.result == 'warning'
+      task.state
+    end
+
+    def format_state(task)
+      task.state
+    end
+  end
+end

data/app/services/katello/repository_type_manager.rb

@@ -198,5 +198,7 @@ module Katello
         end
       end
     end
+
+    load 'katello/repository_types.rb'
   end
 end

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

@@ -10,7 +10,7 @@ template_inputs:
   input_type: user
   required: false
 - name: Application name
-  description: Name of the application to install
+  description: Full Flatpak app ID (e.g. org.mozilla.firefox). Avoid short names like firefox to ensure the correct app is installed.
   input_type: user
   required: true
 - name: Launch a session bus instance
@@ -28,4 +28,19 @@ template_inputs:
   app_name = input('Application name')
   use_dbus_session = input('Launch a session bus instance') == 'true'
 %>
-sudo <%= use_dbus_session ? 'dbus-run-session ' : ''%>flatpak install <%= remote_name %> <%= app_name %> --assumeyes
+<% if use_dbus_session %>
+sudo dbus-run-session bash -c '
+  echo "Installing flatpak app <%= app_name %> from <%= remote_name %>"
+  if ! output=$(flatpak install <%= remote_name %> <%= app_name %> --assumeyes 2>&1); then
+  echo "$output"
+  echo "Flatpak install failed"
+  exit 1
+  fi
+  echo "$output"
+'
+dbus_status=$?
+sudo pkill -TERM -f flatpak-oci-authenticator || true
+exit $dbus_status
+<% else %>
+sudo flatpak install <%= remote_name %> <%= app_name %> --assumeyes
+<% end %>

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

@@ -9,21 +9,35 @@ template_inputs:
   description: URL of container registry
   input_type: user
   required: true
+- name: Set up certificate authentication
+  description: Set up certificate authentication for the registry. You can ignore username/password if using certificate authentication.
+  input_type: user
+  required: false
+  options: "true\r\nfalse"
+  advanced: false
+  value_type: plain
+  default: 'false'
 - name: Username
   description: Username for container registry login
   input_type: user
-  required: true
+  required: false
 - name: Password
   description: Password/Access token for container registry login
   input_type: user
-  required: true
+  required: false
   hidden_value: true
 %>
 
 <%
   server_url = input('Flatpak registry URL')
+  setup_cert_auth = input('Set up certificate authentication')
   username = input('Username')
   password = input('Password')
 %>
 
-echo <%= shell_escape(password) %> | sudo podman login <%= server_url %> --username <%= username %> --password-stdin --authfile /etc/flatpak/oci-auth.json
+<% if truthy?(setup_cert_auth) -%>
+  <% server_hostname = server_url.gsub(/https?:\/\//, '').split('/').first %>
+  <%= snippet('container_certs_setup', variables: { registration_host: server_hostname }) -%>
+<% else -%>
+  echo <%= shell_escape(password) %> | sudo podman login <%= server_url %> --username <%= username %> --password-stdin --authfile /etc/flatpak/oci-auth.json
+<% end -%>

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

@@ -7,7 +7,7 @@ feature: katello_errata_install_by_search
 provider_type: script
 template_inputs:
 - name: Errata search query
-  description: Filter criteria for errata to be installed.
+  description: Filter criteria for errata to be installed. IMPORTANT- If left blank, the job will attempt to install all applicable errata.
   input_type: user
   required: false
 foreign_input_sets: