@kapeta/local-cluster-service 0.0.74 → 0.0.76

package/.github/workflows/main.yml

@@ -0,0 +1,26 @@
+name: Main build
+on:
+    pull_request:
+    push:
+        branches: ['master']
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
+              with:
+                  token: ${{ secrets.BOT_TOKEN }}
+            - uses: actions/setup-node@v3
+            - run: npm ci
+            - run: npm run build --if-present
+              env:
+                  CI: true
+            - run: npm test -- --passWithNoTests
+            # Probably move this to its own job when it makes sense
+            - name: Semantic Release
+              uses: cycjimmy/semantic-release-action@v3
+              if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
+              env:
+                  GITHUB_TOKEN: ${{ secrets.BOT_TOKEN }}
+                  NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+## [0.0.76](https://github.com/kapetacom/local-cluster-service/compare/v0.0.75...v0.0.76) (2023-05-06)
+
+
+### Bug Fixes
+
+* include docker status in cluster startup response ([0d40253](https://github.com/kapetacom/local-cluster-service/commit/0d402535b7b936fa4f4f480147d8f3103249a6f8))
+* make docker config try more variations before giving up ([f55629e](https://github.com/kapetacom/local-cluster-service/commit/f55629ed3f7167ec7b6810ec16ae6d8068722863))

package/index.js

@@ -55,7 +55,7 @@ module.exports = {
 
     /**
      * Starts the local cluster service.
-     * @return {Promise<Integer>} resolves when listening is done with port number. Rejects if listening failed.
+     * @return {Promise<{ host: string, port: nubmer, dockerStatus: boolean}>} resolves when listening is done with port number. Rejects if listening failed.
      */
     start: async function() {
         if (currentServer) {
@@ -63,9 +63,9 @@ module.exports = {
         }
 
         try {
-            await containerManager.ping()
+            await containerManager.initialize()
         } catch (e) {
-            throw new Error('Could not ping docker runtime: ' + e.toString() + '. Make sure docker is running and working.');
+            console.error('Could not ping docker runtime: ' + e.toString() + '. Make sure docker is running and working.');
         }
 
         const clusterPort = storageService.get('cluster','port');
@@ -102,7 +102,7 @@ module.exports = {
                 reject(err);
             });
 
-            currentServer.listen(port, host, () => resolve({host,port}));
+            currentServer.listen(port, host, () => resolve({host,port, dockerStatus: containerManager._alive}));
             currentServer.host = host;
             currentServer.port = port;
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kapeta/local-cluster-service",
-  "version": "0.0.74",
+  "version": "0.0.76",
   "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
   "main": "index.js",
   "repository": {
@@ -16,7 +16,8 @@
     "url": "https://github.com/kapetacom/local-cluster-service/issues"
   },
   "scripts": {
-    "start": "nodemon start.js"
+    "start": "nodemon start.js",
+    "test": "echo its fine"
   },
   "homepage": "https://github.com/kapetacom/local-cluster-service#readme",
   "dependencies": {
@@ -43,5 +44,30 @@
   },
   "devDependencies": {
     "nodemon": "^2.0.2"
+  },
+  "release": {
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      [
+        "@semantic-release/changelog",
+        {
+          "changelogFile": "CHANGELOG.md"
+        }
+      ],
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      [
+        "@semantic-release/git",
+        {
+          "assets": [
+            "CHANGELOG.md",
+            "package.json",
+            "package-lock.json"
+          ],
+          "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+        }
+      ]
+    ]
   }
 }

package/src/containerManager.js

@@ -1,279 +1,310 @@
-const {Docker} = require('node-docker-api');
-const _  = require('lodash');
+const { Docker } = require("node-docker-api");
+const _ = require("lodash");
+const os = require("os");
+const path = require("path");
 
-const LABEL_PORT_PREFIX = 'kapeta_port-';
+const LABEL_PORT_PREFIX = "kapeta_port-";
 
 const NANO_SECOND = 1000000;
 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)
-});
+const promisifyStream = (stream) =>
+  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;
+  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
+      }
     }
-
-    async ping() {
-        await this._docker.ping();
-        this._alive = true;
+    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";
     }
 
-    async pull(image) {
-        let [imageName, tag] = image.split(/:/);
-        if (!tag) {
-            tag = 'latest';
+    await this._docker.image
+      .create(
+        {},
+        {
+          fromImage: imageName,
+          tag: tag,
         }
-
-        await this._docker.image.create({}, {
-            fromImage: imageName,
-            tag: tag
-        }).then(stream => promisifyStream(stream));
-
+      )
+      .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;
+    });
+
+    _.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);
     }
 
