katello 4.12.0 → 4.13.0.rc1

data/app/assets/javascripts/katello/sync_management/sync_management.js

@@ -333,6 +333,7 @@ KT.content_actions = (function () {
           updater.stop();
         }
       );
+      updater.restart();
     };
 
   return {

data/app/controllers/katello/api/registry/registry_proxies_controller.rb

@@ -4,14 +4,16 @@ module Katello
     before_action :disable_strong_params
     before_action :confirm_settings
     before_action :confirm_push_settings, only: [:start_upload_blob, :upload_blob, :finish_upload_blob,
-                                                 :chunk_upload_blob, :push_manifest]
+                                                 :push_manifest]
     skip_before_action :authorize
     before_action :optional_authorize, only: [:token, :catalog]
     before_action :registry_authorize, except: [:token, :v1_search, :catalog]
     before_action :authorize_repository_read, only: [:pull_manifest, :tags_list]
-    before_action :authorize_repository_write, only: [:push_manifest]
+    # TODO: authorize_repository_write commented out until Katello indexes Pulp container push repositories.
+    # before_action :authorize_repository_write, only: [:start_upload_blob, :upload_blob, :finish_upload_blob,
+    #                                                   :push_manifest]
     skip_before_action :check_media_type, only: [:start_upload_blob, :upload_blob, :finish_upload_blob,
-                                                 :chunk_upload_blob, :push_manifest]
+                                                 :push_manifest]
 
     wrap_parameters false
 
@@ -182,15 +184,8 @@ module Katello
     end
 
     def check_blob
-      begin
-        r = Resources::Registry::Proxy.get(@_request.fullpath, 'Accept' => request.headers['Accept'])
-        response.header['Content-Length'] = "#{r.body.size}"
-      rescue RestClient::NotFound
-        digest_file = tmp_file("#{params[:digest][7..-1]}.tar")
-        raise unless File.exist? digest_file
-        response.header['Content-Length'] = "#{File.size digest_file}"
-      end
-      render json: {}
+      pulp_response = Resources::Registry::Proxy.get(@_request.fullpath, 'Accept' => request.headers['Accept'])
+      head pulp_response.code
     end
 
     def redirect_client
@@ -210,94 +205,67 @@ module Katello
       redirect_client { Resources::Registry::Proxy.get(@_request.fullpath, headers, max_redirects: 0) }
     end
 
-    # FIXME: Reimplement for Pulp 3.
     def push_manifest
-      repository = params[:repository]
-      tag = params[:tag]
-
-      manifest = create_manifest
-      return if manifest.nil?
-
-      begin
-        files = get_manifest_files(repository, manifest)
-        return if files.nil?
-
-        tar_file = create_tar_file(files, repository, tag)
-        return if tar_file.nil?
-
-        digest = upload_manifest(tar_file)
-        return if digest.nil?
-
-        tag = upload_tag(digest, tag)
-        return if tag.nil?
-      ensure
-        File.delete(tmp_file('manifest.json')) if File.exist? tmp_file('manifest.json')
+      headers = translated_headers_for_proxy
+      headers['Content-Type'] = request.headers['Content-Type'] if request.headers['Content-Type']
+      body = @_request.body.read
+      pulp_response = Resources::Registry::Proxy.put(@_request.fullpath, body, headers)
+      pulp_response.headers.each do |key, value|
+        response.header[key.to_s] = value
       end
-
-      render json: {}
-    end
-
-    # FIXME: This is referring to a non-existent Pulp 2 server.
-    # Pulp 3 container push support is needed instead.
-    def pulp_content
-      Katello.pulp_server.resources.content
+      head pulp_response.code
     end
 
     def start_upload_blob
