@kapeta/local-cluster-service 0.0.76 → 0.1.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.1.0](https://github.com/kapetacom/local-cluster-service/compare/v0.0.76...v0.1.0) (2023-05-06)
+
+
+### Features
+
+* Allow running docker block operators ([0a3992c](https://github.com/kapetacom/local-cluster-service/commit/0a3992c359a119a623ed7d0423e6f7ad814aa8d3))
+
 ## [0.0.76](https://github.com/kapetacom/local-cluster-service/compare/v0.0.75...v0.0.76) (2023-05-06)
 
 

package/definitions.d.ts

@@ -23,8 +23,8 @@ declare function ProxyRequestHandler(req:Request, res:Response, info:ProxyReques
 
 interface Connection {
     mapping: any
-    from: ResourceRef
-    to: ResourceRef
+    provider: ResourceRef
+    consumer: ResourceRef
 }
 
 interface ResourceInfo {
@@ -36,7 +36,7 @@ interface ResourceInfo {
 interface ProxyRequestInfo {
     address: string
     connection:Connection
-    fromResource:ResourceInfo
-    toResource:ResourceInfo
+    providerResource:ResourceInfo
+    consumerResource:ResourceInfo
     consumerPath:string
 }

package/index.js

@@ -20,7 +20,7 @@ function createServer() {
     app.use('/assets', require('./src/assets/routes'));
     app.use('/providers', require('./src/providers/routes'));
     app.use('/', (err, req, res, next) => {
-        console.error('Request failed: %s %s', req.method, req.originalUrl, err.stack);
+        console.error('Request failed: %s %s', req.method, req.originalUrl, err);
         res.status(500).send({
             ok: false,
             error: err.error ?? err.message
@@ -102,7 +102,7 @@ module.exports = {
                 reject(err);
             });
 
-            currentServer.listen(port, host, () => resolve({host,port, dockerStatus: containerManager._alive}));
+            currentServer.listen(port, host, () => resolve({host,port, dockerStatus: containerManager.isAlive()}));
             currentServer.host = host;
             currentServer.port = port;
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kapeta/local-cluster-service",
-  "version": "0.0.76",
+  "version": "0.1.0",
   "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
   "main": "index.js",
   "repository": {
@@ -23,9 +23,8 @@
   "dependencies": {
     "@kapeta/codegen": "<2",
     "@kapeta/local-cluster-config": "<2",
-    "@kapeta/local-cluster-executor": "<2",
     "@kapeta/nodejs-api-client": "<2",
-    "@kapeta/nodejs-registry-utils": "^0.0.2",
+    "@kapeta/nodejs-registry-utils": "<2",
     "@kapeta/nodejs-utils": "<2",
     "@kapeta/sdk-config": "<2",
     "express": "4.17.1",

package/src/assetManager.js

@@ -54,7 +54,10 @@ class AssetManager {
      */
     getAssets(assetKinds) {
         if (!assetKinds) {
-            const blockTypeProviders = ClusterConfiguration.getDefinitions('core/block-type');
+            const blockTypeProviders = ClusterConfiguration.getDefinitions([
+                'core/block-type',
+                'core/block-type-operator'
+            ]);
             assetKinds = blockTypeProviders.map(p => {
                 return `${p.definition.metadata.name}:${p.version}`
             });
@@ -82,7 +85,6 @@ class AssetManager {
 
     async getAsset(ref) {
         const uri = parseKapetaUri(ref);
-
         await repositoryManager.ensureAsset(uri.handle, uri.name, uri.version);
 
         let asset = ClusterConfiguration.getDefinitions()

package/src/containerManager.js

@@ -1,7 +1,7 @@
-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 LABEL_PORT_PREFIX = "kapeta_port-";
 
@@ -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() {
 
-    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);
+        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}`);
+        }
+
+        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();