katello 4.10.0.rc2 → 4.11.0.rc1

data/app/lib/actions/pulp3/capsule_content/reclaim_space.rb

@@ -3,6 +3,7 @@ module Actions
     module CapsuleContent
       class ReclaimSpace < Pulp3::AbstractAsyncTask
         def plan(smart_proxy)
+          action_subject(smart_proxy)
           if smart_proxy.pulp_primary?
             repository_hrefs = ::Katello::Pulp3::RepositoryReference.default_cv_repository_hrefs(::Katello::Repository.unscoped.on_demand, ::Organization.all)
             repository_hrefs.flatten!
@@ -20,6 +21,10 @@ module Actions
           output[:pulp_tasks] = ::Katello::Pulp3::Api::Core.new(SmartProxy.find(input[:smart_proxy_id])).
             repositories_reclaim_space_api.reclaim(repo_hrefs: input[:repository_hrefs])
         end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
       end
     end
   end

data/app/lib/actions/pulp3/content_view_version/create_export_history.rb

@@ -16,11 +16,16 @@ module Actions
           param :exported_file_checksum, String
         end
 
-        def run
+        def run # rubocop:disable Metrics/AbcSize
           smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
           api = ::Katello::Pulp3::Api::Core.new(smart_proxy)
           export_data = api.export_api.list(input[:exporter_data][:pulp_href]).results.first
           output[:exported_file_checksum] = export_data.output_file_info
+          if output[:exported_file_checksum].blank?
+            output[:export_history_id] = nil
+            output[:message] = _("Export failed: One or more repositories needs to be synced (with Immediate download policy.)")
+            return
+          end
           file_name = output[:exported_file_checksum].first&.first
           path = File.dirname(file_name.to_s)
           output[:path] = path

data/app/lib/actions/pulp3/content_view_version/export.rb

@@ -24,6 +24,14 @@ module Actions
                                                    .create_export(input[:exporter_data],
                                                                         chunk_size: input[:chunk_size])
         end
+
+        def rescue_external_task(error)
+          if error.is_a?(::Katello::Errors::Pulp3Error) && error.message.match?(/Remote artifacts cannot be exported/)
+            fail ::Katello::Errors::Pulp3ExportError, "Failed to export: One or more repositories needs to be synced (with Immediate download policy.)"
+          else
+            super
+          end
+        end
       end
     end
   end

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

@@ -28,7 +28,7 @@ module Actions
           end
 
           def run
-            output[:export_history_id] = input[:export_action_output][:export_history_id]
+            output[:export_history_id] = input[:export_action_output]&.[](:export_history_id)
           end
 
           def humanized_name

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

@@ -88,6 +88,19 @@ module Katello
         end
       end
 
+      apipie :method, 'Returns installed product names for the host with CP IDs' do
+        required :host, 'Host::Managed', desc: 'Host object to get products for'
+        returns array_of: String, desc: 'Array with names and CP IDs of installed products on the host'
+      end
+      def host_products_names_and_ids(host)
+        products = host_products(host)
+        if products
+          products.collect { |product| "#{product.name} (#{product.cp_product_id})" }
+        else
+          []
+        end
+      end
+
       apipie :method, 'Returns the host collections the host belongs to' do
         required :host, 'Host::Managed', desc: 'Host object to get the host collections for'
         returns array_of: 'HostCollection', desc: "Array of the host collection objects the host belongs to"
@@ -370,7 +383,7 @@ module Katello
           (found.chomp.split('=', 2).last || '').split(',')
         else
           TemplateInvocationInputValue.joins(:template_input).where("template_invocation_id = ? AND template_inputs.name = ?", task.template_invocation_id, 'errata')
-            .first.value.split(',')
+            .first&.value&.split(',') || []
         end
       end
     end

data/app/lib/katello/errors.rb

@@ -110,6 +110,7 @@ module Katello
 
     class Pulp3Error < StandardError; end
     class Pulp3MigrationError < StandardError; end
+    class Pulp3ExportError < StandardError; end
 
     class PulpError < StandardError
       def self.from_task(task)

data/app/lib/katello/repo_discovery.rb

@@ -1,3 +1,5 @@
+require 'uri'
+
 module Katello
   class RepoDiscovery
     include Katello::Util::HttpProxy
@@ -42,6 +44,72 @@ module Katello
 
     private
 
