Use new helix sdk/runtime functionality

eng/helix/content/RunTests/Program.cs

@@ -17,15 +17,7 @@ static async Task Main(string[] args)
                 var keepGoing = runner.SetupEnvironment();
                 if (keepGoing)
                 {
-                    keepGoing = await runner.InstallDotnetDump();
-                }
-                if (keepGoing)
-                {
-                    keepGoing = await runner.InstallAspNetAppIfNeededAsync();
-                }
-                if (keepGoing)
-                {
-                    keepGoing = runner.InstallAspNetRefIfNeeded();
+                    keepGoing = await runner.InstallDotnetToolsAsync();
                 }
 #if INSTALLPLAYWRIGHT
                 if (keepGoing)

eng/helix/content/RunTests/TestRunner.cs

@@ -42,6 +42,9 @@ public bool SetupEnvironment()
                 var dotnetEFFullPath = Path.Combine(nugetRestore, helixDir, "dotnet-ef.exe");
                 Console.WriteLine($"Set DotNetEfFullPath: {dotnetEFFullPath}");
                 EnvironmentVariables.Add("DotNetEfFullPath", dotnetEFFullPath);
+                var appRuntimePath = $"{Options.DotnetRoot}/shared/Microsoft.AspNetCore.App/{Options.RuntimeVersion}";
+                Console.WriteLine($"Set ASPNET_RUNTIME_PATH: {appRuntimePath}");
+                EnvironmentVariables.Add("ASPNET_RUNTIME_PATH", appRuntimePath);
 
 #if INSTALLPLAYWRIGHT
                 // Playwright will download and look for browsers to this directory
@@ -66,6 +69,8 @@ public bool SetupEnvironment()
 
                 DisplayContents(Path.Combine(Options.DotnetRoot, "host", "fxr"));
                 DisplayContents(Path.Combine(Options.DotnetRoot, "shared", "Microsoft.NETCore.App"));
+                DisplayContents(Path.Combine(Options.DotnetRoot, "shared", "Microsoft.AspNetCore.App"));
+                DisplayContents(Path.Combine(Options.DotnetRoot, "packs", "Microsoft.AspNetCore.App.Ref"));
 
                 return true;
             }
@@ -116,129 +121,57 @@ public async Task<bool> InstallPlaywrightAsync()
         }
 #endif
 
