Merge pull request #1554 from nagilson/nagilson-does-install-still-exist

nagilson · web-flow · commit 946b20d65245 · 2024-01-19T13:03:26.000-08:00
Improve bugs with installKey management
diff --git a/vscode-dotnet-runtime-library/src/Acquisition/DotnetCoreAcquisitionWorker.ts b/vscode-dotnet-runtime-library/src/Acquisition/DotnetCoreAcquisitionWorker.ts
@@ -60,9 +60,12 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
     private readonly dotnetExecutable: string;
     private globalResolver: GlobalInstallerResolver | null;
 
-    private acquisitionPromises: { [installKeys: string]: Promise<string> | undefined };
+    private acquisitionPromises: { [installKey: string]: Promise<string> | undefined };
     private extensionContext : IVSCodeExtensionContext;
 
+    // @member usingNoInstallInvoker - Only use this for test when using the No Install Invoker to fake the worker into thinking a path is on disk.
+    protected usingNoInstallInvoker = false;
+
     constructor(protected readonly context: IAcquisitionWorkerContext, private readonly utilityContext : IUtilityContext, extensionContext : IVSCodeExtensionContext) {
         const dotnetExtension = os.platform() === 'win32' ? '.exe' : '';
         this.dotnetExecutable = `dotnet${dotnetExtension}`;
@@ -79,8 +82,14 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
 
         this.removeFolderRecursively(this.context.installDirectoryProvider.getStoragePath());
 
-        await this.context.extensionState.update(this.installingVersionsKey, []);
-        await this.context.extensionState.update(this.installedVersionsKey, []);
+        // This does not uninstall global things yet, so don't remove their keys.
+        const installingVersions = this.context.extensionState.get<string[]>(this.installingVersionsKey, []);
+        const remainingInstallingVersions = installingVersions.filter(x => this.isGlobalInstallKey(x));
+        await this.context.extensionState.update(this.installingVersionsKey, remainingInstallingVersions);
+
+        const installedVersions = this.context.extensionState.get<string[]>(this.installedVersionsKey, []);
+        const remainingInstalledVersions = installedVersions.filter(x => this.isGlobalInstallKey(x));
+        await this.context.extensionState.update(this.installedVersionsKey, remainingInstalledVersions);
 
         this.context.eventStream.post(new DotnetUninstallAllCompleted());
     }
@@ -100,6 +109,11 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
         return this.acquire(await installerResolver.getFullySpecifiedVersion(), false, installerResolver);
     }
 
+    private isGlobalInstallKey(installKey : string) : boolean
+    {
+        return installKey.toLowerCase().includes('global');
+    }
+
     /**
      *
      * @remarks this is simply a wrapper around the acquire function.
@@ -109,7 +123,15 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
         return this.acquire(version, true, undefined, invoker);
     }
 
-    public async acquireStatus(version: string, installRuntime: boolean, architecture? : string): Promise<IDotnetAcquireResult | undefined> {
+    /**
+     *
+     * @param version The version of the runtime or sdk to check
+     * @param installRuntime Whether this is a local runtime status check or a local SDK status check.
+     * @param architecture The architecture of the install. Undefined means it will be the default arch, which is the node platform arch.
+     * @returns The result of the install with the path to dotnet if installed, else undefined.
+     */
+    public async acquireStatus(version: string, installRuntime: boolean, architecture? : string): Promise<IDotnetAcquireResult | undefined>
+    {
         const installKey = DotnetCoreAcquisitionWorker.getInstallKeyCustomArchitecture(version, architecture ? architecture : this.installingArchitecture)
 
         const existingAcquisitionPromise = this.acquisitionPromises[installKey];
@@ -129,7 +151,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
             installedVersions = await this.managePreinstalledVersion(dotnetInstallDir, installedVersions);
         }
 
