katello 4.6.2.1 → 4.7.0.rc1

data/app/lib/actions/katello/content_view_version/import.rb

@@ -21,16 +21,28 @@ module Actions
 
           sequence do
             plan_action(AutoCreateProducts, import: import)
-            plan_action(AutoCreateRepositories, import: import)
-            plan_action(AutoCreateRedhatRepositories, import: import)
-            plan_action(ResetContentViewRepositoriesFromMetadata, import: import)
-            plan_action(::Actions::Katello::ContentView::Publish, import.content_view, metadata_map.content_view_version.description,
-                          path: path,
-                          metadata: metadata,
-                          importing: true,
-                          major: metadata_map.content_view_version.major,
-                          minor: metadata_map.content_view_version.minor)
-            plan_self(content_view_id: import.content_view.id)
+            plan_action(AutoCreateRepositories, import: import, path: path)
+            plan_action(AutoCreateRedhatRepositories, import: import, path: path)
+
+            if metadata_map.syncable_format?
+              plan_action(::Actions::BulkAction,
+                    ::Actions::Katello::Repository::Sync,
+                    import.intersecting_repos_library_and_metadata.exportable(format: metadata_map.format),
+                    skip_candlepin_check: true
+                    )
+            end
+
+            if import.content_view
+              plan_action(ResetContentViewRepositoriesFromMetadata, import: import)
+              plan_action(::Actions::Katello::ContentView::Publish, import.content_view, metadata_map.content_view_version.description,
+                            path: path,
+                            metadata: metadata,
+                            importing: !metadata_map.syncable_format?,
+                            syncable: metadata_map.syncable_format?,
+                            major: metadata_map.content_view_version.major,
+                            minor: metadata_map.content_view_version.minor)
+              plan_self(content_view_id: import.content_view.id)
+            end
           end
         end
 

data/app/lib/actions/katello/product/destroy.rb

@@ -11,7 +11,7 @@ module Actions
           unless organization_destroy || product.user_deletable?
             if product.redhat?
               fail _("Cannot delete Red Hat product: %{product}") % { :product => product.name }
-            elsif !product.published_content_view_versions.empty?
+            elsif !product.published_content_view_versions.not_ignorable.empty?
               fail _("Cannot delete product with repositories published in a content view.  Product: %{product}, %{view_versions}") %
                        { :product => product.name, :view_versions => view_versions(product) }
             end

data/app/lib/actions/katello/repository/destroy.rb

@@ -23,7 +23,7 @@ module Actions
                            repository,
                            SmartProxy.pulp_primary)
 
-          remove_versions(repository, repository.content_views.generated_for_none, affected_cvv_ids) if remove_from_content_view_versions
+          remove_versions(repository, repository.content_views_all(include_composite: true)&.generated_for_none, affected_cvv_ids) if remove_from_content_view_versions
 
           handle_alternate_content_sources(repository)
 
@@ -105,12 +105,12 @@ module Actions
 
         def remove_versions(repository, content_views, affected_cvv_ids)
           return if content_views.blank?
-
           interested_inverses = repository.
                                   library_instances_inverse.
                                   joins(:content_view_version => :content_view).
                                   merge(content_views)
-          affected_cvv_ids.concat(interested_inverses.pluck(:content_view_version_id).uniq)
+          return if interested_inverses.blank?
+          affected_cvv_ids.concat(interested_inverses.pluck(:content_view_version_id)&.uniq)
           plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::Destroy, interested_inverses)
         end
 

data/app/lib/actions/katello/repository/errata_mail.rb

@@ -2,18 +2,21 @@ module Actions
   module Katello
     module Repository
       class ErrataMail < Actions::EntryAction
-        middleware.use Actions::Middleware::ExecuteIfContentsChanged
-
-        def plan(repo, contents_changed = nil)
-          last_updated = repo.repository_errata.order('updated_at ASC').last.try(:updated_at) || Time.now
-          plan_self(:repo => repo.id, :contents_changed => contents_changed, :last_updated => last_updated.to_s)
+        def plan(repo)
+          plan_self(:repo => repo.id, :associated_errata_before_syncing => repo.repository_errata.pluck(:erratum_id).uniq.sort.reverse, :new_associated_errata => [])
         end
 
         def run
           ::User.current = ::User.anonymous_admin
           repo = ::Katello::Repository.find(input[:repo])
