katello 4.5.0 → 4.6.0.rc1

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

@@ -2,14 +2,14 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class UpdateRemote < Pulp3::AbstractAsyncTask
-        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)
+        def plan(smart_proxy_acs)
+          smart_proxy_acs.backend_service.create_test_remote
+          plan_self(smart_proxy_acs_id: smart_proxy_acs.id, smart_proxy_id: smart_proxy_acs.smart_proxy_id)
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).update_remote
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.update_remote
         end
       end
     end

data/app/lib/actions/pulp3/capsule_content/reclaim_space.rb

@@ -12,6 +12,7 @@ module Actions
             end
             repository_hrefs = ::Katello::Pulp3::Api::Core.new(smart_proxy).core_repositories_list_all(fields: 'pulp_href').map(&:pulp_href)
           end
+          fail _('There is no downloaded content to clean.') if repository_hrefs.empty?
           plan_self(repository_hrefs: repository_hrefs, smart_proxy_id: smart_proxy.id)
         end
 

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

@@ -27,9 +27,10 @@ module Actions
           cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
           from_cvv = ::Katello::ContentViewVersion.find(input[:from_content_view_version_id]) unless input[:from_content_view_version_id].blank?
 
-          export_metadata = ::Katello::Pulp3::ContentViewVersion::Export.new(
+          export_metadata = ::Katello::Pulp3::ContentViewVersion::Export.create(
                                                      content_view_version: cvv,
                                                      smart_proxy: smart_proxy,
+                                                     format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE,
                                                      from_content_view_version: from_cvv).generate_metadata
 
           toc_path_info = output[:exported_file_checksum].find { |item| item.first.end_with?("toc.json") }
@@ -46,6 +47,7 @@ module Actions
                                                                                              metadata: export_metadata)
           )
           output[:export_history_id] = history.id
+          output[:format] = ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
         end
 
         def humanized_name

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

@@ -6,13 +6,20 @@ module Actions
           param :smart_proxy_id, Integer
           param :content_view_version_id, Integer
           param :destination_server, String
+          param :format, String
+          param :base_path, String
+          param :repository_id, Integer
         end
 
         def run
           cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
-          output[:exporter_data] = ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy,
+          repository = ::Katello::Repository.find(input[:repository_id]) unless input[:repository_id].blank?
+          output[:exporter_data] = ::Katello::Pulp3::ContentViewVersion::Export.create(smart_proxy: smart_proxy,
                                                                             content_view_version: cvv,
-                                                                            destination_server: input[:destination_server]).create_exporter
+                                                                            destination_server: input[:destination_server],
+                                                                            format: input[:format],
+                                                                            base_path: input[:base_path],
+                                                                            repository: repository).create_exporter
         end
       end
     end

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

@@ -0,0 +1,45 @@
+module Actions
+  module Pulp3
+    module ContentViewVersion
+      class CreateSyncableExportHistory < Actions::EntryAction
+        input_format do
+          param :smart_proxy_id, Integer
+          param :base_path, String
+          param :content_view_version_id, Integer
+          param :destination_server, String
+        end
+
+        output_format do
+          param :export_history_id, Integer
+          param :path, String
+        end
+
+        def run
+          smart_proxy = ::SmartProxy.unscoped.find(input[:smart_proxy_id])
+          output[:path] = input[:base_path]
+          cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          export_metadata = ::Katello::Pulp3::ContentViewVersion::Export.create(
+                                                     content_view_version: cvv,
+                                                     smart_proxy: smart_proxy,
+                                                     format: input[:format]).generate_metadata
+
+          history = ::Katello::ContentViewVersionExportHistory.create!(
+            content_view_version_id: input[:content_view_version_id],
+            destination_server: input[:destination_server],
+            path: input[:base_path],
+            metadata: export_metadata,
+            audit_comment: ::Katello::ContentViewVersionExportHistory.generate_audit_comment(content_view_version: cvv,
+                                                                                             user: User.current,
+                                                                                             metadata: export_metadata)
+          )
+          output[:export_history_id] = history.id
+          output[:format] = ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
+        end
+
+        def humanized_name
+          _("Create Syncable Export History")
+        end
+      end
+    end
+  end
+end

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

@@ -5,10 +5,15 @@ module Actions
         input_format do
           param :smart_proxy_id, Integer
           param :exporter_data, Hash