-        public async Task<bool> InstallAspNetAppIfNeededAsync()
+        public async Task<bool> InstallDotnetToolsAsync()
         {
             try
             {
-                if (File.Exists(Options.AspNetRuntime))
-                {
-                    var appRuntimePath = $"{Options.DotnetRoot}/shared/Microsoft.AspNetCore.App/{Options.RuntimeVersion}";
-                    Console.WriteLine($"Creating directory: {appRuntimePath}");
-                    Directory.CreateDirectory(appRuntimePath);
-                    Console.WriteLine($"Set ASPNET_RUNTIME_PATH: {appRuntimePath}");
-                    EnvironmentVariables.Add("ASPNET_RUNTIME_PATH", appRuntimePath);
-                    Console.WriteLine($"Found AspNetRuntime: {Options.AspNetRuntime}, extracting *.txt,json,dll,xml to {appRuntimePath}");
-                    using (var archive = ZipFile.OpenRead(Options.AspNetRuntime))
-                    {
-                        foreach (var entry in archive.Entries)
-                        {
-                            // These are the only extensions that end up in the shared fx directory
-                            if (entry.Name.EndsWith(".txt", StringComparison.OrdinalIgnoreCase) ||
-                                entry.Name.EndsWith(".json", StringComparison.OrdinalIgnoreCase) ||
-                                entry.Name.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) ||
-                                entry.Name.EndsWith(".xml", StringComparison.OrdinalIgnoreCase))
-                            {
-                                entry.ExtractToFile(Path.Combine(appRuntimePath, entry.Name), overwrite: true);
-                            }
-                        }
-                    }
-
-                    DisplayContents(appRuntimePath);
-
-                    Console.WriteLine($"Adding current directory to nuget sources: {Options.HELIX_WORKITEM_ROOT}");
-
-                    await ProcessUtil.RunAsync($"{Options.DotnetRoot}/dotnet",
-                        $"nuget add source {Options.HELIX_WORKITEM_ROOT} --configfile NuGet.config",
-                        environmentVariables: EnvironmentVariables,
-                        outputDataReceived: Console.WriteLine,
-                        errorDataReceived: Console.Error.WriteLine,
-                        throwOnError: false,
-                        cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token);
-
-                    // Write nuget sources to console, useful for debugging purposes
-                    await ProcessUtil.RunAsync($"{Options.DotnetRoot}/dotnet",
-                        "nuget list source",
-                        environmentVariables: EnvironmentVariables,
-                        outputDataReceived: Console.WriteLine,
-                        errorDataReceived: Console.Error.WriteLine,
-                        throwOnError: false,
-                        cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token);
-
-                    await ProcessUtil.RunAsync($"{Options.DotnetRoot}/dotnet",
-                        $"tool install dotnet-ef --version {Options.EfVersion} --tool-path {Options.HELIX_WORKITEM_ROOT}",
-                        environmentVariables: EnvironmentVariables,
-                        outputDataReceived: Console.WriteLine,
-                        errorDataReceived: Console.Error.WriteLine,
-                        throwOnError: false,
-                        cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token);
+                Console.WriteLine($"Adding current directory to nuget sources: {Options.HELIX_WORKITEM_ROOT}");
 
-                    await ProcessUtil.RunAsync($"{Options.DotnetRoot}/dotnet",
-                        $"tool install dotnet-serve --tool-path {Options.HELIX_WORKITEM_ROOT}",
-                        environmentVariables: EnvironmentVariables,
-                        outputDataReceived: Console.WriteLine,
-                        errorDataReceived: Console.Error.WriteLine,
-                        throwOnError: false,
-                        cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token);
-
-                    // ';' is the path separator on Windows, and ':' on Unix
-                    Options.Path += OperatingSystem.IsWindows() ? ";" : ":";
-                    Options.Path += $"{Environment.GetEnvironmentVariable("DOTNET_CLI_HOME")}/.dotnet/tools";
-                    EnvironmentVariables["PATH"] = Options.Path;
-                }
-                else
-                {
-                    Console.WriteLine($"No AspNetRuntime found: {Options.AspNetRuntime}, skipping...");
-                }
-                return true;
-            }
-            catch (Exception e)
-            {
-                Console.WriteLine($"Exception in InstallAspNetAppIfNeeded: {e.ToString()}");
-                return false;
-            }
-        }
+                await ProcessUtil.RunAsync($"{Options.DotnetRoot}/dotnet",
+                    $"nuget add source {Options.HELIX_WORKITEM_ROOT} --configfile NuGet.config",
+                    environmentVariables: EnvironmentVariables,
+                    outputDataReceived: Console.WriteLine,
+                    errorDataReceived: Console.Error.WriteLine,
+                    throwOnError: false,
+                    cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token);
 
