katello 3.8.1 → 3.9.0.rc1

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

@@ -96,10 +96,12 @@ module Katello
     param :content_type, String, :desc => N_("One of yum or docker")
     param :upstream_username, String, :desc => N_("Username to access URL")
     param :upstream_password, String, :desc => N_("Password to access URL")
+    param :search, String, :desc => N_("Search pattern (defaults to '*')")
     def repo_discover
       fail _("url not defined.") if params[:url].blank?
+      registry_search = params[:search].empty? ? '*' : params[:search]
       task = async_task(::Actions::Katello::Repository::Discover, params[:url], params[:content_type],
-                        params[:upstream_username], params[:upstream_password])
+                        params[:upstream_username], params[:upstream_password], registry_search)
       respond_for_async :resource => task
     end
 

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

@@ -7,7 +7,7 @@ module Katello
 
     api :POST, "/package_group", N_("Create a package group")
     param :repository_id, String, :required => true, :desc => N_("repository_id")
-    param :name, String, :required => true, :desc => N_("package group name.")
+    param :name, String, :required => true, :desc => N_("package group name")
     param :description, String, :desc => N_("package group description. Defaults to params[:name]")
     param :user_visible, :bool, :desc => N_("set \"user_visible\" flag on package group. Defaults to true")
     param :mandatory_package_names, Array, :desc => N_("mandatory package names to include in the package group")

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

@@ -31,12 +31,13 @@ module Katello
       validate_contents = ::Foreman::Cast.to_bool(params[:validate_contents])
 
       syncable_products = @products.syncable
-      syncable_repositories = Repository.where(:product_id => syncable_products).has_url.in_default_view
+      syncable_roots = RootRepository.where(:product_id => syncable_products).has_url
 
-      syncable_repositories = syncable_repositories.where(:content_type => Repository::YUM_TYPE) if skip_metadata_check || validate_contents
-      syncable_repositories = syncable_repositories.where.not(:download_policy => ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND) if validate_contents
+      syncable_roots = syncable_roots.yum_type if skip_metadata_check || validate_contents
+      syncable_roots = syncable_roots.where.not(:download_policy => ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND) if validate_contents
 
-      fail _("No syncable repositories found for selected products and options.") if syncable_repositories.empty?
+      syncable_repositories = Katello::Repository.where(:root_id => syncable_roots).in_default_view
+      fail _("No syncable repositories found for selected products and options.") if syncable_roots.empty?
 
       task = async_task(::Actions::BulkAction,
                         ::Actions::Katello::Repository::Sync,

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

@@ -86,7 +86,7 @@ module Katello
     api :GET, "/products/:id", N_("Show a product")
     param :id, :number, :desc => N_("product numeric identifier"), :required => true
     def show
-      find_product(:includes => [{:repositories => :environment}])
+      find_product(:includes => [{:root_repositories => {:repositories => :environment}}])
       respond_for_show(:resource => @product)
     end
 

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

@@ -10,5 +10,10 @@ module Katello
       end
       collection
     end
+
+    def custom_collection_by_content_view_version(versions)
+      resource_class.joins(:content_view_puppet_environments)
+        .where("#{Katello::ContentViewPuppetEnvironment.table_name}.content_view_version_id" => versions)
+    end
   end
 end

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

@@ -2,6 +2,8 @@ module Katello
   class Api::V2::RepositoriesController < Api::V2::ApiController # rubocop:disable Metrics/ClassLength
     include Katello::Concerns::FilteredAutoCompleteSearch
 
+    wrap_parameters :repository, :include => RootRepository.attribute_names
+
     CONTENT_CREDENTIAL_GPG_KEY_TYPE = "gpg_key".freeze
     CONTENT_CREDENTIAL_SSL_CA_CERT_TYPE = "ssl_ca_cert".freeze
     CONTENT_CREDENTIAL_SSL_CLIENT_CERT_TYPE = "ssl_client_cert".freeze
@@ -16,16 +18,20 @@ module Katello
                                               :import_uploads, :gpg_key_content]
     before_action :find_content, :only => :remove_content
     before_action :find_organization_from_repo, :only => [:update]
