todos

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

Author: jeromy-cannon

src/commands/node.mjs

@@ -40,7 +40,7 @@ export class NodeCommand extends BaseCommand {
     if (!opts || !opts.keytoolDepManager) throw new IllegalArgumentError('An instance of KeytoolDependencyManager is required', opts.keytoolDepManager)
 
     this.downloader = opts.downloader
-    this.plaformInstaller = opts.platformInstaller
+    this.platformInstaller = opts.platformInstaller
     this.keyManager = opts.keyManager
     this.accountManager = opts.accountManager
     this.keytoolDepManager = opts.keytoolDepManager
@@ -312,6 +312,51 @@ export class NodeCommand extends BaseCommand {
     }
   }
 
+  async initializeSetup (config, configManager, k8) {
+    // compute other config parameters
+    config.releasePrefix = Templates.prepareReleasePrefix(config.releaseTag)
+    config.buildZipFile = `${config.cacheDir}/${config.releasePrefix}/build-${config.releaseTag}.zip`
+    config.keysDir = path.join(config.cacheDir, 'keys')
+    config.stagingDir = Templates.renderStagingDir(configManager, flags)
+    config.stagingKeysDir = path.join(config.stagingDir, 'keys')
+
+    if (!await k8.hasNamespace(config.namespace)) {
+      throw new FullstackTestingError(`namespace ${config.namespace} does not exist`)
+    }
+
+    // prepare staging keys directory
+    if (!fs.existsSync(config.stagingKeysDir)) {
+      fs.mkdirSync(config.stagingKeysDir, { recursive: true })
+    }
+
+    // create cached keys dir if it does not exist yet
+    if (!fs.existsSync(config.keysDir)) {
+      fs.mkdirSync(config.keysDir)
+    }
+  }
+
+  fetchPlatformSoftware (ctx, task, platformInstaller) {
+    const config = ctx.config
+
+    const subTasks = []
+    for (const nodeId of ctx.config.nodeIds) {
+      const podName = ctx.config.podNames[nodeId]
+      subTasks.push({
+        title: `Node: ${chalk.yellow(nodeId)}`,
+        task: () =>
+          platformInstaller.fetchPlatform(podName, config.releaseTag)
+      })
+    }
+
+    // set up the sub-tasks
+    return task.newListr(subTasks, {
+      concurrent: true, // since we download in the container directly, we want this to be in parallel across all nodes
+      rendererOptions: {
+        collapseSubtasks: false
+      }
+    })
+  }
+
   async setup (argv) {
     const self = this
 
@@ -345,26 +390,7 @@ export class NodeCommand extends BaseCommand {
             curDate: new Date()
           }
 
-          // compute other config parameters
-          config.releasePrefix = Templates.prepareReleasePrefix(config.releaseTag)
-          config.buildZipFile = `${config.cacheDir}/${config.releasePrefix}/build-${config.releaseTag}.zip`
-          config.keysDir = path.join(config.cacheDir, 'keys')
-          config.stagingDir = Templates.renderStagingDir(self.configManager, flags)
-          config.stagingKeysDir = path.join(config.stagingDir, 'keys')
-
-          if (!await this.k8.hasNamespace(config.namespace)) {
-            throw new FullstackTestingError(`namespace ${config.namespace} does not exist`)
-          }
-
-          // prepare staging keys directory
-          if (!fs.existsSync(config.stagingKeysDir)) {
-            fs.mkdirSync(config.stagingKeysDir, { recursive: true })
-          }
-
-          // create cached keys dir if it does not exist yet
-          if (!fs.existsSync(config.keysDir)) {
-            fs.mkdirSync(config.keysDir)
-          }
+          await self.initializeSetup(config, self.configManager, self.k8)
 
           // set config in the context for later tasks to use
           ctx.config = config
@@ -474,7 +500,7 @@ export class NodeCommand extends BaseCommand {
                 const config = ctx.config
                 const configTxtPath = `${config.stagingDir}/config.txt`
                 const template = `${constants.RESOURCES_DIR}/templates/config.template`
-                await self.plaformInstaller.prepareConfigTxt(config.nodeIds, configTxtPath, config.releaseTag, config.chainId, template)
+                await self.platformInstaller.prepareConfigTxt(config.nodeIds, configTxtPath, config.releaseTag, config.chainId, template)
               }
             }
           ]
