Merge master into feature/LSP-alpha

Author: aws-toolkit-automation

packages/core/src/awsService/cloudformation/commands/cfnCommands.ts

@@ -31,7 +31,6 @@ import {
     shouldImportResources,
     getResourcesToImport,
     getEnvironmentName,
-    getChangeSetName,
     chooseOptionalFlagSuggestion as chooseOptionalFlagMode,
     getTags,
     getOnStackFailure,
@@ -111,14 +110,8 @@ export function executeChangeSetCommand(client: LanguageClient, coordinator: Sta
 }
 
 export function deleteChangeSetCommand(client: LanguageClient) {
-    return commands.registerCommand(commandKey('stacks.deleteChangeSet'), async (params?: ChangeSetReference) => {
+    return commands.registerCommand(commandKey('stacks.deleteChangeSet'), async (params: ChangeSetReference) => {
         try {
-            params = params ?? (await promptForChangeSetReference())
-
-            if (!params) {
-                return
-            }
-
             const changeSetDeletion = new ChangeSetDeletion(params.stackName, params.changeSetName, client)
 
             await changeSetDeletion.delete()
@@ -129,14 +122,8 @@ export function deleteChangeSetCommand(client: LanguageClient) {
 }
 
 export function viewChangeSetCommand(client: LanguageClient, diffProvider: DiffWebviewProvider) {
-    return commands.registerCommand(commandKey('stacks.viewChangeSet'), async (params?: ChangeSetReference) => {
+    return commands.registerCommand(commandKey('stacks.viewChangeSet'), async (params: ChangeSetReference) => {
         try {
-            params = params ?? (await promptForChangeSetReference())
-
-            if (!params) {
-                return
-            }
-
             const describeChangeSetResult = await describeChangeSet(client, {
                 changeSetName: params.changeSetName,
                 stackName: params.stackName,
@@ -157,16 +144,6 @@ export function viewChangeSetCommand(client: LanguageClient, diffProvider: DiffW
     })
 }
 
-async function promptForChangeSetReference(): Promise<ChangeSetReference | undefined> {
-    const stackName = await getStackName()
-    const changeSetName = await getChangeSetName()
-    if (!stackName || !changeSetName) {
-        return undefined
-    }
-
-    return { stackName: stackName, changeSetName: changeSetName }
-}
-
 export function deployTemplateCommand(
     client: LanguageClient,
     diffProvider: DiffWebviewProvider,

packages/core/src/awsService/cloudformation/extension.ts

@@ -52,7 +52,7 @@ import { AwsCredentialsService, encryptionKey } from './auth/credentials'
 import { ExtensionId, ExtensionName, Version, CloudFormationTelemetrySettings } from './extensionConfig'
 import { commandKey } from './utils'
 import { CloudFormationExplorer } from './explorer/explorer'
-import { promptTelemetryOptInWithTimeout } from './telemetryOptIn'
+import { handleTelemetryOptIn } from './telemetryOptIn'
 
 import { refreshCommand, StacksManager } from './stacks/stacksManager'
 import { StackOverviewWebviewProvider } from './ui/stackOverviewWebviewProvider'
@@ -89,7 +89,7 @@ let clientDisposables: Disposable[] = []
 
 async function startClient(context: ExtensionContext) {
     const cfnTelemetrySettings = new CloudFormationTelemetrySettings()
-    const telemetryEnabled = await promptTelemetryOptInWithTimeout(context, cfnTelemetrySettings)
+    const telemetryEnabled = await handleTelemetryOptIn(context, cfnTelemetrySettings)
 
     const cfnLspConfig = {
         ...DevSettings.instance.getServiceConfig('cloudformationLsp', {}),

packages/core/src/awsService/cloudformation/stacks/actions/changeSetDeletionWorkflow.ts

@@ -15,20 +15,20 @@ import {
 import { deleteChangeSet, describeChangeSetDeletionStatus, getChangeSetDeletionStatus } from './stackActionApi'
 import { createChangeSetDeletionParams } from './stackActionUtil'
 import { getLogger } from '../../../../shared/logger/logger'
-import { extractErrorMessage } from '../../utils'
+import { commandKey, extractErrorMessage } from '../../utils'
+import { commands } from 'vscode'
+import globals from '../../../../shared/extensionGlobals'
 
 export class ChangeSetDeletion {
     private readonly id: string
-    private readonly stackName: string
-    private readonly changeSetName: string
-    private readonly client: LanguageClient
     private status: StackActionPhase | undefined
 
-    constructor(stackName: string, changeSetName: string, client: LanguageClient) {
+    constructor(
+        private readonly stackName: string,
+        private readonly changeSetName: string,
+        private readonly client: LanguageClient
+    ) {
         this.id = uuidv4()
-        this.stackName = stackName
-        this.changeSetName = changeSetName
-        this.client = client
     }
 
     async delete() {
@@ -38,7 +38,7 @@ export class ChangeSetDeletion {
     }
 
     private pollForProgress() {
-        const interval = setInterval(() => {
+        const interval = globals.clock.setInterval(() => {
             getChangeSetDeletionStatus(this.client, { id: this.id })
                 .then(async (deletionResult) => {
                     if (deletionResult.phase === this.status) {
@@ -66,7 +66,8 @@ export class ChangeSetDeletion {
                                     describeDeplomentStatusResult.FailureReason ?? 'No failure reason provided'
                                 )
                             }
-                            clearInterval(interval)
+                            void commands.executeCommand(commandKey('stacks.refresh'))
+                            globals.clock.clearInterval(interval)
                             break
                         case StackActionPhase.DELETION_FAILED: {
                             const describeDeplomentStatusResult = await describeChangeSetDeletionStatus(this.client, {
@@ -77,15 +78,17 @@ export class ChangeSetDeletion {
                                 this.stackName,
                                 describeDeplomentStatusResult.FailureReason ?? 'No failure reason provided'
                             )
-                            clearInterval(interval)
+                            void commands.executeCommand(commandKey('stacks.refresh'))
+                            globals.clock.clearInterval(interval)
                             break
                         }
                     }
                 })
                 .catch(async (error) => {
                     getLogger().error(`Error polling for deletion status: ${error}`)
                     showErrorMessage(`Error polling for deletion status: ${extractErrorMessage(error)}`)
-                    clearInterval(interval)
+                    void commands.executeCommand(commandKey('stacks.refresh'))
+                    globals.clock.clearInterval(interval)
                 })
         }, 1000)
     }

packages/core/src/awsService/cloudformation/telemetryOptIn.ts

@@ -7,74 +7,165 @@ import { ExtensionContext, env, Uri, window } from 'vscode'
 import { CloudFormationTelemetrySettings } from './extensionConfig'
 import { commandKey } from './utils'
 import { isAutomation } from '../../shared/vscode/env'
+import { getLogger } from '../../shared/logger/logger'
+import globals from '../../shared/extensionGlobals'
 
-export async function promptTelemetryOptInWithTimeout(
-    context: ExtensionContext,
-    cfnTelemetrySettings: CloudFormationTelemetrySettings
-): Promise<boolean> {
-    const promptPromise = promptTelemetryOptIn(context, cfnTelemetrySettings)
-    const timeoutPromise = new Promise<false>((resolve) => setTimeout(() => resolve(false), 2500))
+enum TelemetryChoice {
+    Allow = 'Yes, Allow',
+    Later = 'Not Now',
+    Never = 'Never',
+    LearnMore = 'Learn More',
+}
 
-    const result = await Promise.race([promptPromise, timeoutPromise])
+const telemetryKeys = {
+    hasResponded: commandKey('telemetry.hasResponded'),
+    lastPromptDate: commandKey('telemetry.lastPromptDate'),
+    unpersistedResponse: commandKey('telemetry.unpersistedResponse'),
+} as const
 
-    // Keep prompt alive in background
-    void promptPromise
+const telemetrySettings = {
+    enabled: 'enabled',
+} as const
 
-    return result
-}
+const thirtyDaysMs = 30 * 24 * 60 * 60 * 1000
+const promptTimeoutMs = 2500
+const telemetryDocsUrl = 'https://github.com/aws-cloudformation/cloudformation-languageserver/tree/main/src/telemetry'
 
 /* eslint-disable aws-toolkits/no-banned-usages */
-async function promptTelemetryOptIn(
+export async function handleTelemetryOptIn(
     context: ExtensionContext,
     cfnTelemetrySettings: CloudFormationTelemetrySettings
 ): Promise<boolean> {
-    const telemetryEnabled = cfnTelemetrySettings.get('enabled', false)
-    if (isAutomation()) {
-        return telemetryEnabled
+    // If previous choice failed to persist, persist it now and return
+    const unpersistedResponse = (await context.globalState.get(telemetryKeys.unpersistedResponse)) as string
+    const hasResponded = context.globalState.get<boolean>(telemetryKeys.hasResponded)
+    const lastPromptDate = context.globalState.get<number>(telemetryKeys.lastPromptDate)
+    if (unpersistedResponse) {
+        // May still raise popup if user lacks permission or file is corrupted
+        const didSave = await saveTelemetryResponse(unpersistedResponse, cfnTelemetrySettings)
+        await context.globalState.update(telemetryKeys.unpersistedResponse, undefined)
+        // If we still couldn't save, clear everything so they get asked again until the file/perms is fixed
+        if (!didSave) {
+            getLogger().warn(
+                'CloudFormation telemetry choice was not saved successfully after restart. Clearing related globalState keys for next restart'
+            )
+            await context.globalState.update(telemetryKeys.hasResponded, undefined)
+            await context.globalState.update(telemetryKeys.lastPromptDate, undefined)
+        }
+        return logAndReturnTelemetryChoice(
+            unpersistedResponse === TelemetryChoice.Allow.toString(),
+            hasResponded,
+            lastPromptDate
+        )
     }
 
-    const hasResponded = context.globalState.get<boolean>(commandKey('telemetry.hasResponded'), false)
-    const lastPromptDate = context.globalState.get<number>(commandKey('telemetry.lastPromptDate'), 0)
-    const now = Date.now()
-    const thirtyDaysMs = 30 * 24 * 60 * 60 * 1000
+    // Never throws because we provide a default
+    const telemetryEnabled = cfnTelemetrySettings.get(telemetrySettings.enabled, false)
+
+    if (isAutomation()) {
+        return logAndReturnTelemetryChoice(telemetryEnabled)
+    }
 
     // If user has permanently responded, use their choice
     if (hasResponded) {
-        return telemetryEnabled
+        return logAndReturnTelemetryChoice(telemetryEnabled, hasResponded)
     }
 
     // Check if we should show reminder (30 days since last prompt)
-    const shouldPrompt = lastPromptDate === 0 || now - lastPromptDate >= thirtyDaysMs
+    const shouldPrompt = lastPromptDate === undefined || globals.clock.Date.now() - lastPromptDate >= thirtyDaysMs
     if (!shouldPrompt) {
-        return telemetryEnabled
+        return logAndReturnTelemetryChoice(telemetryEnabled, hasResponded, lastPromptDate)
+    }
+
+    // Show prompt but set false if timeout
+    const promptPromise = promptTelemetryOptIn(context, cfnTelemetrySettings)
+    const timeoutPromise = new Promise<false>((resolve) =>
+        globals.clock.setTimeout(() => resolve(false), promptTimeoutMs)
+    )
+    const result = await Promise.race([promptPromise, timeoutPromise])
+
+    // Keep prompt alive in background
+    void promptPromise
+
+    return logAndReturnTelemetryChoice(result)
+}
+/**
+ * Updates the telemetry setting. In case of error, the update calls do not throw.
+ * They instead raise a popup and return false.
+ *
+ * @returns boolean whether the save/update was successful
+ */
+/* eslint-disable aws-toolkits/no-banned-usages */
+async function saveTelemetryResponse(
+    response: string | undefined,
+    cfnTelemetrySettings: CloudFormationTelemetrySettings
+): Promise<boolean> {
+    if (response === TelemetryChoice.Allow) {
+        return await cfnTelemetrySettings.update(telemetrySettings.enabled, true)
+    } else if (response === TelemetryChoice.Never) {
+        return await cfnTelemetrySettings.update(telemetrySettings.enabled, false)
+    } else if (response === TelemetryChoice.Later) {
+        return await cfnTelemetrySettings.update(telemetrySettings.enabled, false)
     }
+    return false
+}
 
+function logAndReturnTelemetryChoice(choice: boolean, hasResponded?: boolean, lastPromptDate?: number): boolean {
+    getLogger().info(
+        'CloudFormation telemetry: choice=%s, hasResponded=%s, lastPromptDate=%s',
+        choice,
+        hasResponded,
+        lastPromptDate
+    )
+    return choice
+}
+
+/* eslint-disable aws-toolkits/no-banned-usages */
+async function promptTelemetryOptIn(
+    context: ExtensionContext,
+    cfnTelemetrySettings: CloudFormationTelemetrySettings
+): Promise<boolean> {
     const message =
         'Help us improve the AWS CloudFormation Language Server by sharing anonymous telemetry data with AWS. You can change this preference at any time in aws.cloudformation Settings.'
 
-    const allow = 'Yes, Allow'
-    const later = 'Not Now'
-    const never = 'Never'
-    const learnMore = 'Learn More'
-    const response = await window.showInformationMessage(message, allow, later, never, learnMore)
+    const response = await window.showInformationMessage(
+        message,
+        TelemetryChoice.Allow,
+        TelemetryChoice.Later,
+        TelemetryChoice.Never,
+        TelemetryChoice.LearnMore
+    )
 
-    if (response === learnMore) {
-        await env.openExternal(
-            Uri.parse('https://github.com/aws-cloudformation/cloudformation-languageserver/tree/main/src/telemetry')
-        )
+    if (response === TelemetryChoice.LearnMore) {
+        await env.openExternal(Uri.parse(telemetryDocsUrl))
         return promptTelemetryOptIn(context, cfnTelemetrySettings)
     }
 
-    if (response === allow) {
-        await cfnTelemetrySettings.update('enabled', true)
-        await context.globalState.update(commandKey('telemetry.hasResponded'), true)
-    } else if (response === never) {
-        await cfnTelemetrySettings.update('enabled', false)
-        await context.globalState.update(commandKey('telemetry.hasResponded'), true)
-    } else if (response === later) {
-        await cfnTelemetrySettings.update('enabled', false)
-        await context.globalState.update(commandKey('telemetry.lastPromptDate'), now)
+    const now = globals.clock.Date.now()
+    await context.globalState.update(telemetryKeys.lastPromptDate, now)
+
+    // There's a chance our settings aren't registered yet from package.json, so we
+    // see if we can persist to settings first
+    try {
+        // Throws (with no popup) if setting is not registered
+        cfnTelemetrySettings.get(telemetrySettings.enabled)
+    } catch (err) {
+        getLogger().warn(err as Error)
+        // Save the choice in globalState and save to settings next time handleTelemetryOptIn is called
+        await context.globalState.update(telemetryKeys.unpersistedResponse, response)
+        if (response === TelemetryChoice.Allow) {
+            await context.globalState.update(telemetryKeys.hasResponded, true)
+            return true
+        } else if (response === TelemetryChoice.Never) {
+            await context.globalState.update(telemetryKeys.hasResponded, true)
+            return false
+        } else if (response === TelemetryChoice.Later) {
+            return false
+        }
     }
 
-    return cfnTelemetrySettings.get('enabled', false)
+    // At this point should be able to save and get successfully
+    await saveTelemetryResponse(response, cfnTelemetrySettings)
+    await context.globalState.update(telemetryKeys.hasResponded, response !== TelemetryChoice.Later)
+    return cfnTelemetrySettings.get(telemetrySettings.enabled, false)
 }