katello 3.17.0.rc1 → 3.17.0.rc2

data/app/models/katello/docker_meta_tag.rb

@@ -130,7 +130,7 @@ module Katello
     end
 
     def self.cleanup_tags
-      self.where(:schema2_id => nil, :schema1_id => nil).delete_all
+      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
     end
 
     def self.import_meta_tags(repositories)

data/app/models/katello/errata_status.rb

@@ -9,17 +9,28 @@ module Katello
       N_("Errata")
     end
 
+    def errata_status_installable
+      @installable ||= Setting[:errata_status_installable]
+    end
+
+    def profiles_reporter_package_name
+      if host.content_facet.host_tools_installed?
+        Katello::Host::ContentFacet::HOST_TOOLS_PACKAGE_NAME
+      else
+        Katello::Host::ContentFacet::SUBSCRIPTION_MANAGER_PACKAGE_NAME
+      end
+    end
+
     def to_label(_options = {})
-      installable = Setting[:errata_status_installable]
       case status
       when NEEDED_SECURITY_ERRATA
-        installable ? N_("Security errata installable") : N_("Security errata applicable")
+        errata_status_installable ? N_("Security errata installable") : N_("Security errata applicable")
       when NEEDED_ERRATA
-        installable ? N_("Non-security errata installable") : N_("Non-security errata applicable")
+        errata_status_installable ? N_("Non-security errata installable") : N_("Non-security errata applicable")
       when UP_TO_DATE
         N_("All errata applied")
       when UNKNOWN
-        N_("Could not calculate errata status, ensure host is registered and the katello-host-tools package is installed")
+        N_("No installed packages and/or enabled repositories have been reported by %s." % profiles_reporter_package_name)
       else
         N_("Unknown errata status")
       end
@@ -41,19 +52,17 @@ module Katello
     end
 
     def to_status(_options = {})
-      return UNKNOWN if host.content_facet.nil?
-
-      if Setting[:errata_status_installable]
-        errata = host.content_facet.try(:installable_errata)
-      else
-        errata = host.content_facet.try(:applicable_errata)
-      end
+      errata = if errata_status_installable
+                 host.content_facet.try(:installable_errata)
+               else
+                 host.content_facet.try(:applicable_errata)
+               end
 
       if errata.security.any?
         NEEDED_SECURITY_ERRATA
       elsif errata.any?
         NEEDED_ERRATA
-      elsif host.content_facet.bound_repositories.empty?
+      elsif host.installed_packages.empty? || host.content_facet.bound_repositories.empty?
         UNKNOWN
       else
         UP_TO_DATE

data/app/models/katello/erratum.rb

@@ -56,7 +56,7 @@ module Katello
     end
 
     def self.backend_identifier_field
-      SmartProxy.pulp_master!.content_service(CONTENT_TYPE).backend_unit_identifier ? BACKEND_IDENTIFIER_FIELD.to_sym : nil
+      SmartProxy.pulp_primary!.content_service(CONTENT_TYPE).backend_unit_identifier ? BACKEND_IDENTIFIER_FIELD.to_sym : nil
     end
 
     def self.applicable_to_hosts(hosts)

data/app/models/katello/glue/candlepin/owner.rb

@@ -35,8 +35,10 @@ module Katello
         self.owner_details['contentAccessMode']
       end
 
-      def simple_content_access?
-        content_access_mode == "org_environment"
+      def simple_content_access?(cached: true)
+        Rails.cache.fetch("#{self.label}_simple_content_access?", expires_in: 1.minute, force: !cached) do
+          content_access_mode == "org_environment"
+        end
       end
 
       def generate_debug_cert

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

@@ -84,7 +84,9 @@ module Katello
       end
 
       def pulp_scratchpad_checksum_type
-        pulp_repo_facts&.dig('scratchpad', 'checksum_type')
+        if SmartProxy.pulp_primary.has_feature?(SmartProxy::PULP_FEATURE)
+          pulp_repo_facts&.dig('scratchpad', 'checksum_type')
+        end
       end
 
       def pulp_counts_differ?

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

