katello 4.3.0.rc4 → 4.4.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83de032a01e5d20e480d164eb425db853b1eea9a4668eb1aa853bfaa5d6a703a
-  data.tar.gz: aad3b14f2608df9c71cb039222ced8baf98bc89537c28967fcc1d47ac3ce3c5c
+  metadata.gz: 294ac07f46dd213e4ebbdd13f97d387b39ef2e5859ed6224e354672f4b26f244
+  data.tar.gz: b08b1182252900cc7390ae257b1a9243fcdb26f00d64b1f668cc17faff4f08e8
 SHA512:
-  metadata.gz: cb93e596697f4639b7b4ba3d512524f9880f63442bdba0b4963f73fe6aa18b61d4565f71f488a7cd99f54c0908cbe74cc59468b987450c5d02c9f8020a521761
-  data.tar.gz: 9ffa356f5005ab1e2119c119c24837530c23d4d004c1a9c99a3b120fc648f443bf126faae8adff3a5763714ba70d9aa412976f50b6d886e6dc3bd0fb4257dcce
+  metadata.gz: 85c64b73f97252bd9f99c28071bddd97aebc83a525a5ec8559f4538180c733eca336e433e4d2f06204e6d57c5333246fc512e155c2396622daa369fd0dc0bbb4
+  data.tar.gz: e5d7904f19cb93eac89ff6e27b6c585e53f9419e925c4c5bedce2b30ac7a1d8df6c3e518574ad86c6607edbacc99a21360df54cef3b3ddfb94c4c38570f945a7

data/app/assets/javascripts/katello/common/vendor.js

@@ -1,5 +1,4 @@
 //= require "jquery-ui/widgets/dialog"
-//= require "jquery-ui/widgets/sortable"
 //= require "jquery-ui/widgets/progressbar"
 //= require "jquery-ui/effect"
 //= require "jquery-ui/effect.all"

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

@@ -126,7 +126,7 @@ module Katello
       end
     rescue ScopedSearch::QueryNotSupported, ActiveRecord::StatementInvalid => error
       message = error.message
-      if error.class == ActiveRecord::StatementInvalid
+      if error.instance_of? ActiveRecord::StatementInvalid
         Rails.logger.error("Invalid search: #{error.message}")
         message = _('Your search query was invalid. Please revise it and try again. The full error has been sent to the application logs.')
       end
@@ -141,7 +141,7 @@ module Katello
     protected
 
     def scoped_search_query(query, group)
-      if group
+      if group && !query_has_group_by?(query)
         query.select(group).group(group)
       else
         query
@@ -149,7 +149,12 @@ module Katello
     end
 
     def scoped_search_total(query, group)
-      scoped_search_query(query, group).length
+      count_query = scoped_search_query(query, group)
+      if query_has_group_by?(count_query)
+        count_query.length
+      else
+        count_query.count
+      end
     end
 
     def scoped_search_total_selectable(query, group)
@@ -157,10 +162,14 @@ module Katello
       if self.respond_to?(:total_selectable, true)
         total_selectable(q)
       else
-        q.length
+        group ? q.length : q.count
       end
     end
 
