@kapeta/local-cluster-service 0.10.0 → 0.11.0

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

@@ -62,15 +62,21 @@ router.post('/:systemId/:instanceId/stop', async (req, res) => {
 /**
  * Get logs for instance in a plan
  */
-router.get('/:systemId/:instanceId/logs', (req, res) => {
+router.get('/:systemId/:instanceId/logs', async (req, res) => {
     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) {
+        res.status(500).send({ ok: false, error: e.message });
+    }
 });
 /**
  * Get public address for instance in a plan if available

package/dist/esm/src/operatorManager.js

@@ -111,13 +111,11 @@ class OperatorManager {
         const operatorData = operator.getData();
         const portTypes = Object.keys(operatorData.ports);
         portTypes.sort();
-        const containerBaseName = 'kapeta-resource';
-        const nameParts = [resourceType.toLowerCase()];
         const ports = {};
         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' };
             }
@@ -125,14 +123,18 @@ class OperatorManager {
                 containerPortInfo.type = 'tcp';
             }
             const portId = containerPortInfo.port + '/' + containerPortInfo.type;
-            nameParts.push(portType + '-' + portId + '-' + hostPort);
             ports[portId] = {
                 type: portType,
                 hostPort,
             };
         }
-        const mounts = containerManager.createMounts(resourceType, operatorData.mounts);
-        const containerName = containerBaseName + '-' + md5(nameParts.join('_'));
+        const mounts = await containerManager.createMounts(systemId, resourceType, operatorData.mounts);
+        const nameParts = [
+            systemId,
+            resourceType.toLowerCase(),
+            version
+        ];
+        const containerName = `kapeta-resource-${md5(nameParts.join('_'))}`;
         const PortBindings = {};
         const Env = [];
         const Labels = {

package/dist/esm/src/repositoryManager.js

@@ -107,9 +107,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 {
@@ -200,14 +202,12 @@ 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) => dep.name);
             if (refs.length > 0) {
-                console.log(`Auto-installing dependencies: ${refs.join(', ')}`);
                 await this._install(refs);
             }
         }

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

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-import EventEmitter from 'events';
 import express from 'express';
 import { Resource } from '@kapeta/schemas';
 import { StringBodyRequest } from './middleware/stringBody';
@@ -50,10 +48,7 @@ export declare enum DesiredInstanceStatus {
 export type ProcessInfo = {
     type: InstanceType;
     pid?: number | string | null;
-    output: EventEmitter;
     portType?: string;
-    logs: () => LogEntry[];
-    stop: () => Promise<void> | void;
 };
 export type InstanceInfo = {
     systemId: string;
@@ -69,10 +64,6 @@ export type InstanceInfo = {
     health?: string | null;
     pid?: number | string | null;
     portType?: string;
-    internal?: {
-        output: EventEmitter;
-        logs: () => LogEntry[];
-    };
 };
 interface ResourceRef {
     blockId: string;

package/dist/esm/src/utils/BlockInstanceRunner.d.ts

@@ -14,8 +14,6 @@ export declare class BlockInstanceRunner {
      * Starts local process
      */
     private _startLocalProcess;
-    private ensureContainer;
-    private _handleContainer;
     private _startDockerProcess;
     /**
      *
@@ -27,4 +25,7 @@ export declare class BlockInstanceRunner {
      * @private
      */
     _startOperatorProcess(blockInstance: BlockProcessParams, blockUri: KapetaURI, providerDefinition: DefinitionInfo, env: StringMap): Promise<ProcessInfo>;
+    private getDockerPortBindings;
+    private ensureContainer;
+    private _handleContainer;
 }

package/dist/esm/src/utils/BlockInstanceRunner.js

@@ -5,7 +5,6 @@ import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { serviceManager } from '../serviceManager';
 import { containerManager, toLocalBindVolume } from '../containerManager';
 import { LogData } from './LogData';
-import EventEmitter from 'events';
 import { clusterService } from '../clusterService';
 import { InstanceType } from '../types';
 import { definitionsManager } from '../definitionsManager';
@@ -94,7 +93,7 @@ export class BlockInstanceRunner {
                 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) {
                 processInfo.portType = portTypes[0];
@@ -127,31 +126,12 @@ export class BlockInstanceRunner {
         if (!dockerImage) {
             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 = {};
-        const addonEnv = {};
-        const PortBindings = {};
-        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) {
             HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
@@ -184,73 +164,7 @@ export class BlockInstanceRunner {
             ...dockerOpts,
         });
     }
-    async ensureContainer(opts) {
-        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) {
-            logs.addLog(e.message, 'ERROR');
-        }
-        return this._handleContainer(container, logs);
-    }
-    async _handleContainer(container, logs, deleteOnExit = false) {
-        let localContainer = container;
-        const logStream = (await container.logs({
-            follow: true,
-            stdout: true,
-            stderr: true,
-            tail: LogData.MAX_LINES,
-        }));
-        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;
-            if (deleteOnExit) {
-                try {
-                    await containerManager.remove(container);
-                }
-                catch (e) { }
-            }
-            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();
-            },
-        };
-    }
-    async _startDockerProcess(blockInstance, blockInfo, env) {
+    async _startDockerProcess(blockInstance, blockInfo, env, assetVersion) {
         const { versionFile } = ClusterConfig.getRepositoryAssetInfoPath(blockInfo.handle, blockInfo.name, blockInfo.version);
         const versionYml = versionFile;
         if (!FS.existsSync(versionYml)) {
@@ -264,23 +178,28 @@ export class BlockInstanceRunner {
         if (!dockerImage) {
             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();
         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,
             },
         });
     }
@@ -305,7 +224,8 @@ export class BlockInstanceRunner {
             throw new Error(`Provider did not have local image: ${providerRef}`);
         }
         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();
         const ExposedPorts = {};
@@ -332,7 +252,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);
         }
         if (spec.local?.health) {
@@ -373,4 +293,38 @@ export class BlockInstanceRunner {
         }
         return out;
     }