+          input[:new_associated_errata] = repo.repository_errata.pluck(:erratum_id).uniq.sort.reverse - input[:associated_errata_before_syncing]
+
           users = ::User.select { |user| user.receives?(:sync_errata) && user.organization_ids.include?(repo.organization.id) && user.can?(:view_products, repo.product) }.compact
-          errata = ::Katello::Erratum.where(:id => repo.repository_errata.where('katello_repository_errata.updated_at > ?', input['last_updated'].to_datetime).pluck(:erratum_id))
+          errata = ::Katello::Erratum.where(:id => input[:new_associated_errata])
+
+          [:associated_errata_before_syncing, :new_associated_errata].each do |key|
+            input[key] = "Trimmed list... (#{input[key].length} #{key.to_s.gsub('_', ' ')})" if input[key].length > 3
+          end
 
           begin
             MailNotification[:sync_errata].deliver(:users => users, :repo => repo, :errata => errata) unless (users.blank? || errata.blank?)

data/app/lib/actions/katello/repository/refresh_repository.rb

@@ -8,7 +8,7 @@ module Actions
             plan_action(Actions::Pulp3::Orchestration::Repository::RefreshIfNeeded,
                              repo, SmartProxy.default_capsule!, :dependency => options[:dependency])
             repo.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
-              plan_action(::Actions::Pulp3::Orchestration::AlternateContentSource::RefreshRemote, smart_proxy_acs)
+              plan_action(::Actions::Pulp3::AlternateContentSource::RefreshRemote, smart_proxy_acs)
             end
             plan_self(:name => repo.name, :dependency => options[:dependency])
           end

data/app/lib/actions/katello/repository/sync.rb

@@ -16,8 +16,6 @@ module Actions
         # @param repo
         # @param pulp_sync_task_id in case the sync was triggered outside
         #   of Katello and we just need to finish the rest of the orchestration
-        # rubocop:disable Metrics/MethodLength
-        # rubocop:disable Metrics/CyclomaticComplexity
         def plan(repo, options = {})
           action_subject(repo)
 
@@ -26,9 +24,11 @@ module Actions
           skip_metadata_check = options.fetch(:skip_metadata_check, false) || (validate_contents && repo.yum?)
           generate_applicability =  options.fetch(:generate_applicability, repo.yum? || repo.deb?)
 
-          fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank? && source_url.blank?
-          fail ::Katello::Errors::InvalidActionOptionError, _("Cannot validate contents on non-yum/deb repositories.") if validate_contents && !repo.yum? && !repo.deb?
-          fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum repositories.") if skip_metadata_check && !repo.yum?
+          validate_repo!(repo: repo,
+                        source_url: source_url,
+                        validate_contents: validate_contents,
+                        skip_metadata_check: skip_metadata_check,
+                        skip_candlepin_check: options.fetch(:skip_candlepin_check, false))
 
           pulp_sync_options = {}
           pulp_sync_options[:download_policy] = ::Katello::RootRepository::DOWNLOAD_ON_DEMAND if validate_contents && repo.yum?
@@ -51,7 +51,7 @@ module Actions
               plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
               plan_action(Katello::Repository::CorrectChecksum, repo)
               concurrence do
