@webiny/background-tasks-standalone 0.0.0-unstable.33e4fd9647

package/handlers/InProcessBackgroundTaskHandler.js

@@ -0,0 +1,120 @@
+import { BackgroundTaskEventHandler, RequestContainer } from "@webiny/event-handler-core";
+import { RawTenantId, RequestTenantLoader } from "@webiny/api-core/features/requestContext/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { TaskResultStatus } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskRunner } from "@webiny/background-tasks/api/runner/index.js";
+import { TaskEventValidation } from "@webiny/background-tasks/api/runner/TaskEventValidation.js";
+import { ProcessTimer } from "../timer/ProcessTimer.js";
+import { TaskClaim } from "../domain/TaskClaim.js";
+import { CLAIMED_ELSEWHERE_STATUS, HANDED_BACK_STATUS } from "../domain/BackgroundTasksLoop.js";
+import { ShutdownSignal } from "../domain/ShutdownSignal.js";
+import { ClaimRenewal } from "../claim/ClaimRenewal.js";
+import { CLAIM_TTL_MS } from "../claim/constants.js";
+const ITERATION_MAX_DURATION_MS = 900000;
+const claimedElsewhere = ()=>({
+        status: CLAIMED_ELSEWHERE_STATUS
+    });
+const handedBack = ()=>({
+        status: HANDED_BACK_STATUS
+    });
+class InProcessBackgroundTaskHandlerImpl {
+    constructor(container, rawTenantId, tenantLoader, claim, shutdown, logger){
+        this.container = container;
+        this.rawTenantId = rawTenantId;
+        this.tenantLoader = tenantLoader;
+        this.claim = claim;
+        this.shutdown = shutdown;
+        this.logger = logger;
+    }
+    async execute(eventCtx) {
+        const taskEvent = eventCtx.event;
+        if (this.shutdown.isShuttingDown()) return handedBack();
+        this.rawTenantId.set(taskEvent.tenant);
+        await this.tenantLoader.establish();
+        const target = {
+            tenant: taskEvent.tenant,
+            taskId: taskEvent.webinyTaskId
+        };
+        const held = await this.hold(target);
+        if (!held) return claimedElsewhere();
+        const timer = new ProcessTimer(ITERATION_MAX_DURATION_MS);
+        const renewal = new ClaimRenewal({
+            claim: this.claim,
+            target,
+            onLost: ()=>{
+                timer.expire();
+                this.logger.warn({
+                    ...target
+                }, "Lost the claim on a running background task.");
+            },
+            onError: (error)=>{
+                this.logger.warn({
+                    error,
+                    ...target
+                }, "Could not extend a background task claim.");
+            }
+        });
+        const ctx = {
+            container: this.container
+        };
+        const runner = new TaskRunner(ctx, timer, new TaskEventValidation());
+        let result;
+        const stopListening = this.shutdown.onShutdown(()=>{
+            timer.expire();
+        });
+        renewal.start();
+        try {
+            result = await runner.run(taskEvent);
+        } finally{
+            renewal.stop();
+            stopListening();
+        }
+        if (renewal.isLost()) return claimedElsewhere();
+        return this.afterIteration(target, result);
+    }
+    async hold(target) {
+        const kept = await this.claim.keep(target, CLAIM_TTL_MS);
+        if (kept) return true;
+        return this.claim.take(target, CLAIM_TTL_MS);
+    }
+    async afterIteration(target, result) {
+        if (result.status !== TaskResultStatus.CONTINUE) {
+            await this.release(target);
+            return result;
+        }
+        const waitMs = (result.wait ?? 0) * 1000;
+        const shuttingDown = this.shutdown.isShuttingDown();
+        if (shuttingDown && 0 === waitMs) {
+            await this.release(target);
+            return handedBack();
+        }
+        const kept = await this.claim.keep(target, CLAIM_TTL_MS + waitMs);
+        if (!kept) return claimedElsewhere();
+        if (shuttingDown) return handedBack();
+        return result;
+    }
+    async release(target) {
+        try {
+            await this.claim.release(target);
+        } catch (error) {
+            this.logger.warn({
+                error,
+                ...target
+            }, "Could not release a background task claim.");
+        }
+    }
+}
+const InProcessBackgroundTaskHandler = BackgroundTaskEventHandler.createImplementation({
+    implementation: InProcessBackgroundTaskHandlerImpl,
+    dependencies: [
+        RequestContainer,
+        RawTenantId,
+        RequestTenantLoader,
+        TaskClaim,
+        ShutdownSignal,
+        Logger
+    ]
+});
+export { InProcessBackgroundTaskHandler };
+
+//# sourceMappingURL=InProcessBackgroundTaskHandler.js.map

package/handlers/InProcessBackgroundTaskHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers/InProcessBackgroundTaskHandler.js","sources":["../../src/handlers/InProcessBackgroundTaskHandler.ts"],"sourcesContent":["import type { Container } from \"@webiny/feature/api\";\nimport { BackgroundTaskEventHandler } from \"@webiny/event-handler-core\";\nimport { RequestContainer } from \"@webiny/event-handler-core\";\nimport type { EventContext } from \"@webiny/event-handler-core\";\nimport type { IBackgroundTaskEvent } from \"@webiny/event-handler-core\";\nimport { RawTenantId } from \"@webiny/api-core/features/requestContext/index.js\";\nimport { RequestTenantLoader } from \"@webiny/api-core/features/requestContext/index.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { TaskResultStatus } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { TaskRunner } from \"@webiny/background-tasks/api/runner/index.js\";\nimport { TaskEventValidation } from \"@webiny/background-tasks/api/runner/TaskEventValidation.js\";\nimport type { Context } from \"@webiny/background-tasks/api/types.js\";\nimport type { IResponseResult } from \"@webiny/background-tasks/api/response/abstractions/index.js\";\nimport { ProcessTimer } from \"~/timer/ProcessTimer.js\";\nimport { TaskClaim } from \"~/domain/TaskClaim.js\";\nimport { CLAIMED_ELSEWHERE_STATUS } from \"~/domain/BackgroundTasksLoop.js\";\nimport { HANDED_BACK_STATUS } from \"~/domain/BackgroundTasksLoop.js\";\nimport { ShutdownSignal } from \"~/domain/ShutdownSignal.js\";\nimport { ClaimRenewal } from \"~/claim/ClaimRenewal.js\";\nimport { CLAIM_TTL_MS } from \"~/claim/constants.js\";\n\n/*\n * The time one iteration gets, the same 15 minutes as the background-task Lambda on AWS. A task\n * checks `isCloseToTimeout()` to save its progress and continue in a new iteration, so this also sets\n * how much work a crash can make it repeat. Given the 24 hours a whole task may run, it would never save.\n */\nconst ITERATION_MAX_DURATION_MS = 900_000;\n\nconst claimedElsewhere = () => {\n    return { status: CLAIMED_ELSEWHERE_STATUS };\n};\n\nconst handedBack = () => {\n    return { status: HANDED_BACK_STATUS };\n};\n\n/**\n * Runs one iteration of a background task in the request container the dispatcher built for it.\n * The standalone counterpart of `BackgroundTaskLambdaHandler`: same tenant set-up and runner, with\n * a process timer in place of the Lambda countdown.\n *\n * Every iteration runs under the task's claim, so only one process drives a task at a time. The\n * first iteration takes the claim, the later ones find it still theirs.\n *\n * When the process starts shutting down, the running iteration's time runs out at once, so the task saves\n * its progress and hands back control. The task is then left to another process.\n */\nclass InProcessBackgroundTaskHandlerImpl implements BackgroundTaskEventHandler.Interface {\n    public constructor(\n        private readonly container: Container,\n        private readonly rawTenantId: RawTenantId.Interface,\n        private readonly tenantLoader: RequestTenantLoader.Interface,\n        private readonly claim: TaskClaim.Interface,\n        private readonly shutdown: ShutdownSignal.Interface,\n        private readonly logger: Logger.Interface\n    ) {}\n\n    public async execute(eventCtx: EventContext<IBackgroundTaskEvent>): Promise<unknown> {\n        const taskEvent = eventCtx.event;\n\n        // The process started shutting down after this iteration was dispatched: leave the task be.\n        if (this.shutdown.isShuttingDown()) {\n            return handedBack();\n        }\n\n        this.rawTenantId.set(taskEvent.tenant);\n        await this.tenantLoader.establish();\n\n        const target: TaskClaim.Target = {\n            tenant: taskEvent.tenant,\n            taskId: taskEvent.webinyTaskId\n        };\n        const held = await this.hold(target);\n        if (!held) {\n            return claimedElsewhere();\n        }\n\n        const timer = new ProcessTimer(ITERATION_MAX_DURATION_MS);\n        const renewal = new ClaimRenewal({\n            claim: this.claim,\n            target,\n            onLost: () => {\n                // Another process may already be running it. Ask the task to save and stop.\n                timer.expire();\n                this.logger.warn({ ...target }, \"Lost the claim on a running background task.\");\n            },\n            onError: error => {\n                this.logger.warn({ error, ...target }, \"Could not extend a background task claim.\");\n            }\n        });\n\n        // TaskRunner still takes the legacy context object, which now only carries the container.\n        const ctx: Record<string, any> = { container: this.container };\n        const runner = new TaskRunner(ctx as Context, timer, new TaskEventValidation());\n\n        let result: IResponseResult;\n        const stopListening = this.shutdown.onShutdown(() => {\n            timer.expire();\n        });\n        renewal.start();\n        try {\n            result = await runner.run(taskEvent);\n        } finally {\n            renewal.stop();\n            stopListening();\n        }\n\n        if (renewal.isLost()) {\n            return claimedElsewhere();\n        }\n\n        // The loop reads `status`, `wait` and `delay` from this to decide what happens next.\n        return this.afterIteration(target, result);\n    }\n\n    // Later iterations find the claim already theirs; only the first has to take it.\n    private async hold(target: TaskClaim.Target): Promise<boolean> {\n        const kept = await this.claim.keep(target, CLAIM_TTL_MS);\n        if (kept) {\n            return true;\n        }\n        return this.claim.take(target, CLAIM_TTL_MS);\n    }\n\n    private async afterIteration(\n        target: TaskClaim.Target,\n        result: IResponseResult\n    ): Promise<unknown> {\n        if (result.status !== TaskResultStatus.CONTINUE) {\n            await this.release(target);\n            return result;\n        }\n\n        /*\n         * The loop now sleeps for `wait` seconds, with nothing renewing the claim. It is extended\n         * past the wait instead, so other processes leave the task alone until it is due again. If\n         * this process dies meanwhile, they take the task over once the wait and one TTL are up.\n         */\n        const waitMs = (result.wait ?? 0) * 1000;\n\n        /*\n         * Stopping, with the task ready to go on at once: the claim is released, so another process\n         * takes the task over at its next recovery sweep rather than once the claim runs out.\n         */\n        const shuttingDown = this.shutdown.isShuttingDown();\n        if (shuttingDown && waitMs === 0) {\n            await this.release(target);\n            return handedBack();\n        }\n\n        const kept = await this.claim.keep(target, CLAIM_TTL_MS + waitMs);\n        if (!kept) {\n            return claimedElsewhere();\n        }\n        // Stopping, with the task due later: it keeps its claim, so nobody runs it before it's due.\n        if (shuttingDown) {\n            return handedBack();\n        }\n        return result;\n    }\n\n    /*\n     * A claim that cannot be released runs out on its own. Recovery then finds the task finished and\n     * leaves it alone, so the failure is only worth a warning.\n     */\n    private async release(target: TaskClaim.Target): Promise<void> {\n        try {\n            await this.claim.release(target);\n        } catch (error) {\n            this.logger.warn({ error, ...target }, \"Could not release a background task claim.\");\n        }\n    }\n}\n\nexport const InProcessBackgroundTaskHandler = BackgroundTaskEventHandler.createImplementation({\n    implementation: InProcessBackgroundTaskHandlerImpl,\n    dependencies: [\n        RequestContainer,\n        RawTenantId,\n        RequestTenantLoader,\n        TaskClaim,\n        ShutdownSignal,\n        Logger\n    ]\n});\n"],"names":["ITERATION_MAX_DURATION_MS","claimedElsewhere","CLAIMED_ELSEWHERE_STATUS","handedBack","HANDED_BACK_STATUS","InProcessBackgroundTaskHandlerImpl","container","rawTenantId","tenantLoader","claim","shutdown","logger","eventCtx","taskEvent","target","held","timer","ProcessTimer","renewal","ClaimRenewal","error","ctx","runner","TaskRunner","TaskEventValidation","result","stopListening","kept","CLAIM_TTL_MS","TaskResultStatus","waitMs","shuttingDown","InProcessBackgroundTaskHandler","BackgroundTaskEventHandler","RequestContainer","RawTenantId","RequestTenantLoader","TaskClaim","ShutdownSignal","Logger"],"mappings":"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"}

