feat(multi-cluster): Update solo node setup to support multiple clusters

src/commands/base.ts

@@ -22,6 +22,7 @@ import * as constants from '../core/constants.js';
 import fs from 'fs';
 import {Task} from '../core/task.js';
 import {ConsensusNode} from '../core/model/consensus_node.js';
+import {type NodeAlias} from '../types/aliases.js';
 
 export interface CommandHandlers {
   parent: BaseCommand;
@@ -254,11 +255,17 @@ export abstract class BaseCommand extends ShellRunner {
   public getConsensusNodes(): ConsensusNode[] {
     const consensusNodes: ConsensusNode[] = [];
 
+    try {
+      if (!this.getRemoteConfigManager()?.components?.consensusNodes) return [];
+    } catch {
+      return [];
+    }
+
     // using the remoteConfigManager to get the consensus nodes
     Object.values(this.getRemoteConfigManager().components.consensusNodes).forEach(node => {
       consensusNodes.push(
         new ConsensusNode(
-          node.name,
+          node.name as NodeAlias,
           node.nodeId,
           node.namespace,
           node.cluster,

src/commands/node/configs.ts

@@ -18,6 +18,7 @@ import {type NodeAddConfigClass} from './node_add_config.js';
 import {type NamespaceName} from '../../core/kube/resources/namespace/namespace_name.js';
 import {type PodRef} from '../../core/kube/resources/pod/pod_ref.js';
 import {type K8Factory} from '../../core/kube/k8_factory.js';
+import {type ConsensusNode} from '../../core/model/consensus_node.js';
 
 export const PREPARE_UPGRADE_CONFIGS_NAME = 'prepareUpgradeConfig';
 export const DOWNLOAD_GENERATED_FILES_CONFIGS_NAME = 'downloadGeneratedFilesConfig';
@@ -353,6 +354,7 @@ export const setupConfigBuilder = async function (argv, ctx, task) {
 
   config.namespace = await resolveNamespaceFromDeployment(this.parent.localConfig, this.configManager, task);
   config.nodeAliases = helpers.parseNodeAliases(config.nodeAliasesUnparsed);
+  config.consensusNodes = this.parent.getConsensusNodes();
 
   await initializeSetup(config, this.k8Factory);
 
@@ -448,6 +450,10 @@ export interface NodeSetupConfigClass {
   releaseTag: string;
   nodeAliases: NodeAliases;
   podRefs: Record<NodeAlias, PodRef>;
+  consensusNodes: ConsensusNode[];
+  skipStop?: boolean;
+  keysDir: string;
+  stagingDir: string;
   getUnusedConfigs: () => string[];
 }
 

src/commands/node/handlers.ts

@@ -42,6 +42,7 @@ import {type ComponentsDataWrapper} from '../../core/config/remote/components_da
 import {type Optional} from '../../types/index.js';
 import {type NamespaceName} from '../../core/kube/resources/namespace/namespace_name.js';
 import {Templates} from '../../core/templates.js';
+import {type CommandFlag} from '../../types/flag_types.js';
 
 export class NodeCommandHandlers implements CommandHandlers {
   private readonly accountManager: AccountManager;
@@ -53,7 +54,7 @@ export class NodeCommandHandlers implements CommandHandlers {
   private readonly leaseManager: LeaseManager;
   public readonly remoteConfigManager: RemoteConfigManager;
 
-  private getConfig: any;
+  public getConfig: (configName: string, flags: CommandFlag[], extraProperties?: string[]) => object;
   private prepareChartPath: any;
 
   public readonly parent: BaseCommand;

src/commands/node/tasks.ts

@@ -54,7 +54,12 @@ import {type Listr, type ListrTaskWrapper} from 'listr2';
 import {type ConfigBuilder, type NodeAlias, type NodeAliases, type SkipCheck} from '../../types/aliases.js';
 import {PodName} from '../../core/kube/resources/pod/pod_name.js';
 import {NodeStatusCodes, NodeStatusEnums, NodeSubcommandType} from '../../core/enumerations.js';
-import {type NodeDeleteConfigClass, type NodeRefreshConfigClass, type NodeUpdateConfigClass} from './configs.js';
+import {
+  type NodeDeleteConfigClass,
+  type NodeRefreshConfigClass,
+  type NodeSetupConfigClass,
+  type NodeUpdateConfigClass,
+} from './configs.js';
 import {type Lease} from '../../core/lease/lease.js';
 import {ListrLease} from '../../core/lease/listr_lease.js';
 import {Duration} from '../../core/time/duration.js';
@@ -68,6 +73,8 @@ import {ContainerRef} from '../../core/kube/resources/container/container_ref.js
 import {NetworkNodes} from '../../core/network_nodes.js';
 import {container} from 'tsyringe-neo';
 import * as helpers from '../../core/helpers.js';
+import {type Optional, type SoloListrTask, type SoloListrTaskWrapper} from '../../types/index.js';
+import {type ConsensusNode} from '../../core/model/consensus_node.js';
 
 export class NodeCommandTasks {
   private readonly accountManager: AccountManager;
@@ -196,6 +203,7 @@ export class NodeCommandTasks {
     podRefs: Record<NodeAlias, PodRef>,
     task: ListrTaskWrapper<any, any, any>,
     localBuildPath: string,
+    consensusNodes: Optional<ConsensusNode[]>,
   ) {
     const subTasks = [];
 
@@ -216,6 +224,7 @@ export class NodeCommandTasks {
     let localDataLibBuildPath: string;
     for (const nodeAlias of nodeAliases) {
       const podRef = podRefs[nodeAlias];
+      const context = helpers.extractContextFromConsensusNodes(nodeAlias, consensusNodes);
       if (buildPathMap.has(nodeAlias)) {
         localDataLibBuildPath = buildPathMap.get(nodeAlias);
       } else {
@@ -227,24 +236,25 @@ export class NodeCommandTasks {
       }
 
       const self = this;
+
+      const k8 = context ? self.k8Factory.getK8(context) : self.k8Factory.default();
+
       subTasks.push({
         title: `Copy local build to Node: ${chalk.yellow(nodeAlias)} from ${localDataLibBuildPath}`,
         task: async () => {
           // filter the data/config and data/keys to avoid failures due to config and secret mounts
           const filterFunction = (path, stat) => {
             return !(path.includes('data/keys') || path.includes('data/config'));
           };
-          await self.k8Factory
-            .default()
+          await k8
             .containers()
             .readByRef(ContainerRef.of(podRef, constants.ROOT_CONTAINER))
             .copyTo(localDataLibBuildPath, `${constants.HEDERA_HAPI_PATH}`, filterFunction);
           if (self.configManager.getFlag<string>(flags.appConfig)) {
             const testJsonFiles: string[] = this.configManager.getFlag<string>(flags.appConfig)!.split(',');
             for (const jsonFile of testJsonFiles) {
               if (fs.existsSync(jsonFile)) {
-                await self.k8Factory
-                  .default()
+                await k8
                   .containers()
                   .readByRef(ContainerRef.of(podRef, constants.ROOT_CONTAINER))
                   .copyTo(jsonFile, `${constants.HEDERA_HAPI_PATH}`);
@@ -267,13 +277,15 @@ export class NodeCommandTasks {
     releaseTag: string,
     task: ListrTaskWrapper<any, any, any>,
     platformInstaller: PlatformInstaller,
+    consensusNodes?: Optional<ConsensusNode[]>,
   ) {
     const subTasks = [];
     for (const nodeAlias of nodeAliases) {
+      const context = helpers.extractContextFromConsensusNodes(nodeAlias, consensusNodes);
       const podRef = podRefs[nodeAlias];
       subTasks.push({
         title: `Update node: ${chalk.yellow(nodeAlias)} [ platformVersion = ${releaseTag} ]`,
-        task: async () => await platformInstaller.fetchPlatform(podRef, releaseTag),
+        task: async () => await platformInstaller.fetchPlatform(podRef, releaseTag, context),
       });
     }
 
@@ -797,10 +809,12 @@ export class NodeCommandTasks {
     if (!ctx.config) ctx.config = {};
 
     ctx.config.podRefs = {};
+    const consensusNodes: Optional<ConsensusNode[]> = ctx.config.consensusNodes;
 
     const subTasks = [];
     const self = this;
     for (const nodeAlias of nodeAliases) {
+      const context = helpers.extractContextFromConsensusNodes(nodeAlias, consensusNodes);
       subTasks.push({
         title: `Check network pod: ${chalk.yellow(nodeAlias)}`,
         task: async (ctx: any) => {
@@ -809,6 +823,8 @@ export class NodeCommandTasks {
               ctx.config.namespace,
               nodeAlias,
               maxAttempts,
+              undefined,
+              context,
             );
           } catch (_) {
             ctx.config.skipStop = true;
@@ -832,14 +848,16 @@ export class NodeCommandTasks {
     nodeAlias: NodeAlias,
     maxAttempts = constants.PODS_RUNNING_MAX_ATTEMPTS,
     delay = constants.PODS_RUNNING_DELAY,
+    context?: Optional<string>,
   ) {
     nodeAlias = nodeAlias.trim() as NodeAlias;
     const podName = Templates.renderNetworkPodName(nodeAlias);
     const podRef = PodRef.of(namespace, podName);
 
     try {
-      await this.k8Factory
-        .default()
+      const k8 = context ? this.k8Factory.getK8(context) : this.k8Factory.default();
+
+      await k8
         .pods()
         .waitForRunningPhase(
           namespace,
@@ -912,7 +930,7 @@ export class NodeCommandTasks {
     );
   }
 
-  identifyNetworkPods(maxAttempts = undefined) {
+  identifyNetworkPods(maxAttempts?: number) {
     const self = this;
     return new Task('Identify network pods', (ctx: any, task: ListrTaskWrapper<any, any, any>) => {
       return self.taskCheckNetworkNodePods(ctx, task, ctx.config.nodeAliases, maxAttempts);
@@ -924,10 +942,22 @@ export class NodeCommandTasks {
     return new Task('Fetch platform software into network nodes', (ctx: any, task: ListrTaskWrapper<any, any, any>) => {
       const {podRefs, releaseTag, localBuildPath} = ctx.config;
 
-      if (localBuildPath !== '') {
-        return self._uploadPlatformSoftware(ctx.config[aliasesField], podRefs, task, localBuildPath);
-      }
-      return self._fetchPlatformSoftware(ctx.config[aliasesField], podRefs, releaseTag, task, this.platformInstaller);
+      return localBuildPath !== ''
+        ? self._uploadPlatformSoftware(
+            ctx.config[aliasesField],
+            podRefs,
+            task,
+            localBuildPath,
+            ctx.config.consensusNodes,
+          )
+        : self._fetchPlatformSoftware(
+            ctx.config[aliasesField],
+            podRefs,
+            releaseTag,
+            task,
+            this.platformInstaller,
+            ctx.config.consensusNodes,
+          );
     });
   }
 
@@ -955,12 +985,14 @@ export class NodeCommandTasks {
 
       await this.generateNodeOverridesJson(ctx.config.namespace, ctx.config.nodeAliases, ctx.config.stagingDir);
 
+      const consensusNodes = ctx.config.consensusNodes;
       const subTasks = [];
       for (const nodeAlias of ctx.config[nodeAliasesProperty]) {
         const podRef = ctx.config.podRefs[nodeAlias];
+        const context = helpers.extractContextFromConsensusNodes(nodeAlias, consensusNodes);
         subTasks.push({
           title: `Node: ${chalk.yellow(nodeAlias)}`,
-          task: () => this.platformInstaller.taskSetup(podRef, ctx.config.stagingDir, isGenesis),
+          task: () => this.platformInstaller.taskSetup(podRef, ctx.config.stagingDir, isGenesis, context),
         });
       }
 

src/core/helpers.ts

@@ -15,6 +15,8 @@
 import {type SoloLogger} from './logging.js';
 import {type Duration} from './time/duration.js';
 import {type NodeAddConfigClass} from '../commands/node/node_add_config.js';
+import {type ConsensusNode} from './model/consensus_node.js';
+import {type Optional} from '../types/index.js';
 
 export function sleep(duration: Duration) {
   return new Promise<void>(resolve => {
@@ -381,3 +383,18 @@
 
   return valuesArg;
 }
+
+/**
+ * @param nodeAlias
+ * @param consensusNodes
+ * @returns context of the node
+ */
+export function extractContextFromConsensusNodes(
+  nodeAlias: NodeAlias,
+  consensusNodes?: ConsensusNode[],
+): Optional<string> {
+  if (!consensusNodes) return undefined;
+  if (!consensusNodes.length) return undefined;
+  const consensusNode = consensusNodes.find(node => node.name === nodeAlias);
+  return consensusNode ? consensusNode.context : undefined;
+}

src/core/model/consensus_node.ts

@@ -1,10 +1,11 @@
 /**
  * SPDX-License-Identifier: Apache-2.0
  */
+import {type NodeAlias} from '../../types/aliases.js';
 
 export class ConsensusNode {
   constructor(
-    public readonly name: string,
+    public readonly name: NodeAlias,
     public readonly nodeId: number,
     public readonly namespace: string,
     public readonly cluster: string,