@kapeta/local-cluster-service 0.6.1 → 0.7.0

package/{src → dist/esm/src}/instances/routes.js

@@ -1,168 +1,129 @@
-const Router = require('express-promise-router').default;
-
-const instanceManager = require('../instanceManager');
-const serviceManager = require('../serviceManager');
-
-
-const router = new Router();
-router.use('/', require('../middleware/cors'));
-
+import Router from 'express-promise-router';
+import { instanceManager } from '../instanceManager';
+import { serviceManager } from '../serviceManager';
+import { corsHandler } from '../middleware/cors';
+import { kapetaHeaders } from '../middleware/kapeta';
+import { stringBody } from '../middleware/stringBody';
+const router = Router();
+router.use('/', corsHandler);
+router.use('/', kapetaHeaders);
 /**
  * Get all instances
  */
 router.get('/', (req, res) => {
     res.send(instanceManager.getInstances());
 });
-
 /**
  * Get all instances
  */
 router.get('/:systemId/instances', (req, res) => {
     res.send(instanceManager.getInstancesForPlan(req.params.systemId));
 });
-
 /**
  * Start all instances in a plan
  */
 router.post('/:systemId/start', async (req, res) => {
     const processes = await instanceManager.createProcessesForPlan(req.params.systemId);
-
     res.status(202).send({
         ok: true,
-        processes: processes.map(p => {
-            return {pid: p.pid, type: p.type};
-        })
+        processes: processes.map((p) => {
+            return { pid: p.pid, type: p.type };
+        }),
     });
 });
-
 /**
  * Stop all instances in plan
  */
 router.post('/:systemId/stop', async (req, res) => {
     await instanceManager.stopAllForPlan(req.params.systemId);
-
     res.status(202).send({
-        ok: true
+        ok: true,
     });
 });
-
 /**
  * Start single instance in a plan
  */
 router.post('/:systemId/:instanceId/start', async (req, res) => {
     const process = await instanceManager.createProcess(req.params.systemId, req.params.instanceId);
-
     res.status(202).send({
         ok: true,
         pid: process.pid,
-        type: process.type
+        type: process.type,
     });
 });
-
 /**
  * Stop single instance in a plan
  */
 router.post('/:systemId/:instanceId/stop', async (req, res) => {
     await instanceManager.stopProcess(req.params.systemId, req.params.instanceId);
-
-    res.status(202).send({ok: true});
+    res.status(202).send({ ok: true });
 });
-
-
 /**
  * Get logs for instance in a plan
  */
 router.get('/:systemId/:instanceId/logs', (req, res) => {
     const processInfo = instanceManager.getProcessForInstance(req.params.systemId, req.params.instanceId);
     if (!processInfo) {
-        res.status(404).send({ok: false});
+        res.status(404).send({ ok: false });
         return;
     }
-
     res.status(202).send({
-        logs: processInfo.logs()
+        logs: processInfo.logs(),
     });
 });
