katello 4.1.3 → 4.2.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1adb0b8312ecc97c2044f94caff1265923f1cc909ff71a67cb95303c55658c11
-  data.tar.gz: 9a0584aad43b18d1ce26d9cd5fde0709e7b34233e005fd5fff046960a4674693
+  metadata.gz: 8aa0f375342de9345f09a8a5b1cd5d7ab68af3282a4b8863cf9b63c33130fbcd
+  data.tar.gz: 871e47ae53fdd69760c042278b9feb68a1b0d81599db67cfae9ee375a270034e
 SHA512:
-  metadata.gz: 4a887f66325269c29a3d1413184172d357ea097031fffad680789ebbb6c5d044eeb01b053e6e570cd8eb4d8528132ee8739d2b3224b14c73b412c19389d7f144
-  data.tar.gz: b54b6cfd02c914f976b38c6b5ad586192ffb7cf146957b8b1a09626560d046ecb4683760a7c90a72cb58558a3333fe972415c401f1afb06fd4bc96414aa9a536
+  metadata.gz: 11757b1ba7c279ca6a6b70760996c8e81d0be8fc935ba0da3dd531beb69d00a4dadd9b113a7dd8f036ecd9d035c71a7f8ce2a5bebf4e53e8f0d9b80cccef4b92
+  data.tar.gz: 4c9337e95fda3f0e010f9fc11c3e838f15aea5f10fae1dd17312ea067c2bb20d5f5d2b05c36fee9ce274c3916db2c866d10e321c7b9a278eb2c8543983a7e3b4

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

@@ -48,7 +48,8 @@ module Katello
     end
 
     rescue_from RestClient::Exception do |e|
-      Rails.logger.error pp_exception(e)
+      Rails.logger.error(pp_exception(e, with_backtrace: false))
+      Rails.logger.error(e.backtrace.detect { |line| line.match("katello.*controller") })
       if request_from_katello_cli?
         render :json => { :errors => [e.http_body] }, :status => e.http_code
       else
@@ -295,7 +296,6 @@ module Katello
       if facet.nil?
         # check with candlepin if consumer is Gone, raises RestClient::Gone
         User.as_anonymous_admin { Resources::Candlepin::Consumer.get(uuid) }
-        fail HttpErrors::NotFound, _("Couldn't find consumer '%s'") % uuid
       end
       @host = ::Host::Managed.unscoped.find(facet.host_id)
     end

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

@@ -6,7 +6,7 @@ module Katello
     skip_before_action :check_media_type, :only => [:create, :content, :set_content]
 
     def resource_class
-      Katello::GpgKey
+      Katello::ContentCredential
     end
 
     def_param_group :content_credential do
@@ -35,7 +35,7 @@ module Katello
     end
 
     def index_relation
-      query = GpgKey.readable.where(:organization_id => @organization.id)
+      query = ContentCredential.readable.where(:organization_id => @organization.id)
       query = query.where(:name => params[:name]) if params[:name]
       query = query.where(:content_type => params[:content_type]) if params[:content_type]
       query
@@ -68,7 +68,7 @@ module Katello
     param :id, :number, :desc => N_('Content Credential ID'), :required => true
     param_group :content_credential
     def update
-      sync_task(::Actions::Katello::GpgKey::Update, @content_credential, content_credential_params.to_h)
+      sync_task(::Actions::Katello::ContentCredential::Update, @content_credential, content_credential_params.to_h)
       respond_for_show(:resource => @content_credential)
     end
 

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

@@ -10,9 +10,11 @@ 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.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', 'rpm', 'srpm')")
     def create
       content_type = params[:content_type] || ::Katello::RepositoryTypeManager.find(@repository.content_type).default_managed_content_type.label
+      RepositoryTypeManager.check_content_matches_repo_type!(@repository, content_type)
+
       unit_type_id = SmartProxy.pulp_primary.content_service(content_type).content_type
       render :json => @repository.backend_content_service(::SmartProxy.pulp_primary).create_upload(params[:size], params[:checksum], unit_type_id)
     end

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

@@ -1,9 +1,10 @@
 module Katello
   class Api::V2::ContentViewComponentsController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
-    before_action :find_composite_content_view, :only => [:show, :index]
+    before_action :find_composite_content_view, :only => [:show, :index, :show_all]
     before_action :find_composite_content_view_for_edit, :only => [:add_components, :remove_components, :update]
     before_action :find_authorized_katello_resource, :only => [:show, :update]