package/index.d.ts

@@ -0,0 +1,3 @@
+export { BackgroundTasksStandaloneFeature } from "./BackgroundTasksStandaloneFeature.js";
+export { startTaskRecovery } from "./recovery/startTaskRecovery.js";
+export { stopBackgroundTasks } from "./shutdown/stopBackgroundTasks.js";

package/index.js

@@ -0,0 +1,3 @@
+export { BackgroundTasksStandaloneFeature } from "./BackgroundTasksStandaloneFeature.js";
+export { startTaskRecovery } from "./recovery/startTaskRecovery.js";
+export { stopBackgroundTasks } from "./shutdown/stopBackgroundTasks.js";

package/loop/InProcessBackgroundTasksLoop.d.ts

@@ -0,0 +1,22 @@
+import { EventDispatcher } from "@webiny/event-handler-core";
+import type { IBackgroundTaskEvent } from "@webiny/event-handler-core";
+import { BackgroundTasksLoop } from "../domain/BackgroundTasksLoop.js";
+import { ShutdownSignal } from "../domain/ShutdownSignal.js";
+/**
+ * Root singleton: runs every background task of the process, one `TaskExecution` per task. This
+ * class decides which tasks run and how many iterations at once; how one task is driven is
+ * `TaskExecution`'s.
+ */
+declare class InProcessBackgroundTasksLoopImpl implements BackgroundTasksLoop.Interface {
+    private readonly dispatcher;
+    private readonly shutdown;
+    private readonly slots;
+    private readonly executions;
+    constructor(dispatcher: EventDispatcher.Interface, shutdown: ShutdownSignal.Interface);
+    start(event: IBackgroundTaskEvent): void;
+    stop(timeoutMs: number): Promise<void>;
+}
+export declare const InProcessBackgroundTasksLoop: typeof InProcessBackgroundTasksLoopImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/domain/BackgroundTasksLoop.js").IBackgroundTasksLoop>;
+};
+export {};

package/loop/InProcessBackgroundTasksLoop.js

@@ -0,0 +1,58 @@
+import { EventDispatcher } from "@webiny/event-handler-core";
+import { BackgroundTasksLoop } from "../domain/BackgroundTasksLoop.js";
+import { ShutdownSignal } from "../domain/ShutdownSignal.js";
+import { IterationSlots } from "./IterationSlots.js";
+import { TaskExecution } from "./TaskExecution.js";
+const MAX_RUNNING_ITERATIONS = 5;
+class InProcessBackgroundTasksLoopImpl {
+    constructor(dispatcher, shutdown){
+        this.dispatcher = dispatcher;
+        this.shutdown = shutdown;
+        this.slots = new IterationSlots(MAX_RUNNING_ITERATIONS);
+        this.executions = new Map();
+    }
+    start(event) {
+        const taskId = event.webinyTaskId;
+        if (this.shutdown.isShuttingDown() || this.executions.has(taskId)) return;
+        const execution = new TaskExecution({
+            event,
+            dispatcher: this.dispatcher,
+            slots: this.slots,
+            shutdown: this.shutdown
+        });
+        this.executions.set(taskId, execution);
+        execution.run().finally(()=>{
+            this.executions.delete(taskId);
+        });
+    }
+    async stop(timeoutMs) {
+        this.shutdown.begin();
+        this.slots.close();
+        for (const execution of this.executions.values())execution.interrupt();
+        const iterations = [];
+        for (const execution of this.executions.values()){
+            const iteration = execution.getRunningIteration();
+            if (iteration) iterations.push(iteration);
+        }
+        let timer;
+        const timeout = new Promise((resolve)=>{
+            timer = setTimeout(resolve, timeoutMs);
+        });
+        const settled = Promise.allSettled(iterations);
+        await Promise.race([
+            settled,
+            timeout
+        ]);
+        clearTimeout(timer);
+    }
+}
+const InProcessBackgroundTasksLoop = BackgroundTasksLoop.createImplementation({
+    implementation: InProcessBackgroundTasksLoopImpl,
+    dependencies: [
+        EventDispatcher,
+        ShutdownSignal
+    ]
+});
+export { InProcessBackgroundTasksLoop };
+
+//# sourceMappingURL=InProcessBackgroundTasksLoop.js.map

