katello 4.9.1 → 4.10.0.rc2

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

@@ -8,19 +8,20 @@ module Actions
           content_view = cv_env.content_view
           environment = cv_env.environment
           content_view.check_remove_from_environment!(environment) unless organization_destroy
-
+          docker_cleanup = false
           sequence do
             concurrence do
               unless skip_repo_destroy
                 content_view.repos(environment).each do |repo|
                   # no need to update the content view environment since it's
                   # getting destroyed so skip_environment_update
-                  plan_action(Repository::Destroy, repo, skip_environment_update: true)
+                  plan_action(Repository::Destroy, repo, skip_environment_update: true, docker_cleanup: false)
+                  docker_cleanup ||= repo.docker?
                 end
               end
             end
             plan_action(Candlepin::Environment::Destroy, cp_id: cv_env.cp_id) unless organization_destroy
-            plan_self(:id => cv_env.id)
+            plan_self(:id => cv_env.id, :docker_cleanup => docker_cleanup)
           end
         end
 
@@ -31,6 +32,7 @@ module Actions
           else
             cv_env.destroy!
           end
+          ::Katello::DockerMetaTag.cleanup_tags if input[:docker_cleanup]
         end
       end
     end

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

@@ -7,22 +7,26 @@ module Actions
 
           destroy_env_content = !options.fetch(:skip_destroy_env_content, false)
           repos = destroy_env_content ? version.repositories : version.archived_repos
+          docker_cleanup = false
 
           sequence do
             concurrence do
               repos.each do |repo|
                 repo_options = options.clone
+                repo_options[:docker_cleanup] = false
                 plan_action(Repository::Destroy, repo, repo_options)
+                docker_cleanup ||= repo.docker?
               end
             end
           end
 
-          plan_self(:id => version.id)
+          plan_self(:id => version.id, :docker_cleanup => docker_cleanup)
         end
 
         def finalize
           version = ::Katello::ContentViewVersion.find_by(id: input[:id])
           version&.destroy!
+          ::Katello::DockerMetaTag.cleanup_tags if input[:docker_cleanup]
         end
       end
     end

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

@@ -2,10 +2,16 @@ module Actions
   module Katello
     module ContentViewVersion
       class RepublishRepositories < Actions::EntryAction
-        def plan(content_view_version)
+        def plan(content_view_version, options = {force: false})
+          force = options[:force]
           action_subject(content_view_version.content_view)
           plan_self(:version_id => content_view_version.id)
-          plan_action(::Actions::Katello::Repository::BulkMetadataGenerate, content_view_version.repositories.joins(:root).where.not(root: { mirroring_policy: ::Katello::RootRepository::MIRRORING_POLICY_COMPLETE }))
+          repositories = if force
+                           content_view_version.repositories
+                         else
+                           content_view_version.repositories.joins(:root).where.not(root: { mirroring_policy: ::Katello::RootRepository::MIRRORING_POLICY_COMPLETE })
+                         end
+          plan_action(::Actions::Katello::Repository::BulkMetadataGenerate, repositories)
         end
 
         def run

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

@@ -4,8 +4,10 @@ module Actions
       class UpdateContentView < Actions::EntryAction
         def plan(host, content_view_id, lifecycle_environment_id)
           if host.content_facet
-            host.content_facet.content_view = ::Katello::ContentView.find(content_view_id)
-            host.content_facet.lifecycle_environment = ::Katello::KTEnvironment.find(lifecycle_environment_id)
+            host.content_facet.assign_single_environment(
+              content_view_id: content_view_id,
+              lifecycle_environment_id: lifecycle_environment_id
+            )
             host.update_candlepin_associations
             plan_self(:hostname => host.name)
           else

data/app/lib/actions/katello/product/destroy.rb

@@ -2,21 +2,11 @@ module Actions
   module Katello
     module Product
       class Destroy < Actions::EntryAction
-        # rubocop:disable Metrics/MethodLength
         def plan(product, options = {})
           organization_destroy = options.fetch(:organization_destroy, false)
           skip_environment_update = options.fetch(:skip_environment_update, false) ||
               options.fetch(:organization_destroy, false)
