katello 4.10.0 → 4.11.0.rc1

data/app/models/katello/rhel_lifecycle_status.rb

@@ -0,0 +1,214 @@
+module Katello
+  class RhelLifecycleStatus < HostStatus::Status
+    UNKNOWN = 0
+    FULL_SUPPORT = 1
+    MAINTENANCE_SUPPORT = 2
+    APPROACHING_END_OF_MAINTENANCE = 3
+    EXTENDED_SUPPORT = 4
+    APPROACHING_END_OF_SUPPORT = 5
+    SUPPORT_ENDED = 6
+
+    def self.end_of_day(date)
+      DateTime.parse(date.to_s).end_of_day.utc
+    end
+
+    RHEL_EOS_SCHEDULE = { # dates that each support category ends
+      'RHEL9' => {
+        'full_support' => end_of_day('2027-05-31'),
+        'maintenance_support' => end_of_day('2032-05-31'),
+        'extended_support' => end_of_day('2035-05-31')
+      },
+      'RHEL8' => {
+        'full_support' => end_of_day('2024-05-31'),
+        'maintenance_support' => end_of_day('2029-05-31'),
+        'extended_support' => end_of_day('2032-05-31')
+      },
+      'RHEL7' => {
+        'full_support' => end_of_day('2019-08-06'),
+        'maintenance_support' => end_of_day('2024-06-30'),
+        'extended_support' => end_of_day('2028-06-30')
+      },
+      'RHEL7 (System z (Structure A))' => {
+        'full_support' => end_of_day('2019-08-06'),
+        'maintenance_support' => end_of_day('2021-05-31')
+      },
+      'RHEL7 (ARM)' => {
+        'full_support' => end_of_day('2019-08-06'),
+        'maintenance_support' => end_of_day('2020-11-30')
+      },
+      'RHEL7 (POWER9)' => {
+        'full_support' => end_of_day('2019-08-06'),
+        'maintenance_support' => end_of_day('2021-05-31')
+      },
+      'RHEL6' => {
+        'full_support' => end_of_day('2016-05-10'),
+        'maintenance_support' => end_of_day('2020-11-30'),
+        'extended_support' => end_of_day('2024-06-30')
+      },
+      'RHEL5' => {
+        'full_support' => end_of_day('2013-01-08'),
+        'maintenance_support' => end_of_day('2017-03-31'),
+        'extended_support' => end_of_day('2020-11-30')
+      }
+    }.freeze
+
+    EOS_WARNING_THRESHOLD = 1.year
+
+    def self.status_map
+      map = {
+        full_support: FULL_SUPPORT,
+        maintenance_support: MAINTENANCE_SUPPORT,
+        approaching_end_of_maintenance: APPROACHING_END_OF_MAINTENANCE,
+        extended_support: EXTENDED_SUPPORT,
+        approaching_end_of_support: APPROACHING_END_OF_SUPPORT,
+        support_ended: SUPPORT_ENDED
+      }
+
+      map.default = UNKNOWN
+      map
+    end
+
+    def self.approaching_end_of_category(eos_schedule_index:)
+      lifecycles_expire_soon[eos_schedule_index]
+    end
+
+    def self.lifecycles_expire_soon
+      expiring = RHEL_EOS_SCHEDULE.collect do |index, schedules|
+        expire_soon = schedules.except("full_support").select { |_k, v| (Time.now.utc..Time.now.utc + EOS_WARNING_THRESHOLD).cover?(v) }
+        {index => expire_soon} if expire_soon.present?
+      end
+      expiring.compact.reduce(:update) || {}
+    end
+
+    def self.to_status(rhel_eos_schedule_index: nil)
+      release = rhel_eos_schedule_index
+      return UNKNOWN unless release.present? && RHEL_EOS_SCHEDULE.key?(release)
+      approach = approaching_end_of_category(eos_schedule_index: release)
+      if approach.present?
+        case approach.keys.first
+        when last_support_category(eos_schedule_index: release)
+          return APPROACHING_END_OF_SUPPORT
+        when 'maintenance_support'
+          return APPROACHING_END_OF_MAINTENANCE
+        end
+      end
+
+      full_support_end_date = RHEL_EOS_SCHEDULE[release]['full_support']
+      maintenance_support_end_date = RHEL_EOS_SCHEDULE[release]['maintenance_support']
+      extended_support_end_date = RHEL_EOS_SCHEDULE[release]['extended_support']
+
+      case
+      when Date.today <= full_support_end_date
+        return FULL_SUPPORT
+      when Date.today <= maintenance_support_end_date
+        return MAINTENANCE_SUPPORT
+      when extended_support_end_date.present? && Date.today <= extended_support_end_date
+        return EXTENDED_SUPPORT
+      else
+        return SUPPORT_ENDED
+      end
+    end
+
+    def self.status_name
+      N_('RHEL lifecycle')
+    end
+
+    def self.humanized_name
+      'rhel_lifecycle'
+    end
+
+    # {"RHEL9"=>2035-05-31 23:59:59.999999999 UTC,
+    #  "RHEL8"=>2032-05-31 23:59:59.999999999 UTC, ... }
+    def self.schedule_slice(support_category)
+      {}.merge(*RHEL_EOS_SCHEDULE.keys.map do |release|
+        { release => RHEL_EOS_SCHEDULE[release]&.[](support_category) }
+      end)
+    end
+
+    def self.full_support_end_dates
+      schedule_slice('full_support')
+    end
+
+    def self.maintenance_support_end_dates
+      schedule_slice('maintenance_support')
+    end
+
+    def self.extended_support_end_dates
+      schedule_slice('extended_support')
+    end
+
+    def self.last_support_category(eos_schedule_index:)
+      RHEL_EOS_SCHEDULE[eos_schedule_index].keys.last
+    end
+
+    def self.eos_date(eos_schedule_index: nil)
+      return nil unless eos_schedule_index
+      RHEL_EOS_SCHEDULE[eos_schedule_index]&.[]('extended_support') ||
+        RHEL_EOS_SCHEDULE[eos_schedule_index]&.[]('maintenance_support')
+    end
+
+    def self.to_label(status, eos_date: nil, maintenance_support_end_date: nil)
+      case status
+      when FULL_SUPPORT
+        N_('Full support')
+      when MAINTENANCE_SUPPORT
+        N_('Maintenance support')
+      when APPROACHING_END_OF_MAINTENANCE
+        if maintenance_support_end_date.present?
+          N_('Approaching end of maintenance support (%s)') % maintenance_support_end_date.strftime('%Y-%m-%d')
+        else
+          N_('Approaching end of maintenance support')
+        end
+      when EXTENDED_SUPPORT
+        N_('Extended support')
+      when APPROACHING_END_OF_SUPPORT
+        if eos_date.present?
+          N_('Approaching end of support (%s)') % eos_date.strftime('%Y-%m-%d')
+        else
+          N_('Approaching end of support')
+        end
+      when SUPPORT_ENDED
+        N_('Support ended')
+      else
+        N_('Unknown')
+      end
+    end
+
+    def to_label(_options = {})
+      self.class.to_label(status, eos_date: eos_date, maintenance_support_end_date: maintenance_support_end_date)
+    end
+
+    def eos_date
+      self.class.eos_date(eos_schedule_index: rhel_eos_schedule_index)
+    end
+
+    def maintenance_support_end_date
+      self.class.maintenance_support_end_dates[rhel_eos_schedule_index]
+    end
+
+    def rhel_eos_schedule_index
+      host&.rhel_eos_schedule_index
+    end
+
+    def to_global(_options = {})
+      if [FULL_SUPPORT, MAINTENANCE_SUPPORT, EXTENDED_SUPPORT].include?(status)
+        ::HostStatus::Global::OK
+      elsif [APPROACHING_END_OF_SUPPORT, APPROACHING_END_OF_MAINTENANCE].include?(status)
+        ::HostStatus::Global::WARN
+      elsif [SUPPORT_ENDED].include?(status)
+        ::HostStatus::Global::ERROR
+      else
+        ::HostStatus::Global::OK
+      end
+    end
+
+    def to_status
+      self.class.to_status(rhel_eos_schedule_index: self.host&.rhel_eos_schedule_index)
+    end
+
+    # this status is only relevant for RHEL
+    def relevant?(_options = {})
+      host&.rhel_eos_schedule_index.present?
+    end
+  end
+end