@@ -5,6 +5,9 @@ module Katello
       self.table_name = 'katello_content_facets'
       include Facets::Base
 
+      HOST_TOOLS_PACKAGE_NAME = 'katello-host-tools'.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 :content_view, :inverse_of => :content_facets, :class_name => "Katello::ContentView"
       belongs_to :lifecycle_environment, :inverse_of => :content_facets, :class_name => "Katello::KTEnvironment"
@@ -126,6 +129,7 @@ module Katello
         ::Katello::Applicability::ApplicableContentHelper.new(self, ::Katello::Erratum, bound_repos).calculate_and_import
         ::Katello::Applicability::ApplicableContentHelper.new(self, ::Katello::ModuleStream, bound_repos).calculate_and_import
         update_applicability_counts
+        self.update_errata_status
       end
 
       def import_applicability(partial = false)
@@ -226,6 +230,10 @@ module Katello
         self.host.installed_packages.where("#{Katello::InstalledPackage.table_name}.name" => 'katello-host-tools-tracer').any?
       end
 
+      def host_tools_installed?
+        host.installed_packages.where("#{Katello::InstalledPackage.table_name}.name" => HOST_TOOLS_PACKAGE_NAME).any?
+      end
+
       def update_errata_status
         host.get_status(::Katello::ErrataStatus).refresh!
         host.refresh_global_status!

data/app/models/katello/kt_environment.rb

@@ -243,7 +243,7 @@ module Katello
     end
 
     def add_to_default_capsule
-      SmartProxy.pulp_master.try(:add_lifecycle_environment, self)
+      SmartProxy.pulp_primary.try(:add_lifecycle_environment, self)
     end
 
     # Katello, which understands repository content and promotion, provides release versions based upon

data/app/models/katello/package_group.rb

@@ -25,7 +25,7 @@ module Katello
     end
 
     def package_names
-      service_class = SmartProxy.pulp_master!.content_service(CONTENT_TYPE)
+      service_class = SmartProxy.pulp_primary!.content_service(CONTENT_TYPE)
       group = service_class.new(self.pulp_id)
       group.default_package_names + group.conditional_package_names + group.optional_package_names + group.mandatory_package_names
     end

data/app/models/katello/ping.rb

@@ -6,8 +6,13 @@ module Katello
 
     class << self
       def services(capsule_id = nil)
-        services = [:pulp, :pulp_auth, :candlepin, :candlepin_auth, :foreman_tasks, :katello_events, :candlepin_events]
-        services += [:pulp3] if fetch_proxy(capsule_id)&.pulp3_enabled?
+        proxy = fetch_proxy(capsule_id)
+        services = [:candlepin, :candlepin_auth, :foreman_tasks, :katello_events, :candlepin_events]
+        services += [:pulp3] if proxy&.pulp3_enabled?
+        if proxy.nil? || proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE) || proxy.has_feature?(SmartProxy::PULP_FEATURE)
+          services += [:pulp, :pulp_auth]
+        end
+
         services
       end
 
@@ -212,7 +217,7 @@ module Katello
       private
 
       def fetch_proxy(capsule_id)
-        capsule_id ? SmartProxy.unscoped.find(capsule_id) : SmartProxy.pulp_master
+        capsule_id ? SmartProxy.unscoped.find(capsule_id) : SmartProxy.pulp_primary
       end
 
       def backend_status(url, backend)

data/app/models/katello/pulp3/content_guard.rb

@@ -1,7 +1,7 @@
 module Katello
   module Pulp3
     class ContentGuard < Katello::Model
-      def self.import(smart_proxy = SmartProxy.pulp_master!, force = false)
+      def self.import(smart_proxy = SmartProxy.pulp_primary!, force = false)
         return unless (count == 0 || force)
         content_guard_api = Katello::Pulp3::Api::ContentGuard.new(smart_proxy)
         content_guard = content_guard_api.list&.results&.first

data/app/models/katello/purpose_status.rb

@@ -1,8 +1,8 @@
 module Katello
   class PurposeStatus < HostStatus::Status
-    MATCHED = 0
+    UNKNOWN = 0
     MISMATCHED = 1
