katello 4.4.2.2 → 4.5.0.rc1

data/app/lib/actions/katello/product/content_create.rb

@@ -44,16 +44,18 @@ module Actions
           root = ::Katello::RootRepository.find(input[:root_repository_id])
           root.update(:content_id => input[:content_id])
 
-          content = ::Katello::Content.create!(name: root.name,
-                                               organization_id: root.product.organization_id,
-                                               cp_content_id: root.content_id,
-                                               content_type: root.content_type,
-                                               label: root.custom_content_label,
-                                               content_url: root.custom_content_path,
-                                               vendor: ::Katello::Provider::CUSTOM)
+          content = ::Katello::Content.where(organization_id: root.product.organization_id, cp_content_id: root.content_id).first_or_create do |new_content|
+            new_content.name = root.name
+            new_content.content_type = root.content_type
+            new_content.label = root.custom_content_label
+            new_content.content_url = root.custom_content_path
+            new_content.vendor = ::Katello::Provider::CUSTOM
+          end
 
           #custom product content is always enabled by default
-          ::Katello::ProductContent.create!(product: root.product, content: content, enabled: true)
+          ::Katello::ProductContent.where(product: root.product, content: content).first_or_create do |pc|
+            pc.enabled = true
+          end
         end
       end
     end

data/app/lib/actions/katello/repository/destroy.rb

@@ -14,22 +14,16 @@ module Actions
           destroy_content = options.fetch(:destroy_content, true)
           remove_from_content_view_versions = options.fetch(:remove_from_content_view_versions, false)
           action_subject(repository)
+          check_destroyable!(repository, remove_from_content_view_versions)
+          remove_generated_content_views(repository)
 
-          unless repository.destroyable?(remove_from_content_view_versions)
-            # The repository is going to be deleted in finalize, but it cannot be deleted.
-            # Stop now and inform the user.
-            fail repository.errors.messages.values.join("\n")
-          end
+          remove_versions(repository, repository.content_views.generated_for_library, affected_cvv_ids)
 
           plan_action(Actions::Pulp3::Orchestration::Repository::Delete,
                            repository,
                            SmartProxy.pulp_primary)
 
-          if remove_from_content_view_versions
-            library_instances_inverse = repository.library_instances_inverse
-            affected_cvv_ids = library_instances_inverse.pluck(:content_view_version_id).uniq
-            plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::Destroy, library_instances_inverse)
-          end
+          remove_versions(repository, repository.content_views.generated_for_none, affected_cvv_ids) if remove_from_content_view_versions
 
           plan_self(:user_id => ::User.current.id, :affected_cvv_ids => affected_cvv_ids)
           sequence do
@@ -50,8 +44,9 @@ module Actions
             delete_record(repository, {docker_cleanup: docker_cleanup})
 
             if (affected_cvv_ids = input[:affected_cvv_ids]).any?
-              affected_cvv_ids.each do |cvv_id|
-                ::Katello::ContentViewVersion.find(cvv_id).update_content_counts!
+              cvvs = ::Katello::ContentViewVersion.where(id: affected_cvv_ids)
+              cvvs.each do |cvv|
+                cvv.update_content_counts!
               end
             end
           end
@@ -77,6 +72,35 @@ module Actions
           ::Katello::DockerMetaTag.cleanup_tags if options[:docker_cleanup]
         end
 
