@kapeta/local-cluster-service 0.0.0-96f91ef

package/src/config/routes.ts

@@ -0,0 +1,201 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import Router from 'express-promise-router';
+import { configManager, SYSTEM_ID } from '../configManager';
+import { HTTP_PORTS, serviceManager } from '../serviceManager';
+import { operatorManager } from '../operatorManager';
+import { instanceManager } from '../instanceManager';
+import { corsHandler } from '../middleware/cors';
+import { kapetaHeaders, KapetaRequest } from '../middleware/kapeta';
+import { stringBody } from '../middleware/stringBody';
+import { AnyMap, KapetaBodyRequest } from '../types';
+import { Response } from 'express';
+
+const router = Router();
+
+router.use('/', corsHandler);
+router.use('/', kapetaHeaders);
+router.use('/', stringBody);
+
+/**
+ * Returns the full configuration for a given service.
+ */
+router.get('/instance', async (req: KapetaBodyRequest, res: Response) => {
+    try {
+        let config: AnyMap = {};
+        if (req.kapeta!.instanceId) {
+            config = await configManager.getConfigForBlockInstance(req.kapeta!.systemId, req.kapeta!.instanceId);
+        } else {
+            config = configManager.getConfigForSystem(req.kapeta!.systemId);
+        }
+
+        res.send(config);
+    } catch (err: any) {
+        console.error('Failed to get instance config', err);
+        res.status(400).send({ error: err.message });
+        return;
+    }
+});
+
+/**
+ * Updates the full configuration for a given service.
+ */
+router.put('/instance', async (req: KapetaBodyRequest, 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.prepareForRestart(req.kapeta!.systemId, req.kapeta!.instanceId);
+        } else {
+            configManager.setConfigForSystem(req.kapeta!.systemId, config);
+        }
+    } catch (err: any) {
+        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: KapetaRequest, res) => {
+    const config = configManager.getConfigForSection(req.kapeta!.systemId, SYSTEM_ID);
+
+    res.send(config);
+});
+
+/**
+ * Updates the full configuration for a plan
+ */
+router.put('/system', (req: KapetaBodyRequest, 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: KapetaRequest, 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: any) {
+        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: KapetaRequest, res) => {
+    if (req.kapeta!.environment === 'docker' && HTTP_PORTS.includes(req.params.type)) {
+        // Happens when starting a local container with no providers.
+        res.send('80');
+        return;
+    }
+
+    try {
+        const port = await serviceManager.ensureServicePort(
+            req.kapeta!.systemId,
+            req.kapeta!.instanceId,
+            req.params.type
+        );
+        res.send('' + port);
+    } catch (err: any) {
+        console.warn('Failed to resolve service port: ' + req.params.type, err);
+        res.status(400).send({ error: err.message });
+    }
+});
+
+/**
+ * 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: KapetaRequest, res) => {
+    const operatorInfo = await operatorManager.getConsumerResourceInfo(
+        req.kapeta!.systemId,
+        req.kapeta!.instanceId,
+        req.params.resourceType,
+        req.params.portType,
+        req.params.name,
+        req.kapeta!.environment,
+        req.query.ensure !== 'false'
+    );
+
+    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: KapetaRequest, res) => {
+    res.send(
+        serviceManager.getConsumerAddress(
+            req.kapeta!.systemId,
+            req.kapeta!.instanceId,
+            req.params.resourceName,
+            req.params.type,
+            req.kapeta!.environment
+        )
+    );
+});
+
+/**
+ * Used by services to information about a block operator
+ *
+ * If the remote service is not already running it will be started
+ */
+router.get('/operator/:instanceId', async (req: KapetaRequest, res) => {
+    const operatorInfo = await instanceManager.getInstanceOperator(
+        req.kapeta!.systemId,
+        req.params.instanceId,
+        req.kapeta!.environment,
+        req.query.ensure !== 'false'
+    );
+
+    res.send(operatorInfo);
+});
+
+export default router;

