@kapeta/local-cluster-service 0.15.2 → 0.16.0

package/dist/esm/src/progressListener.js

@@ -1,16 +1,31 @@
 import { spawn } from '@kapeta/nodejs-process';
 import { socketManager } from './socketManager';
-class ProgressListener {
-    socketManager;
-    constructor(socketManager) {
-        this.socketManager = socketManager;
+import { format } from 'node:util';
+export class ProgressListener {
+    systemId;
+    instanceId;
+    constructor(systemId, instanceId) {
+        this.systemId = systemId;
+        this.instanceId = instanceId;
+    }
+    emitLog(payload) {
+        const logEntry = {
+            ...payload,
+            source: 'stdout',
+            time: Date.now(),
+        };
+        if (this.systemId && this.instanceId) {
+            socketManager.emitInstanceLog(this.systemId, this.instanceId, logEntry);
+            return;
+        }
+        if (this.systemId) {
+            socketManager.emitSystemLog(this.systemId, logEntry);
+            return;
+        }
+        socketManager.emitGlobalLog(logEntry);
     }
     run(command, directory) {
-        this.socketManager.emit(`install`, 'install:log', {
-            type: 'info',
-            message: `Running command "${command}"`,
-        });
-        const firstCommand = command.split(' ')[0];
+        this.info(`Running command "${command}"`);
         return new Promise(async (resolve, reject) => {
             try {
                 const chunks = [];
@@ -20,7 +35,10 @@ class ProgressListener {
                     shell: true,
                 });
                 child.onData((data) => {
-                    this.socketManager.emit(`install`, 'install:log', { type: 'info', message: data.line });
+                    this.emitLog({
+                        level: data.type === 'stdout' ? 'INFO' : 'WARN',
+                        message: data.line,
+                    });
                 });
                 if (child.process.stdout) {
                     child.process.stdout.on('data', (data) => {
@@ -29,25 +47,16 @@ class ProgressListener {
                 }
                 child.process.on('exit', (exit, signal) => {
                     if (exit !== 0) {
-                        this.socketManager.emit(`install`, 'install:log', {
-                            type: 'info',
-                            message: `"${command}" failed: "${exit}"`,
-                        });
+                        this.warn(`Command "${command}" failed: ${exit}`);
                         reject(new Error(`Command "${command}" exited with code ${exit}`));
                     }
                     else {
-                        this.socketManager.emit(`install`, 'install:log', {
-                            type: 'info',
-                            message: `Command OK: "${command}"`,
-                        });
+                        this.info(`Command OK: "${command}"`);
                         resolve({ exit, signal, output: Buffer.concat(chunks).toString() });
                     }
                 });
                 child.process.on('error', (err) => {
-                    this.socketManager.emit(`install`, 'install:log', {
-                        type: 'info',
-                        message: `"${command}" failed: "${err.message}"`,
-                    });
+                    this.warn(`"${command}" failed: "${err.message}"`);
                     reject(err);
                 });
                 await child.wait();
@@ -58,41 +67,49 @@ class ProgressListener {
         });
     }
     async progress(label, callback) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: started` });
+        this.info(`${label}: started`);
         try {
             const result = await callback();
-            this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: done` });
+            this.info(`${label}: done`);
             return result;
         }
         catch (e) {
-            this.socketManager.emit(`install`, 'install:log', {
-                type: 'info',
-                message: `${label}: failed. ${e.message}`,
-            });
+            this.warn(`${label}: failed. ${e.message}`);
             throw e;
         }
     }
     async check(message, ok) {
         const wasOk = await ok;
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${message}: ${wasOk}` });
+        this.info(`${message}: ${wasOk}`);
     }
     start(label) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: label });
+        this.info(label);
     }
     showValue(label, value) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: ${value}` });
+        this.info(`${label}: ${value}`);
     }
     error(msg, ...args) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'error', message: msg });
+        this.emitLog({
+            message: format(msg, args),
+            level: 'ERROR',
+        });
     }
     warn(msg, ...args) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'warn', message: msg });
+        this.emitLog({
+            message: format(msg, args),
+            level: 'WARN',
+        });
     }
     info(msg, ...args) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: msg });
+        this.emitLog({
+            message: format(msg, args),
+            level: 'INFO',
+        });
     }
     debug(msg, ...args) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'debug', message: msg });
+        this.emitLog({
+            message: format(msg, args),
+            level: 'DEBUG',
+        });
     }
 }
-export const progressListener = new ProgressListener(socketManager);

package/dist/esm/src/repositoryManager.d.ts

