@kapeta/local-cluster-service 0.6.1 → 0.7.0

package/.eslintrc.cjs

@@ -0,0 +1,17 @@
+module.exports = {
+    extends: ['@kapeta/eslint-config'],
+    env: {
+        node: true,
+    },
+    rules: {
+        '@typescript-eslint/no-explicit-any': 'off',
+        '@typescript-eslint/no-non-null-assertion': 'off',
+        '@typescript-eslint/no-unsafe-assignment': 'off',
+        '@typescript-eslint/no-unsafe-member-access': 'off',
+        '@typescript-eslint/no-unsafe-return': 'off',
+    },
+    parserOptions: {
+        project: `${__dirname}/tsconfig.json`,
+        tsconfigRootDir: __dirname,
+    },
+};

package/.github/workflows/main.yml

@@ -1,26 +1,26 @@
 name: Main build
 on:
-    pull_request:
-    push:
-        branches: ['master']
+  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 }}
+  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/.prettierignore

@@ -0,0 +1,4 @@
+dist/*
+package-lock.json
+CHANGELOG.md
+README.md

package/.vscode/launch.json

@@ -8,10 +8,8 @@
             "type": "node",
             "request": "launch",
             "name": "Launch Program",
-            "skipFiles": [
-                "<node_internals>/**"
-            ],
+            "skipFiles": ["<node_internals>/**"],
             "program": "${workspaceFolder}/start.js"
         }
     ]
-}
+}

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.7.0](https://github.com/kapetacom/local-cluster-service/compare/v0.6.1...v0.7.0) (2023-07-16)
+
+
+### Features
+
+* Rewrote service to Typescript ([#40](https://github.com/kapetacom/local-cluster-service/issues/40)) ([e9ead38](https://github.com/kapetacom/local-cluster-service/commit/e9ead38422e648cd270e32e93d240fb9a807c723))
+
 ## [0.6.1](https://github.com/kapetacom/local-cluster-service/compare/v0.6.0...v0.6.1) (2023-06-21)
 
 

package/definitions.d.ts

@@ -1,42 +1,24 @@
-interface Request {
-    method: string
-    stringBody: string
-    headers: {[key:string]:string}
-    params: {[key:string]:string}
+declare module '@kapeta/nodejs-api-client' {
+    export class KapetaAPI {
+        getCurrentIdentity(): Promise<any>;
+        getMemberships(identityId: string): Promise<any>;
+    }
 }
 
-interface Response {
-    headers: {[key:string]:string}
-    status: (status:number) => void
-    send: (body:any) => void
-    end: () => void
-    set: (headers:{[key:string]:string}) => void
-}
+declare module '@kapeta/nodejs-registry-utils' {
+    import { Dependency, Kind } from '@kapeta/schemas';
 
-interface ResourceRef {
-    blockId:string
-    resourceName:string
-}
+    export interface AssetVersion {
+        content: Kind;
+        dependencies: Dependency[];
+    }
 
-declare function ProxyRequestHandler(req:Request, res:Response, info:ProxyRequestInfo);
+    export class RegistryService {
+        constructor(url: string);
 
+        async getVersion(fullName: string, version: string): Promise<AssetVersion>;
+    }
 
-interface Connection {
-    mapping: any
-    provider: ResourceRef
-    consumer: ResourceRef
+    export const Config: any;
+    export const Actions: any;
 }
-
-interface ResourceInfo {
-    spec:any
-    metadata:any
-    kind:string
-}
-
-interface ProxyRequestInfo {
-    address: string
-    connection:Connection
-    providerResource:ResourceInfo
-    consumerResource:ResourceInfo
-    consumerPath:string
-}

package/dist/cjs/index.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import HTTP from 'http';
+export type LocalClusterService = HTTP.Server & {
+    host?: string;
+    port?: number;
+};
+export type StartResult = {
+    host: string;
+    port: number;
+    dockerStatus: boolean;
+};
+declare const _default: {
+    isRunning: () => boolean;
+    getCurrentPort: () => number | undefined;
+    /**
+     * Starts the local cluster service.
+     * resolves when listening is done with port number. Rejects if listening failed.
+     */
+    start: () => Promise<StartResult>;
+    /**
+     * Stops any currently running cluster services.
+     * @return {Promise<boolean>} Returns true if the service was stopped - false if no service was running.
+     */
+    stop: () => Promise<unknown>;
+    getServices: () => any;
+};
+export default _default;