-        public bool InstallAspNetRefIfNeeded()
-        {
-            try
-            {
-                if (File.Exists(Options.AspNetRef))
-                {
-                    var refPath = $"{Options.DotnetRoot}/packs/Microsoft.AspNetCore.App.Ref/{Options.RuntimeVersion}";
-                    Console.WriteLine($"Found AspNetRef: {Options.AspNetRef}, extracting to {refPath}");
-                    ZipFile.ExtractToDirectory(Options.AspNetRef, refPath);
+                // Write nuget sources to console, useful for debugging purposes
+                await ProcessUtil.RunAsync($"{Options.DotnetRoot}/dotnet",
+                    "nuget list source",
+                    environmentVariables: EnvironmentVariables,
+                    outputDataReceived: Console.WriteLine,
+                    errorDataReceived: Console.Error.WriteLine,
+                    throwOnError: false,
+                    cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token);
 
-                    DisplayContents(refPath);
-                }
-                else
-                {
-                    Console.WriteLine($"No AspNetRef found: {Options.AspNetRef}, skipping...");
-                }
-                return true;
-            }
-            catch (Exception e)
-            {
-                Console.WriteLine($"Exception in InstallAspNetRefIfNeeded: {e.ToString()}");
-                return false;
-            }
-        }
+                await ProcessUtil.RunAsync($"{Options.DotnetRoot}/dotnet",
+                    $"tool install dotnet-ef --version {Options.EfVersion} --tool-path {Options.HELIX_WORKITEM_ROOT}",
+                    environmentVariables: EnvironmentVariables,
+                    outputDataReceived: Console.WriteLine,
+                    errorDataReceived: Console.Error.WriteLine,
+                    throwOnError: false,
+                    cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token);
 
-        public async Task<bool> InstallDotnetDump()
-        {
-            try
-            {
                 await ProcessUtil.RunAsync($"{Options.DotnetRoot}/dotnet",
-                            $"tool install dotnet-dump --tool-path {Options.HELIX_WORKITEM_ROOT} --version 5.0.0-*",
-                            environmentVariables: EnvironmentVariables,
-                            outputDataReceived: Console.WriteLine,
-                            errorDataReceived: Console.Error.WriteLine,
-                            throwOnError: false);
+                    $"tool install dotnet-serve --tool-path {Options.HELIX_WORKITEM_ROOT}",
+                    environmentVariables: EnvironmentVariables,
+                    outputDataReceived: Console.WriteLine,
+                    errorDataReceived: Console.Error.WriteLine,
+                    throwOnError: false,
+                    cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token);
+
+                await ProcessUtil.RunAsync($"{Options.DotnetRoot}/dotnet",
+                    $"tool install dotnet-dump --tool-path {Options.HELIX_WORKITEM_ROOT} --version 5.0.0-*",
+                    environmentVariables: EnvironmentVariables,
+                    outputDataReceived: Console.WriteLine,
+                    errorDataReceived: Console.Error.WriteLine,
+                    throwOnError: false);
 
                 return true;
             }
             catch (Exception e)
             {
-                Console.WriteLine($"Exception in InstallDotnetDump: {e}");
+                Console.WriteLine($"Exception in InstallDotnetTools: {e}");
                 return false;
             }
         }

eng/helix/content/runtests.ps1

@@ -1,15 +1,12 @@
 param(
     [string]$Target,
-    [string]$SdkVersion,
-    [string]$RuntimeVersion,
     [string]$AspRuntimeVersion,
     [string]$Queue,
     [string]$Arch,
     [string]$Quarantined,
     [string]$EF,
     [string]$HelixTimeout,
-    [string]$InstallPlaywright,
-    [string]$FeedCred
+    [string]$InstallPlaywright
 )
 
 $env:DOTNET_SKIP_FIRST_TIME_EXPERIENCE = 1
@@ -21,67 +18,6 @@ $env:PLAYWRIGHT_DRIVER_PATH = "$currentDirectory\.playwright\win-x64\native\play
 
 $envPath = "$env:PATH;$env:HELIX_CORRELATION_PAYLOAD\node\bin"
 
