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

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

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

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

@@ -0,0 +1,179 @@
+"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 instanceManager_1 = require("../instanceManager");
+const serviceManager_1 = require("../serviceManager");
+const cors_1 = require("../middleware/cors");
+const kapeta_1 = require("../middleware/kapeta");
+const stringBody_1 = require("../middleware/stringBody");
+const types_1 = require("../types");
+const taskManager_1 = require("../taskManager");
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.use('/', kapeta_1.kapetaHeaders);
+/**
+ * Get all instances
+ */
+router.get('/', (req, res) => {
+    res.send(instanceManager_1.instanceManager.getInstances());
+});
+/**
+ * Get all instances
+ */
+router.get('/:systemId/instances', async (req, res) => {
+    res.send(await instanceManager_1.instanceManager.getInstancesForPlan(req.params.systemId));
+});
+/**
+ * Get single instance in a plan
+ */
+router.get('/:systemId/instances/:instanceId', (req, res) => {
+    res.send(instanceManager_1.instanceManager.getInstance(req.params.systemId, req.params.instanceId));
+});
+/**
+ * Start all instances in a plan
+ */
+router.post('/:systemId/start', async (req, res) => {
+    try {
+        const task = await instanceManager_1.instanceManager.startAllForPlan(req.params.systemId);
+        res.status(202).send({
+            ok: true,
+            taskId: task.id,
+        });
+    }
+    catch (e) {
+        res.status(500).send({ ok: false, error: e.message });
+    }
+});
+/**
+ * Stop all instances in plan
+ */
+router.post('/:systemId/stop', async (req, res) => {
+    const task = instanceManager_1.instanceManager.stopAllForPlan(req.params.systemId);
+    res.status(202).send({
+        ok: true,
+        taskId: task.id,
+    });
+});
+/**
+ * Start single instance in a plan
+ */
+router.post('/:systemId/:instanceId/start', async (req, res) => {
+    try {
+        const result = await instanceManager_1.instanceManager.start(req.params.systemId, req.params.instanceId);
+        if (result instanceof taskManager_1.Task) {
+            res.status(202).send({
+                ok: true,
+                taskId: result.id,
+            });
+        }
+        else {
+            res.status(202).send({
+                ok: true,
+                pid: result.pid,
+                type: result.type,
+            });
+        }
+    }
+    catch (e) {
+        res.status(500).send({ ok: false, error: e.message });
+    }
+});
+/**
+ * Stop single instance in a plan
+ */
+router.post('/:systemId/:instanceId/stop', async (req, res) => {
+    await instanceManager_1.instanceManager.stop(req.params.systemId, req.params.instanceId);
+    res.status(202).send({ ok: true });
+});
+/**
+ * Get logs for instance in a plan
+ */
+router.get('/:systemId/:instanceId/logs', async (req, res) => {
+    const instanceInfo = instanceManager_1.instanceManager.getInstance(req.params.systemId, req.params.instanceId);
+    if (!instanceInfo) {
+        res.status(404).send({ ok: false });
+        return;
+    }
+    try {
+        const logs = await instanceManager_1.instanceManager.getLogs(req.params.systemId, req.params.instanceId);
+        res.status(200).send({
+            logs,
+        });
+    }
+    catch (e) {
+        res.status(500).send({ ok: false, error: e.message });
+    }
+});
+/**
+ * Get public address for instance in a plan if available
+ */
+router.get('/:systemId/:instanceId/address/public', (req, res) => {
+    const instance = instanceManager_1.instanceManager.getInstance(req.params.systemId, req.params.instanceId);
+    if (!instance) {
+        res.status(404).send({ ok: false });
+        return;
+    }
+    if (!instance.address) {
+        res.status(400).send({ error: `Instance does not have an address. Make sure it's running.` });
+        return;
+    }
+    res.status(200).send(instance.address);
+});
+/**
+ * Get public address for particular resource on instance in a plan if available
+ */
+router.get('/:systemId/:instanceId/provider/:portType/:resourceName/address/public', (req, res) => {
+    res.send(serviceManager_1.serviceManager.getConsumerAddress(req.params.systemId, req.params.instanceId, req.params.resourceName, req.params.portType, req.kapeta?.environment));
+});
+router.use('/', stringBody_1.stringBody);
+router.use('/', (req, res, next) => {
+    if (!req.kapeta.blockRef) {
+        res.status(400).send({ error: 'Missing X-Kapeta-Block header.' });
+        return;
+    }
+    next();
+});
+/**
+ * Updates the full configuration for a given instance.
+ */
+router.put('/', async (req, res) => {
+    let instance = req.stringBody ? JSON.parse(req.stringBody) : null;
+    if (req.kapeta.environment === 'docker') {
+        //A bit hacky but we want to avoid overwriting the docker PID with a process PID
+        const oldInstance = instanceManager_1.instanceManager.getInstance(req.kapeta.systemId, req.kapeta.instanceId);
+        if (oldInstance) {
+            instance.pid = oldInstance.pid;
+            instance.desiredStatus = oldInstance.desiredStatus;
+        }
+        instance.type = types_1.InstanceType.DOCKER;
+        instance.owner = types_1.InstanceOwner.INTERNAL;
+    }
+    else {
+        // Coming from user starting the instance outside of kapeta
+        instance.type = types_1.InstanceType.LOCAL;
+        instance.owner = types_1.InstanceOwner.EXTERNAL;
+        instance.desiredStatus = types_1.DesiredInstanceStatus.EXTERNAL;
+    }
+    try {
+        await instanceManager_1.instanceManager.registerInstanceFromSDK(req.kapeta.systemId, req.kapeta.instanceId, instance);
+        res.status(202).send({ ok: true });
+    }
+    catch (e) {
+        res.status(400).send({ error: e.message });
+    }
+});
+/**
+ * Delete instance
+ */
+router.delete('/', async (req, res) => {
+    await instanceManager_1.instanceManager.markAsStopped(req.kapeta.systemId, req.kapeta.instanceId);
+    res.status(202).send({ ok: true });
+});
+exports.default = router;

