katello 4.13.1 → 4.14.0.rc1

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

@@ -85,7 +85,7 @@ module Katello
       end
 
       included do
-        prepend ::ForemanRemoteExecution::HostExtensions if ::Katello.with_remote_execution?
+        prepend ::ForemanRemoteExecution::HostExtensions
         prepend Overrides
 
         delegate :content_source_id, :single_content_view, :single_lifecycle_environment, :default_environment?, :single_content_view_environment?, :multi_content_view_environment?, :kickstart_repository_id, :bound_repositories,
@@ -480,8 +480,10 @@ module Katello
 
       def rhel_eos_schedule_index
         return nil unless probably_rhel?
-        major = operatingsystem.major
+        major = operatingsystem&.major
+        return nil unless major
         return "RHEL#{major}" unless major == "7"
+
         arch_name = architecture&.name
         case arch_name
         when "ppc64le"
@@ -503,53 +505,82 @@ module Katello
         end
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength
       def yum_names_for_job_template(action:, search:, versions: nil)
         actions = %w(install remove update).freeze
         case action
         when 'install'
-          ::Katello::Rpm.yum_installable_for_host(self).search_for(search).distinct.pluck(:name)
+          yum_installable = ::Katello::Rpm.yum_installable_for_host(self).search_for(search).distinct.pluck(:name)
+          if yum_installable.empty?
+            fail N_("No available packages found for search term '%s'. Check the host's content view environments and already-installed packages.") % search
+          end
+          yum_installable
         when 'remove'
           return [] if search.empty?
 
-          installed_packages.search_for(search).distinct.pluck(:name)
+          yum_removable = installed_packages.search_for(search).distinct.pluck(:name)
+          if yum_removable.empty?
+            fail N_("Cannot remove package(s): This host does not have any installed packages matching the search term '%s'.") % search
+          end
+          yum_removable
         when 'update'
           return [] if search.empty?
 
           versions_by_name_arch = {}
           if versions.present?
             JSON.parse(versions).each do |nvra|
-              nvra =~ /([^\.]*)-[-\.\w]*\.(\w+)/
+              nvra =~ /([^.]*)-[-.\w]*\.(\w+)/
               versions_by_name_arch[[Regexp.last_match(1), Regexp.last_match(2)]] = nvra
             end
           end
           pkg_name_archs = installed_packages.search_for(search).distinct.pluck(:name, :arch)
+          if pkg_name_archs.empty?
+            fail _("Cannot upgrade packages: No installed packages found for search term '%s'") % search
+          end
           upgrades = ::Katello::Rpm.installable_for_hosts([self]).select(:id, :name, :arch, :nvra, :evr).order(evr: :desc).group_by { |i| [i.name, i.arch] }
-          pkg_name_archs.map { |name, arch| versions_by_name_arch[[name, arch]] || upgrades[[name, arch]]&.first&.nvra }.compact
+          result = pkg_name_archs.map { |name, arch| versions_by_name_arch[[name, arch]] || upgrades[[name, arch]]&.first&.nvra }.compact
+          if result.empty?
+            fail _("No upgradable packages found for search term '%s'. The host may already have the latest version(s) installed.") % search
+          end
+          result
         else
           fail ::Foreman::Exception.new(N_("package_names_for_job_template: Action must be one of %s"), actions.join(', '))
         end
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       def deb_names_for_job_template(action:, search:)
         actions = %w(install remove update).freeze
         case action
         when 'install'
-          ::Katello::Deb.apt_installable_for_host(self).search_for(search).distinct.pluck(:name)
+          deb_installable = ::Katello::Deb.apt_installable_for_host(self).search_for(search).distinct.pluck(:name)
+          if deb_installable.empty?
+            fail _("No available debs found for search term '%s'. Check the host's content view environments and already-installed debs.") % search
+          end
+          deb_installable
         when 'remove'
           return [] if search.empty?
 
           installed_debs.search_for(search).distinct.pluck(:name)
         when 'update'
           return [] if search.empty?
