katello 3.17.0.rc1 → 3.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf008f8880960ad2a6cf9b615c0e0801fb38cce104e67001f4d17178cca43ab7
-  data.tar.gz: d2cda17cc4664479ac34f7abd33c08f14ef81f038abb0cfe3d43c9542624c48b
+  metadata.gz: d4911d03477352b7d0d1f70c1fe0aabf89a4203f925d11b06b09fb753cca4119
+  data.tar.gz: 0442bdaf70ac3842ccae4d639111cdbefabb4d3c6601292c789fd7184e4273d0
 SHA512:
-  metadata.gz: 27f052edff77986139ef6a82d0cd318c95b90a601a9f42178038896589c1042b1e18d030320173ae2c5a21ac75bfe09b13e7376525574f7dbff9d33b4867b8fa
-  data.tar.gz: 22f05c56710ee8951e1d15d30e5b2d471ab07f17287c51c01b7958e751442197fe89b8d262eb89584e612bba939aad7e8d7ddd407d55937d31a04d00e1df8e10
+  metadata.gz: 93f259c486b6f6d766389c062a894ca2a77e46cebe0fa9d4b6cb00d3722cefbeffefc46d0836c4bfcb08979206517d1e586e10ae5de0b22049798f060626b32f
+  data.tar.gz: 61b4ea0699d961668d15ff3235d67e4bb8bb30e987166a8a8cf6a00444a827b19d63665842fccf3f65539e28ddf46c277b4b0c070321b6cfe4254921b483e629

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

@@ -10,8 +10,8 @@ module Katello
     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]
-    skip_before_action :check_content_type, only: [:start_upload_blob, :upload_blob, :finish_upload_blob,
-                                                   :chunk_upload_blob, :push_manifest]
+    skip_before_action :check_media_type, only: [:start_upload_blob, :upload_blob, :finish_upload_blob,
+                                                 :chunk_upload_blob, :push_manifest]
 
     wrap_parameters false
 
@@ -200,7 +200,9 @@ module Katello
     end
 
     def pull_blob
-      r = Resources::Registry::Proxy.get(@_request.fullpath, 'Accept' => request.headers['Accept'])
+      headers = {}
+      headers['Accept'] = request.headers['Accept'] if request.headers['Accept']
+      r = Resources::Registry::Proxy.get(@_request.fullpath, headers)
       render json: r
     end
 

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

@@ -10,7 +10,7 @@ module Katello
     before_action :find_host, :only => [:upload_package_profile, :upload_profiles, :deb_package_profile]
     before_action :authorize_client_or_user, :only => [:upload_package_profile, :upload_profiles, :deb_package_profile]
 
-    skip_before_action :check_content_type
+    skip_before_action :check_media_type
 
     #api :PUT, "/consumers/:id/packages", N_("Update installed packages")
     #api :PUT, "/consumers/:id/profile", N_("Update installed packages")

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

@@ -26,7 +26,7 @@ module Katello
     before_action :set_organization_id, :except => [:hypervisors_update, :async_hypervisors_update]
     before_action :find_hypervisor_organization, :only => [:async_hypervisors_update, :hypervisors_update]
 
-    before_action :check_content_type, :except => :async_hypervisors_update
+    before_action :check_media_type, :except => :async_hypervisors_update
 
     prepend_before_action :convert_owner_to_organization_id, :except => [:hypervisors_update, :async_hypervisors_update], :if => lambda { params.key?(:owner) }
     prepend_before_action :convert_organization_label_to_id, :only => [:rhsm_index, :consumer_activate, :consumer_create], :if => lambda { params.key?(:organization_id) }
@@ -480,7 +480,7 @@ module Katello
         else
           User.consumer? || ::User.current.can?(:view_organizations, self)
         end
-      when "rhsm_proxy_owner_servicelevels_path"
+      when "rhsm_proxy_owner_servicelevels_path", "rhsm_proxy_owner_system_purpose_path"
         (User.consumer? || ::User.current.can?(:view_organizations, self))
       when "rhsm_proxy_consumer_accessible_content_path", "rhsm_proxy_consumer_certificates_path",
            "rhsm_proxy_consumer_releases_path", "rhsm_proxy_certificate_serials_path",

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

@@ -5,7 +5,7 @@ module Katello
     include Api::V2::Rendering
     include Api::V2::ErrorHandling
     include ::Foreman::Controller::CsvResponder
-    include Concerns::Api::V2::AssociationsPermissionCheck
+    include Concerns::Api::V2::Authorization
 
     # support for session (thread-local) variables must be the last filter in this class
     include Foreman::ThreadSession::Cleaner

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