+    def parse_parameter(field_value)
+      field_value.lstrip!
+      i = field_value.index(/[ \t=;,]/) || field_value.length
+      name = field_value.slice!(0, i).downcase(:ascii)
+      field_value.lstrip!
+      if field_value.delete_prefix!('=')
+        field_value.lstrip!
+        if field_value.delete_prefix!('"')
+          value = ''
+          until field_value.empty?
+            break if field_value.delete_prefix!('"')
+            field_value.delete_prefix!("\\")
+            value += field_value.slice!(0, 1) || ''
+          end
+        else
+          i = field_value.index(/[;,]/) || field_value.length
+          value = field_value.slice!(0, i)
+        end
+      end
+      {name: name, value: value || ''}
+    end
+
+    def parse_parameters(field_value)
+      seen_rel = false
+      has_next_rel = false
+      has_anchor = false
+      until field_value.empty?
+        field_value.lstrip!
+        break if field_value.delete_prefix!(';').nil?
+        param = parse_parameter(field_value)
+        case
+        when param[:name] == 'rel' && !seen_rel
+          seen_rel = true
+          has_next_rel = param[:value].downcase(:ascii).split(/[ \t]/).include?('next')
+        when param[:name] == 'anchor'
+          has_anchor = true
+        end
+      end
+      {has_next_rel: has_next_rel, has_anchor: has_anchor}
+    end
+
+    def get_next_link(link_header)
+      # This code mostly follows Appendix B "Algorithms of Parsing Link Header Fields" of RFC 8288
+      # "Web Linking", <https://www.rfc-editor.org/rfc/rfc8288#appendix-B> (that RFC appears to be
+      # silent about multiple "next" links, so just use the first one and ignore any additional
+      # ones, in the general spirit of being lenient):
+      return nil if link_header.nil?
+      field_value = link_header.clone
+      until field_value.empty?
+        # The following ignores any junk preceding the next <...> link URL:
+        m = field_value.match(/<(.*)>/)
+        break unless m
+        target_string = m[1]
+        field_value = m.post_match
+        params = parse_parameters(field_value)
+        if params[:has_next_rel]
+          # To keep it simple, ignore a link with an (unlikely) anchor parameter; but the RFC
+          # mandates that we "MUST NOT process the link without applying the anchor", so just raise
+          # an exception in that (unlikely) case:
+          fail "anchor not supported" if params[:has_anchor]
+          return target_string
+        end
+      end
+      nil
+    end
+
     def docker_search
       request_params = {
         method: :get,
@@ -49,8 +117,8 @@ module Katello
         url: "#{@uri}v1/search?q=#{@search}"
       }
 
-      request_params[:headers][:user] = @upstream_username unless @upstream_username.empty?
-      request_params[:headers][:password] = @upstream_password unless @upstream_password.empty?
+      request_params[:user] = @upstream_username unless @upstream_username.empty?
+      request_params[:password] = @upstream_password unless @upstream_password.empty?
       request_params[:proxy] = proxy_uri if proxy
 
       begin
@@ -61,9 +129,14 @@ module Katello
       rescue
         # Note: v2 endpoint does not support search
         request_params[:url] = "#{@uri}v2/_catalog"
-        results = RestClient::Request.execute(request_params)
-        JSON.parse(results)['repositories'].each do |result|
-          @found << result
+        loop do
+          results = RestClient::Request.execute(request_params)
+          JSON.parse(results)['repositories'].each do |result|
+            @found << result
+          end
+          next_uri = get_next_link(results.headers[:link])
+          break if next_uri.nil?
+          request_params[:url] = URI(request_params[:url]).merge(next_uri).to_s
         end
       end
       @found.sort!

data/app/lib/katello/validators/content_view_environment_coherent_default_validator.rb

@@ -0,0 +1,22 @@
+module Katello
+  module Validators
+    # ensures that the Default Organization View content view can only be used with the Library environment
+    class ContentViewEnvironmentCoherentDefaultValidator < ActiveModel::Validator
+      def validate(record)
+        #support lifecycle_environment_id for foreman models
+        environment_id = record.respond_to?(:lifecycle_environment_id) ? record.lifecycle_environment_id : record.environment_id
+        if record.content_view_id
+          view = ContentView.where(:id => record.content_view_id).first
+          if environment_id
+            env = KTEnvironment.where(:id => environment_id).first
+            return if view.blank? || env.blank?
+            if view.default? && !env.library?
+              record.errors[:base] << _("Lifecycle environment '%{env}' cannot be used with content view '%{view}'") %
+                                        {:view => view.name, :env => env.name}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/validators/content_view_environment_validator.rb

