Support .NET SDK Container Build

package.json

@@ -636,6 +636,11 @@
             {
                 "type": "docker",
                 "label": "Docker: Debug in Container",
+                "languages": [
+                    "csharp",
+                    "razor",
+                    "aspnetcorerazor"
+                ],
                 "configurationAttributes": {
                     "launch": {
                         "properties": {
@@ -1500,6 +1505,9 @@
                 "required": [
                     "dockerCompose"
                 ]
+            },
+            {
+                "type": "dotnet-container-sdk"
             }
         ],
         "languages": [

resources/netCore/GetProjectProperties.targets

@@ -1,11 +1,16 @@
 <Project>
-    <!-- All the relevant info is in root-level PropertyGroups, so there are no dependent targets to make this work -->
-    <Target Name="GetProjectProperties">
+    <PropertyGroup>
+        <GetProjectPropertiesDependsOn Condition=" '$(SDKContainerSupportEnabled)' == 'true' ">$(GetProjectPropertiesDependsOn);ComputeContainerConfig;</GetProjectPropertiesDependsOn>
+    </PropertyGroup>
+
+    <Target Name="GetProjectProperties" DependsOnTargets="$(GetProjectPropertiesDependsOn)">
         <WriteLinesToFile
             File="$(InfoOutputPath)"
             Lines="$(AssemblyName).dll
 $(TargetFramework)$(TargetFrameworks.Split(';')[0])
-$(OutputPath)$(AssemblyName).dll"
+$(OutputPath)$(AssemblyName).dll
+$(ContainerWorkingDirectory)/$(AssemblyName).dll
+$(SDKContainerSupportEnabled)"
             Overwrite="True" />
     </Target>
 </Project>

src/debugging/DebugHelper.ts

@@ -12,6 +12,7 @@ import { DockerDebugConfiguration, DockerDebugConfigurationProvider } from './Do
 import { DockerPlatform } from './DockerPlatformHelper';
 import { registerServerReadyAction } from './DockerServerReadyAction';
 import { netCoreDebugHelper } from './netcore/NetCoreDebugHelper';
+import { netSdkDebugHelper } from './netSdk/NetSdkDebugHelper';
 import { nodeDebugHelper } from './node/NodeDebugHelper';
 import { pythonDebugHelper } from './python/PythonDebugHelper';
 
@@ -51,6 +52,7 @@ export function registerDebugProvider(ctx: ExtensionContext): void {
                     netCore: netCoreDebugHelper,
                     node: nodeDebugHelper,
                     python: pythonDebugHelper,
+                    netSdk: netSdkDebugHelper
                 }
             )
         )

src/debugging/DockerDebugConfigurationProvider.ts

@@ -3,14 +3,16 @@
  *  Licensed under the MIT License. See LICENSE.md in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { callWithTelemetryAndErrorHandling, IActionContext, registerEvent } from '@microsoft/vscode-azext-utils';
-import { CancellationToken, commands, debug, DebugConfiguration, DebugConfigurationProvider, DebugSession, l10n, MessageItem, ProviderResult, window, workspace, WorkspaceFolder } from 'vscode';
-import { DockerOrchestration } from '../constants';
+import { callWithTelemetryAndErrorHandling, IActionContext, registerEvent, UserCancelledError } from '@microsoft/vscode-azext-utils';
+import { CancellationToken, commands, debug, DebugConfiguration, DebugConfigurationProvider, DebugSession, l10n, ProviderResult, workspace, WorkspaceFolder } from 'vscode';
+import { CSPROJ_GLOB_PATTERN, DockerOrchestration } from '../constants';
 import { ext } from '../extensionVariables';
 import { getAssociatedDockerRunTask } from '../tasks/TaskHelper';
+import { resolveFilesOfPattern } from '../utils/quickPickFile';
 import { DebugHelper, DockerDebugContext, ResolvedDebugConfiguration } from './DebugHelper';
 import { DockerPlatform, getPlatform } from './DockerPlatformHelper';
 import { NetCoreDockerDebugConfiguration } from './netcore/NetCoreDebugHelper';
+import { netSdkDebugHelper } from './netSdk/NetSdkDebugHelper';
 import { NodeDockerDebugConfiguration } from './node/NodeDebugHelper';
 
 export interface DockerDebugConfiguration extends NetCoreDockerDebugConfiguration, NodeDockerDebugConfiguration {
@@ -42,21 +44,14 @@ export class DockerDebugConfigurationProvider implements DebugConfigurationProvi
     }
 
     public provideDebugConfigurations(folder: WorkspaceFolder | undefined, token?: CancellationToken): ProviderResult<DebugConfiguration[]> {
-        const add: MessageItem = { title: l10n.t('Add Docker Files') };
-
-        // Prompt them to add Docker files since they probably haven't
-        /* eslint-disable-next-line @typescript-eslint/no-floating-promises */
-        window.showErrorMessage(
-            l10n.t('To debug in a Docker container on supported platforms, use the command "Docker: Add Docker Files to Workspace", or click "Add Docker Files".'),
-            ...[add])
-            .then((result) => {
-                if (result === add) {
-                    /* eslint-disable-next-line @typescript-eslint/no-floating-promises */
-                    commands.executeCommand('vscode-docker.configure');
-                }
-            });
 
-        return [];
+        return callWithTelemetryAndErrorHandling(
+            'provideDebugConfigurations',
+            async (actionContext: IActionContext) => {
+                return this.handleEmptyDebugConfig(folder, actionContext);
+            }
+        );
+
     }
 
     public resolveDebugConfiguration(folder: WorkspaceFolder | undefined, debugConfiguration: DockerDebugConfiguration, token?: CancellationToken): ProviderResult<DebugConfiguration | undefined> {
@@ -75,10 +70,15 @@ export class DockerDebugConfigurationProvider implements DebugConfigurationProvi
                     }
                 }
 