-      uuid = SecureRandom.hex(16)
-      response.header['Location'] = "#{request_url}/v2/#{params[:repository]}/blobs/uploads/#{uuid}"
-      response.header['Docker-Upload-UUID'] = uuid
-      response.header['Range'] = '0-0'
-      head 202
-    end
+      headers = translated_headers_for_proxy
+      headers['Content-Type'] = request.headers['Content-Type'] if request.headers['Content-Type']
+      headers['Content-Length'] = request.headers['Content-Length'] if request.headers['Content-Length']
+      pulp_response = Resources::Registry::Proxy.post(@_request.fullpath, @_request.body, headers)
 
-    def status_upload_blob
-      response.header['Location'] = "#{request_url}/v2/#{params[:repository]}/blobs/uploads/#{params[:uuid]}"
-      response.header['Range'] = "123"
-      response.header['Docker-Upload-UUID'] = "123"
-      render plain: '', status: :no_content
+      pulp_response.headers.each do |key, value|
+        response.header[key.to_s] = value
+      end
+      head pulp_response.code
     end
 
-    def chunk_upload_blob
-      response.header['Location'] = "#{request_url}/v2/#{params[:repository]}/blobs/uploads/#{params[:uuid]}"
-      render plain: '', status: :accepted
+    def translated_headers_for_proxy
+      current_headers = {}
+      env = request.env.select do |key, _value|
+        key.match("^HTTP_.*")
+      end
+      env.each do |header|
+        current_headers[header[0].split('_')[1..-1].join('-')] = header[1]
+      end
+      current_headers
     end
 
     def upload_blob
-      File.open(tmp_file("#{params[:uuid]}.tar"), 'ab', 0600) do |file|
-        file.write request.body.read
+      headers = translated_headers_for_proxy
+      headers['Content-Type'] = request.headers['Content-Type'] if request.headers['Content-Type']
+      headers['Content-Range'] = request.headers['Content-Range'] if request.headers['Content-Range']
+      headers['Content-Length'] = request.headers['Content-Length'] if request.headers['Content-Length']
+      body = @_request.body.read
+      pulp_response = Resources::Registry::Proxy.patch(@_request.fullpath, body, headers)
+
+      pulp_response.headers.each do |key, value|
+        response.header[key.to_s] = value
       end
 
-      # ???? true chunked data?
-      if request.headers['Content-Range']
-        render_error 'unprocessable_entity', :status => :unprocessable_entity
-      end
-
-      response.header['Location'] = "#{request_url}/v2/#{params[:repository]}/blobs/uploads/#{params[:uuid]}"
-      response.header['Range'] = "1-#{request.body.size}"
-      response.header['Docker-Upload-UUID'] = params[:uuid]
-      head 204
+      head pulp_response.code
     end
 
     def finish_upload_blob
-      # error by client if no params[:digest]
-
-      uuid_file = tmp_file("#{params[:uuid]}.tar")
-      digest_file = tmp_file("#{params[:digest][7..-1]}.tar")
-
-      File.delete(digest_file) if File.exist? digest_file
-      File.rename(uuid_file, digest_file)
-
-      response.header['Location'] = "#{request_url}/v2/#{params[:repository]}/blobs/#{params[:digest]}"
-      response.header['Docker-Content-Digest'] = params[:digest]
-      response.header['Content-Range'] = "1-#{File.size(digest_file)}"
-      response.header['Content-Length'] = "0"
-      response.header['Docker-Upload-UUID'] = params[:uuid]
-      head 201
-    end
+      headers = translated_headers_for_proxy
+      headers['Content-Type'] = request.headers['Content-Type'] if request.headers['Content-Type']
+      headers['Content-Range'] = request.headers['Content-Range'] if request.headers['Content-Range']
+      headers['Content-Length'] = request.headers['Content-Length'] if request.headers['Content-Length']
+      pulp_response = Resources::Registry::Proxy.put(@_request.fullpath, @_request.body, headers)
+
+      pulp_response.headers.each do |key, value|
+        response.header[key.to_s] = value
+      end
 