data/app/models/katello/sync_plan.rb

@@ -24,6 +24,7 @@ module Katello
     validate :validate_sync_date
     validate :product_enabled
     validate :custom_cron_interval_expression
+    validates_associated :products
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
 
     before_destroy :cancel_recurring_logic
@@ -55,7 +56,7 @@ module Katello
 
     def product_enabled
       products.each do |product|
-        errors.add :base, _("Cannot add product %s because it is disabled.") % product.name unless product.enabled?
+        errors.add :base, _("Cannot add product %s because it is disabled.") % product.name if (product.redhat? && !product.enabled?)
       end
     end
 
@@ -174,5 +175,22 @@ module Katello
     def cron_status_mismatch?
       self.interval != CUSTOM_CRON && !(self.cron_expression.nil? || self.cron_expression.eql?(''))
     end
+
+    def validate_and_update_products(force_update: false)
+      sync_plan_products = Product.where(id: self.product_ids).select { |p| p.enabled? }
+      return if sync_plan_products.length == self.product_ids.length
+      sync_plan_product_ids = sync_plan_products.pluck(:id)
+      if sync_plan_product_ids.length < self.product_ids.length
+        missing_ids = self.product_ids - sync_plan_product_ids
+        Rails.logger.warn "Sync plan products with following ids are either disabled or don't exist: #{missing_ids}"
+        if force_update
+          Rails.logger.info "Updating sync plan with valid and enabled product ids: #{sync_plan_product_ids}"
+          self.product_ids = sync_plan_product_ids
+          self.save!
+        else
+          Rails.logger.warn "Some sync plan products are invalid/disabled. Please run validate_and_update_products(force_update: true) on the sync_plan from `foreman-rake console`"
+        end
+      end
+    end
   end
 end

