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

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

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+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)();
+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', async (req, res) => {
+    try {
+        let config = {};
+        if (req.kapeta.instanceId) {
+            config = await configManager_1.configManager.getConfigForBlockInstance(req.kapeta.systemId, req.kapeta.instanceId);
+        }
+        else {
+            config = configManager_1.configManager.getConfigForSystem(req.kapeta.systemId);
+        }
+        res.send(config);
+    }
+    catch (err) {
+        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, 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.prepareForRestart(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, configManager_1.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, configManager_1.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) => {
+    if (req.kapeta.environment === 'docker' && serviceManager_1.HTTP_PORTS.includes(req.params.type)) {
+        // Happens when starting a local container with no providers.
+        res.send('80');
+        return;
+    }
+    try {
+        const port = await serviceManager_1.serviceManager.ensureServicePort(req.kapeta.systemId, req.kapeta.instanceId, req.params.type);
+        res.send('' + port);
+    }
+    catch (err) {
+        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, 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, 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, res) => {
+    res.send(serviceManager_1.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, res) => {
+    const operatorInfo = await instanceManager_1.instanceManager.getInstanceOperator(req.kapeta.systemId, req.params.instanceId, req.kapeta.environment, req.query.ensure !== 'false');
+    res.send(operatorInfo);
+});
+exports.default = router;

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

@@ -0,0 +1,42 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export declare const SYSTEM_ID = "$plan";
+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;
+    getConfigForBlockInstance(systemId: string, instanceId: string): Promise<import("./types").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,136 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = exports.SYSTEM_ID = void 0;
+const storageService_1 = require("./storageService");
+const assetManager_1 = require("./assetManager");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const utils_1 = require("./utils/utils");
+exports.SYSTEM_ID = '$plan';
+class ConfigManager {
+    _config;
+    constructor() {
+        this._config = storageService_1.storageService.section('config');
+    }
+    _forSystem(systemId) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        if (!this._config[systemId]) {
+            this._config[systemId] = {};
+        }
+        return this._config[systemId];
+    }
+    setConfigForSystem(systemId, config) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        const systemConfig = config || {};
+        storageService_1.storageService.put('config', systemId, systemConfig);
+    }
+    getConfigForSystem(systemId) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        return this._forSystem(systemId);
+    }
+    async getConfigForBlockInstance(systemId, instanceId) {
+        const blockInstance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
+        const blockAsset = await assetManager_1.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 (0, utils_1.getResolvedConfiguration)(blockAsset.data.spec.configuration, instanceConfig, blockInstance.defaultConfiguration);
+    }
+    setConfigForSection(systemId, sectionId, config) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        let systemConfig = this._forSystem(systemId);
+        systemConfig[sectionId] = config || {};
+        storageService_1.storageService.put('config', systemId, systemConfig);
+    }
+    getConfigForSection(systemId, sectionId) {
+        systemId = (0, nodejs_utils_1.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, systemId) {
+        blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockRef);
+        if (systemId) {
+            systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        }
+        const planAssets = await 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: (0, nodejs_utils_1.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, systemId, instanceId) {
+        blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockRef);
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        const planAssets = await 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,148 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="node" />
+import FSExtra from 'fs-extra';
+import Docker from 'dockerode';
+import { InstanceInfo, LogEntry } from './types';
+import { Task } from './taskManager';
+import { LocalInstanceHealth } from '@kapeta/schemas';
+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;
+    Labels?: StringMap;
+}
+export type DockerContainerStatus = 'created' | 'running' | 'paused' | 'restarting' | 'removing' | 'exited' | 'dead';
+export type DockerContainerHealth = 'starting' | 'healthy' | 'unhealthy' | 'none';
+export declare const CONTAINER_LABEL_PORT_PREFIX = "kapeta_port-";
+export declare const COMPOSE_LABEL_PROJECT = "com.docker.compose.project";
+export declare const COMPOSE_LABEL_SERVICE = "com.docker.compose.service";
+export declare const HEALTH_CHECK_TIMEOUT: number;
+declare class ContainerManager {
+    private _docker;
+    private _alive;
+    private _mountDir;
+    private _version;
+    private _lastDockerAccessCheck;
+    private logStreams;
+    private _latestImagePulls;
+    constructor();
+    initialize(): Promise<void>;
+    checkAlive(): Promise<boolean>;
+    isAlive(): boolean;
+    getMountPoint(systemId: string, ref: string, mountName: string): string;
+    createMounts(systemId: string, kind: string, mountOpts: StringMap | null | undefined): Promise<StringMap>;
+    createVolumes(systemId: string, serviceId: string, mountOpts: StringMap | null | undefined): Promise<DockerMounts[]>;
+    ping(): Promise<void>;
+    docker(): Docker;
+    getContainerByName(containerName: string): Promise<ContainerInfo | undefined>;
+    pull(image: string): Promise<boolean>;
+    toDockerMounts(mounts: StringMap): DockerMounts[];
+    toDockerHealth(health: LocalInstanceHealth): {
+        Test: string[];
+        Interval: number;
+        Timeout: number;
+        Retries: any;
+    };
+    private applyHash;
+    ensureContainer(opts: any): Promise<Docker.Container>;
+    private createOrUpdateContainer;
+    private startContainer;
+    waitForReady(container: Docker.Container, attempt?: number): Promise<void>;
+    _isReady(container: Docker.Container): Promise<boolean>;
+    remove(container: Docker.Container, opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     *
+     * @param name
+     * @return {Promise<ContainerInfo>}
+     */
+    get(name: string): Promise<ContainerInfo | undefined>;
+    getLogs(instance: InstanceInfo): Promise<LogEntry[]>;
+    stopLogListening(systemId: string, instanceId: string): Promise<void>;
+    ensureLogListening(systemId: string, instanceId: string, handler: (log: LogEntry) => void): Promise<void>;
+    buildDockerImage(dockerFile: string, imageName: string): Task<void>;
+}
+declare class ClosableLogStream {
+    private readonly stream;
+    private readonly eventEmitter;
+    constructor(stream: FSExtra.ReadStream);
+    onLog(listener: (log: LogEntry) => void): () => void;
+    onEnd(listener: () => void): () => void;
+    onError(listener: (error: Error) => void): () => void;
+    close(): Promise<void>;
+}
+export declare class ContainerInfo {
+    private readonly _container;
+    /**
+     *
+     * @param {Docker.Container} dockerContainer
+     */
+    constructor(dockerContainer: Docker.Container);
+    get native(): Docker.Container;
+    isRunning(): Promise<boolean>;
+    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>;
+    inspect(): Promise<Docker.ContainerInspectInfo | undefined>;
+    status(): Promise<{
+        Status: string;
+        Running: boolean;
+        Paused: boolean;
+        Restarting: boolean;
+        OOMKilled: boolean;
+        Dead: boolean;
+        Pid: number;
+        ExitCode: number;
+        Error: string;
+        StartedAt: string;
+        FinishedAt: string;
+        Health?: {
+            Status: string;
+            FailingStreak: number;
+            Log: {
+                Start: string;
+                End: string;
+                ExitCode: number;
+                Output: string;
+            }[];
+        } | undefined;
+    } | undefined>;
+    getPorts(): Promise<PortMap | false>;
+    getLogStream(): Promise<ClosableLogStream>;
+    getLogs(): Promise<LogEntry[]>;
+}
+export declare function getExtraHosts(dockerVersion: string): string[] | undefined;
+/**
+ * Ensure that the volume is in the correct format for the docker daemon on the host
+ *
+ * Windows: c:\path\to\volume -> /c/path/to/volume
+ * Linux: /path/to/volume -> /path/to/volume
+ * Mac: /path/to/volume -> /path/to/volume
+ */
+export declare function toLocalBindVolume(volume: string): string;
+export declare const containerManager: ContainerManager;
+export {};