-function InvokeInstallDotnet([string]$command) {
-    Write-Host "InstallDotNet $command"
-
-    $timeoutSeconds = 180
-    $proc = Start-Process -filePath powershell.exe -ArgumentList "-noLogo -NoProfile -ExecutionPolicy unrestricted -command `"$command`"" -NoNewWindow -PassThru
-
-    $proc | Wait-Process -Timeout $timeoutSeconds
-    $exitCode = $proc.ExitCode
-
-    if ($exitCode -eq 0) {
-        Write-Host "InstallDotNet $command completed successfully"
-        return $true
-    }
-    elseif ([string]::IsNullOrWhiteSpace($exitCode)) {
-        Write-Warning "InstallDotNet $command timed out after $timeoutSeconds seconds"
-    }
-    else {
-        Write-Warning "InstallDotNet $command failed with exit code $exitCode"
-    }
-
-    $proc | Stop-Process -Force
-
-    return $false
-}
-
-function InstallDotnetSDKAndRuntime([string]$Feed, [string]$FeedCredParam) {
-    foreach ($i in 1..5) {
-        $random = Get-Random -Maximum 1024
-        $env:DOTNET_HOME = Join-Path $currentDirectory "sdk$random"
-        $env:DOTNET_ROOT = Join-Path $env:DOTNET_HOME $Arch
-        $env:DOTNET_CLI_HOME = Join-Path $currentDirectory "home$random"
-        $env:PATH = "$env:DOTNET_ROOT;$envPath"
-
-        Write-Host "Set PATH to: $env:PATH"
-
-        $success = InvokeInstallDotnet ". eng\common\tools.ps1; InstallDotNet $env:DOTNET_ROOT $SdkVersion $Arch `'`' `$true `'$Feed`' `'$FeedCredParam`' `$true"
-        if (!$success) {
-            Write-Host "Retrying..."
-            continue
-        }
-
-        $success = InvokeInstallDotnet ". eng\common\tools.ps1; InstallDotNet $env:DOTNET_ROOT $RuntimeVersion $Arch dotnet `$true `'$Feed`' `'$FeedCredParam`' `$true"
-
-        if (!$success) {
-            Write-Host "Retrying..."
-            continue
-        }
-
-        return
-    }
-
-    Write-Error "InstallDotNet $command exceeded retry limit"
-    exit 1
-}
-
-if ([string]::IsNullOrEmpty($FeedCred)) {
-    InstallDotnetSDKAndRuntime
-} else {
-    InstallDotnetSDKAndRuntime "https://dotnetclimsrc.blob.core.windows.net/dotnet" $FeedCred
-}
-
 Write-Host "Restore: dotnet restore RunTests\RunTests.csproj --ignore-failed-sources"
 dotnet restore RunTests\RunTests.csproj --ignore-failed-sources
 

eng/helix/content/runtests.sh

@@ -1,32 +1,20 @@
 #!/usr/bin/env bash
 
-dotnet_sdk_version="$2"
-dotnet_runtime_version="$3"
-helixQueue="$5"
-installPlaywright="${10}"
+helixQueue="$3"
+installPlaywright="$8"
 
 RESET="\033[0m"
 RED="\033[0;31m"
 YELLOW="\033[0;33m"
 MAGENTA="\033[0;95m"
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 
-# Ensures every invocation of dotnet apps uses the same dotnet.exe
-# Add $random to path to ensure tests don't expect dotnet to be in a particular path
-export DOTNET_ROOT="$DIR/.dotnet$RANDOM"
-
-# Ensure dotnet comes first on PATH
-export PATH="$DOTNET_ROOT:$PATH:$DIR/node/bin"
-
 # Prevent fallback to global .NET locations. This ensures our tests use the shared frameworks we specify and don't rollforward to something else that might be installed on the machine
 export DOTNET_MULTILEVEL_LOOKUP=0
-
-# Avoid contaminating userprofiles
-# Add $random to path to ensure tests don't expect home to be in a particular path
-export DOTNET_CLI_HOME="$DIR/.home$RANDOM"
-
 export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
 
+export PATH="$PATH:$DIR/node/bin"
+
 # Set playwright stuff
 export PLAYWRIGHT_BROWSERS_PATH="$DIR/ms-playwright"
 if [[ "$helixQueue" == *"OSX"* ]]; then
@@ -74,39 +62,6 @@ RED="\033[0;31m"
 YELLOW="\033[0;33m"
 MAGENTA="\033[0;95m"
 
