@kapeta/local-cluster-service 0.6.1 → 0.7.0

package/dist/cjs/src/clusterService.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clusterService = void 0;
+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;
+        this._initialized = false;
+        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) {
+            const isUsed = await this._checkIfPortIsUsed(this._port);
+            if (!isUsed) {
+                break;
+            }
+            this._port++;
+        }
+    }
+    /**
+     * Gets next available port
+     * @return {Promise<number>}
+     */
+    async getNextAvailablePort() {
+        while (true) {
+            while (this._reservedPorts.indexOf(this._currentPort) > -1) {
+                this._currentPort++;
+            }
+            const nextPort = this._currentPort++;
+            const isUsed = await this._checkIfPortIsUsed(nextPort);
+            if (!isUsed) {
+                return nextPort;
+            }
+        }
+    }
+    _checkIfPortIsUsed(port, host = this._host) {
+        return new Promise((resolve, reject) => {
+            const server = net.createServer();
+            server.once('error', function (err) {
+                if (err.code === 'EADDRINUSE') {
+                    server.close();
+                    resolve(true);
+                    return;
+                }
+                server.close();
+                reject(err);
+            });
+            server.once('listening', function () {
+                server.close();
+                resolve(false);
+            });
+            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() {
+        return this._host;
+    }
+    /**
+     * Set the port to be used for this local service
+     * @param port
+     */
+    setClusterServicePort(port) {
+        this._port = port;
+    }
+    setClusterServiceHost(host) {
+        this._host = host;
+    }
+    /**
+     * Gets that proxy path of a given request
+     *
+     * @param systemId
+     * @param consumerInstanceId
+     * @param consumerResourceName
+     * @param portType
+     * @return {string}
+     */
+    getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType) {
+        return `/proxy/${encodeURIComponent(systemId)}/${encodeURIComponent(consumerInstanceId)}/${encodeURIComponent(consumerResourceName)}/${encodeURIComponent(portType)}/`;
+    }
+}
+exports.clusterService = new ClusterService();

package/dist/cjs/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/dist/cjs/src/codeGeneratorManager.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeGeneratorManager = void 0;
+const path_1 = __importDefault(require("path"));
+const codegen_1 = require("@kapeta/codegen");
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const TARGET_KIND = 'core/language-target';
+const BLOCK_TYPE_KIND = 'core/block-type';
+class CodeGeneratorManager {
+    async reload() {
+        codegen_1.registry.reset();
+        const languageTargets = local_cluster_config_1.default.getDefinitions(TARGET_KIND);
+        for (const languageTarget of languageTargets) {
+            const key = `${languageTarget.definition.metadata.name}:${languageTarget.version}`;
+            try {
+                const target = require(languageTarget.path);
+                if (target.default) {
+                    codegen_1.registry.register(key, target.default);
+                }
+                else {
+                    codegen_1.registry.register(key, target);
+                }
+            }
+            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 = local_cluster_config_1.default.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);
+    }
+    async generate(yamlFile, yamlContent) {
+        const baseDir = path_1.default.dirname(yamlFile);
+        console.log('Generating code for path: %s', baseDir);
+        const codeGenerator = new codegen_1.BlockCodeGenerator(yamlContent);
+        const output = await codeGenerator.generate();
+        const writer = new codegen_1.CodeWriter(baseDir, {});
+        const assets = writer.write(output);
+        await codeGenerator.postprocess(baseDir, assets);
+        console.log('Code generated for path: %s', baseDir);
+    }
+}
+exports.codeGeneratorManager = new CodeGeneratorManager();
+exports.codeGeneratorManager.reload();

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

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

package/dist/cjs/src/config/routes.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 express_promise_router_1 = __importDefault(require("express-promise-router"));
+const configManager_1 = require("../configManager");
+const serviceManager_1 = require("../serviceManager");
+const operatorManager_1 = require("../operatorManager");
+const instanceManager_1 = require("../instanceManager");
+const cors_1 = require("../middleware/cors");
+const kapeta_1 = require("../middleware/kapeta");
+const stringBody_1 = require("../middleware/stringBody");
+const router = (0, express_promise_router_1.default)();
+const SYSTEM_ID = '$plan';
+router.use('/', cors_1.corsHandler);
+router.use('/', kapeta_1.kapetaHeaders);
+router.use('/', stringBody_1.stringBody);
+/**
+ * Returns the full configuration for a given service.
+ */
+router.get('/instance', (req, res) => {
+    const config = req.kapeta.instanceId
+        ? configManager_1.configManager.getConfigForSection(req.kapeta.systemId, req.kapeta.instanceId)
+        : configManager_1.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_1.configManager.setConfigForSection(req.kapeta.systemId, req.kapeta.instanceId, config);
+            //Restart the instance if it is running after config change
+            await instanceManager_1.instanceManager.restartIfRunning(req.kapeta.systemId, req.kapeta.instanceId);
+        }
+        else {
+            configManager_1.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_1.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_1.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_1.configManager.resolveIdentity(req.kapeta.blockRef, identity.systemId);
+            identity.systemId = systemId;
+            identity.instanceId = instanceId;
+        }
+        else {
+            await configManager_1.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_1.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_1.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_1.serviceManager.getConsumerAddress(req.kapeta.systemId, req.kapeta.instanceId, req.params.resourceName, req.params.type, req.kapeta.environment));
+});
+exports.default = router;

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

