@kapeta/local-cluster-service 0.34.2 → 0.36.0

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

@@ -56,6 +56,31 @@ export type ProcessInfo = {
     pid?: number | string | null;
     portType?: string;
 };
+export interface Health {
+    cmd: string;
+    interval?: number;
+    timeout?: number;
+    retries?: number;
+}
+export type PortInfo = {
+    port: number;
+    type: 'tcp' | 'udp';
+} | number | string;
+export type LocalImageOptions<Credentials = AnyMap, Options = AnyMap> = {
+    image: string;
+    ports: {
+        [key: string]: PortInfo;
+    };
+    credentials?: Credentials;
+    options?: Options;
+    cmd?: string;
+    env?: AnyMap;
+    health?: Health;
+    singleton?: boolean;
+    mounts?: {
+        [key: string]: string;
+    };
+};
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;
@@ -73,6 +98,21 @@ export type InstanceInfo = {
     portType?: string;
 };
 export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response, info: ProxyRequestInfo) => void;
+export interface OperatorInstancePort {
+    protocol: string;
+    port: number;
+}
+export interface OperatorInstanceInfo {
+    hostname: string;
+    ports: {
+        [portType: string]: OperatorInstancePort;
+    };
+    path?: string;
+    query?: string;
+    hash?: string;
+    options?: AnyMap;
+    credentials?: AnyMap;
+}
 export interface OperatorInfo {
     host: string;
     port: string;

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

@@ -2,9 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { DefinitionInfo } from '@kapeta/local-cluster-config';
-import { KapetaURI } from '@kapeta/nodejs-utils';
-import { AnyMap, BlockProcessParams, ProcessInfo, StringMap } from '../types';
+import { AnyMap, ProcessInfo } from '../types';
 export declare function resolvePortType(portType: string): string;
 export declare class BlockInstanceRunner {
     private readonly _systemId;
@@ -20,16 +18,7 @@ export declare class BlockInstanceRunner {
      */
     private _startLocalProcess;
     private _startDockerProcess;
-    /**
-     *
-     * @param blockInstance
-     * @param blockUri
-     * @param providerDefinition
-     * @param {{[key:string]:string}} env
-     * @return {Promise<ProcessDetails>}
-     * @private
-     */
-    _startOperatorProcess(blockInstance: BlockProcessParams, blockUri: KapetaURI, providerDefinition: DefinitionInfo, env: StringMap): Promise<ProcessInfo>;
+    private _startOperatorProcess;
     private getDockerPortBindings;
     private ensureContainer;
     private _handleContainer;

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

@@ -19,6 +19,7 @@ const clusterService_1 = require("../clusterService");
 const types_1 = require("../types");
 const definitionsManager_1 = require("../definitionsManager");
 const node_os_1 = __importDefault(require("node:os"));
+const taskManager_1 = require("../taskManager");
 const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
@@ -155,7 +156,7 @@ class BlockInstanceRunner {
         if (!dockerImage) {
             throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
         }
-        const containerName = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
+        const containerName = await (0, utils_1.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';
@@ -241,7 +242,7 @@ class BlockInstanceRunner {
             throw new Error(`Block type not found: ${kindUri.id}`);
         }
         const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion, providerVersion);
-        const containerName = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, kindUri.id);
         // For windows we need to default to root
         const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
         const systemUri = (0, nodejs_utils_1.parseKapetaUri)(this._systemId);
@@ -268,15 +269,6 @@ class BlockInstanceRunner {
             },
         });
     }