-    UNKNOWN = 2
+    MATCHED = 2
     NOT_SPECIFIED = 3
 
     def self.status_map

data/app/models/katello/repository.rb

@@ -135,6 +135,7 @@ module Katello
     scope :in_published_environments, -> { in_content_views(Katello::ContentView.non_default).where.not(:environment_id => nil) }
     scope :order_by_root, ->(attr) { joins(:root).order("#{Katello::RootRepository.table_name}.#{attr}") }
     scope :with_content, ->(content) { joins(Katello::RepositoryTypeManager.find_content_type(content).model_class.repository_association_class.name.demodulize.underscore.pluralize.to_sym).distinct }
+    scope :by_rpm_count, -> { left_joins(:repository_rpms).group(:id).order("count(katello_repository_rpms.id) ASC") } # smallest count first
 
     scoped_search :on => :name, :relation => :root, :complete_value => true
     scoped_search :rename => :product, :on => :name, :relation => :product, :complete_value => true
@@ -148,7 +149,6 @@ module Katello
     scoped_search :on => :distribution_family, :complete_value => true
     scoped_search :on => :distribution_variant, :complete_value => true
     scoped_search :on => :distribution_bootable, :complete_value => true
-    scoped_search :on => :distribution_uuid, :complete_value => true
     scoped_search :on => :redhat, :complete_value => { :true => true, :false => false }, :ext_method => :search_by_redhat
     scoped_search :on => :container_repository_name, :complete_value => true
     scoped_search :on => :description, :relation => :root, :only_explicit => true
@@ -159,7 +159,7 @@ module Katello
 
     delegate :product, :redhat?, :custom?, :to => :root
     delegate :yum?, :docker?, :puppet?, :deb?, :file?, :ostree?, :ansible_collection?, :to => :root
-    delegate :name, :label, :docker_upstream_name, :url, :to => :root
+    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?",
@@ -594,6 +594,10 @@ module Katello
       environment
     end
 
+    def self.smart_proxy_syncable
+      where.not(:environment_id => nil)
+    end
+
     def exist_for_environment?(environment, content_view, attribute = nil)
       if environment.present? && content_view.in_environment?(environment)
         repos = content_view.version(environment).repos(environment)
@@ -645,11 +649,10 @@ module Katello
           :distribution_arch => target_repo.distribution_arch,
           :distribution_family => target_repo.distribution_family,
           :distribution_variant => target_repo.distribution_variant,
-          :distribution_uuid => target_repo.distribution_uuid,
           :distribution_bootable => target_repo.distribution_bootable
         )
       else
-        self.backend_service(SmartProxy.pulp_master).import_distribution_data
+        self.backend_service(SmartProxy.pulp_primary).import_distribution_data
       end
     end
 
@@ -659,7 +662,6 @@ module Katello
         distribution_arch: self.distribution_arch,
         distribution_family: self.distribution_family,
         distribution_variant: self.distribution_variant,
-        distribution_uuid: self.distribution_uuid,
         distribution_bootable: self.distribution_bootable
       }
     end
@@ -721,10 +723,10 @@ module Katello
       DockerMetaTag.in_repositories(self.id).count
     end
 
-    # a master repository actually has content (rpms, errata, etc) in the pulp repository.  For these repositories, we can use the YumDistributor
+    # a primary repository actually has content (rpms, errata, etc) in the pulp repository.  For these repositories, we can use the YumDistributor
     # to generate metadata and can index the content from pulp, or for the case of content view archives without filters, can also use the YumCloneDistributor
     #
-    def master?
+    def primary?
       !self.yum? || # non-yum repos
           self.in_default_view? || # default content view repos
           (self.archive? && !self.content_view.composite) || # non-composite content view archive repos
@@ -734,19 +736,19 @@ module Katello
     # a link repository has no content in the pulp repository and serves as a shell.  It will always be empty.  Only the YumCloneDistributor can be used
     # to publish yum metadata, and it cannot be indexed from pulp, but must have its indexed associations copied from another repository (its target).
     def link?
-      !master?
+      !primary?
     end
 
     # A link (empty repo) points to a target (a repository that actually has units in pulp).  Target repos are always archive repos of a content view version (a repo with no environment)
