Merged PR 474022: Use runtime extension for runtime aquisition

Use runtime extension for runtime aquisition

fix https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1814738

debugging screenshot below shows the server is using the local runtime acquired from the extension

![image.png](https://devdiv.visualstudio.com/0bdbc590-a062-4c3f-b0f6-9383f67865ee/_apis/git/repositories/ed74911c-9619-4c14-bd9d-20ecfd2250be/pullRequests/474022/attachments/image.png)

Author: genlu

package.json

@@ -64,7 +64,10 @@
     "test:artifacts": "tsc -p ./ && mocha out/test/artifactTests/**/*.test.js",
     "unpackage:vsix": "gulp vsix:release:unpackage",
     "updatePackageDependencies": "gulp updatePackageDependencies"
-  },
+  },  
+	"extensionDependencies": [
+		"ms-dotnettools.vscode-dotnet-runtime"
+	],
   "dependencies": {
     "@microsoft/servicehub-framework": "4.2.99-beta",
     "@types/cross-spawn": "6.0.2",

src/lsptoolshost/dotnetRuntime.ts

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { CSharpExtensionId } from '../constants/CSharpExtensionId';
+
+export const DotNetRuntimeVersion = '7.0';
+
+interface IDotnetAcquireResult {
+    dotnetPath: string;
+}
+
+let runtimePath: string | undefined;
+
+/**
+ * Acquires the .NET runtime if it is not already present.
+ * @returns The path to the .NET runtime
+ */
+export async function acquireRuntime() {
+    if (runtimePath) {
+        return runtimePath;
+    }
+
+    let status = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet.acquireStatus', {
+        version: DotNetRuntimeVersion,
+        requestingExtensionId: CSharpExtensionId,
+    });
+    if (status === undefined) {
+        await vscode.commands.executeCommand('dotnet.showAcquisitionLog');
+
+        status = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet.acquire', {
+            version: DotNetRuntimeVersion,
+            requestingExtensionId: CSharpExtensionId,
+        });
+        if (!status?.dotnetPath) {
+            throw new Error('Could not resolve the dotnet path!');
+        }
+    }
+
+    return (runtimePath = status.dotnetPath);
+}
+
+/**
+ * Acquires the .NET runtime and any other dependencies required to spawn a particular .NET executable.
+ * @param path The path to the entrypoint assembly. Typically a .dll.
+ * @returns The path to the `dotnet` command to use to spawn the process.
+ */
+export async function acquireDotNetProcessDependencies(path: string) {
+    const dotnetPath = await acquireRuntime();
+
+    const args = [path];
+    // This will install any missing Linux dependencies.
+    await vscode.commands.executeCommand('dotnet.ensureDotnetDependencies', { command: dotnetPath, arguments: args });
+
+    return dotnetPath;
+}

src/lsptoolshost/roslynLanguageServer.ts

@@ -35,7 +35,7 @@ import {
     CodeActionResolveRequest,
 } from 'vscode-languageclient/node';
 import { PlatformInformation } from '../shared/platform';
-import { DotnetResolver } from '../shared/DotnetResolver';
+import { acquireDotNetProcessDependencies } from './dotnetRuntime';
 import { readConfigurations } from './configurationMiddleware';
 import OptionProvider from '../shared/observers/OptionProvider';
 import { DynamicFileInfoHandler } from '../razor/src/DynamicFile/DynamicFileInfoHandler';
