katello 4.2.2 → 4.3.0.rc1

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

@@ -31,6 +31,8 @@ module Katello
         has_many :subscriptions, :class_name => "Katello::Subscription", :dependent => :destroy, :inverse_of => :organization
         has_many :pools, :class_name => "Katello::Pool", :dependent => :destroy, :inverse_of => :organization
         has_many :product_contents, :through => :products
+        has_many :repositories, :through => :products
+        has_one :cdn_configuration, :class_name => "Katello::CdnConfiguration", :dependent => :destroy, :inverse_of => :organization
 
         #older association
         has_many :org_tasks, :dependent => :destroy, :class_name => "Katello::TaskStatus", :inverse_of => :organization
@@ -132,7 +134,7 @@ module Katello
         end
 
         def redhat_repository_url
-          redhat_provider.repository_url
+          cdn_configuration.url
         end
 
         def being_deleted?

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

@@ -150,10 +150,9 @@ module Katello
             service = service_class.new(model.pulp_id)
             service.backend_data = unit
             if repository&.generic?
-              service.update_model(model, repository.repository_type, generic_content_type)
-            else
-              service.update_model(model)
+              service.update_model(model, generic_content_type)
             end
+            service.update_model(model)
             ids_to_associate << model.pulp_id
           end
         end
@@ -186,11 +185,12 @@ module Katello
               service = service_class.new(model.pulp_id)
               service.backend_data = unit
               model.repository_id = repository.id unless many_repository_associations
+
               if repository.generic?
-                service.update_model(model, repository.repository_type, generic_content_type)
+                service.update_model(model, generic_content_type)
               elsif self == ::Katello::Erratum
                 # Errata will change pulp_hrefs if the upstream repo updates them
-                erratum_updated_ids << service.update_model(model, repository)
+                erratum_updated_ids << service.update_model(model)
               else
                 service.update_model(model)
               end
@@ -203,6 +203,7 @@ module Katello
 
       def sync_repository_associations(repository, options = {})
         additive = options.fetch(:additive, false)
+        generic_content_type = options.fetch(:generic_content_type, nil)
         pulp_id_href_map = options.dig(:pulp_id_href_map) || {}
         pulp_ids = options.dig(:pulp_ids) || pulp_id_href_map.try(:keys)
         ids_for_repository = with_pulp_id(pulp_ids).pluck(:id, :pulp_id)
@@ -213,7 +214,16 @@ module Katello
         erratum_updated_ids = options.fetch(:erratum_updated_ids, []).flatten.compact
 
         existing_ids = self.repository_association_class.uncached do
-          self.repository_association_class.where(:repository_id => repository).pluck(unit_id_field)
+          repo_assoc_units = self.repository_association_class.where(:repository_id => repository)
+
+          if generic_content_type
+            generic_unit_ids = Katello::GenericContentUnit
+              .where(id: repo_assoc_units.pluck(unit_id_field))
+              .where(content_type: generic_content_type).pluck(:id)
+            repo_assoc_units = repo_assoc_units.where(generic_content_unit_id: generic_unit_ids)
+          end
+
+          repo_assoc_units.pluck(unit_id_field)
         end
 
         new_ids = associated_ids - existing_ids

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

@@ -0,0 +1,9 @@
+module Katello
+  module Concerns
+    module RemoteExecutionProviderExtensions
+      def alternative_names(host)
+        super.merge(:consumer_uuid => host.subscription_facet&.uuid)
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Katello
       extend ActiveSupport::Concern
 
       included do
-        validates :value, inclusion: { in: ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES },
+        validates :value, inclusion: { in: ::Katello::RootRepository::DOWNLOAD_POLICIES },
           if: ->(setting) { setting.name == 'default_download_policy' }
 
         after_save :recalculate_errata_status

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

@@ -1,6 +1,7 @@
 require 'proxy_api'
 require 'proxy_api/pulp'
 require 'proxy_api/pulp_node'
+require 'proxy_api/container_gateway'
 
 module Katello
   module Concerns
@@ -21,7 +22,7 @@ module Katello
       CONTAINER_GATEWAY_FEATURE = "Container_Gateway".freeze
 
       DOWNLOAD_INHERIT = 'inherit'.freeze