package/dist/esm/src/middleware/cors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { NextFunction, Request, Response } from 'express';
+export declare function corsHandler(req: Request, res: Response, next: NextFunction): void;

package/dist/esm/src/middleware/cors.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corsHandler = void 0;
+function corsHandler(req, res, next) {
+    res.set('Access-Control-Allow-Origin', req.headers.origin);
+    res.set('Access-Control-Allow-Methods', 'GET, PUT, POST, DELETE, HEAD, PATCH');
+    res.set('Access-Control-Allow-Headers', '*');
+    next();
+}
+exports.corsHandler = corsHandler;

package/dist/esm/src/middleware/kapeta.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { NextFunction, Request, Response } from 'express';
+import { EnvironmentType } from '../types';
+export interface KapetaRequest extends Request {
+    kapeta?: {
+        blockRef: string;
+        instanceId: string;
+        systemId: string;
+        environment?: EnvironmentType;
+    };
+}
+export declare function kapetaHeaders(req: KapetaRequest, res: Response, next: NextFunction): void;

package/dist/esm/src/middleware/kapeta.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kapetaHeaders = void 0;
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+function kapetaHeaders(req, res, next) {
+    let blockRef = req.headers['x-kapeta-block'];
+    let systemId = req.headers['x-kapeta-system'];
+    let instanceId = req.headers['x-kapeta-instance'];
+    let environment = req.headers['x-kapeta-environment'];
+    if (blockRef) {
+        blockRef = (0, nodejs_utils_1.normalizeKapetaUri)(blockRef);
+    }
+    if (systemId) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+    }
+    req.kapeta = {
+        blockRef,
+        instanceId,
+        systemId,
+        environment: environment ? environment : undefined,
+    };
+    next();
+}
+exports.kapetaHeaders = kapetaHeaders;

package/dist/esm/src/middleware/stringBody.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { NextFunction, Request, Response } from 'express';
+export type StringBodyRequest = Request<any> & {
+    stringBody?: string;
+};
+export declare function stringBody(req: StringBodyRequest, res: Response, next: NextFunction): void;

package/dist/esm/src/middleware/stringBody.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringBody = void 0;
+function stringBody(req, res, next) {
+    // push the data to body
+    const body = [];
+    req.on('data', (chunk) => {
+        body.push(chunk);
+    }).on('end', () => {
+        req.stringBody = Buffer.concat(body).toString();
+        next();
+    });
+}
+exports.stringBody = stringBody;

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

@@ -0,0 +1,37 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { Connection } from '@kapeta/schemas';
+import { SimpleRequest, SimpleResponse } from './types';
+declare class NetworkManager {
+    private _connections;
+    private _sources;
+    private _targets;
+    static toConnectionId(connection: Connection): string;
+    constructor();
+    _ensureSystem(systemId: string): void;
+    _ensureConnection(systemId: string, connectionId: string): Traffic[];
+    _ensureSource(systemId: string, sourceBlockInstanceId: string): Traffic[];
+    _ensureTarget(systemId: string, targetBlockInstanceId: string): Traffic[];
+    addRequest(systemId: string, connection: Connection, request: SimpleRequest, consumerMethodId?: string, providerMethodId?: string): Traffic;
+    getTrafficForConnection(systemId: string, connectionId: string): Traffic[];
+    getTrafficForSource(systemId: string, blockInstanceId: string): Traffic[];
+    getTrafficForTarget(systemId: string, blockInstanceId: string): Traffic[];
+}
+declare class Traffic {
+    readonly id: string;
+    readonly connectionId: string;
+    readonly consumerMethodId: string | undefined;
+    readonly providerMethodId: string | undefined;
+    readonly created: number;
+    readonly request: SimpleRequest;
+    ended: null | number;
+    error: null | string;
+    response: SimpleResponse | null;
+    constructor(connection: Connection, request: SimpleRequest, consumerMethodId?: string, providerMethodId?: string);
+    asError(err: any): void;
+    withResponse(response: SimpleResponse): void;
+}
+export declare const networkManager: NetworkManager;
+export {};

package/dist/esm/src/networkManager.js