package/loop/InProcessBackgroundTasksLoop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop/InProcessBackgroundTasksLoop.js","sources":["../../src/loop/InProcessBackgroundTasksLoop.ts"],"sourcesContent":["import { EventDispatcher } from \"@webiny/event-handler-core\";\nimport type { IBackgroundTaskEvent } from \"@webiny/event-handler-core\";\nimport { BackgroundTasksLoop } from \"~/domain/BackgroundTasksLoop.js\";\nimport { ShutdownSignal } from \"~/domain/ShutdownSignal.js\";\nimport { IterationSlots } from \"./IterationSlots.js\";\nimport { TaskExecution } from \"./TaskExecution.js\";\n\n/*\n * Iterations that run at once in this process; the rest wait in line. A task that waits between its\n * iterations holds no slot, so this caps the work being done, not the tasks in progress.\n */\nconst MAX_RUNNING_ITERATIONS = 5;\n\n/**\n * Root singleton: runs every background task of the process, one `TaskExecution` per task. This\n * class decides which tasks run and how many iterations at once; how one task is driven is\n * `TaskExecution`'s.\n */\nclass InProcessBackgroundTasksLoopImpl implements BackgroundTasksLoop.Interface {\n    private readonly slots = new IterationSlots(MAX_RUNNING_ITERATIONS);\n    // One per task, from `start` until its execution ends, waits included.\n    private readonly executions = new Map<string, TaskExecution>();\n\n    public constructor(\n        private readonly dispatcher: EventDispatcher.Interface,\n        private readonly shutdown: ShutdownSignal.Interface\n    ) {}\n\n    public start(event: IBackgroundTaskEvent): void {\n        const taskId = event.webinyTaskId;\n        if (this.shutdown.isShuttingDown() || this.executions.has(taskId)) {\n            return;\n        }\n        const execution = new TaskExecution({\n            event,\n            dispatcher: this.dispatcher,\n            slots: this.slots,\n            shutdown: this.shutdown\n        });\n        this.executions.set(taskId, execution);\n        void execution.run().finally(() => {\n            this.executions.delete(taskId);\n        });\n    }\n\n    public async stop(timeoutMs: number): Promise<void> {\n        // Running iterations hear this through the signal, and hand their task back.\n        this.shutdown.begin();\n        // Executions waiting for a slot are turned away, and ones waiting between iterations end.\n        this.slots.close();\n        for (const execution of this.executions.values()) {\n            execution.interrupt();\n        }\n\n        /*\n         * Only iterations being dispatched are waited for: saving progress and releasing the claim\n         * happen inside them. The rest have ended above, with nothing to save.\n         */\n        const iterations: Promise<unknown>[] = [];\n        for (const execution of this.executions.values()) {\n            const iteration = execution.getRunningIteration();\n            if (iteration) {\n                iterations.push(iteration);\n            }\n        }\n\n        let timer: ReturnType<typeof setTimeout> | undefined;\n        const timeout = new Promise<void>(resolve => {\n            timer = setTimeout(resolve, timeoutMs);\n        });\n        const settled = Promise.allSettled(iterations);\n        await Promise.race([settled, timeout]);\n        clearTimeout(timer);\n    }\n}\n\nexport const InProcessBackgroundTasksLoop = BackgroundTasksLoop.createImplementation({\n    implementation: InProcessBackgroundTasksLoopImpl,\n    dependencies: [EventDispatcher, ShutdownSignal]\n});\n"],"names":["MAX_RUNNING_ITERATIONS","InProcessBackgroundTasksLoopImpl","dispatcher","shutdown","IterationSlots","Map","event","taskId","execution","TaskExecution","timeoutMs","iterations","iteration","timer","timeout","Promise","resolve","setTimeout","settled","clearTimeout","InProcessBackgroundTasksLoop","BackgroundTasksLoop","EventDispatcher","ShutdownSignal"],"mappings":";;;;;AAWA,MAAMA,yBAAyB;AAO/B,MAAMC;IAKF,YACqBC,UAAqC,EACrCC,QAAkC,CACrD;aAFmBD,UAAU,GAAVA;aACAC,QAAQ,GAARA;aANJ,KAAK,GAAG,IAAIC,eAAeJ;aAE3B,UAAU,GAAG,IAAIK;IAK/B;IAEI,MAAMC,KAA2B,EAAQ;QAC5C,MAAMC,SAASD,MAAM,YAAY;QACjC,IAAI,IAAI,CAAC,QAAQ,CAAC,cAAc,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAACC,SACtD;QAEJ,MAAMC,YAAY,IAAIC,cAAc;YAChCH;YACA,YAAY,IAAI,CAAC,UAAU;YAC3B,OAAO,IAAI,CAAC,KAAK;YACjB,UAAU,IAAI,CAAC,QAAQ;QAC3B;QACA,IAAI,CAAC,UAAU,CAAC,GAAG,CAACC,QAAQC;QACvBA,UAAU,GAAG,GAAG,OAAO,CAAC;YACzB,IAAI,CAAC,UAAU,CAAC,MAAM,CAACD;QAC3B;IACJ;IAEA,MAAa,KAAKG,SAAiB,EAAiB;QAEhD,IAAI,CAAC,QAAQ,CAAC,KAAK;QAEnB,IAAI,CAAC,KAAK,CAAC,KAAK;QAChB,KAAK,MAAMF,aAAa,IAAI,CAAC,UAAU,CAAC,MAAM,GAC1CA,UAAU,SAAS;QAOvB,MAAMG,aAAiC,EAAE;QACzC,KAAK,MAAMH,aAAa,IAAI,CAAC,UAAU,CAAC,MAAM,GAAI;YAC9C,MAAMI,YAAYJ,UAAU,mBAAmB;YAC/C,IAAII,WACAD,WAAW,IAAI,CAACC;QAExB;QAEA,IAAIC;QACJ,MAAMC,UAAU,IAAIC,QAAcC,CAAAA;YAC9BH,QAAQI,WAAWD,SAASN;QAChC;QACA,MAAMQ,UAAUH,QAAQ,UAAU,CAACJ;QACnC,MAAMI,QAAQ,IAAI,CAAC;YAACG;YAASJ;SAAQ;QACrCK,aAAaN;IACjB;AACJ;AAEO,MAAMO,+BAA+BC,oBAAoB,oBAAoB,CAAC;IACjF,gBAAgBpB;IAChB,cAAc;QAACqB;QAAiBC;KAAe;AACnD"}

