katello 4.2.1 → 4.3.0.rc1

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

@@ -20,6 +20,9 @@ module Katello
       has_many :content_facet_repositories, :class_name => "Katello::ContentFacetRepository", :dependent => :destroy, :inverse_of => :content_facet
       has_many :bound_repositories, :through => :content_facet_repositories, :class_name => "Katello::Repository", :source => :repository
 
+      has_many :content_facet_applicable_debs, :class_name => "Katello::ContentFacetApplicableDeb", :dependent => :delete_all, :inverse_of => :content_facet
+      has_many :applicable_debs, :through => :content_facet_applicable_debs, :class_name => "Katello::Deb", :source => :deb
+
       has_many :content_facet_applicable_rpms, :class_name => "Katello::ContentFacetApplicableRpm", :dependent => :delete_all, :inverse_of => :content_facet
       has_many :applicable_rpms, :through => :content_facet_applicable_rpms, :class_name => "Katello::Rpm", :source => :rpm
 
@@ -65,6 +68,10 @@ module Katello
         Erratum.installable_for_content_facet(self, env, content_view)
       end
 
+      def installable_debs(env = nil, content_view = nil)
+        Deb.installable_for_content_facet(self, env, content_view)
+      end
+
       def installable_rpms(env = nil, content_view = nil)
         Rpm.installable_for_content_facet(self, env, content_view)
       end
@@ -95,6 +102,7 @@ module Katello
           repo.library_instance_id.nil? ? repo.id : repo.library_instance_id
         end
 
+        ::Katello::Applicability::ApplicableContentHelper.new(self, ::Katello::Deb, bound_repos).calculate_and_import
         ::Katello::Applicability::ApplicableContentHelper.new(self, ::Katello::Rpm, bound_repos).calculate_and_import
         ::Katello::Applicability::ApplicableContentHelper.new(self, ::Katello::Erratum, bound_repos).calculate_and_import
         ::Katello::Applicability::ApplicableContentHelper.new(self, ::Katello::ModuleStream, bound_repos).calculate_and_import
@@ -105,6 +113,7 @@ module Katello
       def import_applicability(partial = false)
         import_module_stream_applicability(partial)
         import_errata_applicability(partial)
+        import_deb_applicability(partial)
         import_rpm_applicability(partial)
         update_applicability_counts
       end
@@ -114,6 +123,8 @@ module Katello
             :installable_security_errata_count => self.installable_errata.security.count,
             :installable_bugfix_errata_count => self.installable_errata.bugfix.count,
             :installable_enhancement_errata_count => self.installable_errata.enhancement.count,
+            :applicable_deb_count => self.content_facet_applicable_debs.count,
+            :upgradable_deb_count => self.installable_debs.count,
             :applicable_rpm_count => self.content_facet_applicable_rpms.count,
             :upgradable_rpm_count => self.installable_rpms.count,
             :applicable_module_stream_count => self.content_facet_applicable_module_streams.count,
@@ -122,6 +133,10 @@ module Katello
         self.save!(:validate => false)
       end
 
+      def import_deb_applicability(partial)
+        ApplicableContentHelper.new(Deb, self).import(partial)
+      end
+
       def import_rpm_applicability(partial)
         ApplicableContentHelper.new(Rpm, self).import(partial)
       end
@@ -180,6 +195,10 @@ module Katello
         joins_installable_relation(Katello::Erratum, Katello::ContentFacetErratum)
       end
 
+      def self.joins_installable_debs
+        joins_installable_relation(Katello::Deb, Katello::ContentFacetApplicableDeb)
+      end
+
       def self.joins_installable_rpms
         joins_installable_relation(Katello::Rpm, Katello::ContentFacetApplicableRpm)
       end
@@ -243,6 +262,8 @@ module Katello
         property :uuid, String, desc: 'Returns UUID of the facet'
         property :applicable_module_stream_count, Integer, desc: 'Returns applicable Module Stream count'
         property :upgradable_module_stream_count, Integer, desc: 'Returns upgradable Module Stream count'