package/src/configManager.ts

@@ -0,0 +1,180 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import { EnrichedAsset } from './assetManager';
+import { BlockInstance } from '@kapeta/schemas';
+import { storageService } from './storageService';
+import { assetManager } from './assetManager';
+import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
+import { getResolvedConfiguration } from './utils/utils';
+
+export const SYSTEM_ID = '$plan';
+type AnyMap = { [key: string]: any };
+
+interface MatchedIdentity {
+    systemId: string;
+    instanceId: string;
+}
+
+class ConfigManager {
+    private _config: AnyMap;
+
+    constructor() {
+        this._config = storageService.section('config');
+    }
+
+    _forSystem(systemId: string) {
+        systemId = normalizeKapetaUri(systemId);
+        if (!this._config[systemId]) {
+            this._config[systemId] = {};
+        }
+
+        return this._config[systemId];
+    }
+
+    setConfigForSystem(systemId: string, config: AnyMap) {
+        systemId = normalizeKapetaUri(systemId);
+        const systemConfig = config || {};
+
+        storageService.put('config', systemId, systemConfig);
+    }
+
+    getConfigForSystem(systemId: string): AnyMap {
+        systemId = normalizeKapetaUri(systemId);
+        return this._forSystem(systemId);
+    }
+
+    async getConfigForBlockInstance(systemId: string, instanceId: string) {
+        const blockInstance = await assetManager.getBlockInstance(systemId, instanceId);
+        const blockAsset = await assetManager.getAsset(blockInstance.block.ref, true);
+        if (!blockAsset) {
+            throw new Error(`Block definition not found: ${blockInstance.block.ref}`);
+        }
+        const instanceConfig = this.getConfigForSection(systemId, instanceId);
+        return getResolvedConfiguration(
+            blockAsset.data.spec.configuration,
+            instanceConfig,
+            blockInstance.defaultConfiguration
+        );
+    }
+
+    setConfigForSection(systemId: string, sectionId: string, config: AnyMap) {
+        systemId = normalizeKapetaUri(systemId);
+        let systemConfig = this._forSystem(systemId);
+        systemConfig[sectionId] = config || {};
+
+        storageService.put('config', systemId, systemConfig);
+    }
+
+    getConfigForSection(systemId: string, sectionId: string) {
+        systemId = normalizeKapetaUri(systemId);
+        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: string, systemId?: string) {
+        blockRef = normalizeKapetaUri(blockRef);
+        if (systemId) {
+            systemId = normalizeKapetaUri(systemId);
+        }
+        const planAssets = await assetManager.getPlans();
+
+        const blockUri = parseKapetaUri(blockRef);
+
+        let matchingIdentities: MatchedIdentity[] = [];
+        planAssets.forEach((planAsset: EnrichedAsset) => {
+            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: BlockInstance) => {
+                const refUri = parseKapetaUri(blockInstance.block.ref);
+                if (refUri.equals(blockUri)) {
+                    matchingIdentities.push({
+                        systemId: normalizeKapetaUri(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: string, systemId: string, instanceId: string) {
+        blockRef = normalizeKapetaUri(blockRef);
+        systemId = normalizeKapetaUri(systemId);
+        const planAssets = await assetManager.getPlans();
+        const systemUri = systemId ? parseKapetaUri(systemId) : null;
+        const blockUri = parseKapetaUri(blockRef);
+        let found = false;
+        planAssets.forEach((planAsset: EnrichedAsset) => {
+            if (systemUri && !parseKapetaUri(planAsset.ref).equals(systemUri)) {
+                //Skip plans that do not match systemid if provided
+                return;
+            }
+
+            planAsset.data.spec.blocks.forEach((blockInstance: BlockInstance) => {
+                if (blockInstance.id === instanceId && 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.`
+            );
+        }
+    }
+}
+
+export const configManager = new ConfigManager();