-
-          unless organization_destroy || product.user_deletable?
-            if product.redhat?
-              fail _("Cannot delete Red Hat product: %{product}") % { :product => product.name }
-            elsif !product.published_content_view_versions.not_ignorable.empty?
-              fail _("Cannot delete product with repositories published in a content view.  Product: %{product}, %{view_versions}") %
-                       { :product => product.name, :view_versions => view_versions(product) }
-            end
-          end
-
+          check_ready_to_delete(product, organization_destroy)
           action_subject(product)
 
           # Candlepin::Product::ContentRemove is called with Katello::Repository::Destroy, so we only want to run ContentRemove
@@ -99,6 +89,20 @@ module Actions
           end
           results.join(', ')
         end
+
+        def check_ready_to_delete(product, organization_destroy)
+          unless organization_destroy || product.user_deletable?
+            if product.redhat?
+              fail _("Cannot delete Red Hat product: %{product}") % { :product => product.name }
+            elsif !product.published_content_view_versions.not_ignorable.empty?
+              fail _("Cannot delete product with repositories published in a content view.  Product: %{product}, %{view_versions}") %
+                     { :product => product.name, :view_versions => view_versions(product) }
+            elsif product.repositories.any? { |repo| repo.filters.any? { |filter| filter.repositories.size == 1 } }
+              fail _("Cannot delete product: %{product} with repositories that are the last affected repository in content view filters. Delete these repositories before deleting product.") %
+                     { :product => product.name }
+            end
+          end
+        end
       end
     end
   end

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

@@ -9,7 +9,7 @@ module Actions
         def plan(repo)
           if repo.node_syncable?
             concurrence do
-              smart_proxies = ::SmartProxy.with_environment(repo.environment)
+              smart_proxies = ::SmartProxy.unscoped.with_environment(repo.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,
                             :repository_id => repo.id)

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

@@ -15,6 +15,8 @@ module Actions
               options.fetch(:organization_destroy, false)
           destroy_content = options.fetch(:destroy_content, true)
           remove_from_content_view_versions = options.fetch(:remove_from_content_view_versions, false)
+          delete_empty_repo_filters = options.fetch(:delete_empty_repo_filters, true)
+          docker_cleanup = options.fetch(:docker_cleanup, true)
           action_subject(repository)
           check_destroyable!(repository, remove_from_content_view_versions)
           remove_generated_content_views(repository)
@@ -29,8 +31,9 @@ module Actions
 
           handle_acs_product_removal(repository)
           handle_alternate_content_sources(repository)
+          delete_empty_repo_filters(repository) if delete_empty_repo_filters
 
-          plan_self(:user_id => ::User.current.id, :affected_cvv_ids => affected_cvv_ids)
+          plan_self(:user_id => ::User.current.id, :affected_cvv_ids => affected_cvv_ids, :docker_cleanup => docker_cleanup)
           sequence do
             if repository.redhat?
               handle_redhat_content(repository) unless skip_environment_update
@@ -45,7 +48,7 @@ module Actions
         def finalize
           repository = ::Katello::Repository.find_by(id: input[:repository][:id])
           if repository
-            docker_cleanup = repository.content_type == ::Katello::Repository::DOCKER_TYPE
+            docker_cleanup = repository.docker? && input[:docker_cleanup]
             delete_record(repository, {docker_cleanup: docker_cleanup})
 
             if (affected_cvv_ids = input[:affected_cvv_ids]).any?
@@ -81,6 +84,11 @@ module Actions
           end
         end
 
+        def delete_empty_repo_filters(repository)
+          filters_to_delete = repository.filters.select { |filter| filter.repositories.size == 1 }
+          ::Katello::ContentViewFilter.where(id: filters_to_delete).destroy_all
+        end
+
         def handle_custom_content(repository, remove_from_content_view_versions)
           #if this is the last instance of a custom repo, destroy the content
           if remove_from_content_view_versions || repository.root.repositories.where.not(id: repository.id).empty?

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

