katello 4.2.1 → 4.3.0.rc1

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

@@ -36,9 +36,9 @@ module Katello
         end
       end
 
-      def self.api(smart_proxy)
-        api_class = RepositoryTypeManager.find_by(:pulp3_service_class, self).pulp3_api_class
-        api_class ? api_class.new(smart_proxy) : Katello::Pulp3::Api::Core.new(smart_proxy)
+      def self.api(smart_proxy, repository_type_label)
+        repo_type = RepositoryTypeManager.enabled_repository_types[repository_type_label]
+        repo_type.pulp3_api(smart_proxy)
       end
 
       def core_api
@@ -46,12 +46,12 @@ module Katello
       end
 
       def api
-        @api ||= self.class.api(smart_proxy)
+        @api ||= self.class.api(smart_proxy, repo.content_type)
       end
 
       def ignore_404_exception(*)
         yield
-      rescue api.class.api_exception_class => e
+      rescue api.api_exception_class => e
         raise e unless e.code == 404
         nil
       end
@@ -61,7 +61,7 @@ module Katello
       end
 
       def repair(repository_version_href)
-        data = api.class.repository_version_class.new
+        data = api.repository_version_class.new
         api.repository_versions_api.repair(repository_version_href, data)
       end
 
@@ -74,9 +74,17 @@ module Katello
       end
 
       def create_remote
-        remote_file_data = api.class.remote_class.new(remote_options)
+        if remote_options[:url]&.start_with?('uln')
+          remote_file_data = api.class.remote_uln_class.new(remote_options)
+        else
+          remote_file_data = api.remote_class.new(remote_options)
+        end
         reformat_api_exception do
-          response = api.remotes_api.create(remote_file_data)
+          if remote_options[:url]&.start_with?('uln')
+            response = api.remotes_uln_api.create(remote_file_data)
+          else
+            response = api.remotes_api.create(remote_file_data)
+          end
           repo.update!(:remote_href => response.pulp_href)
         end
       end
@@ -89,10 +97,18 @@ module Katello
       def create_test_remote
         test_remote_options = remote_options
         test_remote_options[:name] = test_remote_name
-        remote_file_data = api.class.remote_class.new(test_remote_options)
+        if remote_options[:url]&.start_with?('uln')
+          remote_file_data = api.class.remote_uln_class.new(test_remote_options)
+        else
+          remote_file_data = api.remote_class.new(test_remote_options)
+        end
 
         reformat_api_exception do
-          response = api.remotes_api.create(remote_file_data)
+          if remote_options[:url]&.start_with?('uln')
+            response = api.remotes_uln_api.create(remote_file_data)
+          else
+            response = api.remotes_api.create(remote_file_data)
+          end
           #delete is async, but if its not properly deleted, orphan cleanup will take care of it later
           delete_remote(response.pulp_href)
         end
@@ -104,7 +120,7 @@ module Katello
 
       def reformat_api_exception
         yield
-      rescue api.class.client_module::ApiError => exception
+      rescue api.client_module::ApiError => exception
         body = JSON.parse(exception.response_body) rescue body
         body = body.values.join(',') if body.respond_to?(:values)
         raise ::Katello::Errors::Pulp3Error, body
@@ -128,11 +144,15 @@ module Katello
       end
 
       def remote_partial_update
-        api.remotes_api.partial_update(repo.remote_href, remote_options)
+        if remote_options[:url]&.start_with?('uln')
+          api.remotes_uln_api.partial_update(repo.remote_href, remote_options)
+        else
+          api.remotes_api.partial_update(repo.remote_href, remote_options)
+        end
       end
 
       def delete_remote(href = repo.remote_href)
-        ignore_404_exception { api.remotes_api.delete(href) } if href
+        ignore_404_exception { remote_options[:url]&.start_with?('uln') ? api.remotes_uln_api.delete(href) : api.remotes_api.delete(href) } if href
       end
 
       def self.instance_for_type(repo, smart_proxy)
@@ -175,7 +195,7 @@ module Katello
       end
 
       def get_remote(href = repo.remote_href)
-        api.remotes_api.read(href)
+        repo.url&.start_with?('uln') ? api.remotes_uln_api.read(href) : api.remotes_api.read(href)
       end
 
       def get_distribution(href = distribution_reference.href)
@@ -231,7 +251,7 @@ module Katello
       end
 
       def sync(options = {})
