katello 4.3.0.rc4 → 4.4.0.rc2

data/app/models/katello/erratum.rb

@@ -47,8 +47,6 @@ module Katello
                   :validator => ->(value) { ['true', 'false'].include?(value.downcase) },
                   :operators => ["="]
 
-    before_save lambda { |erratum| erratum.title = erratum.title.truncate(255) unless erratum.title.blank? }
-
     def self.of_type(type)
       where(:errata_type => type)
     end
@@ -92,19 +90,6 @@ module Katello
       where("#{self.table_name}.id in (?) or #{self.table_name}.pulp_id in (?) or #{self.table_name}.errata_id in (?)", id_integers, ids, ids)
     end
 
-    def self.update_repo_association_records(new_ids, erratum_updated_ids, id_href_map_for_repository, repository)
-      if new_ids.any?
-        self.repository_association_class.import(db_columns_sync, db_values(new_ids, id_href_map_for_repository, repository), validate: false)
-      end
-      if erratum_updated_ids.present?
-        upserts = db_values(erratum_updated_ids, id_href_map_for_repository, repository).map do |upsert|
-          { erratum_id: upsert[0], erratum_pulp3_href: upsert[1], repository_id: upsert[2], created_at: upsert[3], updated_at: upsert[4] }
-        end
-        # PostgreSQL refuses to insert and update in the same command: https://github.com/rails/rails/issues/35519
-        self.repository_association_class.upsert_all(upserts, unique_by: [:erratum_id, :repository_id])
-      end
-    end
-
     def hosts_applicable(org_id = nil)
       if org_id.present?
         self.content_facets_applicable.joins(:host).where("#{::Host.table_name}.organization_id" => org_id)

data/app/models/katello/glue/provider.rb

@@ -1,6 +1,6 @@
 module Katello
   module Glue::Provider
-    DISTRIBUTOR_VERSION = 'sat-6.7'.freeze
+    DISTRIBUTOR_VERSION = 'sat-6.10'.freeze
 
     def self.included(base)
       base.send :include, InstanceMethods

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

@@ -132,10 +132,12 @@ module Katello
       def add_repo(repo_param)
         repo_param[:unprotected] = repo_param[:unprotected].nil? ? false : repo_param[:unprotected]
 
-        if repo_param[:download_policy].blank? && repo_param[:content_type] == Repository::YUM_TYPE
+        if repo_param[:download_policy].blank? && Katello::RootRepository::CONTENT_ATTRIBUTE_RESTRICTIONS[:download_policy].include?(repo_param[:content_type])
           repo_param[:download_policy] = Setting[:default_download_policy]
         end
 
+        repo_param[:mirroring_policy] = Katello::RootRepository::MIRRORING_POLICY_ADDITIVE if repo_param[:mirroring_policy].blank?
+
         RootRepository.new(repo_param.merge(:product_id => self.id))
       end
     end

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

@@ -9,10 +9,10 @@ module Katello
       HOST_TOOLS_TRACER_PACKAGE_NAME = 'katello-host-tools-tracer'.freeze
       SUBSCRIPTION_MANAGER_PACKAGE_NAME = 'subscription-manager'.freeze
 
-      belongs_to :kickstart_repository, :class_name => "::Katello::Repository", :foreign_key => :kickstart_repository_id, :inverse_of => :kickstart_content_facets
+      belongs_to :kickstart_repository, :class_name => "::Katello::Repository", :inverse_of => :kickstart_content_facets
       belongs_to :content_view, :inverse_of => :content_facets, :class_name => "Katello::ContentView"
       belongs_to :lifecycle_environment, :inverse_of => :content_facets, :class_name => "Katello::KTEnvironment"
