katello 4.4.2.2 → 4.5.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd651be2d737a3763d7909bb251e2eebe3e5f7e3f64dd2a7d0fb63a3448cd936
-  data.tar.gz: 8d1197de95bbb2618d306324c9a65fe3b67037fc6045460c5a7d4fa5e8dc428d
+  metadata.gz: c2fd3647b864eba8c468c3eea9e6d6d867a43192dcb29c0758f0771085fb1621
+  data.tar.gz: 764696ceedc7d01432439f6ac00012be79383073c35f0d491cbf4a1da1af6a77
 SHA512:
-  metadata.gz: 8c7b25a4e22ef289cd2166765d3ca0e57577bc7fbfbdb788acbcd24122073b5822e7606ef46b1013145f031b6fc5033408a1a1ee61c6b40bb1dc1f213734db8b
-  data.tar.gz: df205f9b36e0ecd51539001572f741aef87be242e75e075186d4f1bb5512e6730e6fda889b9d93ea3ddce2fe994fb8d64512a1befb7e3a0225094d62c7d9fe72
+  metadata.gz: d67f10a68cf3f81316e77099d82266960fc5887513004f5e35daa47c591ccc44f2a8ba78f54e8ef84c6ba8bc53d5a42c0621d842c70fa5b20c3dd61cae90e648
+  data.tar.gz: 5c798d57fbde2baf9c9d62c172e294ade51f32e2d822ed56c63983f48d8f690abd0d2f625e061c7318d4680e916d477fc64025974396ead7f17b919bf06a83c4

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

@@ -406,7 +406,11 @@ module Katello
           where("#{Organization.table_name}.id = ?", organization.id)
       environments = environments.where("#{Katello::ContentViewEnvironment.table_name}.label = ?", label) if label
 
-      environments.reject { |env| (env.content_view.default && !env.environment.readable?) || !env.content_view.readable? }
+      environments.reject do |env|
+        (env.content_view.default && !env.environment.readable?) ||
+            !env.content_view.readable? ||
+            env.content_view.generated_for_repository?
+      end
     end
 
     def rhsm_params

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