+        property :applicable_deb_count, Integer, desc: 'Returns applicable DEB count'
+        property :upgradable_deb_count, Integer, desc: 'Returns upgradable DEB count'
         property :applicable_rpm_count, Integer, desc: 'Returns applicable RPM count'
         property :upgradable_rpm_count, Integer, desc: 'Returns upgradable RPM count'
         property :content_source, 'SmartProxy', desc: 'Returns Smart Proxy object as the content source'
@@ -254,9 +275,9 @@ module Katello
         prop_group :katello_idname_props, Katello::Model, meta: { resource: 'lifecycle_environment' }
       end
       class Jail < ::Safemode::Jail
-        allow :applicable_module_stream_count, :applicable_rpm_count, :content_source, :content_source_id, :content_source_name, :content_view_id,
+        allow :applicable_deb_count, :applicable_module_stream_count, :applicable_rpm_count, :content_source, :content_source_id, :content_source_name, :content_view_id,
               :content_view_name, :errata_counts, :id, :kickstart_repository, :kickstart_repository_id, :kickstart_repository_name,
-              :lifecycle_environment_id, :lifecycle_environment_name, :upgradable_module_stream_count, :upgradable_rpm_count, :uuid
+              :lifecycle_environment_id, :lifecycle_environment_name, :upgradable_deb_count, :upgradable_module_stream_count, :upgradable_rpm_count, :uuid
       end
     end
   end

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

@@ -57,7 +57,7 @@ module Katello
           self.dmi_uuid = consumer_params['facts']['dmi.system.uuid']
         end
 
-        self.autoheal = consumer_params['autoheal'] unless consumer_params['autoheal'].blank?
+        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?

data/app/models/katello/host_tracer.rb

@@ -10,11 +10,30 @@ module Katello
     validates :app_type, :length => {:maximum => 255}, :presence => true
 
     scoped_search :on => :application, :complete_value => true
-    scoped_search :on => :app_type
-    scoped_search :on => :helper
+    scoped_search :on => :app_type, :complete_value => true
+    scoped_search :on => :helper, :complete_value => true
 
     def reboot_required?
       self.app_type == 'static'
     end
+
+    def restart_command
+      case self.app_type
+      when 'static'
+        'reboot'
+      when 'session'
+        nil
+      else
+        self.helper
+      end
+    end
+
+    def self.helpers_for(traces)
+      if traces.any?(&:reboot_required?)
+        ['reboot']
+      else
+        traces.map(&:restart_command).compact.uniq
+      end
+    end
   end
 end

data/app/models/katello/installed_deb.rb

@@ -1,7 +1,7 @@
 module Katello
   class InstalledDeb < Katello::Model
-    has_many :hosts, :through => :host_installed_debs, :class_name => "::Host"
     has_many :host_installed_debs, :class_name => "Katello::HostInstalledDeb", :dependent => :destroy, :inverse_of => :installed_deb
+    has_many :hosts, :through => :host_installed_debs, :class_name => "::Host"
 
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :version

data/app/models/katello/module_stream.rb

@@ -71,6 +71,10 @@ module Katello
       {:name => name, :stream => stream, :version => version, :context => context, :arch => arch}.compact
     end
 
+    def content_view_filters
+      Katello::ContentViewModuleStreamFilterRule.where(module_stream_id: self.id).eager_load(:filter).map(&:filter)
+    end
+
     def self.find_by_host_name(_key, operator, value)
       conditions = sanitize_sql_for_conditions(["#{::Host::Managed.table_name}.name #{operator} ?", value_to_sql(operator, value)])
       hosts = ::Host::Managed.authorized("view_hosts").where(conditions).select(:id)

data/app/models/katello/ping.rb

@@ -8,7 +8,7 @@ module Katello
       def services(capsule_id = nil)
         proxy = fetch_proxy(capsule_id)
         services = [:candlepin, :candlepin_auth, :foreman_tasks, :katello_events, :candlepin_events]
