@kapeta/local-cluster-service 0.17.0 → 0.19.0

package/src/instanceManager.ts

@@ -54,14 +54,14 @@ export class InstanceManager {
         return [...this._instances];
     }
 
-    public getInstancesForPlan(systemId: string) {
+    public async getInstancesForPlan(systemId: string) {
         if (!this._instances) {
             return [];
         }
 
         systemId = normalizeKapetaUri(systemId);
 
-        const planInfo = definitionsManager.getDefinition(systemId);
+        const planInfo = await definitionsManager.getDefinition(systemId);
 
         if (!planInfo) {
             return [];
@@ -458,9 +458,9 @@ export class InstanceManager {
 
             const blockSpec = blockAsset.data.spec as BlockDefinitionSpec;
             if (blockSpec.consumers) {
-                const promises = blockSpec.consumers.map((consumer) => {
+                const promises = blockSpec.consumers.map(async (consumer) => {
                     const consumerUri = parseKapetaUri(consumer.kind);
-                    const asset = definitionsManager.getDefinition(consumer.kind);
+                    const asset = await definitionsManager.getDefinition(consumer.kind);
                     if (!asset) {
                         // Definition not found
                         return Promise.resolve();
@@ -529,12 +529,6 @@ export class InstanceManager {
 
                         socketManager.emitInstanceLog(systemId, instanceId, logs[0]);
 
-                        socketManager.emitInstanceEvent(systemId, blockInstance.id, EVENT_INSTANCE_EXITED, {
-                            error: `Failed to start instance: ${e.message}`,
-                            status: EVENT_INSTANCE_EXITED,
-                            instanceId: blockInstance.id,
-                        });
-
                         return out;
                     }
                 },
@@ -606,6 +600,7 @@ export class InstanceManager {
                     try {
                         const plan = await assetManager.getAsset(instance.systemId, true, false);
                         if (!plan) {
+                            console.log('Plan not found - reset to stop', instance.ref, instance.systemId);
                             instance.desiredStatus = DesiredInstanceStatus.STOP;
                             changed = true;
                             return;
@@ -614,6 +609,7 @@ export class InstanceManager {
                         const planData = plan.data as Plan;
                         const planInstance = planData?.spec?.blocks?.find((b) => b.id === instance.instanceId);
                         if (!planInstance || !planInstance?.block?.ref) {
+                            console.log('Plan instance not found - reset to stop', instance.ref, instance.systemId);
                             instance.desiredStatus = DesiredInstanceStatus.STOP;
                             changed = true;
                             return;
@@ -621,6 +617,7 @@ export class InstanceManager {
 
                         const blockDef = await assetManager.getAsset(instance.ref, true, false);
                         if (!blockDef) {
+                            console.log('Block definition not found - reset to stop', instance.ref, instance.systemId);
                             instance.desiredStatus = DesiredInstanceStatus.STOP;
                             changed = true;
                             return;
@@ -836,7 +833,3 @@ export class InstanceManager {
 }
 
 export const instanceManager = new InstanceManager();
-
-process.on('exit', async () => {
-    await instanceManager.stopAll();
-});

package/src/instances/routes.ts

@@ -21,8 +21,8 @@ router.get('/', (req: Request, res: Response) => {
 /**
  * Get all instances
  */
-router.get('/:systemId/instances', (req: Request, res: Response) => {
-    res.send(instanceManager.getInstancesForPlan(req.params.systemId));
+router.get('/:systemId/instances', async (req: Request, res: Response) => {
+    res.send(await instanceManager.getInstancesForPlan(req.params.systemId));
 });
 
 /**

package/src/operatorManager.ts

@@ -15,6 +15,7 @@ import AsyncLock from 'async-lock';
 import { taskManager } from './taskManager';
 
 export const KIND_OPERATOR = 'core/resource-type-operator';
+const KIND_PLAN = 'core/plan';
 
 class Operator {
     private readonly _data: DefinitionInfo;
@@ -57,8 +58,8 @@ class OperatorManager {
      * @param {string} version
      * @return {Operator}
      */
-    getOperator(resourceType: string, version: string) {
-        const operators = definitionsManager.getDefinitions(KIND_OPERATOR);
+    async getOperator(resourceType: string, version: string) {
+        const operators = await definitionsManager.getDefinitions(KIND_OPERATOR);
 
         const operator: DefinitionInfo | undefined = operators.find(
             (operator) =>
@@ -92,7 +93,7 @@ class OperatorManager {
         environment?: EnvironmentType
     ): Promise<OperatorInfo> {
         systemId = normalizeKapetaUri(systemId);
-        const plans = definitionsManager.getDefinitions('core/plan');
+        const plans = await definitionsManager.getDefinitions(KIND_PLAN);
 
         const planUri = parseKapetaUri(systemId);
         const currentPlan = plans.find(
@@ -109,13 +110,7 @@ class OperatorManager {
             throw new Error(`Unknown instance: ${fromServiceId} in plan ${systemId}`);
         }
 
-        const blockUri = parseKapetaUri(currentInstance.block.ref);
-        const blockDefinition = definitionsManager
-            .getDefinitions()
-            .find(
-                (definition) =>
-                    definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName
-            );
+        const blockDefinition = await definitionsManager.getDefinition(currentInstance.block.ref);
 
         if (!blockDefinition) {
             throw new Error(`Unknown block: ${currentInstance.block.ref} in plan ${systemId}`);
@@ -129,7 +124,7 @@ class OperatorManager {
         }
 
         const kindUri = parseKapetaUri(blockResource.kind);
-        const operator = this.getOperator(resourceType, kindUri.version);
+        const operator = await this.getOperator(resourceType, kindUri.version);
         const credentials = operator.getCredentials();
         const container = await this.ensureResource(systemId, resourceType, kindUri.version);
         const portInfo = await container.getPort(portType);
@@ -164,7 +159,7 @@ class OperatorManager {
         systemId = normalizeKapetaUri(systemId);
         const key = `${systemId}#${resourceType}:${version}`;
         return await this.operatorLock.acquire(key, async () => {
-            const operator = this.getOperator(resourceType, version);
+            const operator = await this.getOperator(resourceType, version);
 
             const operatorData = operator.getLocalData();
 

package/src/providerManager.ts

@@ -3,12 +3,14 @@ import FSExtra from 'fs-extra';
 import { definitionsManager } from './definitionsManager';
 import { cacheManager } from './cacheManager';
 import request from 'request';
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
 
 const PROVIDER_FILE_BASE = 'https://providers.kapeta.com/files';
 
 class ProviderManager {
-    getWebProviders() {
-        return definitionsManager.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
+    async getWebProviders(): Promise<DefinitionInfo[]> {
+        const providers = await definitionsManager.getProviderDefinitions();
+        return providers.filter((providerDefinition) => providerDefinition.hasWeb);
     }
 
     async getProviderWebJS(handle: string, name: string, version: string, sourceMap: boolean = false) {
@@ -22,7 +24,8 @@ class ProviderManager {
             return FSExtra.readFile(file, 'utf8');
         }
 
-        const installedProvider = this.getWebProviders().find((providerDefinition) => {
+        const providers = await this.getWebProviders();
+        const installedProvider = providers.find((providerDefinition) => {
             return providerDefinition.definition.metadata.name === fullName && providerDefinition.version === version;
         });
 
@@ -63,22 +66,27 @@ class ProviderManager {
     }
 }
 
-const providerDefinitions = definitionsManager.getProviderDefinitions();
-
-if (providerDefinitions.length > 0) {
-    console.log('## Loaded the following providers ##');
-    providerDefinitions.forEach((providerDefinition) => {
-        console.log(
-            ' - %s[%s:%s]',
-            providerDefinition.definition.kind,
-            providerDefinition.definition.metadata.name,
-            providerDefinition.version
-        );
-        console.log('   from %s', providerDefinition.path);
+definitionsManager
+    .getProviderDefinitions()
+    .then((providerDefinitions) => {
+        if (providerDefinitions.length > 0) {
+            console.log('## Loaded the following providers ##');
+            providerDefinitions.forEach((providerDefinition) => {
+                console.log(
+                    ' - %s[%s:%s]',
+                    providerDefinition.definition.kind,
+                    providerDefinition.definition.metadata.name,
+                    providerDefinition.version
+                );
+                console.log('   from %s', providerDefinition.path);
+            });
+            console.log('##');
+        } else {
+            console.log('## No providers found ##');
+        }
+    })
+    .catch((e) => {
+        console.error('Failed to load providers', e);
     });
-    console.log('##');
-} else {
-    console.log('## No providers found ##');
-}
 
 export const providerManager = new ProviderManager();

package/src/repositoryManager.ts

@@ -58,19 +58,19 @@ class RepositoryManager {
         return this.watcher.clearSourceOfChangeFor(file);
     }
 
-    public ensureDefaultProviders(): void {
+    public async ensureDefaultProviders(): Promise<void> {
         socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
-        const tasks = this._install(DEFAULT_PROVIDERS);
+        const tasks = await this.scheduleInstallation(DEFAULT_PROVIDERS);
         Promise.allSettled(tasks.map((t) => t.wait())).then(() => {
             socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_END, {});
         });
     }
 
-    private _install(refs: string[]): Task[] {
+    private async scheduleInstallation(refs: string[]): Promise<Task[]> {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
         const createInstaller = (ref: string) => {
             return async () => {
-                if (definitionsManager.exists(ref)) {
+                if (await definitionsManager.exists(ref)) {
                     return;
                 }
                 //console.log(`Installing asset: ${ref}`);
@@ -97,7 +97,7 @@ class RepositoryManager {
             }
             ref = normalizeKapetaUri(ref);
 
-            if (definitionsManager.exists(ref)) {
+            if (await definitionsManager.exists(ref)) {
                 continue;
             }
 
@@ -126,10 +126,7 @@ class RepositoryManager {
             return;
         }
 
-        const definitions = definitionsManager.getDefinitions();
-        const installedAsset = definitions.find(
-            (d) => d.definition.metadata.name === fullName && d.version === version
-        );
+        const installedAsset = await definitionsManager.getDefinition(`${fullName}:${version}`);
 
         let assetVersion;
         try {
@@ -147,12 +144,12 @@ class RepositoryManager {
 
         let tasks: Task[] | undefined = undefined;
         if (!installedAsset) {
-            tasks = this._install([ref]);
+            tasks = await this.scheduleInstallation([ref]);
         } else {
             //Ensure dependencies are installed
             const refs = assetVersion.dependencies.map((dep: Dependency) => dep.name);
             if (refs.length > 0) {
-                tasks = this._install(refs);
+                tasks = await this.scheduleInstallation(refs);
             }
         }
 

package/src/socketManager.ts

@@ -2,6 +2,7 @@ import _ from 'lodash';
 import { Socket, Server } from 'socket.io';
 import { normalizeKapetaUri } from './utils/utils';
 import { LogEntry } from './types';
+import { containerManager } from './containerManager';
 export const EVENT_STATUS_CHANGED = 'status-changed';
 export const EVENT_INSTANCE_CREATED = 'instance-created';
 export const EVENT_INSTANCE_EXITED = 'instance-exited';
@@ -53,14 +54,24 @@ export class SocketManager {
     emitSystemEvent(systemId: string, type: string, payload: any) {
         systemId = normalizeKapetaUri(systemId);
         try {
-            socketManager.emit(`${systemId}/instances`, type, payload);
+            const contextId = `system-events/${encodeURIComponent(systemId)}`;
+            this.emit(contextId, 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);
+        systemId = normalizeKapetaUri(systemId);
+        try {
+            this.emit(
+                `instance-logs/${encodeURIComponent(systemId)}/${encodeURIComponent(instanceId)}`,
+                EVENT_INSTANCE_LOG,
+                payload
+            );
+        } catch (e: any) {
+            console.warn('Failed to emit instance event: %s', e.message);
+        }
     }
 
     emitSystemLog(systemId: string, payload: LogEntry) {
@@ -71,15 +82,6 @@ export class SocketManager {
         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));
     }
@@ -90,17 +92,42 @@ export class SocketManager {
     }
 
     private _bindSocket(socket: Socket) {
-        socket.on('disconnect', () => this._handleSocketDestroyed(socket));
+        socket.on('disconnect', () => {
+            _.pull(this._sockets, socket);
+            socket.rooms.forEach((roomId) => {
+                this.handleLeaveRoom(roomId);
+            });
+        });
         socket.on('join', (id) => {
             socket.join(id);
+            this.handleJoinRoom(id);
         });
         socket.on('leave', (id) => {
             socket.leave(id);
+            this.handleLeaveRoom(id);
         });
     }
-
-    private _handleSocketDestroyed(socket: Socket) {
-        _.pull(this._sockets, socket);
+    private handleJoinRoom(id: string) {
+        if (id.startsWith('instance-logs/')) {
+            let [, systemId, instanceId] = id.split(/\//g);
+            systemId = decodeURIComponent(systemId);
+            instanceId = decodeURIComponent(instanceId);
+            console.log('Start listening for logs', systemId, instanceId);
+            containerManager
+                .ensureLogListening(systemId, instanceId, (log) => {
+                    this.emitInstanceLog(systemId, instanceId, log);
+                })
+                .catch((e) => {});
+        }
+    }
+    private handleLeaveRoom(id: string) {
+        if (id.startsWith('instance-logs/')) {
+            let [, systemId, instanceId] = id.split(/\//g);
+            systemId = decodeURIComponent(systemId);
+            instanceId = decodeURIComponent(instanceId);
+            console.log('Stop listening for logs', systemId, instanceId);
+            containerManager.stopLogListening(systemId, instanceId).catch((e) => {});
+        }
     }
 }
 export const socketManager = new SocketManager();

package/src/utils/BlockInstanceRunner.ts

@@ -25,8 +25,9 @@ const DOCKER_ENV_VARS = [
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ];
 
-function getProvider(uri: KapetaURI) {
-    return definitionsManager.getProviderDefinitions().find((provider) => {
+async function getProvider(uri: KapetaURI) {
+    const providers = await definitionsManager.getProviderDefinitions();
+    return providers.find((provider) => {
         const ref = `${provider.definition.metadata.name}:${provider.version}`;
         return parseKapetaUri(ref).id === uri.id;
     });
@@ -87,10 +88,7 @@ export class BlockInstanceRunner {
             blockUri.version = 'local';
         }
 
-        const assetVersion = definitionsManager.getDefinitions().find((definitions) => {
-            const ref = `${definitions.definition.metadata.name}:${definitions.version}`;
-            return parseKapetaUri(ref).id === blockUri.id;
-        });
+        const assetVersion = await definitionsManager.getDefinition(blockUri.id);
 
         if (!assetVersion) {
             throw new Error(`Block definition not found: ${blockUri.id}`);
@@ -98,7 +96,7 @@ export class BlockInstanceRunner {
 
         const kindUri = parseKapetaUri(assetVersion.definition.kind);
 
-        const providerVersion = getProvider(kindUri);
+        const providerVersion = await getProvider(kindUri);
 
         if (!providerVersion) {
             throw new Error(`Kind not found: ${kindUri.id}`);
@@ -150,7 +148,7 @@ export class BlockInstanceRunner {
 
         const kindUri = parseKapetaUri(assetVersion.definition.spec?.target?.kind);
 
-        const targetVersion = getProvider(kindUri);
+        const targetVersion = await getProvider(kindUri);
 
         if (!targetVersion) {
             throw new Error(`Target not found: ${kindUri.id}`);