@@ -1,13 +1,13 @@
 import { Task } from './taskManager';
 declare class RepositoryManager {
-    private changeEventsEnabled;
     private _registryService;
     private _cache;
-    private watcher?;
+    private watcher;
     constructor();
-    setChangeEventsEnabled(enabled: boolean): void;
     listenForChanges(): void;
-    stopListening(): void;
+    stopListening(): Promise<void>;
+    ignoreChangesFor(file: string): Promise<void>;
+    resumeChangedFor(file: string): Promise<void>;
     ensureDefaultProviders(): void;
     private _install;
     ensureAsset(handle: string, name: string, version: string, wait?: boolean): Promise<undefined | Task[]>;

package/dist/esm/src/repositoryManager.js

@@ -1,17 +1,16 @@
-import FS from 'node:fs';
 import os from 'node:os';
-import Path from 'node:path';
-import watch from 'recursive-watch';
-import FSExtra from 'fs-extra';
-import ClusterConfiguration from '@kapeta/local-cluster-config';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { socketManager } from './socketManager';
-import { progressListener } from './progressListener';
 import { Actions, Config, RegistryService } from '@kapeta/nodejs-registry-utils';
 import { definitionsManager } from './definitionsManager';
 import { taskManager } from './taskManager';
 import { normalizeKapetaUri } from './utils/utils';
+import { ProgressListener } from './progressListener';
+import { RepositoryWatcher } from './RepositoryWatcher';
 import { assetManager } from './assetManager';
+function clearAllCaches() {
+    definitionsManager.clearCache();
+    assetManager.clearCache();
+}
 const EVENT_DEFAULT_PROVIDERS_START = 'default-providers-start';
 const EVENT_DEFAULT_PROVIDERS_END = 'default-providers-end';
 const DEFAULT_PROVIDERS = [
@@ -30,97 +29,31 @@ const DEFAULT_PROVIDERS = [
 ];
 const INSTALL_ATTEMPTED = {};
 class RepositoryManager {
-    changeEventsEnabled;
     _registryService;
     _cache;
     watcher;
     constructor() {
-        this.changeEventsEnabled = true;
-        this.listenForChanges();
         this._registryService = new RegistryService(Config.data.registry.url);
         this._cache = {};
-    }
-    setChangeEventsEnabled(enabled) {
-        this.changeEventsEnabled = enabled;
+        this.watcher = new RepositoryWatcher();
+        this.listenForChanges();
     }
     listenForChanges() {
-        const baseDir = ClusterConfiguration.getRepositoryBasedir();
-        if (!FS.existsSync(baseDir)) {
-            FSExtra.mkdirpSync(baseDir);
-        }
-        let allDefinitions = ClusterConfiguration.getDefinitions();
-        console.log('Watching local repository for provider changes: %s', baseDir);
-        try {
-            this.watcher = watch(baseDir, (filename) => {
-                if (!filename) {
-                    return;
-                }
-                const [handle, name, version] = filename.toString().split(/\//g);
-                if (!name || !version) {
-                    return;
-                }
-                if (!this.changeEventsEnabled) {
-                    return;
-                }
-                const ymlPath = Path.join(baseDir, handle, name, version, 'kapeta.yml');
-                const newDefinitions = ClusterConfiguration.getDefinitions();
-                const newDefinition = newDefinitions.find((d) => d.ymlPath === ymlPath);
-                let currentDefinition = allDefinitions.find((d) => d.ymlPath === ymlPath);
-                const ymlExists = FS.existsSync(ymlPath);
-                let type;
-                if (ymlExists) {
-                    if (currentDefinition) {
-                        type = 'updated';
-                    }
-                    else if (newDefinition) {
-                        type = 'added';
-                        currentDefinition = newDefinition;
-                    }
-                    else {
-                        //Other definition was added / updated - ignore
-                        return;
-                    }
-                }
-                else {
-                    if (currentDefinition) {
-                        const ref = parseKapetaUri(`${currentDefinition.definition.metadata.name}:${currentDefinition.version}`).id;
-                        delete INSTALL_ATTEMPTED[ref];
-                        //Something was removed
-                        type = 'removed';
-                    }
-                    else {
-                        //Other definition was removed - ignore
-                        return;
-                    }
-                }
-                const payload = {
-                    type,
-                    definition: currentDefinition?.definition,
-                    asset: { handle, name, version },
-                };
-                allDefinitions = newDefinitions;
-                socketManager.emit(`assets`, 'changed', payload);
-                definitionsManager.clearCache();
-            });
-        }
-        catch (e) {
-            // Fallback to run without watch mode due to potential platform issues.
-            // https://nodejs.org/docs/latest/api/fs.html#caveats
-            console.log('Unable to watch for changes. Changes to assets will not update automatically.', e);
-            return;
-        }
+        this.watcher.watch();
     }
-    stopListening() {
-        if (!this.watcher) {
-            return;
-        }
-        this.watcher();
-        this.watcher = undefined;
+    async stopListening() {
+        return this.watcher.unwatch();
+    }
+    ignoreChangesFor(file) {
+        return this.watcher.ignoreChangesFor(file);
+    }
+    resumeChangedFor(file) {
+        return this.watcher.resumeChangedFor(file);
     }
     ensureDefaultProviders() {
         socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
         const tasks = this._install(DEFAULT_PROVIDERS);
-        Promise.allSettled(tasks.map(t => t.wait())).then(() => {
+        Promise.allSettled(tasks.map((t) => t.wait())).then(() => {
             socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_END, {});
         });
     }
@@ -140,19 +73,13 @@ class RepositoryManager {
                 try {
                     //We change to a temp dir to avoid issues with the current working directory
                     process.chdir(os.tmpdir());
-                    //Disable change events while installing
-                    this.setChangeEventsEnabled(false);
-                    await Actions.install(progressListener, [ref], {});
+                    await Actions.install(new ProgressListener(), [ref], {});
                 }
                 catch (e) {
                     console.error(`Failed to install asset: ${ref}`, e);
                     throw e;
                 }
-                finally {
-                    this.setChangeEventsEnabled(true);
-                }
-                definitionsManager.clearCache();
-                assetManager.clearCache();
+                clearAllCaches();
                 //console.log(`Asset installed: ${ref}`);
             };
         };

package/dist/esm/src/socketManager.d.ts

@@ -1,16 +1,28 @@
-import { Socket, Server } from 'socket.io';
+import { Server } from 'socket.io';
+import { LogEntry } from './types';
+export declare const EVENT_STATUS_CHANGED = "status-changed";
+export declare const EVENT_INSTANCE_CREATED = "instance-created";
+export declare const EVENT_INSTANCE_EXITED = "instance-exited";
+export declare const EVENT_INSTANCE_LOG = "instance-log";
+export declare const EVENT_SYSTEM_LOG = "system-log";
+export declare const EVENT_LOG = "log";
 export declare class SocketManager {
     private _io;
-    private _sockets;
+    private readonly _sockets;
     constructor();
     setIo(io: Server): void;
     isAlive(): boolean;
     private get io();
     emit(context: string, type: string, payload: any): void;
     emitGlobal(type: string, payload: any): void;
-    _bindIO(): void;
-    _handleSocketCreated(socket: Socket): void;
-    _bindSocket(socket: Socket): void;
-    _handleSocketDestroyed(socket: Socket): void;
+    emitSystemEvent(systemId: string, type: string, payload: any): void;
+    emitInstanceLog(systemId: string, instanceId: string, payload: LogEntry): void;
+    emitSystemLog(systemId: string, payload: LogEntry): void;
+    emitGlobalLog(payload: LogEntry): void;
+    emitInstanceEvent(systemId: string, instanceId: string, type: string, payload: any): void;
+    private _bindIO;
+    private _handleSocketCreated;
+    private _bindSocket;
+    private _handleSocketDestroyed;
 }
 export declare const socketManager: SocketManager;

package/dist/esm/src/socketManager.js

@@ -1,4 +1,11 @@
 import _ from 'lodash';
+import { normalizeKapetaUri } from './utils/utils';
+export const EVENT_STATUS_CHANGED = 'status-changed';
+export const EVENT_INSTANCE_CREATED = 'instance-created';
+export const EVENT_INSTANCE_EXITED = 'instance-exited';
+export const EVENT_INSTANCE_LOG = 'instance-log';
+export const EVENT_SYSTEM_LOG = 'system-log';
+export const EVENT_LOG = 'log';
 export class SocketManager {
     _io;
     _sockets;
@@ -26,6 +33,33 @@ export class SocketManager {
     emitGlobal(type, payload) {
         this.io.emit(type, payload);
     }
+    emitSystemEvent(systemId, type, payload) {
+        systemId = normalizeKapetaUri(systemId);
+        try {
+            socketManager.emit(`${systemId}/instances`, type, payload);
+        }
+        catch (e) {
+            console.warn('Failed to emit instance event: %s', e.message);
+        }
+    }
+    emitInstanceLog(systemId, instanceId, payload) {
+        this.emitInstanceEvent(systemId, instanceId, EVENT_INSTANCE_LOG, payload);
+    }
+    emitSystemLog(systemId, payload) {
+        this.emitSystemEvent(systemId, EVENT_SYSTEM_LOG, payload);
+    }
+    emitGlobalLog(payload) {
+        this.emitGlobal(EVENT_LOG, payload);
+    }
+    emitInstanceEvent(systemId, instanceId, type, payload) {
+        systemId = normalizeKapetaUri(systemId);
+        try {
+            socketManager.emit(`${systemId}/instances/${instanceId}`, type, payload);
+        }
+        catch (e) {
+            console.warn('Failed to emit instance event: %s', e.message);
+        }
+    }
     _bindIO() {
         this.io.on('connection', (socket) => this._handleSocketCreated(socket));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.15.2",
+    "version": "0.16.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -53,6 +53,7 @@
         "@kapeta/sdk-config": "<2",
         "@kapeta/web-microfrontend": "^0.2.1",
         "async-lock": "^1.4.0",
+        "chokidar": "^3.5.3",
         "express": "4.17.1",
         "express-promise-router": "^4.1.1",
         "fs-extra": "^11.1.0",
@@ -62,7 +63,6 @@
         "node-cache": "^5.1.2",
         "node-docker-api": "1.1.22",
         "node-uuid": "^1.4.8",
-        "recursive-watch": "^1.1.4",
         "request": "2.88.2",
         "request-promise": "4.2.6",
         "socket.io": "^4.5.2",