katello 4.5.1 → 4.8.0.rc2

data/app/models/katello/erratum.rb

@@ -24,7 +24,8 @@ module Katello
     has_many :cves, :class_name => "Katello::ErratumCve", :dependent => :destroy, :inverse_of => :erratum
     has_many :packages, :class_name => "Katello::ErratumPackage", :dependent => :destroy, :inverse_of => :erratum
 
-    scoped_search :on => :errata_id, :only_explicit => true
+    scoped_search :on => :id, :rename => :db_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
+    scoped_search :on => :errata_id, :complete_value => true, :only_explicit => true
     scoped_search :on => :errata_id, :rename => :id, :complete_value => true, :only_explicit => true
     scoped_search :on => :title
     scoped_search :on => :title, :rename => :synopsis, :complete_value => true, :only_explicit => true
@@ -127,10 +128,14 @@ module Katello
       statement = query_clauses.join(" AND ")
       ModuleStream.where(:id => ModuleStreamErratumPackage.joins(:erratum_package => {:erratum => :repository_errata}).
           where("#{RepositoryErratum.table_name}.repository_id" => repo.id).
-          where(statement).select("#{ModuleStreamErratumPackage.table_name}.module_stream_id")) -
+          where(statement).select("#{ModuleStreamErratumPackage.table_name}.module_stream_id")).
+        joins(:repository_module_streams).
+        where("#{RepositoryModuleStream.table_name}.repository_id" => repo.id) -
       ModuleStream.where(:id => ModuleStreamErratumPackage.joins(:erratum_package => {:erratum => :repository_errata}).
           where("#{RepositoryErratum.table_name}.repository_id" => repo.id).
-          where(statement).where("#{Erratum.table_name}.errata_id" => additional_included_errata.pluck(:errata_id)).select("#{ModuleStreamErratumPackage.table_name}.module_stream_id"))
+          where(statement).where("#{Erratum.table_name}.errata_id" => additional_included_errata.pluck(:errata_id)).select("#{ModuleStreamErratumPackage.table_name}.module_stream_id")).
+        joins(:repository_module_streams).
+        where("#{RepositoryModuleStream.table_name}.repository_id" => repo.id)
     end
 
     def module_streams
@@ -148,6 +153,10 @@ module Katello
       end
     end
 
+    def module_stream_specs
+      packages.collect { |package| package.module_streams.map(&:module_spec) }.flatten.uniq
+    end
+
     def module_stream_objects
       streams = packages.map do |pack|
         pack.module_streams

data/app/models/katello/glue/candlepin/owner.rb

@@ -30,7 +30,6 @@ module Katello
       def owner_details
         @owner_details ||= find_owner
         @owner_details['virt_who'] ||= self.subscriptions.using_virt_who.any?
-
         @owner_details
       end
 
@@ -46,6 +45,10 @@ module Katello
         self.owner_details['contentAccessMode']
       end
 
+      def content_access_mode_list
+        self.owner_details['contentAccessModeList'].split(',')
+      end
+
       def simple_content_access?(cached: true)
         Rails.cache.fetch("#{self.label}_simple_content_access?", expires_in: 1.minute, force: !cached) do
           content_access_mode == "org_environment"

data/app/models/katello/glue/candlepin/pool.rb

@@ -56,6 +56,12 @@ module Katello
         end
       end
 
