@kapeta/local-cluster-service 0.0.76 → 0.1.1

package/src/containerManager.js

@@ -1,8 +1,8 @@
-const { Docker } = require("node-docker-api");
-const _ = require("lodash");
-const os = require("os");
+const {Docker} = require("node-docker-api");
 const path = require("path");
-
+const _ = require('lodash');
+const FS = require("node:fs");
+const os = require("os");
 const LABEL_PORT_PREFIX = "kapeta_port-";
 
 const NANO_SECOND = 1000000;
@@ -10,301 +10,346 @@ const HEALTH_CHECK_INTERVAL = 1000;
 const HEALTH_CHECK_MAX = 20;
 
 const promisifyStream = (stream) =>
-  new Promise((resolve, reject) => {
-    stream.on("data", (d) => console.log(d.toString()));
-    stream.on("end", resolve);
-    stream.on("error", reject);
-  });
+    new Promise((resolve, reject) => {
+        stream.on("data", (d) => console.log(d.toString()));
+        stream.on("end", resolve);
+        stream.on("error", reject);
+    });
 
 class ContainerManager {
-  constructor() {
-    this._docker = new Docker();
-    this._alive = false;
-  }
-
-  async initialize() {
-    // try
-    const connectOptions = [
-      // use defaults: DOCKER_HOST etc from env, if available
-      undefined,
-      // default linux
-      { socketPath: "/var/run/docker.sock" },
-      // default macOS
-      { socketPath: path.join(os.homedir(), ".docker/run/docker.sock") },
-      // Default http
-      { protocol: "http", host: "localhost", port: 2375 },
-      { protocol: "https", host: "localhost", port: 2376 },
-    ];
-    for (const opts of connectOptions) {
-      try {
-        const client = new Docker(opts);
-        await client.ping();
-        this._docker = client;
-        return;
-      } catch (err) {
-        // silently ignore bad configs
-      }
+    constructor() {
+        this._docker = null;
+        this._alive = false;
     }
-    throw new Error("Unable to connect to docker");
-  }
-
-  async ping() {
-    await this._docker.ping();
-    this._alive = true;
-  }
-
-  async pull(image) {
-    let [imageName, tag] = image.split(/:/);
-    if (!tag) {
-      tag = "latest";
+
+    isAlive() {
+        return this._alive;
     }
 
-    await this._docker.image
-      .create(
-        {},
-        {
-          fromImage: imageName,
-          tag: tag,
+    async initialize() {
+        // try
+        const connectOptions = [
+            // use defaults: DOCKER_HOST etc from env, if available
+            undefined,
+            // default linux
+            {socketPath: "/var/run/docker.sock"},
+            // default macOS
+            {socketPath: path.join(os.homedir(), ".docker/run/docker.sock")},
+            // Default http
+            {protocol: "http", host: "localhost", port: 2375},
+            {protocol: "https", host: "localhost", port: 2376},
+        ];
+        for (const opts of connectOptions) {
+            try {
+                const client = new Docker(opts);
+                await client.ping();
+                this._docker = client;
+                return;
+            } catch (err) {
+                // silently ignore bad configs
+            }
         }
-      )
-      .then((stream) => promisifyStream(stream));
-  }
-
-  /**
-   *
-   * @param {string} image
-   * @param {string} name
-   * @param {{ports:{},mounts:{},env:{}}} opts
-   * @return {Promise<ContainerInfo>}
-   */
-  async run(image, name, opts) {
-    const Mounts = [];
-    const PortBindings = {};
-    const Env = [];
-    const Labels = {
-      kapeta: "true",
-    };
-
-    console.log("Pulling image: %s", image);
-
-    await this.pull(image);
-
-    console.log("Image pulled: %s", image);
-
-    _.forEach(opts.ports, (portInfo, containerPort) => {
-      PortBindings["" + containerPort] = [
-        {
-          HostPort: "" + portInfo.hostPort,
-        },
-      ];
-
-      Labels[LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
-    });
+        throw new Error("Unable to connect to docker");
+    }
 
-    _.forEach(opts.mounts, (Source, Target) => {
-      Mounts.push({
-        Target,
-        Source,
-        Type: "bind",
-        ReadOnly: false,
-        Consistency: "consistent",
-      });
-    });
+    async ping() {
+        await this._docker.ping();
+        this._alive = true;
+    }
 
-    _.forEach(opts.env, (value, name) => {
-      Env.push(name + "=" + value);
-    });
+    async ping() {
+
+        try {
+            const pingResult = await this._docker.ping();
+            if (pingResult !== 'OK') {
+                throw new Error(`Ping failed: ${pingResult}`);
+            }
+        } catch (e) {
+            throw new Error(`Docker not running. Please start the docker daemon before running this command. Error: ${e.message}`);
+        }
 
-    let HealthCheck = undefined;
-
-    if (opts.health) {
-      HealthCheck = {
-        Test: ["CMD-SHELL", opts.health.cmd],
-        Interval: opts.health.interval
-          ? opts.health.interval * NANO_SECOND
-          : 5000 * NANO_SECOND,
-        Timeout: opts.health.timeout
-          ? opts.health.timeout * NANO_SECOND
-          : 15000 * NANO_SECOND,
-        Retries: opts.health.retries || 10,
-      };
-
-      console.log("Adding health check", HealthCheck);
+        this._alive = true;
     }
 
-    const dockerContainer = await this._docker.container.create({
-      name: name,
-      Image: image,
-      Labels,
-      Env,
-      HealthCheck,
-      HostConfig: {
-        PortBindings,
-        Mounts,
-      },
-    });
+    async ensureAlive() {
+        if (!this._alive) {
+            await this.ping();
+        }
+    }
 
-    await dockerContainer.start();
+    async docker() {
+        await this.ensureAlive();
+        return this._docker;
+    }
 
-    if (opts.health) {
-      await this._waitForHealthy(dockerContainer);
+    async getContainerByName(containerName) {
+        const containers = await this._docker.container.list({all: true});
+        return containers.find(container => {
+            return container.data.Names.indexOf(`/${containerName}`) > -1;
+        });
     }
 
-    return new ContainerInfo(dockerContainer);
-  }
+    async pull(image) {
+        let [imageName, tag] = image.split(/:/);
+        if (!tag) {
+            tag = 'latest';
+        }
 
-  async _waitForHealthy(container, attempt) {
-    if (!attempt) {
-      attempt = 0;
+        await this._docker.image
+            .create(
+                {},
+                {
+                    fromImage: imageName,
+                    tag: tag,
+                }
+            )
+            .then((stream) => promisifyStream(stream));
     }
 
-    if (attempt >= HEALTH_CHECK_MAX) {
-      throw new Error("Operator did not become healthy within the timeout");
+    /**
+     *
+     * @param {string} image
+     * @param {string} name
+     * @param {{ports:{},mounts:{},env:{}}} opts
+     * @return {Promise<ContainerInfo>}
+     */
+    async run(image, name, opts) {
+        const Mounts = [];
+        const PortBindings = {};
+        const Env = [];
+        const Labels = {
+            kapeta: "true",
+        };
+
+        console.log("Pulling image: %s", image);
+
+        await this.pull(image);
+
+        console.log("Image pulled: %s", image);
+
+        _.forEach(opts.ports, (portInfo, containerPort) => {
+            PortBindings['' + containerPort] = [
+                {
+                    HostPort: '' + portInfo.hostPort,
+                    HostIp: '127.0.0.1'
+                }
+            ];
+
+            Labels[LABEL_PORT_PREFIX + portInfo.hostPort] = portInfo.type;
+        });
+
+        _.forEach(opts.mounts, (Source, Target) => {
+            Mounts.push({
+                Target,
+                Source,
+                Type: "bind",
+                ReadOnly: false,
+                Consistency: "consistent",
+            });
+        });
+
+        _.forEach(opts.env, (value, name) => {
+            Env.push(name + "=" + value);
+        });
+
+        let HealthCheck = undefined;
+
+        if (opts.health) {
+            HealthCheck = {
+                Test: ["CMD-SHELL", opts.health.cmd],
+                Interval: opts.health.interval
+                    ? opts.health.interval * NANO_SECOND
+                    : 5000 * NANO_SECOND,
+                Timeout: opts.health.timeout
+                    ? opts.health.timeout * NANO_SECOND
+                    : 15000 * NANO_SECOND,
+                Retries: opts.health.retries || 10,
+            };
+
+            console.log("Adding health check", HealthCheck);
+        }
+
+
+        const dockerContainer = await this.startContainer({
+            name: name,
+            Image: image,
+            Labels,
+            Env,
+            HealthCheck,
+            HostConfig: {
+                PortBindings,
+                Mounts
+            }
+        });
+
+        if (opts.health) {
+            await this._waitForHealthy(dockerContainer);
+        }
+
+        return new ContainerInfo(dockerContainer);
     }
 
-    if (await this._isHealthy(container)) {
-      console.log("Container became healthy");
-      return;
+    async startContainer(opts) {
+        const dockerContainer = await this._docker.container.create(opts);
+
+        await dockerContainer.start();
+
+        return dockerContainer;
     }
 
-    return new Promise((resolve) => {
-      setTimeout(async () => {
-        await this._waitForHealthy(container, attempt + 1);
-        resolve();
-      }, HEALTH_CHECK_INTERVAL);
-    });
-  }
-
-  async _isHealthy(container) {
-    const info = await container.status();
-
-    return info?.data?.State?.Health?.Status === "healthy";
-  }
-
-  /**
-   *
-   * @param name
-   * @return {Promise<ContainerInfo>}
-   */
-  async get(name) {
-    let dockerContainer = null;
-
-    try {
-      dockerContainer = await this._docker.container.get(name);
-      await dockerContainer.status();
-    } catch (err) {
-      //Ignore
-      console.log("Container not available - creating it: %s", name);
-      dockerContainer = null;
+
+    async _waitForHealthy(container, attempt) {
+        if (!attempt) {
+            attempt = 0;
+        }
+
+        if (attempt >= HEALTH_CHECK_MAX) {
+            throw new Error("Operator did not become healthy within the timeout");
+        }
+
+        if (await this._isHealthy(container)) {
+            console.log("Container became healthy");
+            return;
+        }
+
+        return new Promise((resolve) => {
+            setTimeout(async () => {
+                await this._waitForHealthy(container, attempt + 1);
+                resolve();
+            }, HEALTH_CHECK_INTERVAL);
+        });
     }
 
-    if (!dockerContainer) {
-      return null;
+    async _isHealthy(container) {
+        const info = await container.status();
+
+        return info?.data?.State?.Health?.Status === "healthy";
     }
 
-    return new ContainerInfo(dockerContainer);
-  }
+    /**
+     *
+     * @param name
+     * @return {Promise<ContainerInfo>}
+     */
+    async get(name) {
+        let dockerContainer = null;
+
+        try {
+            dockerContainer = await this._docker.container.get(name);
+            await dockerContainer.status();
+        } catch (err) {
+            //Ignore
+            console.log("Container not available - creating it: %s", name);
+            dockerContainer = null;
+        }
+
+        if (!dockerContainer) {
+            return null;
+        }
+
+        return new ContainerInfo(dockerContainer);
+    }
 }
 
 class ContainerInfo {
-  /**
-   *
-   * @param {Container} dockerContainer
-   */
-  constructor(dockerContainer) {
     /**
      *
-     * @type {Container}
-     * @private
+     * @param {Container} dockerContainer
      */
-    this._container = dockerContainer;
-  }
-
-  async isRunning() {
-    const inspectResult = await this.getStatus();
-
-    if (!inspectResult || !inspectResult.State) {
-      return false;
+    constructor(dockerContainer) {
+        /**
+         *
+         * @type {Container}
+         * @private
+         */
+        this._container = dockerContainer;
     }
 
-    return inspectResult.State.Running || inspectResult.State.Restarting;
-  }
+    async isRunning() {
+        const inspectResult = await this.getStatus();
 
-  async start() {
-    await this._container.start();
-  }
+        if (!inspectResult || !inspectResult.State) {
+            return false;
+        }
 
-  async restart() {
-    await this._container.restart();
-  }
+        return inspectResult.State.Running || inspectResult.State.Restarting;
+    }
 
-  async stop() {
-    await this._container.stop();
-  }
+    async start() {
+        await this._container.start();
+    }
 
-  async remove(opts) {
-    await this._container.delete({ force: !!opts.force });
-  }
+    async restart() {
+        await this._container.restart();
+    }
 
-  async getPort(type) {
-    const ports = await this.getPorts();
+    async stop() {
+        await this._container.stop();
+    }
 
-    if (ports[type]) {
-      return ports[type];
+    async remove(opts) {
+        await this._container.delete({force: !!opts.force});
     }
 
-    return null;
-  }
+    async getPort(type) {
+        const ports = await this.getPorts();
 
-  async getStatus() {
-    const result = await this._container.status();
+        if (ports[type]) {
+            return ports[type];
+        }
 
-    return result ? result.data : null;
-  }
+        return null;
+    }
 
-  async getPorts() {
-    const inspectResult = await this.getStatus();
+    async getStatus() {
+        const result = await this._container.status();
 
-    if (
-      !inspectResult ||
-      !inspectResult.Config ||
-      !inspectResult.Config.Labels
-    ) {
-      return false;
+        return result ? result.data : null;
     }
 
-    const portTypes = {};
-    const ports = {};
+    async getPorts() {
+        const inspectResult = await this.getStatus();
 
-    _.forEach(inspectResult.Config.Labels, (portType, name) => {
-      if (!name.startsWith(LABEL_PORT_PREFIX)) {
-        return;
-      }
+        if (
+            !inspectResult ||
+            !inspectResult.Config ||
+            !inspectResult.Config.Labels
+        ) {
+            return false;
+        }
 
-      const hostPort = name.substr(LABEL_PORT_PREFIX.length);
+        const portTypes = {};
+        const ports = {};
 
-      portTypes[hostPort] = portType;
-    });
+        _.forEach(inspectResult.Config.Labels, (portType, name) => {
+            if (!name.startsWith(LABEL_PORT_PREFIX)) {
+                return;
+            }
 
-    _.forEach(
-      inspectResult.HostConfig.PortBindings,
-      (portBindings, containerPortSpec) => {
-        let [containerPort, protocol] = containerPortSpec.split(/\//);
+            const hostPort = name.substr(LABEL_PORT_PREFIX.length);
 
-        const hostPort = portBindings[0].HostPort;
+            portTypes[hostPort] = portType;
+        });
 
-        const portType = portTypes[hostPort];
+        _.forEach(
+            inspectResult.HostConfig.PortBindings,
+            (portBindings, containerPortSpec) => {
+                let [containerPort, protocol] = containerPortSpec.split(/\//);
 
-        ports[portType] = {
-          containerPort,
-          protocol,
-          hostPort,
-        };
-      }
-    );
+                const hostPort = portBindings[0].HostPort;
 
-    return ports;
-  }
+                const portType = portTypes[hostPort];
+
+                ports[portType] = {
+                    containerPort,
+                    protocol,
+                    hostPort,
+                };
+            }
+        );
+
+        return ports;
+    }
 }
 
 module.exports = new ContainerManager();

package/src/instanceManager.js

@@ -1,7 +1,7 @@
 const _ = require('lodash');
 const request = require('request');
-
-const {BlockInstanceRunner} = require('@kapeta/local-cluster-executor');
+const EventEmitter = require("events");
+const BlockInstanceRunner = require('./utils/BlockInstanceRunner');
 
 const storageService = require('./storageService');
 const socketManager = require('./socketManager');
@@ -68,6 +68,10 @@ class InstanceManager {
 
             if (instance.status !== newStatus) {
                 instance.status = newStatus;
+                console.log(
+                    'Instance status changed: %s %s -> %s',
+                    instance.systemId, instance.instanceId, instance.status
+                )
                 this._emit(instance.systemId, EVENT_STATUS_CHANGED, instance);
                 changed = true;
             }
@@ -85,7 +89,11 @@ class InstanceManager {
 
         if (instance.type === 'docker') {
             const container = await containerManager.get(instance.pid);
-            return await container.isRunning()
+            if (!container) {
+                console.warn('Container not found: %s', instance.pid);
+                return false;
+            }
+            return await container.isRunning();
         }
 
         //Otherwise its just a normal process.
@@ -185,8 +193,12 @@ class InstanceManager {
         if (instance) {
             instance.status = STATUS_STARTING;
             instance.pid = info.pid;
-            instance.type = info.type;
-            instance.health = healthUrl;
+            if (info.type) {
+                instance.type = info.type;
+            }
+            if (healthUrl) {
+                instance.health = healthUrl;
+            }
             this._emit(systemId, EVENT_STATUS_CHANGED, instance);
         } else {
             instance = {
@@ -268,7 +280,9 @@ class InstanceManager {
         try {
             if (instance.type === 'docker') {
                 const container = await containerManager.get(instance.pid);
-                await container.stop();
+                if (container) {
+                    await container.stop();
+                }
                 return;
             }
             process.kill(instance.pid, 'SIGTERM');
@@ -383,7 +397,8 @@ class InstanceManager {
                     message: e.message,
                     time: Date.now()
                 }
-            ]
+            ];
+
             await this.registerInstance(planRef, instanceId, {
                 type: 'local',
                 pid: null,
@@ -401,7 +416,12 @@ class InstanceManager {
             return this._processes[planRef][instanceId] = {
                 pid: -1,
                 type,
-                logs: () => logs
+                logs: () => logs,
+                stop: () => Promise.resolve(),
+                ref: blockRef,
+                id: instanceId,
+                name: blockInstance.name,
+                output: new EventEmitter()
             };
         }
 
@@ -427,7 +447,11 @@ class InstanceManager {
         }
 
         if (this._processes[planRef][instanceId]) {
-            await this._processes[planRef][instanceId].stop();
+            try {
+                await this._processes[planRef][instanceId].stop();
+            } catch (e) {
+                console.error('Failed to stop process for instance: %s -> %s', planRef, instanceId, e);
+            }
             delete this._processes[planRef][instanceId];
         }
     }