katello 4.11.1 → 4.12.0.rc1

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

@@ -3,7 +3,7 @@ module Actions
     module Orchestration
       module ContentViewVersion
         class Import < Actions::EntryAction
-          def plan(content_view_version, path:, metadata:)
+          def plan(content_view_version, opts = {})
             action_subject(content_view_version)
             sequence do
               smart_proxy = SmartProxy.pulp_primary!
@@ -11,8 +11,8 @@ module Actions
                 ::Actions::Pulp3::ContentViewVersion::CreateImporter,
                 content_view_version_id: content_view_version.id,
                 smart_proxy_id: smart_proxy.id,
-                path: path,
-                metadata: metadata
+                path: opts[:path],
+                metadata: opts[:metadata]
               ).output
 
               plan_action(
@@ -20,8 +20,8 @@ module Actions
                 organization_id: content_view_version.content_view.organization_id,
                 smart_proxy_id: smart_proxy.id,
                 importer_data: importer_output[:importer_data],
-                path: path,
-                metadata: metadata
+                path: opts[:path],
+                metadata: opts[:metadata]
               )
               concurrence do
                 content_view_version.importable_repositories.each do |repo|
@@ -31,20 +31,20 @@ module Actions
               plan_action(
                 ::Actions::Pulp3::ContentViewVersion::CreateImportHistory,
                 content_view_version_id: content_view_version.id,
-                path: path,
-                metadata: metadata,
+                path: opts[:path],
+                metadata: opts[:metadata],
                 content_view_name: content_view_version.name
               )
               plan_action(::Actions::Pulp3::ContentViewVersion::DestroyImporter,
                             organization_id: content_view_version.content_view.organization_id,
                             smart_proxy_id: smart_proxy.id,
-                            path: path,
-                            metadata: metadata,
+                            path: opts[:path],
+                            metadata: opts[:metadata],
                             importer_data: importer_output[:importer_data])
               plan_self(
                 content_view_name: content_view_version.name,
-                metadata: metadata,
-                path: path,
+                metadata: opts[:metadata],
+                path: opts[:path],
                 content_view_version_id: content_view_version.id
               )
             end

data/app/lib/actions/pulp3/orchestration/repository/upload_content.rb

@@ -6,22 +6,27 @@ module Actions
           include Actions::Helpers::OutputPropagator
           def plan(repository, smart_proxy, file, unit_type_id)
             sequence do
-              checksum = Digest::SHA256.hexdigest(File.read(file[:path]))
-              duplicate_sha_path_content_list = ::Katello::Pulp3::PulpContentUnit.find_duplicate_unit(repository, unit_type_id, file, checksum)
-              duplicate_content_href = duplicate_sha_path_content_list&.results&.first&.pulp_href
+              if repository.deb?
+                upload_action_output = plan_action(Pulp3::Repository::UploadFile, repository, smart_proxy, file[:path]).output
+                artifact_action_output = plan_action(Pulp3::Repository::SaveArtifact, file, repository, smart_proxy, upload_action_output[:pulp_tasks], unit_type_id).output
+              else
+                checksum = Digest::SHA256.hexdigest(File.read(file[:path]))
+                duplicate_sha_path_content_list = ::Katello::Pulp3::PulpContentUnit.find_duplicate_unit(repository, unit_type_id, file, checksum)
+                duplicate_content_href = duplicate_sha_path_content_list&.results&.first&.pulp_href
 
