katello 4.12.1 → 4.13.0

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

@@ -3,15 +3,16 @@ module Katello
   class Api::Registry::RegistryProxiesController < Api::V2::ApiController
     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]
     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 due to container push changes. Additional task needed to fix.
+    # before_action :authorize_repository_write, only: [:start_upload_blob, :upload_blob, :finish_upload_blob, :push_manifest]
+    before_action :container_push_prop_validation, only: [:start_upload_blob, :upload_blob, :finish_upload_blob, :push_manifest]
+    before_action :create_container_repo_if_needed, 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
 
@@ -83,6 +84,301 @@ module Katello
       return false
     end
 
+    def container_push_prop_validation(props = nil)
+      # Handle validation and repo creation for container pushes before talking to pulp
+      return false unless confirm_push_settings
+      props = parse_blob_push_props if props.nil?
+      return false unless check_blob_push_field_syntax(props)
+
+      # validate input and find the org and product either using downcase label or id
+      if props[:schema] == "label"
+        return false unless check_blob_push_org_label(props)
+        return false unless check_blob_push_product_label(props)
+      else
+        return false unless check_blob_push_org_id(props)
+        return false unless check_blob_push_product_id(props)
+      end
+
+      return false unless check_blob_push_container(props)
+      true
+    end
+
+    def parse_blob_push_props(path_string = nil)
+      # path string should follow one of these formats:
+      #   - /v2/{org_label}/{product_label}/{name}/blobs/uploads...
+      #   - /v2/id/{org_id}/{product_id}/{name}/blobs/uploads...
+      #   - /v2/{org_label}/{product_label}/{name}/manifests/...
+      #   - /v2/id/{org_id}/{product_id}/{name}/manifests/...
+      # inputs not matching format will return {valid_format: false}
+      path_string = @_request.fullpath if path_string.nil?
+      segments = path_string.split('/')
+
+      if segments.length >= 7 && segments[0] == "" && segments[1] == "v2" &&
+        segments[2] != "id" && (segments[5] == "blobs" || segments[5] == "manifests")
+
+        return {
+          valid_format: true,
+          schema: "label",
+          organization: segments[2],
+          product: segments[3],
+          name: segments[4]
+        }
+      elsif segments.length >= 8 && segments[0] == "" && segments[1] == "v2" &&
+        segments[2] == "id" && (segments[6] == "blobs" || segments[6] == "manifests")
+
+        return {
+          valid_format: true,
+          schema: "id",
+          organization: segments[3],
+          product: segments[4],
+          name: segments[5]
+        }
+      else
+        return {valid_format: false}
+      end
+    end
+
+    def check_blob_push_field_syntax(props)
+      # check basic url field syntax
+      unless props[:valid_format]
+        return render_podman_error(
+          "NAME_INVALID",
+          "Invalid format. Container pushes should follow 'organization_label/product_label/name' OR 'id/organization_id/product_id/name' schema.",
+          :bad_request
+        )
+      end
+      return true
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def check_blob_push_org_label(props)
+      org_label = props[:organization]
+      unless org_label.present? && org_label.length > 0
+        return render_podman_error(
+          "NAME_INVALID",
+          "Invalid format. Organization label cannot be blank.",
+          :bad_request
+        )
+      end
+      org = Organization.where("LOWER(label) = '#{org_label}'") # convert to lowercase
+      # reject ambiguous orgs (possible due to lowercase conversion)
+      if org.length > 1
+        # Determine if the repo already exists in one of the possible products. If yes,
+        # inform the user they need to destroy the existing repo and use the ID format
+        unless props[:product].blank? || props[:name].blank?
+          org.each do |o|
+            products = get_matching_products_from_org(o, props[:product])
+            products.each do |prod|
+              root_repos = get_root_repo_from_product(prod, props[:name])
+              unless root_repos.empty?
+                return render_podman_error(
+                  "NAME_INVALID",
+                  "Due to a change in your organizations, this container name has become "\
+                    "ambiguous (org name '#{org_label}'). If you wish to continue using this "\
+                    "container name, destroy the organization in conflict with '#{o.name} (id "\
+                    "#{o.id}). If you wish to keep both orgs, destroy '#{o.label}/#{prod.label}/"\
+                    "#{root_repos.first.label}' and retry your push using the id format.",
+                  :conflict
+                )
+              end
+            end
+          end
+        end
+
+        # Otherwise tell them to try pushing with ID format
+        return render_podman_error(
+          "NAME_INVALID",
+          "Organization label '#{org_label}' is ambiguous. Try using an id-based container name.",
+          :conflict
+        )
+      end
+      if org.length == 0
+        return render_podman_error(
+          "NAME_UNKNOWN",
+          "Organization not found: '#{org_label}'",
+          :not_found
+        )
+      end
+      @organization = org.first
+      true
+    end
+
+    def check_blob_push_org_id(props)
+      org_id = props[:organization]
+      unless org_id.present? && org_id == org_id.to_i.to_s
+        return render_podman_error(
+          "NAME_INVALID",
+          "Invalid format. Organization id must be an integer without leading zeros.",
+          :bad_request
+        )
+      end
+      @organization = Organization.find_by_id(org_id.to_i)
+      if @organization.nil?
+        return render_podman_error(
+          "NAME_UNKNOWN",
+          "Organization id not found: '#{org_id}'",
+          :not_found
+        )
+      end
+      true
+    end
+
+    def check_blob_push_product_label(props)
+      prod_label = props[:product]
+      unless prod_label.present? && prod_label.length > 0
+        return render_podman_error(
+          "NAME_INVALID",
+          "Invalid format. Product label cannot be blank.",
+          :bad_request
+        )
+      end
+      product = get_matching_products_from_org(@organization, prod_label)
+      # reject ambiguous products (possible due to lowercase conversion)
+      if product.length > 1
+        # Determine if the repo already exists in one of the possible products. If yes,
+        # inform the user they need to destroy the existing repo and use the ID format
+        unless props[:name].blank?
+          product.each do |prod|
+            root_repos = get_root_repo_from_product(prod, props[:name])
+            unless root_repos.empty?
+              return render_podman_error(
+                "NAME_INVALID",
+                "Due to a change in your products, this container name has become ambiguous "\
+                  "(product name '#{prod_label}'). If you wish to continue using this container "\
+                  "name, destroy the product in conflict with '#{prod.name}' (id #{prod.id}). If "\
+                  "you wish to keep both products, destroy '#{@organization.label}/#{prod.label}/"\
+                  "#{root_repos.first.label}' and retry your push using the id format.",
+                :conflict
+              )
+            end
+          end
+        end
+
+        return render_podman_error(
+          "NAME_INVALID",
+          "Product label '#{prod_label}' is ambiguous. Try using an id-based container name.",
+          :conflict
+        )
+      end
+      if product.length == 0
+        return render_podman_error(
+          "NAME_UNKNOWN",
+          "Product not found: '#{prod_label}'",
+          :not_found
+        )
+      end
+      @product = product.first
+      true
+    end
+
+    def check_blob_push_product_id(props)
+      prod_id = props[:product]
+      unless prod_id.present? && prod_id == prod_id.to_i.to_s
+        return render_podman_error(
+          "NAME_INVALID",
+          "Invalid format. Product id must be an integer without leading zeros.",
+          :bad_request
+        )
+      end
+      @product = @organization.products.find_by_id(prod_id.to_i)
+      if @product.nil?
+        return render_podman_error(
+          "NAME_UNKNOWN",
+          "Product id not found: '#{prod_id}'",
+          :not_found
+        )
+      end
+      true
+    end
+
+    def get_matching_products_from_org(organization, product_label)
+      return organization.products.where("LOWER(label) = '#{product_label}'") # convert to lowercase
+    end
+
+    def get_root_repo_from_product(product, root_repo_name)
+      return product.root_repositories.where(label: root_repo_name)
+    end
+
+    def check_blob_push_container(props)
+      unless props[:name].present? && props[:name].length > 0
+        return render_podman_error(
+          "NAME_INVALID",
+          "Invalid format. Container name cannot be blank.",
+          :bad_request
+        )
+      end
+
+      @container_name = props[:name]
+      @container_push_name_format = props[:schema]
+      if @container_push_name_format == "label"
+        @container_path_input = "#{props[:organization]}/#{props[:product]}/#{props[:name]}"
+      else
+        @container_path_input = "id/#{props[:organization]}/#{props[:product]}/#{props[:name]}"
+      end
+
+      # If the repo already exists, check if the existing push format matches
+      root_repo = get_root_repo_from_product(@product, @container_name).first
+      if !root_repo.nil? && @container_push_name_format != root_repo.container_push_name_format
+        return render_podman_error(
+          "NAME_INVALID",
+          "Repository name '#{@container_name}' already exists in this product using a different naming scheme. Please retry your request with the #{root_repo.container_push_name_format} format or destroy and recreate the repository using your preferred schema.",
+          :conflict
+        )
+      end
+
+      true
+    end
+
+    def create_container_repo_if_needed
+      if get_root_repo_from_product(@product, @container_name).empty?
+        root = @product.add_repo(
+          name: @container_name,
+          label: @container_name,
+          download_policy: 'immediate',
+          content_type: Repository::DOCKER_TYPE,
+          unprotected: true,
+          is_container_push: true,
+          container_push_name: @container_path_input,
+          container_push_name_format: @container_push_name_format
+        )
+        sync_task(::Actions::Katello::Repository::CreateRoot, root, @container_path_input)
+      end
+    end
+
+    def blob_push_cleanup
+      # after manifest upload, index content and set version href using pulp api
+      root_repo = get_root_repo_from_product(@product, @container_name)&.first
+      instance_repo = root_repo&.library_instance
+
+      unless root_repo.present? && instance_repo.present?
+        return render_podman_error(
+          "BLOB_UPLOAD_UNKNOWN",
+          "Could not locate local uploaded repository for content indexing.",
+          :not_found
+        )
+      end
+
+      api = ::Katello::Pulp3::Repository.api(SmartProxy.pulp_primary, ::Katello::Repository::DOCKER_TYPE).container_push_api
+      api_response = api.list(name: @container_path_input)&.results&.first
+      latest_version_href = api_response&.latest_version_href
+      pulp_href = api_response&.pulp_href
+
+      if latest_version_href.empty? || pulp_href.empty?
+        return render_podman_error(
+          "BLOB_UPLOAD_UNKNOWN",
+          "Could not locate repository properties for content indexing.",
+          :not_found
+        )
+      end
+
+      instance_repo.update!(version_href: latest_version_href)
+      ::Katello::Pulp3::RepositoryReference.where(root_repository_id: instance_repo.root_id,
+        content_view_id: instance_repo.content_view.id, repository_href: pulp_href).create!
+      instance_repo.index_content
+
+      true
+    end
+
     def find_writable_repository
       Repository.docker_type.syncable.find_by_container_repository_name(params[:repository])
     end