+    before_action :find_organization_from_cv, :only => [:show_all]
 
     wrap_parameters :include => %w(composite_content_view_id content_view_version_id content_view_id latest)
 
@@ -28,6 +29,33 @@ module Katello
       }
     end
 
+    # content_views/:id/components/show_all
+    # Shows all content views, added and available to add, for a content view
+    # Undocumented endpoint since the functionality exists in separate calls already.
+    # This was created for ease of pagination and search for the UI
+    # param :id, :number, desc: N_("Content View id"), required: true
+    # param :status, ["Added", "Not added", "All"], :desc => N_("Filter to show added, not added or all components")
+    def show_all
+      kc = Katello::ContentView.table_name
+      kcc = Katello::ContentViewComponent.table_name
+      join_query = <<-SQL
+         LEFT OUTER JOIN #{kcc}
+         ON #{kc}.id = #{kcc}.content_view_id
+         AND #{kcc}.composite_content_view_id = #{@view.id}
+      SQL
+      order_query = <<-SQL
+         CAST (#{kcc}.composite_content_view_id as BOOLEAN) ASC, #{kc}.name
+      SQL
+
+      query = Katello::ContentView.readable.in_organization(@organization)
+      query = query&.non_composite&.non_default
+      custom_sort = ->(sort_query) { sort_query.joins(join_query).order(order_query) }
+      options = { resource_class: Katello::ContentView, custom_sort: custom_sort }
+      collection = scoped_search(query, nil, nil, options)
+      collection[:results] = ComponentViewPresenter.component_presenter(@view, params[:status], views: collection[:results])
+      respond_for_index(:collection => collection, :template => "index")
+    end
+
     api :PUT, "/content_views/:composite_content_view_id/content_view_components/add",
                                         N_("Add components to the content view")
     param :composite_content_view_id, :number, :desc => N_("composite content view identifier"), :required => true
@@ -135,5 +163,9 @@ module Katello
         fail "Unsupported default_sort type"
       end
     end
+
+    def find_organization_from_cv
+      @organization = @view.organization
+    end
   end
 end

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

@@ -90,6 +90,8 @@ module Katello
     param :description, String, :desc => N_("Description for the new published content view version")
     param :major, :number, :desc => N_("Override the major version number"), :required => false
     param :minor, :number, :desc => N_("Override the minor version number"), :required => false
+    param :environment_ids, Array, :desc => N_("Identifiers for Lifecycle Environment"), :required => false
+    param :is_force_promote, :bool, :desc => N_("force content view promotion and bypass lifecycle environment restriction"), :required => false
     param :repos_units, Array, :desc => N_("Specify the list of units in each repo"), :required => false do
       param :label, String, :desc => N_("repo label"), :required => true
       param :rpm_filenames, Array, of: String, :desc => N_("list of rpm filename strings to include in published version"), :required => true
@@ -108,6 +110,8 @@ module Katello
       end
 
       task = async_task(::Actions::Katello::ContentView::Publish, @content_view, params[:description],
+                        :environment_ids => params[:environment_ids],
+                        :is_force_promote => params[:is_force_promote],
                         :major => params[:major],
                         :minor => params[:minor],
                         :repos_units => params[:repos_units])
@@ -164,6 +168,14 @@ module Katello
       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
+    def remove_filters
+      Katello::ContentViewFilter.where(id: params[:filter_ids]).try(:destroy_all)
+      respond_for_show(:resource => @content_view)
+    end
+
     api :DELETE, "/content_views/:id", N_("Delete a content view")
     param :id, :number, :desc => N_("content view numeric identifier"), :required => true
     def destroy

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

@@ -53,7 +53,7 @@ module Katello
 
     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: false, deprecated: 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
     def apply

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

@@ -53,8 +53,7 @@ module Katello
     param :ids, Array, :desc => N_("List of product ids"), :required => true
     def verify_checksum_products
       repairable_products = @products.syncable
-      repairable_roots = RootRepository.where(:product_id => repairable_products).
-        where(:content_type => ::Katello::Repository::YUM_TYPE).has_url.select { |r| r.library_instance }.uniq
+      repairable_roots = RootRepository.where(:product_id => repairable_products).has_url.select { |r| r.library_instance }.uniq
 
       repairable_repositories = Katello::Repository.where(:root_id => repairable_roots)
       task = async_task(::Actions::BulkAction,

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

@@ -150,7 +150,7 @@ module Katello
     def authorize_gpg_key
       gpg_key_id = product_params[:gpg_key_id]
       if gpg_key_id
-        gpg_key = GpgKey.readable.where(:id => gpg_key_id, :organization_id => @organization).first
+        gpg_key = ContentCredential.readable.where(:id => gpg_key_id, :organization_id => @organization).first
         throw_resource_not_found(name: 'gpg key', id: gpg_key_id) if gpg_key.nil?
       end
     end
@@ -158,7 +158,7 @@ module Katello
     def authorize_ssl_ca_cert
       ssl_ca_cert_id = product_params[:ssl_ca_cert_id]
       if ssl_ca_cert_id
-        ssl_ca_cert = GpgKey.readable.where(:id => ssl_ca_cert_id, :organization_id => @organization).first
+        ssl_ca_cert = ContentCredential.readable.where(:id => ssl_ca_cert_id, :organization_id => @organization).first
         throw_resource_not_found(name: 'ssl ca cert', id: ssl_ca_cert_id) if ssl_ca_cert.nil?
       end
     end
@@ -166,7 +166,7 @@ module Katello
     def authorize_ssl_client_cert
       ssl_client_cert_id = product_params[:ssl_client_cert_id]
       if ssl_client_cert_id
-        ssl_client_cert = GpgKey.readable.where(:id => ssl_client_cert_id, :organization_id => @organization).first
+        ssl_client_cert = ContentCredential.readable.where(:id => ssl_client_cert_id, :organization_id => @organization).first
         throw_resource_not_found(name: 'ssl client cert', id: ssl_client_cert_id) if ssl_client_cert.nil?
       end
     end
@@ -174,7 +174,7 @@ module Katello
     def authorize_ssl_client_key
       ssl_client_key_id = product_params[:ssl_client_key_id]
       if ssl_client_key_id
-        ssl_client_key = GpgKey.readable.where(:id => ssl_client_key_id, :organization_id => @organization).first
+        ssl_client_key = ContentCredential.readable.where(:id => ssl_client_key_id, :organization_id => @organization).first
         throw_resource_not_found(name: 'ssl client key', id: ssl_client_key_id) if ssl_client_key.nil?
       end
     end

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

@@ -7,7 +7,6 @@ module Katello
     def destroy_repositories
       deletion_authorized_repositories = @repositories.deletable
       unpromoted_repos = deletion_authorized_repositories.reject { |repo| repo.promoted? }
-      deletable_repositories = unpromoted_repos.reject { |repo| repo.redhat? }
 
       messages1 = format_bulk_action_messages(
           :success    => "",
@@ -23,18 +22,11 @@ module Katello
           :authorized => unpromoted_repos
       )
 
-      messages3 = format_bulk_action_messages(
-          :success    => "",
-          :error      => _("Repository %s cannot be deleted since they are Red Hat repositories."),
-          :models     => unpromoted_repos,
-          :authorized => deletable_repositories
-      )
-
-      errors = messages3[:error] + messages1[:error] + messages2[:error]
+      errors = messages1[:error] + messages2[:error]
 
       task = nil
-      if deletable_repositories.count > 0
-        task = async_task(::Actions::BulkAction, ::Actions::Katello::Repository::Destroy, deletable_repositories)
+      if unpromoted_repos.any?
+        task = async_task(::Actions::BulkAction, ::Actions::Katello::Repository::Destroy, unpromoted_repos)
       else
         status = 400
       end

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

@@ -2,7 +2,14 @@ module Katello
   class Api::V2::RepositoriesController < Api::V2::ApiController # rubocop:disable Metrics/ClassLength
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    wrap_parameters :repository, :include => RootRepository.attribute_names.concat([:ignore_global_proxy])
+    generic_repo_wrap_params = []
+    RepositoryTypeManager.generic_remote_options(defined_only: true).each do |option|
+      generic_repo_wrap_params << option.name
+    end
+
+    repo_wrap_params = RootRepository.attribute_names.concat([:ignore_global_proxy]) + generic_repo_wrap_params
+
+    wrap_parameters :repository, :include => repo_wrap_params
 
     CONTENT_CREDENTIAL_GPG_KEY_TYPE = "gpg_key".freeze
     CONTENT_CREDENTIAL_SSL_CA_CERT_TYPE = "ssl_ca_cert".freeze
@@ -14,13 +21,12 @@ module Katello
     before_action :find_product_for_create, :only => [:create]
     before_action :find_organization_from_product, :only => [:create]
     before_action :find_unauthorized_katello_resource, :only => [:gpg_key_content]
-    before_action :find_authorized_katello_resource, :only => [:show, :update, :destroy, :sync, :export,
+    before_action :find_authorized_katello_resource, :only => [:show, :update, :destroy, :sync,
                                                                :remove_content, :upload_content, :republish,
                                                                :import_uploads, :verify_checksum]
     before_action :find_content, :only => :remove_content
     before_action :find_organization_from_repo, :only => [:update]
     before_action :error_on_rh_product, :only => [:create]
-    before_action :error_on_rh_repo, :only => [:destroy]
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_GPG_KEY_TYPE }
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CA_CERT_TYPE }
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CLIENT_CERT_TYPE }
@@ -62,12 +68,17 @@ module Katello
       param :http_proxy_policy, ::Katello::RootRepository::HTTP_PROXY_POLICIES, :desc => N_("policies for HTTP proxy for content sync")
       param :http_proxy_id, :number, :desc => N_("ID of a HTTP Proxy")
       param :arch, String, :desc => N_("Architecture of content in the repository")