-              unless duplicate_content_href
-                duplicate_sha_artifact_list = ::Katello::Pulp3::Api::Core.new(smart_proxy).artifacts_api.list("sha256": Digest::SHA256.hexdigest(File.read(file[:path])))
-                duplicate_sha_artifact_href = duplicate_sha_artifact_list&.results&.first&.pulp_href
-                if duplicate_sha_artifact_href
-                  artifact_action_output = plan_action(Pulp3::Repository::SaveArtifact, file, repository, smart_proxy, nil, unit_type_id, artifact_href: duplicate_sha_artifact_href).output
-                else
-                  upload_action_output = plan_action(Pulp3::Repository::UploadFile, repository, smart_proxy, file[:path]).output
-                  artifact_action_output = plan_action(Pulp3::Repository::SaveArtifact, file, repository, smart_proxy, upload_action_output[:pulp_tasks], unit_type_id).output
+                unless duplicate_content_href
+                  duplicate_sha_artifact_list = ::Katello::Pulp3::Api::Core.new(smart_proxy).artifacts_api.list("sha256": Digest::SHA256.hexdigest(File.read(file[:path])))
+                  duplicate_sha_artifact_href = duplicate_sha_artifact_list&.results&.first&.pulp_href
+                  if duplicate_sha_artifact_href
+                    artifact_action_output = plan_action(Pulp3::Repository::SaveArtifact, file, repository, smart_proxy, nil, unit_type_id, artifact_href: duplicate_sha_artifact_href).output
+                  else
+                    upload_action_output = plan_action(Pulp3::Repository::UploadFile, repository, smart_proxy, file[:path]).output
+                    artifact_action_output = plan_action(Pulp3::Repository::SaveArtifact, file, repository, smart_proxy, upload_action_output[:pulp_tasks], unit_type_id).output
+                  end
                 end
-
+                artifact_action_output ||= {:content_unit_href => duplicate_content_href}
               end
-              artifact_action_output ||= {:content_unit_href => duplicate_content_href}
+
               action_output = plan_action(Pulp3::Repository::ImportUpload, artifact_action_output, repository, smart_proxy).output
               plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks]).output
               plan_self(:subaction_output => action_output)

data/app/lib/actions/pulp3/repository/import_upload.rb

@@ -12,17 +12,25 @@ module Actions
         end
 
         def invoke_external_task
+          repo = ::Katello::Repository.find(input[:repository_id])
+          repo_backend_service = repo.backend_service(smart_proxy)
+
           if input[:save_artifact_output][:pulp_tasks]&.any?
-            content_unit_href = input[:save_artifact_output][:pulp_tasks].last[:created_resources].first
+            if repo.deb?
+              content_unit_href = input[:save_artifact_output][:pulp_tasks].last[:created_resources].find { |href| href.include?("/deb/packages") }
+            else
+              content_unit_href = input[:save_artifact_output][:pulp_tasks].last[:created_resources].first
+            end
           else
             content_unit_href = input[:save_artifact_output][:content_unit_href]
           end
 
-          repo = ::Katello::Repository.find(input[:repository_id])
-          repo_backend_service = repo.backend_service(smart_proxy)
-
           output[:content_unit_href] = content_unit_href
-          output[:pulp_tasks] = [repo_backend_service.add_content(content_unit_href)]
+          if repo.deb?
+            output[:pulp_tasks] = input[:save_artifact_output][:pulp_tasks]
+          else
+            output[:pulp_tasks] = [repo_backend_service.add_content(content_unit_href)]
+          end
         end
       end
     end

data/app/lib/actions/pulp3/repository/save_artifact.rb

@@ -16,20 +16,31 @@ module Actions
           content_type = input[:unit_type_id]
           content_backend_service = SmartProxy.pulp_primary.content_service(content_type)
 
-          existing_content = ::Katello::Pulp3::PulpContentUnit.find_duplicate_unit(repository, input[:unit_type_id], {filename: input[:options][:file_name]}, input[:options][:sha256])
-          existing_content_href = existing_content&.results&.first&.pulp_href
-
-          if ::Katello::RepositoryTypeManager.find_content_type(input[:unit_type_id]).repository_import_on_upload
-            output[:pulp_tasks] = [repository.backend_service(smart_proxy).repository_import_content(artifact_href, input[:options])]
+          if repository.deb?
+            repo_url = repository.backend_service(smart_proxy).repository_reference.repository_href
+            output[:pulp_tasks] = [content_backend_service.content_api_create(relative_path: input[:options][:file_name],
+                                                                              repository: repo_url,
+                                                                              repository_id: repository.id,
+                                                                              distribution: "katello",
+                                                                              component: "upload",
+                                                                              artifact: artifact_href,
+                                                                              content_type: content_type)]
           else
-            if existing_content_href
-              output[:content_unit_href] = existing_content_href
-              []
+            existing_content = ::Katello::Pulp3::PulpContentUnit.find_duplicate_unit(repository, input[:unit_type_id], {filename: input[:options][:file_name]}, input[:options][:sha256])
+            existing_content_href = existing_content&.results&.first&.pulp_href
+
+            if ::Katello::RepositoryTypeManager.find_content_type(input[:unit_type_id]).repository_import_on_upload
+              output[:pulp_tasks] = [repository.backend_service(smart_proxy).repository_import_content(artifact_href, input[:options])]
             else