-      DOWNLOAD_POLICIES = ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES + [DOWNLOAD_INHERIT]
+      DOWNLOAD_POLICIES = [::Katello::RootRepository::DOWNLOAD_ON_DEMAND, ::Katello::RootRepository::DOWNLOAD_IMMEDIATE, DOWNLOAD_INHERIT].freeze
 
       included do
         include ForemanTasks::Concerns::ActionSubject
@@ -128,7 +129,7 @@ module Katello
                            auth_required: !unauthenticated_container_repositories.include?(repo.id) }
           end
         end
-        ProxyAPI::ContainerGateway.new(url: self.url).repository_list({ repositories: repo_list })
+        ::ProxyAPI::ContainerGateway.new(url: self.url).repository_list({ repositories: repo_list })
       end
 
       def update_user_container_repo_mapping(users)
@@ -184,17 +185,17 @@ module Katello
         end
       end
 
-      def pulp3_ssl_configuration(config, connection_adapter = Faraday.default_adapter)
-        legacy_pulp_cert = !self.setting(PULP3_FEATURE, 'client_authentication')&.include?('client_certificate')
+      def pulp3_ssl_configuration(config)
+        legacy_pulp_cert = !self.setting(PULP3_FEATURE, 'client_authentication')&.include?('client_certificates')
 
-        if connection_adapter == :excon
+        if Faraday.default_adapter == :excon
           config.ssl_client_cert = ::Cert::Certs.ssl_client_cert_filename(use_admin_as_cn_cert: legacy_pulp_cert)
           config.ssl_client_key = ::Cert::Certs.ssl_client_key_filename(use_admin_as_cn_cert: legacy_pulp_cert)
-        elsif connection_adapter == :net_http
+        elsif Faraday.default_adapter == :net_http
           config.ssl_client_cert = ::Cert::Certs.ssl_client_cert(use_admin_as_cn_cert: legacy_pulp_cert)
           config.ssl_client_key = ::Cert::Certs.ssl_client_key(use_admin_as_cn_cert: legacy_pulp_cert)
         else
-          fail "Unexpected connection_adapter #{Faraday.default_adapter}!  Cannot continue, this is likely a bug."
+          fail "Unexpected faraday default_adapter #{Faraday.default_adapter}!  Cannot continue, this is likely a bug."
         end
       end
 
@@ -348,7 +349,7 @@ module Katello
       end
 
       def set_default_download_policy
-        self.download_policy ||= ::Setting[:default_proxy_download_policy] || ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+        self.download_policy ||= ::Setting[:default_proxy_download_policy] || ::Katello::RootRepository::DOWNLOAD_ON_DEMAND
       end
 
       def associate_lifecycle_environments

data/app/models/katello/content_credential.rb

@@ -13,6 +13,10 @@ module Katello
     has_many :repositories, :through => :root_repositories
 
     has_many :products, :class_name => "Katello::Product", :inverse_of => :gpg_key, :dependent => :nullify, :foreign_key => 'gpg_key_id'
+
+    has_many :ssl_ca_cdn_configurations, :class_name => "Katello::CdnConfiguration", :foreign_key => 'ssl_ca_credential_id',
+      :inverse_of => :ssl_ca_credential, :dependent => :nullify
+
     has_many :ssl_ca_products, :class_name => "Katello::Product", :foreign_key => "ssl_ca_cert_id",
                                :inverse_of => :ssl_ca_cert, :dependent => :nullify
     has_many :ssl_client_products, :class_name => "Katello::Product", :foreign_key => "ssl_client_cert_id",

data/app/models/katello/content_facet_applicable_deb.rb

@@ -0,0 +1,7 @@
+module Katello
+  class ContentFacetApplicableDeb < Katello::Model
+    # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
+    belongs_to :content_facet, :inverse_of => :content_facet_applicable_debs, :class_name => 'Katello::Host::ContentFacet'
+    belongs_to :deb, :inverse_of => :content_facet_applicable_debs, :class_name => 'Katello::Deb'
+  end
+end

data/app/models/katello/content_view.rb

