@kapeta/local-cluster-service 0.6.0 → 0.7.0

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

@@ -0,0 +1,19 @@
+import { LogEntry, LogLevel, LogSource } from '../types';
+export declare class LogData {
+    static readonly MAX_LINES = 1000;
+    private readonly entries;
+    constructor();
+    /**
+     *
+     * @param {string} msg
+     * @param {string} [level]
+     * @param {string} [source]
+     */
+    addLog(msg: string, level?: LogLevel, source?: LogSource): void;
+    /**
+     *
+     * @return {LogEntry[]}
+     */
+    getLogs(): LogEntry[];
+    toString(): string;
+}

package/{src → dist/esm/src}/utils/LogData.js

@@ -1,26 +1,18 @@
 const MAX_LINES = 1000;
-
-class LogData {
-
-    constructor() {
-        /**
-         *
-         * @type {LogEntry[]}
-         */
-        this.entries = [];
-    }
-
+export class LogData {
+    static MAX_LINES = MAX_LINES;
+    entries = [];
+    constructor() { }
     /**
      *
      * @param {string} msg
      * @param {string} [level]
      * @param {string} [source]
      */
-    addLog(msg, level = 'INFO', source = 'STDOUT') {
-        while(this.entries.length > MAX_LINES) {
+    addLog(msg, level = 'INFO', source = 'stdout') {
+        while (this.entries.length > MAX_LINES) {
             this.entries.shift();
         }
-
         if (!msg.endsWith('\n')) {
             msg += '\n';
         }
@@ -28,10 +20,9 @@ class LogData {
             time: Date.now(),
             message: msg,
             level,
-            source
+            source,
         });
     }
-
     /**
      *
      * @return {LogEntry[]}
@@ -39,12 +30,10 @@ class LogData {
     getLogs() {
         return this.entries;
     }
-
     toString() {
-        return this.getLogs().map(entry => entry.message).join('\n');
+        return this.getLogs()
+            .map((entry) => entry.message)
+            .join('\n');
     }
 }
-
-LogData.MAX_LINES = MAX_LINES;
-
-module.exports = LogData;
+module.exports = LogData;

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

@@ -0,0 +1,26 @@
+import { StringMap } from '../types';
+/**
+ * A path template is a string that can be used to match a path and extract variables from it.
+ *
+ * E.g. /foo/{bar}/baz
+ *
+ * Would match /foo/123/baz and extract bar=123
+ *
+ * You can also specify a regex for the variable:
+ *  /foo/{bar:[0-9]+}/baz
+ *
+ */
+export declare class PathTemplate {
+    private _path;
+    private _parts;
+    constructor(pathTemplate: string);
+    get path(): string;
+    matches(path: string): boolean;
+    parse(path: string): StringMap | null;
+    create(variables: StringMap): string;
+    toString(): string;
+}
+/**
+ * Parses a path into a RESTPath
+ */
+export declare function pathTemplateParser(path: string): PathTemplate;

package/{src → dist/esm/src}/utils/pathTemplateParser.js

@@ -1,7 +1,5 @@
-
 const TYPE_VARIABLE = 'variable';
 const TYPE_PATH = 'path';
-
 /**
  * A path template is a string that can be used to match a path and extract variables from it.
  *
@@ -13,123 +11,106 @@ const TYPE_PATH = 'path';
  *  /foo/{bar:[0-9]+}/baz
  *
  */
-class PathTemplate {
+export class PathTemplate {
+    _path;
+    _parts = [];
     constructor(pathTemplate) {
         if (!pathTemplate.startsWith('/')) {
             pathTemplate = '/' + pathTemplate;
         }
         this._path = pathTemplate;
-
         const variableRegex = /{([^}]+)}/g;
         let match, offset = 0;
         this._parts = [];
-        while((match = variableRegex.exec(pathTemplate)) !== null) {
+        while ((match = variableRegex.exec(pathTemplate)) !== null) {
             if (match.index > offset) {
                 this._parts.push({
                     type: TYPE_PATH,
-                    value: pathTemplate.substring(offset, match.index)
+                    value: pathTemplate.substring(offset, match.index),
                 });
             }
-
             let regex;
             let value = match[1];
             [value, regex] = value.split(/:/, 2);
-
             if (regex) {
                 regex = new RegExp('^' + regex);
-            } else {
-                regex = /^[^\/]+/
             }
-
+            else {
+                regex = /^[^\/]+/;
+            }
             this._parts.push({
                 type: TYPE_VARIABLE,
                 value,
-                regex
+                regex,
             });
             offset = match.index + match[0].length;
         }
-
         if (offset < pathTemplate.length) {
             this._parts.push({
                 type: TYPE_PATH,
-                value: pathTemplate.substring(offset)
+                value: pathTemplate.substring(offset),
             });
         }
     }
-
     get path() {
         return this._path;
     }
-
     matches(path) {
         return this.parse(path) !== null;
     }
-
     parse(path) {
         if (!path.startsWith('/')) {
             path = '/' + path;
         }
-
         const values = {};
-
-        for(let i = 0 ; i < this._parts.length; i++) {
+        for (let i = 0; i < this._parts.length; i++) {
             const part = this._parts[i];
             switch (part.type) {
                 case TYPE_PATH:
                     if (!path.startsWith(part.value)) {
                         return null;
                     }
-
                     path = path.substring(part.value.length);
                     break;
                 case TYPE_VARIABLE:
-                    if (!part.regex.test(path)) {
+                    if (!part.regex?.test(path)) {
                         return null;
                     }
-
-                    const newPath = path.replace(part.regex,'');
+                    const newPath = path.replace(part.regex, '');
                     const value = path.substr(0, path.length - newPath.length);
                     values[part.value] = value;
                     path = newPath;
                     break;
             }
         }
-
         if (path && path !== '/') {
             //We did not match all of it
             return null;
         }
-
         return values;
     }
-
     create(variables) {
-        return this._parts.map((part) => {
+        return this._parts
+            .map((part) => {
             switch (part.type) {
                 case TYPE_PATH:
                     return part.value;
                 case TYPE_VARIABLE:
-                    if (variables[part.value] === undefined ||
-                        variables[part.value] === null ) {
-                        return ''
+                    if (variables[part.value] === undefined || variables[part.value] === null) {
+                        return '';
                     }
-
                     return variables[part.value];
             }
-        }).join('');
+        })
+            .join('');
     }
-
     toString() {
-        return 'tmpl: ' + this.path
+        return 'tmpl: ' + this.path;
     }
 }
-
 /**
  * Parses a path into a RESTPath
- * @param {string} path
  */
-function pathTemplateParser(path) {
+export function pathTemplateParser(path) {
     return new PathTemplate(path);
 }
-
-module.exports = pathTemplateParser;

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

@@ -0,0 +1 @@
+export declare function readYML(path: string): any;

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

@@ -0,0 +1,11 @@
+import FS from 'node:fs';
+import YAML from 'yaml';
+export function readYML(path) {
+    const rawYaml = FS.readFileSync(path);
+    try {
+        return YAML.parse(rawYaml.toString());
+    }
+    catch (err) {
+        throw new Error('Failed to parse plan YAML: ' + err);
+    }
+}

package/dist/esm/start.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/start.js

@@ -0,0 +1,7 @@
+import localClusterService from './index';
+localClusterService
+    .start()
+    .then(({ host, port }) => console.log('Listening on port %s:%s', host, port))
+    .catch((e) => {
+    console.error('Failed to start local cluster due to an error:\n\t - %s', e.toString());
+});

package/index.ts

@@ -0,0 +1,147 @@
+import { clusterService } from './src/clusterService';
+import { storageService } from './src/storageService';
+import { serviceManager } from './src/serviceManager';
+import { socketManager } from './src/socketManager';
+import { containerManager } from './src/containerManager';
+import express from 'express';
+import HTTP from 'http';
+import { Server } from 'socket.io';
+
+import TrafficRoutes from './src/traffic/routes';
+import ProxyRoutes from './src/proxy/routes';
+import ConfigRoutes from './src/config/routes';
+import InstancesRoutes from './src/instances/routes';
+import IdentitiesRoutes from './src/identities/routes';
+import FilesystemRoutes from './src/filesystem/routes';
+import AssetsRoutes from './src/assets/routes';
+import ProviderRoutes from './src/providers/routes';
+
+export type LocalClusterService = HTTP.Server & { host?: string; port?: number };
+
+export type StartResult = { host: string; port: number; dockerStatus: boolean };
+
+let currentServer: LocalClusterService | null = null;
+
+function createServer() {
+    const app = express();
+    app.use('/traffic', TrafficRoutes);
+    app.use('/proxy', ProxyRoutes);
+    app.use('/config', ConfigRoutes);
+    app.use('/instances', InstancesRoutes);
+    app.use('/identities', IdentitiesRoutes);
+    app.use('/files', FilesystemRoutes);
+    app.use('/assets', AssetsRoutes);
+    app.use('/providers', ProviderRoutes);
+    app.use('/', (err: any, req: express.Request, res: express.Response) => {
+        console.error('Request failed: %s %s', req.method, req.originalUrl, err);
+        res.status(500).send({
+            ok: false,
+            error: err.error ?? err.message,
+        });
+    });
+    const server = HTTP.createServer(app);
+
+    //socket
+    const io = new Server(server, {
+        cors: {
+            //TODO: This should'nt be hardcoded but also shouldn't be "*"
+            origin: 'http://localhost:8080',
+        },
+    });
+    socketManager.setIo(io);
+    return server;
+}
+
+export default {
+    isRunning: function () {
+        return !!currentServer;
+    },
+
+    getCurrentPort: function () {
+        if (!currentServer) {
+            return -1;
+        }
+
+        return currentServer.port;
+    },
+
+    /**
+     * Starts the local cluster service.
+     * resolves when listening is done with port number. Rejects if listening failed.
+     */
+    start: async function (): Promise<StartResult> {
+        if (currentServer) {
+            throw new Error('Server already started');
+        }
+
+        try {
+            await containerManager.initialize();
+        } catch (e: any) {
+            console.error(
+                'Could not ping docker runtime: ' + e.toString() + '. Make sure docker is running and working.'
+            );
+        }
+
+        const clusterPort = storageService.get('cluster', 'port');
+        if (clusterPort) {
+            clusterService.setClusterServicePort(clusterPort);
+        }
+
+        const clusterHost = storageService.get('cluster', 'host');
+        if (clusterHost) {
+            clusterService.setClusterServiceHost(clusterHost);
+        }
+
+        await clusterService.init();
+
+        currentServer = createServer();
+
+        const port = clusterService.getClusterServicePort();
+
+        const host = clusterService.getClusterServiceHost();
+
+        if (clusterPort !== port) {
+            storageService.put('cluster', 'port', port);
+        }
+
+        if (clusterHost !== host) {
+            storageService.put('cluster', 'host', host);
+        }
+
+        return new Promise((resolve, reject) => {
+            if (!currentServer) {
+                reject(new Error(`Current server wasn't set`));
+                return;
+            }
+            currentServer.once('error', (err) => {
+                if (currentServer) {
+                    currentServer.close();
+                    currentServer = null;
+                }
+                reject(err);
+            });
+
+            currentServer.listen(port, host, () => resolve({ host, port, dockerStatus: containerManager.isAlive() }));
+            currentServer.host = host;
+            currentServer.port = port;
+        });
+    },
+
+    /**
+     * Stops any currently running cluster services.
+     * @return {Promise<boolean>} Returns true if the service was stopped - false if no service was running.
+     */
+    stop: function () {
+        if (currentServer) {
+            return new Promise(function (resolve) {
+                if (currentServer) {
+                    currentServer.close(() => resolve(true));
+                    currentServer = null;
+                }
+            });
+        }
+
+        return Promise.resolve(false);
+    },
+    getServices: () => serviceManager.getServices(),
+};

package/package.json

@@ -1,77 +1,109 @@
 {
-  "name": "@kapeta/local-cluster-service",
-  "version": "0.6.0",
-  "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/kapetacom/local-cluster-service.git"
-  },
-  "keywords": [
-    "kapeta"
-  ],
-  "author": "Henrik Hofmeister <hh@kapeta.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/kapetacom/local-cluster-service/issues"
-  },
-  "scripts": {
-    "start": "nodemon start.js",
-    "test": "echo its fine"
-  },
-  "homepage": "https://github.com/kapetacom/local-cluster-service#readme",
-  "dependencies": {
-    "@kapeta/codegen": "<2",
-    "@kapeta/local-cluster-config": ">= 0.2.3 <2",
-    "@kapeta/nodejs-api-client": "<2",
-    "@kapeta/nodejs-registry-utils": "<2",
-    "@kapeta/nodejs-utils": "<2",
-    "@kapeta/sdk-config": "<2",
-    "express": "4.17.1",
-    "express-promise-router": "^4.1.1",
-    "fs-extra": "^11.1.0",
-    "glob": "7.1.6",
-    "lodash": "^4.17.15",
-    "md5": "2.2.1",
-    "mkdirp": "0.5.1",
-    "node-cache": "^5.1.2",
-    "node-docker-api": "1.1.22",
-    "node-uuid": "^1.4.8",
-    "request": "2.88.2",
-    "request-promise": "4.2.6",
-    "socket.io": "^4.5.2",
-    "yaml": "^1.6.0"
-  },
-  "devDependencies": {
-    "nodemon": "^2.0.2"
-  },
-  "prettier": {
-    "tabWidth": 4,
-    "singleQuote": true
-  },
-  "release": {
-    "plugins": [
-      "@semantic-release/commit-analyzer",
-      "@semantic-release/release-notes-generator",
-      [
-        "@semantic-release/changelog",
-        {
-          "changelogFile": "CHANGELOG.md"
+    "name": "@kapeta/local-cluster-service",
+    "version": "0.7.0",
+    "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
+    "type": "commonjs",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./dist/esm/index.d.ts",
+                "default": "./dist/esm/index.js"
+            },
+            "require": {
+                "types": "./dist/cjs/index.d.cts",
+                "default": "./dist/cjs/index.js"
+            }
         }
-      ],
-      "@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}"
-        }
-      ]
-    ]
-  }
+    },
+    "types": "./dist/esm/index.d.ts",
+    "main": "./dist/cjs/index.js",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/kapetacom/local-cluster-service.git"
+    },
+    "keywords": [
+        "kapeta"
+    ],
+    "author": "Henrik Hofmeister <hh@kapeta.com>",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/kapetacom/local-cluster-service/issues"
+    },
+    "scripts": {
+        "start": "node ./dist/cjs/start.js",
+        "dev": "nodemon -e js,ts,json ts-node --transpile-only ./start.ts",
+        "test": "echo its fine",
+        "clean": "rm -rf ./dist",
+        "build:esm": "tsc --module esnext --outDir ./dist/esm && echo '{\"type\":\"module\"}' > ./dist/esm/package.json",
+        "build:cjs": "tsc --module commonjs --outDir ./dist/cjs && echo '{\"type\":\"commonjs\"}' > ./dist/cjs/package.json",
+        "build": "npm run clean && npm run build:esm && npm run build:cjs",
+        "format": "prettier --write .",
+        "lint": "tsc --noEmit && eslint src/**/*.ts",
+        "prepublishOnly": "npm run build"
+    },
+    "homepage": "https://github.com/kapetacom/local-cluster-service#readme",
+    "dependencies": {
+        "@kapeta/codegen": "<2",
+        "@kapeta/local-cluster-config": ">= 0.2.3 <2",
+        "@kapeta/nodejs-api-client": "<2",
+        "@kapeta/nodejs-registry-utils": "<2",
+        "@kapeta/nodejs-utils": "<2",
+        "@kapeta/schemas": "^0.0.58",
+        "@kapeta/sdk-config": "<2",
+        "express": "4.17.1",
+        "express-promise-router": "^4.1.1",
+        "fs-extra": "^11.1.0",
+        "glob": "7.1.6",
+        "lodash": "^4.17.15",
+        "md5": "2.2.1",
+        "node-cache": "^5.1.2",
+        "node-docker-api": "1.1.22",
+        "node-uuid": "^1.4.8",
+        "request": "2.88.2",
+        "request-promise": "4.2.6",
+        "socket.io": "^4.5.2",
+        "ts-node": "^10.9.1",
+        "typescript": "^5.1.6",
+        "yaml": "^1.6.0"
+    },
+    "devDependencies": {
+        "@kapeta/prettier-config": "^0.6.0",
+        "@tsconfig/node18": "^18.2.0",
+        "@types/express": "^4.17.17",
+        "@types/fs-extra": "^11.0.1",
+        "@types/lodash": "^4.14.195",
+        "@types/md5": "^2.3.2",
+        "@types/node-uuid": "^0.0.29",
+        "@types/request": "^2.48.8",
+        "eslint": "^8.42.0",
+        "eslint-config-prettier": "^8.8.0",
+        "nodemon": "^2.0.2",
+        "prettier": "^2.8.8"
+    },
+    "prettier": "@kapeta/prettier-config",
+    "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}"
+                }
+            ]
+        ]
+    }
 }