-              output[:pulp_tasks] = [content_backend_service.content_api_create(relative_path: input[:options][:file_name],
-                                                                                repository_id: repository.id,
-                                                                                artifact: artifact_href,
-                                                                                content_type: content_type)]
+              if existing_content_href
+                output[:content_unit_href] = existing_content_href
+                []
+              else
+                output[:pulp_tasks] = [content_backend_service.content_api_create(relative_path: input[:options][:file_name],
+                                                                                  repository_id: repository.id,
+                                                                                  artifact: artifact_href,
+                                                                                  content_type: content_type)]
+              end
             end
           end
         end

data/app/lib/katello/api/v2/error_handling.rb

@@ -75,7 +75,7 @@ module Katello
         end
 
         def rescue_from_unsupported_action_exception(exception)
-          respond_for_exception(exception, :status => :bad_request)
+          respond_for_exception(exception, :status => :bad_request, :force_json => true)
         end
 
         def rescue_from_bad_data(exception)

data/app/lib/katello/lazy_accessor.rb

@@ -56,21 +56,21 @@ module Katello
         @changed_remote_attributes = val
       end
 
-      def save(*)
-        if (status = super)
+      def save(...)
+        if (status = super(...))
           changed_remote_attributes.clear
         end
         status
       end
 
-      def save!(*)
-        super.tap do
+      def save!(...)
+        super(...).tap do
           changed_remote_attributes.clear
         end
       end
 
-      def reload(*)
-        super.tap do
+      def reload(...)
+        super(...).tap do
           changed_remote_attributes.clear
         end
       end

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

@@ -18,7 +18,7 @@ module Katello
               :displayName => description,
               :contentPrefix => "/#{key}/$env",
               :contentAccessMode => content_access_mode,
-              :contentAccessModeList => ['entitlement', 'org_environment'].join(',')
+              :contentAccessModeList => 'org_environment'
             }
             owner_json = self.post(path, attrs.to_json, self.default_headers).body
             JSON.parse(owner_json).with_indifferent_access
@@ -42,7 +42,7 @@ module Katello
           def update(key, attrs)
             owner = find(key)
             owner.merge!(attrs)
-            owner.merge!(:contentAccessModeList => ['entitlement', 'org_environment'].join(','))
+            owner.merge!(:contentAccessModeList => 'org_environment')
             self.put(path(key), JSON.generate(owner), self.default_headers).body
           end
 

data/app/mailers/katello/errata_mailer.rb

@@ -50,9 +50,9 @@ module Katello
 
     def errata_counts(errata)
       counts = {:total => errata.count}
-      counts.merge(Hash[[:security, :bugfix, :enhancement].collect do |errata_type|
-        [errata_type, errata.send(errata_type).count]
-      end])
+      counts.merge([:security, :bugfix, :enhancement].index_with do |errata_type|
+        errata.send(errata_type).count
+      end)
     end
   end
 end

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

@@ -48,28 +48,6 @@ module Katello
           inherited_attrs
         end
 
-        def apply_inherited_attributes(attributes, initialized = true)
-          attributes = super(attributes, initialized) || {}
-          facet_attrs = attributes&.[]('content_facet_attributes')
-          return attributes if facet_attrs.blank?
-          cv_id = facet_attrs['content_view_id']
-          lce_id = facet_attrs['lifecycle_environment_id']
-          if initialized && (cv_id.blank? || lce_id.blank?)
-            if cv_id.blank?
-              Rails.logger.info "Hostgroup has no content view assigned; using host's existing content view"
-              facet_attrs['content_view_id'] = content_facet&.single_content_view&.id
-            end
-            if lce_id.blank?
-              Rails.logger.info "Hostgroup has no lifecycle environment assigned; using host's existing lifecycle environment"
-              facet_attrs['lifecycle_environment_id'] = content_facet&.single_lifecycle_environment&.id
-            end
-            attributes['content_facet_attributes'] = facet_attrs
-          else
-            Rails.logger.debug "Hostgroup has content view and lifecycle environment assigned; using those"
-          end
-          attributes
-        end
-
         def smart_proxy_ids
           ids = super
           ids << content_source_id