@@ -147,12 +147,7 @@ export class RoslynLanguageServer {
      * Resolves server options and starts the dotnet language server process.
      */
     public async start(): Promise<void> {
-        const dotnetResolver = new DotnetResolver(this.platformInfo);
-
         let options = this.optionProvider.GetLatestOptions();
-        let resolvedDotnet = await dotnetResolver.getHostExecutableInfo(options);
-        _channel.appendLine("Dotnet version: " + resolvedDotnet.version);
-
         let logLevel = options.languageServerOptions.logLevel;
         const languageClientTraceLevel = this.GetTraceLevel(logLevel);
 
@@ -343,10 +338,9 @@ export class RoslynLanguageServer {
         return capabilities;
     }
 
-    private async startServer(logLevel: string | undefined): Promise<cp.ChildProcess> {
+    private getServerPath(options: Options) {
         let clientRoot = __dirname;
 
-        let options = this.optionProvider.GetLatestOptions();
         let serverPath = options.commonOptions.serverPath;
         if (!serverPath) {
             // Option not set, use the path from the extension.
@@ -357,6 +351,37 @@ export class RoslynLanguageServer {
             throw new Error(`Cannot find language server in path '${serverPath}'`);
         }
 
+        return serverPath;
+    }
+
+    private async startServer(logLevel: string | undefined): Promise<cp.ChildProcess> {
+
+        let options = this.optionProvider.GetLatestOptions();
+        let serverPath = this.getServerPath(options);
+
+        let dotnetRuntimePath = options.commonOptions.dotnetPath; 
+        if (!dotnetRuntimePath)
+        {
+            let dotnetPath = await acquireDotNetProcessDependencies(serverPath); 
+            dotnetRuntimePath = path.dirname(dotnetPath);   
+        }
+        
+        const dotnetExecutableName = this.platformInfo.isWindows() ? 'dotnet.exe' : 'dotnet';
+        const dotnetExecutablePath = path.join(dotnetRuntimePath, dotnetExecutableName);
+        if (!fs.existsSync(dotnetExecutablePath)) {
+            throw new Error(`Cannot find dotnet path '${dotnetExecutablePath}'`);
+        }
+
+        _channel.appendLine("Dotnet path: " + dotnetExecutablePath);
+        
+        // Take care to always run .NET processes on the runtime that we intend.
+        // The dotnet.exe we point to should not go looking for other runtimes.
+        const env: NodeJS.ProcessEnv =  { ...process.env };
+        env.DOTNET_ROOT = dotnetRuntimePath;
+        env.DOTNET_MULTILEVEL_LOOKUP = '0';
+        // Save user's DOTNET_ROOT env-var value so server can recover the user setting when needed
+        env.DOTNET_ROOT_USER = process.env.DOTNET_ROOT ?? 'EMPTY';   
+
         let args: string[] = [ ];
 
         if (options.commonOptions.waitForDebugger) {
@@ -402,7 +427,8 @@ export class RoslynLanguageServer {
         let childProcess: cp.ChildProcessWithoutNullStreams;
         let cpOptions: cp.SpawnOptionsWithoutStdio = {
             detached: true,
-            windowsHide: true
+            windowsHide: true,
+            env: env
         };
 
         if (serverPath.endsWith('.dll')) {

test/runIntegrationTests.ts

@@ -3,8 +3,13 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import * as cp from "child_process";
 import * as path from 'path';
-import { runTests } from '@vscode/test-electron';
+import { 
+    downloadAndUnzipVSCode,
+    resolveCliArgsFromVSCodeExecutablePath,
+    runTests
+} from '@vscode/test-electron';
 import { execChildProcess } from '../src/common';
 
 function getSln(workspacePath: string): string | undefined {
@@ -16,6 +21,15 @@ function getSln(workspacePath: string): string | undefined {
 
 async function main() {
     try {
+        const vscodeExecutablePath = await downloadAndUnzipVSCode("stable");
+        const [cli, ...args] = resolveCliArgsFromVSCodeExecutablePath(vscodeExecutablePath);
+        
+        cp.spawnSync(
+            cli,
+            [...args, "--install-extension", "ms-dotnettools.vscode-dotnet-runtime"],
+            { encoding: "utf-8", stdio: "inherit" },
+        );
+
         // The folder containing the Extension Manifest package.json
         // Passed to `--extensionDevelopmentPath`
         const extensionDevelopmentPath = path.resolve(__dirname, '../../');