@@ -0,0 +1,98 @@
+module Katello
+  class Api::V2::AlternateContentSourcesController < Api::V2::ApiController
+    include Katello::Concerns::FilteredAutoCompleteSearch
+
+    before_action :find_authorized_katello_resource, :only => [:show, :update, :destroy]
+    before_action :find_smart_proxies
+
+    def_param_group :acs do
+      param :name, String, desc: N_("Name of the alternate content source")
+      param :description, String, desc: N_("Description for the alternate content source"), required: false
+      param :base_url, String, desc: N_('Base URL for finding alternate content'), required: false
+      param :subpaths, Array, desc: N_('Path suffixes for finding alternate content'), required: false
+      param :smart_proxy_ids, Array, desc: N_("Ids of smart proxies to associate"), required: false
+      param :content_type, RepositoryTypeManager.defined_repository_types.keys & AlternateContentSource::CONTENT_TYPES, desc: N_("The content type for the Alternate Content Source"), required: false
+      param :alternate_content_source_type, AlternateContentSource::ACS_TYPES, desc: N_("The Alternate Content Source type")
+      param :upstream_username, String, desc: N_("Basic authentication username"), required: false
+      param :upstream_password, String, desc: N_("Basic authentication password"), required: false
+      param :ssl_ca_cert_id, :number, desc: N_("Identifier of the content credential containing the SSL CA Cert"), required: false
+      param :ssl_client_cert_id, :number, desc: N_("Identifier of the content credential containing the SSL Client Cert"), required: false
+      param :ssl_client_key_id, :number, desc: N_("Identifier of the content credential containing the SSL Client Key"), required: false
+      param :http_proxy_id, :number, desc: N_("ID of a HTTP Proxy"), required: false
+      param :verify_ssl, :bool, desc: N_("If SSL should be verified for the upstream URL"), required: false
+    end
+
+    api :GET, "/alternate_content_sources", N_("List of alternate_content_sources")
+    param_group :search, Api::V2::ApiController
+    add_scoped_search_description_for(AlternateContentSource)
+    def index
+      respond_to do |format|
+        format.csv do
+          options[:csv] = true
+          alternate_content_sources = scoped_search(index_relation, :name, :asc)
+          csv_response(alternate_content_sources,
+                       [:id, :name, :description, :label, :base_url, :subpaths, :content_type, :alternate_content_source_type],
+                       ['Id', 'Name', 'Description', 'label', 'Base URL', 'Subpaths', 'Content Type', 'Alternate Content Source Type'])
+        end
+        format.any do
+          alternate_content_sources = scoped_search(index_relation, :name, :asc)
+          respond(collection: alternate_content_sources)
+        end
+      end
+    end
+
+    def index_relation
+      AlternateContentSource.readable.distinct
+    end
+
+    api :GET, '/alternate_content_sources/:id', N_('Show an alternate content source')
+    param :id, :number, :required => true, :desc => N_("Alternate content source ID")
+    def show
+      respond_for_show(:resource => @alternate_content_source)
+    end
+
+    api :POST, '/alternate_content_sources', N_('Create an ACS')
+    param_group :acs
+    def create
+      @alternate_content_source = ::Katello::AlternateContentSource.new(acs_params)
+      sync_task(::Actions::Katello::AlternateContentSource::Create, @alternate_content_source, @smart_proxies)
+      @alternate_content_source.reload
+      respond_for_create(resource: @alternate_content_source)
+    end
+
+    api :PUT, '/alternate_content_sources/:id', N_('Update an alternate content source')
+    param_group :acs
+    param :id, :number, :required => true, :desc => N_("Alternate content source ID")
+    def update
+      # If a user doesn't include smart proxies in the update call, don't accidentally remove all of them.
+      if params[:smart_proxy_ids].nil?
+        @smart_proxies = @alternate_content_source.smart_proxies
+      end
+      sync_task(::Actions::Katello::AlternateContentSource::Update, @alternate_content_source, @smart_proxies, acs_params)
+      respond_for_show(:resource => @alternate_content_source)
+    end
+
+    api :DELETE, '/alternate_content_sources/:id', N_('Destroy an alternate content source')
+    param :id, :number, :required => true, :desc => N_("Alternate content source ID")
+    def destroy
+      sync_task(::Actions::Katello::AlternateContentSource::Destroy, @alternate_content_source)
+      respond_for_destroy
+    end
+
+    protected
+
+    def acs_params
+      keys = [:name, :label, :base_url, {subpaths: []}, {smart_proxy_ids: []}, :content_type, :alternate_content_source_type,
+              :upstream_username, :upstream_password, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id,
+              :http_proxy_id, :verify_ssl]
+      params.require(:alternate_content_source).permit(*keys).to_h.with_indifferent_access
+    end
+
+    def find_smart_proxies
+      if params[:smart_proxy_ids]
+        @smart_proxies = ::SmartProxy.where(id: params[:smart_proxy_ids])
+        fail HttpErrors::NotFound, _("Couldn't find smart proxies with id '%s'") % params[:smart_proxy_ids].to_sentence if @smart_proxies.empty?
+      end
+    end
+  end
+end

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

@@ -2,8 +2,10 @@ module Katello
   class Api::V2::ContentExportIncrementalsController < Api::V2::ApiController
     before_action :find_exportable_organization, :only => [:library]
     before_action :find_exportable_content_view_version, :only => [:version]
+    before_action :find_exportable_repository, :only => [:repository]
     before_action :find_library_export_view, :only => [:library]
-    before_action :find_history, :only => [:version, :library]
+    before_action :find_repository_export_view, :only => [:repository]
+    before_action :find_history, :only => [:version, :library, :repository]
 
     api :POST, "/content_export_incrementals/version", N_("Performs an incremental-export of a content view version.")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
@@ -44,6 +46,20 @@ module Katello
       respond_for_async :resource => tasks
     end
 
+    api :POST, "/content_export_incrementals/repository", N_("Performs a incremental-export of the repository in library.")
+    param :id, :number, :desc => N_("Repository identifier"), :required => true
+    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
+                                               "no greater than the specified size in gigabytes."), :required => false
+    param :from_history_id, :number, :desc => N_("Export history identifier used for incremental export. "\
+                                                 "If not provided the most recent export history will be used."), :required => false
+    def repository
+      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportRepository,
+                          @repository,
+                          chunk_size: params[:chunk_size_gb],
+                          from_history: @history)
+      respond_for_async :resource => tasks
+    end
+
     private
 
     def find_exportable_content_view_version
