fix(codecatalyst): noisy getUserDetails() API calls #3333

Problem:
We try to call getDevEnvironment (and by proxy getUserDetails) even though we
can check if it will fail ahead of time. This happens when rendering the
developer tools view.

Solution:
* Check environment variables before making the call.
* Move error handling up so the meaning of undefined is not conflated with
  errors.
* Lazily generate client for dev env reconnect.

Author: JadenSimon

src/codecatalyst/activation.ts

@@ -14,7 +14,6 @@ import { CodeCatalystAuthenticationProvider } from './auth'
 import { registerDevfileWatcher } from './devfile'
 import { DevEnvClient } from '../shared/clients/devenvClient'
 import { watchRestartingDevEnvs } from './reconnect'
-import { getCodeCatalystDevEnvId } from '../shared/vscode/env'
 import { PromptSettings } from '../shared/settings'
 import { dontShow } from '../shared/localizedText'
 import { isCloud9 } from '../shared/extensionUtilities'
@@ -62,9 +61,12 @@ export async function activate(ctx: ExtContext): Promise<void> {
         ctx.extensionContext.subscriptions.push(registerDevfileWatcher(DevEnvClient.instance))
     }
 
-    const settings = PromptSettings.instance
-    if (getCodeCatalystDevEnvId()) {
-        const thisDevenv = await getThisDevEnv(authProvider)
+    const thisDevenv = (await getThisDevEnv(authProvider))?.unwrapOrElse(err => {
+        getLogger().warn('codecatalyst: failed to get current Dev Enviroment: %s', err)
+        return undefined
+    })
+
+    if (thisDevenv) {
         getLogger().info('codecatalyst: Dev Environment ides=%O', thisDevenv?.summary.ides)
         if (thisDevenv && !isDevenvVscode(thisDevenv.summary.ides)) {
             // Prevent Toolkit from reconnecting to a "non-vscode" devenv by actively closing it.
@@ -73,6 +75,7 @@ export async function activate(ctx: ExtContext): Promise<void> {
             return
         }
 
+        const settings = PromptSettings.instance
         if (await settings.isPromptEnabled('remoteConnected')) {
             const message = localize(
                 'AWS.codecatalyst.connectedMessage',

src/codecatalyst/commands.ts

@@ -184,11 +184,11 @@ interface CodeCatalystCommand<T extends any[], U> {
 }
 
 interface ClientInjector {
-    <T extends any[], U>(command: CodeCatalystCommand<T, U>, ...args: T): Promise<U | undefined>
+    <T extends any[], U>(command: CodeCatalystCommand<T, U>, ...args: T): Promise<U>
 }
 
 interface CommandDecorator {
-    <T extends any[], U>(command: CodeCatalystCommand<T, U>): (...args: T) => Promise<U | undefined>
+    <T extends any[], U>(command: CodeCatalystCommand<T, U>): (...args: T) => Promise<U>
 }
 
 type Inject<T, U> = T extends (...args: infer P) => infer R
@@ -281,10 +281,6 @@ export class CodeCatalystCommands {
     public async openDevEnvSettings(): Promise<void> {
         const devenv = await this.withClient(getConnectedDevEnv)
 
-        if (!devenv) {
-            throw new Error('No devenv available')
-        }
-
         return this.withClient(showConfigureDevEnv, globals.context, devenv, CodeCatalystCommands.declared)
     }
 

src/codecatalyst/explorer.ts

@@ -15,6 +15,7 @@ import { CodeCatalystAuthenticationProvider } from './auth'
 import { CodeCatalystCommands } from './commands'
 import { ConnectedDevEnv, getDevfileLocation, getThisDevEnv } from './model'
 import * as codecatalyst from './model'
+import { getLogger } from '../shared/logger'
 
 const getStartedCommand = Commands.register(
     'aws.codecatalyst.getStarted',
@@ -125,7 +126,10 @@ export class CodeCatalystRootNode implements RootNode {
     }
 
     public async getTreeItem() {
-        this.devenv = await getThisDevEnv(this.authProvider)
+        this.devenv = (await getThisDevEnv(this.authProvider))?.unwrapOrElse(err => {
+            getLogger().warn('codecatalyst: failed to get current Dev Enviroment: %s', err)
+            return undefined
+        })
 
         const item = new vscode.TreeItem('CodeCatalyst', vscode.TreeItemCollapsibleState.Collapsed)
         item.contextValue = this.authProvider.isUsingSavedConnection

src/codecatalyst/model.ts

@@ -17,7 +17,7 @@ import {
 import { DevEnvClient } from '../shared/clients/devenvClient'
 import { getLogger } from '../shared/logger'
 import { AsyncCollection, toCollection } from '../shared/utilities/asyncCollection'
-import { getCodeCatalystSpaceName, getCodeCatalystProjectName } from '../shared/vscode/env'
+import { getCodeCatalystSpaceName, getCodeCatalystProjectName, getCodeCatalystDevEnvId } from '../shared/vscode/env'
 import { writeFile } from 'fs-extra'
 import { sshAgentSocketVariable, startSshAgent, startVscodeRemote } from '../shared/extensions/ssh'
 import { ChildProcess } from '../shared/utilities/childProcess'
@@ -28,7 +28,8 @@ import { Commands } from '../shared/vscode/commands2'
 import { areEqual } from '../shared/utilities/pathUtils'
 import { fileExists } from '../shared/filesystemUtilities'
 import { CodeCatalystAuthenticationProvider } from './auth'
-import { UnknownError } from '../shared/errors'
+import { ToolkitError } from '../shared/errors'
+import { Result } from '../shared/utilities/result'
 
 export type DevEnvironmentId = Pick<DevEnvironment, 'id' | 'org' | 'project'>
 
@@ -154,10 +155,10 @@ export interface ConnectedDevEnv {
 export async function getConnectedDevEnv(
     codeCatalystClient: CodeCatalystClient,
     devenvClient = DevEnvClient.instance
-): Promise<ConnectedDevEnv | undefined> {
+): Promise<ConnectedDevEnv> {
     const devEnvId = devenvClient.id
-    if (!devEnvId || !devenvClient.isCodeCatalystDevEnv()) {
-        return
+    if (!devEnvId) {
+        throw new ToolkitError('Not connected to a dev environment', { code: 'NotConnectedToDevEnv' })
     }
 
     const projectName = getCodeCatalystProjectName()
@@ -180,17 +181,20 @@ export async function getConnectedDevEnv(
  * Gets the current devenv that Toolkit is running in, if any.
  */
 export async function getThisDevEnv(authProvider: CodeCatalystAuthenticationProvider) {
+    if (!getCodeCatalystDevEnvId()) {
+        return
+    }
+
     try {
         await authProvider.restore()
         const conn = authProvider.activeConnection
         if (conn !== undefined && authProvider.auth.getConnectionState(conn) === 'valid') {
             const client = await createClient(conn)
-            return await getConnectedDevEnv(client)
+            return Result.ok(await getConnectedDevEnv(client))
         }
     } catch (err) {
-        getLogger().warn(`codecatalyst: failed to get Dev Environment: ${UnknownError.cast(err).message}`)
+        return Result.err(err)
     }
-    return undefined
 }
 
 /**

src/codecatalyst/reconnect.ts

@@ -16,6 +16,7 @@ import { CodeCatalystAuthenticationProvider } from './auth'
 import { getCodeCatalystDevEnvId } from '../shared/vscode/env'
 import globals from '../shared/extensionGlobals'
 import { isDevenvVscode, recordSource } from './utils'
+import { SsoConnection } from '../credentials/auth'
 
 const localize = nls.loadMessageBundle()
 
@@ -30,14 +31,13 @@ export function watchRestartingDevEnvs(ctx: ExtContext, authProvider: CodeCataly
         }
         getLogger().info(`codecatalyst: reconnect: onDidChangeActiveConnection: startUrl=${conn.startUrl}`)
 
-        const client = await createClient(conn)
         const envId = getCodeCatalystDevEnvId()
-        handleRestart(client, ctx, envId)
+        handleRestart(conn, ctx, envId)
         restartHandled = true
     })
 }
 
-function handleRestart(client: CodeCatalystClient, ctx: ExtContext, envId: string | undefined) {
+function handleRestart(conn: SsoConnection, ctx: ExtContext, envId: string | undefined) {
     if (envId !== undefined) {
         const memento = ctx.extensionContext.globalState
         const pendingReconnects = memento.get<Record<string, DevEnvMemento>>(codecatalystReconnectKey, {})
@@ -55,18 +55,18 @@ function handleRestart(client: CodeCatalystClient, ctx: ExtContext, envId: strin
         getLogger().info('codecatalyst: attempting to poll dev environments')
 
         // Reconnect devenvs (if coming from a restart)
-        reconnectDevEnvs(client, ctx).catch(err => {
+        reconnectDevEnvs(conn, ctx).catch(err => {
             getLogger().error(`codecatalyst: error while resuming devenvs: ${err}`)
         })
     }
 }
 
 /**
  * Attempt to poll for connection in all valid devenvs
- * @param client a connected client
+ * @param conn a connection that may be used for CodeCatalyst
  * @param ctx the extension context
  */
-async function reconnectDevEnvs(client: CodeCatalystClient, ctx: ExtContext): Promise<void> {
+async function reconnectDevEnvs(conn: SsoConnection, ctx: ExtContext): Promise<void> {
     const memento = ctx.extensionContext.globalState
     const pendingDevEnvs = memento.get<Record<string, DevEnvMemento>>(codecatalystReconnectKey, {})
     const validDevEnvs = filterInvalidDevEnvs(pendingDevEnvs)
@@ -85,12 +85,14 @@ async function reconnectDevEnvs(client: CodeCatalystClient, ctx: ExtContext): Pr
         'Dev Environments restarting: {0}',
         polledDevEnvs
     )
-    vscode.window.withProgress(
+    await vscode.window.withProgress(
         {
             location: vscode.ProgressLocation.Notification,
         },
-        (progress, token) => {
+        async (progress, token) => {
             progress.report({ message: progressTitle })
+            const client = await createClient(conn)
+
             return pollDevEnvs(client, progress, token, memento, validDevEnvs)
         }
     )

src/testE2E/codecatalyst/client.test.ts

@@ -12,7 +12,7 @@ import {
     createClient as createCodeCatalystClient,
     DevEnvironment,
 } from '../../shared/clients/codecatalystClient'
-import { prepareDevEnvConnection } from '../../codecatalyst/model'
+import { getThisDevEnv, prepareDevEnvConnection } from '../../codecatalyst/model'
 import { Auth, createBuilderIdProfile, SsoConnection } from '../../credentials/auth'
 import { CodeCatalystAuthenticationProvider, isValidCodeCatalystConnection } from '../../codecatalyst/auth'
 import { CodeCatalystCommands, DevEnvironmentSettings } from '../../codecatalyst/commands'
@@ -131,6 +131,29 @@ describe('Test how this codebase uses the CodeCatalyst API', function () {
             })
         })
 
+        describe('getThisDevEnv', function () {
+            const ccAuth = CodeCatalystAuthenticationProvider.fromContext(globals.context)
+
+            it('returns `undefined` if not in a dev environment', async function () {
+                const result = await getThisDevEnv(ccAuth)
+                assert.strictEqual(result, undefined)
+            })
+
+            it('returns an error if in a dev environment but the API calls fail', async function () {
+                const oldEnv = { ...process.env }
+                process.env['__DEV_ENVIRONMENT_ID'] = defaultDevEnv.id
+                process.env['__DEV_ENVIRONMENT_SPACE_NAME'] = defaultDevEnv.org.name
+                process.env['__DEV_ENVIRONMENT_PROJECT_NAME'] = 'wrong-project-name'
+
+                try {
+                    const result = await getThisDevEnv(ccAuth)
+                    assert.ok(result?.isErr(), 'Expected an error to be returned')
+                } finally {
+                    process.env = oldEnv
+                }
+            })
+        })
+
         it('creates an empty Dev Environment', async function () {
             const emptyDevEnvSettings = buildDevEnvSettings()
             const emptyDevEnv = await createDevEnvFromWebview(emptyDevEnvSettings, {