fix(plugins/plugin-s3): up command does not respect --cos-instance choice for ibm cloud

part of #7677

Author: starpit

plugins/plugin-core-support/up/src/ibm/cos/creds.ts

@@ -19,9 +19,17 @@ import { Arguments, encodeComponent } from '@kui-shell/core'
 
 import Options from '../options'
 
-async function check({ REPL }: Pick<Arguments, 'REPL'>) {
+/** @return a --cos-instance command line option, if specified */
+function cosinstance(parsedOptions: Arguments<Options>['parsedOptions']) {
+  const cosinstance = parsedOptions['cos-instance']
+    ? `--cos-instance ${encodeComponent(parsedOptions['cos-instance'])}`
+    : ''
+  return cosinstance
+}
+
+async function check({ REPL, parsedOptions }: Pick<Arguments<Options>, 'REPL' | 'parsedOptions'>) {
   try {
-    return await REPL.qexec<string>('ibmcloud cos validate --output name')
+    return await REPL.qexec<string>(`ibmcloud cos validate --output name ${cosinstance(parsedOptions)}`)
   } catch (err) {
     return false
   }
@@ -33,10 +41,7 @@ export default {
     (!checkResult ? colors.red('not configured') : colors.gray('service-instance=') + colors.yellow(checkResult)),
   needsCloudLogin: true,
   fix: async (args: Arguments<Options>) => {
-    const cosinstance = args.parsedOptions['cos-instance']
-      ? `--cos-instance ${encodeComponent(args.parsedOptions['cos-instance'])}`
-      : ''
-    await args.REPL.qexec(`ibmcloud cos bind ${cosinstance}`)
+    await args.REPL.qexec(`ibmcloud cos bind ${cosinstance(args.parsedOptions)}`)
     return check(args)
   },
   onFail: 'ibmcloud cos bind',

plugins/plugin-s3/i18n/ibm_en_US.json

@@ -0,0 +1,8 @@
+{
+  "validCreds": "Your connection to IBM Cloud Object Storage looks good",
+  "noCreds": "An HMAC key is needed. Please try [ibmcloud cos bind](#kuiexec?command=ibmcloud%20cos%20bind).",
+  "invalidConfiguration": "Invalid IBM Cloud Object Storage configuration detected.",
+  "noServiceInstanceNameError": "Cannot find the Cloud Object Storage service instance for your credentials",
+  "nonMatchingServiceNameError": "Desired Cloud Object Storage service instance not selected: {0} != {1}",
+  "noEndpoint": "Please set your IBM Cloud Object Storage endpoint via [ibmcloud cos endpoint](#kuiexec?command=ibmcloud%20cos%20endpoint)."
+}

plugins/plugin-s3/ibm/src/controller/bind.ts

@@ -128,15 +128,17 @@ async function findCredentials(
 ): Promise<void | Config> {
   const local = await findLocal(args.REPL)
 
-  if (local) {
+  const instanceName = args.parsedOptions['cos-instance']
+  const matchingNames = local && (!instanceName || local.serviceInstanceName === instanceName)
+
+  if (local && matchingNames) {
     debug('already have valid local config')
     return local
   } else {
     const instances = await (instancesP || findInstances(args))
     debug('instances', instances)
 
     if (instances.length > 0) {
-      const instanceName = args.parsedOptions['cos-instance']
       const instance = instanceName ? instances.find(_ => _.name === instanceName) : instances[0]
       if (!instance) {
         throw new Error(`Cannot find specified instance ${instanceName}`)

plugins/plugin-s3/ibm/src/controller/validate.ts

@@ -22,19 +22,26 @@ import { setServiceInstanceName } from './bind'
 import { setEndpointIfPossible } from './endpoint'
 import Config, { hasEndpoint, hasServiceInstanceName } from '../model/Config'
 
-const strings = i18n('plugin-ibmcloud', 'cos')
+const strings = i18n('plugin-s3', 'ibm')
 
 interface Options extends ParsedOptions {
   output: 'name'
+  'cos-instance': string
 }
 
 /** Avoid redundant lookups for one-and-done headless mode */
 const headlessTasks: Record<string, Promise<string | Config>> = {}
+function invalidate({ command }: Pick<Arguments, 'command'>) {
+  return (headlessTasks[command] = undefined)
+}
 
 async function innerValidate(args: Arguments<Options>): Promise<string | Config> {
   const config = await readConfig(args)
 
-  if (isGoodConfig(config)) {
+  const instanceName = args.parsedOptions['cos-instance']
+  const matchingNames = !instanceName || config.serviceInstanceName === instanceName
+
+  if (isGoodConfig(config) && matchingNames) {
     if (args.execOptions.type !== ExecType.Nested) {
       return strings('validCreds')
     } else if (args.parsedOptions.output === 'name') {
@@ -53,16 +60,24 @@ async function innerValidate(args: Arguments<Options>): Promise<string | Config>
     const noCredsMessage = strings('noCreds')
     const noEndpointMessage = strings('noEndpoint')
     const noServiceInstanceNameError = strings('noServiceInstanceName')
+    const nonMatchingServiceNameError = strings('nonMatchingServiceNameError', instanceName, config.serviceInstanceName)
 
     if (noEndpoint && noCreds) {
+      invalidate(args)
       throw new Error(`${noCredsMessage} ${noEndpointMessage}`)
     } else if (noEndpoint) {
+      invalidate(args)
       throw new Error(noEndpointMessage)
     } else if (noCreds) {
+      invalidate(args)
       throw new Error(noCredsMessage)
     } else {
       if (!hasServiceInstanceName(config) && !(await setServiceInstanceName(args, config))) {
+        invalidate(args)
         throw new Error(noServiceInstanceNameError)
+      } else if (!matchingNames) {
+        invalidate(args)
+        throw new Error(nonMatchingServiceNameError)
       }
 
       if (args.parsedOptions.output === 'name') {