@@ -20,7 +20,6 @@ module Actions
 
           if input[:force_index] || (repo.last_contents_changed >= repo.last_indexed)
             repo.index_content(source_repository: source_repository, full_index: input[:full_index].present?)
-            repo.update(:last_indexed => DateTime.now)
           else
             output[:index_skipped] = true
           end

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

@@ -26,7 +26,6 @@ module Actions
 
           validate_repo!(repo: repo,
                         source_url: source_url,
-                        validate_contents: validate_contents,
                         skip_metadata_check: skip_metadata_check,
                         skip_candlepin_check: options.fetch(:skip_candlepin_check, false))
 
@@ -81,9 +80,8 @@ module Actions
           end
         end
 
-        def validate_repo!(repo:, source_url:, validate_contents:, skip_metadata_check:, skip_candlepin_check:)
+        def validate_repo!(repo:, source_url:, skip_metadata_check:, skip_candlepin_check:)
           fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank? && source_url.blank?
-          fail ::Katello::Errors::InvalidActionOptionError, _("Cannot validate contents on non-yum/deb repositories.") if validate_contents && !repo.yum? && !repo.deb?
           fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum/deb repositories.") if skip_metadata_check && !repo.yum? && !repo.deb?
           ::Katello::Util::CandlepinRepositoryChecker.check_repository_for_sync!(repo) if repo.yum? && !skip_candlepin_check
         end

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

@@ -6,7 +6,7 @@ module Actions
           sequence do
             plan_action(Katello::Repository::MetadataGenerate, repository)
             concurrence do
-              ::SmartProxy.with_repo(repository).each do |capsule|
+              (::SmartProxy.unscoped.with_repo(repository).select { |sp| sp.authorized?(:manage_capsule_content) && sp.authorized?(:view_capsule_content) })&.each do |capsule|
                 next if capsule.pulp_primary?
                 plan_action(Katello::CapsuleContent::Sync, capsule, repository_id: repository.id)
               end

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

@@ -6,19 +6,11 @@ module Actions
 
         def plan(repo)
           action_subject(repo)
-
-          if SmartProxy.pulp_primary.pulp3_support?(repo)
-            plan_action(Actions::Pulp3::Repository::Repair, repo.id, SmartProxy.pulp_primary)
-          else
-            options = {}
-            options[:validate_contents] = true
-            plan_action(Actions::Katello::Repository::Sync, repo, options)
-          end
+          plan_action(Actions::Pulp3::Repository::Repair, repo.id, SmartProxy.pulp_primary)
         end
 
         def presenter
-          found = all_planned_actions(Katello::Repository::Sync)
-          found = all_planned_actions(Pulp3::Repository::Repair) if found.empty?
+          found = all_planned_actions(Pulp3::Repository::Repair)
           Helpers::Presenter::Delegated.new(self, found)
         end
       end

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

@@ -14,6 +14,8 @@ module Actions
                 plan_self(source_repository_id: options[:source_repository].id, target_repository_id: repository.id, smart_proxy_id: smart_proxy.id)
               elsif publication_content_type && (force_publication || repository.publication_href.nil? || !repository.using_mirrored_metadata?)
                 plan_action(Actions::Pulp3::Repository::CreatePublication, repository, smart_proxy, options)
+              elsif !publication_content_type
+                plan_self(target_repository_id: repository.id, contents_changed: options[:contents_changed], skip_publication: true)
               end
               plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
               plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if Setting[:distribute_archived_cvv] || repository.environment
@@ -21,13 +23,18 @@ module Actions
           end
 
           def run
-            #we don't have to actually generate a publication, we can reuse the old one
             target_repo = ::Katello::Repository.find(input[:target_repository_id])