package/loop/IterationSlots.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Limits how many task iterations run at once. An iteration takes a slot before it runs and gives it
+ * back after; one that finds them all taken waits in line, first come first served.
+ */
+export declare class IterationSlots {
+    private readonly size;
+    private used;
+    private readonly waiting;
+    private closed;
+    constructor(size: number);
+    /**
+     * Resolves to `true` once a slot is this caller's, which it must hand back with `release`. Resolves
+     * to `false` when the slots close first: the caller must not run.
+     */
+    acquire(): Promise<boolean>;
+    release(): void;
+    /** Turns away everyone still waiting, and anyone who asks from now on. */
+    close(): void;
+    getRunning(): number;
+    getWaiting(): number;
+}

package/loop/IterationSlots.js

@@ -0,0 +1,37 @@
+class IterationSlots {
+    constructor(size){
+        this.used = 0;
+        this.waiting = [];
+        this.closed = false;
+        this.size = size;
+    }
+    acquire() {
+        if (this.closed) return Promise.resolve(false);
+        if (this.used < this.size) {
+            this.used++;
+            return Promise.resolve(true);
+        }
+        return new Promise((resolve)=>{
+            this.waiting.push(resolve);
+        });
+    }
+    release() {
+        const next = this.waiting.shift();
+        if (next) return void next(true);
+        this.used--;
+    }
+    close() {
+        this.closed = true;
+        const waiting = this.waiting.splice(0);
+        for (const grant of waiting)grant(false);
+    }
+    getRunning() {
+        return this.used;
+    }
+    getWaiting() {
+        return this.waiting.length;
+    }
+}
+export { IterationSlots };
+
+//# sourceMappingURL=IterationSlots.js.map

