metaapi.cloud-sdk
Version:
SDK for MetaApi, a professional cloud forex API which includes MetaTrader REST API and MetaTrader websocket API. Supports both MetaTrader 5 (MT5) and MetaTrader 4 (MT4). CopyFactory copy trading API included. (https://metaapi.cloud)
479 lines (478 loc) • 76.1 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return _default;
}
});
const _convert = /*#__PURE__*/ _interop_require_wildcard(require("../../../../helpers/convert"));
const _helpers = /*#__PURE__*/ _interop_require_wildcard(require("../../../../helpers/helpers"));
const _random = /*#__PURE__*/ _interop_require_wildcard(require("../../../../helpers/random"));
const _format = /*#__PURE__*/ _interop_require_wildcard(require("../../../../helpers/format"));
const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
const _controlSignal = /*#__PURE__*/ _interop_require_default(require("../controlSignal"));
const _usageCounter = /*#__PURE__*/ _interop_require_default(require("../../tools/usageCounter"));
const _logger = /*#__PURE__*/ _interop_require_default(require("../../../../logger"));
const _eventEmitter = /*#__PURE__*/ _interop_require_default(require("../../../../tools/eventEmitter"));
const _timeoutError = /*#__PURE__*/ _interop_require_default(require("../../../../clients/timeoutError"));
const _processContext = /*#__PURE__*/ _interop_require_default(require("./processContext"));
function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function _getRequireWildcardCache(nodeInterop) {
if (typeof WeakMap !== "function") return null;
var cacheBabelInterop = new WeakMap();
var cacheNodeInterop = new WeakMap();
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
})(nodeInterop);
}
function _interop_require_wildcard(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj;
}
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
return {
default: obj
};
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj);
}
var newObj = {
__proto__: null
};
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for(var key in obj){
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc);
} else {
newObj[key] = obj[key];
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj);
}
return newObj;
}
/**
* Starts, stops, restarts and provides long-running background processes (running functions within node process)
* resolving race conditions and including process failovers until process canceled
*/ let AsyncProcessPool = class AsyncProcessPool {
/**
* Returns label for logging
* @returns label
*/ get label() {
return this._label;
}
/**
* Event emitter related to this pool
* @returns event emitter
* @internal
*/ get events() {
return this._events;
}
/**
* Returns whether the scheduler was given command to stop
* @returns whether stopped
*/ get stopped() {
return this._stopped;
}
/**
* Schedules a process. After the process has scheduled, it is immediately available in synchronous way. But it may
* not be started fully yet (its `start` method not completed yet), or currently running process may be an old one,
* which is going to stop. The latest actual and fully started process can be awaited with `waitProcess` method
* @param id process ID. If a process with same ID is already scheduled, the call will be ignored
* @param options process options
* @throws if the pool is stopped and the `throwIfStopped` option is enabled
*/ scheduleProcess(id, options) {
if (id.includes(":")) {
throw new TypeError("Process ID must not contain any colons");
}
const usage = options.usage || "default";
if (this._stopped) {
var _options_throwIfStopped;
if ((_options_throwIfStopped = options.throwIfStopped) !== null && _options_throwIfStopped !== void 0 ? _options_throwIfStopped : true) {
throw new Error("Async pool stopped");
} else {
this._logger.debug(`${this._label}: won't scheduled process ${id} because the pool is stopped`);
return;
}
}
this._logger.debug(`${this._label}: scheduling process ${id} by usage ${usage}`);
this._usages.acquire(id, usage);
if (this._scheduledProcesses[id]) {
this._logger.debug(`${this._label}: won't schedule process ${id} because it is already scheduled`);
return;
}
this._logger.info(`${this._label}: scheduling process ${id}`);
this._scheduledProcesses[id] = {
args: options.args,
failoverThrottleDelay: options.failoverThrottleDelay
};
this._run(id);
}
/**
* Restarts a process if it is scheduled, otherwise the call will be ignored. If the process is waiting for throttle
* delay to failover after error or unexpected stop, this method will force the failover
* @param process process ID or process itself. If the process instance is specified, it will be restarted only if it
* is still actual running process and not scheduled to be restarted yet
*/ restartProcess(process) {
if (typeof process === "string") {
if (this._runtimeProcesses[process]) {
this._logger.info(`${this._label}: restarting process ${process}`);
this._cancelProcess(this._runtimeProcesses[process]);
}
} else {
let runtime = this._processRuntimes.get(process);
if ((runtime === null || runtime === void 0 ? void 0 : runtime.process) === process) {
this._logger.info(`${this._label}: restarting process ${runtime.id} instance`);
this._cancelProcess(runtime);
}
}
}
/**
* Cancels a process
* @param id process ID
* @param options additional options
* @returns promise resolving when currently running process stopped
*/ async cancelProcess(id, options) {
const usage = (options === null || options === void 0 ? void 0 : options.usage) || "default";
if (!this._scheduledProcesses[id]) {
this._logger.debug(`${this._label}: won't cancel process ${id} because it is not scheduled`);
return;
}
if (options === null || options === void 0 ? void 0 : options.allUsages) {
this._logger.debug(`${this._label}: releasing process ${id} by all usages`);
this._usages.releaseAll(id);
} else {
this._logger.debug(`${this._label}: releasing process ${id} by usage ${usage}`);
this._usages.release(id, usage);
}
if (this._usages.isInUse(id)) {
this._logger.debug(`${this._label}: won't cancel process ${id} yet as it is still in use`);
return;
}
this._logger.info(`${this._label}: canceling process ${id}`);
delete this._scheduledProcesses[id];
let runtime = this._runtimeProcesses[id];
if (runtime && !runtime.cancelPromise.completed) {
this._cancelProcess(runtime);
this._events.emit(`canceled:${id}`);
}
return runtime === null || runtime === void 0 ? void 0 : runtime.stopPromise;
}
_cancelProcess(runtime) {
runtime.context.canceled = true;
runtime.cancelPromise.resolve();
}
/**
* Returns scheduled process IDs
* @returns process IDs
*/ getScheduledIds() {
return Object.keys(this._scheduledProcesses);
}
/**
* Returns running at this moment process IDs. It will always include scheduled IDs + some processes that was canceled
* but may be still running or stopping
* @returns process IDs
*/ getRunningIds() {
return Object.keys(this._runtimeProcesses);
}
/**
* Returns whether has scheduled process
* @param id process ID
* @returns true if scheduled
*/ hasScheduled(id) {
return !!this._scheduledProcesses[id];
}
/**
* Returns whether has a process, scheduled by specific usage
* @param id process ID
* @param usage usage
* @returns true if scheduled by
*/ hasScheduledBy(id, usage) {
return this._usages.isAcquiredBy(id, usage);
}
/**
* Returns process IDs which are scheduled by specific usage
* @param usage usage
* @returns process IDs
*/ getScheduledBy(usage) {
return this._usages.getAcquiredBy(usage);
}
/**
* Returns process schedulement
* @param id process ID
* @returns schedulement or undefined if not scheduled
*/ getSchedulement(id) {
if (!this._scheduledProcesses[id]) {
return;
}
return {
options: this._scheduledProcesses[id],
usages: this._usages.getUsages(id)
};
}
/**
* Returns current process in its running state which can be not started yet, starting, running, stopping or stopped
* @param id process ID
* @returns process in its state or undefined if there is no such process scheduled
*/ getProcess(id) {
var _this__runtimeProcesses_id;
return (_this__runtimeProcesses_id = this._runtimeProcesses[id]) === null || _this__runtimeProcesses_id === void 0 ? void 0 : _this__runtimeProcesses_id.process;
}
/**
* Waits for running started process instance. If the process was rescheduled/restarted and an old process instance is
* still running, the method will wait for the new process instance to start only. Note, that a process can become
* stopped or canceled till the method resolves after `await` in the calling code. So this method only increases
* probability the returned process will be running
* @param id process ID
* @param options additional options
* @returns promise resolving with process or `undefined`, depending on specified options
* @throws if process is not scheduled or becomes unscheduled during waiting due to `throwIfNotScheduled` option
* @throws `TimeoutError` if timed out waiting for the process due to timeout options
*/ async waitProcess(id, options) {
if (!this._scheduledProcesses[id]) {
if (options === null || options === void 0 ? void 0 : options.throwIfNotScheduled) {
throw new Error("Process is not scheduled");
}
return;
}
let result = this._runtimeProcesses[id];
if ((result === null || result === void 0 ? void 0 : result.context.stage) === _processContext.default.ProcessStage.RUNNING && !result.context.canceled) {
return result.process;
}
return new Promise((_resolve, _reject)=>{
var _options_stopPromise;
let cleanup = ()=>{
this._events.off(`started:${id}`, resolve);
this._events.off(`canceled:${id}`, processCanceledListener);
clearTimeout(timeout);
return true;
};
let resolve = (value)=>cleanup() && _resolve(value);
let reject = (err)=>cleanup() && _reject(err);
let processCanceledListener = ()=>setImmediate(()=>{
if (!this._scheduledProcesses[id]) {
(options === null || options === void 0 ? void 0 : options.throwIfNotScheduled) ? reject(new Error("Process is not scheduled")) : resolve(undefined);
}
});
this._events.on(`started:${id}`, resolve);
this._events.on(`canceled:${id}`, processCanceledListener);
let timeout;
if (!isNaN(options === null || options === void 0 ? void 0 : options.timeoutInMs)) {
timeout = setTimeout(()=>{
options.throwOnTimeout ? reject(new _timeoutError.default("Timed out waiting for the process")) : resolve(undefined);
}, options.timeoutInMs);
}
options === null || options === void 0 ? void 0 : (_options_stopPromise = options.stopPromise) === null || _options_stopPromise === void 0 ? void 0 : _options_stopPromise.then(()=>resolve(undefined)).catch((err)=>reject(err));
});
}
/**
* Cancels all currently scheduled processes and waits until they stop
* @returns promise resolving when stopped
*/ async cancelAll() {
await Promise.all(Object.keys(this._scheduledProcesses).map((id)=>this.cancelProcess(id, {
allUsages: true
})));
}
/**
* Stops all processes
* @returns promise resolving when stopped
*/ async stop() {
this._stopped = true;
await this.cancelAll();
await Promise.all(Object.values(this._runtimeProcesses).map((runtime)=>runtime.stopPromise));
}
async _run(id) {
if (this._runtimeProcesses[id]) {
return;
}
while(this._scheduledProcesses[id]){
try {
let expected = this._scheduledProcesses[id];
let basicContext = {
processId: id,
pool: this,
stage: _processContext.default.ProcessStage.STARTING
};
let { process, context, args } = this._processProvider(basicContext, expected.args);
let runtime = this._runtimeProcesses[id] = {
id: id,
process,
context: basicContext,
cancelPromise: _helpers.createHandlePromise(),
stopPromise: _helpers.createHandlePromise(),
startPromise: undefined
};
process.inject(...this._dependencies);
process.initialize(...args);
context.initialize(process);
this._processRuntimes.set(runtime.process, runtime);
this._events.emit(`created:${id}`);
try {
this._logger.debug(`${this._label}: starting process ${id}`);
await (runtime.startPromise = _helpers.wrapHandlePromise(_helpers.ensurePromise(()=>runtime.process.start(runtime.cancelPromise)).then(()=>{
var _expected_nextPostProcessThrottling;
return (_expected_nextPostProcessThrottling = expected.nextPostProcessThrottling) === null || _expected_nextPostProcessThrottling === void 0 ? void 0 : _expected_nextPostProcessThrottling.call(expected, true);
}).catch((err)=>{
var _expected_nextPostProcessThrottling;
(_expected_nextPostProcessThrottling = expected.nextPostProcessThrottling) === null || _expected_nextPostProcessThrottling === void 0 ? void 0 : _expected_nextPostProcessThrottling.call(expected, false);
throw err;
}).finally(()=>delete expected.nextPostProcessThrottling)));
if (!runtime.cancelPromise.completed) {
basicContext.stage = _processContext.default.ProcessStage.RUNNING;
this._logger.debug(`${this._label}: running process ${id}`);
this._events.emit(`started:${id}`, runtime.process);
this._events.emit("started", runtime.process);
await runtime.process.run(runtime.cancelPromise);
}
basicContext.stage = _processContext.default.ProcessStage.STOPPING;
await this._handleControlSignal(id, expected, runtime, runtime.cancelPromise.completed ? {
action: "stop",
message: "process ceased to run gracefully",
severity: "debug"
} : {
action: "failover",
message: "process ceased to run unexpectedly"
});
} catch (err) {
basicContext.stage = _processContext.default.ProcessStage.STOPPING;
err instanceof _controlSignal.default ? await this._handleControlSignal(id, expected, runtime, err.options) : await this._handleControlSignal(id, expected, runtime, {
error: err,
message: "failed to run process"
});
} finally{
basicContext.stage = _processContext.default.ProcessStage.STOPPED;
context.release();
runtime.stopPromise.resolve();
delete this._runtimeProcesses[id];
this._processRuntimes.delete(runtime.process);
}
} catch (err) {
this._logger.fatal(`${this._label}: failed to prepare process ${id} instance, it will be canceled`, err);
this.cancelProcess(id, {
allUsages: true
});
}
}
}
// eslint-disable-next-line complexity
async _handleControlSignal(id, schedulement, runtime, signal = {}) {
const action = signal.action || "failover";
const cancel = action === "cancel" && this._scheduledProcesses[id] === schedulement;
const failover = action === "failover" && !!this._scheduledProcesses[id];
const restart = action === "stop" && !!this._scheduledProcesses[id];
const forceFailover = failover && runtime.cancelPromise.completed;
const throttleDelayInMs = failover && !forceFailover ? this._getThrottleDelay(schedulement, runtime) : undefined;
let message = _lodash.default.compact([
signal.message ? `${this._label}: process ${id}: ${signal.message}` : `${this._label}: process ${id} completed with a ${signal.action} control signal`,
cancel && "The process will be canceled",
failover && `The process will be failovered in ${_format.simplifyTimeAmount(throttleDelayInMs || 0, "ms").description}`,
restart && "The process will be restarted"
]).join(". ");
if (signal.severity) {
signal.error ? this._logger[signal.severity](message + ".", signal.error) : this._logger[signal.severity](message);
} else if (signal.error) {
this._logger.error(message + ".", signal.error);
} else if (action === "failover") {
this._logger.warn(message);
} else {
this._logger.info(message);
}
if (cancel) {
this.cancelProcess(id, {
allUsages: true
});
}
await this._stopProcess(id, runtime, failover, throttleDelayInMs);
}
// eslint-disable-next-line complexity
_getThrottleDelay(schedulement, runtime) {
var _this__options, _schedulement_throttlings, _schedulement_throttlings1;
var _this__options_processFailoverThrottleDelayInMs;
let options = schedulement.failoverThrottleDelay || {
mode: "fixed",
delayInMs: (_this__options_processFailoverThrottleDelayInMs = (_this__options = this._options) === null || _this__options === void 0 ? void 0 : _this__options.processFailoverThrottleDelayInMs) !== null && _this__options_processFailoverThrottleDelayInMs !== void 0 ? _this__options_processFailoverThrottleDelayInMs : _convert.time.secondsToMs(10)
};
if (options.mode === "fixed") {
var _options_randomizationFactor;
return _random.getIntegerAround(options.delayInMs, (_options_randomizationFactor = options.randomizationFactor) !== null && _options_randomizationFactor !== void 0 ? _options_randomizationFactor : 0);
}
var _options_resetDelayInMs;
if (((_schedulement_throttlings = schedulement.throttlings) === null || _schedulement_throttlings === void 0 ? void 0 : _schedulement_throttlings.lastSuccessfulConnectTime) !== undefined && Date.now() - schedulement.throttlings.lastSuccessfulConnectTime >= ((_options_resetDelayInMs = options.resetDelayInMs) !== null && _options_resetDelayInMs !== void 0 ? _options_resetDelayInMs : 0)) {
delete schedulement.throttlings;
}
schedulement.nextPostProcessThrottling = (successfulStart)=>{
var _schedulement_throttlings;
return schedulement.throttlings = {
counter: (((_schedulement_throttlings = schedulement.throttlings) === null || _schedulement_throttlings === void 0 ? void 0 : _schedulement_throttlings.counter) || 0) + (runtime.cancelPromise.completed ? 0 : 1),
lastSuccessfulConnectTime: successfulStart ? Date.now() : undefined
};
};
var _options_randomizationFactor1;
return _random.getIntegerAround(_helpers.expBackoffDelay((((_schedulement_throttlings1 = schedulement.throttlings) === null || _schedulement_throttlings1 === void 0 ? void 0 : _schedulement_throttlings1.counter) || 0) + 1, Math.max(options.minDelayInMs, 1), options.maxDelayInMs), (_options_randomizationFactor1 = options.randomizationFactor) !== null && _options_randomizationFactor1 !== void 0 ? _options_randomizationFactor1 : 0);
}
async _stopProcess(id, runtime, failover, throttleDelayInMs) {
this._logger.debug(`${this._label}: stopping process ${id}`);
await runtime.process.stop().then(()=>this._logger.debug(`${this._label}: process ${id} stopped`)).catch((e)=>this._logger.warn(`${this._label}: failed to stop process ${id} properly`, e));
if (throttleDelayInMs) {
let delay = _helpers.delay(throttleDelayInMs);
await Promise.race([
delay,
runtime.cancelPromise
]);
delay.cancel();
}
if (failover && runtime.cancelPromise.completed) {
this._scheduledProcesses[id] ? this._logger.info(`${this._label}: forcing process ${id} failover`) : this._logger.info(`${this._label}: canceling process ${id} failover as it was canceled`);
}
}
/**
* Constructs instance
* @param provider process provider
* @param options additional options
*/ constructor(provider, options){
_define_property(this, "_logger", _logger.default.getLogger("AsyncProcessPool"));
_define_property(this, "_processProvider", void 0);
_define_property(this, "_scheduledProcesses", {});
_define_property(this, "_runtimeProcesses", {});
_define_property(this, "_processRuntimes", new Map());
_define_property(this, "_options", void 0);
_define_property(this, "_events", new _eventEmitter.default());
_define_property(this, "_label", void 0);
_define_property(this, "_stopped", false);
_define_property(this, "_usages", new _usageCounter.default());
_define_property(this, "_dependencies", void 0);
this._processProvider = provider;
this._label = (options === null || options === void 0 ? void 0 : options.label) || "default";
this._options = options;
this._dependencies = options.dependencies;
}
};
const _default = AsyncProcessPool;
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport * as convert from '../../../../helpers/convert';\nimport * as helpers from '../../../../helpers/helpers';\nimport * as random from '../../../../helpers/random';\nimport * as format from '../../../../helpers/format';\nimport AsyncProcess from './asyncProcess';\nimport _ from 'lodash';\nimport ControlSignal from '../controlSignal';\nimport {Dict} from '../../../../types/util';\nimport UsageCounter from '../../tools/usageCounter';\nimport LoggerManager from '../../../../logger';\nimport EventEmitter from '../../../../tools/eventEmitter';\nimport TimeoutError from '../../../../clients/timeoutError';\n\n/**\n * Starts, stops, restarts and provides long-running background processes (running functions within node process)\n * resolving race conditions and including process failovers until process canceled\n */\nclass AsyncProcessPool<\n  Provider /* extends AsyncProcessPool.ProcessProvider<AsyncProcess> */,\n  Process extends AsyncProcess\n> {\n\n  protected _logger = LoggerManager.getLogger('AsyncProcessPool');\n  private _processProvider: Provider;\n  private _scheduledProcesses: Dict<ExpectedProcess<Provider>> = {};\n  private _runtimeProcesses: Dict<RuntimeProcess> = {};\n  private _processRuntimes = new Map<AsyncProcess, RuntimeProcess>();\n  private _options?: AsyncProcessPool.Options<Process>;\n  private _events = new EventEmitter<AsyncProcessPool.Events<Process>>();\n  private _label: string;\n  private _stopped = false;\n  private _usages = new UsageCounter();\n  private _dependencies: any[];\n\n  /**\n   * Constructs instance\n   * @param provider process provider\n   * @param options additional options\n   */\n  constructor(provider: Provider, options: AsyncProcessPool.Options<Process>) {\n    this._processProvider = provider;\n    this._label = options?.label || 'default';\n    this._options = options;\n    this._dependencies = options.dependencies;\n  }\n\n  /**\n   * Returns label for logging\n   * @returns label\n   */\n  get label(): string {\n    return this._label;\n  }\n\n  /**\n   * Event emitter related to this pool\n   * @returns event emitter\n   * @internal\n   */\n  get events(): EventEmitter<AsyncProcessPool.Events<Process>> {\n    return this._events;\n  }\n\n  /**\n   * Returns whether the scheduler was given command to stop\n   * @returns whether stopped\n   */\n  get stopped(): boolean {\n    return this._stopped;\n  }\n\n  /**\n   * Schedules a process. After the process has scheduled, it is immediately available in synchronous way. But it may\n   * not be started fully yet (its `start` method not completed yet), or currently running process may be an old one,\n   * which is going to stop. The latest actual and fully started process can be awaited with `waitProcess` method\n   * @param id process ID. If a process with same ID is already scheduled, the call will be ignored\n   * @param options process options\n   * @throws if the pool is stopped and the `throwIfStopped` option is enabled\n   */\n  scheduleProcess(id: string, options: AsyncProcessPool.ScheduleProcessOptions<Provider>) {\n    if (id.includes(':')) {\n      throw new TypeError('Process ID must not contain any colons');\n    }\n    const usage = options.usage || 'default';\n    if (this._stopped) {\n      if (options.throwIfStopped ?? true) {\n        throw new Error('Async pool stopped');\n      } else {\n        this._logger.debug(`${this._label}: won't scheduled process ${id} because the pool is stopped`);\n        return;\n      }\n    }\n    this._logger.debug(`${this._label}: scheduling process ${id} by usage ${usage}`);\n    this._usages.acquire(id, usage);\n    if (this._scheduledProcesses[id]) {\n      this._logger.debug(`${this._label}: won't schedule process ${id} because it is already scheduled`);\n      return;\n    }\n    this._logger.info(`${this._label}: scheduling process ${id}`);\n    this._scheduledProcesses[id] = {\n      args: options.args,\n      failoverThrottleDelay: options.failoverThrottleDelay\n    };\n    this._run(id);\n  }\n\n  /**\n   * Restarts a process if it is scheduled, otherwise the call will be ignored. If the process is waiting for throttle\n   * delay to failover after error or unexpected stop, this method will force the failover\n   * @param process process ID or process itself. If the process instance is specified, it will be restarted only if it\n   * is still actual running process and not scheduled to be restarted yet\n   */\n  restartProcess(process: string | Process) {\n    if (typeof process === 'string') {\n      if (this._runtimeProcesses[process]) {\n        this._logger.info(`${this._label}: restarting process ${process}`);\n        this._cancelProcess(this._runtimeProcesses[process]);\n      }\n    } else {\n      let runtime = this._processRuntimes.get(process);\n      if (runtime?.process === process) {\n        this._logger.info(`${this._label}: restarting process ${runtime.id} instance`);\n        this._cancelProcess(runtime);\n      }\n    }\n  }\n\n  /**\n   * Cancels a process\n   * @param id process ID\n   * @param options additional options\n   * @returns promise resolving when currently running process stopped\n   */\n  async cancelProcess(id: string, options?: AsyncProcessPool.CancelProcessOptions) {\n    const usage = options?.usage || 'default';\n    if (!this._scheduledProcesses[id]) {\n      this._logger.debug(`${this._label}: won't cancel process ${id} because it is not scheduled`);\n      return;\n    }\n    if (options?.allUsages) {\n      this._logger.debug(`${this._label}: releasing process ${id} by all usages`);\n      this._usages.releaseAll(id);\n    } else {\n      this._logger.debug(`${this._label}: releasing process ${id} by usage ${usage}`);\n      this._usages.release(id, usage);\n    }\n    if (this._usages.isInUse(id)) {\n      this._logger.debug(`${this._label}: won't cancel process ${id} yet as it is still in use`);\n      return;\n    }\n    this._logger.info(`${this._label}: canceling process ${id}`);\n    delete this._scheduledProcesses[id];\n    let runtime = this._runtimeProcesses[id];\n    if (runtime && !runtime.cancelPromise.completed) {\n      this._cancelProcess(runtime);\n      this._events.emit(`canceled:${id}`);\n    }\n    return runtime?.stopPromise;\n  }\n\n  private _cancelProcess(runtime: RuntimeProcess) {\n    runtime.context.canceled = true;\n    runtime.cancelPromise.resolve();\n  }\n\n  /**\n   * Returns scheduled process IDs\n   * @returns process IDs\n   */\n  getScheduledIds(): string[] {\n    return Object.keys(this._scheduledProcesses);\n  }\n\n  /**\n   * Returns running at this moment process IDs. It will always include scheduled IDs + some processes that was canceled\n   * but may be still running or stopping\n   * @returns process IDs\n   */\n  getRunningIds(): string[] {\n    return Object.keys(this._runtimeProcesses);\n  }\n\n  /**\n   * Returns whether has scheduled process\n   * @param id process ID\n   * @returns true if scheduled\n   */\n  hasScheduled(id: string): boolean {\n    return !!this._scheduledProcesses[id];\n  }\n\n  /**\n   * Returns whether has a process, scheduled by specific usage\n   * @param id process ID\n   * @param usage usage\n   * @returns true if scheduled by\n   */\n  hasScheduledBy(id: string, usage: any): boolean {\n    return this._usages.isAcquiredBy(id, usage);\n  }\n\n  /**\n   * Returns process IDs which are scheduled by specific usage\n   * @param usage usage\n   * @returns process IDs\n   */\n  getScheduledBy(usage: any): string[] {\n    return this._usages.getAcquiredBy(usage);\n  }\n\n  /**\n   * Returns process schedulement\n   * @param id process ID\n   * @returns schedulement or undefined if not scheduled\n   */\n  getSchedulement(id: string): AsyncProcessPool.Schedulement<Provider> | undefined {\n    if (!this._scheduledProcesses[id]) {\n      return;\n    }\n    return {\n      options: this._scheduledProcesses[id],\n      usages: this._usages.getUsages(id)\n    };\n  }\n\n  /**\n   * Returns current process in its running state which can be not started yet, starting, running, stopping or stopped\n   * @param id process ID\n   * @returns process in its state or undefined if there is no such process scheduled\n   */\n  getProcess(id: string): Process | undefined {\n    return this._runtimeProcesses[id]?.process as Process;\n  }\n\n  /**\n   * Waits for running started process instance. If the process was rescheduled/restarted and an old process instance is\n   * still running, the method will wait for the new process instance to start only. Note, that a process can become\n   * stopped or canceled till the method resolves after `await` in the calling code. So this method only increases\n   * probability the returned process will be running\n   * @param id process ID\n   * @param options additional options\n   * @returns promise resolving with process or `undefined`, depending on specified options\n   * @throws if process is not scheduled or becomes unscheduled during waiting due to `throwIfNotScheduled` option\n   * @throws `TimeoutError` if timed out waiting for the process due to timeout options\n   */\n  async waitProcess(id: string, options?: AsyncProcessPool.WaitProcessOptions): Promise<Process> {\n    if (!this._scheduledProcesses[id]) {\n      if (options?.throwIfNotScheduled) {\n        throw new Error('Process is not scheduled');\n      }\n      return;\n    }\n    let result = this._runtimeProcesses[id];\n    if (result?.context.stage === ProcessContext.ProcessStage.RUNNING && !result.context.canceled) {\n      return result.process as Process;\n    }\n    return new Promise<Process>((_resolve, _reject) => {\n      let cleanup = () => {\n        this._events.off(`started:${id}`, resolve);\n        this._events.off(`canceled:${id}`, processCanceledListener);\n        clearTimeout(timeout);\n        return true;\n      };\n      let resolve = (value: Process) => cleanup() && _resolve(value);\n      let reject = (err: Error) => cleanup() && _reject(err);\n      let processCanceledListener = () => setImmediate(() => {\n        if (!this._scheduledProcesses[id]) {\n          options?.throwIfNotScheduled ? reject(new Error('Process is not scheduled')) : resolve(undefined);\n        }\n      });\n      this._events.on(`started:${id}`, resolve);\n      this._events.on(`canceled:${id}`, processCanceledListener);\n      let timeout: NodeJS.Timeout;\n      if (!isNaN(options?.timeoutInMs)) {\n        timeout = setTimeout(() => {\n          options.throwOnTimeout ? reject(new TimeoutError('Timed out waiting for the process')) : resolve(undefined);\n        }, options.timeoutInMs);\n      }\n      options?.stopPromise?.then(() => resolve(undefined)).catch(err => reject(err));\n    });\n  }\n\n  /**\n   * Cancels all currently scheduled processes and waits until they stop\n   * @returns promise resolving when stopped\n   */\n  async cancelAll() {\n    await Promise.all(Object.keys(this._scheduledProcesses).map(id => this.cancelProcess(id, {allUsages: true})));\n  }\n\n  /**\n   * Stops all processes\n   * @returns promise resolving when stopped\n   */\n  async stop() {\n    this._stopped = true;\n    await this.cancelAll();\n    await Promise.all(Object.values(this._runtimeProcesses).map(runtime => runtime.stopPromise));\n  }\n\n  private async _run(id: string) {\n    if (this._runtimeProcesses[id]) {\n      return;\n    }\n    while (this._scheduledProcesses[id]) {\n      try {\n        let expected = this._scheduledProcesses[id];\n        let basicContext: AsyncProcessPool.Context = {\n          processId: id,\n          pool: this,\n          stage: ProcessContext.ProcessStage.STARTING\n        };\n        let {process, context, args} = (this._processProvider as AsyncProcessPool.ProcessProvider<AsyncProcess>)(\n          basicContext, expected.args\n        );\n        let runtime: RuntimeProcess = this._runtimeProcesses[id] = {\n          id: id,\n          process,\n          context: basicContext,\n          cancelPromise: helpers.createHandlePromise<void>(),\n          stopPromise: helpers.createHandlePromise(),\n          startPromise: undefined\n        };\n        process.inject(...this._dependencies);\n        process.initialize(...args);\n        context.initialize(process);\n        this._processRuntimes.set(runtime.process, runtime);\n        this._events.emit(`created:${id}`);\n        try {\n          this._logger.debug(`${this._label}: starting process ${id}`);\n          await (runtime.startPromise = helpers.wrapHandlePromise(helpers\n            .ensurePromise(() => runtime.process.start(runtime.cancelPromise))\n            .then(() => expected.nextPostProcessThrottling?.(true))\n            .catch(err => {\n              expected.nextPostProcessThrottling?.(false);\n              throw err;\n            })\n            .finally(() => delete expected.nextPostProcessThrottling)\n          ));\n          if (!runtime.cancelPromise.completed) {\n            basicContext.stage = ProcessContext.ProcessStage.RUNNING;\n            this._logger.debug(`${this._label}: running process ${id}`);\n            this._events.emit(`started:${id}`, runtime.process as Process);\n            this._events.emit('started', runtime.process as Process);\n            await runtime.process.run(runtime.cancelPromise);\n          }\n          basicContext.stage = ProcessContext.ProcessStage.STOPPING;\n          await this._handleControlSignal(id, expected, runtime, runtime.cancelPromise.completed ?\n            {action: 'stop', message: 'process ceased to run gracefully', severity: 'debug'} :\n            {action: 'failover', message: 'process ceased to run unexpectedly'});\n        } catch (err) {\n          basicContext.stage = ProcessContext.ProcessStage.STOPPING;\n          err instanceof ControlSignal ?\n            await this._handleControlSignal(id, expected, runtime, err.options) :\n            await this._handleControlSignal(id, expected, runtime, {error: err, message: 'failed to run process'});\n        } finally {\n          basicContext.stage = ProcessContext.ProcessStage.STOPPED;\n          context.release();\n          runtime.stopPromise.resolve();\n          delete this._runtimeProcesses[id];\n          this._processRuntimes.delete(runtime.process);\n        }\n      } catch (err) {\n        this._logger.fatal(`${this._label}: failed to prepare process ${id} instance, it will be canceled`, err);\n        this.cancelProcess(id, {allUsages: true});\n      }\n    }\n  }\n\n  // eslint-disable-next-line complexity\n  private async _handleControlSignal(\n    id: string, schedulement: ExpectedProcess<Provider>, runtime: RuntimeProcess,\n    signal: ControlSignal.Options = {}\n  ) {\n    const action = signal.action || 'failover';\n    const cancel = action === 'cancel' && this._scheduledProcesses[id] === schedulement;\n    const failover = action === 'failover' && !!this._scheduledProcesses[id];\n    const restart = action === 'stop' && !!this._scheduledProcesses[id];\n    const forceFailover = failover && runtime.cancelPromise.completed;\n    const throttleDelayInMs = (failover && !forceFailover) ? this._getThrottleDelay(schedulement, runtime) : undefined;\n\n    let message = _.compact([\n      signal.message ?\n        `${this._label}: process ${id}: ${signal.message}` :\n        `${this._label}: process ${id} completed with a ${signal.action} control signal`,\n      cancel && 'The process will be canceled',\n      failover && `The process will be failovered in ${\n        format.simplifyTimeAmount(throttleDelayInMs || 0, 'ms').description\n      }`,\n      restart && 'The process will be restarted'\n    ]).join('. ');\n    if (signal.severity) {\n      signal.error ?\n        this._logger[signal.severity](message + '.', signal.error) :\n        this._logger[signal.severity](message);\n    } else if (signal.error) {\n      this._logger.error(message + '.', signal.error);\n    } else if (action === 'failover') {\n      this._logger.warn(message);\n    } else {\n      this._logger.info(message);\n    }\n    if (cancel) {\n      this.cancelProcess(id, {allUsages: true});\n    }\n    await this._stopProcess(id, runtime, failover, throttleDelayInMs);\n  }\n\n  // eslint-disable-next-line complexity\n  private _getThrottleDelay(schedulement: ExpectedProcess<any>, runtime: RuntimeProcess): number {\n    let options = schedulement.failoverThrottleDelay || {\n      mode: 'fixed',\n      delayInMs: this._options?.processFailoverThrottleDelayInMs ?? convert.time.secondsToMs(10)\n    };\n    if (options.mode === 'fixed') {\n      return random.getIntegerAround(options.delayInMs, options.randomizationFactor ?? 0);\n    }\n    if (\n      schedulement.throttlings?.lastSuccessfulConnectTime !== undefined &&\n      Date.now() - schedulement.throttlings.lastSuccessfulConnectTime >= (options.resetDelayInMs ?? 0)\n    ) {\n      delete schedulement.throttlings;\n    }\n    schedulement.nextPostProcessThrottling = (successfulStart) => schedulement.throttlings = {\n      counter: (schedulement.throttlings?.counter || 0) + (runtime.cancelPromise.completed ? 0 : 1),\n      lastSuccessfulConnectTime: successfulStart ? Date.now() : undefined\n    };\n    return random.getIntegerAround(helpers.expBackoffDelay(\n      (schedulement.throttlings?.counter || 0) + 1,\n      Math.max(options.minDelayInMs, 1), options.maxDelayInMs\n    ), options.randomizationFactor ?? 0);\n  }\n\n  private async _stopProcess(id: string, runtime: RuntimeProcess, failover: boolean, throttleDelayInMs?: number) {\n    this._logger.debug(`${this._label}: stopping process ${id}`);\n    await runtime.process.stop()\n      .then(() => this._logger.debug(`${this._label}: process ${id} stopped`))\n      .catch(e => this._logger.warn(`${this._label}: failed to stop process ${id} properly`, e));\n    if (throttleDelayInMs) {\n      let delay = helpers.delay(throttleDelayInMs);\n      await Promise.race([delay, runtime.cancelPromise]);\n      delay.cancel();\n    }\n    if (failover && runtime.cancelPromise.completed) {\n      this._scheduledProcesses[id] ?\n        this._logger.info(`${this._label}: forcing process ${id} failover`) :\n        this._logger.info(`${this._label}: canceling process ${id} failover as it was canceled`);\n    }\n  }\n}\n\nnamespace AsyncProcessPool {\n\n  /** Process provider */\n  export type ProcessProvider<Process extends AsyncProcess> = (\n    context: Context, args: any[]\n  ) => ConstructedProcess<Process>;\n\n  /** Constructed process */\n  export type ConstructedProcess<Process extends AsyncProcess> = {\n    /** Process */\n    process: Process;\n    /** Process context */\n    context: ProcessContext;\n    /** Mapped process args */\n    args: any[];\n  };\n\n  /** Basic process context */\n  export type Context = {\n    /** Process ID */\n    processId: string;\n    /** Current pool */\n    pool: AsyncProcessPool<any, any>;\n    /** Process stage */\n    stage: ProcessContext.ProcessStage;\n    /** Whether the process was scheduled to cancel by external command (cancel or restart) */\n    canceled?: boolean;\n  };\n\n  /** Constructing options */\n  export type Options<Process> = {\n    /** Logging label. Defaults to `default` */\n    label?: string;\n    /**\n     * Process run attempt throttle delay in case of failover. May be overriden by processes when scheduling,\n     * Defaults to 30 seconds\n     */\n    processFailoverThrottleDelayInMs?: number;\n    /** Dependencies shared across all processes */\n    dependen