katello 4.5.1 → 4.8.0.rc2

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

@@ -6,12 +6,6 @@ module Katello
       include Foreman::Controller::Flash
 
       module Overrides
-        def edit
-          @can_toggle_sca = Katello::UpstreamConnectionChecker.new(@taxonomy).can_connect? &&
-            (@taxonomy.upstream_consumer.simple_content_access_eligible? || @taxonomy.simple_content_access?)
-          super
-        end
-
         def destroy
           if @taxonomy.is_a?(Organization)
             begin
@@ -30,7 +24,8 @@ module Katello
           if taxonomy_class == Organization
             begin
               @taxonomy = Organization.new(resource_params)
-              ::Katello::OrganizationCreator.new(@taxonomy).create!
+              sca = ::Foreman::Cast.to_bool(params[:simple_content_access])
+              ::Katello::OrganizationCreator.new(@taxonomy, sca: sca).create!
               @taxonomy.reload
               switch_taxonomy
               if @count_nil_hosts > 0
@@ -50,20 +45,16 @@ module Katello
       end
 
       def update
-        super # we run super first here so that flash messages won't be in a confusing order
         return if params[:simple_content_access].nil?
         sca_param = ::Foreman::Cast.to_bool(params[:simple_content_access])
-        if sca_param && !@taxonomy.simple_content_access?
+        if sca_param && !@taxonomy.simple_content_access?(cached: false)
           # user has requested SCA enable
-          task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:id])
-          info "Enabling Simple Content Access for organization #{@taxonomy.name}.",
-            link: { text: "View progress on the Tasks page", href: "/foreman_tasks/tasks/#{task&.id}" }
-        elsif !sca_param && @taxonomy.simple_content_access?
+          sync_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:id])
+        elsif !sca_param && @taxonomy.simple_content_access?(cached: false)
           # user has requested SCA disable
-          task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:id])
-          info "Disabling Simple Content Access for organization #{@taxonomy.name}.",
-            link: { text: "View progress on the Tasks page", href: "/foreman_tasks/tasks/#{task&.id}" }
+          sync_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:id])
         end
+        super
       end
 
       included do

data/app/helpers/katello/content_source_helper.rb

@@ -37,7 +37,18 @@ module Katello
           --server.prefix="#{content_source.rhsm_url.path}" \
           --rhsm.repo_ca_cert="$KATELLO_SERVER_CA_CERT" \
           --rhsm.baseurl="#{content_source.pulp_content_url}"
+
+        subscription-manager facts --update
       CMD
     end
+
+    def reconfigure_yggdrasild(host)
+      template = Template.find_by(name: 'remote_execution_pull_setup')
+      return '' unless template
+
+      source = Foreman::Renderer.get_source(template: template, host: host)
+      scope = Foreman::Renderer.get_scope(source: source, host: host)
+      Foreman::Renderer.render(source, scope)
+    end
   end
 end

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -64,7 +64,7 @@ module Katello
     end
 
     def fetch_content_view(host, options = {})
-      return host.content_view if host.try(:content_view_id)
+      return host.single_content_view if host.try(:single_content_view)
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.content_view if selected_host_group.present?
     end
@@ -75,8 +75,12 @@ module Katello
       return selected_host_group.content_source if selected_host_group.present?
     end
 
-    def accessible_lifecycle_environments(org, host)
-      selected = host.lifecycle_environment
+    def accessible_lifecycle_environments(org, host_or_hostgroup)
+      selected = if host_or_hostgroup.is_a?(::Host::Managed)
+                   host_or_hostgroup.try(:single_lifecycle_environment)
+                 else
+                   host_or_hostgroup.lifecycle_environment
+                 end
       envs = org.kt_environments.readable.order(:name)
       envs |= [selected] if selected.present? && org == selected.organization
       envs
@@ -207,9 +211,14 @@ module Katello
         if (host.is_a? ::Hostgroup)
           new_host.content_facet = hostgroup_content_facet(host, param_host)
         elsif host.content_facet.present?