+          param :format, String
+          param :repository_id, Integer
         end
 
         def invoke_external_task
-          ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy).destroy_exporter(input[:exporter_data][:pulp_href])
+          repository = ::Katello::Repository.find(input[:repository_id]) unless input[:repository_id].blank?
+          ::Katello::Pulp3::ContentViewVersion::Export.create(smart_proxy: smart_proxy,
+                                                              format: input[:format],
+                                                              repository: repository).destroy_exporter(input[:exporter_data])
         end
       end
     end

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

@@ -7,16 +7,21 @@ module Actions
           param :from_content_view_version_id, Integer
           param :smart_proxy_id, Integer
           param :exporter_data, Hash
+          param :format, String
           param :chunk_size, Integer
+          param :repository_id, Integer
         end
 
         def invoke_external_task
+          repository = ::Katello::Repository.find(input[:repository_id]) unless input[:repository_id].blank?
           cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
           from_cvv = ::Katello::ContentViewVersion.find(input[:from_content_view_version_id]) unless input[:from_content_view_version_id].blank?
-          ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy,
+          ::Katello::Pulp3::ContentViewVersion::Export.create(smart_proxy: smart_proxy,
                                                    content_view_version: cvv,
-                                                   from_content_view_version: from_cvv)
-                                                   .create_export(input[:exporter_data][:pulp_href],
+                                                   from_content_view_version: from_cvv,
+                                                   format: input[:format],
+                                                   repository: repository)
+                                                   .create_export(input[:exporter_data],
                                                                         chunk_size: input[:chunk_size])
         end
       end

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

@@ -3,10 +3,10 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Create < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs)
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::CreateRemote, acs, smart_proxy)
-              plan_action(Actions::Pulp3::AlternateContentSource::Create, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::CreateRemote, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::Create, smart_proxy_acs)
             end
           end
         end

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

@@ -3,18 +3,17 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Delete < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs, options = {})
             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)
+              plan_action(Actions::Pulp3::AlternateContentSource::Delete, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::DeleteRemote, smart_proxy_acs, options)
+              plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.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
+            smart_proxy_acs_id = input[:smart_proxy_acs_id]
+            ::Katello::SmartProxyAlternateContentSource.find_by(id: smart_proxy_acs_id).destroy
           end
         end
       end

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

@@ -3,9 +3,9 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Refresh < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs)
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::Refresh, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::Refresh, smart_proxy_acs)
             end
           end
         end

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

@@ -0,0 +1,18 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module AlternateContentSource
+        class RefreshRemote < Pulp3::AbstractAsyncTask
+          def plan(smart_proxy_acs)
+            plan_self(smart_proxy_acs_id: smart_proxy_acs.id, smart_proxy_id: smart_proxy_acs.smart_proxy_id)
+          end
+
+          def invoke_external_task
+            smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+            smart_proxy_acs.backend_service.update_remote
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,10 +3,10 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Update < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs)
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::UpdateRemote, acs, smart_proxy)
-              plan_action(Actions::Pulp3::AlternateContentSource::Update, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::UpdateRemote, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::Update, smart_proxy_acs)
             end
           end
         end

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

@@ -10,6 +10,7 @@ module Actions
             param :export_history_id, Integer
             param :exporter_data, Hash
             param :destination_server, String
+            param :format, String
           end
 
           output_format do
@@ -19,16 +20,30 @@ module Actions
           def plan(content_view_version:, destination_server: nil,
                    chunk_size: nil, from_history: nil,
                    validate_incremental: true,
-                   fail_on_missing_content: false)
+                   fail_on_missing_content: false,
+                   format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
+            smart_proxy = SmartProxy.pulp_primary!
+
+            if format == ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
+              sequence do
+                export_output = plan_action(SyncableExport,
+                          content_view_version: content_view_version,
+                          smart_proxy: smart_proxy,
+                          destination_server: destination_server).output
+                plan_self(export_history_id: export_output[:export_history_id],
+                          export_path: export_output[:export_path])
+              end
+              return
+            end
 
             sequence do
-              smart_proxy = SmartProxy.pulp_primary!
               from_content_view_version = from_history&.content_view_version
