katello 4.7.3 → 4.8.0.rc1

data/app/models/katello/content_view_environment.rb

@@ -8,9 +8,13 @@ module Katello
 
     belongs_to :content_view, :class_name => "Katello::ContentView", :inverse_of => :content_view_environments
     belongs_to :environment, :class_name => "Katello::KTEnvironment", :inverse_of => :content_view_environments
+    belongs_to :lifecycle_environment, :class_name => "Katello::KTEnvironment", :foreign_key => :environment_id, :inverse_of => :content_view_environments
     belongs_to :content_view_version, :class_name => "Katello::ContentViewVersion",
                :inverse_of => :content_view_environments
 
+    has_many :content_view_environment_content_facets, :class_name => "Katello::ContentViewEnvironmentContentFacet", :dependent => :destroy, :inverse_of => :content_view_environment
+    has_many :content_facets, through: :content_view_environment_content_facets, :class_name => "::Katello::Host::ContentFacet", :inverse_of => :content_view_environments
+
     validates_lengths_from_database
     validates :environment_id, uniqueness: {scope: :content_view_id}, presence: true
     validates :content_view_id, presence: true
@@ -19,10 +23,10 @@ module Katello
     before_save :generate_info
 
     scope :non_default, -> { joins(:content_view).where("katello_content_views.default" => false) }
+    alias :lifecycle_environment :environment
 
     def self.for_content_facets(content_facets)
-      joins("INNER JOIN #{Host::ContentFacet.table_name} on #{Host::ContentFacet.table_name}.lifecycle_environment_id = #{ContentViewEnvironment.table_name}.environment_id").
-          where("#{Host::ContentFacet.table_name}.content_view_id = #{ContentViewEnvironment.table_name}.content_view_id").where("#{Host::ContentFacet.table_name}.id" => content_facets).uniq
+      joins(:content_view_environment_content_facets, :content_facets).where("#{Katello::ContentViewEnvironmentContentFacet.table_name}.content_facet_id" => content_facets).uniq
     end
 
     # retrieve the owning environment for this content view environment.
@@ -38,6 +42,11 @@ module Katello
       content_view.activation_keys.in_environment(environment)
     end
 
+    # TODO: uncomment when we need to start showing multiple CVE names in UI
+    # def candlepin_name
+    #   "#{environment.label}/#{content_view.label}"
+    # end
+
     private
 
     def generate_info

data/app/models/katello/content_view_environment_content_facet.rb

@@ -0,0 +1,9 @@
+module Katello
+  class ContentViewEnvironmentContentFacet < Katello::Model
+    belongs_to :content_view_environment, :class_name => "::Katello::ContentViewEnvironment", :inverse_of => :content_view_environment_content_facets
+    belongs_to :content_facet, :class_name => "::Katello::Host::ContentFacet", :inverse_of => :content_view_environment_content_facets
+
+    validates :content_view_environment_id, presence: true
+    validates :content_facet_id, presence: true, unless: :new_record?
+  end
+end

data/app/models/katello/content_view_version.rb

@@ -99,8 +99,7 @@ module Katello
     def self.for_version(version)
       major, minor = version.to_s.split('.')
       minor ||= 0
-      query = where(:major => major, :minor => minor)
-      query
+      where(:major => major, :minor => minor)
     end
 
     def to_s
@@ -165,6 +164,10 @@ module Katello
       "#{major}.#{minor}"
     end
 
+    def incrementally_updated?
+      minor != 0
+    end
+
     def repos(env)
       self.repositories.in_environment(env)
     end
@@ -333,9 +336,10 @@ module Katello
     def update_content_counts!
       self.content_counts = {}
       RepositoryTypeManager.indexable_content_types.each do |content_type|
-        if content_type&.model_class::CONTENT_TYPE == DockerTag::CONTENT_TYPE
+        case content_type&.model_class::CONTENT_TYPE
+        when DockerTag::CONTENT_TYPE
           content_counts[DockerTag::CONTENT_TYPE] = docker_tags.count
-        elsif content_type&.model_class::CONTENT_TYPE == GenericContentUnit::CONTENT_TYPE
+        when GenericContentUnit::CONTENT_TYPE
           content_counts[content_type.content_type] = content_type&.model_class&.in_repositories(self.repositories.archived)&.where(:content_type => content_type.content_type)&.count
         else
           content_counts[content_type&.model_class::CONTENT_TYPE] = content_type&.model_class&.in_repositories(self.repositories.archived)&.count
@@ -376,9 +380,10 @@ module Katello
       fail _("Default content view versions cannot be promoted") if default?
       content_view.check_composite_action_allowed!(to_env)
       content_view.check_docker_repository_names!(to_env)
+      content_view.check_orphaned_content_facets!(environments: [to_env])
     end
 
-    def validate_destroyable!(skip_environment_check = false)
+    def validate_destroyable!(skip_environment_check: false)
       unless organization.being_deleted?
         if !skip_environment_check && in_environment?
           fail _("Cannot delete version while it is in environments: %s") %

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
@@ -152,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/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:delete_orphaned_custom_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|
@@ -126,6 +125,7 @@ module Katello
 
         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
@@ -144,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

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,85 @@ 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?
+        content_view_environments.size > 1
+      end
+
+      def single_content_view_environment?
+        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/)
@@ -138,13 +217,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)
@@ -202,12 +289,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?
@@ -231,6 +316,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
@@ -267,16 +357,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/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,

data/app/models/katello/package_group.rb

@@ -12,18 +12,6 @@ module Katello
       self.repositories.first
     end
 
-    def self.list_by_filter_clauses(clauses)
-      package_names = []
-      pulp_package_groups = Katello.pulp_server.extensions.package_group.search(Katello::PackageGroup::CONTENT_TYPE, :filters => clauses)
-      groupings = [:default_package_names, :conditional_package_names, :optional_package_names, :mandatory_package_names]
-      if pulp_package_groups.any?
-        pulp_package_groups.flat_map { |group| groupings.each { |grouping| package_names << group[grouping] } }
-        package_names.flatten!
-      else
-        []
-      end
-    end
-
     def package_names
       service_class = SmartProxy.pulp_primary!.content_service(CONTENT_TYPE)
       group = service_class.new(self.pulp_id)

data/app/models/katello/pool.rb

@@ -56,7 +56,10 @@ module Katello
     validate :subscription_matches_organization
 
     def subscription_matches_organization
-      errors.add(:base, _("A Pool and its Subscription cannot belong to different organizations")) unless subscription&.organization_id == self.organization_id
+      return if errors[:subscription].any? || errors[:organization].any? # let other validations catch this
+      unless subscription&.organization_id == self.organization_id
+        errors.add(:base, _("A Pool and its Subscription cannot belong to different organizations."))
+      end
     end
 
     DAYS_RECENTLY_EXPIRED = 30