package/dist/cjs/src/configManager.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = void 0;
+const storageService_1 = require("./storageService");
+const assetManager_1 = require("./assetManager");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+class ConfigManager {
+    _config;
+    constructor() {
+        this._config = storageService_1.storageService.section('config');
+    }
+    _forSystem(systemId) {
+        if (!this._config[systemId]) {
+            this._config[systemId] = {};
+        }
+        return this._config[systemId];
+    }
+    setConfigForSystem(systemId, config) {
+        const systemConfig = config || {};
+        storageService_1.storageService.put('config', systemId, systemConfig);
+    }
+    getConfigForSystem(systemId) {
+        return this._forSystem(systemId);
+    }
+    setConfigForSection(systemId, sectionId, config) {
+        let systemConfig = this._forSystem(systemId);
+        systemConfig[sectionId] = config || {};
+        storageService_1.storageService.put('config', systemId, systemConfig);
+    }
+    getConfigForSection(systemId, sectionId) {
+        const systemConfig = this._forSystem(systemId);
+        if (!systemConfig[sectionId]) {
+            systemConfig[sectionId] = {};
+        }
+        return systemConfig[sectionId];
+    }
+    /**
+     * 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}>}
+     */
+    async resolveIdentity(blockRef, systemId) {
+        const planAssets = assetManager_1.assetManager.getPlans();
+        const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockRef);
+        let matchingIdentities = [];
+        planAssets.forEach((planAsset) => {
+            if (systemId && planAsset.ref !== systemId) {
+                //Skip plans that do not match systemid if provided
+                return;
+            }
+            if (!planAsset.data.spec.blocks) {
+                return;
+            }
+            planAsset.data.spec.blocks.forEach((blockInstance) => {
+                const refUri = (0, nodejs_utils_1.parseKapetaUri)(blockInstance.block.ref);
+                if (refUri.equals(blockUri)) {
+                    matchingIdentities.push({
+                        systemId: planAsset.ref,
+                        instanceId: blockInstance.id,
+                    });
+                }
+            });
+        });
+        if (matchingIdentities.length === 0) {
+            if (systemId) {
+                throw new Error(`No uses of block "${blockRef}" was found in plan: "${systemId}"`);
+            }
+            throw new Error(`No uses of block "${blockRef}" was found in any known plan`);
+        }
+        if (matchingIdentities.length > 1) {
+            if (systemId) {
+                throw new Error(`Multiple uses of block "${blockRef}" was found in plan: "${systemId}". Please specify which instance in the plan you wish to run.`);
+            }
+            throw new Error(`Multiple uses of block "${blockRef}" was found in 1 or more plan. Please specify which instance in which plan you wish to run.`);
+        }
+        return matchingIdentities[0];
+    }
+    async verifyIdentity(blockRef, systemId, instanceId) {
+        const planAssets = assetManager_1.assetManager.getPlans();
+        const systemUri = systemId ? (0, nodejs_utils_1.parseKapetaUri)(systemId) : null;
+        const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockRef);
+        let found = false;
+        planAssets.forEach((planAsset) => {
+            if (systemUri && !(0, nodejs_utils_1.parseKapetaUri)(planAsset.ref).equals(systemUri)) {
+                //Skip plans that do not match systemid if provided
+                return;
+            }
+            planAsset.data.spec.blocks.forEach((blockInstance) => {
+                if (blockInstance.id === instanceId && (0, nodejs_utils_1.parseKapetaUri)(blockInstance.block.ref).equals(blockUri)) {
+                    found = true;
+                }
+            });
+        });
+        if (!found) {
+            throw new Error(`Block "${blockRef}" was not found in plan: "${systemId}" using instance id ${instanceId}. Please verify that the provided information is accurate.`);
+        }
+    }
+}
+exports.configManager = new ConfigManager();

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

