katello 4.3.0.rc4 → 4.4.0.rc2

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

@@ -8,8 +8,9 @@ module Katello
       def filter_package_groups_by_pulp_href(package_groups, package_pulp_hrefs)
         rpms = Katello::Rpm.where(:pulp_id => package_pulp_hrefs)
         package_groups.reject do |package_group|
+          #copy the package group as long as we have 1 package from the group
           package_group.package_names.empty? ||
-          (package_group.package_names - rpms.pluck(:name)).any?
+          (package_group.package_names & rpms.pluck(:name)).empty?
         end
       end
 

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

@@ -34,7 +34,7 @@ module Katello
           :content_type => katello_content_type,
           :unprotected => unprotected?,
           :download_policy => download_policy,
-          :mirror_on_sync => true
+          :mirroring_policy => Katello::RootRepository::MIRRORING_POLICY_COMPLETE
         )
 
         Repository.new(:root => root,
@@ -44,7 +44,7 @@ module Katello
       end
 
       def validate!
-        return if katello_content_type == Repository::OSTREE_TYPE || Setting[:content_disconnected]
+        return if katello_content_type == Repository::OSTREE_TYPE || product.organization.cdn_configuration.airgapped?
         substitutor.validate_substitutions(content, substitutions)
       end
 
@@ -74,6 +74,7 @@ module Katello
       end
 
       def feed_url
+        return if product.organization.cdn_configuration.airgapped?
         @feed_url ||= if product.cdn_resource&.respond_to?(:repository_url)
                         product.cdn_resource.repository_url(content_label: content.label)
                       else

data/app/models/katello/cdn_configuration.rb

@@ -1,31 +1,63 @@
 module Katello
   class CdnConfiguration < Katello::Model
     include Encryptable
+    self.inheritance_column = nil
+    CDN_TYPE = 'redhat_cdn'.freeze
+    UPSTREAM_SERVER_TYPE = 'upstream_server'.freeze
+    AIRGAPPED_TYPE = 'airgapped'.freeze
+
+    TYPES = [CDN_TYPE, UPSTREAM_SERVER_TYPE, AIRGAPPED_TYPE].freeze
 
     belongs_to :organization, :inverse_of => :cdn_configuration
 
     belongs_to :ssl_ca_credential, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_ca_cdn_configurations
 
     encrypts :password
+    validates :password, presence: true, if: :upstream_server?
+    validates :username, presence: true, if: :upstream_server?
+    validates :upstream_organization_label, presence: true, if: :upstream_server?
 
-    validates :url, presence: true
-    validates_with Validators::KatelloUrlFormatValidator, attributes: :url
+    validates :url, presence: true, unless: :airgapped?
+    validates_with Validators::KatelloUrlFormatValidator, attributes: :url, unless: :airgapped?
     validates_with Validators::KatelloLabelFormatValidator, attributes: :upstream_organization_label, if: proc { upstream_organization_label.present? }
-    validate :non_redhat_configuration, unless: :redhat?
+    validate :non_redhat_configuration, if: :upstream_server?
+
+    before_validation :reset_fields
 
     def ssl_ca
       ssl_ca_credential&.content
     end
 
-    def redhat?
-      username.blank? && password.blank? && upstream_organization_label.blank? && ssl_ca_credential_id.blank?
+    def redhat_cdn?
+      type == CDN_TYPE
+    end
+
+    def airgapped?
+      type == AIRGAPPED_TYPE
+    end
+
+    def upstream_server?
+      type == UPSTREAM_SERVER_TYPE
     end
 
     private
 
+    def reset_fields
+      return if upstream_server?
+
+      self.url = nil if airgapped?
+      self.url ||= SETTINGS[:katello][:redhat_repository_url] if redhat_cdn?
+      self.username = nil
+      self.password = nil
+      self.upstream_organization_label = nil
+      self.ssl_ca_credential_id = nil
+      self.upstream_content_view_label = nil
+      self.upstream_lifecycle_environment_label = nil
+    end
+
     def non_redhat_configuration
       if username.blank? || password.blank? || upstream_organization_label.blank? || ssl_ca_credential_id.blank?
-        errors.add(:base, _("Username, Password, Upstream Organization Label, and SSL CA Credential are required when using a non-Red Hat CDN."))
+        errors.add(:base, _("Username, Password, Upstream Organization Label, and SSL CA Credential are required when using an upstream Foreman server."))
       end
     end
   end

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

@@ -0,0 +1,17 @@
+module Katello
+  module Concerns::AuditCommentExtensions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # to prevent PG::StringDataRightTruncation: ERROR:  value too long for type character varying(255)
+      def truncate_audit_comment(long_comment)
+        if long_comment.length > 255
+          Rails.logger.info "Truncating audit comment: #{long_comment}"
+          "#{long_comment[0..250]}..."
+        else
+          long_comment
+        end
+      end
+    end
+  end
+end

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

@@ -28,9 +28,21 @@ module Katello
             content_facet.kickstart_repository_id = valid_repos.first
           end
         end
+
+        def remote_execution_proxies(provider, *_rest)
+          proxies = super
+          if (name = subscription_facet&.registered_through)
+            registered_through = SmartProxy.with_features(provider)
+                                           .authorized
+                                           .where(name: name)
+          end
+          proxies[:registered_through] = registered_through || []
+          proxies
+        end
       end
 
       included do
+        prepend ::ForemanRemoteExecution::HostExtensions if ::Katello.with_remote_execution?
         prepend Overrides
 
         delegate :content_source_id, :content_view_id, :lifecycle_environment_id, :kickstart_repository_id, to: :content_facet, allow_nil: true
@@ -109,7 +121,7 @@ module Katello
         self.host_statuses.where(type: ::Katello::HostStatusManager::STATUSES.map(&:name)).each do |status|
           status.refresh!
         end
-        refresh_global_status!
+        refresh_global_status
       end
 
       def queue_refresh_content_host_status
@@ -388,6 +400,26 @@ module Katello
         ::Katello::HostTracer.helpers_for(traces)
       end
 
+      def package_names_for_job_template(action:, search:)
+        actions = %w(install remove update).freeze
+        case action
+        when 'install'
+          ::Katello::Rpm.yum_installable_for_host(self).search_for(search).distinct.pluck(:name)
+        when 'remove'
+          return [] if search.empty?
+
+          installed_packages.search_for(search).distinct.pluck(:name)
+        when 'update'
+          return [] if search.empty?
+
+          pkg_names = installed_packages.search_for(search).distinct.pluck(:name)
+          upgrades = ::Katello::Rpm.installable_for_hosts([self]).select(:id, :name, :nvra, :evr).order(evr: :desc).group_by(&:name)
+          pkg_names.map { |p| upgrades[p]&.first&.nvra }.compact
+        else
+          fail ::Foreman::Exception.new(N_("package_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)
       end
@@ -414,7 +446,7 @@ end
 class ::Host::Managed::Jail < Safemode::Jail
   allow :content_source, :subscription_manager_configuration_url, :rhsm_organization_label,
         :host_collections, :pools, :hypervisor_host, :lifecycle_environment, :content_view,
-        :installed_packages, :traces_helpers, :advisory_ids
+        :installed_packages, :traces_helpers, :advisory_ids, :package_names_for_job_template
 end
 
 class ActiveRecord::Associations::CollectionProxy::Jail < Safemode::Jail

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

@@ -55,6 +55,10 @@ module Katello
         # so that it will execute after :dependent => :destroy
         before_destroy :destroy_taxable_taxonomies
 
+        def self.non_audited_columns
+          super | [:created_in_katello]
+        end
+
         def default_content_view
           ContentView.default.where(:organization_id => self.id).first
         end
@@ -193,7 +197,7 @@ module Katello
 
         def latest_repo_discovery
           ForemanTasks::Task::DynflowTask.for_action(::Actions::Katello::Repository::Discover)
-            .for_resource(::User.current).order("started_at").last
+            .where(user: ::User.current).order("started_at").last
         end
 
         def cancel_repo_discovery

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

@@ -179,6 +179,7 @@ module Katello
           config.scheme = uri.scheme
           pulp3_ssl_configuration(config)
           config.debugging = false
+          config.timeout = SETTINGS[:katello][:rest_client_timeout]
           config.logger = ::Foreman::Logging.logger('katello/pulp_rest')
           config.username = self.setting(PULP3_FEATURE, 'username')
           config.password = self.setting(PULP3_FEATURE, 'password')
@@ -345,7 +346,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

@@ -1,6 +1,7 @@
 module Katello
   class ContentViewVersionExportHistory < Katello::Model
     include Authorization::ContentViewVersionExportHistory
+    include Concerns::AuditCommentExtensions
     audited except: :metadata
     delegate :organization, to: :content_view_version
     delegate :id, to: :organization, prefix: true
@@ -9,7 +10,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
@@ -58,7 +59,7 @@ module Katello
         export_descriptor = "export of content view '#{content_view_version.content_view.name}' version #{content_view_version.version}"
         export_descriptor += " from #{from_version.name}" if from_version
       end
-      "#{export_type&.capitalize} #{export_descriptor} created by #{user.to_label}"
+      truncate_audit_comment("#{export_type&.capitalize} #{export_descriptor} created by #{user.to_label}")
     end
   end
 end

data/app/models/katello/content_view_version_import_history.rb

@@ -1,6 +1,7 @@
 module Katello
   class ContentViewVersionImportHistory < Katello::Model
     include Authorization::ContentViewVersionImportHistory
+    include Concerns::AuditCommentExtensions
 
     audited except: :metadata
     delegate :organization, to: :content_view_version
@@ -31,12 +32,11 @@ module Katello
     scoped_search :on => :id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
     scoped_search :on => :import_type, :rename => :type, :complete_value => ContentViewVersionExportHistory::EXPORT_TYPES
 
-    def self.generate_audit_comment(user:, path:, content_view_name:)
-      _("Content imported from %{path} into content view '%{name}' by %{user}") % {
-        path: path,
+    def self.generate_audit_comment(user:, content_view_name:)
+      truncate_audit_comment(_("Content imported by %{user} into content view '%{name}'") % {
         user: user.to_label,
         name: content_view_name
-      }
+      })
     end
   end
 end

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 = []