-          new_host.content_facet = ::Katello::Host::ContentFacet.new(:lifecycle_environment_id => host.content_facet.lifecycle_environment_id,
-                                                          :content_view_id => host.content_facet.content_view_id,
-                                                          :content_source_id => host.content_source_id)
+          new_host.content_facet = ::Katello::Host::ContentFacet.new(:content_source_id => host.content_source_id)
+          if host.single_content_view_environment?
+            # assign new_host the same CVE as host
+            new_host.content_facet.assign_single_environment(
+              :lifecycle_environment => host.content_facet.single_lifecycle_environment,
+              :content_view => host.content_facet.single_content_view
+            )
+          end
         end
         new_host.operatingsystem.kickstart_repos(new_host).map { |repo| OpenStruct.new(repo) }
       else
@@ -243,9 +252,11 @@ module Katello
         content_view = fetch_inherited_param(host_params[:content_view_id], ::Katello::ContentView, parent&.content_view)
         content_source = fetch_inherited_param(host_params[:content_source_id], ::SmartProxy, parent&.content_source)
 
-        host.content_facet = Host::ContentFacet.new(:lifecycle_environment_id => lifecycle_env.id,
-                                                    :content_view_id => content_view.id,
-                                                    :content_source => content_source)
+        host.content_facet = Host::ContentFacet.new(:content_source => content_source)
+        host.content_facet.assign_single_environment(
+          :lifecycle_environment_id => lifecycle_env.id,
+          :content_view_id => content_view.id
+        )
         if host.operatingsystem.is_a?(Redhat)
           view_options = host.operatingsystem.kickstart_repos(host).map { |repo| OpenStruct.new(repo) }
         end
@@ -269,24 +280,80 @@ module Katello
       [{ action: [_('Change Content Source'), '/change_host_content_source', false], priority: 100 }]
     end
 
+    def host_status_icon(status)
+      colours = [:green, :yellow, :red]
+
+      colour = colours[status] || :red
+
+      icons = {
+        green: "#{colour} host-status pficon pficon-ok status-ok",
+        yellow: "#{colour} host-status pficon pficon-info status-warn",
+        red: "#{colour} host-status pficon pficon-error-circle-o status-error"
+      }
+
+      "<span class=\"#{icons[colour]}\"></span>".html_safe
+    end
+
+    def errata_counts(host)
+      counts = host.content_facet_attributes&.errata_counts || {}
+      render partial: 'katello/hosts/errata_counts', locals: { counts: counts, host: host }
+    end
+
+    def host_registered_time(host)
+      return ''.html_safe unless host.subscription_facet_attributes&.registered_at
+
+      date_time_relative_value(host.subscription_facet_attributes.registered_at)
+    end
+
+    def host_checkin_time(host)
+      return ''.html_safe unless host.subscription_facet_attributes&.last_checkin
+
+      date_time_relative_value(host.subscription_facet_attributes.last_checkin)
+    end
+
     private
 
-    def hostgroup_content_facet(hostgroup, param_host)
-      lifecycle_environment_id = hostgroup.inherited_lifecycle_environment_id
-      content_view_id = hostgroup.inherited_content_view_id
+    def inherited_or_own_content_source_id(host_or_hostgroup, hostgroup)
       content_source_id = hostgroup.inherited_content_source_id
-      if param_host.lifecycle_environment_id && (hostgroup.inherited_lifecycle_environment_id != param_host.lifecycle_environment_id)
-        lifecycle_environment_id = param_host.lifecycle_environment_id
+      if host_or_hostgroup.content_source_id && (hostgroup.inherited_content_source_id != host_or_hostgroup.content_source_id)
+        content_source_id = host_or_hostgroup.content_source_id
       end