+      param :retain_package_versions_count, :number, :desc => N_("The maximum number of versions of each package to keep.")
+
+      RepositoryTypeManager.generic_remote_options(defined_only: true).each do |option|
+        param option.name, option.type, :desc => N_(option.description)
+      end
     end
 
     def_param_group :repo_create do
       param :label, String, :required => false
       param :product_id, :number, :required => true, :desc => N_("Product the repository belongs to")
-      param :content_type, RepositoryTypeManager.creatable_repository_types.keys, :required => true, :desc => N_("type of repo")
+      param :content_type, RepositoryTypeManager.creatable_repository_types(false).keys, :required => true, :desc => N_("type of repo")
     end
 
     api :GET, "/repositories", N_("List of enabled repositories")
@@ -89,13 +100,13 @@ module Katello
     param :ostree_branch_id, String, :desc => N_("Id of an ostree branch to find repositories that contain that branch")
     param :library, :bool, :desc => N_("show repositories in Library and the default content view")
     param :archived, :bool, :desc => N_("show archived repositories")
-    param :content_type, RepositoryTypeManager.repository_types.keys, :desc => N_("limit to only repositories of this type")
+    param :content_type, RepositoryTypeManager.defined_repository_types.keys, :desc => N_("limit to only repositories of this type")
     param :name, String, :desc => N_("name of the repository"), :required => false
     param :label, String, :desc => N_("label of the repository"), :required => false
     param :description, String, :desc => N_("description of the repository")
     param :available_for, String, :desc => N_("interpret specified object to return only Repositories that can be associated with specified object.  Only 'content_view' & 'content_view_version' are supported."),
           :required => false
