@kapeta/local-cluster-service 0.34.2 → 0.36.0

package/src/utils/BlockInstanceRunner.ts

@@ -5,22 +5,24 @@
 
 import FSExtra from 'fs-extra';
 import ClusterConfig, { DefinitionInfo } from '@kapeta/local-cluster-config';
-import { getBindHost, getBlockInstanceContainerName, readYML } from './utils';
+import { getBindHost, getBlockInstanceContainerName, readYML, toPortInfo } from './utils';
 import { KapetaURI, parseKapetaUri, normalizeKapetaUri } from '@kapeta/nodejs-utils';
 import { DEFAULT_PORT_TYPE, HTTP_PORT_TYPE, HTTP_PORTS, serviceManager } from '../serviceManager';
 import {
     COMPOSE_LABEL_PROJECT,
     COMPOSE_LABEL_SERVICE,
+    CONTAINER_LABEL_PORT_PREFIX,
     containerManager,
     DockerMounts,
     toLocalBindVolume,
 } from '../containerManager';
 import { LogData } from './LogData';
 import { clusterService } from '../clusterService';
-import { AnyMap, BlockProcessParams, InstanceType, ProcessInfo, StringMap } from '../types';
+import { AnyMap, BlockProcessParams, InstanceType, LocalImageOptions, ProcessInfo, StringMap } from '../types';
 import { definitionsManager } from '../definitionsManager';
 import Docker from 'dockerode';
 import OS from 'node:os';
+import { taskManager } from '../taskManager';
 
 const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
@@ -200,7 +202,7 @@ export class BlockInstanceRunner {
             throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
         }
 
-        const containerName = getBlockInstanceContainerName(this._systemId, blockInstance.id);
+        const containerName = await getBlockInstanceContainerName(this._systemId, blockInstance.id, targetKindUri.id);
         const startCmd = localContainer.handlers?.onCreate ? localContainer.handlers.onCreate : '';
         const dockerOpts = localContainer.options ?? {};
         const homeDir = localContainer.userHome ? localContainer.userHome : '/root';
@@ -321,7 +323,7 @@ export class BlockInstanceRunner {
             providerVersion
         );
 
-        const containerName = getBlockInstanceContainerName(this._systemId, blockInstance.id);
+        const containerName = await getBlockInstanceContainerName(this._systemId, blockInstance.id, kindUri.id);
 
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
@@ -351,16 +353,7 @@ export class BlockInstanceRunner {
         });
     }
 
