katello 4.18.1 → 4.19.0.rc1

data/app/models/katello/deb.rb

@@ -27,16 +27,16 @@ module Katello
       ContentFacetApplicableDeb
     end
 
-    def self.search_version_range(min = nil, max = nil)
-      query = self.all
-      query = Katello::Util::PackageFilter.new(query, min, Katello::Util::PackageFilter::GREATER_THAN).results if min
-      query = Katello::Util::PackageFilter.new(query, max, Katello::Util::PackageFilter::LESS_THAN).results if max
+    scope :search_version_equal, ->(ver) {
+      where("deb_version_cmp(#{::Katello::Deb.table_name}.version, ?) = 0", ver)
+    }
+
+    scope :search_version_range, ->(min_ver, max_ver) {
+      query = all
+      query = query.where("deb_version_cmp(#{::Katello::Deb.table_name}.version, ?) >= 0", min_ver) if min_ver.present?
+      query = query.where("deb_version_cmp(#{::Katello::Deb.table_name}.version, ?) <= 0", max_ver) if max_ver.present?
       query
-    end
-
-    def self.search_version_equal(version)
-      Katello::Util::PackageFilter.new(self, version, Katello::Util::PackageFilter::EQUAL).results
-    end
+    }
 
     def self.total_for_repositories(repos)
       self.in_repositories(repos).count
@@ -96,7 +96,7 @@ module Katello
 
     # Return deb packages that are not installed on a host, but could be installed
     # the word 'installable' has a different meaning here than elsewhere
-    def self.apt_installable_for_host(host)
+    def self.deb_installable_for_host(host)
       repos = host.content_facet.bound_repositories.pluck(:id)
       Katello::Deb.in_repositories(repos).where.not(name: host.installed_debs.pluck(:name)).order(:name)
     end

data/app/models/katello/erratum.rb

@@ -227,7 +227,7 @@ module Katello
       property :summary, String, desc: 'Returns the errata summary, the length can very, it is usually in range of 60 to 1000 characters. It can include empty line characters.'
     end
     class Jail < ::Safemode::Jail
-      allow :errata_id, :errata_type, :issued, :created_at, :severity, :package_names, :cves, :reboot_suggested, :title, :summary
+      allow :errata_id, :errata_type, :issued, :updated, :created_at, :severity, :package_names, :cves, :reboot_suggested, :title, :summary
     end
   end
 end

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

@@ -31,10 +31,21 @@ module Katello
     end
 
     module InstanceMethods
-      API_URL = 'https://subscription.rhsm.redhat.com/subscription/consumers/'.freeze
+      API_BASE_URL = 'https://subscription.rhsm.redhat.com'.freeze
+      SUBSCRIPTION_PATH = '/subscription'.freeze
+      CONSUMERS_PATH = '/consumers/'.freeze
+      API_URL = API_BASE_URL + SUBSCRIPTION_PATH + CONSUMERS_PATH # https://subscription.rhsm.redhat.com/subscription/consumers/
+
+      def normalize_api_url(api_url)
+        return nil if api_url.blank?
+        uri = URI.parse(api_url)
+        # only take base url; we will overwrite the path to ensure it's correct
+        uri.path = SUBSCRIPTION_PATH + CONSUMERS_PATH # https://subscription.rhsm.redhat.com/subscription/consumers/
+        uri.to_s
+      end
+
       def api_url(upstream = {})
-        # Default to Red Hat
-        ENV['REDHAT_RHSM_API_URL'] || upstream['apiUrl'] || API_URL
+        ENV['REDHAT_RHSM_API_URL'] || normalize_api_url(upstream['apiUrl']) || API_URL
       end
 
       def sync

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

@@ -202,7 +202,7 @@ module Katello
         #           "/pulp/content/Org/Library/custom/Test_product/test2/%3Fcomp%3Dmain%26rel%3Dstable"]
         paths.each do |path|
           if (prefix = prefixes.find { |pre| path.start_with?(pre) })
-            # strip prefix and structured_apt postfix before adding to relative_paths
+            # strip prefix and deb? content postfix before adding to relative_paths
             relative_paths << path.sub(prefix, '').sub(%r{/?(%3F|\?).*}, '')
           else
             Rails.logger.warn("System #{self.host.name} (#{self.host.id}) requested binding to repo with unknown prefix. #{path}")

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