+    async getDockerPortBindings(blockInstance, assetVersion) {
+        const bindHost = getBindHost();
+        const ExposedPorts = {};
+        const addonEnv = {};
+        const PortBindings = {};
+        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 };
+    }
+    async ensureContainer(opts) {
+        const container = await containerManager.ensureContainer(opts);
+        await containerManager.waitForReady(container);
+        return this._handleContainer(container);
+    }
+    async _handleContainer(container) {
+        return {
+            type: InstanceType.DOCKER,
+            pid: container.id
+        };
+    }
 }

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

@@ -1,4 +1,4 @@
-export declare function getBlockInstanceContainerName(instanceId: string): string;
+export declare function getBlockInstanceContainerName(systemId: string, instanceId: string): string;
 export declare function normalizeKapetaUri(uri: string): string;
 export declare function readYML(path: string): any;
 export declare function isWindows(): boolean;

package/dist/esm/src/utils/utils.js

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

package/package.json

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

package/src/containerManager.ts

@@ -9,6 +9,10 @@ import ClusterConfiguration from '@kapeta/local-cluster-config';
 import { Container } from 'node-docker-api/lib/container';
 import uuid from 'node-uuid';
 import md5 from 'md5';
+import {getBlockInstanceContainerName} from "./utils/utils";
+import {InstanceInfo, LogEntry, LogSource} from "./types";
+import EventEmitter from "events";
+import {LogData} from "./utils/LogData";
 
 type StringMap = { [key: string]: string };
 
@@ -63,9 +67,9 @@ const IMAGE_PULL_CACHE: { [key: string]: number } = {};
 
 export const HEALTH_CHECK_TIMEOUT = HEALTH_CHECK_INTERVAL * HEALTH_CHECK_MAX * 2;
 
-const promisifyStream = (stream: ReadStream) =>
+const promisifyStream = (stream: ReadStream, handler:(d:string|Buffer) => void) =>
     new Promise((resolve, reject) => {
-        stream.on('data', (d) => console.log(d.toString()));
+        stream.on('data', handler);
         stream.on('end', resolve);
         stream.on('error', reject);
     });