-
-          installed_debs.search_for(search).distinct.pluck(:name)
+          deb_results = installed_debs.search_for(search).distinct.pluck(:name)
+          if deb_results.empty?
+            fail _("No installed debs found for search term '%s'") % search
+          end
+          deb_results
         else
           fail ::Foreman::Exception.new(N_("deb_names_for_job_template: Action must be one of %s"), actions.join(', '))
         end
       end
 
       def advisory_ids(search:)
-        ::Katello::Erratum.installable_for_hosts([self]).search_for(search).pluck(:errata_id)
+        ids = ::Katello::Erratum.installable_for_hosts([self]).search_for(search).pluck(:errata_id)
+        if ids.empty?
+          fail _("Cannot install errata: No installable errata found for search term '%s'") % search
+        end
+        ids
       end
 
       def filtered_entitlement_quantity_consumed(pool)

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

@@ -39,10 +39,8 @@ module Katello
           self.medium = nil
         end
 
-        if content_facet&.kickstart_repository_id && !matching_kickstart_repository?(content_facet)
-          if (equivalent = equivalent_kickstart_repository)
-            self.content_facet.kickstart_repository_id = equivalent[:id]
-          end
+        if content_facet&.kickstart_repository_id && !matching_kickstart_repository?(content_facet) && (equivalent = equivalent_kickstart_repository)
+          self.content_facet.kickstart_repository_id = equivalent[:id]
         end
       end
 

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

@@ -16,10 +16,8 @@ module Katello
       end
 
       def reset_settings
-        if saved_change_to_attribute?(:title)
-          if ::Setting[:default_location_subscribed_hosts] == self.title_before_last_save
-            ::Setting[:default_location_subscribed_hosts] = self.title
-          end
+        if saved_change_to_attribute?(:title) && (::Setting[:default_location_subscribed_hosts] == self.title_before_last_save)
+          ::Setting[:default_location_subscribed_hosts] = self.title
         end
       end
 

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

@@ -6,33 +6,101 @@ module Katello
       REDHAT_ATOMIC_HOST_DISTRO_NAME = "Red Hat Enterprise Linux Atomic Host".freeze
       REDHAT_ATOMIC_HOST_OS = "RedHat_Enterprise_Linux_Atomic_Host".freeze
 
+      DEBIAN_DEFAULT_PROVISIONING_TEMPLATE = "Preseed default %{template_kind_name}".freeze
+      DEBIAN_DEFAULT_PTABLE = "Preseed default".freeze
+
+      SUSE_DEFAULT_PROVISIONING_TEMPLATE = "AutoYaST default %{template_kind_name}".freeze
+      SUSE_DEFAULT_PTABLE = "AutoYaST entire SCSI disk".freeze
+
       included do
         after_create :assign_templates!
         before_create :set_atomic_attributes, :if => proc { |os| os.name == ::Operatingsystem::REDHAT_ATOMIC_HOST_OS }
       end
 
-      def assign_templates!
-        # Automatically assign default templates
-        if self.family == 'Redhat'
-          TemplateKind.all.each do |kind|
-            if name == ::Operatingsystem::REDHAT_ATOMIC_HOST_OS && kind.name == "provision"
-              provisioning_template_name = Setting["katello_default_atomic_provision"]
-            else
-              provisioning_template_name = Setting["katello_default_#{kind.name}"]
-            end
+      def find_related_os
+        Operatingsystem.unscoped.where(name: self.name).order(major: :desc, minor: :desc).where.not(id: self.id)
+      end
+
+      def assign_related_os_templates
+        all_related_os = find_related_os
+        return false if all_related_os.nil?
+
+        boot_loader_template_kinds = TemplateKind.where(name: ["PXELinux", "PXEGrub", "PXEGrub2", "iPXE"]).pluck(:id)
+        provision_template_kinds = TemplateKind.where(name: ["provision", "finish"]).pluck(:id)
 
