@kapeta/local-cluster-service 0.11.0 → 0.12.0

package/dist/esm/src/operatorManager.js

@@ -8,7 +8,8 @@ import FSExtra from 'fs-extra';
 import { definitionsManager } from './definitionsManager';
 import { getBindHost, normalizeKapetaUri } from './utils/utils';
 import _ from 'lodash';
-const KIND_OPERATOR = 'core/resource-type-operator';
+import AsyncLock from 'async-lock';
+export const KIND_OPERATOR = 'core/resource-type-operator';
 class Operator {
     _data;
     constructor(data) {
@@ -23,6 +24,7 @@ class Operator {
 }
 class OperatorManager {
     _mountDir;
+    operatorLock = new AsyncLock();
     constructor() {
         this._mountDir = Path.join(storageService.getKapetaBasedir(), 'mounts');
         FSExtra.mkdirpSync(this._mountDir);
@@ -107,74 +109,74 @@ class OperatorManager {
      * @return {Promise<ContainerInfo>}
      */
     async ensureResource(systemId, resourceType, version) {
-        const operator = this.getOperator(resourceType, version);
-        const operatorData = operator.getData();
-        const portTypes = Object.keys(operatorData.ports);
-        portTypes.sort();
-        const ports = {};
-        for (let i = 0; i < portTypes.length; i++) {
-            const portType = portTypes[i];
-            let containerPortInfo = operatorData.ports[portType];
-            const hostPort = await serviceManager.ensureServicePort(systemId, resourceType, portType);
-            if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
-                containerPortInfo = { port: containerPortInfo, type: 'tcp' };
-            }
-            if (!containerPortInfo.type) {
-                containerPortInfo.type = 'tcp';
+        systemId = normalizeKapetaUri(systemId);
+        const key = `${systemId}#${resourceType}:${version}`;
+        return await this.operatorLock.acquire(key, async () => {
+            const operator = this.getOperator(resourceType, version);
+            const operatorData = operator.getData();
+            const portTypes = Object.keys(operatorData.ports);
+            portTypes.sort();
+            const ports = {};
+            for (let i = 0; i < portTypes.length; i++) {
+                const portType = portTypes[i];
+                let containerPortInfo = operatorData.ports[portType];
+                const hostPort = await serviceManager.ensureServicePort(systemId, resourceType, portType);
+                if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
+                    containerPortInfo = { port: containerPortInfo, type: 'tcp' };
+                }
+                if (!containerPortInfo.type) {
+                    containerPortInfo.type = 'tcp';
+                }
+                const portId = containerPortInfo.port + '/' + containerPortInfo.type;
+                ports[portId] = {
+                    type: portType,
+                    hostPort,
+                };
             }
-            const portId = containerPortInfo.port + '/' + containerPortInfo.type;
-            ports[portId] = {
-                type: portType,
-                hostPort,
+            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 = {
+                kapeta: 'true',
             };
-        }
-        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 = {
-            kapeta: 'true',
-        };
-        const bindHost = getBindHost();
-        const ExposedPorts = {};
-        _.forEach(ports, (portInfo, containerPort) => {
-            ExposedPorts['' + containerPort] = {};
-            PortBindings['' + containerPort] = [
-                {
-                    HostPort: '' + portInfo.hostPort,
-                    HostIp: bindHost,
+            const bindHost = getBindHost();
+            const ExposedPorts = {};
+            _.forEach(ports, (portInfo, containerPort) => {
+                ExposedPorts['' + containerPort] = {};
+                PortBindings['' + containerPort] = [
+                    {
+                        HostPort: '' + portInfo.hostPort,
+                        HostIp: bindHost,
+                    },
+                ];
+                Labels[CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
+            });
+            const Mounts = containerManager.toDockerMounts(mounts);
+            _.forEach(operatorData.env, (value, name) => {
+                Env.push(name + '=' + value);
+            });
+            let HealthCheck = undefined;
+            if (operatorData.health) {
+                HealthCheck = containerManager.toDockerHealth(operatorData.health);
+            }
+            const container = await containerManager.ensureContainer({
+                name: containerName,
+                Image: operatorData.image,
+                Hostname: containerName + '.kapeta',
+                Labels,
+                Cmd: operatorData.cmd,
+                ExposedPorts,
+                Env,
+                HealthCheck,
+                HostConfig: {
+                    PortBindings,
+                    Mounts,
                 },
-            ];
-            Labels[CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
-        });
-        const Mounts = containerManager.toDockerMounts(mounts);
-        _.forEach(operatorData.env, (value, name) => {
-            Env.push(name + '=' + value);
-        });
-        let HealthCheck = undefined;
-        if (operatorData.health) {
-            HealthCheck = containerManager.toDockerHealth(operatorData.health);
-        }
-        const container = await containerManager.ensureContainer({
-            name: containerName,
-            Image: operatorData.image,
-            Hostname: containerName + '.kapeta',
-            Labels,
-            Cmd: operatorData.cmd,
-            ExposedPorts,
-            Env,
-            HealthCheck,
-            HostConfig: {
-                PortBindings,
-                Mounts,
-            },
+            });
+            return new ContainerInfo(container);
         });
-        return new ContainerInfo(container);
     }
 }
 export const operatorManager = new OperatorManager();

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

@@ -7,6 +7,7 @@ export declare class SocketManager {
     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;

package/dist/esm/src/socketManager.js

@@ -23,6 +23,9 @@ export class SocketManager {
     emit(context, type, payload) {
         this.io.to(context).emit(type, { context, payload });
     }
+    emitGlobal(type, payload) {
+        this.io.emit(type, { payload });
+    }
     _bindIO() {
         this.io.on('connection', (socket) => this._handleSocketCreated(socket));
     }

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

@@ -58,6 +58,7 @@ export type InstanceInfo = {
     type: InstanceType;
     owner: InstanceOwner;
     status: InstanceStatus;
+    errorMessage?: string;
     desiredStatus: DesiredInstanceStatus;
     address?: string;
     startedAt?: number;

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

@@ -194,7 +194,7 @@ export class BlockInstanceRunner {
                 `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
                 ...Object.entries({
                     ...env,
-                    ...addonEnv
+                    ...addonEnv,
                 }).map(([key, value]) => `${key}=${value}`),
             ],
             HostConfig: {
@@ -324,7 +324,7 @@ export class BlockInstanceRunner {
     async _handleContainer(container) {
         return {
             type: InstanceType.DOCKER,
-            pid: container.id
+            pid: container.id,
         };
     }
 }

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.11.0",
+    "version": "0.12.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -50,6 +50,7 @@
         "@kapeta/nodejs-utils": "<2",
         "@kapeta/schemas": "^0.0.58",
         "@kapeta/sdk-config": "<2",
+        "async-lock": "^1.4.0",
         "express": "4.17.1",
         "express-promise-router": "^4.1.1",
         "fs-extra": "^11.1.0",
@@ -70,6 +71,7 @@
         "@kapeta/eslint-config": "^0.6.1",
         "@kapeta/prettier-config": "^0.6.0",
         "@tsconfig/node18": "^18.2.0",
+        "@types/async-lock": "^1.4.0",
         "@types/express": "^4.17.17",
         "@types/fs-extra": "^11.0.1",
         "@types/lodash": "^4.14.195",

package/src/config/routes.ts

@@ -41,7 +41,7 @@ router.put('/instance', async (req: KapetaBodyRequest, res) => {
         if (req.kapeta!.instanceId) {
             configManager.setConfigForSection(req.kapeta!.systemId, req.kapeta!.instanceId, config);
             //Restart the instance if it is running after config change
-            await instanceManager.restart(req.kapeta!.systemId, req.kapeta!.instanceId);
+            await instanceManager.prepareForRestart(req.kapeta!.systemId, req.kapeta!.instanceId);
         } else {
             configManager.setConfigForSystem(req.kapeta!.systemId, config);
         }

package/src/containerManager.ts

@@ -9,10 +9,14 @@ 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";
+import { getBlockInstanceContainerName } from './utils/utils';
+import { InstanceInfo, LogEntry, LogSource } from './types';
+import { socketManager } from './socketManager';
+import { handlers as ArtifactHandlers } from '@kapeta/nodejs-registry-utils';
+import { progressListener } from './progressListener';
+import { KapetaAPI } from '@kapeta/nodejs-api-client';
+
+const EVENT_IMAGE_PULL = 'docker-image-pull';
 
 type StringMap = { [key: string]: string };
 
@@ -67,7 +71,7 @@ const IMAGE_PULL_CACHE: { [key: string]: number } = {};
 
 export const HEALTH_CHECK_TIMEOUT = HEALTH_CHECK_INTERVAL * HEALTH_CHECK_MAX * 2;
 
-const promisifyStream = (stream: ReadStream, handler:(d:string|Buffer) => void) =>
+const promisifyStream = (stream: ReadStream, handler: (d: string | Buffer) => void) =>
     new Promise((resolve, reject) => {
         stream.on('data', handler);
         stream.on('end', resolve);
@@ -79,6 +83,7 @@ class ContainerManager {
     private _alive: boolean;
     private _mountDir: string;
     private _version: string;
+    private _lastDockerAccessCheck: number = 0;
 
     constructor() {
         this._docker = null;
@@ -155,24 +160,27 @@ class ContainerManager {
         return this._alive;
     }
 
-    getMountPoint(systemId:string, ref: string, mountName: string) {
+    getMountPoint(systemId: string, ref: string, mountName: string) {
         const kindUri = parseKapetaUri(ref);
-        const systemUri = parseKapetaUri(systemId)
-        return Path.join(this._mountDir,
+        const systemUri = parseKapetaUri(systemId);
+        return Path.join(
+            this._mountDir,
             systemUri.handle,
             systemUri.name,
             systemUri.version,
             kindUri.handle,
             kindUri.name,
-            kindUri.version, mountName);
+            kindUri.version,
+            mountName
+        );
     }
 
-    async createMounts(systemId:string, kind: string, mountOpts: StringMap|null|undefined): Promise<StringMap> {
+    async createMounts(systemId: string, kind: string, mountOpts: StringMap | null | undefined): Promise<StringMap> {
         const mounts: StringMap = {};
 
         if (mountOpts) {
             const mountOptList = Object.entries(mountOpts);
-            for(const [mountName, containerPath] of mountOptList) {
+            for (const [mountName, containerPath] of mountOptList) {
                 const hostPath = this.getMountPoint(systemId, kind, mountName);
                 await FSExtra.mkdirp(hostPath);
                 mounts[containerPath] = hostPath;
@@ -238,23 +246,153 @@ class ContainerManager {
             return false;
         }
 
-        console.log('Pulling image: %s', image);
-        const stream = await this.docker()
-            .image.create(
-                {},
-                {
-                    fromImage: imageName,
-                    tag: tag,
+        const timeStarted = Date.now();
+        socketManager.emitGlobal(EVENT_IMAGE_PULL, { image, percent: 0 });
+
+        const api = new KapetaAPI();
+        const accessToken = await api.getAccessToken();
+
+        const auth = image.startsWith('docker.kapeta.com/')
+            ? {
+                  username: 'kapeta',
+                  password: accessToken,
+                  serveraddress: 'docker.kapeta.com',
+              }
+            : {};
+
+        const stream = (await this.docker().image.create(auth, {
+            fromImage: imageName,
+            tag: tag,
+        })) as ReadStream;
+
+        const chunks: {
+            [p: string]: {
+                downloading: {
+                    total: number;
+                    current: number;
+                };
+                extracting: {
+                    total: number;
+                    current: number;
+                };
+                done: boolean;
+            };
+        } = {};
+
+        let lastEmitted = Date.now();
+        await promisifyStream(stream, (rawData) => {
+            const lines = rawData.toString().trim().split('\n');
+            lines.forEach((line) => {
+                const data = JSON.parse(line);
+                if (
+                    ![
+                        'Waiting',
+                        'Downloading',
+                        'Extracting',
+                        'Download complete',
+                        'Pull complete',
+                        'Already exists',
+                    ].includes(data.status)
+                ) {
+                    return;
+                }
+
+                if (!chunks[data.id]) {
+                    chunks[data.id] = {
+                        downloading: {
+                            total: 0,
+                            current: 0,
+                        },
+                        extracting: {
+                            total: 0,
+                            current: 0,
+                        },
+                        done: false,
+                    };
+                }
+
+                const chunk = chunks[data.id];
+
+                switch (data.status) {
+                    case 'Downloading':
+                        chunk.downloading = data.progressDetail;
+                        break;
+                    case 'Extracting':
+                        chunk.extracting = data.progressDetail;
+                        break;
+                    case 'Download complete':
+                        chunk.downloading.current = chunks[data.id].downloading.total;
+                        break;
+                    case 'Pull complete':
+                        chunk.extracting.current = chunks[data.id].extracting.total;
+                        chunk.done = true;
+                        break;
+                    case 'Already exists':
+                        // Force layer to be done
+                        chunk.downloading.current = 1;
+                        chunk.downloading.total = 1;
+                        chunk.extracting.current = 1;
+                        chunk.extracting.total = 1;
+                        chunk.done = true;
+                        break;
+                }
+            });
+
+            if (Date.now() - lastEmitted < 1000) {
+                return;
+            }
+
+            const chunkList = Object.values(chunks);
+            let totals = {
+                downloading: {
+                    total: 0,
+                    current: 0,
+                },
+                extracting: {
+                    total: 0,
+                    current: 0,
+                },
+                total: chunkList.length,
+                done: 0,
+            };
+
+            chunkList.forEach((chunk) => {
+                if (chunk.downloading.current > 0) {
+                    totals.downloading.current += chunk.downloading.current;
+                }
+
+                if (chunk.downloading.total > 0) {
+                    totals.downloading.total += chunk.downloading.total;
+                }
+
+                if (chunk.extracting.current > 0) {
+                    totals.extracting.current += chunk.extracting.current;
+                }
+
+                if (chunk.extracting.total > 0) {
+                    totals.extracting.total += chunk.extracting.total;
+                }
+
+                if (chunk.done) {
+                    totals.done++;
                 }
-            ) as ReadStream;
+            });
 
-        await promisifyStream(stream, (chunk) => {
-            console.log('Data from docker: "%s"', chunk.toString());
+            const percent = totals.total > 0 ? (totals.done / totals.total) * 100 : 0;
+            //We emit at most every second to not spam the client
+            socketManager.emitGlobal(EVENT_IMAGE_PULL, {
+                image,
+                percent,
+                status: totals,
+                timeTaken: Date.now() - timeStarted,
+            });
+            lastEmitted = Date.now();
+            //console.log('Pulling image %s: %s % [done: %s, total: %s]', image, Math.round(percent), totals.done, totals.total);
         });
 
         IMAGE_PULL_CACHE[image] = Date.now();
 
-        console.log('Image pulled: %s', image);
+        socketManager.emitGlobal(EVENT_IMAGE_PULL, { image, percent: 100, timeTaken: Date.now() - timeStarted });
 
         return true;
     }
@@ -305,12 +443,7 @@ class ContainerManager {
     }
 
     private async createOrUpdateContainer(opts: any) {
-        let imagePulled = false;
-        try {
-            imagePulled = await this.pull(opts.Image);
-        } catch (e) {
-            console.warn('Failed to pull image. Continuing...', e);
-        }
+        let imagePulled = await this.pull(opts.Image);
 
         this.applyHash(opts);
         if (!opts.name) {
@@ -448,24 +581,27 @@ class ContainerManager {
         return new ContainerInfo(dockerContainer);
     }
 
-    async getLogs(instance: InstanceInfo):Promise<LogEntry[]> {
+    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 [
+                {
+                    source: 'stdout',
+                    level: 'ERROR',
+                    time: Date.now(),
+                    message: 'Container not found',
+                },
+            ];
         }
 
-        return containerInfo.getLogs()
+        return containerInfo.getLogs();
     }
 }
 
 export class ContainerInfo {
     private readonly _container: Container;
+
     /**
      *
      * @param {Container} dockerContainer
@@ -572,21 +708,20 @@ export class ContainerInfo {
         return ports;
     }
 
-    async getLogs():Promise<LogEntry[]> {
-
-        const logStream = await this.native.logs({
+    async getLogs(): Promise<LogEntry[]> {
+        const logStream = (await this.native.logs({
             stdout: true,
             stderr: true,
             follow: false,
             tail: 100,
             timestamps: true,
-        })  as ReadStream;
+        })) as ReadStream;
 
         const out = [] as LogEntry[];
         await promisifyStream(logStream, (data) => {
             const buf = data as Buffer;
             let offset = 0;
-            while(offset < buf.length) {
+            while (offset < buf.length) {
                 try {
                     // Read the docker log format - explained here:
                     // https://docs.docker.com/engine/api/v1.41/#operation/ContainerAttach
@@ -594,7 +729,7 @@ export class ContainerInfo {
 
                     // First byte is stream type
                     const streamTypeInt = buf.readInt8(offset);
-                    const streamType:LogSource = streamTypeInt === 1 ? 'stdout' : 'stderr';
+                    const streamType: LogSource = streamTypeInt === 1 ? 'stdout' : 'stderr';
 
                     // Bytes 4-8 is frame size
                     const messageLength = buf.readInt32BE(offset + 4);
@@ -619,7 +754,7 @@ export class ContainerInfo {
                     });
                 } catch (err) {
                     console.error('Error parsing log entry', err);
-                    offset = buf.length
+                    offset = buf.length;
                 }
             }
         });

package/src/definitionsManager.ts

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