-    def cancel_upload_blob
-      render plain: '', status: :ok
+      head pulp_response.code
     end
 
     def ping
@@ -411,47 +379,6 @@ module Katello
       tar_file
     end
 
-    # FIXME: Reimplement for Pulp 3.
-    def upload_manifest(tar_file)
-      upload_id = pulp_content.create_upload_request['upload_id']
-      filename = tmp_file(tar_file)
-      uploads = []
-
-      File.open(filename, 'rb') do |file|
-        content = file.read
-        pulp_content.upload_bits(upload_id, 0, content)
-
-        uploads << {
-          id: upload_id,
-          name: filename,
-          size: file.size,
-          checksum: Digest::SHA256.hexdigest(content)
-        }
-      end
-
-      File.delete(filename)
-      task = sync_task(::Actions::Katello::Repository::ImportUpload,
-                       @repository, uploads, generate_metadata: true, sync_capsule: true)
-      task.output['upload_results'][0]['digest']
-    ensure
-      pulp_content.delete_upload_request(upload_id) if upload_id
-    end
-
-    # FIXME: Reimplement for Pulp 3.
-    def upload_tag(digest, tag)
-      upload_id = pulp_content.create_upload_request['upload_id']
-      uploads = [{
-        id: upload_id,
-        name: tag,
-        digest: digest
-      }]
-      sync_task(::Actions::Katello::Repository::ImportUpload, @repository, uploads,
-                :generate_metadata => true, :sync_capsule => true)
-      tag
-    ensure
-      pulp_content.delete_upload_request(upload_id) if upload_id
-    end
-
     def tmp_dir
       "#{Rails.root}/tmp"
     end

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

@@ -15,16 +15,12 @@ module Katello
     #param :id, String, :desc => N_("UUID of the consumer"), :required => true
     def upload_package_profile
       User.as_anonymous_admin do
-        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
+        uploader = ::Katello::Host::PackageProfileUploader.new(
+          host: @host,
+          profile_string: request.raw_post
+        )
+        uploader.upload
+        uploader.trigger_applicability_generation
       end
       render :json => Resources::Candlepin::Consumer.get(@host.subscription_facet.uuid)
     end
@@ -33,16 +29,12 @@ module Katello
     param :id, String, :desc => N_("UUID of the consumer"), :required => true
     def upload_profiles
       User.as_anonymous_admin do
-        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
+        uploader = ::Katello::Host::ProfilesUploader.new(
+          host: @host,
+          profile_string: request.raw_post
+        )
+        uploader.upload
+        uploader.trigger_applicability_generation
       end
       render :json => Resources::Candlepin::Consumer.get(@host.subscription_facet.uuid)
     end

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

@@ -40,7 +40,7 @@ module Katello
     param :unlimited_hosts, :bool, :desc => N_("can the activation key have unlimited hosts")
     param :release_version, String, :desc => N_("content release version")
     param :service_level, String, :desc => N_("service level")
-    param :auto_attach, :bool, :desc => N_("auto attach subscriptions upon registration")
+    param :auto_attach, :bool, :desc => N_("auto attach subscriptions upon registration"), deprecated: true
     param :purpose_usage, String, :desc => N_("Sets the system purpose usage")
     param :purpose_role, String, :desc => N_("Sets the system purpose usage")
     param :purpose_addons, Array, :desc => N_("Sets the system add-ons")
@@ -163,7 +163,11 @@ module Katello
       respond_for_show(:resource => @activation_key)
     end
 
-    api :PUT, "/activation_keys/:id/add_subscriptions", N_("Attach a subscription")
+    def deprecate_entitlement_mode_endpoint
+      ::Foreman::Deprecation.api_deprecation_warning(N_("This endpoint is deprecated and will be removed in an upcoming release. Simple Content Access is the only supported content access mode."))
+    end
+
+    api :PUT, "/activation_keys/:id/add_subscriptions", N_("Attach a subscription"), deprecated: true
     param :id, :number, :desc => N_("ID of the activation key"), :required => true
     param :subscription_id, :number, :desc => N_("Subscription identifier"), :required => false
     param :quantity, :number, :desc => N_("Quantity of this subscription to add"), :required => false
