nick-fields/retry
0
0
Fork 0
mirror of https://github.com/nick-fields/retry.git synced 2026-02-13 00:25:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor to make testing easier (#90)

Browse Source 
* minor: refactor to make testing easier

* patch: retrieve inputs into object rather than globals

* test: run more "integration" tests in parallel

* test: fix needs and rearrange ci_integration_* jobs

* test: forgot comma

* test: fix sad_path_timeout_minutes assertions

* test: add single ci_all_tests_passed job that can be required for CI rather than each individual job

* test: add single ci_all_tests_passed job that can be required for CI rather than each individual job
This commit is contained in:
Nick Fields
2022-08-05 23:31:37 -04:00
committed by GitHub
parent 616fa81820
commit b4fa57557d
5 changed files with 525 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
src/index.ts
View File

@@ -1,24 +1,10 @@
import { getInput, error, warning, info, debug, setOutput } from '@actions/core';
import { error, warning, info, debug, setOutput } from '@actions/core';
import { execSync, spawn } from 'child_process';
import ms from 'milliseconds';
import kill from 'tree-kill';
import { wait } from './util';
// inputs
const TIMEOUT_MINUTES = getInputNumber('timeout_minutes', false);
const TIMEOUT_SECONDS = getInputNumber('timeout_seconds', false);
const MAX_ATTEMPTS = getInputNumber('max_attempts', true) || 3;
const COMMAND = getInput('command', { required: true });
const RETRY_WAIT_SECONDS = getInputNumber('retry_wait_seconds', false) || 10;
const SHELL = getInput('shell');
const POLLING_INTERVAL_SECONDS = getInputNumber('polling_interval_seconds', false) || 1;
const RETRY_ON = getInput('retry_on') || 'any';
const WARNING_ON_RETRY = getInput('warning_on_retry').toLowerCase() === 'true';
const ON_RETRY_COMMAND = getInput('on_retry_command');
const CONTINUE_ON_ERROR = getInputBoolean('continue_on_error');
const NEW_COMMAND_ON_RETRY = getInput('new_command_on_retry');
const RETRY_ON_EXIT_CODE = getInputNumber('retry_on_exit_code', false);
import { getInputs, getTimeout, Inputs, validateInputs } from './inputs';
import { retryWait, wait } from './util';
const OS = process.platform;
const OUTPUT_TOTAL_ATTEMPTS_KEY = 'total_attempts';
@@ -28,117 +14,69 @@ const OUTPUT_EXIT_ERROR_KEY = 'exit_error';
let exit: number;
let done: boolean;
function getInputNumber(id: string, required: boolean): number | undefined {
const input = getInput(id, { required });
const num = Number.parseInt(input);
// empty is ok
if (!input && !required) {
return;
}
if (!Number.isInteger(num)) {
throw `Input ${id} only accepts numbers. Received ${input}`;
}
return num;
}
function getInputBoolean(id: string): boolean {
const input = getInput(id);
if (!['true', 'false'].includes(input.toLowerCase())) {
throw `Input ${id} only accepts boolean values. Received ${input}`;
}
return input.toLowerCase() === 'true';
}
async function retryWait() {
const waitStart = Date.now();
await wait(ms.seconds(RETRY_WAIT_SECONDS));
debug(`Waited ${Date.now() - waitStart}ms`);
debug(`Configured wait: ${ms.seconds(RETRY_WAIT_SECONDS)}ms`);
}
async function validateInputs() {
if ((!TIMEOUT_MINUTES && !TIMEOUT_SECONDS) || (TIMEOUT_MINUTES && TIMEOUT_SECONDS)) {
throw new Error('Must specify either timeout_minutes or timeout_seconds inputs');
}
}
function getTimeout(): number {
if (TIMEOUT_MINUTES) {
return ms.minutes(TIMEOUT_MINUTES);
} else if (TIMEOUT_SECONDS) {
return ms.seconds(TIMEOUT_SECONDS);
}
throw new Error('Must specify either timeout_minutes or timeout_seconds inputs');
}
function getExecutable(): string {
if (!SHELL) {
function getExecutable(inputs: Inputs): string {
if (!inputs.shell) {
return OS === 'win32' ? 'powershell' : 'bash';
}
let executable: string;
switch (SHELL) {
switch (inputs.shell) {
case 'bash':
case 'python':
case 'pwsh': {
executable = SHELL;
executable = inputs.shell;
break;
}
case 'sh': {
if (OS === 'win32') {
throw new Error(`Shell ${SHELL} not allowed on OS ${OS}`);
throw new Error(`Shell ${inputs.shell} not allowed on OS ${OS}`);
}
executable = SHELL;
executable = inputs.shell;
break;
}
case 'cmd':
case 'powershell': {
if (OS !== 'win32') {
throw new Error(`Shell ${SHELL} not allowed on OS ${OS}`);
throw new Error(`Shell ${inputs.shell} not allowed on OS ${OS}`);
}
executable = SHELL + '.exe';
executable = inputs.shell + '.exe';
break;
}
default: {
throw new Error(
`Shell ${SHELL} not supported. See https://docs.github.com/en/free-pro-team@latest/actions/reference/workflow-syntax-for-github-actions#using-a-specific-shell for supported shells`
`Shell ${inputs.shell} not supported. See https://docs.github.com/en/free-pro-team@latest/actions/reference/workflow-syntax-for-github-actions#using-a-specific-shell for supported shells`
);
}
}
return executable;
}
async function runRetryCmd(): Promise<void> {
async function runRetryCmd(inputs: Inputs): Promise<void> {
// if no retry script, just continue
if (!ON_RETRY_COMMAND) {
if (!inputs.on_retry_command) {
return;
}
try {
await execSync(ON_RETRY_COMMAND, { stdio: 'inherit' });
await execSync(inputs.on_retry_command, { stdio: 'inherit' });
// eslint-disable-next-line
} catch (error: any) {
info(`WARNING: Retry command threw the error ${error.message}`);
}
}
async function runCmd(attempt: number) {
const end_time = Date.now() + getTimeout();
const executable = getExecutable();
async function runCmd(attempt: number, inputs: Inputs) {
const end_time = Date.now() + getTimeout(inputs);
const executable = getExecutable(inputs);
exit = 0;
done = false;
debug(`Running command ${COMMAND} on ${OS} using shell ${executable}`);
debug(`Running command ${inputs.command} on ${OS} using shell ${executable}`);
const child =
attempt > 1 && NEW_COMMAND_ON_RETRY
? spawn(NEW_COMMAND_ON_RETRY, { shell: executable })
: spawn(COMMAND, { shell: executable });
attempt > 1 && inputs.new_command_on_retry
? spawn(inputs.new_command_on_retry, { shell: executable })
: spawn(inputs.command, { shell: executable });
child.stdout?.on('data', (data) => {
process.stdout.write(data);
@@ -161,46 +99,46 @@ async function runCmd(attempt: number) {
});
do {
await wait(ms.seconds(POLLING_INTERVAL_SECONDS));
await wait(ms.seconds(inputs.polling_interval_seconds));
} while (Date.now() < end_time && !done);
if (!done && child.pid) {
kill(child.pid);
await retryWait();
throw new Error(`Timeout of ${getTimeout()}ms hit`);
await retryWait(ms.seconds(inputs.retry_wait_seconds));
throw new Error(`Timeout of ${getTimeout(inputs)}ms hit`);
} else if (exit > 0) {
await retryWait();
await retryWait(ms.seconds(inputs.retry_wait_seconds));
throw new Error(`Child_process exited with error code ${exit}`);
} else {
return;
}
}
async function runAction() {
await validateInputs();
async function runAction(inputs: Inputs) {
await validateInputs(inputs);
for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
for (let attempt = 1; attempt <= inputs.max_attempts; attempt++) {
try {
// just keep overwriting attempts output
setOutput(OUTPUT_TOTAL_ATTEMPTS_KEY, attempt);
await runCmd(attempt);
await runCmd(attempt, inputs);
info(`Command completed after ${attempt} attempt(s).`);
break;
// eslint-disable-next-line
} catch (error: any) {
if (attempt === MAX_ATTEMPTS) {
if (attempt === inputs.max_attempts) {
throw new Error(`Final attempt failed. ${error.message}`);
} else if (!done && RETRY_ON === 'error') {
} else if (!done && inputs.retry_on === 'error') {
// error: timeout
throw error;
} else if (RETRY_ON_EXIT_CODE && RETRY_ON_EXIT_CODE !== exit) {
} else if (inputs.retry_on_exit_code && inputs.retry_on_exit_code !== exit) {
throw error;
} else if (exit > 0 && RETRY_ON === 'timeout') {
} else if (exit > 0 && inputs.retry_on === 'timeout') {
// error: error
throw error;
} else {
await runRetryCmd();
if (WARNING_ON_RETRY) {
await runRetryCmd(inputs);
if (inputs.warning_on_retry) {
warning(`Attempt ${attempt} failed. Reason: ${error.message}`);
} else {
info(`Attempt ${attempt} failed. Reason: ${error.message}`);
@@ -210,7 +148,9 @@ async function runAction() {
}
}
runAction()
const inputs = getInputs();
runAction(inputs)
.then(() => {
setOutput(OUTPUT_EXIT_CODE_KEY, 0);
process.exit(0); // success
@@ -219,7 +159,7 @@ runAction()
// exact error code if available, otherwise just 1
const exitCode = exit > 0 ? exit : 1;
if (CONTINUE_ON_ERROR) {
if (inputs.continue_on_error) {
warning(err.message);
} else {
error(err.message);
@@ -231,5 +171,5 @@ runAction()
// if continue_on_error, exit with exact error code else exit gracefully
// mimics native continue-on-error that is not supported in composite actions
process.exit(CONTINUE_ON_ERROR ? 0 : exitCode);
process.exit(inputs.continue_on_error ? 0 : exitCode);
});

94
src/inputs.ts Normal file
View File

@@ -0,0 +1,94 @@
import { getInput } from '@actions/core';
import ms from 'milliseconds';
export interface Inputs {
timeout_minutes: number | undefined;
timeout_seconds: number | undefined;
max_attempts: number;
command: string;
retry_wait_seconds: number;
shell: string | undefined;
polling_interval_seconds: number;
retry_on: string | undefined;
warning_on_retry: boolean;
on_retry_command: string | undefined;
continue_on_error: boolean;
new_command_on_retry: string | undefined;
retry_on_exit_code: number | undefined;
}
export function getInputNumber(id: string, required: boolean): number | undefined {
const input = getInput(id, { required });
const num = Number.parseInt(input);
// empty is ok
if (!input && !required) {
return;
}
if (!Number.isInteger(num)) {
throw `Input ${id} only accepts numbers. Received ${input}`;
}
return num;
}
export function getInputBoolean(id: string): boolean {
const input = getInput(id);
if (!['true', 'false'].includes(input.toLowerCase())) {
throw `Input ${id} only accepts boolean values. Received ${input}`;
}
return input.toLowerCase() === 'true';
}
export async function validateInputs(inputs: Inputs) {
if (
(!inputs.timeout_minutes && !inputs.timeout_seconds) ||
(inputs.timeout_minutes && inputs.timeout_seconds)
) {
throw new Error('Must specify either timeout_minutes or timeout_seconds inputs');
}
}
export function getTimeout(inputs: Inputs): number {
if (inputs.timeout_minutes) {
return ms.minutes(inputs.timeout_minutes);
} else if (inputs.timeout_seconds) {
return ms.seconds(inputs.timeout_seconds);
}
throw new Error('Must specify either timeout_minutes or timeout_seconds inputs');
}
export function getInputs(): Inputs {
const timeout_minutes = getInputNumber('timeout_minutes', false);
const timeout_seconds = getInputNumber('timeout_seconds', false);
const max_attempts = getInputNumber('max_attempts', true) || 3;
const command = getInput('command', { required: true });
const retry_wait_seconds = getInputNumber('retry_wait_seconds', false) || 10;
const shell = getInput('shell');
const polling_interval_seconds = getInputNumber('polling_interval_seconds', false) || 1;
const retry_on = getInput('retry_on') || 'any';
const warning_on_retry = getInput('warning_on_retry').toLowerCase() === 'true';
const on_retry_command = getInput('on_retry_command');
const continue_on_error = getInputBoolean('continue_on_error');
const new_command_on_retry = getInput('new_command_on_retry');
const retry_on_exit_code = getInputNumber('retry_on_exit_code', false);
return {
timeout_minutes,
timeout_seconds,
max_attempts,
command,
retry_wait_seconds,
shell,
polling_interval_seconds,
retry_on,
warning_on_retry,
on_retry_command,
continue_on_error,
new_command_on_retry,
retry_on_exit_code,
};
}

9
src/util.ts
View File

@@ -1,3 +1,12 @@
import { debug } from '@actions/core';
export async function wait(ms: number) {
return new Promise((r) => setTimeout(r, ms));
}
export async function retryWait(retryWaitSeconds: number) {
const waitStart = Date.now();
await wait(retryWaitSeconds);
debug(`Waited ${Date.now() - waitStart}ms`);
debug(`Configured wait: ${retryWaitSeconds}ms`);
}