-                if (debugConfiguration.type === undefined) {
-                    // If type is undefined, they may be doing F5 without creating any real launch.json, which won't work
-                    // VSCode subsequently will call provideDebugConfigurations which will show an error message
-                    return null;
+                if (Object.keys(debugConfiguration).length === 0) {
+
+                    const newlyCreatedDebugConfig = await this.handleEmptyDebugConfig(folder, actionContext);
+                    // if there is no debugConfiguration, we should return undefined to exit the debug session
+                    if (newlyCreatedDebugConfig.length === 0 || !newlyCreatedDebugConfig[0]) {
+                        return undefined;
+                    }
+
+                    debugConfiguration = newlyCreatedDebugConfig[0];
                 }
 
                 if (!debugConfiguration.request) {
@@ -170,4 +170,35 @@ export class DockerDebugConfigurationProvider implements DebugConfigurationProvi
             }
         }
     }
+
+    /**
+     * If the user has an empty debug launch.json, then we will:
+     *  1. check if it's a .NET Core project, if so, we will provide .NET Core debug configurations
+     *  2. otherwise, we will scaffold docker files
+     */
+    private async handleEmptyDebugConfig(folder: WorkspaceFolder, actionContext: IActionContext): Promise<DockerDebugConfiguration[]> {
+
+        // NOTE: We can not determine the language from `DockerDebugContext`, so we need to check the
+        //       type of files inside the folder here to determine the language.
+
+        // check if it's a .NET Core project
+        const csProjUris = await resolveFilesOfPattern(folder, [CSPROJ_GLOB_PATTERN]);
+        if (csProjUris) {
+            return await netSdkDebugHelper.provideDebugConfigurations(
+                {
+                    actionContext,
+                    dockerfile: undefined,
+                    folder: folder
+                },
+                {
+                    appProject: csProjUris[0]?.absoluteFilePath || '',
+                }
+            );
+        } else {
+            // for now, we scaffold docker files
+            await commands.executeCommand('vscode-docker.configure');
+            throw new UserCancelledError();
+        }
+        // TODO: (potentially) in the future, we can add more support for ambient tasks for other types of projects
+    }
 }