@@ -63,6 +79,16 @@ module Katello
       end
     end
 
+    def find_repository_export_view
+      @view = ::Katello::Pulp3::ContentViewVersion::Export.find_repository_export_view(
+                                                                repository: @repository,
+                                                                create_by_default: false)
+      if @view.blank?
+        msg = _("Unable to incrementally export. Do a Full Export on the repository content.")
+        fail HttpErrors::BadRequest, msg
+      end
+    end
+
     def find_history
       if params[:from_history_id].present?
         @history = ::Katello::ContentViewVersionExportHistory.find(params[:from_history_id])
@@ -72,8 +98,7 @@ module Katello
         end
       else
         @history = ::Katello::ContentViewVersionExportHistory.
-                      latest(@view,
-                                          destination_server: params[:destination_server])
+                      latest(@view, destination_server: params[:destination_server])
         if @history.blank?
           msg = _("No existing export history was found to perform an incremental export. A full export must be performed")
           fail HttpErrors::NotFound, msg
@@ -87,5 +112,16 @@ module Katello
         throw_resource_not_found(name: 'organization', id: params[:organization_id])
       end
     end
+
+    def find_exportable_repository
+      @repository = Repository.find_by_id(params[:id])
+      if @repository.blank?
+        throw_resource_not_found(name: 'repository', id: params[:id])
+      end
+
+      unless @repository.organization.can_export_content?
+        throw_resource_not_found(name: 'organization', id: @repository.organization.id)
+      end
+    end
   end
 end

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

@@ -2,6 +2,7 @@ module Katello
   class Api::V2::ContentExportsController < Api::V2::ApiController
     before_action :find_exportable_organization, :only => [:library]
     before_action :find_exportable_content_view_version, :only => [:version]
+    before_action :find_exportable_repository, :only => [:repository]
 
     api :GET, "/content_exports", N_("List export histories")
     param :content_view_version_id, :number, :desc => N_("Content view version identifier"), :required => false
@@ -58,8 +59,26 @@ module Katello
       respond_for_async :resource => tasks
     end
 
+    api :POST, "/content_exports/repository", N_("Performs a full-export of the repository in library.")
+    param :id, :number, :desc => N_("Repository identifier"), :required => true
+    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
+                                               "no greater than the specified size in gigabytes."), :required => false
+    def repository
+      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportRepository,
+                          @repository,
+                          chunk_size: params[:chunk_size_gb])
+      respond_for_async :resource => tasks
+    end
+
     private
 
+    def find_exportable_repository
+      @repository = Repository.find_by_id(params[:id])
+      if @repository.blank? || !@repository.organization.can_export_content?
+        throw_resource_not_found(name: 'repository', id: params[:id])
+      end
+    end
+
     def find_exportable_content_view_version
       @version = ContentViewVersion.exportable.find_by_id(params[:id])
       throw_resource_not_found(name: 'content view version', id: params[:id]) if @version.blank?

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

@@ -1,10 +1,7 @@
 module Katello
   class Api::V2::ContentImportsController < Api::V2::ApiController
-    before_action :find_organization, :only => [:version]
-    before_action :check_authorized, :only => [:version]
-
-    before_action :find_importable_organization, :only => [:library]
-    before_action :find_default_content_view, :only => [:library]
+    before_action :find_organization, :only => [:version, :repository, :library]
+    before_action :check_authorized, :only => [:version, :repository, :library]
 
     api :GET, "/content_imports", N_("List import histories")
     param :content_view_version_id, :number, :desc => N_("Content view version identifier"), :required => false
@@ -46,22 +43,21 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :POST, "/content_imports/repository", N_("Import a repository")
+    param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
+    param :path, String, :desc => N_("Directory containing the exported Content View Version"), :required => true
+    param :metadata, Hash, :desc => N_("Metadata taken from the upstream export history for this Content View Version"), :required => true
+    def repository
+      task = async_task(::Actions::Katello::ContentViewVersion::ImportRepository, @organization, path: params[:path], metadata: metadata_params.to_h)
+      respond_for_async :resource => task
+    end
+
     private
 
     def check_authorized
       fail HttpErrors::Forbidden, _("Action unauthorized to be performed in this organization.") unless @organization.can_import_content?
     end
 