-              export_service = ::Katello::Pulp3::ContentViewVersion::Export.new(
+              export_service = ::Katello::Pulp3::ContentViewVersion::Export.create(
                   smart_proxy: smart_proxy,
                   content_view_version: content_view_version,
                   destination_server: destination_server,
-                  from_content_view_version: from_content_view_version)
+                  from_content_view_version: from_content_view_version,
+                  format: format)
               export_service.validate!(fail_on_missing_content: fail_on_missing_content,
                                        validate_incremental: validate_incremental,
                                        chunk_size: chunk_size)
@@ -36,14 +51,16 @@ module Actions
               action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
                                           content_view_version_id: content_view_version.id,
                                           smart_proxy_id: smart_proxy.id,
-                                          destination_server: destination_server).output
+                                          destination_server: destination_server,
+                                          format: format).output
 
               plan_action(::Actions::Pulp3::ContentViewVersion::Export,
                           content_view_version_id: content_view_version.id,
                           smart_proxy_id: smart_proxy.id,
                           exporter_data: action_output[:exporter_data],
                           chunk_size: chunk_size,
-                          from_content_view_version_id: from_content_view_version&.id)
+                          from_content_view_version_id: from_content_view_version&.id,
+                          format: format)
 
               history_output = plan_action(
                   ::Actions::Pulp3::ContentViewVersion::CreateExportHistory,
@@ -52,18 +69,16 @@ module Actions
                   pulp_href: action_output[:exporter_data][:pulp_href],
                   content_view_version_id: content_view_version.id,
                   from_content_view_version_id: from_content_view_version&.id,
-                  destination_server: destination_server
+                  destination_server: destination_server,
+                  format: format
               ).output
 
               plan_action(::Actions::Pulp3::ContentViewVersion::DestroyExporter,
                           smart_proxy_id: smart_proxy.id,
-                          exporter_data: action_output[:exporter_data])
+                          exporter_data: action_output[:exporter_data],
+                          format: format)
 
-              plan_self(exporter_data: action_output[:exporter_data], smart_proxy_id: smart_proxy.id,
-                        destination_server: destination_server,
-                        content_view_version_id: content_view_version.id,
-                        from_content_view_version_id: from_content_view_version&.id,
-                        export_history_id: history_output[:export_history_id],
+              plan_self(export_history_id: history_output[:export_history_id],
                         exported_file_checksum: history_output[:exported_file_checksum],
                         export_path: history_output[:path])
             end

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

@@ -6,7 +6,8 @@ module Actions
           def plan(organization, destination_server: nil,
                                  chunk_size: nil,
                                  from_history: nil,
-                                 fail_on_missing_content: false)
+                                 fail_on_missing_content: false,
+                                 format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
             action_subject(organization)
             validate_repositories_immediate!(organization) if fail_on_missing_content
 
@@ -24,7 +25,8 @@ module Actions
                                           chunk_size: chunk_size,
                                           from_history: from_history,
                                           validate_incremental: false,
-                                          fail_on_missing_content: fail_on_missing_content)
+                                          fail_on_missing_content: fail_on_missing_content,
+                                          format: format)
               plan_self(export_action_output: export_action.output)
             end
           end

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

@@ -5,7 +5,8 @@ module Actions
         class ExportRepository < Actions::EntryAction
           def plan(repository,
                     chunk_size: nil,
-                    from_history: nil)
+                    from_history: nil,
+                    format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE)
             action_subject(repository)
             validate_repositories_immediate!(repository)
 
@@ -19,7 +20,8 @@ module Actions
               export_action = plan_action(Actions::Katello::ContentViewVersion::Export,
                                           content_view_version: publish_action.version,
                                           chunk_size: chunk_size,
-                                          from_history: from_history)
+                                          from_history: from_history,
+                                          format: format)
               plan_self(export_action_output: export_action.output)
             end
           end

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