-      belongs_to :content_source, :class_name => "::SmartProxy", :foreign_key => :content_source_id, :inverse_of => :content_facets
+      belongs_to :content_source, :class_name => "::SmartProxy", :inverse_of => :content_facets
 
       has_many :content_facet_errata, :class_name => "Katello::ContentFacetErratum", :dependent => :delete_all, :inverse_of => :content_facet
       has_many :applicable_errata, :through => :content_facet_errata, :class_name => "Katello::Erratum", :source => :erratum
@@ -110,14 +110,6 @@ module Katello
         self.update_errata_status
       end
 
-      def import_applicability(partial = false)
-        import_module_stream_applicability(partial)
-        import_errata_applicability(partial)
-        import_deb_applicability(partial)
-        import_rpm_applicability(partial)
-        update_applicability_counts
-      end
-
       def update_applicability_counts
         self.assign_attributes(
             :installable_security_errata_count => self.installable_errata.security.count,
@@ -133,23 +125,6 @@ module Katello
         self.save!(:validate => false)
       end
 
-      def import_deb_applicability(partial)
-        ApplicableContentHelper.new(Deb, self).import(partial)
-      end
-
-      def import_rpm_applicability(partial)
-        ApplicableContentHelper.new(Rpm, self).import(partial)
-      end
-
-      def import_errata_applicability(partial)
-        ApplicableContentHelper.new(Erratum, self).import(partial)
-        self.update_errata_status
-      end
-
-      def import_module_stream_applicability(partial)
-        ApplicableContentHelper.new(ModuleStream, self).import(partial)
-      end
-
       def self.in_content_view_version_environments(version_environments)
         #takes a structure of [{:content_view_version => ContentViewVersion, :environments => [KTEnvironment]}]
         queries = version_environments.map do |version_environment|

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

@@ -16,6 +16,15 @@ module Katello
         if host.content_facet.present?
           info['parameters']['kickstart_repository'] = host.content_facet.kickstart_repository.try(:label)
         end
+
+        if (rhsm_url = host.content_source&.rhsm_url)
+          info['parameters']['rhsm_url'] = rhsm_url.to_s
+        end
+
+        if (content_url = host.content_source&.pulp_content_url)
+          info['parameters']['content_url'] = content_url.to_s
+        end
+
         info
       end
 

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

@@ -7,7 +7,7 @@ module Katello
       include DirtyAssociations
 
       belongs_to :user, :inverse_of => :subscription_facets, :class_name => "::User"
-      belongs_to :hypervisor_host, :class_name => "::Host::Managed", :foreign_key => "hypervisor_host_id"
+      belongs_to :hypervisor_host, :class_name => "::Host::Managed"
 
       has_many :subscription_facet_activation_keys, :class_name => "Katello::SubscriptionFacetActivationKey", :dependent => :destroy, :inverse_of => :subscription_facet
       has_many :activation_keys, :through => :subscription_facet_activation_keys, :class_name => "Katello::ActivationKey"
@@ -217,7 +217,7 @@ module Katello
         if ignore_os?(host.operatingsystem, rhsm_facts)
           rhsm_facts[:ignore_os] = true
         end
-        host.import_facts(rhsm_facts)
+        ::HostFactImporter.new(host).import_facts(rhsm_facts)
       end
 
       def self.ignore_os?(host_os, rhsm_facts)

data/app/models/katello/host_available_module_stream.rb

@@ -37,6 +37,16 @@ module Katello
                                              :stream => available_module_stream.stream}).exists?
     end
 
+    def install_status
+      return 'Not installed' if installed_profiles.blank?
+      case status
+      when 'disabled'
+        'Installed'
+      when 'enabled'
+        upgradable? ? 'Upgradable' : 'Up-to-date'
+      end
+    end
+
     def self.upgradable(host)
       upgradable_module_name_streams = ModuleStream.installable_for_hosts([host]).select(:name, :stream)
 

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

@@ -5,10 +5,10 @@ module Katello
       self.table_name = 'katello_hostgroup_content_facets'
       include Facets::HostgroupFacet
 
