Fix Linux Mutex Utilization (#2229)

* Protect against stdout.txt not existing

It seems like it dropped the execution lock (maybe it threw an error) when executing The command apt-get -o DPkg::Lock::Timeout=180 upgrade -y dotnet-sdk-8.0 was forwarded to the master process to run.

It waited about 2 seconds then freed the server before it was done.  It freed before it threw but free happens before throw, so it might have failed for some reason, then failed again since stdout.txt didn't exist because the process wasn't done running. then freed. When it freed, it was still going but then it allowed the sudo master process killer to run which caused this to fail later....

Still not sure why that'd happen, it might be if the locking was not implemented correctly.

* Fix lint

* Add timeout to the logging

* Make each sudo process instance get its own directory.

This will help prevent an existing process from colliding with another.

* Dont delay anymore since the chance of this is very low

this is basically like random int collision at this point, could probably remove.

* Fix lint

* Throw an error if stderr DNE

Co-authored-by: Copilot <[email protected]>

* Fix support matrix

* Dont echo env in linux

* Fix copilot change

* Fix lint

* Fix env var logging

* Fix env var logging

* Consider that EEXIST may be thrown instead of EADDRINUSE with certain kernels

EACCESS as well. This may be something that will not resolve, though if some admin thing is blocking and holding the file, perhaps this is a good resolution. I never encountered this when trying different permissions on my demos but it seems that some people are.

* Remove extraneous check

* Use the old dir as a fallback if we cant create dirs and throw

* Lint

* Delete the directory

might as well do it in this PR

---------

Co-authored-by: Copilot <[email protected]>

Author: nagilson

vscode-dotnet-runtime-library/src/Acquisition/DotnetPathFinder.ts

@@ -133,7 +133,8 @@ export class DotnetPathFinder implements IDotnetPathFinder
 
         else
         {
-            this.executor?.execute(CommandExecutor.makeCommand('env', []), { dotnetInstallToolCacheTtlMs: DOTNET_INFORMATION_CACHE_DURATION_MS }, false)
+            this.executor?.execute(CommandExecutor.makeCommand('echo', ['$PATH']), { dotnetInstallToolCacheTtlMs: DOTNET_INFORMATION_CACHE_DURATION_MS }, false)
+
                 .then((result) =>
                 {
                     // Log the default shell state
@@ -143,7 +144,8 @@ export class DotnetPathFinder implements IDotnetPathFinder
 
             if (!(options.shell === '/bin/bash'))
             {
-                this.executor?.execute(CommandExecutor.makeCommand('env', []), { shell: 'bin/bash', dotnetInstallToolCacheTtlMs: SYS_CMD_SEARCH_CACHE_DURATION_MS }, false)
+                this.executor?.execute(CommandExecutor.makeCommand('echo', ['$PATH']), { shell: 'bin/bash', dotnetInstallToolCacheTtlMs: SYS_CMD_SEARCH_CACHE_DURATION_MS }, false)
+
                     .then((result) =>
                     {
                         this.workerContext.eventStream.post(new DotnetFindPathLookupPATH(`Execution Path (Unix Bash): ${result?.stdout}`));

vscode-dotnet-runtime-library/src/EventStream/EventStreamEvents.ts

@@ -1168,6 +1168,16 @@ export class DotnetFindPathNoHostOnRegistry extends DotnetCustomMessageEvent
     public readonly eventName = 'DotnetFindPathNoHostOnRegistry';
 }
 
+export class SudoDirCreationFailed extends DotnetCustomMessageEvent
+{
+    public readonly eventName = 'SudoDirCreationFailed';
+}
+
+export class SudoDirDeletionFailed extends DotnetCustomMessageEvent
+{
+    public readonly eventName = 'SudoDirDeletionFailed';
+}
+
 export class DotnetFindPathOnFileSystem extends DotnetCustomMessageEvent
 {
     public readonly eventName = 'DotnetFindPathOnFileSystem';
@@ -1535,6 +1545,10 @@ export class NetInstallerEndExecutionEvent extends DotnetCustomMessageEvent
     public readonly eventName = 'NetInstallerEndExecutionEvent';
 }
 
+export class FailedToRunSudoCommand extends DotnetCustomMessageEvent
+{
+    public readonly eventName = 'FailedToRunSudoCommand';
+}
 
 export class DotnetInstallLinuxChecks extends DotnetCustomMessageEvent
 {

vscode-dotnet-runtime-library/src/Utils/CommandExecutor.ts

@@ -31,6 +31,8 @@ import
     DotnetWSLSecurityError,
     EventBasedError,
     EventCancellationError,
+    FailedToRunSudoCommand,
+    SudoDirCreationFailed,
     SudoProcAliveCheckBegin,
     SudoProcAliveCheckEnd,
     SudoProcCommandExchangeBegin,
@@ -68,12 +70,15 @@ export class CommandExecutor extends ICommandExecutor
         LANGUAGE: 'en',
         DOTNET_CLI_UI_LANGUAGE: 'en-US',
     }; // Not all systems have english installed -- not sure if it's safe to use this.
-    private sudoProcessCommunicationDir = path.join(__dirname, 'install scripts');
+    private sudoProcessScript = path.join(__dirname, 'install scripts', 'interprocess-communicator.sh');
+    private sudoProcessCommunicationDir: string;
     private fileUtil: IFileUtilities;
 
     constructor(context: IAcquisitionWorkerContext, utilContext: IUtilityContext, protected readonly validSudoCommands?: string[])
     {
         super(context, utilContext);
+
+        this.sudoProcessCommunicationDir = path.join(__dirname, LockUsedByThisInstanceSingleton.SUDO_SESSION_ID);
         this.fileUtil = new FileUtilities();
     }
 
@@ -85,7 +90,31 @@ export class CommandExecutor extends ICommandExecutor
     {
         const fullCommandString = CommandExecutor.prettifyCommandExecutorCommand(command, false);
         this.context?.eventStream.post(new CommandExecutionUnderSudoEvent(`The command ${fullCommandString} is being ran under sudo.`));
-        const shellScript = path.join(this.sudoProcessCommunicationDir, 'interprocess-communicator.sh');
+        const shellScript = this.sudoProcessScript;
+
+        try
+        {
+            await fs.promises.mkdir(this.sudoProcessCommunicationDir, { recursive: true });
+        }
+        catch (error: any)
+        {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            error.message = error?.message + `\nFailed to create ${this.sudoProcessCommunicationDir}. Please check your permissions or install dotnet manually.`;
+            this.context?.eventStream.post(new SudoDirCreationFailed(`The command ${fullCommandString} failed, as no directory could be made: ${JSON.stringify(error)}`));
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (error?.code !== 'EEXIST')
+            {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                if (error?.code === 'EPERM' || error?.code === 'EACCES')
+                {
+                    this.sudoProcessCommunicationDir = path.dirname(this.sudoProcessScript);
+                }
+                else
+                {
+                    throw error;
+                }
+            }
+        }
 
         if (await isRunningUnderWSL(this.context, this.utilityContext, this))
         {
@@ -104,7 +133,7 @@ Please install the .NET SDK manually by following https://learn.microsoft.com/en
 
         const waitForLockTimeMs = this.context?.timeoutSeconds ? (this.context?.timeoutSeconds * 1000 / 3) : 180000;
         // @ts-expect-error We want to hold the lock and sometimes return a bool, sometimes a CommandExecutorResult. The bool will never be returned if runCommand is true, so this makes the compiler accept this (its bad ik).
-        return executeWithLock(this.context.eventStream, false, RUN_UNDER_SUDO_LOCK(this.sudoProcessCommunicationDir), SUDO_LOCK_PING_DURATION_MS, waitForLockTimeMs,
+        return executeWithLock(this.context.eventStream, false, RUN_UNDER_SUDO_LOCK(this.sudoProcessScript), SUDO_LOCK_PING_DURATION_MS, waitForLockTimeMs,
             async () =>
             {
                 this.startupSudoProc(fullCommandString, shellScript, terminalFailure).catch(() => {});
@@ -128,14 +157,6 @@ Please install the .NET SDK manually by following https://learn.microsoft.com/en
                 return '0';
             }
         }
-        else
-        {
-            if (await this.sudoProcIsLive(false, fullCommandString, 1000)) // If the sudo process was spawned by another instance of code, we do not want to have 2 at once but also do not waste a lot of time checking
-            // As it should not be in the middle of an operation which may cause it to take a while.
-            {
-                return '0';
-            }
-        }
 
         // Launch the process under sudo
         this.context?.eventStream.post(new CommandExecutionUserAskDialogueEvent(`Prompting user for command ${fullCommandString} under sudo.`));
@@ -187,7 +208,7 @@ ${stderr}`));
     private async sudoProcIsLive(errorIfDead: boolean, fullCommandString: string, maxTimeoutTimeMs?: number, runCommand = false): Promise<boolean | CommandExecutorResult>
     {
         const processAliveOkSentinelFile = path.join(this.sudoProcessCommunicationDir, 'ok.txt');
-        const waitForLockTimeMs = maxTimeoutTimeMs ? maxTimeoutTimeMs : this.context?.timeoutSeconds ? (this.context?.timeoutSeconds * 1000 / 5) : 180000;
+        const waitForLockTimeMs = maxTimeoutTimeMs ? maxTimeoutTimeMs : (this.context?.timeoutSeconds !== undefined ? (Math.max(this.context.timeoutSeconds * 1000 / 5, 100)) : 180000);
         const waitForSudoResponseTimeMs = waitForLockTimeMs * 0.75; // Arbitrary, but this should be less than the time to get the lock.
 
         await (this.fileUtil as FileUtilities).wipeDirectory(this.sudoProcessCommunicationDir, this.context?.eventStream, ['.txt']);
@@ -219,7 +240,7 @@ ${stderr}`));
 
         const isLive = LockUsedByThisInstanceSingleton.getInstance().isCurrentSudoProcCheckAlive();
         this.context?.eventStream.post(new SudoProcAliveCheckEnd(`Finished Sudo Process Master: Is Alive? ${isLive}. ${new Date().toISOString()}
-                    maxTimeoutTimeMs: ${maxTimeoutTimeMs} with lockTime ${waitForLockTimeMs} and responseTime ${waitForSudoResponseTimeMs}`));
+                    waitForLockTimeMs: ${waitForLockTimeMs} with lockTime ${waitForLockTimeMs} and responseTime ${waitForSudoResponseTimeMs}`));
 
         // The sudo process spawned by vscode does not exit unless it fails or times out after an hour. We can't await it as we need it to persist.
         // If someone cancels the install, we store that error here since this gets awaited to prevent further code statement control flow from executing.
@@ -279,22 +300,24 @@ ${stderr}`));
         this.context?.eventStream.post(new CommandProcessorExecutionBegin(`The command ${commandToExecuteString} was forwarded to the master process to run.`));
 
 
-        const waitTimeMs = this.context?.timeoutSeconds ? (this.context?.timeoutSeconds * 1000) : 600000;
-        await loopWithTimeoutOnCond(100, waitTimeMs,
+        const waitTimeMs = this.context?.timeoutSeconds ? (Math.max(this.context?.timeoutSeconds * 1000, 1000)) : 600000;
+        const sampleRateMs = 100;
+        await loopWithTimeoutOnCond(sampleRateMs, waitTimeMs,
             function ProcessFinishedExecutingAndWroteOutput(): boolean { return fs.existsSync(outputFile) },
             function doNothing(): void { ; },
             this.context.eventStream,
-            new SudoProcCommandExchangePing(`Ping : Waiting. ${new Date().toISOString()}`)
+            new SudoProcCommandExchangePing(`Ping : Waiting, at rate ${sampleRateMs} with timeout ${waitTimeMs} ${new Date().toISOString()}`)
         )
             .catch(error =>
             {
+                this.context?.eventStream.post(new FailedToRunSudoCommand(`The command ${commandToExecuteString} failed to run: ${JSON.stringify(error ?? '')}.`));
                 // Let the rejected promise get handled below. This is required to not make an error from the checking if this promise is alive
             });
 
         commandOutputJson = {
-            stdout: (fs.readFileSync(stdoutFile, 'utf8')).trim(),
-            stderr: (fs.readFileSync(stderrFile, 'utf8')).trim(),
-            status: (fs.readFileSync(statusFile, 'utf8')).trim()
+            stdout: (await (this.fileUtil as FileUtilities).read(stdoutFile)).trim(),
+            stderr: (await (this.fileUtil as FileUtilities).read(stderrFile)).trim(),
+            status: (await (this.fileUtil as FileUtilities).read(statusFile)).trim()
         } as CommandExecutorResult;
 
         this.context?.eventStream.post(new SudoProcCommandExchangeEnd(`Finished or timed out with master process. ${new Date().toISOString()}`));
@@ -347,6 +370,7 @@ ${stderr}`));
         await executeWithLock(this.context.eventStream, false, RUN_UNDER_SUDO_LOCK(this.sudoProcessCommunicationDir), SUDO_LOCK_PING_DURATION_MS, this.context.timeoutSeconds * 1000 / 5,
             async () =>
             {
+                await (this.fileUtil as FileUtilities).wipeDirectory(this.sudoProcessCommunicationDir, this.context?.eventStream, ['.txt']);
                 const processExitFile = path.join(this.sudoProcessCommunicationDir, 'exit.txt');
                 await (this.fileUtil as FileUtilities).writeFileOntoDisk('', processExitFile, this.context?.eventStream);
 
@@ -369,6 +393,19 @@ ${stderr}`));
                 eventStream.post(new TriedToExitMasterSudoProcess(`Tried to exit sudo master process: exit code ${LockUsedByThisInstanceSingleton.getInstance().hasSpawnedSudoSuccessfullyWithoutDeath()}`));
             });
 
+        try
+        {
+            fs.rmdirSync(this.sudoProcessCommunicationDir, { recursive: true });
+        }
+        catch (error: any)
+        {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (error?.code !== 'ENOENT')
+            {
+                eventStream.post(new SudoDirCreationFailed(`The command ${this.sudoProcessCommunicationDir} failed to rm the sudo directory: ${JSON.stringify(error)}`));
+            }
+        }
+
         return LockUsedByThisInstanceSingleton.getInstance().hasSpawnedSudoSuccessfullyWithoutDeath() ? 1 : 0;
     }
 

vscode-dotnet-runtime-library/src/Utils/FileUtilities.ts

@@ -96,8 +96,16 @@ export class FileUtilities extends IFileUtilities
 
     public async read(filePath: string): Promise<string>
     {
-        const output = await fs.promises.readFile(filePath, 'utf8');
-        return output;
+        try
+        {
+            const output = await fs.promises.readFile(filePath, 'utf8');
+            return output;
+        }
+        catch (error: any)
+        {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            throw new Error(`Failed to read file ${filePath}: ${error?.message}`);
+        }
     }
 
     public async exists(filePath: string): Promise<boolean>

vscode-dotnet-runtime-library/src/Utils/LockUsedByThisInstanceSingleton.ts

@@ -11,6 +11,8 @@ export class LockUsedByThisInstanceSingleton
     private currentAliveStatus = false;
     private sudoError: any = null;
 
+    public static readonly SUDO_SESSION_ID = crypto.randomUUID().substring(0, 8);
+
     protected constructor(protected lockStringAndThisVsCodeInstanceOwnsIt: { [lockString: string]: boolean } = {})
     {
 

vscode-dotnet-runtime-library/src/Utils/NodeIPCMutex.ts

@@ -108,7 +108,7 @@ export class NodeIPCMutex
             catch (error: any)
             {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                if (error?.code === 'EADDRINUSE') //  We couldn't acquire the lock, even though nobody else is using it.
+                if (error?.code === 'EADDRINUSE' || error?.code === 'EEXIST' || error?.code === 'EACCESS')
                 {
                     if (retries >= maxRetryCountToEndAtRoughlyTimeoutTime)
                     {

vscode-dotnet-runtime-library/src/Utils/TypescriptUtilities.ts

@@ -25,12 +25,12 @@ export async function loopWithTimeoutOnCond(sampleRatePerMs: number, durationToW
         if (conditionToStop())
         {
             doAfterStop();
-            return;
+            return Promise.resolve();
         }
         eventStream?.post(waitEvent);
         await new Promise(waitAndResolve => setTimeout(waitAndResolve, sampleRatePerMs));
     }
-    throw new Error('The promise timed out.');
+    throw new Error(`The promise timed out at ${durationToWaitBeforeTimeoutMs}.`);
 }
 
 /**

vscode-dotnet-runtime-library/src/test/unit/TestUtility.ts

@@ -149,6 +149,10 @@ export async function getLinuxSupportedDotnetSDKVersion(context: IAcquisitionWor
         {
             return '6.0.100';
         }
+        if (distroInfo.version < '22.06')
+        {
+            return '9.0.100';
+        }
         if (distroInfo.version < '24.04')
         {
             return '8.0.100';