@kapeta/local-cluster-service 0.11.1 → 0.12.1

package/src/operatorManager.ts

@@ -11,9 +11,9 @@ import { BlockInstance, Resource } from '@kapeta/schemas';
 import { definitionsManager } from './definitionsManager';
 import { getBindHost, normalizeKapetaUri } from './utils/utils';
 import _ from 'lodash';
-import { Container } from 'node-docker-api/lib/container';
+import AsyncLock from 'async-lock';
 
-const KIND_OPERATOR = 'core/resource-type-operator';
+export const KIND_OPERATOR = 'core/resource-type-operator';
 
 class Operator {
     private _data: any;
@@ -33,6 +33,8 @@ class Operator {
 class OperatorManager {
     private _mountDir: string;
 
+    private operatorLock: AsyncLock = new AsyncLock();
+
     constructor() {
         this._mountDir = Path.join(storageService.getKapetaBasedir(), 'mounts');
 
@@ -154,98 +156,100 @@ class OperatorManager {
      * @return {Promise<ContainerInfo>}
      */
     async ensureResource(systemId: string, resourceType: string, version: string): Promise<ContainerInfo> {
-        const operator = this.getOperator(resourceType, version);
+        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 operatorData = operator.getData();
 
-        const portTypes = Object.keys(operatorData.ports);
+            const portTypes = Object.keys(operatorData.ports);
 
-        portTypes.sort();
+            portTypes.sort();
 
-        const ports: AnyMap = {};
+            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(systemId, resourceType, portType);
+            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 (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
+                    containerPortInfo = { port: containerPortInfo, type: 'tcp' };
+                }
+
+                if (!containerPortInfo.type) {
+                    containerPortInfo.type = 'tcp';
+                }
+
+                const portId = containerPortInfo.port + '/' + containerPortInfo.type;
 
-            if (!containerPortInfo.type) {
-                containerPortInfo.type = 'tcp';
+                ports[portId] = {
+                    type: portType,
+                    hostPort,
+                };
             }
 
-            const portId = containerPortInfo.port + '/' + containerPortInfo.type;
+            const mounts = await containerManager.createMounts(systemId, resourceType, operatorData.mounts);
 
-            ports[portId] = {
-                type: portType,
-                hostPort,
-            };
-        }
+            const nameParts = [systemId, resourceType.toLowerCase(), version];
 
-        const mounts = await containerManager.createMounts(systemId, resourceType, operatorData.mounts);
+            const containerName = `kapeta-resource-${md5(nameParts.join('_'))}`;
 
-        const nameParts = [
-            systemId,
-            resourceType.toLowerCase(),
-            version
-        ];
+            const PortBindings: { [key: string]: any } = {};
+            const Env: string[] = [];
 
-        const containerName = `kapeta-resource-${md5(nameParts.join('_'))}`;
+            const Labels: StringMap = {
+                kapeta: 'true',
+            };
 
-        const PortBindings: { [key: string]: any } = {};
-        const Env: string[] = [];
+            const bindHost = getBindHost();
 
-        const Labels: StringMap = {
-            kapeta: 'true',
-        };
+            const ExposedPorts: { [key: string]: any } = {};
 
-        const bindHost = getBindHost();
+            _.forEach(ports, (portInfo: any, containerPort) => {
+                ExposedPorts['' + containerPort] = {};
+                PortBindings['' + containerPort] = [
+                    {
+                        HostPort: '' + portInfo.hostPort,
+                        HostIp: bindHost,
+                    },
+                ];
 
-        const ExposedPorts: { [key: string]: any } = {};
+                Labels[CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
+            });
 
-        _.forEach(ports, (portInfo: any, containerPort) => {
-            ExposedPorts['' + containerPort] = {};
-            PortBindings['' + containerPort] = [
-                {
-                    HostPort: '' + portInfo.hostPort,
-                    HostIp: bindHost,
-                },
-            ];
+            const Mounts = containerManager.toDockerMounts(mounts);
 
-            Labels[CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
-        });
+            _.forEach(operatorData.env, (value, name) => {
+                Env.push(name + '=' + value);
+            });
 
-        const Mounts = containerManager.toDockerMounts(mounts);
+            let HealthCheck = undefined;
 
-        _.forEach(operatorData.env, (value, name) => {
-            Env.push(name + '=' + value);
-        });
+            if (operatorData.health) {
+                HealthCheck = containerManager.toDockerHealth(operatorData.health);
+            }
 
-        let HealthCheck = undefined;
+            const container = await containerManager.ensureContainer({
+                name: containerName,
+                Image: operatorData.image,
+                Hostname: containerName + '.kapeta',
+                Labels,
+                Cmd: operatorData.cmd,
+                ExposedPorts,
+                Env,
+                HealthCheck,
+                HostConfig: {
+                    PortBindings,
+                    Mounts,
+                },
+            });
 
-        if (operatorData.health) {
-            HealthCheck = containerManager.toDockerHealth(operatorData.health);
-        }
+            await containerManager.waitForReady(container);
 
-        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);
     }
 }
 

package/src/socketManager.ts

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

package/src/types.ts

@@ -64,6 +64,7 @@ export type InstanceInfo = {
     type: InstanceType;
     owner: InstanceOwner;
     status: InstanceStatus;
+    errorMessage?: string;
     desiredStatus: DesiredInstanceStatus;
     address?: string;
 
@@ -71,7 +72,6 @@ export type InstanceInfo = {
     health?: string | null;
     pid?: number | string | null;
     portType?: string;
-
 };
 
 interface ResourceRef {

package/src/utils/BlockInstanceRunner.ts

@@ -175,11 +175,7 @@ export class BlockInstanceRunner {
         const homeDir = localContainer.userHome ? localContainer.userHome : '/root';
         const workingDir = localContainer.workingDir ? localContainer.workingDir : '/workspace';
 
-        const {
-            PortBindings,
-            ExposedPorts,
-            addonEnv
-        } = await this.getDockerPortBindings(blockInstance, assetVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
 
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
@@ -215,7 +211,12 @@ export class BlockInstanceRunner {
         });
     }
 
-    private async _startDockerProcess(blockInstance: BlockProcessParams, blockInfo: KapetaURI, env: StringMap, assetVersion: DefinitionInfo) {
+    private async _startDockerProcess(
+        blockInstance: BlockProcessParams,
+        blockInfo: KapetaURI,
+        env: StringMap,
+        assetVersion: DefinitionInfo
+    ) {
         const { versionFile } = ClusterConfig.getRepositoryAssetInfoPath(
             blockInfo.handle,
             blockInfo.name,
@@ -237,11 +238,7 @@ export class BlockInstanceRunner {
             throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
         }
 
-        const {
-            PortBindings,
-            ExposedPorts,
-            addonEnv
-        } = await this.getDockerPortBindings(blockInstance, assetVersion);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
 
         const containerName = getBlockInstanceContainerName(this._systemId, blockInstance.id);
 
@@ -260,9 +257,8 @@ export class BlockInstanceRunner {
                 `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
                 ...Object.entries({
                     ...env,
-                    ...addonEnv
+                    ...addonEnv,
                 }).map(([key, value]) => `${key}=${value}`),
-
             ],
             HostConfig: {
                 Binds: [`${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`],
@@ -388,7 +384,6 @@ export class BlockInstanceRunner {
         return out;
     }
 
-
     private async getDockerPortBindings(blockInstance: BlockProcessParams, assetVersion: DefinitionInfo) {
         const bindHost = getBindHost();
         const ExposedPorts: AnyMap = {};
@@ -412,28 +407,21 @@ export class BlockInstanceRunner {
             ];
         });
 
-
         await Promise.all(promises);
 
-        return {PortBindings,ExposedPorts, addonEnv};
+        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> {
-
+    private async _handleContainer(container: Container): Promise<ProcessInfo> {
         return {
             type: InstanceType.DOCKER,
-            pid: container.id
+            pid: container.id,
         };
     }
 }

package/src/utils/utils.ts

@@ -1,9 +1,9 @@
 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:string, instanceId: string) {
+export function getBlockInstanceContainerName(systemId: string, instanceId: string) {
     return `kapeta-block-instance-${md5(systemId + instanceId)}`;
 }