-      belongs_to :kickstart_repository, :class_name => "::Katello::Repository", :foreign_key => :kickstart_repository_id, :inverse_of => :kickstart_hostgroup_content_facets
+      belongs_to :kickstart_repository, :class_name => "::Katello::Repository", :inverse_of => :kickstart_hostgroup_content_facets
       belongs_to :content_view, :inverse_of => :hostgroup_content_facets, :class_name => "Katello::ContentView"
       belongs_to :lifecycle_environment, :inverse_of => :hostgroup_content_facets, :class_name => "Katello::KTEnvironment"
-      belongs_to :content_source, :class_name => "::SmartProxy", :foreign_key => :content_source_id, :inverse_of => :hostgroup_content_facets
+      belongs_to :content_source, :class_name => "::SmartProxy", :inverse_of => :hostgroup_content_facets
 
       validates_with Katello::Validators::ContentViewEnvironmentValidator
       validates_with Katello::Validators::HostgroupKickstartRepositoryValidator

data/app/models/katello/installed_package.rb

@@ -15,6 +15,7 @@ module Katello
     has_many :host_installed_packages, :class_name => "Katello::HostInstalledPackage", :dependent => :destroy, :inverse_of => :installed_package
     has_many :hosts, :through => :host_installed_packages, :class_name => "::Host"
 
+    scoped_search :on => :id, :complete_value => true
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :nvrea
     scoped_search :on => :nvra

data/app/models/katello/product.rb

@@ -15,7 +15,7 @@ module Katello
     belongs_to :provider, :inverse_of => :products, :class_name => 'Katello::Provider'
     belongs_to :sync_plan, :inverse_of => :products, :class_name => 'Katello::SyncPlan'
     belongs_to :gpg_key, :inverse_of => :products, :class_name => "Katello::ContentCredential"
-    has_many :product_contents, :foreign_key => 'product_id', :class_name => "Katello::ProductContent", :dependent => :destroy
+    has_many :product_contents, :class_name => "Katello::ProductContent", :dependent => :destroy
     has_many :contents, :through => :product_contents
     has_many :displayable_product_contents, -> { displayable }, :foreign_key => 'product_id', :class_name => "Katello::ProductContent", :dependent => :destroy
     belongs_to :ssl_ca_cert, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_ca_products

data/app/models/katello/product_content.rb

@@ -1,7 +1,7 @@
 module Katello
   class ProductContent < Katello::Model
-    belongs_to :product, :class_name => 'Katello::Product', :foreign_key => 'product_id', :inverse_of => :product_contents
-    belongs_to :content, :class_name => 'Katello::Content', :foreign_key => 'content_id', :inverse_of => :product_contents
+    belongs_to :product, :class_name => 'Katello::Product', :inverse_of => :product_contents
+    belongs_to :content, :class_name => 'Katello::Content', :inverse_of => :product_contents
 
     default_scope { includes(:content) }
 

data/app/models/katello/repository.rb

@@ -37,7 +37,7 @@ module Katello
 
     belongs_to :root, :inverse_of => :repositories, :class_name => "Katello::RootRepository"
     belongs_to :environment, :inverse_of => :repositories, :class_name => "Katello::KTEnvironment"
-    belongs_to :library_instance, :class_name => "Katello::Repository", :inverse_of => :library_instances_inverse, :foreign_key => :library_instance_id
+    belongs_to :library_instance, :class_name => "Katello::Repository", :inverse_of => :library_instances_inverse
     has_many :library_instances_inverse,
              :class_name  => 'Katello::Repository',
              :dependent   => :restrict_with_exception,
@@ -105,7 +105,7 @@ module Katello
     has_many :filters, :through => :repository_content_view_filters
 
     belongs_to :content_view_version, :inverse_of => :repositories, :class_name => "Katello::ContentViewVersion"