-                plan_action(Katello::Repository::ErrataMail, repo, output[:contents_changed])
+                plan_action(Katello::Repository::ErrataMail, repo)
                 plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repo.id]) if generate_applicability
               end
               plan_self(:id => repo.id, :sync_result => output, :skip_metadata_check => skip_metadata_check, :validate_contents => validate_contents,
@@ -82,6 +82,13 @@ module Actions
           end
         end
 
+        def validate_repo!(repo:, source_url:, validate_contents:, skip_metadata_check:, skip_candlepin_check:)
+          fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank? && source_url.blank?
+          fail ::Katello::Errors::InvalidActionOptionError, _("Cannot validate contents on non-yum/deb repositories.") if validate_contents && !repo.yum? && !repo.deb?
+          fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum repositories.") if skip_metadata_check && !repo.yum?
+          ::Katello::Util::CandlepinRepositoryChecker.check_repository_for_sync!(repo) if repo.yum? && !skip_candlepin_check
+        end
+
         def presenter
           found = all_planned_actions(Pulp3::Repository::Sync) if found.empty?
           found = all_planned_actions(Pulp3::Repository::Repair) if found.empty?

data/app/lib/actions/katello/repository_set/enable_repository.rb

@@ -6,15 +6,19 @@ module Actions
           _("Enable")
         end
 
-        def plan(product, content, options)
+        def plan(product, content, substitutions, override_url: nil)
           mapper = ::Katello::Candlepin::RepositoryMapper.new(product,
                                                                content,
-                                                               options)
+                                                               substitutions)
           mapper.validate!
           if mapper.find_repository
             fail ::Katello::Errors::ConflictException, _("The repository is already enabled")
           end
           repository = mapper.build_repository
+          if override_url
+            repository.root.url = override_url
+            repository.root.download_policy = ::Katello::RootRepository::DOWNLOAD_IMMEDIATE if URI(override_url).scheme == 'file'
+          end
           plan_action(Repository::Create, repository, clone: false)
           action_subject(repository)
           plan_self

data/app/lib/actions/pulp3/alternate_content_source/refresh_remote.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp3
+    module AlternateContentSource
+      class RefreshRemote < Pulp3::AbstractAsyncTask
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_acs_id: smart_proxy_acs.id, smart_proxy_id: smart_proxy_acs.smart_proxy_id)
+        end
+
+        def invoke_external_task
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          smart_proxy_acs.backend_service.update_remote
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/refresh.rb

@@ -5,6 +5,7 @@ module Actions
         class Refresh < Pulp3::Abstract
           def plan(smart_proxy_acs)
             sequence do
+              plan_action(Actions::Pulp3::AlternateContentSource::RefreshRemote, smart_proxy_acs)
               plan_action(Actions::Pulp3::AlternateContentSource::Refresh, smart_proxy_acs)
             end
           end

data/app/lib/actions/pulp3/orchestration/content_view_version/export_library.rb

@@ -14,7 +14,7 @@ module Actions
                                                                            organization: organization,
                                                                            create_by_default: true,
                                                                            format: format)
-            repo_ids_in_library = organization.default_content_view_version.repositories.exportable.immediate_or_none.pluck(:id)
+            repo_ids_in_library = organization.default_content_view_version.repositories.exportable(format: format).immediate_or_none.pluck(:id)
             content_view.update!(repository_ids: repo_ids_in_library)
 
             sequence do

data/app/lib/actions/pulp3/orchestration/content_view_version/export_repository.rb

@@ -9,7 +9,7 @@ module Actions
                     format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
             action_subject(repository)
             validate_repositories_immediate!(repository)