-    # But for composite view versions, an archive repo, usually won't be a master (but might be if multple components contain the same repo)
+    # But for composite view versions, an archive repo, usually won't be a primary (but might be if multple components contain the same repo)
     def target_repository
-      fail _("This is not a linked repository") if master?
+      fail _("This is not a linked repository") if primary?
       return nil if self.archived_instance.nil?
 
-      #this is an environment repo, and the archived_instance is a master (not always true with composite)
-      if self.environment_id? && self.archived_instance.master?
+      #this is an environment repo, and the archived_instance is a primary (not always true with composite)
+      if self.environment_id? && self.archived_instance.primary?
         self.archived_instance
-      elsif self.environment_id #this is an environment repo, but a composite who's archived_instance isn't a master
+      elsif self.environment_id #this is an environment repo, but a composite who's archived_instance isn't a primary
         self.archived_instance.target_repository || self.archived_instance #to archived_instance if nil
       else #must be a composite archive repo, with only one component repo
         self.component_source_repositories.first
@@ -857,19 +859,25 @@ module Katello
     def index_content(options = {})
       source_repository = options.fetch(:source_repository, nil)
 
-      if self.yum? && !self.master?
+      if self.yum? && !self.primary?
         index_linked_repo
       elsif source_repository && !repository_type.unique_content_per_repo
         copy_indexed_data(source_repository)
       else
         repository_type.content_types_to_index.each do |type|
-          type.model_class.import_for_repository(self)
+          Katello::Logging.time("CONTENT_INDEX", data: {type: type.model_class}) do
+            type.model_class.import_for_repository(self)
+          end
         end
         repository_type.index_additional_data_proc&.call(self)
       end
       true
     end
 
+    def in_content_view?(content_view)
+      content_view.repositories.include? self
+    end
+
     protected
 
     def unit_type_for_removal(type_class = nil)

data/app/models/katello/rhsm_fact_parser.rb

@@ -113,7 +113,7 @@ module Katello
     end
 
     def get_rhsm_mac(interface)
-      # if slave then permanent_mac_address contains the physical mac
+      # if secondary then permanent_mac_address contains the physical mac
       facts["net.interface.#{interface}.permanent_mac_address"] || facts["net.interface.#{interface}.mac_address"]
     end
   end

data/app/models/katello/root_repository.rb

@@ -65,7 +65,6 @@ module Katello
     validate :ensure_valid_docker_tags_whitelist
     validate :ensure_content_attribute_restrictions
     validate :ensure_valid_upstream_authorization
-    validate :ensure_auto_enablement_not_set
     validate :ensure_no_checksum_on_demand
     validates :url, presence: true, if: :ostree?
     validates :checksum_type, :inclusion => {:in => CHECKSUM_TYPES}, :allow_blank => true
@@ -103,6 +102,7 @@ module Katello
       where(:http_proxy_policy => RootRepository::USE_SELECTED_HTTP_PROXY).
       where(:http_proxy_id => http_proxy_id)
     }
+    scope :orphaned, -> { where.not(id: Katello::Repository.pluck(:root_id).uniq) }
     delegate :redhat?, :provider, :organization, to: :product
 
     def library_instance
@@ -225,11 +225,6 @@ module Katello
       end
     end
 
-    def ensure_auto_enablement_not_set
-      return if new_record? || !auto_enabled_changed?
-      errors.add(:auto_enabled, N_("Auto Enablement may only be set on custom repositories.")) if redhat?
-    end
-
     def custom_content_path
       parts = []
       # We generate repo path only for custom product content. We add this
@@ -288,7 +283,7 @@ module Katello
     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 ostree_upstream_sync_policy ostree_upstream_sync_depth ignorable_content
-                                 ssl_ca_cert_id ssl_client_cert_id ssl_client_key_id http_proxy_policy http_proxy_id)
+                                 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(deb_releases deb_components deb_architectures gpg_key_id) if deb?
       changeable_attributes += %w(ansible_collection_requirements) if ansible_collection?
