katello 4.3.0.rc2.1 → 4.4.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bef8f9a19283e1e922e5fd790b8cad66e87076521d03f8ee38a3b943d2c836db
-  data.tar.gz: f43be54d4e047f721872fc83ad6bf084412aa79e09d0b0fe615a5a857e653705
+  metadata.gz: 2cffead633d7427ab354f070ad520ef1436914690ae62a83707bd51f0ff94156
+  data.tar.gz: 759afa6d6768f23db062327899cd38db646b99c59d5068027dcf4bdc74f47896
 SHA512:
-  metadata.gz: 7a9be75ea348924a76d51e354203f184a6079173c29bf9273310beee15c7a4f5f677cda11740321abad79d39df25f63d427dd218173ff818263d2ffdc5132126
-  data.tar.gz: 61e8e11e80f1f8c7a5e3a4376777213fc0ce186da26971fdbc180bdd12e01cd3fcb6d188402eade222c157bd2321b8227c7ef1a2f66bfee79b745c280f824d07
+  metadata.gz: f4d6669e6c29532fe48cb70fd014bc0fb0fd9e7ddfb29a3832e175134be2ecb40b2dbcedd458cef5303805680e28ec3d17a3ea9f250a3482403490c7dd22b3d1
+  data.tar.gz: 458b225423b94a7cfb95034ee9bbff4d0fceca0effcf2dfd2651bb98bf535cadc681791ccbbaca19175cd17446fffab9b1190140f07973e8b220c28239aaf398

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/capsule_content_controller.rb

@@ -4,7 +4,7 @@ module Katello
       api_base_url "/katello/api"
     end
 
-    before_action :find_capsule, :except => [:sync, :cancel_sync, :add_lifecycle_environment, :remove_lifecycle_environment]
+    before_action :find_capsule, :except => [:sync, :cancel_sync, :add_lifecycle_environment, :remove_lifecycle_environment, :reclaim_space]
     before_action :find_editable_capsule, :only => [:sync, :cancel_sync, :add_lifecycle_environment, :remove_lifecycle_environment]
     before_action :find_environment, :only => [:add_lifecycle_environment, :remove_lifecycle_environment]
     before_action :find_optional_organization, :only => [:sync_status]
@@ -86,6 +86,14 @@ module Katello
       end
     end
 
+    api :POST, '/capsules/:id/reclaim_space', N_('Reclaim space from all On Demand repositories on a smart proxy')
+    param :id, :number, :required => true, :desc => N_('Id of the smart proxy')
+    def reclaim_space
+      find_capsule(true)
+      task = async_task(::Actions::Pulp3::CapsuleContent::ReclaimSpace, @capsule)
+      respond_for_async :resource => task
+    end
+
     protected
 
     def respond_for_lifecycle_environments_index(environments)
@@ -104,9 +112,9 @@ module Katello
       end
     end
 
-    def find_capsule
+    def find_capsule(primary_okay = false)
       @capsule = SmartProxy.unscoped.authorized(:view_capsule_content).find(params[:id])
-      unless @capsule&.pulp_mirror?
+      unless @capsule&.pulp_mirror? || primary_okay
         fail _("This request may only be performed on a Smart proxy that has the Pulpcore feature with mirror=true.")
       end
     end

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

@@ -10,7 +10,7 @@ module Katello
     param :repository_id, :number, :required => true, :desc => N_("repository id")
     param :size, :number, :required => true, :desc => N_("Size of file to upload")
     param :checksum, String, :required => false, :desc => N_("Checksum of file to upload")
-    param :content_type, RepositoryTypeManager.uploadable_content_types(false).map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree', 'rpm', 'srpm')")
+    param :content_type, RepositoryTypeManager.uploadable_content_types(false).map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree_ref', 'rpm', 'srpm')")
     def create
       fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Ansible collections.") if @repository.ansible_collection?
       content_type = params[:content_type] || ::Katello::RepositoryTypeManager.find(@repository.content_type)&.default_managed_content_type&.label

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/generic_content_units_controller.rb

@@ -1,10 +1,15 @@
 module Katello
   class Api::V2::GenericContentUnitsController < Api::V2::ApiController
+    resource_description do
+      name 'Content Units'
+      param :content_type, String, desc: N_("Possible values: #{Katello::RepositoryTypeManager.generic_content_types.join(", ")}"), required: true
+    end
+    apipie_concern_subst(:a_resource => N_("a content unit"), :resource_id => "content_units")
+
     Katello::RepositoryTypeManager.generic_content_types(false).each do |type|
-      apipie_concern_subst(:a_resource => N_(type), :resource_id => type.pluralize)
-      resource_description do
-        name type.pluralize.titleize
-      end
+      api :GET, "/#{type.pluralize}", N_("List %s" % type.pluralize)
+      api :GET, "/#{type.pluralize}/:id", N_("Show %s" % type.gsub(/_/, ' '))
+      api :GET, "/repositories/:repository_id/#{type.pluralize}/:id", N_("Show %s" % type.gsub(/_/, ' '))
     end
 
     include Katello::Concerns::Api::V2::RepositoryContentController