-        if (installedVersions.includes(installKey) && fs.existsSync(dotnetPath))
+        if (installedVersions.includes(installKey) && (fs.existsSync(dotnetPath) || this.usingNoInstallInvoker ))
         {
             // Requested version has already been installed.
             this.context.eventStream.post(new DotnetAcquisitionStatusResolved(installKey, version));
@@ -170,6 +192,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
                 Debugging.log(`The Acquisition Worker has Determined a Global Install was requested.`, this.context.eventStream);
 
                 acquisitionPromise = this.acquireGlobalCore(globalInstallerResolver, installKey).catch((error: Error) => {
+                    this.removeVersionFromExtensionState(this.installingVersionsKey, installKey);
                     delete this.acquisitionPromises[installKey];
                     throw new Error(`.NET Acquisition Failed: ${error.message}`);
                 });
@@ -179,11 +202,14 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
                 Debugging.log(`The Acquisition Worker has Determined a Local Install was requested.`, this.context.eventStream);
 
                 acquisitionPromise = this.acquireLocalCore(version, installRuntime, installKey, localInvoker!).catch((error: Error) => {
+                    this.removeVersionFromExtensionState(this.installingVersionsKey, installKey);
                     delete this.acquisitionPromises[installKey];
                     throw new Error(`.NET Acquisition Failed: ${error.message}`);
                 });
             }
 
+            // Put this promise into the list so we can let other requests run at the same time
+            // Allows us to return the end result of this current request for any following duplicates while we are still running.
             this.acquisitionPromises[installKey] = acquisitionPromise;
             return acquisitionPromise.then((res) => ({ dotnetPath: res }));
         }
@@ -229,7 +255,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
             installedVersions = await this.managePreinstalledVersion(dotnetInstallDir, installedVersions);
         }
 
-        if (installedVersions.includes(installKey) && fs.existsSync(dotnetPath)) {
+        if (installedVersions.includes(installKey) && (fs.existsSync(dotnetPath) || this.usingNoInstallInvoker)) {
             // Version requested has already been installed.
             this.context.installationValidator.validateDotnetInstall(installKey, dotnetPath);
             this.context.eventStream.post(new DotnetAcquisitionAlreadyInstalled(installKey,
@@ -261,6 +287,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
         await this.removeVersionFromExtensionState(this.installingVersionsKey, installKey);
         await this.addVersionToExtensionState(this.installedVersionsKey, installKey);
 
+        delete this.acquisitionPromises[installKey];
         return dotnetPath;
     }
 
@@ -280,7 +307,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
             }
             if(uninstallLocalSDK)
             {
-                await this.uninstallRuntimeOrSDK(installKey);
+                await this.uninstallLocalRuntimeOrSDK(installKey);
             }
         }
     }
@@ -330,6 +357,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
         await this.addVersionToExtensionState(this.installedVersionsKey, installKey);
 
         this.context.eventStream.post(new DotnetGlobalAcquisitionCompletionEvent(`The version ${installKey} completed successfully.`));
+        delete this.acquisitionPromises[installKey];
         return installedSDKPath;
     }
 
@@ -366,7 +394,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
             if(legacyInstall.includes(version))
             {
                 this.context.eventStream.post(new DotnetLegacyInstallRemovalRequestEvent(`Trying to remove legacy install: ${legacyInstall} of ${version}.`));
-                await this.uninstallRuntimeOrSDK(legacyInstall);
+                await this.uninstallLocalRuntimeOrSDK(legacyInstall);
             }
         }
     }
@@ -398,7 +426,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
         {
             this.context.eventStream.post(new DotnetInstallGraveyardEvent(
                 `Attempting to remove .NET at ${installKey} again, as it was left in the graveyard.`));
-            await this.uninstallRuntimeOrSDK(installKey);
+            await this.uninstallLocalRuntimeOrSDK(installKey);
         }
     }
 
@@ -425,7 +453,13 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker
         await this.context.extensionState.update(this.installPathsGraveyardKey, graveyard);
     }
 