-    def find_default_content_view
-      @view = @organization&.default_content_view
-      throw_resource_not_found(name: 'organization', id: params[:organization_id]) if @view.blank?
-    end
-
-    def find_importable_organization
-      find_organization
-      throw_resource_not_found(name: 'organization', id: params[:organization_id]) unless @organization.can_import_content?
-    end
-
     def metadata_params
       params.require(:metadata).permit(
         :organization,
@@ -69,8 +65,9 @@ module Katello
         :products,
         :toc,
         :incremental,
+        :destination_server,
         gpg_keys: {},
-        content_view: [:name, :label, :description],
+        content_view: [:name, :label, :description, :generated_for],
         content_view_version: [:major, :minor, :description],
         from_content_view_version: [:major, :minor]
       ).tap do |nested|

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

@@ -274,17 +274,5 @@ module Katello
       return deny_access unless @content_view_version.content_view.deletable?
       true
     end
-
-    def metadata_params
-      params.require(:metadata).permit(
-        :organization,
-        :content_view,
-        :repository_mapping,
-        :toc,
-        content_view_version: [:major, :minor]
-      ).tap do |nested|
-        nested[:repository_mapping] = params[:metadata].require(:repository_mapping).permit!
-      end
-    end
   end
 end

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

@@ -5,6 +5,7 @@ module Katello
     include Katello::Concerns::Api::V2::BulkExtensions
 
     before_action :find_authorized_katello_resource, :except => [:index, :create, :copy, :auto_complete_search]
+    before_action :ensure_non_generated, only: [:publish]
     before_action :ensure_non_default, :except => [:index, :create, :copy, :auto_complete_search]
     before_action :find_organization, :only => [:create]
     before_action :find_optional_organization, :only => [:index, :auto_complete_search]
@@ -54,6 +55,7 @@ module Katello
     param :without, Array, :desc => N_("Do not include this array of content views")
     param :name, String, :desc => N_("Name of the content view"), :required => false
     param :label, String, :desc => N_("Label of the content view"), :required => false
+    param :include_generated, :bool, :desc => N_("Include content views generated by imports/exports. Defaults to false")
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(ContentView)
     def index
@@ -64,6 +66,7 @@ module Katello
 
     def index_relation
       content_views = ContentView.readable
+      content_views = content_views.not_generated_for_repository unless Foreman::Cast.to_bool(params[:include_generated])
       content_views = content_views.where(:organization_id => @organization.id) if @organization
       content_views = content_views.in_environment(@environment) if @environment
       content_views = ::Foreman::Cast.to_bool(params[:nondefault]) ? content_views.non_default : content_views.default if params[:nondefault]
@@ -257,6 +260,16 @@ module Katello
       end
     end
 
+    def  ensure_non_generated
+      if @content_view.import_only?
+        fail HttpErrors::BadRequest, _("Import only Content Views cannot be directly publsihed. Content can only be updated by importing into the view.")
+      end
+
+      if @content_view.generated?
+        fail HttpErrors::BadRequest, _("Generated content views cannot be directly published. They can updated only via export.")
+      end
+    end
+
     def view_params
       attrs = [:name, :description, :auto_publish, :solve_dependencies, :import_only,
                :default, :created_at, :updated_at, :next_version, {:component_ids => []}]

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

@@ -107,7 +107,7 @@ module Katello
       fail HttpErrors::BadRequest, _("Can't update the '%s' environment") % "Library" if @environment.library? && update_params.empty?
       update_params[:name] = params[:environment][:new_name] if params[:environment][:new_name]
       @environment.update!(update_params)
-      if update_params[:registry_name_pattern]
+      if update_params[:registry_name_pattern] || update_params[:registry_unauthenticated_pull]
         task = send(async ? :async_task : :sync_task, ::Actions::Katello::Environment::PublishRepositories,
                     @environment, content_type: Katello::Repository::DOCKER_TYPE)
       end

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