@@ -1,5 +1,6 @@
 module Katello
   module Validators
+    # used by activation key and content facet
     class ContentViewEnvironmentValidator < ActiveModel::Validator
       def validate(record)
         #support lifecycle_environment_id for foreman models

data/app/mailers/katello/task_mailer.rb

@@ -0,0 +1,54 @@
+module Katello
+  class TaskMailer < ApplicationMailer
+    helper ApplicationHelper
+    include Rails.application.routes.url_helpers
+
+    def repo_sync_failure(options)
+      user, @repo, @task = options.values_at(:user, :repo, :task)
+
+      ::User.as(user.login) do
+        subject = _("Repository %{label} failed to synchronize") % { :label => @repo.label }
+
+        set_locale_for(user) do
+          mail(:to => user.mail, :subject => subject)
+        end
+      end
+    end
+
+    def cv_publish_failure(options)
+      user, @content_view, @task = options.values_at(:user, :content_view, :task)
+
+      ::User.as(user.login) do
+        subject = _("%{label} failed") % { :label => @task.action }
+
+        set_locale_for(user) do
+          mail(:to => user.mail, :subject => subject)
+        end
+      end
+    end
+
+    def cv_promote_failure(options)
+      user, @content_view, @task = options.values_at(:user, :content_view, :task)
+
+      ::User.as(user.login) do
+        subject = _("%{label} failed") % { :label => @task.action }
+
+        set_locale_for(user) do
+          mail(:to => user.mail, :subject => subject)
+        end
+      end
+    end
+
+    def proxy_sync_failure(options)
+      user, @environment, @repo, @content_view, @task, @smart_proxy = options.values_at(:user, :environment, :repository, :content_view, :task, :smart_proxy)
+
+      ::User.as(user.login) do
+        subject = _("%{label} failed") % { :label => @task.action }
+
+        set_locale_for(user) do
+          mail(:to => user.mail, :subject => subject)
+        end
+      end
+    end
+  end
+end

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

@@ -108,6 +108,8 @@ module Katello
         delegate :content_source_id, :single_content_view, :single_lifecycle_environment, :default_environment?, :single_content_view_environment?, :multi_content_view_environment?, :kickstart_repository_id, :bound_repositories,
           :installable_errata, :installable_rpms, to: :content_facet, allow_nil: true
 
+        delegate :release_version, :purpose_role, :purpose_usage, to: :subscription_facet, allow_nil: true
+
         has_many :content_view_environment_content_facets, through: :content_facet, class_name: 'Katello::ContentViewEnvironmentContentFacet'
         has_many :content_view_environments, through: :content_view_environment_content_facets
         has_many :content_views, through: :content_view_environments
@@ -481,6 +483,18 @@ module Katello
         @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
+
+      def rhel_lifecycle_status
+        @rhel_lifecycle_status ||= get_status(::Katello::RhelLifecycleStatus).status
+      end
+
+      def rhel_lifecycle_status_label
+        @rhel_lifecycle_status_label ||= get_status(::Katello::RhelLifecycleStatus).to_label
+      end
+
       def traces_status
         @traces_status ||= get_status(::Katello::TraceStatus).status
       end
@@ -494,6 +508,31 @@ module Katello
         ::Katello::HostTracer.helpers_for(traces)
       end
 
+      def probably_rhel?
+        # Get the os name from sub-man facts rather than operatingsystem. This is
+        # less likely to have been changed by the user.
+        os_name, = facts('distribution::name').values # only query for that one fact, then get its value
+        # if this fact isn't there, we can ignore it because the host is not "managed"
+        os_name.present? && os_name.start_with?('Red Hat Enterprise Linux')
+      end
+
+      def rhel_eos_schedule_index
+        return nil unless probably_rhel?
+        major = operatingsystem.major
+        return "RHEL#{major}" unless major == "7"
+        arch_name = architecture&.name
+        case arch_name
+        when "ppc64le"
+          "RHEL7 (POWER9)"
+        when "aarch64"
+          "RHEL7 (ARM)"
+        when "s390x"
+          "RHEL7 (System z (Structure A))"
+        else
+          "RHEL#{major}"
+        end
+      end
+
       def package_names_for_job_template(action:, search:, versions: nil)
         actions = %w(install remove update).freeze
         case action