+        def remove_generated_content_views(repository)
+          # remove the content views generated for this repository (since we are deleting the repo)
+          content_views = repository.content_views.generated_for_repository
+          return if content_views.blank?
+          plan_action(::Actions::BulkAction, ::Actions::Katello::ContentView::Remove,
+                        content_views,
+                        skip_repo_destroy: true,
+                        destroy_content_view: true)
+        end
+
+        def remove_versions(repository, content_views, affected_cvv_ids)
+          return if content_views.blank?
+
+          interested_inverses = repository.
+                                  library_instances_inverse.
+                                  joins(:content_view_version => :content_view).
+                                  merge(content_views)
+          affected_cvv_ids.concat(interested_inverses.pluck(:content_view_version_id).uniq)
+          plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::Destroy, interested_inverses)
+        end
+
+        def check_destroyable!(repository, remove_from_content_view_versions)
+          unless repository.destroyable?(remove_from_content_view_versions)
+            # The repository is going to be deleted in finalize, but it cannot be deleted.
+            # Stop now and inform the user.
+            fail repository.errors.messages.values.join("\n")
+          end
+        end
+
         def humanized_name
           _("Delete")
         end

data/app/lib/actions/katello/repository_set/disable_repository.rb

@@ -7,9 +7,14 @@ module Actions
         end
 
         def plan(product, content, options)
-          repository = repository_mapper(product,
-                                         content,
-                                         options).find_repository
+          if options[:repository_id]
+            repository = ::Katello::Repository.find(options[:repository_id])
+          else
+            repository = repository_mapper(product,
+                                           content,
+                                           options).find_repository
+          end
+
           if repository
             action_subject(repository)
             plan_action(Repository::Destroy, repository)

data/app/lib/actions/pulp3/alternate_content_source/create.rb

@@ -0,0 +1,20 @@
+module Actions
+  module Pulp3
+    module AlternateContentSource
+      class Create < Pulp3::Abstract
+        def plan(acs, smart_proxy)
+          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def run
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).create
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/alternate_content_source/create_remote.rb

@@ -0,0 +1,20 @@
+module Actions
+  module Pulp3
+    module AlternateContentSource
+      class CreateRemote < Pulp3::Abstract
+        def plan(acs, smart_proxy)
+          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def run
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).create_remote
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/alternate_content_source/delete.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp3
+    module AlternateContentSource
+      class Delete < Pulp3::Abstract
+        def plan(acs, smart_proxy)
+          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def run
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).delete_alternate_content_source
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/alternate_content_source/delete_remote.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp3
+    module AlternateContentSource
+      class DeleteRemote < Pulp3::Abstract
+        def plan(acs, smart_proxy)
+          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def run
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).delete_remote
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/alternate_content_source/update.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp3
+    module AlternateContentSource
+      class Update < Pulp3::Abstract
+        def plan(acs, smart_proxy)
+          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def run
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).update
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/alternate_content_source/update_remote.rb

@@ -0,0 +1,17 @@
+module Actions
+  module Pulp3
+    module AlternateContentSource
+      class UpdateRemote < Pulp3::Abstract
+        def plan(acs, smart_proxy)
+          acs.backend_service(smart_proxy).create_test_remote
+          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def run
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).update_remote
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/content_view_version/{import.rb → create_import.rb}

@@ -1,9 +1,9 @@
 module Actions
   module Pulp3
     module ContentViewVersion
-      class Import < Pulp3::AbstractAsyncTask
+      class CreateImport < Pulp3::AbstractAsyncTask
         input_format do
-          param :content_view_version_id, Integer
+          param :organization_id, Integer
           param :smart_proxy_id, Integer
           param :importer_data, Hash
           param :path, String
@@ -11,12 +11,12 @@ module Actions
         end
 
         def invoke_external_task
-          cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          metadata_map = ::Katello::Pulp3::ContentViewVersion::MetadataMap.new(metadata: input[:metadata])
           output[:pulp_tasks] = ::Katello::Pulp3::ContentViewVersion::Import.new(
+            organization: ::Organization.find(input[:organization_id]),
             smart_proxy: smart_proxy,
-            content_view_version: cvv,
             path: input[:path],
-            metadata: input[:metadata]
+            metadata_map: metadata_map
           ).create_import(input[:importer_data][:pulp_href])
         end
 

data/app/lib/actions/pulp3/content_view_version/create_importer.rb

