@kapeta/local-cluster-service 0.10.0 → 0.11.0

package/src/instanceManager.ts

@@ -67,6 +67,37 @@ export class InstanceManager {
         return this._instances.find((i) => i.systemId === systemId && i.instanceId === instanceId);
     }
 
+
+    public async getLogs(systemId: string, instanceId: string):Promise<LogEntry[]> {
+        const instance = this.getInstance(systemId, instanceId);
+        if (!instance) {
+            throw new Error(`Instance ${systemId}/${instanceId} not found`);
+        }
+
+        switch (instance.type) {
+            case InstanceType.DOCKER:
+                 return await containerManager.getLogs(instance);
+
+            case InstanceType.UNKNOWN:
+                return [{
+                    level: 'INFO',
+                    message: 'Instance is starting...',
+                    time: Date.now(),
+                    source: 'stdout',
+                }];
+
+            case InstanceType.LOCAL:
+                return [{
+                    level: 'INFO',
+                    message: 'Instance started outside Kapeta - logs not available...',
+                    time: Date.now(),
+                    source: 'stdout',
+                }];
+        }
+
+        return [];
+    }
+
     public async saveInternalInstance(instance: InstanceInfo) {
         instance.systemId = normalizeKapetaUri(instance.systemId);
         if (instance.ref) {
@@ -143,7 +174,6 @@ export class InstanceManager {
 
                 instance.desiredStatus = info.desiredStatus;
                 instance.owner = info.owner;
-                instance.internal = undefined;
                 instance.status = InstanceStatus.STARTING;
                 instance.startedAt = Date.now();
             }
@@ -260,7 +290,7 @@ export class InstanceManager {
 
         try {
             if (instance.type === 'docker') {
-                const containerName = getBlockInstanceContainerName(instance.instanceId);
+                const containerName = getBlockInstanceContainerName(instance.systemId, instance.instanceId);
                 const container = await containerManager.getContainerByName(containerName);
                 if (container) {
                     try {
@@ -350,7 +380,7 @@ export class InstanceManager {
             name: blockAsset.data.metadata.name,
             desiredStatus: DesiredInstanceStatus.RUN,
             owner: InstanceOwner.INTERNAL,
-            type: InstanceType.UNKNOWN,
+            type: existingInstance?.type ?? InstanceType.UNKNOWN,
             status: InstanceStatus.STARTING,
             startedAt: Date.now(),
         };
@@ -374,45 +404,6 @@ export class InstanceManager {
         const startTime = Date.now();
         try {
             const processInfo = await runner.start(blockRef, instanceId, instanceConfig);
-            //emit stdout/stderr via sockets
-            processInfo.output.on('data', (data: Buffer) => {
-                const payload = {
-                    source: 'stdout',
-                    level: 'INFO',
-                    message: data.toString(),
-                    time: Date.now(),
-                };
-                this.emitInstanceEvent(systemId, instanceId, EVENT_INSTANCE_LOG, payload);
-            });
-
-            processInfo.output.on('exit', (exitCode: number) => {
-                const timeRunning = Date.now() - startTime;
-                const instance = this.getInstance(systemId, instanceId);
-                if (instance?.status === InstanceStatus.READY) {
-                    //It's already been running
-                    return;
-                }
-
-                if (exitCode === 143 || exitCode === 137) {
-                    //Process got SIGTERM (143) or SIGKILL (137)
-                    //TODO: Windows?
-                    return;
-                }
-
-                if (exitCode !== 0 || timeRunning < MIN_TIME_RUNNING) {
-                    const instance = this.getInstance(systemId, instanceId);
-                    if (instance) {
-                        instance.status = InstanceStatus.FAILED;
-                        this.save();
-                    }
-
-                    this.emitSystemEvent(systemId, EVENT_INSTANCE_EXITED, {
-                        error: 'Failed to start instance',
-                        status: EVENT_INSTANCE_EXITED,
-                        instanceId: blockInstance.id,
-                    });
-                }
-            });
 
             instance.status = InstanceStatus.READY;
 
@@ -423,10 +414,6 @@ export class InstanceManager {
                 health: null,
                 portType: processInfo.portType,
                 status: InstanceStatus.READY,
-                internal: {
-                    logs: processInfo.logs,
-                    output: processInfo.output,
-                },
             });
         } catch (e: any) {
             console.warn('Failed to start instance', e);
@@ -482,9 +469,7 @@ export class InstanceManager {
             storageService.put(
                 'instances',
                 this._instances.map((instance) => {
-                    const copy = { ...instance };
-                    delete copy.internal;
-                    return copy;
+                    return { ...instance };
                 })
             );
         } catch (e) {
@@ -612,7 +597,7 @@ export class InstanceManager {
 
     private async getExternalStatus(instance: InstanceInfo): Promise<InstanceStatus> {
         if (instance.type === InstanceType.DOCKER) {
-            const containerName = getBlockInstanceContainerName(instance.instanceId);
+            const containerName = getBlockInstanceContainerName(instance.systemId, instance.instanceId);
             const container = await containerManager.getContainerByName(containerName);
             if (!container) {
                 // If the container doesn't exist, we consider the instance stopped

package/src/instances/routes.ts

@@ -74,16 +74,21 @@ router.post('/:systemId/:instanceId/stop', async (req: Request, res: Response) =
 /**
  * Get logs for instance in a plan
  */
-router.get('/:systemId/:instanceId/logs', (req: Request, res: Response) => {
+router.get('/:systemId/:instanceId/logs', async (req: Request, res: Response) => {
     const instanceInfo = instanceManager.getInstance(req.params.systemId, req.params.instanceId);
     if (!instanceInfo) {
         res.status(404).send({ ok: false });
         return;
     }
 
-    res.status(202).send({
-        logs: instanceInfo.internal?.logs() ?? [],
-    });
+    try {
+        const logs = await instanceManager.getLogs(req.params.systemId, req.params.instanceId);
+        res.status(200).send({
+            logs,
+        });
+    } catch (e:any) {
+        res.status(500).send({ ok: false, error: e.message });
+    }
 });
 
 /**

package/src/operatorManager.ts

@@ -162,16 +162,12 @@ class OperatorManager {
 
         portTypes.sort();
 
-        const containerBaseName = 'kapeta-resource';
-
-        const nameParts = [resourceType.toLowerCase()];
-
         const ports: AnyMap = {};
 
         for (let i = 0; i < portTypes.length; i++) {
             const portType = portTypes[i];
             let containerPortInfo = operatorData.ports[portType];
-            const hostPort = await serviceManager.ensureServicePort(resourceType, portType);
+            const hostPort = await serviceManager.ensureServicePort(systemId, resourceType, portType);
 
             if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
                 containerPortInfo = { port: containerPortInfo, type: 'tcp' };
@@ -182,7 +178,6 @@ class OperatorManager {
             }
 
             const portId = containerPortInfo.port + '/' + containerPortInfo.type;
-            nameParts.push(portType + '-' + portId + '-' + hostPort);
 
             ports[portId] = {
                 type: portType,
@@ -190,9 +185,15 @@ class OperatorManager {
             };
         }
 
-        const mounts = containerManager.createMounts(resourceType, operatorData.mounts);
+        const mounts = await containerManager.createMounts(systemId, resourceType, operatorData.mounts);
+
+        const nameParts = [
+            systemId,
+            resourceType.toLowerCase(),
+            version
+        ];
 
-        const containerName = containerBaseName + '-' + md5(nameParts.join('_'));
+        const containerName = `kapeta-resource-${md5(nameParts.join('_'))}`;
 
         const PortBindings: { [key: string]: any } = {};
         const Env: string[] = [];

package/src/repositoryManager.ts

@@ -2,7 +2,7 @@ import FS from 'node:fs';
 import os from 'node:os';
 import Path from 'node:path';
 import watch from 'recursive-watch';
-import FSExtra, { FSWatcher } from 'fs-extra';
+import FSExtra from 'fs-extra';
 import ClusterConfiguration from '@kapeta/local-cluster-config';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { socketManager } from './socketManager';
@@ -119,9 +119,11 @@ class RepositoryManager {
             this._installQueue.push(async () => {
                 try {
                     const normalizedRefs = refs.map((ref) => parseKapetaUri(ref).id);
-                    const filteredRefs = normalizedRefs.filter((ref) => !INSTALL_ATTEMPTED[ref]);
-                    console.log(filteredRefs);
+                    const filteredRefs = normalizedRefs
+                        .filter((ref) => !INSTALL_ATTEMPTED[ref])
+                        .filter((ref) => !definitionsManager.exists(ref));
                     if (filteredRefs.length > 0) {
+                        console.log(`Auto-installing dependencies: ${filteredRefs.join(', ')}`);
                         filteredRefs.forEach((ref) => (INSTALL_ATTEMPTED[ref] = true));
                         //Auto-install missing asset
                         try {
@@ -218,13 +220,11 @@ class RepositoryManager {
 
         this._cache[ref] = true;
         if (!installedAsset) {
-            console.log(`Auto-installing missing asset: ${ref}`);
             await this._install([ref]);
         } else {
             //Ensure dependencies are installed
             const refs = assetVersion.dependencies.map((dep: Dependency) => dep.name);
             if (refs.length > 0) {
-                console.log(`Auto-installing dependencies: ${refs.join(', ')}`);
                 await this._install(refs);
             }
         }

package/src/types.ts

@@ -53,10 +53,7 @@ export enum DesiredInstanceStatus {
 export type ProcessInfo = {
     type: InstanceType;
     pid?: number | string | null;
-    output: EventEmitter;
     portType?: string;
-    logs: () => LogEntry[];
-    stop: () => Promise<void> | void;
 };
 
 export type InstanceInfo = {
@@ -75,10 +72,6 @@ export type InstanceInfo = {
     pid?: number | string | null;
     portType?: string;
 
-    internal?: {
-        output: EventEmitter;
-        logs: () => LogEntry[];
-    };
 };
 
 interface ResourceRef {

package/src/utils/BlockInstanceRunner.ts

@@ -117,7 +117,7 @@ export class BlockInstanceRunner {
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             } else {
-                processInfo = await this._startDockerProcess(blockInstance, blockUri, env);
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, env, assetVersion);
             }
 
             if (portTypes.length > 0) {
@@ -169,37 +169,17 @@ export class BlockInstanceRunner {
             throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
         }
 
-        const containerName = getBlockInstanceContainerName(blockInstance.id);
-
+        const containerName = getBlockInstanceContainerName(this._systemId, blockInstance.id);
         const startCmd = localContainer.handlers?.onCreate ? localContainer.handlers.onCreate : '';
         const dockerOpts = localContainer.options ?? {};
         const homeDir = localContainer.userHome ? localContainer.userHome : '/root';
         const workingDir = localContainer.workingDir ? localContainer.workingDir : '/workspace';
 
-        const bindHost = getBindHost();
-
-        const ExposedPorts: AnyMap = {};
-        const addonEnv: StringMap = {};
-        const PortBindings: AnyMap = {};
-
-        const portTypes = getProviderPorts(assetVersion);
-        let port = 80;
-        const promises = portTypes.map(async (portType) => {
-            const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
-            const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
-            const dockerPort = `${thisPort}/tcp`;
-            ExposedPorts[dockerPort] = {};
-            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
-
-            PortBindings[dockerPort] = [
-                {
-                    HostIp: bindHost,
-                    HostPort: `${publicPort}`,
-                },
-            ];
-        });
-
-        await Promise.all(promises);
+        const {
+            PortBindings,
+            ExposedPorts,
+            addonEnv
+        } = await this.getDockerPortBindings(blockInstance, assetVersion);
 
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
@@ -235,83 +215,7 @@ export class BlockInstanceRunner {
         });
     }
 
-    private async ensureContainer(opts: any) {
-        const logs = new LogData();
-
-        const container = await containerManager.ensureContainer(opts);
-
-        try {
-            if (opts.HealthCheck) {
-                await containerManager.waitForHealthy(container);
-            } else {
-                await containerManager.waitForReady(container);
-            }
-        } catch (e: any) {
-            logs.addLog(e.message, 'ERROR');
-        }
-
-        return this._handleContainer(container, logs);
-    }
-
-    private async _handleContainer(
-        container: Container,
-        logs: LogData,
-        deleteOnExit: boolean = false
-    ): Promise<ProcessInfo> {
-        let localContainer: Container | null = container;
-        const logStream = (await container.logs({
-            follow: true,
-            stdout: true,
-            stderr: true,
-            tail: LogData.MAX_LINES,
-        })) as EventEmitter;
-
-        const outputEvents = new EventEmitter();
-        logStream.on('data', (data) => {
-            logs.addLog(data.toString());
-            outputEvents.emit('data', data);
-        });
-
-        logStream.on('error', (data) => {
-            logs.addLog(data.toString());
-            outputEvents.emit('data', data);
-        });
-
-        logStream.on('close', async () => {
-            const status = await container.status();
-            const data = status.data as any;
-            if (deleteOnExit) {
-                try {
-                    await containerManager.remove(container);
-                } catch (e: any) {}
-            }
-            outputEvents.emit('exit', data?.State?.ExitCode ?? 0);
-        });
-
-        return {
-            type: InstanceType.DOCKER,
-            pid: container.id,
-            output: outputEvents,
-            stop: async () => {
-                if (!localContainer) {
-                    return;
-                }
-
-                try {
-                    await localContainer.stop();
-                    if (deleteOnExit) {
-                        await containerManager.remove(localContainer);
-                    }
-                } catch (e) {}
-                localContainer = null;
-            },
-            logs: () => {
-                return logs.getLogs();
-            },
-        };
-    }
-
-    private async _startDockerProcess(blockInstance: BlockProcessParams, blockInfo: KapetaURI, env: StringMap) {
+    private async _startDockerProcess(blockInstance: BlockProcessParams, blockInfo: KapetaURI, env: StringMap, assetVersion: DefinitionInfo) {
         const { versionFile } = ClusterConfig.getRepositoryAssetInfoPath(
             blockInfo.handle,
             blockInfo.name,
@@ -333,8 +237,13 @@ export class BlockInstanceRunner {
             throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
         }
 
-        const containerName = getBlockInstanceContainerName(blockInstance.id);
-        const logs = new LogData();
+        const {
+            PortBindings,
+            ExposedPorts,
+            addonEnv
+        } = await this.getDockerPortBindings(blockInstance, assetVersion);
+
+        const containerName = getBlockInstanceContainerName(this._systemId, blockInstance.id);
 
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
@@ -342,16 +251,22 @@ export class BlockInstanceRunner {
         return this.ensureContainer({
             Image: dockerImage,
             name: containerName,
+            ExposedPorts,
             Labels: {
                 instance: blockInstance.id,
             },
             Env: [
                 ...DOCKER_ENV_VARS,
                 `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
-                ...Object.entries(env).map(([key, value]) => `${key}=${value}`),
+                ...Object.entries({
+                    ...env,
+                    ...addonEnv
+                }).map(([key, value]) => `${key}=${value}`),
+
             ],
             HostConfig: {
                 Binds: [`${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`],
+                PortBindings,
             },
         });
     }
@@ -391,7 +306,8 @@ export class BlockInstanceRunner {
 
         const dockerImage = spec?.local?.image;
 
-        const containerName = getBlockInstanceContainerName(blockInstance.id);
+        //We only want 1 operator per operator type - across all local systems
+        const containerName = getBlockInstanceContainerName(this._systemId, blockInstance.id);
         const logs = new LogData();
 
         const bindHost = getBindHost();
@@ -425,7 +341,7 @@ export class BlockInstanceRunner {
         }
 
         if (spec.local?.mounts) {
-            const mounts = containerManager.createMounts(blockUri.id, spec.local.mounts);
+            const mounts = await containerManager.createMounts(this._systemId, blockUri.id, spec.local.mounts);
             Mounts = containerManager.toDockerMounts(mounts);
         }
 
@@ -471,4 +387,53 @@ export class BlockInstanceRunner {
 
         return out;
     }
+
+
+    private async getDockerPortBindings(blockInstance: BlockProcessParams, assetVersion: DefinitionInfo) {
+        const bindHost = getBindHost();
+        const ExposedPorts: AnyMap = {};
+        const addonEnv: StringMap = {};
+        const PortBindings: AnyMap = {};
+
+        const portTypes = getProviderPorts(assetVersion);
+        let port = 80;
+        const promises = portTypes.map(async (portType) => {
+            const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
+            const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
+            const dockerPort = `${thisPort}/tcp`;
+            ExposedPorts[dockerPort] = {};
+            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
+
+            PortBindings[dockerPort] = [
+                {
+                    HostIp: bindHost,
+                    HostPort: `${publicPort}`,
+                },
+            ];
+        });
+
+
+        await Promise.all(promises);
+
+        return {PortBindings,ExposedPorts, addonEnv};
+    }
+
+    private async ensureContainer(opts: any) {
+        const container = await containerManager.ensureContainer(opts);
+
+        await containerManager.waitForReady(container);
+
+        return this._handleContainer(container);
+
+    }
+
+    private async _handleContainer(
+        container: Container
+    ): Promise<ProcessInfo> {
+
+        return {
+            type: InstanceType.DOCKER,
+            pid: container.id
+        };
+    }
 }

package/src/utils/LogData.ts

@@ -20,6 +20,7 @@ export class LogData {
         if (!msg.endsWith('\n')) {
             msg += '\n';
         }
+
         this.entries.push({
             time: Date.now(),
             message: msg,

package/src/utils/utils.ts

@@ -1,9 +1,10 @@
 import FS from 'node:fs';
 import YAML from 'yaml';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import md5 from "md5";
 
-export function getBlockInstanceContainerName(instanceId: string) {
-    return `kapeta-block-instance-${instanceId}`;
+export function getBlockInstanceContainerName(systemId:string, instanceId: string) {
+    return `kapeta-block-instance-${md5(systemId + instanceId)}`;
 }
 
 export function normalizeKapetaUri(uri: string) {