-            source_repo = ::Katello::Repository.find(input[:source_repository_id])
-            if (target_repo.publication_href != source_repo.publication_href && smart_proxy.pulp_primary?)
-              target_repo.clear_smart_proxy_sync_histories
+            if input[:skip_publication]
+              #Need to clear smart proxy sync histories for non-publication content_types: docker, ansible collection
+              target_repo.clear_smart_proxy_sync_histories if input[:contents_changed]
+            else
+              #we don't have to actually generate a publication, we can reuse the old one
+              source_repo = ::Katello::Repository.find(input[:source_repository_id])
+              if (target_repo.publication_href != source_repo.publication_href && smart_proxy.pulp_primary?)
+                target_repo.clear_smart_proxy_sync_histories
+              end
+              target_repo.update!(publication_href: source_repo.publication_href)
             end
-            target_repo.update!(publication_href: source_repo.publication_href)
           end
         end
       end

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

@@ -320,17 +320,12 @@ module Katello
         Util::Package.sortable_version(version)
       end
 
-      apipie :method, 'Returns true if Katello Agent infrastructure is enabled on the server'
-      def katello_agent_enabled?
-        Katello.with_katello_agent?
-      end
-
       include Katello::ContentSourceHelper
 
       apipie :method, "Generate script to change a host's content source" do
         returns String
       end
-      def change_content_source(host, ca_cert)
+      def configure_host_for_new_content_source(host, ca_cert)
         return missing_content_source(host) unless host.content_source
 
         prepare_ssl_cert(ca_cert) + configure_subman(host.content_source)
@@ -359,9 +354,9 @@ module Katello
       def parse_errata(task)
         task_input = get_task_input(task)
         agent_input = task_input['errata'] || task_input['content']
-        # Pick katello agent errata if present
-        # Otherwise pick rex errata. There are multiple template inputs, such as errata, pre_script and post_script we only need the
-        # errata input here.
+        # agent_input retrieves past katello-agent tasks.
+        # There are multiple template inputs, such as errata, pre_script and post_script.
+        # We only need the errata input here.
         @_tasks_errata_cache[task.id] ||= agent_input.presence || errata_ids_from_template_invocation(task, task_input)
       end
 

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

@@ -67,6 +67,10 @@ module Katello
             self.new(cdn_configuration.url, options)
           elsif cdn_configuration.custom_cdn?
             options[:ssl_ca_cert] = cdn_configuration.ssl_ca
+            if cdn_configuration.custom_cdn_auth_enabled?
+              options[:ssl_client_cert] = OpenSSL::X509::Certificate.new(product.certificate)
+              options[:ssl_client_key] = OpenSSL::PKey::RSA.new(product.key)
+            end
             self.new(cdn_configuration.url, options)
           else
             options[:username] = cdn_configuration.username

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

@@ -7,7 +7,7 @@ module Katello
             product = ::Katello::Product.find(value)
             content_type = record.alternate_content_source.content_type
             if product.repositories.with_type(content_type).has_url.empty?
-              record.errors[attribute] << N_("The product %{name} has no %{type} repositories with upstream URLs to add to the alternate content source.") % { name: product.name, type: content_type }
+              record.errors.add(attribute, _("%{name} has no %{type} repositories with upstream URLs to add to the alternate content source.") % { name: product.name, type: content_type })
             end
           end
         end

data/app/models/katello/candlepin/repository_mapper.rb

@@ -56,6 +56,7 @@ module Katello
       end
 
       def substitutor
+        fail _("Manifest does not have a valid subscription") if product.cdn_resource.nil?
         product.cdn_resource.substitutor
       end
 

data/app/models/katello/cdn_configuration.rb

@@ -37,6 +37,10 @@ module Katello
       type == CUSTOM_CDN_TYPE
     end
 
+    def custom_cdn_auth_enabled?
+      custom_cdn_auth_enabled
+    end
+
     def redhat_cdn_url?
       Katello::Resources::CDN::CdnResource.redhat_cdn?(url)
     end

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

@@ -1,22 +1,40 @@
 module Katello
   module Concerns
+    # rubocop:disable Metrics/ModuleLength
     module HostManagedExtensions
       extend ActiveSupport::Concern
       include Katello::KatelloUrlsHelper
       include ForemanTasks::Concerns::ActionSubject
 
       module Overrides
