katello 4.9.2 → 4.10.0.rc1

data/app/controllers/katello/api/rhsm/candlepin_proxies_controller.rb

@@ -188,7 +188,7 @@ module Katello
 
     api :PUT, "/systems/:id/enabled_repos", N_("Update the information about enabled repositories")
     desc <<-DESC
-      Used by katello-agent to keep the information about enabled repositories up to date.
+      Used to keep the information about enabled repositories up to date.
       This information is then used for computing the errata available for the system.
     DESC
     param :enabled_repos, Hash, :required => true do

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

@@ -1,6 +1,6 @@
 module Katello
   class Api::V2::AlternateContentSourcesBulkActionsController < Api::V2::ApiController
-    before_action :find_alternate_content_sources
+    before_action :find_alternate_content_sources, except: [:refresh_all_alternate_content_sources]
 
     api :PUT, '/alternate_content_sources/bulk/destroy', N_('Destroy one or more alternate content sources')
     param :ids, Array, desc: N_('List of alternate content source IDs'), required: true
@@ -34,11 +34,32 @@ module Katello
       end
     end
 
+    api :POST, '/alternate_content_sources/bulk/refresh_all', N_("Refresh all alternate content sources")
+    def refresh_all_alternate_content_sources
+      refreshable_alternate_content_sources = AlternateContentSource.editable
+      if refreshable_alternate_content_sources.empty?
+        msg = _("Unable to refresh any alternate content source. You either do"\
+          " not have the permission to refresh, or no alternate content sources exist.")
+        fail HttpErrors::UnprocessableEntity, msg
+      else
+        task = async_task(::Actions::BulkAction,
+                          ::Actions::Katello::AlternateContentSource::Refresh,
+                          refreshable_alternate_content_sources)
+        respond_for_async resource: task
+      end
+    end
+
     private
 
     def find_alternate_content_sources
       params.require(:ids)
       @alternate_content_sources = AlternateContentSource.readable.where(id: params[:ids])
+      unless params[:ids].size == @alternate_content_sources.size
+        missing_ids = params[:ids].map(&:to_s) - @alternate_content_sources.pluck(:id)&.map(&:to_s)
+        msg = "Could not find alternate content sources with id: #{missing_ids} . You either do not have required permissions"\
+                ", or these alternate content sources do not exist."
+        fail HttpErrors::UnprocessableEntity, msg
+      end
     end
   end
 end

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

@@ -38,21 +38,6 @@ module Katello
       @resource_class ||= "Katello::#{resource_name.classify}".constantize
     end
 
