feat(multi-cluster): updated 'solo account init' to upload secrets to all clusters

src/commands/account.ts

@@ -17,6 +17,7 @@
 import {Duration} from '../core/time/duration.js';
 import {type NamespaceName} from '../core/kube/resources/namespace/namespace_name.js';
 import {type DeploymentName} from '../core/config/remote/types.js';
+import {type SoloListrTask} from '../types/index.js';
 import {Templates} from '../core/templates.js';
 import {sleep} from '../core/helpers.js';
 import {SecretType} from '../core/kube/resources/secret/secret_type.js';
@@ -37,7 +38,7 @@
     super(opts);
 
     if (!opts || !opts.accountManager)
       throw new IllegalArgumentError('An instance of core/AccountManager is required', opts.accountManager as any);
 
     this.accountManager = opts.accountManager;
     this.accountInfo = null;
@@ -72,7 +73,7 @@
       try {
         const privateKey = PrivateKey.fromStringDer(newAccountInfo.privateKey);
         newAccountInfo.privateKeyRaw = privateKey.toStringRaw();
       } catch (e: Error | any) {
         this.logger.error(`failed to retrieve EVM address for accountId ${newAccountInfo.accountId}`);
       }
     }
@@ -113,7 +114,7 @@
     return this.accountManager.accountInfoQuery(ctx.config.accountId);
   }
 
   async updateAccountInfo(ctx: any) {
     let amount = ctx.config.amount;
     if (ctx.config.ed25519PrivateKey) {
       if (
@@ -149,13 +150,14 @@
     return await this.accountManager.transferAmount(constants.TREASURY_ACCOUNT_ID, toAccountId, amount);
   }
 
   async init(argv: any) {
     const self = this;
 
     interface Context {
       config: {
         namespace: NamespaceName;
         nodeAliases: NodeAliases;
+        contexts: string[];
       };
       updateSecrets: boolean;
       accountsBatchedSet: number[][];
@@ -172,18 +174,20 @@
           title: 'Initialize',
           task: async (ctx, task) => {
             self.configManager.update(argv);
-            const namespace = await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task);
+            const config = {
+              namespace: await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task),
+              contexts: this.getContexts(),
+              nodeAliases: helpers.parseNodeAliases(this.configManager.getFlag(flags.nodeAliasesUnparsed)),
+            };
 
-            if (!(await this.k8Factory.default().namespaces().has(namespace))) {
-              throw new SoloError(`namespace ${namespace.name} does not exist`);
+            if (!(await this.k8Factory.getK8(config.contexts[0]).namespaces().has(config.namespace))) {
+              throw new SoloError(`namespace ${config.namespace.name} does not exist`);
             }
 
-            ctx.config = {
-              namespace: namespace,
-              nodeAliases: helpers.parseNodeAliases(this.configManager.getFlag(flags.nodeAliasesUnparsed)),
-            };
+            // set config in the context for later tasks to use
+            ctx.config = config;
 
-            self.logger.debug('Initialized config', ctx.config);
+            self.logger.debug('Initialized config', {config});
 
             await self.accountManager.loadNodeClient(
               ctx.config.namespace,
@@ -200,12 +204,11 @@
                 {
                   title: 'Prepare for account key updates',
                   task: async ctx => {
-                    const namespace = await resolveNamespaceFromDeployment(this.localConfig, this.configManager, task);
-                    const secrets = await self.k8Factory
+                    ctx.updateSecrets = await self.k8Factory
                       .default()
                       .secrets()
-                      .list(namespace, ['solo.hedera.com/account-id']);
-                    ctx.updateSecrets = secrets.length > 0;
+                      .list(ctx.config.namespace, ['solo.hedera.com/account-id'])
+                      .then(secrets => secrets.length > 0);
 
                     ctx.accountsBatchedSet = self.accountManager.batchAccounts(this.systemAccounts);
 
@@ -222,16 +225,18 @@
                 {
                   title: 'Update special account key sets',
                   task: ctx => {
-                    const subTasks: any[] = [];
+                    const subTasks: SoloListrTask<Context>[] = [];
                     const realm = constants.HEDERA_NODE_ACCOUNT_ID_START.realm;
                     const shard = constants.HEDERA_NODE_ACCOUNT_ID_START.shard;
+
                     for (const currentSet of ctx.accountsBatchedSet) {
                       const accStart = `${realm}.${shard}.${currentSet[0]}`;
                       const accEnd = `${realm}.${shard}.${currentSet[currentSet.length - 1]}`;
                       const rangeStr =
                         accStart !== accEnd
                           ? `${chalk.yellow(accStart)} to ${chalk.yellow(accEnd)}`
                           : `${chalk.yellow(accStart)}`;
+
                       subTasks.push({
                         title: `Updating accounts [${rangeStr}]`,
                         task: async (ctx: Context) => {
@@ -240,6 +245,7 @@
                             currentSet,
                             ctx.updateSecrets,
                             ctx.resultTracker,
+                            ctx.config.contexts,
                           );
                         },
                       });
@@ -319,6 +325,7 @@
                       );
                     }
                     self.logger.showUser(chalk.gray('Waiting for sockets to be closed....'));
+
                     if (ctx.resultTracker.rejectedCount > 0) {
                       throw new SoloError(
                         `Account keys updates failed for ${ctx.resultTracker.rejectedCount} accounts.`,
@@ -345,7 +352,7 @@
 
     try {
       await tasks.run();
-    } catch (e: Error | any) {
+    } catch (e) {
       throw new SoloError(`Error in creating account: ${e.message}`, e);
     } finally {
       await this.closeConnections();
@@ -357,7 +364,7 @@
     return true;
   }
 
   async create(argv: any) {
     const self = this;
     const lease = await self.leaseManager.create();
 
@@ -437,7 +444,7 @@
 
     try {
       await tasks.run();
     } catch (e: Error | any) {
       throw new SoloError(`Error in creating account: ${e.message}`, e);
     } finally {
       await lease.release();
@@ -447,7 +454,7 @@
     return true;
   }
 
   async update(argv: any) {
     const self = this;
 
     interface Context {
@@ -528,7 +535,7 @@
 
     try {
       await tasks.run();
     } catch (e: Error | any) {
       throw new SoloError(`Error in updating account: ${e.message}`, e);
     } finally {
       await this.closeConnections();
@@ -537,7 +544,7 @@
     return true;
   }
 
   async get(argv: any) {
     const self = this;
 
     interface Context {

src/core/account_manager.ts

@@ -593,6 +593,7 @@
    * @param currentSet - the accounts to update
    * @param updateSecrets - whether to delete the secret prior to creating a new secret
    * @param resultTracker - an object to keep track of the results from the accounts that are being updated
+   * @param contexts
    * @returns the updated resultTracker object
    */
   async updateSpecialAccountsKeys(
@@ -604,6 +605,7 @@
       rejectedCount: number;
       fulfilledCount: number;
     },
+    contexts: string[],
   ) {
     const genesisKey = PrivateKey.fromStringED25519(constants.OPERATOR_KEY);
     const realm = constants.HEDERA_NODE_ACCOUNT_ID_START.realm;
@@ -618,6 +620,7 @@
           AccountId.fromString(`${realm}.${shard}.${accountNum}`),
           genesisKey,
           updateSecrets,
+          contexts,
         ),
       );
     }
@@ -657,19 +660,21 @@
    * @param namespace - the namespace of the nodes network
    * @param accountId - the account that will get its keys updated
    * @param genesisKey - the genesis key to compare against
-   * @param updateSecrets - whether to delete the secret prior to creating a new secret
+   * @param updateSecrets - whether to delete the secret before creating a new secret
+   * @param [contexts]
    * @returns the result of the call
    */
   async updateAccountKeys(
     namespace: NamespaceName,
     accountId: AccountId,
     genesisKey: PrivateKey,
     updateSecrets: boolean,
+    contexts?: string[],
   ): Promise<{value: string; status: string} | {reason: string; value: string; status: string}> {
     let keys: Key[];
     try {
       keys = await this.getAccountKeys(accountId);
-    } catch (e: Error | any) {
+    } catch (e) {
       this.logger.error(`failed to get keys for accountId ${accountId.toString()}, e: ${e.toString()}\n  ${e.stack}`);
       return {
         status: REJECTED,
@@ -704,37 +709,35 @@
     };
 
     try {
-      const createdOrUpdated = updateSecrets
-        ? await this.k8Factory
-            .default()
+      for (const context of contexts) {
+        const secretName = Templates.renderAccountKeySecretName(accountId);
+        const secretLabels = Templates.renderAccountKeySecretLabelObject(accountId);
+        const secretType = SecretType.OPAQUE;
+
+        let createdOrUpdated: boolean;
+
+        if (updateSecrets) {
+          createdOrUpdated = await this.k8Factory
+            .getK8(context)
             .secrets()
-            .replace(
-              namespace,
-              Templates.renderAccountKeySecretName(accountId),
-              SecretType.OPAQUE,
-              data,
-              Templates.renderAccountKeySecretLabelObject(accountId),
-            )
-        : await this.k8Factory
-            .default()
+            .replace(namespace, secretName, secretType, data, secretLabels);
+        } else {
+          createdOrUpdated = await this.k8Factory
+            .getK8(context)
             .secrets()
-            .create(
-              namespace,
-              Templates.renderAccountKeySecretName(accountId),
-              SecretType.OPAQUE,
-              data,
-              Templates.renderAccountKeySecretLabelObject(accountId),
-            );
-
-      if (!createdOrUpdated) {
-        this.logger.error(`failed to create secret for accountId ${accountId.toString()}`);
-        return {
-          status: REJECTED,
-          reason: REASON_FAILED_TO_CREATE_K8S_S_KEY,
-          value: accountId.toString(),
-        };
+            .create(namespace, secretName, secretType, data, secretLabels);
+        }
+
+        if (!createdOrUpdated) {
+          this.logger.error(`failed to create secret for accountId ${accountId.toString()}`);
+          return {
+            status: REJECTED,
+            reason: REASON_FAILED_TO_CREATE_K8S_S_KEY,
+            value: accountId.toString(),
+          };
+        }
       }
-    } catch (e: Error | any) {
+    } catch (e) {
       this.logger.error(`failed to create secret for accountId ${accountId.toString()}, e: ${e.toString()}`);
       return {
         status: REJECTED,