katello 4.3.0 → 4.4.0.rc1

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

@@ -74,6 +74,61 @@ module Katello
         self.name.demodulize.pluralize.underscore.to_sym
       end
 
+      def import_for_repository(repo, options = {})
+        content_type = options[:content_type] || self.content_type
+        Katello::ContentUnitIndexer.new(content_type: Katello::RepositoryTypeManager.find_content_type(content_type), repository: repo).import_all
+      end
+
+      def import_all(unit_ids, repository = nil, options = {})
+        content_type = options[:content_type] || self.content_type
+        Katello::ContentUnitIndexer.new(content_type: Katello::RepositoryTypeManager.find_content_type(content_type), repository: repository, pulp_content_ids: unit_ids).import_all
+      end
+
+      def copy_repository_associations(source_repo, dest_repo)
+        if many_repository_associations
+          delete_query = "delete from #{repository_association_class.table_name} where repository_id = #{dest_repo.id} and
+                         #{unit_id_field} not in (select #{unit_id_field} from #{repository_association_class.table_name} where repository_id = #{source_repo.id})"
+          ActiveRecord::Base.transaction do
+            ActiveRecord::Base.connection.execute(delete_query)
+            self.repository_association_class.import(db_columns_copy, db_values_copy(source_repo, dest_repo), validate: false)
+          end
+        else
+          columns = column_names - ["id", "pulp_id", "created_at", "updated_at", "repository_id"]
+          queries = []
+          queries << "delete from #{self.table_name} where repository_id = #{dest_repo.id} and
+                          pulp_id not in (select pulp_id from #{self.table_name} where repository_id = #{source_repo.id})"
+          queries << "insert into #{self.table_name} (repository_id, pulp_id, #{columns.join(',')})
+                    select #{dest_repo.id} as repository_id, pulp_id, #{columns.join(',')} from #{self.table_name}
+                    where repository_id = #{source_repo.id} and pulp_id not in (select pulp_id
+                    from #{self.table_name} where repository_id = #{dest_repo.id})"
+          ActiveRecord::Base.transaction do
+            queries.each do |query|
+              ActiveRecord::Base.connection.execute(query)
+            end
+          end
+        end
+      end
+
+      def db_columns_copy
+        [unit_id_field, backend_identifier_field, :repository_id].compact
+      end
+
+      def db_values_copy(source_repo, dest_repo)
+        db_values = []
+        existing_unit_ids = self.repository_association_class.where(repository: dest_repo).pluck(unit_id_field)
+        if existing_unit_ids.empty?
+          new_units = self.repository_association_class.where(repository: source_repo)
+        else
+          new_units = self.repository_association_class.where(repository: source_repo).where.not("#{unit_id_field} in (?) ", existing_unit_ids)
+        end
+        unit_backend_identifier_field = backend_identifier_field
+        unit_identifier_filed = unit_id_field
+        new_units.each do |unit|
+          db_values << [unit[unit_identifier_filed], unit[unit_backend_identifier_field], dest_repo.id].compact
+        end
+        db_values
+      end
+
       def installable_for_content_facet(facet, env = nil, content_view = nil)
         repos = if env && content_view
                   Katello::Repository.in_environment(env).in_content_views([content_view])
@@ -95,8 +150,8 @@ module Katello
 
         if hosts
           hosts = ::Host.where(id: hosts) if hosts.is_a?(Array)
-          facet_repos = facet_repos.merge(hosts).reorder(nil)
-          facet_content_units = facet_content_units.merge(hosts).reorder(nil)
+          facet_repos = facet_repos.where(hosts: { id: hosts }).reorder(nil)
+          facet_content_units = facet_content_units.where(hosts: { id: hosts }).reorder(nil)
         end
 
         self.joins(repository_association_units).
@@ -123,181 +178,12 @@ module Katello
         content_unit_class.new(pulp_id)
       end
 
-      def unit_id_field
-        "#{self.name.demodulize.underscore}_id"
-      end
-
-      def import_all(pulp_ids = nil, repository = nil, generic_content_type = nil)
-        ids_to_associate = []
-        if generic_content_type
-          service_class = SmartProxy.pulp_primary!.content_service(generic_content_type)
-        else
-          service_class = SmartProxy.pulp_primary!.content_service(content_type)
-        end
-        service_class.pulp_units_batch_all(pulp_ids).each do |units|
-          units.each do |unit|
-            unit = unit.with_indifferent_access
-            if content_type == 'rpm' && repository
-              rpms_to_disassociate = ::Katello::Rpm.where(name: unit[:name], version: unit[:version], release: unit[:release],
-                                                          epoch: unit[:epoch], arch: unit[:arch]).select(:id)
-              if rpms_to_disassociate.any?
-                ::Katello::RepositoryRpm.where(rpm_id: rpms_to_disassociate, repository_id: repository.id).destroy_all
-              end
-            end
-            model = Katello::Util::Support.active_record_retry do
-              self.where(:pulp_id => unit[service_class.unit_identifier]).first_or_create
-            end
-            service = service_class.new(model.pulp_id)
-            service.backend_data = unit
-            if repository&.generic?
-              service.update_model(model, generic_content_type)
-            end
-            service.update_model(model)
-            ids_to_associate << model.pulp_id
-          end
-        end
-        sync_repository_associations(repository, :pulp_ids => ids_to_associate, :additive => true) if self.many_repository_associations && repository && ids_to_associate.present?
-      end
-
-      # rubocop:disable Metrics/MethodLength
-      def import_for_repository(repository, generic_content_type: nil, full_index: false)
-        pulp_id_href_map = {}
-        if generic_content_type
-          service_class = SmartProxy.pulp_primary!.content_service(generic_content_type)
-        else
-          service_class = SmartProxy.pulp_primary!.content_service(content_type)
-        end
-        fetch_only_ids = !full_index &&
-                         !repository.content_view.default? &&
-                         !repository.repository_type.unique_content_per_repo &&
-                         service_class.supports_id_fetch?
-
-        erratum_updated_ids = []
-        service_class.pulp_units_batch_for_repo(repository, fetch_identifiers: fetch_only_ids, content_type: generic_content_type).each do |units|
-          units.each do |unit|
-            unit = unit.with_indifferent_access
-            pulp_id = unit[service_class.unit_identifier]
-            backend_identifier = unit.dig(service_class.backend_unit_identifier)
-            unless fetch_only_ids
-              model = Katello::Util::Support.active_record_retry do
-                self.where(:pulp_id => pulp_id).first_or_create
-              end
-              service = service_class.new(model.pulp_id)
-              service.backend_data = unit
-              model.repository_id = repository.id unless many_repository_associations
-
-              if repository.generic?
-                service.update_model(model, generic_content_type)
-              elsif self == ::Katello::Erratum
-                # Errata will change pulp_hrefs if the upstream repo updates them
-                erratum_updated_ids << service.update_model(model)
-              else
-                service.update_model(model)
-              end
-            end
-            pulp_id_href_map[pulp_id] = backend_identifier
-          end
-        end
-        sync_repository_associations(repository, :pulp_id_href_map => pulp_id_href_map, generic_content_type: generic_content_type, erratum_updated_ids: erratum_updated_ids.uniq) if self.many_repository_associations
-      end
-
-      def sync_repository_associations(repository, options = {})
-        additive = options.fetch(:additive, false)
-        generic_content_type = options.fetch(:generic_content_type, nil)
-        pulp_id_href_map = options.dig(:pulp_id_href_map) || {}
-        pulp_ids = options.dig(:pulp_ids) || pulp_id_href_map.try(:keys)
-        ids_for_repository = with_pulp_id(pulp_ids).pluck(:id, :pulp_id)
-        associated_ids = ids_for_repository.map(&:first)
-        id_href_map_for_repository = {}
-        ids_for_repository.each { |id_href| id_href_map_for_repository[id_href[0]] = id_href[1] }
-        id_href_map_for_repository.each_pair { |k, v| id_href_map_for_repository[k] = pulp_id_href_map[v] }
-        erratum_updated_ids = options.fetch(:erratum_updated_ids, []).flatten.compact
-
-        existing_ids = self.repository_association_class.uncached do
-          repo_assoc_units = self.repository_association_class.where(:repository_id => repository)
-
-          if generic_content_type
-            generic_unit_ids = Katello::GenericContentUnit
-              .where(id: repo_assoc_units.pluck(unit_id_field))
-              .where(content_type: generic_content_type).pluck(:id)
-            repo_assoc_units = repo_assoc_units.where(generic_content_unit_id: generic_unit_ids)
-          end
-
-          repo_assoc_units.pluck(unit_id_field)
-        end
-
-        new_ids = associated_ids - existing_ids
-        ActiveRecord::Base.transaction do
-          if !additive && (delete_ids = existing_ids - associated_ids).any?
-            query = "DELETE FROM #{self.repository_association_class.table_name} WHERE repository_id=#{repository.id} AND #{unit_id_field} IN (#{delete_ids.join(', ')})"
-            ActiveRecord::Base.connection.execute(query)
-          end
-          if self == ::Katello::Erratum
-            self.update_repo_association_records(new_ids, erratum_updated_ids, id_href_map_for_repository, repository)
-          else
-            unless new_ids.empty?
-              self.repository_association_class.import(db_columns_sync, db_values(new_ids, id_href_map_for_repository, repository), validate: false)
-            end
-          end
-        end
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      def copy_repository_associations(source_repo, dest_repo)
-        if many_repository_associations
-          delete_query = "delete from #{repository_association_class.table_name} where repository_id = #{dest_repo.id} and
-                         #{unit_id_field} not in (select #{unit_id_field} from #{repository_association_class.table_name} where repository_id = #{source_repo.id})"
-          ActiveRecord::Base.transaction do
-            ActiveRecord::Base.connection.execute(delete_query)
-            self.repository_association_class.import(db_columns_copy, db_values_copy(source_repo, dest_repo), validate: false)
-          end
-        else
-          columns = column_names - ["id", "pulp_id", "created_at", "updated_at", "repository_id"]
-          queries = []
-          queries << "delete from #{self.table_name} where repository_id = #{dest_repo.id} and
-                          pulp_id not in (select pulp_id from #{self.table_name} where repository_id = #{source_repo.id})"
-          queries << "insert into #{self.table_name} (repository_id, pulp_id, #{columns.join(',')})
-                    select #{dest_repo.id} as repository_id, pulp_id, #{columns.join(',')} from #{self.table_name}
-                    where repository_id = #{source_repo.id} and pulp_id not in (select pulp_id
-                    from #{self.table_name} where repository_id = #{dest_repo.id})"
-          ActiveRecord::Base.transaction do
-            queries.each do |query|
-              ActiveRecord::Base.connection.execute(query)
-            end
-          end
-        end
-      end
-
       def with_pulp_id(unit_pulp_ids)
         where('pulp_id in (?)', unit_pulp_ids)
       end
 
-      def db_columns_sync
-        [unit_id_field, backend_identifier_field, :repository_id, :created_at, :updated_at].compact
-      end
-
-      def db_columns_copy
-        [unit_id_field, backend_identifier_field, :repository_id].compact
-      end
-
-      def db_values_copy(source_repo, dest_repo)
-        db_values = []
-        existing_unit_ids = self.repository_association_class.where(repository: dest_repo).pluck(unit_id_field)
-        if existing_unit_ids.empty?
-          new_units = self.repository_association_class.where(repository: source_repo)
-        else
-          new_units = self.repository_association_class.where(repository: source_repo).where.not("#{unit_id_field} in (?) ", existing_unit_ids)
-        end
-        unit_backend_identifier_field = backend_identifier_field
-        unit_identifier_filed = unit_id_field
-        new_units.each do |unit|
-          db_values << [unit[unit_identifier_filed], unit[unit_backend_identifier_field], dest_repo.id].compact
-        end
-        db_values
-      end
-
-      def db_values(new_ids, pulp_id_href_map, repository)
-        new_ids.map { |unit_id| [unit_id.to_i, pulp_id_href_map.dig(unit_id), repository.id.to_i, Time.now.utc.to_s(:db), Time.now.utc.to_s(:db)].compact }
+      def unit_id_field
+        "#{self.name.demodulize.underscore}_id"
       end
     end
   end

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

@@ -0,0 +1,11 @@
+module Katello
+  module Concerns
+    module RemoteExecutionProxySelectorExtensions
+      def strategies
+        order = [super, [:registered_through]]
+        order = order.reverse if Setting[:remote_execution_prefer_registered_through_proxy]
+        order.reduce(:+)
+      end
+    end
+  end
+end

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

@@ -345,7 +345,7 @@ module Katello
           fail _("Content type %{content_type_string} does not belong to an enabled repo type.") %
                 { content_type_string: content_type_string }
         end
-        pulp3_content_support?(content_type_obj) ? content_type_obj.pulp3_service_class : content_type_obj.pulp2_service_class
+        content_type_obj.pulp3_service_class
       end
 
       def set_default_download_policy

data/app/models/katello/content_view.rb

@@ -30,7 +30,7 @@ module Katello
              :inverse_of => :composite_content_view, :foreign_key => :composite_content_view_id, autosave: true
 
     has_many :component_composites, :class_name => "Katello::ContentViewComponent",
-             :dependent => :destroy, :inverse_of => :content_view, :foreign_key => :content_view_id
+             :dependent => :destroy, :inverse_of => :content_view
 
     has_many :content_view_repositories, :class_name => 'Katello::ContentViewRepository',
              :dependent => :destroy, :inverse_of => :content_view
@@ -41,16 +41,16 @@ module Katello
 
     has_many :activation_keys, :class_name => "Katello::ActivationKey", :dependent => :restrict_with_exception
 
-    has_many :content_facets, :class_name => "Katello::Host::ContentFacet", :foreign_key => :content_view_id,
+    has_many :content_facets, :class_name => "Katello::Host::ContentFacet",
                           :inverse_of => :content_view, :dependent => :restrict_with_exception
     has_many :hosts,      :class_name => "::Host::Managed", :through => :content_facets,
                           :inverse_of => :content_view
-    has_many :hostgroup_content_facets, :class_name => "Katello::Hostgroup::ContentFacet", :foreign_key => :content_view_id,
+    has_many :hostgroup_content_facets, :class_name => "Katello::Hostgroup::ContentFacet",
                           :inverse_of => :content_view, :dependent => :nullify
     has_many :hostgroups, :class_name => "::Hostgroup", :through => :hostgroup_content_facets,
                           :inverse_of => :content_view
 
-    has_many :repository_references, :class_name => 'Katello::Pulp3::RepositoryReference', :foreign_key => :content_view_id,
+    has_many :repository_references, :class_name => 'Katello::Pulp3::RepositoryReference',
              :dependent => :destroy, :inverse_of => :content_view
 
     validates_lengths_from_database :except => [:label]

data/app/models/katello/content_view_filter.rb

@@ -15,7 +15,7 @@ module Katello
                :class_name => "Katello::ContentView",
                :inverse_of => :filters
 
-    has_many :repository_content_view_filters, :class_name => "Katello::RepositoryContentViewFilter", :dependent => :delete_all, :inverse_of => :filter, :foreign_key => :content_view_filter_id
+    has_many :repository_content_view_filters, :class_name => "Katello::RepositoryContentViewFilter", :dependent => :delete_all, :inverse_of => :filter
     has_many :repositories, :through => :repository_content_view_filters, :class_name => "Katello::Repository"
 
     validates_lengths_from_database

data/app/models/katello/content_view_history.rb

@@ -8,7 +8,7 @@ module Katello
 
     belongs_to :triggered_by, :class_name => "Katello::ContentViewVersion", :inverse_of => :triggered_histories
 
-    belongs_to :task, :class_name => "ForemanTasks::Task::DynflowTask", :foreign_key => :task_id
+    belongs_to :task, :class_name => "ForemanTasks::Task::DynflowTask"
 
     IN_PROGRESS = 'in progress'.freeze
     FAILED = 'failed'.freeze

data/app/models/katello/content_view_version.rb

@@ -24,9 +24,9 @@ module Katello
              :inverse_of => :triggered_by, :foreign_key => :triggered_by_id
 
     has_many :export_histories, :class_name => "::Katello::ContentViewVersionExportHistory", :dependent => :destroy,
-             :inverse_of => :content_view_version, :foreign_key => :content_view_version_id
+             :inverse_of => :content_view_version
     has_many :import_histories, :class_name => "::Katello::ContentViewVersionImportHistory", :dependent => :destroy,
-             :inverse_of => :content_view_version, :foreign_key => :content_view_version_id
+             :inverse_of => :content_view_version
     has_many :repositories, :class_name => "::Katello::Repository", :dependent => :destroy
     has_one :task_status, :class_name => "Katello::TaskStatus", :as => :task_owner, :dependent => :destroy
 
@@ -239,6 +239,10 @@ module Katello
       Rpm.in_repositories(archived_repos)
     end
 
+    def generic_content_units(content_type)
+      GenericContentUnit.in_repositories(archived_repos).where(content_type: content_type)
+    end
+
     def library_packages
       Rpm.in_repositories(library_repos)
     end

data/app/models/katello/content_view_version_export_history.rb

@@ -9,7 +9,7 @@ module Katello
     INCREMENTAL = "incremental".freeze
     EXPORT_TYPES = [COMPLETE, INCREMENTAL].freeze
 
-    belongs_to :content_view_version, :class_name => "::Katello::ContentViewVersion", :inverse_of => :export_histories, foreign_key: 'content_view_version_id'
+    belongs_to :content_view_version, :class_name => "::Katello::ContentViewVersion", :inverse_of => :export_histories
     validates_lengths_from_database
 
     validates :content_view_version_id, :presence => true

data/app/models/katello/deb.rb

@@ -2,7 +2,7 @@ module Katello
   class Deb < Katello::Model
     include Concerns::PulpDatabaseUnit
 
-    CONTENT_TYPE = Pulp::Deb::CONTENT_TYPE
+    CONTENT_TYPE = 'deb'.freeze
 
     has_many :repository_debs, :class_name => "Katello::RepositoryDeb", :dependent => :destroy, :inverse_of => :deb
     has_many :repositories, :through => :repository_debs, :class_name => "Katello::Repository"
@@ -16,8 +16,6 @@ module Katello
     scoped_search :on => :filename, :complete_value => true
     scoped_search :on => :checksum
 
-    before_save lambda { |deb| deb.description = deb.description.truncate(255) unless deb.description.blank? }
-
     def self.default_sort
       order(:name).order(:version).order(:architecture)
     end

data/app/models/katello/docker_meta_tag.rb

@@ -153,7 +153,7 @@ module Katello
         end
 
         unless params_to_query_for_delete.empty?
-          RepositoryDockerMetaTag.where(:docker_meta_tag => DockerMetaTag.where(params_to_query_for_delete.join(" OR "))).delete_all
+          RepositoryDockerMetaTag.where(:repository_id => repo.id).where(:docker_meta_tag => DockerMetaTag.where(params_to_query_for_delete.join(" OR "))).delete_all
         end
 
         metatags = []

data/app/models/katello/erratum.rb

@@ -47,8 +47,6 @@ module Katello
                   :validator => ->(value) { ['true', 'false'].include?(value.downcase) },
                   :operators => ["="]
 
-    before_save lambda { |erratum| erratum.title = erratum.title.truncate(255) unless erratum.title.blank? }
-
     def self.of_type(type)
       where(:errata_type => type)
     end
@@ -92,19 +90,6 @@ module Katello
       where("#{self.table_name}.id in (?) or #{self.table_name}.pulp_id in (?) or #{self.table_name}.errata_id in (?)", id_integers, ids, ids)
     end
 
-    def self.update_repo_association_records(new_ids, erratum_updated_ids, id_href_map_for_repository, repository)
-      if new_ids.any?
-        self.repository_association_class.import(db_columns_sync, db_values(new_ids, id_href_map_for_repository, repository), validate: false)
-      end
-      if erratum_updated_ids.present?
-        upserts = db_values(erratum_updated_ids, id_href_map_for_repository, repository).map do |upsert|
-          { erratum_id: upsert[0], erratum_pulp3_href: upsert[1], repository_id: upsert[2], created_at: upsert[3], updated_at: upsert[4] }
-        end
-        # PostgreSQL refuses to insert and update in the same command: https://github.com/rails/rails/issues/35519
-        self.repository_association_class.upsert_all(upserts, unique_by: [:erratum_id, :repository_id])
-      end
-    end
-
     def hosts_applicable(org_id = nil)
       if org_id.present?
         self.content_facets_applicable.joins(:host).where("#{::Host.table_name}.organization_id" => org_id)

data/app/models/katello/glue/pulp/repos.rb

@@ -132,7 +132,7 @@ module Katello
       def add_repo(repo_param)
         repo_param[:unprotected] = repo_param[:unprotected].nil? ? false : repo_param[:unprotected]
 
-        if repo_param[:download_policy].blank? && repo_param[:content_type] == Repository::YUM_TYPE
+        if repo_param[:download_policy].blank? && Katello::RootRepository::CONTENT_ATTRIBUTE_RESTRICTIONS[:download_policy].include?(repo_param[:content_type])
           repo_param[:download_policy] = Setting[:default_download_policy]
         end
 

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

@@ -9,10 +9,10 @@ module Katello
       HOST_TOOLS_TRACER_PACKAGE_NAME = 'katello-host-tools-tracer'.freeze
       SUBSCRIPTION_MANAGER_PACKAGE_NAME = 'subscription-manager'.freeze
 
-      belongs_to :kickstart_repository, :class_name => "::Katello::Repository", :foreign_key => :kickstart_repository_id, :inverse_of => :kickstart_content_facets
+      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", :foreign_key => :content_source_id, :inverse_of => :content_facets
+      belongs_to :content_source, :class_name => "::SmartProxy", :inverse_of => :content_facets
 
       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
@@ -110,14 +110,6 @@ module Katello
         self.update_errata_status
       end
 
-      def import_applicability(partial = false)
-        import_module_stream_applicability(partial)
-        import_errata_applicability(partial)
-        import_deb_applicability(partial)
-        import_rpm_applicability(partial)
-        update_applicability_counts
-      end
-
       def update_applicability_counts
         self.assign_attributes(
             :installable_security_errata_count => self.installable_errata.security.count,
@@ -133,23 +125,6 @@ module Katello
         self.save!(:validate => false)
       end
 
-      def import_deb_applicability(partial)
-        ApplicableContentHelper.new(Deb, self).import(partial)
-      end
-
-      def import_rpm_applicability(partial)
-        ApplicableContentHelper.new(Rpm, self).import(partial)
-      end
-
-      def import_errata_applicability(partial)
-        ApplicableContentHelper.new(Erratum, self).import(partial)
-        self.update_errata_status
-      end
-
-      def import_module_stream_applicability(partial)
-        ApplicableContentHelper.new(ModuleStream, self).import(partial)
-      end
-
       def self.in_content_view_version_environments(version_environments)
         #takes a structure of [{:content_view_version => ContentViewVersion, :environments => [KTEnvironment]}]
         queries = version_environments.map do |version_environment|

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

@@ -16,6 +16,15 @@ module Katello
         if host.content_facet.present?
           info['parameters']['kickstart_repository'] = host.content_facet.kickstart_repository.try(:label)
         end
+
+        if (rhsm_url = host.content_source&.rhsm_url)
+          info['parameters']['rhsm_url'] = rhsm_url.to_s
+        end
+
+        if (content_url = host.content_source&.pulp_content_url)
+          info['parameters']['content_url'] = content_url.to_s
+        end
+
         info
       end
 

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

@@ -7,7 +7,7 @@ module Katello
       include DirtyAssociations
 
       belongs_to :user, :inverse_of => :subscription_facets, :class_name => "::User"
-      belongs_to :hypervisor_host, :class_name => "::Host::Managed", :foreign_key => "hypervisor_host_id"
+      belongs_to :hypervisor_host, :class_name => "::Host::Managed"
 
       has_many :subscription_facet_activation_keys, :class_name => "Katello::SubscriptionFacetActivationKey", :dependent => :destroy, :inverse_of => :subscription_facet
       has_many :activation_keys, :through => :subscription_facet_activation_keys, :class_name => "Katello::ActivationKey"
@@ -217,7 +217,7 @@ module Katello
         if ignore_os?(host.operatingsystem, rhsm_facts)
           rhsm_facts[:ignore_os] = true
         end
-        host.import_facts(rhsm_facts)
+        ::HostFactImporter.new(host).import_facts(rhsm_facts)
       end
 
       def self.ignore_os?(host_os, rhsm_facts)

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

@@ -5,10 +5,10 @@ module Katello
       self.table_name = 'katello_hostgroup_content_facets'
       include Facets::HostgroupFacet
 
-      belongs_to :kickstart_repository, :class_name => "::Katello::Repository", :foreign_key => :kickstart_repository_id, :inverse_of => :kickstart_hostgroup_content_facets
+      belongs_to :kickstart_repository, :class_name => "::Katello::Repository", :inverse_of => :kickstart_hostgroup_content_facets
       belongs_to :content_view, :inverse_of => :hostgroup_content_facets, :class_name => "Katello::ContentView"
       belongs_to :lifecycle_environment, :inverse_of => :hostgroup_content_facets, :class_name => "Katello::KTEnvironment"
-      belongs_to :content_source, :class_name => "::SmartProxy", :foreign_key => :content_source_id, :inverse_of => :hostgroup_content_facets
+      belongs_to :content_source, :class_name => "::SmartProxy", :inverse_of => :hostgroup_content_facets
 
       validates_with Katello::Validators::ContentViewEnvironmentValidator
       validates_with Katello::Validators::HostgroupKickstartRepositoryValidator

data/app/models/katello/product.rb

@@ -15,7 +15,7 @@ module Katello
     belongs_to :provider, :inverse_of => :products, :class_name => 'Katello::Provider'
     belongs_to :sync_plan, :inverse_of => :products, :class_name => 'Katello::SyncPlan'
     belongs_to :gpg_key, :inverse_of => :products, :class_name => "Katello::ContentCredential"
-    has_many :product_contents, :foreign_key => 'product_id', :class_name => "Katello::ProductContent", :dependent => :destroy
+    has_many :product_contents, :class_name => "Katello::ProductContent", :dependent => :destroy
     has_many :contents, :through => :product_contents
     has_many :displayable_product_contents, -> { displayable }, :foreign_key => 'product_id', :class_name => "Katello::ProductContent", :dependent => :destroy
     belongs_to :ssl_ca_cert, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_ca_products

data/app/models/katello/product_content.rb

@@ -1,7 +1,7 @@
 module Katello
   class ProductContent < Katello::Model
-    belongs_to :product, :class_name => 'Katello::Product', :foreign_key => 'product_id', :inverse_of => :product_contents
-    belongs_to :content, :class_name => 'Katello::Content', :foreign_key => 'content_id', :inverse_of => :product_contents
+    belongs_to :product, :class_name => 'Katello::Product', :inverse_of => :product_contents
+    belongs_to :content, :class_name => 'Katello::Content', :inverse_of => :product_contents
 
     default_scope { includes(:content) }
 

data/app/models/katello/repository.rb

@@ -37,7 +37,7 @@ module Katello
 
     belongs_to :root, :inverse_of => :repositories, :class_name => "Katello::RootRepository"
     belongs_to :environment, :inverse_of => :repositories, :class_name => "Katello::KTEnvironment"
-    belongs_to :library_instance, :class_name => "Katello::Repository", :inverse_of => :library_instances_inverse, :foreign_key => :library_instance_id
+    belongs_to :library_instance, :class_name => "Katello::Repository", :inverse_of => :library_instances_inverse
     has_many :library_instances_inverse,
              :class_name  => 'Katello::Repository',
              :dependent   => :restrict_with_exception,
@@ -105,7 +105,7 @@ module Katello
     has_many :filters, :through => :repository_content_view_filters
 
     belongs_to :content_view_version, :inverse_of => :repositories, :class_name => "Katello::ContentViewVersion"
-    has_many :distribution_references, :class_name => 'Katello::Pulp3::DistributionReference', :foreign_key => :repository_id,
+    has_many :distribution_references, :class_name => 'Katello::Pulp3::DistributionReference',
              :dependent => :destroy, :inverse_of => :repository
 
     has_many :smart_proxy_sync_histories, :class_name => "::Katello::SmartProxySyncHistory", :inverse_of => :repository, :dependent => :delete_all
@@ -177,8 +177,8 @@ module Katello
              :download_policy, :verify_ssl_on_sync, :"verify_ssl_on_sync?", :upstream_username, :upstream_password,
              :upstream_authentication_token, :deb_releases,
              :deb_components, :deb_architectures, :ssl_ca_cert_id, :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_id,
-             :ssl_client_key_id, :os_versions, :ssl_client_key, :ignorable_content, :description, :docker_tags_whitelist,
-             :ansible_collection_requirements, :ansible_collection_auth_url, :ansible_collection_auth_token,
+             :ssl_client_key_id, :os_versions, :ssl_client_key, :ignorable_content, :description, :include_tags, :exclude_tags,
+             :docker_tags_whitelist, :ansible_collection_requirements, :ansible_collection_auth_url, :ansible_collection_auth_token,
              :http_proxy_policy, :http_proxy_id, :to => :root
 
     delegate :content_id, to: :root, allow_nil: true
@@ -285,6 +285,11 @@ module Katello
       ::Katello::Resources::CDN::CdnResource.ca_file if ::Katello::Resources::CDN::CdnResource.redhat_cdn?(url)
     end
 
+    def soft_copy_of_library?
+      return false if self.version_href.nil?
+      self.version_href.starts_with?(self.library_instance.backend_service(SmartProxy.pulp_primary).repository_reference.repository_href)
+    end
+
     def archive?
       self.environment.nil?
     end
@@ -910,11 +915,7 @@ module Katello
       else
         repository_type.content_types_to_index.each do |type|
           Katello::Logging.time("CONTENT_INDEX", data: {type: type.model_class}) do
-            if self.generic?
-              type.model_class.import_for_repository(self, generic_content_type: type.content_type, full_index: full_index)
-            else
-              type.model_class.import_for_repository(self, full_index: full_index)
-            end
+            Katello::ContentUnitIndexer.new(content_type: type, repository: self, optimized: !full_index).import_all
           end
         end
         repository_type.index_additional_data_proc&.call(self)