-    def deprecate_katello_agent
-      check_katello_agent_not_disabled
-      ::Foreman::Deprecation.api_deprecation_warning("This action uses katello-agent, which is deprecated and will be removed in #{katello_agent_removal_release}.")
-    end
-
-    def check_katello_agent_not_disabled
-      unless ::Katello.with_katello_agent?
-        fail HttpErrors::BadRequest, _("This action uses katello-agent, which is currently disabled. Use remote execution instead.")
-      end
-    end
-
-    def katello_agent_removal_release
-      self.class.katello_agent_removal_release
-    end
-
     def full_result_response(collection)
       { :results => collection,
         :total => collection.count,

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

@@ -22,6 +22,8 @@ module Katello
     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 :file_id, :number, :desc => N_("Filter content view versions that contain the file")
+    param :nondefault, :bool, :desc => N_("Filter out default content views"), :required => false
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(ContentViewVersion)
     def index
@@ -36,10 +38,12 @@ module Katello
       versions = ContentViewVersion.readable
       versions = versions.triggered_by(params[:triggered_by_id]) if params[:triggered_by_id]
       versions = versions.with_organization_id(params[:organization_id]) if params[:organization_id]
+      versions = versions.non_default_view if ::Foreman::Cast.to_bool(params[:nondefault])
       versions = versions.where(:content_view_id => @view.id) if @view
       versions = versions.for_version(version_number) if version_number
       versions = versions.in_environment(@environment) if @environment
       versions = versions.component_of(params[:composite_version_id]) if params[:composite_version_id]
+      versions = versions.contains_file(params[:file_id]) if params[:file_id]
       versions
     end
 
@@ -78,9 +82,15 @@ module Katello
 
     api :PUT, "/content_view_versions/:id/republish_repositories", N_("Forces a republish of the version's repositories' metadata")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
-    param :force, :bool, :desc => N_("Force metadata regeneration to proceed. (Deprecated)"), deprecated: true
+    param :force, :bool, :desc => N_("Force metadata regeneration to proceed. Dangerous operation when version has repositories with the 'Complete Mirroring' mirroring policy")
     def republish_repositories
-      task = async_task(::Actions::Katello::ContentViewVersion::RepublishRepositories, @content_view_version)
+      mirror_complete_repos = @content_view_version.repositories.joins(:root).where(root: { mirroring_policy: ::Katello::RootRepository::MIRRORING_POLICY_COMPLETE })
+      if mirror_complete_repos.size > 0 && !::Foreman::Cast.to_bool(params[:force])
+        fail HttpErrors::BadRequest, _("Metadata republishing is dangerous on content view versions with repositories with the 'Complete Mirroring' mirroring policy.
+Change the mirroring policy on these repositories: #{mirror_complete_repos.pluck(:name)} and try again.
+Alternatively, use the 'force' parameter to regenerate metadata locally. New versions of the content view will continue to use upstream metadata for repositories with 'Complete Mirroring'.")
+      end
+      task = async_task(::Actions::Katello::ContentViewVersion::RepublishRepositories, @content_view_version, force: ::Foreman::Cast.to_bool(params[:force]))
       respond_for_async :resource => task
     end
 
@@ -127,8 +137,7 @@ module Katello
       validate_content(params[:add_content])
       resolve_dependencies = params.fetch(:resolve_dependencies, true)
       task = async_task(::Actions::Katello::ContentView::IncrementalUpdates, @content_view_version_environments, @composite_version_environments,
-                        params[:add_content], resolve_dependencies, hosts, params[:description],
-                        Setting[:remote_execution_by_default] && ::Katello.with_remote_execution?)
+                        params[:add_content], resolve_dependencies, hosts, params[:description])
       respond_for_async :resource => task
     end
 

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

@@ -14,7 +14,6 @@ module Katello
     before_action :find_errata_ids, only: :apply
     before_action :find_environment, only: :index
     before_action :find_content_view, only: :index
-    before_action :deprecate_katello_agent, only: :apply
 
     resource_description do
       api_version 'v2'
@@ -58,17 +57,6 @@ module Katello
       respond_for_index :collection => collection
     end
 
-    api :PUT, "/hosts/:host_id/errata/apply", N_("Schedule errata for installation using katello-agent. %s") % katello_agent_deprecation_text, deprecated: true
-    param :host_id, :number, :desc => N_("Host ID"), :required => true
-    param :errata_ids, Array, :desc => N_("List of Errata ids to install. Will be removed in %s") % katello_agent_removal_release, required: true
-
-    param_group :bulk_errata_ids
-    param_group :search, Api::V2::ApiController
-    def apply
-      task = async_task(::Actions::Katello::Host::Erratum::Install, @host, content: @errata_ids)
-      respond_for_async :resource => task
-    end
-
     api :GET, "/hosts/:host_id/errata/:id", N_("Retrieve a single errata for a host")
     param :host_id, :number, :desc => N_("Host ID"), :required => true
     param :id, String, :desc => N_("Errata id of the erratum (RHSA-2012:108)"), :required => true

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

@@ -10,7 +10,6 @@ module Katello
     before_action :require_packages_only, :only => [:upgrade]
     before_action :find_editable_host_with_facet, :except => :index
     before_action :find_host, :only => :index
-    before_action :deprecate_katello_agent, :only => [:install, :remove, :upgrade, :upgrade_all]
 
     resource_description do
       api_version 'v2'
@@ -35,60 +34,6 @@ module Katello
       respond_for_index(:collection => collection)
     end
 
-    api :PUT, "/hosts/:host_id/packages/install", N_("Install packages remotely using katello-agent. %s") % katello_agent_deprecation_text, deprecated: true
-    param :host_id, :number, :required => true, :desc => N_("ID of the host")
-    param_group :packages_or_groups
-    def install
-      if params[:packages]
-        packages = validate_package_list_format(params[:packages])
-        task     = async_task(::Actions::Katello::Host::Package::Install, @host, content: packages)
-        respond_for_async :resource => task
-        return
-      end
-
-      if params[:groups]
-        groups = extract_group_names(params[:groups])
-        task   = async_task(::Actions::Katello::Host::PackageGroup::Install, @host, content: groups)
-        respond_for_async :resource => task
-      end
-    end
-
-    api :PUT, "/hosts/:host_id/packages/upgrade", N_("Update packages remotely using katello-agent. %s") % katello_agent_deprecation_text, deprecated: true
-    param :host_id, :number, :required => true, :desc => N_("ID of the host")
-    param :packages, Array, :desc => N_("list of packages names"), :required => true
-    def upgrade
-      if params[:packages]
-        packages = validate_package_list_format(params[:packages])
-        task     = async_task(::Actions::Katello::Host::Package::Update, @host, content: packages)
-        respond_for_async :resource => task
-      end
-    end
-
-    api :PUT, "/hosts/:host_id/packages/upgrade_all", N_("Update packages remotely using katello-agent. %s") % katello_agent_deprecation_text, deprecated: true
-    param :host_id, :number, :required => true, :desc => N_("ID of the host")
-    def upgrade_all
-      task = async_task(::Actions::Katello::Host::Package::Update, @host, content: [])
-      respond_for_async :resource => task
-    end
-
-    api :PUT, "/hosts/:host_id/packages/remove", N_("Uninstall packages remotely using katello-agent. %s") % katello_agent_deprecation_text, deprecated: true
-    param :host_id, :number, :required => true, :desc => N_("ID of the host")
-    param_group :packages_or_groups
-    def remove
-      if params[:packages]
-        packages = validate_package_list_format(params[:packages])
-        task     = async_task(::Actions::Katello::Host::Package::Remove, @host, content: packages)
-        respond_for_async :resource => task
-        return
-      end
-
-      if params[:groups]
-        groups = extract_group_names(params[:groups])
-        task   = async_task(::Actions::Katello::Host::PackageGroup::Remove, @host, content: groups)
-        respond_for_async :resource => task
-      end
-    end
-
     def index_relation
       packages = @host.installed_packages
       upgradable_packages = ::Katello::Rpm.installable_for_hosts([@host]).select(:name)

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

@@ -1,5 +1,4 @@
 module Katello
-  # rubocop:disable Metrics/ClassLength
   class Api::V2::HostsBulkActionsController < Api::V2::ApiController
     include Concerns::Api::V2::BulkHostsExtensions
     include Katello::Concerns::Api::V2::ContentOverridesController
@@ -15,9 +14,7 @@ module Katello
     before_action :find_errata, only: [:available_incremental_updates]
     before_action :find_organization, only: [:add_subscriptions]
     before_action :find_traces, only: [:resolve_traces]
-    before_action :deprecate_katello_agent, only: [:install_content, :update_content, :remove_content]
 
-    before_action :validate_content_action, only: [:install_content, :update_content, :remove_content]
     before_action :validate_organization, only: [:add_subscriptions]
 
     # disable *_count fields on erratum rabl, since they perform N+1 queries
@@ -28,22 +25,6 @@ module Katello
       api_base_url "/api"
     end
 
-    PARAM_ACTIONS = {
-      :install_content => {
-        :package => ::Actions::Katello::Host::Package::Install,
-        :package_group => ::Actions::Katello::Host::PackageGroup::Install,
-        :errata => :install_errata
-      },
-      :update_content => {
-        :package => ::Actions::Katello::Host::Package::Update,
-        :package_group => ::Actions::Katello::Host::PackageGroup::Install
-      },
-      :remove_content => {
-        :package => ::Actions::Katello::Host::Package::Remove,
-        :package_group => ::Actions::Katello::Host::PackageGroup::Remove
-      }
-    }.with_indifferent_access
-
     def_param_group :bulk_params do
       param :organization_id, :number, :required => true, :desc => N_("ID of the organization")
       param :included, Hash, :required => true, :action_aware => true do
@@ -117,37 +98,6 @@ module Katello
                                                      :resource_class => Erratum))
     end
 