+    def query_has_group_by?(query)
+      query.to_sql.include?('GROUP BY')
+    end
+
     def scoped_search_results(query:, subtotal: 0, total: 0, page: 0, per_page: 0, error: nil, selectable: nil)
       {
         :results => query,

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

@@ -76,7 +76,7 @@ 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.  Dangerous when repositories use mirror on sync."), :required => true
+    param :force, :bool, :desc => N_("Force metadata regeneration to proceed.  Dangerous when repositories use the 'Complete Mirroring' mirroring policy"), :required => true
     def republish_repositories
       unless ::Foreman::Cast.to_bool(params[:force])
         fail HttpErrors::BadRequest, _("Metadata republishing must be forced because it is a dangerous operation.")
@@ -163,6 +163,9 @@ module Katello
 
     def find_optional_readable_content_view
       @view = ContentView.readable.find_by(:id => params[:content_view_id])
+      if params[:content_view_id] && !@view
+        fail HttpErrors::NotFound, _("Couldn't find content view with id: '%s'") % params[:content_view_id]
+      end
     end
 
     def find_publishable_content_view

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

@@ -2,6 +2,7 @@ module Katello
   class Api::V2::ContentViewsController < Api::V2::ApiController
     include Concerns::Authorization::Api::V2::ContentViewsController
     include Katello::Concerns::FilteredAutoCompleteSearch
+    include Katello::Concerns::Api::V2::BulkExtensions
 
     before_action :find_authorized_katello_resource, :except => [:index, :create, :copy, :auto_complete_search]
     before_action :ensure_non_default, :except => [:index, :create, :copy, :auto_complete_search]
@@ -24,6 +25,18 @@ module Katello
       param :import_only, :bool, :desc => N_("Designate this Content View for importing from upstream servers only. Defaults to false")
     end
 
+    def_param_group :bulk_content_view_version_ids do
+      param :included, Hash, :desc => N_("Versions to exclusively include in the action"), :required => true, :action_aware => true do
+        param :search, String, :required => false, :desc => N_("Search string for versions to perform an action on")
+        param :ids, Array, :required => false, :desc => N_("List of versions to perform an action on")
+      end
+      param :excluded, Hash, :desc => N_("Versions to explicitly exclude in the action."\
+                                         " All other versions will be included in the action,"\
+                                         " unless an included parameter is passed as well."), :required => true, :action_aware => true do
+        param :ids, Array, :required => false, :desc => N_("List of versions to exclude and not run an action on")
+      end
+    end
+
     def filtered_associations
       {
         :component_ids => Katello::ContentViewVersion,
@@ -175,6 +188,39 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :PUT, "/content_views/:id/bulk_delete_versions", N_("Bulk remove versions from a content view and reassign systems and keys")
+    param_group :bulk_content_view_version_ids
+    param :id, :number, :desc => N_("content view numeric identifier"), :required => true
+    param :system_content_view_id, :number, :desc => N_("content view to reassign orphaned systems to")
+    param :system_environment_id, :number, :desc => N_("environment to reassign orphaned systems to")
+    param :key_content_view_id, :number, :desc => N_("content view to reassign orphaned activation keys to")
+    param :key_environment_id, :number, :desc => N_("environment to reassign orphaned activation keys to")
+    def bulk_delete_versions
+      params[:bulk_content_view_version_ids] ||= {}
+
+      versions = find_bulk_items(bulk_params: params[:bulk_content_view_version_ids],
+                                 model_scope: ::Katello::ContentViewVersion.where(content_view_id: @content_view.id),
+                                 key: :id)
+      cv_envs = ContentViewEnvironment.where(:content_view_version_id => versions.pluck(:id),
+                                             :content_view_id => @content_view.id
+      )
+
+      if !params[:destroy_content_view] && cv_envs.empty? && versions.empty?
+        fail _("There either were no environments nor versions specified or there were invalid environments/versions specified. "\
+               "Please check environment_ids and content_view_version_ids parameters.")
+      end
+
+      options = params.slice(:system_content_view_id,
+                             :system_environment_id,
+                             :key_content_view_id,
+                             :key_environment_id
+      ).reject { |_k, v| v.nil? }.to_unsafe_h
+      options[:content_view_versions] = versions
+      options[:content_view_environments] = cv_envs
+      task = async_task(::Actions::Katello::ContentView::Remove, @content_view, options)
+      respond_for_async :resource => task
+    end
+
     api :PUT, "/content_views/:id/remove_filters", N_("Delete multiple filters from a content view")
     param :id, :number, :desc => N_("content view numeric identifier"), :required => true
     param :filter_ids, Array, of: :number, :desc => N_("filter identifiers"), :required => true

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

@@ -2,6 +2,10 @@ module Katello
   class Api::V2::HostPackagesController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
+    UPGRADABLE = "upgradable".freeze
+    UP_TO_DATE = "up-to-date".freeze
+    VERSION_STATUSES = [UPGRADABLE, UP_TO_DATE].freeze
+
     before_action :require_packages_or_groups, :only => [:install, :remove]
     before_action :require_packages_only, :only => [:upgrade]
     before_action :find_editable_host_with_facet, :except => :index
@@ -21,9 +25,11 @@ module Katello
     api :GET, "/hosts/:host_id/packages", N_("List packages installed on the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
     param :include_latest_upgradable, :boolean, :desc => N_("Also include the latest upgradable package version for each host package")
+    param :status, String, :desc => N_("Return only packages of a particular status (upgradable or up-to-date)"), :required => false
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Katello::InstalledPackage)
     def index
+      validate_index_params!
       collection = scoped_search(index_relation, :name, :asc, :resource_class => ::Katello::InstalledPackage)
       collection[:results] = HostPackagePresenter.with_latest(collection[:results], @host) if ::Foreman::Cast.to_bool(params[:include_latest_upgradable])
       respond_for_index(:collection => collection)
@@ -84,7 +90,15 @@ module Katello
     end
 
     def index_relation
-      @host.installed_packages
+      packages = @host.installed_packages
+      upgradable_packages = ::Katello::Rpm.installable_for_hosts([@host]).select(:name)
+      if params[:status].present?
+        packages = case params[:status]
+                   when 'up-to-date' then packages.where.not(name: upgradable_packages)
+                   when 'upgradable' then packages.where(name: upgradable_packages)
+                   end
+      end
+      packages
     end
 
     def resource_class
@@ -137,5 +151,11 @@ module Katello
         group.gsub(/^@/, "")
       end
     end
+
+    def validate_index_params!
+      if params[:status].present?
+        fail _("Status must be one of: %s" % VERSION_STATUSES.join(', ')) unless VERSION_STATUSES.include?(params[:status])
+      end
+    end
   end
 end

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

@@ -3,11 +3,13 @@ module Katello
   class Api::V2::HostsBulkActionsController < Api::V2::ApiController
     include Concerns::Api::V2::BulkHostsExtensions
     include Katello::Concerns::Api::V2::ContentOverridesController
+    include Katello::ContentSourceHelper
+    include ::Foreman::Renderer::Scope::Macros::Base
 
     before_action :find_host_collections, only: [:bulk_add_host_collections, :bulk_remove_host_collections]
     before_action :find_environment, only: [:environment_content_view]
     before_action :find_content_view, only: [:environment_content_view]
-    before_action :find_editable_hosts, except: [:destroy_hosts, :resolve_traces]
+    before_action :find_editable_hosts, except: [:destroy_hosts, :resolve_traces, :change_content_source]
     before_action :find_deletable_hosts, only: [:destroy_hosts]
     before_action :find_readable_hosts, only: [:applicable_errata, :installable_errata, :available_incremental_updates]
     before_action :find_errata, only: [:available_incremental_updates]
@@ -305,6 +307,33 @@ module Katello
                         template: '../../../api/v2/module_streams/name_streams')
     end
 
+    api :PUT, "/hosts/bulk/change_content_source", N_("Update the content source for specified hosts and generate the reconfiguration script")
+    param :host_ids, Array, required: true, desc: N_("The ids of the hosts to alter. Hosts not managed by Katello are ignored")
+    param :environment_id, :number, required: true, desc: N_("The id of the lifecycle environment")
+    param :content_view_id, :number, required: true, desc: N_("The id of the content view")
+    param :content_source_id, :number, required: true, desc: N_("The id of the content source")
+    def change_content_source
+      hosts = ::Host.where(id: params[:host_ids])
+      throw_resource_not_found(name: 'host', id: params[:host_ids]) unless hosts.any?
+
+      lifecycle_environment = KTEnvironment.readable.find(params[:environment_id])
+      content_view = Katello::ContentView.readable.find(params[:content_view_id])
+      content_source = SmartProxy.authorized(:view_smart_proxies).find(params[:content_source_id])
+      template = prepare_ssl_cert(foreman_server_ca_cert) + configure_subman(content_source)
+
+      hosts.each do |host|
+        next unless host.content_facet
+
+        host.content_facet.lifecycle_environment = lifecycle_environment
+        host.content_facet.content_view = content_view
+        host.content_facet.content_source = content_source
+
+        host.update_candlepin_associations
+      end
+
+      render plain: template
+    end
+
     private
 
     def find_errata

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

@@ -134,13 +134,17 @@ module Katello
 
     api :PUT, "/organizations/:id/cdn_configuration", N_("Update the CDN configuration")
     param :id, String, :desc => N_("ID of the Organization"), :required => true
-    param :ssl_ca_credential_id, Integer, :desc => N_("Content Credential to use for SSL CA")
-    param :username, String, :desc => N_("Username for authentication")
-    param :password, String, :desc => N_("Password for authentication")
-    param :upstream_organization_label, String, :desc => N_("Upstream organization to sync CDN content from")
-    param :url, String, :desc => N_("Upstream server to sync CDN content from")
+    param :type, String, :desc => N_("CDN configuration type. One of %s.") % CdnConfiguration::TYPES, :required => true
+    param :url, String, :desc => N_("Upstream foreman server to sync CDN content from. Relevant only for 'upstream_server' type.")
+    param :username, String, :desc => N_("Username for authentication. Relevant only for 'upstream_server' type.")
+    param :password, String, :desc => N_("Password for authentication. Relevant only for 'upstream_server' type.")
+    param :upstream_organization_label, String, :desc => N_("Upstream organization to sync CDN content from. Relevant only for 'upstream_server' type.")
+    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.")
     def cdn_configuration
-      config_keys = [:url, :username, :password, :upstream_organization_label, :ssl_ca_credential_id]
+      config_keys = [:url, :username, :password, :upstream_organization_label, :ssl_ca_credential_id, :type,
+                     :upstream_lifecycle_environment_label, :upstream_content_view_label]
       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/packages_controller.rb

@@ -53,9 +53,13 @@ module Katello
     def custom_index_relation(collection)
       applicable = ::Foreman::Cast.to_bool(params[:packages_restrict_applicable]) || params[:host_id]
       upgradable = ::Foreman::Cast.to_bool(params[:packages_restrict_upgradable])
+      not_installed = ::Foreman::Cast.to_bool(params[:packages_restrict_not_installed])
 
       if upgradable
         collection = collection.installable_for_hosts(@hosts)
+      elsif not_installed && params[:host_id]
+        host = @hosts.first
+        collection = Katello::Rpm.yum_installable_for_host(host)
       elsif applicable
         collection = collection.applicable_to_hosts(@hosts)
       end

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

@@ -53,7 +53,16 @@ module Katello
     api :POST, "/repositories/bulk/reclaim_space", N_("Reclaim space from On Demand repositories")
     param :ids, Array, :desc => N_("List of repository ids"), :required => true
     def reclaim_space_from_repositories
-      task = async_task(::Actions::Pulp3::Repository::ReclaimSpace, @repositories)
+      if @repositories.empty?
+        fail _("No repositories selected.")
+      end
+      repositories = @repositories.select { |repo| repo.download_policy == ::Katello::RootRepository::DOWNLOAD_ON_DEMAND }
+      if repositories.empty?
+        fail _("Only On Demand repositories may have space reclaimed.")
+      end
+      task = async_task(::Actions::BulkAction,
+                        ::Actions::Pulp3::Repository::ReclaimSpace,
+                        repositories)
 
       respond_for_async :resource => task
     end

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

@@ -7,7 +7,7 @@ module Katello
       generic_repo_wrap_params << option.name
     end
 
-    repo_wrap_params = RootRepository.attribute_names.concat([:ignore_global_proxy]) + generic_repo_wrap_params
+    repo_wrap_params = RootRepository.attribute_names.concat([:ignore_global_proxy, :mirror_on_sync]) + generic_repo_wrap_params
 
     wrap_parameters :repository, :include => repo_wrap_params
 
@@ -50,10 +50,13 @@ module Katello
       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")
-      param :download_policy, ["immediate", "on_demand"], :desc => N_("download policy for yum repos (either 'immediate' or 'on_demand')")
+      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')")
       param :download_concurrency, :number, :desc => N_("Used to determine download concurrency of the repository in pulp3. Use value less than 20. Defaults to 10")
-      param :mirror_on_sync, :bool, :desc => N_("true if this repository when synced has to be mirrored from the source and stale rpms removed")
+      param :mirror_on_sync, :bool, :desc => N_("true if this repository when synced has to be mirrored from the source and stale rpms removed (Deprecated)")
+      param :mirroring_policy, Katello::RootRepository::MIRRORING_POLICIES, :desc => N_("Policy to set for mirroring content.  Must be one of %s.") % RootRepository::MIRRORING_POLICIES
       param :verify_ssl_on_sync, :bool, :desc => N_("if true, Katello will verify the upstream url's SSL certifcates are signed by a trusted CA")
       param :upstream_username, String, :desc => N_("Username of the upstream repository user used for authentication")
       param :upstream_password, String, :desc => N_("Password of the upstream repository user used for authentication")
@@ -268,7 +271,7 @@ module Katello
 
     api :PUT, "/repositories/:id/republish", N_("Forces a republish of the specified repository, regenerating metadata and symlinks on the filesystem.")
     param :id, :number, :desc => N_("Repository identifier"), :required => true
-    param :force, :bool, :desc => N_("Force metadata regeneration to proceed.  Dangerous when repositories use mirror on sync."), :required => true
+    param :force, :bool, :desc => N_("Force metadata regeneration to proceed.  Dangerous when repositories use the 'Complete Mirroring' mirroring policy."), :required => true
     def republish
       unless ::Foreman::Cast.to_bool(params[:force])
         fail HttpErrors::BadRequest, _('Metadata republishing must be forced because it is a dangerous operation.')
@@ -324,6 +327,9 @@ module Katello
     api :POST, "/repositories/:id/reclaim_space", N_("Reclaim space from an On Demand repository")
     param :id, :number, :required => true, :desc => N_("repository ID")
     def reclaim_space
+      if @repository.download_policy != ::Katello::RootRepository::DOWNLOAD_ON_DEMAND
+        fail HttpErrors::BadRequest, _("Only On Demand repositories may have space reclaimed.")
+      end
       task = async_task(::Actions::Pulp3::Repository::ReclaimSpace, @repository)
       respond_for_async :resource => task
     rescue Errors::InvalidActionOptionError => e
@@ -501,12 +507,12 @@ module Katello
 
     # rubocop:disable Metrics/CyclomaticComplexity
     def repository_params
-      keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password,
+      keys = [:download_policy, :mirror_on_sync, :mirroring_policy, :sync_policy, :arch, :verify_ssl_on_sync, :upstream_password,
               :upstream_username, :download_concurrency, :upstream_authentication_token,
               {: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 => []}, :docker_upstream_name] if params[:action] == 'create' || @repository&.docker?
+      keys += [{:docker_tags_whitelist => []}, {: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"
 
@@ -525,7 +531,8 @@ module Katello
         keys += [:url, :gpg_key_id, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id, :unprotected, :name,
                  :checksum_type]
       end
-      params.require(:repository).permit(*keys).to_h.with_indifferent_access
+      to_return = params.require(:repository).permit(*keys).to_h.with_indifferent_access
+      handle_mirror_on_sync(to_return)
     end
 
     def get_content_credential(repo_params, content_type)
@@ -538,15 +545,22 @@ module Katello
       credential_value
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/PerceivedComplexity,Metrics/MethodLength
     def construct_repo_from_params(repo_params) # rubocop:disable Metrics/AbcSize
       root = @product.add_repo(repo_params.slice(:label, :name, :description, :url, :content_type, :arch, :unprotected,
                                                             :gpg_key, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key,
                                                             :checksum_type, :download_policy, :http_proxy_policy).to_h.with_indifferent_access)
       root.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
-      root.docker_tags_whitelist = repo_params.fetch(:docker_tags_whitelist, []) if root.docker?
-      root.mirror_on_sync = ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync]) if repo_params.key?(:mirror_on_sync)
+      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
+      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)
+      root.mirroring_policy = repo_params[:mirroring_policy] || Katello::RootRepository::MIRRORING_POLICY_CONTENT
       root.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
       root.upstream_password = repo_params[:upstream_password] if repo_params.key?(:upstream_password)
       root.upstream_authentication_token = repo_params[:upstream_authentication_token] if repo_params.key?(:upstream_authentication_token)