-        services += [:pulp3] if proxy&.pulp3_enabled?
+        services += [:pulp3, :pulp3_content] if proxy&.pulp3_enabled?
         services += [:katello_agent] if ::Katello.with_katello_agent?
         if proxy.nil? || proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE) || proxy.has_feature?(SmartProxy::PULP_FEATURE)
           services += [:pulp, :pulp_auth]
@@ -77,6 +77,12 @@ module Katello
         end
       end
 
+      def ping_pulp3_content_without_auth(service_result, capsule_id)
+        exception_watch(service_result) do
+          Katello::Ping.pulp3_content_without_auth(fetch_proxy(capsule_id).pulp3_url)
+        end
+      end
+
       def ping_pulp_without_auth(service_result, capsule_id)
         exception_watch(service_result) do
           Katello::Ping.pulp_without_auth(pulp_url(capsule_id))
@@ -195,10 +201,17 @@ module Katello
         end
 
         workers = json["online_workers"] || []
+        fail _("No pulpcore workers are running at %s.") % url if workers.empty?
 
-        unless workers.count > 1
-          fail _("Not all necessary pulp workers running at %s.") % url
-        end
+        json
+      end
+
+      def pulp3_content_without_auth(url)
+        json = backend_status(url, :pulp)
+        fail _("Pulp does not appear to be running at %s.") % url if json.empty?
+
+        content_apps = json["online_content_apps"] || []
+        fail _("No pulpcore content apps are running at %s.") % url if content_apps.empty?
 
         json
       end
@@ -220,12 +233,14 @@ module Katello
         end
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity
       def ping_services_for_capsule(services, capsule_id)
         services ||= self.services(capsule_id)
         result = {}
         services.each { |service| result[service] = {} }
 
         ping_pulp3_without_auth(result[:pulp3], capsule_id) if result.include?(:pulp3)
+        ping_pulp3_content_without_auth(result[:pulp3_content], capsule_id) if result.include?(:pulp3_content)
         ping_pulp_without_auth(result[:pulp], capsule_id) if result.include?(:pulp)
         ping_candlepin_without_auth(result[:candlepin]) if result.include?(:candlepin)
 
@@ -241,6 +256,7 @@ module Katello
         result[:status] = result[:services].each_value.any? { |v| v[:status] == FAIL_RETURN_CODE } ? FAIL_RETURN_CODE : OK_RETURN_CODE
         result
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       def fetch_proxy(capsule_id)
         capsule_id ? SmartProxy.unscoped.find(capsule_id) : SmartProxy.pulp_primary

data/app/models/katello/product.rb

@@ -106,7 +106,7 @@ module Katello
       !self.provider.redhat_provider? || self.repositories.present?
     end
 
-    delegate :library, to: :organization
+    delegate :cdn_configuration, :library, to: :organization
 
     def plan_name
       return sync_plan.name if sync_plan
@@ -214,10 +214,12 @@ module Katello
     end
 
     def cdn_resource
-      return unless (product_certificate = certificate)
-      certs = { :ssl_client_cert => OpenSSL::X509::Certificate.new(product_certificate),
-                :ssl_client_key => OpenSSL::PKey::RSA.new(key) }
-      ::Katello::Resources::CDN::CdnResource.new(provider.repository_url, certs)
+      return if self.certificate.nil?
+
+      @cdn_resource ||= ::Katello::Resources::CDN::CdnResource.create(
+        product: self,
+        cdn_configuration: self.organization.cdn_configuration
+      )
     end
 
     def total_package_count(env, view)

data/app/models/katello/provider.rb

@@ -21,22 +21,13 @@ module Katello
     validate :constraint_redhat_update
     validate :only_one_rhn_provider
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
-    validates_with Validators::KatelloUrlFormatValidator, :if => :redhat_provider?,
-                                                          :attributes => [:repository_url]
 
     before_destroy :prevent_redhat_deletion
-    before_validation :sanitize_repository_url
 
     scope :redhat, -> { where(:provider_type => REDHAT) }
     scope :custom, -> { where(:provider_type => CUSTOM) }
     scope :anonymous, -> { where(:provider_type => ANONYMOUS) }
 
