Activity children and output log support for deployWorkspaceProject

src/commands/createContainerApp/ContainerAppCreateStep.ts

@@ -5,19 +5,21 @@
 
 import { ContainerAppsAPIClient, Ingress, KnownActiveRevisionsMode } from "@azure/arm-appcontainers";
 import { LocationListStep } from "@microsoft/vscode-azext-azureutils";
-import { AzureWizardExecuteStep, nonNullProp, nonNullValueAndProp } from "@microsoft/vscode-azext-utils";
+import { GenericTreeItem, nonNullProp, nonNullValueAndProp } from "@microsoft/vscode-azext-utils";
 import { Progress } from "vscode";
-import { containerAppsWebProvider } from "../../constants";
+import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon, containerAppsWebProvider } from "../../constants";
 import { ContainerAppItem } from "../../tree/ContainerAppItem";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../utils/activity/ExecuteActivityOutputStepBase";
+import { createActivityChildContext } from "../../utils/activity/activityUtils";
 import { createContainerAppsAPIClient } from "../../utils/azureClients";
 import { localize } from "../../utils/localize";
 import { getContainerNameForImage } from "../deployImage/imageSource/containerRegistry/getContainerNameForImage";
 import { ICreateContainerAppContext } from "./ICreateContainerAppContext";
 
-export class ContainerAppCreateStep extends AzureWizardExecuteStep<ICreateContainerAppContext> {
+export class ContainerAppCreateStep extends ExecuteActivityOutputStepBase<ICreateContainerAppContext> {
     public priority: number = 750;
 
-    public async execute(context: ICreateContainerAppContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+    protected async executeCore(context: ICreateContainerAppContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         const appClient: ContainerAppsAPIClient = await createContainerAppsAPIClient(context);
 
         const resourceGroupName: string = context.newResourceGroupName || nonNullValueAndProp(context.resourceGroup, 'name');
@@ -58,9 +60,39 @@ export class ContainerAppCreateStep extends AzureWizardExecuteStep<ICreateContai
                 ]
             }
         }));
+
+        if (!context.activityChildren) {
+            context.activityResult = {
+                id: nonNullValueAndProp(context.containerApp, 'id'),
+                name: containerAppName,
+                type: containerAppsWebProvider
+            };
+        }
+    }
+
+    public shouldExecute(context: ICreateContainerAppContext): boolean {
+        return !context.containerApp;
+    }
+
+    protected initSuccessOutput(context: ICreateContainerAppContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['containerAppCreateStep', activitySuccessContext]),
+                label: localize('createContainerApp', 'Create container app "{0}"', context.newContainerAppName),
+                iconPath: activitySuccessIcon
+            }),
+            output: localize('createContainerAppSuccess', 'Created container app "{0}".', context.newContainerAppName)
+        };
     }
 
-    public shouldExecute(): boolean {
-        return true;
+    protected initFailOutput(context: ICreateContainerAppContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['containerAppCreateStep', activityFailContext]),
+                label: localize('createContainerApp', 'Create container app "{0}"', context.newContainerAppName),
+                iconPath: activityFailIcon
+            }),
+            output: localize('createContainerAppFail', 'Failed to create container app "{0}".', context.newContainerAppName)
+        };
     }
 }

src/commands/createContainerApp/createContainerApp.ts

@@ -9,7 +9,7 @@ import { webProvider } from "../../constants";
 import { ext } from "../../extensionVariables";
 import { ContainerAppItem } from "../../tree/ContainerAppItem";
 import type { ManagedEnvironmentItem } from "../../tree/ManagedEnvironmentItem";
-import { createActivityContext } from "../../utils/activityUtils";
+import { createActivityContext } from "../../utils/activity/activityUtils";
 import { localize } from "../../utils/localize";
 import { pickEnvironment } from "../../utils/pickItem/pickEnvironment";
 import { ImageSourceListStep } from "../deployImage/imageSource/ImageSourceListStep";

src/commands/createManagedEnvironment/LogAnalyticsCreateStep.ts

@@ -4,32 +4,54 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { LocationListStep } from "@microsoft/vscode-azext-azureutils";
-import { AzureWizardExecuteStep } from "@microsoft/vscode-azext-utils";
+import { GenericTreeItem } from "@microsoft/vscode-azext-utils";
 import { Progress } from "vscode";
