111 lines
3.3 KiB
TypeScript
111 lines
3.3 KiB
TypeScript
import * as plugins from './lik.plugins.js';
|
|
|
|
interface IExecutionSlot<T> {
|
|
executionDeferred: plugins.smartpromise.Deferred<T>;
|
|
funcToExecute: () => Promise<T>;
|
|
timeout?: number;
|
|
mode: 'exclusive' | 'nonexclusive';
|
|
}
|
|
|
|
export class AsyncExecutionStack {
|
|
private executionSlots: IExecutionSlot<any>[] = [];
|
|
private isProcessing = false;
|
|
|
|
public async getExclusiveExecutionSlot<T = any>(
|
|
funcArg: () => Promise<T>,
|
|
timeoutArg?: number
|
|
): Promise<T> {
|
|
const executionDeferred = plugins.smartpromise.defer<T>();
|
|
const executionSlot: IExecutionSlot<T> = {
|
|
funcToExecute: funcArg,
|
|
executionDeferred,
|
|
timeout: timeoutArg,
|
|
mode: 'exclusive',
|
|
};
|
|
this.executionSlots.push(executionSlot);
|
|
this.processExecutionSlots();
|
|
return executionDeferred.promise;
|
|
}
|
|
|
|
public async getNonExclusiveExecutionSlot<T = any>(
|
|
funcArg: () => Promise<T>,
|
|
timeoutArg?: number
|
|
): Promise<T> {
|
|
const executionDeferred = plugins.smartpromise.defer<T>();
|
|
const executionSlot: IExecutionSlot<T> = {
|
|
funcToExecute: funcArg,
|
|
executionDeferred,
|
|
timeout: timeoutArg,
|
|
mode: 'nonexclusive',
|
|
};
|
|
this.executionSlots.push(executionSlot);
|
|
this.processExecutionSlots();
|
|
return executionDeferred.promise;
|
|
}
|
|
|
|
private async processExecutionSlots() {
|
|
if (this.isProcessing) {
|
|
return;
|
|
}
|
|
this.isProcessing = true;
|
|
|
|
while (this.executionSlots.length > 0) {
|
|
const currentSlot = this.executionSlots[0];
|
|
if (currentSlot.mode === 'exclusive') {
|
|
await this.executeExclusiveSlot(currentSlot);
|
|
this.executionSlots.shift();
|
|
} else {
|
|
// Gather all non-exclusive slots at the front of the queue
|
|
const nonExclusiveSlots: IExecutionSlot<any>[] = [];
|
|
while (this.executionSlots.length > 0 && this.executionSlots[0].mode === 'nonexclusive') {
|
|
nonExclusiveSlots.push(this.executionSlots.shift()!);
|
|
}
|
|
await this.executeNonExclusiveSlots(nonExclusiveSlots);
|
|
}
|
|
}
|
|
this.isProcessing = false;
|
|
}
|
|
|
|
private async executeExclusiveSlot(slot: IExecutionSlot<any>) {
|
|
try {
|
|
if (slot.timeout) {
|
|
const result = await Promise.race([
|
|
slot.funcToExecute(),
|
|
plugins.smartdelay.delayFor(slot.timeout).then(() => {
|
|
throw new Error('Timeout reached');
|
|
}),
|
|
]);
|
|
slot.executionDeferred.resolve(result);
|
|
} else {
|
|
const result = await slot.funcToExecute();
|
|
slot.executionDeferred.resolve(result);
|
|
}
|
|
} catch (error) {
|
|
slot.executionDeferred.reject(error);
|
|
}
|
|
}
|
|
|
|
private async executeNonExclusiveSlots(slots: IExecutionSlot<any>[]) {
|
|
const promises = slots.map(async (slot) => {
|
|
try {
|
|
if (slot.timeout) {
|
|
const result = await Promise.race([
|
|
slot.funcToExecute(),
|
|
plugins.smartdelay.delayFor(slot.timeout).then(() => {
|
|
throw new Error('Timeout reached');
|
|
}),
|
|
]);
|
|
slot.executionDeferred.resolve(result);
|
|
} else {
|
|
const result = await slot.funcToExecute();
|
|
slot.executionDeferred.resolve(result);
|
|
}
|
|
} catch (error) {
|
|
slot.executionDeferred.reject(error);
|
|
}
|
|
});
|
|
|
|
await Promise.all(promises);
|
|
}
|
|
}
|