@@ -550,7 +589,8 @@ 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
+        :single_content_view, :single_lifecycle_environment, :purpose_role, :purpose_usage, :release_version,
+        :purpose_role_status_label, :purpose_usage_status_label
 end
 
 class ActiveRecord::Associations::CollectionProxy::Jail < Safemode::Jail

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

@@ -248,5 +248,5 @@ module Katello
 end
 
 class ::Organization::Jail < ::Safemode::Jail
-  allow :label
+  allow :label, :simple_content_access?
 end

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

@@ -121,6 +121,43 @@ module Katello
         SmartProxy.joins(:smart_proxy_alternate_content_sources).where('katello_smart_proxy_alternate_content_sources.smart_proxy_id' => self.id)
       end
 
+      def update_content_counts!
+        # {:content_view_versions=>{87=>{:repositories=>{1=>{:metadata=>{},:counts=>{:rpms=>98, :module_streams=>9898}}}}}
+        new_content_counts = { content_view_versions: {} }
+        smart_proxy_helper = ::Katello::SmartProxyHelper.new(self)
+        repos = smart_proxy_helper.repositories_available_to_capsule
+
+        repos&.each do |repo|
+          repo_mirror_service = repo.backend_service(self).with_mirror_adapter
+          repo_content_counts = repo_mirror_service.latest_content_counts
+          translated_counts = {metadata: {}, counts: {}}
+          translated_counts[:metadata] = {
+            env_id: repo.environment_id,
+            library_instance_id: repo.library_instance_or_self.id,
+            product_id: repo.product_id,
+            content_type: repo.content_type
+          }
+          repo_content_counts&.each do |name, count|
+            count = count[:count]
+            # Some content units in Pulp have the same model
+            if name == 'rpm.package' && repo.content_counts['srpm'] > 0
+              translated_counts[:counts]['srpm'] = repo_mirror_service.count_by_pulpcore_type(::Katello::Pulp3::Srpm)
+              translated_counts[:counts]['rpm'] = count - translated_counts[:counts]['srpm']
+            elsif name == 'container.manifest' && repo.content_counts['docker_manifest_list'] > 0
+              translated_counts[:counts]['docker_manifest_list'] = repo_mirror_service.count_by_pulpcore_type(::Katello::Pulp3::DockerManifestList)
+              translated_counts[:counts]['docker_manifest'] = count - translated_counts[:counts]['docker_manifest_list']
+            else
+              translated_counts[:counts][::Katello::Pulp3::PulpContentUnit.katello_name_from_pulpcore_name(name, repo)] = count
+            end
+          end
+          new_content_counts[:content_view_versions][repo.content_view_version_id] ||= { repositories: {}}
+          # Store counts on capsule of archived repos which are reused across environment copies
+          # of the archived repo corresponding to each environment CV version is promoted to.
+          new_content_counts[:content_view_versions][repo.content_view_version_id][:repositories][repo.id] = translated_counts
+        end
+        update(content_counts: new_content_counts)
+      end
+
       def sync_container_gateway
         if has_feature?(::SmartProxy::CONTAINER_GATEWAY_FEATURE)
           update_container_repo_list
@@ -376,14 +413,30 @@ module Katello
         scope
       end
 
+      def last_complete_sync_task
+        ForemanTasks::Task.for_resource(self).where(:label => 'Actions::Katello::CapsuleContent::Sync').order(started_at: :desc).detect do |task|
+          task.input.with_indifferent_access[:options][:environment_id].nil? &&
+          task.input.with_indifferent_access[:options][:content_view_id].nil? &&
+          task.input.with_indifferent_access[:options][:repository_id].nil?
+        end
+      end
+
       def sync_tasks
         ForemanTasks::Task.for_resource(self).where(:label => 'Actions::Katello::CapsuleContent::Sync')
       end
 
+      def reclaim_space_tasks
+        ForemanTasks::Task.for_resource(self).where(:label => 'Actions::Pulp3::CapsuleContent::ReclaimSpace')
+      end
+
       def active_sync_tasks
         sync_tasks.where(:result => 'pending')
       end
 
+      def last_failed_reclaim_tasks
+        reclaim_space_tasks.where('started_at > ?', last_sync_time).where.not(:result => 'pending')
+      end
+
       def last_failed_sync_tasks
         sync_tasks.where('started_at > ?', last_sync_time).where.not(:result => 'pending')
       end
@@ -392,16 +445,35 @@ module Katello
         Audited::Audit.where(:auditable_id => self, :auditable_type => SmartProxy.name, action: "sync capsule").order(:created_at).last
       end
 
