katello 4.5.1 → 4.8.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 668ae7f77ea1cb1924c60b96931b249de9198b20caa055ee5142422ee5e72d44
-  data.tar.gz: 746ebbe54eb3ad9f4208b344b4bb671143a21489e19a16720c2987a2ffa6719e
+  metadata.gz: 623f96f2d316d946b9a19bbed0bd70a58c56541dfcde05261848efb7f868881d
+  data.tar.gz: f39b3c6dca68f3b742f6a09fb5a821ab5e9d11128835023f09a5a8df30a27272
 SHA512:
-  metadata.gz: 41d0ed1bfd6b88b4414a79c3f8479b3a6ad2c170f055fb707434b7ba72b6e51c83d7582c03bef5bb6a297583a2553776cf324d945311c66442d8c54a40fe7e6a
-  data.tar.gz: 35a1df76e4d090c8628d9c9d22fc623f12ab436fa229c6a55142e3fc53b3a82b6bd5e42e56d0e9282e9efa0fb6d925f378eedcc9c49cdb65335f146842dcbbae
+  metadata.gz: 3d4e46aa5cdededbea344d58cc4dd5c43c1fcdd480e5a62594a1bf0892ff80c048e07a3a7460646b2778502849cc58d7ab6f8f22aaeb1ce3fd0ea8aa59f844c7
+  data.tar.gz: 97fa1540ab108458032dc4a4963b9644af0a6c7207079bf2c3ef2cc895cacab6521eec73e4ed4aadc2eaf8428fc3b2d5b7bec489a03f02a2d972310344b7c07f

data/app/assets/javascripts/katello/common/vendor.js

@@ -3,4 +3,3 @@
 //= require "jquery-ui/effect"
 //= require "jquery-ui/effect.all"
 //= require "katello/jquery.periodicalupdater"
-//= require "katello/jquery.trunk8"

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

@@ -161,25 +161,9 @@ module Katello
       end
 
       if (manifest_response = redirect_client { Resources::Registry::Proxy.get(@_request.fullpath, headers) })
-        #for some requests, we get a redirect, but for others we get the actual manifest in response
-        results = JSON.parse(manifest_response)
         response.header['Docker-Content-Digest'] = manifest_response.headers[:docker_content_digest]
-        # https://docs.docker.com/registry/spec/manifest-v2-2/
-        # If its v2 schema 2 only the mediaType attribute will be present in the manifest
-        media_type = results['mediaType']
-        if media_type.blank?
-          # so mediaType is not schema2 v2 only set the mediaType based on
-          # https://docs.docker.com/registry/spec/manifest-v2-1/
-          media_type = if results["signatures"].blank?
-                         'application/vnd.docker.distribution.manifest.v1+json'
-                       else
-                         'application/vnd.docker.distribution.manifest.v1+prettyjws'
-                       end
-        end
-        response.headers['Content-Type'] = media_type
-        length = manifest_response.try(:body).try(:size)
-        length ||= 0
-        response.header['Content-Length'] = "#{length}"
+        response.headers['Content-Type'] = manifest_response.headers[:content_type]
+        response.header['Content-Length'] = manifest_response.headers[:content_length]
         render json: manifest_response
       end
     end
@@ -210,12 +194,10 @@ module Katello
     def pull_blob
       headers = {}
       headers['Accept'] = request.headers['Accept'] if request.headers['Accept']
-      if (blob_response = redirect_client { Resources::Registry::Proxy.get(@_request.fullpath, headers, max_redirects: 0) })
-        #when pulp 2 is removed, this should no longer be needed, and all clients should be redirected
-        render json: blob_response
-      end
+      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]
@@ -242,6 +224,8 @@ module Katello
       render json: {}
     end
 
+    # FIXME: This is referring to a non-existent Pulp 2 server.
+    # Pulp 3 container push support is needed instead.
     def pulp_content
       Katello.pulp_server.resources.content
     end
