function listMultipartUploads(authInfo, request, log, callback) {
    log.debug('processing request', { method: 'listMultipartUploads' });
    const query = request.query;
    const bucketName = request.bucketName;
    const mpuBucketName = `${constants.mpuBucketPrefix}${bucketName}`;
    const encoding = query['encoding-type'];
    const prefix = query.prefix ? query.prefix : '';
    const metadataValParams = {
        authInfo,
        bucketName,
        // AWS docs state that the bucket owner and anyone with
        // s3:ListBucketMultipartUploads rights under the bucket policies
        // have access. They do not address ACLs at all.  It seems inconsisent
        // that someone who has read access on a bucket would not be able
        // to list the multipart uploads so we have provided here that
        // the authorization to list multipart uploads is the same
        // as listing objects in a bucket.
        requestType: request.apiMethods || 'bucketGet',
        preciseRequestType: request.apiMethods || 'listMultipartUploads',
        request,
    };

    async.waterfall([
        function waterfall1(next) {
            // Check final destination bucket for authorization rather
            // than multipart upload bucket
            standardMetadataValidateBucket(metadataValParams, request.actionImplicitDenies, log,
                (err, bucket) => next(err, bucket));
        },
        function getMPUBucket(bucket, next) {
            services.getMPUBucket(bucket, bucketName, log,
                (err, mpuBucket) => next(err, bucket, mpuBucket));
        },
        function waterfall2(bucket, mpuBucket, next) {
            let splitter = constants.splitter;
            // BACKWARD: Remove to remove the old splitter
            if (mpuBucket.getMdBucketModelVersion() < 2) {
                splitter = constants.oldSplitter;
            }
            let maxUploads = query['max-uploads'] !== undefined ?
                Number.parseInt(query['max-uploads'], 10) : 1000;
            if (maxUploads < 0) {
                monitoring.promMetrics('GET', bucketName, 400,
                    'listMultipartUploads');
                return callback(errors.InvalidArgument, bucket);
            }
            if (maxUploads > constants.listingHardLimit) {
                maxUploads = constants.listingHardLimit;
            }
            const listingParams = {
                delimiter: query.delimiter,
                keyMarker: query['key-marker'],
                uploadIdMarker: query['upload-id-marker'],
                maxKeys: maxUploads,
                prefix: `overview${splitter}${prefix}`,
                queryPrefixLength: prefix.length,
                listingType: 'MPU',
                splitter,
            };
            services.getMultipartUploadListing(mpuBucketName, listingParams,
                log, (err, list) => next(err, bucket, list));
            return undefined;
        },
    ], (err, bucket, list) => {
        const corsHeaders = collectCorsHeaders(request.headers.origin,
            request.method, bucket);
        if (err) {
            monitoring.promMetrics('GET', bucketName, err.code,
                'listMultipartUploads');
            return callback(err, null, corsHeaders);
        }
        const xmlParams = {
            bucketName,
            encoding,
            list,
            prefix: query.prefix,
            keyMarker: query['key-marker'],
            uploadIdMarker: query['upload-id-marker'],
        };
        const xml = convertToXml('listMultipartUploads', xmlParams);
        pushMetric('listMultipartUploads', log, {
            authInfo,
            bucket: bucketName,
        });
        monitoring.promMetrics(
            'GET', bucketName, '200', 'listMultipartUploads');
        return callback(null, xml, corsHeaders);
    });
}
list multipart uploads - Return list of open multipart uploads
@param {AuthInfo} authInfo - Instance of AuthInfo class with requester's info
@param {object} request - http request object
@param {object} log - Werelogs logger
@param {function} callback - callback to respond to http request
 with either error code or xml response body
@return {undefined}