-import { ext } from "../../extensionVariables";
+import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon } from "../../constants";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../utils/activity/ExecuteActivityOutputStepBase";
+import { createActivityChildContext } from "../../utils/activity/activityUtils";
 import { createOperationalInsightsManagementClient } from "../../utils/azureClients";
 import { localize } from "../../utils/localize";
-import { nonNullProp, nonNullValue } from "../../utils/nonNull";
+import { nonNullProp } from "../../utils/nonNull";
 import { IManagedEnvironmentContext } from "./IManagedEnvironmentContext";
 
-export class LogAnalyticsCreateStep extends AzureWizardExecuteStep<IManagedEnvironmentContext> {
+export class LogAnalyticsCreateStep extends ExecuteActivityOutputStepBase<IManagedEnvironmentContext> {
     public priority: number = 220;
 
-    public async execute(context: IManagedEnvironmentContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+    protected async executeCore(context: IManagedEnvironmentContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         const opClient = await createOperationalInsightsManagementClient(context);
-        const rg = nonNullValue(context.resourceGroup);
-        const creatingLaw: string = localize('creatingLogAnalyticsWorkspace', 'Creating new Log Analytics workspace...');
-        progress.report({ message: creatingLaw });
-        ext.outputChannel.appendLog(creatingLaw);
-        context.logAnalyticsWorkspace = await opClient.workspaces.beginCreateOrUpdateAndWait(
-            nonNullProp(rg, 'name'), nonNullProp(context, 'newManagedEnvironmentName'), { location: (await LocationListStep.getLocation(context)).name });
+        const resourceGroup = nonNullProp(context, 'resourceGroup');
+        const workspaceName = nonNullProp(context, 'newManagedEnvironmentName');
+
+        const creating: string = localize('creatingLogAnalyticsWorkspace', 'Creating log analytics workspace...');
+        progress.report({ message: creating });
 
-        const createdLaw: string = localize('createdLogAnalyticWorkspace', 'Successfully created new log analytic workspace.');
-        ext.outputChannel.appendLog(createdLaw);
-        void progress.report({ message: createdLaw });
+        context.logAnalyticsWorkspace = await opClient.workspaces.beginCreateOrUpdateAndWait(
+            nonNullProp(resourceGroup, 'name'), workspaceName, { location: (await LocationListStep.getLocation(context)).name });
     }
 
     public shouldExecute(context: IManagedEnvironmentContext): boolean {
         return !context.logAnalyticsWorkspace;
     }
+
+    protected initSuccessOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['logAnalyticsCreateStep', activitySuccessContext]),
+                label: localize('createWorkspace', 'Create log analytics workspace "{0}"', context.newManagedEnvironmentName),
+                iconPath: activitySuccessIcon
+            }),
+            output: localize('createLogAnalyticsWorkspaceSuccess', 'Created log analytics workspace "{0}".', context.newManagedEnvironmentName)
+        };
+    }
+
+    protected initFailOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['logAnalyticsCreateStep', activityFailContext]),
+                label: localize('createWorkspace', 'Create log analytics workspace "{0}"', context.newManagedEnvironmentName),
+                iconPath: activityFailIcon
+            }),
+            output: localize('createLogAnalyticsWorkspaceFail', 'Failed to create log analytics workspace "{0}".', context.newManagedEnvironmentName)
+        };
+    }
 }

src/commands/createManagedEnvironment/ManagedEnvironmentCreateStep.ts

@@ -5,56 +5,79 @@
 
 import { ContainerAppsAPIClient } from "@azure/arm-appcontainers";
 import { getResourceGroupFromId, LocationListStep } from "@microsoft/vscode-azext-azureutils";
-import { AzureWizardExecuteStep } from "@microsoft/vscode-azext-utils";
+import { GenericTreeItem } from "@microsoft/vscode-azext-utils";
 import { Progress } from "vscode";
-import { managedEnvironmentsAppProvider } from "../../constants";
-import { ext } from "../../extensionVariables";
+import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon, managedEnvironmentsAppProvider } from "../../constants";
+import { createActivityChildContext } from "../../utils/activity/activityUtils";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../utils/activity/ExecuteActivityOutputStepBase";
 import { createContainerAppsAPIClient, createOperationalInsightsManagementClient } from '../../utils/azureClients';
 import { localize } from "../../utils/localize";
 import { nonNullProp, nonNullValueAndProp } from "../../utils/nonNull";
 import { IManagedEnvironmentContext } from "./IManagedEnvironmentContext";
 