@@ -14,6 +19,7 @@ module Katello
     end
 
     def resource_class
+      fail "Required param content_type is missing" unless params[:content_type]
       ::Katello::GenericContentUnit.where(content_type: params[:content_type].singularize)
     end
 

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

@@ -50,6 +50,14 @@ module Katello
       end
     end
 
+    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)
+
+      respond_for_async :resource => task
+    end
+
     private
 
     def find_repositories

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
 
@@ -23,7 +23,7 @@ module Katello
     before_action :find_unauthorized_katello_resource, :only => [:gpg_key_content]
     before_action :find_authorized_katello_resource, :only => [:show, :update, :destroy, :sync,
                                                                :remove_content, :upload_content, :republish,
-                                                               :import_uploads, :verify_checksum]
+                                                               :import_uploads, :verify_checksum, :reclaim_space]
     before_action :find_content, :only => :remove_content
     before_action :find_organization_from_repo, :only => [:update]
     before_action :error_on_rh_product, :only => [:create]
@@ -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")
@@ -234,6 +237,10 @@ module Katello
         fail HttpErrors::UnprocessableEntity, msg
       end
 
+      if !repo_params[:url].nil? && URI(repo_params[:url]).userinfo
+        fail "Do not include the username/password in the URL. Use the username/password settings instead."
+      end
+
       gpg_key = get_content_credential(repo_params, CONTENT_CREDENTIAL_GPG_KEY_TYPE)
       ssl_ca_cert = get_content_credential(repo_params, CONTENT_CREDENTIAL_SSL_CA_CERT_TYPE)
       ssl_client_cert = get_content_credential(repo_params, CONTENT_CREDENTIAL_SSL_CLIENT_CERT_TYPE)
@@ -264,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.')
@@ -317,6 +324,15 @@ module Katello
       raise HttpErrors::BadRequest, e.message
     end
 
+    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
+      task = async_task(::Actions::Pulp3::Repository::ReclaimSpace, @repository)
+      respond_for_async :resource => task
+    rescue Errors::InvalidActionOptionError => e
+      raise HttpErrors::BadRequest, e.message
+    end
+
     api :PUT, "/repositories/:id", N_("Update a repository")
     param :id, :number, :required => true, :desc => N_("repository ID")
     param :name, String, :required => false
@@ -324,6 +340,9 @@ module Katello
     param_group :repo
     def update
       repo_params = repository_params
+      if !repo_params[:url].nil? && URI(repo_params[:url]).userinfo
+        fail "Do not include the username/password in the URL. Use the username/password settings instead."
+      end
 
       if @repository.generic?
         generic_remote_options = generic_remote_options_hash(repo_params)
@@ -421,10 +440,16 @@ module Katello
       end
 
       begin
+        upload_args = {
+          content_type: params[:content_type],
+          generate_metadata: generate_metadata,
+          sync_capsule: sync_capsule
+        }
+        upload_args.merge!(generic_content_type_import_upload_args)
+
         respond_for_async(resource: send(
           async ? :async_task : :sync_task,
-          ::Actions::Katello::Repository::ImportUpload, @repository, uploads,
-          generate_metadata: generate_metadata, sync_capsule: sync_capsule, content_type: params[:content_type]))
+          ::Actions::Katello::Repository::ImportUpload, @repository, uploads, upload_args))
       rescue => e
         raise HttpErrors::BadRequest, e.message
       end
@@ -479,12 +504,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"
 
@@ -503,7 +528,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)
@@ -516,15 +542,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)
@@ -553,7 +586,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?
@@ -611,16 +657,27 @@ 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
     end
 
+    def generic_content_type_import_upload_args
+      args = {}
+      @repository.repository_type&.import_attributes&.collect do |import_attribute|
+        if params[import_attribute.api_param]
+          args[import_attribute.api_param] = params[import_attribute.api_param]
+        end
+      end
+      args
+    end
+
     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/registration_controller_extensions.rb

@@ -28,7 +28,7 @@ module Katello
       end
 
       def context_urls
-        super.merge(rhsm_url: rhsm_url, pulp_content_url: pulp_content_url)
+        super.merge(rhsm_url: smart_proxy.rhsm_url, pulp_content_url: smart_proxy.pulp_content_url)
       end
 
       private
@@ -43,14 +43,6 @@ module Katello
           proxy
         end
       end
-
-      def rhsm_url
-        URI(smart_proxy.rhsm_url)
-      end
-
-      def pulp_content_url
-        smart_proxy.setting(SmartProxy::PULP3_FEATURE, 'content_app_url')
-      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