@@ -575,7 +589,20 @@ module Katello
 
       root
     end
-    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/MethodLength
+
+    def handle_mirror_on_sync(repo_params)
+      if !repo_params.key?(:mirroring_policy) && repo_params.key?(:mirror_on_sync)
+        ::Foreman::Deprecation.api_deprecation_warning("mirror_on_sync is deprecated in favor of mirroring_policy.  It will be removed in Katello 4.6.")
+        if ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync])
+          repo_params[:mirroring_policy] = Katello::RootRepository::MIRRORING_POLICY_CONTENT
+        else
+          repo_params[:mirroring_policy] = Katello::RootRepository::MIRRORING_POLICY_ADDITIVE
+        end
+      end
+      repo_params.delete(:mirror_on_sync)
+      repo_params
+    end
 
     def error_on_rh_product
       fail HttpErrors::BadRequest, _("Red Hat products cannot be manipulated.") if @product.redhat?
@@ -633,7 +660,8 @@ module Katello
 
     def generic_remote_options_hash(repo_params)
       generic_remote_options = {}
-      RepositoryTypeManager.generic_remote_options(content_type: repo_params[:content_type]).each do |option|
+      content_type = @repository&.content_type || repo_params[:content_type]
+      RepositoryTypeManager.generic_remote_options(content_type: content_type).each do |option|
         generic_remote_options[option.name] = repo_params[option.name]
       end
       generic_remote_options