-        repository_sync_url_data = api.class.repository_sync_url_class.new(sync_url_params(options))
+        repository_sync_url_data = api.repository_sync_url_class.new(sync_url_params(options))
         [api.repositories_api.sync(repository_reference.repository_href, repository_sync_url_data)]
       end
 
@@ -242,7 +262,7 @@ module Katello
       end
 
       def create_publication
-        publication_data = api.class.publication_class.new(publication_options(repo.version_href))
+        publication_data = api.publication_class.new(publication_options(repo.version_href))
         api.publications_api.create(publication_data)
       end
 
@@ -276,7 +296,7 @@ module Katello
         # Since we got this far, we need to create a new distribution
         begin
           create_distribution(relative_path)
-        rescue api.class.client_module::ApiError => e
+        rescue api.client_module::ApiError => e
           # Now it seems there is a distribution. Fetch it and save the reference.
           if e.message.include?("\"base_path\":[\"This field must be unique.\"]") ||
               e.message.include?("\"base_path\":[\"Overlaps with existing distribution\"")
@@ -290,7 +310,7 @@ module Katello
       end
 
       def create_distribution(path)
-        distribution_data = api.class.distribution_class.new(secure_distribution_options(path))
+        distribution_data = api.distribution_class.new(secure_distribution_options(path))
         api.distributions_api.create(distribution_data)
       end
 
@@ -413,12 +433,18 @@ module Katello
       end
 
       def ssl_remote_options
-        if root.redhat? && Katello::Resources::CDN::CdnResource.redhat_cdn?(root.url)
+        if root.redhat? && root.cdn_configuration.redhat?
           {
             client_cert: root.product.certificate,
             client_key: root.product.key,
             ca_cert: Katello::Repository.feed_ca_cert(root.url)
           }
