fix: add retries to verification

dist/index.js

@@ -32886,7 +32886,7 @@ var validate_awaiter = (undefined && undefined.__awaiter) || function (thisArg,
 
 
 
-const verify = (filename, platform, version, verbose, failCi) => validate_awaiter(void 0, void 0, void 0, function* () {
+const verify = (filename, platform, version, verbose) => validate_awaiter(void 0, void 0, void 0, function* () {
     try {
         const uploaderName = getUploaderName(platform);
         // Get SHASUM and SHASUM signature files
@@ -32918,8 +32918,8 @@ const verify = (filename, platform, version, verbose, failCi) => validate_awaite
                 core.info(`==> Uploader SHASUM verified (${hash})`);
             }
             else {
-                setFailure('Codecov: Uploader shasum does not match -- ' +
+                throw new Error('Codecov: Uploader shasum does not match -- ' +
-                    `uploader hash: ${hash}, public hash: ${shasum}`, failCi);
+                    `uploader hash: ${hash}, public hash: ${shasum}`);
             }
         });
         const verifySignature = () => {
@@ -32931,7 +32931,7 @@ const verify = (filename, platform, version, verbose, failCi) => validate_awaite
                 external_path_.join(__dirname, `${uploaderName}.SHA256SUM`),
             ], (err, verifyResult) => validate_awaiter(void 0, void 0, void 0, function* () {
                 if (err) {
-                    setFailure('Codecov: Error importing pgp key', failCi);
+                    throw new Error(`Codecov: Error importing pgp key: ${err.message}`);
                 }
                 core.info(verifyResult);
                 yield validateSha();
@@ -32946,14 +32946,14 @@ const verify = (filename, platform, version, verbose, failCi) => validate_awaite
             __nccwpck_require__.ab + "pgp_keys.asc",
         ], (err, importResult) => validate_awaiter(void 0, void 0, void 0, function* () {
             if (err) {
-                setFailure('Codecov: Error importing pgp key', failCi);
+                throw new Error(`Codecov: Error importing pgp key: ${err.message}`);
             }
             core.info(importResult);
             verifySignature();
         }));
     }
     catch (err) {
-        setFailure(`Codecov: Error validating uploader: ${err.message}`, failCi);
+        throw new Error(`Codecov: Error validating uploader: ${err.message}`);
     }
 });
 /* harmony default export */ const validate = (verify);
@@ -33021,7 +33021,21 @@ const run = () => src_awaiter(void 0, void 0, void 0, function* () {
                 setFailure(`Codecov: Failed to write uploader binary: ${err.message}`, true);
             }).on('finish', () => src_awaiter(void 0, void 0, void 0, function* () {
                 filePath.close();
-                yield validate(filename, platform, uploaderVersion, verbose, failCi);
+                let verifyRetries = 3;
+                while (verifyRetries > 0) {
+                    try {
+                        yield validate(filename, platform, uploaderVersion, verbose);
+                        break;
+                    }
+                    catch (err) {
+                        if (verifyRetries > 0) {
+                            verifyRetries--;
+                        }
+                        else {
+                            setFailure(err.message, failCi);
+                        }
+                    }
+                }
                 yield version(platform, uploaderVersion);
                 yield external_fs_.chmodSync(filename, '777');
                 if (!disableSafeDirectory) {

src/index.ts

@@ -55,7 +55,19 @@ const run = async () => {
           }).on('finish', async () => {
             filePath.close();
 
-            await verify(filename, platform, uploaderVersion, verbose, failCi);
+            let verifyRetries = 3;
+            while (verifyRetries > 0) {
+              try {
+                await verify(filename, platform, uploaderVersion, verbose);
+                break;
+              } catch (err) {
+                if (verifyRetries > 0) {
+                  verifyRetries--;
+                } else {
+                  setFailure(err.message, failCi);
+                }
+              }
+            }
             await versionInfo(platform, uploaderVersion);
             await fs.chmodSync(filename, '777');
             if (!disableSafeDirectory) {

src/validate.ts

@@ -9,7 +9,6 @@ import {request} from 'undici';
 import {
   getBaseUrl,
   getUploaderName,
-  setFailure,
 } from './helpers';
 
 const verify = async (
@@ -17,7 +16,6 @@ const verify = async (
     platform: string,
     version: string,
     verbose: boolean,
-    failCi: boolean,
 ): Promise<void> => {
   try {
     const uploaderName = getUploaderName(platform);
@@ -68,10 +66,9 @@ const verify = async (
       if (hash === shasum) {
         core.info(`==> Uploader SHASUM verified (${hash})`);
       } else {
-        setFailure(
+        throw new Error(
             'Codecov: Uploader shasum does not match -- ' +
               `uploader hash: ${hash}, public hash: ${shasum}`,
-            failCi,
         );
       }
     };
@@ -85,7 +82,7 @@ const verify = async (
         path.join(__dirname, `${uploaderName}.SHA256SUM`),
       ], async (err, verifyResult) => {
         if (err) {
-          setFailure(`Codecov: Error importing pgp key: ${err.message}`, failCi);
+          throw new Error(`Codecov: Error importing pgp key: ${err.message}`);
         }
         core.info(verifyResult);
         await validateSha();
@@ -101,13 +98,13 @@ const verify = async (
       path.join(__dirname, 'pgp_keys.asc'),
     ], async (err, importResult) => {
       if (err) {
-        setFailure(`Codecov: Error importing pgp key: ${err.message}`, failCi);
+        throw new Error(`Codecov: Error importing pgp key: ${err.message}`);
       }
       core.info(importResult);
       verifySignature();
     });
   } catch (err) {
-    setFailure(`Codecov: Error validating uploader: ${err.message}`, failCi);
+    throw new Error(`Codecov: Error validating uploader: ${err.message}`);
   }
 };
 export default verify;