katello 4.8.4 → 4.9.0.rc1

data/app/controllers/katello/api/v2/content_view_versions_controller.rb

@@ -20,6 +20,7 @@ module Katello
     param :version, String, :desc => N_("Filter versions by version number"), :required => false
     param :composite_version_id, :number, :desc => N_("Filter versions that are components in the specified composite version"), :required => false
     param :organization_id, :number, :desc => N_("Organization identifier")
+    param :include_applied_filters, :bool, :desc => N_("Whether or not to return filters applied to the content view version"), :required => false
     param :triggered_by_id, :number, :desc => N_("Filter composite versions whose publish was triggered by the specified component version"), :required => false
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(ContentViewVersion)
@@ -44,6 +45,7 @@ module Katello
 
     api :GET, "/content_view_versions/:id", N_("Show content view version")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
+    param :include_applied_filters, :bool, :desc => N_("Whether or not to return filters applied to the content view version"), :required => false
     def show
       respond :resource => @content_view_version
     end

data/app/controllers/katello/api/v2/content_views_controller.rb

@@ -109,23 +109,14 @@ module Katello
     param :major, :number, :desc => N_("Override the major version number"), :required => false
     param :minor, :number, :desc => N_("Override the minor version number"), :required => false
     param :environment_ids, Array, :desc => N_("Identifiers for Lifecycle Environment"), :required => false
-    param :is_force_promote, :bool, :desc => N_("force content view promotion and bypass lifecycle environment restriction"), :required => false
+    param :publish_only_if_needed, :bool, :desc => N_("Check audited changes and proceed only if content or filters have changed since last publish"), :required => false
+    param :is_force_promote, :bool, :desc => N_("Force content view promotion and bypass lifecycle environment restriction"), :required => false
     param :repos_units, Array, :desc => N_("Specify the list of units in each repo"), :required => false do
       param :label, String, :desc => N_("repo label"), :required => true
       param :rpm_filenames, Array, of: String, :desc => N_("list of rpm filename strings to include in published version"), :required => true
     end
     def publish