-    api :PUT, "/hosts/bulk/install_content", N_("Install content on one or more hosts using katello-agent. %s") % katello_agent_deprecation_text, deprecated: true
-    param_group :bulk_params
-    param :content_type, String,
-          :desc => N_("The type of content.  The following types are supported: 'package', 'package_group' and 'errata'."),
-          :required => true
-    param :content, Array, :desc => N_("List of content (e.g. package names, package group names (Deprecated) or errata ids)")
-    def install_content
-      content_action
-    end
-
-    api :PUT, "/hosts/bulk/update_content", N_("Update content on one or more hosts using katello-agent. %s") % katello_agent_deprecation_text, deprecated: true
-    param_group :bulk_params
-    param :content_type, String,
-          :desc => N_("The type of content.  The following types are supported: 'package' and 'package_group."),
-          :required => true
-    param :content, Array, :desc => N_("List of content (e.g. package or package group names)"), :required => true
-    param :update_all, :bool, :desc => N_("Updates all packages on the host(s)")
-    def update_content
-      content_action
-    end
-
-    api :PUT, "/hosts/bulk/remove_content", N_("Remove content on one or more hosts using katello-agent. %s") % katello_agent_deprecation_text, deprecated: true
-    param_group :bulk_params
-    param :content_type, String,
-          :desc => N_("The type of content.  The following types are supported: 'package' and 'package_group."),
-          :required => true
-    param :content, Array, :desc => N_("List of content (e.g. package or package group names)"), :required => true
-    def remove_content
-      content_action
-    end
-
     api :PUT, "/hosts/bulk/destroy", N_("Destroy one or more hosts")
     param_group :bulk_params
     def destroy_hosts