data/app/models/katello/yum_metadata_file.rb

@@ -15,7 +15,7 @@ module Katello
       [repository]
     end
 
-    def self.completer_scope_options
+    def self.completer_scope_options(_search)
       {"#{Katello::Repository.table_name}" => lambda { |repo_class| repo_class.yum_type } }
     end
   end

data/app/services/katello/applicability/applicable_content_helper.rb

@@ -69,7 +69,7 @@ module Katello
         deb_version_compare = Arel::Nodes::NamedFunction.new('deb_version_cmp', [deb[:version], installed_deb[:version]]).gt(0)
 
         content = deb.join(repo_deb).on(repo_deb[:deb_id].eq(deb[:id]))
-                     .join(installed_deb).on(installed_deb[:name].eq(deb[:name]))
+                     .join(installed_deb).on(installed_deb[:name].eq(deb[:name]), installed_deb[:architecture].eq(deb[:architecture]))
                      .join(host_installed_deb).on(host_installed_deb[:installed_deb_id].eq(installed_deb[:id]))
                      .where(deb_version_compare)
                      .where(host_installed_deb[:host_id].eq(self.content_facet.host.id))

data/app/services/katello/event_queue.rb

@@ -34,8 +34,16 @@ module Katello
     end
 
     def self.mark_in_progress(event)
-      ::Katello::Event.where(:in_progress => false, :object_id => event.object_id, :event_type => event.event_type).
-                       update_all(:in_progress => true)
+      query = ::Katello::Event.where(
+        in_progress: false,
+        object_id: event.object_id,
+        event_type: event.event_type
+      )
+
+      # Don't mark future events as in progress!
+      query = query.where('process_after <= ?', event.process_after) if event.process_after
+
+      query.update_all(in_progress: true)
     end
 
     def self.reset_in_progress

data/app/services/katello/host_status_manager.rb

@@ -8,6 +8,7 @@ module Katello
       Katello::PurposeUsageStatus,
       Katello::PurposeAddonsStatus,
       Katello::PurposeStatus,
