katello 4.16.1 → 4.17.0.rc1

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

@@ -43,6 +43,9 @@ module Katello
     param :repository_ids, Array, :desc => N_("list of repository ids")
     param :description, String, :desc => N_("description of the filter")
     def create
+      if @view.rolling?
+        fail HttpErrors::BadRequest, _("It's not possible to create a filter for a rolling content view.")
+      end
       params[:type] = "erratum" if (params[:type] == "erratum_date" || params[:type] == "erratum_id")
       filter = ContentViewFilter.create_for(params[:type], filter_params.merge(:content_view => @view))
       respond :resource => filter

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

@@ -60,6 +60,9 @@ module Katello
     param :environment_ids, Array, :desc => N_("Identifiers for Lifecycle Environment")
     param :description, String, :desc => N_("The description for the content view version promotion")
     def promote
+      if @view.rolling?
+        fail HttpErrors::BadRequest, _("It's not possible to promote a rolling content view.")
+      end
       is_force = ::Foreman::Cast.to_bool(params[:force])
       task = async_task(::Actions::Katello::ContentView::Promote,
                         @content_view_version, @environments, is_force, params[:description])
@@ -97,6 +100,9 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. New ver
     api :DELETE, "/content_view_versions/:id", N_("Remove content view version")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
     def destroy
+      if @view.rolling?
+        fail HttpErrors::BadRequest, _("It's not possible to destroy a version of a rolling content view.")
+      end
       task = async_task(::Actions::Katello::ContentViewVersion::Destroy, @content_view_version)
       respond_for_async :resource => task
     end

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

@@ -84,12 +84,14 @@ module Katello
     param :name, String, :desc => N_("Name of the content view"), :required => true
     param :label, String, :desc => N_("Content view label")
     param :composite, :bool, :desc => N_("Composite content view")
+    param :rolling, :bool, :desc => N_("Rolling content view")
     param_group :content_view
     def create
       @content_view = ContentView.create!(view_params) do |view|
         view.organization = @organization
         view.label ||= labelize_params(params[:content_view])
       end
+      sync_task(::Actions::Katello::ContentView::Create, @content_view)
 
       respond :resource => @content_view
     end
@@ -192,6 +194,9 @@ module Katello
     param :key_content_view_id, :number, :desc => N_("content view to reassign orphaned activation keys to")
     param :key_environment_id, :number, :desc => N_("environment to reassign orphaned activation keys to")
     def bulk_delete_versions
