From db5738640c4e6bbff3a048014aa663e22e7dabbe Mon Sep 17 00:00:00 2001 From: Michael J Mulligan Date: Wed, 7 Apr 2021 20:49:04 +0100 Subject: [PATCH] Better env failover. I have been jumping through way too many hoops to make the non-standard checks on origin behave properly, oh well. --- dist/post_run/index.js | 70 +++++++++++++++++++++++---------------- dist/pre/index.js | 70 +++++++++++++++++++++++---------------- dist/run/index.js | 70 +++++++++++++++++++++++---------------- src/run.ts | 75 +++++++++++++++++++++++++----------------- 4 files changed, 171 insertions(+), 114 deletions(-) diff --git a/dist/post_run/index.js b/dist/post_run/index.js index aff7eb2..6506a8b 100644 --- a/dist/post_run/index.js +++ b/dist/post_run/index.js @@ -6903,37 +6903,43 @@ function resolveCheckRunId(checkRunIdent) { function prepareEnv() { return __awaiter(this, void 0, void 0, function* () { const startedAt = Date.now(); - // Resolve Check Run ID - const prepareCheckRunIdentPromise = prepareCheckRunIdent(); + const checkRunPromise = (() => __awaiter(this, void 0, void 0, function* () { + let checkRunIdent; + try { + checkRunIdent = JSON.parse(core.getState(constants_1.Env.CheckRunIdent)); + } + catch (e) { + checkRunIdent = undefined; + } + if (!checkRunIdent) { + core.saveState(constants_1.Env.CheckRunIdent, JSON.stringify((checkRunIdent = yield prepareCheckRunIdent()))); + } + return checkRunIdent; + }))(); + const prepareLintPromise = (() => __awaiter(this, void 0, void 0, function* () { + let lintPath = core.getState(constants_1.Env.LintPath); + if (!lintPath) { + core.saveState(constants_1.Env.LintPath, (lintPath = yield prepareLint())); + } + return lintPath; + }))(); + const patchPromise = (() => __awaiter(this, void 0, void 0, function* () { + let patchPath = core.getState(constants_1.Env.PatchPath); + if (!patchPath) { + core.saveState(constants_1.Env.PatchPath, (patchPath = yield fetchPatch())); + } + return patchPath; + }))(); // Prepare cache, lint and go in parallel. const restoreCachePromise = cache_1.restoreCache(); - const prepareLintPromise = prepareLint(); const installGoPromise = install_1.installGo(); - const patchPromise = fetchPatch(); - core.saveState(constants_1.Env.LintPath, yield prepareLintPromise); + const lintPath = yield prepareLintPromise; + const patchPath = yield patchPromise; + const checkRunIdent = yield checkRunPromise; yield installGoPromise; yield restoreCachePromise; - core.saveState(constants_1.Env.PatchPath, yield patchPromise); - core.saveState(constants_1.Env.CheckRunIdent, JSON.stringify(yield prepareCheckRunIdentPromise)); core.info(`Prepared env in ${Date.now() - startedAt}ms`); - }); -} -function restoreEnv() { - return __awaiter(this, void 0, void 0, function* () { - const startedAt = Date.now(); - const lintPath = core.getState(constants_1.Env.LintPath); - const patchPath = core.getState(constants_1.Env.PatchPath); - let checkRunId; - try { - const checkRunIdent = JSON.parse(core.getState(constants_1.Env.CheckRunIdent)); - checkRunId = yield resolveCheckRunId(checkRunIdent); - } - catch (e) { - core.info(`::error::Error Resolving Check Run ID: ${e}`); - checkRunId = -1; - } - core.info(`Restored env in ${Date.now() - startedAt}ms`); - return { lintPath, patchPath, checkRunId }; + return { lintPath, patchPath, checkRunIdent }; }); } var LintSeverity; @@ -7200,10 +7206,10 @@ function runLint(lintPath, patchPath, checkRunId) { function setup() { return __awaiter(this, void 0, void 0, function* () { try { - yield core.group(`prepare environment`, prepareEnv); + yield core.group(`pre-prepare environment`, prepareEnv); } catch (error) { - core.error(`Failed to prepare: ${error}, ${error.stack}`); + core.error(`Failed to pre-prepare: ${error}, ${error.stack}`); core.setFailed(error.message); } }); @@ -7212,8 +7218,16 @@ exports.setup = setup; function run() { return __awaiter(this, void 0, void 0, function* () { try { - const { lintPath, patchPath, checkRunId } = yield core.group(`restore environment`, restoreEnv); + const { lintPath, patchPath, checkRunIdent } = yield core.group(`prepare environment`, prepareEnv); core.addPath(path.dirname(lintPath)); + let checkRunId; + try { + checkRunId = yield resolveCheckRunId(checkRunIdent); + } + catch (e) { + core.info(`::error::Error Resolving Check Run ID: ${e}`); + checkRunId = -1; + } yield core.group(`run golangci-lint`, () => runLint(lintPath, patchPath, checkRunId)); } catch (error) { diff --git a/dist/pre/index.js b/dist/pre/index.js index 79c8f34..242ad11 100644 --- a/dist/pre/index.js +++ b/dist/pre/index.js @@ -6903,37 +6903,43 @@ function resolveCheckRunId(checkRunIdent) { function prepareEnv() { return __awaiter(this, void 0, void 0, function* () { const startedAt = Date.now(); - // Resolve Check Run ID - const prepareCheckRunIdentPromise = prepareCheckRunIdent(); + const checkRunPromise = (() => __awaiter(this, void 0, void 0, function* () { + let checkRunIdent; + try { + checkRunIdent = JSON.parse(core.getState(constants_1.Env.CheckRunIdent)); + } + catch (e) { + checkRunIdent = undefined; + } + if (!checkRunIdent) { + core.saveState(constants_1.Env.CheckRunIdent, JSON.stringify((checkRunIdent = yield prepareCheckRunIdent()))); + } + return checkRunIdent; + }))(); + const prepareLintPromise = (() => __awaiter(this, void 0, void 0, function* () { + let lintPath = core.getState(constants_1.Env.LintPath); + if (!lintPath) { + core.saveState(constants_1.Env.LintPath, (lintPath = yield prepareLint())); + } + return lintPath; + }))(); + const patchPromise = (() => __awaiter(this, void 0, void 0, function* () { + let patchPath = core.getState(constants_1.Env.PatchPath); + if (!patchPath) { + core.saveState(constants_1.Env.PatchPath, (patchPath = yield fetchPatch())); + } + return patchPath; + }))(); // Prepare cache, lint and go in parallel. const restoreCachePromise = cache_1.restoreCache(); - const prepareLintPromise = prepareLint(); const installGoPromise = install_1.installGo(); - const patchPromise = fetchPatch(); - core.saveState(constants_1.Env.LintPath, yield prepareLintPromise); + const lintPath = yield prepareLintPromise; + const patchPath = yield patchPromise; + const checkRunIdent = yield checkRunPromise; yield installGoPromise; yield restoreCachePromise; - core.saveState(constants_1.Env.PatchPath, yield patchPromise); - core.saveState(constants_1.Env.CheckRunIdent, JSON.stringify(yield prepareCheckRunIdentPromise)); core.info(`Prepared env in ${Date.now() - startedAt}ms`); - }); -} -function restoreEnv() { - return __awaiter(this, void 0, void 0, function* () { - const startedAt = Date.now(); - const lintPath = core.getState(constants_1.Env.LintPath); - const patchPath = core.getState(constants_1.Env.PatchPath); - let checkRunId; - try { - const checkRunIdent = JSON.parse(core.getState(constants_1.Env.CheckRunIdent)); - checkRunId = yield resolveCheckRunId(checkRunIdent); - } - catch (e) { - core.info(`::error::Error Resolving Check Run ID: ${e}`); - checkRunId = -1; - } - core.info(`Restored env in ${Date.now() - startedAt}ms`); - return { lintPath, patchPath, checkRunId }; + return { lintPath, patchPath, checkRunIdent }; }); } var LintSeverity; @@ -7200,10 +7206,10 @@ function runLint(lintPath, patchPath, checkRunId) { function setup() { return __awaiter(this, void 0, void 0, function* () { try { - yield core.group(`prepare environment`, prepareEnv); + yield core.group(`pre-prepare environment`, prepareEnv); } catch (error) { - core.error(`Failed to prepare: ${error}, ${error.stack}`); + core.error(`Failed to pre-prepare: ${error}, ${error.stack}`); core.setFailed(error.message); } }); @@ -7212,8 +7218,16 @@ exports.setup = setup; function run() { return __awaiter(this, void 0, void 0, function* () { try { - const { lintPath, patchPath, checkRunId } = yield core.group(`restore environment`, restoreEnv); + const { lintPath, patchPath, checkRunIdent } = yield core.group(`prepare environment`, prepareEnv); core.addPath(path.dirname(lintPath)); + let checkRunId; + try { + checkRunId = yield resolveCheckRunId(checkRunIdent); + } + catch (e) { + core.info(`::error::Error Resolving Check Run ID: ${e}`); + checkRunId = -1; + } yield core.group(`run golangci-lint`, () => runLint(lintPath, patchPath, checkRunId)); } catch (error) { diff --git a/dist/run/index.js b/dist/run/index.js index 3a55489..37e0ba2 100644 --- a/dist/run/index.js +++ b/dist/run/index.js @@ -6913,37 +6913,43 @@ function resolveCheckRunId(checkRunIdent) { function prepareEnv() { return __awaiter(this, void 0, void 0, function* () { const startedAt = Date.now(); - // Resolve Check Run ID - const prepareCheckRunIdentPromise = prepareCheckRunIdent(); + const checkRunPromise = (() => __awaiter(this, void 0, void 0, function* () { + let checkRunIdent; + try { + checkRunIdent = JSON.parse(core.getState(constants_1.Env.CheckRunIdent)); + } + catch (e) { + checkRunIdent = undefined; + } + if (!checkRunIdent) { + core.saveState(constants_1.Env.CheckRunIdent, JSON.stringify((checkRunIdent = yield prepareCheckRunIdent()))); + } + return checkRunIdent; + }))(); + const prepareLintPromise = (() => __awaiter(this, void 0, void 0, function* () { + let lintPath = core.getState(constants_1.Env.LintPath); + if (!lintPath) { + core.saveState(constants_1.Env.LintPath, (lintPath = yield prepareLint())); + } + return lintPath; + }))(); + const patchPromise = (() => __awaiter(this, void 0, void 0, function* () { + let patchPath = core.getState(constants_1.Env.PatchPath); + if (!patchPath) { + core.saveState(constants_1.Env.PatchPath, (patchPath = yield fetchPatch())); + } + return patchPath; + }))(); // Prepare cache, lint and go in parallel. const restoreCachePromise = cache_1.restoreCache(); - const prepareLintPromise = prepareLint(); const installGoPromise = install_1.installGo(); - const patchPromise = fetchPatch(); - core.saveState(constants_1.Env.LintPath, yield prepareLintPromise); + const lintPath = yield prepareLintPromise; + const patchPath = yield patchPromise; + const checkRunIdent = yield checkRunPromise; yield installGoPromise; yield restoreCachePromise; - core.saveState(constants_1.Env.PatchPath, yield patchPromise); - core.saveState(constants_1.Env.CheckRunIdent, JSON.stringify(yield prepareCheckRunIdentPromise)); core.info(`Prepared env in ${Date.now() - startedAt}ms`); - }); -} -function restoreEnv() { - return __awaiter(this, void 0, void 0, function* () { - const startedAt = Date.now(); - const lintPath = core.getState(constants_1.Env.LintPath); - const patchPath = core.getState(constants_1.Env.PatchPath); - let checkRunId; - try { - const checkRunIdent = JSON.parse(core.getState(constants_1.Env.CheckRunIdent)); - checkRunId = yield resolveCheckRunId(checkRunIdent); - } - catch (e) { - core.info(`::error::Error Resolving Check Run ID: ${e}`); - checkRunId = -1; - } - core.info(`Restored env in ${Date.now() - startedAt}ms`); - return { lintPath, patchPath, checkRunId }; + return { lintPath, patchPath, checkRunIdent }; }); } var LintSeverity; @@ -7210,10 +7216,10 @@ function runLint(lintPath, patchPath, checkRunId) { function setup() { return __awaiter(this, void 0, void 0, function* () { try { - yield core.group(`prepare environment`, prepareEnv); + yield core.group(`pre-prepare environment`, prepareEnv); } catch (error) { - core.error(`Failed to prepare: ${error}, ${error.stack}`); + core.error(`Failed to pre-prepare: ${error}, ${error.stack}`); core.setFailed(error.message); } }); @@ -7222,8 +7228,16 @@ exports.setup = setup; function run() { return __awaiter(this, void 0, void 0, function* () { try { - const { lintPath, patchPath, checkRunId } = yield core.group(`restore environment`, restoreEnv); + const { lintPath, patchPath, checkRunIdent } = yield core.group(`prepare environment`, prepareEnv); core.addPath(path.dirname(lintPath)); + let checkRunId; + try { + checkRunId = yield resolveCheckRunId(checkRunIdent); + } + catch (e) { + core.info(`::error::Error Resolving Check Run ID: ${e}`); + checkRunId = -1; + } yield core.group(`run golangci-lint`, () => runLint(lintPath, patchPath, checkRunId)); } catch (error) { diff --git a/src/run.ts b/src/run.ts index 10994e0..eaef497 100644 --- a/src/run.ts +++ b/src/run.ts @@ -80,7 +80,7 @@ async function fetchPatch(): Promise { type Env = { lintPath: string patchPath: string - checkRunId: number + checkRunIdent: CheckRunIdent } type CheckRunIdent = { @@ -270,44 +270,52 @@ async function resolveCheckRunId(checkRunIdent: CheckRunIdent): Promise return checkRunId } -async function prepareEnv(): Promise { +async function prepareEnv(): Promise { const startedAt = Date.now() - // Resolve Check Run ID - const prepareCheckRunIdentPromise = prepareCheckRunIdent() + const checkRunPromise = (async () => { + let checkRunIdent: CheckRunIdent | undefined + try { + checkRunIdent = JSON.parse(core.getState(EnvKey.CheckRunIdent)) + } catch (e) { + checkRunIdent = undefined + } + if (!checkRunIdent) { + core.saveState(EnvKey.CheckRunIdent, JSON.stringify((checkRunIdent = await prepareCheckRunIdent()))) + } + + return checkRunIdent + })() + + const prepareLintPromise = (async () => { + let lintPath = core.getState(EnvKey.LintPath) + if (!lintPath) { + core.saveState(EnvKey.LintPath, (lintPath = await prepareLint())) + } + return lintPath + })() + + const patchPromise = (async () => { + let patchPath = core.getState(EnvKey.PatchPath) + if (!patchPath) { + core.saveState(EnvKey.PatchPath, (patchPath = await fetchPatch())) + } + return patchPath + })() // Prepare cache, lint and go in parallel. const restoreCachePromise = restoreCache() - const prepareLintPromise = prepareLint() const installGoPromise = installGo() - const patchPromise = fetchPatch() - core.saveState(EnvKey.LintPath, await prepareLintPromise) + const lintPath = await prepareLintPromise + const patchPath = await patchPromise + const checkRunIdent = await checkRunPromise await installGoPromise await restoreCachePromise - core.saveState(EnvKey.PatchPath, await patchPromise) - core.saveState(EnvKey.CheckRunIdent, JSON.stringify(await prepareCheckRunIdentPromise)) core.info(`Prepared env in ${Date.now() - startedAt}ms`) -} -async function restoreEnv(): Promise { - const startedAt = Date.now() - - const lintPath = core.getState(EnvKey.LintPath) - const patchPath = core.getState(EnvKey.PatchPath) - let checkRunId: number - try { - const checkRunIdent: CheckRunIdent = JSON.parse(core.getState(EnvKey.CheckRunIdent)) - checkRunId = await resolveCheckRunId(checkRunIdent) - } catch (e) { - core.info(`::error::Error Resolving Check Run ID: ${e}`) - checkRunId = -1 - } - - core.info(`Restored env in ${Date.now() - startedAt}ms`) - - return { lintPath, patchPath, checkRunId } + return { lintPath, patchPath, checkRunIdent } } type ExecRes = { @@ -664,17 +672,24 @@ async function runLint(lintPath: string, patchPath: string, checkRunId: number): export async function setup(): Promise { try { - await core.group(`prepare environment`, prepareEnv) + await core.group(`pre-prepare environment`, prepareEnv) } catch (error) { - core.error(`Failed to prepare: ${error}, ${error.stack}`) + core.error(`Failed to pre-prepare: ${error}, ${error.stack}`) core.setFailed(error.message) } } export async function run(): Promise { try { - const { lintPath, patchPath, checkRunId } = await core.group(`restore environment`, restoreEnv) + const { lintPath, patchPath, checkRunIdent } = await core.group(`prepare environment`, prepareEnv) core.addPath(path.dirname(lintPath)) + let checkRunId: number + try { + checkRunId = await resolveCheckRunId(checkRunIdent) + } catch (e) { + core.info(`::error::Error Resolving Check Run ID: ${e}`) + checkRunId = -1 + } await core.group(`run golangci-lint`, () => runLint(lintPath, patchPath, checkRunId)) } catch (error) { core.error(`Failed to run: ${error}, ${error.stack}`)