@@ -652,7 +680,7 @@ module Katello
     def check_import_parameters
       @repository.repository_type&.import_attributes&.each do |import_attribute|
         if import_attribute.required && params[import_attribute.api_param].blank?
-          fail HttpErrors::UnprocessableEntity, _("%s is required", import_attributes.api_param)
+          fail HttpErrors::UnprocessableEntity, _('%s is required') % import_attribute.api_param
         end
       end
     end

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

@@ -13,6 +13,7 @@ module Katello
     before_action :find_authorized_host, :only => [:index, :auto_complete_search]
     before_action :find_organization
     before_action :find_product_content, :except => [:index, :auto_complete_search]
+    before_action :check_airgapped, :only => [:index]
 
     resource_description do
       api_version "v2"
@@ -209,5 +210,11 @@ module Katello
         params[:host_id] ||= params[:id]
       end
     end
+
+    def check_airgapped
+      if @organization.cdn_configuration.airgapped?
+        respond_for_index(:collection => { :error => _("Repositories are not available for enablement while CDN configuration is set to Air-gapped (disconnected).") }, :status => :forbidden)
+      end
+    end
   end
 end

data/app/controllers/katello/concerns/api/v2/repository_content_controller.rb

@@ -130,6 +130,9 @@ module Katello
       end
 
       def filter_by_content_view_version(version, collection)