@@ -4,7 +4,7 @@ module Katello
     before_action :authorize
     before_action :find_organization, :only => [:create, :index, :auto_complete_search]
     before_action :find_content_credential, :only => [:show, :update, :destroy, :content, :set_content]
-    skip_before_action :check_content_type, :only => [:create, :content, :set_content]
+    skip_before_action :check_media_type, :only => [:create, :content, :set_content]
 
     def resource_class
       Katello::GpgKey

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

@@ -1,7 +1,7 @@
 module Katello
   class Api::V2::ContentUploadsController < Api::V2::ApiController
     before_action :find_repository
-    skip_before_action :check_content_type, :only => [:update]
+    skip_before_action :check_media_type, :only => [:update]
 
     include ::Foreman::Controller::FilterParameters
     filter_parameters :content
@@ -13,8 +13,8 @@ module Katello
     param :content_type, RepositoryTypeManager.uploadable_content_types.map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree', 'puppet_module', 'rpm', 'srpm')")
     def create
       content_type = params[:content_type] || ::Katello::RepositoryTypeManager.find(@repository.content_type).default_managed_content_type.label
-      unit_type_id = SmartProxy.pulp_master.content_service(content_type).content_type
-      render :json => @repository.backend_content_service(::SmartProxy.pulp_master).create_upload(params[:size], params[:checksum], unit_type_id)
+      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
 
     api :PUT, "/repositories/:repository_id/content_uploads/:id", N_("Upload a chunk of the file's content")
@@ -24,7 +24,7 @@ module Katello
     param :offset, :number, :required => true, :desc => N_("The offset in the file where the content starts")
     param :content, File, :required => true, :desc => N_("The actual file contents")
     def update
-      @repository.backend_content_service(::SmartProxy.pulp_master)
+      @repository.backend_content_service(::SmartProxy.pulp_primary)
         .upload_chunk(params[:id], params[:offset], params[:content], params[:size])
       head :no_content
     end
@@ -33,7 +33,7 @@ module Katello
     param :repository_id, :number, :required => true, :desc => N_("Repository id")
     param :id, String, :required => true, :desc => N_("Upload request id")
     def destroy
-      @repository.backend_content_service(::SmartProxy.pulp_master).delete_upload(params[:id])
+      @repository.backend_content_service(::SmartProxy.pulp_primary).delete_upload(params[:id])
       head :no_content
     end
 

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

