@constellation-network/node-pilot 0.0.7 → 0.0.9

package/dist/checks/check-wallet.js

@@ -0,0 +1,37 @@
+import chalk from "chalk";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { promptHelper } from "../helpers/prompt-helper.js";
+export const checkWallet = {
+    async checkCollateral() {
+        const { type } = configStore.getNetworkInfo();
+        if (type !== 'mainnet')
+            return;
+        const skipCollateralCheck = configStore.hasProjectFlag('skipCollateralCheck');
+        if (skipCollateralCheck)
+            return;
+        clm.preStep('Checking for required collateral...');
+        const { dagAddress } = configStore.getProjectInfo();
+        const url = `https://be-mainnet.constellationnetwork.io/addresses/${dagAddress}/balance`;
+        let hasError = false;
+        const balance = await fetch(url)
+            .then(res => res.json())
+            .then(i => i.data.balance)
+            .catch(() => {
+            clm.warn(`Failed to fetch balance from ${url}`);
+            hasError = true;
+        });
+        if (!hasError && balance < 25_000_000_000_000) {
+            clm.warn(`You need at least 250k DAG to run a validator node. Your account ${chalk.cyan(dagAddress)} has a balance of ${chalk.cyan(balance)} DAG.`);
+            hasError = true;
+        }
+        if (hasError) {
+            clm.echo('You may continue and skip this check in the future');
+            await promptHelper.doYouWishToContinue();
+        }
+        else {
+            clm.postStep('Collateral check PASSED');
+        }
+        configStore.setProjectFlag('skipCollateralCheck', true);
+    }
+};

package/dist/clm.d.ts