@@ -168,6 +146,8 @@ module Katello
 
         scoped_search relation: :pools, on: :pools_expiring_in_days, ext_method: :find_with_expiring_pools, only_explicit: true
 
+        smart_proxy_reference :content_facet => [:content_source_id]
+
         def add_back_cve_errors
           if @pending_cve_attrs&.[](:content_view_id).present? || @pending_cve_attrs&.[](:lifecycle_environment_id).present?
             check_cve_attributes({ content_facet_attributes: @pending_cve_attrs })
@@ -430,18 +410,6 @@ module Katello
         update_trace_status
       end
 
-      def subscription_status
-        @subscription_status ||= get_status(::Katello::SubscriptionStatus).status
-      end
-
-      def subscription_status_label(options = {})
-        @subscription_status_label ||= get_status(::Katello::SubscriptionStatus).to_label(options)
-      end
-
-      def subscription_global_status
-        @subscription_global_status ||= get_status(::Katello::SubscriptionStatus).to_global
-      end
-
       def errata_status
         @errata_status ||= get_status(::Katello::ErrataStatus).status
       end
@@ -450,46 +418,6 @@ module Katello
         @errata_status_label ||= get_status(::Katello::ErrataStatus).to_label(options)
       end
 
-      def purpose_status
-        @purpose_status ||= get_status(::Katello::PurposeStatus).status
-      end
-
-      def purpose_status_label(options = {})
-        @purpose_status_label ||= get_status(::Katello::PurposeStatus).to_label(options)
-      end
-
-      def purpose_sla_status
-        @purpose_sla_status ||= get_status(::Katello::PurposeSlaStatus).status
-      end
-
-      def purpose_sla_status_label(options = {})
-        @purpose_sla_status_label ||= get_status(::Katello::PurposeSlaStatus).to_label(options)
-      end
-
-      def purpose_role_status
-        @purpose_role_status ||= get_status(::Katello::PurposeRoleStatus).status
-      end
-
-      def purpose_role_status_label(options = {})
-        @purpose_role_status_label ||= get_status(::Katello::PurposeRoleStatus).to_label(options)
-      end
-
-      def purpose_usage_status
-        @purpose_usage_status ||= get_status(::Katello::PurposeUsageStatus).status
-      end
-
-      def purpose_usage_status_label(options = {})
-        @purpose_usage_status_label ||= get_status(::Katello::PurposeUsageStatus).to_label(options)
-      end
-
-      def purpose_addons_status
-        @purpose_addons_status ||= get_status(::Katello::PurposeAddonsStatus).status
-      end
-
-      def purpose_addons_status_label(options = {})
-        @purpose_addons_status_label ||= get_status(::Katello::PurposeAddonsStatus).to_label(options)
-      end
-
       def rhel_lifecycle_global_status
         @rhel_lifecycle_global_status ||= get_status(::Katello::RhelLifecycleStatus).to_global
       end
@@ -541,6 +469,14 @@ module Katello
       end
 
       def package_names_for_job_template(action:, search:, versions: nil)
+        if self.operatingsystem.family == 'Debian'
+          deb_names_for_job_template(action: action, search: search)
+        else
+          yum_names_for_job_template(action: action, search: search, versions: versions)
+        end
+      end
+
+      def yum_names_for_job_template(action:, search:, versions: nil)
         actions = %w(install remove update).freeze
         case action
         when 'install'
@@ -567,6 +503,24 @@ module Katello
         end
       end
 
+      def deb_names_for_job_template(action:, search:)
+        actions = %w(install remove update).freeze
+        case action
+        when 'install'
+          ::Katello::Deb.apt_installable_for_host(self).search_for(search).distinct.pluck(:name)
+        when 'remove'
+          return [] if search.empty?
+
+          installed_debs.search_for(search).distinct.pluck(:name)
+        when 'update'
+          return [] if search.empty?
+
+          installed_debs.search_for(search).distinct.pluck(:name)
+        else
+          fail ::Foreman::Exception.new(N_("deb_names_for_job_template: Action must be one of %s"), actions.join(', '))
+        end
+      end
+
       def advisory_ids(search:)
         ::Katello::Erratum.installable_for_hosts([self]).search_for(search).pluck(:errata_id)
       end
