katello 4.4.1 → 4.5.0

data/app/lib/actions/pulp3/orchestration/alternate_content_source/refresh.rb

@@ -0,0 +1,15 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module AlternateContentSource
+        class Refresh < Pulp3::Abstract
+          def plan(acs, smart_proxy)
+            sequence do
+              plan_action(Actions::Pulp3::AlternateContentSource::Refresh, acs, smart_proxy)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/update.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module AlternateContentSource
+        class Update < Pulp3::Abstract
+          def plan(acs, smart_proxy)
+            sequence do
+              plan_action(Actions::Pulp3::AlternateContentSource::UpdateRemote, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::Update, acs, smart_proxy)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module Actions
                   plan_action(Actions::Pulp3::Repository::CopyContent, repo, SmartProxy.pulp_primary!,
                                                     repo.library_instance,
                                                     copy_all: true,
-                                                    mirror: content_view_version.content_view.library_import?)
+                                                    mirror: content_view_version.content_view.generated?)
                   plan_action(Actions::Pulp3::Repository::SaveVersion, repo.library_instance)
                   plan_action(Katello::Repository::IndexContent, id: repo.library_instance_id)
                   plan_action(Katello::Repository::MetadataGenerate, repo.library_instance, :force => true)

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

@@ -0,0 +1,51 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module ContentViewVersion
+        class ExportRepository < Actions::EntryAction
+          def plan(repository,
+                    chunk_size: nil,
+                    from_history: nil)
+            action_subject(repository)
+            validate_repositories_immediate!(repository)
+
+            content_view = ::Katello::Pulp3::ContentViewVersion::Export.find_repository_export_view(
+                                                                           repository: repository,
+                                                                           create_by_default: true)
+            content_view.update!(repository_ids: [repository.library_instance_or_self.id])
+
+            sequence do
+              publish_action = plan_action(::Actions::Katello::ContentView::Publish, content_view, '')
+              export_action = plan_action(Actions::Katello::ContentViewVersion::Export,
+                                          content_view_version: publish_action.version,
+                                          chunk_size: chunk_size,
+                                          from_history: from_history)
+              plan_self(export_action_output: export_action.output)
+            end
+          end
+
+          def run
+            output[:export_history_id] = input[:export_action_output][:export_history_id]
+          end
+
+          def humanized_name
+            _("Export Repository")
+          end
+
+          def rescue_strategy
+            Dynflow::Action::Rescue::Skip
+          end
+
+          def validate_repositories_immediate!(repository)
+            unless repository.immediate?
+              fail _("NOTE: Unable to fully export repository '%{repository}' because"\
+                     " it does not have the 'immediate' download policy."\
+                     " Update the download policy and sync the affected repository to include them in the export."\
+                       % { repository: repository.name })
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,8 +16,8 @@ module Actions
               ).output
 
               plan_action(
-                ::Actions::Pulp3::ContentViewVersion::Import,
-                content_view_version_id: content_view_version.id,
+                ::Actions::Pulp3::ContentViewVersion::CreateImport,
+                organization_id: content_view_version.content_view.organization_id,
                 smart_proxy_id: smart_proxy.id,
                 importer_data: importer_output[:importer_data],
                 path: path,
@@ -36,7 +36,10 @@ module Actions
                 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,
                             importer_data: importer_output[:importer_data])
               plan_self(
                 content_view_name: content_view_version.name,

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

@@ -5,7 +5,7 @@ module Actions
         #This task creates a content unit and may or may not create a new repository version in the process
         def plan(file, repository, smart_proxy, tasks, unit_type_id, options = {})
           options[:file_name] = file[:filename]
-          options[:sha256] = file[:sha256] || Digest::SHA256.hexdigest(File.read(file[:path]))
+          options[:sha256] = file[:sha256] || (Digest::SHA256.hexdigest(File.read(file[:path])) if file[:path].present?)
           plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :tasks => tasks, :unit_type_id => unit_type_id, :options => options)
         end
 

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

@@ -23,6 +23,7 @@ module Katello
           rescue_from Errors::CdnSubstitutionError, :with => :rescue_from_bad_data
           rescue_from Errors::RegistrationError, :with => :rescue_from_bad_data
           rescue_from ActionController::ParameterMissing, :with => :rescue_from_missing_param