@@ -0,0 +1,82 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module ContentViewVersion
+        class SyncableExport < Actions::EntryAction
+          input_format do
+            param :smart_proxy_id, Integer
+            param :content_view_version_id, Integer
+            param :export_history_id, Integer
+            param :export_path, String
+          end
+
+          output_format do
+            param :export_path, String
+            param :export_history_id, Integer
+          end
+
+          def plan(content_view_version:,
+                   smart_proxy:,
+                   fail_on_missing_content: false,
+                   destination_server:)
+            format = ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE
+            sequence do
+              export_service = ::Katello::Pulp3::ContentViewVersion::Export.create(
+                  smart_proxy: smart_proxy,
+                  content_view_version: content_view_version,
+                  format: format,
+                  destination_server: destination_server)
+              export_service.validate!(fail_on_missing_content: fail_on_missing_content)
+              base_path = export_service.generate_exporter_path
+              export_service.repositories.each do |repository|
+                action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
+                                            content_view_version_id: content_view_version.id,
+                                            smart_proxy_id: smart_proxy.id,
+                                            format: format,
+                                            base_path: base_path,
+                                            repository_id: repository.id,
+                                            destination_server: destination_server).output
+
+                plan_action(::Actions::Pulp3::ContentViewVersion::Export,
+                            content_view_version_id: content_view_version.id,
+                            smart_proxy_id: smart_proxy.id,
+                            exporter_data: action_output[:exporter_data],
+                            format: format,
+                            repository_id: repository.id)
+
+                plan_action(::Actions::Pulp3::ContentViewVersion::DestroyExporter,
+                          smart_proxy_id: smart_proxy.id,
+                          exporter_data: action_output[:exporter_data],
+                          format: format,
+                          repository_id: repository.id)
+              end
+
+              history_output = plan_action(
+                  ::Actions::Pulp3::ContentViewVersion::CreateSyncableExportHistory,
+                  smart_proxy_id: smart_proxy.id,
+                  content_view_version_id: content_view_version.id,
+                  destination_server: destination_server,
+                  format: format,
+                  base_path: base_path
+              ).output
+
+              plan_self(export_history_id: history_output[:export_history_id],
+                        export_path: base_path)
+            end
+          end
+
+          def run
+            output.update(
+                export_history_id: input[:export_history_id],
+                export_path: input[:export_path]
+            )
+          end
+
+          def rescue_strategy
+            Dynflow::Action::Rescue::Skip
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/repository/generate_metadata.rb

@@ -16,7 +16,7 @@ module Actions
                 plan_action(Actions::Pulp3::Repository::CreatePublication, repository, smart_proxy, options)
               end
               plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
-              plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if repository.environment
+              plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if Setting[:distribute_archived_cvv] || repository.environment
             end
           end
 

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -161,7 +161,7 @@ module Katello
         returns String, desc: 'Package version'
       end
       def host_latest_applicable_rpm_version(host, package)
-        host.applicable_rpms.where(name: package).order(:version_sortable).limit(1).pluck(:nvra).first
+        ::Katello::Rpm.latest(host.applicable_rpms.where(name: package)).first.nvra
       end
 
       apipie :method, 'Loads Pool objects' do

data/app/lib/katello/errors.rb

@@ -154,7 +154,7 @@ module Katello
 
     class NoManifestImported < StandardError
       def message
-        _("Current organization has no manifest imported.")
+        _("Current organization does not have a manifest imported.")
       end
     end
 

data/app/lib/katello/resources/candlepin/owner.rb

@@ -12,8 +12,14 @@ module Katello
 
           # Set the contentPrefix at creation time so that the client will get
           # content only for the org it has been subscribed to
-          def create(key, description)
-            attrs = {:key => key, :displayName => description, :contentPrefix => "/#{key}/$env"}
+          def create(key, description, content_access_mode: 'org_environment')
+            attrs = {
+              :key => key,
+              :displayName => description,
+              :contentPrefix => "/#{key}/$env",
+              :contentAccessMode => content_access_mode,
+              :contentAccessModeList => ['entitlement', 'org_environment'].join(',')
+            }
             owner_json = self.post(path, attrs.to_json, self.default_headers).body
             JSON.parse(owner_json).with_indifferent_access
           end
@@ -36,6 +42,7 @@ module Katello
           def update(key, attrs)
             owner = find(key)
             owner.merge!(attrs)
+            owner.merge!(:contentAccessModeList => ['entitlement', 'org_environment'].join(','))
             self.put(path(key), JSON.generate(owner), self.default_headers).body
           end
 

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

@@ -0,0 +1,17 @@
+module Katello
+  module Validators
+    class AlternateContentSourceProductsValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if value
+          if attribute == :product_id
+            product = ::Katello::Product.find(value)
+            content_type = record.alternate_content_source.content_type
+            if product.repositories.with_type(content_type).has_url.empty?
+              record.errors[attribute] << N_("The product %{name} has no %{type} repositories with upstream URLs to add to the alternate content source.") % { name: product.name, type: content_type }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katello/alternate_content_source.rb

@@ -1,5 +1,7 @@
 module Katello
   class AlternateContentSource < Katello::Model