@@ -0,0 +1,47 @@
+module Katello
+  class Api::V2::ContentViewRepositoriesController < Api::V2::ApiController
+    # There are other Content View Repository related endpoints that are in RepositoriesController
+    include Katello::Concerns::FilteredAutoCompleteSearch
+
+    before_action :find_content_view
+    before_action :find_organization_from_cv
+
+    # content_views/:id/repositories/show_all
+    # Shows all repositories, 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
+    def show_all
+      kr = Katello::Repository.table_name
+      krr = Katello::RootRepository.table_name
+      kcvr = Katello::ContentViewRepository.table_name
+      join_query = <<-SQL
+        LEFT OUTER JOIN #{kcvr}
+        ON #{kr}.id = #{kcvr}.repository_id
+        AND #{kcvr}.content_view_id = #{@content_view.id}
+      SQL
+      order_query = <<-SQL
+        CAST (#{kcvr}.repository_id as BOOLEAN) ASC, #{krr}.name
+      SQL
+
+      query = Katello::Repository.readable.in_default_view.in_organization(@organization)
+      # Use custom sort to perform the join and order since we need to order by specific content_view
+      # and the ORDER BY query needs access to the katello_content_view_repositories table
+      custom_sort = ->(sort_query) { sort_query.joins(:root).joins(join_query).order(order_query) }
+      options = { resource_class: Katello::Repository, custom_sort: custom_sort }
+      repos = scoped_search(query, nil, nil, options)
+
+      respond_for_index(:collection => repos)
+    end
+
+    private
+
+    def find_content_view
+      @content_view = ContentView.find(params[:content_view_id])
+    end
+
+    def find_organization_from_cv
+      @organization = @content_view.organization
+    end
+  end
+end

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

@@ -82,33 +82,72 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :POST, "/content_view_versions/:id/export", N_("Export a content view version"), :deprecated => true
+    api :GET, "/content_view_versions/export_histories", N_("Show the export history for a content view version")
+    param :content_view_version_id, :number, :desc => N_("Content view version identifier"), :required => false
+    param :content_view_id, :number, :desc => N_("Content view identifier"), :required => false
+    param :destination_server, String, :desc => N_("Destination Server name"), :required => false
+    param :organization_id, :number, :desc => N_("Organization identifier"), :required => false
+    param_group :search, Api::V2::ApiController
+    add_scoped_search_description_for(ContentViewVersionExportHistory)
+    def export_histories
+      history = ContentViewVersionExportHistory.readable
+      history = history.where(:content_view_version_id => params[:content_view_version_id]) unless params[:content_view_version_id].blank?
+      history = history.where(:destination_server => params[:destination_server]) unless params[:destination_server].blank?
+      history = history.with_organization_id(params[:organization_id]) unless params[:organization_id].blank?
+      history = history.with_content_view_id(params[:content_view_id]) unless params[:content_view_id].blank?
+      respond_for_index(:collection => scoped_search(history, 'id', 'asc', resource_class: ContentViewVersionExportHistory),
+                        :template => '../../../api/v2/content_view_version_export_histories/index')
+    end
+
+    api :POST, "/content_view_versions/:id/export", N_("Export a content view version")
     param :id, :number, :desc => N_("Content view version 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
+    param :destination_server, String, :desc => N_("Destination Server name, required for Pulp3")
+    param :export_to_iso, :bool, :desc => N_("Export to ISO format. Relevant only for Pulp 2 repositories"), :required => false
+    param :iso_mb_size, :number, :desc => N_("maximum size of each ISO in MB. Relevant only for Pulp 2 repositories"), :required => false
+    param :since, Date, :desc => N_("Optional date of last export (ex: 2010-01-01T12:00:00Z). Relevant only for Pulp 2 repositories"), :required => false
     def export
-      ::Foreman::Deprecation.api_deprecation_warning("Export is being deprecated and will be removed in a future version of Katello. Use hammer content-view version export instead.")
-      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 SmartProxy.pulp_primary.pulp3_repository_type_support?(Katello::Repository::YUM_TYPE)
+        invalid_params = [:export_to_iso, :iso_mb_size, :since].reject { |param| params[param].blank? }
+        unless invalid_params.empty?
+          fail HttpErrors::BadRequest, _("Invalid parameters provided - %{params}. These are only relevant for Pulp 2 repositories" % { params: invalid_params.join(', ')})
+        end
 
-      if (repos = @version.content_view.on_demand_repositories).any?
-        fail HttpErrors::BadRequest, _("This content view has on demand repositories that cannot be exported: %{repos}" % {repos: repos.pluck(:label).join(", ")})
-      end
+        if params[:destination_server].blank?
+          fail HttpErrors::BadRequest, _("Destination Server Name required for Pulp3 repositories")
+        end
 
-      if params[:since].present?
-        begin
-          params[:since].to_datetime
-        rescue
-          raise HttpErrors::BadRequest, _("Invalid date provided.")
+        task = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::Export, @version, destination_server: params[:destination_server])
+      else
+        ::Foreman::Deprecation.api_deprecation_warning("Export is being deprecated and will be removed in a future version of Katello. Use hammer content-view version export instead.")
+        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 (repos = @version.content_view.on_demand_repositories).any?
+          fail HttpErrors::BadRequest, _("This content view has on demand repositories that cannot be exported: %{repos}" % {repos: repos.pluck(:label).join(", ")})
+        end
+
+        if params[:since].present?
+          begin
+            params[:since].to_datetime
+          rescue
+            raise HttpErrors::BadRequest, _("Invalid date provided.")
+          end
+        end
+        task = async_task(::Actions::Katello::ContentViewVersion::Export, @version,
+                          ::Foreman::Cast.to_bool(params[:export_to_iso]),
+                          params[:since].try(:to_datetime),
+                          params[:iso_mb_size])
       end
 
-      task = async_task(::Actions::Katello::ContentViewVersion::Export, @version,
-                        ::Foreman::Cast.to_bool(params[:export_to_iso]),
-                        params[:since].try(:to_datetime),
-                        params[:iso_mb_size])
+      respond_for_async :resource => task
+    end
+
+    api :POST, "/content_view_versions/import", N_("Import a content view version")
+    param :content_view_id, :number, :desc => N_("Content view identifier"), :required => true
+    param :path, String, :desc => N_("Import path"), :required => true
+    def import
+      task = async_task(::Actions::Katello::ContentViewVersion::Import, @view, path: params[:path])
       respond_for_async :resource => task
     end
 

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

@@ -5,7 +5,7 @@ module Katello
     before_action :authorize
     before_action :find_organization, :only => [:create, :index, :auto_complete_search]
     before_action :find_gpg_key, :only => [:show, :update, :destroy, :content, :set_content]
-    skip_before_action :check_content_type, :only => [:create, :content, :set_content]
+    skip_before_action :check_media_type, :only => [:create, :content, :set_content]
 
     def_param_group :gpg_key do
       param :name, :identifier, :action_aware => true, :required => true, :desc => N_("identifier of the gpg key")

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

@@ -1,6 +1,6 @@
 module Katello
   class Api::V2::HostTracerController < Api::V2::ApiController
-    before_action :find_host, :only => :index
+    before_action :find_host
 
     resource_description do
       api_version 'v2'
@@ -14,43 +14,18 @@ module Katello
       respond_for_index(:collection => collection)
     end
 
-    api :PUT, "/traces/resolve", N_("Resolve Traces")
+    api :PUT, "/hosts/:host_id/traces/resolve", N_("Resolve Traces")
+    param :host_id, :number, :required => true, :desc => N_("ID of the host")
     param :trace_ids, Array, :required => true, :desc => N_("Array of Trace IDs")
     def resolve
-      traces = Katello::HostTracer.resolvable.where(id: params[:trace_ids])
-
-      traces.each do |trace|
-        if trace.reboot_required?
-          trace.helper = 'reboot'
-        end
-      end
-
-      traces_by_host_id = traces.group_by(&:host_id)
-      traces_by_helper = traces.group_by(&:helper)
-
-      composers = []
-
-      if traces_by_host_id.size < traces_by_helper.size
-        traces_by_host_id.each do |host_id, trace|
-          needed_traces = trace.map(&:helper).join(',')
-          joined_helpers = { :helper => needed_traces }
-          composers << JobInvocationComposer.for_feature(:katello_service_restart, [host_id], joined_helpers)
-        end
-      else
-        traces_by_helper.each do |helper, trace|
-          helpers = { :helper => helper }
-          composers << JobInvocationComposer.for_feature(:katello_service_restart, trace.map(&:host_id), helpers)
-        end
-      end
+      traces = @host.host_traces.resolvable.where(id: params[:trace_ids])
+      fail HttpErrors::BadRequest, _("The requested traces were not found for this host") if traces.empty?
 
-      job_invocations = []
+      result = Katello::HostTraceManager.resolve_traces(traces)
 
-      composers.each do |composer|
-        composer.trigger
-        job_invocations << composer.job_invocation
-      end
+      task = ForemanTasks::Task.find(result.first.task_id)
 
-      render json: job_invocations
+      respond_for_async(resource: task)
     end
 
     protected

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

@@ -1,4 +1,5 @@
 module Katello
+  # rubocop:disable Metrics/ClassLength
   class Api::V2::HostsBulkActionsController < Api::V2::ApiController
     include Concerns::Api::V2::BulkHostsExtensions
     include Katello::Concerns::Api::V2::ContentOverridesController
@@ -6,7 +7,7 @@ module Katello
     before_action :find_host_collections, :only => [:bulk_add_host_collections, :bulk_remove_host_collections]
     before_action :find_environment, :only => [:environment_content_view]
     before_action :find_content_view, :only => [:environment_content_view]
-    before_action :find_editable_hosts, :except => [:destroy_hosts, :applicable_errata, :installable_errata]
+    before_action :find_editable_hosts, :except => [:destroy_hosts, :applicable_errata, :installable_errata, :resolve_traces]
     before_action :find_deletable_hosts, :only => [:destroy_hosts]
     before_action :find_readable_hosts, :only => [:applicable_errata, :installable_errata, :available_incremental_updates]
     before_action :find_errata, :only => [:available_incremental_updates]
@@ -236,6 +237,16 @@ module Katello
       respond_for_index(:collection => collection, :template => '../../../api/v2/host_tracer/index')
     end
 
+    api :PUT, "/hosts/bulk/resolve_traces", N_("Resolve traces for one or more hosts")
+    param_group :bulk_params
+    param :trace_ids, Array, :required => true, :desc => N_("Array of Trace IDs")
+    def resolve_traces
+      traces = Katello::HostTracer.resolvable.where(id: params[:trace_ids])
+      result = Katello::HostTraceManager.resolve_traces(traces)
+
+      render json: result
+    end
+
     api :POST, "/hosts/bulk/available_incremental_updates", N_("Given a set of hosts and errata, lists the content view versions" \
                                                                  " and environments that need updating.")
     param_group :bulk_params

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

@@ -50,6 +50,21 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :PUT, "/products/bulk/verify_checksum", N_("Verify checksum for one or more products")
+    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_repositories = Katello::Repository.where(:root_id => repairable_roots)
+      task = async_task(::Actions::BulkAction,
+                        ::Actions::Katello::Repository::VerifyChecksum,
+                        repairable_repositories)
+
+      respond_for_async :resource => task
+    end
+
     api :PUT, "/products/bulk/http_proxy", N_("Update the HTTP proxy configuration on the repositories of one or more products.")
     param :ids, Array, :desc => N_("List of product ids"), :required => true
     param :http_proxy_policy, ::Katello::RootRepository::HTTP_PROXY_POLICIES, :desc => N_("policy for HTTP proxy for content sync")

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

@@ -13,9 +13,10 @@ module Katello
     before_action :find_product, :only => [:index, :auto_complete_search]
     before_action :find_product_for_create, :only => [:create]
     before_action :find_organization_from_product, :only => [:create]
-    before_action :find_repository, :only => [:show, :update, :destroy, :sync, :export,
-                                              :remove_content, :upload_content, :republish,
-                                              :import_uploads, :gpg_key_content]
+    before_action :find_unauthorized_katello_resource, :only => [:gpg_key_content]
+    before_action :find_authorized_katello_resource, :only => [:show, :update, :destroy, :sync, :export,
+                                                               :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]
@@ -26,7 +27,7 @@ module Katello
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CLIENT_KEY_TYPE }
     before_action :check_ignore_global_proxy, :only => [ :update, :create ]
     skip_before_action :authorize, :only => [:gpg_key_content]