-
-
 /**
  * Get public address for instance in a plan if available
  */
 router.get('/:systemId/:instanceId/address/public', (req, res) => {
     const instance = instanceManager.getInstance(req.params.systemId, req.params.instanceId);
     if (!instance) {
-        res.status(404).send({ok: false});
+        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.`});
+        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.getConsumerAddress(
-        req.params.systemId,
-        req.params.instanceId,
-        req.params.resourceName,
-        req.params.portType,
-        req.headers['x-kapeta-environment'],
-    ));
+    res.send(serviceManager.getConsumerAddress(req.params.systemId, req.params.instanceId, req.params.resourceName, req.params.portType, req.kapeta?.environment));
 });
-
-router.use('/', require('../middleware/stringBody'));
-router.use('/', require('../middleware/kapeta'));
+router.use('/', stringBody);
 router.use('/', (req, res, next) => {
     if (!req.kapeta.blockRef) {
-        res.status(400).send({error: 'Missing X-Kapeta-Block header.'});
+        res.status(400).send({ error: 'Missing X-Kapeta-Block header.' });
         return;
     }
     next();
-})
-
+});
 /**
  * Updates the full configuration for a given service.
  */
 router.put('/', async (req, res) => {
-
-    let instance = JSON.parse(req.stringBody);
+    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.getInstance(
-            req.kapeta.systemId,
-            req.kapeta.instanceId
-        );
+        const oldInstance = instanceManager.getInstance(req.kapeta.systemId, req.kapeta.instanceId);
         if (oldInstance) {
             instance.pid = oldInstance.pid;
         }
         instance.type = 'docker';
-    } else if (req.kapeta.environment === 'process') {
+    }
+    else if (req.kapeta.environment === 'process') {
         instance.type = 'process';
     }
-
-    await instanceManager.registerInstance(
-        req.kapeta.systemId,
-        req.kapeta.instanceId,
-        instance
-    );
-
-    res.status(202).send({ok: true});
+    await instanceManager.registerInstance(req.kapeta.systemId, req.kapeta.instanceId, instance);
+    res.status(202).send({ ok: true });
 });
-
 /**
  * Delete instance
  */
 router.delete('/', async (req, res) => {
     await instanceManager.setInstanceAsStopped(req.kapeta.systemId, req.kapeta.instanceId);
-
-    res.status(202).send({ok: true});
+    res.status(202).send({ ok: true });
 });
-
-
-module.exports = router;
+export default router;

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

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from 'express';
+export declare function corsHandler(req: Request, res: Response, next: NextFunction): void;

package/{src → dist/esm/src}/middleware/cors.js

@@ -1,7 +1,6 @@
-module.exports = function cors(req, res, next) {
+export 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();
-};
+}

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

@@ -0,0 +1,11 @@
+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/{src → dist/esm/src}/middleware/kapeta.js

@@ -1,17 +1,13 @@
-
-module.exports = function kapeta(req, res, next) {
-
+export 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'];
-
     req.kapeta = {
         blockRef,
         instanceId,
         systemId,
-        environment
+        environment: environment ? environment : undefined,
     };
-
     next();
-};
+}

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

@@ -0,0 +1,5 @@
+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/{src → dist/esm/src}/middleware/stringBody.js

@@ -1,5 +1,4 @@
-module.exports = function stringBody (req, res, next) {
-
+export function stringBody(req, res, next) {
     // push the data to body
     const body = [];
     req.on('data', (chunk) => {
@@ -8,4 +7,4 @@ module.exports = function stringBody (req, res, next) {
         req.stringBody = Buffer.concat(body).toString();
         next();
     });
-};
+}

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

@@ -0,0 +1,32 @@
+import { Connection, 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/{src → dist/esm/src}/networkManager.js

@@ -1,93 +1,80 @@
-const uuid = require('node-uuid');
+import uuid from 'node-uuid';
 class NetworkManager {
-
+    _connections;
+    _sources;
+    _targets;
     static toConnectionId(connection) {
         return [
             connection.provider.blockId,
             connection.provider.resourceName,
             connection.consumer.blockId,
-            connection.consumer.resourceName
+            connection.consumer.resourceName,
         ].join('_');
     }
-
     constructor() {
         this._connections = {};
         this._sources = {};
         this._targets = {};
     }
-
     _ensureSystem(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) {
         this._ensureSystem(systemId);
-
         if (!this._connections[systemId][connectionId]) {
             this._connections[systemId][connectionId] = [];
         }
-
         return this._connections[systemId][connectionId];
     }
-
     _ensureSource(systemId, sourceBlockInstanceId) {
         this._ensureSystem(systemId);
-
         if (!this._sources[systemId][sourceBlockInstanceId]) {
             this._sources[systemId][sourceBlockInstanceId] = [];
         }
-
         return this._sources[systemId][sourceBlockInstanceId];
     }
-
     _ensureTarget(systemId, targetBlockInstanceId) {
         this._ensureSystem(systemId);
-
         if (!this._targets[systemId][targetBlockInstanceId]) {
             this._targets[systemId][targetBlockInstanceId] = [];
         }
-
         return this._targets[systemId][targetBlockInstanceId];
     }
-
     addRequest(systemId, connection, request, consumerMethodId, providerMethodId) {
-
         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 = uuid.v4();
         this.connectionId = NetworkManager.toConnectionId(connection);
@@ -99,22 +86,18 @@ class Traffic {
         this.ended = null;
         this.created = new Date().getTime();
     }
-
     asError(err) {
         this.ended = new Date().getTime();
         this.response = {
             code: 0,
             headers: {},
-            body: null
+            body: null,
         };
         this.error = err + '';
     }
-
     withResponse(response) {
         this.ended = new Date().getTime();
         this.response = response;
     }
-
 }
-
-module.exports = new NetworkManager();
+export const networkManager = new NetworkManager();

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

@@ -0,0 +1,36 @@
+import { ContainerInfo } from './containerManager';
+import { EnvironmentType, OperatorInfo } from './types';
+declare class Operator {
+    private _data;
+    constructor(data: any);
+    getData(): any;
+    getCredentials(): any;
+}
+declare class OperatorManager {
+    private _mountDir;
+    constructor();
+    _getMountPoint(operatorType: string, mountName: string): string;
+    /**
+     * Get operator definition for resource type
+     *
+     * @param {string} resourceType
+     * @param {string} version
+     * @return {Operator}
+     */
+    getOperator(resourceType: string, version: string): Operator;
+    /**
+     * Get information about a specific consumed resource
+     */
+    getConsumerResourceInfo(systemId: string, fromServiceId: string, resourceType: string, portType: string, name: string, environment?: EnvironmentType): Promise<OperatorInfo>;
+    /**
+     * Ensure we have a running operator of given type
+     *
+     * @param {string} systemId
+     * @param {string} resourceType
+     * @param {string} version
+     * @return {Promise<ContainerInfo>}
+     */
+    ensureResource(systemId: string, resourceType: string, version: string): Promise<ContainerInfo>;
+}
+export declare const operatorManager: OperatorManager;
+export {};