@@ -108,7 +108,7 @@ module Katello
     end
 
     def self.in_organization(org)
-      where(organization_id: org.id)
+      where(organization_id: org.id) unless org.nil?
     end
 
     def to_s
@@ -641,6 +641,29 @@ module Katello
       repositories.on_demand
     end
 
+    def related_cv_count
+      if composite
+        content_view_components.length
+      else
+        component_composites.length
+      end
+    end
+
+    def related_composite_cvs
+      content_views = []
+      component_composites.each do |cv|
+        cv_id = cv.composite_content_view_id
+        cv_name = ContentView.find(cv_id).name
+        content_views.push(
+          {
+            id: cv_id,
+            name: cv_name
+          }
+        )
+      end
+      content_views
+    end
+
     protected
 
     def remove_repository(repository)

data/app/models/katello/content_view_component.rb

@@ -31,6 +31,10 @@ module Katello
       end
     end
 
+    def component_content_view_versions
+      self.content_view&.versions
+    end
+
     private
 
     def ensure_valid_content_view

data/app/models/katello/content_view_erratum_filter.rb

@@ -27,6 +27,8 @@ module Katello
     end
 
     def content_unit_pulp_ids(repo)
+      return [] if erratum_rules.blank?
+
       if filter_by_id?
         errata_ids = erratum_rules.map(&:errata_id)
         errata_pulp_ids = errata_package_pulp_ids_from_errata_ids(repo, errata_ids)

data/app/models/katello/content_view_filter.rb

@@ -35,7 +35,7 @@ module Katello
                                       Erratum::CONTENT_TYPE.to_sym => "Katello::ContentViewErratumFilter",
                                       DOCKER.to_sym => "Katello::ContentViewDockerFilter",
                                       MODULE_STREAM.to_sym => "Katello::ContentViewModuleStreamFilter"}
-    scoped_search :on => :inclusion, :rename => :inclusion_type, :complete_value => {:include => true, :exclude => :false}
+    scoped_search :on => :inclusion, :rename => :inclusion_type, :complete_value => {include: "true", exclude: "false"}
 
     def self.yum(include_module_streams = true)
       types = [::Katello::ContentViewPackageGroupFilter.name,

data/app/models/katello/content_view_package_filter_rule.rb

@@ -20,7 +20,8 @@ module Katello
                                :version => self.version,
                                :content_view_filter_id => self.content_view_filter_id,
                                :min_version => self.min_version,
-                               :max_version => self.max_version)
+                               :max_version => self.max_version,
+                               :architecture => self.architecture)
       other = other.where.not(:id => self.id) if self.id
       if other.exists?
         errors.add(:base, "This package filter rule already exists.")

data/app/models/katello/content_view_version.rb

@@ -1,4 +1,5 @@
 module Katello
+  # rubocop:disable Metrics/ClassLength
   class ContentViewVersion < Katello::Model
     include Authorization::ContentViewVersion
     include ForemanTasks::Concerns::ActionSubject
@@ -61,6 +62,10 @@ module Katello
       where("#{Katello::ContentViewVersion.table_name}.id in (#{sql})")
     end
 
+    scope :with_repositories, ->(repositories) do
+      joins(:repositories).includes(:content_view).merge(repositories).distinct
+    end
+
     scoped_search :on => :content_view_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
     scoped_search :on => :major, :rename => :version, :complete_value => true, :ext_method => :find_by_version
     serialize :content_counts
@@ -102,6 +107,10 @@ module Katello
       name
     end
 
+    def ansible_collections
+      AnsibleCollection.in_repositories(archived_repos)
+    end
+
     delegate :organization, to: :content_view
 
     def active_history
@@ -121,13 +130,17 @@ module Katello
     end
 
     def description
-      history.publish.successful.first.try(:notes)
+      history.publish.first.try(:notes)
     end
 
     def default_content_view?
       default?
     end
 
+    def latest?
+      content_view.latest_version_id == self.id
+    end
+
     def in_composite?
       composite_content_views.any?
     end
@@ -263,6 +276,14 @@ module Katello
       Katello::Deb.in_repositories(self.repositories.archived)
     end
 