+    audited
+
     include Ext::LabelFromName
     include Encryptable
     include ::ScopedSearchExtensions
@@ -8,9 +10,9 @@ module Katello
 
     self.table_name = :katello_alternate_content_sources
 
-    # TODO: simplified, rhui
-    ACS_TYPES = %w(custom).freeze
+    ACS_TYPES = %w(custom simplified).freeze
     CONTENT_TYPES = [::Katello::Repository::YUM_TYPE, ::Katello::Repository::FILE_TYPE].freeze
+    AUDIT_REFRESH_ACTION = 'refresh'.freeze
 
     encrypts :upstream_password
 
@@ -18,18 +20,27 @@ module Katello
     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,
+
+    has_many :alternate_content_source_products, dependent: :delete_all, inverse_of: :alternate_content_source,
+             class_name: "Katello::AlternateContentSourceProduct"
+    has_many :products, through: :alternate_content_source_products, inverse_of: :alternate_content_sources,
+             class_name: "Katello::Product"
+
+    has_many :smart_proxy_alternate_content_sources, dependent: :delete_all,
              inverse_of: :alternate_content_source
-    has_many :smart_proxies, through: :smart_proxy_alternate_content_sources
+    has_many :smart_proxies, -> { distinct }, through: :smart_proxy_alternate_content_sources
 
+    validates :base_url, :subpaths, :verify_ssl, :upstream_username,
+              :upstream_password, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key, if: :simplified?, absence: true
     validates :base_url, if: :custom?, presence: true
+    validates :products, if: :custom?, absence: 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: {
+    validates :content_type, 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(',') }
@@ -44,16 +55,28 @@ module Katello
     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
+    scoped_search on: :id, relation: :smart_proxies, rename: :smart_proxy_id, validator: ScopedSearch::Validators::INTEGER, only_explicit: true
+    scoped_search on: :name, relation: :smart_proxies, rename: :smart_proxy_name, complete_value: true
+    scoped_search on: :id, relation: :products, rename: :product_id, validator: ScopedSearch::Validators::INTEGER, only_explicit: true
+    scoped_search on: :name, relation: :products, rename: :product_name, complete_value: true
 
-    def backend_service(smart_proxy)
-      @service ||= ::Katello::Pulp3::AlternateContentSource.new(self, smart_proxy)
+    def backend_service(smart_proxy, repository = nil)
+      @service ||= ::Katello::Pulp3::AlternateContentSource.new(self, smart_proxy, repository)
     end
 
     def custom?
       alternate_content_source_type == 'custom'
     end
 
+    def simplified?
+      alternate_content_source_type == 'simplified'
+    end
+
+    def self.with_products(products)
+      products = [products] unless products.is_a?(Array)
+      joins(:alternate_content_source_products).where('katello_alternate_content_source_products.product_id in (:product_ids)', product_ids: products.pluck(:id))
+    end
+
     def self.with_type(content_type)
       where(content_type: content_type)
     end
@@ -67,5 +90,13 @@ module Katello
       @latest_dynflow_refresh_task ||= ForemanTasks::Task::DynflowTask.where(:label => Actions::Katello::AlternateContentSource::Refresh.name).
           for_resource(self).order(:started_at).last
     end
+
+    def audit_refresh
+      write_audit(action: AUDIT_REFRESH_ACTION, comment: _('Successfully refreshed.'), audited_changes: {})
+    end
+
+    def audit_updated_products(old_product_ids)
+      write_audit(action: 'update', comment: _('Products updated.'), audited_changes: { 'product_ids' => [old_product_ids, product_ids] })
+    end
   end
 end

data/app/models/katello/alternate_content_source_product.rb

@@ -0,0 +1,13 @@
+module Katello
+  class AlternateContentSourceProduct < Katello::Model
+    audited
+    # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
+    self.table_name = :katello_alternate_content_source_products
+    belongs_to :alternate_content_source, inverse_of: :alternate_content_source_products, class_name: 'Katello::AlternateContentSource'
+    belongs_to :product, inverse_of: :alternate_content_source_products, class_name: 'Katello::Product'
+    delegate :custom?, to: :alternate_content_source
+    delegate :simplified?, to: :alternate_content_source
+
+    validates_with Validators::AlternateContentSourceProductsValidator, :attributes => [:product_id], if: :simplified?
+  end
+end