-export class ManagedEnvironmentCreateStep extends AzureWizardExecuteStep<IManagedEnvironmentContext> {
+export class ManagedEnvironmentCreateStep extends ExecuteActivityOutputStepBase<IManagedEnvironmentContext> {
     public priority: number = 250;
 
-    public async execute(context: IManagedEnvironmentContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+    protected async executeCore(context: IManagedEnvironmentContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         const client: ContainerAppsAPIClient = await createContainerAppsAPIClient(context);
         const opClient = await createOperationalInsightsManagementClient(context);
-        const rgName = nonNullValueAndProp(context.resourceGroup, 'name');
+
+        const resourceGroupName = nonNullValueAndProp(context.resourceGroup, 'name');
+        const managedEnvironmentName = nonNullProp(context, 'newManagedEnvironmentName');
         const logAnalyticsWorkspace = nonNullProp(context, 'logAnalyticsWorkspace');
 
-        const creatingKuEnv: string = localize('creatingManagedEnvironment', 'Creating new Container Apps environment "{0}"...', context.newManagedEnvironmentName);
-        progress.report({ message: creatingKuEnv });
-        ext.outputChannel.appendLog(creatingKuEnv);
+        const creating: string = localize('creatingManagedEnvironment', 'Creating environment...');
+        progress.report({ message: creating });
 
         const sharedKeys = await opClient.sharedKeysOperations.getSharedKeys(
             getResourceGroupFromId(nonNullProp(logAnalyticsWorkspace, 'id')),
             nonNullProp(logAnalyticsWorkspace, 'name'));
 
-        context.managedEnvironment = await client.managedEnvironments.beginCreateOrUpdateAndWait(rgName, nonNullProp(context, 'newManagedEnvironmentName'),
+        context.managedEnvironment = await client.managedEnvironments.beginCreateOrUpdateAndWait(resourceGroupName, managedEnvironmentName,
             {
                 location: (await LocationListStep.getLocation(context)).name,
                 appLogsConfiguration: {
                     "destination": "log-analytics",
                     "logAnalyticsConfiguration": {
-                        "customerId": nonNullProp(context, 'logAnalyticsWorkspace').customerId,
+                        "customerId": logAnalyticsWorkspace.customerId,
                         "sharedKey": sharedKeys.primarySharedKey
                     }
                 }
             }
         );
 
-        context.activityResult = {
-            id: nonNullProp(context.managedEnvironment, 'id'),
-            name: nonNullProp(context, 'newManagedEnvironmentName'),
-            type: managedEnvironmentsAppProvider
+        if (!context.activityChildren) {
+            context.activityResult = {
+                id: nonNullProp(context.managedEnvironment, 'id'),
+                name: managedEnvironmentName,
+                type: managedEnvironmentsAppProvider
+            };
         }
-
-        const createdKuEnv: string = localize('createKuEnv', 'Successfully created new Container Apps environment "{0}".', context.newManagedEnvironmentName);
-        ext.outputChannel.appendLog(createdKuEnv);
     }
 
     public shouldExecute(context: IManagedEnvironmentContext): boolean {
         return !context.managedEnvironment;
     }
+
+    protected initSuccessOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['managedEnvironmentCreateStep', activitySuccessContext]),
+                label: localize('createManagedEnvironment', 'Create container apps environment "{0}"', context.newManagedEnvironmentName),
+                iconPath: activitySuccessIcon
+            }),
+            output: localize('createdManagedEnvironmentSuccess', 'Created container apps environment "{0}".', context.newManagedEnvironmentName)
+        };
+    }
+
+    protected initFailOutput(context: IManagedEnvironmentContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['managedEnvironmentCreateStep', activityFailContext]),
+                label: localize('createManagedEnvironment', 'Create container apps environment "{0}"', context.newManagedEnvironmentName),
+                iconPath: activityFailIcon
+            }),
+            output: localize('createdManagedEnvironmentFail', 'Failed to create container apps environment "{0}".', context.newManagedEnvironmentName)
+        };
+    }
 }

src/commands/createManagedEnvironment/createManagedEnvironment.ts