@@ -414,6 +398,7 @@ 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)
@@ -439,6 +424,7 @@ module Katello
       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 = [{

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

@@ -59,6 +59,16 @@ module Katello
       @host = facet.host
     end
 
+    rescue_from RestClient::Exception do |e|
+      Rails.logger.error(pp_exception(e, with_backtrace: false))
+      Rails.logger.error(e.backtrace.detect { |line| line.match("katello.*controller") })
+      if request_from_katello_cli?
+        render :json => { :errors => [e.http_body] }, :status => e.http_code
+      else
+        render :plain => e.http_body, :status => e.http_code
+      end
+    end
+
     def authorize_client_or_user
       client_authorized? || authorize
     end

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

@@ -211,7 +211,7 @@ module Katello
 
     #api :POST, "/environments/:environment_id/consumers", N_("Register a consumer in environment")
     def consumer_create
-      host = Katello::RegistrationManager.process_registration(rhsm_params, find_content_view_environment)
+      host = Katello::RegistrationManager.process_registration(rhsm_params, find_content_view_environments)
 
       host.reload
 
@@ -271,7 +271,7 @@ module Katello
 
     def get_parent_host(headers)
       hostnames = headers["HTTP_X_FORWARDED_HOST"]
-      host = hostnames.split(/[\,,:]/)[0].strip if hostnames
+      host = hostnames.split(/[,,:]/)[0].strip if hostnames
       host || URI.parse(Setting[:foreman_url]).host
     end
 
@@ -308,21 +308,27 @@ module Katello
       @host = ::Host::Managed.unscoped.find(facet.host_id)
     end
 
-    def find_content_view_environment
-      environment = nil
+    def find_content_view_environments
+      environments = []
 
       if params.key?(:environment_id)
-        environment = get_content_view_environment("cp_id", params[:environment_id])
-      elsif params.key?(:organization_id) && !params.key?(:environment_id)
+        environments = [get_content_view_environment("cp_id", params[:environment_id])]
+      elsif params.key?(:environments)
+        if params['environments'].length > 1 && !Setting['allow_multiple_content_views']
+          fail HttpErrors::BadRequest, _('Registering to multiple environments is not enabled.')
+        end
+        environments = params[:environments].map do |env|
+          get_content_view_environment("cp_id", env['id'])
+        end
+      elsif params.key?(:organization_id) && !params.key?(:environment_id) && !params.key?(:environments)
         organization = Organization.current
-        environment = organization.library.content_view_environment
+        environments = organization.library.content_view_environment
       elsif User.current.default_organization.present?
-        environment = User.current.default_organization.library.content_view_environment
+        environments = User.current.default_organization.library.content_view_environment
       else
         fail HttpErrors::NotFound, _("User '%s' did not specify an organization ID and does not have a default organization.") % current_user.login
       end
-
-      environment
+      environments
     end
 
     def find_hypervisor_organization

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

@@ -11,6 +11,7 @@ module Katello
                                                                :content_override, :add_subscriptions, :remove_subscriptions,
                                                                :subscriptions]
     before_action :verify_simple_content_access_disabled, :only => [:add_subscriptions]
+    before_action :validate_release_version, :only => [:create, :update]
 
     wrap_parameters :include => (ActivationKey.attribute_names + %w(host_collection_ids service_level auto_attach purpose_role purpose_usage purpose_addons content_view_environment))
 
@@ -229,6 +230,7 @@ module Katello
     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_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
       # note this is just there as a place holder for apipie.
       # The routing would automatically redirect it to repository_sets#index
@@ -337,5 +339,12 @@ module Katello
         fail HttpErrors::BadRequest, _("The specified organization is in Simple Content Access mode. Attaching subscriptions is disabled")
       end
     end
+
+    def validate_release_version
+      @organization ||= find_organization
+      if params[:release_version].present? && !@organization.library.available_releases.include?(params[:release_version])
+        fail HttpErrors::BadRequest, _("Invalid release version: [%s]") % params[:release_version]
+      end
+    end
   end
 end

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

@@ -2,10 +2,12 @@ module Katello
   class Api::V2::AlternateContentSourcesController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    acs_wrap_params = AlternateContentSource.attribute_names + [:smart_proxy_ids, :smart_proxy_names]
+    acs_wrap_params = AlternateContentSource.attribute_names + [:smart_proxy_ids, :smart_proxy_names, :product_ids]
     wrap_parameters :alternate_content_source, include: acs_wrap_params
 
     before_action :find_authorized_katello_resource, only: [:show, :update, :destroy, :refresh]
+    before_action :find_smart_proxies, only: :create
+    before_action :find_products, only: :create
 
     def_param_group :acs do
       param :name, String, desc: N_("Name of the alternate content source")
@@ -14,18 +16,18 @@ module Katello
       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 :smart_proxy_names, Array, desc: N_("Names 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
+      param :use_http_proxies, :bool, desc: N_("If the smart proxies' assigned HTTP proxies should be used"), required: false
+      param :product_ids, Array, desc: N_("IDs of products to copy repository information from into a Simplified Alternate Content Source. Products must include at least one repository of the chosen content type."), required: false
     end
 
-    api :GET, "/alternate_content_sources", N_("List of alternate_content_sources")
+    api :GET, "/alternate_content_sources", N_("List alternate content sources.")
+    param :name, String, :desc => N_("Name of the alternate content source"), :required => false
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(AlternateContentSource)
     def index
@@ -33,9 +35,15 @@ module Katello
         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'])
+          if @acs.custom? || @acs.rhui?
+            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'])
+          elsif @acs.simplified?
+            csv_response(alternate_content_sources,
+                        [:id, :name, :description, :label, :content_type, :alternate_content_source_type, :products],
+                        ['Id', 'Name', 'Description', 'label', 'Content Type', 'Alternate Content Source Type', 'Products'])
+          end
         end
         format.any do
           alternate_content_sources = scoped_search(index_relation, :name, :asc)
@@ -45,49 +53,60 @@ module Katello
     end
 
     def index_relation
-      AlternateContentSource.readable.distinct
+      query = AlternateContentSource.readable.distinct
+      query = query.where(name: params[:name]) if params[:name]
+      query
     end
 
-    api :GET, '/alternate_content_sources/:id', N_('Show an alternate content source')
+    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')
+    api :POST, '/alternate_content_sources', N_('Create an alternate content source to download content from during repository syncing.  Note: alternate content sources are global and affect ALL sync actions on their smart proxies regardless of organization.')
+    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_group :acs
     def create
-      find_smart_proxies
-      @alternate_content_source = ::Katello::AlternateContentSource.new(acs_params.except(:smart_proxy_ids, :smart_proxy_names))
-      sync_task(::Actions::Katello::AlternateContentSource::Create, @alternate_content_source, @smart_proxies)
+      @alternate_content_source = ::Katello::AlternateContentSource.new(acs_params.except(:smart_proxy_ids, :smart_proxy_names, :product_ids))
+      sync_task(::Actions::Katello::AlternateContentSource::Create, @alternate_content_source, @smart_proxies, @products)
       @alternate_content_source.reload
       respond_for_create(resource: @alternate_content_source)
     end
 
-    api :PUT, '/alternate_content_sources/:id', N_('Update an alternate content source')
+    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?
+      # If a user doesn't include smart proxies or products in the update call, don't accidentally remove all of them.
+      if params[:smart_proxy_ids].nil? && params[:smart_proxy_names].nil?
         @smart_proxies = @alternate_content_source.smart_proxies
-      elsif params[:smart_proxy_ids].empty?
+      elsif params[:smart_proxy_ids] == [] || params[:smart_proxy_names] == []
         @smart_proxies = []
       else
         find_smart_proxies
       end
-      sync_task(::Actions::Katello::AlternateContentSource::Update, @alternate_content_source, @smart_proxies, acs_params.except(:smart_proxy_ids))
+      if params[:product_ids].nil?
+        @products = @alternate_content_source.products
+      elsif params[:product_ids] == []
+        @products = []
+      else
+        find_products
+      end
+
+      sync_task(::Actions::Katello::AlternateContentSource::Update, @alternate_content_source, @smart_proxies, @products, acs_params.except(:smart_proxy_ids, :smart_proxy_names, :product_ids))
       respond_for_show(:resource => @alternate_content_source)
     end
 
-    api :DELETE, '/alternate_content_sources/:id', N_('Destroy an alternate content source')
+    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
 
-    api :POST, '/alternate_content_sources/:id/refresh', N_('Refresh an alternate content source')
+    api :POST, '/alternate_content_sources/:id/refresh', N_('Refresh an alternate content source. Refreshing, like repository syncing, is required before using an alternate content source.')
     param :id, :number, :required => true, :desc => N_("Alternate content source ID")
     def refresh
       task = async_task(::Actions::Katello::AlternateContentSource::Refresh, @alternate_content_source)
@@ -97,9 +116,12 @@ module Katello
     protected
 
     def acs_params
-      keys = [:name, :label, :base_url, {subpaths: []}, {smart_proxy_ids: []}, {smart_proxy_names: []}, :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]
+      keys = [
+        :name, :label, :description, {smart_proxy_ids: []}, {smart_proxy_names: []}, :content_type,
+        :alternate_content_source_type, :use_http_proxies, :base_url, {subpaths: []}, :upstream_username,
+        :upstream_password, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id, :verify_ssl, {product_ids: []}
+      ]
+
       params.require(:alternate_content_source).permit(*keys).to_h.with_indifferent_access
     end
 
@@ -117,5 +139,18 @@ module Katello
         fail HttpErrors::NotFound, _("Couldn't find smart proxies with name '%s'") % missing_smart_proxies.to_sentence
       end
     end
+
+    def find_products
+      if params[:product_ids]
+        @products = ::Katello::Product.where(id: params[:product_ids])
+      else
+        @products = nil
+      end
+
+      if params[:product_ids] && @products.length < params[:product_ids].length
+        missing_products = params[:product_ids] - @products.pluck(:id)
+        fail HttpErrors::NotFound, _("Couldn't find products with id '%s'") % missing_products.to_sentence
+      end
+    end
   end
 end

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

@@ -7,6 +7,7 @@ module Katello
     before_action :find_capsule, :except => [:sync, :cancel_sync, :add_lifecycle_environment, :remove_lifecycle_environment, :reclaim_space]
     before_action :find_editable_capsule, :only => [:sync, :cancel_sync, :add_lifecycle_environment, :remove_lifecycle_environment]
     before_action :find_environment, :only => [:add_lifecycle_environment, :remove_lifecycle_environment]
+    before_action :find_acs_http_proxy, :only => [:add_acs_http_proxy]
     before_action :find_optional_organization, :only => [:sync_status]
 
     def_param_group :lifecycle_environments do
@@ -123,6 +124,10 @@ module Katello
       @environment = Katello::KTEnvironment.readable.find(params[:environment_id])
     end
 
+    def find_acs_http_proxy
+      @acs_http_proxy = ::HttpProxy.readable.find(params[:alternate_content_source_http_proxy_id])
+    end
+
     def find_content_view
       @content_view = Katello::ContentView.readable.find(params[:content_view_id])
     end
@@ -130,9 +135,5 @@ module Katello
     def find_repository
       @repository = Katello::Repository.readable.find(params[:repository_id])
     end
-
-    def smart_proxy_service
-      Pulp::SmartProxyRepository.new(@capsule)
-    end
   end
 end

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

@@ -1,5 +1,5 @@
 module Katello
-  class Api::V2::ContentExportIncrementalsController < Api::V2::ApiController
+  class Api::V2::ContentExportIncrementalsController < Api::V2::ExportsController
     before_action :find_exportable_organization, :only => [:library]
     before_action :find_exportable_content_view_version, :only => [:version]
     before_action :find_exportable_repository, :only => [:repository]
@@ -7,70 +7,45 @@ module Katello
     before_action :find_repository_export_view, :only => [:repository]
     before_action :find_history, :only => [:version, :library, :repository]
 
+    def_param_group :incremental do
+      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
+    end
+
     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
-    param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    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
-    param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this version"\
-                                                         " are unexportable. False by default."), :required => false
+    param_group :version_fail_on_missing_content, Api::V2::ExportsController
+    param_group :destination_server, Api::V2::ExportsController
+    param_group :export, Api::V2::ExportsController
+    param_group :incremental
     def version
-      tasks = async_task(Actions::Katello::ContentViewVersion::Export,
-                          content_view_version: @version,
-                          destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_gb],
-                          from_history: @history,
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
-
-      respond_for_async :resource => tasks
+      export_content_view_version
     end
 
     api :POST, "/content_export_incrementals/library", N_("Performs an incremental-export of the repositories in library.")
     param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
-    param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    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
-    param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this organization"\
-                                                         " are unexportable. False by default."), :required => false
+    param_group :org_fail_on_missing_content, Api::V2::ExportsController
+    param_group :destination_server, Api::V2::ExportsController
+    param_group :export, Api::V2::ExportsController
+    param_group :incremental
     def library
-      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportLibrary,
-                          @organization,
-                          destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_gb],
-                          from_history: @history,
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
-      respond_for_async :resource => tasks
+      export_library
     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
+    param_group :export, Api::V2::ExportsController
+    param_group :incremental
     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
+      export_repository
     end
 
     private
 
-    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?
-      @view = @version.content_view
-    end
-
     def find_library_export_view
       @view = ::Katello::Pulp3::ContentViewVersion::Export.find_library_export_view(destination_server: params[:destination_server],
                                                                 organization: @organization,
+                                                                format: find_export_format,
                                                                 create_by_default: false)
       if @view.blank?
         msg = _("Unable to incrementally export. Do a Full Export on the library content "\
@@ -82,46 +57,12 @@ module Katello
     def find_repository_export_view
       @view = ::Katello::Pulp3::ContentViewVersion::Export.find_repository_export_view(
                                                                 repository: @repository,
-                                                                create_by_default: false)
+                                                                create_by_default: false,
+                                                                format: find_export_format)
       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])