-      if params[:repos_units].present? && @content_view.composite?
-        fail HttpErrors::BadRequest, _("Directly setting package lists on composite content views is not allowed. Please " \
-                                     "update the components, then re-publish the composite.")
-      end
-      if params[:major].present? && params[:minor].present? && ContentViewVersion.find_by(:content_view_id => params[:id], :major => params[:major], :minor => params[:minor]).present?
-        fail HttpErrors::BadRequest, _("A CV version already exists with the same major and minor version (%{major}.%{minor})") % {:major => params[:major], :minor => params[:minor]}
-      end
-
-      if params[:major].present? && params[:minor].nil? || params[:major].nil? && params[:minor].present?
-        fail HttpErrors::BadRequest, _("Both major and minor parameters have to be used to override a CV version")
-      end
+      validate_publish_params!
 
       task = async_task(::Actions::Katello::ContentView::Publish, @content_view, params[:description],
                         :environment_ids => params[:environment_ids],
@@ -254,6 +245,25 @@ module Katello
 
     private
 
+    def validate_publish_params!
+      if params[:repos_units].present? && @content_view.composite?
+        fail HttpErrors::BadRequest, _("Directly setting package lists on composite content views is not allowed. Please " \
+                                     "update the components, then re-publish the composite.")
+      end
+      if params[:major].present? && params[:minor].present? && ContentViewVersion.find_by(:content_view_id => params[:id], :major => params[:major], :minor => params[:minor]).present?
+        fail HttpErrors::BadRequest, _("A CV version already exists with the same major and minor version (%{major}.%{minor})") % {:major => params[:major], :minor => params[:minor]}
+      end
+
+      if params[:major].present? && params[:minor].nil? || params[:major].nil? && params[:minor].present?
+        fail HttpErrors::BadRequest, _("Both major and minor parameters have to be used to override a CV version")
+      end
+
+      if (::Foreman::Cast.to_bool(params[:publish_only_if_needed]) && !@content_view.needs_publish?)
+        fail HttpErrors::BadRequest, _("Content view does not need a publish since there are no audited changes since the last publish." \
+                                     " Pass check_needs_publish parameter as false if you don't want to check if content view needs a publish.")
+      end
+    end
+
     def  ensure_non_default
       if @content_view.default? && !%w(show history).include?(params[:action])
         fail HttpErrors::BadRequest, _("The default content view cannot be edited, published, or deleted.")

data/app/controllers/katello/api/v2/environments_controller.rb

@@ -132,6 +132,7 @@ module Katello
 
     api :GET, "/organizations/:organization_id/environments/paths", N_("List environment paths")
     param :organization_id, :number, :desc => N_("organization identifier")
+    param :content_source_id, :number, :desc => N_("Show whether each lifecycle environment is associated with the given Smart Proxy id.")
     param :permission_type, String, :desc => <<-DESC
       The associated permission type. One of (readable | promotable)
       Default: readable
@@ -142,7 +143,10 @@ module Katello
                   else
                     @organization.readable_promotion_paths
                   end
-
+      if params[:content_source_id]
+        @content_source_id = params[:content_source_id].to_i
+        @content_source = SmartProxy.authorized(:view_smart_proxies).find(@content_source_id)
+      end
       paths = env_paths.inject([]) do |result, path|
         result << { :environments => [@organization.library] + path.select(&:readable?) }
       end

data/app/controllers/katello/api/v2/host_subscriptions_controller.rb

@@ -81,7 +81,7 @@ module Katello
     def create
       rhsm_params = params_to_rhsm_params
 
-      host = Katello::RegistrationManager.process_registration(rhsm_params, [@content_view_environment])
+      host = Katello::RegistrationManager.process_registration(rhsm_params, @content_view_environment)
       host.reload
       ::Katello::Host::SubscriptionFacet.update_facts(host, rhsm_params[:facts]) unless rhsm_params[:facts].blank?
 

data/app/controllers/katello/api/v2/hosts_bulk_actions_controller.rb

@@ -326,12 +326,11 @@ module Katello
 
       hosts.each do |host|
         next unless host.content_facet
+        host.content_facet.content_source = content_source
         host.content_facet.assign_single_environment(
           :content_view_id => content_view.id,
           :environment_id => lifecycle_environment.id
         )
-        host.content_facet.content_source = content_source
-
         host.update_candlepin_associations
       end
 

data/app/controllers/katello/api/v2/organizations_controller.rb

@@ -56,11 +56,22 @@ module Katello
     api :PUT, '/organizations/:id', N_('Update organization')
     param :id, :number, :desc => N_("organization ID"), :required => true
     param :redhat_repository_url, String, :desc => N_("Red Hat CDN URL"), deprecated: true
+    param :simple_content_access, :bool, :desc => N_('Whether Simple Content Access should be enabled for the organization.'), :required => false, :default => true
     param_group :resource
     def update
       if params[:redhat_repository_url]
         sync_task(::Actions::Katello::CdnConfiguration::Update, @organization.cdn_configuration, url: params[:redhat_repository_url])
       end
+      unless params[:simple_content_access].nil?
+        sca_param = ::Foreman::Cast.to_bool(params[:simple_content_access])
+        if sca_param && !@taxonomy.simple_content_access?(cached: false)
+          # user has requested SCA enable
+          sync_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:id])
+        elsif !sca_param && @taxonomy.simple_content_access?(cached: false)
+          # user has requested SCA disable
+          sync_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:id])
+        end
+      end
       super
     end
 

data/app/controllers/katello/api/v2/repositories_controller.rb

@@ -71,7 +71,7 @@ module Katello
       param :http_proxy_id, :number, :desc => N_("ID of a HTTP Proxy")
       param :arch, String, :desc => N_("Architecture of content in the repository")
       param :retain_package_versions_count, :number, :desc => N_("The maximum number of versions of each package to keep.")