-    has_many :distribution_references, :class_name => 'Katello::Pulp3::DistributionReference', :foreign_key => :repository_id,
+    has_many :distribution_references, :class_name => 'Katello::Pulp3::DistributionReference',
              :dependent => :destroy, :inverse_of => :repository
 
     has_many :smart_proxy_sync_histories, :class_name => "::Katello::SmartProxySyncHistory", :inverse_of => :repository, :dependent => :delete_all
@@ -173,12 +173,12 @@ module Katello
     delegate :name, :label, :docker_upstream_name, :url, :download_concurrency, :to => :root
 
     delegate :name, :created_at, :updated_at, :major, :minor, :gpg_key_id, :gpg_key, :arch, :label, :url, :unprotected,
-             :content_type, :product_id, :checksum_type, :docker_upstream_name, :mirror_on_sync, :"mirror_on_sync?",
+             :content_type, :product_id, :checksum_type, :docker_upstream_name, :mirroring_policy,
              :download_policy, :verify_ssl_on_sync, :"verify_ssl_on_sync?", :upstream_username, :upstream_password,
              :upstream_authentication_token, :deb_releases,
              :deb_components, :deb_architectures, :ssl_ca_cert_id, :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_id,
-             :ssl_client_key_id, :os_versions, :ssl_client_key, :ignorable_content, :description, :docker_tags_whitelist,
-             :ansible_collection_requirements, :ansible_collection_auth_url, :ansible_collection_auth_token,
+             :ssl_client_key_id, :os_versions, :ssl_client_key, :ignorable_content, :description, :include_tags, :exclude_tags,
+             :docker_tags_whitelist, :ansible_collection_requirements, :ansible_collection_auth_url, :ansible_collection_auth_token,
              :http_proxy_policy, :http_proxy_id, :to => :root
 
     delegate :content_id, to: :root, allow_nil: true
@@ -285,14 +285,19 @@ module Katello
       ::Katello::Resources::CDN::CdnResource.ca_file if ::Katello::Resources::CDN::CdnResource.redhat_cdn?(url)
     end
 
-    def using_mirrored_metadata?
-      self.yum? && self.library_instance? && self.mirror_on_sync
+    def soft_copy_of_library?
+      return false if self.version_href.nil?
+      self.version_href.starts_with?(self.library_instance.backend_service(SmartProxy.pulp_primary).repository_reference.repository_href)
     end
 
     def archive?
       self.environment.nil?
     end
 
+    def using_mirrored_metadata?
+      self.yum? && self.library_instance? && self.root.mirroring_policy == Katello::RootRepository::MIRRORING_POLICY_COMPLETE
+    end
+
     def in_default_view?
       content_view_version&.default_content_view?
     end
@@ -910,11 +915,7 @@ module Katello
       else
         repository_type.content_types_to_index.each do |type|
           Katello::Logging.time("CONTENT_INDEX", data: {type: type.model_class}) do
-            if self.generic?
-              type.model_class.import_for_repository(self, generic_content_type: type.content_type, full_index: full_index)
-            else
-              type.model_class.import_for_repository(self, full_index: full_index)
-            end
+            Katello::ContentUnitIndexer.new(content_type: type, repository: self, optimized: !full_index).import_all
           end
         end
         repository_type.index_additional_data_proc&.call(self)

data/app/models/katello/root_repository.rb

@@ -4,6 +4,8 @@ module Katello
     audited :except => [:content_id]
     serialize :ignorable_content
     serialize :docker_tags_whitelist
+    serialize :include_tags
+    serialize :exclude_tags
     serialize :os_versions
 
     include Ext::LabelFromName
@@ -21,7 +23,7 @@ module Katello
     SUBSCRIBABLE_TYPES = [Repository::YUM_TYPE, Repository::OSTREE_TYPE, Repository::DEB_TYPE].freeze
 
     CONTENT_ATTRIBUTE_RESTRICTIONS = {
-      :download_policy => [Repository::YUM_TYPE, Repository::DEB_TYPE]
+      :download_policy => [Repository::YUM_TYPE, Repository::DEB_TYPE, Repository::DOCKER_TYPE]
     }.freeze
 
     NO_DEFAULT_HTTP_PROXY = 'none'.freeze