+      if @content_view.rolling?
+        fail HttpErrors::BadRequest, _("It's not possible to bulk remove versions from a rolling content view.")
+      end
       params[:bulk_content_view_version_ids] ||= {}
 
       versions = find_bulk_items(bulk_params: params[:bulk_content_view_version_ids],
@@ -237,6 +242,9 @@ module Katello
     param :name, String, :required => true, :desc => N_("New content view name")
     def copy
       @content_view = Katello::ContentView.readable.find_by(:id => params[:id])
+      if @content_view.rolling?
+        fail HttpErrors::BadRequest, _("It's not possible to copy a rolling content view.")
+      end
       throw_resource_not_found(name: 'content_view', id: params[:id]) if @content_view.blank?
       ensure_non_default
       new_content_view = @content_view.copy(params[:content_view][:name])
@@ -246,6 +254,9 @@ module Katello
     private
 
     def validate_publish_params!
+      if @content_view.rolling?
+        fail HttpErrors::BadRequest, _("It's not possible to publish a rolling content view.")
+      end
       if params[:repos_units].present? && @content_view.composite?
         fail HttpErrors::BadRequest, _("Directly setting package lists on composite content views is not allowed. Please " \
                                      "update the components, then re-publish the composite.")
@@ -284,7 +295,7 @@ module Katello
     def view_params
       attrs = [:name, :description, :auto_publish, :solve_dependencies, :import_only,
                :default, :created_at, :updated_at, :next_version, {:component_ids => []}]
-      attrs.push(:label, :composite) if action_name == "create"
+      attrs.push(:label, :composite, :rolling) if action_name == "create"
       if (!@content_view || !@content_view.composite?)
         attrs.push({:repository_ids => []}, :repository_ids)
       end

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

@@ -108,6 +108,9 @@ module Katello
       @version = ContentViewVersion.exportable.find_by_id(params[:id])
       throw_resource_not_found(name: 'content view version', id: params[:id]) if @version.blank?
       @view = @version.content_view
+      if @view.rolling?
+        fail HttpErrors::BadRequest, _("It's not possible to export a rolling content view.")
+      end
     end
 
     def find_history

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

@@ -240,20 +240,18 @@ module Katello
     def find_content_overrides
       if !params.dig(:content_overrides_search, :search).nil?
 
-        content_labels = ::Katello::Content.joins(:product_contents)
-                            .where("#{Katello::ProductContent.table_name}.product_id": @host.organization.products.subscribable.enabled)
-                            .search_for(params[:content_overrides_search][:search])
-                            .pluck(:label)
-
-        if Foreman::Cast.to_bool(params.dig(:content_overrides_search, :limit_to_env))
-          env_content = ProductContentFinder.new(
-              :match_subscription => false,
-              :match_environment => true,
-              :consumable => @host.subscription_facet
-          ).product_content
-          env_content_labels = ::Katello::Content.find(env_content.pluck(:content_id)).pluck(:label)
-          content_labels &= env_content_labels
-        end
+        content = ::Katello::Content.joins(:product_contents)
+                                    .where("#{Katello::ProductContent.table_name}.product_id": @host.organization.products.subscribable.enabled)
+
+        env_content = ProductContentFinder.new(
+          :match_subscription => false,
+          :match_environment => Foreman::Cast.to_bool(params.dig(:content_overrides_search, :limit_to_env)),
+          :consumable => @host.subscription_facet
+        ).product_content
+        content = content.where(id: env_content.pluck(:content_id))
+
+        content_labels = content.search_for(params[:content_overrides_search][:search])
+          .pluck(:label)
 
         @content_overrides = content_labels.map do |label|
           { content_label: label,

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

@@ -109,16 +109,16 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/organizations/:label/cancel_repo_discover", N_("Cancel repository discovery")
-    param :label, String, :desc => N_("Organization label")
+    api :PUT, "/organizations/:id/cancel_repo_discover", N_("Cancel repository discovery")
+    param :id, String, :desc => N_("Organization ID or title")
     param :url, String, :desc => N_("base url to perform repo discovery on")
     def cancel_repo_discover
       task = @organization.cancel_repo_discovery
       respond_for_async :resource => task
     end
 
-    api :GET, "/organizations/:label/download_debug_certificate", N_("Download a debug certificate")
-    param :label, String, :desc => N_("Organization label")
+    api :GET, "/organizations/:id/download_debug_certificate", N_("Download a debug certificate")
+    param :id, String, :desc => N_("Organization ID or title")
     def download_debug_certificate
       pem = @organization.debug_cert
       data = "#{pem[:key]}\n\n#{pem[:cert]}"
@@ -168,11 +168,15 @@ module Katello
 
     protected
 
+    def organization_export_content_permission?
+      org = Organization.friendly.find(params[:id])
+      org&.authorized?(:export_content)
+    end
+
     def action_permission
       if params[:action] == "releases"
         :view
-      elsif params[:action] == "download_debug_certificate" &&
-          Organization.find(params[:id]).authorized?(:export_content)
+      elsif params[:action] == "download_debug_certificate" && organization_export_content_permission?
         :view
       elsif %w(download_debug_certificate redhat_provider repo_discover cdn_configuration
                cancel_repo_discover).include?(params[:action])
@@ -182,10 +186,6 @@ module Katello
       end
     end
 
-    def resource_identifying_attributes
-      %w(id label)
-    end
-
     def skip_nested_id
       ["default_content_view_id", "library_id"]
     end

data/app/controllers/katello/concerns/authorization/api/v2/content_views_controller.rb

@@ -119,7 +119,11 @@ module Katello
       return deny_access unless KTEnvironment.promotable.where(:id => env_ids).count == env_ids.size && view.promotable_or_removable?
 
       total_count = Katello::Host::ContentFacet.with_content_views(view).with_environments(env_ids).count
-      if total_count > 0
+      single_env_host_count = Katello::Host::ContentFacet
+        .with_content_views(view)
+        .with_environments(env_ids)
+        .count { |facet| !facet.multi_content_view_environment? }
+      if single_env_host_count > 0
         unless options[:system_content_view_id] && options[:system_environment_id]
           fail _("Unable to reassign content hosts. Please provide system_content_view_id and system_environment_id.")
         end
@@ -132,7 +136,9 @@ module Katello
         end
       end
 
-      if Katello::ActivationKey.with_content_views(view).with_environments(env_ids).count > 0
+      keys = Katello::ActivationKey.with_content_views(view).with_environments(env_ids)
+      single_env_keys_exist = keys.any? { |key| !key.multi_content_view_environment? }
+      if single_env_keys_exist
         # if we are reassigning activation key environments/ cv
         # make sure the activation key using present environments or cv are editable.
         unless options[:key_content_view_id] && options[:key_environment_id]

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

@@ -0,0 +1,25 @@
+module Actions
+  module Helpers
+    module RollingCVRepos
+      def find_related_rolling_repos(repo)
+        repo.root.repositories.in_environment(repo.environment).where(
+          content_view_version: ::Katello::ContentViewVersion.where(content_view: ::Katello::ContentView.rolling)
+        )
+      end
+
+      def update_rolling_content_views(repo)
+        concurrence do
+          find_related_rolling_repos(repo).each do |rolling_repo|
+            plan_action(::Actions::Katello::ContentView::RefreshRollingRepo, rolling_repo, true)
+          end
+        end
+      end
+
+      def update_rolling_content_views_async(repo, contents_changed)
+        find_related_rolling_repos(repo).each do |rolling_repo|
+          ForemanTasks.async_task(::Actions::Katello::ContentView::RefreshRollingRepo, rolling_repo, contents_changed)
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@ module Actions
   module Katello
     module CapsuleContent
       class SyncCapsule < ::Actions::EntryAction
+        include Helpers::RollingCVRepos
         # rubocop:disable Metrics/MethodLength
         execution_plan_hooks.use :update_content_counts, :on => :success
         def plan(smart_proxy, options = {})
@@ -58,7 +59,11 @@ module Actions
           smart_proxy_helper.lifecycle_environment_check(environment, repository)
           if repository
             if skip_metatadata_check || !repository.smart_proxy_sync_histories.where(:smart_proxy_id => smart_proxy).any? { |sph| !sph.finished_at.nil? }
-              [repository]
+              if repository.library_instance?
+                [repository] + find_related_rolling_repos(repository)
+              else
+                [repository]
+              end
             end
           else
             repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count

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

@@ -0,0 +1,39 @@
+module Actions
+  module Katello
+    module ContentView
+      class AddRollingRepoClone < Actions::EntryAction
+        def plan(content_view, repository_ids)
+          library = content_view.organization.library
+          clone_ids = []
+
+          concurrence do
+            ::Katello::Repository.where(id: repository_ids).each do |repository|
+              sequence do
+                clone = content_view.get_repo_clone(library, repository).first
+                if clone.nil?
+                  clone = repository.build_clone(content_view: content_view, environment: library)
+                  clone.save!
+                end
+                plan_action(RefreshRollingRepo, clone, false)
+
+                view_env_cp_id = content_view.content_view_environment(library).cp_id
+                content_id = repository.content_id
+                plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env_cp_id, :content_id => content_id)
+                clone_ids << clone.id
+              end
+            end
+          end
+          plan_self(repository_ids: clone_ids)
+        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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,9 @@ module Actions
       class Create < Actions::Base
         def plan(content_view)
           content_view.save!
+          if content_view.rolling?
+            plan_action(AddToEnvironment, content_view.create_new_version, content_view.organization.library)
+          end
         end
 
         def humanized_name

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

@@ -0,0 +1,40 @@
+module Actions
+  module Katello
+    module ContentView
+      class RefreshRollingRepo < Actions::EntryAction
+        def plan(repository, contents_changed)
+          action_subject repository
+          sequence do
+            plan_self(repository_id: repository.id, contents_changed: contents_changed)
+            plan_action(Pulp3::Repository::RefreshDistribution, repository, SmartProxy.pulp_primary)
+            plan_action(Repository::IndexContent, id: repository.id, source_repository_id: repository.library_instance.id)
+            plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repository.id])
+          end
+        end
+
+        def humanized_name
+          _('Refresh RollingCV Repo')
+        end
+
+        def run
+          repository = ::Katello::Repository.find(input[:repository_id])
+          library_instance = repository.library_instance
+          # ensure IndexContent is not skipped!
+          repository.last_contents_changed = DateTime.now if repository.version_href != library_instance.version_href
+
+          repository.version_href = library_instance.version_href
+          repository.publication_href = library_instance.publication_href
+          if repository.deb_using_structured_apt?
+            repository.content_id = library_instance.content_id
+          end
+          repository.save!
+        end
+
+        def finalize
+          repository = ::Katello::Repository.find(input[:repository_id])
+          repository.clear_smart_proxy_sync_histories if input[:contents_changed]
+        end
+      end
+    end
+  end
+end

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

