From 9ec16e95f3d95dfc19538836564f9e476d6b1622 Mon Sep 17 00:00:00 2001 From: Sankalp Kotewar <98868223+kotewar@users.noreply.github.com> Date: Tue, 20 Dec 2022 10:10:04 +0000 Subject: [PATCH] Basic error handling in wrappers --- dist/restore-only/index.js | 6 +- dist/restore/index.js | 6 +- dist/save-only/index.js | 116 +++++++++++++++++++++++-------------- dist/save/index.js | 108 ++++++++++++++++++++-------------- src/save.ts | 20 ++++++- src/saveImpl.ts | 83 ++++++++++++-------------- src/saveOnly.ts | 12 +++- 7 files changed, 209 insertions(+), 142 deletions(-) diff --git a/dist/restore-only/index.js b/dist/restore-only/index.js index cf72416..b6f4031 100644 --- a/dist/restore-only/index.js +++ b/dist/restore-only/index.js @@ -47354,12 +47354,10 @@ function saveCache(paths, key, options) { } catch (error) { const typedError = error; - if (typedError.name === ValidationError.name) { + if (typedError.name === ValidationError.name || + typedError.name === ReserveCacheError.name) { throw error; } - else if (typedError.name === ReserveCacheError.name) { - core.info(`Failed to save: ${typedError.message}`); - } else { core.warning(`Failed to save: ${typedError.message}`); } diff --git a/dist/restore/index.js b/dist/restore/index.js index 5d3a662..58ea412 100644 --- a/dist/restore/index.js +++ b/dist/restore/index.js @@ -47325,12 +47325,10 @@ function saveCache(paths, key, options) { } catch (error) { const typedError = error; - if (typedError.name === ValidationError.name) { + if (typedError.name === ValidationError.name || + typedError.name === ReserveCacheError.name) { throw error; } - else if (typedError.name === ReserveCacheError.name) { - core.info(`Failed to save: ${typedError.message}`); - } else { core.warning(`Failed to save: ${typedError.message}`); } diff --git a/dist/save-only/index.js b/dist/save-only/index.js index 42f8457..12637e8 100644 --- a/dist/save-only/index.js +++ b/dist/save-only/index.js @@ -1043,6 +1043,29 @@ class ExecState extends events.EventEmitter { "use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } return new (P || (P = Promise))(function (resolve, reject) { @@ -1056,11 +1079,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", { value: true }); +const cache_1 = __webpack_require__(692); +const core = __importStar(__webpack_require__(470)); const saveImpl_1 = __importDefault(__webpack_require__(471)); const stateProvider_1 = __webpack_require__(309); +const utils = __importStar(__webpack_require__(443)); +// Catch and log any unhandled exceptions. These exceptions can leak out of the uploadChunk method in +// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to +// throw an uncaught exception. Instead of failing this action, just warn. +process.on("uncaughtException", e => utils.logWarning(e.message)); function run() { return __awaiter(this, void 0, void 0, function* () { - yield (0, saveImpl_1.default)(new stateProvider_1.NullStateProvider()); + try { + yield (0, saveImpl_1.default)(new stateProvider_1.NullStateProvider()); + } + catch (error) { + const typedError = error; + if (typedError.name === cache_1.ReserveCacheError.name) { + core.info(`Failed to save: ${typedError.message}`); + } + else { + utils.logWarning(error.message); + } + } }); } run(); @@ -41086,47 +41127,38 @@ const cache = __importStar(__webpack_require__(692)); const core = __importStar(__webpack_require__(470)); const constants_1 = __webpack_require__(196); const utils = __importStar(__webpack_require__(443)); -// Catch and log any unhandled exceptions. These exceptions can leak out of the uploadChunk method in -// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to -// throw an uncaught exception. Instead of failing this action, just warn. -process.on("uncaughtException", e => utils.logWarning(e.message)); function saveImpl(stateProvider) { return __awaiter(this, void 0, void 0, function* () { - try { - if (!utils.isCacheFeatureAvailable()) { - return; - } - if (!utils.isValidEvent()) { - utils.logWarning(`Event Validation Error: The event type ${process.env[constants_1.Events.Key]} is not supported because it's not tied to a branch or tag ref.`); - return; - } - // If restore has stored a primary key in state, reuse that - // Else re-evaluate from inputs - const primaryKey = stateProvider.getState(constants_1.State.CachePrimaryKey) || - core.getInput(constants_1.Inputs.Key); - if (!primaryKey) { - utils.logWarning(`Key is not specified.`); - return; - } - // If matched restore key is same as primary key, then do not save cache - // NO-OP in case of SaveOnly action - const restoredKey = stateProvider.getCacheState(); - if (utils.isExactKeyMatch(primaryKey, restoredKey)) { - core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`); - return; - } - const cachePaths = utils.getInputAsArray(constants_1.Inputs.Path, { - required: true - }); - const cacheId = yield cache.saveCache(cachePaths, primaryKey, { - uploadChunkSize: utils.getInputAsInt(constants_1.Inputs.UploadChunkSize) - }); - if (cacheId != -1) { - core.info(`Cache saved with key: ${primaryKey}`); - } + if (!utils.isCacheFeatureAvailable()) { + return; } - catch (error) { - utils.logWarning(error.message); + if (!utils.isValidEvent()) { + utils.logWarning(`Event Validation Error: The event type ${process.env[constants_1.Events.Key]} is not supported because it's not tied to a branch or tag ref.`); + return; + } + // If restore has stored a primary key in state, reuse that + // Else re-evaluate from inputs + const primaryKey = stateProvider.getState(constants_1.State.CachePrimaryKey) || + core.getInput(constants_1.Inputs.Key); + if (!primaryKey) { + utils.logWarning(`Key is not specified.`); + return; + } + // If matched restore key is same as primary key, then do not save cache + // NO-OP in case of SaveOnly action + const restoredKey = stateProvider.getCacheState(); + if (utils.isExactKeyMatch(primaryKey, restoredKey)) { + core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`); + return; + } + const cachePaths = utils.getInputAsArray(constants_1.Inputs.Path, { + required: true + }); + const cacheId = yield cache.saveCache(cachePaths, primaryKey, { + uploadChunkSize: utils.getInputAsInt(constants_1.Inputs.UploadChunkSize) + }); + if (cacheId != -1) { + core.info(`Cache saved with key: ${primaryKey}`); } }); } @@ -47438,12 +47470,10 @@ function saveCache(paths, key, options) { } catch (error) { const typedError = error; - if (typedError.name === ValidationError.name) { + if (typedError.name === ValidationError.name || + typedError.name === ReserveCacheError.name) { throw error; } - else if (typedError.name === ReserveCacheError.name) { - core.info(`Failed to save: ${typedError.message}`); - } else { core.warning(`Failed to save: ${typedError.message}`); } diff --git a/dist/save/index.js b/dist/save/index.js index d5c5f68..3af9e14 100644 --- a/dist/save/index.js +++ b/dist/save/index.js @@ -41057,47 +41057,38 @@ const cache = __importStar(__webpack_require__(692)); const core = __importStar(__webpack_require__(470)); const constants_1 = __webpack_require__(196); const utils = __importStar(__webpack_require__(443)); -// Catch and log any unhandled exceptions. These exceptions can leak out of the uploadChunk method in -// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to -// throw an uncaught exception. Instead of failing this action, just warn. -process.on("uncaughtException", e => utils.logWarning(e.message)); function saveImpl(stateProvider) { return __awaiter(this, void 0, void 0, function* () { - try { - if (!utils.isCacheFeatureAvailable()) { - return; - } - if (!utils.isValidEvent()) { - utils.logWarning(`Event Validation Error: The event type ${process.env[constants_1.Events.Key]} is not supported because it's not tied to a branch or tag ref.`); - return; - } - // If restore has stored a primary key in state, reuse that - // Else re-evaluate from inputs - const primaryKey = stateProvider.getState(constants_1.State.CachePrimaryKey) || - core.getInput(constants_1.Inputs.Key); - if (!primaryKey) { - utils.logWarning(`Key is not specified.`); - return; - } - // If matched restore key is same as primary key, then do not save cache - // NO-OP in case of SaveOnly action - const restoredKey = stateProvider.getCacheState(); - if (utils.isExactKeyMatch(primaryKey, restoredKey)) { - core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`); - return; - } - const cachePaths = utils.getInputAsArray(constants_1.Inputs.Path, { - required: true - }); - const cacheId = yield cache.saveCache(cachePaths, primaryKey, { - uploadChunkSize: utils.getInputAsInt(constants_1.Inputs.UploadChunkSize) - }); - if (cacheId != -1) { - core.info(`Cache saved with key: ${primaryKey}`); - } + if (!utils.isCacheFeatureAvailable()) { + return; } - catch (error) { - utils.logWarning(error.message); + if (!utils.isValidEvent()) { + utils.logWarning(`Event Validation Error: The event type ${process.env[constants_1.Events.Key]} is not supported because it's not tied to a branch or tag ref.`); + return; + } + // If restore has stored a primary key in state, reuse that + // Else re-evaluate from inputs + const primaryKey = stateProvider.getState(constants_1.State.CachePrimaryKey) || + core.getInput(constants_1.Inputs.Key); + if (!primaryKey) { + utils.logWarning(`Key is not specified.`); + return; + } + // If matched restore key is same as primary key, then do not save cache + // NO-OP in case of SaveOnly action + const restoredKey = stateProvider.getCacheState(); + if (utils.isExactKeyMatch(primaryKey, restoredKey)) { + core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`); + return; + } + const cachePaths = utils.getInputAsArray(constants_1.Inputs.Path, { + required: true + }); + const cacheId = yield cache.saveCache(cachePaths, primaryKey, { + uploadChunkSize: utils.getInputAsInt(constants_1.Inputs.UploadChunkSize) + }); + if (cacheId != -1) { + core.info(`Cache saved with key: ${primaryKey}`); } }); } @@ -47169,6 +47160,29 @@ exports.default = _default; "use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } return new (P || (P = Promise))(function (resolve, reject) { @@ -47184,9 +47198,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) { Object.defineProperty(exports, "__esModule", { value: true }); const saveImpl_1 = __importDefault(__webpack_require__(471)); const stateProvider_1 = __webpack_require__(309); +const utils = __importStar(__webpack_require__(443)); +// Catch and log any unhandled exceptions. These exceptions can leak out of the uploadChunk method in +// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to +// throw an uncaught exception. Instead of failing this action, just warn. +process.on("uncaughtException", e => utils.logWarning(e.message)); function run() { return __awaiter(this, void 0, void 0, function* () { - yield (0, saveImpl_1.default)(new stateProvider_1.StateProvider()); + try { + yield (0, saveImpl_1.default)(new stateProvider_1.StateProvider()); + } + catch (error) { + utils.logWarning(error.message); + } }); } run(); @@ -47438,12 +47462,10 @@ function saveCache(paths, key, options) { } catch (error) { const typedError = error; - if (typedError.name === ValidationError.name) { + if (typedError.name === ValidationError.name || + typedError.name === ReserveCacheError.name) { throw error; } - else if (typedError.name === ReserveCacheError.name) { - core.info(`Failed to save: ${typedError.message}`); - } else { core.warning(`Failed to save: ${typedError.message}`); } diff --git a/src/save.ts b/src/save.ts index 222c87e..87057ee 100644 --- a/src/save.ts +++ b/src/save.ts @@ -1,8 +1,26 @@ +import { ReserveCacheError } from "@actions/cache"; +import * as core from "@actions/core"; + import saveImpl from "./saveImpl"; import { StateProvider } from "./stateProvider"; +import * as utils from "./utils/actionUtils"; + +// Catch and log any unhandled exceptions. These exceptions can leak out of the uploadChunk method in +// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to +// throw an uncaught exception. Instead of failing this action, just warn. +process.on("uncaughtException", e => utils.logWarning(e.message)); async function run(): Promise { - await saveImpl(new StateProvider()); + try { + await saveImpl(new StateProvider()); + } catch (error: unknown) { + const typedError = error as Error; + if (typedError.name === ReserveCacheError.name) { + core.info(`Failed to save: ${typedError.message}`); + } else { + utils.logWarning((error as Error).message); + } + } } run(); diff --git a/src/saveImpl.ts b/src/saveImpl.ts index 1f0d366..b3882a8 100644 --- a/src/saveImpl.ts +++ b/src/saveImpl.ts @@ -5,61 +5,52 @@ import { Events, Inputs, State } from "./constants"; import { IStateProvider } from "./stateProvider"; import * as utils from "./utils/actionUtils"; -// Catch and log any unhandled exceptions. These exceptions can leak out of the uploadChunk method in -// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to -// throw an uncaught exception. Instead of failing this action, just warn. -process.on("uncaughtException", e => utils.logWarning(e.message)); - async function saveImpl(stateProvider: IStateProvider): Promise { - try { - if (!utils.isCacheFeatureAvailable()) { - return; - } + if (!utils.isCacheFeatureAvailable()) { + return; + } - if (!utils.isValidEvent()) { - utils.logWarning( - `Event Validation Error: The event type ${ - process.env[Events.Key] - } is not supported because it's not tied to a branch or tag ref.` - ); - return; - } + if (!utils.isValidEvent()) { + utils.logWarning( + `Event Validation Error: The event type ${ + process.env[Events.Key] + } is not supported because it's not tied to a branch or tag ref.` + ); + return; + } - // If restore has stored a primary key in state, reuse that - // Else re-evaluate from inputs - const primaryKey = - stateProvider.getState(State.CachePrimaryKey) || - core.getInput(Inputs.Key); + // If restore has stored a primary key in state, reuse that + // Else re-evaluate from inputs + const primaryKey = + stateProvider.getState(State.CachePrimaryKey) || + core.getInput(Inputs.Key); - if (!primaryKey) { - utils.logWarning(`Key is not specified.`); - return; - } + if (!primaryKey) { + utils.logWarning(`Key is not specified.`); + return; + } - // If matched restore key is same as primary key, then do not save cache - // NO-OP in case of SaveOnly action - const restoredKey = stateProvider.getCacheState(); + // If matched restore key is same as primary key, then do not save cache + // NO-OP in case of SaveOnly action + const restoredKey = stateProvider.getCacheState(); - if (utils.isExactKeyMatch(primaryKey, restoredKey)) { - core.info( - `Cache hit occurred on the primary key ${primaryKey}, not saving cache.` - ); - return; - } + if (utils.isExactKeyMatch(primaryKey, restoredKey)) { + core.info( + `Cache hit occurred on the primary key ${primaryKey}, not saving cache.` + ); + return; + } - const cachePaths = utils.getInputAsArray(Inputs.Path, { - required: true - }); + const cachePaths = utils.getInputAsArray(Inputs.Path, { + required: true + }); - const cacheId = await cache.saveCache(cachePaths, primaryKey, { - uploadChunkSize: utils.getInputAsInt(Inputs.UploadChunkSize) - }); + const cacheId = await cache.saveCache(cachePaths, primaryKey, { + uploadChunkSize: utils.getInputAsInt(Inputs.UploadChunkSize) + }); - if (cacheId != -1) { - core.info(`Cache saved with key: ${primaryKey}`); - } - } catch (error: unknown) { - utils.logWarning((error as Error).message); + if (cacheId != -1) { + core.info(`Cache saved with key: ${primaryKey}`); } } diff --git a/src/saveOnly.ts b/src/saveOnly.ts index e028d0e..cc886b7 100644 --- a/src/saveOnly.ts +++ b/src/saveOnly.ts @@ -1,8 +1,18 @@ import saveImpl from "./saveImpl"; import { NullStateProvider } from "./stateProvider"; +import * as utils from "./utils/actionUtils"; + +// Catch and log any unhandled exceptions. These exceptions can leak out of the uploadChunk method in +// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to +// throw an uncaught exception. Instead of failing this action, just warn. +process.on("uncaughtException", e => utils.logWarning(e.message)); async function run(): Promise { - await saveImpl(new NullStateProvider()); + try { + await saveImpl(new NullStateProvider()); + } catch (error: unknown) { + utils.logWarning((error as Error).message); + } } run();