@kapeta/local-cluster-service 0.35.0 → 0.36.1

package/src/utils/BlockInstanceRunner.ts

@@ -22,6 +22,7 @@ import { AnyMap, BlockProcessParams, InstanceType, LocalImageOptions, ProcessInf
 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';
@@ -47,17 +48,24 @@ async function getProvider(uri: KapetaURI) {
 }
 
 export function resolvePortType(portType: string) {
-    if (HTTP_PORTS.includes(portType)) {
+    if (portType && HTTP_PORTS.includes(portType.toLowerCase())) {
         return HTTP_PORT_TYPE;
     }
     return portType;
 }
 
-function getProviderPorts(assetVersion: DefinitionInfo, providerVersion: DefinitionInfo): string[] {
+/**
+ * Get the port types for a non-operator block instance
+ */
+function getServiceProviderPorts(assetVersion: DefinitionInfo, providerVersion: DefinitionInfo): string[] {
     const out =
         assetVersion.definition?.spec?.providers
+            ?.filter((provider: any) => {
+                // We only support HTTP provider ports for now. Need to figure out how to handle other types
+                return HTTP_PORTS.includes(provider.spec?.port?.type?.toLowerCase());
+            })
             ?.map((provider: any) => {
-                return resolvePortType(provider.spec?.port?.type);
+                return resolvePortType(provider.spec?.port?.type?.toLowerCase());
             })
             .filter((t: any) => !!t) ?? [];
 
@@ -136,7 +144,7 @@ export class BlockInstanceRunner {
             processInfo = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, env);
         } else {
             //We need a port type to know how to connect to the block consistently
-            const portTypes = getProviderPorts(assetVersion, providerVersion);
+            const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
 
             if (blockUri.version === 'local') {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
@@ -201,7 +209,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';
@@ -216,7 +224,7 @@ export class BlockInstanceRunner {
         delete localContainer.Labels;
         delete localContainer.Env;
 
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(
             blockInstance,
             assetVersion,
             providerVersion
@@ -316,13 +324,13 @@ export class BlockInstanceRunner {
             throw new Error(`Block type not found: ${kindUri.id}`);
         }
 
-        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getServiceBlockPortBindings(
             blockInstance,
             assetVersion,
             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();
@@ -352,16 +360,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,
@@ -388,96 +387,127 @@ export class BlockInstanceRunner {
         const local = spec.local as LocalImageOptions;
 
         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;
 
-        //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 = 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, blockInstance.id, 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, blockUri.id, local.mounts);
+        if (local.singleton && env) {
+            env[KAPETA_BLOCK_REF] = operatorRef;
+            env[KAPETA_INSTANCE_ID] = operatorId;
         }
 
-        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 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: {
-                ...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 = local.ports ? Object.keys(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(
+    /**
+     * Get the port bindings for a non-operator block
+     */
+    private async getServiceBlockPortBindings(
         blockInstance: BlockProcessParams,
         assetVersion: DefinitionInfo,
         providerVersion: DefinitionInfo
@@ -487,7 +517,7 @@ export class BlockInstanceRunner {
         const addonEnv: StringMap = {};
         const PortBindings: AnyMap = {};
 
-        const portTypes = getProviderPorts(assetVersion, providerVersion);
+        const portTypes = getServiceProviderPorts(assetVersion, providerVersion);
         let port = 80;
         const promises = portTypes.map(async (portType) => {
             const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);

package/src/utils/utils.ts

@@ -10,9 +10,35 @@ import { EntityList } from '@kapeta/schemas';
 import _ from 'lodash';
 import { AnyMap, PortInfo } from '../types';
 import ClusterConfiguration from '@kapeta/local-cluster-config';
+import { definitionsManager } from '../definitionsManager';
+import { normalizeKapetaUri, 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(normalizeKapetaUri(systemId) + normalizeKapetaUri(blockType))}`;
+    }
 
-export function getBlockInstanceContainerName(systemId: string, instanceId: string) {
-    return `kapeta-block-instance-${md5(systemId + instanceId)}`;
+    return `kapeta-block-instance-${md5(normalizeKapetaUri(systemId) + instanceId)}`;
 }
 
 export function toPortInfo(port: PortInfo) {