katello 4.2.2 → 4.3.0.rc1

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

@@ -4,8 +4,6 @@ module Katello
       class Consumer < CandlepinResource
         extend ConsumerResource
 
-        GET_PARAM_BATCH_SIZE = 75
-
         class << self
           def all_uuids
             cp_consumers = Organization.all.map do |org|
@@ -27,14 +25,6 @@ module Katello
             end
           end
 
-          def get_all(uuids)
-            consumers = []
-            uuids.each_slice(GET_PARAM_BATCH_SIZE) do |slice|
-              consumers += get(:uuid => slice)
-            end
-            consumers
-          end
-
           # workaround for https://bugzilla.redhat.com/1647724
           def get_all_with_facts(uuids)
             consumers = []
@@ -139,16 +129,6 @@ module Katello
             self.delete(uri, self.default_headers).code.to_i
           end
 
-          def remove_entitlements(uuid)
-            uri = join_path(path(uuid), 'entitlements')
-            self.delete(uri, self.default_headers).code.to_i
-          end
-
-          def remove_certificate(uuid, serial_id)
-            uri = join_path(path(uuid), 'certificates') + "/#{serial_id}"
-            self.delete(uri, self.default_headers).code.to_i
-          end
-
           def virtual_guests(uuid)
             response = Candlepin::CandlepinResource.get(join_path(path(uuid), 'guests'), self.default_headers).body
             ::Katello::Util::Data.array_with_indifferent_access JSON.parse(response)

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

@@ -20,10 +20,12 @@ module Katello
           client.delete({:accept => :json, :content_type => :json}.merge(User.cp_oauth_header))
         end
 
-        def self.get(path)
+        def self.get(path, extra_headers = {})
           logger.debug "Sending GET request to Candlepin: #{path}"
           client = CandlepinResource.rest_client(Net::HTTP::Get, :get, path_with_cp_prefix(path))
-          client.get({:accept => :json}.merge(User.cp_oauth_header))
+          client.get(extra_headers.merge!(default_request_headers))
+        rescue RestClient::NotModified => e
+          e.response
         end
 
         def self.put(path, body)
@@ -35,6 +37,10 @@ module Katello
         def self.path_with_cp_prefix(path)
           CandlepinResource.prefix + path
         end
+
+        def self.default_request_headers
+          @default_request_headers ||= User.cp_oauth_header.merge(accept: :json)
+        end
       end
     end
   end

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

@@ -13,6 +13,8 @@ module Katello
             resource.head
           rescue RestClient::Unauthorized, RestClient::Gone
             raise ::Katello::Errors::UpstreamConsumerGone
+          rescue RestClient::NotFound
+            raise ::Katello::Errors::UpstreamConsumerNotFound
           end
 
           # Overrides the HttpResource get method to check if the upstream

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