+        if params[:content_type]
+          return collection.where(:id => version.send(controller_name, params[:content_type]))
+        end
         collection.where(:id => version.send(controller_name))
       end
 

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

@@ -9,6 +9,8 @@ module Katello
           case params[:action]
           when 'content_hosts'
             'view'
+          when 'change_content_source'
+            'edit'
           else
             super
           end
@@ -68,6 +70,36 @@ module Katello
             end
           end
         end
+
+        def change_content_source_data
+          hosts = ::Host.where(id: params[:host_ids])
+          content_hosts_ids = []
+          hosts_without_content = []
+
+          hosts.each do |host|
+            if host.content_facet
+              content_hosts_ids << host.id
+            else
+              hosts_without_content << host.name
+            end
+          end
+
+          environments = KTEnvironment.readable.where(organization: Organization.current).includes([:organization, :env_priors, :priors]).order(:name)
+          content_sources = SmartProxy.authorized(:view_smart_proxies).with_content.includes([:smart_proxy_features])
+
+          if Katello.with_remote_execution?
+            template_id = JobTemplate.find_by(name: 'Change content source')&.id
+            job_invocation_path = new_job_invocation_path(template_id: template_id, host_ids: content_hosts_ids) if template_id
+          end
+
+          render json: {
+            content_hosts_ids: content_hosts_ids,
+            hosts_without_content: hosts_without_content,
+            environments: environments,
+            content_sources: content_sources,
+            job_invocation_path: job_invocation_path
+          }
+        end
       end
     end
   end