@@ -182,15 +478,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 +499,72 @@ 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?
+    def start_upload_blob
+      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)
 
-        tag = upload_tag(digest, tag)
-        return if tag.nil?
-      ensure
-        File.delete(tmp_file('manifest.json')) if File.exist? tmp_file('manifest.json')
+      pulp_response.headers.each do |key, value|
+        response.header[key.to_s] = value
       end
 
-      render json: {}
+      head pulp_response.code
     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
-    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
-
-    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
-    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]
+      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
 
-      uuid_file = tmp_file("#{params[:uuid]}.tar")
-      digest_file = tmp_file("#{params[:digest][7..-1]}.tar")
+      head pulp_response.code
+    end
 
-      File.delete(digest_file) if File.exist? digest_file
-      File.rename(uuid_file, digest_file)
+    def push_manifest
+      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
 
-      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
+      cleanup_result = blob_push_cleanup if pulp_response.code.between?(200, 299)
+      return false unless cleanup_result
 
-    def cancel_upload_blob
-      render plain: '', status: :ok
+      head pulp_response.code
     end
 
     def ping
@@ -310,10 +577,10 @@ module Katello
     end
 
     def v1_search
-      # Checks for podman client and issues a 404 in that case. Podman
+      # Checks for v2 client and issues a 404 in that case. Podman
       # examines the response from a /v1_search request. If the result
       # is a 4XX, it will then proceed with a request to /_catalog