@@ -11,12 +11,13 @@ module Actions
 
         def run
           cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          metadata_map = ::Katello::Pulp3::ContentViewVersion::MetadataMap.new(metadata: input[:metadata])
           output[:importer_data] = ::Katello::Pulp3::ContentViewVersion::Import.new(
+            organization: cvv.content_view.organization,
             smart_proxy: smart_proxy,
-            content_view_version: cvv,
             path: input[:path],
-            metadata: input[:metadata]
-          ).create_importer
+            metadata_map: metadata_map
+          ).create_importer(cvv)
         end
       end
     end

data/app/lib/actions/pulp3/content_view_version/destroy_importer.rb

@@ -5,10 +5,21 @@ module Actions
         input_format do
           param :smart_proxy_id, Integer
           param :importer_data, Hash
+          param :organization_id, Integer
+          param :importer_data, Hash
+          param :path, String
+          param :metadata, Hash
         end
 
         def run
-          ::Katello::Pulp3::ContentViewVersion::Import.new(smart_proxy: smart_proxy).destroy_importer(input[:importer_data][:pulp_href])
+          metadata_map = ::Katello::Pulp3::ContentViewVersion::MetadataMap.new(metadata: input[:metadata])
+          import = ::Katello::Pulp3::ContentViewVersion::Import.new(
+            organization: ::Organization.find(input[:organization_id]),
+            smart_proxy: smart_proxy,
+            path: input[:path],
+            metadata_map: metadata_map
+          )
+          import.destroy_importer(input[:importer_data][:pulp_href])
         end
       end
     end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/create.rb

@@ -0,0 +1,18 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module AlternateContentSource
+        class Create < Pulp3::Abstract
+          def plan(acs, smart_proxy)
+            sequence do
+              plan_action(Actions::Pulp3::AlternateContentSource::CreateRemote, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::Create, acs, smart_proxy)
+              # TODO: Should the hrefs be committed to acs records in a new action? Is it okay to be in the service class methods?
+              #  -> i.e. do we need something like SaveVersions?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/delete.rb

@@ -0,0 +1,23 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module AlternateContentSource
+        class Delete < Pulp3::Abstract
+          def plan(acs, smart_proxy)
+            sequence do
+              plan_action(Actions::Pulp3::AlternateContentSource::Delete, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::DeleteRemote, acs, smart_proxy)
+              plan_self(acs_id: acs.id, smart_proxy_id: smart_proxy.id)
+            end
+          end
+
+          def finalize
+            acs_id = input[:acs_id]
+            smart_proxy_id = input[:smart_proxy_id]
+            ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs_id, smart_proxy_id: smart_proxy_id).destroy
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/update.rb

@@ -0,0 +1,18 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module AlternateContentSource
+        class Update < Pulp3::Abstract
+          def plan(acs, smart_proxy)
+            sequence do
+              plan_action(Actions::Pulp3::AlternateContentSource::UpdateRemote, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::Update, acs, smart_proxy)
+              # TODO: Should the hrefs be committed to acs records in a new action? Is it okay to be in the service class methods?
+              #  -> i.e. do we need something like SaveVersions?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/content_view_version/copy_version_units_to_library.rb

@@ -10,7 +10,7 @@ module Actions
                   plan_action(Actions::Pulp3::Repository::CopyContent, repo, SmartProxy.pulp_primary!,
                                                     repo.library_instance,
                                                     copy_all: true,
-                                                    mirror: content_view_version.content_view.library_import?)
+                                                    mirror: content_view_version.content_view.generated?)
                   plan_action(Actions::Pulp3::Repository::SaveVersion, repo.library_instance)
                   plan_action(Katello::Repository::IndexContent, id: repo.library_instance_id)
                   plan_action(Katello::Repository::MetadataGenerate, repo.library_instance, :force => true)

data/app/lib/actions/pulp3/orchestration/content_view_version/export_repository.rb