-        def update(attrs)
+        def check_cve_attributes(attrs)
           if attrs[:content_facet_attributes]
             cv_id = attrs[:content_facet_attributes].delete(:content_view_id)
             lce_id = attrs[:content_facet_attributes].delete(:lifecycle_environment_id)
+            # Running validations on a host will clear out any existing errors, and then
+            # validate all attributes. As we know, running update or save will run validations.
+            # Since we've just removed two attributes that may
+            # have caused an error, we need to save those so we can explicitly validate
+            # them below in add_back_cve_errors.
+            @pending_cve_attrs = { content_view_id: cv_id, lifecycle_environment_id: lce_id }
             if cv_id && lce_id
-              content_facet.assign_single_environment(content_view_id: cv_id, lifecycle_environment_id: lce_id)
+              cve = content_facet&.assign_single_environment(content_view_id: cv_id, lifecycle_environment_id: lce_id)
+              Rails.logger.warn "Couldn't assign content view environment; host has no content facet" if cve.blank?
+              @pending_cve_attrs = {}
             end
             if (cv_id.present? && lce_id.blank?) || (cv_id.blank? && lce_id.present?)
-              fail "content_view_id and lifecycle_environment_id must be provided together"
+              errors.add(:base, _("Content view and lifecycle environment must be provided together"))
             end
           end
+        end
+
+        def attributes=(attrs)
+          check_cve_attributes(attrs) unless self.content_facet.blank?
+          super
+        end
+
+        def update(attrs)
+          check_cve_attributes(attrs) unless self.content_facet.blank?
           super
         end
 
@@ -30,6 +48,28 @@ module Katello
           inherited_attrs
         end
 
+        def apply_inherited_attributes(attributes, initialized = true)
+          attributes = super(attributes, initialized) || {}
+          facet_attrs = attributes&.[]('content_facet_attributes')
+          return attributes if facet_attrs.blank?
+          cv_id = facet_attrs['content_view_id']
+          lce_id = facet_attrs['lifecycle_environment_id']
+          if initialized && (cv_id.blank? || lce_id.blank?)
+            if cv_id.blank?
+              Rails.logger.info "Hostgroup has no content view assigned; using host's existing content view"
+              facet_attrs['content_view_id'] = content_facet&.single_content_view&.id
+            end
+            if lce_id.blank?
+              Rails.logger.info "Hostgroup has no lifecycle environment assigned; using host's existing lifecycle environment"
+              facet_attrs['lifecycle_environment_id'] = content_facet&.single_lifecycle_environment&.id
+            end
+            attributes['content_facet_attributes'] = facet_attrs
+          else
+            Rails.logger.debug "Hostgroup has content view and lifecycle environment assigned; using those"
+          end
+          attributes
+        end
+
         def smart_proxy_ids
           ids = super
           ids << content_source_id
@@ -72,7 +112,6 @@ module Katello
         has_many :content_view_environments, through: :content_view_environment_content_facets
         has_many :content_views, through: :content_view_environments
         has_many :lifecycle_environments, through: :content_view_environments
-        has_many :dispatch_histories, :class_name => "::Katello::Agent::DispatchHistory", :foreign_key => :host_id, :dependent => :delete_all
 
         has_many :host_installed_packages, :class_name => "::Katello::HostInstalledPackage", :foreign_key => :host_id, :dependent => :delete_all
         has_many :installed_packages, :class_name => "::Katello::InstalledPackage", :through => :host_installed_packages
@@ -89,7 +128,11 @@ module Katello
 
         has_many :hypervisor_pools, :class_name => '::Katello::Pool', :foreign_key => :hypervisor_id, :dependent => :nullify
 
+        validates :name, format: { with: Net::Validations::HOST_REGEXP, message: _("%{value} can contain only lowercase letters, numbers, dashes and dots.") }
+
         before_validation :correct_kickstart_repository
+        after_validation :add_back_cve_errors
+        after_update :clear_pending_cve_attributes
         before_update :check_host_registration, :if => proc { organization_id_changed? }
 
         after_validation :queue_reset_content_host_status
