@kapeta/local-cluster-service 0.15.1 → 0.15.3

package/src/progressListener.ts

@@ -1,19 +1,38 @@
 import { spawn } from '@kapeta/nodejs-process';
-import { SocketManager, socketManager } from './socketManager';
-class ProgressListener {
-    private socketManager: SocketManager;
+import { socketManager } from './socketManager';
+import { LogEntry } from './types';
+import { format } from 'node:util';
 
-    constructor(socketManager: SocketManager) {
-        this.socketManager = socketManager;
+export class ProgressListener {
+    private readonly systemId: string | undefined;
+    private readonly instanceId: string | undefined;
+
+    constructor(systemId?: string, instanceId?: string) {
+        this.systemId = systemId;
+        this.instanceId = instanceId;
     }
 
-    run(command: string, directory?: string): Promise<{ exit: number; signal: NodeJS.Signals | null; output: string }> {
-        this.socketManager.emit(`install`, 'install:log', {
-            type: 'info',
-            message: `Running command "${command}"`,
-        });
+    private emitLog(payload: Omit<LogEntry, 'time' | 'source'>) {
+        const logEntry: 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);
+    }
 
-        const firstCommand = command.split(' ')[0];
+    run(command: string, directory?: string): Promise<{ exit: number; signal: NodeJS.Signals | null; output: string }> {
+        this.info(`Running command "${command}"`);
 
         return new Promise(async (resolve, reject) => {
             try {
@@ -25,7 +44,10 @@ class ProgressListener {
                 });
 
                 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) {
@@ -36,25 +58,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);
                 });
 
@@ -66,48 +79,55 @@ class ProgressListener {
     }
 
     async progress(label: string, callback: () => void | Promise<void>) {
-        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: any) {
-            this.socketManager.emit(`install`, 'install:log', {
-                type: 'info',
-                message: `${label}: failed. ${e.message}`,
-            });
+            this.warn(`${label}: failed. ${e.message}`);
             throw e;
         }
     }
 
     async check(message: string, ok: boolean | Promise<boolean> | (() => Promise<boolean>)) {
         const wasOk = await ok;
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${message}: ${wasOk}` });
+        this.info(`${message}: ${wasOk}`);
     }
 
     start(label: string) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: label });
+        this.info(label);
     }
 
     showValue(label: string, value: any) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: ${value}` });
+        this.info(`${label}: ${value}`);
     }
 
     error(msg: string, ...args: any[]) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'error', message: msg });
+        this.emitLog({
+            message: format(msg, args),
+            level: 'ERROR',
+        });
     }
 
     warn(msg: string, ...args: any[]) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'warn', message: msg });
+        this.emitLog({
+            message: format(msg, args),
+            level: 'WARN',
+        });
     }
 
     info(msg: string, ...args: any[]) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: msg });
+        this.emitLog({
+            message: format(msg, args),
+            level: 'INFO',
+        });
     }
 
     debug(msg: string, ...args: any[]) {
-        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/src/repositoryManager.ts

@@ -6,13 +6,16 @@ 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 { Dependency } from '@kapeta/schemas';
 import { Actions, Config, RegistryService } from '@kapeta/nodejs-registry-utils';
 import { definitionsManager } from './definitionsManager';
 import { Task, taskManager } from './taskManager';
 import { normalizeKapetaUri } from './utils/utils';
 import { assetManager } from './assetManager';
+import { ProgressListener } from './progressListener';
+
+const EVENT_DEFAULT_PROVIDERS_START = 'default-providers-start';
+const EVENT_DEFAULT_PROVIDERS_END = 'default-providers-end';
 
 const DEFAULT_PROVIDERS = [
     'kapeta/block-type-service',
@@ -130,7 +133,11 @@ class RepositoryManager {
     }
 
     public ensureDefaultProviders(): void {
-        this._install(DEFAULT_PROVIDERS);
+        socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
+        const tasks = this._install(DEFAULT_PROVIDERS);
+        Promise.allSettled(tasks.map((t) => t.wait())).then(() => {
+            socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_END, {});
+        });
     }
 
     private _install(refs: string[]): Task[] {
@@ -152,7 +159,7 @@ class RepositoryManager {
                     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;

package/src/socketManager.ts

@@ -1,9 +1,18 @@
 import _ from 'lodash';
 import { Socket, Server } from 'socket.io';
+import { normalizeKapetaUri } from './utils/utils';
+import { LogEntry } from './types';
+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 {
     private _io: Server | null;
-    private _sockets: Socket[];
+    private readonly _sockets: Socket[];
 
     constructor() {
         this._io = null;
@@ -35,16 +44,46 @@ export class SocketManager {
         this.io.emit(type, payload);
     }
 
-    _bindIO() {
+    emitSystemEvent(systemId: string, type: string, payload: any) {
+        systemId = normalizeKapetaUri(systemId);
+        try {
+            socketManager.emit(`${systemId}/instances`, type, payload);
+        } catch (e: any) {
+            console.warn('Failed to emit instance event: %s', e.message);
+        }
+    }
+
+    emitInstanceLog(systemId: string, instanceId: string, payload: LogEntry) {
+        this.emitInstanceEvent(systemId, instanceId, EVENT_INSTANCE_LOG, payload);
+    }
+
+    emitSystemLog(systemId: string, payload: LogEntry) {
+        this.emitSystemEvent(systemId, EVENT_SYSTEM_LOG, payload);
+    }
+
+    emitGlobalLog(payload: LogEntry) {
+        this.emitGlobal(EVENT_LOG, payload);
+    }
+
+    emitInstanceEvent(systemId: string, instanceId: string, type: string, payload: any) {
+        systemId = normalizeKapetaUri(systemId);
+        try {
+            socketManager.emit(`${systemId}/instances/${instanceId}`, type, payload);
+        } catch (e: any) {
+            console.warn('Failed to emit instance event: %s', e.message);
+        }
+    }
+
+    private _bindIO() {
         this.io.on('connection', (socket) => this._handleSocketCreated(socket));
     }
 
-    _handleSocketCreated(socket: Socket) {
+    private _handleSocketCreated(socket: Socket) {
         this._bindSocket(socket);
         this._sockets.push(socket);
     }
 
-    _bindSocket(socket: Socket) {
+    private _bindSocket(socket: Socket) {
         socket.on('disconnect', () => this._handleSocketDestroyed(socket));
         socket.on('join', (id) => {
             socket.join(id);
@@ -54,7 +93,7 @@ export class SocketManager {
         });
     }
 
-    _handleSocketDestroyed(socket: Socket) {
+    private _handleSocketDestroyed(socket: Socket) {
         _.pull(this._sockets, socket);
     }
 }