-      def last_sync_time
-        task = sync_tasks.where.not(:ended_at => nil).where(:result => 'success').order(:ended_at).last
+      def last_sync_task
+        sync_tasks.where.not(:ended_at => nil).where(:result => 'success').order(:ended_at).last
+      end
 
-        task&.ended_at || last_sync_audit&.created_at&.to_s
+      def last_sync_time
+        last_sync_task&.ended_at || last_sync_audit&.created_at&.to_s
       end
 
       def environment_syncable?(env)
         last_sync_time.nil? || env.content_view_environments.where('updated_at > ?', last_sync_time).any?
       end
 
+      def last_env_sync_task(env)
+        last_env_sync_task = sync_tasks.order(ended_at: :desc).detect { |task| task.input.with_indifferent_access[:options][:environment_id] == env.id || task.input.with_indifferent_access[:options][:environment_ids]&.include?(env.id) }
+
+        # env_ids_task_exists checks if any full syncs have run since we started tracking env_ids at time of sync.
+        # If yes, return last_env_sync_task which checks for env_id specific sync + full syncs which contain env as part of env_ids
+        env_ids_task_exists = sync_tasks.order(ended_at: :desc).any? { |task| task.input.with_indifferent_access[:options][:environment_ids] }
+        return last_env_sync_task if env_ids_task_exists
+
+        if (last_complete_sync_task&.ended_at && last_env_sync_task&.ended_at)
+          return last_complete_sync_task.ended_at > last_env_sync_task.ended_at ? last_complete_sync_task : last_env_sync_task
+        elsif last_env_sync_task
+          return last_env_sync_task
+        elsif last_complete_sync_task
+          return last_complete_sync_task
+        end
+      end
+
       def cancel_sync
         active_sync_tasks.map(&:cancel)
       end

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

@@ -31,6 +31,7 @@ module Katello
         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,
@@ -41,6 +42,7 @@ module Katello
         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
         scoped_search :on => :autoheal, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
@@ -100,6 +102,10 @@ module Katello
           ::Katello::PurposeStatus.status_map
         end
 
+        def rhel_lifecycle_status_map
+          ::Katello::RhelLifecycleStatus.status_map
+        end
+
         def find_by_purpose_addon(_key, operator, value)
           conditions = sanitize_sql_for_conditions(["#{Katello::PurposeAddon.table_name}.name #{operator} ?", value_to_sql(operator, value)])
           hosts = ::Host::Managed.joins(:purpose_addons).where(conditions)

data/app/models/katello/content_view.rb

@@ -111,6 +111,27 @@ module Katello
     scoped_search :on => :composite, :complete_value => true
     scoped_search :on => :generated_for, :complete_value => true
     scoped_search :on => :default # just for ordering