@@ -384,33 +334,6 @@ module Katello
       end
     end
 
-    def content_action
-      if params[:content_type] == 'errata'
-        options = {}
-        options[:update_all] = true if ::Foreman::Cast.to_bool(params[:install_all])
-        options[:errata_ids] = params[:content]
-
-        task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::Erratum::ApplicableErrataInstall, @hosts, options)
-        respond_for_async :resource => task
-      else
-        content = params[:content]
-        if params[:action] == :update_content && params[:update_all]
-          content = []
-        end
-        task = async_task(Actions::Katello::BulkAgentAction, PARAM_ACTIONS[params[:action]][params[:content_type]], @hosts, content: content)
-        respond_for_async :resource => task
-      end
-    end
-
-    def validate_content_action
-      fail HttpErrors::BadRequest, _("A content_type must be provided.") if params[:content_type].blank?
-      fail HttpErrors::BadRequest, _("No content has been provided.") if params[:content].blank? && !params[:update_all]
-
-      if PARAM_ACTIONS[params[:action]][params[:content_type]].nil?
-        fail HttpErrors::BadRequest, _("Invalid content type %s") % params[:content_type]
-      end
-    end
-
     def find_environment
       @environment = KTEnvironment.editable.find(params[:environment_id])
       throw_resource_not_found(name: 'lifecycle environment', id: params[:environment_id]) unless @environment

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

@@ -161,9 +161,10 @@ module Katello
     param :upstream_content_view_label, String, :desc => N_("Upstream Content View Label, default: Default_Organization_View. Relevant only for 'upstream_server' type.")
     param :upstream_lifecycle_environment_label, String, :desc => N_("Upstream Lifecycle Environment, default: Library. Relevant only for 'upstream_server' type.")
     param :ssl_ca_credential_id, Integer, :desc => N_("Content Credential to use for SSL CA. Relevant only for 'upstream_server' type.")
+    param :custom_cdn_auth_enabled, :bool, :desc => N_("If product certificates should be used to authenticate to a custom CDN.")
     def cdn_configuration
       config_keys = [:url, :username, :password, :upstream_organization_label, :ssl_ca_credential_id, :type,
-                     :upstream_lifecycle_environment_label, :upstream_content_view_label]
+                     :upstream_lifecycle_environment_label, :upstream_content_view_label, :custom_cdn_auth_enabled]
       config_params = params.slice(*config_keys).permit!.to_h
 
       task = sync_task(::Actions::Katello::CdnConfiguration::Update, @organization.cdn_configuration, config_params)

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

@@ -50,7 +50,6 @@ Pass [] to make repo available for clients regardless of OS version. Maximum len
       param :unprotected, :bool, :desc => N_("true if this repository can be published via HTTP")
       param :checksum_type, String, :desc => N_("Checksum of the repository, currently 'sha1' & 'sha256' are supported")
       param :docker_upstream_name, String, :desc => N_("Name of the upstream docker repository")
-      param :docker_tags_whitelist, Array, :desc => N_("Comma-separated list of tags to sync for Container Image repository (Deprecated)"), :deprecated => true
       param :include_tags, Array, :desc => N_("Comma-separated list of tags to sync for a container image repository")
       param :exclude_tags, Array, :desc => N_("Comma-separated list of tags to exclude when syncing a container image repository. Default: any tag ending in \"-source\"")
       param :download_policy, ["immediate", "on_demand"], :desc => N_("download policy for yum, deb, and docker repos (either 'immediate' or 'on_demand')")
@@ -325,10 +324,11 @@ Pass [] to make repo available for clients regardless of OS version. Maximum len
 
     api :PUT, "/repositories/:id/republish", N_("Forces a republish of the specified repository, regenerating metadata and symlinks on the filesystem. Not allowed for repositories with the 'Complete Mirroring' mirroring policy.")
     param :id, :number, :desc => N_("Repository identifier"), :required => true
-    param :force, :bool, :desc => N_("Force metadata regeneration to proceed. (Deprecated)"), deprecated: true
+    param :force, :bool, :desc => N_("Force metadata regeneration to proceed. Dangerous when repositories use the 'Complete Mirroring' mirroring policy")
     def republish
-      if @repository.mirroring_policy == Katello::RootRepository::MIRRORING_POLICY_COMPLETE
-        fail HttpErrors::BadRequest, _("Metadata republishing is not allowed on repositories with the 'Complete Mirroring' mirroring policy.")
+      if @repository.mirroring_policy == Katello::RootRepository::MIRRORING_POLICY_COMPLETE && !::Foreman::Cast.to_bool(params[:force])
+        fail HttpErrors::BadRequest, _("Metadata republishing is risky on 'Complete Mirroring' repositories. Change the mirroring policy and try again.
+Alternatively, use the 'force' parameter to regenerate metadata locally. On the next sync, the upstream repository's metadata will overwrite local metadata for 'Complete Mirroring' repositories.")
       end
       task = async_task(::Actions::Katello::Repository::MetadataGenerate, @repository)
       respond_for_async :resource => task
@@ -587,7 +587,7 @@ Pass [] to make repo available for clients regardless of OS version. Maximum len
               {:os_versions => []}, :deb_releases, :deb_components, :deb_architectures, :description,
               :http_proxy_policy, :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
              ]