@@ -119,13 +119,17 @@ module Actions
           end
           all_cv_envs = combined_cv_envs(cv_envs, versions)
 
-          if all_cv_envs.flat_map(&:hosts).any? && !cve_exists?(options[:system_environment_id],
-                                                                options[:system_content_view_id])
+          single_env_hosts_exist = all_cv_envs.flat_map(&:hosts).any? do |host|
+            !host.content_facet.multi_content_view_environment?
+          end
+          if single_env_hosts_exist && !cve_exists?(options[:system_environment_id], options[:system_content_view_id])
             fail _("Unable to reassign systems. Please check system_content_view_id and system_environment_id.")
           end
 
-          if all_cv_envs.flat_map(&:activation_keys).any? && !cve_exists?(options[:key_environment_id],
-                                                                          options[:key_content_view_id])
+          single_env_keys_exist = all_cv_envs.flat_map(&:activation_keys).any? do |key|
+            !key.multi_content_view_environment?
+          end
+          if single_env_keys_exist && !cve_exists?(options[:key_environment_id], options[:key_content_view_id])
             fail _("Unable to reassign activation_keys. Please check activation_key_content_view_id and activation_key_environment_id.")
           end
         end

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

@@ -0,0 +1,28 @@
+module Actions
+  module Katello
+    module ContentView
+      class RemoveRollingRepoClone < Actions::EntryAction
+        def plan(content_view, repository_ids)
+          library = content_view.organization.library
+
+          clone_repo_ids = []
+          concurrence do
+            ::Katello::Repository.where(id: repository_ids).each do |repository|
+              clone_repo = content_view.get_repo_clone(library, repository).first
+              next if clone_repo.nil?
+
+              clone_repo_ids << clone_repo.id
+              plan_action(Actions::Pulp3::Repository::DeleteDistributions, clone_repo.id, SmartProxy.pulp_primary)
+            end
+            plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library))
+          end
+          plan_self(repository_ids: clone_repo_ids)
+        end
+
+        def run
+          ::Katello::Repository.where(id: input[:repository_ids]).destroy_all
+        end
+      end
+    end
+  end
+end

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