-    skip_before_action :check_content_type, :only => [:upload_content]
+    skip_before_action :check_media_type, :only => [:upload_content]
 
     def custom_index_relation(collection)
       collection.includes(:product)
@@ -43,6 +44,7 @@ module Katello
       param :docker_upstream_name, String, :desc => N_("Name of the upstream docker repository")
       param :docker_tags_whitelist, Array, :desc => N_("Comma separated list of tags to sync for Container Image repository")
       param :download_policy, ["immediate", "on_demand", "background"], :desc => N_("download policy for yum repos (either 'immediate', 'on_demand', or 'background (deprecated)')")
+      param :download_concurrency, :number, :desc => N_("Used to determine download concurrency of the repository in pulp3. Use value less than 20. Defaults to 10")
       param :mirror_on_sync, :bool, :desc => N_("true if this repository when synced has to be mirrored from the source and stale rpms removed")
       param :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")
@@ -57,7 +59,6 @@ module Katello
       param :ansible_collection_requirements, String, :desc => N_("Contents of requirement yaml file to sync from URL")
       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 :auto_enabled, :bool, :desc => N_("if true, the repositories will be automatically enabled on a registered host subscribed to this product. Default: true")
     end
 
     def_param_group :repo_create do
@@ -295,6 +296,15 @@ module Katello
       raise HttpErrors::BadRequest, e.message
     end
 
