@kapeta/local-cluster-service 0.9.1 → 0.10.1

package/dist/esm/src/operatorManager.js

@@ -3,10 +3,11 @@ import md5 from 'md5';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { serviceManager } from './serviceManager';
 import { storageService } from './storageService';
-import { containerManager } from './containerManager';
+import { CONTAINER_LABEL_PORT_PREFIX, ContainerInfo, containerManager } from './containerManager';
 import FSExtra from 'fs-extra';
 import { definitionsManager } from './definitionsManager';
-import { normalizeKapetaUri } from './utils/utils';
+import { getBindHost, normalizeKapetaUri } from './utils/utils';
+import _ from 'lodash';
 const KIND_OPERATOR = 'core/resource-type-operator';
 class Operator {
     _data;
@@ -132,32 +133,46 @@ class OperatorManager {
         }
         const mounts = containerManager.createMounts(resourceType, operatorData.mounts);
         const containerName = containerBaseName + '-' + md5(nameParts.join('_'));
-        let container = await containerManager.get(containerName);
-        const isRunning = container ? await container.isRunning() : false;
-        if (container && !isRunning) {
-            await container.start();
-        }
-        if (!container) {
-            container = await containerManager.run(operatorData.image, containerName, {
-                mounts,
-                ports,
-                health: operatorData.health,
-                env: operatorData.env,
-                cmd: operatorData.cmd,
-            });
-        }
-        try {
-            if (operatorData.health) {
-                await containerManager.waitForHealthy(container.native);
-            }
-            else {
-                await containerManager.waitForReady(container.native);
-            }
-        }
-        catch (e) {
-            console.error(e.message);
+        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,
+                },
+            ];
+            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);
         }
-        return 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);
     }
 }
 export const operatorManager = new OperatorManager();

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

@@ -14,7 +14,6 @@ export declare class BlockInstanceRunner {
      * Starts local process
      */
     private _startLocalProcess;
-    private _handleContainer;
     private _startDockerProcess;
     /**
      *
@@ -26,4 +25,7 @@ export declare class BlockInstanceRunner {
      * @private
      */
     _startOperatorProcess(blockInstance: BlockProcessParams, blockUri: KapetaURI, providerDefinition: DefinitionInfo, env: StringMap): Promise<ProcessInfo>;
+    private getDockerPortBindings;
+    private ensureContainer;
+    private _handleContainer;
 }

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

