katello 4.9.1 → 4.10.0.rc2

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/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

@@ -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/products_controller.rb

@@ -17,10 +17,10 @@ module Katello
 
     def_param_group :product do
       param :description, String, :desc => N_("Product description")
-      param :gpg_key_id, :number, :desc => N_("Identifier of the GPG key")
-      param :ssl_ca_cert_id, :number, :desc => N_("Idenifier of the SSL CA Cert")
-      param :ssl_client_cert_id, :number, :desc => N_("Identifier of the SSL Client Cert")
-      param :ssl_client_key_id, :number, :desc => N_("Identifier of the SSL Client Key")
+      param :gpg_key_id, :number, :desc => N_("Identifier of the GPG key"), :allow_nil => true
+      param :ssl_ca_cert_id, :number, :desc => N_("Idenifier of the SSL CA Cert"), :allow_nil => true
+      param :ssl_client_cert_id, :number, :desc => N_("Identifier of the SSL Client Cert"), :allow_nil => true
+      param :ssl_client_key_id, :number, :desc => N_("Identifier of the SSL Client Key"), :allow_nil => true
       param :sync_plan_id, :number, :desc => N_("Plan numeric identifier"), :allow_nil => true
     end
 

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

@@ -7,7 +7,7 @@ module Katello
     def destroy_repositories
       deletion_authorized_repositories = @repositories.deletable
       unpromoted_repos = deletion_authorized_repositories.reject { |repo| repo.promoted? && repo.content_views.generated_for_none.exists? }