@@ -172,6 +176,7 @@ module Katello
       param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => false
     end
     def add_subscriptions
+      deprecate_entitlement_mode_endpoint
       if params[:subscriptions]
         params[:subscriptions].each { |subscription| @activation_key.subscribe(subscription[:id], subscription[:quantity]) }
       elsif params[:subscription_id]
@@ -181,13 +186,14 @@ module Katello
       respond_for_index(:collection => subscription_index, :template => 'subscriptions')
     end
 
-    api :PUT, "/activation_keys/:id/remove_subscriptions", N_("Unattach a subscription")
+    api :PUT, "/activation_keys/:id/remove_subscriptions", N_("Unattach a subscription"), deprecated: true
     param :id, :number, :desc => N_("ID of the activation key"), :required => true
     param :subscription_id, String, :desc => N_("Subscription ID"), :required => false
     param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => false do
       param :id, String, :desc => N_("Subscription Pool uuid"), :required => false
     end
     def remove_subscriptions
+      deprecate_entitlement_mode_endpoint
       if params[:subscriptions]
         params[:subscriptions].each { |subscription| @activation_key.unsubscribe(subscription[:id]) }
       elsif params[:subscription_id]
@@ -229,7 +235,7 @@ module Katello
 
     api :GET, "/activation_keys/:id/product_content", N_("Show content available for an activation key")
     param :id, String, :desc => N_("ID of the activation key"), :required => true
-    param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions")
+    param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions"), deprecated: true, default: true
     param :content_access_mode_env, :bool, :desc => N_("Limit content to just that available in the activation key's content view version")
     param_group :search, Api::V2::ApiController
     def product_content

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

@@ -112,6 +112,30 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :POST, '/capsules/:id/content/verify_checksum', N_('Check for missing or corrupted artifacts, and attempt to redownload them.')
+    param :id, :number, :required => true, :desc => N_('Id of the smart proxy')
+    param :environment_id, Integer, :desc => N_('Id of the environment to limit verifying checksum on')
+    param :content_view_id, Integer, :desc => N_('Id of the content view to limit verifying checksum on')
+    param :repository_id, Integer, :desc => N_('Id of the repository to limit verifying checksum on')
+    def verify_checksum
+      find_capsule(false)
+      find_environment if params[:environment_id]
+      find_content_view if params[:content_view_id]
+      find_repository if params[:repository_id]
+
+      repair_options = {
+        :environment_id => @environment.try(:id),
+        :content_view_id => @content_view.try(:id),
+        :repository_id => @repository.try(:id)
+      }
+      repair_options[:environment_ids] = @capsule.lifecycle_environments&.pluck(:id) unless (@environment || @content_view || @repository)
+
+      task = async_task(::Actions::Katello::CapsuleContent::VerifyChecksum,
+                        @capsule,
+                        repair_options)
+      respond_for_async :resource => task
+    end
+
     protected
 
     def respond_for_lifecycle_environments_index(environments)

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

@@ -3,8 +3,8 @@ module Katello
     include ::Api::V2::BulkHostsExtension
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_action :find_authorized_katello_resource, :only => [:show, :update, :promote, :destroy, :republish_repositories]
-    before_action :find_content_view_from_version, :only => [:show, :update, :promote, :destroy, :republish_repositories]
+    before_action :find_authorized_katello_resource, :only => [:show, :update, :promote, :destroy, :republish_repositories, :verify_checksum]
+    before_action :find_content_view_from_version, :only => [:show, :update, :promote, :destroy, :republish_repositories, :verify_checksum]
     before_action :find_optional_readable_content_view, :only => [:index]
 
     before_action :find_environment, :only => [:index]