-    def self.create_anonymous!(organization)
-      create!(:name => SecureRandom.uuid, :description => nil,
-              :organization => organization, :provider_type => ANONYMOUS,
-              :repository_url => nil)
-    end
-
     def only_one_rhn_provider
       # validate only when new record is added (skip explicit valid? calls)
       if new_record? && provider_type == REDHAT && count_providers(REDHAT) != 0
@@ -56,7 +47,7 @@ module Katello
 
     def constraint_redhat_update
       if !new_record? && redhat_provider?
-        allowed_changes = %w(repository_url task_status_id)
+        allowed_changes = %w(task_status_id)
         not_allowed_changes = changes.keys - allowed_changes
         unless not_allowed_changes.empty?
           errors.add(:base, _("the following attributes can not be updated for the Red Hat provider: [ %s ]") % not_allowed_changes.join(", "))
@@ -117,19 +108,5 @@ module Katello
     def related_resources
       self.organization
     end
-
-    protected
-
-    def sanitize_repository_url
-      sanitize_url(:repository_url, SETTINGS[:katello][:redhat_repository_url])
-    end
-
-    def sanitize_url(attrib, default_value)
-      if redhat_provider? && self.send(attrib).blank?
-        self.send("#{attrib}=", default_value)
-      end
-
-      self.send(attrib)&.strip!
-    end
   end
 end

data/app/models/katello/repository.rb

@@ -123,9 +123,9 @@ module Katello
     before_validation :set_container_repository_name, :if => :docker?
 
     scope :has_url, -> { joins(:root).where.not("#{RootRepository.table_name}.url" => nil) }
-    scope :on_demand, -> { joins(:root).where("#{RootRepository.table_name}.download_policy" => ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND) }
-    scope :immediate, -> { joins(:root).where("#{RootRepository.table_name}.download_policy" => ::Runcible::Models::YumImporter::DOWNLOAD_IMMEDIATE) }
-    scope :non_immediate, -> { joins(:root).where.not("#{RootRepository.table_name}.download_policy" => ::Runcible::Models::YumImporter::DOWNLOAD_IMMEDIATE) }
+    scope :on_demand, -> { joins(:root).where("#{RootRepository.table_name}.download_policy" => ::Katello::RootRepository::DOWNLOAD_ON_DEMAND) }
+    scope :immediate, -> { joins(:root).where("#{RootRepository.table_name}.download_policy" => ::Katello::RootRepository::DOWNLOAD_IMMEDIATE) }
+    scope :non_immediate, -> { joins(:root).where.not("#{RootRepository.table_name}.download_policy" => ::Katello::RootRepository::DOWNLOAD_IMMEDIATE) }
     scope :in_default_view, -> { joins(:content_view_version => :content_view).where("#{Katello::ContentView.table_name}.default" => true) }
     scope :in_non_default_view, -> { joins(:content_view_version => :content_view).where("#{Katello::ContentView.table_name}.default" => false) }
     scope :deb_type, -> { with_type(DEB_TYPE) }
@@ -148,6 +148,7 @@ module Katello
     end
     scope :redhat, -> { joins(:product => :provider).where("#{Provider.table_name}.provider_type": Provider::REDHAT) }
     scope :custom, -> { joins(:product => :provider).where.not("#{Provider.table_name}.provider_type": Provider::REDHAT) }
+    scope :library, -> { where(library_instance_id: nil) }
 
     scoped_search :on => :name, :relation => :root, :complete_value => true
     scoped_search :rename => :product, :on => :name, :relation => :product, :complete_value => true
@@ -190,6 +191,10 @@ module Katello
       joins(:root).where("#{RootRepository.table_name}.content_type" => content_type)
     end
 
+    def self.for_products(products)
+      joins(:root).where("#{Katello::RootRepository.table_name}.product_id" => products)
+    end
+
     def to_label
       name
     end
@@ -289,6 +294,10 @@ module Katello
       ::Katello::Resources::CDN::CdnResource.ca_file if ::Katello::Resources::CDN::CdnResource.redhat_cdn?(url)
     end
 