-      if param_host.content_view_id && (hostgroup.inherited_content_view_id != param_host.content_view_id)
-        content_view_id = param_host.content_view_id
+      content_source_id
+    end
+
+    def inherited_or_own_facet_attributes(host_or_hostgroup, hostgroup)
+      lifecycle_environment_id = hostgroup.inherited_lifecycle_environment_id
+      content_view_id = hostgroup.inherited_content_view_id
+      case host_or_hostgroup
+      when ::Hostgroup
+        if host_or_hostgroup.lifecycle_environment_id && (hostgroup.inherited_lifecycle_environment_id != host_or_hostgroup.lifecycle_environment_id)
+          lifecycle_environment_id = host_or_hostgroup.lifecycle_environment_id
+        end
+        if host_or_hostgroup.content_view_id && (hostgroup.inherited_content_view_id != host_or_hostgroup.content_view_id)
+          content_view_id = host_or_hostgroup.content_view_id
+        end
+      when ::Host::Managed
+        if host_or_hostgroup.single_lifecycle_environment && (hostgroup.inherited_lifecycle_environment_id != host_or_hostgroup.single_lifecycle_environment.id)
+          lifecycle_environment_id = host_or_hostgroup.single_lifecycle_environment.id
+        end
+        if host_or_hostgroup.single_content_view && (hostgroup.inherited_content_view_id != host_or_hostgroup.single_content_view.id)
+          content_view_id = host_or_hostgroup.single_content_view.id
+        end
       end
-      if param_host.content_source_id && (hostgroup.inherited_content_source_id != param_host.content_source_id)
-        content_source_id = param_host.content_source_id
+      [lifecycle_environment_id, content_view_id]
+    end
+
+    def hostgroup_content_facet(hostgroup, param_host)
+      lifecycle_environment_id, content_view_id = inherited_or_own_facet_attributes(param_host, hostgroup)
+      content_source_id = inherited_or_own_content_source_id(param_host, hostgroup)
+      facet = ::Katello::Host::ContentFacet.new(:content_source_id => content_source_id)
+      if content_view_id && lifecycle_environment_id
+        facet.assign_single_environment(
+          :lifecycle_environment_id => lifecycle_environment_id,
+          :content_view_id => content_view_id
+        )
       end
-      ::Katello::Host::ContentFacet.new(:lifecycle_environment_id => lifecycle_environment_id,
-                                        :content_view_id => content_view_id,
-                                        :content_source_id => content_source_id)
+      facet
     end
   end
 end

data/app/helpers/katello/katello_urls_helper.rb

@@ -43,20 +43,5 @@ module Katello
       optional :content_type, String, desc: 'Content type', default: 'repos'
       returns String, desc: 'Absolute path to a file'
     end
-    def repository_url(content_path, _content_type = nil, schema = 'http')
-      return content_path if content_path =~ %r|^([\w\-\+]+)://|
-      url = if @host.content_source
-              "#{schema}://#{@host.content_source.hostname}"
-            else
-              foreman_settings_url(schema)
-            end
-      content_path = content_path.sub(%r|^/|, '')
-      if @host.content_view && !@host.content_view.default?
-        content_path = [@host.content_view.label, content_path].join('/')
-      end
-      path = ::Katello::Glue::Pulp::Repos.repo_path_from_content_path(
-        @host.lifecycle_environment, content_path)
-      "#{url}/pulp/content/#{path}"
-    end
   end
 end

data/app/helpers/katello/sync_management_helper.rb

@@ -28,10 +28,6 @@ module Katello
       Product.syncable? && current_organization_object.syncable_content?
     end
 
-    def error_state?(status)
-      status[:raw_state] == PulpSyncStatus::ERROR && !status[:error_details].blank?
-    end
-
     module RepoMethods
       # returns all repos in hash representation with minors and arch children included
       def collect_repos(products, env, include_feedless = true)

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

@@ -14,12 +14,12 @@ module Actions
         case state
         when :running
           if self.external_task.nil?
-            _("initiating Candlepin task")
+            _("initiating %s task") % candlepin
           else
-            _("checking Candlepin task status")
+            _("checking %s task status") % candlepin
           end
         when :suspended
-          _("waiting for Candlepin to finish the task")
+          _("waiting for %s to finish the task") % candlepin
         else
           super
         end
@@ -30,6 +30,10 @@ module Actions
         !::Katello::Resources::Candlepin::Job.not_finished?(external_task)
       end
 
+      def candlepin
+        _("Candlepin")
+      end
+
       private
 
       def job_poll_params

data/app/lib/actions/candlepin/environment/set_content.rb