-    param :with_content, RepositoryTypeManager.enabled_content_types, :desc => N_("only repositories having at least one of the specified content type ex: rpm , erratum")
+    param :with_content, RepositoryTypeManager.enabled_content_types(false), :desc => N_("only repositories having at least one of the specified content type ex: rpm , erratum")
     param :download_policy, ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES, :desc => N_("limit to only repositories with this download policy")
     param :username, String, :desc => N_("only show the repositories readable by this user with this username")
     param_group :search, Api::V2::ApiController
@@ -217,8 +228,9 @@ module Katello
     param_group :repo
     def create
       repo_params = repository_params
-      unless RepositoryTypeManager.creatable_by_user?(repo_params[:content_type])
-        msg = _("Invalid params provided - content_type must be one of %s") % RepositoryTypeManager.creatable_repository_types.keys.join(",")
+      unless RepositoryTypeManager.creatable_by_user?(repo_params[:content_type], false)
+        msg = _("Invalid params provided - content_type must be one of %s") %
+          RepositoryTypeManager.creatable_repository_types(false).keys.join(",")
         fail HttpErrors::UnprocessableEntity, msg
       end
 
@@ -246,7 +258,7 @@ module Katello
     param :creatable, :bool, :desc => N_("When set to 'True' repository types that are creatable will be returned")
     def repository_types
       creatable = ::Foreman::Cast.to_bool(params[:creatable])
