@kapeta/local-cluster-service 0.6.0 → 0.7.0

package/{src → dist/esm/src}/operatorManager.js

@@ -1,41 +1,33 @@
-const ClusterConfiguration = require('@kapeta/local-cluster-config').default;
-const serviceManager = require('./serviceManager');
-const storageService = require('./storageService');
-const containerManager = require('./containerManager');
-const _ = require('lodash');
-const mkdirp = require('mkdirp');
-const Path = require('path');
-const md5 = require('md5');
-const {parseKapetaUri} = require("@kapeta/nodejs-utils");
-
+import ClusterConfiguration from '@kapeta/local-cluster-config';
+import Path from 'path';
+import md5 from 'md5';
+import { parseKapetaUri } from '@kapeta/nodejs-utils';
+import { serviceManager } from './serviceManager';
+import { storageService } from './storageService';
+import { containerManager } from './containerManager';
+import FSExtra from 'fs-extra';
 const KIND_OPERATOR = 'core/resource-type-operator';
-
 class Operator {
+    _data;
     constructor(data) {
         this._data = data;
     }
-
     getData() {
         return this._data;
     }
-
     getCredentials() {
         return this._data.credentials;
     }
 }
-
 class OperatorManager {
-
+    _mountDir;
     constructor() {
         this._mountDir = Path.join(storageService.getKapetaBasedir(), 'mounts');
-
-        mkdirp.sync(this._mountDir);
+        FSExtra.mkdirpSync(this._mountDir);
     }
-
     _getMountPoint(operatorType, mountName) {
         return Path.join(this._mountDir, operatorType, mountName);
     }
-
     /**
      * Get operator definition for resource type
      *
@@ -45,89 +37,62 @@ class OperatorManager {
      */
     getOperator(resourceType, version) {
         const operators = ClusterConfiguration.getDefinitions(KIND_OPERATOR);
-
-        const operator = _.find(operators, (operator) => operator.definition &&
+        const operator = operators.find((operator) => operator.definition &&
             operator.definition.metadata &&
             operator.definition.metadata.name &&
             operator.definition.metadata.name.toLowerCase() === resourceType.toLowerCase() &&
             operator.version === version);
-
         if (!operator) {
             throw new Error(`Unknown resource type: ${resourceType}:${version}`);
         }
-
-        if (!operator.definition.spec ||
-            !operator.definition.spec.local) {
+        if (!operator.definition.spec || !operator.definition.spec.local) {
             throw new Error(`Operator missing local definition: ${resourceType}:${version}`);
         }
-
         return new Operator(operator.definition.spec.local);
     }
-
     /**
      * Get information about a specific consumed resource
-     *
-     * @param {string} systemId
-     * @param {string} fromServiceId
-     * @param {string} resourceType
-     * @param {string} portType
-     * @param {string} name
-     * @returns {Promise<{host: string, port: (*|string), type: *, protocol: *, credentials: *}>}
      */
     async getConsumerResourceInfo(systemId, fromServiceId, resourceType, portType, name, environment) {
-
         const plans = ClusterConfiguration.getDefinitions('core/plan');
-
         const planUri = parseKapetaUri(systemId);
-        const currentPlan = plans.find(plan => plan.definition.metadata.name === planUri.fullName && plan.version === planUri.version);
+        const currentPlan = plans.find((plan) => plan.definition.metadata.name === planUri.fullName && plan.version === planUri.version);
         if (!currentPlan) {
             throw new Error(`Unknown plan: ${systemId}`);
         }
-
-        const currentInstance = currentPlan.definition.spec.blocks?.find(instance => instance.id === fromServiceId);
+        const currentInstance = currentPlan.definition.spec.blocks?.find((instance) => instance.id === fromServiceId);
         if (!currentInstance) {
             throw new Error(`Unknown instance: ${fromServiceId} in plan ${systemId}`);
         }
-
         const blockUri = parseKapetaUri(currentInstance.block.ref);
-        const blockDefinition = ClusterConfiguration.getDefinitions().find(definition =>
-            definition.version === blockUri.version &&
-            definition.definition.metadata.name === blockUri.fullName
-        );
-
+        const blockDefinition = ClusterConfiguration.getDefinitions().find((definition) => definition.version === blockUri.version && definition.definition.metadata.name === blockUri.fullName);
         if (!blockDefinition) {
             throw new Error(`Unknown block: ${currentInstance.block.ref} in plan ${systemId}`);
         }
-
-        const blockResource = blockDefinition.definition.spec?.consumers?.find(resource => resource.metadata.name === name);
+        const blockResource = blockDefinition.definition.spec?.consumers?.find((resource) => resource.metadata.name === name);
         if (!blockResource) {
             throw new Error(`Unknown resource: ${name} in block ${currentInstance.block.ref} in plan ${systemId}`);
         }
-
         const kindUri = parseKapetaUri(blockResource.kind);
         const operator = this.getOperator(resourceType, kindUri.version);
         const credentials = operator.getCredentials();
         const container = await this.ensureResource(systemId, resourceType, kindUri.version);
         const portInfo = await container.getPort(portType);
-
         if (!portInfo) {
             throw new Error('Unknown resource port type : ' + resourceType + '#' + portType);
         }
-
         const dbName = name + '_' + fromServiceId.replace(/[^a-z0-9]/gi, '');
-
         return {
             host: environment === 'docker' ? 'host.docker.internal' : '127.0.0.1',
             port: portInfo.hostPort,
             type: portType,
             protocol: portInfo.protocol,
             options: {
-                dbName
+                dbName,
             },
-            credentials
+            credentials,
         };
     }
-
     /**
      * Ensure we have a running operator of given type
      *
@@ -138,78 +103,57 @@ class OperatorManager {
      */
     async ensureResource(systemId, resourceType, version) {
         const operator = this.getOperator(resourceType, version);
-
         const operatorData = operator.getData();
-
         const portTypes = Object.keys(operatorData.ports);
-
         portTypes.sort();
-
         const containerBaseName = 'kapeta-resource';
-
         const nameParts = [resourceType.toLowerCase()];
-
         const ports = {};
-
-        for(let i = 0 ; i < portTypes.length; i++) {
+        for (let i = 0; i < portTypes.length; i++) {
             const portType = portTypes[i];
             let containerPortInfo = operatorData.ports[portType];
             const hostPort = await serviceManager.ensureServicePort(resourceType, portType);
-
-            if (typeof containerPortInfo === 'number' ||
-                typeof containerPortInfo === 'string') {
-                containerPortInfo = {port: containerPortInfo, type: 'tcp'};
+            if (typeof containerPortInfo === 'number' || typeof containerPortInfo === 'string') {
+                containerPortInfo = { port: containerPortInfo, type: 'tcp' };
             }
-
             if (!containerPortInfo.type) {
                 containerPortInfo.type = 'tcp';
             }
-
             const portId = containerPortInfo.port + '/' + containerPortInfo.type;
             nameParts.push(portType + '-' + portId + '-' + hostPort);
-
             ports[portId] = {
                 type: portType,
-                hostPort
+                hostPort,
             };
         }
-
         const mounts = containerManager.createMounts(resourceType, operatorData.mounts);
-
         const containerName = containerBaseName + '-' + md5(nameParts.join('_'));
         let container = await containerManager.get(containerName);
-
         const isRunning = container ? await container.isRunning() : false;
         if (container && !isRunning) {
             await container.start();
         }
-
         if (!container) {
-
-            container = await containerManager.run(
-                operatorData.image,
-                containerName,
-                {
-                    mounts,
-                    ports,
-                    health: operatorData.health,
-                    env: operatorData.env,
-                    cmd: operatorData.cmd
-                });
+            container = await containerManager.run(operatorData.image, containerName, {
+                mounts,
+                ports,
+                health: operatorData.health,
+                env: operatorData.env,
+                cmd: operatorData.cmd,
+            });
         }
-
         try {
             if (operatorData.health) {
                 await containerManager.waitForHealthy(container.native);
-            } else {
+            }
+            else {
                 await containerManager.waitForReady(container.native);
             }
-        } catch (e) {
+        }
+        catch (e) {
             console.error(e.message);
         }
-
         return container;
     }
 }
-
-module.exports = new OperatorManager();
+export const operatorManager = new OperatorManager();

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

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { SocketManager } from './socketManager';
+declare class ProgressListener {
+    private socketManager;
+    constructor(socketManager: SocketManager);
+    run(command: string, directory?: string): Promise<{
+        exit: number;
+        signal: NodeJS.Signals | null;
+    }>;
+    progress(label: string, callback: () => void | Promise<void>): Promise<void>;
+    check(message: string, ok: boolean | Promise<boolean> | (() => Promise<boolean>)): Promise<void>;
+    start(label: string): void;
+    showValue(label: string, value: any): void;
+    error(msg: string, ...args: any[]): void;
+    warn(msg: string, ...args: any[]): void;
+    info(msg: string, ...args: any[]): void;
+    debug(msg: string, ...args: any[]): void;
+}
+export declare const progressListener: ProgressListener;
+export {};

package/dist/esm/src/progressListener.js

@@ -0,0 +1,88 @@
+import { spawn } from 'child_process';
+import { socketManager } from './socketManager';
+class ProgressListener {
+    socketManager;
+    constructor(socketManager) {
+        this.socketManager = socketManager;
+    }
+    run(command, directory) {
+        this.socketManager.emit(`install`, 'install:log', {
+            type: 'info',
+            message: `Running command "${command}"`,
+        });
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, {
+                cwd: directory ? directory : process.cwd(),
+                detached: true,
+                shell: true,
+            });
+            child.stdout.on('data', (data) => {
+                this.socketManager.emit(`install`, 'install:log', { type: 'info', message: data.toString() });
+            });
+            child.stderr.on('data', (data) => {
+                this.socketManager.emit(`install`, 'install:log', { type: 'info', message: data.toString() });
+            });
+            child.on('exit', (exit, signal) => {
+                if (exit !== 0) {
+                    this.socketManager.emit(`install`, 'install:log', {
+                        type: 'info',
+                        message: `"${command}" failed: "${exit}"`,
+                    });
+                    reject(new Error(`Command "${command}" exited with code ${exit}`));
+                }
+                else {
+                    this.socketManager.emit(`install`, 'install:log', {
+                        type: 'info',
+                        message: `Command OK: "${command}"`,
+                    });
+                    resolve({ exit, signal });
+                }
+            });
+            child.on('error', (err) => {
+                this.socketManager.emit(`install`, 'install:log', {
+                    type: 'info',
+                    message: `"${command}" failed: "${err.message}"`,
+                });
+                reject(err);
+            });
+        });
+    }
+    async progress(label, callback) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: started` });
+        try {
+            const result = await callback();
+            this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: done` });
+            return result;
+        }
+        catch (e) {
+            this.socketManager.emit(`install`, 'install:log', {
+                type: 'info',
+                message: `${label}: failed. ${e.message}`,
+            });
+            throw e;
+        }
+    }
+    async check(message, ok) {
+        const wasOk = await ok;
+        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${message}: ${wasOk}` });
+    }
+    start(label) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: label });
+    }
+    showValue(label, value) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: ${value}` });
+    }
+    error(msg, ...args) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'error', message: msg });
+    }
+    warn(msg, ...args) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'warn', message: msg });
+    }
+    info(msg, ...args) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: msg });
+    }
+    debug(msg, ...args) {
+        this.socketManager.emit(`install`, 'install:log', { type: 'debug', message: msg });
+    }
+}
+export const progressListener = new ProgressListener(socketManager);

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+declare class ProviderManager {
+    private _webAssetCache;
+    constructor();
+    getWebProviders(): import("@kapeta/local-cluster-config").DefinitionInfo[];
+    getAsset(handle: string, name: string, version: string, sourceMap?: boolean): Promise<string | Buffer | null>;
+}
+export declare const providerManager: ProviderManager;
+export {};

package/dist/esm/src/providerManager.js

@@ -0,0 +1,45 @@
+import Path from 'path';
+import FSExtra from 'fs-extra';
+import { repositoryManager } from './repositoryManager';
+import ClusterConfiguration from '@kapeta/local-cluster-config';
+class ProviderManager {
+    _webAssetCache;
+    constructor() {
+        this._webAssetCache = {};
+    }
+    getWebProviders() {
+        return ClusterConfiguration.getProviderDefinitions().filter((providerDefinition) => providerDefinition.hasWeb);
+    }
+    async getAsset(handle, name, version, sourceMap = false) {
+        const fullName = `${handle}/${name}`;
+        const id = `${handle}/${name}/${version}/web.js${sourceMap ? '.map' : ''}`;
+        if (this._webAssetCache[id] && (await FSExtra.pathExists(this._webAssetCache[id]))) {
+            return FSExtra.readFile(this._webAssetCache[id], 'utf8');
+        }
+        await repositoryManager.ensureAsset(handle, name, version);
+        const installedProvider = this.getWebProviders().find((providerDefinition) => {
+            return providerDefinition.definition.metadata.name === fullName && providerDefinition.version === version;
+        });
+        if (installedProvider) {
+            //Check locally installed providers
+            const path = Path.join(installedProvider.path, 'web', handle, `${name}.js${sourceMap ? '.map' : ''}`);
+            if (await FSExtra.pathExists(path)) {
+                this._webAssetCache[id] = path;
+                return FSExtra.readFile(path);
+            }
+        }
+        return null;
+    }
+}
+const providerDefinitions = ClusterConfiguration.getProviderDefinitions();
+if (providerDefinitions.length > 0) {
+    console.log('## Loaded the following providers ##');
+    providerDefinitions.forEach((providerDefinition) => {
+        console.log(' - %s[%s:%s]', providerDefinition.definition.kind, providerDefinition.definition.metadata.name, providerDefinition.version);
+        console.log('   from %s', providerDefinition.path);
+    });
+}
+else {
+    console.log('## No providers found ##');
+}
+export const providerManager = new ProviderManager();