-        if @history.blank?
-          throw_resource_not_found(name: 'export history',
-                                   id: params[:from_history_id])
-        end
-      else
-        @history = ::Katello::ContentViewVersionExportHistory.
-                      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
-        end
-      end
-    end
-
-    def find_exportable_organization
-      find_organization
-      unless @organization.can_export_content?
-        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

@@ -1,5 +1,5 @@
 module Katello
-  class Api::V2::ContentExportsController < Api::V2::ApiController
+  class Api::V2::ContentExportsController < Api::V2::ExportsController
     before_action :find_exportable_organization, :only => [:library]
     before_action :find_exportable_content_view_version, :only => [:version]
     before_action :find_exportable_repository, :only => [:repository]
@@ -29,96 +29,27 @@ module Katello
 
     api :POST, "/content_exports/version", N_("Performs a full-export of a content view version.")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
-    param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in gigabytes."), :required => false
-    param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this version"\
-                                                         " are unexportable. False by default."), :required => false
-    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
-                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
-                               "Choose importable if content is to be imported via hammer content-import.
-                                Defaults to importable."),
-                   :required => false
+    param_group :version_fail_on_missing_content, Api::V2::ExportsController
+    param_group :destination_server, Api::V2::ExportsController
+    param_group :export, Api::V2::ExportsController
     def version