-      repo_types = creatable ? RepositoryTypeManager.creatable_repository_types : RepositoryTypeManager.repository_types
+      repo_types = creatable ? RepositoryTypeManager.creatable_repository_types : RepositoryTypeManager.enabled_repository_types
       render :json => repo_types.values
     end
 
@@ -301,36 +313,6 @@ module Katello
       raise HttpErrors::BadRequest, e.message
     end
 
-    api :POST, "/repositories/:id/export", N_("Export a repository")
-    param :id, :number, :desc => N_("Repository identifier"), :required => true
-    param :export_to_iso, :bool, :desc => N_("Export to ISO format"), :required => false
-    param :iso_mb_size, :number, :desc => N_("maximum size of each ISO in MB"), :required => false
-    param :since, Date, :desc => N_("Optional date of last export (ex: 2010-01-01T12:00:00Z)"), :required => false
-    def export
-      if params[:export_to_iso].blank? && params[:iso_mb_size].present?
-        fail HttpErrors::BadRequest, _("ISO export must be enabled when specifying ISO size")
-      end
-
-      if params[:since].present?
-        begin
-          params[:since].to_datetime
-        rescue
-          raise HttpErrors::BadRequest, _("Invalid date provided.")
-        end
-      end
-
-      fail HttpErrors::BadRequest, _("Repository content type must be 'yum' to export.") unless @repository.content_type == 'yum'
-
-      fail HttpErrors::BadRequest, _("On demand repositories cannot be exported.") if @repository.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
-
-      task = async_task(::Actions::Katello::Repository::Export, [@repository],
-                        ::Foreman::Cast.to_bool(params[:export_to_iso]),
-                        params[:since].try(:to_datetime),
-                        params[:iso_mb_size],
-                        @repository.pulp_id)
-      respond_for_async :resource => task
-    end
-
     api :PUT, "/repositories/:id", N_("Update a repository")
     param :id, :number, :required => true, :desc => N_("repository ID")
     param :name, String, :required => false
@@ -339,6 +321,14 @@ module Katello
     def update
       repo_params = repository_params
 
+      if @repository.generic?
+        generic_remote_options = generic_remote_options_hash(repo_params)
+        repo_params[:generic_remote_options] = generic_remote_options.to_json
+        RepositoryTypeManager.generic_remote_options.each do |option|
+          repo_params&.delete(option.name)
+        end
+      end
+
       sync_task(::Actions::Katello::Repository::Update, @repository.root, repo_params)
       respond_for_show(:resource => @repository)
     end
@@ -356,7 +346,7 @@ module Katello
     desc "Remove content from a repository"
     param :id, :number, :required => true, :desc => "repository ID"
     param 'ids', Array, :required => true, :desc => "Array of content ids to remove"
-    param :content_type, RepositoryTypeManager.removable_content_types.map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree', 'rpm', 'srpm')")
+    param :content_type, RepositoryTypeManager.removable_content_types(false).map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree', 'rpm', 'srpm')")
     param 'sync_capsule', :bool, :desc => N_("Whether or not to sync an external capsule after upload. Default: true")
     def remove_content
       sync_capsule = ::Foreman::Cast.to_bool(params.fetch(:sync_capsule, true))
@@ -367,7 +357,7 @@ module Katello
     api :POST, "/repositories/:id/upload_content", N_("Upload content into the repository")
     param :id, :number, :required => true, :desc => N_("repository ID")
     param :content, File, :required => true, :desc => N_("Content files to upload. Can be a single file or array of files.")
-    param :content_type, RepositoryTypeManager.uploadable_content_types.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', 'rpm', 'srpm')")
     def upload_content
       fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Container Image content.") if @repository.docker?
 
@@ -396,7 +386,7 @@ module Katello
     param :async, :bool, desc: N_("Do not wait for the ImportUpload action to finish. Default: false")
     param 'publish_repository', :bool, :desc => N_("Whether or not to regenerate the repository on disk. Default: true")
     param 'sync_capsule', :bool, :desc => N_("Whether or not to sync an external capsule after upload. Default: true")
-    param :content_type, RepositoryTypeManager.uploadable_content_types.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', 'rpm', 'srpm')")
     param :uploads, Array, :desc => N_("Array of uploads to import") do
       param 'id', String, :required => true
       param 'content_unit_id', String