@@ -0,0 +1,119 @@
+"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 });
+exports.networkManager = void 0;
+const node_uuid_1 = __importDefault(require("node-uuid"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+class NetworkManager {
+    _connections;
+    _sources;
+    _targets;
+    static toConnectionId(connection) {
+        return [
+            connection.provider.blockId,
+            connection.provider.resourceName,
+            connection.consumer.blockId,
+            connection.consumer.resourceName,
+        ].join('_');
+    }
+    constructor() {
+        this._connections = {};
+        this._sources = {};
+        this._targets = {};
+    }
+    _ensureSystem(systemId) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        if (!this._connections[systemId]) {
+            this._connections[systemId] = {};
+        }
+        if (!this._sources[systemId]) {
+            this._sources[systemId] = {};
+        }
+        if (!this._targets[systemId]) {
+            this._targets[systemId] = {};
+        }
+    }
+    _ensureConnection(systemId, connectionId) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        this._ensureSystem(systemId);
+        if (!this._connections[systemId][connectionId]) {
+            this._connections[systemId][connectionId] = [];
+        }
+        return this._connections[systemId][connectionId];
+    }
+    _ensureSource(systemId, sourceBlockInstanceId) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        this._ensureSystem(systemId);
+        if (!this._sources[systemId][sourceBlockInstanceId]) {
+            this._sources[systemId][sourceBlockInstanceId] = [];
+        }
+        return this._sources[systemId][sourceBlockInstanceId];
+    }
+    _ensureTarget(systemId, targetBlockInstanceId) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        this._ensureSystem(systemId);
+        if (!this._targets[systemId][targetBlockInstanceId]) {
+            this._targets[systemId][targetBlockInstanceId] = [];
+        }
+        return this._targets[systemId][targetBlockInstanceId];
+    }
+    addRequest(systemId, connection, request, consumerMethodId, providerMethodId) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        const traffic = new Traffic(connection, request, consumerMethodId, providerMethodId);
+        this._ensureConnection(systemId, traffic.connectionId).push(traffic);
+        this._ensureSource(systemId, connection.provider.blockId).push(traffic);
+        this._ensureTarget(systemId, connection.consumer.blockId).push(traffic);
+        return traffic;
+    }
+    getTrafficForConnection(systemId, connectionId) {
+        return this._ensureConnection(systemId, connectionId);
+    }
+    getTrafficForSource(systemId, blockInstanceId) {
+        return this._ensureSource(systemId, blockInstanceId);
+    }
+    getTrafficForTarget(systemId, blockInstanceId) {
+        return this._ensureTarget(systemId, blockInstanceId);
+    }
+}
+class Traffic {
+    id;
+    connectionId;
+    consumerMethodId;
+    providerMethodId;
+    created;
+    request;
+    ended;
+    error;
+    response;
+    constructor(connection, request, consumerMethodId, providerMethodId) {
+        this.id = node_uuid_1.default.v4();
+        this.connectionId = NetworkManager.toConnectionId(connection);
+        this.consumerMethodId = consumerMethodId;
+        this.providerMethodId = providerMethodId;
+        this.request = request;
+        this.response = null;
+        this.error = null;
+        this.ended = null;
+        this.created = new Date().getTime();
+    }
+    asError(err) {
+        this.ended = new Date().getTime();
+        this.response = {
+            code: 0,
+            headers: {},
+            body: null,
+        };
+        this.error = err + '';
+    }
+    withResponse(response) {
+        this.ended = new Date().getTime();
+        this.response = response;
+    }
+}
+exports.networkManager = new NetworkManager();

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

@@ -0,0 +1,41 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
+import { ContainerInfo } from './containerManager';
+import { AnyMap, EnvironmentType } from './types';
+import { LocalInstance } from '@kapeta/schemas';
+import { ResourceInfo } from '@kapeta/sdk-config';
+declare class Operator {
+    private readonly _data;
+    constructor(data: DefinitionInfo);
+    getLocalData(): LocalInstance;
+    getDefinitionInfo(): DefinitionInfo;
+    getCredentials(): any;
+}
+declare class OperatorManager {
+    private _mountDir;
+    private operatorLock;
+    constructor();
+    _getMountPoint(operatorType: string, mountName: string): string;
+    /**
+     * Get operator definition for resource type
+     */
+    getOperator(fullName: string, version: string): Promise<Operator>;
+    /**
+     * Get information about a specific consumed resource
+     */
+    getConsumerResourceInfo(systemId: string, fromServiceId: string, resourceType: string, portType: string, name: string, environment?: EnvironmentType, ensureContainer?: boolean): Promise<ResourceInfo<any, any>>;
+    getOperatorPorts(systemId: string, kind: string, version: string): Promise<AnyMap>;
+    /**
+     * Ensure we have a running operator of given type
+     *
+     * @param systemId the plan ref
+     * @param kind the full name - e.g. myhandle/rabbitmq
+     * @param version the version of the operator
+     */
+    ensureOperator(systemId: string, kind: string, version: string): Promise<ContainerInfo>;
+}
+export declare const operatorManager: OperatorManager;
+export {};