data/app/controllers/katello/remote_execution_controller.rb

@@ -47,11 +47,12 @@ module Katello
       end
 
       def inputs
-        if feature_name == 'katello_errata_install'
-          { "Errata Search Query" => "errata_id ^ (#{errata_inputs.join(',')})" }
-        elsif feature_name == 'katello_service_restart'
+        case feature_name
+        when 'katello_errata_install'
+          { :errata => errata_inputs }
+        when 'katello_service_restart'
           { :helper => params[:name] }
-        elsif feature_name == 'katello_module_stream_action'
+        when 'katello_module_stream_action'
           fail HttpErrors::NotFound, _('module streams not found') if params[:module_spec].blank?
           fail HttpErrors::NotFound, _('actions not found') if params[:module_stream_action].blank?
           inputs = { :module_spec => params[:module_spec], :action => params[:module_stream_action] }

data/app/graphql/types/host_collection.rb

@@ -0,0 +1,18 @@
+module Types
+  class HostCollection < BaseObject
+    description "A collection of hosts"
+    model_class ::Katello::HostCollection
+
+    global_id_field :id
+    timestamps
+    field :name, String
+    field :description, String
+    field :max_hosts, Integer
+    field :unlimited_hosts, Boolean
+    has_many :hosts, Types::Host
+
+    def self.graphql_definition
+      super.tap { |type| type.instance_variable_set(:@name, 'Katello::HostCollection') }
+    end
+  end
+end