-
+            validate_export_types!(repository, format)
             content_view = ::Katello::Pulp3::ContentViewVersion::Export.find_repository_export_view(
                                                                            repository: repository,
                                                                            create_by_default: true,
@@ -40,13 +40,21 @@ module Actions
           end
 
           def validate_repositories_immediate!(repository)
-            unless repository.immediate?
+            unless repository.download_policy.blank? || repository.immediate?
               fail _("NOTE: Unable to fully export repository '%{repository}' because"\
                      " it does not have the 'immediate' download policy."\
                      " Update the download policy and sync the affected repository to include them in the export."\
                        % { repository: repository.name })
             end
           end
+
+          def validate_export_types!(repository, format)
+            unless ::Katello::Repository.exportable(format: format).where(id: repository.id).exists?
+              fail _("NOTE: Unable to export repository '%{repository}' because"\
+                     " it does not have an exportable content type."\
+                       % { repository: repository.name })
+            end
+          end
         end
       end
     end

data/app/lib/katello/concerns/renderer_extensions.rb

@@ -11,7 +11,8 @@ module Katello
           content_view = host.try(:content_facet).try(:content_view) || host.try(:content_view)
 
           if content_view && host.operatingsystem.is_a?(Redhat) &&
-                  host.operatingsystem.kickstart_repos(host).first.present?
+                  host.operatingsystem.kickstart_repos(host).first.present? &&
+                  host&.content_facet&.kickstart_repository.present?
             @mediapath ||= host.operatingsystem.mediumpath(medium_provider)
           end
         end

data/app/lib/katello/errors.rb

@@ -130,8 +130,8 @@ module Katello
 
     class UpstreamConsumerGone < StandardError
       def message
-        _("The Subscription Allocation providing the imported manifest has been removed. " \
-          "Please create a new Subscription Allocation and import the new manifest.")
+        _("The manifest doesn't exist on console.redhat.com. " \
+          "Please create and import a new manifest.")
       end
     end
 

data/app/lib/katello/resources/candlepin.rb

@@ -89,10 +89,16 @@ module Katello
           delegate :[], to: :json_resource
 
           def resource(url = self.site + self.path, client_cert = self.client_cert, client_key = self.client_key, ca_file = nil, options = {})
+            cert_store = OpenSSL::X509::Store.new
+            cert_store.add_file(ca_file) if ca_file
+
+            if proxy&.cacert
+              Foreman::Util.add_ca_bundle_to_store(proxy.cacert, cert_store)
+            end
             RestClient::Resource.new(url,
                                      :ssl_client_cert => OpenSSL::X509::Certificate.new(client_cert),
                                      :ssl_client_key => OpenSSL::PKey::RSA.new(client_key),
-                                     :ssl_ca_file => ca_file,
+                                     :ssl_cert_store => cert_store,
                                      :verify_ssl => ca_file ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE,
                                      :open_timeout => Setting[:manifest_refresh_timeout],
                                      :timeout => Setting[:manifest_refresh_timeout],

data/app/lib/katello/resources/cdn/katello_cdn.rb

@@ -33,19 +33,9 @@ module Katello
           results = json_body['results']
 
           results.map do |repo|
-            arch = repo['arch']
-            arch = nil if arch == "noarch"
-            substitutions = {
-              :releasever => repo['minor'],
-              :basearch => arch
-            }.compact
-            path = substitutions.inject(content_path) do |path_url, (key, value)|
-              path_url.gsub("$#{key}", value)
-            end
-            {
-              path: path,
-              substitutions: substitutions
-            }
+            Katello::Content.substitute_content_path(arch: repo[:arch],
+                                                     releasever: repo[:minor],
+                                                     content_path: content_path)
           end
         end
 

data/app/lib/katello/resources/cdn.rb

@@ -38,17 +38,19 @@ module Katello
                                     :username,
                                     :password,
                                     :organization_label,
-                                    :ssl_ca_cert)
+                                    :ssl_ca_cert,
+                                    :custom_cdn)
 
           if options[:ssl_ca_cert].present?
-            begin
-              ca_cert = OpenSSL::X509::Certificate.new(options[:ssl_ca_cert])
-            rescue
-              raise _("Invalid SSL CA certificate given for CDN")
-            end
-
             @cert_store = OpenSSL::X509::Store.new
-            @cert_store.add_cert(ca_cert)
+            Foreman::Util.add_ca_bundle_to_store(options[:ssl_ca_cert], @cert_store)
+          elsif options[:ssl_ca_file]
+            @cert_store = OpenSSL::X509::Store.new
+            @cert_store.add_file(options[:ssl_ca_file])
+          end
+
+          if @cert_store && proxy&.cacert
+            Foreman::Util.add_ca_bundle_to_store(proxy.cacert, @cert_store)
           end
 
           @url = url
@@ -63,6 +65,9 @@ module Katello
             options[:ssl_client_key] = OpenSSL::PKey::RSA.new(product.key)
             options[:ssl_ca_file] = self.ca_file
             self.new(cdn_configuration.url, options)
+          elsif cdn_configuration.custom_cdn?
+            options[:ssl_ca_cert] = cdn_configuration.ssl_ca
+            self.new(cdn_configuration.url, options)
           else
             options[:username] = cdn_configuration.username
             options[:password] = cdn_configuration.password
@@ -91,9 +96,9 @@ module Katello
           net.use_ssl = @uri.is_a?(URI::HTTPS)
 
           if @uri.is_a?(URI::HTTPS)
+            net.cert_store = @cert_store
             net.cert = @options[:ssl_client_cert]
             net.key = @options[:ssl_client_key]