+          rescue_from ::ForemanTasks::Lock::LockConflict, :with => :rescue_from_bad_data
         end
 
         protected

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

@@ -206,21 +206,22 @@ module Katello
         search_up_to = up_to.present? ? "ended_at < \"#{up_to}\"" : nil
         search_since = since.present? ? "ended_at > \"#{since}\"" : nil
         search_result = status.present? && status != 'all' ? "result = #{status}" : nil
-        search = [search_up_to, search_since, search_result].compact.join(' and ')
+        labels = 'label ^ (Actions::Katello::Host::Erratum::Install, Actions::Katello::Host::Erratum::ApplicableErrataInstall)'
+        select = 'foreman_tasks_tasks.*'
 
         if Katello.with_remote_execution?
-          condition = ["state = 'stopped' AND ((label = 'Actions::RemoteExecution::RunHostJob' AND templates.id = ?) " \
-                       "OR label = 'Actions::Katello::Host::Erratum::Install' OR label = 'Actions::Katello::Host::Erratum::ApplicableErrataInstall')",
-                       RemoteExecutionFeature.feature('katello_errata_install').job_template_id]
+          new_labels = 'label = Actions::RemoteExecution::RunHostJob AND remote_execution_feature.label ^ (katello_errata_install, katello_errata_install_by_search)'
+          labels = [labels, new_labels].map { |label| "(#{label})" }.join(' OR ')
+          select += ',template_invocations.id AS template_invocation_id'
         else
-          condition = "state = 'stopped' AND (label = 'Actions::Katello::Host::Erratum::Install' OR label = 'Actions::Katello::Host::Erratum::ApplicableErrataInstall')"
+          select += ',NULL AS template_invocation_id'
         end
 
+        search = [search_up_to, search_since, search_result, "state = stopped", labels].compact.join(' and ')
+
         tasks = load_resource(klass: ForemanTasks::Task,
-                              where: condition,
                               permission: 'view_foreman_tasks',
-                              joins: 'LEFT OUTER JOIN template_invocations ON foreman_tasks_tasks.id = template_invocations.run_host_job_task_id LEFT OUTER JOIN templates ON template_invocations.template_id = templates.id',
-                              select: 'foreman_tasks_tasks.*,template_invocations.id AS template_invocation_id',
+                              select: select,
                               search: search)
         only_host_ids = ::Host.search_for(host_filter).pluck(:id) if host_filter
 
@@ -325,9 +326,21 @@ module Katello
         # Pick katello agent errata if present
         # Otherwise pick rex errata. There are multiple template inputs, such as errata, pre_script and post_script we only need the
         # errata input here.