+      Katello::RhelLifecycleStatus,
       Katello::TraceStatus].freeze
 
     PURPOSE_STATUS = [

data/app/services/katello/product_content_importer.rb

@@ -20,6 +20,47 @@ module Katello
     #    },
     #    "enabled":false
     # }
+    #
+    #Example cp_products json structure (key:values where values are arrays and productContent is an array of contents inside value array)
+    # {
+    #    "230"=>
+    #   [{"id"=>"230",
+    #     "productContent"=>
+    #      [{"content"=>
+    #         {"created"=>"2023-11-01T18:02:54+0000",
+    #          "updated"=>"2023-11-01T18:02:54+0000",
+    #          "uuid"=>"ff8080818b715841018b8c0d76d90190",
+    #          "id"=>"3996",
+    #          "type"=>"yum",
+    #          "label"=>"rhel-7-server-rt-htb-rpms",
+    #          "name"=>"Red Hat Enterprise Linux for Real Time HTB (RHEL 7 Server) (RPMs)",
+    #          "vendor"=>"Red Hat",
+    #          "contentUrl"=>"/content/htb/rhel/server/7/$basearch/rt/os",
+    #          "requiredTags"=>"rhel-7-server",
+    #          "releaseVer"=>nil,
+    #          "gpgUrl"=>"file:///etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-beta,file:///etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-release",
+    #          "modifiedProductIds"=>[],
+    #          "arches"=>nil,
+    #          "metadataExpire"=>1},
+    #        "enabled"=>false},
+    #       {"content"=>
+    #         {"created"=>"2023-11-01T18:02:54+0000",
+    #          "updated"=>"2023-11-01T18:02:54+0000",
+    #          "uuid"=>"ff8080818b715841018b8c0d76d90181",
+    #          "id"=>"2165",
+    #          "type"=>"yum",
+    #          "label"=>"rhel-7-server-optional-htb-debug-rpms",
+    #          "name"=>"Red Hat Enterprise Linux 7 Server - Optional HTB (Debug RPMs)",
+    #          "vendor"=>"Red Hat",
+    #          "contentUrl"=>"/content/htb/rhel/server/7/$basearch/optional/debug",
+    #          "requiredTags"=>"rhel-7-server",
+    #          "releaseVer"=>nil,
+    #          "gpgUrl"=>"file:///etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-beta,file:///etc/pki/rpm-gpg/RPM-GPG-KEY-redhat-release",
+    #          "modifiedProductIds"=>[],
+    #          "arches"=>nil,
+    #          "metadataExpire"=>1},
+    #        "enabled"=>false}]}]
+    # }
     attr_reader :content_url_updated
 
     def initialize(cp_products = [])
@@ -35,12 +76,13 @@ module Katello
     end
 
     def find_product_for_content(content_id)
-      prod = @cp_products.find do |prod_json|
-        prod_json['productContent'].any? do |product_content_json|
+      #Hash.find converts hash into enumerable iterating over each key,value pair which we can capture based on find result
+      cp_product_id, __cp_product_value = @cp_products.find do |prod_json|
+        prod_json&.last&.first&.[]('productContent')&.any? do |product_content_json|
           product_content_json["content"]["id"] == content_id
         end
       end
-      ::Katello::Product.find_by(cp_id: prod["id"]) if prod
+      ::Katello::Product.find_by(cp_id: cp_product_id)
     end
 
     def fetch_product_contents_to_move(product, prod_contents_json)

data/app/services/katello/pulp3/ansible_collection.rb

@@ -2,6 +2,7 @@ module Katello
   module Pulp3
     class AnsibleCollection < PulpContentUnit
       include LazyAccessor
+      PULPCORE_CONTENT_TYPE = "ansible.collection_version".freeze
 
       def self.content_api
         PulpAnsibleClient::ContentCollectionVersionsApi.new(Katello::Pulp3::Api::AnsibleCollection.new(SmartProxy.pulp_primary!).api_client)

data/app/services/katello/pulp3/api/core.rb

@@ -224,7 +224,7 @@ module Katello
           remotes_api.list(args).results
         end
 
-        def remotes_list_all(_smart_proxy, options)
+        def remotes_list_all(_smart_proxy, options = {})
           self.class.fetch_from_list do |page_opts|
             remotes_api.list(page_opts.merge(options))
           end

data/app/services/katello/pulp3/deb.rb

@@ -3,6 +3,7 @@ module Katello
     class Deb < PulpContentUnit
       include LazyAccessor
       CONTENT_TYPE = "deb".freeze
+      PULPCORE_CONTENT_TYPE = "deb.package".freeze
 
       def self.content_api
         PulpDebClient::ContentPackagesApi.new(Katello::Pulp3::Api::Apt.new(SmartProxy.pulp_primary!).api_client)

data/app/services/katello/pulp3/docker_manifest.rb

@@ -3,6 +3,7 @@ module Katello
     class DockerManifest < PulpContentUnit
       include LazyAccessor
       CONTENT_TYPE = "docker_manifest".freeze
+      PULPCORE_CONTENT_TYPE = "container.manifest".freeze
 
       def self.content_api
         PulpContainerClient::ContentManifestsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_primary!).api_client)