-    /**
-     *
-     * @param blockInstance
-     * @param blockUri
-     * @param providerDefinition
-     * @param {{[key:string]:string}} env
-     * @return {Promise<ProcessDetails>}
-     * @private
-     */
     async _startOperatorProcess(blockInstance, blockUri, providerDefinition, env) {
         const { assetFile } = local_cluster_config_1.default.getRepositoryAssetInfoPath(blockUri.handle, blockUri.name, blockUri.version);
         const kapetaYmlPath = assetFile;
@@ -288,79 +280,99 @@ class BlockInstanceRunner {
         if (!spec?.local?.image) {
             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 = (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id);
-        const logs = new LogData_1.LogData();
-        const bindHost = (0, utils_1.getBindHost)();
-        const ExposedPorts = {};
-        const addonEnv = {};
-        const PortBindings = {};
-        let HealthCheck = undefined;
-        let Mounts = [];
-        const localPorts = spec.local.ports;
-        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_1.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;
-            });
-        }
-        if (spec.local?.mounts) {
-            const mounts = await containerManager_1.containerManager.createMounts(this._systemId, blockUri.id, spec.local.mounts);
-            Mounts = containerManager_1.containerManager.toDockerMounts(mounts);
-        }
-        if (spec.local?.health) {
-            HealthCheck = containerManager_1.containerManager.toDockerHealth(spec.local?.health);
+        const local = spec.local;
+        const dockerImage = local.image;
+        const operatorUri = local.singleton ? (0, nodejs_utils_1.parseKapetaUri)(providerRef) : blockUri;
+        const operatorId = local.singleton ? providerRef : blockInstance.id;
+        const operatorRef = local.singleton ? providerRef : blockInstance.ref;
+        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' : local_cluster_config_1.default.getKapetaBasedir();
-        const systemUri = (0, nodejs_utils_1.parseKapetaUri)(this._systemId);
-        logs.addLog(`Creating new container for block: ${containerName}`);
-        const out = await this.ensureContainer({
-            Image: dockerImage,
-            name: containerName,
-            ExposedPorts,
-            HealthCheck,
-            HostConfig: {
-                Binds: [
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, providerRef);
+        const task = taskManager_1.taskManager.add(`container:start:${containerName}`, async () => {
+            const logs = new LogData_1.LogData();
+            const bindHost = (0, utils_1.getBindHost)();
+            const ExposedPorts = {};
+            const addonEnv = {};
+            const PortBindings = {};
+            let HealthCheck = undefined;
+            let Mounts = [];
+            const localPorts = local.ports ?? {};
+            const labels = {};
+            const promises = Object.entries(localPorts).map(async ([portType, value]) => {
+                const portInfo = (0, utils_1.toPortInfo)(value);
+                const dockerPort = `${portInfo.port}/${portInfo.type}`;
+                ExposedPorts[dockerPort] = {};
+                addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = `${portInfo.port}`;
+                const publicPort = await serviceManager_1.serviceManager.ensureServicePort(this._systemId, operatorId, portType);
+                PortBindings[dockerPort] = [
+                    {
+                        HostIp: bindHost,
+                        HostPort: `${publicPort}`,
+                    },
+                ];
+                labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + publicPort] = portType;
+            });
+            await Promise.all(promises);
+            if (local.env) {
+                Object.entries(local.env).forEach(([key, value]) => {
+                    addonEnv[key] = value;
+                });
+            }
+            if (local.mounts) {
+                Mounts = await containerManager_1.containerManager.createVolumes(this._systemId, operatorUri.id, local.mounts);
+            }
+            if (local.health) {
+                HealthCheck = containerManager_1.containerManager.toDockerHealth(local.health);
+            }
+            // For windows we need to default to root
+            const innerHome = process.platform === 'win32' ? '/root/.kapeta' : local_cluster_config_1.default.getKapetaBasedir();
+            const Binds = local.singleton
+                ? [`${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${innerHome}`]
+                : [
                     `${(0, containerManager_1.toLocalBindVolume)(kapetaYmlPath)}:/kapeta.yml:ro`,
                     `${(0, containerManager_1.toLocalBindVolume)(local_cluster_config_1.default.getKapetaBasedir())}:${innerHome}`,
+                ];
+            const systemUri = (0, nodejs_utils_1.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,
+                    [containerManager_1.COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
+                    [containerManager_1.COMPOSE_LABEL_SERVICE]: operatorUri.id.replace(/[^a-z0-9]/gi, '_'),
+                },
+                Env: [
+                    `KAPETA_INSTANCE_NAME=${operatorRef}`,
+                    `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.clusterService.getClusterServicePort()}`,
+                    ...DOCKER_ENV_VARS,
+                    ...Object.entries({
+                        ...env,
+                        ...addonEnv,
+                    }).map(([key, value]) => `${key}=${value}`),
                 ],
-                PortBindings,
-                Mounts,
-            },
-            Labels: {
-                instance: blockInstance.id,
-                [containerManager_1.COMPOSE_LABEL_PROJECT]: systemUri.id.replace(/[^a-z0-9]/gi, '_'),
-                [containerManager_1.COMPOSE_LABEL_SERVICE]: blockUri.id.replace(/[^a-z0-9]/gi, '_'),
-            },
-            Env: [
-                `KAPETA_INSTANCE_NAME=${blockInstance.ref}`,
-                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService_1.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;
+        }, {
+            name: `Starting container for ${providerRef}`,
+            systemId: this._systemId,
         });
-        const portTypes = spec.local.ports ? Object.keys(spec.local.ports) : [];
-        if (portTypes.length > 0) {
-            out.portType = portTypes[0];
-        }
-        return out;
+        return task.wait();
     }
     async getDockerPortBindings(blockInstance, assetVersion, providerVersion) {
         const bindHost = (0, utils_1.getBindHost)();

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

@@ -3,8 +3,12 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 import { EntityList } from '@kapeta/schemas';
-import { AnyMap } from '../types';
-export declare function getBlockInstanceContainerName(systemId: string, instanceId: string): string;
+import { AnyMap, PortInfo } from '../types';
+export declare function getBlockInstanceContainerName(systemId: string, instanceId: string, blockType?: string): Promise<string>;
+export declare function toPortInfo(port: PortInfo): {
+    port: number;
+    type: string;
+};
 export declare function getRemoteUrl(id: string, defautValue: string): any;
 export declare function readYML(path: string): any;
 export declare function isWindows(): boolean;

package/dist/cjs/src/utils/utils.js

@@ -7,16 +7,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getResolvedConfiguration = exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = exports.getBlockInstanceContainerName = void 0;
+exports.getResolvedConfiguration = exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = exports.toPortInfo = exports.getBlockInstanceContainerName = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const yaml_1 = __importDefault(require("yaml"));
 const md5_1 = __importDefault(require("md5"));
 const lodash_1 = __importDefault(require("lodash"));
 const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
-function getBlockInstanceContainerName(systemId, instanceId) {
+const definitionsManager_1 = require("../definitionsManager");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const operatorManager_1 = require("../operatorManager");
+const assetManager_1 = require("../assetManager");
+async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
+    if (!blockType) {
+        const instance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
+        if (!instance) {
+            throw new Error(`Instance ${instanceId} not found in plan ${systemId}`);
+        }
+        const block = await assetManager_1.assetManager.getAsset(instance.block.ref);
+        if (!block) {
+            throw new Error(`Block ${instance.block.ref} not found`);
+        }
+        blockType = block.data.kind;
+    }
+    const typeDefinition = await definitionsManager_1.definitionsManager.getDefinition(blockType);
+    if (!typeDefinition) {
+        throw new Error(`Block type ${blockType} not found`);
+    }
+    if ((0, nodejs_utils_1.parseKapetaUri)(typeDefinition.definition.kind).fullName === operatorManager_1.KIND_BLOCK_OPERATOR &&
+        typeDefinition.definition.spec?.local?.singleton) {
+        return `kapeta-instance-operator-${(0, md5_1.default)(systemId + blockType)}`;
+    }
     return `kapeta-block-instance-${(0, md5_1.default)(systemId + instanceId)}`;
 }
 exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
+function toPortInfo(port) {
+    if (typeof port === 'number' || typeof port === 'string') {
+        return { port: parseInt(`${port}`), type: 'tcp' };
+    }
+    if (!port.type) {
+        port.type = 'tcp';
+    }
+    return port;
+}
+exports.toPortInfo = toPortInfo;
 function getRemoteUrl(id, defautValue) {
     const remoteConfig = local_cluster_config_1.default.getClusterConfig().remote;
     return remoteConfig?.[id] ?? defautValue;

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

@@ -148,4 +148,13 @@ router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res)
 router.get('/consumes/:resourceName/:type', (req, res) => {
     res.send(serviceManager_1.serviceManager.getConsumerAddress(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceName, req.params.type, req.kapeta.environment));
 });
+/**
+ * Used by services to information about a block operator
+ *
+ * If the remote service is not already running it will be started
+ */
+router.get('/operator/:instanceId', async (req, res) => {
+    const operatorInfo = await instanceManager_1.instanceManager.getInstanceOperator(req.kapeta.systemId, req.params.instanceId, req.kapeta.environment);
+    res.send(operatorInfo);
+});
 exports.default = router;

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

@@ -5,7 +5,7 @@
 /// <reference types="node" />
 import FSExtra from 'fs-extra';
 import Docker from 'dockerode';
-import { InstanceInfo, LogEntry } from './types';
+import { Health, InstanceInfo, LogEntry } from './types';
 type StringMap = {
     [key: string]: string;
 };
@@ -26,12 +26,6 @@ export interface DockerMounts {
 }
 export type DockerContainerStatus = 'created' | 'running' | 'paused' | 'restarting' | 'removing' | 'exited' | 'dead';
 export type DockerContainerHealth = 'starting' | 'healthy' | 'unhealthy' | 'none';
-interface Health {
-    cmd: string;
-    interval?: number;
-    timeout?: number;
-    retries?: number;
-}
 export declare const CONTAINER_LABEL_PORT_PREFIX = "kapeta_port-";
 export declare const COMPOSE_LABEL_PROJECT = "com.docker.compose.project";
 export declare const COMPOSE_LABEL_SERVICE = "com.docker.compose.service";
@@ -50,7 +44,7 @@ declare class ContainerManager {
     isAlive(): boolean;
     getMountPoint(systemId: string, ref: string, mountName: string): string;
     createMounts(systemId: string, kind: string, mountOpts: StringMap | null | undefined): Promise<StringMap>;
-    createVolumes(systemId: string, kind: string, mountOpts: StringMap | null | undefined): Promise<DockerMounts[]>;
+    createVolumes(systemId: string, serviceId: string, mountOpts: StringMap | null | undefined): Promise<DockerMounts[]>;
     ping(): Promise<void>;
     docker(): Docker;
     getContainerByName(containerName: string): Promise<ContainerInfo | undefined>;

package/dist/esm/src/containerManager.js

@@ -168,12 +168,12 @@ class ContainerManager {
         }
         return mounts;
     }
-    async createVolumes(systemId, kind, mountOpts) {
+    async createVolumes(systemId, serviceId, mountOpts) {
         const Mounts = [];
         if (mountOpts) {
             const mountOptList = Object.entries(mountOpts);
             for (const [mountName, containerPath] of mountOptList) {
-                const volumeName = `${systemId}_${kind}_${mountName}`.replace(/[^a-z0-9]/gi, '_');
+                const volumeName = `${systemId}_${serviceId}_${mountName}`.replace(/[^a-z0-9]/gi, '_');
                 Mounts.push({
                     Target: containerPath,
                     Source: volumeName,
@@ -182,7 +182,7 @@ class ContainerManager {
                     Consistency: 'consistent',
                     Labels: {
                         [exports.COMPOSE_LABEL_PROJECT]: systemId.replace(/[^a-z0-9]/gi, '_'),
-                        [exports.COMPOSE_LABEL_SERVICE]: kind.replace(/[^a-z0-9]/gi, '_'),
+                        [exports.COMPOSE_LABEL_SERVICE]: serviceId.replace(/[^a-z0-9]/gi, '_'),
                     },
                 });
             }
@@ -533,7 +533,7 @@ class ContainerManager {
         return new ContainerInfo(dockerContainer);
     }
     async getLogs(instance) {
-        const containerName = (0, utils_1.getBlockInstanceContainerName)(instance.systemId, instance.instanceId);
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(instance.systemId, instance.instanceId);
         const containerInfo = await this.getContainerByName(containerName);
         if (!containerInfo) {
             return [
@@ -548,7 +548,7 @@ class ContainerManager {
         return containerInfo.getLogs();
     }
     async stopLogListening(systemId, instanceId) {
-        const containerName = (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
         if (this.logStreams[containerName]) {
             if (this.logStreams[containerName]?.timer) {
                 clearTimeout(this.logStreams[containerName].timer);
@@ -566,7 +566,7 @@ class ContainerManager {
         }
     }
     async ensureLogListening(systemId, instanceId, handler) {
-        const containerName = (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
+        const containerName = await (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
         try {
             if (this.logStreams[containerName]?.stream) {
                 // Already listening - will shut itself down
@@ -791,7 +791,7 @@ class ContainerInfo {
             if (!name.startsWith(exports.CONTAINER_LABEL_PORT_PREFIX)) {
                 return;
             }
-            const hostPort = name.substr(exports.CONTAINER_LABEL_PORT_PREFIX.length);
+            const hostPort = name.substring(exports.CONTAINER_LABEL_PORT_PREFIX.length);
             portTypes[hostPort] = portType;
         });
         lodash_1.default.forEach(inspectResult.HostConfig.PortBindings, (portBindings, containerPortSpec) => {

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

@@ -2,7 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { InstanceInfo, LogEntry } from './types';
+import { EnvironmentType, InstanceInfo, LogEntry, OperatorInstanceInfo } from './types';
 import { Task } from './taskManager';
 export declare class InstanceManager {
     private _interval;
@@ -24,10 +24,11 @@ export declare class InstanceManager {
     private getHealthUrl;
     markAsStopped(systemId: string, instanceId: string): Promise<void>;
     startAllForPlan(systemId: string): Promise<Task<InstanceInfo[]>>;
+    stopAllForPlan(systemId: string): Task<void>;
+    getInstanceOperator(systemId: string, instanceId: string, environment?: EnvironmentType): Promise<OperatorInstanceInfo>;
     stop(systemId: string, instanceId: string): Promise<void>;
     private stopInner;
-    stopAllForPlan(systemId: string): Task<void>;
-    start(systemId: string, instanceId: string): Promise<InstanceInfo | Task<InstanceInfo>>;
+    start(systemId: string, instanceId: string, checkForSingleton?: boolean): Promise<InstanceInfo | Task<InstanceInfo>>;
     /**
      * Stops an instance but does not remove it from the list of active instances
      *
@@ -42,5 +43,9 @@ export declare class InstanceManager {
     private checkInstances;
     private getExternalStatus;
     private requestInstanceStatus;
+    private isSingletonOperator;
+    private getKindForAssetRef;
+    private isUsingKind;
+    private getAllInstancesForKind;
 }
 export declare const instanceManager: InstanceManager;