-    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 }
-    before_action :only => [:create, :update] { find_content_credential CONTENT_CREDENTIAL_SSL_CLIENT_KEY_TYPE }
     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 }
+    before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CLIENT_KEY_TYPE }
 
-    skip_before_action :authorize, :only => [:sync_complete, :gpg_key_content]
+    skip_before_action :authorize, :only => [:gpg_key_content]
     skip_before_action :check_content_type, :only => [:upload_content]
 
+    def custom_index_relation(collection)
+      collection.includes(:product)
+    end
+
     def_param_group :repo do
       param :url, String, :desc => N_("repository source url")
       param :gpg_key_id, :number, :desc => N_("id of the gpg key that will be assigned to the new repository")
@@ -33,20 +39,21 @@ module Katello
       param :ssl_client_cert_id, :number, :desc => N_("Identifier of the SSL Client Cert")
       param :ssl_client_key_id, :number, :desc => N_("Identifier of the SSL Client Key")
       param :unprotected, :bool, :desc => N_("true if this repository can be published via HTTP")
-      param :checksum_type, String, :desc => N_("checksum of the repository, currently 'sha1' & 'sha256' are supported.")
-      param :docker_upstream_name, String, :desc => N_("name of the upstream docker repository")
+      param :checksum_type, String, :desc => N_("Checksum of the repository, currently 'sha1' & 'sha256' are supported")
+      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')")
-      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 :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")
       param :upstream_password, String, :desc => N_("Password of the upstream repository user used for authentication")
-      param :ostree_upstream_sync_policy, ::Katello::Repository::OSTREE_UPSTREAM_SYNC_POLICIES, :desc => N_("policies for syncing upstream ostree repositories.")
-      param :ostree_upstream_sync_depth, :number, :desc => N_("if a custom sync policy is chosen for ostree repositories then a 'depth' value must be provided.")
+      param :ostree_upstream_sync_policy, ::Katello::RootRepository::OSTREE_UPSTREAM_SYNC_POLICIES, :desc => N_("policies for syncing upstream ostree repositories")
+      param :ostree_upstream_sync_depth, :number, :desc => N_("if a custom sync policy is chosen for ostree repositories then a 'depth' value must be provided")
       param :deb_releases, String, :desc => N_("comma separated list of releases to be synched from deb-archive")
       param :deb_components, String, :desc => N_("comma separated list of repo components to be synched from deb-archive")
       param :deb_architectures, String, :desc => N_("comma separated list of architectures to be synched from deb-archive")
-      param :ignore_global_proxy, :bool, :desc => N_("if true, will ignore the globally configured proxy when syncing.")
-      param :ignorable_content, Array, :desc => N_("List of content units to ignore while syncing a yum repository. Must be subset of %s") % Repository::IGNORABLE_CONTENT_UNIT_TYPES.join(",")
+      param :ignore_global_proxy, :bool, :desc => N_("if true, will ignore the globally configured proxy when syncing")
+      param :ignorable_content, Array, :desc => N_("List of content units to ignore while syncing a yum repository. Must be subset of %s") % RootRepository::IGNORABLE_CONTENT_UNIT_TYPES.join(",")
     end
 
     def_param_group :repo_create do
@@ -75,12 +82,12 @@ module Katello
     param :content_type, RepositoryTypeManager.repository_types.keys, :desc => N_("limit to only repositories of this type")
     param :name, String, :desc => N_("name 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' is supported."),
+    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_group :search, Api::V2::ApiController
     def index
       base_args = [index_relation.distinct, :name, :asc]
-      options = {:includes => [:gpg_key, :product, :environment]}
+      options = {:includes => [:environment, {:root => [:gpg_key, :product]}]}
 
       respond_to do |format|
         format.csv do