@@ -596,8 +550,7 @@ class ::Host::Managed::Jail < Safemode::Jail
         :host_collections, :pools, :hypervisor_host, :installed_debs,
         :installed_packages, :traces_helpers, :advisory_ids, :package_names_for_job_template,
         :filtered_entitlement_quantity_consumed, :bound_repositories,
-        :single_content_view, :single_lifecycle_environment, :purpose_role, :purpose_usage, :release_version,
-        :purpose_role_status_label, :purpose_usage_status_label
+        :single_content_view, :single_lifecycle_environment, :release_version
 end
 
 class ActiveRecord::Associations::CollectionProxy::Jail < Safemode::Jail

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

@@ -122,8 +122,10 @@ module Katello
           # it will return the value 2.
           facet_model = Facets.registered_facets[facet].hostgroup_configuration.model
           value = facet_model.where.not(attribute => nil).joins(:hostgroup).merge(
-            ::Hostgroup.where(id: self.ancestor_ids).reorder(ancestry: :desc)
-          ).limit(1).pluck(attribute).first
+            ::Hostgroup.where(id: self.ancestor_ids).reorder(
+              "#{::Hostgroup.table_name}.ancestry desc nulls last"
+            )
+          ).pick(attribute)
         end
         value
       end

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

@@ -79,7 +79,7 @@ module Katello
         end
 
         def redhat_account_number
-          pools.upstream.pluck(:account_number).first
+          pools.upstream.pick(:account_number)
         end
 
         def active_pools_count

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

@@ -169,7 +169,7 @@ module Katello
 
       def orphaned
         if many_repository_associations
-          where.not(:id => repository_association_class.select(unit_id_field))
+          left_joins(repository_association.to_sym).where("#{repository_association_class.table_name}.#{unit_id_field}" => nil)
         else
           where.not(:repository_id => ::Katello::Repository.select(:id))
         end

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

@@ -10,38 +10,15 @@ module Katello
       included do
         audited :associations => [:pools]
 
-        SUBSCRIPTION_STATUS_MAP = {
-          :valid => Katello::SubscriptionStatus::VALID,
-          :partial => Katello::SubscriptionStatus::PARTIAL,
-          :invalid => Katello::SubscriptionStatus::INVALID,
-          :unknown => Katello::SubscriptionStatus::UNKNOWN,
-          :disabled => Katello::SubscriptionStatus::DISABLED,
-          :unsubscribed_hypervisor => Katello::SubscriptionStatus::UNSUBSCRIBED_HYPERVISOR
-        }.freeze
-
         accepts_nested_attributes_for :subscription_facet, :update_only => true, :reject_if => lambda { |attrs| attrs.values.compact.empty? }
 
         has_many :activation_keys, :through => :subscription_facet
         has_many :pools, :through => :subscription_facet
         has_many :purpose_addons, :through => :subscription_facet
         has_many :subscriptions, :through => :pools
-        has_one :subscription_status_object, :class_name => 'Katello::SubscriptionStatus', :foreign_key => 'host_id', :dependent => :destroy
-        has_one :purpose_sla_status_object, :class_name => 'Katello::PurposeSlaStatus', :foreign_key => 'host_id', :dependent => :destroy
-        has_one :purpose_role_status_object, :class_name => 'Katello::PurposeRoleStatus', :foreign_key => 'host_id', :dependent => :destroy
-        has_one :purpose_usage_status_object, :class_name => 'Katello::PurposeUsageStatus', :foreign_key => 'host_id', :dependent => :destroy
-        has_one :purpose_addons_status_object, :class_name => 'Katello::PurposeAddonsStatus', :foreign_key => 'host_id', :dependent => :destroy
-        has_one :purpose_status_object, :class_name => 'Katello::PurposeStatus', :foreign_key => 'host_id', :dependent => :destroy
         has_one :rhel_lifecycle_status_object, :class_name => 'Katello::RhelLifecycleStatus', :foreign_key => 'host_id', :dependent => :destroy
         has_one :hypervisor_host, :through => :subscription_facet
 