-      keys += [{:docker_tags_whitelist => []}, {:include_tags => []}, {:exclude_tags => []}, :docker_upstream_name] if params[:action] == 'create' || @repository&.docker?
+      keys += [{:include_tags => []}, {:exclude_tags => []}, :docker_upstream_name] if params[:action] == 'create' || @repository&.docker?
       keys += [:ansible_collection_requirements, :ansible_collection_auth_url, :ansible_collection_auth_token] if params[:action] == 'create' || @repository&.ansible_collection?
       keys += [:label, :content_type] if params[:action] == "create"
 
@@ -627,11 +627,7 @@ Pass [] to make repo available for clients regardless of OS version. Maximum len
                                                             :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?
-          root.include_tags = repo_params.fetch(:docker_tags_whitelist, [])
-        else
-          root.include_tags = repo_params.fetch(:include_tags, [])
-        end
+        root.include_tags = repo_params.fetch(:include_tags, [])
       end
       root.exclude_tags = repo_params.fetch(:exclude_tags, ['*-source']) if root.docker?
       root.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)

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

@@ -4,7 +4,6 @@ module Katello
     before_action :find_object, :only => [:index]
     before_action :ensure_library, :only => [:index]
 
-    api :GET, "/organizations/:organization_id/products/:product_id/sync", N_("Get status of repo synchronisation for given product")
     api :GET, "/repositories/:repository_id/sync", N_("Get status of synchronisation for given repository")
     def index
       respond_for_async(:resource => @obj.sync_status)

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

@@ -17,16 +17,6 @@ module Katello
         User.current
       end
 
-      class_methods do
-        def katello_agent_deprecation_text
-          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_("Katello 4.10")
-        end
-      end
-
       protected
 
       def request_from_katello_cli?

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

@@ -91,7 +91,7 @@ module Katello
                                       .distinct
 
           if Katello.with_remote_execution?
-            template_id = JobTemplate.find_by(name: 'Change content source')&.id
+            template_id = JobTemplate.find_by(name: 'Configure host for new content source')&.id
             job_invocation_path = new_job_invocation_path(template_id: template_id, host_ids: content_hosts.map { |h| h[:id] }) if template_id
           end
 

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

@@ -71,7 +71,7 @@ module Actions
               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)
+                  plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs) if smart_proxy_acs.present?
                 end
               end
             end

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

@@ -9,7 +9,7 @@ module Actions
         def plan(content_view, environment)
           sequence do
             concurrence do
-              smart_proxies = SmartProxy.with_environment(environment)
+              smart_proxies = SmartProxy.unscoped.with_environment(environment).select { |sp| sp.authorized?(:manage_capsule_content) && sp.authorized?(:view_capsule_content) }
               unless smart_proxies.blank?
                 plan_action(::Actions::BulkAction, ::Actions::Katello::CapsuleContent::Sync, smart_proxies.sort,
                             :content_view_id => content_view.id, :environment_id => environment.id)

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

@@ -4,8 +4,7 @@ module Actions
       class IncrementalUpdates < Actions::EntryAction
         include Helpers::Presenter
 
-        def plan(version_environments, composite_version_environments, content, dep_solve, hosts, description,
-                use_remote_execution = false)
+        def plan(version_environments, composite_version_environments, content, dep_solve, hosts, description)
           old_new_version_map = {}
           output_for_version_ids = []
 
@@ -34,13 +33,8 @@ module Actions
               handle_composites(old_new_version_map, composite_version_environments, output_for_version_ids, description)
             end
 
