https://github.com/simple-automation-testing/process-rerun
Run your processes in parallel mode with possibility to re-run them on fail
https://github.com/simple-automation-testing/process-rerun
flaky-proceses flaky-tests parallel-execution parallel-processing processing ret retry
Last synced: 6 months ago
JSON representation
Run your processes in parallel mode with possibility to re-run them on fail
- Host: GitHub
- URL: https://github.com/simple-automation-testing/process-rerun
- Owner: Simple-Automation-Testing
- License: mit
- Created: 2018-08-04T08:27:44.000Z (almost 7 years ago)
- Default Branch: master
- Last Pushed: 2022-11-10T11:36:26.000Z (over 2 years ago)
- Last Synced: 2024-11-11T19:38:12.932Z (6 months ago)
- Topics: flaky-proceses, flaky-tests, parallel-execution, parallel-processing, processing, ret, retry
- Language: TypeScript
- Homepage:
- Size: 152 KB
- Stars: 14
- Watchers: 2
- Forks: 5
- Open Issues: 0
-
Metadata Files:
- Readme: readme.md
Awesome Lists containing this project
README
# process-rerun
The purpose of this library is - build simple and flexible interface for parallel command execution with rerun (on fail) possibility
[Documents](#documents)
[Usage](#usage)
[getFilesList](#getfileslist)
[Changelog](#changelog)
## Documents
**buildRunner(buildOpts): returns rerunner: function(string[]): {retriable: string[]; notRetriable: string[]}**
arguments | description
--- | ---
**`buildOpts`** | Type: `object`
Options for executor
**`buildOpts.maxThreads`** | **Optional** Type: `number`,
How many threads can be executed in same time
**Default threads count is 5**
**`buildOpts.intime`** | **Optional** Type: `boolean`,
if intime is true intime execution approach will be enabled
**Default is false**
**`buildOpts.shuffle`** | **Optional** Type: `boolean`,
Shuffle commands during execution
**Default threads count is 5**
**`buildOpts.attemptsCount`** | **Optional** Type: `number`,
How many times can we try to execute command for success result **in next cycle will be executed only faild command, success commands will not be reexecuted**
**Default attempts count is 2**
**`buildOpts.pollTime`** | **Optional** Type: `number`,
Period for recheck about free thread
**Default is 1 second**
**`buildOpts.successExitCode`** | **Optional** Type: `number`,
Exit code what will be used for succes process check
**Default is 0**
**`buildOpts.logLevel`** | Type: `string`, one of 'ERROR', 'WARN', 'INFO', 'VERBOSE', 'MUTE'
ERROR - only errors, WARN - errors and warnings, INFO - errors, warnings and information, VERBOSE - full logging, MUTE - mute execution output
**Default is 'ERROR'**
**`buildOpts.currentExecutionVariable`** | **Optional** Type: `string`, will be execution variable with execution index for every cycle will be ++
**`buildOpts.everyCycleCallback`** | **Optional** Type: `function`,
Optional. everyCycleCallback will be executed after cycle, before next execution cycle.
**Default is false**
**`buildOpts.processResultAnalyzer`** | **Optional** Type: `function`,
Optional. processResultAnalyzer is a function where arguments are original command, execution stack trace and notRetriable array processResultAnalyzer should return a new command what will be executed in next cycle or **boolean** - if satisfactory result
**`buildOpts.longestProcessTime`** | **Optional** Type: `number`,
In case if command execution time is longer than longest Process Time - executor will kill it automatically and will try to execute this command again.
**Default time is 45 seconds**
## Usage
```js
const {buildRunner} = require('process-rerun');
async function execCommands() {
const runner = buildRunner({
maxThreads: 10, // ten threads
attemptsCount: 2, // will try to pass all commands two times, one main and one times rerun
longestProcessTime: 60 * 1000,// if command process execution time is longre than 1 minute will kill it and try to pass in next cycle
pollTime: 1000, // will check free thread every second
everyCycleCallback: () => console.log('Cycle done'),
processResultAnalyzer: (cmd, stackTrace, notRetriableArr) => {
if (stackTrace.includes('Should be re executed')) {
return cmd;
}
notRetriableArr.push(cmd)
}, //true - command will be reexecuted
});
const result = await runner([
`node -e 'console.log("Success first")'`,
`node -e 'console.log("Success second")'`,
`node -e 'console.log("Failed first"); process.exit(1)'`,
`node -e 'console.log("Success third")'`,
`node -e 'console.log("Failed second"); process.exit(1)'`,
])
console.log(result);
/*
{
retriable: [
`node -e 'console.log("Failed first"); process.exit(1)' --opt1=opt1value --opt1=opt1value`,
`node -e 'console.log("Failed second"); process.exit(1)' --opt1=opt1value --opt1=opt1value`
],
notRetriable: []
}
*/
}
```
## getfileslist
arguments | description
--- | ---
**`dir`** | Type: `string` , *required*
Directory what will be used as a root
**`fileList`** | Type: `Array` ,
This array will be used as a target for push new file
**`directoryToSkip`** | Type: `Array|string|regex`,
Exlude some directory
**`ignoreSubDirs`** | Type: `boolean`,
In case of true - sub directories will be ignored
### usage exampele
```js
const {getFilesList} = require('process-rerun');
const readmePath = getFilesList(__dirname).find((filePath) => filePath.include('readme.md'));
```
## intime approach vs circle approach
### circle approach
five processes execution, two execution attempts, five parallel execution
first execution attempt (three failed) | second execution attempt (one failed) | third execution attempt (o failed)
--- | --- | ----
1 p1 --------------------------> success | p2 ---> success | p4 -----------> success
2 p2 ---> fail | p4 -----------> fail |
3 p3 -------> fail | p3 -------> success |
4 p4 -----------> fail | |
5 p5 -----> success | |
Full execution time:
p1 (first attempt) --------------------------> + p4 (second attempt) -----------> + (third attempt) p4 ----------->
### intime approach (with same fail scheme)
every process has attemp count timer
f - fail
s - success
1 p1 -------------------------->s
2 p2 --->f--->s
3 p3 ------->f------->s
4 p4 ----------->f
5 p5 ----->s(p4)----------->f----------->s
Full execution time:
5 p5 ----->s(p4)----------->f----------->s
Failed process will check that free parallel exists and start execution when free parallel will be found.
## Changelog
[Version 0.1.11](/docs/verion0.1.11.md)