@@ -52,7 +52,13 @@ module Actions
         def existing_ids
           ::Katello::Resources::Candlepin::Environment.
               find(input[:cp_environment_id])[:environmentContent].map do |content|
-            content[:content][:id]
+            if content.key?('contentId')
+              # Supports Candlepin 4.2.11 and up
+              content['contentId']
+            else
+              # Supports Candlepin versions below 4.2.11
+              content[:content][:id]
+            end
           end
         end
       end

data/app/lib/actions/candlepin/owner/destroy_imports.rb

@@ -8,7 +8,7 @@ module Actions
 
         def run
           organization = ::Organization.find_by!(label: input[:label])
-          output[:response] = ::Katello::Resources::Candlepin::Owner.destroy_imports(organization.label, true)
+          output[:response] = ::Katello::Resources::Candlepin::Owner.destroy_imports(organization.label, wait_until_complete: true)
           organization.redhat_provider.index_subscriptions
         end
       end

data/app/lib/actions/candlepin/owner/{upstream_export.rb → retrieve_upstream_export.rb}

@@ -1,16 +1,16 @@
 module Actions
   module Candlepin
     module Owner
-      class UpstreamExport < Candlepin::Abstract
+      class RetrieveUpstreamExport < Candlepin::Abstract
         input_format do
           param :organization_id
           param :path
-          param :upstream
+          param :export_id
         end
 
         def run
           organization = ::Organization.find(input[:organization_id])
-          output[:response] = organization.redhat_provider.owner_upstream_export(input[:upstream], input[:path], {})
+          output[:response] = organization.redhat_provider.retrieve_owner_upstream_export(input[:upstream], input[:path], input[:export_id])
         end
       end
     end

data/app/lib/actions/candlepin/owner/start_upstream_export.rb

@@ -0,0 +1,24 @@
+module Actions
+  module Candlepin
+    module Owner
+      class StartUpstreamExport < Candlepin::UpstreamAbstractAsyncTask
+        input_format do
+          param :organization_id
+          param :upstream
+        end
+
+        def invoke_external_task
+          organization = ::Organization.find(input[:organization_id])
+          output[:response] = organization.redhat_provider.start_owner_upstream_export(input[:upstream])
+        end
+
+        def humanized_output
+          result_data = output[:task]&.[]('resultData')
+          return '' if result_data&.[]('status').blank?
+          "Upstream Candlepin job status: #{result_data['status']}\n
+          Message: #{result_data['statusMessage']}"
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/candlepin/upstream_abstract_async_task.rb

@@ -0,0 +1,30 @@
+module Actions
+  module Candlepin
+    class UpstreamAbstractAsyncTask < AbstractAsyncTask
+      input_format do
+        param :upstream
+      end
+
+      def done?
+        check_for_errors!(external_task)
+        !::Katello::Resources::Candlepin::UpstreamJob.not_finished?(external_task)
+      end
+
+      def candlepin
+        _("Upstream Candlepin")
+      end
+
+      private
+
+      def poll_external_task
+        ::Katello::Resources::Candlepin::UpstreamJob.get(external_task[:id], input[:upstream])
+      end
+
+      def check_for_errors!(task)
+        if task[:state] == 'FAILED'
+          fail ::Katello::Errors::UpstreamCandlepinError, task[:resultData]
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@ module Actions
     module ActivationKey
       class Destroy < Actions::EntryAction
         def plan(activation_key, options = {})
+          activation_key.validate_destroyable!
           skip_candlepin = options.fetch(:skip_candlepin, false)
           action_subject(activation_key)
 

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

@@ -91,6 +91,7 @@ module Actions
           if finish_limit < DateTime.now
             fail _("Host did not finish content action in %s seconds.  The task has been cancelled.") % finish_timeout
           end
+          suspend
         end
       end
 

data/app/lib/actions/katello/alternate_content_source/alternate_content_source_common.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Katello
+    module AlternateContentSource
+      module AlternateContentSourceCommon
+        def create_simplified_acs(acs, smart_proxy)
+          acs.products.each do |product|
+            product.repositories.has_url.library.with_type(acs.content_type).each do |repo|
+              smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repo.id)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,15 +2,23 @@ module Actions
   module Katello
     module AlternateContentSource
       class Create < Actions::EntryAction
