pushing latest

Signed-off-by: Jeromy Cannon <[email protected]>

Author: jeromy-cannon

src/commands/base.ts

@@ -72,6 +72,9 @@ export abstract class BaseCommand extends ShellRunner {
     return `${chartRepo}/${chartReleaseName}`;
   }
 
+  // TODO @Lenin, this is in the base so it will be used by everyone, which might be good because they won't have to duplicate the code
+  //  perhaps we should clone this method and have the new method return an object Record<ClusterRef, valuesFileArg>
+  //  need to support: --values-file aws-cluster=aws/solo-values.yaml,aws-cluster=aws/solo-values2.yaml,gcp-cluster=gcp/solo-values.yaml,gcp-cluster=gcp/solo-values2.yaml
   public prepareValuesFiles(valuesFile: string) {
     let valuesArg = '';
     if (valuesFile) {

src/commands/deployment.ts

@@ -16,7 +16,7 @@ import {type SoloListrTask} from '../types/index.js';
 import {type Opts} from '../types/command_types.js';
 import {ErrorMessages} from '../core/error_messages.js';
 import {splitFlagInput} from '../core/helpers.js';
-import {type NamespaceName} from '../core/kube/resources/namespace/namespace_name.js';
+import {NamespaceName} from '../core/kube/resources/namespace/namespace_name.js';
 import {type ClusterChecks} from '../core/cluster_checks.js';
 import {container} from 'tsyringe-neo';
 import {InjectTokens} from '../core/dependency_injection/inject_tokens.js';
@@ -39,14 +39,15 @@ export class DeploymentCommand extends BaseCommand {
       flags.userEmailAddress,
       flags.deployment,
       flags.deploymentClusters,
+      flags.nodeAliasesUnparsed,
     ];
   }
 
   private static get LIST_DEPLOYMENTS_FLAGS_LIST(): CommandFlag[] {
     return [flags.quiet, flags.clusterRef];
   }
 
-  private async create(argv: any): Promise<boolean> {
+  public async create(argv: any): Promise<boolean> {
     const self = this;
 
     interface Config {
@@ -57,6 +58,7 @@ export class DeploymentCommand extends BaseCommand {
       namespace: NamespaceName;
       deployment: DeploymentName;
       deploymentClusters: string[];
+      nodeAliases: string[];
     }
 
     interface Context {
@@ -82,6 +84,7 @@ export class DeploymentCommand extends BaseCommand {
               namespace: self.configManager.getFlag<NamespaceName>(flags.namespace),
               deployment: self.configManager.getFlag<DeploymentName>(flags.deployment),
               deploymentClusters: splitFlagInput(self.configManager.getFlag<string>(flags.deploymentClusters)),
+              nodeAliases: splitFlagInput(self.configManager.getFlag<string>(flags.nodeAliasesUnparsed)),
             } as Config;
 
             self.logger.debug('Prepared config', {config: ctx.config, cachedConfig: self.configManager.config});
@@ -93,7 +96,13 @@ export class DeploymentCommand extends BaseCommand {
           title: 'Add new deployment to local config',
           task: async (ctx, task) => {
             const {deployments} = this.localConfig;
-            const {deployment, namespace, deploymentClusters} = ctx.config;
+            const {deployment, namespace: configNamespace, deploymentClusters} = ctx.config;
+            let namespace = configNamespace;
+            if (!namespace?.name) {
+              namespace = NamespaceName.of(deployment);
+              ctx.config.namespace = namespace;
+              this.configManager.setFlag(flags.namespace, namespace);
+            }
             deployments[deployment] = {
               namespace: namespace.name,
               clusters: deploymentClusters,

src/commands/network.ts

@@ -159,6 +159,7 @@ export class NetworkCommand extends BaseCommand {
       // Generating new minio credentials
       const envString = `MINIO_ROOT_USER=${minioAccessKey}\nMINIO_ROOT_PASSWORD=${minioSecretKey}`;
       minioData['config.env'] = Base64.encode(envString);
+      // TODO: @Lenin, needs to run once for each cluster
       const isMinioSecretCreated = await this.k8Factory
         .default()
         .secrets()
@@ -192,6 +193,7 @@ export class NetworkCommand extends BaseCommand {
         cloudData['S3_SECRET_KEY'] = Base64.encode(minioSecretKey);
       }
 
+      // TODO: @Lenin, needs to run once for each cluster
       const isCloudSecretCreated = await this.k8Factory
         .default()
         .secrets()
@@ -206,6 +208,8 @@ export class NetworkCommand extends BaseCommand {
         const backupData = {};
         const googleCredential = fs.readFileSync(config.googleCredential, 'utf8');
         backupData['saJson'] = Base64.encode(googleCredential);
+
+        // TODO: @Lenin, needs to run once for each cluster
         const isBackupSecretCreated = await this.k8Factory
           .default()
           .secrets()
@@ -336,7 +340,10 @@ export class NetworkCommand extends BaseCommand {
       valuesArg += ' --set "defaults.envoyProxy.serviceType=LoadBalancer"';
     }
 
+    // TODO @Lenin, entrypoint for setting the values files,
     if (config.valuesFile) {
+      // TODO: @Lenin, instead of adding it to the valuesArg, then create a copy of the valuesArg, one for each cluster, and append the
+      //   correct valuesFileArg to each valuesArg using the same argument structure as referenced above prepareValuesFiles
       valuesArg += this.prepareValuesFiles(config.valuesFile);
     }
 
@@ -429,9 +436,6 @@ export class NetworkCommand extends BaseCommand {
       flags.genesisThrottlesFile.definition.defaultValue as string,
     );
 
-    config.valuesArg = await this.prepareValuesArg(config);
-    config.namespace = namespace;
-
     config.consensusNodes = this.getConsensusNodes();
     config.contexts = this.getContexts();
     if (config.nodeAliases.length === 0) {
@@ -441,6 +445,11 @@ export class NetworkCommand extends BaseCommand {
       }
     }
 
+    // TODO: @Lenin, maybe we should turn `config.valuesArg` into an object, Record<ClusterRef, valuesArg: string>
+    config.valuesArg = await this.prepareValuesArg(config);
+    config.namespace = namespace;
+
+    // TODO: @Lenin, will need to run once for each cluster
     if (!(await this.k8Factory.default().namespaces().has(namespace))) {
       await this.k8Factory.default().namespaces().create(namespace);
     }
@@ -536,8 +545,10 @@ export class NetworkCommand extends BaseCommand {
         {
           title: 'Check if cluster setup chart is installed',
           task: async () => {
+            // TODO @Lenin, need to use the config.contexts for each isChartInstalled call
             const isChartInstalled = await this.chartManager.isChartInstalled(null, constants.SOLO_CLUSTER_SETUP_CHART);
             if (!isChartInstalled) {
+              // TODO @Lenin, update error message
               throw new SoloError(
                 `Chart ${constants.SOLO_CLUSTER_SETUP_CHART} is not installed. Run 'solo cluster setup'`,
               );
@@ -553,7 +564,7 @@ export class NetworkCommand extends BaseCommand {
                   title: 'Copy Gossip keys to staging',
                   task: ctx => {
                     const config = ctx.config;
-
+                    // TODO @Lenin, need to use consensusNodes instead of nodeAliases
                     this.keyManager.copyGossipKeysToStaging(config.keysDir, config.stagingKeysDir, config.nodeAliases);
                   },
                 },

src/commands/node/handlers.ts

@@ -53,8 +53,8 @@ export class NodeCommandHandlers implements CommandHandlers {
   private readonly tasks: NodeCommandTasks;
   private readonly leaseManager: LeaseManager;
   public readonly remoteConfigManager: RemoteConfigManager;
-  public readonly contexts: string[];
-  public readonly consensusNodes: ConsensusNode[];
+  public contexts: string[];
+  public consensusNodes: ConsensusNode[];
 
   private getConfig: any;
   private prepareChartPath: any;
@@ -83,9 +83,6 @@ export class NodeCommandHandlers implements CommandHandlers {
     this.getConfig = opts.parent.getConfig.bind(opts.parent);
     this.prepareChartPath = opts.parent.prepareChartPath.bind(opts.parent);
 
-    this.consensusNodes = opts.parent.getConsensusNodes();
-    this.contexts = opts.parent.getContexts();
-
     this.parent = opts.parent;
   }
 
@@ -94,6 +91,10 @@ export class NodeCommandHandlers implements CommandHandlers {
   static readonly UPDATE_CONTEXT_FILE = 'node-update.json';
   static readonly UPGRADE_CONTEXT_FILE = 'node-upgrade.json';
 
+  private init() {
+    this.consensusNodes = this.parent.getConsensusNodes();
+    this.contexts = this.parent.getContexts();
+  }
   /** ******** Task Lists **********/
 
   deletePrepareTaskList(argv: any, lease: Lease) {
@@ -742,6 +743,7 @@ export class NodeCommandHandlers implements CommandHandlers {
   }
 
   async keys(argv: any) {
+    this.init();
     argv = helpers.addFlagsToArgv(argv, NodeFlags.KEYS_FLAGS);
 
     const action = this.parent.commandActionBuilder(

src/core/config/remote/components_data_wrapper.ts

@@ -1,7 +1,7 @@
 /**
  * SPDX-License-Identifier: Apache-2.0
  */
-import {ComponentType} from './enumerations.js';
+import {ComponentType, ConsensusNodeStates} from './enumerations.js';
 import {SoloError} from '../../errors.js';
 import {BaseComponent} from './components/base_component.js';
 import {RelayComponent} from './components/relay_component.js';
@@ -16,8 +16,10 @@ import {
   type IConsensusNodeComponent,
   type IRelayComponent,
   type ComponentName,
+  type NamespaceNameAsString,
 } from './types.js';
 import {type ToObject, type Validate} from '../../../types/index.js';
+import * as cluster from 'node:cluster';
 
 /**
  * Represent the components in the remote config and handles:
@@ -230,6 +232,32 @@ export class ComponentsDataWrapper implements Validate, ToObject<ComponentsDataS
     return new ComponentsDataWrapper();
   }
 
+  public static initializeWithNodes(
+    nodeAliases: string[],
+    cluster: string,
+    namespace: NamespaceNameAsString,
+  ): ComponentsDataWrapper {
+    const consensusNodeComponents: Record<ComponentName, ConsensusNodeComponent> = {};
+    nodeAliases.forEach((alias, index) => {
+      consensusNodeComponents[alias] = new ConsensusNodeComponent(
+        alias,
+        cluster,
+        namespace,
+        ConsensusNodeStates.INITIALIZED,
+        index,
+      );
+    });
+    const componentDataWrapper = new ComponentsDataWrapper(
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      consensusNodeComponents,
+      undefined,
+    );
+    return componentDataWrapper;
+  }
+
   /** checks if component exists in the respective group */
   private exists(components: Record<ComponentName, BaseComponent>, newComponent: BaseComponent): boolean {
     return Object.values(components).some(component => BaseComponent.compare(component, newComponent));

src/core/config/remote/remote_config_manager.ts

@@ -27,6 +27,7 @@ import {NamespaceName} from '../../kube/resources/namespace/namespace_name.js';
 import {ResourceNotFoundError} from '../../kube/errors/resource_operation_errors.js';
 import {InjectTokens} from '../../dependency_injection/inject_tokens.js';
 import {Cluster} from './cluster.js';
+import {splitFlagInput} from '../../helpers.js';
 
 /**
  * Uses Kubernetes ConfigMaps to manage the remote configuration data by creating, loading, modifying,
@@ -102,12 +103,19 @@ export class RemoteConfigManager {
       },
     );
 
+    // temporary workaround until we can have `solo deployment add` command
+    const nodeAliases: string[] = splitFlagInput(this.configManager.getFlag(flags.nodeAliasesUnparsed));
+
     this.remoteConfig = new RemoteConfigDataWrapper({
       metadata: new RemoteConfigMetadata(this.getNamespace().name, new Date(), this.localConfig.userEmailAddress),
       clusters,
       commandHistory: ['deployment create'],
       lastExecutedCommand: 'deployment create',
-      components: ComponentsDataWrapper.initializeEmpty(),
+      components: ComponentsDataWrapper.initializeWithNodes(
+        nodeAliases,
+        this.configManager.getFlag(flags.deploymentClusters),
+        this.getNamespace().name,
+      ),
       flags: await CommonFlagsDataWrapper.initialize(this.configManager, argv),
     });
 
@@ -133,12 +141,16 @@ export class RemoteConfigManager {
   private async load(): Promise<boolean> {
     if (this.remoteConfig) return true;
 
-    const configMap = await this.getConfigMap();
-    if (!configMap) return false;
+    try {
+      const configMap = await this.getConfigMap();
 
-    this.remoteConfig = RemoteConfigDataWrapper.fromConfigmap(this.configManager, configMap);
+      if (!configMap) return false;
+      this.remoteConfig = RemoteConfigDataWrapper.fromConfigmap(this.configManager, configMap);
 
-    return true;
+      return true;
+    } catch {
+      return false;
+    }
   }
 
   /**

src/core/kube/k8_client/resources/namespace/k8_client_namespaces.ts

@@ -2,10 +2,12 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import {type Namespaces} from '../../../resources/namespace/namespaces.js';
-import {type CoreV1Api} from '@kubernetes/client-node';
+import {type V1Status, type CoreV1Api} from '@kubernetes/client-node';
 import {StatusCodes} from 'http-status-codes';
 import {SoloError} from '../../../../errors.js';
 import {NamespaceName} from '../../../resources/namespace/namespace_name.js';
+import {ResourceDeleteError} from '../../../errors/resource_operation_errors.js';
+import {ResourceType} from '../../../resources/resource_type.js';
 
 export class K8ClientNamespaces implements Namespaces {
   constructor(private readonly kubeClient: CoreV1Api) {}
@@ -22,8 +24,12 @@ export class K8ClientNamespaces implements Namespaces {
   }
 
   public async delete(namespace: NamespaceName): Promise<boolean> {
-    const resp = await this.kubeClient.deleteNamespace(namespace.name);
-    return resp.response.statusCode === StatusCodes.OK;
+    try {
+      const resp: {response: any; body?: V1Status} = await this.kubeClient.deleteNamespace(namespace.name);
+      return resp.response.statusCode === StatusCodes.OK;
+    } catch {
+      return false;
+    }
   }
 
   public async has(namespace: NamespaceName): Promise<boolean> {

test/e2e/commands/network.test.ts

@@ -20,16 +20,17 @@ import {type NetworkNodes} from '../../../src/core/network_nodes.js';
 import {container} from 'tsyringe-neo';
 import {InjectTokens} from '../../../src/core/dependency_injection/inject_tokens.js';
 
-describe('NetworkCommand', () => {
+describe('NetworkCommand', function networkCommand() {
+  this.bail(true);
   const testName = 'network-cmd-e2e';
   const namespace = NamespaceName.of(testName);
   const applicationEnvFileContents = '# row 1\n# row 2\n# row 3';
   const applicationEnvParentDirectory = path.join(getTmpDir(), 'network-command-test');
   const applicationEnvFilePath = path.join(applicationEnvParentDirectory, 'application.env');
-  const argv = getDefaultArgv();
+  const argv = getDefaultArgv(namespace);
   // argv[flags.namespace.name] = namespace.name;
   argv[flags.releaseTag.name] = HEDERA_PLATFORM_VERSION_TAG;
-  // argv[flags.nodeAliasesUnparsed.name] = 'node1';
+  argv[flags.nodeAliasesUnparsed.name] = 'node1';
   argv[flags.generateGossipKeys.name] = true;
   argv[flags.generateTlsKeys.name] = true;
   argv[flags.deployMinio.name] = true;
@@ -49,6 +50,7 @@ describe('NetworkCommand', () => {
   const clusterCmd = bootstrapResp.cmd.clusterCmd;
   const initCmd = bootstrapResp.cmd.initCmd;
   const nodeCmd = bootstrapResp.cmd.nodeCmd;
+  const deploymentCmd = bootstrapResp.cmd.deploymentCmd;
 
   after(async function () {
     this.timeout(Duration.ofMinutes(3).toMillis());
@@ -59,13 +61,19 @@ describe('NetworkCommand', () => {
   });
 
   before(async () => {
+    await k8Factory.default().namespaces().delete(namespace);
     await initCmd.init(argv);
     await clusterCmd.handlers.setup(argv);
     fs.mkdirSync(applicationEnvParentDirectory, {recursive: true});
     fs.writeFileSync(applicationEnvFilePath, applicationEnvFileContents);
   });
 
-  it('deployment create should succeed', async () => {});
+  it('deployment create should succeed', async () => {
+    expect(await deploymentCmd.create(argv)).to.be.true;
+    argv[flags.nodeAliasesUnparsed.name] = undefined;
+    configManager.reset();
+    configManager.update(argv);
+  });
 
   it('keys should be generated', async () => {
     expect(await nodeCmd.handlers.keys(argv)).to.be.true;

test/test_container.ts

@@ -27,8 +27,9 @@ export function resetForTest(namespace?: NamespaceNameAsString, cacheDir: string
     parsedData.deployments['deployment'].namespace = namespace;
   }
 
-  fs.writeFileSync(path.join(cacheDirectory, localConfigFile), yaml.stringify(parsedData));
+  // need to init the container prior to using K8Client for dependency injection to work
   resetTestContainer(cacheDir);
 
   parsedData.clusterRefs['cluster-1'] = new K8Client(undefined).contexts().readCurrent();
+  fs.writeFileSync(path.join(cacheDirectory, localConfigFile), yaml.stringify(parsedData));
 }