Function runWebsite

lib/api/website.js:203–307

* Recursive function with 1 recursive call to look for index * in case of error for potential redirect to folder notation * if there is not already an index appended * @param {Error} [originalError] - presence of this argument * differentiates original user reques

(originalError)

         * @returns {undefined}
         */
        function runWebsite(originalError) {
            // get object metadata and check authorization and header
            // validation
            return metadata.getObjectMD(bucketName, request.objectKey, {}, log,
                (err, objMD) => {
                    // Note: In case of error, we intentionally send the original
                    // object key to _errorActions as in case of a redirect, we do
                    // not want to append index key to redirect location
                    if (err) {
                        log.trace('error retrieving object metadata',
                        { error: err });
                        let returnErr = err;
                        const bucketAuthorized = isBucketAuthorized(bucket, request.apiMethods || 'bucketGet',
                        constants.publicId, null, log, request, request.actionImplicitDenies, true);
                        // if index object does not exist and bucket is private AWS
                        // returns 403 - AccessDenied error.
                        if (err.is.NoSuchKey && !bucketAuthorized) {
                            returnErr = errors.AccessDenied;
                        }

                        // Check if key is a folder containing index for redirect 302
                        // https://docs.aws.amazon.com/AmazonS3/latest/userguide/IndexDocumentSupport.html
                        if (!originalError && reqObjectKey && !reqObjectKey.endsWith('/')) {
                            appendWebsiteIndexDocument(request, websiteConfig.getIndexDocument(), true);
                            // propagate returnErr as originalError to be used if index is not found
                            return runWebsite(returnErr);
                        }

                        return _errorActions(originalError || returnErr,
                        websiteConfig.getErrorDocument(), routingRules,
                        bucket, reqObjectKey, corsHeaders, request, log,
                        callback);
                    }
                    if (!isObjAuthorized(bucket, objMD, request.apiMethods || 'objectGet',
                        constants.publicId, null, log, request, request.actionImplicitDenies, true)) {
                        const err = errors.AccessDenied;
                        log.trace('request not authorized', { error: err });
                        return _errorActions(err, websiteConfig.getErrorDocument(),
                            routingRules, bucket,
                            reqObjectKey, corsHeaders, request, log, callback);
                    }

                    // access granted to index document, needs a redirect 302
                    // to the original key with trailing /
                    if (originalError) {
                        const redirectInfo = { withError: true,
                            location: `/${reqObjectKey}/` };
                        return callback(errors.Found, false, null, corsHeaders,
                            redirectInfo, '');
                    }

                    const headerValResult = validateHeaders(request.headers,
                        objMD['last-modified'], objMD['content-md5']);
                    if (headerValResult.error) {
                        const err = headerValResult.error;
                        log.trace('header validation error', { error: err });
                        return _errorActions(err, websiteConfig.getErrorDocument(),
                            routingRules, bucket, reqObjectKey,