@@ -1,6 +1,7 @@
 export declare const clm: {
     debug(msg: string): void;
     echo(msg: string): void;
+    echoRepeatLine(char: string): void;
     error(msg: string, silent?: boolean): never;
     postStep(s: string): void;
     preStep(s: string): void;

package/dist/clm.js

@@ -11,6 +11,9 @@ export const clm = {
     echo(msg) {
         console.log(msg);
     },
+    echoRepeatLine(char) {
+        process.stdout.write('\r' + char);
+    },
     error(msg, silent = true) {
         console.error(chalk.red(msg));
         process.exit(silent ? 0 : 1);
@@ -19,7 +22,7 @@ export const clm = {
         console.log(chalk.green(s));
     },
     preStep(s) {
-        console.log('\n', chalk.italic(chalk.green(s)));
+        console.log('\n' + chalk.italic(chalk.green(s)));
     },
     step(msg) {
         console.warn(chalk.whiteBright(msg));

package/dist/commands/config/get.d.ts

@@ -5,5 +5,11 @@ export default class ConfigGet extends Command {
     };
     static description: string;
     static examples: string[];
+    getKeyInfo(): {
+        KEY_ALIAS: string;
+        KEY_FILE: string;
+        NODE_ADDRESS: string;
+        NODE_ID: string;
+    };
     run(): Promise<void>;
 }

package/dist/commands/config/get.js

@@ -1,5 +1,6 @@
 import { Args, Command } from '@oclif/core';
-import { commonEnvNames, configStore, layerEnvNames } from "../../config-store.js";
+import { clm } from "../../clm.js";
+import { configStore, layerEnvNames, networkEnvNames } from "../../config-store.js";
 import { configHelper } from "../../helpers/config-helper.js";
 export default class ConfigGet extends Command {
     static args = {
@@ -11,27 +12,72 @@ export default class ConfigGet extends Command {
         '<%= config.bin %> <%= command.id %> CL_EXTERNAL_IP',
         '<%= config.bin %> <%= command.id %> gl0:CL_PUBLIC_HTTP_PORT',
     ];
+    getKeyInfo() {
+        const { dagAddress, nodeId } = configStore.getProjectInfo();
+        const { CL_KEYALIAS, CL_KEYSTORE } = configStore.getEnvInfo();
+        return {
+            KEY_ALIAS: CL_KEYALIAS,
+            KEY_FILE: CL_KEYSTORE,
+            NODE_ADDRESS: dagAddress,
+            NODE_ID: nodeId,
+        };
+    }
     async run() {
         configHelper.assertProject('No configuration found. ');
         const { args } = await this.parse(ConfigGet);
-        const info = configStore.getEnvInfo();
+        // const info = configStore.getEnvInfo();
         const { layersToRun } = configStore.getProjectInfo();
-        const common = info.common;
-        const layers = info.layers;
+        const { type: network } = configStore.getNetworkInfo();
+        const networkEnv = configStore.getEnvNetworkInfo(network);
+        // const networkProp = info.network as Record<string, string>;
+        // const layers = info.layers as Record<string, Record<string, string>>;
+        const gl = (l) => configStore.getEnvLayerInfo(network, l);
         if (Object.keys(args).length === 0 || args.name === undefined) {
-            const commonsList = Object.keys(commonEnvNames).sort().map(k => ({ name: k, value: common[k] }));
-            const layersList = layersToRun.map(l => (Object.keys(layerEnvNames).map(k => ({ name: `${l}:${k}`, value: layers[l][k] }))));
-            // const layersList = layersToRun.map(l => (Object.keys(layerEnvNames).map(k => `${l}:${k}="${green(layers[l][k] || '')}"`)))
-            configHelper.showEnvInfoList(commonsList);
+            const networkList = Object.keys(networkEnvNames).sort().map(k => ({ name: k, value: networkEnv[k] }));
+            const layersList = layersToRun.map(l => (Object.keys(layerEnvNames).map(k => ({ name: `${l}:${k}`, value: gl(l)[k] }))));
+            const keyInfo = this.getKeyInfo();
+            const keyInfoList = Object.keys(keyInfo).map(k => ({ name: 'key:' + k, value: keyInfo[k] }));
+            configHelper.showEnvInfoList(networkList);
+            configHelper.showEnvInfoList(keyInfoList);
             configHelper.showEnvInfoList(layersList.flat());
         }
         else if (args.name.includes(':')) {
             const [layer, name] = args.name.split(':');
-            configHelper.showEnvInfo(args.name, layers[layer][name]);
+            if (layer === 'key') {
+                const keyInfo = this.getKeyInfo();
+                if (Object.hasOwn(keyInfo, name)) {
+                    configHelper.showEnvInfo(args.name, keyInfo[name]);
+                }
+                else {
+                    clm.warn('Invalid key property. Valid properties are: ' + Object.keys(keyInfo).join(', '));
+                }
+            }
+            else if (!layersToRun.includes(layer)) {
+                clm.warn(`Layer ${layer} is not running. Valid layers are: ` + layersToRun.join(', '));
+            }
+            else if (Object.hasOwn(layerEnvNames, name)) {
+                configHelper.showEnvInfo(args.name, gl(layer)[name]);
+            }
+            else {
+                clm.warn('Invalid layer property. Valid properties are: ' + Object.keys(layerEnvNames).join(', '));
+            }
+        }
+        else if (args.name === 'key') {
+            const keyInfo = this.getKeyInfo();
+            const keyInfoList = Object.keys(keyInfo).map(k => ({ name: 'key:' + k, value: keyInfo[k] }));
+            configHelper.showEnvInfoList(keyInfoList);
+        }
+        else if (layersToRun.includes(args.name)) {
+            const layer = args.name;
+            const list = Object.keys(layerEnvNames).map(k => ({ name: `${layer}:${k}`, value: gl(layer)[k] }));
+            configHelper.showEnvInfoList(list);
         }
         else {
-            // const props = keyof EnvCommonInfo
-            configHelper.showEnvInfo(args.name, common[args.name]);
+            if (!Object.hasOwn(networkEnvNames, args.name)) {
+                clm.warn('Invalid network-wide property. Valid properties are: ' + Object.keys(networkEnvNames).join(', '));
+                return;
+            }
+            configHelper.showEnvInfo(args.name, networkEnv[args.name]);
         }
     }
 }

package/dist/commands/config/set.d.ts

@@ -6,6 +6,5 @@ export default class ConfigSet extends Command {
     };
     static description: string;
     static examples: string[];
-    logErrorAndExit(message: string): void;
     run(): Promise<void>;
 }

package/dist/commands/config/set.js

@@ -1,5 +1,7 @@
 import { Args, Command } from '@oclif/core';
-import { commonEnvNames, configStore, layerEnvNames } from "../../config-store.js";
+import chalk from "chalk";
+import { clm } from "../../clm.js";
+import { configStore, layerEnvNames, networkEnvNames } from "../../config-store.js";
 import { configHelper } from "../../helpers/config-helper.js";
 export default class ConfigSet extends Command {
     static args = {
@@ -11,31 +13,31 @@ export default class ConfigSet extends Command {
         '<%= config.bin %> <%= command.id %> CL_EXTERNAL_IP 127.0.0.1',
         '<%= config.bin %> <%= command.id %> gl0:CL_PUBLIC_HTTP_PORT 9000',
     ];
-    logErrorAndExit(message) {
-        this.log(message);
-        this.exit(0);
-    }
     async run() {
         configHelper.assertProject('No configuration found. ');
         const { args } = await this.parse(ConfigSet);
         const { layersToRun } = configStore.getProjectInfo();
+        if (args.name.startsWith('key')) {
+            clm.error(`Key properties cannot be set directly. Please run ${chalk.cyan('cpilot config')} and select ${chalk.cyan('Key Info')} to manage the key file.`);
+        }
+        const { type: network } = configStore.getNetworkInfo();
         if (args.name.includes(':')) {
             const [layer, name] = args.name.split(':');
             if (!layersToRun.includes(layer)) {
-                this.logErrorAndExit(`Invalid layer: ${layer}. Available layers: ${layersToRun.join(',')}`);
+                clm.error(`Invalid layer: ${layer}. Available layers: ${layersToRun.join(',')}`);
             }
             const validLayer = layer;
             if (!Object.hasOwn(layerEnvNames, name)) {
-                this.logErrorAndExit(`Invalid layer configuration name: ${name}`);
+                clm.error(`Invalid layer configuration name: ${name}. Valid names are: ${Object.keys(layerEnvNames).join(', ')}`);
             }
-            configStore.setEnvLayerInfo(validLayer, { [name]: args.value });
+            configStore.setEnvLayerInfo(network, validLayer, { [name]: args.value });
         }
         else {
             const { name } = args;
-            if (!Object.hasOwn(commonEnvNames, name)) {
-                this.logErrorAndExit(`Invalid configuration name: ${name}`);
+            if (!Object.hasOwn(networkEnvNames, name)) {
+                clm.error(`Invalid configuration name: ${name}. Valid names are: ${Object.keys(networkEnvNames).join(', ')}`);
             }
-            configStore.setEnvCommonInfo({ [name]: args.value });
+            configStore.setEnvNetworkInfo(network, { [name]: args.value });
         }
     }
 }

package/dist/commands/config.js

@@ -3,11 +3,10 @@ import { Command } from '@oclif/core';
 import { checkNetwork } from "../checks/check-network.js";
 import { checkProject } from "../checks/check-project.js";
 import { clm } from "../clm.js";
-import { configStore } from "../config-store.js";
 import { configHelper } from "../helpers/config-helper.js";
-import { dockerHelper } from "../helpers/docker-helper.js";
 import { keyFileHelper } from "../helpers/key-file-helper.js";
 import { promptHelper } from "../helpers/prompt-helper.js";
+import { dockerService } from "../services/docker-service.js";
 export default class Config extends Command {
     static description = 'Update configuration settings';
     static examples = [
@@ -15,51 +14,47 @@ export default class Config extends Command {
     ];
     async run() {
         configHelper.assertProject('No configuration found. ');
-        let { name } = configStore.getProjectInfo();
-        name = name.charAt(0).toUpperCase() + name.slice(1);
+        // let {name} = configStore.getProjectInfo();
+        // name = name.charAt(0).toUpperCase() + name.slice(1);
         const answer = await select({
             choices: [
-                { name: 'Auto Restart', value: 'autoRestart' },
                 { name: 'External IP Address', value: 'externalIp' },
                 { name: 'Java Memory', value: 'javaMemory' },
                 { name: 'Key File', value: 'keyFile' },
-                { name: `${name} - Layers To Run`, value: 'layersToRun' },
-                { name: `Network (mainnet, testnet or intnet)`, value: 'network' },
+                { name: 'Layers To Run', value: 'layersToRun' },
+                { name: `Network`, value: 'network' },
             ],
             message: 'What would you like to change?:',
         });
         // eslint-disable-next-line unicorn/prefer-switch
-        if (answer === 'autoRestart') {
-            await promptHelper.configureAutoRestart();
-        }
-        else if (answer === 'externalIp') {
+        if (answer === 'externalIp') {
             await checkNetwork.configureIpAddress();
         }
         else if (answer === 'javaMemory') {
+            await shutdownNodeIfRunning();
             await promptHelper.configureJavaMemoryArguments();
-            if (await dockerHelper.isRunning()) {
-                clm.preStep('The validator node must be restarted before changes can be applied.');
-                await promptHelper.doYouWishToContinue();
-                await dockerHelper.dockerDown();
-                await dockerHelper.dockerUp();
-            }
         }
         else if (answer === 'keyFile') {
+            await shutdownNodeIfRunning();
             await keyFileHelper.showKeyFileInfo();
             await keyFileHelper.promptForKeyFile();
         }
         else if (answer === 'layersToRun') {
-            if (await dockerHelper.isRunning()) {
-                clm.preStep('The validator node must be stopped first.');
-                await promptHelper.doYouWishToContinue();
-                await dockerHelper.dockerDown();
-            }
+            await shutdownNodeIfRunning();
             await promptHelper.selectLayers();
             await promptHelper.configureJavaMemoryArguments();
         }
         else if (answer === 'network') {
+            await shutdownNodeIfRunning();
             await promptHelper.selectNetwork();
             await checkProject.runInstall();
         }
     }
 }
+async function shutdownNodeIfRunning() {
+    if (await dockerService.isRunning()) {
+        clm.preStep('The validator node must be stopped first.');
+        await promptHelper.doYouWishToContinue();
+        await dockerService.dockerDown();
+    }
+}

package/dist/commands/info.js

@@ -10,10 +10,13 @@ export default class Info extends Command {
         configHelper.assertProject('No project info found. ');
         const projectInfo = configStore.getProjectInfo();
         const networkInfo = configStore.getNetworkInfo();
+        const { CL_EXTERNAL_IP: currentIpAddress } = configStore.getEnvInfo();
         // Project Name
         configHelper.showEnvInfo('Project Name', projectInfo.name);
         // DAG Address
         configHelper.showEnvInfo('DAG Address', projectInfo.dagAddress);
+        // External IP Address
+        configHelper.showEnvInfo('External IP Address', currentIpAddress);
         // Node ID
         configHelper.showEnvInfo('Node ID', projectInfo.nodeId);
         // Layers to Run
@@ -26,7 +29,5 @@ export default class Info extends Command {
         configHelper.showEnvInfo('Project Directory', projectInfo.projectDir);
         // Fast Forward
         configHelper.showEnvInfo('Fast Forward Enabled', (projectInfo.fastForward === undefined || Boolean(projectInfo.fastForward)).toString());
-        // Auto Restart
-        configHelper.showEnvInfo('Auto Restart Enabled', Boolean(projectInfo.autoRestart).toString());
     }
 }

package/dist/commands/logs.d.ts

@@ -1,12 +1,13 @@
 import { Command } from '@oclif/core';
 export default class Logs extends Command {
     static args: {
-        layer: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        layer: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static description: string;
     static examples: string[];
     static flags: {
         follow: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        numOfLines: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/logs.js

@@ -1,11 +1,11 @@
 import { Args, Command, Flags } from '@oclif/core';
 import path from "node:path";
-import { shellService } from "../services/shell-service.js";
 import { configStore } from "../config-store.js";
 import { configHelper } from "../helpers/config-helper.js";
+import { shellService } from "../services/shell-service.js";
 export default class Logs extends Command {
     static args = {
-        layer: Args.string({ description: 'network layer to view. e.g. gl0' }),
+        layer: Args.string({ description: 'network layer to view. e.g. gl0', required: true }),
     };
     static description = 'view validator node runtime logs';
     static examples = [
@@ -13,16 +13,22 @@ export default class Logs extends Command {
     ];
     static flags = {
         follow: Flags.boolean({ char: 'f', description: 'continuously wait for additional data to be appended' }),
+        numOfLines: Flags.string({ char: 'n', description: 'number of lines at the end of the log to display' }),
     };
     async run() {
         configHelper.assertProject('No project found. ');
-        let tailFlag = '';
-        const { flags } = await this.parse(Logs);
+        const { args, flags } = await this.parse(Logs);
+        const numOfLines = Number.isNaN(Number(flags.numOfLines)) ? 100 : Number(flags.numOfLines);
+        const { layersToRun } = configStore.getProjectInfo();
+        if (!layersToRun.includes(args.layer)) {
+            this.error(`Invalid layer: ${args.layer}. Available layers: ${layersToRun.join(',')}`);
+        }
+        let tailFlag = flags.numOfLines ? `-n ${numOfLines}` : '-n 100';
         if (flags.follow) {
-            tailFlag = '-f';
+            tailFlag = ' -f';
         }
         const { projectDir } = configStore.getProjectInfo();
-        const logPath = path.join(projectDir, 'app-data', 'gl0-logs', 'app.log');
+        const logPath = path.join(projectDir, 'app-data', `${args.layer}-logs`, 'app.log');
         await shellService.runCommand(`tail ${tailFlag} ${logPath}`).catch(() => 1);
     }
 }

package/dist/commands/restart.d.ts

@@ -1,5 +1,8 @@
-import { Command } from '@oclif/core';
-export default class Restart extends Command {
+import { BaseCommand } from "../base-command.js";
+export default class Restart extends BaseCommand {
+    static args: {
+        layer: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
     static description: string;
     static examples: string[];
     run(): Promise<void>;

package/dist/commands/restart.js

@@ -1,25 +1,45 @@
-import { Command } from '@oclif/core';
+import { Args } from '@oclif/core';
+import { BaseCommand } from "../base-command.js";
 import { checkProject } from "../checks/check-project.js";
 import { clm } from "../clm.js";
 import { configStore } from "../config-store.js";
 import { configHelper } from "../helpers/config-helper.js";
-import { dockerHelper } from "../helpers/docker-helper.js";
+import { dockerService } from "../services/docker-service.js";
 import { nodeService } from "../services/node-service.js";
-export default class Restart extends Command {
+export default class Restart extends BaseCommand {
+    static args = {
+        layer: Args.string({ description: 'network layer to view. e.g. gl0' }),
+    };
     static description = 'A full shutdown of the validator node, then restart';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
     ];
     async run() {
+        const { args, flags } = await this.parse(Restart);
+        this.checkProject(flags);
         configHelper.assertProject('No project found. ');
         const { layersToRun } = configStore.getProjectInfo();
+        if (!await dockerService.isRunning()) {
+            this.error('The validator node is not running.');
+        }
+        if (args && args.layer) {
+            const layer = args.layer;
+            if (!layersToRun.includes(layer)) {
+                this.error(`Invalid layer: ${layer}. Available layers: ${layersToRun.join(',')}`);
+            }
+            await nodeService.leaveCluster(layer);
+            await nodeService.pollForLayersState([layer], 'Offline');
+            clm.preStep(`Restarting ${layer.toUpperCase()}...`);
+            await dockerService.dockerRestart(layer);
+            return;
+        }
         await nodeService.leaveClusterAllLayers();
         await nodeService.pollForLayersState(layersToRun, 'Offline');
         clm.preStep('Stopping the node...');
-        await dockerHelper.dockerDown();
+        await dockerService.dockerDown();
         clm.preStep('Checking for a new version...');
         await checkProject.runUpgrade();
         clm.preStep('Starting the node...');
-        await dockerHelper.dockerUp();
+        await dockerService.dockerUp();
     }
 }

package/dist/commands/shutdown.js

@@ -1,8 +1,8 @@
 import { Command } from '@oclif/core';
 import { configStore } from "../config-store.js";
-import { dockerHelper } from "../helpers/docker-helper.js";
-import { nodeService } from "../services/node-service.js";
 import { configHelper } from "../helpers/config-helper.js";
+import { dockerService } from "../services/docker-service.js";
+import { nodeService } from "../services/node-service.js";
 export default class Shutdown extends Command {
     static description = 'A full shutdown of the validator node';
     static examples = [
@@ -13,6 +13,6 @@ export default class Shutdown extends Command {
         const { layersToRun } = configStore.getProjectInfo();
         await nodeService.leaveClusterAllLayers();
         await nodeService.pollForLayersState(layersToRun, 'Offline');
-        await dockerHelper.dockerDown();
+        await dockerService.dockerDown();
     }
 }

package/dist/commands/status.js

@@ -1,7 +1,10 @@
 import { Command } from '@oclif/core';
 import { checkInitialSetup } from "../checks/check-initial-setup.js";
 import { checkLayers } from "../checks/check-layers.js";
+import { checkNetwork } from "../checks/check-network.js";
+import { checkNodeCtl } from "../checks/check-node-ctl.js";
 import { checkProject } from "../checks/check-project.js";
+import { checkWallet } from "../checks/check-wallet.js";
 import { keyFileHelper } from "../helpers/key-file-helper.js";
 export default class Status extends Command {
     // eslint-disable-next-line no-warning-comments
@@ -14,8 +17,13 @@ export default class Status extends Command {
 export async function checkInstallationAndConfigurationStatus() {
     await checkInitialSetup.firstTimeRun();
     await checkProject.projectInstallation();
+    await checkNetwork.isNetworkConnectable();
     await checkProject.releaseVersion();
+    await checkNodeCtl.check4Migration();
     await keyFileHelper.promptIfNoKeyFile();
+    await checkNetwork.checkSeedList();
+    await checkNetwork.checkForExistingNodeIdInCluster();
+    await checkWallet.checkCollateral();
     await checkLayers.layersRunning();
     await checkLayers.layersReadyToJoin();
     await checkLayers.layersStatus();

package/dist/commands/test.d.ts

@@ -3,4 +3,5 @@ export default class Test extends Command {
     static description: string;
     static hidden: boolean;
     run(): Promise<void>;
+    testRandomNode(): Promise<void>;
 }

package/dist/commands/test.js

@@ -1,13 +1,43 @@
 import { Command } from "@oclif/core";
+import dotenv from "dotenv";
 import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { archiverService } from "../services/archiver-service.js";
+import { getRandomNode } from "../services/get-random-node.js";
 export default class Test extends Command {
     static description = 'node pilot test command';
     static hidden = true;
     async run() {
-        // await promptHelper.configureJavaMemoryArguments();
-        const r = fs.statfsSync('/');
-        const totalSpace = (r.bsize * r.blocks / (1024 * 1024 * 1024)).toFixed(2);
-        const totalFreeSpace = (r.bsize * r.bfree / (1024 * 1024 * 1024)).toFixed(2);
-        console.log(totalSpace, totalFreeSpace);
+        // await checkNodeCtl.importKeyInfo(path.resolve('/Users/ffox/Projects/Constellation/node-pilot/cn-config.yaml'));
+        // await this.testRandomNode();
+        // const info = await archiverService.getArchiveSnapshotInfo();
+        // console.log(info);
+        // const ordinal = archiverService.getDownloadedSnapshotRange();
+        // console.log(ordinal)
+        //
+        // await archiverService.syncToLatestSnapshot();
+        await archiverService.checkLogsForMissingSnapshots();
+    }
+    async testRandomNode() {
+        const filePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../projects/hypergraph/networks/mainnet/source-nodes.env`);
+        const conetent = fs.readFileSync(filePath);
+        const parsed = dotenv.parse(conetent);
+        const nodes = ['1', '2', '3'].map(i => {
+            return { host: parsed[`SOURCE_NODE_${i}_HOST`], id: parsed[`SOURCE_NODE_${i}_ID`], publicPort: parsed[`SOURCE_NODE_${i}_PORT`] };
+        });
+        const n = await getRandomNode(nodes);
+        console.log('Random node:', n);
     }
 }
+// type NetworkEnvType = {
+//     SOURCE_NODE_1_HOST:string,
+//     SOURCE_NODE_1_ID:string,
+//     SOURCE_NODE_1_PORT:string,
+//     SOURCE_NODE_2_HOST:string,
+//     SOURCE_NODE_2_ID:string,
+//     SOURCE_NODE_2_PORT:string,
+//     SOURCE_NODE_3_HOST:string,
+//     SOURCE_NODE_3_ID:string,
+//     SOURCE_NODE_3_PORT:string,
+// }