@@ -12,6 +12,7 @@ module Katello
     api :GET, "/hosts/:host_id/module_streams", N_("List module streams available to the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
     param :status, ::Katello::HostAvailableModuleStream::API_STATES.keys, :desc => N_("Streams based on the host based on their status")
+    param :install_status, String, :desc => N_("Streams based on the host based on the installation status"), :required => false
     param_group :search, Api::V2::ApiController
     def index
       collection = scoped_search(index_relation, :name, :asc, :resource_class => ::Katello::HostAvailableModuleStream)
@@ -22,8 +23,13 @@ module Katello
       return HostAvailableModuleStream.upgradable([@host]) if params[:status] == HostAvailableModuleStream::UPGRADABLE
 
       rel = @host.host_available_module_streams
-      return rel if params[:status].blank?
-      rel.send(::Katello::HostAvailableModuleStream::API_STATES[params[:status]])
+      if params[:sort_by] == 'installed_profiles'
+        rel = rel.order([:installed_profiles, :status])
+      end
+      return rel if (params[:status].blank? && params[:install_status].blank?)
+      rel = rel.send(::Katello::HostAvailableModuleStream::API_STATES[params[:status]]) unless params[:status].blank?
+      rel = rel.installed_status(params[:install_status], @host) unless params[:install_status].blank?
+      rel
     end
 
     def resource_class

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

@@ -5,6 +5,7 @@ module Katello
     before_action :check_subscriptions, :only => [:add_subscriptions, :remove_subscriptions]
     before_action :find_content_view_environment, :only => :create
     before_action :check_registration_services, :only => [:destroy, :create]
+    before_action :find_content_overrides, :only => [:content_override]
 
     def_param_group :installed_products do
       param :product_id, String, :desc => N_("Product id as listed from a host's installed products, \
@@ -165,12 +166,16 @@ module Katello
       param :name, String, :desc => N_("Override key or name. Note if name is not provided the default name will be 'enabled'"), :required => false
       param :remove, :bool, :desc => N_("Set true to remove an override and reset it to 'default'"), :required => false
     end
+    param :content_overrides_search, Hash, :desc => N_("Content override search parameters") do
+      param_group :search, Api::V2::ApiController
+      param :enabled, :bool, :desc => N_("Set true to override to enabled; Set false to override to disabled.'"), :required => false
+      param :remove, :bool, :desc => N_("Set true to remove an override and reset it to 'default'"), :required => false
+    end
     def content_override
-      content_overrides = params[:content_overrides] || []
-
-      content_override_values = content_overrides.map do |override_params|
+      content_override_values = @content_overrides.map do |override_params|
         validate_content_overrides_enabled(override_params)
       end
+
       sync_task(::Actions::Katello::Host::UpdateContentOverrides, @host, content_override_values, false)
       fetch_product_content
     end
@@ -217,5 +222,22 @@ module Katello
         fail ::Foreman::Exception.new(N_("unknown permission for %s"), "#{params[:controller]}##{params[:action]}")
       end
     end
+
+    def find_content_overrides
+      if params[:content_overrides_search]
+        content_labels = ::Katello::Content.joins(:product_contents)
+                            .where("#{Katello::ProductContent.table_name}.product_id": @host.organization.products.subscribable.enabled)
+                            .search_for(params[:content_overrides_search][:search])
+                            .pluck(:label)
+        @content_overrides = content_labels.map do |label|
+          { content_label: label,
+            value: Foreman::Cast.to_bool(params[:content_overrides_search][:enabled]),
+            remove: Foreman::Cast.to_bool(params[:content_overrides_search][:remove])
+          }
+        end
+      else
+        @content_overrides = params[:content_overrides] || []
+      end
+    end
   end
 end

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

@@ -29,7 +29,6 @@ module Katello
         param :hostgroup_ids, Array, N_("Host group IDs"), :required => false
         param :environment_ids, Array, N_("Environment IDs"), :required => false
         param :subnet_ids, Array, N_("Subnet IDs"), :required => false
-        param :label, String, :required => false
         param :location_ids, Array, N_("Associated location IDs"), :required => false
       end
     end
@@ -66,6 +65,9 @@ module Katello
 
     api :POST, '/organizations', N_('Create organization')
     param_group :resource
+    param :organization, Hash do
+      param :label, String, :required => false
+    end
     def create
       @organization = Organization.new(resource_params)
       creator = ::Katello::OrganizationCreator.new(@organization)
@@ -134,7 +136,7 @@ module Katello
 
     api :PUT, "/organizations/:id/cdn_configuration", N_("Update the CDN configuration")
     param :id, String, :desc => N_("ID of the Organization"), :required => true
-    param :type, String, :desc => N_("CDN configuration type. One of %s.") % CdnConfiguration::TYPES, :required => true
+    param :type, String, :desc => N_("CDN configuration type. One of %s.") % CdnConfiguration::TYPES.join(", "), :required => true
     param :url, String, :desc => N_("Upstream foreman server to sync CDN content from. Relevant only for 'upstream_server' type.")
     param :username, String, :desc => N_("Username for authentication. Relevant only for 'upstream_server' type.")
     param :password, String, :desc => N_("Password for authentication. Relevant only for 'upstream_server' type.")

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

@@ -6,7 +6,7 @@ module Katello
     param :ids, Array, :desc => N_("List of repository ids"), :required => true
     def destroy_repositories
       deletion_authorized_repositories = @repositories.deletable
-      unpromoted_repos = deletion_authorized_repositories.reject { |repo| repo.promoted? }
+      unpromoted_repos = deletion_authorized_repositories.reject { |repo| repo.promoted? && repo.content_views.generated_for_none.exists? }
 
       messages1 = format_bulk_action_messages(
           :success    => "",

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

@@ -7,7 +7,7 @@ module Katello
       generic_repo_wrap_params << option.name
     end
 
-    repo_wrap_params = RootRepository.attribute_names.concat([:ignore_global_proxy, :mirror_on_sync]) + generic_repo_wrap_params
+    repo_wrap_params = RootRepository.attribute_names + [:mirror_on_sync] + generic_repo_wrap_params
 
     wrap_parameters :repository, :include => repo_wrap_params
 
@@ -420,8 +420,8 @@ module Katello
       param 'id', String, :required => true
       param 'content_unit_id', String
       param 'size', String
-      param 'checksum', String
-      param 'name', String, :desc => N_("Needs to only be set for file repositories or docker tags")
+      param 'checksum', String, :required => true
+      param 'name', String, :required => true, :desc => N_("Needs to only be set for file repositories or docker tags")
       param 'digest', String, :desc => N_("Needs to only be set for docker tags")
     end
     Katello::RepositoryTypeManager.generic_repository_types.each_pair do |_, repo_type|
@@ -439,6 +439,12 @@ module Katello
       end
 
       uploads = (params[:uploads] || []).map do |upload|
+        if upload[:checksum].nil?
+          fail HttpErrors::BadRequest, _('Checksum is a required parameter.')
+        end
+        if upload[:name].nil?
+          fail HttpErrors::BadRequest, _('Name is a required parameter.')
+        end
         upload.permit(:id, :content_unit_id, :size, :checksum, :name, :digest).to_h
       end
 

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

@@ -13,7 +13,7 @@ module Katello
     before_action :find_authorized_host, :only => [:index, :auto_complete_search]
     before_action :find_organization
     before_action :find_product_content, :except => [:index, :auto_complete_search]
-    before_action :check_airgapped, :only => [:index]
+    before_action :check_airgapped, :only => [:available_repositories, :enable, :disable]
 
     resource_description do
       api_version "v2"
@@ -31,13 +31,19 @@ module Katello
     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_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"),
+                                  :required => false
+
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Katello::ProductContent)
     def index
       collection = scoped_search(index_relation, :name, :asc, :resource_class => Katello::ProductContent)
-      collection[:results] = ProductContentFinder.wrap_with_overrides(
-          product_contents: collection[:results],
-          overrides: @consumable&.content_overrides)
+      pcf = ProductContentFinder.wrap_with_overrides(
+        product_contents: collection[:results],
+        overrides: @consumable&.content_overrides,
+        status: params[:status])
+      collection[:results] = custom_sort_results(pcf)
       respond(:collection => collection)
     end
 
@@ -100,6 +106,7 @@ module Katello
     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 :repository_id, :number, :required => false, :desc => N_("ID of the repository within the set to disable")
     param :product_id, :number, :required => false, :desc => N_("ID of the product containing the repository set")
     param :basearch, String, :required => false, :desc => N_("Basearch to disable")
     param :releasever, String, :required => false, :desc => N_("Releasever to disable")
@@ -186,7 +193,7 @@ module Katello
     end
 
     def substitutions
-      params.permit(:basearch, :releasever).to_h
+      params.permit(:basearch, :releasever, :repository_id).to_h
     end
 
     def find_authorized_activation_key
@@ -212,8 +219,34 @@ module Katello
     end
 
     def check_airgapped
-      if @organization.cdn_configuration.airgapped?
-        respond_for_index(:collection => { :error => _("Repositories are not available for enablement while CDN configuration is set to Air-gapped (disconnected).") }, :status => :forbidden)
+      if @organization.cdn_configuration.export_sync?
+        fail HttpErrors::BadRequest, _("Repositories are not available for enablement while CDN configuration is set to Air-gapped (disconnected).")
+      end
+    end
+
+    def sort_score(pc) # sort order for enabled
+      score = if pc.enabled_content_override&.value == "1"
+                4 # overridden to enabled
+              elsif pc.enabled_content_override.nil? && pc.enabled
+                3 # enabled
+              elsif pc.enabled_content_override.nil? && !pc.enabled
+                2 # disabled
+              elsif pc.enabled_content_override&.value == "0"
+                1 # overridden to disabled
+              else
+                0
+              end
+      Rails.logger.debug [pc.product_name, pc.enabled_content_override, "Id: #{pc.id}", "Score: #{score}"]
+      score
+    end
+
+    def custom_sort_results(product_content_finder)
+      if params[:sort_by] == 'enabled_by_default' && params[:sort_order] == 'desc'
+        product_content_finder.sort { |pca, pcb| sort_score(pca) <=> sort_score(pcb) }.reverse!
+      elsif params[:sort_by] == 'enabled_by_default'
+        product_content_finder.sort { |pca, pcb| sort_score(pca) <=> sort_score(pcb) }
+      else
+        product_content_finder
       end
     end
   end

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

@@ -43,11 +43,11 @@ module Katello
           collection = scoped_search(*base_args, options)
           csv_response(collection,
                        [:id, :subscription_id, :name, :cp_id, :organization_id, :sockets, :cores,
-                        :start_date, :end_date, :available, :quantity, :account_number, :contract_number,
+                        :start_date, :end_date, :consumed, :quantity, :account_number, :contract_number,
                         :support_level, :ram, :stacking_id, :multi_entitlement, :type, :product_id,
                         :unmapped_guest, :virt_only, :virt_who, :upstream?],
                        ['Pool Id Number', 'Subscription Id', 'Name', 'Pool Id', 'Organization Id',
-                        'Sockets', 'Cores', 'Start Date', 'End Date', 'Available', 'Quantity', 'Account Number',
+                        'Sockets', 'Cores', 'Start Date', 'End Date', 'Consumed', 'Quantity', 'Account Number',
                         'Contract Number', 'Support Level', 'RAM', 'Stacking Id', 'Multi Entitlement', 'Type',
                         'Product Id', 'Unmapped Guest', 'Virt Only', 'Requires Virt Who', 'Upstream'])
         end

data/app/controllers/katello/concerns/api/v2/hosts_controller_extensions.rb

@@ -24,7 +24,7 @@ module Katello
           process_response(:object => @host)
         end
 
-        api :PUT, "/hosts/:host_id/host_collections", N_("Alter a hosts host collections")
+        api :PUT, "/hosts/:host_id/host_collections", N_("Alter a host's host collections")
         param :host_id, :number, :required => true, :desc => N_("The id of the host to alter")
         param :host_collection_ids, Array, :required => true, :desc => N_("List of host collection ids to update")
         def host_collections

data/app/helpers/katello/concerns/smart_proxy_helper_extensions.rb

@@ -35,6 +35,10 @@ module Katello
             :name => _("Immediate"),
             :label => ::Katello::RootRepository::DOWNLOAD_IMMEDIATE
           },
+          {
+            :name => _("Streamed"),
+            :label => SmartProxy::DOWNLOAD_STREAMED
+          },
           {
             :name => _("Inherit from Repository"),
             :label => SmartProxy::DOWNLOAD_INHERIT