@@ -88,12 +95,12 @@ module Katello
           repos = scoped_search(*base_args, options)
           csv_response(repos,
                        [:id, :name, :description, :label, :content_type, :arch, :url, :major, :minor,
-                        :cp_label, :content_label, :pulp_id, :container_repository_name,
+                        :content_label, :pulp_id, :container_repository_name,
                         :download_policy, 'relative_path', 'product.id', 'product.name',
                         'environment_id'],
-                       ['Id', 'Name', 'label', 'Description', 'Content Type', 'Arch', 'Url', 'Major', 'Minor',
-                        'Candlepin Label', 'Content Label', 'Pulp Id', 'Container Repository Name',
-                        'Download Policy', 'Relative Path', 'Product Id', 'Product Name',
+                       ['Id', 'Name', 'Description', 'label', 'Content Type', 'Arch', 'Url', 'Major', 'Minor',
+                        'Content Label', 'Pulp Id', 'Container Repository Name', 'Download Policy', 'Relative Path',
+                        'Product Id', 'Product Name',
                         'Environment Id'])
         end
         format.any do
@@ -106,8 +113,8 @@ module Katello
     def index_relation
       query = Repository.readable
       query = index_relation_product(query)
-      query = query.where(:content_type => params[:content_type]) if params[:content_type]
-      query = query.where(:name => params[:name]) if params[:name]
+      query = query.with_type(params[:content_type]) if params[:content_type]
+      query = query.where(:root_id => RootRepository.where(:name => params[:name])) if params[:name]
       query = index_relation_content_unit(query)
       query = index_relation_content_view(query)
       query = index_relation_environment(query)
@@ -115,15 +122,15 @@ module Katello
     end
 
     def index_relation_product(query)
-      query = query.joins(:product).where("#{Product.table_name}.organization_id" => @organization) if @organization
-      query = query.where(:product_id => @product.id) if @product
+      query = query.joins(:root => :product).where("#{Product.table_name}.organization_id" => @organization) if @organization
+      query = query.joins(:root).where("#{RootRepository.table_name}.product_id" => @product.id) if @product
       query
     end
 
     def index_relation_content_view(query)
       if params[:content_view_version_id]
         query = query.where(:content_view_version_id => params[:content_view_version_id])
-        query = Repository.where(:id => query.map(&:library_instance_id)) if params[:library]
+        query = Katello::Repository.where(:id => query.select(:library_instance_id)) if params[:library]
       elsif params[:content_view_id]
         query = filter_by_content_view(query, params[:content_view_id], params[:environment_id], params[:available_for] == 'content_view')
       end
@@ -139,8 +146,9 @@ module Katello
         instance_ids += instances.where(:library_instance_id => nil)
         query = Repository.where(:id => instance_ids)
       elsif (params[:library] && !params[:environment_id]) || (params[:environment_id].blank? && params[:content_view_version_id].blank? && params[:content_view_id].blank?)
-
-        if @organization
+        if params[:available_for] == 'content_view_version'
+          query = query.where.not(:content_view_version_id => nil, :environment_id => nil)
+        elsif @organization
           query = query.where(:content_view_version_id => @organization.default_content_view.versions.first.id)
         else
           query = query.in_default_view
@@ -189,7 +197,7 @@ module Katello
     param_group :repo_create
     param_group :repo
     def create
-      repo_params = repository_params
+      repo_params = filtered_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(",")
         fail HttpErrors::UnprocessableEntity, msg
@@ -209,10 +217,10 @@ module Katello
       repo_params[:ssl_client_cert] = ssl_client_cert
       repo_params[:ssl_client_key] = ssl_client_key
 
-      repository = construct_repo_from_params(repo_params)
-      sync_task(::Actions::Katello::Repository::Create, repository, false, true)
-      repository = Repository.find(repository.id)
-      respond_for_create(:resource => repository)
+      root = construct_repo_from_params(repo_params)
+      sync_task(::Actions::Katello::Repository::CreateRoot, root)
+      @repository = root.reload.library_instance
+      respond_for_create(:resource => @repository)
     end
 
     api :GET, "/repositories/repository_types", N_("Show the available repository types")
@@ -300,7 +308,7 @@ module Katello
     param_group :repo
     def update
       repo_params = repository_params
-      sync_task(::Actions::Katello::Repository::Update, @repository, repo_params)
+      sync_task(::Actions::Katello::Repository::Update, @repository.root, repo_params)
       respond_for_show(:resource => @repository)
     end
 
@@ -311,34 +319,6 @@ module Katello
       respond_for_destroy
     end
 
-    api :POST, "/repositories/sync_complete"
-    desc N_("URL for post sync notification from pulp")
-    param 'token', String, :desc => N_("shared secret token"), :required => true
-    param 'payload', Hash, :required => true do
-      param 'repo_id', String, :required => true
-    end
-    param 'call_report', Hash, :required => true do
-      param 'task_id', String, :required => true
-    end
-    def sync_complete
-      if params[:token] != Rack::Utils.parse_query(URI(SETTINGS[:katello][:post_sync_url]).query)['token']
-        fail Errors::SecurityViolation, _("Token invalid during sync_complete.")
-      end
-
-      repo_id = params['payload']['repo_id']
-      task_id = params['call_report']['task_id']
-      User.current = User.anonymous_admin
-
-      repo = Repository.where(:pulp_id => repo_id).first
-      fail _("Couldn't find repository '%s'") % repo_id if repo.nil?
-      Rails.logger.info("Sync_complete called for #{repo.name}, running after_sync.")
-
-      unless repo.dynflow_handled_last_sync?(task_id)
-        async_task(::Actions::Katello::Repository::ScheduledSync, repo, task_id)
-      end
-      render :json => {}
-    end
-
     api :PUT, "/repositories/:id/remove_packages"
     api :PUT, "/repositories/:id/remove_docker_manifests"
     api :PUT, "/repositories/:id/remove_puppet_modules"
@@ -436,8 +416,8 @@ module Katello
     api :GET, "/repositories/:id/gpg_key_content", N_("Return the content of a repo gpg key, used directly by yum")
     param :id, :number, :required => true
     def gpg_key_content
-      if @repository.gpg_key && @repository.gpg_key.content.present?
-        render(:plain => @repository.gpg_key.content, :layout => false)
+      if @repository.root.gpg_key && @repository.root.gpg_key.content.present?
+        render(:plain => @repository.root.gpg_key.content, :layout => false)
       else
         head(404)
       end
@@ -471,17 +451,27 @@ module Katello
       end
     end
 
+    def filtered_repository_params
+      params = repository_params
+      ::Katello::RootRepository::CONTENT_ATTRIBUTE_RESTRICTIONS.each do |attribute, types|
+        params.delete(attribute) unless types.include?(params[:content_type])
+      end
+      params
+    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, :ignore_global_proxy,
-              :deb_releases, :deb_components, :deb_architectures, :description, {:ignorable_content => []}
+              :deb_releases, :deb_components, :deb_architectures, :description, {:ignorable_content => []},
+              {:docker_tags_whitelist => []}
              ]
 
       keys += [:label, :content_type] if params[:action] == "create"
       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, :docker_upstream_name]
+        keys += [:url, :gpg_key_id, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id, :unprotected, :name,
+                 :checksum_type, :docker_upstream_name]
       end
-      params.require(:repository).permit(*keys).to_h
+      params.require(:repository).permit(*keys).to_h.with_indifferent_access
     end
 
     def get_content_credential(repo_params, content_type)
@@ -494,30 +484,33 @@ module Katello
       credential_value
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity
     def construct_repo_from_params(repo_params)
-      repository = @product.add_repo(Hash[repo_params.slice(:label, :name, :description, :url, :content_type, :arch, :unprotected,
+      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).to_h.map { |k, v| [k.to_sym, v] }])
-      repository.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
-      repository.mirror_on_sync = ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync]) if repo_params.key?(:mirror_on_sync)
-      repository.ignore_global_proxy = ::Foreman::Cast.to_bool(repo_params[:ignore_global_proxy]) if repo_params.key?(:ignore_global_proxy)
-      repository.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
-      repository.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
-      repository.upstream_password = repo_params[:upstream_password] if repo_params.key?(:upstream_password)
-      repository.ignorable_content = repo_params[:ignorable_content] if repository.yum? && repo_params.key?(:ignorable_content)
-
-      if repository.ostree?
-        repository.ostree_upstream_sync_policy = repo_params[:ostree_upstream_sync_policy]
-        repository.ostree_upstream_sync_depth = repo_params[:ostree_upstream_sync_depth]
+                                                            :checksum_type, :download_policy).to_h.with_indifferent_access)
+      root.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
+      root.docker_tags_whitelist = repo_params[:docker_tags_whitelist] if repo_params[:docker_tags_whitelist]
+      root.mirror_on_sync = ::Foreman::Cast.to_bool(repo_params[:mirror_on_sync]) if repo_params.key?(:mirror_on_sync)
+      root.ignore_global_proxy = ::Foreman::Cast.to_bool(repo_params[:ignore_global_proxy]) if repo_params.key?(:ignore_global_proxy)
+      root.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
+      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.ignorable_content = repo_params[:ignorable_content] if root.yum? && repo_params.key?(:ignorable_content)
+
+      if root.ostree?
+        root.ostree_upstream_sync_policy = repo_params[:ostree_upstream_sync_policy]
+        root.ostree_upstream_sync_depth = repo_params[:ostree_upstream_sync_depth]
       end
-      if repository.deb?
-        repository.deb_releases = repo_params[:deb_releases] if repo_params[:deb_releases]
-        repository.deb_components = repo_params[:deb_components] if repo_params[:deb_components]
-        repository.deb_architectures = repo_params[:deb_architectures] if repo_params[:deb_architectures]
+      if root.deb?
+        root.deb_releases = repo_params[:deb_releases] if repo_params[:deb_releases]
+        root.deb_components = repo_params[:deb_components] if repo_params[:deb_components]
+        root.deb_architectures = repo_params[:deb_architectures] if repo_params[:deb_architectures]
       end
 
-      repository
+      root
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
 
     def error_on_rh_product
       fail HttpErrors::BadRequest, _("Red Hat products cannot be manipulated.") if @product.redhat?
@@ -547,8 +540,11 @@ module Katello
       elsif environment_id
         version = ContentViewVersion.in_environment(environment_id).where(:content_view_id => content_view_id)
         query = query.where(:content_view_version_id => version)
-      else
+      elsif params[:available_for] != 'content_view_version'
         query = query.joins(:content_view_repositories).where("#{ContentViewRepository.table_name}.content_view_id" => content_view_id)
+      else
+        version_ids = ContentViewVersion.where(:content_view_id => content_view_id).pluck(:id)
+        query = query.where('content_view_version_id IN (?) AND environment_id IS NOT NULL', version_ids)
       end
       query
     end

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

@@ -13,17 +13,19 @@ module Katello
       api_version "v2"
     end
 
+    api :GET, "/repository_sets", N_("List repository sets.")
     api :GET, "/products/:product_id/repository_sets", N_("List repository sets for a product.")
     param :product_id, :number, :required => true, :desc => N_("ID of a product to list repository sets from")
     param :name, String, :required => false, :desc => N_("Repository set name to search on")
     param :enabled, :bool, :required => false, :desc => N_("If true, only return repository sets that have been enabled. Defaults to false")
     param :with_active_subscription, :bool, :required => false, :desc => N_("If true, only return repository sets that are associated with an active subscriptions")