src/debugging/DockerPlatformHelper.ts

@@ -3,17 +3,22 @@
  *  Licensed under the MIT License. See LICENSE.md in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-export type DockerPlatform = 'netCore' | 'node' | 'python';
+import { netSdkDebugHelper } from "./netSdk/NetSdkDebugHelper";
+
+export type DockerPlatform = 'netCore' | 'node' | 'python' | 'netSdk';
 
 interface DockerPlatformConfiguration {
     platform?: DockerPlatform;
     netCore?: unknown;
     node?: unknown;
     python?: unknown;
+    preLaunchTask?: string;
 }
 
 export function getPlatform<T extends DockerPlatformConfiguration>(configuration: T): DockerPlatform | undefined {
-    if (configuration.platform === 'netCore' || configuration.netCore !== undefined) {
+    if (netSdkDebugHelper.isDotNetSdkBuild(configuration?.preLaunchTask) && configuration.netCore !== undefined) {
+        return 'netSdk';
+    } else if (configuration.platform === 'netCore' || configuration.netCore !== undefined) {
         return 'netCore';
     } else if (configuration.platform === 'node' || configuration.node !== undefined) {
         return 'node';

src/debugging/netSdk/NetSdkDebugHelper.ts

@@ -0,0 +1,52 @@
+import { commands } from "vscode";
+import { NetChooseBuildTypeContext, netContainerBuild } from "../../scaffolding/wizard/net/NetContainerBuild";
+import { AllNetContainerBuildOptions } from "../../scaffolding/wizard/net/NetSdkChooseBuildStep";
+import { unresolveWorkspaceFolder } from "../../utils/resolveVariables";
+import { DockerDebugScaffoldContext } from "../DebugHelper";
+import { DockerDebugConfiguration } from "../DockerDebugConfigurationProvider";
+import { NetCoreDebugHelper, NetCoreDebugScaffoldingOptions } from "../netcore/NetCoreDebugHelper";
+
+const NetSdkTaskFullSymbol = 'dotnet-container-sdk: debug';
+export class NetSdkDebugHelper extends NetCoreDebugHelper {
+
+    public async provideDebugConfigurations(context: DockerDebugScaffoldContext, options?: NetCoreDebugScaffoldingOptions): Promise<DockerDebugConfiguration[]> {
+
+        const configurations: DockerDebugConfiguration[] = [];
+
+        const netCoreBuildContext: NetChooseBuildTypeContext = {
+            ...context.actionContext,
+            scaffoldType: 'debugging',
+            workspaceFolder: context.folder,
+        };
+
+        await netContainerBuild(netCoreBuildContext);
+
+        if (netCoreBuildContext?.containerBuildOptions === AllNetContainerBuildOptions[1]) {
+            configurations.push({
+                name: 'Docker .NET Container SDK Launch',
+                type: 'docker',
+                request: 'launch',
+                preLaunchTask: NetSdkTaskFullSymbol,
+                netCore: {
+                    appProject: unresolveWorkspaceFolder(options.appProject, context.folder),
+                },
+            });
+        } else {
+            await commands.executeCommand('vscode-docker.configure');
+        }
+
+        return configurations;
+    }
+
+    /**
+     * Checks if the launch task is using the .NET SDK Container build
+     * @param preLaunchTask
+     * @returns true if the launch task is using the .NET SDK Container build
+     *          false otherwise
+     */
+    public isDotNetSdkBuild(preLaunchTask: string): boolean {
+        return preLaunchTask === NetSdkTaskFullSymbol;
+    }
+}
+
+export const netSdkDebugHelper = new NetSdkDebugHelper();

src/debugging/netcore/NetCoreDebugHelper.ts

@@ -9,6 +9,7 @@ import * as path from 'path';
 import { DebugConfiguration, MessageItem, ProgressLocation, l10n, window } from 'vscode';
 import { ext } from '../../extensionVariables';
 import { CommandLineArgs, ContainerOS, VoidCommandResponse, composeArgs, withArg, withQuotedArg } from '../../runtimes/docker';
+import { NetContainerBuildOptionsKey } from '../../scaffolding/wizard/net/NetSdkChooseBuildStep';
 import { NetCoreTaskHelper, NetCoreTaskOptions } from '../../tasks/netcore/NetCoreTaskHelper';
 import { ContainerTreeItem } from '../../tree/containers/ContainerTreeItem';
 import { getNetCoreProjectInfo } from '../../utils/netCoreUtils';
@@ -18,6 +19,7 @@ import { PlatformOS } from '../../utils/platform';
 import { unresolveWorkspaceFolder } from '../../utils/resolveVariables';
 import { DebugHelper, DockerDebugContext, DockerDebugScaffoldContext, ResolvedDebugConfiguration, inferContainerName, resolveDockerServerReadyAction } from '../DebugHelper';
 import { DockerAttachConfiguration, DockerDebugConfiguration } from '../DockerDebugConfigurationProvider';
+import { netSdkDebugHelper } from '../netSdk/NetSdkDebugHelper';
 import { exportCertificateIfNecessary, getHostSecretsFolders, trustCertificateIfNecessary } from './AspNetSslHelper';
 import { VsDbgType, installDebuggersIfNecessary, vsDbgInstallBasePath } from './VsDbgHelper';
 
@@ -68,7 +70,7 @@ export class NetCoreDebugHelper implements DebugHelper {
         debugConfiguration.netCore.appProject = await NetCoreTaskHelper.inferAppProject(context, debugConfiguration.netCore); // This method internally checks the user-defined input first
 
         const { configureSsl, containerName, platformOS } = await this.loadExternalInfo(context, debugConfiguration);
-        const appOutput = await this.inferAppOutput(debugConfiguration.netCore);
+        const appOutput = debugConfiguration.netCore?.appOutput || await this.inferAppOutput(debugConfiguration);
         if (context.cancellationToken && context.cancellationToken.isCancellationRequested) {
             // inferAppOutput is slow, give a chance to cancel
             return undefined;
@@ -90,7 +92,9 @@ export class NetCoreDebugHelper implements DebugHelper {
 
         const additionalProbingPathsArgs = NetCoreDebugHelper.getAdditionalProbingPathsArgs(platformOS);
 
-        const containerAppOutput = NetCoreDebugHelper.getContainerAppOutput(debugConfiguration, appOutput, platformOS);
+        const containerAppOutput = netSdkDebugHelper.isDotNetSdkBuild(debugConfiguration?.preLaunchTask)
+            ? appOutput
+            : NetCoreDebugHelper.getContainerAppOutput(debugConfiguration, appOutput, platformOS);
 
         const dockerServerReadyAction = resolveDockerServerReadyAction(
             debugConfiguration,
@@ -176,12 +180,22 @@ export class NetCoreDebugHelper implements DebugHelper {
         };
     }
 
-    private async inferAppOutput(helperOptions: NetCoreDebugOptions): Promise<string> {
-        const projectInfo = await getNetCoreProjectInfo('GetProjectProperties', helperOptions.appProject);
+    private async inferAppOutput(debugConfiguration: DockerDebugConfiguration): Promise<string> {
+        const projectInfo = await getNetCoreProjectInfo('GetProjectProperties', debugConfiguration.netCore?.appProject);
+
         if (projectInfo.length < 3) {
             throw new Error(l10n.t('Unable to determine assembly output path.'));
         }
 
+        if (netSdkDebugHelper.isDotNetSdkBuild(debugConfiguration.preLaunchTask) && projectInfo.length >= 5) { // if .NET has support for SDK Build
+            if (projectInfo[4] === 'true') { // fifth is whether .NET supports SDK Containers
+                return projectInfo[3]; // fourth is output path
+            } else {
+                await ext.context.workspaceState.update(NetContainerBuildOptionsKey, ''); // clear the workspace state
+                throw new Error(l10n.t('Your current version of .NET SDK does not support SDK Container build. Please update to a later version of .NET SDK to use this feature.'));
+            }
+        }
+
         return projectInfo[2]; // First line is assembly name, second is target framework, third+ are output path(s)
     }
 

src/runtimes/docker/clients/DockerClientBase/DockerClientBase.ts

@@ -106,6 +106,7 @@ import { withContainerPathArg } from './withContainerPathArg';
 import { withDockerAddHostArg } from './withDockerAddHostArg';
 import { withDockerBuildArg } from './withDockerBuildArg';
 import { withDockerEnvArg } from './withDockerEnvArg';
+import { withDockerExposePortsArg } from './withDockerExposePortsArg';
 import { withDockerBooleanFilterArg, withDockerFilterArg } from './withDockerFilterArg';
 import { withDockerIgnoreSizeArg } from './withDockerIgnoreSizeArg';
 import { withDockerJsonFormatArg } from "./withDockerJsonFormatArg";
@@ -683,6 +684,7 @@ export abstract class DockerClientBase extends ConfigurableClient implements ICo
             withDockerEnvArg(options.environmentVariables),
             withNamedArg('--env-file', options.environmentFiles),
             withNamedArg('--entrypoint', options.entrypoint),
+            withDockerExposePortsArg(options.exposePorts),
             withVerbatimArg(options.customOptions),
             withArg(options.imageRef),
             typeof options.command === 'string' ? withVerbatimArg(options.command) : withArg(...(toArray(options.command || []))),

src/runtimes/docker/clients/DockerClientBase/withDockerExposePortsArg.ts

@@ -0,0 +1,10 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { withNamedArg } from "../../utils/commandLineBuilder";
+
+export function withDockerExposePortsArg(ports?: Array<number>) {
+    return withNamedArg('--expose', (ports || []).map(port => port.toString()), { shouldQuote: false });
+}

src/runtimes/docker/contracts/ContainerClient.ts

@@ -744,6 +744,10 @@ export type RunContainerCommandOptions = CommonCommandOptions & {
      * Optional command to use in starting the container
      */
     command?: Array<string> | string;
+    /**
+     * Optional expose ports for the container
+     */
+    exposePorts?: Array<number>;
     /**
      * Additional custom options to pass
      */

src/scaffolding/wizard/net/NetContainerBuild.ts

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE.md in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AzureWizard, AzureWizardPromptStep, UserCancelledError } from '@microsoft/vscode-azext-utils';
+import * as vscode from 'vscode';
+import { ScaffoldingWizardContext } from '../ScaffoldingWizardContext';
+import { NetContainerBuildOptions, NetSdkChooseBuildStep } from './NetSdkChooseBuildStep';
+
+export interface NetChooseBuildTypeContext extends ScaffoldingWizardContext {
+    containerBuildOptions?: NetContainerBuildOptions;
+}
+
+export async function netContainerBuild(wizardContext: Partial<NetChooseBuildTypeContext>, apiInput?: NetChooseBuildTypeContext): Promise<void> {
+    if (!vscode.workspace.isTrusted) {
+        throw new UserCancelledError('enforceTrust');
+    }
+
+    const promptSteps: AzureWizardPromptStep<NetChooseBuildTypeContext>[] = [
+        new NetSdkChooseBuildStep()
+    ];
+
+    const wizard = new AzureWizard<NetChooseBuildTypeContext>(wizardContext as NetChooseBuildTypeContext, {
+        promptSteps: promptSteps,
+        title: vscode.l10n.t('Initialize for Debugging'),
+    });
+
+    await wizard.prompt();
+    await wizard.execute();
+}