+        elsif root.redhat? && !root.cdn_configuration.redhat?
+          {
+            client_cert: root.cdn_configuration.ssl_cert,
+            client_key: root.cdn_configuration.ssl_key,
+            ca_cert: root.cdn_configuration.ssl_ca
+          }
         elsif root.custom?
           {
             client_cert: root.ssl_client_cert&.content,
@@ -432,14 +458,14 @@ module Katello
 
       def lookup_version(href)
         api.repository_versions_api.read(href) if href
-      rescue api.class.api_exception_class => e
+      rescue api.api_exception_class => e
         Rails.logger.error "Exception when calling repository_versions_api->read: #{e}"
         nil
       end
 
       def lookup_publication(href)
         api.publications_api.read(href) if href
-      rescue api.class.api_exception_class => e
+      rescue api.api_exception_class => e
         Rails.logger.error "Exception when calling publications_api->read: #{e}"
         nil
       end

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

@@ -24,7 +24,11 @@ module Katello
       def refresh_entities
         href = remote_href
         if href
-          [api.remotes_api.partial_update(href, remote_options)]
+          if remote_options[:url]&.start_with?('uln')
+            [api.remotes_uln_api.partial_update(href, remote_options)]
+          else
+            [api.remotes_api.partial_update(href, remote_options)]
+          end
         else
           create_remote
           []
@@ -57,7 +61,7 @@ module Katello
 
       def delete(href = repository_href)
         api.repositories_api.delete(href) if href
-      rescue api.class.api_exception_class => e
+      rescue api.api_exception_class => e
         raise e if e.code != 404
         nil
       end
@@ -74,6 +78,10 @@ module Katello
         fetch_repository.latest_version_href
       end
 
+      def publication_href
+        api.publications_api.list(:repository_version => version_href).results.first.pulp_href
+      end
+
       def create_version(options = {})
         api.repository_versions_api.create(repository_href, options)
       end
@@ -99,8 +107,13 @@ module Katello
       end
 
       def create_remote
-        remote_file_data = @repo_service.api.class.remote_class.new(remote_options)
-        api.remotes_api.create(remote_file_data)
+        if remote_options[:url]&.start_with?('uln')
+          remote_file_data = @repo_service.api.class.remote_uln_class.new(remote_options)
+          api.remotes_uln_api.create(remote_file_data)
+        else
+          remote_file_data = @repo_service.api.remote_class.new(remote_options)
+          api.remotes_api.create(remote_file_data)
+        end
       end
 
       def compute_remote_options
@@ -115,7 +128,7 @@ module Katello
         sync_params = repo_service.sync_url_params(options)
         sync_params[:remote] = remote_href
         sync_params[:mirror] = true
-        repository_sync_url_data = api.class.repository_sync_url_class.new(sync_params)
+        repository_sync_url_data = api.repository_sync_url_class.new(sync_params)
         [api.repositories_api.sync(repository_href, repository_sync_url_data)]
       end
 
@@ -153,16 +166,22 @@ module Katello
 
       def create_publication
         if (href = version_href)
-          publication_data = api.class.publication_class.new(publication_options(href))
+          publication_data = api.publication_class.new(publication_options(href))
           api.publications_api.create(publication_data)
         end
       end
 
-      def refresh_distributions(options = {})
+      def refresh_distributions(_options = {})
         path = repo_service.relative_path
         dist_params = {}
-        dist_params[:publication] = options[:publication] if options[:publication]
-        dist_params[:repository_version] = version_href if options[:use_repository_version]
+        if repo_service.repo.repository_type.pulp3_skip_publication
+          dist_params[:repository_version] = version_href
+          fail "could not lookup a version_href for repo #{repo_service.repo.id}" if version_href.nil?
+        else
+          dist_params[:publication] = publication_href
+          fail "Could not lookup a publication_href for repo #{repo_service.repo.id}" if publication_href.nil?
+        end
+
         dist_options = distribution_options(path, dist_params)
         dist_options.delete(:content_guard) if repo_service.repo.content_type == "docker"
         if (distro = repo_service.lookup_distributions(base_path: path).first) ||
@@ -172,7 +191,7 @@ module Katello
           api.distributions_api.partial_update(distro.pulp_href, dist_options)
         else
           # create dist
-          distribution_data = api.class.distribution_class.new(dist_options)
+          distribution_data = api.distribution_class.new(dist_options)
           api.distributions_api.create(distribution_data)
         end
       end
@@ -184,7 +203,7 @@ module Katello
       end
 
       def create_distribution(path)
-        distribution_data = api.class.distribution_class.new(distribution_options(path))
+        distribution_data = api.distribution_class.new(distribution_options(path))
         repo_service.distributions_api.create(distribution_data)
       end
     end

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

@@ -26,41 +26,11 @@ module Katello
       end
 
       def requires
-        results = []
-        flags = {'GT' => '>', 'LT' => '>', 'EQ' => '=', 'GE' => '>=', 'LE' => '<='}
-
-        backend_data['requires']&.each do |requirement|
-          requires_str = ""
-          if requirement.count < 3
-            requires_str = requirement.first
-            results << requires_str
-          else
-            requirement[1] = flags[requirement[1]]
-            requirement[0...2].each { |requirement_piece| requires_str += "#{requirement_piece} " }
-            requirement[2...-1].each { |requirement_piece| requires_str += "#{requirement_piece}." }
-            results << requires_str[0...-1]
-          end
-        end
-        results.uniq
+        Util::Package.parse_dependencies(backend_data['requires'])
       end
 
       def provides
-        results = []
-        flags = {'GT' => '>', 'LT' => '>', 'EQ' => '=', 'GE' => '>=', 'LE' => '<='}
-
-        backend_data['provides']&.each do |provided|
-          provides_str = ""
-          if provided.count < 3
-            provides_str = provided.first
-            results << provides_str
-          else
-            provided[1] = flags[provided[1]]
-            provided[0...2].each { |provided_piece| provides_str += "#{provided_piece} " }
-            provided[2...-1].each { |provided_piece| provides_str += "#{provided_piece}." }
-            results << provides_str[0...-1]
-          end
-        end
-        results.uniq
+        Util::Package.parse_dependencies(backend_data['provides'])
       end
 
       def files

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

@@ -12,7 +12,7 @@ module Katello
         smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
         katello_pulp_ids = smart_proxy_helper.combined_repos_available_to_capsule.map(&:pulp_id)
         pulp3_enabled_repo_types.each do |repo_type|
-          api = repo_type.pulp3_service_class.api(smart_proxy)
+          api = repo_type.pulp3_api(smart_proxy)
           repo_map[api] = api.list_all.reject { |capsule_repo| katello_pulp_ids.include? capsule_repo.name }
         end
 
@@ -23,7 +23,7 @@ module Katello
         repo_version_map = {}
 
         pulp3_enabled_repo_types.each do |repo_type|
-          api = repo_type.pulp3_service_class.api(smart_proxy)
+          api = repo_type.pulp3_api(smart_proxy)
           version_hrefs = api.repository_versions
           orphan_version_hrefs = api.list_all.collect do |pulp_repo|
             mirror_repo_versions = api.versions_list_for_repository(pulp_repo.pulp_href, ordering: :_created)
@@ -52,16 +52,15 @@ module Katello
       def delete_orphan_distributions
         tasks = []
         pulp3_enabled_repo_types.each do |repo_type|
-          pulp3_class = repo_type.pulp3_service_class
-          orphan_distributions(pulp3_class).each do |distribution|
-            tasks << pulp3_class.api(smart_proxy).delete_distribution(distribution.pulp_href)
+          orphan_distributions(repo_type).each do |distribution|
+            tasks << repo_type.pulp3_api(smart_proxy).delete_distribution(distribution.pulp_href)
           end
         end
         tasks
       end
 
-      def orphan_distributions(pulp3_service_class)
-        api = pulp3_service_class.api(smart_proxy)
+      def orphan_distributions(repo_type)
+        api = repo_type.pulp3_api(smart_proxy)
         api.distributions_list_all.select do |distribution|
           dist = api.get_distribution(distribution.pulp_href)
           self.class.orphan_distribution?(dist)
@@ -78,7 +77,7 @@ module Katello
         tasks = []
         repo_names = Katello::Repository.pluck(:pulp_id)
         pulp3_enabled_repo_types.each do |repo_type|
-          api = repo_type.pulp3_service_class.api(smart_proxy)
+          api = repo_type.pulp3_api(smart_proxy)
           remotes = api.remotes_list
 
           remotes.each do |remote|

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

@@ -26,7 +26,7 @@ module Katello
         katello_repos = katello_repos.in_content_views([content_view_id]) if content_view_id
         katello_repos = katello_repos.select { |repo| smart_proxy.pulp3_support?(repo) }
         repos_on_capsule = pulp3_enabled_repo_types.collect do |repo_type|
-          repo_type.pulp3_service_class.api(smart_proxy).list_all(name_in: katello_repos.map(&:pulp_id))
+          repo_type.pulp3_api(smart_proxy).list_all(name_in: katello_repos.map(&:pulp_id))
         end
         repos_on_capsule.flatten!
         repo_ids = repos_on_capsule.map(&:name)

data/app/services/katello/registration_manager.rb

@@ -262,6 +262,8 @@ module Katello
       end
 
       def delete_agent_queue(host)
+        return unless ::Katello.with_katello_agent?
+
         queue_name = Katello::Agent::Dispatcher.host_queue_name(host)
         Katello::EventQueue.push_event(::Katello::Events::DeleteHostAgentQueue::EVENT_TYPE, host.id) do |attrs|
           attrs[:metadata] = { queue_name: queue_name }

data/app/services/katello/repository_type.rb

@@ -13,13 +13,14 @@ module Katello
     end
 
     def_field :allow_creation_by_user, :service_class, :pulp3_service_class, :pulp3_plugin,
-              :pulp3_skip_publication, :configuration_class, :partial_repo_path, :pulp3_api_class,
+              :pulp3_skip_publication, :configuration_class, :pulp3_api_class,
               :repositories_api_class, :api_class, :remotes_api_class, :repository_versions_api_class,
               :distributions_api_class, :remote_class, :repo_sync_url_class, :client_module_class,
-              :distribution_class, :publication_class, :publications_api_class, :model_name, :model_version
+              :distribution_class, :publication_class, :publications_api_class, :url_description
 
     attr_accessor :metadata_publish_matching_check, :index_additional_data_proc
     attr_reader :id, :unique_content_per_repo
+    attr_writer :url_description
 
     def initialize(id)
       @id = id.to_sym
@@ -27,6 +28,7 @@ module Katello
       @unique_content_per_repo = false
       @content_types = []
       @generic_remote_options = []
+      @import_attributes = []
     end
 
     def set_unique_content_per_repo
@@ -41,6 +43,33 @@ module Katello
       @generic_remote_options.sort_by(&:name)
     end
 
+    def import_attributes
+      @import_attributes.sort_by(&:name)
+    end
+
+    def primary_content_types
+      found = self.content_types.select { |type| type.primary_content }
+      found = self.content_types if found.empty?
+      found
+    end
+
+    def translated_generic_remote_options
+      translated = generic_remote_options.deep_dup
+      translated.map do |option|
+        option.title = _(option.title)
+        option.description = _(option.description)
+      end
+      translated
+    end
+
+    def translated_import_attributes
+      translated = import_attributes.deep_dup
+      translated.map do |option|
+        option.description = _(option.description)
+      end
+      translated
+    end
+
     def content_types_to_index
       if SmartProxy.pulp_primary&.pulp3_repository_type_support?(self)
         # type.index being false supersedes type.index_on_pulp3 being true
@@ -60,7 +89,7 @@ module Katello
 
     def content_type(model_class, options = {})
       @content_types ||= []
-      @content_types << ContentType.new(options.merge(:model_class => model_class))
+      @content_types << ContentType.new(options.merge(:model_class => model_class, :content_type => model_class::CONTENT_TYPE))
     end
 
     def generic_content_type(content_type, options = {})
@@ -73,6 +102,10 @@ module Katello
       @generic_remote_options << GenericRemoteOption.new(options.merge(:name => name))
     end
 
+    def import_attribute(name, options = {})
+      @import_attributes << GenericImportAttribute.new(options.merge(:name => name))
+    end
+
     def prevent_unneeded_metadata_publish
       self.metadata_publish_matching_check = true
     end
@@ -90,23 +123,33 @@ module Katello
         :name => self.id.to_s,
         :id => self.id,
         :creatable => @allow_creation_by_user,
-        :pulp3_support => SmartProxy.pulp_primary.pulp3_repository_type_support?(self)
+        :pulp3_support => SmartProxy.pulp_primary.pulp3_repository_type_support?(self),
+        :generic_remote_options => translated_generic_remote_options,
+        :import_attributes => translated_import_attributes,
+        :url_description => _(@url_description),
+        :content_types => content_types.as_json
       }
     end
 
