katello 4.16.3 → 4.17.0.rc1

data/app/controllers/katello/api/registry/registry_proxies_controller.rb

@@ -1,6 +1,7 @@
 module Katello
   # rubocop:disable Metrics/ClassLength
   class Api::Registry::RegistryProxiesController < Api::V2::ApiController
+    include Katello::Authentication::ClientAuthentication
     before_action :disable_strong_params
     before_action :confirm_settings
     skip_before_action :authorize
@@ -43,6 +44,18 @@ module Katello
       end
     end
 
+    def authenticate_cert_request
+      if cert_present?
+        client_cert = ::Cert::RhsmClient.new(cert_from_request)
+        uuid = client_cert.uuid
+        auth = authenticate_client
+        if auth
+          ::User.current = ::User.anonymous_admin
+          @host = Katello::Host::ContentFacet.find_by(uuid: uuid)&.host
+        end
+      end
+    end
+
     def redirect_authorization_headers
       response.headers['Docker-Distribution-API-Version'] = 'registry/2.0'
       response.headers['Www-Authenticate'] = "Bearer realm=\"#{request_url}/v2/token\"," \
@@ -64,6 +77,9 @@ module Katello
           redirect_authorization_headers if redirect_on_failure
           return false
         end
+      else
+        authenticate_cert_request
+        return true if @host
       end
       false
     end
@@ -454,7 +470,7 @@ module Katello
       return nil unless params[:repository]
       repository = Repository.docker_type.find_by(container_repository_name: params[:repository])
       if require_user_authorization?(repository)
-        repository = Repository.readable_docker_catalog.find_by(container_repository_name: params[:repository])
+        repository = Repository.readable_docker_catalog(@host).find_by(container_repository_name: params[:repository])
       end
       repository
     end
@@ -544,8 +560,6 @@ module Katello
 
     def check_blob
       pulp_response = Resources::Registry::Proxy.get(@_request.fullpath, 'Accept' => request.headers['Accept'])
-      response.headers['Content-Type'] = pulp_response.headers[:content_type] if pulp_response.headers[:content_type]
-      response.headers['Content-Length'] = pulp_response.headers[:content_length] if pulp_response.headers[:content_length]
       head pulp_response.code
     end
 
@@ -662,7 +676,7 @@ module Katello
       params[:per_page] = params[:n] || 25
       params[:search] = params[:q]
 
-      search_results = scoped_search(Repository.readable_docker_catalog.distinct,
+      search_results = scoped_search(Repository.readable_docker_catalog(@host).distinct,
                                      :container_repository_name, :asc, options)
 
       results = {
@@ -676,7 +690,7 @@ module Katello
     end
 
     def catalog
-      repositories = Repository.readable_docker_catalog.collect do |repository|
+      repositories = Repository.readable_docker_catalog(@host).collect do |repository|
         repository.container_repository_name
       end
       render json: { repositories: repositories }

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

@@ -47,7 +47,7 @@ module Katello
          CAST (#{kcc}.composite_content_view_id as BOOLEAN) ASC, #{kc}.name
       SQL
       query = Katello::ContentView.readable.in_organization(@organization)
-      query = query&.non_composite&.non_default&.generated_for_none
+      query = query&.non_composite&.non_default&.non_rolling&.generated_for_none
       component_cv_ids = Katello::ContentViewComponent.where(composite_content_view_id: @view.id).select(:content_view_id)
       query = case params[:status]
               when "Not added"
@@ -145,23 +145,23 @@ module Katello
     def get_total(status)
       case status
       when 'All'
-        return Katello::ContentView.non_default.non_composite.in_organization(@organization).count
+        return Katello::ContentView.non_default.non_composite.non_rolling.in_organization(@organization).count
       when 'Added'
         return Katello::ContentViewComponent.where(composite_content_view_id: @view.id).count
       when 'Not added'
-        return Katello::ContentView.non_default.non_composite.in_organization(@organization).count - Katello::ContentViewComponent.where(composite_content_view_id: @view.id).count
+        return Katello::ContentView.non_default.non_composite.non_rolling.in_organization(@organization).count - Katello::ContentViewComponent.where(composite_content_view_id: @view.id).count
       else
-        return Katello::ContentView.non_default.non_composite.in_organization(@organization).count
+        return Katello::ContentView.non_default.non_composite.non_rolling.in_organization(@organization).count
       end
     end
 
     def find_composite_content_view
-      @view = ContentView.composite.non_default.readable.find_by(id: params[:composite_content_view_id])
+      @view = ContentView.composite.non_default.non_rolling.readable.find_by(id: params[:composite_content_view_id])
       throw_resource_not_found(name: 'composite content view', id: params[:composite_content_view_id]) if @view.nil?
     end
 
     def find_composite_content_view_for_edit
-      @view = ContentView.composite.non_default.editable.find_by(id: params[:composite_content_view_id])
+      @view = ContentView.composite.non_default.non_rolling.editable.find_by(id: params[:composite_content_view_id])
       throw_resource_not_found(name: 'composite content view', id: params[:composite_content_view_id]) if @view.nil?
     end
 

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