@@ -28,6 +28,14 @@ module Actions
             end
           end
 
+          if content_view.rolling? && content_view_params.key?(:repository_ids)
+            repo_ids_to_add = content_view_params[:repository_ids] - content_view.repository_ids
+            repo_ids_to_remove = content_view.repository_ids - content_view_params[:repository_ids]
+
+            plan_action(AddRollingRepoClone, content_view, repo_ids_to_add) if repo_ids_to_add.any?
+            plan_action(RemoveRollingRepoClone, content_view, repo_ids_to_remove) if repo_ids_to_remove.any?
+          end
+
           content_view.update!(content_view_params)
         end
       end

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

@@ -21,11 +21,10 @@ module Actions
             errata = errata_match?(source_repo, target_repo)
             package_groups = package_groups_match?(source_repo, target_repo)
             distributions = distributions_match?(source_repo, target_repo)
-            yum_metadata_files = yum_metadata_files_match?(source_repo, target_repo)
             checksum_match = (target_repo.saved_checksum_type == source_repo.saved_checksum_type)
 
             output[:checksum_match] = checksum_match
-            output[:matching_content] = yum_metadata_files && srpms_match && rpms && errata && package_groups && distributions && target_repo_published && checksum_match
+            output[:matching_content] = srpms_match && rpms && errata && package_groups && distributions && target_repo_published && checksum_match
           end
 
           if source_repo.content_type == ::Katello::Repository::DEB_TYPE
@@ -66,12 +65,6 @@ module Actions
         def distributions_match?(source_repo, target_repo)
           source_repo.distribution_information == target_repo.distribution_information
         end
-
-        def yum_metadata_files_match?(source_repo, target_repo)
-          source_repo_items = source_repo.yum_metadata_files.pluck(:name, :checksum).sort.uniq
-          target_repo_items = target_repo.yum_metadata_files.pluck(:name, :checksum).sort.uniq
-          source_repo_items == target_repo_items
-        end
       end
     end
   end

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