package/dist/cjs/index.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const clusterService_1 = require("./src/clusterService");
+const storageService_1 = require("./src/storageService");
+const serviceManager_1 = require("./src/serviceManager");
+const socketManager_1 = require("./src/socketManager");
+const containerManager_1 = require("./src/containerManager");
+const express_1 = __importDefault(require("express"));
+const http_1 = __importDefault(require("http"));
+const socket_io_1 = require("socket.io");
+const routes_1 = __importDefault(require("./src/traffic/routes"));
+const routes_2 = __importDefault(require("./src/proxy/routes"));
+const routes_3 = __importDefault(require("./src/config/routes"));
+const routes_4 = __importDefault(require("./src/instances/routes"));
+const routes_5 = __importDefault(require("./src/identities/routes"));
+const routes_6 = __importDefault(require("./src/filesystem/routes"));
+const routes_7 = __importDefault(require("./src/assets/routes"));
+const routes_8 = __importDefault(require("./src/providers/routes"));
+let currentServer = null;
+function createServer() {
+    const app = (0, express_1.default)();
+    app.use('/traffic', routes_1.default);
+    app.use('/proxy', routes_2.default);
+    app.use('/config', routes_3.default);
+    app.use('/instances', routes_4.default);
+    app.use('/identities', routes_5.default);
+    app.use('/files', routes_6.default);
+    app.use('/assets', routes_7.default);
+    app.use('/providers', routes_8.default);
+    app.use('/', (err, req, res) => {
+        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_1.default.createServer(app);
+    //socket
+    const io = new socket_io_1.Server(server, {
+        cors: {
+            //TODO: This should'nt be hardcoded but also shouldn't be "*"
+            origin: 'http://localhost:8080',
+        },
+    });
+    socketManager_1.socketManager.setIo(io);
+    return server;
+}
+exports.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 () {
+        if (currentServer) {
+            throw new Error('Server already started');
+        }
+        try {
+            await containerManager_1.containerManager.initialize();
+        }
+        catch (e) {
+            console.error('Could not ping docker runtime: ' + e.toString() + '. Make sure docker is running and working.');
+        }
+        const clusterPort = storageService_1.storageService.get('cluster', 'port');
+        if (clusterPort) {
+            clusterService_1.clusterService.setClusterServicePort(clusterPort);
+        }
+        const clusterHost = storageService_1.storageService.get('cluster', 'host');
+        if (clusterHost) {
+            clusterService_1.clusterService.setClusterServiceHost(clusterHost);
+        }
+        await clusterService_1.clusterService.init();
+        currentServer = createServer();
+        const port = clusterService_1.clusterService.getClusterServicePort();
+        const host = clusterService_1.clusterService.getClusterServiceHost();
+        if (clusterPort !== port) {
+            storageService_1.storageService.put('cluster', 'port', port);
+        }
+        if (clusterHost !== host) {
+            storageService_1.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_1.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_1.serviceManager.getServices(),
+};

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

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

@@ -0,0 +1,31 @@
+import { Definition } from '@kapeta/local-cluster-config';
+import { BlockDefinition } from '@kapeta/schemas';
+export interface EnrichedAsset {
+    ref: string;
+    editable: boolean;
+    exists: boolean;
+    version: string;
+    kind: string;
+    data: Definition;
+    path: string;
+    ymlPath: string;
+}
+declare class AssetManager {
+    private cache;
+    constructor();
+    /**
+     *
+     * @param {string[]} [assetKinds]
+     * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
+     */
+    getAssets(assetKinds?: string[]): EnrichedAsset[];
+    getPlans(): EnrichedAsset[];
+    getPlan(ref: string, noCache?: boolean): Promise<Definition>;
+    getAsset(ref: string, noCache?: boolean): Promise<EnrichedAsset | undefined>;
+    createAsset(path: string, yaml: BlockDefinition): Promise<EnrichedAsset[]>;
+    updateAsset(ref: string, yaml: BlockDefinition): Promise<void>;
+    importFile(filePath: string): Promise<EnrichedAsset[]>;
+    unregisterAsset(ref: string): Promise<void>;
+}
+export declare const assetManager: AssetManager;
+export {};

package/dist/cjs/src/assetManager.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assetManager = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const yaml_1 = __importDefault(require("yaml"));
+const node_cache_1 = __importDefault(require("node-cache"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const codeGeneratorManager_1 = require("./codeGeneratorManager");
+const progressListener_1 = require("./progressListener");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const repositoryManager_1 = require("./repositoryManager");
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+function enrichAsset(asset) {
+    return {
+        ref: `kapeta://${asset.definition.metadata.name}:${asset.version}`,
+        editable: asset.version === 'local',
+        exists: true,
+        version: asset.version,
+        kind: asset.definition.kind,
+        data: asset.definition,
+        path: asset.path,
+        ymlPath: asset.ymlPath,
+    };
+}
+function compareRefs(a, b) {
+    const [aProtocol, aId] = parseRef(a);
+    const [bProtocol, bId] = parseRef(b);
+    return aProtocol === bProtocol && aId === bId;
+}
+function parseRef(ref) {
+    let out = ref.split(/:\/\//, 2);
+    if (out.length === 1) {
+        return ['kapeta', ref.toLowerCase()];
+    }
+    return [out[0].toLowerCase(), out[1].toLowerCase()];
+}
+class AssetManager {
+    cache;
+    constructor() {
+        this.cache = new node_cache_1.default({
+            stdTTL: 60 * 60, // 1 hour
+        });
+    }
+    /**
+     *
+     * @param {string[]} [assetKinds]
+     * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
+     */
+    getAssets(assetKinds) {
+        if (!assetKinds) {
+            const blockTypeProviders = local_cluster_config_1.default.getDefinitions([
+                'core/block-type',
+                'core/block-type-operator',
+            ]);
+            assetKinds = blockTypeProviders.map((p) => {
+                return `${p.definition.metadata.name}:${p.version}`;
+            });
+            assetKinds.push('core/plan');
+        }
+        const assets = local_cluster_config_1.default.getDefinitions(assetKinds);
+        return assets.map(enrichAsset);
+    }
+    getPlans() {
+        return this.getAssets(['core/plan']);
+    }
+    async getPlan(ref, noCache = false) {
+        const asset = await this.getAsset(ref, noCache);
+        if ('core/plan' !== asset?.kind) {
+            throw new Error('Asset was not a plan: ' + ref);
+        }
+        return asset.data;
+    }
+    async getAsset(ref, noCache = false) {
+        const cacheKey = `getAsset:${ref}`;
+        if (!noCache && this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+        await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version);
+        let asset = local_cluster_config_1.default.getDefinitions()
+            .map(enrichAsset)
+            .find((a) => (0, nodejs_utils_1.parseKapetaUri)(a.ref).equals(uri));
+        if (!asset) {
+            throw new Error('Asset not found: ' + ref);
+        }
+        this.cache.set(cacheKey, asset);
+        return asset;
+    }
+    async createAsset(path, yaml) {
+        if (node_fs_1.default.existsSync(path)) {
+            throw new Error('File already exists: ' + path);
+        }
+        const dirName = node_path_1.default.dirname(path);
+        if (!node_fs_1.default.existsSync(dirName)) {
+            fs_extra_1.default.mkdirpSync(dirName);
+        }
+        node_fs_1.default.writeFileSync(path, yaml_1.default.stringify(yaml));
+        const asset = await this.importFile(path);
+        if (codeGeneratorManager_1.codeGeneratorManager.canGenerateCode(yaml)) {
+            await codeGeneratorManager_1.codeGeneratorManager.generate(path, yaml);
+        }
+        this.cache.flushAll();
+        return asset;
+    }
+    async updateAsset(ref, yaml) {
+        const asset = await this.getAsset(ref, true);
+        if (!asset) {
+            throw new Error('Attempted to update unknown asset: ' + ref);
+        }
+        if (!asset.editable) {
+            throw new Error('Attempted to update read-only asset: ' + ref);
+        }
+        if (!asset.ymlPath) {
+            throw new Error('Attempted to update corrupted asset: ' + ref);
+        }
+        node_fs_1.default.writeFileSync(asset.ymlPath, yaml_1.default.stringify(yaml));
+        this.cache.flushAll();
+        if (codeGeneratorManager_1.codeGeneratorManager.canGenerateCode(yaml)) {
+            await codeGeneratorManager_1.codeGeneratorManager.generate(asset.ymlPath, yaml);
+        }
+        else {
+            console.log('Could not generate code for %s', yaml.kind ? yaml.kind : 'unknown yaml');
+        }
+    }
+    async importFile(filePath) {
+        if (filePath.startsWith('file://')) {
+            filePath = filePath.substring('file://'.length);
+        }
+        if (!node_fs_1.default.existsSync(filePath)) {
+            throw new Error('File not found: ' + filePath);
+        }
+        const assetInfos = yaml_1.default.parseAllDocuments(node_fs_1.default.readFileSync(filePath).toString()).map((doc) => doc.toJSON());
+        await nodejs_registry_utils_1.Actions.link(progressListener_1.progressListener, node_path_1.default.dirname(filePath));
+        const version = 'local';
+        const refs = assetInfos.map((assetInfo) => `kapeta://${assetInfo.metadata.name}:${version}`);
+        this.cache.flushAll();
+        return this.getAssets().filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
+    }
+    async unregisterAsset(ref) {
+        const asset = await this.getAsset(ref, true);
+        if (!asset) {
+            throw new Error('Asset does not exists: ' + ref);
+        }
+        this.cache.flushAll();
+        await nodejs_registry_utils_1.Actions.uninstall(progressListener_1.progressListener, [asset.ref]);
+    }
+}
+exports.assetManager = new AssetManager();

package/dist/cjs/src/assets/routes.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

package/dist/cjs/src/assets/routes.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const yaml_1 = __importDefault(require("yaml"));
+const assetManager_1 = require("../assetManager");
+const cors_1 = require("../middleware/cors");
+const stringBody_1 = require("../middleware/stringBody");
+function parseBody(req) {
+    switch (req.headers['content-type']) {
+        case 'application/json':
+        case 'application/x-json':
+        case 'text/json':
+            return JSON.parse(req.stringBody ?? '{}');
+        case 'application/yaml':
+        case 'application/x-yaml':
+        case 'text/yaml':
+        case 'text/x-yaml':
+        default:
+            return yaml_1.default.parse(req.stringBody ?? '{}');
+    }
+}
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.use('/', stringBody_1.stringBody);
+/**
+ * Get all local assets available
+ */
+router.get('/', (req, res) => {
+    res.send(assetManager_1.assetManager.getAssets());
+});
+/**
+ * Get single asset
+ */
+router.get('/read', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
+        return;
+    }
+    try {
+        res.send(await assetManager_1.assetManager.getAsset(req.query.ref, true));
+    }
+    catch (err) {
+        res.status(400).send({ error: err.message });
+    }
+});
+/**
+ * Creates a new local file and registers it as an asset
+ */
+router.post('/create', async (req, res) => {
+    if (!req.query.path) {
+        res.status(400).send({ error: 'Query parameter "path" is missing' });
+        return;
+    }
+    const content = parseBody(req);
+    try {
+        const assets = await assetManager_1.assetManager.createAsset(req.query.path, content);
+        res.status(200).send(assets);
+    }
+    catch (err) {
+        console.log('Failed while creating asset', req.query.path, err.message);
+        res.status(400).send({ error: err.message });
+    }
+});
+/**
+ * Updates reference with new content
+ */
+router.put('/update', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
+        return;
+    }
+    const content = parseBody(req);
+    try {
+        await assetManager_1.assetManager.updateAsset(req.query.ref, content);
+        res.sendStatus(204);
+    }
+    catch (err) {
+        console.log('Failed while updating asset', req.query.ref, err.message);
+        res.status(400).send({ error: err.message });
+    }
+});
+/**
+ * Unregisters an asset (doesn't delete the asset)
+ */
+router.delete('/', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
+        return;
+    }
+    try {
+        await assetManager_1.assetManager.unregisterAsset(req.query.ref);
+        res.status(204).send();
+    }
+    catch (err) {
+        res.status(400).send({ error: err.message });
+    }
+});
+/**
+ * Registers an existing file as an asset
+ */
+router.put('/import', async (req, res) => {
+    if (!req.query.ref) {
+        res.status(400).send({ error: 'Query parameter "ref" is missing' });
+        return;
+    }
+    try {
+        const assets = await assetManager_1.assetManager.importFile(req.query.ref);
+        res.status(200).send(assets);
+    }
+    catch (err) {
+        res.status(400).send({ error: err.message });
+    }
+});
+exports.default = router;

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

@@ -0,0 +1,40 @@
+declare class ClusterService {
+    private _port;
+    private _currentPort;
+    private _initialized;
+    private _reservedPorts;
+    private _host;
+    constructor();
+    reservePort(port: number | string): void;
+    init(): Promise<void>;
+    _findClusterServicePort(): Promise<void>;
+    /**
+     * Gets next available port
+     * @return {Promise<number>}
+     */
+    getNextAvailablePort(): Promise<number>;
+    _checkIfPortIsUsed(port: number, host?: string): Promise<unknown>;
+    /**
+     * The port of this local cluster service itself
+     */
+    getClusterServicePort(): number;
+    getClusterServiceHost(): string;
+    /**
+     * Set the port to be used for this local service
+     * @param port
+     */
+    setClusterServicePort(port: number): void;
+    setClusterServiceHost(host: string): void;
+    /**
+     * Gets that proxy path of a given request
+     *
+     * @param systemId
+     * @param consumerInstanceId
+     * @param consumerResourceName
+     * @param portType
+     * @return {string}
+     */
+    getProxyPath(systemId: string, consumerInstanceId: string, consumerResourceName: string, portType: string): string;
+}
+export declare const clusterService: ClusterService;
+export {};