@@ -0,0 +1,51 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module ContentViewVersion
+        class ExportRepository < Actions::EntryAction
+          def plan(repository,
+                    chunk_size: nil,
+                    from_history: nil)
+            action_subject(repository)
+            validate_repositories_immediate!(repository)
+
+            content_view = ::Katello::Pulp3::ContentViewVersion::Export.find_repository_export_view(
+                                                                           repository: repository,
+                                                                           create_by_default: true)
+            content_view.update!(repository_ids: [repository.library_instance_or_self.id])
+
+            sequence do
+              publish_action = plan_action(::Actions::Katello::ContentView::Publish, content_view, '')
+              export_action = plan_action(Actions::Katello::ContentViewVersion::Export,
+                                          content_view_version: publish_action.version,
+                                          chunk_size: chunk_size,
+                                          from_history: from_history)
+              plan_self(export_action_output: export_action.output)
+            end
+          end
+
+          def run
+            output[:export_history_id] = input[:export_action_output][:export_history_id]
+          end
+
+          def humanized_name
+            _("Export Repository")
+          end
+
+          def rescue_strategy
+            Dynflow::Action::Rescue::Skip
+          end
+
+          def validate_repositories_immediate!(repository)
+            unless repository.immediate?
+              fail _("NOTE: Unable to fully export repository '%{repository}' because"\
+                     " it does not have the 'immediate' download policy."\
+                     " Update the download policy and sync the affected repository to include them in the export."\
+                       % { repository: repository.name })
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/content_view_version/import.rb

@@ -16,8 +16,8 @@ module Actions
               ).output
 
               plan_action(
-                ::Actions::Pulp3::ContentViewVersion::Import,
-                content_view_version_id: content_view_version.id,
+                ::Actions::Pulp3::ContentViewVersion::CreateImport,
+                organization_id: content_view_version.content_view.organization_id,
                 smart_proxy_id: smart_proxy.id,
                 importer_data: importer_output[:importer_data],
                 path: path,
@@ -36,7 +36,10 @@ module Actions
                 content_view_name: content_view_version.name
               )
               plan_action(::Actions::Pulp3::ContentViewVersion::DestroyImporter,
+                            organization_id: content_view_version.content_view.organization_id,
                             smart_proxy_id: smart_proxy.id,
+                            path: path,
+                            metadata: metadata,
                             importer_data: importer_output[:importer_data])
               plan_self(
                 content_view_name: content_view_version.name,

data/app/lib/actions/pulp3/repository/refresh_distribution.rb

@@ -3,6 +3,7 @@ module Actions
     module Repository
       class RefreshDistribution < Pulp3::AbstractAsyncTask
         include Helpers::Presenter
+        middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
         def plan(repository, smart_proxy, options = {})
           smart_proxy = SmartProxy.unscoped.find_by(id: smart_proxy) #support bulk actions
@@ -15,9 +16,11 @@ module Actions
               :repository_id => repository.id,
               :smart_proxy_id => smart_proxy.id
             }
+            refresh_options[:contents_changed] if options.key?(:contents_changed)
             action = plan_self(refresh_options)
 
-            plan_action(SaveDistributionReferences, repository, smart_proxy, action.output)
+            plan_action(SaveDistributionReferences, repository, smart_proxy,
+                        action.output, :contents_changed => options[:contents_changed])
           end
         end
 

data/app/lib/actions/pulp3/repository/save_distribution_references.rb

@@ -2,6 +2,8 @@ module Actions
   module Pulp3
     module Repository
       class SaveDistributionReferences < Pulp3::Abstract
+        middleware.use Actions::Middleware::ExecuteIfContentsChanged
+
         def plan(repository, smart_proxy, tasks, options = {})
           plan_self(repository_id: repository.id, smart_proxy_id: smart_proxy.id, tasks: tasks, contents_changed: options[:contents_changed])
         end

data/app/lib/katello/api/v2/error_handling.rb

