Use ELF/COFF/PE/MACHO Header to get Executable Architecture (#2309)

* Use ELF/COFF/PE/MACHO Header to get Executable Architecture

We need to verify a user's install matches the architecture that the code application / extension wants to run under.

We used to do this with dotnet --info which is a fallback.
Now, we can also do this with dotnet --list-runtimes --arch when supported. However, checking if it is supported requires an extra process call which is slower than reading the file header.

Once we hit dotnet 11, we will know that --arch is supported so we can skip this work of reading the file header. For now, this will allow us to gain a perf boost in the cases where this works.

Documented in the code is how this logic works. Additionally, I've added test executables (real .net 9 ones) to show it works. Finally, I added the copyfiles module to copy the test assets into the dist folder, as otherwise they dont get copied.

* Update package lock to include copy file

in a separate commit so easy to revert /etc

* Fix merge conflict

* Fix typo

* Fix lint

* Fix tests

* Fix tests more

* Speed up test by mocking list sdks

* Fix other tests

* Fix comments

Author: nagilson

sample/yarn.lock

@@ -424,12 +424,12 @@ suite('DotnetCoreAcquisitionExtension End to End', function ()
     }).timeout(standardTimeoutTime);
 
 
-    test('Find dotnet PATH Command No Arch Available But Accept By Default', async () =>
+    test('Find dotnet PATH Command No Arch Available But Arch Found From File', async () =>
     {
         // look for a different architecture of 3.1
         if (os.platform() !== 'darwin')
         {
-            await findPathWithRequirementAndInstall('3.1', 'runtime', os.arch() == 'arm64' ? 'x64' : os.arch(), 'greater_than_or_equal', true,
+            await findPathWithRequirementAndInstall('3.1', 'runtime', os.arch() == 'arm64' ? 'x64' : os.arch(), 'greater_than_or_equal', false,
                 { version: '3.1', mode: 'runtime', architecture: 'arm64', requestingExtensionId: requestingExtensionId }
             );
         }
@@ -623,7 +623,7 @@ the fake dotnet path setting is an empty dir -- if it is not empty, test cleanup
 
         // acquire with the alternative extension id which has a path setting set to the fake path
         // If the setting is bad then it should also acquire somewhere else.
-        const context: IDotnetAcquireContext = { version: '5.0', requestingExtensionId: 'alternative.extension', architecture: os.platform() };
+        const context: IDotnetAcquireContext = { version: '5.0', requestingExtensionId: 'alternative.extension', architecture: os.arch() };
 
         const resultForAcquiringPathSettingRuntime = await vscode.commands.executeCommand<IDotnetAcquireResult>('dotnet.acquire', context);
         assert.exists(resultForAcquiringPathSettingRuntime!.dotnetPath, 'Basic acquire works');

vscode-dotnet-runtime-extension/package-lock.json

@@ -16,17 +16,19 @@
 		"vscode:prepublish": "npm run compile && dotnet build ../msbuild/signJs --property jsOutputPath=..\\..\\vscode-dotnet-runtime-library\\dist -bl -v:normal",
 		"compile": "npm run clean && tsc -p ./ && npm run mockPack",
 		"mockPack": "run-script-os",
+		"copyTestAssets": "copyfiles -u 4 \"src/test/mocks/Executables/**/*\" dist/test/mocks/Executables/",
 		"mockPack:darwin:linux": "cd .. && sh ./mock-webpack.sh && cd vscode-dotnet-runtime-library",
 		"mockPack:win32": "pushd .. && @powershell -NoProfile -ExecutionPolicy Unrestricted -Command ./mock-webpack.ps1 && popd",
 		"watch": "npm run clean && tsc -watch -p ./",
-		"test": "npm run compile --silent && npm run unit-test",
+		"test": "npm run compile --silent && npm run copyTestAssets && npm run unit-test",
 		"unit-test": "mocha -u tdd -- dist/test/unit/**.test.js",
 		"clean": "rimraf dist"
 	},
 	"devDependencies": {
 		"@types/chai": "4.2.22",
 		"@types/lodash": "^4.17.13",
 		"@types/proper-lockfile": "^4.1.2",
+		"copyfiles": "^2.4.1",
 		"glob": "^7.2.0"
 	},
 	"dependencies": {

vscode-dotnet-runtime-extension/src/test/functional/DotnetCoreAcquisitionExtension.test.ts

@@ -6,6 +6,7 @@ import { DotnetConditionsValidated, DotnetFindPathDidNotMeetCondition, DotnetUna
 import { IDotnetFindPathContext } from '../IDotnetFindPathContext';
 import { CommandExecutor } from '../Utils/CommandExecutor';
 import { CommandExecutorCommand } from '../Utils/CommandExecutorCommand';
+import { ExecutableArchitectureDetector } from '../Utils/ExecutableArchitectureDetector';
 import { FileUtilities } from '../Utils/FileUtilities';
 import { ICommandExecutor } from '../Utils/ICommandExecutor';
 import { IUtilityContext } from '../Utils/IUtilityContext';
@@ -29,7 +30,7 @@ export class DotnetConditionValidator implements IDotnetConditionValidator
 
     public async dotnetMeetsRequirement(dotnetExecutablePath: string, requirement: IDotnetFindPathContext): Promise<boolean>
     {
-        let hostArch = '';
+        const hostArch = new ExecutableArchitectureDetector().getExecutableArchitecture(dotnetExecutablePath);
         const oldLookup = process.env.DOTNET_MULTILEVEL_LOOKUP;
         // This is deprecated but still needed to scan .NET 6 and below
         process.env.DOTNET_MULTILEVEL_LOOKUP = '0'; // make it so --list-runtimes only finds the runtimes on that path: https://learn.microsoft.com/en-us/dotnet/core/compatibility/deployment/7.0/multilevel-lookup#reason-for-change
@@ -38,11 +39,11 @@ export class DotnetConditionValidator implements IDotnetConditionValidator
         {
             if (requirement.acquireContext.mode === 'sdk')
             {
-                const availableSDKs = await this.getSDKs(dotnetExecutablePath, requirement.acquireContext.architecture ?? DotnetCoreAcquisitionWorker.defaultArchitecture());
-                hostArch = availableSDKs?.at(0)?.architecture ?? await this.getHostArchitecture(dotnetExecutablePath, requirement);
+                const availableSDKs = await this.getSDKs(dotnetExecutablePath, requirement.acquireContext.architecture ?? DotnetCoreAcquisitionWorker.defaultArchitecture(), ExecutableArchitectureDetector.IsKnownArchitecture(hostArch));
+                const finalHostArch = ExecutableArchitectureDetector.IsKnownArchitecture(hostArch) ? hostArch : availableSDKs?.at(0)?.architecture ?? await this.getHostArchitecture(dotnetExecutablePath, requirement);
                 if (availableSDKs.some((sdk) =>
                 {
-                    return this.stringArchitectureMeetsRequirement(hostArch, requirement.acquireContext.architecture) &&
+                    return this.stringArchitectureMeetsRequirement(finalHostArch!, requirement.acquireContext.architecture) &&
                         this.stringVersionMeetsRequirement(sdk.version, requirement.acquireContext.version, requirement) && this.allowPreview(sdk.version, requirement);
                 }))
                 {
@@ -53,11 +54,11 @@ export class DotnetConditionValidator implements IDotnetConditionValidator
             else
             {
                 // No need to consider SDKs when looking for runtimes as all the runtimes installed with the SDKs will be included in the runtimes list.
-                const availableRuntimes = await this.getRuntimes(dotnetExecutablePath, requirement.acquireContext.architecture ?? DotnetCoreAcquisitionWorker.defaultArchitecture());
-                hostArch = availableRuntimes?.at(0)?.architecture ?? await this.getHostArchitecture(dotnetExecutablePath, requirement);
+                const availableRuntimes = await this.getRuntimes(dotnetExecutablePath, requirement.acquireContext.architecture ?? DotnetCoreAcquisitionWorker.defaultArchitecture(), ExecutableArchitectureDetector.IsKnownArchitecture(hostArch));
+                const finalHostArch = ExecutableArchitectureDetector.IsKnownArchitecture(hostArch) ? hostArch : availableRuntimes?.at(0)?.architecture ?? await this.getHostArchitecture(dotnetExecutablePath, requirement);
                 if (availableRuntimes.some((runtime) =>
                 {
-                    return runtime.mode === requirement.acquireContext.mode && this.stringArchitectureMeetsRequirement(hostArch, requirement.acquireContext.architecture) &&
+                    return runtime.mode === requirement.acquireContext.mode && this.stringArchitectureMeetsRequirement(finalHostArch!, requirement.acquireContext.architecture) &&
                         this.stringVersionMeetsRequirement(runtime.version, requirement.acquireContext.version, requirement) && this.allowPreview(runtime.version, requirement);
                 }))
                 {
@@ -135,7 +136,7 @@ Please set the PATH to a dotnet host that matches the architecture ${requirement
         return hostArch;
     }
 
-    public async getSDKs(existingPath: string, requestedArchitecture: string): Promise<IDotnetListInfo[]>
+    public async getSDKs(existingPath: string, requestedArchitecture: string, knownArchitecture: boolean): Promise<IDotnetListInfo[]>
     {
         if (!existingPath || existingPath === '""')
         {
@@ -151,7 +152,7 @@ Please set the PATH to a dotnet host that matches the architecture ${requirement
                 return [];
             }
 
-            const hostSupportsArchFlag = await this.hostSupportsArchFlag(existingPath, result.stdout);
+            const architectureKnown = knownArchitecture ? true : await this.hostSupportsArchFlag(existingPath, result.stdout);
             const sdks = result.stdout.split('\n').map((line) => line.trim()).filter((line) => (line?.length ?? 0) > 0);
             const sdkInfos: IDotnetListInfo[] = sdks.map((sdk) =>
             {
@@ -160,7 +161,7 @@ Please set the PATH to a dotnet host that matches the architecture ${requirement
                     mode: 'sdk',
                     version: parts[0],
                     directory: sdk.split(' ').slice(1).join(' ').slice(1, -1), // need to remove the brackets from the path [path],
-                    architecture: hostSupportsArchFlag ? requestedArchitecture : null
+                    architecture: architectureKnown ? requestedArchitecture : null
                 } as IDotnetListInfo;
             }).filter(x => x !== null) as IDotnetListInfo[];
 
@@ -327,7 +328,7 @@ Please set the PATH to a dotnet host that matches the architecture ${requirement
         return CommandExecutor.makeCommand(`"${existingPath}"`, ['--list-runtimes', '--arch', requestedArchitecture]);
     }
 
-    public async getRuntimes(existingPath: string, requestedArchitecture: string | null): Promise<IDotnetListInfo[]>
+    public async getRuntimes(existingPath: string, requestedArchitecture: string | null, knownArchitecture: boolean): Promise<IDotnetListInfo[]>
     {
         if (!existingPath || existingPath === '""')
         {
@@ -347,7 +348,7 @@ Please set the PATH to a dotnet host that matches the architecture ${requirement
                 return [];
             }
 
-            const hostSupportsArchFlag = await this.hostSupportsArchFlag(existingPath, result.stdout);
+            const architectureKnown = knownArchitecture ? true : await this.hostSupportsArchFlag(existingPath, result.stdout);
             const runtimes = result.stdout.split('\n').map((line) => line.trim()).filter((line) => (line?.length ?? 0) > 0);
             const runtimeInfos: IDotnetListInfo[] = runtimes.map((runtime) =>
             {
@@ -357,7 +358,7 @@ Please set the PATH to a dotnet host that matches the architecture ${requirement
                     version: parts[1],
                     directory: runtime.split(' ').slice(2).join(' ').slice(1, -1), // account for spaces in PATH, no space should appear before then and luckily path is last.
                     // the 2nd slice needs to remove the brackets from the path [path]
-                    architecture: hostSupportsArchFlag ? requestedArchitecture : null
+                    architecture: architectureKnown ? requestedArchitecture : null
                 } as IDotnetListInfo;
             }).filter(x => x !== null) as IDotnetListInfo[];
 

vscode-dotnet-runtime-extension/yarn.lock

@@ -388,7 +388,7 @@ export class DotnetPathFinder implements IDotnetPathFinder
         {
             // This will even work if only the sdk is installed, list-runtimes on an sdk installed host would work
             const validator = new DotnetConditionValidator(this.workerContext, this.utilityContext, this.executor);
-            const runtimeInfo = await validator.getRuntimes(tentativePath, requestedArchitecture);
+            const runtimeInfo = await validator.getRuntimes(tentativePath, requestedArchitecture, true);
             if ((runtimeInfo?.length ?? 0) > 0)
             {
                 // q.t. from @dibarbet on the C# Extension:

vscode-dotnet-runtime-library/package-lock.json

@@ -136,7 +136,8 @@ export class LocalMemoryCacheSingleton
         let optionsString = '{';
         sortedKeys.forEach((k, index) =>
         {
-            const v = key.options[k];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            const v = key.options?.[k];
             // Apply same replacer logic
             let value = v;
             if (k === 'dotnetInstallToolCacheTtlMs')