-
+      param :metadata_expire, :number, :desc => N_("Time to expire yum metadata in seconds. Only relevant for custom yum repositories.")
       RepositoryTypeManager.generic_remote_options(defined_only: true).each do |option|
         param option.name, option.type, :desc => N_(option.description)
       end
@@ -580,7 +580,7 @@ module Katello
     # rubocop:disable Metrics/CyclomaticComplexity
     def repository_params
       keys = [:download_policy, :mirroring_policy, :sync_policy, :arch, :verify_ssl_on_sync, :upstream_password,
-              :upstream_username, :download_concurrency, :upstream_authentication_token,
+              :upstream_username, :download_concurrency, :upstream_authentication_token, :metadata_expire,
               {:os_versions => []}, :deb_releases, :deb_components, :deb_architectures, :description,
               :http_proxy_policy, :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
              ]
@@ -620,7 +620,8 @@ module Katello
     def construct_repo_from_params(repo_params) # rubocop:disable Metrics/AbcSize
       root = @product.add_repo(repo_params.slice(:label, :name, :description, :url, :content_type, :arch, :unprotected,
                                                             :gpg_key, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key,
-                                                            :checksum_type, :download_policy, :http_proxy_policy).to_h.with_indifferent_access)
+                                                            :checksum_type, :download_policy, :http_proxy_policy,
+                                                            :metadata_expire).to_h.with_indifferent_access)
       root.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
       if root.docker?
         if repo_params[:docker_tags_whitelist].present?

data/app/controllers/katello/api/v2/repository_sets_controller.rb

@@ -26,7 +26,7 @@ module Katello
     param :enabled, :bool, :required => false, :desc => N_("If true, only return repository sets that have been enabled. Defaults to false")
     param :with_active_subscription, :bool, :required => false, :desc => N_("If true, only return repository sets that are associated with an active subscriptions")
     param :organization_id, :number, :desc => N_("organization identifier"), :required => false
-    param :with_custom, :bool, :required => false, :desc => N_("If true, return custom repository sets along with redhat repos")
+    param :with_custom, :bool, :required => false, :desc => N_("If true, return custom repository sets along with redhat repos. Will be ignored if repository_type is supplied.")
     param :activation_key_id, :number, :desc => N_("activation key identifier"), :required => false
     param :host_id, :number, :desc => N_("Id of the host"), :required => false
     param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions.")
@@ -34,6 +34,7 @@ module Katello
     param :status, [:enabled, :disabled, :overridden],
                                   :desc => N_("Limit content to enabled / disabled / overridden"),
                                   :required => false
+    param :repository_type, [:redhat, :custom], :desc => N_("Limit content to Red Hat / custom"), :required => false
 
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Katello::ProductContent)
@@ -128,6 +129,9 @@ module Katello
       else
         relation = @product.displayable_product_contents
       end
+      if %w(custom redhat).include?(params[:repository_type])
+        relation = relation.send(params[:repository_type].to_sym)
+      end
 
       if ::Foreman::Cast.to_bool(params[:enabled])
         relation = relation.enabled(@organization)
@@ -139,7 +143,10 @@ module Katello
       end
 
       relation = relation.where(Katello::Content.table_name => {:name => params[:name]}) if params[:name].present?
-      relation = relation.redhat unless ::Foreman::Cast.to_bool(params[:with_custom])
+      # ignore with_custom if repository_type is specified
+      if params[:repository_type].blank?
+        relation = relation.redhat unless ::Foreman::Cast.to_bool(params[:with_custom])
+      end
       index_relation_with_consumable_overrides(relation)
     end
 
@@ -154,11 +161,13 @@ module Katello
           :match_environment => content_access_mode_env,
           :consumable => @consumable)
       unfiltered = relation.merge(content_finder.product_content)