@@ -38,6 +40,11 @@ module Katello
     RHEL9 = 'rhel-9'.freeze
     ALLOWED_OS_VERSIONS = [RHEL6, RHEL7, RHEL8, RHEL9].freeze
 
+    MIRRORING_POLICY_ADDITIVE = 'additive'.freeze
+    MIRRORING_POLICY_CONTENT = 'mirror_content_only'.freeze
+    MIRRORING_POLICY_COMPLETE = 'mirror_complete'.freeze
+    MIRRORING_POLICIES = [MIRRORING_POLICY_ADDITIVE, MIRRORING_POLICY_COMPLETE, MIRRORING_POLICY_CONTENT].freeze
+
     belongs_to :product, :inverse_of => :root_repositories, :class_name => "Katello::Product"
     has_one :provider, :through => :product
 
@@ -49,13 +56,14 @@ module Katello
     has_many :repositories, :class_name => "Katello::Repository", :foreign_key => :root_id,
                           :inverse_of => :root, :dependent => :destroy
 
-    has_many :repository_references, :class_name => 'Katello::Pulp3::RepositoryReference', :foreign_key => :root_repository_id,
+    has_many :repository_references, :class_name => 'Katello::Pulp3::RepositoryReference',
              :dependent => :destroy, :inverse_of => :root_repository
 
     validates_lengths_from_database :except => [:label]
     validates_with Validators::KatelloLabelFormatValidator, :attributes => :label
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
-    validates_with Validators::KatelloUrlFormatValidator, :attributes => :url, :nil_allowed => proc { |repo| repo.custom? },
+    validates_with Validators::KatelloUrlFormatValidator, :attributes => :url,
+                   :nil_allowed => proc { |repo| repo.custom? || repo.organization.cdn_configuration.airgapped? },
                    :field_name => :url
     validates_with Validators::RootRepositoryUniqueAttributeValidator, :attributes => :name
     validates_with Validators::RootRepositoryUniqueAttributeValidator, :attributes => :label
@@ -67,13 +75,16 @@ module Katello
     validate :ensure_valid_collection_attributes, :if => :ansible_collection?
     validate :ensure_valid_auth_url_token, :if => :ansible_collection?
     validate :ensure_valid_ignorable_content
-    validate :ensure_valid_docker_tags_whitelist
+    validate :ensure_valid_include_tags
+    validate :ensure_valid_exclude_tags
     validate :ensure_valid_os_versions
     validate :ensure_content_attribute_restrictions
     validate :ensure_valid_upstream_authorization
     validate :ensure_valid_authentication_token, :if => :yum?
     validate :ensure_valid_deb_constraints, :if => :deb?
     validate :ensure_no_checksum_on_demand
+    validate :ensure_valid_mirroring_policy
+    validate :ensure_valid_retain_package_versions_count
     validates :checksum_type, :inclusion => {:in => CHECKSUM_TYPES}, :allow_blank => true
     validates :product_id, :presence => true
     validates :content_type, :inclusion => {
@@ -107,6 +118,7 @@ module Katello
     }
     scope :orphaned, -> { where.not(id: Katello::Repository.pluck(:root_id).uniq) }
     scope :redhat, -> { joins(:provider).merge(Katello::Provider.redhat) }
+    scope :custom, -> { where.not(:id => self.redhat) }
     delegate :redhat?, :provider, :organization, to: :product
     delegate :cdn_configuration, to: :organization
 
@@ -145,6 +157,21 @@ module Katello
       end
     end
 