-            net.ca_file = @options[:ssl_ca_file]
             net.cert_store = @cert_store
           end
 

data/app/lib/katello/util/candlepin_repository_checker.rb

@@ -0,0 +1,73 @@
+module Katello
+  module Util
+    module CandlepinRepositoryChecker
+      def self.check_repositories_for_promote!(content_view_version)
+        bad_repo = content_view_version.repositories.yum_type.find { |repo| !repository_exist_in_backend?(repo) }
+        return if bad_repo.blank?
+        item = _("Content View Version: '%{cvv}', Product: '%{product}', Repository: '%{repo}' " %
+                  { repo: bad_repo.name, product: bad_repo.product.name, cvv: content_view_version.name })
+
+        if bad_repo.redhat?
+          fail _("'%{item}' does not exist in the backend system [ Candlepin ]. "\
+                 " Either remove the invalid repository or try refreshing "\
+                 "the manifest before promoting. " % { item: item })
+        else
+          fail _("'%{item}' does not exist in the backend system [ Candlepin ]. "\
+                 " Remove the invalid repository before promoting. " % { item: item })
+        end
+      end
+
+      def self.check_repository_for_sync!(repo)
+        return if !repo.yum? || repository_exist_in_backend?(repo)
+        item = _("Product: '%{product}', Repository: '%{repo}' " %
+                  { repo: repo.name, product: repo.product.name })
+
+        if repo.redhat?
+          fail _("'%{item}' does not exist in the backend system [ Candlepin ]. "\
+                 " Either remove and re-enable the repository or try refreshing "\
+                 "the manifest before synchronizing. " % { item: item })
+        else
+          fail _("'%{item}' does not exist in the backend system [ Candlepin ]. "\
+                 " Remove and recreate the repository before synchronizing. " % { item: item })
+        end
+      end
+
+      def self.repository_exist_in_backend?(repository)
+        ::Katello::Resources::Candlepin::Content.get(repository.organization.label, repository.root.content_id)
+        true
+      rescue RestClient::NotFound
+        false
+      end
+
+      def self.check_repositories_for_publish!(content_view)
+        if content_view.composite?
+          content_view.components.each do |cvv|
+            check_repositories_for_content_view_publish!(cvv.repositories, component_version: cvv)
+          end
+        else
+          check_repositories_for_content_view_publish!(content_view.repositories)
+        end
+      end
+
+      def self.check_repositories_for_content_view_publish!(repositories, component_version: nil)
+        bad_repo = repositories.yum_type.find { |repo| !repository_exist_in_backend?(repo) }
+        return if bad_repo.blank?
+        if component_version
+          item = _("Component Version: '%{cvv}', Product: '%{product}', Repository: '%{repo}' " %
+                  { repo: bad_repo.name, product: bad_repo.product.name, cvv: component_version.name })
+        else
+          item = _("Product: '%{product}', Repository: '%{repo}' " %
+                  { repo: bad_repo.name, product: bad_repo.product.name })
+        end
+        if bad_repo.redhat?
+          fail _("'%{item}' in this content view does not exist in the backend system [ Candlepin ]. "\
+                 " Either remove the invalid repository or try refreshing "\
+                 "the manifest before publishing again. " % { item: item })
+        else
+          fail _("'%{item}' in this content view does not exist in the backend system [ Candlepin ]. "\
+                 " Remove the invalid repository before publishing again. " % { item: item })
+        end
+      end
+    end
+  end
+end

data/app/models/katello/activation_key.rb

@@ -28,7 +28,7 @@ module Katello
     alias_method :lifecycle_environment, :environment
 
     before_validation :set_default_content_view, :unless => :persisted?
-
+    before_destroy :validate_destroyable!
     accepts_nested_attributes_for :purpose_addons
 
     validates_lengths_from_database
@@ -177,6 +177,17 @@ module Katello
       return_activation_keys_by_id(activation_keys.pluck(:id))
     end
 
+    def validate_destroyable!
+      unless organization.being_deleted?
+        if Parameter.where(name: 'kt_activation_keys').pluck(:value).any? { |value| value.split(",").include?(name) }
+          fail _("This activation key is associated to one or more Hosts/Hostgroups. "\
+                  "Search and unassociate Hosts/Hostgroups using params.kt_activation_keys ~ \"%{name}\" "\
+                  "before deleting." % {name: name})
+        end
+      end
+      true
+    end
+
     private
 
     def set_default_content_view

