Merge branch 'main' of https://github.com/microsoft/vscode-azurefunctions into mwf/durable-feedback

Author: MicroFish91

.github/copilot-instructions.md

@@ -0,0 +1,3 @@
+# Coding Instructions for GitHub Copilot
+
+- Do not commit or suggest changes to `main.js` when those changes are automatically generated as part of the webpack build process.

.gitignore

@@ -73,6 +73,3 @@ resources/backupTemplates/dotnet/**/cache/
 
 # macOS related extra files
 .DS_Store
-
-# Copilot instructions (internal development documentation)
-.github/copilot-instructions.md

package-lock.json

@@ -3,16 +3,19 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzExtFsExtra, AzureWizardExecuteStepWithActivityOutput } from '@microsoft/vscode-azext-utils';
+import { AzExtFsExtra, AzureWizardExecuteStepWithActivityOutput, parseError, type IParsedError } from '@microsoft/vscode-azext-utils';
 import * as path from "path";
 import { type Progress } from 'vscode';
 import { ConnectionKey, DurableBackend, hostFileName, ProjectLanguage } from '../../../constants';
 import { viewOutput } from '../../../constants-nls';
 import { ext } from '../../../extensionVariables';
-import { type IHostJsonV2 } from '../../../funcConfig/host';
+import { type IDTSTaskJson, type IHostJsonV2, type INetheriteTaskJson, type ISqlTaskJson, type IStorageTaskJson } from '../../../funcConfig/host';
 import { MismatchBehavior, setLocalAppSetting } from '../../../funcConfig/local.settings';
 import { localize } from '../../../localize';
+import { cpUtils } from '../../../utils/cpUtils';
 import { durableUtils } from '../../../utils/durableUtils';