-        @_tasks_errata_cache[task.id] ||= agent_input.presence || TemplateInvocationInputValue.joins(:template_input)
-                                            .where("template_invocation_id = ? AND template_inputs.name = ?", task.template_invocation_id, 'errata')
-                                            .first.value.split(',')
+        @_tasks_errata_cache[task.id] ||= agent_input.presence || errata_ids_from_template_invocation(task, task_input)
+      end
+
+      def errata_ids_from_template_invocation(task, task_input)
+        if task_input.key?('job_features') && task_input['job_features'].include?('katello_errata_install_by_search')
+          # This may give wrong results if the template is not rendered yet
+          # This also will not work for jobs run before we started storing
+          #   resolved ids in the template
+          script = task.execution_plan.actions[1].try(:input).try(:[], 'script') || ''
+          found = script.lines.find { |line| line.start_with? '# RESOLVED_ERRATA_IDS=' } || ''
+          (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(',')
+        end
       end
     end
   end

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

@@ -118,7 +118,9 @@ module Katello
 
         def find_organization(label)
           response = get("/api/v2/organizations?search=#{CGI.escape("label = #{label}")}")
-          JSON.parse(response)['results'].first
+          JSON.parse(response)['results'].first.tap do |org|
+            fail "Specified organization was not found: #{label}" if org.nil?
+          end
         rescue => e
           Rails.logger.error("Couldn't load upstream organization with label=#{label} error=#{e.message}")
           raise e

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

@@ -56,10 +56,9 @@ module Katello
         matching_errata = []
         errata.each do |erratum|
           # The erratum should be copied if package_pulp_hrefs has all of its packages that are available in the source repo.
-          next if erratum.packages.empty?
           rpms_in_erratum_and_source_repo = erratum.packages.pluck(:filename) & source_repo_rpm_filenames
-          next if rpms_in_erratum_and_source_repo.empty?
-          if (rpms_in_erratum_and_source_repo - rpm_filenames - srpm_filenames).empty?
+          if (rpms_in_erratum_and_source_repo - rpm_filenames - srpm_filenames).empty? ||
+              erratum.packages.empty? || rpms_in_erratum_and_source_repo.empty?
             matching_errata << erratum
           end
         end

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

@@ -0,0 +1,29 @@
+module Katello
+  module Validators
+    class AlternateContentSourcePathValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if value
+          if attribute == :base_url
+            unless AlternateContentSourcePathValidator.validate_base_url(value)
+              record.errors[attribute] << N_("%s is not a valid path") % value
+            end
+          elsif attribute == :subpaths
+            unless AlternateContentSourcePathValidator.validate_subpaths(value)
+              record.errors[attribute] << N_('All subpaths must have a slash at the end and none at the front')
+            end
+          end
+        end
+      end
+
+      def self.validate_base_url(base_url)
+        base_url =~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
+      end
+
+      # Subpaths must have a slash at the end and none at the front: 'path/'
+      def self.validate_subpaths(subpaths)
+        bad_subpaths = subpaths.select { |subpath| subpath[0] == '/' || subpath[-1] != '/' }
+        bad_subpaths.empty?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Katello
+  module Validators
+    class ContentDefaultHttpProxySettingValidator < ActiveModel::Validator
+      def validate(record)
+        proxy = HttpProxy.where(name: record.value).first
+        return if proxy || record.value.blank?
+
+        record.errors.add(:base, _('There is no such HTTP proxy'))
+      end
+    end
+  end
+end

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

@@ -5,12 +5,17 @@ module Katello
         #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 && environment_id
+        if record.content_view_id
           view = ContentView.where(:id => record.content_view_id).first
-          env = KTEnvironment.where(:id => environment_id).first
-          unless view.blank? || env.blank? || view.in_environment?(env)
-            record.errors[:base] << _("Content view '%{view}' is not in environment '%{env}'") %
-                                      {:view => view.name, :env => env.name}
+          if environment_id
+            env = KTEnvironment.where(:id => environment_id).first
+            unless view.blank? || env.blank? || view.in_environment?(env)
+              record.errors[:base] << _("Content view '%{view}' is not in environment '%{env}'") %
+                                        {:view => view.name, :env => env.name}
+            end
+          end
+          if view&.generated_for_repository?
+            record.errors[:base] << _("Generated Content views cannot be assigned to Host/Activation Keys")
           end
         end
       end

data/app/models/katello/alternate_content_source.rb

@@ -0,0 +1,71 @@
+module Katello
+  class AlternateContentSource < Katello::Model
+    include Ext::LabelFromName
+    include Encryptable
+    include ::ScopedSearchExtensions
+    include Authorization::AlternateContentSource
+    include ForemanTasks::Concerns::ActionSubject
+
+    self.table_name = :katello_alternate_content_sources
+
+    # TODO: simplified, rhui
+    ACS_TYPES = %w(custom).freeze
+    CONTENT_TYPES = [::Katello::Repository::YUM_TYPE, ::Katello::Repository::FILE_TYPE].freeze
+
+    encrypts :upstream_password
+
+    belongs_to :ssl_ca_cert, inverse_of: :ssl_ca_alternate_content_sources, class_name: "Katello::ContentCredential"
+    belongs_to :ssl_client_cert, inverse_of: :ssl_client_alternate_content_sources, class_name: "Katello::ContentCredential"
+    belongs_to :ssl_client_key, inverse_of: :ssl_key_alternate_content_sources, class_name: "Katello::ContentCredential"
+    belongs_to :http_proxy, inverse_of: :alternate_content_sources
+    has_many :smart_proxy_alternate_content_sources, dependent: :destroy,
+             inverse_of: :alternate_content_source
+    has_many :smart_proxies, through: :smart_proxy_alternate_content_sources
+
+    validates :base_url, if: :custom?, presence: true
+    validates :verify_ssl, if: :custom?, exclusion: [nil]
+    validates :alternate_content_source_type, inclusion: {
+      in: ->(_) { ACS_TYPES },
+      allow_blank: false,
+      message: ->(_, _) { _("is not a valid type. Must be one of the following: %s") % ACS_TYPES.join(',') }
+    }
+    validates :content_type, if: :custom?, inclusion: {
+      in: ->(_) { RepositoryTypeManager.defined_repository_types.keys & CONTENT_TYPES },
+      allow_blank: false,
+      message: ->(_, _) { _("is not allowed for ACS. Must be one of the following: %s") % (RepositoryTypeManager.defined_repository_types.keys & CONTENT_TYPES).join(',') }
+    }
+    validates_with Validators::AlternateContentSourcePathValidator, :attributes => [:base_url, :subpaths], :if => :custom?
+
+    scoped_search on: :name, complete_value: true
+    scoped_search on: :label, complete_value: true
+    scoped_search on: :description, complete_value: true
+    scoped_search on: :base_url, complete_value: true
+    scoped_search on: :subpath, ext_method: :search_by_subpath
+    scoped_search on: :content_type, complete_value: true
+    scoped_search on: :alternate_content_source_type, complete_value: true
+    scoped_search on: :upstream_username, complete_value: true
+    scoped_search on: :smart_proxy_id, relation: :smart_proxy_alternate_content_sources, validator: ScopedSearch::Validators::INTEGER, only_explicit: true
+
+    def backend_service(smart_proxy)
+      @service ||= ::Katello::Pulp3::AlternateContentSource.new(self, smart_proxy)
+    end
+
+    def custom?
+      alternate_content_source_type == 'custom'
+    end
+
+    def self.with_type(content_type)
+      where(content_type: content_type)
+    end
+
+    def self.search_by_subpath(_key, operator, value)
+      conditions = sanitize_sql_for_conditions(["? #{operator} ANY (subpaths)", value_to_sql(operator, value)])
+      { conditions: conditions }
+    end
+
+    def latest_dynflow_refresh_task
+      @latest_dynflow_refresh_task ||= ForemanTasks::Task::DynflowTask.where(:label => Actions::Katello::AlternateContentSource::Refresh.name).
+          for_resource(self).order(:started_at).last
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Katello
+  module Authorization::AlternateContentSource
+    extend ActiveSupport::Concern
+
+    include Authorizable
+
+    def readable?
+      authorized?(:view_alternate_content_sources)
+    end
+
+    def editable?
+      authorized?(:edit_alternate_content_sources)
+    end
+
+    def deletable?
+      authorized?(:destroy_alternate_content_sources)
+    end
+
+    module ClassMethods
+      def readable
+        authorized(:view_alternate_content_sources)
+      end
+
+      def editable
+        authorized(:edit_alternate_content_sources)
+      end
+
+      def deletable
+        authorized(:destroy_alternate_content_sources)
+      end
+    end
+  end
+end

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

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

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

@@ -10,10 +10,17 @@ module Katello
       end
 
       def find_repository
-        root = ::Katello::RootRepository.where(product_id: product.id,
-                                    content_id: content.cp_content_id,
-                                    minor: minor,
-                                    arch: arch).first
+        if substitutions[:basearch]
+          root = ::Katello::RootRepository.where(product_id: product.id,
+                                                 content_id: content.cp_content_id,
+                                                 minor: minor,
+                                                 arch: arch).first
+        else
+          root = ::Katello::RootRepository.where(product_id: product.id,
+                                                 content_id: content.cp_content_id,
+                                                 minor: minor).first
+        end
+
         if root
           Katello::Repository.where(root: root,
                                     environment_id: product.organization.library.id).first
@@ -44,7 +51,7 @@ module Katello
       end
 
       def validate!
-        return if katello_content_type == Repository::OSTREE_TYPE || product.organization.cdn_configuration.airgapped?
+        return if katello_content_type == Repository::OSTREE_TYPE || product.organization.cdn_configuration.export_sync?
         substitutor.validate_substitutions(content, substitutions)
       end
 
@@ -74,7 +81,7 @@ module Katello
       end
 
       def feed_url
-        return if product.organization.cdn_configuration.airgapped?
+        return if product.organization.cdn_configuration.export_sync?
         @feed_url ||= if product.cdn_resource&.respond_to?(:repository_url)
                         product.cdn_resource.repository_url(content_label: content.label, arch: arch, major: version[:major], minor: version[:minor])
                       else

data/app/models/katello/cdn_configuration.rb

@@ -3,24 +3,24 @@ module Katello
     include Encryptable
     self.inheritance_column = nil
     CDN_TYPE = 'redhat_cdn'.freeze
-    UPSTREAM_SERVER_TYPE = 'upstream_server'.freeze
-    AIRGAPPED_TYPE = 'airgapped'.freeze
+    NETWORK_SYNC = 'network_sync'.freeze
+    EXPORT_SYNC = 'export_sync'.freeze
 
-    TYPES = [CDN_TYPE, UPSTREAM_SERVER_TYPE, AIRGAPPED_TYPE].freeze
+    TYPES = [CDN_TYPE, NETWORK_SYNC, EXPORT_SYNC].freeze
 
     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 :password, presence: true, if: :upstream_server?
-    validates :username, presence: true, if: :upstream_server?
-    validates :upstream_organization_label, presence: true, if: :upstream_server?
+    validates :password, presence: true, if: :network_sync?
+    validates :username, presence: true, if: :network_sync?
+    validates :upstream_organization_label, presence: true, if: :network_sync?
 
-    validates :url, presence: true, unless: :airgapped?
-    validates_with Validators::KatelloUrlFormatValidator, attributes: :url, unless: :airgapped?
+    validates :url, presence: true, unless: :export_sync?
+    validates_with Validators::KatelloUrlFormatValidator, attributes: :url, unless: :export_sync?
     validates_with Validators::KatelloLabelFormatValidator, attributes: :upstream_organization_label, if: proc { upstream_organization_label.present? }
-    validate :non_redhat_configuration, if: :upstream_server?
+    validate :non_redhat_configuration, if: :network_sync?
 
     before_validation :reset_fields
 
@@ -32,20 +32,20 @@ module Katello
       type == CDN_TYPE
     end
 
-    def airgapped?
-      type == AIRGAPPED_TYPE
+    def export_sync?
+      type == EXPORT_SYNC
     end
 
-    def upstream_server?
-      type == UPSTREAM_SERVER_TYPE
+    def network_sync?
+      type == NETWORK_SYNC
     end
 
     private
 
     def reset_fields
-      return if upstream_server?
+      return if network_sync?
 
-      self.url = nil if airgapped?
+      self.url = nil if export_sync?
       self.url ||= SETTINGS[:katello][:redhat_repository_url] if redhat_cdn?
       self.username = nil
       self.password = nil

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

@@ -33,6 +33,9 @@ module Katello
         has_many :applicable_debs, :through => :content_facet
         has_many :applicable_rpms, :through => :content_facet
         has_many :applicable_module_streams, :through => :content_facet
+        has_many :bound_repositories, :through => :content_facet
+        has_many :bound_root_repositories, :through => :content_facet
+        has_many :bound_content, :through => :content_facet
 
         scoped_search :relation => :content_view, :on => :name, :complete_value => true, :rename => :content_view
         scoped_search :relation => :content_facet, :on => :content_view_id, :rename => :content_view_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
@@ -46,6 +49,8 @@ module Katello
         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
+        scoped_search :relation => :bound_root_repositories, :on => :name, :rename => :repository, :complete_value => true, :ext_method => :find_by_repository_name, :only_explicit => true
+        scoped_search :relation => :bound_content, :on => :label, :rename => :repository_content_label, :complete_value => true, :ext_method => :find_by_repository_content_label, :only_explicit => true
 
         # preserve options set by facets framework, but add new :reject_if statement
         accepts_nested_attributes_for(
@@ -129,6 +134,26 @@ module Katello
           end
         end
 
+        def find_by_repository_content_label(_key, operator, value)
+          conditions = sanitize_sql_for_conditions(["#{Katello::Content.table_name}.label #{operator} ?", value_to_sql(operator, value)])
+          facets = Katello::Host::ContentFacet.joins_repositories.where(conditions)
+          if facets.empty?
+            { :conditions => "1=0" }
+          else
+            { :conditions => "#{::Host::Managed.table_name}.id IN (#{facets.pluck(:host_id).join(',')})" }
+          end
+        end
+
+        def find_by_repository_name(_key, operator, value)
+          conditions = sanitize_sql_for_conditions(["#{Katello::RootRepository.table_name}.name #{operator} ?", value_to_sql(operator, value)])
+          facets = Katello::Host::ContentFacet.joins_repositories.where(conditions)
+          if facets.empty?
+            { :conditions => "1=0" }
+          else
+            { :conditions => "#{::Host::Managed.table_name}.id IN (#{facets.pluck(:host_id).join(',')})" }
+          end
+        end
+
         def in_content_view_environment(content_view: nil, lifecycle_environment: nil)
           relation = self.joins(:content_facet)
           relation = relation.where("#{::Katello::Host::ContentFacet.table_name}.content_view_id" => content_view) if content_view

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

@@ -45,7 +45,7 @@ module Katello
         prepend ::ForemanRemoteExecution::HostExtensions if ::Katello.with_remote_execution?
         prepend Overrides
 
-        delegate :content_source_id, :content_view_id, :lifecycle_environment_id, :kickstart_repository_id, to: :content_facet, allow_nil: true
+        delegate :content_source_id, :content_view_id, :lifecycle_environment_id, :kickstart_repository_id, :bound_repositories, to: :content_facet, allow_nil: true
 
         has_many :dispatch_histories, :class_name => "::Katello::Agent::DispatchHistory", :foreign_key => :host_id, :dependent => :delete_all
 
@@ -246,7 +246,6 @@ module Katello
         streams = {}
         module_streams.each do |module_stream|
           stream = AvailableModuleStream.where(name: module_stream["name"],
-                                               context: module_stream["context"],
                                                stream: module_stream["stream"]).first_or_create!
           streams[stream.id] = module_stream
         end
@@ -424,9 +423,10 @@ module Katello
         ::Katello::Erratum.installable_for_hosts([self]).search_for(search).pluck(:errata_id)
       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 }
+      def filtered_entitlement_quantity_consumed(pool)
+        entitlements = subscription_facet.candlepin_consumer.filter_entitlements(pool.cp_id)
+        return nil if entitlements.empty?
+        entitlements.sum { |e| e[:quantity] }
       end
 
       protected
@@ -446,7 +446,8 @@ 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, :traces_helpers, :advisory_ids, :package_names_for_job_template
+        :installed_packages, :traces_helpers, :advisory_ids, :package_names_for_job_template,
+        :filtered_entitlement_quantity_consumed, :bound_repositories
 end
 
 class ActiveRecord::Associations::CollectionProxy::Jail < Safemode::Jail

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

@@ -6,6 +6,8 @@ module Katello
       included do
         has_many :root_repositories, :class_name => "::Katello::RootRepository", :foreign_key => :http_proxy_id,
           :inverse_of => :http_proxy, :dependent => :nullify
+        has_many :alternate_content_sources, :class_name => "::Katello::AlternateContentSource", :foreign_key => :http_proxy_id,
+          :inverse_of => :http_proxy, :dependent => :nullify
         after_update :update_default_proxy_setting
         after_commit :update_repository_proxy_details
         before_destroy :remove_references_to_proxy
@@ -29,6 +31,7 @@ module Katello
 
       def remove_references_to_proxy
         root_repos = repositories_with_proxy(nil).uniq.sort
+        acss = ::Katello::AlternateContentSource.where(http_proxy_id: id)
 
         setting = Setting.find_by(name: 'content_default_http_proxy')
         if setting&.value && setting.value == self.name
@@ -43,6 +46,17 @@ module Katello
             http_proxy_policy: Katello::RootRepository::GLOBAL_DEFAULT_HTTP_PROXY,
             http_proxy_id: nil)
         end
+
+        unless acss.empty?
+          acss.each do |acs|
+            ForemanTasks.async_task(
+              ::Actions::Katello::AlternateContentSource::Update,
+              acs,
+              acs.smart_proxies,
+              http_proxy_id: nil
+            )
+          end
+        end
       end
 
       def update_default_proxy_setting