@@ -141,6 +141,13 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. New ver
       respond_for_async :resource => task
     end
 
+    api :POST, "/content_view_versions/:id/verify_checksum", N_("Verify checksum of repository contents in the content view version")
+    param :id, :number, :required => true, :desc => N_("Content view version identifier")
+    def verify_checksum
+      task = async_task(::Actions::Katello::ContentViewVersion::VerifyChecksum, @content_view_version)
+      respond_for_async :resource => task
+    end
+
     private
 
     def calculate_hosts_for_incremental(bulk_params, use_composites)

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

@@ -37,7 +37,7 @@ module Katello
     api :GET, "/repositories/:repository_id/debs", N_("List deb packages")
     param :organization_id, :number, :desc => N_("Organization identifier")
     param :content_view_version_id, :number, :desc => N_("Content View Version identifier")
-    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier")
+    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier. Use to filter by ID")
     param :repository_id, :number, :desc => N_("Repository identifier")
     param :environment_id, :number, :desc => N_("Environment identifier")
     param :ids, Array, :desc => N_("Deb package identifiers to filter content by")

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

@@ -9,7 +9,7 @@ module Katello
     api :GET, "/errata", N_("List errata")
     param :organization_id, :number, :desc => N_("Organization identifier")
     param :content_view_version_id, :number, :desc => N_("Content View Version identifier")
-    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier")
+    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier. Use to filter by ID")
     param :repository_id, :number, :desc => N_("Repository identifier")
     param :environment_id, :number, :desc => N_("Environment identifier")
     param :cve, String, :desc => N_("CVE identifier")

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

@@ -33,9 +33,14 @@ module Katello
       api_base_url "/api"
     end
 
-    api :GET, "/hosts/:host_id/subscriptions", N_("List a host's subscriptions")
+    def deprecate_entitlement_mode_endpoint
+      ::Foreman::Deprecation.api_deprecation_warning(N_("This endpoint is deprecated and will be removed in an upcoming release. Simple Content Access is the only supported content access mode."))
+    end
+
+    api :GET, "/hosts/:host_id/subscriptions", N_("List a host's subscriptions"), deprecated: true
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     def index
+      deprecate_entitlement_mode_endpoint
       @collection = index_response
       respond_for_index :collection => @collection
     end
@@ -47,9 +52,10 @@ module Katello
       full_result_response(presenter.subscriptions)
     end
 
-    api :PUT, "/hosts/:host_id/subscriptions/auto_attach", N_("Trigger an auto-attach of subscriptions")
+    api :PUT, "/hosts/:host_id/subscriptions/auto_attach", N_("Trigger an auto-attach of subscriptions"), deprecated: true
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     def auto_attach
+      deprecate_entitlement_mode_endpoint
       if @host.organization.simple_content_access?
         fail ::Katello::HttpErrors::BadRequest, _("This host's organization is in Simple Content Access mode. Auto-attach is disabled")
       end
@@ -111,13 +117,14 @@ module Katello
       rhsm_params
     end
 
-    api :PUT, "/hosts/:host_id/subscriptions/remove_subscriptions"
+    api :PUT, "/hosts/:host_id/subscriptions/remove_subscriptions", N_("Remove subscriptions from a host"), deprecated: true
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     param :subscriptions, Array, :desc => N_("Array of subscriptions to remove") do
       param :id, String, :desc => N_("Subscription Pool id"), :required => true
       param :quantity, Integer, :desc => N_("If specified, remove the first instance of a subscription with matching id and quantity"), :required => false
     end
     def remove_subscriptions
+      deprecate_entitlement_mode_endpoint
       #combine the quantities for duplicate pools into PoolWithQuantities objects
       pool_id_quantities = params.require(:subscriptions).inject({}) do |new_hash, subscription|
         new_hash[subscription['id']] ||= PoolWithQuantities.new(Pool.with_identifier(subscription['id']))