@@ -94,7 +94,7 @@ export class BlockInstanceRunner {
                 processInfo = await this._startLocalProcess(blockInstance, blockUri, env, assetVersion);
             }
             else {
-                processInfo = await this._startDockerProcess(blockInstance, blockUri, env);
+                processInfo = await this._startDockerProcess(blockInstance, blockUri, env, assetVersion);
             }
             if (portTypes.length > 0) {
                 processInfo.portType = portTypes[0];
@@ -128,57 +128,16 @@ export class BlockInstanceRunner {
             throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
         }
         const containerName = getBlockInstanceContainerName(blockInstance.id);
-        const logs = new LogData();
-        logs.addLog(`Starting block ${blockInstance.ref}`);
-        let containerInfo = await containerManager.getContainerByName(containerName);
-        let container = containerInfo?.native;
-        console.log('Starting dev container', containerName);
-        if (containerInfo) {
-            console.log(`Dev container already exists. Deleting...`);
-            try {
-                await containerInfo.remove({
-                    force: true,
-                });
-            }
-            catch (e) {
-                throw new Error('Failed to delete existing container: ' + e.message);
-            }
-            container = undefined;
-            containerInfo = undefined;
-        }
-        logs.addLog(`Creating new container for block: ${containerName}`);
-        console.log('Creating new dev container', containerName, dockerImage);
-        await containerManager.pull(dockerImage);
         const startCmd = localContainer.handlers?.onCreate ? localContainer.handlers.onCreate : '';
         const dockerOpts = localContainer.options ?? {};
         const homeDir = localContainer.userHome ? localContainer.userHome : '/root';
         const workingDir = localContainer.workingDir ? localContainer.workingDir : '/workspace';
-        const bindHost = getBindHost();
-        const ExposedPorts = {};
-        const addonEnv = {};
-        const PortBindings = {};
-        const portTypes = getProviderPorts(assetVersion);
-        let port = 80;
-        const promises = portTypes.map(async (portType) => {
-            const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
-            const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
-            const dockerPort = `${thisPort}/tcp`;
-            ExposedPorts[dockerPort] = {};
-            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
-            PortBindings[dockerPort] = [
-                {
-                    HostIp: bindHost,
-                    HostPort: `${publicPort}`,
-                },
-            ];
-        });
-        await Promise.all(promises);
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
         let HealthCheck = undefined;
         if (localContainer.healthcheck) {
             HealthCheck = containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
-        console.log('Starting dev container', containerName, dockerImage);
-        container = await containerManager.startContainer({
+        return this.ensureContainer({
             Image: dockerImage,
             name: containerName,
             WorkingDir: workingDir,
@@ -205,8 +164,163 @@ export class BlockInstanceRunner {
             },
             ...dockerOpts,
         });
+    }
+    async _startDockerProcess(blockInstance, blockInfo, env, assetVersion) {
+        const { versionFile } = ClusterConfig.getRepositoryAssetInfoPath(blockInfo.handle, blockInfo.name, blockInfo.version);
+        const versionYml = versionFile;
+        if (!FS.existsSync(versionYml)) {
+            throw new Error(`Did not find version info at the expected path: ${versionYml}`);
+        }
+        const versionInfo = readYML(versionYml);
+        if (versionInfo?.artifact?.type !== 'docker') {
+            throw new Error(`Unsupported artifact type: ${versionInfo?.artifact?.type}`);
+        }
+        const dockerImage = versionInfo?.artifact?.details?.primary;
+        if (!dockerImage) {
+            throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
+        }
+        const { PortBindings, ExposedPorts, addonEnv } = await this.getDockerPortBindings(blockInstance, assetVersion);
+        const containerName = getBlockInstanceContainerName(blockInstance.id);
+        // For windows we need to default to root
+        const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
+        return this.ensureContainer({
+            Image: dockerImage,
+            name: containerName,
+            ExposedPorts,
+            Labels: {
+                instance: blockInstance.id,
+            },
+            Env: [
+                ...DOCKER_ENV_VARS,
+                `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
+                ...Object.entries({
+                    ...env,
+                    ...addonEnv
+                }).map(([key, value]) => `${key}=${value}`),
+            ],
+            HostConfig: {
+                Binds: [`${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`],
+                PortBindings,
+            },
+        });
+    }
+    /**
+     *
+     * @param blockInstance
+     * @param blockUri
+     * @param providerDefinition
+     * @param {{[key:string]:string}} env
+     * @return {Promise<ProcessDetails>}
+     * @private
+     */
+    async _startOperatorProcess(blockInstance, blockUri, providerDefinition, env) {
+        const { assetFile } = ClusterConfig.getRepositoryAssetInfoPath(blockUri.handle, blockUri.name, blockUri.version);
+        const kapetaYmlPath = assetFile;
+        if (!FS.existsSync(kapetaYmlPath)) {
+            throw new Error(`Did not find kapeta.yml at the expected path: ${kapetaYmlPath}`);
+        }
+        const spec = providerDefinition.definition.spec;
+        const providerRef = `${providerDefinition.definition.metadata.name}:${providerDefinition.version}`;
+        if (!spec?.local?.image) {
+            throw new Error(`Provider did not have local image: ${providerRef}`);
+        }
+        const dockerImage = spec?.local?.image;
+        const containerName = getBlockInstanceContainerName(blockInstance.id);
+        const logs = new LogData();
+        const bindHost = getBindHost();
+        const ExposedPorts = {};
+        const addonEnv = {};
+        const PortBindings = {};
+        let HealthCheck = undefined;
+        let Mounts = [];
+        const promises = Object.entries(spec.local.ports).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;
+            });
+        }
+        if (spec.local?.mounts) {
+            const mounts = containerManager.createMounts(blockUri.id, spec.local.mounts);
+            Mounts = containerManager.toDockerMounts(mounts);
+        }
+        if (spec.local?.health) {
+            HealthCheck = containerManager.toDockerHealth(spec.local?.health);
+        }
+        // For windows we need to default to root
+        const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
+        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,
+            },
+            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];
+        }
+        return out;
+    }
+    async getDockerPortBindings(blockInstance, assetVersion) {
+        const bindHost = getBindHost();
+        const ExposedPorts = {};
+        const addonEnv = {};
+        const PortBindings = {};
+        const portTypes = getProviderPorts(assetVersion);
+        let port = 80;
+        const promises = portTypes.map(async (portType) => {
+            const publicPort = await serviceManager.ensureServicePort(this._systemId, blockInstance.id, portType);
+            const thisPort = port++; //TODO: Not sure how we should handle multiple ports or non-HTTP ports
+            const dockerPort = `${thisPort}/tcp`;
+            ExposedPorts[dockerPort] = {};
+            addonEnv[`KAPETA_LOCAL_SERVER_PORT_${portType.toUpperCase()}`] = '' + thisPort;
+            PortBindings[dockerPort] = [
+                {
+                    HostIp: bindHost,
+                    HostPort: `${publicPort}`,
+                },
+            ];
+        });
+        await Promise.all(promises);
+        return { PortBindings, ExposedPorts, addonEnv };
+    }
+    async ensureContainer(opts) {
+        const logs = new LogData();
+        const container = await containerManager.ensureContainer(opts);
         try {
-            if (HealthCheck) {
+            if (opts.HealthCheck) {
                 await containerManager.waitForHealthy(container);
             }
             else {
@@ -268,201 +382,4 @@ export class BlockInstanceRunner {
             },
         };
     }
-    async _startDockerProcess(blockInstance, blockInfo, env) {
-        const { versionFile } = ClusterConfig.getRepositoryAssetInfoPath(blockInfo.handle, blockInfo.name, blockInfo.version);
-        const versionYml = versionFile;
-        if (!FS.existsSync(versionYml)) {
-            throw new Error(`Did not find version info at the expected path: ${versionYml}`);
-        }
-        const versionInfo = readYML(versionYml);
-        if (versionInfo?.artifact?.type !== 'docker') {
-            throw new Error(`Unsupported artifact type: ${versionInfo?.artifact?.type}`);
-        }
-        const dockerImage = versionInfo?.artifact?.details?.primary;
-        if (!dockerImage) {
-            throw new Error(`Missing docker image information: ${JSON.stringify(versionInfo?.artifact?.details)}`);
-        }
-        const containerName = getBlockInstanceContainerName(blockInstance.id);
-        const logs = new LogData();
-        const containerInfo = await containerManager.getContainerByName(containerName);
-        let container = containerInfo?.native;
-        // For windows we need to default to root
-        const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
-        if (container) {
-            const containerData = container.data;
-            if (containerData.State === 'running') {
-                logs.addLog(`Found existing running container for block: ${containerName}`);
-            }
-            else {
-                logs.addLog(`Found existing container for block: ${containerName}. Starting now`);
-                await container.start();
-            }
-        }
-        else {
-            logs.addLog(`Creating new container for block: ${containerName}`);
-            container = await containerManager.startContainer({
-                Image: dockerImage,
-                name: containerName,
-                Labels: {
-                    instance: blockInstance.id,
-                },
-                Env: [
-                    ...DOCKER_ENV_VARS,
-                    `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
-                    ...Object.entries(env).map(([key, value]) => `${key}=${value}`),
-                ],
-                HostConfig: {
-                    Binds: [`${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`],
-                },
-            });
-            try {
-                await containerManager.waitForReady(container);
-            }
-            catch (e) {
-                logs.addLog(e.message, 'ERROR');
-            }
-        }
-        return this._handleContainer(container, logs);
-    }
-    /**
-     *
-     * @param blockInstance
-     * @param blockUri
-     * @param providerDefinition
-     * @param {{[key:string]:string}} env
-     * @return {Promise<ProcessDetails>}
-     * @private
-     */
-    async _startOperatorProcess(blockInstance, blockUri, providerDefinition, env) {
-        const { assetFile } = ClusterConfig.getRepositoryAssetInfoPath(blockUri.handle, blockUri.name, blockUri.version);
-        const kapetaYmlPath = assetFile;
-        if (!FS.existsSync(kapetaYmlPath)) {
-            throw new Error(`Did not find kapeta.yml at the expected path: ${kapetaYmlPath}`);
-        }
-        const spec = providerDefinition.definition.spec;
-        const providerRef = `${providerDefinition.definition.metadata.name}:${providerDefinition.version}`;
-        if (!spec?.local?.image) {
-            throw new Error(`Provider did not have local image: ${providerRef}`);
-        }
-        const dockerImage = spec?.local?.image;
-        try {
-            await containerManager.pull(dockerImage);
-        }
-        catch (e) {
-            console.warn('Failed to pull image. Continuing...', e);
-        }
-        const containerName = getBlockInstanceContainerName(blockInstance.id);
-        const logs = new LogData();
-        const containerInfo = await containerManager.getContainerByName(containerName);
-        let container = containerInfo?.native;
-        if (container) {
-            const containerData = container.data;
-            if (containerData.State === 'running') {
-                logs.addLog(`Found existing running container for block: ${containerName}`);
-            }
-            else {
-                if (containerData.State?.ExitCode > 0) {
-                    logs.addLog(`Container exited with code: ${containerData.State.ExitCode}. Deleting...`);
-                    try {
-                        await containerManager.remove(container);
-                    }
-                    catch (e) { }
-                    container = undefined;
-                }
-                else {
-                    logs.addLog(`Found existing container for block: ${containerName}. Starting now`);
-                    try {
-                        await container.start();
-                    }
-                    catch (e) {
-                        console.warn('Failed to start container. Deleting...', e);
-                        try {
-                            await containerManager.remove(container);
-                        }
-                        catch (e) { }
-                        container = undefined;
-                    }
-                }
-            }
-        }
-        const bindHost = getBindHost();
-        if (!container) {
-            const ExposedPorts = {};
-            const addonEnv = {};
-            const PortBindings = {};
-            let HealthCheck = undefined;
-            let Mounts = [];
-            const promises = Object.entries(spec.local.ports).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;
-                });
-            }
-            if (spec.local?.mounts) {
-                const mounts = containerManager.createMounts(blockUri.id, spec.local.mounts);
-                Mounts = containerManager.toDockerMounts(mounts);
-            }
-            if (spec.local?.health) {
-                HealthCheck = containerManager.toDockerHealth(spec.local?.health);
-            }
-            // For windows we need to default to root
-            const innerHome = process.platform === 'win32' ? '/root/.kapeta' : ClusterConfig.getKapetaBasedir();
-            logs.addLog(`Creating new container for block: ${containerName}`);
-            container = await containerManager.startContainer({
-                Image: dockerImage,
-                name: containerName,
-                ExposedPorts,
-                HealthCheck,
-                HostConfig: {
-                    Binds: [
-                        `${toLocalBindVolume(kapetaYmlPath)}:/kapeta.yml:ro`,
-                        `${toLocalBindVolume(ClusterConfig.getKapetaBasedir())}:${innerHome}`,
-                    ],
-                    PortBindings,
-                    Mounts,
-                },
-                Labels: {
-                    instance: blockInstance.id,
-                },
-                Env: [
-                    `KAPETA_INSTANCE_NAME=${blockInstance.ref}`,
-                    `KAPETA_LOCAL_CLUSTER_PORT=${clusterService.getClusterServicePort()}`,
-                    ...DOCKER_ENV_VARS,
-                    ...Object.entries({
-                        ...env,
-                        ...addonEnv,
-                    }).map(([key, value]) => `${key}=${value}`),
-                ],
-            });
-            try {
-                if (HealthCheck) {
-                    await containerManager.waitForHealthy(container);
-                }
-                else {
-                    await containerManager.waitForReady(container);
-                }
-            }
-            catch (e) {
-                logs.addLog(e.message, 'ERROR');
-            }
-        }
-        const out = await this._handleContainer(container, logs, true);
-        const portTypes = spec.local.ports ? Object.keys(spec.local.ports) : [];
-        if (portTypes.length > 0) {
-            out.portType = portTypes[0];
-        }
-        return out;
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.9.1",
+    "version": "0.10.1",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {