@kapeta/local-cluster-service 0.6.0 → 0.7.0

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

@@ -1,35 +1,31 @@
-const Router = require('express-promise-router').default;
-const YAML = require('yaml');
-const assetManager = require('../assetManager');
-
+import Router from 'express-promise-router';
+import YAML from 'yaml';
+import { assetManager } from '../assetManager';
+import { corsHandler } from '../middleware/cors';
+import { stringBody } from '../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);
-
+            return JSON.parse(req.stringBody ?? '{}');
         case 'application/yaml':
         case 'application/x-yaml':
         case 'text/yaml':
         case 'text/x-yaml':
         default:
-            return YAML.parse(req.stringBody);
+            return YAML.parse(req.stringBody ?? '{}');
     }
 }
-
-const router = new Router();
-
-router.use('/', require('../middleware/cors'));
-router.use('/', require('../middleware/stringBody'));
-
+const router = Router();
+router.use('/', corsHandler);
+router.use('/', stringBody);
 /**
  * Get all local assets available
  */
 router.get('/', (req, res) => {
     res.send(assetManager.getAssets());
 });
-
 /**
  * Get single asset
  */
@@ -38,14 +34,13 @@ router.get('/read', async (req, res) => {
         res.status(400).send({ error: 'Query parameter "ref" is missing' });
         return;
     }
-
     try {
         res.send(await assetManager.getAsset(req.query.ref, true));
-    } catch (err) {
+    }
+    catch (err) {
         res.status(400).send({ error: err.message });
     }
 });
-
 /**
  * Creates a new local file and registers it as an asset
  */
@@ -54,19 +49,16 @@ router.post('/create', async (req, res) => {
         res.status(400).send({ error: 'Query parameter "path" is missing' });
         return;
     }
-
     const content = parseBody(req);
-
     try {
         const assets = await assetManager.createAsset(req.query.path, content);
-
         res.status(200).send(assets);
-    } catch (err) {
+    }
+    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
  */
@@ -75,19 +67,16 @@ router.put('/update', async (req, res) => {
         res.status(400).send({ error: 'Query parameter "ref" is missing' });
         return;
     }
-
     const content = parseBody(req);
-
     try {
         await assetManager.updateAsset(req.query.ref, content);
-
         res.sendStatus(204);
-    } catch (err) {
+    }
+    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)
  */
@@ -96,16 +85,14 @@ router.delete('/', async (req, res) => {
         res.status(400).send({ error: 'Query parameter "ref" is missing' });
         return;
     }
-
     try {
         await assetManager.unregisterAsset(req.query.ref);
-
         res.status(204).send();
-    } catch (err) {
+    }
+    catch (err) {
         res.status(400).send({ error: err.message });
     }
 });
-
 /**
  * Registers an existing file as an asset
  */
@@ -114,14 +101,12 @@ router.put('/import', async (req, res) => {
         res.status(400).send({ error: 'Query parameter "ref" is missing' });
         return;
     }
-
     try {
         const assets = await assetManager.importFile(req.query.ref);
-
         res.status(200).send(assets);
-    } catch (err) {
+    }
+    catch (err) {
         res.status(400).send({ error: err.message });
     }
 });
-
-module.exports = router;
+export default router;

package/dist/esm/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 {};

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

@@ -2,9 +2,12 @@ const net = require('net');
 const DEFAULT_SERVER_PORT = 35100;
 const DEFAULT_START_PORT = 40000;
 const DEFAULT_HOST = '127.0.0.1';