-      if request.headers['HTTP_USER_AGENT'].downcase.include?('libpod')
+      if request.headers['HTTP_DOCKER_DISTRIBUTION_API_VERSION'] == 'registry/2.0'
         render json: {}, status: :not_found
         return
       end
@@ -411,47 +678,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
@@ -496,8 +722,11 @@ module Katello
 
     def confirm_push_settings
       return true if SETTINGS.dig(:katello, :container_image_registry, :allow_push)
-      render_error('custom_error', :status => :not_found,
-                   :locals => { :message => "Registry push not supported" })
+      render_podman_error(
+        "UNSUPPORTED",
+        "Registry push is not enabled. To enable, add ':katello:'->':container_image_registry:'->':allow_push: true' in the katello settings file.",
+        :unprocessable_entity
+      )
     end
 
     def request_url
@@ -519,10 +748,19 @@ module Katello
       Rails.logger.debug "With body: #{filter_sensitive_data(response.body)}\n" unless route_name == 'pull_blob'
     end
 
+    def render_podman_error(code, message, status = :bad_request)
+      # Renders a podman-compatible error and returns false.
+      #     code: uppercase string code from opencontainer error code spec:
+      #         https://specs.opencontainers.org/distribution-spec/?v=v1.0.0#DISTRIBUTION-SPEC-140
+      #     message: a custom error string
+      #     status: a symbol in the 400 block of the rails response code table:
+      #         https://guides.rubyonrails.org/layouts_and_rendering.html#the-status-option
+      render json: {errors: [{code: code, message: message}]}, status: status
+      false
+    end
+
     def item_not_found(item)
-      msg = "#{item} was not found!"
-      # returning errors based on registry specifications in https://docs.docker.com/registry/spec/api/#errors
-      render json: {errors: [code: :invalid_request, message: msg, details: msg]}, status: :not_found
+      render_podman_error("NAME_UNKNOWN", "#{item} was not found!", :not_found)
     end
   end
 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