@@ -0,0 +1,68 @@
+module Katello
+  module Resources
+    module CDN
+      class KatelloCdn < CdnResource
+        def initialize(url, options)
+          @organization_label = options.delete(:organization_label)
+          fail ArgumentError, "No upstream organization was specified" if @organization_label.nil?
+
+          super
+        end
+
+        def fetch_paths(content_path)
+          url = "/katello/api/v2/repository_sets?organization_id=#{organization['id']}&search=#{CGI.escape("path = #{content_path}")}"
+          response = get(url)
+          repo_set = JSON.parse(response)['results'].first
+
+          fail _("Upstream organization %s does not provide this content path") % @organization_label if repo_set.nil?
+
+          # now get available repositories when we know the upstream repo set ID
+          url = "/katello/api/v2/repository_sets/#{repo_set['id']}/available_repositories?organization_id=#{organization['id']}"
+          response = get(url)
+          json_body = JSON.parse(response)
+          results = json_body['results']
+
+          results.map do |r|
+            {
+              path: r['path'],
+              substitutions: r['substitutions']
+            }
+          end
+        end
+
+        def valid_path?(_path, _postfix)
+          true
+        end
+
+        def debug_certificate
+          get("/katello/api/v2/organizations/#{organization['id']}/download_debug_certificate")
+        end
+
+        def repository_url(content_label:)
+          response = get("/katello/api/v2/organizations/#{organization['id']}/repositories?search=#{CGI.escape("content_label = #{content_label}")}")
+          repository = JSON.parse(response)['results'].first
+
+          if repository.nil?
+            fail _("Repository with content label %{content_label} was not found in upstream organization %{org_label}") % { content_label: content_label, org_label: @organization_label }
+          end
+
+          repository['full_path']
+        end
+
+        private
+
+        def organization
+          @organization ||= find_organization(@organization_label)
+        end
+
+        def find_organization(label)
+          response = get("/api/v2/organizations?search=#{CGI.escape("label = #{label}")}")
+          JSON.parse(response)['results'].first
+        rescue => e
+          Rails.logger.error("Couldn't load upstream organization with label=#{label} error=#{e.message}")
+          raise e
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@ module Katello
   module Resources
     module CDN
       SUPPORTED_SSL_VERSIONS = ['SSLv23', 'TLSv1'].freeze
+
       class Utils
         # takes releasever from contentUrl (e.g. 6Server, 6.0, 6.1)
         # returns hash e.g. {:major => 6, :minor => "6.1"}
@@ -18,53 +19,75 @@ module Katello
       class CdnResource
         CDN_DOCKER_CONTAINER_LISTING = "CONTAINER_REGISTRY_LISTING".freeze
 
-        attr_reader :url, :product, :options, :proxy
-
-        def substitutor(logger = nil)
-          @logger = logger
-          Util::CdnVarSubstitutor.new(self)
+        def substitutor
+          @substitutor ||= Util::CdnVarSubstitutor.new(self)
         end
 
         def initialize(url, options = {})
-          @proxy = ::HttpProxy.default_global_content_proxy
           @ssl_version = Setting[:cdn_ssl_version]
           if @ssl_version && !SUPPORTED_SSL_VERSIONS.include?(@ssl_version)
             fail("Invalid SSL version specified. Check the 'CDN SSL Version' setting")
           end
+
           options.reverse_merge!(:verify_ssl => 9)
-          options.assert_valid_keys(:ssl_client_key, :ssl_client_cert, :ssl_ca_file, :verify_ssl,
-                                    :product)
-
-          ca = Katello::Repository.feed_ca_file(url)
-          if ca && URI(url).scheme == 'https'
-            options.reverse_merge!(:ssl_ca_file => ca)
-          elsif URI(url).scheme == 'https'
-            store = OpenSSL::X509::Store.new
-            store.set_default_paths
-            options.reverse_merge!(:cert_store => store)
+          options.assert_valid_keys(:ssl_client_key,
+                                    :ssl_client_cert,
+                                    :ssl_ca_file,
+                                    :ssl_ca_cert,
+                                    :verify_ssl,
+                                    :username,
+                                    :password,
+                                    :organization_label,
+                                    :ssl_ca_cert)
+
+          if options[:ssl_ca_cert].present?
+            ca_cert = OpenSSL::X509::Certificate.new(options[:ssl_ca_cert])
+            @cert_store = OpenSSL::X509::Store.new
+            @cert_store.add_cert(ca_cert)
           end
 
-          @product = options[:product]
-
           @url = url
           @uri = URI.parse(url)
           @options = options
         end
 
+        def self.create(product: nil, cdn_configuration:)
+          options = {}
+          if cdn_configuration.redhat?
+            options[:ssl_client_cert] = OpenSSL::X509::Certificate.new(product.certificate)
+            options[:ssl_client_key] = OpenSSL::PKey::RSA.new(product.key)
+            options[:ssl_ca_file] = self.ca_file
+            self.new(cdn_configuration.url, options)
+          else
+            options[:username] = cdn_configuration.username
+            options[:password] = cdn_configuration.password
+            options[:organization_label] = cdn_configuration.upstream_organization_label
+            options[:ssl_ca_cert] = cdn_configuration.ssl_ca
+            CDN::KatelloCdn.new(cdn_configuration.url, options)
+          end
+        end
+
+        def self.redhat_cdn_url
+          SETTINGS[:katello][:redhat_repository_url]
+        end
+
         def self.redhat_cdn?(url)
-          url.include?(SETTINGS[:katello][:redhat_repository_url])
+          url.include?(redhat_cdn_url)
+        end
+
+        def proxy
+          ::HttpProxy.default_global_content_proxy
         end
 
         def http_downloader
           net = net_http_class.new(@uri.host, @uri.port)
           net.use_ssl = @uri.is_a?(URI::HTTPS)
 
-          if CdnResource.redhat_cdn?(@uri.to_s)
+          if @uri.is_a?(URI::HTTPS)
             net.cert = @options[:ssl_client_cert]
             net.key = @options[:ssl_client_key]
-            net.ca_file = @options[:ssl_ca_file] if @options[:ssl_ca_file]
-          else
-            net.cert_store = @options[:cert_store]
+            net.ca_file = @options[:ssl_ca_file]
+            net.cert_store = @cert_store
           end
 
           # NOTE: This was added because some proxies dont support SSLv23 and do not handle TLS 1.2
@@ -93,8 +116,13 @@ module Katello
           net = http_downloader
           path = File.join(@uri.request_uri, path)
           used_url = File.join("#{@uri.scheme}://#{@uri.host}:#{@uri.port}", path)
-          Rails.logger.debug "CDN: Requesting path #{used_url}"
+          Rails.logger.info "CDN: Requesting path #{used_url}"
           req = Net::HTTP::Get.new(path)
+
+          if @options[:username] && @options[:password]
+            req.basic_auth(@options[:username], @options[:password])
+          end
+
           begin
             net.start do |http|
               res = http.request(req, nil) { |http_response| http_response.read_body }
@@ -125,6 +153,14 @@ module Katello
           end
         end
 
+        def valid_path?(path, postfix)
+          get(File.join(path, postfix)).present?
+        rescue RestClient::MovedPermanently
+          return true
+        rescue Errors::NotFound
+          return false
+        end
+
         def fetch_substitutions(base_path)
           get(File.join(base_path, "listing")).split("\n")
         rescue Errors::NotFound => e # some of listing file points to not existing content
@@ -136,12 +172,8 @@ module Katello
           "#{Katello::Engine.root}/ca/redhat-uep.pem"
         end
 
-        def self.ca_file_contents
-          File.read(ca_file)
-        end
-
         def net_http_class
-          if self.proxy
+          if proxy
             uri = URI(proxy.url) #Net::HTTP::Proxy ignores port as part of the url
             Net::HTTP::Proxy("#{uri.host}#{uri.path}", uri.port, proxy.username, proxy.password)
           else

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

@@ -32,7 +32,7 @@ module Katello
             self.prefix = "/pulpcore_registry/"
             self.site = "#{uri.scheme}://#{uri.host}:#{uri.port}"
             self.ca_cert_file = Setting[:ssl_ca_file]
-            pulp_primary.pulp3_ssl_configuration(self, :net_http)
+            pulp_primary.pulp3_ssl_configuration(self)
 
             self
           end

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

@@ -48,7 +48,7 @@ module Katello
       end
 
       def any_valid_metadata_file?(repo_path)
-        ['repodata/repomd.xml', 'PULP_MANIFEST', '.treeinfo', 'treeinfo'].any? { |filename| valid_path?(repo_path, filename) }
+        ['repodata/repomd.xml', 'PULP_MANIFEST', '.treeinfo', 'treeinfo'].any? { |filename| @resource.valid_path?(repo_path, filename) }
       end
 
       protected
@@ -59,10 +59,10 @@ module Katello
 
         return resolved if to_resolve.empty?
 
-        to_resolve.in_groups_of(8) do |group|
+        to_resolve.in_groups_of(8, false) do |group|
           futures = group.map do |path_with_substitution|
             Concurrent::Promises.future do
-              path_with_substitution.resolve_substitutions(@resource)
+              resolve_path(path_with_substitution)
             end
           end
 
@@ -75,12 +75,18 @@ module Katello
         find_substitutions(resolved.compact.flatten)
       end
 
-      def valid_path?(path, postfix)
-        @resource.get(File.join(path, postfix)).present?
-      rescue RestClient::MovedPermanently
-        return true
-      rescue Errors::NotFound
-        return false
+      def resolve_path(path_with_substitutions)
+        if @resource.respond_to?(:fetch_paths)
+          @resource.fetch_paths(path_with_substitutions.path).compact.map do |element|
+            PathWithSubstitutions.new(element[:path], element[:substitutions])
+          end
+        elsif @resource.respond_to?(:fetch_substitutions)
+          @resource.fetch_substitutions(path_with_substitutions.base_path).compact.map do |value|
+            path_with_substitutions.resolve_token(value)
+          end
+        else
+          fail _("Unsupported CDN resource")
+        end
       end
     end
   end

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

@@ -170,6 +170,28 @@ module Katello
         end
         pieces.join(".")
       end
+
+      def self.parse_dependencies(dependencies)
+        # dependencies is either 'requires' or 'provides' metadata attribute of rpm package in pulp
+        results = []
+        flags = {'GT' => '>', 'LT' => '<', 'EQ' => '=', 'GE' => '>=', 'LE' => '<='}
+
+        dependencies&.each do |dependency|
+          dependencies_str = ""
+          if dependency.count < 3
+            dependencies_str = dependency.first
+            results << dependencies_str
+          else
+            dependency[1] = flags[dependency[1]]
+            dependency[0...2].each { |dependency_piece| dependencies_str += "#{dependency_piece} " }
+            dependencies_str += "#{dependency[2]}:" unless dependency[2] == "0" # epoch
+            dependencies_str += "#{dependency[3]}-" # version
+            dependency[4...-1].each { |dependency_piece| dependencies_str += "#{dependency_piece}." }
+            results << dependencies_str[0...-1]
+          end
+        end
+        results.uniq
+      end
     end
   end
 end

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

@@ -3,15 +3,19 @@ module Katello
     class PathWithSubstitutions
       include Comparable
 
-      attr_accessor :substitutions
-      attr_accessor :path
+      attr_reader :base_path, :path, :substitutions
+
+      SUBSTITUTABLE_REGEX = /^(.*?)\$([^\/]*)/.freeze
 
       #path /content/rhel/server/$arch/$releasever/os
       #substitutions  {$arch => 'x86_64'}
       def initialize(path, substitutions)
         @substitutions = substitutions
         @path = path
-        @resolved = []
+
+        if @path =~ SUBSTITUTABLE_REGEX
+          @base_path, @token = Regexp.last_match[1], Regexp.last_match[2]
+        end
       end
 
       def split_path
@@ -25,19 +29,13 @@ module Katello
       end
 
       def substitutable?
-        path =~ /^(.*?)\$([^\/]*)/
+        @token.present?
       end
 
-      def resolve_substitutions(cdn_resource)
-        if @resolved.empty? && path =~ /^(.*?)\$([^\/]*)/
-          base_path, var = Regexp.last_match[1], Regexp.last_match[2]
-          cdn_resource.fetch_substitutions(base_path).compact.map do |value|
-            new_substitutions = substitutions.merge(var => value)
-            new_path = path.sub("$#{var}", value)
-            @resolved << PathWithSubstitutions.new(new_path, new_substitutions)
-          end
-        end
-        @resolved
+      def resolve_token(value)
+        new_substitutions = substitutions.merge(@token => value)
+        new_path = path.sub("$#{@token}", value)
+        PathWithSubstitutions.new(new_path, new_substitutions)
       end
 
       def unused_substitutions

data/app/models/katello/activation_key.rb

@@ -184,5 +184,15 @@ module Katello
         self.content_view = self.environment.try(:default_content_view)
       end
     end
+
+    apipie :class, desc: "A class representing #{model_name.human} object" do
+      name 'Activation Key'
+      refs 'ActivationKey'
+      sections only: %w[all additional]
+      property :name, String, desc: 'Returns the name of the Activation Key.'
+    end
+    class Jail < ::Safemode::Jail
+      allow :name
+    end
   end
 end

data/app/models/katello/ansible_collection.rb

@@ -3,7 +3,7 @@ module Katello
     include Concerns::PulpDatabaseUnit
 
     self.table_name = 'katello_ansible_collections'
-    CONTENT_TYPE = 'ansible collection'.freeze
+    CONTENT_TYPE = 'ansible_collection'.freeze
 
     has_many :ansible_collection_tags, :class_name => "Katello::AnsibleCollectionTag", :dependent => :delete_all
     has_many :tags, :through => :ansible_collection_tags

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

@@ -4,12 +4,12 @@ module Katello
 
     delegate :editable?, to: :product
 
-    def deletable?
-      product.editable? && !promoted?
+    def deletable?(remove_from_content_view_versions = false)
+      product.editable? && (remove_from_content_view_versions || !promoted?)
     end
 
-    def redhat_deletable?
-      !self.promoted? && self.product.editable?
+    def redhat_deletable?(remove_from_content_view_versions = false)
+      (remove_from_content_view_versions || !self.promoted?) && self.product.editable?
     end
 
     def readable?

data/app/models/katello/candlepin/repository_mapper.rb

@@ -74,7 +74,11 @@ module Katello
       end
 
       def feed_url
-        product.repo_url(path)
+        @feed_url ||= if product.cdn_resource&.respond_to?(:repository_url)
+                        product.cdn_resource.repository_url(content_label: content.label)
+                      else
+                        product.repo_url(path)
+                      end
       end
 
       def arch

data/app/models/katello/cdn_configuration.rb

@@ -0,0 +1,32 @@
+module Katello
+  class CdnConfiguration < Katello::Model
+    include Encryptable
+
+    belongs_to :organization, :inverse_of => :cdn_configuration
+
+    belongs_to :ssl_ca_credential, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_ca_cdn_configurations
+
+    encrypts :password
+
+    validates :url, presence: true
+    validates_with Validators::KatelloUrlFormatValidator, attributes: :url
+    validates_with Validators::KatelloLabelFormatValidator, attributes: :upstream_organization_label, if: proc { upstream_organization_label.present? }
+    validate :non_redhat_configuration, unless: :redhat?
+
+    def ssl_ca
+      ssl_ca_credential&.content
+    end
+
+    def redhat?
+      username.blank? && password.blank? && upstream_organization_label.blank? && ssl_ca_credential_id.blank?
+    end
+
+    private
+
+    def non_redhat_configuration
+      if username.blank? || password.blank? || upstream_organization_label.blank? || ssl_ca_credential_id.blank?
+        errors.add(:base, _("Username, Password, Upstream Organization Label, and SSL CA Credential are required when using a non-Red Hat CDN."))
+      end
+    end
+  end
+end

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

@@ -30,6 +30,7 @@ module Katello
         has_one :content_source, :through => :content_facet
         has_many :content_facet_errata, :through => :content_facet, :class_name => 'Katello::ContentFacetErratum'
         has_many :applicable_errata, :through => :content_facet_errata, :source => :erratum
+        has_many :applicable_debs, :through => :content_facet
         has_many :applicable_rpms, :through => :content_facet
         has_many :applicable_module_streams, :through => :content_facet
 
@@ -40,6 +41,8 @@ module Katello
         scoped_search :relation => :applicable_errata, :on => :errata_id, :rename => :applicable_errata, :complete_value => true, :ext_method => :find_by_applicable_errata, :only_explicit => true
         scoped_search :relation => :applicable_errata, :on => :errata_id, :rename => :installable_errata, :complete_value => true, :ext_method => :find_by_installable_errata, :only_explicit => true
         scoped_search :relation => :applicable_errata, :on => :issued, :rename => :applicable_errata_issued, :complete_value => true, :only_explicit => true
+        scoped_search :relation => :applicable_debs, :on => :nav, :rename => :applicable_debs, :complete_value => true, :ext_method => :find_by_applicable_debs, :only_explicit => true, :operators => ['=']
+        scoped_search :relation => :applicable_debs, :on => :nav, :rename => :upgradable_debs, :complete_value => true, :ext_method => :find_by_installable_debs, :only_explicit => true, :operators => ['=']
         scoped_search :relation => :applicable_rpms, :on => :nvra, :rename => :applicable_rpms, :complete_value => true, :ext_method => :find_by_applicable_rpms, :only_explicit => true
         scoped_search :relation => :applicable_rpms, :on => :nvra, :rename => :upgradable_rpms, :complete_value => true, :ext_method => :find_by_installable_rpms, :only_explicit => true
         scoped_search :relation => :content_source, :on => :name, :complete_value => true, :rename => :content_source
@@ -88,6 +91,24 @@ module Katello
           end
         end
 
+        def find_by_applicable_debs(_key, operator, value)
+          hosts = find_by_debs(::Host::Managed.joins(:applicable_debs), operator, value)
+          if hosts.empty?
+            { :conditions => "1=0" }
+          else
+            { :conditions => "#{::Host::Managed.table_name}.id IN (#{hosts.pluck(:id).join(',')})" }
+          end
+        end
+
+        def find_by_installable_debs(_key, operator, value)
+          facets = find_by_debs(Katello::Host::ContentFacet.joins_installable_debs, operator, value)
+          if facets.empty?
+            { :conditions => "1=0" }
+          else
+            { :conditions => "#{::Host::Managed.table_name}.id IN (#{facets.pluck(:host_id).join(',')})" }
+          end
+        end
+
         def find_by_applicable_rpms(_key, operator, value)
           conditions = sanitize_sql_for_conditions(["#{Katello::Rpm.table_name}.nvra #{operator} ?", value_to_sql(operator, value)])
           hosts = ::Host::Managed.joins(:applicable_rpms).where(conditions)
@@ -118,6 +139,25 @@ module Katello
         def in_environment(lifecycle_environment)
           in_content_view_environment(:lifecycle_environment => lifecycle_environment)
         end
+
+        private
+
+        def find_by_debs(base, operator, value)
+          table = Katello::Deb.table_name
+
+          name, architecture, version = Katello::Deb.split_nav(value)
+          if name.nil?
+            return []
+          end
+
+          res = base.where(sanitize_sql_for_conditions(["#{table}.name #{operator} ?", value_to_sql(operator, name)]))
+
+          res = res.where(sanitize_sql_for_conditions(["#{table}.architecture #{operator} ?", value_to_sql(operator, architecture)])) unless architecture.nil?
+
+          res = res.where(sanitize_sql_for_conditions(["#{table}.version #{operator} ?", value_to_sql(operator, version)])) unless version.nil?
+
+          res
+        end
       end
     end
   end

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

@@ -67,9 +67,10 @@ module Katello
         scoped_search :relation => :host_collections, :on => :name, :complete_value => true, :rename => :host_collection
         scoped_search :relation => :installed_packages, :on => :nvra, :complete_value => true, :rename => :installed_package, :only_explicit => true
         scoped_search :relation => :installed_packages, :on => :name, :complete_value => true, :rename => :installed_package_name, :only_explicit => true
+        scoped_search :relation => :installed_debs, :on => :name, :rename => :installed_deb, :only_explicit => true, :ext_method => :find_by_installed_debs, operators: ['=']
+        scoped_search :relation => :installed_debs, :on => :name, :complete_value => true, :rename => :installed_package_name, :only_explicit => true
         scoped_search :relation => :available_module_streams, :on => :name, :complete_value => true, :rename => :available_module_stream_name, :only_explicit => true
         scoped_search :relation => :available_module_streams, :on => :stream, :complete_value => true, :rename => :available_module_stream_stream, :only_explicit => true
-        scoped_search :relation => :installed_debs, :on => :name, :complete_value => true, :rename => :installed_package_name, :only_explicit => true
         scoped_search :relation => :host_traces, :on => :application, :complete_value => true, :rename => :trace_app, :only_explicit => true
         scoped_search :relation => :host_traces, :on => :app_type, :complete_value => true, :rename => :trace_app_type, :only_explicit => true
         scoped_search :relation => :host_traces, :on => :helper, :complete_value => true, :rename => :trace_helper, :only_explicit => true
@@ -108,7 +109,7 @@ module Katello
         self.host_statuses.where(type: ::Katello::HostStatusManager::STATUSES.map(&:name)).each do |status|
           status.refresh!
         end
-        refresh_global_status
+        refresh_global_status!
       end
 
       def queue_refresh_content_host_status
@@ -141,6 +142,25 @@ module Katello
         !new_record? && build && self.changes.key?('build')
       end
 
+      module ClassMethods
+        def find_by_installed_debs(_key, _operator, value)
+          name, architecture, version = Katello::Deb.split_nav(value)
+          debs = Katello::InstalledDeb.where(:name => name)
+          debs = debs.where(:architecture => architecture) unless architecture.nil?
+          debs = debs.where(:version => version) unless version.nil?
+          hosts = debs.joins(:host_installed_debs).select("#{Katello::HostInstalledDeb.table_name}.host_id as host_id").pluck(:host_id)
+          if hosts.empty?
+            {
+              :conditions => "1=0"
+            }
+          else
+            {
+              :conditions => "#{::Host::Managed.table_name}.id IN (#{hosts.join(',')})"
+            }
+          end
+        end
+      end
+
       def correct_kickstart_repository
         return unless content_facet
 
@@ -363,6 +383,12 @@ module Katello
         @traces_status_label ||= get_status(::Katello::TraceStatus).to_label(options)
       end
 
+      def traces_helpers(ids = nil)
+        traces = host_traces
+        traces = host_traces.where(id: ids) if ids.present?
+        ::Katello::HostTracer.helpers_for(traces)
+      end
+
       def valid_content_override_label?(content_label)
         available_content = subscription_facet.candlepin_consumer.available_product_content
         available_content.map(&:content).any? { |content| content.label == content_label }
@@ -385,7 +411,7 @@ end
 class ::Host::Managed::Jail < Safemode::Jail
   allow :content_source, :subscription_manager_configuration_url, :rhsm_organization_label,
         :host_collections, :pools, :hypervisor_host, :lifecycle_environment, :content_view,
-        :installed_packages
+        :installed_packages, :traces_helpers
 end
 
 class ActiveRecord::Associations::CollectionProxy::Jail < Safemode::Jail

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

@@ -59,7 +59,7 @@ module Katello
       # instead of calling nested_attribute_for(:content_source_id) in Foreman, define the methods explictedly
       def content_source
         return super if ancestry.nil? || self.content_source_id.present?
-        SmartProxy.find_by(:id => inherited_content_source_id)
+        SmartProxy.unscoped.find_by(:id => inherited_content_source_id)
       end
 
       def inherited_content_source_id