@@ -461,7 +451,7 @@ module Katello
       credential_var = "@#{content_type}"
 
       if params[credential_id]
-        credential_value = GpgKey.readable.where(:id => params[credential_id], :organization_id => @organization).first
+        credential_value = ContentCredential.readable.where(:id => params[credential_id], :organization_id => @organization).first
         instance_variable_set(credential_var, credential_value)
         if instance_variable_get(credential_var).nil?
           fail HttpErrors::NotFound, _("Couldn't find %{content_type} with id '%{id}'") % { :content_type => content_type, :id => params[credential_id] }
@@ -469,16 +459,29 @@ module Katello
       end
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity
     def repository_params
       keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password, :upstream_username, :download_concurrency,
               :ostree_upstream_sync_depth, :ostree_upstream_sync_policy, {:os_versions => []},
-              :deb_releases, :deb_components, :deb_architectures, :description, :http_proxy_policy, :http_proxy_id,
+              :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 += [: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"
+
+      if params[:action] == 'create' || @repository&.generic?
+        RepositoryTypeManager.generic_remote_options.each do |option|
+          if option.type == Array
+            keys += [{option.name => []}]
+          elsif option.type == Hash
+            keys += [{option.name => {}}]
+          else
+            keys += [option.name]
+          end
+        end
+      end
       if params[:action] == 'create' || @repository.custom?
         keys += [:url, :gpg_key_id, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id, :unprotected, :name,
                  :checksum_type]
@@ -496,8 +499,8 @@ module Katello
       credential_value
     end
 
-    # rubocop:disable Metrics/CyclomaticComplexity
     # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable 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,
@@ -512,6 +515,12 @@ module Katello
       root.http_proxy_policy = repo_params[:http_proxy_policy] if repo_params.key?(:http_proxy_policy)
       root.http_proxy_id = repo_params[:http_proxy_id] if repo_params.key?(:http_proxy_id)
       root.os_versions = repo_params.fetch(:os_versions, []) if root.yum?
+      root.retain_package_versions_count = repo_params[:retain_package_versions_count] if root.yum? && repo_params.key?(:retain_package_versions_count)
+
+      if root.generic?
+        generic_remote_options = generic_remote_options_hash(repo_params)
+        root.generic_remote_options = generic_remote_options.to_json
+      end
 
       if root.ostree?
         root.ostree_upstream_sync_policy = repo_params[:ostree_upstream_sync_policy]
@@ -550,11 +559,15 @@ module Katello
     end
 
     def find_content
-      if params[:content_type]
-        @content = @repository.units_for_removal(params[:ids], params[:content_type])
+      content_type = params[:content_type]
+
+      if content_type
+        @content = @repository.units_for_removal(params[:ids], content_type)
       else
         @content = @repository.units_for_removal(params[:ids])
       end
+
+      RepositoryTypeManager.check_content_matches_repo_type!(@repository, @content.first.class::CONTENT_TYPE)
     end
 
     def filter_by_content_view(query, content_view_id, environment_id, is_available_for)
@@ -573,5 +586,13 @@ module Katello
       end
       query
     end
+
+    def generic_remote_options_hash(repo_params)
+      generic_remote_options = {}
+      RepositoryTypeManager.generic_remote_options(content_type: repo_params[:content_type]).each do |option|
+        generic_remote_options[option.name] = repo_params[option.name]
+      end
+      generic_remote_options
+    end
   end
 end

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

@@ -2,7 +2,6 @@ module Katello
   class Api::V2::UpstreamSubscriptionsController < Api::V2::ApiController
     before_action :find_organization
     before_action :check_upstream_connection
-    before_action :deprecated, only: [:simple_content_access_eligible, :enable_simple_content_access, :disable_simple_content_access]
     resource_description do
       description "Red Hat subscriptions management platform."
       api_version 'v2'
@@ -77,29 +76,6 @@ module Katello
       render json: { status: 'OK' }
     end
 
-    api :GET, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/eligible",
-      N_("Check if the specified organization is eligible for Simple Content Access"), :deprecated => true
-    def simple_content_access_eligible
-      eligible = @organization.upstream_consumer.simple_content_access_eligible?
-      render json: { simple_content_access_eligible: eligible }
-    end
-
-    api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/enable",
-      N_("Enable simple content access for a manifest"), :deprecated => true
-    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
-    def enable_simple_content_access
-      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id])
-      respond_for_async :resource => task
-    end
-
-    api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/disable",
-      N_("Disable simple content access for a manifest"), :deprecated => true
-    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
-    def disable_simple_content_access
-      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:organization_id])
-      respond_for_async :resource => task
-    end
-
     private
 
     def update_params
