feat: Create remote config (#862)

Signed-off-by: Ivo Yankov <[email protected]>
Signed-off-by: instamenta <[email protected]>
Signed-off-by: Jeromy Cannon <[email protected]>
Co-authored-by: Ivo Yankov <[email protected]>
Co-authored-by: Jeromy Cannon <[email protected]>

Author: 3 people

package-lock.json

@@ -63,7 +63,6 @@
     "inquirer": "^12.1.0",
     "ip": "^2.0.1",
     "js-base64": "^3.7.7",
-    "js-yaml": "^4.1.0",
     "jsdoc": "^4.0.4",
     "listr2": "^8.2.5",
     "semver": "^7.6.3",
@@ -98,6 +97,7 @@
     "@types/stream-buffers": "^3.0.7",
     "@types/tar": "^6.1.13",
     "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.5.13",
     "@types/yargs": "^17.0.33",
     "@typescript-eslint/utils": "^8.17.0",
     "c8": "^10.1.2",

package.json

@@ -18,9 +18,17 @@
 import paths from 'path';
 import {MissingArgumentError} from '../core/errors.js';
 import {ShellRunner} from '../core/shell_runner.js';
-import type {ChartManager, ConfigManager, Helm, K8, DependencyManager, LeaseManager} from '../core/index.js';
+import type {
+  ChartManager,
+  ConfigManager,
+  Helm,
+  K8,
+  DependencyManager,
+  LeaseManager,
+  RemoteConfigManager,
+  LocalConfig,
+} from '../core/index.js';
 import type {CommandFlag, Opts} from '../types/index.js';
-import {type LocalConfig} from '../core/config/local_config.js';
 
 export class BaseCommand extends ShellRunner {
   protected readonly helm: Helm;
@@ -31,6 +39,7 @@ export class BaseCommand extends ShellRunner {
   protected readonly leaseManager: LeaseManager;
   protected readonly _configMaps = new Map<string, any>();
   protected readonly localConfig: LocalConfig;
+  protected readonly remoteConfigManager: RemoteConfigManager;
 
   constructor(opts: Opts) {
     if (!opts || !opts.logger) throw new Error('An instance of core/SoloLogger is required');
@@ -40,6 +49,8 @@ export class BaseCommand extends ShellRunner {
     if (!opts || !opts.configManager) throw new Error('An instance of core/ConfigManager is required');
     if (!opts || !opts.depManager) throw new Error('An instance of core/DependencyManager is required');
     if (!opts || !opts.localConfig) throw new Error('An instance of core/LocalConfig is required');
+    if (!opts || !opts.remoteConfigManager)
+      throw new Error('An instance of core/config/RemoteConfigManager is required');
 
     super(opts.logger);
 
@@ -50,6 +61,7 @@ export class BaseCommand extends ShellRunner {
     this.depManager = opts.depManager;
     this.leaseManager = opts.leaseManager;
     this.localConfig = opts.localConfig;
+    this.remoteConfigManager = opts.remoteConfigManager;
   }
 
   async prepareChartPath(chartDir: string, chartRepo: string, chartReleaseName: string) {

src/commands/base.ts

@@ -36,7 +36,7 @@ export class ContextCommandHandlers implements CommandHandlers {
     const action = helpers.commandActionBuilder(
       [
         this.tasks.initialize(argv),
-        this.parent.getLocalConfig().promptLocalConfigTask(this.parent.getK8(), argv),
+        this.parent.getLocalConfig().promptLocalConfigTask(),
         this.tasks.updateLocalConfig(argv),
       ],
       {

src/commands/context/handlers.ts

@@ -35,25 +35,25 @@ export class ContextCommandTasks {
       const isQuiet = !!argv[flags.quiet.name];
 
       let currentDeploymentName = argv[flags.namespace.name];
-      let clusterAliases = Templates.parseClusterAliases(argv[flags.clusterName.name]);
+      let clusters = Templates.parseClusterAliases(argv[flags.clusterName.name]);
       let contextName = argv[flags.context.name];
 
       const kubeContexts = await this.parent.getK8().getContexts();
 
       if (isQuiet) {
         const currentCluster = await this.parent.getK8().getKubeConfig().getCurrentCluster();
-        if (!clusterAliases.length) clusterAliases = [currentCluster.name];
+        if (!clusters.length) clusters = [currentCluster.name];
         if (!contextName) contextName = await this.parent.getK8().getKubeConfig().getCurrentContext();
 
         if (!currentDeploymentName) {
           const selectedContext = kubeContexts.find(e => e.name === contextName);
           currentDeploymentName = selectedContext && selectedContext.namespace ? selectedContext.namespace : 'default';
         }
       } else {
-        if (!clusterAliases.length) {
+        if (!clusters.length) {
           const prompt = this.promptMap.get(flags.clusterName.name);
-          const unparsedClusterAliases = await prompt(task, clusterAliases);
-          clusterAliases = Templates.parseClusterAliases(unparsedClusterAliases);
+          const unparsedClusterAliases = await prompt(task, clusters);
+          clusters = Templates.parseClusterAliases(unparsedClusterAliases);
         }
         if (!contextName) {
           const prompt = this.promptMap.get(flags.context.name);
@@ -74,13 +74,13 @@ export class ContextCommandTasks {
 
       // Set clusters for active deployment
       const deployments = this.parent.getLocalConfig().deployments;
-      deployments[currentDeploymentName].clusterAliases = clusterAliases;
+      deployments[currentDeploymentName].clusters = clusters;
       this.parent.getLocalConfig().setDeployments(deployments);
 
       this.parent.getK8().getKubeConfig().setCurrentContext(contextName);
 
       this.parent.logger.info(
-        `Save LocalConfig file: [currentDeploymentName: ${currentDeploymentName}, contextName: ${contextName}, clusterAliases: ${clusterAliases.join(' ')}]`,
+        `Save LocalConfig file: [currentDeploymentName: ${currentDeploymentName}, contextName: ${contextName}, clusters: ${clusters.join(' ')}]`,
       );
       await this.parent.getLocalConfig().write();
     });

src/commands/context/tasks.ts

@@ -0,0 +1,157 @@
+/**
+ * Copyright (C) 2024 Hedera Hashgraph, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the ""License"");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an ""AS IS"" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+import {Listr, type ListrTaskWrapper} from 'listr2';
+import {SoloError} from '../core/errors.js';
+import {BaseCommand} from './base.js';
+import * as flags from './flags.js';
+import {constants, Templates} from '../core/index.js';
+import * as prompts from './prompts.js';
+import chalk from 'chalk';
+import {RemoteConfigTasks} from '../core/config/remote/remote_config_tasks.js';
+import {ListrLease} from '../core/lease/listr_lease.js';
+import type {Namespace} from '../core/config/remote/types.js';
+import type {CommandFlag, ContextClusterStructure} from '../types/index.js';
+
+export class DeploymentCommand extends BaseCommand {
+  private static get DEPLOY_FLAGS_LIST(): CommandFlag[] {
+    return [
+      flags.quiet,
+      flags.namespace,
+      flags.userEmailAddress,
+      flags.deploymentClusters,
+      flags.contextClusterUnparsed,
+    ];
+  }
+
+  private async create(argv: any): Promise<boolean> {
+    const self = this;
+    const lease = await self.leaseManager.create();
+
+    interface Config {
+      namespace: Namespace;
+      contextClusterUnparsed: string;
+      contextCluster: ContextClusterStructure;
+    }
+    interface Context {
+      config: Config;
+    }
+
+    const tasks = new Listr<Context>(
+      [
+        {
+          title: 'Initialize',
+          task: async (ctx, task): Promise<Listr<Context, any, any>> => {
+            self.configManager.update(argv);
+            self.logger.debug('Loaded cached config', {config: self.configManager.config});
+
+            await prompts.execute(task, self.configManager, DeploymentCommand.DEPLOY_FLAGS_LIST);
+
+            ctx.config = {
+              contextClusterUnparsed: self.configManager.getFlag<string>(flags.contextClusterUnparsed),
+              namespace: self.configManager.getFlag<Namespace>(flags.namespace),
+            } as Config;
+
+            ctx.config.contextCluster = Templates.parseContextCluster(ctx.config.contextClusterUnparsed);
+
+            const namespace = ctx.config.namespace;
+
+            if (!(await self.k8.hasNamespace(namespace))) {
+              await self.k8.createNamespace(namespace);
+            }
+
+            self.logger.debug('Prepared config', {config: ctx.config, cachedConfig: self.configManager.config});
+
+            return ListrLease.newAcquireLeaseTask(lease, task);
+          },
+        },
+        this.localConfig.promptLocalConfigTask(),
+        {
+          title: 'Validate cluster connections',
+          task: async (ctx, task): Promise<Listr<Context, any, any>> => {
+            const subTasks = [];
+
+            for (const cluster of Object.keys(ctx.config.contextCluster)) {
+              subTasks.push({
+                title: `Testing connection to cluster: ${chalk.cyan(cluster)}`,
+                task: async (_: Context, task: ListrTaskWrapper<Context, any, any>) => {
+                  if (!(await self.k8.testClusterConnection(cluster))) {
+                    task.title = `${task.title} - ${chalk.red('Cluster connection failed')}`;
+
+                    throw new SoloError(`Cluster connection failed for: ${cluster}`);
+                  }
+                },
+              });
+            }
+
+            return task.newListr(subTasks, {
+              concurrent: true,
+              rendererOptions: {collapseSubtasks: false},
+            });
+          },
+        },
+        RemoteConfigTasks.createRemoteConfig.bind(this)(),
+      ],
+      {
+        concurrent: false,
+        rendererOptions: constants.LISTR_DEFAULT_RENDERER_OPTION,
+      },
+    );
+
+    try {
+      await tasks.run();
+    } catch (e: Error | any) {
+      throw new SoloError(`Error installing chart ${constants.SOLO_DEPLOYMENT_CHART}`, e);
+    } finally {
+      await lease.release();
+    }
+
+    return true;
+  }
+
+  public getCommandDefinition(): {command: string; desc: string; builder: Function} {
+    const self = this;
+    return {
+      command: 'deployment',
+      desc: 'Manage solo network deployment',
+      builder: (yargs: any): any => {
+        return yargs
+          .command({
+            command: 'create',
+            desc: 'Creates solo deployment',
+            builder: (y: any) => flags.setCommandFlags(y, ...DeploymentCommand.DEPLOY_FLAGS_LIST),
+            handler: (argv: any) => {
+              self.logger.debug("==== Running 'deployment create' ===");
+              self.logger.debug(argv);
+
+              self
+                .create(argv)
+                .then(r => {
+                  self.logger.debug('==== Finished running `deployment create`====');
+
+                  if (!r) process.exit(1);
+                })
+                .catch(err => {
+                  self.logger.showUserError(err);
+                  process.exit(1);
+                });
+            },
+          })
+          .demandCommand(1, 'Select a chart command');
+      },
+    };
+  }
+}

src/commands/deployment.ts

@@ -745,7 +745,6 @@ export const userEmailAddress: CommandFlag = {
   name: 'email',
   definition: {
     describe: 'User email address used for local configuration',
-    defaultValue: '',
     type: 'string',
   },
 };
@@ -760,22 +759,11 @@ export const context: CommandFlag = {
   },
 };
 
-export const deploymentName: CommandFlag = {
-  constName: 'deploymentName',
-  name: 'deployment-name',
-  definition: {
-    describe: 'Solo deployment name',
-    defaultValue: '',
-    type: 'string',
-  },
-};
-
 export const deploymentClusters: CommandFlag = {
   constName: 'deploymentClusters',
   name: 'deployment-clusters',
   definition: {
     describe: 'Solo deployment cluster list (comma separated)',
-    defaultValue: '',
     type: 'string',
   },
 };
@@ -855,6 +843,17 @@ export const stakeAmounts: CommandFlag = {
   },
 };
 
+export const contextClusterUnparsed: CommandFlag = {
+  constName: 'contextClusterUnparsed',
+  name: 'context-cluster',
+  definition: {
+    describe:
+      'Context cluster mapping where context is key = value is cluster and comma delimited if more than one, ' +
+      '(e.g.: --context-cluster kind-solo=kind-solo,kind-solo-2=kind-solo-2)',
+    type: 'string',
+  },
+};
+
 export const allFlags: CommandFlag[] = [
   accountId,
   amount,
@@ -869,14 +868,14 @@ export const allFlags: CommandFlag[] = [
   chartDirectory,
   clusterName,
   clusterSetupNamespace,
+  context,
   deletePvcs,
   deleteSecrets,
   deployCertManager,
   deployCertManagerCrds,
   deployHederaExplorer,
   deployJsonRpcRelay,
   deploymentClusters,
-  deploymentName,
   deployMinio,
   deployPrometheusStack,
   devMode,
@@ -931,6 +930,7 @@ export const allFlags: CommandFlag[] = [
   grpcWebTlsCertificatePath,
   grpcTlsKeyPath,
   grpcWebTlsKeyPath,
+  contextClusterUnparsed,
 ];
 
 /** Resets the definition.disablePrompt for all flags */