@@ -8,7 +8,7 @@ import { AzureWizard, AzureWizardExecuteStep, AzureWizardPromptStep, IActionCont
 import { AzureSubscription } from "@microsoft/vscode-azureresources-api";
 import { appProvider, managedEnvironmentsId, operationalInsightsProvider } from "../../constants";
 import { ext } from "../../extensionVariables";
-import { createActivityContext } from "../../utils/activityUtils";
+import { createActivityContext } from "../../utils/activity/activityUtils";
 import { localize } from "../../utils/localize";
 import { IManagedEnvironmentContext } from "./IManagedEnvironmentContext";
 import { LogAnalyticsCreateStep } from "./LogAnalyticsCreateStep";

src/commands/deleteManagedEnvironment/deleteManagedEnvironment.ts

@@ -8,7 +8,7 @@ import { AzureWizard, createSubscriptionContext, IActionContext } from "@microso
 import { ext } from "../../extensionVariables";
 import { ContainerAppItem } from "../../tree/ContainerAppItem";
 import type { ManagedEnvironmentItem } from "../../tree/ManagedEnvironmentItem";
-import { createActivityContext } from "../../utils/activityUtils";
+import { createActivityContext } from "../../utils/activity/activityUtils";
 import { localize } from "../../utils/localize";
 import { pickEnvironment } from "../../utils/pickItem/pickEnvironment";
 import { DeleteAllContainerAppsStep } from "../deleteContainerApp/DeleteAllContainerAppsStep";

src/commands/deployImage/ContainerAppUpdateStep.ts

@@ -3,19 +3,22 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { AzureWizardExecuteStep, nonNullProp } from "@microsoft/vscode-azext-utils";
-import type { Progress } from "vscode";
+import { GenericTreeItem, nonNullProp } from "@microsoft/vscode-azext-utils";
+import { type Progress } from "vscode";
+import { activityFailContext, activityFailIcon, activitySuccessContext, activitySuccessIcon } from "../../constants";
 import { ext } from "../../extensionVariables";
 import { ContainerAppModel, getContainerEnvelopeWithSecrets } from "../../tree/ContainerAppItem";
+import { ExecuteActivityOutput, ExecuteActivityOutputStepBase } from "../../utils/activity/ExecuteActivityOutputStepBase";
+import { createActivityChildContext } from "../../utils/activity/activityUtils";
 import { localize } from "../../utils/localize";
 import { updateContainerApp } from "../../utils/updateContainerApp";
 import type { IDeployImageContext } from "./deployImage";
 import { getContainerNameForImage } from "./imageSource/containerRegistry/getContainerNameForImage";
 
-export class ContainerAppUpdateStep extends AzureWizardExecuteStep<IDeployImageContext> {
+export class ContainerAppUpdateStep extends ExecuteActivityOutputStepBase<IDeployImageContext> {
     public priority: number = 480;
 
-    public async execute(context: IDeployImageContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
+    protected async executeCore(context: IDeployImageContext, progress: Progress<{ message?: string | undefined; increment?: number | undefined }>): Promise<void> {
         const containerApp: ContainerAppModel = nonNullProp(context, 'containerApp');
         const containerAppEnvelope = await getContainerEnvelopeWithSecrets(context, context.subscription, containerApp);
 
@@ -44,4 +47,26 @@ export class ContainerAppUpdateStep extends AzureWizardExecuteStep<IDeployImageC
     public shouldExecute(context: IDeployImageContext): boolean {
         return !!context.containerApp;
     }
+
+    protected initSuccessOutput(context: IDeployImageContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['containerAppUpdateStep', activitySuccessContext]),
+                label: localize('updateContainerAppLabel', 'Update container app "{0}"', context.containerApp?.name),
+                iconPath: activitySuccessIcon
+            }),
+            output: localize('updateContainerAppSuccess', 'Updated container app "{0}".', context.containerApp?.name)
+        };
+    }
+
+    protected initFailOutput(context: IDeployImageContext): ExecuteActivityOutput {
+        return {
+            item: new GenericTreeItem(undefined, {
+                contextValue: createActivityChildContext(['containerAppUpdateStep', activityFailContext]),
+                label: localize('updateContainerAppLabel', 'Update container app "{0}"', context.containerApp?.name),
+                iconPath: activityFailIcon
+            }),
+            output: localize('updateContainerAppFail', 'Failed to update container app "{0}".', context.containerApp?.name)
+        };
+    }
 }