+import { pythonUtils } from '../../../utils/pythonUtils';
+import { venvUtils } from '../../../utils/venvUtils';
 import { type IFunctionWizardContext } from '../IFunctionWizardContext';
 
 export class DurableProjectConfigureStep<T extends IFunctionWizardContext> extends AzureWizardExecuteStepWithActivityOutput<T> {
@@ -25,22 +28,22 @@ export class DurableProjectConfigureStep<T extends IFunctionWizardContext> exten
     protected getOutputLogFail(_context: T): string {
         return localize('failedToConfigureDurableProject', 'Failed to configure durable project settings.');
     }
-    protected getOutputLogProgress(_context: T): string {
-        return localize('configuringDurableProject', 'Configuring durable project settings...');
-    }
     protected preDeployTask: string = 'funcHostStart';
     public stepName: string = 'DurableProjectConfigureStep';
     public priority: number = 225;
 
-    public async execute(context: T, _progress: Progress<{ message?: string; increment?: number }>): Promise<void> {
+    public async execute(context: T, progress: Progress<{ message?: string; increment?: number }>): Promise<void> {
+        progress.report({ message: localize('configuringDurableProject', 'Configuring durable project settings...') });
         await this.configureHostAndLocalSettingsJson(context);
-        await durableUtils.tryInstallDurableDependencies(context);
+        await this.tryInstallDurableDependencies(context);
     }
 
     public shouldExecute(context: T): boolean {
         return !!context.newDurableStorageType;
     }
 
+    // #region Durable Task Local Settings
+
     private async configureHostAndLocalSettingsJson(context: T): Promise<void> {
         const hostJsonPath: string = path.join(context.projectPath, hostFileName);
 
@@ -65,15 +68,15 @@ export class DurableProjectConfigureStep<T extends IFunctionWizardContext> exten
 
         switch (context.newDurableStorageType) {
             case DurableBackend.Storage:
-                hostJson.extensions.durableTask = durableUtils.getDefaultStorageTaskConfig();
+                hostJson.extensions.durableTask = this.getDefaultStorageTaskConfig();
                 // Omit setting azureWebJobsStorage since it should already be initialized during 'createNewProject'
                 break;
             case DurableBackend.Netherite:
-                hostJson.extensions.durableTask = durableUtils.getDefaultNetheriteTaskConfig();
+                hostJson.extensions.durableTask = this.getDefaultNetheriteTaskConfig();
                 await setLocalAppSetting(context, context.projectPath, ConnectionKey.EventHubs, '', MismatchBehavior.Overwrite);
                 break;
             case DurableBackend.DTS:
-                hostJson.extensions.durableTask = durableUtils.getDefaultDTSTaskConfig();
+                hostJson.extensions.durableTask = this.getDefaultDTSTaskConfig();
                 // Non- .NET projects require a special preview extension bundle to work properly
                 // Todo: Remove once this functionality is out of preview
                 if (context.language !== ProjectLanguage.CSharp && context.language !== ProjectLanguage.FSharp) {
@@ -84,15 +87,147 @@ export class DurableProjectConfigureStep<T extends IFunctionWizardContext> exten
                     ext.outputChannel.appendLog(localize('extensionBundlePreview', 'Updated "host.json" extension bundle to preview version to enable new DTS features.'));
                 }
                 await setLocalAppSetting(context, context.projectPath, ConnectionKey.DTS, '', MismatchBehavior.Overwrite);
-                await setLocalAppSetting(context, context.projectPath, ConnectionKey.DTSHub, 'default', MismatchBehavior.Overwrite);
+                await setLocalAppSetting(context, context.projectPath, ConnectionKey.DTSHub, '', MismatchBehavior.Overwrite);
                 break;
             case DurableBackend.SQL:
-                hostJson.extensions.durableTask = durableUtils.getDefaultSqlTaskConfig();
+                hostJson.extensions.durableTask = this.getDefaultSqlTaskConfig();
                 await setLocalAppSetting(context, context.projectPath, ConnectionKey.SQL, '', MismatchBehavior.Overwrite);
                 break;
             default:
         }
 
         await AzExtFsExtra.writeJSON(hostJsonPath, hostJson);
     }
+
+    private getDefaultStorageTaskConfig(): IStorageTaskJson {
+        return {
+            storageProvider: {
+                type: DurableBackend.Storage,
+            }
+        };
+    }
+
+    private getDefaultNetheriteTaskConfig(): INetheriteTaskJson {
+        return {
+            hubName: '',
+            useGracefulShutdown: true,
+            storageProvider: {
+                type: DurableBackend.Netherite,
+                StorageConnectionName: ConnectionKey.Storage,
+                EventHubsConnectionName: ConnectionKey.EventHubs,
+            }
+        };
+    }
+
+    private getDefaultDTSTaskConfig(): IDTSTaskJson {
+        return {
+            hubName: '%TASKHUB_NAME%',
+            storageProvider: {
+                type: DurableBackend.DTS,
+                connectionStringName: ConnectionKey.DTS,
+            }
+        };
+    }
+
+    private getDefaultSqlTaskConfig(): ISqlTaskJson {
+        return {
+            storageProvider: {
+                type: DurableBackend.SQL,
+                connectionStringName: ConnectionKey.SQL,
+                taskEventLockTimeout: "00:02:00",
+                createDatabaseIfNotExists: true,
+            }
+        };
+    }
+
+    // #endregion Durable Task Local Settings
+
+    // #region Install Durable Dependencies
+
+    private async tryInstallDurableDependencies(context: IFunctionWizardContext): Promise<void> {
+        switch (context.language) {
+            case ProjectLanguage.Java:
+                // Todo: Revisit when adding Java implementation
+                break;
+            case ProjectLanguage.CSharp:
+            case ProjectLanguage.FSharp:
+                await this.installDotnetDependencies(context);
+                break;
+            case ProjectLanguage.JavaScript:
+            case ProjectLanguage.TypeScript:
+                await this.installNodeDependencies(context);
+                break;
+            case ProjectLanguage.Python:
+                await pythonUtils.addDependencyToRequirements(durableUtils.pythonDfPackage, context.projectPath);
+                await venvUtils.runPipInstallCommandIfPossible(context.projectPath);
+                break;
+            case ProjectLanguage.PowerShell:
+                // Todo: Revisit when adding PowerShell implementation
+                break;
+            default:
+        }
+    }
+
+    private async installDotnetDependencies(context: IFunctionWizardContext): Promise<void> {
+        const packages: { name: string; prerelease?: boolean }[] = [];
+        const isDotnetIsolated: boolean = /Isolated/i.test(context.functionTemplate?.id ?? '');
+
+        switch (context.newDurableStorageType) {
+            case DurableBackend.Netherite:
+                isDotnetIsolated ?
+                    packages.push({ name: durableUtils.dotnetIsolatedDfNetheritePackage }) :
+                    packages.push({ name: durableUtils.dotnetInProcDfNetheritePackage });
+                break;
+            case DurableBackend.DTS:
+                // Todo: Remove prerelease flag once this functionality is out of preview
+                isDotnetIsolated ?
+                    packages.push({ name: durableUtils.dotnetIsolatedDTSPackage, prerelease: true }) :
+                    packages.push({ name: durableUtils.dotnetInProcDTSPackage, prerelease: true });
+                break;
+            case DurableBackend.SQL:
+                isDotnetIsolated ?
+                    packages.push({ name: durableUtils.dotnetIsolatedDfSqlPackage }) :
+                    packages.push({ name: durableUtils.dotnetInProcDfSqlPackage });
+                break;
+            case DurableBackend.Storage:
+            default:
+        }
+
+        // Although the templates should incorporate this package already, it is often included with an out-dated version
+        // which can lead to errors on first run.  To improve this experience for our users, ensure that the latest version is used.
+        if (!isDotnetIsolated) {
+            packages.push({ name: durableUtils.dotnetInProcDfBasePackage });
+        }
+
+        const failedPackages: string[] = [];
+        for (const p of packages) {
+            try {
+                const packageArgs: string[] = [p.name];
+                if (p.prerelease) {
+                    packageArgs.push('--prerelease');
+                }
+                await cpUtils.executeCommand(ext.outputChannel, context.projectPath, 'dotnet', 'add', 'package', ...packageArgs);
+            } catch {
+                failedPackages.push(p.name);
+            }
+        }
+
+        if (failedPackages.length) {
+            ext.outputChannel.appendLog(localize('durableDependencyInstallFailed', 'WARNING: Failed to install and update Durable Functions NuGet packages to the root .csproj project file. You may need to install the following packages manually: "{0}".', failedPackages.join('", "')));
+        }
+    }
+
+    private async installNodeDependencies(context: IFunctionWizardContext): Promise<void> {
+        try {
+            const packageVersion = context.languageModel === 4 ? '3' : '2';
+            await cpUtils.executeCommand(ext.outputChannel, context.projectPath, 'npm', 'install', `${durableUtils.nodeDfPackage}@${packageVersion}`);
+        } catch (error) {
+            const pError: IParsedError = parseError(error);
+            const dfDepInstallFailed: string = localize('failedToAddDurableNodeDependency', 'Failed to add or install the "{0}" dependency. Please inspect and verify if it needs to be added manually.', durableUtils.nodeDfPackage);
+            ext.outputChannel.appendLog(pError.message);
+            ext.outputChannel.appendLog(dfDepInstallFailed);
+        }
+    }
+
+    // #endregion Install Durable Dependencies
 }

src/commands/createFunction/durableSteps/DurableProjectConfigureStep.ts

@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { type InnerDeployContext } from "@microsoft/vscode-azext-azureappservice";
+import { ActivityChildItem, ActivityChildType, activityFailContext, activityFailIcon, activityProgressContext, activityProgressIcon, activitySuccessContext, activitySuccessIcon, AzureWizardExecuteStep, createContextValue, randomUtils, type ExecuteActivityOutput } from "@microsoft/vscode-azext-utils";
+import { l10n, ThemeIcon, TreeItemCollapsibleState, type Progress } from "vscode";
+import { ext } from "../../extensionVariables";
+import { cpUtils } from "../../utils/cpUtils";
+
+export class DeployFunctionCoreToolsStep extends AzureWizardExecuteStep<InnerDeployContext> {
+    stepName: string;
+    private _childId: string = randomUtils.getRandomHexString(8); // create child id in class to make it idempotent
+    private _command: { title: string; command: string } = {
+        title: '',
+        command: ext.prefix + '.showOutputChannel'
+    };
+    public createSuccessOutput(context: InnerDeployContext): ExecuteActivityOutput {
+        const label = l10n.t('Publish "{0}" to "{1}" with Function Core Tools', context.originalDeployFsPath, context.site.fullName);
+        return {
+            item: new ActivityChildItem({
+                contextValue: createContextValue([activitySuccessContext, context.site.id]),
+                label,
+                iconPath: activitySuccessIcon,
+                activityType: ActivityChildType.Success,
+
+            })
+        };
+    }
+    public createProgressOutput(context: InnerDeployContext): ExecuteActivityOutput {
+        const label = l10n.t('Publish "{0}" to "{1}" with Function Core Tools', context.originalDeployFsPath, context.site.fullName);
+        const item = new ActivityChildItem({
+            contextValue: createContextValue([activityProgressContext, context.site.id]),
+            label,
+            iconPath: activityProgressIcon,
+            activityType: ActivityChildType.Progress,
+            isParent: true,
+            initialCollapsibleState: TreeItemCollapsibleState.Expanded
+        });
+
+        item.getChildren = () => {
+            return [
+                new ActivityChildItem({
+                    label: l10n.t('Click to view output channel'),
+                    id: this._childId,
+                    command: this._command,
+                    activityType: ActivityChildType.Info,
+                    contextValue: createContextValue([activityProgressContext, 'viewOutputChannel']),
+                    iconPath: new ThemeIcon('output')
+                })
+            ];
+        };
+
+        return {
+            item
+        };
+    }
+    public createFailOutput(context: InnerDeployContext): ExecuteActivityOutput {
+        const label = l10n.t('Publish "{0}" to "{1}" with Function Core Tools', context.originalDeployFsPath, context.site.fullName);
+        const item = new ActivityChildItem({
+            contextValue: createContextValue([activityFailContext, context.site.id]),
+            label,
+            iconPath: activityFailIcon,
+            activityType: ActivityChildType.Fail,
+            isParent: true,
+            initialCollapsibleState: TreeItemCollapsibleState.Expanded
+        });
+
+        item.getChildren = () => {
+            return [
+                new ActivityChildItem({
+                    label: l10n.t('Click to view output channel'),
+                    id: this._childId,
+                    command: this._command,
+                    activityType: ActivityChildType.Info,
+                    contextValue: createContextValue([activityProgressContext, 'viewOutputChannel']),
+                    iconPath: new ThemeIcon('output')
+                })
+            ];
+        };
+
+        return {
+            item
+        };
+    }
+    public priority: number = 100;
+    public async execute(context: InnerDeployContext, progress: Progress<{ message?: string; increment?: number; }>): Promise<void> {
+        const message = l10n.t('Publishing "{0}" to "{1}" with Functiontion Core Tools...', context.originalDeployFsPath, context.site.fullName);
+        progress.report({ message });
+        context.activityAttributes = context.activityAttributes ?? { logs: [] };
+        const args = ['func', 'azure', 'functionapp', 'publish', context.site.siteName];
+        if (context.site.isSlot) {
+            // if there's no slotName, then just assume production
+            args.push('--slot', context.site.slotName ?? 'production');
+        }
+        const cmdOutput = await cpUtils.tryExecuteCommand(ext.outputChannel, context.originalDeployFsPath, args.join(' '));
+        context.activityAttributes.logs = [{ content: cmdOutput.cmdOutputIncludingStderr }];
+    }
+    public shouldExecute(_context: InnerDeployContext): boolean {
+        return true;
+    }
+}