+    def inspect
+      "RepositoryType[#{self.id}]"
+    end
+
     def pulp3_api(smart_proxy)
       if pulp3_api_class == Katello::Pulp3::Api::Generic
         pulp3_api_class.new(smart_proxy, self)
       else
-        pulp3_api_class ? pulp3_api_class.new(smart_proxy) : Katello::Pulp3::Api::Core.new(smart_proxy)
+        pulp3_api_class ? pulp3_api_class.new(smart_proxy, self) : Katello::Pulp3::Api::Core.new(smart_proxy)
       end
     end
 
     class ContentType
-      attr_accessor :model_class, :priority, :pulp2_service_class, :pulp3_service_class, :index, :uploadable, :removable, :index_on_pulp3
+      attr_accessor :model_class, :priority, :pulp2_service_class, :pulp3_service_class, :index, :uploadable, :removable,
+                    :primary_content, :index_on_pulp3, :generic_browser, :content_type
 
       def initialize(options)
         self.model_class = options[:model_class]
+        self.content_type = options[:content_type]
         self.priority = options[:priority] || 99
         self.pulp2_service_class = options[:pulp2_service_class]
         self.pulp3_service_class = options[:pulp3_service_class]
@@ -114,43 +157,88 @@ module Katello
         self.index_on_pulp3 = options[:index_on_pulp3].nil? ? true : options[:index_on_pulp3]
         self.uploadable = options[:uploadable] || false
         self.removable = options[:removable] || false
