@kapeta/local-cluster-service 0.9.1 → 0.10.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.10.1](https://github.com/kapetacom/local-cluster-service/compare/v0.10.0...v0.10.1) (2023-07-27)
+
+
+### Bug Fixes
+
+* Include port bindings for non-local containers ([#51](https://github.com/kapetacom/local-cluster-service/issues/51)) ([64fd440](https://github.com/kapetacom/local-cluster-service/commit/64fd4409ea9e2dda8e2438d0ec85a8f5a2092b1e))
+
+# [0.10.0](https://github.com/kapetacom/local-cluster-service/compare/v0.9.1...v0.10.0) (2023-07-26)
+
+
+### Features
+
+* Auto-reuse containers ([#50](https://github.com/kapetacom/local-cluster-service/issues/50)) ([ecb396b](https://github.com/kapetacom/local-cluster-service/commit/ecb396b541f9184302e0681f4803d2404336138e))
+
 ## [0.9.1](https://github.com/kapetacom/local-cluster-service/compare/v0.9.0...v0.9.1) (2023-07-26)
 
 

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

@@ -41,6 +41,7 @@ interface Health {
     timeout?: number;
     retries?: number;
 }
+export declare const CONTAINER_LABEL_PORT_PREFIX = "kapeta_port-";
 export declare const HEALTH_CHECK_TIMEOUT: number;
 declare class ContainerManager {
     private _docker;
@@ -56,7 +57,7 @@ declare class ContainerManager {
     ping(): Promise<void>;
     docker(): Docker;
     getContainerByName(containerName: string): Promise<ContainerInfo | undefined>;
-    pull(image: string, cacheForMS?: number): Promise<void>;
+    pull(image: string, cacheForMS?: number): Promise<boolean>;
     toDockerMounts(mounts: StringMap): DockerMounts[];
     toDockerHealth(health: Health): {
         Test: string[];
@@ -64,13 +65,8 @@ declare class ContainerManager {
         Timeout: number;
         Retries: number;
     };
-    run(image: string, name: string, opts: {
-        ports: {};
-        mounts: {};
-        env: {};
-        cmd: string;
-        health: Health;
-    }): Promise<ContainerInfo>;
+    private applyHash;
+    ensureContainer(opts: any): Promise<Container>;
     startContainer(opts: any): Promise<Container>;
     waitForReady(container: Container, attempt?: number): Promise<void>;
     waitForHealthy(container: Container, attempt?: number): Promise<void>;

package/dist/cjs/src/containerManager.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.containerManager = exports.toLocalBindVolume = exports.getExtraHosts = exports.ContainerInfo = exports.HEALTH_CHECK_TIMEOUT = void 0;
+exports.containerManager = exports.toLocalBindVolume = exports.getExtraHosts = exports.ContainerInfo = exports.HEALTH_CHECK_TIMEOUT = exports.CONTAINER_LABEL_PORT_PREFIX = void 0;
 const path_1 = __importDefault(require("path"));
 const storageService_1 = require("./storageService");
 const os_1 = __importDefault(require("os"));
@@ -12,9 +12,9 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_docker_api_1 = require("node-docker-api");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
-const utils_1 = require("./utils/utils");
 const node_uuid_1 = __importDefault(require("node-uuid"));
-const LABEL_PORT_PREFIX = 'kapeta_port-';
+const md5_1 = __importDefault(require("md5"));
+exports.CONTAINER_LABEL_PORT_PREFIX = 'kapeta_port-';
 const NANO_SECOND = 1000000;
 const HEALTH_CHECK_INTERVAL = 3000;
 const HEALTH_CHECK_MAX = 20;
@@ -147,22 +147,19 @@ class ContainerManager {
         if (!tag) {
             tag = 'latest';
         }
-        if (tag !== 'latest') {
-            if (IMAGE_PULL_CACHE[image]) {
-                const timeSince = Date.now() - IMAGE_PULL_CACHE[image];
-                if (timeSince < cacheForMS) {
-                    return;
-                }
-            }
-            const imageTagList = (await this.docker().image.list())
-                .map((image) => image.data)
-                .filter((imageData) => !!imageData.RepoTags)
-                .map((imageData) => imageData.RepoTags);
-            if (imageTagList.some((imageTags) => imageTags.indexOf(image) > -1)) {
-                console.log('Image found: %s', image);
-                return;
+        if (IMAGE_PULL_CACHE[image]) {
+            const timeSince = Date.now() - IMAGE_PULL_CACHE[image];
+            if (timeSince < cacheForMS) {
+                return false;
             }
-            console.log('Image not found: %s', image);
+        }
+        const imageTagList = (await this.docker().image.list())
+            .map((image) => image.data)
+            .filter((imageData) => !!imageData.RepoTags)
+            .map((imageData) => imageData.RepoTags);
+        if (imageTagList.some((imageTags) => imageTags.indexOf(image) > -1)) {
+            console.log('Image found: %s', image);
+            return false;
         }
         console.log('Pulling image: %s', image);
         await this.docker()
@@ -173,6 +170,7 @@ class ContainerManager {
             .then((stream) => promisifyStream(stream));
         IMAGE_PULL_CACHE[image] = Date.now();
         console.log('Image pulled: %s', image);
+        return true;
     }
     toDockerMounts(mounts) {
         const Mounts = [];
@@ -195,51 +193,58 @@ class ContainerManager {
             Retries: health.retries || 10,
         };
     }
-    async run(image, name, opts) {
-        const PortBindings = {};
-        const Env = [];
-        const Labels = {
-            kapeta: 'true',
-        };
-        await this.pull(image);
-        const bindHost = (0, utils_1.getBindHost)();
-        const ExposedPorts = {};
-        lodash_1.default.forEach(opts.ports, (portInfo, containerPort) => {
-            ExposedPorts['' + containerPort] = {};
-            PortBindings['' + containerPort] = [
-                {
-                    HostPort: '' + portInfo.hostPort,
-                    HostIp: bindHost,
-                },
-            ];
-            Labels[LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
-        });
-        const Mounts = this.toDockerMounts(opts.mounts);
-        lodash_1.default.forEach(opts.env, (value, name) => {
-            Env.push(name + '=' + value);
-        });
-        let HealthCheck = undefined;
-        if (opts.health) {
-            HealthCheck = this.toDockerHealth(opts.health);
-        }
-        const dockerContainer = await this.startContainer({
-            name: name,
-            Image: image,
-            Hostname: name + '.kapeta',
-            Labels,
-            Cmd: opts.cmd,
-            ExposedPorts,
-            Env,
-            HealthCheck,
-            HostConfig: {
-                PortBindings,
-                Mounts,
-            },
-        });
-        if (opts.health) {
-            await this.waitForHealthy(dockerContainer);
+    applyHash(dockerOpts) {
+        if (dockerOpts?.Labels?.HASH) {
+            delete dockerOpts.Labels.HASH;
         }
-        return new ContainerInfo(dockerContainer);
+        const hash = (0, md5_1.default)(JSON.stringify(dockerOpts));
+        if (!dockerOpts.Labels) {
+            dockerOpts.Labels = {};
+        }
+        dockerOpts.Labels.HASH = hash;
+    }
+    async ensureContainer(opts) {
+        let imagePulled = false;
+        try {
+            imagePulled = await this.pull(opts.Image);
+        }
+        catch (e) {
+            console.warn('Failed to pull image. Continuing...', e);
+        }
+        this.applyHash(opts);
+        if (!opts.name) {
+            console.log('Starting unnamed container: %s', opts.Image);
+            return this.startContainer(opts);
+        }
+        const containerInfo = await this.getContainerByName(opts.name);
+        if (imagePulled) {
+            console.log('New version of image was pulled: %s', opts.Image);
+        }
+        else {
+            // If image was pulled always recreate
+            if (!containerInfo) {
+                console.log('Starting new container: %s', opts.name);
+                return this.startContainer(opts);
+            }
+            const containerData = containerInfo.native.data;
+            if (containerData?.Labels?.HASH === opts.Labels.HASH) {
+                if (!(await containerInfo.isRunning())) {
+                    console.log('Starting previously created container: %s', opts.name);
+                    await containerInfo.start();
+                }
+                else {
+                    console.log('Previously created container already running: %s', opts.name);
+                }
+                return containerInfo.native;
+            }
+        }
+        if (containerInfo) {
+            // Remove the container and start a new one
+            console.log('Replacing previously created container: %s', opts.name);
+            await containerInfo.remove({ force: true });
+        }
+        console.log('Starting new container: %s', opts.name);
+        return this.startContainer(opts);
     }
     async startContainer(opts) {
         const extraHosts = getExtraHosts(this._version);
@@ -417,10 +422,10 @@ class ContainerInfo {
         const portTypes = {};
         const ports = {};
         lodash_1.default.forEach(inspectResult.Config.Labels, (portType, name) => {
-            if (!name.startsWith(LABEL_PORT_PREFIX)) {
+            if (!name.startsWith(exports.CONTAINER_LABEL_PORT_PREFIX)) {
                 return;
             }
-            const hostPort = name.substr(LABEL_PORT_PREFIX.length);
+            const hostPort = name.substr(exports.CONTAINER_LABEL_PORT_PREFIX.length);
             portTypes[hostPort] = portType;
         });
         lodash_1.default.forEach(inspectResult.HostConfig.PortBindings, (portBindings, containerPortSpec) => {

package/dist/cjs/src/instanceManager.js

@@ -453,7 +453,8 @@ class InstanceManager {
                         changed = true;
                     }
                 }
-                if (instance.desiredStatus === types_1.DesiredInstanceStatus.RUN && newStatus === types_1.InstanceStatus.STOPPED) {
+                if (instance.desiredStatus === types_1.DesiredInstanceStatus.RUN &&
+                    [types_1.InstanceStatus.STOPPED, types_1.InstanceStatus.FAILED, types_1.InstanceStatus.STOPPING].includes(newStatus)) {
                     //If the instance is stopped but we want it to run, start it
                     try {
                         await this.start(instance.systemId, instance.instanceId);
@@ -463,7 +464,8 @@ class InstanceManager {
                     }
                     return;
                 }
-                if (instance.desiredStatus === types_1.DesiredInstanceStatus.STOP && newStatus === types_1.InstanceStatus.READY) {
+                if (instance.desiredStatus === types_1.DesiredInstanceStatus.STOP &&
+                    [types_1.InstanceStatus.READY, types_1.InstanceStatus.STARTING, types_1.InstanceStatus.UNHEALTHY].includes(newStatus)) {
                     //If the instance is running but we want it to stop, stop it
                     try {
                         await this.stop(instance.systemId, instance.instanceId);

package/dist/cjs/src/operatorManager.js

@@ -13,6 +13,7 @@ const containerManager_1 = require("./containerManager");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const definitionsManager_1 = require("./definitionsManager");
 const utils_1 = require("./utils/utils");
+const lodash_1 = __importDefault(require("lodash"));
 const KIND_OPERATOR = 'core/resource-type-operator';
 class Operator {
     _data;
@@ -138,32 +139,46 @@ class OperatorManager {
         }
         const mounts = containerManager_1.containerManager.createMounts(resourceType, operatorData.mounts);
         const containerName = containerBaseName + '-' + (0, md5_1.default)(nameParts.join('_'));
-        let container = await containerManager_1.containerManager.get(containerName);
-        const isRunning = container ? await container.isRunning() : false;
-        if (container && !isRunning) {
-            await container.start();
-        }
-        if (!container) {
-            container = await containerManager_1.containerManager.run(operatorData.image, containerName, {
-                mounts,
-                ports,
-                health: operatorData.health,
-                env: operatorData.env,
-                cmd: operatorData.cmd,
-            });
-        }
-        try {
-            if (operatorData.health) {
-                await containerManager_1.containerManager.waitForHealthy(container.native);
-            }
-            else {
-                await containerManager_1.containerManager.waitForReady(container.native);
-            }
-        }
-        catch (e) {
-            console.error(e.message);
+        const PortBindings = {};
+        const Env = [];
+        const Labels = {
+            kapeta: 'true',
+        };
+        const bindHost = (0, utils_1.getBindHost)();
+        const ExposedPorts = {};
+        lodash_1.default.forEach(ports, (portInfo, containerPort) => {
+            ExposedPorts['' + containerPort] = {};
+            PortBindings['' + containerPort] = [
+                {
+                    HostPort: '' + portInfo.hostPort,
+                    HostIp: bindHost,
+                },
+            ];
+            Labels[containerManager_1.CONTAINER_LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
+        });
+        const Mounts = containerManager_1.containerManager.toDockerMounts(mounts);
+        lodash_1.default.forEach(operatorData.env, (value, name) => {
+            Env.push(name + '=' + value);
+        });
+        let HealthCheck = undefined;
+        if (operatorData.health) {
+            HealthCheck = containerManager_1.containerManager.toDockerHealth(operatorData.health);
         }
-        return container;
+        const container = await containerManager_1.containerManager.ensureContainer({
+            name: containerName,
+            Image: operatorData.image,
+            Hostname: containerName + '.kapeta',
+            Labels,
+            Cmd: operatorData.cmd,
+            ExposedPorts,
+            Env,
+            HealthCheck,
+            HostConfig: {
+                PortBindings,
+                Mounts,
+            },
+        });
+        return new containerManager_1.ContainerInfo(container);
     }
 }
 exports.operatorManager = new OperatorManager();

package/dist/cjs/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;
 }