-      return unfiltered unless params[:status]
+      return unfiltered unless params[:status] || params[:repository_type]
       filtered_ids = ProductContentFinder.wrap_with_overrides(
         product_contents: unfiltered,
         overrides: @consumable&.content_overrides,
-        status: params[:status]).map(&:id).uniq
+        status: params[:status],
+        repository_type: params[:repository_type]
+      ).map(&:id).uniq
       unfiltered.where(id: filtered_ids)
     end
 

data/app/controllers/katello/api/v2/simple_content_access_controller.rb

@@ -26,10 +26,8 @@ module Katello
     api :PUT, "/organizations/:organization_id/simple_content_access/enable",
       N_("Enable simple content access for a manifest")
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
-    param :auto_create_overrides, :bool, :desc => N_("Automatically create disabled content overrides for custom products which do not have an attached subscription"), :required => false, :default => true
     def enable
-      auto_create = params.key?(:auto_create_overrides) ? ::Foreman::Cast.to_bool(params[:auto_create_overrides]) : true
-      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id], auto_create_overrides: auto_create)
+      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id])
       respond_for_async :resource => task
     end
 

data/app/controllers/katello/concerns/api/api_controller.rb

@@ -19,11 +19,11 @@ module Katello
 
       class_methods do
         def katello_agent_deprecation_text
-          N_("NOTE: Katello-agent is deprecated and will be removed in %s. Consider using remote execution instead.") % katello_agent_removal_release
+          N_("WARNING: Katello-agent is deprecated and will be removed in %s. Migrate to remote execution now.") % katello_agent_removal_release
         end
 
         def katello_agent_removal_release
-          N_("a future release")
+          N_("Katello 4.10")
         end
       end
 

data/app/controllers/katello/concerns/content_facet_hosts_controller_extensions.rb

@@ -6,7 +6,7 @@ module Katello
         before_action :set_up_content_view_environment, only: [:update]
 
         def set_up_content_view_environment
-          return unless @host&.content_facet.present? && params[:host]&.[](:content_facet_attributes)&.present?
+          return unless params[:host] && params[:host][:content_facet_attributes]
           cv_id = params[:host][:content_facet_attributes].delete(:content_view_id)
           env_id = params[:host][:content_facet_attributes].delete(:lifecycle_environment_id)
           Rails.logger.info "set_up_content_view_environment: cv_id=#{cv_id}, env_id=#{env_id}"

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -57,14 +57,16 @@ module Katello
       end
     end
 
-    def fetch_lifecycle_environment(host, options = {})
-      return host.lifecycle_environment if host.try(:lifecycle_environment_id)
+    def fetch_lifecycle_environment(host_or_hostgroup, options = {})
+      return host_or_hostgroup.single_lifecycle_environment if host_or_hostgroup.try(:single_lifecycle_environment)
+      return host_or_hostgroup.lifecycle_environment if host_or_hostgroup.try(:lifecycle_environment)
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.lifecycle_environment if selected_host_group.present?
     end
 
-    def fetch_content_view(host, options = {})
-      return host.single_content_view if host.try(:single_content_view)
+    def fetch_content_view(host_or_hostgroup, options = {})
+      return host_or_hostgroup.single_content_view if host_or_hostgroup.try(:single_content_view)
+      return host_or_hostgroup.content_view if host_or_hostgroup.try(:content_view)
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.content_view if selected_host_group.present?
     end

data/app/lib/actions/candlepin/product/content_add.rb

@@ -2,6 +2,8 @@ module Actions
   module Candlepin
     module Product
       class ContentAdd < Candlepin::Abstract
+        DEFAULT_ENABLEMENT = false
+
         input_format do
           param :product_id
           param :content_id
@@ -10,7 +12,17 @@ module Actions
 
         def run
           output[:response] = ::Katello::Resources::Candlepin::Product.
-              add_content(input[:owner], input[:product_id], input[:content_id], true)
+              add_content(input[:owner], input[:product_id], input[:content_id], DEFAULT_ENABLEMENT)
+        end
+
+        def humanized_name
+          _("Add content")
+        end
+
+        # results in correct grammar on Tasks page,
+        # e.g. "Import manifest for organization Default Organization"
+        def humanized_input
+          "for Candlepin product #{input[:product_id]}"
         end
       end
     end