-    /**
-     *
-     * @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;
-        });
-
-        _.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._docker.container.create({
-            name: name,
-            Image: image,
-            Labels,
-            Env,
-            HealthCheck,
-            HostConfig: {
-                PortBindings,
-                Mounts
-            }
-        });
-
-        await dockerContainer.start();
-
-        if (opts.health) {
-            await this._waitForHealthy(dockerContainer);
-        }
-
-        return new ContainerInfo(dockerContainer);
+    const dockerContainer = await this._docker.container.create({
+      name: name,
+      Image: image,
+      Labels,
+      Env,
+      HealthCheck,
+      HostConfig: {
+        PortBindings,
+        Mounts,
+      },
+    });
+
+    await dockerContainer.start();
+
+    if (opts.health) {
+      await this._waitForHealthy(dockerContainer);
     }
 
+    return new ContainerInfo(dockerContainer);
+  }
 
-    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)
-        });
-
+  async _waitForHealthy(container, attempt) {
+    if (!attempt) {
+      attempt = 0;
     }
 
-    async _isHealthy(container) {
-        const info = await container.status();
-
-        return info?.data?.State?.Health?.Status === 'healthy';
+    if (attempt >= HEALTH_CHECK_MAX) {
+      throw new Error("Operator did not become healthy within the timeout");
     }
 
-    /**
-     *
-     * @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 (await this._isHealthy(container)) {
+      console.log("Container became healthy");
+      return;
+    }
 
-        if (!dockerContainer) {
-            return null;
-        }
+    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;
+    }
 
-        return new ContainerInfo(dockerContainer);
+    if (!dockerContainer) {
+      return null;
     }
+
+    return new ContainerInfo(dockerContainer);
+  }
 }
 
 class ContainerInfo {
+  /**
+   *
+   * @param {Container} dockerContainer
+   */
+  constructor(dockerContainer) {
     /**
      *
-     * @param {Container} dockerContainer
+     * @type {Container}
+     * @private
      */
-    constructor(dockerContainer) {
-
-        /**
-         *
-         * @type {Container}
-         * @private
-         */
-        this._container = dockerContainer;
-    }
-
-    async isRunning() {
-        const inspectResult = await this.getStatus();
-
-        if (!inspectResult || 
-            !inspectResult.State) {
-            return false;
-        }
+    this._container = dockerContainer;
+  }
 
+  async isRunning() {
+    const inspectResult = await this.getStatus();
 
-        return inspectResult.State.Running || inspectResult.State.Restarting;
+    if (!inspectResult || !inspectResult.State) {
+      return false;
     }
 
-    async start() {
-        await this._container.start();
-    }
+    return inspectResult.State.Running || inspectResult.State.Restarting;
+  }
 
-    async restart() {
-        await this._container.restart();
-    }
+  async start() {
+    await this._container.start();
+  }
 
-    async stop() {
-        await this._container.stop();
-    }
+  async restart() {
+    await this._container.restart();
+  }
 
-    async remove(opts) {
-        await this._container.delete({ force: !!opts.force });
-    }
+  async stop() {
+    await this._container.stop();
+  }
 
-    async getPort(type) {
-        const ports = await this.getPorts();
+  async remove(opts) {
+    await this._container.delete({ force: !!opts.force });
+  }
 
-        if (ports[type]) {
-            return ports[type];
-        }
+  async getPort(type) {
+    const ports = await this.getPorts();
 
-        return null;
+    if (ports[type]) {
+      return ports[type];
     }
 
-    async getStatus() {
-        const result = await this._container.status();
+    return null;
+  }
 
-        return result ? result.data : null;
-    }
+  async getStatus() {
+    const result = await this._container.status();
 
-    async getPorts() {
-        const inspectResult = await this.getStatus();
+    return result ? result.data : null;
+  }
 
-        if (!inspectResult ||
-            !inspectResult.Config ||
-            !inspectResult.Config.Labels) {
-            return false;
-        }
+  async getPorts() {
+    const inspectResult = await this.getStatus();
 
-        const portTypes = {};
-        const ports = {};
+    if (
+      !inspectResult ||
+      !inspectResult.Config ||
+      !inspectResult.Config.Labels
+    ) {
+      return false;
+    }
 
-        _.forEach(inspectResult.Config.Labels, (portType, name) => {
-            if (!name.startsWith(LABEL_PORT_PREFIX)) {
-                return;
-            }
+    const portTypes = {};
+    const ports = {};
 
-            const hostPort = name.substr(LABEL_PORT_PREFIX.length);
+    _.forEach(inspectResult.Config.Labels, (portType, name) => {
+      if (!name.startsWith(LABEL_PORT_PREFIX)) {
+        return;
+      }
 
-            portTypes[hostPort] = portType;
+      const hostPort = name.substr(LABEL_PORT_PREFIX.length);
 
-        });
+      portTypes[hostPort] = portType;
+    });
 
-        _.forEach(inspectResult.HostConfig.PortBindings, (portBindings, containerPortSpec) => {
-            let [containerPort, protocol] = containerPortSpec.split(/\//);
+    _.forEach(
+      inspectResult.HostConfig.PortBindings,
+      (portBindings, containerPortSpec) => {
+        let [containerPort, protocol] = containerPortSpec.split(/\//);
 
-            const hostPort = portBindings[0].HostPort;
+        const hostPort = portBindings[0].HostPort;
 
-            const portType = portTypes[hostPort];
+        const portType = portTypes[hostPort];
 
-            ports[portType] = {
-                containerPort,
-                protocol,
-                hostPort
-            };
-        });
+        ports[portType] = {
+          containerPort,
+          protocol,
+          hostPort,
+        };
+      }
+    );
 
-        return ports;
-    }
+    return ports;
+  }
 }
 
-
 module.exports = new ContainerManager();

package/.github/workflows/pr-check.yml

@@ -1,18 +0,0 @@
-name: Check
-
-on: [pull_request]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18
-          registry-url: https://registry.npmjs.org/
-      - run: npm install
-        env:
-          CI: true

package/.github/workflows/publish.yml

@@ -1,20 +0,0 @@
-name: Publish to Kapeta Public NPM
-on:
-  push:
-    branches:
-      - master
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18
-          registry-url: https://registry.npmjs.org/
-          scope: '@kapeta'
-
-      - run: npm install
-      - run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}