-            if (template = ProvisioningTemplate.unscoped.find_by_name(provisioning_template_name))
-              provisioning_templates << template unless provisioning_templates.include?(template)
-              if OsDefaultTemplate.where(:template_kind_id => kind.id, :operatingsystem_id => id).empty?
-                OsDefaultTemplate.create(:template_kind_id => kind.id, :provisioning_template_id => template.id, :operatingsystem_id => id)
-              end
+        all_related_os.each do |related_os|
+          next if related_os.provisioning_templates.empty? || related_os.ptables.empty?
+          next if related_os.provisioning_templates.where(template_kind_id: boot_loader_template_kinds).size == 0
+          next if related_os.provisioning_templates.where(template_kind_id: provision_template_kinds).size == 0
+
+          Rails.logger.info "Using operating system #{related_os.name} (major: #{related_os.major}, minor: #{related_os.minor}) " \
+                            "as a template source for the new OS #{name} (major: #{major}, minor: #{minor})."
+
+          related_os.ptables.each do |ptable|
+            ptables << ptable unless ptables.include?(ptable)
+          end
+
+          related_os.provisioning_templates.each do |template|
+            provisioning_templates << template unless provisioning_templates.include?(template)
+            OsDefaultTemplate.where(:operatingsystem_id => related_os.id, :provisioning_template_id => template.id).each do |os_default_temp|
+              OsDefaultTemplate.create(:template_kind_id => os_default_temp.template_kind_id,
+                                       :provisioning_template_id => os_default_temp.provisioning_template_id,
+                                       :operatingsystem_id => id)
             end
           end
+          return true
+        end
+        false
+      end
+
+      def provisioning_template_name_for_os(template_kind_name)
+        case self.family
+        when 'Redhat'
+          if name == ::Operatingsystem::REDHAT_ATOMIC_HOST_OS && template_kind_name == "provision"
+            Setting["katello_default_atomic_provision"]
+          else
+            Setting["katello_default_#{template_kind_name}"]
+          end
+        when 'Debian'
+          format(DEBIAN_DEFAULT_PROVISIONING_TEMPLATE, template_kind_name: template_kind_name)
+        when 'Suse'
+          format(SUSE_DEFAULT_PROVISIONING_TEMPLATE, template_kind_name: template_kind_name)
+        end
+      end
 
-          if (ptable = Ptable.unscoped.find_by_name(Setting["katello_default_ptable"]))
-            ptables << ptable unless ptables.include?(ptable)
+      def partition_table_name_for_os
+        case self.family
+        when 'Redhat'
+          Setting["katello_default_ptable"]
+        when 'Debian'
+          DEBIAN_DEFAULT_PTABLE
+        when 'Suse'
+          SUSE_DEFAULT_PTABLE
+        end
+      end
+
+      def assign_templates!
+        if [ 'Suse', 'Debian' ].include?(self.family) && assign_related_os_templates
+          return
+        end
+
+        # Automatically assign default templates
+        TemplateKind.all.each do |kind|
+          provisioning_template_name = provisioning_template_name_for_os(kind.name)
+          next if provisioning_template_name.nil?
+          if (template = ProvisioningTemplate.unscoped.find_by_name(provisioning_template_name))
+            provisioning_templates << template unless provisioning_templates.include?(template)
+            if OsDefaultTemplate.where(:template_kind_id => kind.id, :operatingsystem_id => id).empty?
+              OsDefaultTemplate.create(:template_kind_id => kind.id, :provisioning_template_id => template.id, :operatingsystem_id => id)
+            end
           end
         end
+
+        partition_table_name = partition_table_name_for_os
+        return if partition_table_name.nil?
+        if (ptable = Ptable.unscoped.find_by_name(partition_table_name)) && !ptables.include?(ptable)
+          ptables << ptable
+        end
       end
 
       def set_atomic_attributes

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