data/app/models/katello/alternate_content_source.rb

@@ -10,7 +10,7 @@ module Katello
 
     self.table_name = :katello_alternate_content_sources
 
-    ACS_TYPES = %w(custom simplified).freeze
+    ACS_TYPES = %w(custom simplified rhui).freeze
     CONTENT_TYPES = [::Katello::Repository::YUM_TYPE, ::Katello::Repository::FILE_TYPE].freeze
     AUDIT_REFRESH_ACTION = 'refresh'.freeze
 
@@ -19,7 +19,6 @@ module Katello
     belongs_to :ssl_ca_cert, inverse_of: :ssl_ca_alternate_content_sources, class_name: "Katello::ContentCredential"
     belongs_to :ssl_client_cert, inverse_of: :ssl_client_alternate_content_sources, class_name: "Katello::ContentCredential"
     belongs_to :ssl_client_key, inverse_of: :ssl_key_alternate_content_sources, class_name: "Katello::ContentCredential"
-    belongs_to :http_proxy, inverse_of: :alternate_content_sources
 
     has_many :alternate_content_source_products, dependent: :delete_all, inverse_of: :alternate_content_source,
              class_name: "Katello::AlternateContentSourceProduct"
@@ -32,8 +31,10 @@ module Katello
 
     validates :base_url, :subpaths, :verify_ssl, :upstream_username,
               :upstream_password, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key, if: :simplified?, absence: true
-    validates :base_url, if: :custom?, presence: true
-    validates :products, if: :custom?, absence: true
+    validates :base_url, if: -> { custom? || rhui? }, presence: true
+    validates :products, if: -> { custom? || rhui? }, absence: true
+    validates :label, :uniqueness => true
+    validates :name, :uniqueness => true
     validates :verify_ssl, if: :custom?, exclusion: [nil]
     validates :alternate_content_source_type, inclusion: {
       in: ->(_) { ACS_TYPES },
@@ -47,6 +48,8 @@ module Katello
     }
     validates_with Validators::AlternateContentSourcePathValidator, :attributes => [:base_url, :subpaths], :if => :custom?
 
+    scope :uses_http_proxies, -> { where(use_http_proxies: true) }
+
     scoped_search on: :name, complete_value: true
     scoped_search on: :label, complete_value: true
     scoped_search on: :description, complete_value: true
@@ -72,6 +75,10 @@ module Katello
       alternate_content_source_type == 'simplified'
     end
 
+    def rhui?
+      alternate_content_source_type == 'rhui'
+    end
+
     def self.with_products(products)
       products = [products] unless products.is_a?(Array)
       joins(:alternate_content_source_products).where('katello_alternate_content_source_products.product_id in (:product_ids)', product_ids: products.pluck(:id))
@@ -98,5 +105,9 @@ module Katello
     def audit_updated_products(old_product_ids)
       write_audit(action: 'update', comment: _('Products updated.'), audited_changes: { 'product_ids' => [old_product_ids, product_ids] })
     end
+
+    def self.humanize_class_name
+      "Alternate Content Sources"
+    end
   end
 end

data/app/models/katello/alternate_content_source_product.rb

@@ -5,7 +5,7 @@ module Katello
     self.table_name = :katello_alternate_content_source_products
     belongs_to :alternate_content_source, inverse_of: :alternate_content_source_products, class_name: 'Katello::AlternateContentSource'
     belongs_to :product, inverse_of: :alternate_content_source_products, class_name: 'Katello::Product'
-    delegate :custom?, to: :alternate_content_source
+    delegate :custom?, :rhui?, to: :alternate_content_source
     delegate :simplified?, to: :alternate_content_source
 
     validates_with Validators::AlternateContentSourceProductsValidator, :attributes => [:product_id], if: :simplified?

data/app/models/katello/authorization/repository.rb

@@ -6,12 +6,12 @@ module Katello
 
     def deletable?(remove_from_content_view_versions = true)
       return false unless product.editable?