+    def library_debs
+      Katello::Deb.in_repositories(library_repos)
+    end
+
+    def available_debs
+      library_packages.where.not(:id => debs)
+    end
+
     def errata(errata_type = nil)
       errata = Erratum.in_repositories(archived_repos)
       errata = errata.of_type(errata_type) if errata_type
@@ -323,6 +344,14 @@ module Katello
       save!
     end
 
+    def repository_type_counts_map
+      counts = {}
+      Katello::RepositoryTypeManager.enabled_repository_types.keys.each do |repo_type|
+        counts["#{repo_type}_repository_count"] = archived_repos.with_type(repo_type).count
+      end
+      counts
+    end
+
     def content_counts_map
       # if its empty, calculate it on demand
       update_content_counts! if content_counts.blank?

data/app/models/katello/deb.rb

@@ -3,6 +3,13 @@ module Katello
     include Concerns::PulpDatabaseUnit
 
     CONTENT_TYPE = Pulp::Deb::CONTENT_TYPE
+
+    has_many :repository_debs, :class_name => "Katello::RepositoryDeb", :dependent => :destroy, :inverse_of => :deb
+    has_many :repositories, :through => :repository_debs, :class_name => "Katello::Repository"
+    has_many :content_facet_applicable_debs, :class_name => "Katello::ContentFacetApplicableDeb",
+             :dependent => :destroy, :inverse_of => :deb
+    has_many :content_facets, :through => :content_facet_applicable_debs, :class_name => "Katello::Host::ContentFacet"
+
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :version, :complete_value => true
     scoped_search :on => :architecture, :complete_value => true
@@ -15,6 +22,14 @@ module Katello
       order(:name).order(:version).order(:architecture)
     end
 
+    def self.repository_association_class
+      RepositoryDeb
+    end
+
+    def self.content_facet_association_class
+      ContentFacetApplicableDeb
+    end
+
     def self.search_version_range(min = nil, max = nil)
       query = self.all
       query = Katello::Util::PackageFilter.new(query, min, Katello::Util::PackageFilter::GREATER_THAN).results if min
@@ -29,5 +44,61 @@ module Katello
     def self.total_for_repositories(repos)
       self.in_repositories(repos).count
     end
+
+    # the format apt needs to identify the packet with version and architecture
+    def nav
+      "#{self.name}:#{self.architecture}=#{self.version}"
+    end
+
+    # the more natural format ;-)
+    def nva
+      "#{self.name}_#{self.version}_#{self.architecture}"
+    end
+
+    def self.split_nav(value)
+      v = /^(?<name>[^:\s]+)(:(?<architecture>[^=\s]*))?(=(?<version>.*))?$/.match(value)&.named_captures
+      if v
+        [ v['name'], v['architecture'], v['version'] ]
+      end
+    end
+
+    def hosts_applicable(org_id = nil)
+      if org_id.present?
+        self.content_facets.joins(:host).where("#{::Host.table_name}.organization_id" => org_id)
+      else
+        self.content_facets.joins(:host)
+      end
+    end
+
+    def hosts_available(org_id = nil)
+      self.hosts_applicable(org_id).joins("INNER JOIN #{Katello::RepositoryDeb.table_name} on \
+        #{Katello::RepositoryDeb.table_name}.deb_id = #{self.id}").joins(:content_facet_repositories).
+        where("#{Katello::ContentFacetRepository.table_name}.repository_id = #{Katello::RepositoryDeb.table_name}.repository_id").uniq
+    end
+
+    def self.installable_for_hosts(hosts = nil)
+      debs = Katello::Deb.joins(:repositories,
+                                "INNER JOIN #{Katello::InstalledDeb.table_name} ON #{Katello::InstalledDeb.table_name}.name = #{self.table_name}.name",
+                                "INNER JOIN #{Katello::HostInstalledDeb.table_name} ON #{Katello::HostInstalledDeb.table_name}.installed_deb_id = #{Katello::InstalledDeb.table_name}.id")
+                               .where("deb_version_cmp(#{self.table_name}.version, #{Katello::InstalledDeb.table_name}.version) > 0")
+      unless hosts.nil?
+        facet_repos = Katello::ContentFacetRepository.joins(:content_facet => :host).select(:repository_id)
+        hosts = ::Host.where(id: hosts) if hosts.is_a?(Array)
+        facet_repos = facet_repos.merge(hosts).reorder(nil)
+
+        debs = debs.where("#{Katello::HostInstalledDeb.table_name}.host_id": hosts.pluck(:id))
+                   .where("#{Katello::RepositoryDeb.table_name}.repository_id" => facet_repos)
+      end
+      debs.distinct
+    end
+
+    def self.applicable_to_hosts(hosts)
+      self.joins(:content_facets).
+        where("#{Katello::Host::ContentFacet.table_name}.host_id" => hosts).distinct
+    end
+
+    def self.latest(_relation)
+      fail 'NotImplemented'
+    end
   end
 end