package/loop/IterationSlots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop/IterationSlots.js","sources":["../../src/loop/IterationSlots.ts"],"sourcesContent":["type Grant = (granted: boolean) => void;\n\n/**\n * Limits how many task iterations run at once. An iteration takes a slot before it runs and gives it\n * back after; one that finds them all taken waits in line, first come first served.\n */\nexport class IterationSlots {\n    private readonly size: number;\n    private used = 0;\n    private readonly waiting: Grant[] = [];\n    private closed = false;\n\n    public constructor(size: number) {\n        this.size = size;\n    }\n\n    /**\n     * Resolves to `true` once a slot is this caller's, which it must hand back with `release`. Resolves\n     * to `false` when the slots close first: the caller must not run.\n     */\n    public acquire(): Promise<boolean> {\n        if (this.closed) {\n            return Promise.resolve(false);\n        }\n        if (this.used < this.size) {\n            this.used++;\n            return Promise.resolve(true);\n        }\n        return new Promise<boolean>(resolve => {\n            this.waiting.push(resolve);\n        });\n    }\n\n    public release(): void {\n        const next = this.waiting.shift();\n        if (next) {\n            // The slot passes straight to the next in line, so the count stays the same.\n            next(true);\n            return;\n        }\n        this.used--;\n    }\n\n    /** Turns away everyone still waiting, and anyone who asks from now on. */\n    public close(): void {\n        this.closed = true;\n        const waiting = this.waiting.splice(0);\n        for (const grant of waiting) {\n            grant(false);\n        }\n    }\n\n    public getRunning(): number {\n        return this.used;\n    }\n\n    public getWaiting(): number {\n        return this.waiting.length;\n    }\n}\n"],"names":["IterationSlots","size","Promise","resolve","next","waiting","grant"],"mappings":"AAMO,MAAMA;IAMT,YAAmBC,IAAY,CAAE;aAJzB,IAAI,GAAG;aACE,OAAO,GAAY,EAAE;aAC9B,MAAM,GAAG;QAGb,IAAI,CAAC,IAAI,GAAGA;IAChB;IAMO,UAA4B;QAC/B,IAAI,IAAI,CAAC,MAAM,EACX,OAAOC,QAAQ,OAAO,CAAC;QAE3B,IAAI,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE;YACvB,IAAI,CAAC,IAAI;YACT,OAAOA,QAAQ,OAAO,CAAC;QAC3B;QACA,OAAO,IAAIA,QAAiBC,CAAAA;YACxB,IAAI,CAAC,OAAO,CAAC,IAAI,CAACA;QACtB;IACJ;IAEO,UAAgB;QACnB,MAAMC,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK;QAC/B,IAAIA,MAAM,YAENA,KAAK;QAGT,IAAI,CAAC,IAAI;IACb;IAGO,QAAc;QACjB,IAAI,CAAC,MAAM,GAAG;QACd,MAAMC,UAAU,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;QACpC,KAAK,MAAMC,SAASD,QAChBC,MAAM;IAEd;IAEO,aAAqB;QACxB,OAAO,IAAI,CAAC,IAAI;IACpB;IAEO,aAAqB;QACxB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM;IAC9B;AACJ"}

package/loop/TaskExecution.d.ts

@@ -0,0 +1,31 @@
+import type { EventDispatcher } from "@webiny/event-handler-core";
+import type { IBackgroundTaskEvent } from "@webiny/event-handler-core";
+import type { ShutdownSignal } from "../domain/ShutdownSignal.js";
+import type { IterationSlots } from "./IterationSlots.js";
+interface ITaskExecutionParams {
+    event: IBackgroundTaskEvent;
+    dispatcher: EventDispatcher.Interface;
+    slots: IterationSlots;
+    shutdown: ShutdownSignal.Interface;
+}
+/**
+ * One task, driven from its first iteration until it is done: take a slot, run an iteration, decide
+ * what follows, wait as long as the task asked, and run the next. The standalone counterpart of one
+ * Step Functions execution on AWS, whose `Run`, `CheckStatus` and `Waiter` states these steps are.
+ *
+ * Each iteration is one dispatched `BackgroundTaskEvent`, handled in a fresh request container like
+ * an HTTP request would be.
+ */
+export declare class TaskExecution {
+    private readonly params;
+    private iteration;
+    private wake;
+    constructor(params: ITaskExecutionParams);
+    run(): Promise<void>;
+    /** The iteration being dispatched right now, if there is one. */
+    getRunningIteration(): Promise<unknown> | undefined;
+    /** Ends a wait between iterations early. */
+    interrupt(): void;
+    private sleep;
+}
+export {};

package/loop/TaskExecution.js

@@ -0,0 +1,61 @@
+import { ProcessTimer } from "../timer/ProcessTimer.js";
+import { nextStep } from "./nextStep.js";
+const MAX_TASK_DURATION_MS = 86400000;
+class TaskExecution {
+    constructor(params){
+        this.params = params;
+    }
+    async run() {
+        const { dispatcher, slots, shutdown } = this.params;
+        const taskId = this.params.event.webinyTaskId;
+        const timer = new ProcessTimer(MAX_TASK_DURATION_MS);
+        let event = this.params.event;
+        while(timer.getRemainingMilliseconds() > 0){
+            const granted = await slots.acquire();
+            if (!granted) return;
+            let result;
+            const iteration = dispatcher.dispatch(event);
+            this.iteration = iteration;
+            try {
+                result = await iteration;
+            } catch (error) {
+                console.error(`Background task "${taskId}" failed:`, error);
+                return;
+            } finally{
+                this.iteration = void 0;
+                slots.release();
+            }
+            const step = nextStep(result);
+            if ("end" === step.kind) return;
+            if ("unexpected" === step.kind) return void console.error(`Background task "${taskId}" stopped with status "${step.status}":`, result);
+            event = {
+                ...event,
+                delay: step.delay
+            };
+            if (step.waitMs > 0) await this.sleep(step.waitMs);
+            if (shutdown.isShuttingDown()) return;
+        }
+        console.error(`Background task "${taskId}" exceeded the maximum duration.`);
+    }
+    getRunningIteration() {
+        return this.iteration;
+    }
+    interrupt() {
+        this.wake?.();
+    }
+    sleep(ms) {
+        return new Promise((resolve)=>{
+            const timer = setTimeout(()=>{
+                this.wake?.();
+            }, ms);
+            this.wake = ()=>{
+                clearTimeout(timer);
+                this.wake = void 0;
+                resolve();
+            };
+        });
+    }
+}
+export { TaskExecution };
+
+//# sourceMappingURL=TaskExecution.js.map

package/loop/TaskExecution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop/TaskExecution.js","sources":["../../src/loop/TaskExecution.ts"],"sourcesContent":["import type { EventDispatcher } from \"@webiny/event-handler-core\";\nimport type { IBackgroundTaskEvent } from \"@webiny/event-handler-core\";\nimport type { ShutdownSignal } from \"~/domain/ShutdownSignal.js\";\nimport { ProcessTimer } from \"~/timer/ProcessTimer.js\";\nimport type { IterationSlots } from \"./IterationSlots.js\";\nimport { nextStep } from \"./nextStep.js\";\nimport type { IIterationResult } from \"./nextStep.js\";\n\n// 24 hours, the most one task may run in total.\nconst MAX_TASK_DURATION_MS = 86_400_000;\n\ninterface ITaskExecutionParams {\n    event: IBackgroundTaskEvent;\n    dispatcher: EventDispatcher.Interface;\n    slots: IterationSlots;\n    shutdown: ShutdownSignal.Interface;\n}\n\n/**\n * One task, driven from its first iteration until it is done: take a slot, run an iteration, decide\n * what follows, wait as long as the task asked, and run the next. The standalone counterpart of one\n * Step Functions execution on AWS, whose `Run`, `CheckStatus` and `Waiter` states these steps are.\n *\n * Each iteration is one dispatched `BackgroundTaskEvent`, handled in a fresh request container like\n * an HTTP request would be.\n */\nexport class TaskExecution {\n    private readonly params: ITaskExecutionParams;\n    private iteration: Promise<unknown> | undefined;\n    private wake: (() => void) | undefined;\n\n    public constructor(params: ITaskExecutionParams) {\n        this.params = params;\n    }\n\n    public async run(): Promise<void> {\n        const { dispatcher, slots, shutdown } = this.params;\n        const taskId = this.params.event.webinyTaskId;\n        const timer = new ProcessTimer(MAX_TASK_DURATION_MS);\n        let event = this.params.event;\n\n        while (timer.getRemainingMilliseconds() > 0) {\n            /*\n             * A slot that is not granted means the process is shutting down. A task that was waiting\n             * keeps its claim, which runs out when it is due, so another process does not run it early.\n             */\n            const granted = await slots.acquire();\n            if (!granted) {\n                return;\n            }\n\n            let result: IIterationResult | undefined;\n            const iteration = dispatcher.dispatch<IIterationResult>(event);\n            this.iteration = iteration;\n            try {\n                result = await iteration;\n            } catch (error) {\n                console.error(`Background task \"${taskId}\" failed:`, error);\n                return;\n            } finally {\n                this.iteration = undefined;\n                slots.release();\n            }\n\n            const step = nextStep(result);\n            if (step.kind === \"end\") {\n                return;\n            }\n            if (step.kind === \"unexpected\") {\n                console.error(\n                    `Background task \"${taskId}\" stopped with status \"${step.status}\":`,\n                    result\n                );\n                return;\n            }\n\n            event = { ...event, delay: step.delay };\n            if (step.waitMs > 0) {\n                await this.sleep(step.waitMs);\n            }\n            if (shutdown.isShuttingDown()) {\n                return;\n            }\n        }\n\n        console.error(`Background task \"${taskId}\" exceeded the maximum duration.`);\n    }\n\n    /** The iteration being dispatched right now, if there is one. */\n    public getRunningIteration(): Promise<unknown> | undefined {\n        return this.iteration;\n    }\n\n    /** Ends a wait between iterations early. */\n    public interrupt(): void {\n        this.wake?.();\n    }\n\n    private sleep(ms: number): Promise<void> {\n        return new Promise(resolve => {\n            const timer = setTimeout(() => {\n                this.wake?.();\n            }, ms);\n            this.wake = () => {\n                clearTimeout(timer);\n                this.wake = undefined;\n                resolve();\n            };\n        });\n    }\n}\n"],"names":["MAX_TASK_DURATION_MS","TaskExecution","params","dispatcher","slots","shutdown","taskId","timer","ProcessTimer","event","granted","result","iteration","error","console","undefined","step","nextStep","ms","Promise","resolve","setTimeout","clearTimeout"],"mappings":";;AASA,MAAMA,uBAAuB;AAiBtB,MAAMC;IAKT,YAAmBC,MAA4B,CAAE;QAC7C,IAAI,CAAC,MAAM,GAAGA;IAClB;IAEA,MAAa,MAAqB;QAC9B,MAAM,EAAEC,UAAU,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAG,IAAI,CAAC,MAAM;QACnD,MAAMC,SAAS,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY;QAC7C,MAAMC,QAAQ,IAAIC,aAAaR;QAC/B,IAAIS,QAAQ,IAAI,CAAC,MAAM,CAAC,KAAK;QAE7B,MAAOF,MAAM,wBAAwB,KAAK,EAAG;YAKzC,MAAMG,UAAU,MAAMN,MAAM,OAAO;YACnC,IAAI,CAACM,SACD;YAGJ,IAAIC;YACJ,MAAMC,YAAYT,WAAW,QAAQ,CAAmBM;YACxD,IAAI,CAAC,SAAS,GAAGG;YACjB,IAAI;gBACAD,SAAS,MAAMC;YACnB,EAAE,OAAOC,OAAO;gBACZC,QAAQ,KAAK,CAAC,CAAC,iBAAiB,EAAER,OAAO,SAAS,CAAC,EAAEO;gBACrD;YACJ,SAAU;gBACN,IAAI,CAAC,SAAS,GAAGE;gBACjBX,MAAM,OAAO;YACjB;YAEA,MAAMY,OAAOC,SAASN;YACtB,IAAIK,AAAc,UAAdA,KAAK,IAAI,EACT;YAEJ,IAAIA,AAAc,iBAAdA,KAAK,IAAI,EAAmB,YAC5BF,QAAQ,KAAK,CACT,CAAC,iBAAiB,EAAER,OAAO,uBAAuB,EAAEU,KAAK,MAAM,CAAC,EAAE,CAAC,EACnEL;YAKRF,QAAQ;gBAAE,GAAGA,KAAK;gBAAE,OAAOO,KAAK,KAAK;YAAC;YACtC,IAAIA,KAAK,MAAM,GAAG,GACd,MAAM,IAAI,CAAC,KAAK,CAACA,KAAK,MAAM;YAEhC,IAAIX,SAAS,cAAc,IACvB;QAER;QAEAS,QAAQ,KAAK,CAAC,CAAC,iBAAiB,EAAER,OAAO,gCAAgC,CAAC;IAC9E;IAGO,sBAAoD;QACvD,OAAO,IAAI,CAAC,SAAS;IACzB;IAGO,YAAkB;QACrB,IAAI,CAAC,IAAI;IACb;IAEQ,MAAMY,EAAU,EAAiB;QACrC,OAAO,IAAIC,QAAQC,CAAAA;YACf,MAAMb,QAAQc,WAAW;gBACrB,IAAI,CAAC,IAAI;YACb,GAAGH;YACH,IAAI,CAAC,IAAI,GAAG;gBACRI,aAAaf;gBACb,IAAI,CAAC,IAAI,GAAGQ;gBACZK;YACJ;QACJ;IACJ;AACJ"}

package/loop/nextStep.d.ts

@@ -0,0 +1,20 @@
+export interface IIterationResult {
+    status?: string;
+    wait?: number;
+    delay?: number;
+}
+export type TaskStep = {
+    kind: "continue";
+    waitMs: number;
+    delay: number;
+} | {
+    kind: "end";
+} | {
+    kind: "unexpected";
+    status: string | undefined;
+};
+/**
+ * Decides what follows one iteration. The standalone counterpart of the `CheckStatus` choice state
+ * in the Step Functions definition that drives a task on AWS.
+ */
+export declare function nextStep(result: IIterationResult | undefined): TaskStep;

package/loop/nextStep.js

@@ -0,0 +1,26 @@
+import { CLAIMED_ELSEWHERE_STATUS, HANDED_BACK_STATUS } from "../domain/BackgroundTasksLoop.js";
+const QUIET_ENDS = new Set([
+    "done",
+    "aborted",
+    CLAIMED_ELSEWHERE_STATUS,
+    HANDED_BACK_STATUS
+]);
+function nextStep(result) {
+    const status = result?.status;
+    if (status && QUIET_ENDS.has(status)) return {
+        kind: "end"
+    };
+    if ("continue" !== status) return {
+        kind: "unexpected",
+        status
+    };
+    const waitSeconds = result?.wait ?? 0;
+    return {
+        kind: "continue",
+        waitMs: 1000 * waitSeconds,
+        delay: result?.delay ?? -1
+    };
+}
+export { nextStep };
+
+//# sourceMappingURL=nextStep.js.map

package/loop/nextStep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop/nextStep.js","sources":["../../src/loop/nextStep.ts"],"sourcesContent":["import { CLAIMED_ELSEWHERE_STATUS } from \"~/domain/BackgroundTasksLoop.js\";\nimport { HANDED_BACK_STATUS } from \"~/domain/BackgroundTasksLoop.js\";\n\n// What the handler answers for one iteration; only the fields an execution reads.\nexport interface IIterationResult {\n    status?: string;\n    wait?: number;\n    delay?: number;\n}\n\nexport type TaskStep =\n    | {\n          kind: \"continue\";\n          // How long to wait before the next iteration.\n          waitMs: number;\n          // The delay the next iteration's event carries.\n          delay: number;\n      }\n    // The task is finished, or is no longer this process's to run.\n    | { kind: \"end\" }\n    // The handler answered something an execution does not expect, an error result included.\n    | { kind: \"unexpected\"; status: string | undefined };\n\n// Statuses after which the execution ends without it being an error.\nconst QUIET_ENDS = new Set([\"done\", \"aborted\", CLAIMED_ELSEWHERE_STATUS, HANDED_BACK_STATUS]);\n\n/**\n * Decides what follows one iteration. The standalone counterpart of the `CheckStatus` choice state\n * in the Step Functions definition that drives a task on AWS.\n */\nexport function nextStep(result: IIterationResult | undefined): TaskStep {\n    const status = result?.status;\n    if (status && QUIET_ENDS.has(status)) {\n        return { kind: \"end\" };\n    }\n    if (status !== \"continue\") {\n        return { kind: \"unexpected\", status };\n    }\n\n    /*\n     * The first event carries the trigger's delay, and the runner answers it with `continue` and\n     * `wait: delay` without running anything. Every later event must carry the delay the runner sent\n     * back (-1), as the Step Functions state does on AWS. Resending the original delay would make the\n     * runner answer `continue` forever.\n     */\n    const waitSeconds = result?.wait ?? 0;\n    return {\n        kind: \"continue\",\n        waitMs: waitSeconds * 1000,\n        delay: result?.delay ?? -1\n    };\n}\n"],"names":["QUIET_ENDS","Set","CLAIMED_ELSEWHERE_STATUS","HANDED_BACK_STATUS","nextStep","result","status","waitSeconds"],"mappings":";AAwBA,MAAMA,aAAa,IAAIC,IAAI;IAAC;IAAQ;IAAWC;IAA0BC;CAAmB;AAMrF,SAASC,SAASC,MAAoC;IACzD,MAAMC,SAASD,QAAQ;IACvB,IAAIC,UAAUN,WAAW,GAAG,CAACM,SACzB,OAAO;QAAE,MAAM;IAAM;IAEzB,IAAIA,AAAW,eAAXA,QACA,OAAO;QAAE,MAAM;QAAcA;IAAO;IASxC,MAAMC,cAAcF,QAAQ,QAAQ;IACpC,OAAO;QACH,MAAM;QACN,QAAQE,AAAc,OAAdA;QACR,OAAOF,QAAQ,SAAS;IAC5B;AACJ"}