@@ -151,19 +155,30 @@ class ContainerManager {
         return this._alive;
     }
 
-    getMountPoint(kind: string, mountName: string) {
-        const kindUri = parseKapetaUri(kind);
-        return Path.join(this._mountDir, kindUri.handle, kindUri.name, mountName);
+    getMountPoint(systemId:string, ref: string, mountName: string) {
+        const kindUri = parseKapetaUri(ref);
+        const systemUri = parseKapetaUri(systemId)
+        return Path.join(this._mountDir,
+            systemUri.handle,
+            systemUri.name,
+            systemUri.version,
+            kindUri.handle,
+            kindUri.name,
+            kindUri.version, mountName);
     }
 
-    createMounts(kind: string, mountOpts: StringMap): StringMap {
+    async createMounts(systemId:string, kind: string, mountOpts: StringMap|null|undefined): Promise<StringMap> {
         const mounts: StringMap = {};
 
-        _.forEach(mountOpts, (containerPath, mountName) => {
-            const hostPath = this.getMountPoint(kind, mountName);
-            FSExtra.mkdirpSync(hostPath);
-            mounts[containerPath] = hostPath;
-        });
+        if (mountOpts) {
+            const mountOptList = Object.entries(mountOpts);
+            for(const [mountName, containerPath] of mountOptList) {
+                const hostPath = this.getMountPoint(systemId, kind, mountName);
+                await FSExtra.mkdirp(hostPath);
+                mounts[containerPath] = hostPath;
+            }
+        }
+
         return mounts;
     }
 
@@ -224,15 +239,18 @@ class ContainerManager {
         }
 
         console.log('Pulling image: %s', image);
-        await this.docker()
+        const stream = await this.docker()
             .image.create(
                 {},
                 {
                     fromImage: imageName,
                     tag: tag,
                 }
-            )
-            .then((stream) => promisifyStream(stream as ReadStream));
+            ) as ReadStream;
+
+        await promisifyStream(stream, (chunk) => {
+            console.log('Data from docker: "%s"', chunk.toString());
+        });
 
         IMAGE_PULL_CACHE[image] = Date.now();
 
@@ -278,7 +296,15 @@ class ContainerManager {
         dockerOpts.Labels.HASH = hash;
     }
 
-    async ensureContainer(opts: any) {
+    public async ensureContainer(opts: any) {
+        const container = await this.createOrUpdateContainer(opts);
+
+        await this.waitForReady(container);
+
+        return container;
+    }
+
+    private async createOrUpdateContainer(opts: any) {
         let imagePulled = false;
         try {
             imagePulled = await this.pull(opts.Image);
@@ -369,31 +395,6 @@ class ContainerManager {
         });
     }
 
-    async waitForHealthy(container: Container, attempt?: number): Promise<void> {
-        if (!attempt) {
-            attempt = 0;
-        }
-
-        if (attempt >= HEALTH_CHECK_MAX) {
-            throw new Error('Container did not become healthy within the timeout');
-        }
-
-        if (await this._isHealthy(container)) {
-            return;
-        }
-
-        return new Promise((resolve, reject) => {
-            setTimeout(async () => {
-                try {
-                    await this.waitForHealthy(container, (attempt ?? 0) + 1);
-                    resolve();
-                } catch (err) {
-                    reject(err);
-                }
-            }, HEALTH_CHECK_INTERVAL);
-        });
-    }
-
     async _isReady(container: Container) {
         let info: Container;
         try {
@@ -403,19 +404,16 @@ class ContainerManager {
         }
         const infoData: any = info?.data;
         const state = infoData?.State as DockerState;
+
         if (state?.Status === 'exited' || state?.Status === 'removing' || state?.Status === 'dead') {
             throw new Error('Container exited unexpectedly');
         }
-        return infoData?.State?.Running ?? false;
-    }
 
-    async _isHealthy(container: Container) {
-        try {
-            const info = await container.status();
-            const infoData: any = info?.data;
-            return infoData?.State?.Health?.Status === 'healthy';
-        } catch (err) {
-            return false;
+        if (infoData?.State?.Health) {
+            // If container has health info - wait for it to become healthy
+            return infoData.State.Health.Status === 'healthy';
+        } else {
+            return infoData?.State?.Running ?? false;
         }
     }
 
@@ -449,6 +447,21 @@ class ContainerManager {
 
         return new ContainerInfo(dockerContainer);
     }
+
+    async getLogs(instance: InstanceInfo):Promise<LogEntry[]> {
+        const containerName = getBlockInstanceContainerName(instance.systemId, instance.instanceId);
+        const containerInfo = await this.getContainerByName(containerName);
+        if (!containerInfo) {
+            return [{
+                source: "stdout",
+                level: "ERROR",
+                time: Date.now(),
+                message: "Container not found"
+            }];
+        }
+
+        return containerInfo.getLogs()
+    }
 }
 
 export class ContainerInfo {
@@ -558,6 +571,70 @@ export class ContainerInfo {
 
         return ports;
     }
+
+    async getLogs():Promise<LogEntry[]> {
+
+        const logStream = await this.native.logs({
+            stdout: true,
+            stderr: true,
+            follow: false,
+            tail: 100,
+            timestamps: true,
+        })  as ReadStream;
+
+        const out = [] as LogEntry[];
+        await promisifyStream(logStream, (data) => {
+            const buf = data as Buffer;
+            let offset = 0;
+            while(offset < buf.length) {
+                try {
+                    // Read the docker log format - explained here:
+                    // https://docs.docker.com/engine/api/v1.41/#operation/ContainerAttach
+                    // or here : https://ahmet.im/blog/docker-logs-api-binary-format-explained/
+
+                    // First byte is stream type
+                    const streamTypeInt = buf.readInt8(offset);
+                    const streamType:LogSource = streamTypeInt === 1 ? 'stdout' : 'stderr';
+
+                    // Bytes 4-8 is frame size
+                    const messageLength = buf.readInt32BE(offset + 4);
+
+                    // After that is the message - with the message length
+                    const dataWithoutStreamType = buf.subarray(offset + 8, offset + 8 + messageLength);
+                    const raw = dataWithoutStreamType.toString();
+
+                    // Split the message into date and message
+                    const firstSpaceIx = raw.indexOf(' ');
+                    const dateString = raw.substring(0, firstSpaceIx);
+                    const line = raw.substring(firstSpaceIx + 1);
+                    offset = offset + messageLength + 8;
+                    if (!dateString) {
+                        continue;
+                    }
+                    out.push({
+                        time: new Date(dateString).getTime(),
+                        message: line,
+                        level: 'INFO',
+                        source: streamType,
+                    });
+                } catch (err) {
+                    console.error('Error parsing log entry', err);
+                    offset = buf.length
+                }
+            }
+        });
+
+        if (out.length === 0) {
+            out.push({
+                time: Date.now(),
+                message: 'No logs found for container',
+                level: 'INFO',
+                source: 'stdout',
+            });
+        }
+
+        return out;
+    }
 }
 
 export function getExtraHosts(dockerVersion: string): string[] | undefined {

package/src/definitionsManager.ts

@@ -1,4 +1,5 @@
 import ClusterConfiguration, { DefinitionInfo } from '@kapeta/local-cluster-config';
+import {parseKapetaUri} from "@kapeta/nodejs-utils";
 
 const CACHE_TTL = 60 * 1000; // 1 min
 
@@ -46,6 +47,13 @@ class DefinitionsManager {
         return this.doCached(key, () => ClusterConfiguration.getDefinitions(kindFilter));
     }
 
+    public exists(ref: string) {
+        const uri = parseKapetaUri(ref);
+        return !!this.getDefinitions().find((d) => {
+            return parseKapetaUri(`${d.definition.metadata.name}:${d.version}`).id === uri.id;
+        });
+    }
+
     public getProviderDefinitions() {
         return this.doCached('providers', () => ClusterConfiguration.getProviderDefinitions());
     }