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

package/src/instances/routes.ts

@@ -0,0 +1,203 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import Router from 'express-promise-router';
+import { instanceManager } from '../instanceManager';
+import { serviceManager } from '../serviceManager';
+import { corsHandler } from '../middleware/cors';
+import { NextFunction, Request, Response } from 'express';
+import { kapetaHeaders, KapetaRequest } from '../middleware/kapeta';
+import { stringBody } from '../middleware/stringBody';
+import { DesiredInstanceStatus, InstanceInfo, InstanceOwner, InstanceType, KapetaBodyRequest } from '../types';
+import { Task } from '../taskManager';
+
+const router = Router();
+router.use('/', corsHandler);
+router.use('/', kapetaHeaders);
+/**
+ * Get all instances
+ */
+router.get('/', (req: Request, res: Response) => {
+    res.send(instanceManager.getInstances());
+});
+
+/**
+ * Get all instances
+ */
+router.get('/:systemId/instances', async (req: Request, res: Response) => {
+    res.send(await instanceManager.getInstancesForPlan(req.params.systemId));
+});
+
+/**
+ * Get single instance in a plan
+ */
+router.get('/:systemId/instances/:instanceId', (req: Request, res: Response) => {
+    res.send(instanceManager.getInstance(req.params.systemId, req.params.instanceId));
+});
+
+/**
+ * Start all instances in a plan
+ */
+router.post('/:systemId/start', async (req: Request, res: Response) => {
+    try {
+        const task = await instanceManager.startAllForPlan(req.params.systemId);
+
+        res.status(202).send({
+            ok: true,
+            taskId: task.id,
+        });
+    } catch (e: any) {
+        res.status(500).send({ ok: false, error: e.message });
+    }
+});
+
+/**
+ * Stop all instances in plan
+ */
+router.post('/:systemId/stop', async (req: Request, res: Response) => {
+    const task = 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: Request, res: Response) => {
+    try {
+        const result = await instanceManager.start(req.params.systemId, req.params.instanceId);
+        if (result instanceof 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: any) {
+        res.status(500).send({ ok: false, error: e.message });
+    }
+});
+
+/**
+ * Stop single instance in a plan
+ */
+router.post('/:systemId/:instanceId/stop', async (req: Request, res: Response) => {
+    await 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: Request, res: Response) => {
+    const instanceInfo = instanceManager.getInstance(req.params.systemId, req.params.instanceId);
+    if (!instanceInfo) {
+        res.status(404).send({ ok: false });
+        return;
+    }
+
+    try {
+        const logs = await instanceManager.getLogs(req.params.systemId, req.params.instanceId);
+        res.status(200).send({
+            logs,
+        });
+    } catch (e: any) {
+        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: Request, res: Response) => {
+    const instance = 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: KapetaRequest, res: Response) => {
+        res.send(
+            serviceManager.getConsumerAddress(
+                req.params.systemId,
+                req.params.instanceId,
+                req.params.resourceName,
+                req.params.portType,
+                req.kapeta?.environment
+            )
+        );
+    }
+);
+
+router.use('/', stringBody);
+router.use('/', (req: KapetaBodyRequest, res: Response, next: NextFunction) => {
+    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: KapetaBodyRequest, res: Response) => {
+    let instance: InstanceInfo = 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.getInstance(req.kapeta!.systemId, req.kapeta!.instanceId);
+        if (oldInstance) {
+            instance.pid = oldInstance.pid;
+            instance.desiredStatus = oldInstance.desiredStatus;
+        }
+        instance.type = InstanceType.DOCKER;
+        instance.owner = InstanceOwner.INTERNAL;
+    } else {
+        // Coming from user starting the instance outside of kapeta
+        instance.type = InstanceType.LOCAL;
+        instance.owner = InstanceOwner.EXTERNAL;
+        instance.desiredStatus = DesiredInstanceStatus.EXTERNAL;
+    }
+
+    try {
+        await instanceManager.registerInstanceFromSDK(req.kapeta!.systemId, req.kapeta!.instanceId, instance);
+        res.status(202).send({ ok: true });
+    } catch (e: any) {
+        res.status(400).send({ error: e.message });
+    }
+});
+
+/**
+ * Delete instance
+ */
+router.delete('/', async (req: KapetaRequest, res: Response) => {
+    await instanceManager.markAsStopped(req.kapeta!.systemId, req.kapeta!.instanceId);
+
+    res.status(202).send({ ok: true });
+});
+
+export default router;

package/src/middleware/cors.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import { NextFunction, Request, Response } from 'express';
+
+export function corsHandler(req: Request, res: Response, next: NextFunction) {
+    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();
+}

package/src/middleware/kapeta.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import { NextFunction, Request, Response } from 'express';
+import { EnvironmentType } from '../types';
+import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
+
+export interface KapetaRequest extends Request {
+    kapeta?: {
+        blockRef: string;
+        instanceId: string;
+        systemId: string;
+        environment?: EnvironmentType;
+    };
+}
+
+export function kapetaHeaders(req: KapetaRequest, res: Response, next: NextFunction) {
+    let blockRef: string = req.headers['x-kapeta-block'] as string;
+    let systemId: string = req.headers['x-kapeta-system'] as string;
+    let instanceId: string = req.headers['x-kapeta-instance'] as string;
+    let environment: string = req.headers['x-kapeta-environment'] as string;
+
+    if (blockRef) {
+        blockRef = normalizeKapetaUri(blockRef);
+    }
+
+    if (systemId) {
+        systemId = normalizeKapetaUri(systemId);
+    }
+
+    req.kapeta = {
+        blockRef,
+        instanceId,
+        systemId,
+        environment: environment ? (environment as EnvironmentType) : undefined,
+    };
+
+    next();
+}

package/src/middleware/stringBody.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import { NextFunction, Request, Response } from 'express';
+
+export type StringBodyRequest = Request<any> & {
+    stringBody?: string;
+};
+
+export function stringBody(req: StringBodyRequest, res: Response, next: NextFunction) {
+    // push the data to body
+    const body: Buffer[] = [];
+    req.on('data', (chunk) => {
+        body.push(chunk);
+    }).on('end', () => {
+        req.stringBody = Buffer.concat(body).toString();
+        next();
+    });
+}

package/src/networkManager.ts

@@ -0,0 +1,148 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import { Connection } from '@kapeta/schemas';
+import uuid from 'node-uuid';
+import { SimpleRequest, SimpleResponse } from './types';
+import { normalizeKapetaUri } from '@kapeta/nodejs-utils';
+
+class NetworkManager {
+    private _connections: { [systemId: string]: { [connectionId: string]: Traffic[] } };
+    private _sources: { [systemId: string]: { [instanceId: string]: Traffic[] } };
+    private _targets: { [systemId: string]: { [instanceId: string]: Traffic[] } };
+
+    static toConnectionId(connection: Connection) {
+        return [
+            connection.provider.blockId,
+            connection.provider.resourceName,
+            connection.consumer.blockId,
+            connection.consumer.resourceName,
+        ].join('_');
+    }
+
+    constructor() {
+        this._connections = {};
+        this._sources = {};
+        this._targets = {};
+    }
+
+    _ensureSystem(systemId: string) {
+        systemId = 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: string, connectionId: string) {
+        systemId = normalizeKapetaUri(systemId);
+        this._ensureSystem(systemId);
+
+        if (!this._connections[systemId][connectionId]) {
+            this._connections[systemId][connectionId] = [];
+        }
+
+        return this._connections[systemId][connectionId];
+    }
+
+    _ensureSource(systemId: string, sourceBlockInstanceId: string) {
+        systemId = normalizeKapetaUri(systemId);
+        this._ensureSystem(systemId);
+
+        if (!this._sources[systemId][sourceBlockInstanceId]) {
+            this._sources[systemId][sourceBlockInstanceId] = [];
+        }
+
+        return this._sources[systemId][sourceBlockInstanceId];
+    }
+
+    _ensureTarget(systemId: string, targetBlockInstanceId: string) {
+        systemId = normalizeKapetaUri(systemId);
+        this._ensureSystem(systemId);
+
+        if (!this._targets[systemId][targetBlockInstanceId]) {
+            this._targets[systemId][targetBlockInstanceId] = [];
+        }
+
+        return this._targets[systemId][targetBlockInstanceId];
+    }
+
+    addRequest(
+        systemId: string,
+        connection: Connection,
+        request: SimpleRequest,
+        consumerMethodId?: string,
+        providerMethodId?: string
+    ) {
+        systemId = 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: string, connectionId: string) {
+        return this._ensureConnection(systemId, connectionId);
+    }
+
+    getTrafficForSource(systemId: string, blockInstanceId: string) {
+        return this._ensureSource(systemId, blockInstanceId);
+    }
+
+    getTrafficForTarget(systemId: string, blockInstanceId: string) {
+        return this._ensureTarget(systemId, blockInstanceId);
+    }
+}
+
+class Traffic {
+    public readonly id: string;
+    public readonly connectionId: string;
+    public readonly consumerMethodId: string | undefined;
+    public readonly providerMethodId: string | undefined;
+    public readonly created: number;
+    public readonly request: SimpleRequest;
+    public ended: null | number;
+    public error: null | string;
+    public response: SimpleResponse | null;
+
+    constructor(connection: Connection, request: SimpleRequest, consumerMethodId?: string, providerMethodId?: string) {
+        this.id = uuid.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: any) {
+        this.ended = new Date().getTime();
+        this.response = {
+            code: 0,
+            headers: {},
+            body: null,
+        };
+        this.error = err + '';
+    }
+
+    withResponse(response: SimpleResponse) {
+        this.ended = new Date().getTime();
+        this.response = response;
+    }
+}
+
+export const networkManager = new NetworkManager();