+    def valid_mirroring_policies
+      if self.yum?
+        MIRRORING_POLICIES
+      else
+        [MIRRORING_POLICY_ADDITIVE, MIRRORING_POLICY_CONTENT]
+      end
+    end
+
+    def ensure_valid_mirroring_policy
+      unless valid_mirroring_policies.include?(self.mirroring_policy)
+        errors.add(:mirroring_policy, _("Invalid mirroring policy for repository type %{type}, only %{policies} are valid.") %
+          {:type => self.content_type, :policies => valid_mirroring_policies.join(', ')})
+      end
+    end
+
     def ensure_valid_docker_attributes
       if (!url.blank? && docker_upstream_name.blank?)
         errors.add(:docker_upstream_name, N_("cannot be blank when Repository URL is provided."))
@@ -201,10 +228,17 @@ module Katello
       end
     end
 
-    def ensure_valid_docker_tags_whitelist
-      return if docker_tags_whitelist.blank?
-      unless docker_tags_whitelist.is_a?(Array)
-        errors.add(:docker_tags_whitelist, N_("Invalid value specified for Container Image repositories."))
+    def ensure_valid_include_tags
+      return if include_tags.blank?
+      unless include_tags.is_a?(Array)
+        errors.add(:include_tags, N_("Invalid value specified for Container Image repositories."))
+      end
+    end
+
+    def ensure_valid_exclude_tags
+      return if exclude_tags.blank?
+      unless exclude_tags.is_a?(Array)
+        errors.add(:exclude_tags, N_("Invalid value specified for Container Image repositories."))
       end
     end
 
@@ -274,6 +308,16 @@ module Katello
       end
     end
 
+    def ensure_valid_retain_package_versions_count
+      return unless self.retain_package_versions_count
+      unless yum?
+        errors.add(:retain_package_versions_count, N_("is only allowed for Yum repositories."))
+      end
+      if self.retain_package_versions_count.to_i < 0
+        errors.add(:retain_package_versions_count, N_("must not be a negative value."))
+      end
+    end
+
     def custom_content_path
       parts = []
       # We generate repo path only for custom product content. We add this
@@ -293,6 +337,11 @@ module Katello
       Katello::Content.find_by(:cp_content_id => self.content_id, :organization_id => self.product.organization_id)
     end
 
+    # For API support during deprecation period.
+    def docker_tags_whitelist
+      include_tags
+    end
+
     def docker?
       self.content_type == Repository::DOCKER_TYPE
     end
@@ -325,15 +374,19 @@ module Katello
       (%w(unprotected checksum_type container_repsoitory_name) & previous_changes.keys).any?
     end
 
+    def using_mirrored_content?
+      self.mirroring_policy != Katello::RootRepository::MIRRORING_POLICY_ADDITIVE
+    end
+
     def on_demand?
       self.download_policy == DOWNLOAD_ON_DEMAND
     end
 
     def pulp_update_needed?