package/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "@webiny/background-tasks-standalone",
+	"version": "0.0.0-unstable.33e4fd9647",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"description": "Node server transport for Webiny background tasks (worker-thread orchestrator).",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/background-tasks-standalone"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/api-core": "0.0.0-unstable.33e4fd9647",
+		"@webiny/background-tasks": "0.0.0-unstable.33e4fd9647",
+		"@webiny/event-handler-core": "0.0.0-unstable.33e4fd9647",
+		"@webiny/event-handler-standalone": "0.0.0-unstable.33e4fd9647",
+		"@webiny/feature": "0.0.0-unstable.33e4fd9647",
+		"@webiny/utils": "0.0.0-unstable.33e4fd9647"
+	},
+	"devDependencies": {
+		"@webiny/build-tools": "0.0.0-unstable.33e4fd9647",
+		"@webiny/di": "2.0.0",
+		"rimraf": "6.1.3",
+		"typescript": "7.0.2",
+		"vitest": "4.1.11"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}

package/recovery/RecoverTasksHandler.d.ts

@@ -0,0 +1,47 @@
+import { ListTenantsUseCase } from "@webiny/api-core/features/tenancy/ListTenants/index.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { ListTasksUseCase } from "@webiny/background-tasks/api/features/ListTasks/index.js";
+import { UpdateTaskUseCase } from "@webiny/background-tasks/api/features/UpdateTask/index.js";
+import { BackgroundTasksLoop } from "../domain/BackgroundTasksLoop.js";
+import { TaskClaim } from "../domain/TaskClaim.js";
+import { TaskRecoveries } from "../domain/TaskRecoveries.js";
+import { ShutdownSignal } from "../domain/ShutdownSignal.js";
+import { TaskRecoverEventHandler } from "./TaskRecoverEventHandler.js";
+/**
+ * Takes over every unfinished task that no process holds: those of a process that died or was
+ * replaced, and any that were triggered but never started. Pending and running tasks alike are
+ * resumed from their last saved state, the way the next iteration would have continued them.
+ *
+ * A running task is resumed rather than failed because a redeploy kills healthy work, and the runner
+ * picks it up where its last iteration saved it. Work an iteration did after that save runs again,
+ * so a task must cope with an iteration being repeated.
+ *
+ * Each time recovery picks a task up, it counts that, and the count starts over whenever the task
+ * has saved since the last pick-up. A task picked up more than `MAX_RECOVERIES` times without saving
+ * in between is marked failed instead of resumed. This is for a task that takes the server down
+ * itself, say by running out of memory: resumed after every restart, it would crash the server again
+ * each time, and the server would never stay up. A long task that keeps saving survives any number
+ * of redeploys.
+ */
+declare class RecoverTasksHandlerImpl implements TaskRecoverEventHandler.Interface {
+    private readonly listTenants;
+    private readonly tenantContext;
+    private readonly listTasks;
+    private readonly updateTask;
+    private readonly claim;
+    private readonly recoveries;
+    private readonly tasksLoop;
+    private readonly shutdown;
+    private readonly logger;
+    constructor(listTenants: ListTenantsUseCase.Interface, tenantContext: TenantContext.Interface, listTasks: ListTasksUseCase.Interface, updateTask: UpdateTaskUseCase.Interface, claim: TaskClaim.Interface, recoveries: TaskRecoveries.Interface, tasksLoop: BackgroundTasksLoop.Interface, shutdown: ShutdownSignal.Interface, logger: Logger.Interface);
+    execute(): Promise<TaskRecoverEventHandler.Result>;
+    private recoverTenant;
+    private recoverUnfinished;
+    private recoverTask;
+    private fail;
+}
+export declare const RecoverTasksHandler: typeof RecoverTasksHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./TaskRecoverEventHandler.js").ITaskRecoverEventHandler>;
+};
+export {};