-
 class ClusterService {
-
+    _port;
+    _currentPort;
+    _initialized;
+    _reservedPorts;
+    _host;
     constructor() {
         this._port = DEFAULT_SERVER_PORT;
         this._currentPort = DEFAULT_START_PORT;
@@ -12,51 +15,38 @@ class ClusterService {
         this._reservedPorts = [];
         this._host = DEFAULT_HOST;
     }
-
     reservePort(port) {
         const intPort = parseInt(port);
         if (this._reservedPorts.indexOf(intPort) > -1) {
             throw new Error('Port already reserved: ' + intPort);
         }
-
         this._reservedPorts.push(intPort);
     }
-
     async init() {
         if (this._initialized) {
             return;
         }
-
         this._initialized = true;
         await this._findClusterServicePort();
-
     }
-
     async _findClusterServicePort() {
-        while(true) {
-
+        while (true) {
             const isUsed = await this._checkIfPortIsUsed(this._port);
             if (!isUsed) {
                 break;
             }
-
             this._port++;
-
         }
     }
-
-
     /**
      * Gets next available port
      * @return {Promise<number>}
      */
     async getNextAvailablePort() {
-        while(true) {
-
+        while (true) {
             while (this._reservedPorts.indexOf(this._currentPort) > -1) {
                 this._currentPort++;
             }
-
             const nextPort = this._currentPort++;
             const isUsed = await this._checkIfPortIsUsed(nextPort);
             if (!isUsed) {
@@ -64,47 +54,37 @@ class ClusterService {
             }
         }
     }
-
-    _checkIfPortIsUsed(port, host=this._host) {
+    _checkIfPortIsUsed(port, host = this._host) {
         return new Promise((resolve, reject) => {
             const server = net.createServer();
-
-            server.once('error', function(err) {
+            server.once('error', function (err) {
                 if (err.code === 'EADDRINUSE') {
                     server.close();
                     resolve(true);
                     return;
                 }
-
                 server.close();
                 reject(err);
             });
-
-            server.once('listening', function() {
+            server.once('listening', function () {
                 server.close();
                 resolve(false);
             });
-
-            server.listen( port, host );
+            server.listen(port, host);
         });
-
     }
-
-
     /**
      * The port of this local cluster service itself
      */
     getClusterServicePort() {
         return this._port;
     }
-    
-    /* 
+    /*
      *Gets the host name ( 127.0.0.1 ) on which Express JS is listening
      */
-     getClusterServiceHost() {
+    getClusterServiceHost() {
         return this._host;
     }
-
     /**
      * Set the port to be used for this local service
      * @param port
@@ -112,11 +92,9 @@ class ClusterService {
     setClusterServicePort(port) {
         this._port = port;
     }
-
     setClusterServiceHost(host) {
         this._host = host;
     }
-
     /**
      * Gets that proxy path of a given request
      *
@@ -130,5 +108,4 @@ class ClusterService {
         return `/proxy/${encodeURIComponent(systemId)}/${encodeURIComponent(consumerInstanceId)}/${encodeURIComponent(consumerResourceName)}/${encodeURIComponent(portType)}/`;
     }
 }
-
-module.exports = new ClusterService();
+export const clusterService = new ClusterService();

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

@@ -0,0 +1,8 @@
+import { BlockDefinition } from '@kapeta/schemas';
+declare class CodeGeneratorManager {
+    reload(): Promise<void>;
+    canGenerateCode(yamlContent: BlockDefinition): boolean;
+    generate(yamlFile: string, yamlContent: BlockDefinition): Promise<void>;
+}
+export declare const codeGeneratorManager: CodeGeneratorManager;
+export {};

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

@@ -1,56 +1,47 @@
-const Path = require('path');
-
-const {registry:Targets, BlockCodeGenerator, CodeWriter} = require('@kapeta/codegen');
-const ClusterConfiguration = require('@kapeta/local-cluster-config').default;
+import Path from 'path';
+import { registry as Targets, BlockCodeGenerator, CodeWriter } from '@kapeta/codegen';
+import ClusterConfiguration from '@kapeta/local-cluster-config';
 const TARGET_KIND = 'core/language-target';
 const BLOCK_TYPE_KIND = 'core/block-type';
-
 class CodeGeneratorManager {
-
-    reload() {
+    async reload() {
         Targets.reset();
         const languageTargets = ClusterConfiguration.getDefinitions(TARGET_KIND);
-        languageTargets.forEach((languageTarget) => {
-            const key = `${languageTarget.definition.metadata.name}:${languageTarget.version}`
+        for (const languageTarget of languageTargets) {
+            const key = `${languageTarget.definition.metadata.name}:${languageTarget.version}`;
             try {
                 const target = require(languageTarget.path);
                 if (target.default) {
                     Targets.register(key, target.default);
-                } else {
+                }
+                else {
                     Targets.register(key, target);
                 }
-            } catch (e) {
+            }
+            catch (e) {
                 console.error('Failed to load target: %s', key, e);
             }
-        });
+        }
     }
-
     canGenerateCode(yamlContent) {
         if (!yamlContent.spec.target?.kind) {
             //Not all block types have targets
             return false;
         }
-
         const blockTypes = ClusterConfiguration.getDefinitions(BLOCK_TYPE_KIND);
-        const blockTypeKinds = blockTypes.map(blockType => blockType.definition.metadata.name.toLowerCase() + ':' + blockType.version);
-        return yamlContent && yamlContent.kind && blockTypeKinds.indexOf(yamlContent.kind.toLowerCase()) > -1;
+        const blockTypeKinds = blockTypes.map((blockType) => blockType.definition.metadata.name.toLowerCase() + ':' + blockType.version);
+        return !!(yamlContent && yamlContent.kind && blockTypeKinds.indexOf(yamlContent.kind.toLowerCase()) > -1);
     }
-
     async generate(yamlFile, yamlContent) {
         const baseDir = Path.dirname(yamlFile);
         console.log('Generating code for path: %s', baseDir);
         const codeGenerator = new BlockCodeGenerator(yamlContent);
-
         const output = await codeGenerator.generate();
         const writer = new CodeWriter(baseDir, {});
         const assets = writer.write(output);
-
         await codeGenerator.postprocess(baseDir, assets);
-
         console.log('Code generated for path: %s', baseDir);
     }
 }
-
-const manager = new CodeGeneratorManager();
-manager.reload();
-module.exports = manager;
+export const codeGeneratorManager = new CodeGeneratorManager();
+codeGeneratorManager.reload();

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

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

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

@@ -0,0 +1,121 @@
+import Router from 'express-promise-router';
+import { configManager } from '../configManager';
+import { serviceManager } from '../serviceManager';
+import { operatorManager } from '../operatorManager';
+import { instanceManager } from '../instanceManager';
+import { corsHandler } from '../middleware/cors';
+import { kapetaHeaders } from '../middleware/kapeta';
+import { stringBody } from '../middleware/stringBody';
+const router = Router();
+const SYSTEM_ID = '$plan';
+router.use('/', corsHandler);
+router.use('/', kapetaHeaders);
+router.use('/', stringBody);
+/**
+ * Returns the full configuration for a given service.
+ */
+router.get('/instance', (req, res) => {
+    const config = req.kapeta.instanceId
+        ? configManager.getConfigForSection(req.kapeta.systemId, req.kapeta.instanceId)
+        : configManager.getConfigForSystem(req.kapeta.systemId);
+    res.send(config);
+});
+/**
+ * Updates the full configuration for a given service.
+ */
+router.put('/instance', async (req, res) => {
+    try {
+        let config = JSON.parse(req.stringBody ?? '{}');
+        if (!config) {
+            config = {};
+        }
+        if (req.kapeta.instanceId) {
+            configManager.setConfigForSection(req.kapeta.systemId, req.kapeta.instanceId, config);
+            //Restart the instance if it is running after config change
+            await instanceManager.restartIfRunning(req.kapeta.systemId, req.kapeta.instanceId);
+        }
+        else {
+            configManager.setConfigForSystem(req.kapeta.systemId, config);
+        }
+    }
+    catch (err) {
+        console.error('Failed to update instance config', err);
+        res.status(400).send({ error: err.message });
+        return;
+    }
+    res.status(202).send({ ok: true });
+});
+/**
+ * Returns the full configuration for a plan
+ */
+router.get('/system', (req, res) => {
+    const config = configManager.getConfigForSection(req.kapeta.systemId, SYSTEM_ID);
+    res.send(config);
+});
+/**
+ * Updates the full configuration for a plan
+ */
+router.put('/system', (req, res) => {
+    let config = JSON.parse(req.stringBody ?? '{}');
+    if (!config) {
+        config = {};
+    }
+    configManager.setConfigForSection(req.kapeta.systemId, SYSTEM_ID, config);
+    res.status(202).send({ ok: true });
+});
+/**
+ * Resolves and checks the identity of a block instance
+ */
+router.get('/identity', async (req, res) => {
+    const identity = {
+        systemId: req.kapeta.systemId,
+        instanceId: req.kapeta.instanceId,
+    };
+    if (!req.kapeta.blockRef) {
+        res.status(400).send({ error: 'Missing required header "X-Kapeta-Block"' });
+        return;
+    }
+    try {
+        if (!identity.systemId || !identity.instanceId) {
+            const { systemId, instanceId } = await configManager.resolveIdentity(req.kapeta.blockRef, identity.systemId);
+            identity.systemId = systemId;
+            identity.instanceId = instanceId;
+        }
+        else {
+            await configManager.verifyIdentity(req.kapeta.blockRef, identity.systemId, identity.instanceId);
+        }
+        res.send(identity);
+    }
+    catch (err) {
+        console.warn('Failed to resolve identity', err);
+        res.status(400).send({ error: err.message });
+    }
+});
+/**
+ * Services call this to request a free port. If a service has
+ * already called the endpoint the same port is returned.
+ */
+router.get('/provides/:type', async (req, res) => {
+    //Get service port
+    res.send('' + (await serviceManager.ensureServicePort(req.kapeta.systemId, req.kapeta.instanceId, req.params.type)));
+});
+/**
+ * Used by services to get info for consumed operator resource.
+ *
+ * If the operator resource is not already available this will cause it to start an instance and
+ * assign port numbers to it etc.
+ */
+router.get('/consumes/resource/:resourceType/:portType/:name', async (req, res) => {
+    const operatorInfo = await operatorManager.getConsumerResourceInfo(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceType, req.params.portType, req.params.name, req.kapeta.environment);
+    res.send(operatorInfo);
+});
+/**
+ * Used by services to get address for their clients.
+ *
+ * If the remote service is not already registered with a port - we do that here
+ * to handle clients for services that hasn't started yet.
+ */
+router.get('/consumes/:resourceName/:type', (req, res) => {
+    res.send(serviceManager.getConsumerAddress(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceName, req.params.type, req.kapeta.environment));
+});
+export default router;

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

@@ -0,0 +1,36 @@
+type AnyMap = {
+    [key: string]: any;
+};
+interface MatchedIdentity {
+    systemId: string;
+    instanceId: string;
+}
+declare class ConfigManager {
+    private _config;
+    constructor();
+    _forSystem(systemId: string): any;
+    setConfigForSystem(systemId: string, config: AnyMap): void;
+    getConfigForSystem(systemId: string): AnyMap;
+    setConfigForSection(systemId: string, sectionId: string, config: AnyMap): void;
+    getConfigForSection(systemId: string, sectionId: string): any;
+    /**
+     * Try to identify the plan and instance in a plan automatically based on the block reference
+     *
+     * It will:
+     * 1. Go through all plans available in the assets
+     * 2. Look through each plan and see if the plan is referencing the block
+     * 3. If only 1 plan references the block - assume that as the system id
+     * 4. If only 1 instance in 1 plan references the block - assume that as instance id
+     *
+     * In case multiple uses of the same block reference we will prompt to user to choose which instance they want to
+     * use.
+     *
+     * @param blockRef block reference
+     * @param [systemId] plan reference
+     * @returns {Promise<{systemId:string,instanceId:string}>}
+     */
+    resolveIdentity(blockRef: string, systemId?: string): Promise<MatchedIdentity>;
+    verifyIdentity(blockRef: string, systemId: string, instanceId: string): Promise<void>;
+}
+export declare const configManager: ConfigManager;
+export {};