-        def plan(acs, smart_proxies)
+        include Actions::Katello::AlternateContentSource::AlternateContentSourceCommon
+
+        def plan(acs, smart_proxies, products = nil)
           acs.save!
           action_subject(acs)
-          smart_proxies = smart_proxies.uniq
+          if products.present?
+            acs.update!(products: products)
+          end
+          smart_proxies = smart_proxies.present? ? smart_proxies.uniq : []
           concurrence do
             smart_proxies.each do |smart_proxy|
-              ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Create,
-                          acs, smart_proxy)
+              if acs.custom? || acs.rhui?
+                smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
+                plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+              elsif acs.simplified?
+                create_simplified_acs(acs, smart_proxy)
+              end
             end
           end
         end

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

@@ -5,11 +5,10 @@ module Actions
         def plan(acs)
           action_subject(acs)
           sequence do
-            acs.smart_proxies.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete,
-                          acs, smart_proxy)
+            acs.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
             end
-            plan_self(:acs_id => acs.id)
+            plan_self(acs_id: acs.id)
           end
         end
 

data/app/lib/actions/katello/alternate_content_source/refresh.rb

@@ -5,17 +5,15 @@ module Actions
         def plan(acs)
           action_subject(acs)
           concurrence do
-            acs.smart_proxies.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Refresh,
-                          acs, smart_proxy)
+            acs.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Refresh, smart_proxy_acs)
             end
           end
           plan_self(acs_id: acs.id)
         end
 
         def finalize
-          acs = ::Katello::AlternateContentSource.find_by(id: input[:acs_id])
-          acs.update(last_refreshed: ::DateTime.now)
+          ::Katello::AlternateContentSource.find_by(id: input[:acs_id])&.audit_refresh
         end
 
         def humanized_name

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

@@ -2,32 +2,78 @@ module Actions
   module Katello
     module AlternateContentSource
       class Update < Actions::EntryAction
+        include Actions::Katello::AlternateContentSource::AlternateContentSourceCommon
         # smart_proxies ALWAYS represents the smart proxies to remain associated
         # after the action runs.  If smart_proxies == [], there will be none afterwards.
-        def plan(acs, smart_proxies, acs_params)
+        # The same rule applies to products.
+        def plan(acs, smart_proxies, products, acs_params)
           action_subject(acs)
           acs.update!(acs_params)
 
           smart_proxies = smart_proxies.uniq
-          smart_proxies_to_add = smart_proxies - acs.smart_proxies
-          smart_proxies_to_delete = acs.smart_proxies - smart_proxies
+          smart_proxies_to_associate = smart_proxies - acs.smart_proxies
+          smart_proxies_to_disassociate = acs.smart_proxies - smart_proxies
           smart_proxies_to_update = smart_proxies & acs.smart_proxies
 
+          products ||= []
+          products_to_associate = []
+          products_to_disassociate = []
+
+          if products.present? || acs.products.present?
+            products = products.uniq
+            products_to_associate = products - acs.products
+            products_to_disassociate = acs.products - products
+            old_product_ids = acs.products.pluck(:id)
+            acs.products = products
+            acs.audit_updated_products(old_product_ids) unless products_to_associate.empty? && products_to_disassociate.empty?
+          end
+
+          acs.save!
+
           concurrence do
-            smart_proxies_to_add&.each do |smart_proxy|
-              ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Create,
-                          acs, smart_proxy)
+            create_acss(acs, smart_proxies_to_associate)
+            delete_acss(acs, smart_proxies_to_disassociate)
+            update_acss(acs, smart_proxies_to_update, products_to_associate, products_to_disassociate)
+          end
+        end
+
+        def create_acss(acs, smart_proxies_to_associate)
+          smart_proxies_to_associate&.each do |smart_proxy|
+            if acs.custom? || acs.rhui?
+              smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+            elsif acs.simplified?
+              create_simplified_acs(acs, smart_proxy)
             end
+          end
+        end
 