-    public async uninstallRuntimeOrSDK(installKey : string) {
+    public async uninstallLocalRuntimeOrSDK(installKey : string)
+    {
+        if(this.isGlobalInstallKey(installKey))
+        {
+            return;
+        }
+
         try
         {
             delete this.acquisitionPromises[installKey];
diff --git a/vscode-dotnet-runtime-library/src/Acquisition/LinuxVersionResolver.ts b/vscode-dotnet-runtime-library/src/Acquisition/LinuxVersionResolver.ts
@@ -175,9 +175,9 @@ export class LinuxVersionResolver
         {
             // Implement any custom logic for a Distro Class in a new DistroSDKProvider and add it to the factory here.
             case null:
-                const error = new DotnetAcquisitionDistroUnknownError(new Error(this.baseUnsupportedDistroErrorMessage), getInstallKeyFromContext(this.acquireContext));
-                this.acquisitionContext.eventStream.post(error);
-                throw error.error;
+                const unknownDistroErr = new DotnetAcquisitionDistroUnknownError(new Error(this.baseUnsupportedDistroErrorMessage), getInstallKeyFromContext(this.acquireContext));
+                this.acquisitionContext.eventStream.post(unknownDistroErr);
+                throw unknownDistroErr.error;
             case 'Red Hat Enterprise Linux':
                 if(this.isRedHatVersion7(distroAndVersion.version))
                 {
diff --git a/vscode-dotnet-runtime-library/src/test/mocks/MockObjects.ts b/vscode-dotnet-runtime-library/src/test/mocks/MockObjects.ts
@@ -36,6 +36,7 @@ import { ITelemetryReporter } from '../../EventStream/TelemetryObserver';
 import { IUtilityContext } from '../../Utils/IUtilityContext';
 import { IVSCodeEnvironment } from '../../Utils/IVSCodeEnvironment';
 import { IDotnetAcquireResult } from '../../IDotnetAcquireResult';
+import { IDotnetCoreAcquisitionWorker } from '../../Acquisition/IDotnetCoreAcquisitionWorker';
 
 const testDefaultTimeoutTimeMs = 60000;
 /* tslint:disable:no-any */
@@ -81,6 +82,13 @@ export class NoInstallAcquisitionInvoker extends IAcquisitionInvoker {
 
         });
     }
+
+    constructor(eventStream : IEventStream, worker : MockDotnetCoreAcquisitionWorker)
+    {
+        super(eventStream);
+        worker.enableNoInstallInvoker();
+    }
+
 }
 
 export class MockDotnetCoreAcquisitionWorker extends DotnetCoreAcquisitionWorker
@@ -115,6 +123,11 @@ export class MockDotnetCoreAcquisitionWorker extends DotnetCoreAcquisitionWorker
         this.context.installingArchitecture = newArch;
         this.context.acquisitionContext!.architecture = newArch;
     }
+
+    public enableNoInstallInvoker()
+    {
+        this.usingNoInstallInvoker = true;
+    }
 }
 
 export class RejectingAcquisitionInvoker extends IAcquisitionInvoker {
diff --git a/vscode-dotnet-runtime-library/src/test/unit/DotnetCoreAcquisitionWorker.test.ts b/vscode-dotnet-runtime-library/src/test/unit/DotnetCoreAcquisitionWorker.test.ts
@@ -44,7 +44,7 @@ suite('DotnetCoreAcquisitionWorker Unit Tests', function () {
         const context = new MockExtensionContext();
         const eventStream = new MockEventStream();
         const acquisitionWorker = getMockAcquisitionWorker(isRuntimeWorker, version, arch, eventStream, context);
-        const invoker = new NoInstallAcquisitionInvoker(eventStream);
+        const invoker = new NoInstallAcquisitionInvoker(eventStream, acquisitionWorker);
         return [acquisitionWorker, eventStream, context, invoker];
     }
 
@@ -140,7 +140,7 @@ suite('DotnetCoreAcquisitionWorker Unit Tests', function () {
         assert.exists(undefinedEvent, 'Undefined event exists');
 
         await acquisitionWorker.acquireSDK(version, invoker);
-        result = await acquisitionWorker.acquireStatus(version, false);
+        result = await acquisitionWorker.acquireStatus(version, false, undefined);
         await assertAcquisitionSucceeded(installKey, result!.dotnetPath, eventStream, context, false);
         const resolvedEvent = eventStream.events.find(event => event instanceof DotnetAcquisitionStatusResolved);
         assert.exists(resolvedEvent, 'The sdk is resolved');
@@ -155,8 +155,8 @@ suite('DotnetCoreAcquisitionWorker Unit Tests', function () {
         const undefinedEvent = eventStream.events.find(event => event instanceof DotnetAcquisitionStatusUndefined);
         assert.exists(undefinedEvent);
 
-        await acquisitionWorker.acquireSDK(version, invoker);
-        result = await acquisitionWorker.acquireStatus(version, true);
+        await acquisitionWorker.acquireRuntime(version, invoker);
+        result = await acquisitionWorker.acquireStatus(version, true, undefined);
         await assertAcquisitionSucceeded(installKey, result!.dotnetPath, eventStream, context, true);
         const resolvedEvent = eventStream.events.find(event => event instanceof DotnetAcquisitionStatusResolved);
         assert.exists(resolvedEvent);
diff --git a/vscode-dotnet-runtime-library/src/test/unit/WinMacGlobalInstaller.test.ts b/vscode-dotnet-runtime-library/src/test/unit/WinMacGlobalInstaller.test.ts
@@ -7,7 +7,7 @@ import * as chai from 'chai';
 import * as os from 'os';
 import * as fs from 'fs';
 import * as path from 'path';
-import { MockCommandExecutor, MockEventStream, MockExtensionContext, MockFileUtilities, MockInstallationValidator, NoInstallAcquisitionInvoker } from '../mocks/MockObjects';
+import { MockCommandExecutor, MockFileUtilities } from '../mocks/MockObjects';
 import { WinMacGlobalInstaller } from '../../Acquisition/WinMacGlobalInstaller';
 import { FileUtilities } from '../../Utils/FileUtilities';
 import { getMockAcquisitionContext, getMockUtilityContext } from './TestUtility';
diff --git a/vscode-dotnet-sdk-extension/src/test/functional/DotnetCoreAcquisitionExtension.test.ts b/vscode-dotnet-sdk-extension/src/test/functional/DotnetCoreAcquisitionExtension.test.ts
@@ -160,7 +160,7 @@ suite('DotnetCoreAcquisitionExtension End to End', function()
     fs.writeFileSync(dotnetExePath, '');
 
     // Assert preinstalled SDKs are detected
-    const acquisitionInvoker = new NoInstallAcquisitionInvoker(eventStream);
+    const acquisitionInvoker = new NoInstallAcquisitionInvoker(eventStream, acquisitionWorker);
     const result = await acquisitionWorker.acquireSDK(version, acquisitionInvoker);
     assert.equal(path.dirname(result.dotnetPath), dotnetDir);
     const preinstallEvents = eventStream.events

Original file line number	Diff line number	Diff line change
`@@ -60,9 +60,12 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`60`	`60`	`private readonly dotnetExecutable: string;`
`61`	`61`	`private globalResolver: GlobalInstallerResolver \| null;`
`62`	`62`
`63`		`- private acquisitionPromises: { [installKeys: string]: Promise<string> \| undefined };`
	`63`	`+ private acquisitionPromises: { [installKey: string]: Promise<string> \| undefined };`
`64`	`64`	`private extensionContext : IVSCodeExtensionContext;`
`65`	`65`
	`66`	`+ // @member usingNoInstallInvoker - Only use this for test when using the No Install Invoker to fake the worker into thinking a path is on disk.`
	`67`	`+ protected usingNoInstallInvoker = false;`
	`68`	`+`
`66`	`69`	`constructor(protected readonly context: IAcquisitionWorkerContext, private readonly utilityContext : IUtilityContext, extensionContext : IVSCodeExtensionContext) {`
`67`	`70`	`const dotnetExtension = os.platform() === 'win32' ? '.exe' : '';`
`68`	`71`	this.dotnetExecutable = `dotnet${dotnetExtension}`;
`@@ -79,8 +82,14 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`79`	`82`
`80`	`83`	`this.removeFolderRecursively(this.context.installDirectoryProvider.getStoragePath());`
`81`	`84`
`82`		`- await this.context.extensionState.update(this.installingVersionsKey, []);`
`83`		`- await this.context.extensionState.update(this.installedVersionsKey, []);`
	`85`	`+ // This does not uninstall global things yet, so don't remove their keys.`
	`86`	`+ const installingVersions = this.context.extensionState.get<string[]>(this.installingVersionsKey, []);`
	`87`	`+ const remainingInstallingVersions = installingVersions.filter(x => this.isGlobalInstallKey(x));`
	`88`	`+ await this.context.extensionState.update(this.installingVersionsKey, remainingInstallingVersions);`
	`89`	`+`
	`90`	`+ const installedVersions = this.context.extensionState.get<string[]>(this.installedVersionsKey, []);`
	`91`	`+ const remainingInstalledVersions = installedVersions.filter(x => this.isGlobalInstallKey(x));`
	`92`	`+ await this.context.extensionState.update(this.installedVersionsKey, remainingInstalledVersions);`
`84`	`93`
`85`	`94`	`this.context.eventStream.post(new DotnetUninstallAllCompleted());`
`86`	`95`	`}`
`@@ -100,6 +109,11 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`100`	`109`	`return this.acquire(await installerResolver.getFullySpecifiedVersion(), false, installerResolver);`
`101`	`110`	`}`
`102`	`111`
	`112`	`+ private isGlobalInstallKey(installKey : string) : boolean`
	`113`	`+ {`
	`114`	`+ return installKey.toLowerCase().includes('global');`
	`115`	`+ }`
	`116`	`+`
`103`	`117`	`/**`
`104`	`118`	`*`
`105`	`119`	`* @remarks this is simply a wrapper around the acquire function.`
`@@ -109,7 +123,15 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`109`	`123`	`return this.acquire(version, true, undefined, invoker);`
`110`	`124`	`}`
`111`	`125`
`112`		`- public async acquireStatus(version: string, installRuntime: boolean, architecture? : string): Promise<IDotnetAcquireResult \| undefined> {`
	`126`	`+ /**`
	`127`	`+ *`
	`128`	`+ * @param version The version of the runtime or sdk to check`
	`129`	`+ * @param installRuntime Whether this is a local runtime status check or a local SDK status check.`
	`130`	`+ * @param architecture The architecture of the install. Undefined means it will be the default arch, which is the node platform arch.`
	`131`	`+ * @returns The result of the install with the path to dotnet if installed, else undefined.`
	`132`	`+ */`
	`133`	`+ public async acquireStatus(version: string, installRuntime: boolean, architecture? : string): Promise<IDotnetAcquireResult \| undefined>`
	`134`	`+ {`
`113`	`135`	`const installKey = DotnetCoreAcquisitionWorker.getInstallKeyCustomArchitecture(version, architecture ? architecture : this.installingArchitecture)`
`114`	`136`
`115`	`137`	`const existingAcquisitionPromise = this.acquisitionPromises[installKey];`
`@@ -129,7 +151,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`129`	`151`	`installedVersions = await this.managePreinstalledVersion(dotnetInstallDir, installedVersions);`
`130`	`152`	`}`
`131`	`153`
`132`		`- if (installedVersions.includes(installKey) && fs.existsSync(dotnetPath))`
	`154`	`+ if (installedVersions.includes(installKey) && (fs.existsSync(dotnetPath) \|\| this.usingNoInstallInvoker ))`
`133`	`155`	`{`
`134`	`156`	`// Requested version has already been installed.`
`135`	`157`	`this.context.eventStream.post(new DotnetAcquisitionStatusResolved(installKey, version));`
`@@ -170,6 +192,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`170`	`192`	Debugging.log(`The Acquisition Worker has Determined a Global Install was requested.`, this.context.eventStream);
`171`	`193`
`172`	`194`	`acquisitionPromise = this.acquireGlobalCore(globalInstallerResolver, installKey).catch((error: Error) => {`
	`195`	`+ this.removeVersionFromExtensionState(this.installingVersionsKey, installKey);`
`173`	`196`	`delete this.acquisitionPromises[installKey];`
`174`	`197`	throw new Error(`.NET Acquisition Failed: ${error.message}`);
`175`	`198`	`});`
`@@ -179,11 +202,14 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`179`	`202`	Debugging.log(`The Acquisition Worker has Determined a Local Install was requested.`, this.context.eventStream);
`180`	`203`
`181`	`204`	`acquisitionPromise = this.acquireLocalCore(version, installRuntime, installKey, localInvoker!).catch((error: Error) => {`
	`205`	`+ this.removeVersionFromExtensionState(this.installingVersionsKey, installKey);`
`182`	`206`	`delete this.acquisitionPromises[installKey];`
`183`	`207`	throw new Error(`.NET Acquisition Failed: ${error.message}`);
`184`	`208`	`});`
`185`	`209`	`}`
`186`	`210`
	`211`	`+ // Put this promise into the list so we can let other requests run at the same time`
	`212`	`+ // Allows us to return the end result of this current request for any following duplicates while we are still running.`
`187`	`213`	`this.acquisitionPromises[installKey] = acquisitionPromise;`
`188`	`214`	`return acquisitionPromise.then((res) => ({ dotnetPath: res }));`
`189`	`215`	`}`
`@@ -229,7 +255,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`229`	`255`	`installedVersions = await this.managePreinstalledVersion(dotnetInstallDir, installedVersions);`
`230`	`256`	`}`
`231`	`257`
`232`		`- if (installedVersions.includes(installKey) && fs.existsSync(dotnetPath)) {`
	`258`	`+ if (installedVersions.includes(installKey) && (fs.existsSync(dotnetPath) \|\| this.usingNoInstallInvoker)) {`
`233`	`259`	`// Version requested has already been installed.`
`234`	`260`	`this.context.installationValidator.validateDotnetInstall(installKey, dotnetPath);`
`235`	`261`	`this.context.eventStream.post(new DotnetAcquisitionAlreadyInstalled(installKey,`
`@@ -261,6 +287,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`261`	`287`	`await this.removeVersionFromExtensionState(this.installingVersionsKey, installKey);`
`262`	`288`	`await this.addVersionToExtensionState(this.installedVersionsKey, installKey);`
`263`	`289`
	`290`	`+ delete this.acquisitionPromises[installKey];`
`264`	`291`	`return dotnetPath;`
`265`	`292`	`}`
`266`	`293`
`@@ -280,7 +307,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`280`	`307`	`}`
`281`	`308`	`if(uninstallLocalSDK)`
`282`	`309`	`{`
`283`		`- await this.uninstallRuntimeOrSDK(installKey);`
	`310`	`+ await this.uninstallLocalRuntimeOrSDK(installKey);`
`284`	`311`	`}`
`285`	`312`	`}`
`286`	`313`	`}`
`@@ -330,6 +357,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`330`	`357`	`await this.addVersionToExtensionState(this.installedVersionsKey, installKey);`
`331`	`358`
`332`	`359`	this.context.eventStream.post(new DotnetGlobalAcquisitionCompletionEvent(`The version ${installKey} completed successfully.`));
	`360`	`+ delete this.acquisitionPromises[installKey];`
`333`	`361`	`return installedSDKPath;`
`334`	`362`	`}`
`335`	`363`
`@@ -366,7 +394,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`366`	`394`	`if(legacyInstall.includes(version))`
`367`	`395`	`{`
`368`	`396`	this.context.eventStream.post(new DotnetLegacyInstallRemovalRequestEvent(`Trying to remove legacy install: ${legacyInstall} of ${version}.`));
`369`		`- await this.uninstallRuntimeOrSDK(legacyInstall);`
	`397`	`+ await this.uninstallLocalRuntimeOrSDK(legacyInstall);`
`370`	`398`	`}`
`371`	`399`	`}`
`372`	`400`	`}`
`@@ -398,7 +426,7 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`398`	`426`	`{`
`399`	`427`	`this.context.eventStream.post(new DotnetInstallGraveyardEvent(`
`400`	`428`	`Attempting to remove .NET at ${installKey} again, as it was left in the graveyard.`));
`401`		`- await this.uninstallRuntimeOrSDK(installKey);`
	`429`	`+ await this.uninstallLocalRuntimeOrSDK(installKey);`
`402`	`430`	`}`
`403`	`431`	`}`
`404`	`432`
`@@ -425,7 +453,13 @@ export class DotnetCoreAcquisitionWorker implements IDotnetCoreAcquisitionWorker`
`425`	`453`	`await this.context.extensionState.update(this.installPathsGraveyardKey, graveyard);`
`426`	`454`	`}`
`427`	`455`
`428`		`- public async uninstallRuntimeOrSDK(installKey : string) {`
	`456`	`+ public async uninstallLocalRuntimeOrSDK(installKey : string)`
	`457`	`+ {`
	`458`	`+ if(this.isGlobalInstallKey(installKey))`
	`459`	`+ {`
	`460`	`+ return;`
	`461`	`+ }`
	`462`	`+`
`429`	`463`	`try`
`430`	`464`	`{`
`431`	`465`	`delete this.acquisitionPromises[installKey];`
Original file line number	Diff line number	Diff line change
`@@ -175,9 +175,9 @@ export class LinuxVersionResolver`
`175`	`175`	`{`
`176`	`176`	`// Implement any custom logic for a Distro Class in a new DistroSDKProvider and add it to the factory here.`
`177`	`177`	`case null:`
`178`		`- const error = new DotnetAcquisitionDistroUnknownError(new Error(this.baseUnsupportedDistroErrorMessage), getInstallKeyFromContext(this.acquireContext));`
`179`		`- this.acquisitionContext.eventStream.post(error);`
`180`		`- throw error.error;`
	`178`	`+ const unknownDistroErr = new DotnetAcquisitionDistroUnknownError(new Error(this.baseUnsupportedDistroErrorMessage), getInstallKeyFromContext(this.acquireContext));`
	`179`	`+ this.acquisitionContext.eventStream.post(unknownDistroErr);`
	`180`	`+ throw unknownDistroErr.error;`
`181`	`181`	`case 'Red Hat Enterprise Linux':`
`182`	`182`	`if(this.isRedHatVersion7(distroAndVersion.version))`
`183`	`183`	`{`