@@ -118,6 +161,16 @@ module Katello
 
         scoped_search relation: :pools, on: :pools_expiring_in_days, ext_method: :find_with_expiring_pools, only_explicit: true
 
+        def add_back_cve_errors
+          if @pending_cve_attrs&.[](:content_view_id).present? || @pending_cve_attrs&.[](:lifecycle_environment_id).present?
+            check_cve_attributes({ content_facet_attributes: @pending_cve_attrs })
+          end
+        end
+
+        def clear_pending_cve_attributes
+          @pending_cve_attrs = {}
+        end
+
         def self.find_with_expiring_pools(_key, _operator, days_from_now)
           host_ids = with_pools_expiring_in_days(days_from_now).ids
           if host_ids.any?

data/app/models/katello/content_view.rb

@@ -1,7 +1,7 @@
 module Katello
   # rubocop:disable Metrics/ClassLength
   class ContentView < Katello::Model
-    audited :associations => [:repositories, :environments, :filters], :except => [:name, :label, :description]
+    audited :associations => [:repositories, :environments, :filters]
     has_associated_audits
     include Ext::LabelFromName
     include Katello::Authorization::ContentView
@@ -178,6 +178,10 @@ module Katello
       content_view_components.map(&:latest_version).compact.freeze
     end
 
+    def sorted_versions
+      versions.order('created_at DESC')
+    end
+
     # Adds content view components based on the input
     # [{:content_view_version_id=>1, :latest=> false}, {:content_view_id=>1, :latest=> true} ..]
     def add_components(components_to_add)
@@ -794,12 +798,20 @@ module Katello
       return last_publish_result.present? && last_publish_result == 'success'
     end
 
+    def cv_repo_indexed_after_last_published?
+      repositories.any? { |repo| repo.last_indexed && repo.last_indexed > latest_version_object.created_at }
+    end
+
     def needs_publish?
       #Returns
       # True:
       #     a) When content/repo/filter change audit records exist
       #     b) CV hasn't ever been published
       #     c) CV dependency_solving != latest_version.applied_filters.dependency_solving
+      #     d) If repo was indexed after cv publish. This can happen under 3 cases:
+      #       i) Index runs because last index(before publish) had failed and repo is picked up for index even if pulp publication hasn't changed.
+      #       ii) Complete sync runs or sync adds/removes new content (Already true because new pulp publication/version gets created)
+      #       iii) repo.index_content is run. (This doesn't necessarily indicate contents changed. Corner case where we play safe and return true)
       # nil:
       #     a) When CV version creation audit is missing(Indicating audit cleanup)
       #     b) Version doesn't have audited_filters set indicating
@@ -814,10 +826,11 @@ module Katello
       return nil unless last_publish_task_success?
       return composite_cv_components_changed? if composite?
       # return true if the audit records clearly show we have unpublished changes
-      return true if (audited_cv_repositories_since_last_publish.present? || audited_cv_repository_changed.present? ||
-        audited_cv_filters_changed.present? || audited_cv_filter_rules_changed.present?)
+      return true if audited_changes_present?
       # return true if the dependency solving changed for CV between last publish and now
       return true if dependency_solving_changed?
+      # return true if any child repo's indexed_at > last_version.created_at
+      return true if cv_repo_indexed_after_last_published?
       # if we didn't return `true` already, either the audit records show that we don't need to publish, or we may
       # have insufficient data to make the determination (either audits were cleaned, or never got created at all).
       # first, check for the `create` audit record; its absence indicates that audits were cleaned some time after
@@ -834,6 +847,11 @@ module Katello
       latest_version_object.applied_filters.nil? ? nil : false
     end
 
+    def audited_changes_present?
+      audited_cv_repositories_since_last_publish.present? || audited_cv_repository_changed.present? ||
+        audited_cv_filters_changed.present? || audited_cv_filter_rules_changed.present?
+    end
+
     def dependency_solving_changed?
       latest_version_object.applied_filters && solve_dependencies != latest_version_object.applied_filters['dependency_solving']
     end

data/app/models/katello/content_view_component.rb