data/app/lib/actions/candlepin/product/content_update.rb

@@ -12,6 +12,7 @@ module Actions
           param :content_url
           param :gpg_key_url
           param :owner
+          param :metadata_expire
         end
 
         def run
@@ -25,7 +26,7 @@ module Actions
                      arches: input[:arches] || '',
                      requiredTags: input[:os_versions],
                      label: input[:label],
-                     metadataExpire: 1,
+                     metadataExpire: input[:metadata_expire] || 1,
                      vendor: ::Katello::Provider::CUSTOM)
         end
       end

data/app/lib/actions/katello/agent_action.rb

@@ -14,10 +14,8 @@ module Actions
 
       def plan(host, options)
         action_subject(host, :hostname => host.name, :content => options[:content])
-        # options[:dispatch_histories] keys might be strings or integers
-        dispatch_history_id = options.dig(:dispatch_histories, host.id.to_s) ||
-        options.dig(:dispatch_histories, host.id.to_i) ||
-          ::Katello::Agent::Dispatcher.create_histories(
+
+        dispatch_history_id = options.dig(:dispatch_histories, host.id.to_s) || ::Katello::Agent::Dispatcher.create_histories(
           host_ids: [host.id]
         ).first.id
 
@@ -46,6 +44,7 @@ module Actions
             history.dynflow_execution_plan_id = suspended_action.execution_plan_id
             history.dynflow_step_id = suspended_action.step_id
             history.save!
+
             dispatch_message(history) unless input[:bulk]
 
             schedule_timeout(timeout, optional: true)

data/app/lib/actions/katello/bulk_agent_action.rb

@@ -21,10 +21,7 @@ module Actions
 
       def spawn_plans
         args = input[:args].first
-        # args[:dispatch_histories] keys are numeric host ids; they may be integer or string
-        # Hash#slice will return a filtered hash only with the specified keys, and ignore keys that don't exist
-        possible_keys = [*current_batch.map(&:to_i), *current_batch.map(&:to_s)]
-        histories = ::Katello::Agent::DispatchHistory.where(id: args[:dispatch_histories].slice(*possible_keys).values)
+        histories = ::Katello::Agent::DispatchHistory.where(id: args[:dispatch_histories].slice(*current_batch.map(&:to_s)).values)
         ::Katello::Agent::Dispatcher.dispatch(
           args[:type].to_sym,
           histories,

data/app/lib/actions/katello/content_view/publish.rb

@@ -110,6 +110,7 @@ module Actions
         def finalize
           version = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
           version.update_content_counts!
+          version.add_applied_filters!
           # update errata applicability counts for all hosts in the CV & Library
           unless input[:skip_promotion]
             environment = ::Katello::KTEnvironment.find(input[:environment_id])

data/app/lib/actions/katello/content_view_version/incremental_update.rb

@@ -248,6 +248,7 @@ module Actions
         def finalize
           version = ::Katello::ContentViewVersion.find(input[:new_content_view_version_id])
           version.update_content_counts!
+          version.add_applied_filters!
           generate_description(version, output[:added_units]) if version.description.blank?
 
           history = ::Katello::ContentViewHistory.find(input[:history_id])

data/app/lib/actions/katello/host/update_content_view.rb

@@ -4,10 +4,8 @@ module Actions
       class UpdateContentView < Actions::EntryAction
         def plan(host, content_view_id, lifecycle_environment_id)
           if host.content_facet
-            host.content_facet.assign_single_environment(
-              content_view_id: content_view_id,
-              lifecycle_environment_id: lifecycle_environment_id
-            )
+            host.content_facet.content_view = ::Katello::ContentView.find(content_view_id)
+            host.content_facet.lifecycle_environment = ::Katello::KTEnvironment.find(lifecycle_environment_id)
             host.update_candlepin_associations
             plan_self(:hostname => host.name)
           else

data/app/lib/actions/katello/organization/simple_content_access/enable.rb

@@ -3,16 +3,6 @@ module Actions
     module Organization
       module SimpleContentAccess
         class Enable < Toggle
-          def plan(organization_id, auto_create_overrides: true)
-            input[:auto_create_overrides] = auto_create_overrides
-            sequence do
-              if auto_create_overrides
-                plan_action(PrepareContentOverrides, organization_id)
-              end
-              super(organization_id) # puts plan_self inside the sequence
-            end
-          end
-
           def content_access_mode_value
             SIMPLE_CONTENT_ACCESS_ENABLED_VALUE
           end

data/app/lib/actions/katello/organization/simple_content_access/toggle.rb

@@ -12,15 +12,9 @@ module Actions
           attr_reader :organization
 
           def plan(organization_id)
-            organization = ::Organization.find(organization_id.to_i)
-            input[:organization_name] = organization.name
-            input[:organization_label] = organization.label
+            @organization = ::Organization.find(organization_id)
             action_subject organization
-            plan_self(organization_id: organization_id)
-          end
-
-          def run
-            ::Katello::Resources::Candlepin::Owner.update(input[:organization_label], contentAccessMode: content_access_mode_value)
+            ::Katello::Resources::Candlepin::Owner.update(@organization.label, contentAccessMode: content_access_mode_value)
           end
 
           def failure_notification(plan)
@@ -36,10 +30,6 @@ module Actions
             )
           end
 
-          def humanized_input
-            _("for organization %s") % input[:organization_name]
-          end
-
           private
 
           def consumer

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

@@ -52,9 +52,9 @@ module Actions
             new_content.vendor = ::Katello::Provider::CUSTOM
           end
 
-          #custom product content is always enabled by default
+          # custom product content is always disabled by default
           ::Katello::ProductContent.where(product: root.product, content: content).first_or_create do |pc|
-            pc.enabled = true
+            pc.enabled = false
           end
         end
       end

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

@@ -1,3 +1,5 @@
+require 'set'
+
 module Actions
   module Katello
     module Repository
@@ -25,6 +27,7 @@ module Actions
 
           remove_versions(repository, repository.content_views_all(include_composite: true)&.generated_for_none, affected_cvv_ids) if remove_from_content_view_versions
 
+          handle_acs_product_removal(repository)
           handle_alternate_content_sources(repository)
 
           plan_self(:user_id => ::User.current.id, :affected_cvv_ids => affected_cvv_ids)
@@ -55,17 +58,22 @@ module Actions
         end
 
         def handle_alternate_content_sources(repository)
-          product = repository.product
-          content_type = repository.content_type
           repository.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
             plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
           end
+        end
 
-          # Remove the product from the ACS if it's empty.
-          # An ACS with only an empty product will not function correctly
-          ## because there will be no smart_proxy_alternate_content_sources.
-          if product.repositories.with_type(content_type).count == 1
-            ::Katello::AlternateContentSource.with_products(product).each do |acs|
+        def handle_acs_product_removal(repository)
+          # Remove products from ACS's that contain no repositories which both
+          # match the ACS content type and have a non-nil URL
+          product = repository.product
+          repo_content_types = Set.new
+          product.repositories.each do |test_repo|
+            # we need to check id because test_repo will still contain the old, non-nil url
+            repo_content_types.add(test_repo.content_type) if (repository.id != test_repo.id) && test_repo.url.present?
+          end
+          ::Katello::AlternateContentSource.with_products(product).each do |acs|
+            unless repo_content_types.include?(acs.content_type)
               acs.products = acs.products - [product]
               Rails.logger.info _('Removing product %{prod_name} with ID %{prod_id} from ACS %{acs_name} with ID %{acs_id}') %
                 { prod_name: product.name, prod_id: product.id, acs_name: acs.name, acs_id: acs.id }

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

@@ -1,3 +1,5 @@
+require 'set'
+
 module Actions
   module Katello
     module Repository
@@ -29,7 +31,8 @@ module Actions
                         :label => content.label,
                         :type => root.content_type,
                         :arches => root.format_arches,
-                        :os_versions => root.os_versions&.join(',')
+                        :os_versions => root.os_versions&.join(','),
+                        :metadata_expire => root.metadata_expire
                       )
 
             content.update!(name: root.name,
@@ -73,6 +76,7 @@ module Actions
               end
             end
           elsif delete_acs
+            handle_acs_product_removal(repository)
             repository.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
               plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs, old_url: old_url)
             end