+        self.primary_content = options[:primary_content] || false
+        self.generic_browser = options[:generic_browser]
       end
 
       def label
         self.model_class::CONTENT_TYPE
       end
+
+      def as_json(_options = {})
+        {
+          label: label,
+          generic_browser: generic_browser,
+          generic: false,
+          removable: removable
+        }
+      end
     end
 
     class GenericContentType < ContentType
-      attr_accessor :pulp3_api, :pulp3_model, :content_type, :filename_key, :duplicates_allowed
+      attr_accessor :pulp3_api, :pulp3_model, :filename_key, :duplicates_allowed, :pluralized_name,
+                    :model_name, :model_version, :model_filename, :model_additional_metadata
 
       def initialize(options)
-        self.model_class = options[:model_class]
-        self.priority = options[:priority] || 99
-        self.pulp3_service_class = options[:pulp3_service_class]
-        self.index = options[:index].nil? ? true : options[:index]
-        self.index_on_pulp3 = options[:index_on_pulp3].nil? ? true : options[:index_on_pulp3]
-        self.uploadable = options[:uploadable] || false
-        self.removable = options[:removable] || false
+        super
         self.pulp3_api = options[:pulp3_api]
         self.pulp3_model = options[:pulp3_model]
         self.content_type = options[:content_type]
         self.filename_key = options[:filename_key]
         self.duplicates_allowed = options[:duplicates_allowed]