-            if hosts.any? && !content[:errata_ids].blank? && !use_remote_execution
-              errata = ::Katello::Erratum.with_identifiers(content[:errata_ids])
-              hosts = hosts.where(:id => ::Katello::Host::ContentFacet.with_applicable_errata(errata).pluck(:host_id))
-              plan_action(::Actions::BulkAction, ::Actions::Katello::Host::Erratum::ApplicableErrataInstall, hosts, :errata_ids => content[:errata_ids])
-            end
             plan_self(:version_outputs => output_for_version_ids, :host_ids => hosts.pluck(:id),
-                      :errata_ids => content[:errata_ids], :use_remote_execution => use_remote_execution)
+                      :errata_ids => content[:errata_ids])
           end
         end
 
@@ -65,7 +59,7 @@ module Actions
         end
 
         def run
-          if input[:errata_ids].present? && input[:host_ids].present? && input[:use_remote_execution]
+          if input[:errata_ids].present? && input[:host_ids].present?
             errata_ids = input[:errata_ids].join(',')
             errata = ::Katello::Erratum.with_identifiers(input[:errata_ids])
             hosts = ::Host.where(:id => input[:host_ids] &

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

@@ -2,10 +2,16 @@ module Actions
   module Katello
     module ContentViewVersion
       class RepublishRepositories < Actions::EntryAction
-        def plan(content_view_version)
+        def plan(content_view_version, options = {force: false})
+          force = options[:force]
           action_subject(content_view_version.content_view)
           plan_self(:version_id => content_view_version.id)
-          plan_action(::Actions::Katello::Repository::BulkMetadataGenerate, content_view_version.repositories.joins(:root).where.not(root: { mirroring_policy: ::Katello::RootRepository::MIRRORING_POLICY_COMPLETE }))
+          repositories = if force
+                           content_view_version.repositories
+                         else
+                           content_view_version.repositories.joins(:root).where.not(root: { mirroring_policy: ::Katello::RootRepository::MIRRORING_POLICY_COMPLETE })
+                         end
+          plan_action(::Actions::Katello::Repository::BulkMetadataGenerate, repositories)
         end
 
         def run

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

@@ -9,7 +9,7 @@ module Actions
         def plan(repo)
           if repo.node_syncable?
             concurrence do
-              smart_proxies = ::SmartProxy.with_environment(repo.environment)
+              smart_proxies = ::SmartProxy.unscoped.with_environment(repo.environment).select { |sp| sp.authorized?(:manage_capsule_content) && sp.authorized?(:view_capsule_content) }
               unless smart_proxies.blank?
                 plan_action(::Actions::BulkAction, ::Actions::Katello::CapsuleContent::Sync, smart_proxies,
                             :repository_id => repo.id)

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

@@ -6,7 +6,7 @@ module Actions
           sequence do
             plan_action(Katello::Repository::MetadataGenerate, repository)
             concurrence do
-              ::SmartProxy.with_repo(repository).each do |capsule|
+              (::SmartProxy.unscoped.with_repo(repository).select { |sp| sp.authorized?(:manage_capsule_content) && sp.authorized?(:view_capsule_content) })&.each do |capsule|
                 next if capsule.pulp_primary?
                 plan_action(Katello::CapsuleContent::Sync, capsule, repository_id: repository.id)
               end

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

@@ -320,17 +320,12 @@ module Katello
         Util::Package.sortable_version(version)
       end
 
-      apipie :method, 'Returns true if Katello Agent infrastructure is enabled on the server'
-      def katello_agent_enabled?
-        Katello.with_katello_agent?
-      end
-
       include Katello::ContentSourceHelper
 
       apipie :method, "Generate script to change a host's content source" do
         returns String
       end
-      def change_content_source(host, ca_cert)
+      def configure_host_for_new_content_source(host, ca_cert)
         return missing_content_source(host) unless host.content_source
 
         prepare_ssl_cert(ca_cert) + configure_subman(host.content_source)
@@ -359,9 +354,9 @@ module Katello
       def parse_errata(task)
         task_input = get_task_input(task)
         agent_input = task_input['errata'] || task_input['content']
-        # Pick katello agent errata if present
-        # Otherwise pick rex errata. There are multiple template inputs, such as errata, pre_script and post_script we only need the
-        # errata input here.
+        # agent_input retrieves past katello-agent tasks.
+        # There are multiple template inputs, such as errata, pre_script and post_script.
+        # We only need the errata input here.
         @_tasks_errata_cache[task.id] ||= agent_input.presence || errata_ids_from_template_invocation(task, task_input)
       end
 

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

@@ -67,6 +67,10 @@ module Katello
             self.new(cdn_configuration.url, options)
           elsif cdn_configuration.custom_cdn?
             options[:ssl_ca_cert] = cdn_configuration.ssl_ca
+            if cdn_configuration.custom_cdn_auth_enabled?
+              options[:ssl_client_cert] = OpenSSL::X509::Certificate.new(product.certificate)
+              options[:ssl_client_key] = OpenSSL::PKey::RSA.new(product.key)
+            end
             self.new(cdn_configuration.url, options)
           else
             options[:username] = cdn_configuration.username

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

@@ -7,7 +7,7 @@ module Katello
             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 }