@@ -11,8 +11,7 @@ module Katello
 
       module Overrides
         def refresh
-          errors = super
-          errors
+          super
         end
       end
 
@@ -254,10 +253,11 @@ module Katello
       end
 
       def pulp3_ssl_configuration(config, connection_adapter = Faraday.default_adapter)
-        if connection_adapter == :excon
+        case connection_adapter
+        when :excon
           config.ssl_client_cert = ::Cert::Certs.ssl_client_cert_filename
           config.ssl_client_key = ::Cert::Certs.ssl_client_key_filename
-        elsif connection_adapter == :net_http
+        when :net_http
           config.ssl_client_cert = ::Cert::Certs.ssl_client_cert
           config.ssl_client_key = ::Cert::Certs.ssl_client_key
         else

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

@@ -28,6 +28,7 @@ module Katello
         scoped_search :on => :registered_through, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
         scoped_search :on => :registered_at, :relation => :subscription_facet, :rename => :registered_at, :only_explicit => true
         scoped_search :on => :uuid, :relation => :subscription_facet, :rename => :subscription_uuid, :only_explicit => true
+        scoped_search :on => :convert2rhel_through_foreman, :relation => :subscription_facet, :only_explicit => true
         scoped_search :relation => :activation_keys, :on => :name, :rename => :activation_key, :complete_value => true, :ext_method => :find_by_activation_key
         scoped_search :relation => :activation_keys, :on => :id, :rename => :activation_key_id, :complete_value => true, :ext_method => :find_by_activation_key_id,
                       :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
@@ -42,6 +43,7 @@ module Katello
       end
 
       def update_candlepin_associations(consumer_params = nil)
+        Rails.logger.debug "Updating Candlepin associations for host #{name}"
         content_facet.cves_changed = false if content_facet
         content_facet&.save!
 

data/app/models/katello/content_view.rb

@@ -712,6 +712,7 @@ module Katello
     end
 
     def check_remove_from_environment!(env)