+      def import_candlepin_records(pools, org)
+        # Skip import of pools that were associated with an orphaned custom product
+        pools = pools.reject { |cp_pool| ::Katello::Glue::Provider.orphaned_custom_product?(cp_pool['productId'], org) }
+        super(pools, org)
+      end
+
       def import_candlepin_record(record:, organization:)
         subscription = determine_subscription(
           product_id: record['productId'],

data/app/models/katello/glue/candlepin/product.rb

@@ -32,7 +32,7 @@ module Katello
       id.match(/^\d+$/) #engineering products are numeric
     end
 
-    def self.import_from_cp(attrs, organization)
+    def self.import_redhat_product_from_cp(attrs, organization)
       import_logger = attrs[:import_logger]
 
       product_attrs = {'name' => attrs['name'],
@@ -50,6 +50,12 @@ module Katello
       raise e
     end
 
+    def self.custom_product_id?(id)
+      # Engineering products with 12 digits are custom products (see Katello::Product#unused_product_id)
+      # however, previously generated ids are random and can be shorter than 12 digits
+      id =~ /^\d{8,12}$/
+    end
+
     module InstanceMethods
       def support_level
         return _attr(:support_level)

data/app/models/katello/glue/candlepin/subscription.rb

@@ -21,6 +21,11 @@ module Katello
           !Glue::Candlepin::Product.engineering_product_id?(product['id']) || Katello::Product.find_by(:cp_id => product['id']).try(:custom?)
         end
       end
+
+      def import_candlepin_records(cp_subs, org)
+        cp_subs = cp_subs.reject { |cp_subscription| ::Katello::Glue::Provider.orphaned_custom_product?(cp_subscription['productId'], org) }
+        super(cp_subs, org)
+      end
     end
 
     module InstanceMethods

data/app/models/katello/glue/provider.rb

@@ -6,6 +6,30 @@ module Katello
       base.send :include, InstanceMethods
     end
 
+    def self.orphaned_custom_product?(cp_id, organization)
+      return unless cp_id.present? && orphaned_product?(cp_id, organization)
+      product_provider = provider_for_cp_id(cp_id: cp_id, organization: organization)
+      if product_provider.redhat_provider?
+        false
+      else
+        Rails.logger.warn "Found orphaned object with id #{cp_id} in Candlepin. Skipping import into Katello; run rake katello:clean_candlepin_orphaned_products to remove it from Candlepin."
+        true
+      end
+    end
+
+    def self.orphaned_product?(cp_id, organization)
+      !organization.products.where(:cp_id => cp_id).exists?
+    end
+
+    def self.provider_for_cp_id(cp_id:, organization:)
+      return organization.redhat_provider unless ::Katello::Glue::Candlepin::Product.engineering_product_id?(cp_id)
+      if ::Katello::Glue::Candlepin::Product.custom_product_id?(cp_id)
+        organization.anonymous_provider
+      else
+        organization.redhat_provider
+      end
+    end
+
     module InstanceMethods
       API_URL = 'https://subscription.rhsm.redhat.com/subscription/consumers/'.freeze
 
@@ -21,31 +45,6 @@ module Katello
         self.products.any? { |p| p.synced? }
       end
 
-      # Get the most relavant status for all the repos in this Provider
-      def sync_status
-        statuses = self.products.reject { |r| r.empty? }.map { |r| r.sync_status }
-        return PulpSyncStatus.new(:state => PulpSyncStatus::Status::NOT_SYNCED) if statuses.empty?
-
-        [PulpSyncStatus::Status::RUNNING,
-         PulpSyncStatus::Status::NOT_SYNCED,
-         PulpSyncStatus::Status::CANCELED,
-         PulpSyncStatus::Status::ERROR].each do |interesting_status|
-          relevant_status = statuses.find { |s| s[:state].to_s == interesting_status.to_s }
-          return relevant_status if relevant_status
-        end
-
-        #else -> all finished
-        return statuses[0]
-      end
-
-      def sync_state
-        self.sync_status[:state]
-      end
-
-      def sync_size
-        self.products.inject(0) { |sum, v| sum + v.sync_status.progress.total_size }
-      end
-
       def last_sync
         sync_times = []
         self.products.each do |prod|
@@ -66,11 +65,6 @@ module Katello
         # Default to Red Hat
         url = upstream['apiUrl'] || API_URL
 
-        # TODO: wait until ca_path is supported
-        #       https://github.com/L2G/rest-client-fork/pull/8
-        #ca_file = '/etc/candlepin/certs/upstream/subscription.rhn.stage.redhat.com.crt'
-        ca_file = nil
-
         params = {}
         params[:capabilities] = Resources::Candlepin::CandlepinPing.ping['managerCapabilities'].inject([]) do |result, element|
           result << {'name' => element}
@@ -80,26 +74,25 @@ module Katello
                                                       upstream['idCert']['key'], ca_file, params)
       end
 
-      def owner_upstream_export(upstream, zip_file_path, _options)
-        if !upstream['idCert'] || !upstream['idCert']['cert'] || !upstream['idCert']['key']
-          Rails.logger.error "Upstream identity certificate not available"
-          fail _("Upstream identity certificate not available")
-        end
-
-        # Default to Red Hat
+      def start_owner_upstream_export(upstream)
+        validate_upstream_identity_cert!(upstream)
         url = upstream['apiUrl'] || API_URL
 
-        # TODO: wait until ca_path is supported
-        #       https://github.com/L2G/rest-client-fork/pull/8
-        #ca_file = '/etc/candlepin/certs/upstream/subscription.rhn.stage.redhat.com.crt'
-        ca_file = nil
+        response = Resources::Candlepin::UpstreamConsumer.get_export("#{url}#{upstream['uuid']}/export/async", upstream['idCert']['cert'],
+          upstream['idCert']['key'], ca_file)
+        JSON.parse(response)
+      end
 
-        data = Resources::Candlepin::UpstreamConsumer.export("#{url}#{upstream['uuid']}/export", upstream['idCert']['cert'],
+      def retrieve_owner_upstream_export(upstream, zip_file_path, export_id)
+        validate_upstream_identity_cert!(upstream)
+        url = upstream['apiUrl'] || API_URL
+
+        data = Resources::Candlepin::UpstreamConsumer.get_export("#{url}#{upstream['uuid']}/export/#{export_id}", upstream['idCert']['cert'],
                                                              upstream['idCert']['key'], ca_file)
 
         File.write(zip_file_path, data, mode: 'wb')
 
-        return true
+        true
       end
 
       def del_owner_import
@@ -128,10 +121,11 @@ module Katello
         cp_products = ::Katello::Resources::Candlepin::Product.all(organization.label, [:id, :name, :multiplier, :productContent])
         cp_products = cp_products.select { |prod| Glue::Candlepin::Product.engineering_product_id?(prod['id']) }
 
-        prod_content_importer = Katello::ProductContentImporter.new
+        prod_content_importer = Katello::ProductContentImporter.new(cp_products)
 
         Katello::Logging.time("Imported #{cp_products.size} products") do
           cp_products.each do |product_json|
+            next if ::Katello::Glue::Provider.orphaned_custom_product?(product_json['id'], organization)
             product = import_product(product_json)
             prod_content_importer.add_product_content(product, product_json['productContent']) if product.redhat?
           end
@@ -150,7 +144,7 @@ module Katello
         if product&.redhat?
           product.update!(:name => product_json['name']) unless product.name == product_json['name']
         elsif product.nil?
-          product = Glue::Candlepin::Product.import_from_cp(product_json, organization)
+          product = Glue::Candlepin::Product.import_redhat_product_from_cp(product_json, organization)
         end
         product
       end
@@ -168,6 +162,22 @@ module Katello
         redhat_provider? ? candlepin_ping['rulesVersion'] : ''
       end
 
+      private
+
+      def validate_upstream_identity_cert!(upstream)
+        if !upstream['idCert'] || !upstream['idCert']['cert'] || !upstream['idCert']['key']
+          Rails.logger.error "Upstream identity certificate not available"
+          fail _("Upstream identity certificate not available")
+        end
+      end
+
+      def ca_file
+        # TODO: wait until ca_path is supported
+        #       https://github.com/L2G/rest-client-fork/pull/8
+        # ca_file = '/etc/candlepin/certs/upstream/subscription.rhn.stage.redhat.com.crt'
+        nil
+      end
+
       protected
 
       def candlepin_ping

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

@@ -10,10 +10,15 @@ module Katello
       SUBSCRIPTION_MANAGER_PACKAGE_NAME = 'subscription-manager'.freeze
 
       belongs_to :kickstart_repository, :class_name => "::Katello::Repository", :inverse_of => :kickstart_content_facets
-      belongs_to :content_view, :inverse_of => :content_facets, :class_name => "Katello::ContentView"
-      belongs_to :lifecycle_environment, :inverse_of => :content_facets, :class_name => "Katello::KTEnvironment"
       belongs_to :content_source, :class_name => "::SmartProxy", :inverse_of => :content_facets
 
+      has_many :content_view_environment_content_facets, :class_name => "Katello::ContentViewEnvironmentContentFacet", :dependent => :destroy, :inverse_of => :content_facet
+      has_many :content_view_environments, :through => :content_view_environment_content_facets,
+               :class_name => "Katello::ContentViewEnvironment", :source => :content_view_environment,
+               :after_add => :mark_cves_changed, :after_remove => :mark_cves_changed
+      has_many :content_views, :through => :content_view_environments, :class_name => "Katello::ContentView"
+      has_many :lifecycle_environments, :through => :content_view_environments, :class_name => "Katello::KTEnvironment"
+
       has_many :content_facet_errata, :class_name => "Katello::ContentFacetErratum", :dependent => :delete_all, :inverse_of => :content_facet
       has_many :applicable_errata, :through => :content_facet_errata, :class_name => "Katello::Erratum", :source => :erratum
 
@@ -31,11 +36,87 @@ module Katello
       has_many :content_facet_applicable_module_streams, :class_name => "Katello::ContentFacetApplicableModuleStream", :dependent => :delete_all, :inverse_of => :content_facet
       has_many :applicable_module_streams, :through => :content_facet_applicable_module_streams, :class_name => "Katello::ModuleStream", :source => :module_stream
 
-      validates :content_view, :presence => true, :allow_blank => false
-      validates :lifecycle_environment, :presence => true, :allow_blank => false
       validates_with ::AssociationExistsValidator, attributes: [:content_source]
+      validates_with Katello::Validators::GeneratedContentViewValidator
       validates :host, :presence => true, :allow_blank => false
-      validates_with Validators::ContentViewEnvironmentValidator
+
+      attr_accessor :cves_changed
+
+      def initialize(*args)
+        init_args = args.first || {}
+        env_id = init_args.delete(:lifecycle_environment_id)
+        cv_id = init_args.delete(:content_view_id)
+        super(*args)
+        if env_id && cv_id
+          assign_single_environment(
+            lifecycle_environment_id: env_id,
+            content_view_id: cv_id
+          )
+        end
+        self.cves_changed = false
+      end
+
+      def mark_cves_changed(_cve)
+        self.cves_changed = true
+      end
+
+      def cves_changed?
+        cves_changed
+      end
+
+      def multi_content_view_environment?
+        # returns false if there are no content view environments
+        content_view_environments.size > 1
+      end
+
+      def single_content_view_environment?
+        # also returns false if there are no content view environments
+        content_view_environments.size == 1
+      end
+
+      def single_content_view
+        if multi_content_view_environment?
+          Rails.logger.warn _("Content facet for host %s has more than one content view. Use #content_views instead.") % host.name
+        end
+        content_view_environments&.first&.content_view
+      end
+
+      def single_lifecycle_environment
+        if multi_content_view_environment?
+          Rails.logger.warn _("Content facet for host %s has more than one lifecycle environment. Use #lifecycle_environments instead.") % host.name
+        end
+        content_view_environments&.first&.lifecycle_environment
+      end
+
+      def assign_single_environment(
+        content_view_id: nil, lifecycle_environment_id: nil, environment_id: nil,
+        content_view: nil, lifecycle_environment: nil, environment: nil
+      )
+        lifecycle_environment_id ||= environment_id || lifecycle_environment&.id || environment&.id
+        content_view_id ||= content_view&.id
+
+        unless lifecycle_environment_id
+          fail _("Lifecycle environment must be specified")
+        end
+
+        unless content_view_id
+          fail _("Content view must be specified")
+        end
+
+        content_view_environment = ::Katello::ContentViewEnvironment
+          .where(:content_view_id => content_view_id, :environment_id => lifecycle_environment_id)
+          .first_or_create do |cve|
+          Rails.logger.info("ContentViewEnvironment not found for content view '#{cve.content_view_name}' and environment '#{cve.environment&.name}'; creating a new one.")
+        end
+        fail _("Unable to create ContentViewEnvironment. Check the logs for more information.") if content_view_environment.nil?
+        self.content_view_environments = [content_view_environment]
+      end
+
+      def default_environment?
+        content_view_environments.any? do |cve|
+          cve.content_view.default? && cve.lifecycle_environment.library?
+        end
+      end
 
       def update_repositories_by_paths(paths)
         prefixes = %w(/pulp/deb/ /pulp/repos/ /pulp/content/)
@@ -83,13 +164,23 @@ module Katello
       end
 
       def errata_counts
-        hash = {
+        installable_hash = {
           :security => installable_security_errata_count,
           :bugfix => installable_bugfix_errata_count,
           :enhancement => installable_enhancement_errata_count
         }
-        hash[:total] = hash.values.inject(:+)
-        hash
+        installable_hash[:total] = installable_hash.values.inject(:+)
+        # same for applicable, but we need to get the counts from the db
+        applicable_hash = {
+          :security => applicable_errata.security.count,
+          :bugfix => applicable_errata.bugfix.count,
+          :enhancement => applicable_errata.enhancement.count
+        }
+        applicable_hash[:total] = applicable_hash.values.inject(:+)
+        # keeping installable at the top level for backward compatibility
+        installable_hash.merge({
+                                 :applicable => applicable_hash
+                               })
       end
 
       def self.trigger_applicability_generation(host_ids)
@@ -128,13 +219,21 @@ module Katello
       end
 
       def self.in_content_view_version_environments(version_environments)
-        #takes a structure of [{:content_view_version => ContentViewVersion, :environments => [KTEnvironment]}]
+        # takes a structure of [{:content_view_version => ContentViewVersion, :environments => [KTEnvironment]}]
+        relation = self.joins(:content_view_environment_content_facets => :content_view_environment)
         queries = version_environments.map do |version_environment|
           version = version_environment[:content_view_version]
           env_ids = version_environment[:environments].map(&:id)
-          "(#{table_name}.content_view_id = #{version.content_view_id} AND #{table_name}.lifecycle_environment_id IN (#{env_ids.join(',')}))"
+          "(#{::Katello::ContentViewEnvironment.table_name}.content_view_version_id = #{version.id} AND #{::Katello::ContentViewEnvironment.table_name}.environment_id IN (#{env_ids.join(',')}))"
         end
-        where(queries.join(" OR "))
+        relation.where(queries.join(" OR "))
+      end
+
+      def self.in_content_views_and_environments(content_views: nil, lifecycle_environments: nil)
+        relation = self.joins(:content_view_environment_content_facets => :content_view_environment)
+        relation = relation.where("#{::Katello::ContentViewEnvironment.table_name}.content_view_id" => content_views) if content_views
+        relation = relation.where("#{::Katello::ContentViewEnvironment.table_name}.environment_id" => lifecycle_environments) if lifecycle_environments
+        relation
       end
 
       def self.with_non_installable_errata(errata, hosts = nil)
@@ -192,12 +291,10 @@ module Katello
              where("#{facet_repository}.content_facet_id = #{self.table_name}.id")
       end
 
-      def content_view_version
-        content_view.version(lifecycle_environment)
-      end
-
       def available_releases
-        self.content_view.version(self.lifecycle_environment).available_releases
+        self.content_view_environments.flat_map do |cve|
+          cve.content_view.version(cve.lifecycle_environment).available_releases
+        end
       end
 
       def katello_agent_installed?
@@ -221,6 +318,11 @@ module Katello
         host.refresh_global_status!
       end
 
+      # TODO: uncomment when we need to display multiple CVE names in the UI
+      # def content_view_environment_names
+      #   content_view_environments.map(&:candlepin_name).join(', ')
+      # end
+
       def self.joins_installable_relation(content_model, facet_join_model)
         facet_repository = Katello::ContentFacetRepository.table_name
         content_table = content_model.table_name
@@ -257,16 +359,14 @@ module Katello
         property :upgradable_rpm_count, Integer, desc: 'Returns upgradable RPM count'
         property :content_source, 'SmartProxy', desc: 'Returns Smart Proxy object as the content source'
         prop_group :katello_idname_props, Katello::Model, meta: { resource: 'content_source' }
-        prop_group :katello_idname_props, Katello::Model, meta: { resource: 'content_view' }
         property :errata_counts, Hash, desc: 'Returns key=value object with errata counts, e.g. {security: 0, bugfix: 0, enhancement: 0, total: 0}'
         property :kickstart_repository, 'Repository', desc: 'Returns Kickstart repository object'
         prop_group :katello_idname_props, Katello::Model, meta: { resource: 'kickstart_repository' }
-        prop_group :katello_idname_props, Katello::Model, meta: { resource: 'lifecycle_environment' }
       end
       class Jail < ::Safemode::Jail
-        allow :applicable_deb_count, :applicable_module_stream_count, :applicable_rpm_count, :content_source, :content_source_id, :content_source_name, :content_view_id,
-              :content_view_name, :errata_counts, :id, :kickstart_repository, :kickstart_repository_id, :kickstart_repository_name,
-              :lifecycle_environment_id, :lifecycle_environment_name, :upgradable_deb_count, :upgradable_module_stream_count, :upgradable_rpm_count, :uuid
+        allow :applicable_deb_count, :applicable_module_stream_count, :applicable_rpm_count, :content_source, :content_source_id, :content_source_name,
+              :errata_counts, :id, :kickstart_repository, :kickstart_repository_id, :kickstart_repository_name,
+              :upgradable_deb_count, :upgradable_module_stream_count, :upgradable_rpm_count, :uuid
       end
     end
   end

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

@@ -6,15 +6,21 @@ module Katello
       def host_info
         info = {}
         info['parameters'] = {
-          'foreman_host_collections' => host.host_collections.map(&:name),
-          'lifecycle_environment' => host.lifecycle_environment.try(:label),
-
-          'content_view' => host.content_view.try(:label),
-          'content_view_info' => content_view_info
+          'foreman_host_collections' => host.host_collections.map(&:name)
         }
 
         if host.content_facet.present?
           info['parameters']['kickstart_repository'] = host.content_facet.kickstart_repository.try(:label)
+          if host.single_content_view_environment?
+            info['parameters']['lifecycle_environment'] = host.single_lifecycle_environment.try(:label)
+            info['parameters']['content_view'] = host.single_content_view.try(:label)
+            info['parameters']['content_view_info'] = content_view_info(host.content_view_environments.first)
+          end
+          info['parameters']['content_views'] = host.content_view_environments.map do |cve|
+            content_view_info(cve).merge(
+              'lifecycle_environment' => cve.lifecycle_environment.try(:label)
+            )
+          end
         end
 
         if (rhsm_url = host.content_source&.rhsm_url)
@@ -28,25 +34,23 @@ module Katello
         info
       end
 
-      def content_view_info
-        return {} if host.content_view.blank?
-
-        content_view_info = {
-          'label' => host.content_view.try(:label),
-          'latest-version' => host.content_view.try(:latest_version),
-          'version' => content_version.try(:version),
-          'published' => content_version.try(:created_at).try(:time).to_s,
-          'components' => content_view_components
+      def content_view_info(content_view_environment)
+        content_view = content_view_environment.content_view
+        return {} if content_view.blank?
+        {
+          'label' => content_view.try(:label),
+          'latest-version' => content_view.try(:latest_version),
+          'version' => content_version(content_view_environment).try(:version),
+          'published' => content_version(content_view_environment).try(:created_at).try(:time).to_s,
+          'components' => content_view_components(content_view_environment)
         }
-
-        content_view_info
       end
 
-      def content_view_components
-        return {} unless host.content_view.try(:composite)
+      def content_view_components(content_view_environment)
+        return {} unless content_view_environment.content_view.try(:composite)
 
         components = {}
-        content_version.try(:content_view_version_components).map do |cv|
+        content_version(content_view_environment).try(:content_view_version_components).map do |cv|
           cv_label = cv.component_version.content_view.label
           components[cv_label] = {}
           components[cv_label]['version'] = cv.component_version.try(:version)
@@ -55,8 +59,8 @@ module Katello
         components
       end
 
-      def content_version
-        host.content_view.try(:version, host.lifecycle_environment)
+      def content_version(content_view_environment)
+        content_view_environment.content_view.try(:version, content_view_environment.lifecycle_environment)
       end
     end
   end

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

@@ -114,9 +114,10 @@ module Katello
         if self.hypervisor
           if !consumer_params.try(:[], 'guestIds').empty?
             guest_ids = consumer_params['guestIds'].map do |id|
-              if id.is_a?(Hash)
+              case id
+              when Hash
                 id['guestId'].downcase
-              elsif id.is_a?(String)
+              when String
                 id.downcase
               end
             end
@@ -144,7 +145,7 @@ module Katello
           :addOns => purpose_addons.pluck(:name),
           :serviceLevel => service_level,
           :releaseVer => release_version,
-          :environment => {:id => self.candlepin_environment_id},
+          :environments => self.candlepin_environments,
           :installedProducts => self.installed_products.map(&:consumer_attributes),
           :guestIds => virtual_guest_uuids
         }
@@ -152,20 +153,18 @@ module Katello
         HashWithIndifferentAccess.new(attrs)
       end
 
-      def candlepin_environment_id
+      def candlepin_environments
         if self.host.content_facet
-          self.host.content_facet.content_view.cp_environment_id(self.host.content_facet.lifecycle_environment)
+          self.host.content_facet.content_view_environments.map do |cve|
+            { :id => cve.content_view.cp_environment_id(cve.lifecycle_environment) }
+          end
         else
           self.host.organization.default_content_view.cp_environment_id(self.host.organization.library)
         end
       end
 
-      def content_view
-        self.host.content_facet.try(:content_view) || self.organization.default_content_view
-      end
-
-      def lifecycle_environment
-        self.host.content_facet.try(:lifecycle_environment) || self.organization.library
+      def content_view_environments
+        self.host.content_facet.try(:content_view_environments)
       end
 
       def organization
@@ -294,10 +293,15 @@ module Katello
 
       def backend_update_needed?
         %w(release_version service_level autoheal purpose_role purpose_usage purpose_addon_ids).each do |method|
-          return true if self.send("#{method}_changed?")
+          if self.send("#{method}_changed?")
+            Rails.logger.debug("backend_update_needed: subscription facet #{method} changed")
+            return true
+          end
         end
-        if self.host.content_facet
-          return true if (self.host.content_facet.content_view_id_changed? || self.host.content_facet.lifecycle_environment_id_changed?)
+        facet = self.host&.content_facet
+        if facet&.cves_changed? && !facet.new_record?
+          Rails.logger.debug("backend_update_needed: content facet CVEs changed")
+          return true
         end
         false
       end

data/app/models/katello/installed_package.rb

@@ -23,5 +23,6 @@ module Katello
     scoped_search :on => :version
     scoped_search :on => :release
     scoped_search :on => :arch
+    scoped_search :on => :vendor, :complete_value => true
   end
 end

data/app/models/katello/kt_environment.rb

@@ -18,17 +18,22 @@ module Katello
     has_many :successors, :class_name => "Katello::KTEnvironment", :through => :env_successors, :source => :env
 
     has_many :repositories, :class_name => "Katello::Repository", dependent: :destroy, foreign_key: :environment_id
+    has_many :content_view_histories, :class_name => "Katello::ContentViewHistory", :dependent => :destroy,
+    :inverse_of => :environment, :foreign_key => :katello_environment_id
+
     has_many :content_view_environments, :class_name => "Katello::ContentViewEnvironment",
-                                         :foreign_key => :environment_id, :inverse_of => :environment, :dependent => :restrict_with_exception
+             :foreign_key => :environment_id, :inverse_of => :environment, :dependent => :destroy
+    has_many :content_view_environment_content_facets, :through => :content_view_environments,
+                          :class_name => "Katello::ContentViewEnvironmentContentFacet",
+                          :inverse_of => :lifecycle_environment
+    has_many :content_facets, :through => :content_view_environment_content_facets,
+                          :class_name => "Katello::Host::ContentFacet",
+                          :inverse_of => :lifecycle_environments
+    has_many :content_views, :through => :content_view_environments
     has_many :content_view_versions, :through => :content_view_environments, :inverse_of => :environments
-    has_many :content_views, :through => :content_view_environments, :inverse_of => :environments
-    has_many :content_view_histories, :class_name => "Katello::ContentViewHistory", :dependent => :destroy,
-                                      :inverse_of => :environment, :foreign_key => :katello_environment_id
 
-    has_many :content_facets, :class_name => "Katello::Host::ContentFacet", :foreign_key => :lifecycle_environment_id,
-                          :inverse_of => :lifecycle_environment, :dependent => :restrict_with_exception
     has_many :hosts,      :class_name => "::Host::Managed", :through => :content_facets,
-                          :inverse_of => :lifecycle_environment
+                          :inverse_of => :lifecycle_environments
     has_many :hostgroup_content_facets, :class_name => "Katello::Hostgroup::ContentFacet", :foreign_key => :lifecycle_environment_id,
                           :inverse_of => :lifecycle_environment, :dependent => :restrict_with_exception
     has_many :hostgroups, :class_name => "::Hostgroup", :through => :hostgroup_content_facets,