+              record.errors.add(attribute, _("%{name} has no %{type} repositories with upstream URLs to add to the alternate content source.") % { name: product.name, type: content_type })
             end
           end
         end

data/app/models/katello/cdn_configuration.rb

@@ -37,6 +37,10 @@ module Katello
       type == CUSTOM_CDN_TYPE
     end
 
+    def custom_cdn_auth_enabled?
+      custom_cdn_auth_enabled
+    end
+
     def redhat_cdn_url?
       Katello::Resources::CDN::CdnResource.redhat_cdn?(url)
     end

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

@@ -112,7 +112,6 @@ module Katello
         has_many :content_view_environments, through: :content_view_environment_content_facets
         has_many :content_views, through: :content_view_environments
         has_many :lifecycle_environments, through: :content_view_environments
-        has_many :dispatch_histories, :class_name => "::Katello::Agent::DispatchHistory", :foreign_key => :host_id, :dependent => :delete_all
 
         has_many :host_installed_packages, :class_name => "::Katello::HostInstalledPackage", :foreign_key => :host_id, :dependent => :delete_all
         has_many :installed_packages, :class_name => "::Katello::InstalledPackage", :through => :host_installed_packages
@@ -129,6 +128,8 @@ module Katello
 
         has_many :hypervisor_pools, :class_name => '::Katello::Pool', :foreign_key => :hypervisor_id, :dependent => :nullify
 
+        validates :name, format: { with: Net::Validations::HOST_REGEXP, message: _("%{value} can contain only lowercase letters, numbers, dashes and dots.") }
+
         before_validation :correct_kickstart_repository
         after_validation :add_back_cve_errors
         after_update :clear_pending_cve_attributes

data/app/models/katello/content_view.rb

@@ -1,7 +1,7 @@
 module Katello
   # rubocop:disable Metrics/ClassLength
   class ContentView < Katello::Model
-    audited :associations => [:repositories, :environments, :filters], :except => [:name, :label, :description]
+    audited :associations => [:repositories, :environments, :filters]
     has_associated_audits
     include Ext::LabelFromName
     include Katello::Authorization::ContentView
@@ -178,6 +178,10 @@ module Katello
       content_view_components.map(&:latest_version).compact.freeze
     end
 
+    def sorted_versions
+      versions.order('created_at DESC')
+    end
+
     # Adds content view components based on the input
     # [{:content_view_version_id=>1, :latest=> false}, {:content_view_id=>1, :latest=> true} ..]
     def add_components(components_to_add)

data/app/models/katello/content_view_component.rb

@@ -32,7 +32,7 @@ module Katello
     end
 
     def component_content_view_versions
-      self.content_view&.versions
+      self.content_view&.versions&.order(created_at: :desc)
     end
 
     private