-
+      unpromoted_repos_non_last_affected_repo = unpromoted_repos.reject { |repo| repo.filters.any? { |filter| filter.repositories.size == 1 } }
       messages1 = format_bulk_action_messages(
           :success    => "",
           :error      => _("You do not have permissions to delete %s"),
@@ -17,16 +17,23 @@ module Katello
 
       messages2 = format_bulk_action_messages(
           :success    => "",
-          :error      => _("Repository %s cannot be deleted since it has already been included in a published Content View."),
+          :error      => _("Repository %s cannot be deleted since it has already been included in a published Content View. Use repository details page to delete"),
           :models     => deletion_authorized_repositories,
           :authorized => unpromoted_repos
       )
 
-      errors = messages1[:error] + messages2[:error]
+      messages3 = format_bulk_action_messages(
+        :success    => "",
+        :error      => _("Repository %s cannot be deleted since it is the last affected repository in a filter. Use repository details page to delete."),
+        :models     => unpromoted_repos,
+        :authorized => unpromoted_repos_non_last_affected_repo
+      )
+
+      errors = messages1[:error] + messages2[:error] + messages3[:error]
 
       task = nil
-      if unpromoted_repos.any?
-        task = async_task(::Actions::BulkAction, ::Actions::Katello::Repository::Destroy, unpromoted_repos)
+      if unpromoted_repos_non_last_affected_repo.any?
+        task = async_task(::Actions::BulkAction, ::Actions::Katello::Repository::Destroy, unpromoted_repos_non_last_affected_repo)
       else
         status = 400
       end

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

@@ -41,16 +41,15 @@ module Katello
 
     def_param_group :repo do
       param :url, String, :desc => N_("repository source url")
-      param :os_versions, Array,
-            :desc => N_("Identifies whether the repository should be disabled on a client with a non-matching OS version. Pass [] to enable regardless of OS version. Maximum length 1; allowed tags are: %s") % Katello::RootRepository::ALLOWED_OS_VERSIONS.join(', ')
-      param :gpg_key_id, :number, :desc => N_("id of the gpg key that will be assigned to the new repository")
-      param :ssl_ca_cert_id, :number, :desc => N_("Identifier of the content credential containing the SSL CA Cert")
-      param :ssl_client_cert_id, :number, :desc => N_("Identifier of the content credential containing the SSL Client Cert")
-      param :ssl_client_key_id, :number, :desc => N_("Identifier of the content credential containing the SSL Client Key")
+      param :os_versions, Array, :desc => N_("Identifies whether the repository should be unavailable on a client with a non-matching OS version.
+Pass [] to make repo available for clients regardless of OS version. Maximum length 1; allowed tags are: %s") % Katello::RootRepository::ALLOWED_OS_VERSIONS.join(', ')
+      param :gpg_key_id, :number, :desc => N_("id of the gpg key that will be assigned to the new repository"), :allow_nil => true
+      param :ssl_ca_cert_id, :number, :desc => N_("Identifier of the content credential containing the SSL CA Cert"), :allow_nil => true
+      param :ssl_client_cert_id, :number, :desc => N_("Identifier of the content credential containing the SSL Client Cert"), :allow_nil => true
+      param :ssl_client_key_id, :number, :desc => N_("Identifier of the content credential containing the SSL Client Key"), :allow_nil => true
       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 @@ module Katello
 
     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
@@ -416,9 +416,12 @@ module Katello
     api :DELETE, "/repositories/:id", N_("Destroy a custom repository")
     param :id, :number, :required => true
     param :remove_from_content_view_versions, :bool, :required => false, :desc => N_("Force delete the repository by removing it from all content view versions")
+    param :delete_empty_repo_filters, :bool, :required => false, :desc => N_("Delete content view filters that have this repository as the last associated repository. Defaults to true. If false, such filters will now apply to all repositories in the content view.")
     def destroy
       sync_task(::Actions::Katello::Repository::Destroy, @repository,
-        remove_from_content_view_versions: ::Foreman::Cast.to_bool(params.fetch(:remove_from_content_view_versions, false)))
+                remove_from_content_view_versions: ::Foreman::Cast.to_bool(params.fetch(:remove_from_content_view_versions, false)),
+                delete_empty_repo_filters: ::Foreman::Cast.to_bool(params.fetch(:delete_empty_repo_filters, true))
+                )
       respond_for_destroy
     end
 
@@ -584,7 +587,7 @@ module Katello
               {: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"
 
@@ -624,11 +627,7 @@ module Katello
                                                             :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/content_facet_hosts_controller_extensions.rb

@@ -6,17 +6,15 @@ module Katello
         before_action :set_up_content_view_environment, only: [:update]
 
         def set_up_content_view_environment
-          return unless params[:host] && params[:host][:content_facet_attributes]
+          return unless @host&.content_facet.present? && params[:host]&.[](:content_facet_attributes)&.present?
           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}"
-          if (cv_id.present? && env_id.present?)
-            @host.content_facet.assign_single_environment(
-              lifecycle_environment_id: env_id,
-              content_view_id: cv_id
-            )
-            Rails.logger.info "set_up_content_view_environment: done"
-          end
+          Rails.logger.info "#{__method__}: cv_id=#{cv_id}, env_id=#{env_id}"
+          @host.content_facet.assign_single_environment(
+            lifecycle_environment_id: env_id,
+            content_view_id: cv_id
+          )
+          Rails.logger.info "#{__method__}: done"
         end
       end
     end

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/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -4,6 +4,18 @@ module Katello
       "kt_activation_keys"
     end
 
+    def edit_action?
+      params[:action] == 'edit'
+    end
+
+    def cv_lce_disabled?
+      edit_action? && !using_discovered_hosts_page?
+    end
+
+    def using_discovered_hosts_page?
+      controller.controller_name == "discovered_hosts"
+    end
+
     def using_hostgroups_page?
       controller.controller_name == "hostgroups"
     end
@@ -23,7 +35,7 @@ module Katello
     end
 
     def use_install_media(host, options = {})
-      return true if host&.errors && host.errors.include?(:medium_id)
+      return true if host&.errors && host.errors.include?(:medium_id) && host.medium.present?
       kickstart_repository_id(host, options).blank?
     end
 
@@ -164,7 +176,7 @@ module Katello
 
       views = []
       if lifecycle_environment
-        views = Katello::ContentView.in_environment(lifecycle_environment).readable.order(:name)
+        views = Katello::ContentView.in_environment(lifecycle_environment).ignore_generated.readable.order(:name)
         views |= [content_view] if content_view.present? && content_view.in_environment?(lifecycle_environment)
       elsif content_view
         views = [content_view]

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] &