@@ -489,25 +515,7 @@ export class NodeCommand extends BaseCommand {
         title: 'Fetch platform software into network nodes',
         task:
           async (ctx, task) => {
-            const config = ctx.config
-
-            const subTasks = []
-            for (const nodeId of ctx.config.nodeIds) {
-              const podName = ctx.config.podNames[nodeId]
-              subTasks.push({
-                title: `Node: ${chalk.yellow(nodeId)}`,
-                task: () =>
-                  self.plaformInstaller.fetchPlatform(podName, config.releaseTag)
-              })
-            }
-
-            // set up the sub-tasks
-            return task.newListr(subTasks, {
-              concurrent: true, // since we download in the container directly, we want this to be in parallel across all nodes
-              rendererOptions: {
-                collapseSubtasks: false
-              }
-            })
+            return self.fetchPlatformSoftware(ctx, task, self.platformInstaller)
           }
       },
       {
@@ -521,7 +529,7 @@ export class NodeCommand extends BaseCommand {
             subTasks.push({
               title: `Node: ${chalk.yellow(nodeId)}`,
               task: () =>
-                self.plaformInstaller.taskInstall(podName, config.buildZipFile, config.stagingDir, config.nodeIds, config.keyFormat, config.force)
+                self.platformInstaller.taskInstall(podName, config.buildZipFile, config.stagingDir, config.nodeIds, config.keyFormat, config.force)
             })
           }
 
@@ -879,45 +887,22 @@ export class NodeCommand extends BaseCommand {
             flags.nodeIDs,
             flags.releaseTag,
             flags.cacheDir,
-            flags.chainId,
             flags.keyFormat
-          ]) // TODO verify we need all of these
+          ])
 
           const config = {
             namespace: self.configManager.getFlag(flags.namespace),
             nodeIds: helpers.parseNodeIDs(self.configManager.getFlag(flags.nodeIDs)),
             releaseTag: self.configManager.getFlag(flags.releaseTag),
             cacheDir: self.configManager.getFlag(flags.cacheDir),
             force: self.configManager.getFlag(flags.force),
-            chainId: self.configManager.getFlag(flags.chainId),
             applicationEnv: self.configManager.getFlag(flags.applicationEnv),
             keyFormat: self.configManager.getFlag(flags.keyFormat),
             de3vMode: self.configManager.getFlag(flags.devMode),
             curDate: new Date()
           }
 
-          // compute other config parameters
-          // TODO DRY
-          self.logger.debug(`[cacheDir=${config.cacheDir}]`)
-          config.releasePrefix = Templates.prepareReleasePrefix(config.releaseTag)
-          config.buildZipFile = `${config.cacheDir}/${config.releasePrefix}/build-${config.releaseTag}.zip`
-          config.keysDir = path.join(config.cacheDir, 'keys')
-          config.stagingDir = Templates.renderStagingDir(self.configManager, flags)
-          config.stagingKeysDir = path.join(config.stagingDir, 'keys')
-
-          if (!await this.k8.hasNamespace(config.namespace)) {
-            throw new FullstackTestingError(`namespace ${config.namespace} does not exist`)
-          }
-
-          // prepare staging keys directory
-          if (!fs.existsSync(config.stagingKeysDir)) {
-            fs.mkdirSync(config.stagingKeysDir, { recursive: true })
-          }
-
-          // create cached keys dir if it does not exist yet
-          if (!fs.existsSync(config.keysDir)) {
-            fs.mkdirSync(config.keysDir)
-          }
+          await self.initializeSetup(config, self.configManager, self.k8)
 
           // set config in the context for later tasks to use
           ctx.config = config
@@ -952,32 +937,14 @@ export class NodeCommand extends BaseCommand {
               })
             }
       },
-      { // TODO DRY
+      {
         title: 'Fetch platform software into network nodes',
         task:
             async (ctx, task) => {
-              const config = ctx.config
-
-              const subTasks = []
-              for (const nodeId of ctx.config.nodeIds) {
-                const podName = ctx.config.podNames[nodeId]
-                subTasks.push({
-                  title: `Node: ${chalk.yellow(nodeId)}`,
-                  task: () =>
-                    self.plaformInstaller.fetchPlatform(podName, config.releaseTag)
-                })
-              }
-
-              // set up the sub-tasks
-              return task.newListr(subTasks, {
-                concurrent: true, // since we download in the container directly, we want this to be in parallel across all nodes
-                rendererOptions: {
-                  collapseSubtasks: false
-                }
-              })
+              return self.fetchPlatformSoftware(ctx, task, self.platformInstaller)
             }
       },
-      { // TODO DRY
+      {
         title: 'Setup network nodes',
         task: async (ctx, parentTask) => {
           const config = ctx.config
@@ -993,7 +960,7 @@ export class NodeCommand extends BaseCommand {
             subTasks.push({
               title: `Node: ${chalk.yellow(nodeId)}`,
               task: () =>
-                self.plaformInstaller.taskInstall(podName, config.buildZipFile,
+                self.platformInstaller.taskInstall(podName, config.buildZipFile,
                   config.stagingDir, nodeList, config.keyFormat, config.force)
             })
           }
@@ -1218,7 +1185,6 @@ export class NodeCommand extends BaseCommand {
               flags.nodeIDs,
               flags.releaseTag,
               flags.cacheDir,
-              flags.chainId,
               flags.applicationEnv,
               flags.keyFormat
             ),