data/app/models/katello/erratum.rb

@@ -5,8 +5,15 @@ module Katello
     SECURITY = ["security"].freeze
     BUGZILLA = ["bugfix", "recommended"].freeze
     ENHANCEMENT = ["enhancement", "optional"].freeze
-
     TYPES = [SECURITY, BUGZILLA, ENHANCEMENT].flatten.freeze
+
+    NONE = "None".freeze
+    LOW = "Low".freeze
+    MODERATE = "Moderate".freeze
+    IMPORTANT = "Important".freeze
+    CRITICAL = "Critical".freeze
+    SEVERITIES = [NONE, LOW, MODERATE, IMPORTANT, CRITICAL].freeze
+
     CONTENT_TYPE = "erratum".freeze
     BACKEND_IDENTIFIER_FIELD = "erratum_pulp3_href".freeze
 
@@ -20,6 +27,7 @@ module Katello
     scoped_search :on => :errata_id, :only_explicit => true
     scoped_search :on => :errata_id, :rename => :id, :complete_value => true, :only_explicit => true
     scoped_search :on => :title
+    scoped_search :on => :title, :rename => :synopsis, :complete_value => true, :only_explicit => true
     scoped_search :on => :severity, :complete_value => true
     scoped_search :on => :errata_type, :only_explicit => true
     scoped_search :on => :errata_type, :rename => :type, :complete_value => true
@@ -170,6 +178,10 @@ module Katello
       { :conditions => conditions }
     end
 
+    def content_view_filters
+      Katello::ContentViewErratumFilterRule.where(errata_id: self.errata_id).eager_load(:filter).map(&:filter)
+    end
+
     apipie :class, desc: "A class representing #{model_name.human} object" do
       name 'Erratum'
       refs 'Erratum'

data/app/models/katello/generic_content_unit.rb

@@ -5,8 +5,10 @@ module Katello
 
     CONTENT_TYPE = 'generic'.freeze
 
-    scoped_search :on => :name, :complete_value => true
     scoped_search :on => :id, :complete_value => true
+    scoped_search :on => :name, :complete_value => true
+    scoped_search :on => :version, :complete_value => true
+    scoped_search :on => :filename, :complete_value => true
 
     def self.default_sort
       order(:name)

data/app/models/katello/glue/pulp/repos.rb

@@ -42,7 +42,7 @@ module Katello
       def sync_status
         all_repos = repos(self.library, nil, false)
         task = last_repo_sync_task
-        last_synced_repo = task ? all_repos.find { |repo| task.locks.where(:resource_type => ::Katello::Repository.name).pluck(:resource_id).map(&:to_s).include?(repo.id.to_s) } : nil
+        last_synced_repo = task ? all_repos.find { |repo| task.links.where(:resource_type => ::Katello::Repository.name).pluck(:resource_id).map(&:to_s).include?(repo.id.to_s) } : nil
         ::Katello::SyncStatusPresenter.new(last_synced_repo, task).sync_progress
       end
 
@@ -124,7 +124,7 @@ module Katello
           content_url.dup
         else
           path = content_url.sub(%r{^/}, '')
-          repo_url = self.provider.repository_url&.sub(%r{/$}, '')
+          repo_url = cdn_configuration.url.sub(%r{/$}, '')
           "#{repo_url}/#{path}"
         end
       end

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)