-    /**
-     *
-     * @param blockInstance
-     * @param blockUri
-     * @param providerDefinition
-     * @param {{[key:string]:string}} env
-     * @return {Promise<ProcessDetails>}
-     * @private
-     */
-    async _startOperatorProcess(
+    private async _startOperatorProcess(
         blockInstance: BlockProcessParams,
         blockUri: KapetaURI,
         providerDefinition: DefinitionInfo,
@@ -384,90 +377,124 @@ export class BlockInstanceRunner {
             throw new Error(`Provider did not have local image: ${providerRef}`);
         }
 
-        const dockerImage = spec?.local?.image;
-
-        //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: AnyMap = {};
-        const addonEnv: StringMap = {};
-        const PortBindings: AnyMap = {};
-        let HealthCheck = undefined;
-        let Mounts: DockerMounts[] = [];
-        const localPorts = spec.local.ports as { [p: string]: { port: string; type: string } };
-        const promises = Object.entries(localPorts).map(async ([portType, value]) => {
-            const dockerPort = `${value.port}/${value.type}`;
-            ExposedPorts[dockerPort] = {};
-            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = value.port;
-            const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
-            PortBindings[dockerPort] = [
-                {
-                    HostIp: bindHost,
-                    HostPort: `${publicPort}`,
-                },
-            ];
-        });
-
-        await Promise.all(promises);
-
-        if (spec.local?.env) {
-            Object.entries(spec.local.env).forEach(([key, value]) => {
-                addonEnv[key] = value as string;
-            });
-        }
+        const local = spec.local as LocalImageOptions;
 
-        if (spec.local?.mounts) {
-            const mounts = await containerManager.createMounts(this._systemId, blockUri.id, spec.local.mounts);
-            Mounts = containerManager.toDockerMounts(mounts);
-        }
+        const dockerImage = local.image;
+        const operatorUri = local.singleton ? parseKapetaUri(providerRef) : blockUri;
+        const operatorId = local.singleton ? providerRef : blockInstance.id;
+        const operatorRef = local.singleton ? providerRef : blockInstance.ref;
 
-        if (spec.local?.health) {
-            HealthCheck = containerManager.toDockerHealth(spec.local?.health);
+        if (local.singleton && env) {
+            env[KAPETA_BLOCK_REF] = operatorRef;
+            env[KAPETA_INSTANCE_ID] = operatorId;
         }
 
-        // For windows we need to default to root
-        const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
-
-        const systemUri = parseKapetaUri(this._systemId);
-        logs.addLog(`Creating new container for block: ${containerName}`);
-        const out = await this.ensureContainer({
-            Image: dockerImage,
-            name: containerName,
-            ExposedPorts,
-            HealthCheck,
-            HostConfig: {
-                Binds: [
-                    `${toLocalBindVolume(kapetaYmlPath)}:/kapeta.yml:ro`,
-                    `${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`,
-                ],
-                PortBindings,
-                Mounts,
-            },
-            Labels: {
-                instance: blockInstance.id,
-                [COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
-                [COMPOSE_LABEL_SERVICE]: blockUri.id.replace(/[^a-z0-9]/gi, '_'),
+        const containerName = await getBlockInstanceContainerName(this._systemId, blockInstance.id, providerRef);
+
+        const task = taskManager.add(
+            `container:start:${containerName}`,
+            async () => {
+                const logs = new LogData();
+
+                const bindHost = getBindHost();
+
+                const ExposedPorts: AnyMap = {};
+                const addonEnv: StringMap = {};
+                const PortBindings: AnyMap = {};
+                let HealthCheck = undefined;
+                let Mounts: DockerMounts[] = [];
+                const localPorts = local.ports ?? {};
+                const labels: { [key: string]: string } = {};
+                const promises = Object.entries(localPorts).map(async ([portType, value]) => {
+                    const portInfo = toPortInfo(value);
+                    const dockerPort = `${portInfo.port}/${portInfo.type}`;
+                    ExposedPorts[dockerPort] = {};
+                    addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = `${portInfo.port}`;
+                    const publicPort = await serviceManager.ensureServicePort(this._systemId, operatorId, portType);
+                    PortBindings[dockerPort] = [
+                        {
+                            HostIp: bindHost,
+                            HostPort: `${publicPort}`,
+                        },
+                    ];
+
+                    labels[CONTAINER_LABEL_PORT_PREFIX + publicPort] = portType;
+                });
+
+                await Promise.all(promises);
+
+                if (local.env) {
+                    Object.entries(local.env).forEach(([key, value]) => {
+                        addonEnv[key] = value as string;
+                    });
+                }
+
+                if (local.mounts) {
+                    Mounts = await containerManager.createVolumes(this._systemId, operatorUri.id, local.mounts);
+                }
+
+                if (local.health) {
+                    HealthCheck = containerManager.toDockerHealth(local.health);
+                }
+
+                // For windows we need to default to root
+                const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
+
+                const Binds = local.singleton
+                    ? [`${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`]
+                    : [
+                          `${toLocalBindVolume(kapetaYmlPath)}:/kapeta.yml:ro`,
+                          `${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`,
+                      ];
+
+                const systemUri = parseKapetaUri(this._systemId);
+
+                console.log(
+                    `Ensuring container for operator block: ${containerName} [singleton: ${!!local.singleton}]`
+                );
+
+                logs.addLog(`Ensuring container for operator block: ${containerName}`);
+                const out = await this.ensureContainer({
+                    Image: dockerImage,
+                    name: containerName,
+                    ExposedPorts,
+                    HealthCheck,
+                    HostConfig: {
+                        Binds,
+                        PortBindings,
+                        Mounts,
+                    },
+                    Labels: {
+                        ...labels,
+                        instance: operatorId,
+                        [COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
+                        [COMPOSE_LABEL_SERVICE]: operatorUri.id.replace(/[^a-z0-9]/gi, '_'),
+                    },
+                    Env: [
+                        `KAPETA_INSTANCE_NAME=${operatorRef}`,
+                        `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
+                        ...DOCKER_ENV_VARS,
+                        ...Object.entries({
+                            ...env,
+                            ...addonEnv,
+                        }).map(([key, value]) => `${key}=${value}`),
+                    ],
+                });
+
+                const portTypes = local.ports ? Object.keys(local.ports) : [];
+                if (portTypes.length > 0) {
+                    out.portType = portTypes[0];
+                }
+
+                return out;
             },
-            Env: [
-                `KAPETA_INSTANCE_NAME=${blockInstance.ref}`,
-                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
-                ...DOCKER_ENV_VARS,
-                ...Object.entries({
-                    ...env,
-                    ...addonEnv,
-                }).map(([key, value]) => `${key}=${value}`),
-            ],
-        });
-
-        const portTypes = spec.local.ports ? Object.keys(spec.local.ports) : [];
-        if (portTypes.length > 0) {
-            out.portType = portTypes[0];
-        }
+            {
+                name: `Starting container for ${providerRef}`,
+                systemId: this._systemId,
+            }
+        );
 
-        return out;
+        return task.wait();
     }
 
     private async getDockerPortBindings(

package/src/utils/utils.ts

@@ -5,17 +5,54 @@
 
 import FS from 'node:fs';
 import YAML from 'yaml';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import md5 from 'md5';
 import { EntityList } from '@kapeta/schemas';
 import _ from 'lodash';
-import { AnyMap } from '../types';
+import { AnyMap, PortInfo } from '../types';
 import ClusterConfiguration from '@kapeta/local-cluster-config';
+import { definitionsManager } from '../definitionsManager';
+import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import { KIND_BLOCK_OPERATOR } from '../operatorManager';
+import { assetManager } from '../assetManager';
+
+export async function getBlockInstanceContainerName(systemId: string, instanceId: string, blockType?: string) {
+    if (!blockType) {
+        const instance = await assetManager.getBlockInstance(systemId, instanceId);
+        if (!instance) {
+            throw new Error(`Instance ${instanceId} not found in plan ${systemId}`);
+        }
+        const block = await assetManager.getAsset(instance.block.ref);
+        if (!block) {
+            throw new Error(`Block ${instance.block.ref} not found`);
+        }
+        blockType = block.data.kind;
+    }
+    const typeDefinition = await definitionsManager.getDefinition(blockType);
+    if (!typeDefinition) {
+        throw new Error(`Block type ${blockType} not found`);
+    }
+    if (
+        parseKapetaUri(typeDefinition.definition.kind).fullName === KIND_BLOCK_OPERATOR &&
+        typeDefinition.definition.spec?.local?.singleton
+    ) {
+        return `kapeta-instance-operator-${md5(systemId + blockType)}`;
+    }
 
-export function getBlockInstanceContainerName(systemId: string, instanceId: string) {
     return `kapeta-block-instance-${md5(systemId + instanceId)}`;
 }
 
+export function toPortInfo(port: PortInfo) {
+    if (typeof port === 'number' || typeof port === 'string') {
+        return { port: parseInt(`${port}`), type: 'tcp' };
+    }
+
+    if (!port.type) {
+        port.type = 'tcp';
+    }
+
+    return port;
+}
+
 export function getRemoteUrl(id: string, defautValue: string) {
     const remoteConfig = ClusterConfiguration.getClusterConfig().remote;
     return remoteConfig?.[id] ?? defautValue;