-      changeable_attributes = %w(url unprotected checksum_type docker_upstream_name download_policy mirror_on_sync verify_ssl_on_sync
-                                 upstream_username upstream_password ignorable_content
+      changeable_attributes = %w(url unprotected checksum_type docker_upstream_name download_policy mirroring_policy verify_ssl_on_sync
+                                 upstream_username upstream_password ignorable_content retain_package_versions_count
                                  ssl_ca_cert_id ssl_client_cert_id ssl_client_key_id http_proxy_policy http_proxy_id download_concurrency)
-      changeable_attributes += %w(name container_repository_name docker_tags_whitelist) if docker?
+      changeable_attributes += %w(name container_repository_name include_tags exclude_tags) if docker?
       changeable_attributes += %w(deb_releases deb_components deb_architectures gpg_key_id) if deb?
       changeable_attributes += %w(ansible_collection_requirements ansible_collection_auth_url ansible_collection_auth_token) if ansible_collection?
       changeable_attributes.any? { |key| previous_changes.key?(key) }
@@ -370,11 +423,7 @@ module Katello
 
     def format_arches
       if content_type == ::Katello::Repository::DEB_TYPE
-        # FIXME: This should be set to self.deb_architectures but it needs to have the
-        # subscription-manager PR https://github.com/candlepin/subscription-manager/pull/2213
-        # merged. Otherwise subscription-manager returns _NO_ debian repository as described in
-        # https://community.theforeman.org/t/katello-3-16-1-1-el7-subscription-manager-doesnt-create-rhsm-repos-for-ubuntu/20928/38
-        nil
+        self.deb_architectures
       else
         self.arch == "noarch" ? nil : self.arch
       end

data/app/models/katello/rpm.rb

@@ -8,6 +8,7 @@ module Katello
     has_many :content_facets, :through => :content_facet_applicable_rpms, :class_name => "Katello::Host::ContentFacet"
     has_many :module_stream_rpms, class_name: "Katello::ModuleStreamRpm", inverse_of: :rpm, dependent: :destroy
     has_many :module_streams, :through => :module_stream_rpms
+    scoped_search :on => :id, :complete_value => true
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :version, :complete_value => true, :ext_method => :scoped_search_version
     scoped_search :on => :release, :complete_value => true, :ext_method => :scoped_search_release
@@ -19,8 +20,6 @@ module Katello
     scoped_search :on => :modular, :complete_value => true, :only_explicit => true
     scoped_search :on => :checksum
 
-    before_save lambda { |rpm| rpm.summary = rpm.summary.truncate(255) unless rpm.summary.blank? }
-
     scope :modular, -> { where(modular: true) }
     scope :non_modular, -> { where(modular: false) }
 
@@ -215,6 +214,13 @@ module Katello
         where("#{Katello::Host::ContentFacet.table_name}.host_id" => hosts).distinct
     end
 
+    # Return RPMs that are not installed on a host, but could be installed
+    # the word 'installable' has a different meaning here than elsewhere
+    def self.yum_installable_for_host(host)
+      repos = host.content_facet.bound_repositories.pluck(:id)
+      Katello::Rpm.in_repositories(repos).where.not(name: host.installed_packages.pluck(:name)).order(:name)
+    end
+
     def self.latest(relation)
       # There are several different ways to implement this:
 

data/app/models/setting/content.rb

@@ -75,8 +75,8 @@ class Setting::Content < Setting
                20, N_('Accept action timeout')),
       self.set('content_action_finish_timeout', N_("Time in seconds to wait for a Host to finish a remote action"),
                3600, N_('Finish action timeout')),