@@ -32,7 +32,7 @@ module Katello
     end
 
     def component_content_view_versions
-      self.content_view&.versions
+      self.content_view&.versions&.order(created_at: :desc)
     end
 
     private

data/app/models/katello/content_view_version.rb

@@ -106,6 +106,10 @@ module Katello
       name
     end
 
+    def self.contains_file(file_unit_id)
+      where(id: Katello::Repository.where(id: Katello::RepositoryFileUnit.where(file_unit_id: file_unit_id).select(:repository_id)).select(:content_view_version_id))
+    end
+
     def ansible_collections
       AnsibleCollection.in_repositories(archived_repos)
     end

data/app/models/katello/docker_meta_tag.rb

@@ -134,7 +134,9 @@ module Katello
     end
 
     def self.cleanup_tags
-      self.where("id not in (?) OR (schema2_id IS NULL AND schema1_id IS NULL)", Katello::RepositoryDockerMetaTag.pluck(:docker_meta_tag_id) + [0]).delete_all
+      #Cleanup RepositoryMetaTag for nil schema meta tags
+      RepositoryDockerMetaTag.where(docker_meta_tag: where(schema1: nil, schema2: nil)).delete_all
+      self.where.not(id: RepositoryDockerMetaTag.select(:docker_meta_tag_id)).or(where(schema1: nil, schema2: nil)).delete_all
     end
 
     def self.import_meta_tags(repositories)

data/app/models/katello/host/content_facet.rb

@@ -61,6 +61,10 @@ module Katello
         self.cves_changed = true
       end
 
+      def mark_cves_unchanged
+        self.cves_changed = false
+      end
+
       def cves_changed?
         cves_changed
       end
@@ -89,12 +93,13 @@ module Katello
         content_view_environments&.first&.lifecycle_environment
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity
       def assign_single_environment(
         content_view_id: nil, lifecycle_environment_id: nil, environment_id: nil,
         content_view: nil, lifecycle_environment: nil, environment: nil
       )
-        lifecycle_environment_id ||= environment_id || lifecycle_environment&.id || environment&.id
-        content_view_id ||= content_view&.id
+        lifecycle_environment_id ||= environment_id || lifecycle_environment&.id || environment&.id || self.single_lifecycle_environment&.id
+        content_view_id ||= content_view&.id || self.single_content_view&.id
 
         unless lifecycle_environment_id
           fail _("Lifecycle environment must be specified")
@@ -299,11 +304,6 @@ module Katello
         end
       end
 
-      def katello_agent_installed?
-        self.host.installed_packages.where("#{Katello::InstalledPackage.table_name}.name" => 'katello-agent').any? ||
-          self.host.installed_debs.where("#{Katello::InstalledDeb.table_name}.name" => 'katello-agent').any?
-      end
-
       def tracer_installed?
         self.host.installed_packages.where("#{Katello::InstalledPackage.table_name}.name" => [ "python-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
                                                                                                "python3-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
@@ -375,7 +375,9 @@ module Katello
       class Jail < ::Safemode::Jail
         allow :applicable_deb_count, :applicable_module_stream_count, :applicable_rpm_count, :content_source, :content_source_id, :content_source_name,
               :errata_counts, :id, :kickstart_repository, :kickstart_repository_id, :kickstart_repository_name,
-              :upgradable_deb_count, :upgradable_module_stream_count, :upgradable_rpm_count, :uuid
+              :upgradable_deb_count, :upgradable_module_stream_count, :upgradable_rpm_count, :uuid,
+              :installable_security_errata_count, :installable_bugfix_errata_count, :installable_enhancement_errata_count,
+              :single_content_view, :single_lifecycle_environment
       end
     end
   end

data/app/models/katello/kt_environment.rb

@@ -278,7 +278,7 @@ module Katello
       prop_group :katello_basic_props, Katello::Model, meta: { friendly_name: 'Katello Environment' }
     end
     class Jail < ::Safemode::Jail
-      allow :name, :label
+      allow :id, :name, :label
     end
 
     private