@@ -129,13 +136,14 @@ module Katello
       respond_for_index(:collection => index_response(reload_host: true), :template => "index")
     end
 
-    api :PUT, "/hosts/:host_id/subscriptions/add_subscriptions", N_("Add a subscription to a host")
+    api :PUT, "/hosts/:host_id/subscriptions/add_subscriptions", N_("Add a subscription to a host"), deprecated: true
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => true do
       param :id, String, :desc => N_("Subscription Pool id"), :required => true
       param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
     end
     def add_subscriptions
+      deprecate_entitlement_mode_endpoint
       if @host.organization.simple_content_access?
         fail ::Katello::HttpErrors::BadRequest, _("This host's organization is in Simple Content Access mode. Attaching subscriptions is disabled.")
       end

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

@@ -106,7 +106,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/remove_subscriptions", N_("Remove subscriptions from one or more hosts")
+    api :PUT, "/hosts/bulk/remove_subscriptions", N_("Remove subscriptions from one or more hosts"), deprecated: true
     param_group :bulk_params
     param :subscriptions, Array, :desc => N_("Array of subscriptions to remove") do
       param :id, String, :desc => N_("Subscription Pool id"), :required => true
@@ -123,7 +123,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/add_subscriptions", N_("Add subscriptions to one or more hosts")
+    api :PUT, "/hosts/bulk/add_subscriptions", N_("Add subscriptions to one or more hosts"), deprecated: true
     param_group :bulk_params
     param :subscriptions, Array, :desc => N_("Array of subscriptions to add"), :required => true do
       param :id, String, :desc => N_("Subscription Pool id"), :required => true
@@ -142,7 +142,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/hosts/bulk/auto_attach", N_("Trigger an auto-attach of subscriptions on one or more hosts")
+    api :PUT, "/hosts/bulk/auto_attach", N_("Trigger an auto-attach of subscriptions on one or more hosts"), deprecated: true
     param_group :bulk_params
     def auto_attach
       task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::AutoAttachSubscriptions, @hosts)

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

@@ -56,22 +56,11 @@ module Katello
     api :PUT, '/organizations/:id', N_('Update organization')
     param :id, :number, :desc => N_("organization ID"), :required => true
     param :redhat_repository_url, String, :desc => N_("Red Hat CDN URL"), deprecated: true
-    param :simple_content_access, :bool, :desc => N_('Whether Simple Content Access should be enabled for the organization.'), :required => false, :default => true, deprecated: true
     param_group :resource
     def update
       if params[:redhat_repository_url]
         sync_task(::Actions::Katello::CdnConfiguration::Update, @organization.cdn_configuration, url: params[:redhat_repository_url])
       end
-      unless params[:simple_content_access].nil?
-        sca_param = ::Foreman::Cast.to_bool(params[:simple_content_access])
-        if sca_param && !@taxonomy.simple_content_access?(cached: false)
-          # user has requested SCA enable
-          sync_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:id])
-        elsif !sca_param && @taxonomy.simple_content_access?(cached: false)
-          # user has requested SCA disable
-          sync_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:id])
-        end
-      end
       super
     end
 

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

@@ -32,7 +32,7 @@ module Katello
     api :GET, "/repositories/:repository_id/:resource_id", N_("List :resource_id")
     param :organization_id, :number, :desc => N_("Organization identifier")
     param :content_view_version_id, :number, :desc => N_("Content View Version identifier")
-    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier")
+    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier. Use to filter by ID")
     param :repository_id, :number, :desc => N_("Repository identifier")
     param :environment_id, :number, :desc => N_("Environment identifier")
     param :ids, Array, :desc => N_("Package identifiers to filter content by")

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

@@ -55,7 +55,7 @@ module Katello
       repairable_products = @products.syncable
       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)