-        scoped_search :on => :status, :relation => :subscription_status_object, :rename => :subscription_status,
-                      :complete_value => SUBSCRIPTION_STATUS_MAP
-
-        scoped_search on: :status, relation: :purpose_sla_status_object, rename: :sla_status, complete_value: purpose_status_map
-        scoped_search on: :status, relation: :purpose_role_status_object, rename: :role_status, complete_value: purpose_status_map
-        scoped_search on: :status, relation: :purpose_usage_status_object, rename: :usage_status, complete_value: purpose_status_map
-        scoped_search on: :status, relation: :purpose_addons_status_object, rename: :addons_status, complete_value: purpose_status_map
-        scoped_search on: :status, relation: :purpose_status_object, rename: :purpose_status, complete_value: purpose_status_map
         scoped_search on: :status, relation: :rhel_lifecycle_status_object, rename: :rhel_lifecycle_status, complete_value: rhel_lifecycle_status_map
 
         scoped_search :on => :release_version, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
@@ -98,10 +75,6 @@ module Katello
       end
 
       module ClassMethods
-        def purpose_status_map
-          ::Katello::PurposeStatus.status_map
-        end
-
         def rhel_lifecycle_status_map
           ::Katello::RhelLifecycleStatus.status_map
         end

data/app/models/katello/content_view.rb

@@ -18,6 +18,7 @@ module Katello
 
     has_many :content_view_versions, :class_name => "Katello::ContentViewVersion", :dependent => :destroy
     alias_method :versions, :content_view_versions
+    has_one :latest_version_object, -> { latest }, :class_name => "Katello::ContentViewVersion", :dependent => :destroy
     # Note the difference between content_view_components and component_composites both refer to
     # ContentViewComponent but mean different things.
     # content_view_components -> Topdown, given I am a composite CV get the associated components belonging to me
@@ -188,7 +189,7 @@ module Katello
     end
 
     def content_host_count
-      hosts.count
+      hosts.size
     end
 
     def component_ids
@@ -341,10 +342,6 @@ module Katello
       latest_version_object.try(:environments) || []
     end
 
-    def latest_version_object
-      self.versions.order('major DESC').order('minor DESC').first
-    end
-
     def last_task
       last_task_id = history.order(:created_at)&.last&.task_id
       last_task_id ? ForemanTasks::Task.find_by(id: last_task_id) : nil
@@ -611,6 +608,14 @@ module Katello
                                            :components => components
       )
 
+      # TODO: If a controller creates a new version and then uses latest_version_object, the old data is displayed.
+      #       To prevent this, a 'reload' would currently be necessary, but this is not very performant.
+      #       However, this is currently not a problem because after your create_new_version there is no immediate
+      #       access to latest_version_object, but the ContentView object is first completely reloaded.
+      #
+      #       In Rails 7.1, individual connections can be reloaded:
+      #       https://www.shakacode.com/blog/rails-7-1-allows-resetting-singular-associations/
+
       update(:next_version => major.to_i + 1) unless major.to_i < next_version
       version
     end
@@ -735,7 +740,7 @@ module Katello
     end
 
     def version_count
-      content_view_versions.count
+      content_view_versions.size
     end
 
     def on_demand_repositories

data/app/models/katello/content_view_version.rb

@@ -66,6 +66,8 @@ module Katello
       joins(:repositories).includes(:content_view).merge(repositories).distinct
     end
 
+    scope :latest, -> { order('major DESC', 'minor DESC').limit(1) }
+
     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

data/app/models/katello/deb.rb

@@ -10,6 +10,7 @@ module Katello
              :dependent => :destroy, :inverse_of => :deb
     has_many :content_facets, :through => :content_facet_applicable_debs, :class_name => "Katello::Host::ContentFacet"
 
+    scoped_search :on => :id, :complete_value => true
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :version, :complete_value => true
     scoped_search :on => :architecture, :complete_value => true
@@ -95,6 +96,13 @@ module Katello
         where("#{Katello::Host::ContentFacet.table_name}.host_id" => hosts).distinct
     end
 
+    # Return deb packages that are not installed on a host, but could be installed
+    # the word 'installable' has a different meaning here than elsewhere
+    def self.apt_installable_for_host(host)
+      repos = host.content_facet.bound_repositories.pluck(:id)
+      Katello::Deb.in_repositories(repos).where.not(name: host.installed_debs.pluck(:name)).order(:name)
+    end
+
     def self.latest(_relation)
       fail 'NotImplemented'
     end

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