@@ -51,7 +51,6 @@ module Katello
           self.dmi_uuid = consumer_params['facts']['dmi.system.uuid']
         end
 
-        self.autoheal = consumer_params['autoheal'] unless consumer_params['autoheal'].nil?
         self.service_level = consumer_params['serviceLevel'] unless consumer_params['serviceLevel'].nil?
         self.registered_at = consumer_params['created'] unless consumer_params['created'].blank?
         self.last_checkin = consumer_params['lastCheckin'] unless consumer_params['lastCheckin'].blank?
@@ -130,7 +129,6 @@ module Katello
 
       def consumer_attributes
         attrs = {
-          :autoheal => autoheal,
           :usage => purpose_usage,
           :role => purpose_role,
           :serviceLevel => service_level,
@@ -257,10 +255,6 @@ module Katello
         Katello::Product.joins(:subscriptions => {:pools => :subscription_facets}).where("#{Katello::Host::SubscriptionFacet.table_name}.id" => self.id).enabled.uniq
       end
 
-      def remove_subscriptions(pools_with_quantities)
-        ForemanTasks.sync_task(Actions::Katello::Host::RemoveSubscriptions, self.host, pools_with_quantities)
-      end
-
       def self.sanitize_name(name)
         name.gsub('_', '-').chomp('.').downcase
       end
@@ -274,7 +268,7 @@ module Katello
       end
 
       def backend_update_needed?
-        %w(release_version service_level autoheal purpose_role purpose_usage).each do |method|
+        %w(release_version service_level purpose_role purpose_usage).each do |method|
           if self.send("#{method}_changed?")
             Rails.logger.debug("backend_update_needed: subscription facet #{method} changed")
             return true

data/app/models/katello/product_content.rb

@@ -46,8 +46,8 @@ module Katello
 
     def self.enabled(organization)
       content_ids = Katello::RootRepository.in_organization(organization).where.not(content_id: nil).pluck(:content_id)
-      structured_apt_content_ids = Katello::Repository.in_organization(organization).library.pluck(:content_id)
-      joins(:content).where("#{self.content_table_name}.cp_content_id" => content_ids + structured_apt_content_ids)
+      deb_content_ids = Katello::Repository.in_organization(organization).library.deb_type.pluck(:content_id)
+      joins(:content).where("#{self.content_table_name}.cp_content_id" => content_ids + deb_content_ids)
     end
 
     def self.with_valid_subscription(organization)

data/app/models/katello/repository.rb

@@ -170,7 +170,7 @@ module Katello
     scoped_search :on => :label, :relation => :root, :complete_value => true, :only_explicit => true
     scoped_search :on => :content_label, :ext_method => :search_by_content_label, :default_operator => :like
 
-    delegate :product, :redhat?, :custom?, :deb_using_structured_apt?, :to => :root
+    delegate :product, :redhat?, :custom?, :to => :root
     delegate :yum?, :docker?, :deb?, :file?, :ostree?, :ansible_collection?, :generic?, :to => :root
     delegate :name, :label, :docker_upstream_name, :url, :download_concurrency, :to => :root
 
@@ -1046,32 +1046,13 @@ module Katello
 
     def deb_content_url_options
       return '' unless version_href
-      return '' if backend_service(SmartProxy.pulp_primary).version_missing_structure_content?
 
-      components = deb_pulp_components.join(',')
-      distributions = deb_pulp_distributions.join(',')
+      backend_service = self.backend_service(SmartProxy.pulp_primary)
+      components = backend_service.pulp_components.join(',')
+      distributions = backend_service.pulp_distributions.join(',')
       "/?comp=#{components}&rel=#{distributions}"
     end
 
-    def deb_pulp_components(version_href = self.version_href)
-      return [] if version_href.blank?
-
-      pulp_api = Katello::Pulp3::Repository.instance_for_type(self, SmartProxy.pulp_primary).api.content_release_components_api
-      pulp_api.list({:repository_version => version_href}).results.map { |x| x.plain_component }.uniq
-    end
-
-    def deb_sanitize_pulp_distribution(distribution)
-      return "flat-repo" if distribution == "/"
-      return distribution.chomp("/") if distribution&.end_with?("/")
-      distribution
-    end
-
-    def deb_pulp_distributions(version_href = self.version_href)
-      return [] if version_href.blank?
-      pulp_api = Katello::Pulp3::Repository.instance_for_type(self, SmartProxy.pulp_primary).api.content_release_components_api
-      pulp_api.list({:repository_version => version_href}).results.map { |x| deb_sanitize_pulp_distribution(x.distribution) }.uniq
-    end
-
     def sync_status
       return latest_dynflow_sync
     end

data/app/models/katello/root_repository.rb

@@ -389,10 +389,6 @@ module Katello
       self.content_type == Repository::DEB_TYPE
     end
 
-    def deb_using_structured_apt?
-      self.deb? && !self.content_id
-    end
-
     def ansible_collection?
       self.content_type == Repository::ANSIBLE_COLLECTION_TYPE
     end
@@ -446,7 +442,8 @@ module Katello
     end
 
     def format_arches
-      if content_type == ::Katello::Repository::DEB_TYPE
+      if self.deb?
+        # Pulp 2 needed a "," separated string-list, but Pulp 3 needs " " separated!
         self.deb_architectures&.gsub(" ", ",")
       else
         self.arch == "noarch" ? nil : self.arch

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

@@ -15,46 +15,13 @@ module Katello
           @message_handler = ::Katello::Candlepin::MessageHandler.new(message)
           data[:entity_id] = @message_handler.entity_id
           case message_handler.subject
-          when /entitlement\.created/
-            message_handler.import_pool
-            message_handler.create_pool_on_host
-          when /entitlement\.deleted/
-            message_handler.import_pool
-            message_handler.remove_pool_from_host
           when /pool\.created/
             message_handler.import_pool
           when /pool\.deleted/
             message_handler.delete_pool
-          when /^compliance\.created/
-            event_no_longer_handled
-          when /system_purpose_compliance\.created/
-            event_no_longer_handled
-          when /owner_content_access_mode\.modified/
-            message_handler.handle_content_access_mode_modified
           end
         end
       end
-
-      private
-
-      def event_no_longer_handled
-        @logger.error "Received #{message_handler.subject} event from Candlepin. Handling of this event is no longer supported."
-      end
-
-      def subscription_facet
-        message_handler.subscription_facet
-      end
-
-      def reindex_consumer
-        if subscription_facet.nil?
-          @logger.debug "skip re-indexing of non-existent content host #{message_handler.consumer_uuid}"
-          return
-        end
-
-        @logger.debug "re-indexing content host #{subscription_facet.host.name}"
-
-        yield
-      end
     end
   end
 end

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

@@ -46,27 +46,9 @@ module Katello
         case subject
         when 'pool.created', 'pool.deleted'
           content['entityId']
-        when 'entitlement.created', 'entitlement.deleted'
-          content['referenceId']
         end
       end
 
-      def create_pool_on_host
-        return if self.subscription_facet.nil? || pool.nil?
-        old_host_ids = subscription_facet_host_ids
-        ::Katello::SubscriptionFacetPool.where(subscription_facet_id: self.subscription_facet.id,
-                                               pool_id: pool.id).first_or_create
-        pool.import_audit_record(old_host_ids)
-      end
-
-      def remove_pool_from_host
-        return if self.subscription_facet.nil? || pool.nil?
-        old_host_ids = subscription_facet_host_ids
-        ::Katello::SubscriptionFacetPool.where(subscription_facet_id: self.subscription_facet.id,
-                                               pool_id: pool.id).destroy_all
-        pool.import_audit_record(old_host_ids)
-      end
-
       def import_pool(index_hosts = true)
         if pool
           ::Katello::EventQueue.push_event(::Katello::Events::ImportPool::EVENT_TYPE, pool.id)
@@ -86,29 +68,6 @@ module Katello
           Rails.logger.info "Deleted Katello::Pool with cp_id=#{pool_id}"
         end
       end
-
-      def handle_content_access_mode_modified
-        # Ideally the target_name would be the Candlepin Owner key
-        # Since it's the displayName, and we don't update that after org creation, there could be a mismatch
-        # For now, find the Candlepin Owner displayName from this event, and tie it back to a Katello org based on owner key
-        owners = Katello::Resources::Candlepin::Owner.all
-        owner = owners.find { |o| o['displayName'] == target_name }
-
-        unless owner
-          fail("Candlepin Owner %s could not be found" % target_name)
-        end
-
-        org = ::Organization.find_by!(label: owner['key'])
-
-        Rails.logger.error "Received content_access_mode_modified event for org #{org.label}. This event is no longer supported."
-        org.simple_content_access?(cached: false)
-      end
-
-      private
-
-      def subscription_facet_host_ids
-        ::Katello::SubscriptionFacetPool.where(pool_id: pool_id).joins(:subscription_facet).pluck(:host_id)
-      end
     end
   end
 end

data/app/services/katello/content_unit_indexer.rb

@@ -39,18 +39,14 @@ module Katello
           end
 
           # Even after this bug (https://github.com/pulp/pulp_rpm/issues/2821) is fixed,
-          # it is possible to have duplicate errata asosociated to a repo.
+          # it is possible to have duplicate errata associated to a repo.
           if @content_type.label == 'erratum'
             to_insert.uniq! { |row| row["pulp_id"] || row[:pulp_id] }
           end
 
           next if to_insert.empty?
           insert_timestamps(to_insert)
-          if @content_type.mutable
-            @model_class.upsert_all(to_insert, unique_by: :pulp_id)
-          else
-            @model_class.insert_all(to_insert, unique_by: :pulp_id)
-          end
+          upsert_with_deadlock_retry(to_insert)
         end
 
         import_associations(units) if @repository
@@ -107,11 +103,13 @@ module Katello
       def push(unit)
         if @service_class.backend_unit_identifier
           pulp_href = unit.dig(@service_class.backend_unit_identifier)
+          pulp_prn = unit['prn']
         else
           pulp_href = nil
+          pulp_prn = nil
         end
         unit_id = unit[@service_class.unit_identifier]
-        @values[unit_id] = pulp_href
+        @values[unit_id] = { href: pulp_href, prn: pulp_prn }
       end
 
       def db_values
@@ -121,7 +119,10 @@ module Katello
         @final_values = ::Katello::ContentUnitIndexer.pulp_id_to_id_map(@content_type, @values.keys).map do |pulp_id, katello_id|
           #:repository_id => X, :erratum_id => y
           row = {:repository_id => @repository.id, @content_type.model_class.unit_id_field => katello_id}
-          row[pulp_href_association_name] = @values[pulp_id] if pulp_href_association_name
+          if pulp_href_association_name
+            row[pulp_href_association_name] = @values[pulp_id][:href]
+            row[pulp_prn_association_name] = @values[pulp_id][:prn] if pulp_prn_association_name
+          end
           row
         end
         ContentUnitIndexer.insert_timestamps(@content_type.model_class, @final_values)
@@ -131,6 +132,10 @@ module Katello
       def pulp_href_association_name
         'erratum_pulp3_href' if @content_type.label == 'erratum'
       end
+
+      def pulp_prn_association_name
+        'erratum_prn' if @content_type.label == 'erratum'
+      end
     end
 
     def insert_timestamps(units)
@@ -154,17 +159,19 @@ module Katello
         @service_class.supports_id_fetch?
     end
 
-    def sync_repository_associations(assocication_tracker, additive: false)
+    def sync_repository_associations(association_tracker, additive: false)
       unless additive
         ActiveRecord::Base.connection.uncached do
           repo_associations_to_destroy = @model_class.repository_association_class.where(repository_id: @repository.id).where.
-            not(@model_class.unit_id_field => assocication_tracker.unit_ids)
+            not(@model_class.unit_id_field => association_tracker.unit_ids)
           clean_filter_rules(repo_associations_to_destroy) if repo_associations_to_destroy.present? && [::Katello::ModuleStream, ::Katello::Erratum, ::Katello::PackageGroup].include?(@model_class)
           repo_associations_to_destroy.destroy_all
         end
       end
-      return if assocication_tracker.db_values.empty?
-      @model_class.repository_association_class.upsert_all(assocication_tracker.db_values, :unique_by => association_class_uniqiness_attributes)
+      return if association_tracker.db_values.empty?
+      @model_class.repository_association_class.upsert_all(association_tracker.db_values, :unique_by => association_class_uniqueness_attributes)
+
+      clean_duplicate_docker_tags if @model_class == Katello::DockerTag
     end
 
     def clean_filter_rules(repo_associations_to_destroy)
@@ -190,7 +197,46 @@ module Katello
       end
     end
 
-    def association_class_uniqiness_attributes
+    def clean_duplicate_docker_tags
+      # Deduplicate docker tags by name, keeping the one with the newest updated_at
+      deduplicated_tags = @repository.docker_tags.group_by(&:name).map { |_name, tags| tags.max_by(&:updated_at) }
+      return if deduplicated_tags.empty?
+      valid_names = deduplicated_tags.map(&:name)
+      valid_taggable_ids = deduplicated_tags.map(&:id)
+
+      # Remove duplicate tags with same names as valid tags, keeping only the newest ones
+      # Lookup by docker_manifest is important; docker_tags usually only contains the newest tag.
+      tag_ids_to_remove = @repository.docker_manifests
+                            .joins(:docker_tags)
+                            .where(katello_docker_tags: { name: valid_names })
+                            .where.not(katello_docker_tags: {id: valid_taggable_ids})
+                            .pluck('katello_docker_tags.id')
+
+      return if tag_ids_to_remove.empty?
+      Rails.logger.info("Removing #{tag_ids_to_remove.count} duplicate docker tag associations in repository '#{@repository.label}'")
+      Katello::DockerTag.where(id: tag_ids_to_remove).destroy_all
+    end
+
+    def upsert_with_deadlock_retry(to_insert)
+      retry_count = 0
+      begin
+        if @content_type.mutable
+          @model_class.upsert_all(to_insert, unique_by: :pulp_id)
+        else
+          @model_class.insert_all(to_insert, unique_by: :pulp_id)
+        end
+      rescue ActiveRecord::Deadlocked
+        retry_count += 1
+        if retry_count <= 3
+          sleep(rand(1..5))
+          retry
+        else
+          raise
+        end
+      end
+    end
+
+    def association_class_uniqueness_attributes
       columns = [@model_class.unit_id_field, 'repository_id']
       found = ActiveRecord::Base.connection.indexes(@model_class.repository_association_class.table_name).find do |index|
         index.columns.sort == columns.sort

data/app/services/katello/product_content_finder.rb

@@ -22,10 +22,11 @@ module Katello
 
       roots = Katello::RootRepository.where(:product_id => considered_products).subscribable
       roots = roots.in_content_view_version(versions).distinct if versions.present?
-      content_ids = roots.where.not(:content_id => nil).pluck(:content_id)
-      structured_apt_roots = roots.where(:content_id => nil)
-      if structured_apt_roots.any?
-        deb_repos_query = Katello::Repository.where(root: structured_apt_roots)
+      content_ids = roots.where.not(:content_type => ::Katello::Repository::DEB_TYPE).pluck(:content_id)
+      deb_roots = roots.where(:content_type => ::Katello::Repository::DEB_TYPE)
+      if deb_roots.any?
+        # deb? roots need to be considered separately because they do not have content_ids on the root!
+        deb_repos_query = Katello::Repository.where(root: deb_roots)
         deb_repos_library = Set.new
         deb_repos_batch = []
         if match_environment

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

@@ -81,7 +81,7 @@ module Katello
       def create_remote
         if smart_proxy_acs&.remote_href.nil?
           response = super
-          smart_proxy_acs.update!(remote_href: response.pulp_href)
+          smart_proxy_acs.update!(remote_href: response.pulp_href, remote_prn: response.prn)
         end
       end
 
@@ -106,7 +106,7 @@ module Katello
           end
           response = api.alternate_content_source_api.create(name: generate_backend_object_name, paths: paths.sort,
                                                              remote: smart_proxy_acs.remote_href)
-          smart_proxy_acs.update!(alternate_content_source_href: response.pulp_href)
+          smart_proxy_acs.update!(alternate_content_source_href: response.pulp_href, alternate_content_source_prn: response.prn)
           return response
         end
       end

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

@@ -22,6 +22,7 @@ module Katello
       def self.generate_model_row(unit)
         {
           pulp_id: unit['pulp_href'],
+          pulp_prn: unit['prn'],
           checksum: unit['sha256'],
           namespace: unit['namespace'],
           version: unit['version'],

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

@@ -31,21 +31,21 @@ module Katello
         def refresh
           found = list(name: default_name).results.first
           if found && found.ca_certificate != ca_cert
-            partial_update(found.pulp_href)
+            partial_update(found.pulp_href)  # Still use pulp_href for API calls
           else
             found = create
           end
-          persist_if_needed(found.pulp_href)
+          persist_if_needed(found)
         end
 
-        def persist_if_needed(href)
+        def persist_if_needed(content_guard_obj)
           return if self.smart_proxy.pulp_mirror?
           Katello::Util::Support.active_record_retry do
             found = Katello::Pulp3::ContentGuard.find_by(:name => default_name)
             if found
-              found.update(pulp_href: href)
+              found.update(pulp_href: content_guard_obj.pulp_href, pulp_prn: content_guard_obj.prn)
             else
-              Katello::Pulp3::ContentGuard.create(name: default_name, pulp_href: href)
+              Katello::Pulp3::ContentGuard.create(name: default_name, pulp_href: content_guard_obj.pulp_href, pulp_prn: content_guard_obj.prn)
             end
           end
         end

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

@@ -64,6 +64,10 @@ module Katello
           PulpcoreClient::RepositoriesApi.new(core_api_client)
         end
 
+        def core_repository_versions_api
+          PulpcoreClient::RepositoryVersionsApi.new(core_api_client)
+        end
+
         def repositories_api
           repository_type.repositories_api_class.new(api_client)
         end
@@ -237,6 +241,12 @@ module Katello
           end
         end
 
+        def core_repository_versions_list_all(options = {})
+          self.class.fetch_from_list do |page_opts|
+            core_repository_versions_api.list(page_opts.merge(options))
+          end
+        end
+
         def list_all(options = {})
           self.class.fetch_from_list do |page_opts|
             repositories_api.list(page_opts.merge(options))

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

@@ -31,6 +31,7 @@ module Katello
         unit = unit.try(:with_indifferent_access)
         return {
           pulp_id: unit[unit_identifier],
+          pulp_prn: unit[:prn],
           checksum: unit[:sha256],
           filename: unit[:relative_path],
           name: unit[:package],

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

@@ -27,6 +27,7 @@ module Katello
           schema_version: unit['schema_version'],
           digest: unit['digest'],
           pulp_id: unit[unit_identifier],
+          pulp_prn: unit['prn'],
           annotations: unit['annotations'],
           labels: unit['labels'],
           is_bootable: unit['is_bootable'] || unit['type'] == 'bootable',

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

@@ -29,6 +29,7 @@ module Katello
           schema_version: unit['schema_version'],
           digest: unit['digest'],
           pulp_id: unit[unit_identifier],
+          pulp_prn: unit['prn'],
           annotations: unit['annotations'],
           labels: unit['labels'],
           is_bootable: unit['is_bootable'] || unit['type'] == 'bootable',

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

@@ -18,6 +18,7 @@ module Katello
       def self.generate_model_row(unit)
         row = {
           pulp_id: unit[unit_identifier],
+          pulp_prn: unit['prn'],
           name: unit['name'],
         }
 

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

@@ -25,6 +25,7 @@ module Katello
 
         {
           pulp_id: unit[unit_identifier],
+          pulp_prn: unit['prn'],
           name: filename,
           path: unit['relative_path'],
           checksum: unit['sha256'],

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

@@ -20,6 +20,7 @@ module Katello
       def self.generate_model_row(unit, content_type)
         {
           pulp_id: unit['pulp_href'],
+          pulp_prn: unit['prn'],
           name: content_type&.model_name&.call(unit),
           version: content_type&.model_version&.call(unit),
           filename: content_type&.model_filename&.call(unit),

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

@@ -68,6 +68,7 @@ module Katello
         shared_attributes = unit.keys & Katello::ModuleStream.column_names
         to_return = unit.select { |key, _v| shared_attributes.include?(key) }
         to_return['pulp_id'] = unit['pulp_href']
+        to_return['pulp_prn'] = unit['prn']
         to_return[:created_at] = DateTime.now
         to_return[:updated_at] = DateTime.now
         to_return

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

@@ -58,6 +58,7 @@ module Katello
       def self.generate_model_row(unit)
         custom_json = {}
         custom_json['pulp_id'] = unit['pulp_href']
+        custom_json['pulp_prn'] = unit['prn']
         custom_json['name'] = unit['name']
         custom_json['description'] = unit['description']
         custom_json