package/dist/esm/src/providers/routes.d.ts

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

package/{src → dist/esm/src}/providers/routes.js

@@ -1,37 +1,32 @@
-const Router = require('express-promise-router').default;
-const providerManager = require('../providerManager');
-
-const router = new Router();
-
-router.use('/', require('../middleware/cors'));
-
+import Router from 'express-promise-router';
+import { providerManager } from '../providerManager';
+import { corsHandler } from '../middleware/cors';
+const router = Router();
+router.use('/', corsHandler);
 router.get('/', async (req, res) => {
     const result = await providerManager.getWebProviders();
-
     res.send(result);
 });
-
 router.get('/asset/:handle/:name/:version/web.js', async (req, res) => {
     const { handle, name, version } = req.params;
     let result = await providerManager.getAsset(handle, name, version);
-
     if (!result) {
         res.status(404).send('');
-    } else {
+    }
+    else {
         if (version !== 'local') {
             res.setHeader('Cache-Control', 'max-age=31536000, immutable');
         }
         res.send(result.toString().replace(`${name}.js.map`, 'web.js.map'));
     }
 });
-
 router.get('/asset/:handle/:name/:version/web.js.map', async (req, res) => {
     const { handle, name, version } = req.params;
     const result = await providerManager.getAsset(handle, name, version, true);
-
     if (!result) {
         res.status(404).send('');
-    } else {
+    }
+    else {
         // Only cache successful requests
         if (version !== 'local') {
             res.setHeader('Cache-Control', 'max-age=31536000, immutable');
@@ -39,5 +34,4 @@ router.get('/asset/:handle/:name/:version/web.js.map', async (req, res) => {
         res.send(result);
     }
 });
-
-module.exports = router;
+export default router;

package/dist/esm/src/proxy/routes.d.ts

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

package/dist/esm/src/proxy/routes.js

@@ -0,0 +1,106 @@
+import Router from 'express-promise-router';
+import { proxyRestRequest } from './types/rest';
+import { proxyWebRequest } from './types/web';
+import { stringBody } from '../middleware/stringBody';
+import { serviceManager } from '../serviceManager';
+import { clusterService } from '../clusterService';
+import { assetManager } from '../assetManager';
+import _ from 'lodash';
+const router = Router();
+/**
+ * @var {{[key:string]:ProxyRequestHandler}}
+ */
+const TYPE_HANDLERS = {
+    rest: proxyRestRequest,
+    web: proxyWebRequest,
+};
+function getResource(resources, resourceName) {
+    return resources.find((resource) => {
+        return resource.metadata.name.toLowerCase() === resourceName.toLowerCase();
+    });
+}
+router.use('/:systemId/:consumerInstanceId/:consumerResourceName', stringBody);
+router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async (req, res) => {
+    try {
+        const typeHandler = TYPE_HANDLERS[req.params.type.toLowerCase()];
+        if (!typeHandler) {
+            res.status(401).send({ error: 'Unknown connection type: ' + req.params.type });
+            return;
+        }
+        const plan = await assetManager.getPlan(req.params.systemId);
+        // We can find the connection by the consumer information alone since
+        // only 1 provider can be connected to a consumer resource at a time
+        const connection = _.find(plan.spec.connections, (connection) => {
+            return (connection.consumer.blockId.toLowerCase() === req.params.consumerInstanceId.toLowerCase() &&
+                connection.consumer.resourceName.toLowerCase() === req.params.consumerResourceName.toLowerCase());
+        });
+        if (!connection) {
+            res.status(401).send({
+                error: `No connection found for consumer "${req.params.consumerInstanceId}::${req.params.consumerResourceName}"`,
+            });
+            return;
+        }
+        const toBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
+            return blockInstance.id.toLowerCase() === connection.consumer.blockId.toLowerCase();
+        });
+        if (!toBlockInstance) {
+            res.status(401).send({ error: `Block instance not found "${req.params.consumerInstanceId}` });
+            return;
+        }
+        const toBlockAsset = await assetManager.getAsset(toBlockInstance.block.ref);
+        if (!toBlockAsset) {
+            res.status(401).send({ error: `Block asset not found "${toBlockInstance.block.ref}` });
+            return;
+        }
+        const consumerResource = getResource(toBlockAsset.data.spec.consumers, req.params.consumerResourceName);
+        if (!consumerResource) {
+            res.status(401).send({
+                error: `Block resource not found "${req.params.consumerInstanceId}::${req.params.consumerResourceName}`,
+            });
+            return;
+        }
+        const basePath = clusterService.getProxyPath(req.params.systemId, req.params.consumerInstanceId, req.params.consumerResourceName, req.params.type);
+        const fromBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
+            return blockInstance.id.toLowerCase() === connection.provider.blockId.toLowerCase();
+        });
+        if (!fromBlockInstance) {
+            res.status(401).send({ error: `Block instance not found "${connection.provider.blockId}` });
+            return;
+        }
+        const fromBlockAsset = await assetManager.getAsset(fromBlockInstance.block.ref);
+        if (!fromBlockAsset) {
+            res.status(401).send({ error: `Block asset not found "${fromBlockInstance.block.ref}` });
+            return;
+        }
+        const providerResource = getResource(fromBlockAsset.data.spec.providers, connection.provider.resourceName);
+        if (!providerResource) {
+            res.status(401).send({
+                error: `Block resource not found "${connection.provider.blockId}::${connection.provider.resourceName}`,
+            });
+            return;
+        }
+        //Get target address
+        let address = await serviceManager.getProviderAddress(req.params.systemId, connection.provider.blockId, req.params.type);
+        while (address.endsWith('/')) {
+            address = address.substring(0, address.length - 1);
+        }
+        /*
+     Get the path the consumer requested.
+     Note that this might not match the path the destination is expecting so we need to identify the method
+     that is being called and identify the destination path from the connection.
+     */
+        const consumerPath = req.originalUrl.substring(basePath.length - 1);
+        typeHandler(req, res, {
+            consumerPath,
+            address,
+            consumerResource,
+            providerResource,
+            connection,
+        });
+    }
+    catch (err) {
+        console.warn('Failed to process proxy request', err);
+        res.status(400).send({ error: err.message });
+    }
+});
+export default router;

package/dist/esm/src/proxy/types/rest.d.ts

@@ -0,0 +1,4 @@
+import { Response } from 'express';
+import { ProxyRequestInfo } from '../../types';
+import { StringBodyRequest } from '../../middleware/stringBody';
+export declare function proxyRestRequest(req: StringBodyRequest, res: Response, opts: ProxyRequestInfo): void;