@kapeta/local-cluster-service 0.6.0 → 0.7.0

package/{src → dist/esm/src}/configManager.js

@@ -1,49 +1,36 @@
-const _ = require('lodash');
-const storageService = require('./storageService');
-const assetManager = require('./assetManager');
-const {parseKapetaUri} = require("@kapeta/nodejs-utils");
-
+import { storageService } from './storageService';
+import { assetManager } from './assetManager';
+import { parseKapetaUri } from '@kapeta/nodejs-utils';
 class ConfigManager {
-
+    _config;
     constructor() {
         this._config = storageService.section('config');
     }
-
     _forSystem(systemId) {
         if (!this._config[systemId]) {
             this._config[systemId] = {};
         }
-
         return this._config[systemId];
     }
-
     setConfigForSystem(systemId, config) {
         const systemConfig = config || {};
-
         storageService.put('config', systemId, systemConfig);
     }
-
     getConfigForSystem(systemId) {
         return this._forSystem(systemId);
     }
-
     setConfigForSection(systemId, sectionId, config) {
         let systemConfig = this._forSystem(systemId);
         systemConfig[sectionId] = config || {};
-
         storageService.put('config', systemId, systemConfig);
     }
-
     getConfigForSection(systemId, sectionId) {
         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
      *
@@ -62,75 +49,59 @@ class ConfigManager {
      */
     async resolveIdentity(blockRef, systemId) {
         const planAssets = assetManager.getPlans();
-
         const blockUri = 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 = parseKapetaUri(blockInstance.block.ref);
                 if (refUri.equals(blockUri)) {
                     matchingIdentities.push({
                         systemId: planAsset.ref,
-                        instanceId: blockInstance.id
+                        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 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 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) {
-        const planAssets = await assetManager.getPlans();
+        const planAssets = assetManager.getPlans();
         const systemUri = systemId ? parseKapetaUri(systemId) : null;
         const blockUri = parseKapetaUri(blockRef);
         let found = false;
         planAssets.forEach((planAsset) => {
-            if (systemUri &&
-                !parseKapetaUri(planAsset.ref).equals(systemUri)) {
+            if (systemUri && !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 &&
-                    parseKapetaUri(blockInstance.block.ref).equals(blockUri)) {
+                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.`);
         }
     }
 }
-
-module.exports = new ConfigManager();
+export const configManager = new ConfigManager();

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

@@ -0,0 +1,89 @@
+import { Docker } from 'node-docker-api';
+import { Container } from 'node-docker-api/lib/container';
+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;
+}
+interface Health {
+    cmd: string;
+    interval?: number;
+    timeout?: number;
+    retries?: number;
+}
+declare class ContainerManager {
+    private _docker;
+    private _alive;
+    private _mountDir;
+    constructor();
+    initialize(): Promise<void>;
+    isAlive(): boolean;
+    getMountPoint(kind: string, mountName: string): string;
+    createMounts(kind: string, mountOpts: StringMap): StringMap;
+    ping(): Promise<void>;
+    docker(): Docker;
+    getContainerByName(containerName: string): Promise<Container | undefined>;
+    pull(image: string, cacheForMS?: number): Promise<void>;
+    toDockerMounts(mounts: StringMap): DockerMounts[];
+    toDockerHealth(health: Health): {
+        Test: string[];
+        Interval: number;
+        Timeout: number;
+        Retries: number;
+    };
+    run(image: string, name: string, opts: {
+        ports: {};
+        mounts: {};
+        env: {};
+        cmd: string;
+        health: Health;
+    }): Promise<ContainerInfo>;
+    startContainer(opts: any): Promise<Container>;
+    waitForReady(container: Container, attempt?: number): Promise<void>;
+    waitForHealthy(container: Container, attempt?: number): Promise<void>;
+    _isReady(container: Container): Promise<any>;
+    _isHealthy(container: Container): Promise<boolean>;
+    /**
+     *
+     * @param name
+     * @return {Promise<ContainerInfo>}
+     */
+    get(name: string): Promise<ContainerInfo | null>;
+}
+export declare class ContainerInfo {
+    private readonly _container;
+    /**
+     *
+     * @param {Container} dockerContainer
+     */
+    constructor(dockerContainer: Container);
+    get native(): Container;
+    isRunning(): Promise<any>;
+    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>;
+    getStatus(): Promise<any>;
+    getPorts(): Promise<PortMap | false>;
+}
+export declare const containerManager: ContainerManager;
+export {};