@@ -23,6 +23,7 @@ module Katello
           rescue_from Errors::CdnSubstitutionError, :with => :rescue_from_bad_data
           rescue_from Errors::RegistrationError, :with => :rescue_from_bad_data
           rescue_from ActionController::ParameterMissing, :with => :rescue_from_missing_param
+          rescue_from ::ForemanTasks::Lock::LockConflict, :with => :rescue_from_bad_data
         end
 
         protected

data/app/lib/katello/resources/cdn/katello_cdn.rb

@@ -118,7 +118,9 @@ module Katello
 
         def find_organization(label)
           response = get("/api/v2/organizations?search=#{CGI.escape("label = #{label}")}")
-          JSON.parse(response)['results'].first
+          JSON.parse(response)['results'].first.tap do |org|
+            fail "Specified organization was not found: #{label}" if org.nil?
+          end
         rescue => e
           Rails.logger.error("Couldn't load upstream organization with label=#{label} error=#{e.message}")
           raise e

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

@@ -56,10 +56,9 @@ module Katello
         matching_errata = []
         errata.each do |erratum|
           # The erratum should be copied if package_pulp_hrefs has all of its packages that are available in the source repo.
-          next if erratum.packages.empty?
           rpms_in_erratum_and_source_repo = erratum.packages.pluck(:filename) & source_repo_rpm_filenames
-          next if rpms_in_erratum_and_source_repo.empty?
-          if (rpms_in_erratum_and_source_repo - rpm_filenames - srpm_filenames).empty?
+          if (rpms_in_erratum_and_source_repo - rpm_filenames - srpm_filenames).empty? ||
+              erratum.packages.empty? || rpms_in_erratum_and_source_repo.empty?
             matching_errata << erratum
           end
         end

data/app/lib/katello/validators/alternate_content_source_path_validator.rb

@@ -0,0 +1,29 @@
+module Katello
+  module Validators
+    class AlternateContentSourcePathValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if value
+          if attribute == :base_url
+            unless AlternateContentSourcePathValidator.validate_base_url(value)
+              record.errors[attribute] << N_("%s is not a valid path") % value
+            end
+          elsif attribute == :subpaths
+            unless AlternateContentSourcePathValidator.validate_subpaths(value)
+              record.errors[attribute] << N_('All subpaths must have a slash at the end and none at the front')
+            end
+          end
+        end
+      end
+
+      def self.validate_base_url(base_url)
+        base_url =~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
+      end
+
+      # Subpaths must have a slash at the end and none at the front: 'path/'
+      def self.validate_subpaths(subpaths)
+        bad_subpaths = subpaths.select { |subpath| subpath[0] == '/' || subpath[-1] != '/' }
+        bad_subpaths.empty?
+      end
+    end
+  end
+end

data/app/lib/katello/validators/content_default_http_proxy_setting_validator.rb

@@ -0,0 +1,12 @@
+module Katello
+  module Validators
+    class ContentDefaultHttpProxySettingValidator < ActiveModel::Validator
+      def validate(record)
+        proxy = HttpProxy.where(name: record.value).first
+        return if proxy || record.value.blank?
+
+        record.errors.add(:base, _('There is no such HTTP proxy'))
+      end
+    end
+  end
+end

data/app/lib/katello/validators/content_view_environment_validator.rb

@@ -5,12 +5,17 @@ module Katello
         #support lifecycle_environment_id for foreman models
         environment_id = record.respond_to?(:lifecycle_environment_id) ? record.lifecycle_environment_id : record.environment_id
 
-        if record.content_view_id && environment_id
+        if record.content_view_id
           view = ContentView.where(:id => record.content_view_id).first
-          env = KTEnvironment.where(:id => environment_id).first
-          unless view.blank? || env.blank? || view.in_environment?(env)
-            record.errors[:base] << _("Content view '%{view}' is not in environment '%{env}'") %
-                                      {:view => view.name, :env => env.name}
+          if environment_id
+            env = KTEnvironment.where(:id => environment_id).first
+            unless view.blank? || env.blank? || view.in_environment?(env)
+              record.errors[:base] << _("Content view '%{view}' is not in environment '%{env}'") %
+                                        {:view => view.name, :env => env.name}
+            end
+          end
+          if view&.generated_for_repository?
+            record.errors[:base] << _("Generated Content views cannot be assigned to Host/Activation Keys")
           end
         end
       end

data/app/models/katello/alternate_content_source.rb

@@ -0,0 +1,66 @@
+module Katello
+  class AlternateContentSource < Katello::Model
+    include Ext::LabelFromName
+    include Encryptable
+    include ::ScopedSearchExtensions
+    include Authorization::AlternateContentSource
+    include ForemanTasks::Concerns::ActionSubject
+
+    self.table_name = :katello_alternate_content_sources
+
+    # TODO: simplified, rhui
+    ACS_TYPES = %w(custom).freeze
+    CONTENT_TYPES = [::Katello::Repository::YUM_TYPE, ::Katello::Repository::FILE_TYPE].freeze
+
+    encrypts :upstream_password
+
+    belongs_to :ssl_ca_cert, inverse_of: :ssl_ca_alternate_content_sources, class_name: "Katello::ContentCredential"
+    belongs_to :ssl_client_cert, inverse_of: :ssl_client_alternate_content_sources, class_name: "Katello::ContentCredential"
+    belongs_to :ssl_client_key, inverse_of: :ssl_key_alternate_content_sources, class_name: "Katello::ContentCredential"
+    belongs_to :http_proxy, inverse_of: :alternate_content_sources
+    has_many :smart_proxy_alternate_content_sources, dependent: :destroy,
+             inverse_of: :alternate_content_source
+    has_many :smart_proxies, through: :smart_proxy_alternate_content_sources
+
+    validates :base_url, if: :custom?, presence: true
+    validates :verify_ssl, if: :custom?, exclusion: [nil]
+    validates :alternate_content_source_type, inclusion: {
+      in: ->(_) { ACS_TYPES },
+      allow_blank: false,
+      message: ->(_, _) { _("is not a valid type. Must be one of the following: %s") % ACS_TYPES.join(',') }
+    }
+    validates :content_type, if: :custom?, inclusion: {
+      in: ->(_) { RepositoryTypeManager.defined_repository_types.keys & CONTENT_TYPES },
+      allow_blank: false,
+      message: ->(_, _) { _("is not allowed for ACS. Must be one of the following: %s") % (RepositoryTypeManager.defined_repository_types.keys & CONTENT_TYPES).join(',') }
+    }
+    validates_with Validators::AlternateContentSourcePathValidator, :attributes => [:base_url, :subpaths], :if => :custom?
+
+    scoped_search on: :name, complete_value: true
+    scoped_search on: :label, complete_value: true
+    scoped_search on: :description, complete_value: true
+    scoped_search on: :base_url, complete_value: true
+    scoped_search on: :subpath, ext_method: :search_by_subpath
+    scoped_search on: :content_type, complete_value: true
+    scoped_search on: :alternate_content_source_type, complete_value: true
+    scoped_search on: :upstream_username, complete_value: true
+    scoped_search on: :smart_proxy_id, relation: :smart_proxy_alternate_content_sources, validator: ScopedSearch::Validators::INTEGER, only_explicit: true
+
+    def backend_service(smart_proxy)
+      @service ||= ::Katello::Pulp3::AlternateContentSource.new(self, smart_proxy)
+    end
+
+    def custom?
+      alternate_content_source_type == 'custom'
+    end
+
+    def self.with_type(content_type)
+      where(content_type: content_type)
+    end
+
+    def self.search_by_subpath(_key, operator, value)
+      conditions = sanitize_sql_for_conditions(["? #{operator} ANY (subpaths)", value_to_sql(operator, value)])
+      { conditions: conditions }
+    end
+  end
+end