@@ -0,0 +1,89 @@
+import { Docker } from 'node-docker-api';
+import { Container } from 'node-docker-api/lib/container';
+type StringMap = {
+    [key: string]: string;
+};
+export type PortMap = {
+    [key: string]: {
+        containerPort: string;
+        protocol: string;
+        hostPort: string;
+    };
+};
+export interface DockerMounts {
+    Target: string;
+    Source: string;
+    Type: string;
+    ReadOnly: boolean;
+    Consistency: string;
+}
+interface Health {
+    cmd: string;
+    interval?: number;
+    timeout?: number;
+    retries?: number;
+}
+declare class ContainerManager {
+    private _docker;
+    private _alive;
+    private _mountDir;
+    constructor();
+    initialize(): Promise<void>;
+    isAlive(): boolean;
+    getMountPoint(kind: string, mountName: string): string;
+    createMounts(kind: string, mountOpts: StringMap): StringMap;
+    ping(): Promise<void>;
+    docker(): Docker;
+    getContainerByName(containerName: string): Promise<Container | undefined>;
+    pull(image: string, cacheForMS?: number): Promise<void>;
+    toDockerMounts(mounts: StringMap): DockerMounts[];
+    toDockerHealth(health: Health): {
+        Test: string[];
+        Interval: number;
+        Timeout: number;
+        Retries: number;
+    };
+    run(image: string, name: string, opts: {
+        ports: {};
+        mounts: {};
+        env: {};
+        cmd: string;
+        health: Health;
+    }): Promise<ContainerInfo>;
+    startContainer(opts: any): Promise<Container>;
+    waitForReady(container: Container, attempt?: number): Promise<void>;
+    waitForHealthy(container: Container, attempt?: number): Promise<void>;
+    _isReady(container: Container): Promise<any>;
+    _isHealthy(container: Container): Promise<boolean>;
+    /**
+     *
+     * @param name
+     * @return {Promise<ContainerInfo>}
+     */
+    get(name: string): Promise<ContainerInfo | null>;
+}
+export declare class ContainerInfo {
+    private readonly _container;
+    /**
+     *
+     * @param {Container} dockerContainer
+     */
+    constructor(dockerContainer: Container);
+    get native(): Container;
+    isRunning(): Promise<any>;
+    start(): Promise<void>;
+    restart(): Promise<void>;
+    stop(): Promise<void>;
+    remove(opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    getPort(type: string): Promise<{
+        containerPort: string;
+        protocol: string;
+        hostPort: string;
+    } | null>;
+    getStatus(): Promise<any>;
+    getPorts(): Promise<PortMap | false>;
+}
+export declare const containerManager: ContainerManager;
+export {};