@@ -332,14 +327,6 @@ module Katello
       end
     end
 
-    def content_enablements
-      product.root_repositories.map do |repo|
-        repo_content = { id: repo.content_id }
-        repo_content[:enabled] = repo.auto_enabled? if repo == self
-        repo_content
-      end
-    end
-
     apipie :class, desc: 'A class representing Repository object' do
       name 'Repository'
       refs 'Repository'

data/app/models/katello/sync_plan.rb

@@ -121,6 +121,14 @@ module Katello
       errors.add :base, _("Start Date and Time can't be blank") if self.sync_date.nil?
     end
 
+    def sync_date_sans_tz
+      if User.current.try(:timezone)
+        return self.sync_date.strftime('%a, %d %b %Y %H:%M:%S')
+      else
+        sync_date
+      end
+    end
+
     def next_sync
       return nil unless self.enabled?
       self.foreman_tasks_recurring_logic&.tasks&.order(:start_at)&.last&.start_at

data/app/models/setting/content.rb

@@ -92,7 +92,7 @@ class Setting::Content < Setting
       self.set('check_services_before_actions', N_("Whether or not to check the status of backend services such as pulp and candlepin prior to performing some actions."),
                true, N_('Check services before actions')),
       self.set('foreman_proxy_content_batch_size', N_("How many repositories should be synced concurrently on the capsule.  A smaller number may lead to longer sync times.  A larger number will increase dynflow load."),
-               25, N_('Batch size to sync repositories in.')),
+               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('default_download_policy', N_("Default download policy for custom repositories (either 'immediate', 'on_demand', or 'background')"), "immediate",
@@ -105,6 +105,8 @@ class Setting::Content < Setting
                5000, N_('Pulp Docker registry port')),
       self.set('pulp_export_destination', N_("On-disk location for exported repositories"),
                "/var/lib/pulp/katello-export", N_('Pulp export destination filepath')),
+      self.set('pulpcore_export_destination', N_("On-disk location for pulp 3 exported repositories"),
+               "/var/lib/pulp/exports", N_('Pulp 3 export destination filepath')),
       self.set('pulp_client_key', N_("Path for ssl key used for pulp server auth"),
                "/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"),

data/app/services/cert/certs.rb

@@ -9,11 +9,19 @@ module Cert
     end
 
     def self.ssl_client_cert
-      @ssl_client_cert ||= OpenSSL::X509::Certificate.new(File.open(Setting['pulp_client_cert'], 'r').read)
+      @ssl_client_cert ||= OpenSSL::X509::Certificate.new(File.open(ssl_client_cert_filename, 'r').read)
+    end
+
+    def self.ssl_client_cert_filename
+      Setting['pulp_client_cert']
     end
 
     def self.ssl_client_key
-      @ssl_client_key ||= OpenSSL::PKey::RSA.new(File.open(Setting['pulp_client_key'], 'r').read)
+      @ssl_client_key ||= OpenSSL::PKey::RSA.new(File.open(ssl_client_key_filename, 'r').read)
+    end
+
+    def self.ssl_client_key_filename
+      Setting['pulp_client_key']
     end
 
     def self.verify_ueber_cert(organization)

data/app/services/katello/candlepin/event_handler.rb

@@ -53,6 +53,7 @@ module Katello
 
       def reindex_purpose_status
         reindex_consumer do
+          return if subscription_facet.host.organization.simple_content_access?
           subscription_facet.update_purpose_status(role_status: message_handler.system_purpose.role_status,
                                                    usage_status: message_handler.system_purpose.usage_status,
                                                    addons_status: message_handler.system_purpose.addons_status,

data/app/services/katello/host_status_manager.rb

@@ -9,5 +9,12 @@ module Katello
       Katello::PurposeAddonsStatus,
       Katello::PurposeStatus,
       Katello::TraceStatus].freeze
+
+    PURPOSE_STATUS = [
+      Katello::PurposeStatus,
+      Katello::PurposeAddonsStatus,
+      Katello::PurposeRoleStatus,
+      Katello::PurposeSlaStatus,
+      Katello::PurposeUsageStatus].freeze
   end
 end