-. eng/common/tools.sh
-
-if [[ -z "${11:-}" ]]; then
-    echo "InstallDotNet $DOTNET_ROOT $dotnet_sdk_version '' '' true"
-    InstallDotNet $DOTNET_ROOT $dotnet_sdk_version "" "" true || {
-      exit_code=$?
-      Write-PipelineTelemetryError -Category 'InitializeToolset' -Message "dotnet-install.sh failed (exit code '$exit_code')." >&2
-      ExitWithExitCode $exit_code
-    }
-    echo
-
-    echo "InstallDotNet $DOTNET_ROOT $dotnet_runtime_version '' dotnet true"
-    InstallDotNet $DOTNET_ROOT $dotnet_runtime_version "" dotnet true || {
-      exit_code=$?
-      Write-PipelineTelemetryError -Category 'InitializeToolset' -Message "dotnet-install.sh failed (exit code '$exit_code')." >&2
-      ExitWithExitCode $exit_code
-    }
-else
-    echo "InstallDotNet $DOTNET_ROOT $dotnet_sdk_version '' '' true https://dotnetclimsrc.blob.core.windows.net/dotnet ..."
-    InstallDotNet $DOTNET_ROOT $dotnet_sdk_version "" "" true https://dotnetclimsrc.blob.core.windows.net/dotnet ${11} || {
-      exit_code=$?
-      Write-PipelineTelemetryError -Category 'InitializeToolset' -Message "dotnet-install.sh failed (exit code '$exit_code')." >&2
-      ExitWithExitCode $exit_code
-    }
-    echo
-
-    echo "InstallDotNet $DOTNET_ROOT $dotnet_runtime_version '' dotnet true https://dotnetclimsrc.blob.core.windows.net/dotnet ..."
-    InstallDotNet $DOTNET_ROOT $dotnet_runtime_version "" dotnet true https://dotnetclimsrc.blob.core.windows.net/dotnet ${11} || {
-      exit_code=$?
-      Write-PipelineTelemetryError -Category 'InitializeToolset' -Message "dotnet-install.sh failed (exit code '$exit_code')." >&2
-      ExitWithExitCode $exit_code
-    }
-fi
 echo
 
 if [ -e /proc/self/coredump_filter ]; then
@@ -121,15 +76,12 @@ sync
 
 exit_code=0
 
-echo "Restore: $DOTNET_ROOT/dotnet restore RunTests/RunTests.csproj --ignore-failed-sources"
-$DOTNET_ROOT/dotnet restore RunTests/RunTests.csproj --ignore-failed-sources
+echo "Restore: dotnet restore RunTests/RunTests.csproj --ignore-failed-sources"
+dotnet restore RunTests/RunTests.csproj --ignore-failed-sources
 
-echo "Running tests: $DOTNET_ROOT/dotnet run --no-restore --project RunTests/RunTests.csproj -- --target $1 --runtime $4 --queue $helixQueue --arch $6 --quarantined $7 --ef $8 --helixTimeout $9"
-$DOTNET_ROOT/dotnet run --no-restore --project RunTests/RunTests.csproj -- --target $1 --runtime $4 --queue $helixQueue --arch $6 --quarantined $7 --ef $8 --helixTimeout $9
+echo "Running tests: dotnet run --no-restore --project RunTests/RunTests.csproj -- --target $1 --runtime $2 --queue $helixQueue --arch $4 --quarantined $5 --ef $6 --helixTimeout $7"
+dotnet run --no-restore --project RunTests/RunTests.csproj -- --target $1 --runtime $2 --queue $helixQueue --arch $4 --quarantined $5 --ef $6 --helixTimeout $7
 exit_code=$?
 echo "Finished tests...exit_code=$exit_code"
 
-# dotnet-install.sh leaves the temporary SDK archive on the helix machine which slowly fills the disk, we'll be nice and clean it until the script fixes the issue
-rm -r -f ${TMPDIR:-/tmp}/dotnet.*
-
 exit $exit_code