katello 4.1.2 → 4.2.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1df4c90d3b97976268e14d23a3a58a006ef9659059f029f4c5eff51099dca23
-  data.tar.gz: 228835f2dff702bcef05b93738aca3248e94e03d7f1f8874eabf7648964f7d3f
+  metadata.gz: '0888b27382889ee155584abcf025ee49161afc59cd18d578a7fd517d5a50dae5'
+  data.tar.gz: 5e488c438f3a561d2b76eaf6d657842ec117efb95d887af8f7dfa040d265e5ae
 SHA512:
-  metadata.gz: 73cff67750374c2235cbe78cfe11a3a0d8d1f86982d05bba2288eda2a416ff622466d089ea3a3633fa59b3cad27a28dfaf022c917e0809ebfdf741580d2199da
-  data.tar.gz: b5478182ea63c8a1c0386c9952c40481bea38a549b7e93c7566016a39a08c43f7ac495a175d473ee9cf39fb85279725949326a1f8179dc20edfe05d195883d7a
+  metadata.gz: 7572571d4da028a2c7d8f1822632b1629a274ad6f0f21746f345f994ae60d04c4e5f8e22f3f2c848df6c809ba497d49487ccd491b4748ca31978926ee8ec9e9f
+  data.tar.gz: 6ef52bd64650d97097a29590bd8602045ec9e0c72978047be9e5f998bff112314f6be1028dc06f977682daea13ca1d270c4d0d13587e56dbabba8f5ea3e66c08

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

@@ -15,7 +15,16 @@ module Katello
     #param :id, String, :desc => N_("UUID of the consumer"), :required => true
     def upload_package_profile
       User.as_anonymous_admin do
-        async_task(::Actions::Katello::Host::UploadPackageProfile, @host, request.raw_post)
+        if Setting['upload_profiles_without_dynflow']
+          uploader = ::Katello::Host::PackageProfileUploader.new(
+            host: @host,
+            profile_string: request.raw_post
+          )
+          uploader.upload
+          uploader.trigger_applicability_generation
+        else
+          async_task(::Actions::Katello::Host::UploadPackageProfile, @host, request.raw_post)
+        end
       end
       render :json => Resources::Candlepin::Consumer.get(@host.subscription_facet.uuid)
     end
@@ -24,7 +33,16 @@ module Katello
     param :id, String, :desc => N_("UUID of the consumer"), :required => true
     def upload_profiles
       User.as_anonymous_admin do
-        async_task(::Actions::Katello::Host::UploadProfiles, @host, request.raw_post)
+        if Setting['upload_profiles_without_dynflow']
+          uploader = ::Katello::Host::ProfilesUploader.new(
+            host: @host,
+            profile_string: request.raw_post
+          )
+          uploader.upload
+          uploader.trigger_applicability_generation
+        else
+          async_task(::Actions::Katello::Host::UploadProfiles, @host, request.raw_post)
+        end
       end
       render :json => Resources::Candlepin::Consumer.get(@host.subscription_facet.uuid)
     end

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,12 @@ 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
+      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
+      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,9 +357,10 @@ 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?
+      fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Ansible collections.") if @repository.ansible_collection?
 
       filepaths = Array.wrap(params[:content]).compact.collect do |content|
         {path: content.path, filename: content.original_filename}
@@ -396,7 +387,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 +452,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 +460,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 +500,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 +516,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 +560,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 +587,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