+    def using_mirrored_metadata?
+      self.yum? && self.library_instance? && self.mirror_on_sync
+    end
+
     def archive?
       self.environment.nil?
     end
@@ -298,11 +307,11 @@ module Katello
     end
 
     def on_demand?
-      root.download_policy == Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+      root.download_policy == ::Katello::RootRepository::DOWNLOAD_ON_DEMAND
     end
 
     def immediate?
-      root.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_IMMEDIATE
+      root.download_policy == ::Katello::RootRepository::DOWNLOAD_ON_IMMEDIATE
     end
 
     def yum_gpg_key_url
@@ -316,6 +325,26 @@ module Katello
       redhat? ? "redhat" : "custom"
     end
 
+    def content_counts
+      content_counts = {}
+      RepositoryTypeManager.defined_repository_types[content_type].content_types_to_index.each do |content_type|
+        if content_type&.model_class::CONTENT_TYPE == DockerTag::CONTENT_TYPE
+          content_counts[DockerTag::CONTENT_TYPE] = docker_tags.count
+        elsif content_type&.model_class::CONTENT_TYPE == GenericContentUnit::CONTENT_TYPE
+          content_counts[content_type.content_type] = content_type&.model_class&.in_repositories(self)&.where(:content_type => content_type.content_type)&.count
+        else
+          content_counts[content_type.label] = content_type&.model_class&.in_repositories(self)&.count
+        end
+      end
+
+      content_counts['module_stream'] = content_counts.delete('modulemd') if content_counts.key?('modulemd')
+      content_counts
+    end
+
+    def published_in_versions
+      Katello::ContentViewVersion.with_repositories(self.library_instances_inverse).distinct
+    end
+
     def self.errata_with_package_counts(repo)
       repository_rpm = Katello::RepositoryRpm.table_name
       repository_errata = Katello::RepositoryErratum.table_name
@@ -411,8 +440,6 @@ module Katello
       scheme = force_http ? 'http' : 'https'
       if docker?
         "#{pulp_uri.host.downcase}/#{container_repository_name}"
-      elsif ostree?
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/web/#{relative_path}"
       elsif ansible_collection?
         "#{scheme}://#{pulp_uri.host.downcase}/pulp_ansible/galaxy/#{relative_path}/api/"
       else
@@ -728,13 +755,13 @@ module Katello
     end
 
     # deleteable? is already taken by the authorization mixin
-    def destroyable?
+    def destroyable?(remove_from_content_view_versions = false)
       if self.environment.try(:library?) && self.content_view.default?
         if self.environment.organization.being_deleted?
           return true
-        elsif self.custom? && self.deletable?
+        elsif self.custom? && self.deletable?(remove_from_content_view_versions)
           return true
