Function callApiHandler

lib/api/api.js:246–431

(apiMethod, apiHandler, request, response, log, callback)

}

function callApiHandler(apiMethod, apiHandler, request, response, log, callback) {
    let returnTagCount = true;

    const validationRes = validateQueryAndHeaders(request, log);
    if (validationRes.error) {
        log.debug('request query / header validation failed', {
            error: validationRes.error,
            method: 'api.callApiMethod',
        });
        return process.nextTick(callback, validationRes.error);
    }

    // no need to check auth on website or cors preflight requests
    if (apiMethod === 'websiteGet' || apiMethod === 'websiteHead' ||
    apiMethod === 'corsPreflight') {
        request.actionImplicitDenies = false;
        return apiHandler(request, log, callback);
    }

    const { sourceBucket, sourceObject, sourceVersionId, parsingError } =
        parseCopySource(apiMethod, request.headers['x-amz-copy-source']);
    if (parsingError) {
        log.debug('error parsing copy source', {
            error: parsingError,
        });
        return process.nextTick(callback, parsingError);
    }

    const { httpHeadersSizeError } = checkHttpHeadersSize(request.headers);
    if (httpHeadersSizeError) {
        log.debug('http header size limit exceeded', {
            error: httpHeadersSizeError,
        });
        return process.nextTick(callback, httpHeadersSizeError);
    }

    const requestContexts = prepareRequestContexts(apiMethod, request,
        sourceBucket, sourceObject, sourceVersionId);

    // Extract all the _apiMethods and store them in an array
    const apiMethods = requestContexts ? requestContexts.map(context => context._apiMethod) : [];
    // Attach the names to the current request
    request.apiMethods = apiMethods;

    return async.waterfall([
        next => auth.server.doAuth(
            request, log, (err, userInfo, authorizationResults, streamingV4Params, infos) => {
                if (request.serverAccessLog) {
                    request.serverAccessLog.authInfo = userInfo;
                }
                if (err) {
                    // VaultClient returns standard errors, but the route requires
                    // Arsenal errors
                    const arsenalError = err.metadata ? err : errors[err.code] || errors.InternalError;
                    log.trace('authentication error', { error: err });
                    return next(arsenalError);
                }
                return next(null, userInfo, authorizationResults, streamingV4Params, infos);