data/app/services/katello/pulp3/docker_manifest_list.rb

@@ -2,9 +2,10 @@ module Katello
   module Pulp3
     class DockerManifestList < PulpContentUnit
       include LazyAccessor
+      PULPCORE_CONTENT_TYPE = "container.manifest".freeze
 
-      def self.content_api
-        PulpContainerClient::ContentManifestsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_primary!).api_client)
+      def self.content_api(smart_proxy = SmartProxy.pulp_primary!)
+        PulpContainerClient::ContentManifestsApi.new(Katello::Pulp3::Api::Docker.new(smart_proxy).api_client)
       end
 
       def self.ids_for_repository(repo_id)
@@ -13,10 +14,14 @@ module Katello
         repo_content_list.map { |content| content.try(:pulp_href) }
       end
 
-      def self.content_unit_list(page_opts)
+      def self.page_options(page_opts = {})
         page_opts[:media_type] = ['application/vnd.docker.distribution.manifest.list.v2+json',
                                   'application/vnd.oci.image.index.v1+json']
-        self.content_api.list(page_opts)
+        page_opts
+      end
+
+      def self.content_unit_list(page_opts = {})
+        self.content_api.list(self.page_options(page_opts))
       end
 
       def self.generate_model_row(unit)

data/app/services/katello/pulp3/docker_tag.rb

@@ -3,6 +3,7 @@ module Katello
     class DockerTag < PulpContentUnit
       include LazyAccessor
       CONTENT_TYPE = "docker_tag".freeze
+      PULPCORE_CONTENT_TYPE = "container.tag".freeze
 
       def self.content_api
         PulpContainerClient::ContentTagsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_primary!).api_client)

data/app/services/katello/pulp3/erratum.rb

@@ -2,6 +2,7 @@ module Katello
   module Pulp3
     class Erratum < PulpContentUnit
       include LazyAccessor
+      PULPCORE_CONTENT_TYPE = "rpm.advisory".freeze
 
       def self.content_api
         PulpRpmClient::ContentAdvisoriesApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_primary!).api_client)

data/app/services/katello/pulp3/file_unit.rb

@@ -3,6 +3,7 @@ module Katello
     class FileUnit < PulpContentUnit
       include LazyAccessor
       CONTENT_TYPE = "file".freeze
+      PULPCORE_CONTENT_TYPE = "file.file".freeze
 
       def self.content_api
         PulpFileClient::ContentFilesApi.new(Katello::Pulp3::Api::File.new(SmartProxy.pulp_primary!).api_client)

data/app/services/katello/pulp3/module_stream.rb

@@ -2,6 +2,7 @@ module Katello
   module Pulp3
     class ModuleStream < PulpContentUnit
       include LazyAccessor
+      PULPCORE_CONTENT_TYPE = "rpm.modulemd".freeze
 
       def self.content_api
         PulpRpmClient::ContentModulemdsApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_primary!).api_client)

data/app/services/katello/pulp3/package_group.rb

@@ -2,6 +2,7 @@ module Katello
   module Pulp3
     class PackageGroup < PulpContentUnit
       include LazyAccessor
