remove unused functions and introduce new helpers

Author: benzekrimaha

tests/functional/raw-node/utils/gcpUtils.js

@@ -1,51 +1,112 @@
 const async = require('async');
-const assert = require('assert');
+const { callbackify } = require('util');
 const { v4: uuidv4 } = require('uuid');
-
-const { makeGcpRequest } = require('./makeRequest');
+const { HeadBucketCommand } = require('@aws-sdk/client-s3');
 
 const genUniqID = () => uuidv4().replace(/-/g, '');
 
-function gcpRequestRetry(params, retry, callback) {
-    const maxRetries = 4;
-    const timeout = Math.pow(2, retry) * 1000;
-    return setTimeout(makeGcpRequest, timeout, params, (err, res) => {
-        if (err) {
-            if (retry <= maxRetries && err.statusCode === 429) {
-                return gcpRequestRetry(params, retry + 1, callback);
+const defaultShouldRetry = err =>
+    err && (err.name === 'SlowDown' || err.$metadata?.httpStatusCode === 429);
+
+async function gcpRetryCall(callFn, retryOptions) {
+    const {
+        maxAttempts = 3,
+        shouldRetry = defaultShouldRetry,
+        getDelayMs = attempt => Math.pow(2, attempt) * 1000,
+    } = retryOptions || {};
+
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+             
+            return await callFn();
+        } catch (err) {
+            lastError = err;
+            if (!shouldRetry(err, attempt) || attempt === maxAttempts - 1) {
+                throw err;
             }
-            return callback(err);
+            const delay = getDelayMs(attempt);
+            process.stdout.write(
+                'Retryable error from GCP, retrying in ' +
+                `${delay}ms (attempt ${attempt + 1}): ${err}\n`);
+             
+            await new Promise(resolve => setTimeout(resolve, delay));
         }
-        return callback(null, res);
-    });
+    }
+
+    throw lastError;
 }
 
-function gcpClientRetry(fn, params, callback, retry = 0) {
-    const maxRetries = 4;
-    const timeout = Math.pow(2, retry) * 1000;
-    return setTimeout(fn, timeout, params, (err, res) => {
-        if (err) {
-            if (retry <= maxRetries && err.statusCode === 429) {
-                return gcpClientRetry(fn, params, callback, retry + 1);
+async function gcpRetry(gcpClient, command, retryOptions, cb) {
+    if (cb) {
+        return callbackify(() => gcpRetry(gcpClient, command,
+            retryOptions))(cb);
+    }
+
+    return gcpRetryCall(() => gcpClient.send(command), retryOptions);
+}
+
+const defaultShouldRetryUpload = err => err && (
+    err.name === 'NoSuchBucket'
+    || err.name === 'NotFound'
+    || err.$metadata?.httpStatusCode === 404
+    || err.name === 'SlowDown'
+    || err.$metadata?.httpStatusCode === 429
+    || (typeof err.message === 'string'
+        && (err.message.includes('NoSuchBucket')
+            || err.message.includes('unable to complete upload')))
+);
+
+const defaultShouldRetryMpuCreate = err => err && (
+    err.name === 'NoSuchBucket'
+    || err.name === 'NotFound'
+    || err.$metadata?.httpStatusCode === 404
+    || err.name === 'SlowDown'
+    || err.$metadata?.httpStatusCode === 429
+);
+
+async function gcpUploadWithRetry(gcpClient, params, retryOptions) {
+    const callFn = () => new Promise((resolve, reject) => {
+        gcpClient.upload(params, (err, data) => {
+            if (err) {
+                return reject(err);
             }
-            return callback(err);
-        }
-        return callback(null, res);
+            return resolve(data);
+        });
+    });
+
+    return gcpRetryCall(callFn, {
+        maxAttempts: 6,
+        shouldRetry: defaultShouldRetryUpload,
+        getDelayMs: attempt => (attempt + 1) * 1000,
+        ...retryOptions,
+    });
+}
+
+async function gcpCreateMultipartUploadWithRetry(gcpClient, params, retryOptions) {
+    const callFn = () => new Promise((resolve, reject) => {
+        gcpClient.createMultipartUpload(params,
+            (err, res) => (err ? reject(err) : resolve(res)));
+    });
+    return gcpRetryCall(callFn, {
+        maxAttempts: 6,
+        shouldRetry: defaultShouldRetryMpuCreate,
+        getDelayMs: attempt => (attempt + 1) * 1000,
+        ...retryOptions,
     });
 }
 
 // mpu test helpers
 function gcpMpuSetup(params, callback) {
     const { gcpClient, bucketNames, key, partCount, partSize } = params;
+
     return async.waterfall([
-        next => gcpClient.createMultipartUpload({
-            Bucket: bucketNames.mpu.Name,
-            Key: key,
-        }, (err, res) => {
-            assert.equal(err, null,
-                `Expected success, but got error ${err}`);
-            return next(null, res.UploadId);
-        }),
+        next => gcpCreateMultipartUploadWithRetry(gcpClient, {
+                Bucket: bucketNames.mpu.Name,
+                Key: key,
+            })
+                .then(res => next(null, res.UploadId))
+                .catch(err => next(err)),
         (uploadId, next) => {
             if (partCount <= 0) {
                 return next('SkipPutPart', { uploadId });
@@ -141,13 +202,26 @@ function setBucketClass(storageClass) {
         '</CreateBucketConfiguration>';
 }
 
+async function waitForBucketReady(gcpClient, bucketName, retryOptions) {
+    const cmd = new HeadBucketCommand({ Bucket: bucketName });
+    return await gcpRetry(gcpClient, cmd, {
+        maxAttempts: 6,
+        shouldRetry: defaultShouldRetryMpuCreate,
+        getDelayMs: attempt => (attempt + 1) * 1000,
+        ...retryOptions,
+    });
+}
+
 module.exports = {
-    gcpRequestRetry,
-    gcpClientRetry,
     setBucketClass,
     gcpMpuSetup,
     genPutTagObj,
     genGetTagObj,
     genDelTagObj,
     genUniqID,
+    gcpRetryCall,
+    gcpRetry,
+    gcpCreateMultipartUploadWithRetry,
+    gcpUploadWithRetry,
+    waitForBucketReady,
 };

tests/functional/raw-node/utils/makeRequest.js

@@ -185,55 +185,6 @@ function makeS3Request(params, callback) {
     makeRequest(options, callback);
 }
 
-/** makeGcpRequest - utility function to generate a request against GCP
- * @param {object} params - params for making request
- * @param {string} params.method - request method
- * @param {object} [params.queryObj] - query fields and their string values
- * @param {object} [params.headers] - headers and their string values
- * @param {string} [params.bucket] - bucket name
- * @param {string} [params.objectKey] - object key name
- * @param {object} [params.authCredentials] - authentication credentials
- * @param {object} params.authCredentials.accessKey - access key
- * @param {object} params.authCredentials.secretKey - secret key
- * @param {string} [params.region] - request body contents
- * @param {function} callback - with error and response parameters
- * @return {undefined} - and call callback
- */
-async function makeGcpRequest(params, callback) {
-    const { method, queryObj, headers, bucket, objectKey, authCredentials,
-        requestBody, region } = params;
-    
-    let resolvedCredentials = authCredentials;
-    if (authCredentials && typeof authCredentials === 'function') {
-        try {
-           resolvedCredentials = await authCredentials();
-            resolvedCredentials = {
-                accessKey: resolvedCredentials.accessKeyId,
-                secretKey: resolvedCredentials.secretAccessKey,
-            };
-        } catch (err) {
-            return callback(err);
-        }
-    }
-    
-    const options = {
-        authCredentials: resolvedCredentials,
-        requestBody,
-        hostname: 'storage.googleapis.com',
-        port: 80,
-        method,
-        queryObj,
-        headers: headers || {},
-        path: bucket ? `/${bucket}/` : '/',
-        GCP: true,
-        region,
-    };
-    if (objectKey) {
-        options.path = `${options.path}${objectKey}`;
-    }
-    return makeRequest(options, callback);
-}
-
 /** makeBackbeatRequest - utility function to generate a request going
  * through backbeat route
  * @param {object} params - params for making request
@@ -270,6 +221,5 @@ function makeBackbeatRequest(params, callback) {
 module.exports = {
     makeRequest,
     makeS3Request,
-    makeGcpRequest,
     makeBackbeatRequest,
 };