+      check_orphaned_content_facets!(environments: [env])
       errors = []
 
       dependencies = { hosts: _("hosts"),
@@ -730,6 +731,7 @@ module Katello
     end
 
     def check_ready_to_destroy!
+      check_orphaned_content_facets!(environments: self.environments)
       errors = []
 
       dependencies = { environments: _("environments"),
@@ -862,7 +864,9 @@ module Katello
       }
 
       table = Audit.arel_table
-      repository_condition = table[:auditable_id].eq(id).and(audited_changes_like.call("repository_ids"))
+      repository_condition = table[:auditable_id].eq(id)
+                                                 .and(table[:auditable_type].eq('Katello::ContentView'))
+                                                 .and(audited_changes_like.call("repository_ids"))
 
       cv_repository_condition = table[:auditable_id].in(cv_repository_ids)
                                                     .and(table[:auditable_type].eq('Katello::Repository'))

data/app/models/katello/content_view_environment.rb

@@ -24,12 +24,23 @@ module Katello
     before_save :generate_info
 
     scope :non_default, -> { joins(:content_view).where("katello_content_views.default" => false) }
+    scope :default, -> { joins(:content_view).where("katello_content_views.default" => true) }
     alias :lifecycle_environment :environment
 
     def self.for_content_facets(content_facets)
       joins(:content_view_environment_content_facets, :content_facets).where("#{Katello::ContentViewEnvironmentContentFacet.table_name}.content_facet_id" => content_facets).uniq
     end
 
+    def self.with_candlepin_name(cp_name, organization: Organization.current)
+      lce_name, cv_name = cp_name.split('/')
+      if cv_name.blank? && lce_name == 'Library'
+        return default.find_by(
+          environment: ::Katello::KTEnvironment.library.where(organization: organization)&.first
+        )
+      end
+      joins(:environment, :content_view).where("#{Katello::KTEnvironment.table_name}.label" => lce_name, "#{Katello::ContentView.table_name}.label" => cv_name).first
+    end
+
     # retrieve the owning environment for this content view environment.
     def owner
       self.environment
@@ -47,10 +58,14 @@ module Katello
       content_view.default? && environment.library?
     end
 
-    # TODO: uncomment when we need to start showing multiple CVE names in UI
-    # def candlepin_name
-    #   "#{environment.label}/#{content_view.label}"
-    # end
+    def candlepin_name
+      return environment.label if default_environment?
+      "#{environment.label}/#{content_view.label}"
+    end
+
+    def priority(content_facet)
+      content_view_environment_content_facets.find_by(:content_facet_id => content_facet.id).try(:priority)
+    end
 
     private
 

data/app/models/katello/content_view_environment_content_facet.rb

@@ -3,6 +3,8 @@ module Katello
     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
 
+    default_scope { order(:priority => :asc) }
+
     validates :content_view_environment_id, presence: true
     validates :content_facet_id, presence: true, unless: :new_record?
     validate :ensure_valid_content_source, if: proc { Setting['validate_host_lce_content_source_coherence'] }
@@ -19,5 +21,14 @@ module Katello
         errors.add(:base, error_msg)
       end
     end
+
+    def self.reprioritize_for_content_facet(content_facet, new_cves)
+      new_order = new_cves.map do |cve|
+        content_facet.content_view_environment_content_facets.find_by(:content_view_environment_id => cve.id)
+      end
+      new_order.compact.each_with_index do |cvecf, index|
+        cvecf.update_column(:priority, index)
+      end
+    end
   end
 end

data/app/models/katello/erratum.rb

@@ -67,7 +67,7 @@ module Katello
     end
 
     def self.applicable_to_hosts(hosts)
-      # Note: ContentFacetErrata actually holds the "Applicable Errata" to that host
+      # NOTE: ContentFacetErrata actually holds the "Applicable Errata" to that host
       # It is not the errata "belonging" to the host. Its rather the errata that is "applicable"
       # which is calculated elsewhere.
 

data/app/models/katello/event.rb

@@ -1,7 +1,7 @@
 module Katello
   class Event < Katello::Model
     validate :validate_event_type
-    # Note: Do not use active record call backs or dependent references on this class
+    # NOTE: Do not use active record call backs or dependent references on this class
     # Direct deletes are made in EventQueue#clear_events (instead of destroys).
 
     serialize :metadata, Hash

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

@@ -34,7 +34,7 @@ module Katello
       API_URL = 'https://subscription.rhsm.redhat.com/subscription/consumers/'.freeze
       def api_url(upstream = {})
         # Default to Red Hat
-        upstream['apiUrl'] || API_URL
+        ENV['REDHAT_RHSM_API_URL'] || upstream['apiUrl'] || API_URL
       end
 
       def sync
@@ -65,7 +65,6 @@ module Katello
           Rails.logger.error "Upstream identity certificate not available"
           fail _("Upstream identity certificate not available")
         end
-
         params = {}
         params[:capabilities] = Resources::Candlepin::CandlepinPing.ping['managerCapabilities'].inject([]) do |result, element|
           result << {'name' => element}

data/app/models/katello/hash_util.rb

@@ -16,7 +16,7 @@ module Katello
       subhash = hash[params.first]
       # If we don't have a subhash don't try and recurse down
       if !subhash.nil? && !subhash.empty?
-        self.null_safe_get(subhash, default, params[1..-1])
+        self.null_safe_get(subhash, default, params[1..])
       else
         default
       end

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

@@ -64,6 +64,7 @@ module Katello
       end
 
       def mark_cves_changed(_cve)
+        Rails.logger.debug("ContentFacet: Marking CVEs changed for host #{host&.to_label}")
         self.cves_changed = true
       end
 
@@ -99,6 +100,17 @@ module Katello
         content_view_environments&.first&.lifecycle_environment
       end
 
+      def content_view_environments=(new_cves)
+        if new_cves.length > 1 && !Setting['allow_multiple_content_views']
+          fail ::Katello::Errors::MultiEnvironmentNotSupportedError,
+          _("Assigning a host to multiple content view environments is not enabled.")
+        end
+        super(new_cves)
+        Katello::ContentViewEnvironmentContentFacet.reprioritize_for_content_facet(self, new_cves)
+        self.content_view_environments.reload unless self.new_record?
+        self.host&.update_candlepin_associations unless self.host&.new_record?
+      end
+
       # rubocop:disable Metrics/CyclomaticComplexity
       def assign_single_environment(
         content_view_id: nil, lifecycle_environment_id: nil, environment_id: nil,
@@ -126,9 +138,10 @@ module Katello
       end
 
       def default_environment?
-        content_view_environments.any? do |cve|
-          cve.content_view.default? && cve.lifecycle_environment.library?
-        end
+        return if content_view_environments.blank?
+        # if default cve is first, this is equivalent to default being the only one.
+        # if default cve is not first, candlepin will prioritize CV repos over library repos in case of conflicts.
+        content_view_environments.first.default_environment?
       end
 
       def update_repositories_by_paths(paths)

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

@@ -162,10 +162,22 @@ module Katello
         end
       end
 
+      def candlepin_environments_cp_ids
+        candlepin_environments.map { |e| e[:id] }
+      end
+
       def content_view_environments
         self.host.content_facet.try(:content_view_environments)
       end
 
+      def consumer_cve_order_from_candlepin
+        Katello::Resources::Candlepin::Consumer.get(uuid)['environments'].map { |e| e['id'] }
+      end
+
+      def cves_ordered_correctly?
+        consumer_cve_order_from_candlepin == candlepin_environments_cp_ids
+      end
+
       def organization
         self.host.organization
       end
@@ -229,10 +241,8 @@ module Katello
         setting_fact = Setting[:register_hostname_fact]
         only_use_custom_fact = Setting[:register_hostname_fact_strict_match]
 
-        if !setting_fact.blank? && !facts[setting_fact].blank?
-          if only_use_custom_fact || ::Host.where(:name => setting_fact.downcase).any?
-            facts[setting_fact]
-          end
+        if !setting_fact.blank? && !facts[setting_fact].blank? && (only_use_custom_fact || ::Host.where(:name => setting_fact.downcase).any?)
+          facts[setting_fact]
         end
       end
 
@@ -287,6 +297,19 @@ module Katello
         false
       end
 
+      def self.populate_fields_from_facts(host, parser, _type, _source_proxy)
+        has_convert2rhel = parser.facts.key?('conversions.env.CONVERT2RHEL_THROUGH_FOREMAN')
+        return unless host.subscription_facet || has_convert2rhel
+        # Add in custom convert2rhel fact if system was converted using convert2rhel through Katello
+        # We want the value nil unless the custom fact is present otherwise we get a 0 in the database which if debugging
+        # might make you think it was converted2rhel but not with satellite, that is why I have the tenary below.
+        facet = host.subscription_facet || host.build_subscription_facet
+        facet.attributes = {
+          convert2rhel_through_foreman: has_convert2rhel ? ::Foreman::Cast.to_bool(parser.facts['conversions.env.CONVERT2RHEL_THROUGH_FOREMAN']) : nil
+        }.compact
+        facet.save unless facet.new_record?
+      end
+
       private
 
       def update_status(status_class, **args)

data/app/models/katello/host_collection.rb

@@ -58,8 +58,12 @@ module Katello
       consumer_ids
     end
 
-    def errata(type = nil)
-      query = Erratum.joins(:content_facets).where("#{Katello::Host::ContentFacet.table_name}.host_id" => self.host_ids)
+    def errata(type = nil, installable_only: false)
+      query = if installable_only
+                Katello::Erratum.installable_for_hosts(self.hosts)
+              else
+                Katello::Erratum.applicable_to_hosts(self.hosts)
+              end
       type ? query.of_type(type) : query
     end
 
@@ -95,16 +99,16 @@ module Katello
       return host_collections_hash[:critical].to_a, host_collections_hash[:warning].to_a, host_collections_hash[:ok].to_a
     end
 
-    def security_updates?
-      errata(Erratum::SECURITY).any?
+    def security_updates?(installable_only: false)
+      errata(Erratum::SECURITY, installable_only: installable_only).any?
     end
 
-    def bugzilla_updates?
-      errata(Erratum::BUGZILLA).any?
+    def bugzilla_updates?(installable_only: false)
+      errata(Erratum::BUGZILLA, installable_only: installable_only).any?
     end
 
-    def enhancement_updates?
-      errata(Erratum::ENHANCEMENT).any?
+    def enhancement_updates?(installable_only: false)
+      errata(Erratum::ENHANCEMENT, installable_only: installable_only).any?
     end
 
     def self.humanize_class_name(_name = nil)

data/app/models/katello/pool.rb

@@ -55,6 +55,10 @@ module Katello
 
     validate :subscription_matches_organization
 
+    def product_host_count
+      Katello::Host::ContentFacet.joins(bound_repositories: { product: :pools }).where(pools: { id: id }).distinct.count
+    end
+
     def subscription_matches_organization
       return if errors[:subscription].any? || errors[:organization].any? # let other validations catch this
       unless subscription&.organization_id == self.organization_id
@@ -147,7 +151,7 @@ module Katello
       property :days_until_expiration, Integer, desc: 'Returns number of days until expiration'
     end
     class Jail < ::Safemode::Jail
-      allow :id, :name, :available, :quantity, :product_id, :contract_number, :type, :account_number, :start_date, :end_date, :organization, :consumed, :days_until_expiration
+      allow :id, :name, :available, :quantity, :product_id, :contract_number, :type, :account_number, :start_date, :end_date, :organization, :consumed, :days_until_expiration, :product_host_count
     end
   end
 end

data/app/models/katello/product.rb

@@ -84,6 +84,10 @@ module Katello
 
     before_create :assign_unique_label
 
+    def acs_compatible_repositories
+      repositories.has_url.not_uln.library
+    end
+
     def orphaned?
       self.pool_products.empty?
     end
@@ -122,13 +126,12 @@ module Katello
       options = {} if options.nil?
 
       hash = super(options.merge(:except => [:cp_id, :id]))
-      hash = hash.merge(:multiplier => self.multiplier,
+      hash.merge(:multiplier => self.multiplier,
                         :attributes => self.attrs,
                         :id => self.cp_id,
                         :sync_plan_name => self.sync_plan ? self.sync_plan.name : nil,
                         :sync_state => self.sync_state,
                         :last_sync => self.last_sync)
-      hash
     end
 
     def redhat?
@@ -168,8 +171,8 @@ module Katello
       self.label = Util::Model.labelize(self.name) if self.label.blank?
 
       # if the object label is already being used in this org, append the id to make it unique
-      if Product.all_in_org(self.organization).where("#{Katello::Product.table_name}.label = ?", self.label).count > 0
-        self.label = self.label + "_" + self.cp_id unless self.cp_id.blank?
+      if Product.all_in_org(self.organization).where("#{Katello::Product.table_name}.label = ?", self.label).count > 0 && !self.cp_id.blank?
+        self.label = self.label + "_" + self.cp_id
       end
     end
 

data/app/models/katello/provider.rb

@@ -84,9 +84,8 @@ module Katello
     def serializable_hash(options = {})
       options = {} if options.nil?
       hash = super(options)
-      hash = hash.merge(:sync_state => self.sync_state,
+      hash.merge(:sync_state => self.sync_state,
                         :last_sync => self.last_sync)
-      hash
     end
 
     def manifest_task