@@ -83,6 +87,24 @@ module Actions
           end
         end
 
+        def handle_acs_product_removal(repository)
+          # Remove products from ACS's that contain no repositories which both
+          # match the ACS content type and have a non-nil URL
+          product = repository.product
+          repo_content_types = Set.new
+          product.repositories.each do |test_repo|
+            # we need to check id because test_repo will still contain the old, non-nil url
+            repo_content_types.add(test_repo.content_type) if (repository.id != test_repo.id) && test_repo.url.present?
+          end
+          ::Katello::AlternateContentSource.with_products(product).each do |acs|
+            unless repo_content_types.include?(acs.content_type)
+              acs.products = acs.products - [product]
+              Rails.logger.info _('Removing product %{prod_name} with ID %{prod_id} from ACS %{acs_name} with ID %{acs_id}') %
+                { prod_name: product.name, prod_id: product.id, acs_name: acs.name, acs_id: acs.id }
+            end
+          end
+        end
+
         def update_content?(repository)
           repository.library_instance? && !repository.product.redhat?
         end

data/app/lib/actions/pulp3/abstract_async_task.rb

@@ -114,6 +114,8 @@ module Actions
         case message
         when 'This repository uses features which are incompatible with \'mirror\' sync. Please sync without mirroring enabled.'
           'The "Complete Mirroring" mirroring policy is not compatible with this repository.  You may want to update it to use "Content Only"'