-      tasks = async_task(::Actions::Katello::ContentViewVersion::Export,
-                          content_view_version: @version,
-                          destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_gb],
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]),
-                          format: find_export_format)
-      respond_for_async :resource => tasks
+      export_content_view_version
     end
 
     api :POST, "/content_exports/library", N_("Performs a full-export of the repositories in library.")
     param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
-    param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in gigabytes."), :required => false
-    param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this organization"\
-                                                         " are unexportable. False by default."), :required => false
-    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
-                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
-                               "Choose importable if content is to be imported via hammer content-import.
-                                Defaults to importable."),
-                   :required => false
+    param_group :org_fail_on_missing_content, Api::V2::ExportsController
+    param_group :destination_server, Api::V2::ExportsController
+    param_group :export, Api::V2::ExportsController
     def library
-      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportLibrary,
-                          @organization,
-                          destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_gb],
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]),
-                          format: find_export_format)
-      respond_for_async :resource => tasks
+      export_library
     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
-    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
-                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
-                               "Choose importable if content is to be imported via hammer content-import.
-                                Defaults to importable."),
-                   :required => false
+    param_group :export, Api::V2::ExportsController
     def repository
-      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportRepository,
-                          @repository,
-                          chunk_size: params[:chunk_size_gb],
-                          format: find_export_format)
-      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?
-    end
-
-    def find_exportable_organization
-      find_organization
-      unless @organization.can_export_content?
-        throw_resource_not_found(name: 'organization', id: params[:organization_id])
-      end
-    end
-
-    def find_export_format
-      if params[:format]
-        unless ::Katello::Pulp3::ContentViewVersion::Export::FORMATS.include?(params[:format])
-          fail HttpErrors::UnprocessableEntity, _('Invalid export format provided. Format must be one of  %s ') %
-                                            ::Katello::Pulp3::ContentViewVersion::Export::FORMATS.join(',')
-        end
-        params[:format]
-      else
-        ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
-      end
+      export_repository
     end
   end
 end