data/app/helpers/katello/content_source_helper.rb

@@ -0,0 +1,43 @@
+module Katello
+  module ContentSourceHelper
+    def missing_content_source(host)
+      <<~CMD
+        echo "Host [#{host.name}] doesn't have an assigned content source!"
+        exit 1
+      CMD
+    end
+
+    def prepare_ssl_cert(ca_cert)
+      <<~CMD
+        # Prepare SSL certificate
+
+        KATELLO_SERVER_CA_CERT=/etc/rhsm/ca/katello-server-ca.pem
+        SSL_CA_CERT=$(mktemp)
+        cat << EOF > $SSL_CA_CERT
+        #{ca_cert}
+        EOF
+
+        mkdir -p /etc/rhsm/ca
+        cp -f $SSL_CA_CERT $KATELLO_SERVER_CA_CERT
+        chmod 644 $KATELLO_SERVER_CA_CERT
+
+      CMD
+    end
+
+    def configure_subman(content_source)
+      <<~CMD
+        # Configure subscription-manager
+        RHSM_CFG=/etc/rhsm/rhsm.conf
+
+        test -f $RHSM_CFG.bak || cp $RHSM_CFG $RHSM_CFG.bak
+
+        subscription-manager config \
+          --server.hostname="#{content_source.rhsm_url.host}" \
+          --server.port="#{content_source.rhsm_url.port}" \
+          --server.prefix="#{content_source.rhsm_url.path}" \
+          --rhsm.repo_ca_cert="$KATELLO_SERVER_CA_CERT" \
+          --rhsm.baseurl="#{content_source.pulp_content_url}"
+      CMD
+    end
+  end
+end

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -266,5 +266,9 @@ module Katello
         :priority => 900
       }]
     end
+
+    def hosts_change_content_source
+      [{ action: [_('Change Content Source'), '/change_host_content_source', false], priority: 100 }]
+    end
   end
 end