+      PULPCORE_CONTENT_TYPE = "rpm.packagegroup".freeze
 
       lazy_accessor :optional_package_names, :mandatory_package_names,
                     :conditional_package_names, :default_package_names, :_id,

data/app/services/katello/pulp3/pulp_content_unit.rb

@@ -7,6 +7,45 @@ module Katello
       # Any class that extends this class should define:
       # Class#update_model
 
+      # rubocop:disable Metrics/MethodLength
+      def self.katello_name_from_pulpcore_name(pulpcore_name, repo)
+        # Counts shouldn't be needed for more than the default generic content unit type.
+        if repo.generic?
+          generic_unit = repo.repository_type.default_managed_content_type
+          if pulpcore_name == generic_unit.pulpcore_name
+            return generic_unit.content_type
+          end
+        end
+
+        case pulpcore_name
+        when ::Katello::Pulp3::Rpm::PULPCORE_CONTENT_TYPE
+          ::Katello::Rpm::CONTENT_TYPE
+        when ::Katello::Pulp3::Srpm::PULPCORE_CONTENT_TYPE
+          ::Katello::Srpm::CONTENT_TYPE
+        when ::Katello::Pulp3::PackageGroup::PULPCORE_CONTENT_TYPE
+          ::Katello::PackageGroup::CONTENT_TYPE
+        when ::Katello::Pulp3::Erratum::PULPCORE_CONTENT_TYPE
+          ::Katello::Erratum::CONTENT_TYPE
+        when ::Katello::Pulp3::ModuleStream::PULPCORE_CONTENT_TYPE
+          'module_stream'
+        when ::Katello::Pulp3::DockerTag::PULPCORE_CONTENT_TYPE
+          ::Katello::DockerTag::CONTENT_TYPE
+        when ::Katello::Pulp3::DockerManifest::PULPCORE_CONTENT_TYPE
+          ::Katello::DockerManifest::CONTENT_TYPE
+        when ::Katello::Pulp3::DockerManifestList::PULPCORE_CONTENT_TYPE
+          ::Katello::DockerManifestList::CONTENT_TYPE
+        when ::Katello::Pulp3::FileUnit::PULPCORE_CONTENT_TYPE
+          ::Katello::FileUnit::CONTENT_TYPE
+        when ::Katello::Pulp3::Deb::PULPCORE_CONTENT_TYPE
+          ::Katello::Deb::CONTENT_TYPE
+        when ::Katello::Pulp3::AnsibleCollection::PULPCORE_CONTENT_TYPE
+          ::Katello::AnsibleCollection::CONTENT_TYPE
+        else
+          pulpcore_name
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
       def self.content_api
         fail NotImplementedError
       end

data/app/services/katello/pulp3/repository_mirror.rb

@@ -75,7 +75,7 @@ module Katello
       end
 
       def version_href
-        fetch_repository.latest_version_href
+        fetch_repository&.latest_version_href
       end
 
       def publication_href
@@ -144,7 +144,12 @@ module Katello
 
       def common_remote_options
         remote_options = {
-          name: backend_object_name
+          name: backend_object_name,
+          total_timeout: Setting[:sync_total_timeout],
+          connect_timeout: Setting[:sync_connect_timeout_v2],
+          sock_connect_timeout: Setting[:sync_sock_connect_timeout],
+          sock_read_timeout: Setting[:sync_sock_read_timeout],
+          rate_limit: Setting[:download_rate_limit]
         }
         remote_options.merge!({download_concurrency: repo.download_concurrency}) if repo.download_concurrency
         remote_options.merge!(ssl_remote_options)
@@ -211,6 +216,20 @@ module Katello
         end
       end
 
+      def count_by_pulpcore_type(service_class)
+        # Currently only supports SRPMs and Docker Manifest Lists
+        fail NotImplementedError unless [::Katello::Pulp3::Srpm, ::Katello::Pulp3::DockerManifestList].include?(service_class)
+        count = service_class.content_api(smart_proxy).list(service_class.page_options(limit: 1, fields: ['count'], repository_version: version_href)).count
+        return 0 if count.nil?
+        count
+      end
+
+      def latest_content_counts
+        version_pulp_href = version_href
+        return unless version_pulp_href
+        api.repository_versions_api.read(version_pulp_href)&.content_summary&.present
+      end
+
       def pulp3_enabled_repo_types
         Katello::RepositoryTypeManager.enabled_repository_types.values.select do |repository_type|
           smart_proxy.pulp3_repository_type_support?(repository_type)