+        self.pluralized_name = options[:pluralized_name]
+        self.model_name = options[:model_name]
+        self.model_version = options[:model_version]
+        self.model_filename = options[:model_filename]
+        self.model_additional_metadata = options[:model_additional_metadata]
       end
 
       def label
         self.content_type
       end
+
+      def details_columns
+        columns = []
+        columns << "Name" if self.model_name
+        columns << "Version" if self.model_version
+        columns << "Filename" if self.model_filename
+        columns
+      end
+
+      def as_json(_options = {})
+        super.merge(
+          {
+            :generic => true,
+            :pluralized_label => content_type.pluralize,
+            :pluralized_name => pluralized_name,
+            :details_columns => details_columns
+          }
+        )
+      end
     end
 
     class GenericRemoteOption
-      attr_accessor :name, :type, :description
+      attr_accessor :name, :title, :type, :description, :input_type, :delimiter
+
+      def initialize(options)
+        self.name = options[:name]
+        self.title = options[:title]
+        self.type = options[:type]
+        self.description = options[:description]
+        self.input_type = options[:input_type]
+        self.delimiter = options[:delimiter]
+      end
+    end
+
+    class GenericImportAttribute
+      attr_accessor :name, :api_param, :type, :description, :required
 
       def initialize(options)
         self.name = options[:name]
+        self.api_param = options[:api_param]
         self.type = options[:type]
         self.description = options[:description]
+        self.required = options[:required]
       end
     end
   end

data/app/services/katello/repository_type_manager.rb

@@ -63,7 +63,7 @@ module Katello
       def enabled_content_types(enabled_only = true)
         repo_types = enabled_only ? enabled_repository_types : defined_repository_types
         list = repo_types.values.map do |type|
-          type.content_types.map(&:model_class).flatten.map { |ct| ct::CONTENT_TYPE }
+          type.content_types.map(&:label).flatten
         end
         list.flatten
       end
@@ -83,6 +83,14 @@ module Katello
         list.flatten.map(&:content_type)
       end
 
+      def generic_ui_content_types(enabled_only = true)
+        repo_types = enabled_only ? enabled_repository_types : defined_repository_types
+        list = repo_types.values.map do |type|
+          type.content_types.select { |ct| ct.generic_browser }
+        end
+        list.flatten.map(&:content_type)
+      end
+
       def generic_content_type?(content_type, enabled_only = true)
         types = generic_content_types(enabled_only)
         types.include?(content_type)
@@ -128,12 +136,7 @@ module Katello
       end
 
       def find_repository_type(katello_label)
-        enabled_repository_types.values.each do |repo_type|
-          repo_type.content_types.each do |content_type|
-            return repo_type if content_type.label == katello_label.to_s
-          end
-        end
-        nil
+        enabled_repository_types[katello_label]
       end
 
       def find_content_type(katello_label)
@@ -171,15 +174,18 @@ module Katello
 
       def generic_remote_options(opts = {})
         options = []
+        sorted_options = {}
         repo_types = opts[:defined_only] ? defined_repository_types : enabled_repository_types
         repo_types.each do |_, type|
           if opts[:content_type]
             (options << type.generic_remote_options).flatten! if type.pulp3_service_class == Katello::Pulp3::Repository::Generic && type.id.to_s == opts[:content_type]
+          elsif opts[:sort_by_repo_type]
+            sorted_options[type.id] = type.generic_remote_options if type.pulp3_service_class == Katello::Pulp3::Repository::Generic
           else
             (options << type.generic_remote_options).flatten! if type.pulp3_service_class == Katello::Pulp3::Repository::Generic
           end
         end
-        options
+        opts[:sort_by_repo_type] ? sorted_options : options
       end
 
       private

data/app/services/katello/ui_notifications/subscriptions/manifest_expired_warning.rb

@@ -67,7 +67,7 @@ module Katello
         end
 
         def self.redhat_connected?(org)
-          org.redhat_provider.repository_url.include?(CDN_HOSTNAME)
+          org.cdn_configuration.url.include?(CDN_HOSTNAME)
         end
       end
     end