@@ -3,6 +3,8 @@ module Actions
   module Katello
     module Repository
       class ImportUpload < Actions::EntryAction
+        include Helpers::RollingCVRepos
+
         # rubocop:disable Metrics/MethodLength
         def plan(repository, uploads, options = {})
           action_subject(repository)
@@ -52,6 +54,9 @@ module Actions
             plan_action(Katello::Repository::MetadataGenerate, repository, force_publication: true) if generate_metadata
             plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repository.id]) if generate_applicability
             plan_self(repository_id: repository.id, sync_capsule: sync_capsule, upload_results: upload_results)
+
+            # Refresh rolling CVs that have this repository
+            update_rolling_content_views(repository)
           end
         end
         # rubocop:enable Metrics/MethodLength

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

@@ -5,6 +5,7 @@ module Actions
       class Sync < Actions::EntryAction
         extend ApipieDSL::Class
         include Helpers::Presenter
+        include Helpers::RollingCVRepos
         include ::Actions::ObservableAction
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
@@ -62,16 +63,19 @@ module Actions
         end
 
         def run
+        end
+
+        def finalize
           repo = ::Katello::Repository.find(input[:id])
+          if repo
+            repo&.audit_sync
+            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]
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 
-        def finalize
-          ::Katello::Repository.find(input[:id])&.audit_sync
-        end
-
         def humanized_name
           if input && input[:validate_contents]
             _("Synchronize: Validate Content")

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

@@ -6,6 +6,8 @@ module Actions
   module Katello
     module Repository
       class UploadFiles < Actions::EntryAction
+        include Helpers::RollingCVRepos
+
         def plan(repository, files, content_type = nil, options = {})
           action_subject(repository)
           repository.check_ready_to_act!
@@ -38,6 +40,9 @@ module Actions
             plan_action(FinishUpload, repository, content_type: content_type, upload_actions: upload_actions)
             plan_self(tmp_files: tmp_files)
             plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repository.id]) if generate_applicability
+
+            # Refresh rolling CVs that have this repository
+            update_rolling_content_views(repository)
           end
         ensure
           # Delete tmp files when some exception occurred. Would be
@@ -46,7 +51,8 @@ module Actions
         end
 
         def run
-          ForemanTasks.async_task(Repository::CapsuleSync, ::Katello::Repository.find(input[:repository][:id])) if Setting[:foreman_proxy_content_auto_sync]
+          repository = ::Katello::Repository.find(input[:repository][:id])
+          ForemanTasks.async_task(Repository::CapsuleSync, repository) if Setting[:foreman_proxy_content_auto_sync]
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 

data/app/lib/actions/pulp3/orchestration/orphan_cleanup/remove_orphans.rb

@@ -6,13 +6,14 @@ module Actions
           def plan(proxy)
             if proxy.pulp3_enabled?
               sequence do
-                plan_action(Actions::Pulp3::OrphanCleanup::DeleteOrphanRepositoryVersions, proxy)
                 if proxy.pulp_mirror?
                   plan_action(Actions::Pulp3::OrphanCleanup::RemoveUnneededRepos, proxy)
-                  plan_action(Actions::Pulp3::OrphanCleanup::DeleteOrphanDistributions, proxy)
                   plan_action(Actions::Pulp3::OrphanCleanup::DeleteOrphanAlternateContentSources, proxy)
                   plan_action(Actions::Pulp3::OrphanCleanup::DeleteOrphanRemotes, proxy)
                 end
+                # Deleting repos causes orphaned distributions, so delete them before the distributions.
+                plan_action(Actions::Pulp3::OrphanCleanup::DeleteOrphanDistributions, proxy)
+                plan_action(Actions::Pulp3::OrphanCleanup::DeleteOrphanRepositoryVersions, proxy)
                 plan_action(Actions::Pulp3::OrphanCleanup::RemoveOrphans, proxy)
                 plan_action(Actions::Pulp3::OrphanCleanup::PurgeCompletedTasks, proxy)
               end

data/app/lib/actions/pulp3/orphan_cleanup/delete_orphan_repository_versions.rb

@@ -6,8 +6,15 @@ module Actions
           plan_self(:smart_proxy_id => smart_proxy.id)
         end
 
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+
         def run