+    scoped_search :on => :name, :complete_value => true,
+                  :rename => :content_views,
+                  :operators => ['='],
+                  :ext_method => :find_components_by_cv_name
+
+    def self.find_components_by_cv_name(_key, operator, value)
+      kcv = Katello::ContentView.table_name
+      kcvc = Katello::ContentViewComponent.table_name
+      { :conditions => "#{kcv}.composite = 't' AND #{kcv}.id IN (SELECT #{kcvc}.composite_content_view_id FROM #{kcvc} WHERE #{kcvc}.content_view_id IN (SELECT #{kcv}.id FROM #{kcv} WHERE #{kcv}.name #{operator} ?))",
+        :parameter => [value]
+      }
+    end
+
+    def self.completer_scope_options(search)
+      if search.include?('content_views')
+        # Don't autocomplete CCV names when searching for components
+        { :value_filter => { :composite => false } }
+      else
+        {}
+      end
+    end
 
     enum generated_for: {
       none: 0,

data/app/models/katello/content_view_environment.rb

@@ -19,6 +19,7 @@ module Katello
     validates :environment_id, uniqueness: {scope: :content_view_id}, presence: true
     validates :content_view_id, presence: true
     validates_with Validators::ContentViewEnvironmentOrgValidator
+    validates_with Validators::ContentViewEnvironmentCoherentDefaultValidator
 
     before_save :generate_info
 
@@ -42,6 +43,10 @@ module Katello
       content_view.activation_keys.in_environment(environment)
     end
 
+    def default_environment?
+      content_view.default? && environment.library?
+    end
+
     # TODO: uncomment when we need to start showing multiple CVE names in UI
     # def candlepin_name
     #   "#{environment.label}/#{content_view.label}"
@@ -52,7 +57,7 @@ module Katello
     def generate_info
       self.name ||= environment.name
 
-      if content_view.default?
+      if default_environment?
         self.label ||= environment.label
         self.cp_id ||= Katello::Util::Data.hexdigest(environment.organization.label)
       else

data/app/models/katello/docker_meta_tag.rb

@@ -111,7 +111,7 @@ module Katello
       if grouped
         grouped_fields = "#{table_name}.name, katello_repositories.root_id"
         ids = distinct.select("ON (#{grouped_fields}) #{table_name}.id").joins(:repositories)
-        self.where(:id => ids)
+        self.where(:id => ids).where("#{self.table_name}.schema1_id in (#{sql}) or #{self.table_name}.schema2_id in (#{sql})")
       else
         self.where("#{self.table_name}.schema1_id in (#{sql}) or #{self.table_name}.schema2_id in (#{sql})")
       end

data/app/models/katello/docker_tag.rb

@@ -73,7 +73,7 @@ module Katello
       self.where(:id => ids)
     end
 
-    def self.completer_scope_options
+    def self.completer_scope_options(_search)
       {"#{Katello::Repository.table_name}" => lambda { |repo_class| repo_class.docker_type } }
     end
 

data/app/models/katello/erratum.rb

@@ -71,7 +71,7 @@ module Katello
       # It is not the errata "belonging" to the host. Its rather the errata that is "applicable"
       # which is calculated elsewhere.
 
-      self.joins(:content_facets).
+      self.group(:id).distinct.joins(:content_facets).
         where("#{Katello::Host::ContentFacet.table_name}.host_id" => hosts.select(:id))
     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_TRACER_PACKAGE_NAMES = [ "python-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
+                                   "python3-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
+                                   HOST_TOOLS_TRACER_PACKAGE_NAME ].freeze
 
       belongs_to :kickstart_repository, :class_name => "::Katello::Repository", :inverse_of => :kickstart_content_facets
       belongs_to :content_source, :class_name => "::SmartProxy", :inverse_of => :content_facets
@@ -207,7 +210,7 @@ module Katello
         ::Katello::Applicability::ApplicableContentHelper.new(self, ::Katello::Erratum, bound_repos).calculate_and_import
         ::Katello::Applicability::ApplicableContentHelper.new(self, ::Katello::ModuleStream, bound_repos).calculate_and_import
         update_applicability_counts
-        self.update_errata_status
+        self.host&.refresh_statuses([::Katello::ErrataStatus, ::Katello::RhelLifecycleStatus])
       end
 
       def update_applicability_counts
@@ -305,12 +308,12 @@ module Katello
       end
 
       def tracer_installed?
-        self.host.installed_packages.where("#{Katello::InstalledPackage.table_name}.name" => [ "python-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
-                                                                                               "python3-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
-                                                                                               HOST_TOOLS_TRACER_PACKAGE_NAME ]).any? ||
-          self.host.installed_debs.where("#{Katello::InstalledDeb.table_name}.name" => [ "python-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
-                                                                                         "python3-#{HOST_TOOLS_TRACER_PACKAGE_NAME}",
-                                                                                         HOST_TOOLS_TRACER_PACKAGE_NAME ]).any?
+        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
+
+      def tracer_rpm_available?
+        ::Katello::Rpm.yum_installable_for_host(self.host).where(name: ALL_TRACER_PACKAGE_NAMES).any?
       end
 
       def host_tools_installed?

data/app/models/katello/product.rb

@@ -34,6 +34,7 @@ module Katello
     validates_lengths_from_database :except => [:label]
     validates :provider_id, :presence => true
     validate :ensure_provider_type_matches_id
+    validate :ensure_no_sync_plans_on_empty_product
     validates_with Validators::KatelloNameFormatValidator, :attributes => :name
     validates_with Validators::KatelloLabelFormatValidator, :attributes => :label
     validates_with Validators::ProductUniqueAttributeValidator, :attributes => :name
@@ -263,5 +264,12 @@ module Katello
         errors.add(:base, _("Cannot associate a Red Hat provider with a custom product"))
       end
     end
+
+    def ensure_no_sync_plans_on_empty_product
+      return if sync_plan_id.nil?
+      if redhat? && !enabled?
+        errors.add(:base, _("Cannot add disabled Red Hat product %s to sync plan!") % name)
+      end
+    end
   end
 end