-      self.set('content_disconnected', N_("A server operating in disconnected mode does not communicate with the Red Hat CDN."),
-               false, N_('Disconnected mode')),
+      self.set('subscription_connection_enabled', N_("Can communicate with the Red Hat Portal for subscriptions."),
+               true, N_('Subscription connection enabled')),
       self.set('errata_status_installable', N_("Calculate errata host status based only on errata in a Host's Content View and Lifecycle Environment"),
                false, N_('Installable errata from Content View')),
       self.set('restrict_composite_view', N_("If this is enabled, a composite content view may not be published or "\
@@ -88,6 +88,7 @@ class Setting::Content < Setting
                100, N_('Batch size to sync repositories in.')),
       self.set('foreman_proxy_content_auto_sync', N_("Whether or not to auto sync the Smart Proxies after a Content View promotion."),
                true, N_('Sync Smart Proxies after Content View promotion')),
+      self.set('download_rate_limit', N_("Maximum download rate when syncing a repository (requests per second). Use 0 for no limit."), 0, N_("Download rate limit")),
       self.set('default_download_policy', N_("Default download policy for custom repositories (either 'immediate' or 'on_demand')"), "immediate",
                N_('Default Custom Repository download policy'), nil, :collection => download_policies),
       self.set('default_redhat_download_policy', N_("Default download policy for enabled Red Hat repositories (either 'immediate' or 'on_demand')"), "on_demand",
@@ -104,8 +105,15 @@ class Setting::Content < Setting
                "/etc/pki/katello/private/pulp-client.key", N_('Pulp client key')),
       self.set('pulp_client_cert', N_("Path for ssl cert used for pulp server auth"),
                "/etc/pki/katello/certs/pulp-client.crt", N_('Pulp client cert')),
-      self.set('sync_connect_timeout', N_("Total timeout in seconds for connections when syncing"),
-               300, N_('Sync Connection Timeout')),
+      self.set('sync_total_timeout', N_("The maximum number of second that Pulp can take to do a single sync operation, e.g., download a single metadata file."),
+               3600, N_('Sync Total Timeout')),
+      self.set('sync_connect_timeout_v2',
+               N_("The maximum number of seconds for Pulp to establish a new connection or for waiting for a free connection from a pool if pool connection limits are exceeded."),
+               60, N_('Sync Connect Timeout')),
+      self.set('sync_sock_connect_timeout', N_("The maximum number of seconds for Pulp to connect to a peer for a new connection not given from a pool."),
+               60, N_('Sync Sock Connect Timeout')),
+      self.set('sync_sock_read_timeout', N_("The maximum number of seconds that Pulp can take to download a file, not counting connection time."),
+               3600, N_('Sync Sock Read Timeout')),
       self.set('remote_execution_by_default', N_("If this is enabled, remote execution is used instead of katello-agent for remote actions"),
                false, N_('Use remote execution by default')),
       self.set('unregister_delete_host', N_("When unregistering a host via subscription-manager, also delete the host record. Managed resources linked to host " \
@@ -148,7 +156,9 @@ class Setting::Content < Setting
                N_('Pulp bulk load size')),
       self.set('upload_profiles_without_dynflow', N_('Allow Katello to update host installed packages, enabled repos, and module inventory directly instead of wrapped in Dynflow tasks (try turning off if Puma processes are using too much memory)'), true,
                N_('Upload profiles without Dynflow')),
-      self.set('orphan_protection_time', N_('Time in minutes to consider orphan content as orphaned.'), 1440, N_('Orphaned Content Protection Time'))
+      self.set('orphan_protection_time', N_('Time in minutes to consider orphan content as orphaned.'), 1440, N_('Orphaned Content Protection Time')),
+      self.set('remote_execution_prefer_registered_through_proxy', N_('Prefer using a proxy to which a host is registered when using remote execution'), false,
+               N_('Prefer registered through proxy for remote execution'))
     ]
   end
 

data/app/services/cert/rhsm_client.rb

@@ -10,7 +10,7 @@ module Cert
     end
 
     def uuid
-      drop_cn_prefix_from_subject(@cert.subject.to_s)
+      @uuid ||= @cert.subject.to_a.detect { |name, _, _| name == 'CN' }&.second
     end
 
     private
@@ -26,10 +26,6 @@ module Cert
       end
     end
 
-    def drop_cn_prefix_from_subject(subject_string)
-      subject_string.sub(/\/CN=/i, '')
-    end
-
     def strip_cert(cert)
       cert = cert.to_s.gsub("-----BEGIN CERTIFICATE-----", "").gsub("-----END CERTIFICATE-----", "")
       cert.delete!(' ')

data/app/services/katello/component_view_presenter.rb

@@ -20,7 +20,7 @@ module Katello
         not_added_cvs = views.reject { |component_content_view| Katello::ContentViewComponent.where(composite_content_view_id: composite_cv.id, content_view_id: component_content_view.id).first }
         not_added_cvs.map { |component_content_view| ComponentViewPresenter.new(composite_cv, nil, Katello::ContentViewComponent.where(composite_content_view_id: composite_cv.id, content_view_id: component_content_view.id, latest: true).new) }
       else
-        views.map { |component_content_view| ComponentViewPresenter.new(cv, component_content_view) }
+        views.map { |component_content_view| ComponentViewPresenter.new(composite_cv, component_content_view) }
       end
     end
   end