-          output[:pulp_tasks] = ::Katello::Pulp3::SmartProxyRepository.instance_for_type(smart_proxy).delete_orphan_repository_versions
+          cleanup_outputs = ::Katello::Pulp3::SmartProxyRepository.instance_for_type(smart_proxy).delete_orphan_repository_versions
+          output[:pulp_tasks] = cleanup_outputs[:pulp_tasks]
+          output[:errors] = cleanup_outputs[:errors]
+          fail ::Katello::Errors::OrphanCleanupRepoVersionDeleteError if output[:errors].any?
         end
       end
     end

data/app/lib/katello/errors.rb

@@ -14,6 +14,8 @@ module Katello
 
     class MultiEnvironmentNotSupportedError < StandardError; end
 
+    class ContentViewEnvironmentError < StandardError; end
+
     # unauthorized access
     class SecurityViolation < StandardError; end
 
@@ -170,5 +172,11 @@ module Katello
         _("This Organization's subscription manifest has expired. Please import a new manifest.")
       end
     end
+
+    class OrphanCleanupRepoVersionDeleteError < StandardError
+      def message
+        _('Orphan cleanup failed to delete some Pulp repository versions. Check the logs for more details.')
+      end
+    end
   end
 end

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

@@ -3,12 +3,13 @@ module Katello
     class ContainerImageNameValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         if value && !ContainerImageNameValidator.validate_name(value)
-          record.errors.add(attribute, N_("invalid container image name"))
+          record.errors.add(attribute, N_("The generated container repository name is invalid. Please review the lifecycle environment's registry name pattern. It may be caused by special characters in the components that make up the name, like the organization."))
         end
       end
 
       def self.validate_name(name)
-        if name.empty? || name.length > 255 || !/\A([a-z0-9]+[a-z0-9\-_.]*)+(\/[a-z0-9]+[a-z0-9\-_.]*)*\z/.match?(name)
+        # regexp-source: https://specs.opencontainers.org/distribution-spec/?v=v1.0.0#DISTRIBUTION-SPEC-26
+        if name.empty? || name.length > 255 || !/\A[a-z0-9]+([\-_.][a-z0-9]+)*(\/[a-z0-9]+([\-_.][a-z0-9]+)*)*\z/.match?(name)
           return false
         end
         true

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

@@ -37,7 +37,17 @@ module Katello
         joins(:root).where("#{Repository.table_name}.id in (?) or #{self.table_name}.id in (?) or #{self.table_name}.id in (?) or #{self.table_name}.id in (?)", in_products, in_content_views, in_versions, in_environments)
       end
 
-      def readable_docker_catalog
+      def readable_docker_catalog(host = nil)
+        if host
+          repo_ids = nil
+          if host&.content_view_environments&.any?
+            repo_ids = host.content_view_environments.flat_map do |cve|
+              cve&.content_view_version&.repositories&.where(environment_id: cve.environment)&.non_archived&.docker_type&.pluck(:id)
+            end
+          end
+          repos = Katello::Repository.where(id: repo_ids)
+          return repos
+        end
         readable_docker_catalog_as(User.current)
       end
 

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

@@ -89,7 +89,7 @@ module Katello
         prepend Overrides
 
         delegate :content_source_id, :single_content_view, :single_lifecycle_environment, :default_environment?, :single_content_view_environment?, :multi_content_view_environment?, :kickstart_repository_id, :bound_repositories,
-          :content_view_environment_labels, :installable_errata, :installable_rpms, :image_mode_host?, to: :content_facet, allow_nil: true
+          :content_view_environment_labels, :installable_errata, :installable_rpms, :image_mode_host?, :yum_or_yum_transient, to: :content_facet, allow_nil: true
 
         delegate :release_version, :purpose_role, :purpose_usage, to: :subscription_facet, allow_nil: true
 
@@ -624,7 +624,7 @@ class ::Host::Managed::Jail < Safemode::Jail
         :installed_packages, :traces_helpers, :advisory_ids, :package_names_for_job_template,
         :filtered_entitlement_quantity_consumed, :bound_repositories,
         :single_content_view, :single_lifecycle_environment, :content_view_environment_labels, :multi_content_view_environment?,
-        :release_version, :purpose_role, :purpose_usage
+        :release_version, :purpose_role, :purpose_usage, :image_mode_host?, :yum_or_yum_transient
 end
 
 class ActiveRecord::Associations::CollectionProxy::Jail < Safemode::Jail