+        when 'Treeinfo file should have INI format'
+          'This repository has a malformed or inaccessible treeinfo file. To sync, try enabling \'Ignore treeinfo\'. All kickstart contents will be skipped.'
         else
           message
         end

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

@@ -14,8 +14,6 @@ module Actions
                 plan_self(source_repository_id: options[:source_repository].id, target_repository_id: repository.id, smart_proxy_id: smart_proxy.id)
               elsif publication_content_type && (force_publication || repository.publication_href.nil? || !repository.using_mirrored_metadata?)
                 plan_action(Actions::Pulp3::Repository::CreatePublication, repository, smart_proxy, options)
-              elsif !publication_content_type
-                plan_self(target_repository_id: repository.id, contents_changed: options[:contents_changed], skip_publication: true)
               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 Setting[:distribute_archived_cvv] || repository.environment
@@ -23,18 +21,13 @@ module Actions
           end
 
           def run
+            #we don't have to actually generate a publication, we can reuse the old one
             target_repo = ::Katello::Repository.find(input[:target_repository_id])
-            if input[:skip_publication]
-              #Need to clear smart proxy sync histories for non-publication content_types: docker, ansible collection
-              target_repo.clear_smart_proxy_sync_histories if input[:contents_changed]
-            else
-              #we don't have to actually generate a publication, we can reuse the old one
-              source_repo = ::Katello::Repository.find(input[:source_repository_id])
-              if (target_repo.publication_href != source_repo.publication_href && smart_proxy.pulp_primary?)
-                target_repo.clear_smart_proxy_sync_histories
-              end
-              target_repo.update!(publication_href: source_repo.publication_href)
+            source_repo = ::Katello::Repository.find(input[:source_repository_id])
+            if (target_repo.publication_href != source_repo.publication_href && smart_proxy.pulp_primary?)
+              target_repo.clear_smart_proxy_sync_histories
             end
+            target_repo.update!(publication_href: source_repo.publication_href)
           end
         end
       end