@@ -8,6 +8,9 @@ module Katello
       HOST_TOOLS_PACKAGE_NAME = 'katello-host-tools'.freeze
       HOST_TOOLS_TRACER_PACKAGE_NAME = 'katello-host-tools-tracer'.freeze
       SUBSCRIPTION_MANAGER_PACKAGE_NAME = 'subscription-manager'.freeze
+      ALL_HOST_TOOLS_PACKAGE_NAMES = [ "python-#{HOST_TOOLS_PACKAGE_NAME}",
+                                       "python3-#{HOST_TOOLS_PACKAGE_NAME}",
+                                       HOST_TOOLS_PACKAGE_NAME ].freeze
       ALL_TRACER_PACKAGE_NAMES = [ "python-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
                                    "python3-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
                                    HOST_TOOLS_TRACER_PACKAGE_NAME ].freeze
@@ -181,12 +184,14 @@ module Katello
         }
         installable_hash[:total] = installable_hash.values.inject(:+)
         # same for applicable, but we need to get the counts from the db
+        applicable_errata_counts = applicable_errata.pluck(:errata_type).tally
         applicable_hash = {
-          :security => applicable_errata.security.count,
-          :bugfix => applicable_errata.bugfix.count,
-          :enhancement => applicable_errata.enhancement.count
+          :bugfix => applicable_errata_counts.values_at(*Katello::Erratum::BUGZILLA).compact.sum,
+          :security => applicable_errata_counts.values_at(*Katello::Erratum::SECURITY).compact.sum,
+          :enhancement => applicable_errata_counts.values_at(*Katello::Erratum::ENHANCEMENT).compact.sum
         }
-        applicable_hash[:total] = applicable_hash.values.inject(:+)
+        applicable_hash[:total] = applicable_errata_counts.values.sum
+
         # keeping installable at the top level for backward compatibility
         installable_hash.merge({
                                  :applicable => applicable_hash
@@ -307,22 +312,22 @@ module Katello
         end
       end
 
-      def tracer_installed?
-        self.host.installed_packages.where("#{Katello::InstalledPackage.table_name}.name" => ALL_TRACER_PACKAGE_NAMES).any? ||
-          self.host.installed_debs.where("#{Katello::InstalledDeb.table_name}.name" => ALL_TRACER_PACKAGE_NAMES).any?
+      def tracer_installed?(force_update_cache: false)
+        Rails.cache.fetch("#{self.host.id}/tracer_installed", expires_in: 7.days, force: force_update_cache) do
+          self.host.installed_packages.where("#{Katello::InstalledPackage.table_name}.name" => ALL_TRACER_PACKAGE_NAMES).any? ||
+            self.host.installed_debs.where("#{Katello::InstalledDeb.table_name}.name" => ALL_TRACER_PACKAGE_NAMES).any?
+        end
       end
 
       def tracer_rpm_available?
         ::Katello::Rpm.yum_installable_for_host(self.host).where(name: ALL_TRACER_PACKAGE_NAMES).any?
       end
 
-      def host_tools_installed?
-        host.installed_packages.where("#{Katello::InstalledPackage.table_name}.name" => [ "python-#{HOST_TOOLS_PACKAGE_NAME}",
-                                                                                          "python3-#{HOST_TOOLS_PACKAGE_NAME}",
-                                                                                          HOST_TOOLS_PACKAGE_NAME ]).any? ||
-          host.installed_debs.where("#{Katello::InstalledDeb.table_name}.name" => [ "python-#{HOST_TOOLS_PACKAGE_NAME}",
-                                                                                    "python3-#{HOST_TOOLS_PACKAGE_NAME}",
-                                                                                    HOST_TOOLS_PACKAGE_NAME ]).any?
+      def host_tools_installed?(force_update_cache: false)
+        Rails.cache.fetch("#{self.host.id}/host_tools_installed", expires_in: 7.days, force: force_update_cache) do
+          self.host.installed_packages.where("#{Katello::InstalledPackage.table_name}.name" => ALL_HOST_TOOLS_PACKAGE_NAMES).any? ||
+            self.host.installed_debs.where("#{Katello::InstalledDeb.table_name}.name" => ALL_HOST_TOOLS_PACKAGE_NAMES).any?
+        end
       end
 
       def update_errata_status