@@ -124,9 +100,5 @@ module Katello
         { "pool" => pool[:id], "quantity" => pool[:quantity] } if pool
       end
     end
-
-    def deprecated
-      ::Foreman::Deprecation.api_deprecation_warning("This will be removed in Katello 4.2, Please see /api/v2/simple_content_access")
-    end
   end
 end

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

@@ -17,9 +17,8 @@ module Katello
           args
         end
 
-        def append_array_of_ids(hash_params)
-          return if registration_params['activation_key'].present? || registration_params['activation_keys'].present?
-          super
+        def append_array_of_ids(*)
+          return
         end
       end
 
@@ -28,8 +27,8 @@ module Katello
 
         update_api(:create) do
           param :registration_command, Hash do
-            param :activation_key, String, desc: N_('Activation key for subscription-manager client. Required for CentOS and Red Hat Enterprise Linux. Multiple keys add separated by comma, example: key1,key2,key3.'), deprecated: true
-            param :activation_keys, Array, required: true, desc: N_('Activation key(s) for subscription-manager client. Required for CentOS and Red Hat Enterprise Linux. Required only if host group has no activation keys')
+            param :activation_key, String, desc: N_('Activation key for subscription-manager client, required for CentOS and Red Hat Enterprise Linux. For multiple keys use `activation_keys` param instead.'), deprecated: true
+            param :activation_keys, Array, desc: N_('Activation keys for subscription-manager client, required for CentOS and Red Hat Enterprise Linux. Required only if host group has no activation keys.')
             param :lifecycle_environment_id, :number, required: false, desc: N_('Lifecycle environment for the host.')
             param :force, :bool, required: false, desc: N_('Clear any previous registration and run subscription-manager with --force.')
             param :ignore_subman_errors, :bool, required: false, desc: N_('Ignore subscription-manager errors for `subscription-manager register` command')
@@ -40,6 +39,28 @@ module Katello
       included do
         prepend Overrides
         include ApiPieExtensions
+
+        before_action :check_activation_keys, only: [:create]
+      end
+
+      private
+
+      def check_activation_keys
+        return if params['registration_command']['activation_key'].present? ||
+                  params['registration_command']['activation_keys'].present? ||
+                  hostgroup_have_acks?
+
+        render_error 'custom_error', status: :unprocessable_entity,
+                                     locals: { message: N_('Missing activation key!') }
+      end
+
+      def hostgroup_have_acks?
+        return unless params['registration_command']['hostgroup_id']
+
+        ::Hostgroup.authorized(:view_hostgroups)
+                   .find(params['registration_command']['hostgroup_id'])
+                   .params['kt_activation_keys']
+                   .present?
       end
     end
   end

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

@@ -7,7 +7,7 @@ module Katello
         if params['uuid']
           @host = Katello::Host::SubscriptionFacet.find_by(uuid: params['uuid'])&.host
           if @host.nil?
-            msg = N_("Host was not found by the subscription UUID: '%s', this can happen if the host is registered already, but not to this Foreman") % params['uuid']
+            msg = _("Host was not found by the subscription UUID: '%s', this can happen if the host is registered already, but not to this instance") % params['uuid']
             fail ActiveRecord::RecordNotFound, msg
           end
           @host.assign_attributes(host_params('host'))
@@ -26,6 +26,31 @@ module Katello
 
         super
       end
+
+      def context_urls
+        super.merge(rhsm_url: rhsm_url, pulp_content_url: pulp_content_url)
+      end
+
+      private
+
+      def smart_proxy
+        @smart_proxy ||= begin
+          proxy = params[:url] ? SmartProxy.find_by(url: params[:url]) : SmartProxy.pulp_primary
+
+          fail Foreman::Exception, _('Smart proxy content source not found!') unless proxy
+          fail Foreman::Exception, _('Pulp 3 is not enabled on Smart proxy!') unless proxy.pulp3_enabled?
+
+          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