-            smart_proxies_to_delete&.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete,
-                          acs, smart_proxy)
+        def delete_acss(acs, smart_proxies_to_disassociate)
+          smart_proxies_to_disassociate&.each do |smart_proxy|
+            acs.smart_proxy_alternate_content_sources.where(smart_proxy_id: smart_proxy.id).each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
             end
+          end
+        end
 
-            smart_proxies_to_update&.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Update,
-                          acs, smart_proxy)
+        def update_acss(acs, smart_proxies_to_update, products_to_associate, products_to_disassociate)
+          smart_proxies_to_update&.each do |smart_proxy|
+            if acs.custom? || acs.rhui?
+              smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: nil)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Update, smart_proxy_acs)
+            elsif acs.simplified?
+              products_to_associate.each do |product|
+                product.repositories.library.with_type(acs.content_type).each do |repo|
+                  smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repo.id)
+                  plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+                end
+              end
+              products_to_disassociate.each do |product|
+                product.repositories.library.with_type(acs.content_type).each do |repo|
+                  smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repo.id)
+                  plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
+                end
+              end
             end
           end
         end

data/app/lib/actions/katello/applicability/hosts/bulk_generate.rb

@@ -32,8 +32,8 @@ module Actions
           end
 
           def humanized_name
-            if input[:host_ids]&.length == 1
-              _("Bulk generate applicability for host %s" % hostname(input[:host_ids].first))
+            if input && input[:host_ids]&.length == 1
+              _("Bulk generate applicability for host %s" % hostname(input[:host_ids]&.first))
             else
               _("Bulk generate applicability for hosts")
             end

data/app/lib/actions/katello/capsule_content/sync.rb

@@ -31,19 +31,23 @@ module Actions
           fail _("Action not allowed for the default smart proxy.") if smart_proxy.pulp_primary?
 
           refresh_options = options.merge(content_view: content_view,
-                                             environment:  environment,
-                                             repository: repository)
+                                          environment: environment,
+                                          repository: repository)
           sequence do
-            if smart_proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE)
-              plan_action(Actions::Pulp::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
-            end
-
             if smart_proxy.has_feature?(SmartProxy::PULP3_FEATURE)
               plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy)
               plan_action(Actions::Pulp3::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
             end
             plan_action(SyncCapsule, smart_proxy, refresh_options)
           end
+          plan_self(smart_proxy_id: smart_proxy.id)
+        end
+
+        def finalize
+          smart_proxy = SmartProxy.unscoped.authorized(:view_capsule_content).find(input[:smart_proxy_id])
+          unless smart_proxy&.pulp_primary?
+            smart_proxy&.audit_capsule_sync
+          end
         end
       end
     end

data/app/lib/actions/katello/capsule_content/sync_capsule.rb

@@ -2,7 +2,6 @@ module Actions
   module Katello
     module CapsuleContent
       class SyncCapsule < ::Actions::EntryAction
-        include Actions::Katello::PulpSelector
         # rubocop:disable Metrics/MethodLength
         def plan(smart_proxy, options = {})
           plan_self(:smart_proxy_id => smart_proxy.id)
@@ -18,7 +17,7 @@ module Actions
             repos.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
               concurrence do
                 repo_batch.each do |repo|
-                  if smart_proxy.backend_service_type(repo) == Actions::Pulp3::Abstract::BACKEND_SERVICE_TYPE
+                  if smart_proxy.pulp3_support?(repo)
                     plan_action(Actions::Pulp3::CapsuleContent::Sync,
                       repo, smart_proxy,
                       skip_metadata_check: skip_metadata_check)

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

@@ -18,7 +18,7 @@ module Actions
           org = cdn_configuration.organization
           roots = ::Katello::RootRepository.redhat.in_organization(org)
           roots.each do |root|
-            full_path = if cdn_configuration.redhat_cdn?
+            full_path = if cdn_configuration.redhat_cdn? || cdn_configuration.custom_cdn?
                           root.product.repo_url(root.library_instance.generate_content_path)
                         elsif cdn_configuration.network_sync?
                           resource.repository_url(content_label: root.content.label, arch: root.arch, major: root.major, minor: root.minor)