+    param :organization_id, :number, :desc => N_("organization identifier"), :required => false
     param_group :search, Api::V2::ApiController
     def index
-      respond(:collection => scoped_search(index_relation, nil, nil, :custom_sort => default_sort,
-                                           :resource_class => Katello::ProductContent))
+      respond(:collection => scoped_search(index_relation, :name, :asc, :resource_class => Katello::ProductContent))
     end
 
+    api :GET, "/repository_sets/:id", N_("Get info about a repository set")
     api :GET, "/products/:product_id/repository_sets/:id", N_("Get info about a repository set")
     param :id, :number, :required => true, :desc => N_("ID of the repository set")
     param :product_id, :number, :required => true, :desc => N_("ID of a product to list repository sets from")
@@ -31,6 +33,7 @@ module Katello
       respond :resource => @product_content
     end
 
+    api :GET, "/repository_sets/:id/available_repositories", N_("Get list of available repositories for the repository set")
     api :GET, "/products/:product_id/repository_sets/:id/available_repositories", N_("Get list of available repositories for the repository set")
     param :id, :number, :required => true, :desc => N_("ID of the repository set")
     param :product_id, :number, :required => true, :desc => N_("ID of a product to list repository sets from")
@@ -48,14 +51,25 @@ module Katello
         end
       end
 
+      sorted_repos = repos.sort_by do |repo|
+        major, minor = repo[:substitutions][:releasever].nil? ? [1000, 1000] : repo[:substitutions][:releasever].split('.').map(&:to_i)
+        major = major == 0 ? 1000 : major
+        minor = minor.nil? ? 1000 : minor
+        arch = repo[:substitutions][:basearch].nil? ? "" : repo[:substitutions][:basearch]
+
+        [arch, major, minor]
+      end
+
       collection = {
-        :results  => repos,
+        :results => sorted_repos.reverse,
         :subtotal => repos.size,
         :total    => repos.size
       }
+
       respond_for_index :collection => collection
     end
 
+    api :PUT, "/repository_sets/:id/enable", N_("Enable a repository from the set")
     api :PUT, "/products/:product_id/repository_sets/:id/enable", N_("Enable a repository from the set")
     param :id, :number, :required => true, :desc => N_("ID of the repository set to enable")
     param :product_id, :number, :required => true, :desc => N_("ID of the product containing the repository set")
@@ -66,6 +80,7 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :PUT, "/repository_sets/:id/disable", N_("Disable a repository from the set")
     api :PUT, "/products/:product_id/repository_sets/:id/disable", N_("Disable a repository from the set")
     param :id, :number, :required => true, :desc => N_("ID of the repository set to disable")
     param :product_id, :number, :required => true, :desc => N_("ID of the product containing the repository set")
@@ -82,10 +97,6 @@ module Katello
       Katello::Content
     end
 
-    def default_sort
-      lambda { |relation| relation.order("#{Katello::Content.table_name}.name asc") }
-    end
-
     def index_relation
       if @product.nil?
         relation = @organization.product_contents.displayable

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

@@ -30,8 +30,8 @@ module Katello
     param :match_installed, :bool, :desc => N_("Return subscriptions that match installed products of the specified host")
     param :no_overlap, :bool, :desc => N_("Return subscriptions which do not overlap with a currently-attached subscription")
     def index
-      options = { resource_class: Pool, includes: [:subscription], custom_sort: name_sort }
-      base_args = [index_relation.distinct, nil, nil]
+      options = { resource_class: Pool, includes: [:subscription] }
+      base_args = [index_relation.distinct, :name, :asc]
 
       respond_to do |format|
         format.csv do
@@ -60,10 +60,6 @@ module Katello
       end
     end
 
-    def name_sort
-      lambda { |relation| relation.order("katello_subscriptions.name ASC") }
-    end
-
     def index_relation
       return for_host if params[:host_id]
       return available_for_activation_key if params[:available_for] == "activation_key"