-        elsif !self.custom? && self.redhat_deletable?
+        elsif !self.custom? && self.redhat_deletable?(remove_from_content_view_versions)
           return true
         else
           errors.add(:base, _("Repository cannot be deleted since it has already been included in a published Content View. " \

data/app/models/katello/root_repository.rb

@@ -11,6 +11,10 @@ module Katello
 
     encrypts :upstream_password, :upstream_authentication_token
 
+    DOWNLOAD_IMMEDIATE = 'immediate'.freeze
+    DOWNLOAD_ON_DEMAND = 'on_demand'.freeze
+    DOWNLOAD_POLICIES = [DOWNLOAD_IMMEDIATE, DOWNLOAD_ON_DEMAND].freeze
+
     IGNORABLE_CONTENT_UNIT_TYPES = %w(srpm).freeze
     CHECKSUM_TYPES = %w(sha1 sha256).freeze
 
@@ -24,7 +28,7 @@ module Katello
     CONTENT_ATTRIBUTE_RESTRICTIONS = {
       :ostree_upstream_sync_depth => [Repository::OSTREE_TYPE],
       :ostree_upstream_sync_policy => [Repository::OSTREE_TYPE],
-      :download_policy => [Repository::YUM_TYPE]
+      :download_policy => [Repository::YUM_TYPE, Repository::DEB_TYPE]
 
     }.freeze
 
@@ -42,6 +46,8 @@ module Katello
     ALLOWED_OS_VERSIONS = [RHEL6, RHEL7, RHEL8].freeze
 
     belongs_to :product, :inverse_of => :root_repositories, :class_name => "Katello::Product"
+    has_one :provider, :through => :product
+
     belongs_to :gpg_key, :inverse_of => :root_repositories, :class_name => "Katello::ContentCredential"
     belongs_to :ssl_ca_cert, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_ca_root_repos
     belongs_to :ssl_client_cert, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_client_root_repos
@@ -66,7 +72,6 @@ module Katello
 
     validate :ensure_valid_docker_attributes, :if => :docker?
     validate :ensure_docker_repo_unprotected, :if => :docker?
-    validate :ensure_ostree_repo_protected, :if => :ostree?
     validate :ensure_compatible_download_policy, :if => :yum?
     validate :ensure_valid_collection_attributes, :if => :ansible_collection?
     validate :ensure_valid_auth_url_token, :if => :ansible_collection?
@@ -76,6 +81,7 @@ module Katello
     validate :ensure_content_attribute_restrictions
     validate :ensure_valid_upstream_authorization
     validate :ensure_valid_authentication_token, :if => :yum?
+    validate :ensure_valid_deb_constraints, :if => :deb?
     validate :ensure_no_checksum_on_demand
     validates :url, presence: true, if: :ostree?
     validates :checksum_type, :inclusion => {:in => CHECKSUM_TYPES}, :allow_blank => true
@@ -89,8 +95,8 @@ module Katello
       :message => ->(_, _) { _("is not enabled. must be one of the following: %s") % Katello::RepositoryTypeManager.enabled_repository_types.keys.join(', ') }
     }
     validates :download_policy, inclusion: {
-      :in => ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES,
-      :message => _("must be one of the following: %s") % ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES.join(', ')
+      :in => DOWNLOAD_POLICIES,
+      :message => _("must be one of the following: %s") % DOWNLOAD_POLICIES.join(', ')
     }, if: :yum?
     validates :http_proxy_policy, inclusion: {
       :in => HTTP_PROXY_POLICIES,
@@ -113,7 +119,9 @@ module Katello
       where(:http_proxy_id => http_proxy_id)
     }
     scope :orphaned, -> { where.not(id: Katello::Repository.pluck(:root_id).uniq) }
+    scope :redhat, -> { joins(:provider).merge(Katello::Provider.redhat) }
     delegate :redhat?, :provider, :organization, to: :product
+    delegate :cdn_configuration, to: :organization
 
     def library_instance
       repositories.in_default_view.first
@@ -145,7 +153,7 @@ module Katello
 
     def ensure_compatible_download_policy
       if !url.blank? && URI(url).scheme == 'file' &&
-          [::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND, ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND].include?(download_policy)
+          download_policy == ::Katello::RootRepository::DOWNLOAD_ON_DEMAND
         errors.add(:download_policy, _("Cannot sync file:// repositories with the On Demand Download Policy"))
       end
     end
@@ -175,17 +183,11 @@ module Katello
     end
 
     def ensure_no_checksum_on_demand
-      if checksum_type.present? && ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND == download_policy
+      if checksum_type.present? && download_policy == DOWNLOAD_ON_DEMAND
         errors.add(:checksum_type, _("Checksum type cannot be set for yum repositories with on demand download policy."))
       end
     end
 
-    def ensure_ostree_repo_protected
-      if unprotected
-        errors.add(:base, _("OSTree Repositories cannot be unprotected."))
-      end
-    end
-
     def ensure_valid_collection_attributes
       errors.add(:base, _("URL needs to have a trailing /")) if !url.blank? && url[-1] != '/'
       return unless ansible_collection_requirements
@@ -271,6 +273,9 @@ module Katello
       if self.upstream_username.blank? && self.upstream_password.blank?
         self.upstream_username = nil
         self.upstream_password = nil
+        if !self.url.blank? && self.url.start_with?('uln') && !self.content
+          errors.add(:base, N_("Upstream username and upstream password cannot be blank for ULN repositories"))
+        end
         return
       end
 
@@ -301,6 +306,15 @@ module Katello
       end
     end
 
+    def ensure_valid_deb_constraints
+      return if self.deb_releases.blank? && self.url.blank?
+      if self.deb_releases.blank?
+        errors.add(:base, N_("When \"Upstream URL\" is set, \"Releases/Distributions\" must also be set!"))
+      elsif self.url.blank? && !self.content
+        errors.add(:base, N_("When \"Releases/Distributions\" is set, \"Upstream URL\" must also be set!"))
+      end
+    end
+
     def custom_content_path
       parts = []
       # We generate repo path only for custom product content. We add this
@@ -353,7 +367,7 @@ module Katello
     end
 
     def on_demand?
-      self.download_policy == Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+      self.download_policy == DOWNLOAD_ON_DEMAND
     end
 
     def pulp_update_needed?
@@ -371,7 +385,7 @@ module Katello
     end
 
     def repo_mapper
-      Katello::Candlepin::RepositoryMapper.new(self.product, self.content, self.substitutions)
+      @repo_mapper ||= Katello::Candlepin::RepositoryMapper.new(self.product, self.content, self.substitutions)
     end
 
     def calculate_updated_name

data/app/models/setting/content.rb

@@ -9,15 +9,10 @@ class Setting::Content < Setting
     Hash[parameters.map { |p| [p, p] }]
   end
 
-  def self.deprecate_background(policies_hash)
-    policies_hash['background'] = 'background (deprecated)'
-    policies_hash
-  end
-
   def self.default_settings
-    download_policies = proc { deprecate_background(hashify_parameters(::Runcible::Models::YumImporter::DOWNLOAD_POLICIES)) }
+    download_policies = proc { hashify_parameters(::Katello::RootRepository::DOWNLOAD_POLICIES) }
 
-    proxy_download_policies = proc { deprecate_background(hashify_parameters(::SmartProxy::DOWNLOAD_POLICIES)) }
+    proxy_download_policies = proc { hashify_parameters(::SmartProxy::DOWNLOAD_POLICIES) }
     dependency_solving_options = proc { hashify_parameters(['conservative', 'greedy']) }
     cdn_ssl_versions = proc { hashify_parameters(Katello::Resources::CDN::SUPPORTED_SSL_VERSIONS) }
     http_proxy_select = [{
@@ -85,7 +80,7 @@ class Setting::Content < Setting
                false, N_('Disconnected mode')),
       self.set('errata_status_installable', N_("Calculate errata host status based only on errata in a Host's Content View and Lifecycle Environment"),
                false, N_('Installable errata from Content View')),
-      self.set('restrict_composite_view', N_("If set to true, a composite content view may not be published or "\
+      self.set('restrict_composite_view', N_("If this is enabled, a composite content view may not be published or "\
                "promoted, unless the component content view versions that it includes exist in the target environment."),
                false, N_('Restrict Composite Content View promotion')),
       self.set('check_services_before_actions', N_("Whether or not to check the status of backend services such as pulp and candlepin prior to performing some actions."),
@@ -94,11 +89,11 @@ class Setting::Content < Setting
                100, N_('Batch size to sync repositories in.')),
       self.set('foreman_proxy_content_auto_sync', N_("Whether or not to auto sync the Smart Proxies after a Content View promotion."),
                true, N_('Sync Smart Proxies after Content View promotion')),
-      self.set('default_download_policy', N_("Default download policy for custom repositories (either 'immediate', 'on_demand', or 'background')"), "immediate",
+      self.set('default_download_policy', N_("Default download policy for custom repositories (either 'immediate' or 'on_demand')"), "immediate",
                N_('Default Custom Repository download policy'), nil, :collection => download_policies),
-      self.set('default_redhat_download_policy', N_("Default download policy for enabled Red Hat repositories (either 'immediate', 'on_demand', or 'background')"), "on_demand",
+      self.set('default_redhat_download_policy', N_("Default download policy for enabled Red Hat repositories (either 'immediate' or 'on_demand')"), "on_demand",
                        N_('Default Red Hat Repository download policy'), nil, :collection => download_policies),
-      self.set('default_proxy_download_policy', N_("Default download policy for Smart Proxy syncs (either 'inherit', immediate', 'on_demand', or 'background')"), "on_demand",
+      self.set('default_proxy_download_policy', N_("Default download policy for Smart Proxy syncs (either 'inherit', immediate', or 'on_demand')"), "on_demand",
                N_('Default Smart Proxy download policy'), nil, :collection => proxy_download_policies),
       self.set('pulp_docker_registry_port', N_("The port used by Pulp Crane to provide Docker Registries"),
                5000, N_('Pulp Docker registry port')),
@@ -112,14 +107,14 @@ class Setting::Content < Setting
                "/etc/pki/katello/certs/pulp-client.crt", N_('Pulp client cert')),
       self.set('sync_connect_timeout', N_("Total timeout in seconds for connections when syncing"),
                300, N_('Sync Connection Timeout')),
-      self.set('remote_execution_by_default', N_("If set to true, use remote execution instead of katello-agent for remote actions"),
+      self.set('remote_execution_by_default', N_("If this is enabled, remote execution is used instead of katello-agent for remote actions"),
                false, N_('Use remote execution by default')),
       self.set('unregister_delete_host', N_("When unregistering a host via subscription-manager, also delete the host record. Managed resources linked to host " \
                                             "such as virtual machines and DNS records may also be deleted."),
                false, N_('Delete Host upon unregister')),
       self.set('register_hostname_fact', N_("When registering a host via subscription-manager, force use the specified fact (in the form of 'fact.fact')"),
                '', N_('Subscription manager name registration fact'), nil),
-      self.set('register_hostname_fact_strict_match', N_('If true, and register_hostname_fact is set and provided, registration will look for a new host by name only '\
+      self.set('register_hostname_fact_strict_match', N_('If this is enabled, and register_hostname_fact is set and provided, registration will look for a new host by name only '\
                 'using that fact, and will skip all hostname matching'), false, N_('Subscription manager name registration fact strict matching'), nil),
       self.set('default_location_subscribed_hosts',
                N_('Default Location where new subscribed hosts will put upon registration'),

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

@@ -22,6 +22,8 @@ module Katello
       def fetch_content_ids
         if self.content_unit_class == ::Katello::Erratum
           fetch_errata_content_ids
+        elsif self.content_unit_class == ::Katello::Deb
+          fetch_deb_content_ids
         elsif self.content_unit_class == ::Katello::ModuleStream
           fetch_module_stream_content_ids
         else
@@ -59,6 +61,24 @@ module Katello
         return Katello::ModuleStream.find_by_sql([query, { content_facet_id: content_facet.id, repo_ids: self.bound_library_instance_repos }]).map(&:id)
       end
 
+      def fetch_deb_content_ids
+        repo_deb = ::Katello::RepositoryDeb.arel_table
+        deb = ::Katello::Deb.arel_table
+        installed_deb = Katello::InstalledDeb.arel_table
+        host_installed_deb = Katello::HostInstalledDeb.arel_table
+        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(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))
+                     .distinct
+                     .project(deb[Arel.star])
+
+        ::Katello::Deb.find_by_sql(content.to_sql).pluck(:id)
+      end
+
       def fetch_rpm_content_ids
         enabled_module_stream_ids = fetch_enabled_module_stream_ids
 

data/app/services/katello/organization_creator.rb

@@ -36,6 +36,7 @@ module Katello
         create_content_view_environment
         create_anonymous_provider
         create_redhat_provider
+        create_cdn_configuration
       end
     end
 
@@ -116,5 +117,12 @@ module Katello
         organization: @organization
       ).first_or_create!
     end
+
+    def create_cdn_configuration
+      @cdn_configuration = Katello::CdnConfiguration.where(
+        organization: @organization,
+        url: ::Katello::Resources::CDN::CdnResource.redhat_cdn_url
+      ).first_or_create!
+    end
   end
 end