@kapeta/local-cluster-service 0.58.2 → 0.58.3

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.58.3](https://github.com/kapetacom/local-cluster-service/compare/v0.58.2...v0.58.3) (2024-07-26)
+
+
+### Bug Fixes
+
+* Ensure that we can control concurrency in page generation ([#203](https://github.com/kapetacom/local-cluster-service/issues/203)) ([4a919e0](https://github.com/kapetacom/local-cluster-service/commit/4a919e013b20f10d4199927970fbe38091a2b858))
+
 ## [0.58.2](https://github.com/kapetacom/local-cluster-service/compare/v0.58.1...v0.58.2) (2024-07-25)
 
 

package/dist/cjs/src/storm/PromiseQueue.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export type Future<T> = () => Promise<T>;
+export declare class PromiseQueue {
+    private readonly queue;
+    private readonly active;
+    private readonly maxConcurrency;
+    constructor(maxConcurrency?: number);
+    private toInternal;
+    add<T>(future: Future<T>): Promise<T>;
+    private next;
+    cancel(): void;
+    wait(): Promise<void>;
+}

package/dist/cjs/src/storm/PromiseQueue.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseQueue = void 0;
+class PromiseQueue {
+    queue = [];
+    active = [];
+    // Maximum number of concurrent promises
+    maxConcurrency;
+    constructor(maxConcurrency = 5) {
+        this.maxConcurrency = maxConcurrency;
+    }
+    toInternal(future) {
+        let resolve = () => { };
+        let reject = () => { };
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        return {
+            execute: future,
+            promise,
+            resolve,
+            reject,
+        };
+    }
+    add(future) {
+        const internal = this.toInternal(future);
+        this.queue.push(internal);
+        this.next();
+        return internal.promise;
+    }
+    next() {
+        if (this.active.length >= this.maxConcurrency) {
+            return false;
+        }
+        if (this.queue.length === 0) {
+            return false;
+        }
+        const future = this.queue.shift();
+        if (!future) {
+            return false;
+        }
+        const promise = future
+            .execute()
+            .then(future.resolve)
+            .catch(future.reject)
+            .finally(() => {
+            this.active.splice(this.active.indexOf(promise), 1);
+            this.next();
+        });
+        this.active.push(promise);
+        return this.next();
+    }
+    cancel() {
+        this.queue.splice(0, this.queue.length);
+        this.active.splice(0, this.active.length);
+    }
+    async wait() {
+        while (this.queue.length > 0 || this.active.length > 0) {
+            await Promise.all(this.active);
+        }
+    }
+}
+exports.PromiseQueue = PromiseQueue;

package/dist/cjs/src/storm/routes.js

@@ -19,6 +19,7 @@ const event_parser_1 = require("./event-parser");
 const codegen_1 = require("./codegen");
 const assetManager_1 = require("../assetManager");
 const node_uuid_1 = __importDefault(require("node-uuid"));
+const PromiseQueue_1 = require("./PromiseQueue");
 const router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.use('/', stringBody_1.stringBody);
@@ -61,6 +62,10 @@ router.post('/:handle/ui', async (req, res) => {
         res.set('Access-Control-Expose-Headers', stormClient_1.ConversationIdHeader);
         res.set(stormClient_1.ConversationIdHeader, userJourneysStream.getConversationId());
         const promises = {};
+        const queue = new PromiseQueue_1.PromiseQueue(10);
+        onRequestAborted(req, res, () => {
+            queue.cancel();
+        });
         userJourneysStream.on('data', async (data) => {
             try {
                 console.log('Processing user journey event', data);
@@ -68,11 +73,14 @@ router.post('/:handle/ui', async (req, res) => {
                 if (data.type !== 'USER_JOURNEY') {
                     return;
                 }
+                if (userJourneysStream.isAborted()) {
+                    return;
+                }
                 data.payload.screens.forEach((screen) => {
                     if (screen.name in promises) {
                         return;
                     }
-                    promises[screen.name] = new Promise(async (resolve, reject) => {
+                    promises[screen.name] = queue.add(() => new Promise(async (resolve, reject) => {
                         try {
                             const innerConversationId = node_uuid_1.default.v4();
                             const screenStream = await stormClient_1.stormClient.createUIPage({
@@ -88,7 +96,6 @@ router.post('/:handle/ui', async (req, res) => {
                                 if (screenData.type === 'PAGE') {
                                     screenData.payload.conversationId = innerConversationId;
                                 }
-                                console.log('Processing screen event', screenData);
                                 sendEvent(res, screenData);
                             });
                             screenStream.on('end', () => {
@@ -96,9 +103,10 @@ router.post('/:handle/ui', async (req, res) => {
                             });
                         }
                         catch (e) {
+                            console.error('Failed to process screen', e);
                             reject(e);
                         }
-                    });
+                    }));
                 });
             }
             catch (e) {
@@ -106,10 +114,10 @@ router.post('/:handle/ui', async (req, res) => {
             }
         });
         await waitForStormStream(userJourneysStream);
+        await queue.wait();
         if (userJourneysStream.isAborted()) {
             return;
         }
-        await Promise.all(Object.values(promises));
         sendDone(res);
     }
     catch (err) {

package/dist/esm/src/storm/PromiseQueue.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export type Future<T> = () => Promise<T>;
+export declare class PromiseQueue {
+    private readonly queue;
+    private readonly active;
+    private readonly maxConcurrency;
+    constructor(maxConcurrency?: number);
+    private toInternal;
+    add<T>(future: Future<T>): Promise<T>;
+    private next;
+    cancel(): void;
+    wait(): Promise<void>;
+}

package/dist/esm/src/storm/PromiseQueue.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseQueue = void 0;
+class PromiseQueue {
+    queue = [];
+    active = [];
+    // Maximum number of concurrent promises
+    maxConcurrency;
+    constructor(maxConcurrency = 5) {
+        this.maxConcurrency = maxConcurrency;
+    }
+    toInternal(future) {
+        let resolve = () => { };
+        let reject = () => { };
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        return {
+            execute: future,
+            promise,
+            resolve,
+            reject,
+        };
+    }
+    add(future) {
+        const internal = this.toInternal(future);
+        this.queue.push(internal);
+        this.next();
+        return internal.promise;
+    }
+    next() {
+        if (this.active.length >= this.maxConcurrency) {
+            return false;
+        }
+        if (this.queue.length === 0) {
+            return false;
+        }
+        const future = this.queue.shift();
+        if (!future) {
+            return false;
+        }
+        const promise = future
+            .execute()
+            .then(future.resolve)
+            .catch(future.reject)
+            .finally(() => {
+            this.active.splice(this.active.indexOf(promise), 1);
+            this.next();
+        });
+        this.active.push(promise);
+        return this.next();
+    }
+    cancel() {
+        this.queue.splice(0, this.queue.length);
+        this.active.splice(0, this.active.length);
+    }
+    async wait() {
+        while (this.queue.length > 0 || this.active.length > 0) {
+            await Promise.all(this.active);
+        }
+    }
+}
+exports.PromiseQueue = PromiseQueue;

package/dist/esm/src/storm/routes.js

@@ -19,6 +19,7 @@ const event_parser_1 = require("./event-parser");
 const codegen_1 = require("./codegen");
 const assetManager_1 = require("../assetManager");
 const node_uuid_1 = __importDefault(require("node-uuid"));
+const PromiseQueue_1 = require("./PromiseQueue");
 const router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.use('/', stringBody_1.stringBody);
@@ -61,6 +62,10 @@ router.post('/:handle/ui', async (req, res) => {
         res.set('Access-Control-Expose-Headers', stormClient_1.ConversationIdHeader);
         res.set(stormClient_1.ConversationIdHeader, userJourneysStream.getConversationId());
         const promises = {};
+        const queue = new PromiseQueue_1.PromiseQueue(10);
+        onRequestAborted(req, res, () => {
+            queue.cancel();
+        });
         userJourneysStream.on('data', async (data) => {
             try {
                 console.log('Processing user journey event', data);
@@ -68,11 +73,14 @@ router.post('/:handle/ui', async (req, res) => {
                 if (data.type !== 'USER_JOURNEY') {
                     return;
                 }
+                if (userJourneysStream.isAborted()) {
+                    return;
+                }
                 data.payload.screens.forEach((screen) => {
                     if (screen.name in promises) {
                         return;
                     }
-                    promises[screen.name] = new Promise(async (resolve, reject) => {
+                    promises[screen.name] = queue.add(() => new Promise(async (resolve, reject) => {
                         try {
                             const innerConversationId = node_uuid_1.default.v4();
                             const screenStream = await stormClient_1.stormClient.createUIPage({
@@ -88,7 +96,6 @@ router.post('/:handle/ui', async (req, res) => {
                                 if (screenData.type === 'PAGE') {
                                     screenData.payload.conversationId = innerConversationId;
                                 }
-                                console.log('Processing screen event', screenData);
                                 sendEvent(res, screenData);
                             });
                             screenStream.on('end', () => {
@@ -96,9 +103,10 @@ router.post('/:handle/ui', async (req, res) => {
                             });
                         }
                         catch (e) {
+                            console.error('Failed to process screen', e);
                             reject(e);
                         }
-                    });
+                    }));
                 });
             }
             catch (e) {
@@ -106,10 +114,10 @@ router.post('/:handle/ui', async (req, res) => {
             }
         });
         await waitForStormStream(userJourneysStream);
+        await queue.wait();
         if (userJourneysStream.isAborted()) {
             return;
         }
-        await Promise.all(Object.values(promises));
         sendDone(res);
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.58.2",
+    "version": "0.58.3",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/storm/PromiseQueue.ts

@@ -0,0 +1,86 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export type Future<T> = () => Promise<T>;
+
+type InternalFuture<T> = {
+    execute: Future<T>;
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: any) => void;
+};
+
+export class PromiseQueue {
+    private readonly queue: InternalFuture<any>[] = [];
+    private readonly active: Promise<any>[] = [];
+
+    // Maximum number of concurrent promises
+    private readonly maxConcurrency: number;
+
+    constructor(maxConcurrency: number = 5) {
+        this.maxConcurrency = maxConcurrency;
+    }
+
+    private toInternal<T>(future: Future<T>): InternalFuture<T> {
+        let resolve: (value: T) => void = () => {};
+        let reject: (reason: any) => void = () => {};
+
+        const promise = new Promise<T>((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        return {
+            execute: future,
+            promise,
+            resolve,
+            reject,
+        };
+    }
+
+    public add<T>(future: Future<T>) {
+        const internal = this.toInternal<T>(future);
+        this.queue.push(internal);
+        this.next();
+
+        return internal.promise;
+    }
+
+    private next(): boolean {
+        if (this.active.length >= this.maxConcurrency) {
+            return false;
+        }
+        if (this.queue.length === 0) {
+            return false;
+        }
+
+        const future = this.queue.shift();
+        if (!future) {
+            return false;
+        }
+
+        const promise = future
+            .execute()
+            .then(future.resolve)
+            .catch(future.reject)
+            .finally(() => {
+                this.active.splice(this.active.indexOf(promise), 1);
+                this.next();
+            });
+
+        this.active.push(promise);
+
+        return this.next();
+    }
+
+    public cancel() {
+        this.queue.splice(0, this.queue.length);
+        this.active.splice(0, this.active.length);
+    }
+
+    public async wait() {
+        while (this.queue.length > 0 || this.active.length > 0) {
+            await Promise.all(this.active);
+        }
+    }
+}

package/src/storm/routes.ts

@@ -24,6 +24,7 @@ import {
 import { StormCodegen } from './codegen';
 import { assetManager } from '../assetManager';
 import uuid from 'node-uuid';
+import { PromiseQueue } from './PromiseQueue';
 
 const router = Router();
 
@@ -82,6 +83,11 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
 
         const promises: { [key: string]: Promise<void> } = {};
 
+        const queue = new PromiseQueue(10);
+        onRequestAborted(req, res, () => {
+            queue.cancel();
+        });
+
         userJourneysStream.on('data', async (data: StormEvent) => {
             try {
                 console.log('Processing user journey event', data);
@@ -90,39 +96,47 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
                     return;
                 }
 
+                if (userJourneysStream.isAborted()) {
+                    return;
+                }
+
                 data.payload.screens.forEach((screen) => {
                     if (screen.name in promises) {
                         return;
                     }
-                    promises[screen.name] = new Promise(async (resolve, reject) => {
-                        try {
-                            const innerConversationId = uuid.v4();
-                            const screenStream = await stormClient.createUIPage(
-                                {
-                                    prompt: screen.requirements,
-                                    method: screen.method,
-                                    path: screen.path,
-                                    description: screen.requirements,
-                                    name: screen.name,
-                                    title: screen.title,
-                                    filename: screen.filename,
-                                },
-                                innerConversationId
-                            );
-                            screenStream.on('data', (screenData: StormEvent) => {
-                                if (screenData.type === 'PAGE') {
-                                    screenData.payload.conversationId = innerConversationId;
+                    promises[screen.name] = queue.add(
+                        () =>
+                            new Promise(async (resolve, reject) => {
+                                try {
+                                    const innerConversationId = uuid.v4();
+                                    const screenStream = await stormClient.createUIPage(
+                                        {
+                                            prompt: screen.requirements,
+                                            method: screen.method,
+                                            path: screen.path,
+                                            description: screen.requirements,
+                                            name: screen.name,
+                                            title: screen.title,
+                                            filename: screen.filename,
+                                        },
+                                        innerConversationId
+                                    );
+                                    screenStream.on('data', (screenData: StormEvent) => {
+                                        if (screenData.type === 'PAGE') {
+                                            screenData.payload.conversationId = innerConversationId;
+                                        }
+
+                                        sendEvent(res, screenData);
+                                    });
+                                    screenStream.on('end', () => {
+                                        resolve();
+                                    });
+                                } catch (e: any) {
+                                    console.error('Failed to process screen', e);
+                                    reject(e);
                                 }
-                                console.log('Processing screen event', screenData);
-                                sendEvent(res, screenData);
-                            });
-                            screenStream.on('end', () => {
-                                resolve();
-                            });
-                        } catch (e: any) {
-                            reject(e);
-                        }
-                    });
+                            })
+                    );
                 });
             } catch (e) {
                 console.error('Failed to process event', e);
@@ -130,13 +144,12 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
         });
 
         await waitForStormStream(userJourneysStream);
+        await queue.wait();
 
         if (userJourneysStream.isAborted()) {
             return;
         }
 
-        await Promise.all(Object.values(promises));
-
         sendDone(res);
     } catch (err: any) {
         sendError(err, res);