+    api :POST, "/repositories/:id/verify_checksum", N_("Verify checksum of repository contents")
+    param :id, :number, :required => true, :desc => N_("repository ID")
+    def verify_checksum
+      task = async_task(::Actions::Katello::Repository::VerifyChecksum, @repository)
+      respond_for_async :resource => task
+    rescue Errors::InvalidActionOptionError => e
+      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
@@ -438,16 +448,17 @@ module Katello
     protected
 
     def find_product
-      @product = Product.find(params[:product_id]) if params[:product_id]
+      if params[:product_id]
+        @product = Product.readable.find_by(id: params[:product_id])
+        throw_resource_not_found(name: 'product', id: params[:product_id]) if @product.nil?
+      end
+
       find_organization_from_product if @organization.nil? && @product
     end
 
     def find_product_for_create
-      @product = Product.find(params[:product_id])
-    end
-
-    def find_repository
-      @repository = Repository.find(params[:id])
+      @product = Product.editable.find_by(id: params[:product_id])
+      throw_resource_not_found(name: 'product', id: params[:product_id]) if @product.nil?
     end
 
     def find_content_credential(content_type)
@@ -464,8 +475,8 @@ module Katello
     end
 
     def repository_params
-      keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password, :upstream_username,
-              :ostree_upstream_sync_depth, :ostree_upstream_sync_policy, :auto_enabled,
+      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,
               :deb_releases, :deb_components, :deb_architectures, :description, :http_proxy_policy, :http_proxy_id,
               {:ignorable_content => []}
              ]
@@ -516,7 +527,6 @@ module Katello
       root.ansible_collection_requirements = repo_params[:ansible_collection_requirements] if root.ansible_collection?
       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.auto_enabled = repo_params[:auto_enabled] if repo_params.key?(:auto_enabled)
 
       if root.ostree?
         root.ostree_upstream_sync_policy = repo_params[:ostree_upstream_sync_policy]