data/app/services/katello/pulp3/rpm.rb

@@ -3,6 +3,7 @@ module Katello
     class Rpm < PulpContentUnit
       include LazyAccessor
       CONTENT_TYPE = "rpm".freeze
+      PULPCORE_CONTENT_TYPE = "rpm.package".freeze
 
       PULP_INDEXED_FIELDS = %w(pulp_href name version release arch epoch summary is_modular rpm_sourcerpm location_href pkgId).freeze
 

data/app/services/katello/pulp3/smart_proxy_mirror_repository.rb

@@ -102,7 +102,7 @@ module Katello
         acs_remotes = Katello::SmartProxyAlternateContentSource.pluck(:remote_href)
         pulp3_enabled_repo_types.each do |repo_type|
           api = repo_type.pulp3_api(smart_proxy)
-          remotes = api.remotes_list
+          remotes = api.remotes_list_all(smart_proxy)
 
           remotes.each do |remote|
             if !repo_names.include?(remote.name) && !acs_remotes.include?(remote.pulp_href)

data/app/services/katello/pulp3/srpm.rb

@@ -2,6 +2,7 @@ module Katello
   module Pulp3
     class Srpm < PulpContentUnit
       include LazyAccessor
+      PULPCORE_CONTENT_TYPE = "rpm.package".freeze
 
       CONTENT_TYPE = "srpm".freeze
 
@@ -13,8 +14,8 @@ module Katello
                     :changelog, :group, :size, :url, :build_time, :group,
                     :initializer => :pulp_facts
 
-      def self.content_api
-        PulpRpmClient::ContentPackagesApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_primary!).api_client)
+      def self.content_api(smart_proxy = SmartProxy.pulp_primary!)
+        PulpRpmClient::ContentPackagesApi.new(Katello::Pulp3::Api::Yum.new(smart_proxy).api_client)
       end
 
       def self.page_options(page_opts = {})

data/app/services/katello/registration_manager.rb

@@ -241,9 +241,11 @@ module Katello
         host.subscription_facet.update_from_consumer_attributes(host.subscription_facet.candlepin_consumer.
             consumer_attributes.except(:guestIds, :facts))
         host.subscription_facet.save!
-        host.subscription_facet.update_subscription_status
-        host.content_facet.update_errata_status
-        host.refresh_global_status!
+        host.refresh_statuses([
+                                ::Katello::ErrataStatus,
+                                ::Katello::SubscriptionStatus,
+                                ::Katello::RhelLifecycleStatus
+                              ])
       end
 
       def set_host_collections(host, activation_keys)
@@ -304,6 +306,7 @@ module Katello
           host.content_facet.applicable_errata = []
           host.content_facet.uuid = nil
           host.content_facet.content_view_environments = []
+          host.content_facet.content_source = ::SmartProxy.pulp_primary
           host.content_facet.save!
           Rails.logger.debug "remove_host_artifacts: marking CVEs unchanged to prevent backend update"
           host.content_facet.mark_cves_unchanged

data/app/services/katello/repository_type.rb

@@ -181,7 +181,7 @@ module Katello
 
     class GenericContentType < ContentType
       attr_accessor :pulp3_api, :pulp3_model, :filename_key, :duplicates_allowed, :pluralized_name,
-                    :model_name, :model_version, :model_filename, :model_additional_metadata
+                    :model_name, :model_version, :model_filename, :model_additional_metadata, :pulpcore_name
 
       def initialize(options)
         super
@@ -195,6 +195,7 @@ module Katello
         self.model_version = options[:model_version]
         self.model_filename = options[:model_filename]
         self.model_additional_metadata = options[:model_additional_metadata]
+        self.pulpcore_name = options[:pulpcore_name]
       end
 
       def label