-      remove_from_content_view_versions || !promoted? || (self.content_views.exists? && !self.content_views.generated_for_none.exists?)
+      remove_from_content_view_versions || !promoted? || (self.content_views_all(include_composite: true).exists? && !self.content_views_all(include_composite: true).generated_for_none.exists?)
     end
 
     def redhat_deletable?(remove_from_content_view_versions = false)
       return false unless product.editable?
-      remove_from_content_view_versions || !self.promoted? || (self.content_views.exists? && !self.content_views.generated_for_none.exists?)
+      remove_from_content_view_versions || !self.promoted? || (self.content_views_all(include_composite: true).exists? && !self.content_views_all(include_composite: true).generated_for_none.exists?)
     end
 
     def readable?

data/app/models/katello/cdn_configuration.rb

@@ -5,8 +5,9 @@ module Katello
     CDN_TYPE = 'redhat_cdn'.freeze
     NETWORK_SYNC = 'network_sync'.freeze
     EXPORT_SYNC = 'export_sync'.freeze
+    CUSTOM_CDN_TYPE = 'custom_cdn'.freeze
 
-    TYPES = [CDN_TYPE, NETWORK_SYNC, EXPORT_SYNC].freeze
+    TYPES = [CDN_TYPE, NETWORK_SYNC, EXPORT_SYNC, CUSTOM_CDN_TYPE].freeze
 
     belongs_to :organization, :inverse_of => :cdn_configuration
 
@@ -32,6 +33,14 @@ module Katello
       type == CDN_TYPE
     end
 
+    def custom_cdn?
+      type == CUSTOM_CDN_TYPE
+    end
+
+    def redhat_cdn_url?
+      Katello::Resources::CDN::CdnResource.redhat_cdn?(url)
+    end
+
     def export_sync?
       type == EXPORT_SYNC
     end
@@ -46,11 +55,11 @@ module Katello
       return if network_sync?
 
       self.url = nil if export_sync?
-      self.url ||= SETTINGS[:katello][:redhat_repository_url] if redhat_cdn?
+      self.url = SETTINGS[:katello][:redhat_repository_url] if redhat_cdn?
       self.username = nil
       self.password = nil
       self.upstream_organization_label = nil
-      self.ssl_ca_credential_id = nil
+      self.ssl_ca_credential_id = nil unless custom_cdn?
       self.upstream_content_view_label = nil
       self.upstream_lifecycle_environment_label = nil
       self.ssl_cert = nil

data/app/models/katello/concerns/host_managed_extensions.rb

@@ -10,6 +10,12 @@ module Katello
           (content_source_id.blank? || (content_facet && content_facet.kickstart_repository.blank?)) && super
         end
 
+        def inherited_attributes
+          inherited_attrs = super
+          inherited_attrs.delete('medium_id') if content_facet && !content_facet.kickstart_repository.blank?
+          inherited_attrs
+        end
+
         def smart_proxy_ids
           ids = super
           ids << content_source_id
@@ -410,7 +416,7 @@ module Katello
         ::Katello::HostTracer.helpers_for(traces)
       end
 
-      def package_names_for_job_template(action:, search:)
+      def package_names_for_job_template(action:, search:, versions: nil)
         actions = %w(install remove update).freeze
         case action
         when 'install'
@@ -422,9 +428,16 @@ module Katello
         when 'update'
           return [] if search.empty?
 
+          versions_by_name = {}
+          if versions.present?
+            JSON.parse(versions).each do |nvra|
+              nvra =~ /([^\.]*)-\d+\.[-\.\w]*/
+              versions_by_name[Regexp.last_match(1)] = nvra
+            end
+          end
           pkg_names = installed_packages.search_for(search).distinct.pluck(:name)
           upgrades = ::Katello::Rpm.installable_for_hosts([self]).select(:id, :name, :nvra, :evr).order(evr: :desc).group_by(&:name)
-          pkg_names.map { |p| upgrades[p]&.first&.nvra }.compact
+          pkg_names.map { |p| versions_by_name[p] || upgrades[p]&.first&.nvra }.compact
         else
           fail ::Foreman::Exception.new(N_("package_names_for_job_template: Action must be one of %s"), actions.join(', '))
         end