+      repairable_repositories = Katello::Repository.library.where(:root_id => repairable_roots)
       task = async_task(::Actions::BulkAction,
                         ::Actions::Katello::Repository::VerifyChecksum,
                         repairable_repositories)

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

@@ -58,7 +58,7 @@ Pass [] to make repo available for clients regardless of OS version. Maximum len
       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")
-      param :upstream_authentication_token, String, :desc => N_("Password of the upstream authentication token.")
+      param :upstream_authentication_token, String, :desc => N_("Upstream authentication token string for yum repositories.")
       param :deb_releases, String, :desc => N_("whitespace-separated list of releases to be synced from deb-archive")
       param :deb_components, String, :desc => N_("whitespace-separated list of repo components to be synced from deb-archive")
       param :deb_architectures, String, :desc => N_("whitespace-separated list of architectures to be synced from deb-archive")
@@ -576,13 +576,15 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
     end
 
     # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
     def repository_params
       keys = [:download_policy, :mirroring_policy, :sync_policy, :arch, :verify_ssl_on_sync, :upstream_password,
-              :upstream_username, :download_concurrency, :upstream_authentication_token, :metadata_expire,
+              :upstream_username, :download_concurrency, :metadata_expire,
               {:os_versions => []}, :deb_releases, :deb_components, :deb_architectures, :description,
               :http_proxy_policy, :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
              ]
       keys += [{:include_tags => []}, {:exclude_tags => []}, :docker_upstream_name] if params[:action] == 'create' || @repository&.docker?
+      keys += [:upstream_authentication_token] if params[:action] == 'create' || @repository&.yum?
       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"
 
@@ -614,27 +616,31 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
       credential_value
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity,Metrics/MethodLength
+    # 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,
                                                             :checksum_type, :download_policy, :http_proxy_policy,
                                                             :metadata_expire).to_h.with_indifferent_access)
-      root.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
-      if root.docker?
-        root.include_tags = repo_params.fetch(:include_tags, [])
-      end
-      root.exclude_tags = repo_params.fetch(:exclude_tags, ['*-source']) if root.docker?
       root.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
       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)
-      root.ignorable_content = repo_params[:ignorable_content] if root.yum? && repo_params.key?(:ignorable_content)
       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.yum?
+        root.upstream_authentication_token = repo_params[:upstream_authentication_token] if repo_params.key?(:upstream_authentication_token)
+        root.retain_package_versions_count = repo_params[:retain_package_versions_count] if repo_params.key?(:retain_package_versions_count)
+        root.ignorable_content = repo_params[:ignorable_content] if repo_params.key?(:ignorable_content)
+        root.os_versions = repo_params.fetch(:os_versions, [])
+      end
+
+      if root.docker?
+        root.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
+        root.include_tags = repo_params.fetch(:include_tags, [])
+        root.exclude_tags = repo_params.fetch(:exclude_tags, ['*-source'])
+      end
 
       if root.generic?
         generic_remote_options = generic_remote_options_hash(repo_params)

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

@@ -29,7 +29,7 @@ module Katello
     param :with_custom, :bool, :required => false, :desc => N_("If true, return custom repository sets along with redhat repos. Will be ignored if repository_type is supplied.")
     param :activation_key_id, :number, :desc => N_("activation key identifier"), :required => false
     param :host_id, :number, :desc => N_("Id of the host"), :required => false
-    param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions.")
+    param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions."), deprecated: true, default: true
     param :content_access_mode_env, :bool, :desc => N_("Limit content to just that available in the host's or activation key's content view version and lifecycle environment.")
     param :status, [:enabled, :disabled, :overridden],
                                   :desc => N_("Limit content to enabled / disabled / overridden"),
@@ -225,6 +225,7 @@ module Katello
 
     def setup_params
       return unless params[:id]
+      params[:content_access_mode_all] = true
       if params[:entity] == :activation_key
         params[:activation_key_id] ||= params[:id]
       else