[release/9.0] Revert change to follow symlinks of dotnet host

NuGet.config

@@ -9,7 +9,7 @@
     <clear />
     <!--Begin: Package sources managed by Dependency Flow automation. Do not edit the sources below.-->
     <!--  Begin: Package sources from dotnet-emsdk -->
-    <add key="darc-pub-dotnet-emsdk-78f6f07" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/darc-pub-dotnet-emsdk-78f6f07d/nuget/v3/index.json" />
+    <add key="darc-pub-dotnet-emsdk-e3d8e8e" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/darc-pub-dotnet-emsdk-e3d8e8ea/nuget/v3/index.json" />
     <!--  End: Package sources from dotnet-emsdk -->
     <!--  Begin: Package sources from dotnet-sdk -->
     <add key="darc-pub-dotnet-sdk-b562a30" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/darc-pub-dotnet-sdk-b562a300/nuget/v3/index.json" />

eng/Version.Details.xml

@@ -64,18 +64,18 @@
       <Sha>6aaf3af113593a4c993854bff4141bbc73061ea5</Sha>
       <SourceBuild RepoName="cecil" ManagedOnly="true" />
     </Dependency>
-    <Dependency Name="Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport" Version="9.0.5-servicing.25212.1">
+    <Dependency Name="Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport" Version="9.0.6-servicing.25258.2">
       <Uri>https://github.com/dotnet/emsdk</Uri>
-      <Sha>78f6f07d38e8755e573039a8aa04e131d3e59b76</Sha>
+      <Sha>e3d8e8ea6df192d864698cdd76984d74135d0d13</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100" Version="9.0.5">
+    <Dependency Name="Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100" Version="9.0.6">
       <Uri>https://github.com/dotnet/emsdk</Uri>
-      <Sha>78f6f07d38e8755e573039a8aa04e131d3e59b76</Sha>
+      <Sha>e3d8e8ea6df192d864698cdd76984d74135d0d13</Sha>
     </Dependency>
     <!-- Intermediate is necessary for source build. -->
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.emsdk" Version="9.0.5-servicing.25212.1">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.emsdk" Version="9.0.6-servicing.25258.2">
       <Uri>https://github.com/dotnet/emsdk</Uri>
-      <Sha>78f6f07d38e8755e573039a8aa04e131d3e59b76</Sha>
+      <Sha>e3d8e8ea6df192d864698cdd76984d74135d0d13</Sha>
       <SourceBuild RepoName="emsdk" ManagedOnly="true" />
     </Dependency>
     <!-- Intermediate is necessary for source build. -->

eng/Versions.props

@@ -1,11 +1,11 @@
 <Project>
   <PropertyGroup>
     <!-- The .NET product branding version -->
-    <ProductVersion>9.0.5</ProductVersion>
+    <ProductVersion>9.0.6</ProductVersion>
     <!-- File version numbers -->
     <MajorVersion>9</MajorVersion>
     <MinorVersion>0</MinorVersion>
-    <PatchVersion>5</PatchVersion>
+    <PatchVersion>6</PatchVersion>
     <SdkBandVersion>9.0.100</SdkBandVersion>
     <PackageVersionNet8>8.0.$([MSBuild]::Add($(PatchVersion),11))</PackageVersionNet8>
     <PackageVersionNet7>7.0.20</PackageVersionNet7>
@@ -243,8 +243,8 @@
          Note: when the name is updated, make sure to update dependency name in eng/pipelines/common/xplat-setup.yml
                like - DarcDependenciesChanged.Microsoft_NET_Workload_Emscripten_Current_Manifest-9_0_100_Transport
     -->
-    <MicrosoftNETWorkloadEmscriptenCurrentManifest90100TransportVersion>9.0.5-servicing.25212.1</MicrosoftNETWorkloadEmscriptenCurrentManifest90100TransportVersion>
-    <MicrosoftNETWorkloadEmscriptenCurrentManifest90100Version>9.0.5</MicrosoftNETWorkloadEmscriptenCurrentManifest90100Version>
+    <MicrosoftNETWorkloadEmscriptenCurrentManifest90100TransportVersion>9.0.6-servicing.25258.2</MicrosoftNETWorkloadEmscriptenCurrentManifest90100TransportVersion>
+    <MicrosoftNETWorkloadEmscriptenCurrentManifest90100Version>9.0.6</MicrosoftNETWorkloadEmscriptenCurrentManifest90100Version>
     <MicrosoftNETRuntimeEmscriptenVersion>$(MicrosoftNETWorkloadEmscriptenCurrentManifest90100Version)</MicrosoftNETRuntimeEmscriptenVersion>
     <!-- workloads -->
     <SwixPackageVersion>1.1.87-gba258badda</SwixPackageVersion>

eng/pipelines/common/macos-sign-with-entitlements.yml

@@ -30,12 +30,13 @@ steps:
   - task: EsrpCodeSigning@5
     displayName: 'ESRP CodeSigning'
     inputs:
-      ConnectedServiceName: 'DotNet-Engineering-Services_KeyVault'
-      AppRegistrationClientId: '28ec6507-2167-4eaa-a294-34408cf5dd0e'
-      AppRegistrationTenantId: '72f988bf-86f1-41af-91ab-2d7cd011db47'
-      AuthAKVName: 'EngKeyVault'
-      AuthCertName: 'DotNetCore-ESRP-AuthCert'
-      AuthSignCertName: 'DotNetCore-ESRP-AuthSignCert'
+      ConnectedServiceName: 'DotNetBuildESRP'
+      UseMSIAuthentication: true
+      EsrpClientId: '28ec6507-2167-4eaa-a294-34408cf5dd0e'
+      AppRegistrationClientId: '0ecbcdb7-8451-4cbe-940a-4ed97b08b955'
+      AppRegistrationTenantId: '975f013f-7f24-47e8-a7d3-abc4752bf346'
+      AuthAKVName: 'DotNetEngKeyVault'
+      AuthSignCertName: 'DotNet-ESRP-AuthSignCert'
       FolderPath: '$(Build.ArtifactStagingDirectory)/'
       Pattern: 'mac_entitled_to_sign.zip'
       UseMinimatch: true

src/installer/tests/HostActivation.Tests/SymbolicLinks.cs

@@ -2,8 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Build.Framework;
@@ -21,6 +23,166 @@ public SymbolicLinks(SymbolicLinks.SharedTestState fixture)
             sharedTestState = fixture;
         }
 
+        [Theory]
+        [InlineData("a/b/SymlinkToFrameworkDependentApp")]
+        [InlineData("a/SymlinkToFrameworkDependentApp")]
+        public void Symlink_all_files_fx(string symlinkRelativePath)
+        {
+            using var testDir = TestArtifact.Create("symlink");
+            Directory.CreateDirectory(Path.Combine(testDir.Location, Path.GetDirectoryName(symlinkRelativePath)));
+
+            // Symlink every file in the app directory
+            var symlinks = new List<SymLink>();
+            try
+            {
+                foreach (var file in Directory.EnumerateFiles(sharedTestState.FrameworkDependentApp.Location))
+                {
+                    var fileName = Path.GetFileName(file);
+                    var symlinkPath = Path.Combine(testDir.Location, symlinkRelativePath, fileName);
+                    Directory.CreateDirectory(Path.GetDirectoryName(symlinkPath));
+                    symlinks.Add(new SymLink(symlinkPath, file));
+                }
+
+                var result = Command.Create(Path.Combine(testDir.Location, symlinkRelativePath, Path.GetFileName(sharedTestState.FrameworkDependentApp.AppExe)))
+                    .CaptureStdErr()
+                    .CaptureStdOut()
+                    .DotNetRoot(TestContext.BuiltDotNet.BinPath)
+                    .Execute();
+
+                // This should succeed on all platforms, but for different reasons:
+                // * Windows: The apphost will look next to the symlink for the app dll and find the symlinked dll
+                // * Unix: The apphost will look next to the resolved apphost for the app dll and find the real thing
+                result
+                    .Should().Pass()
+                    .And.HaveStdOutContaining("Hello World");
+            }
+            finally
+            {
+                foreach (var symlink in symlinks)
+                {
+                    symlink.Dispose();
+                }
+            }
+        }
+
+        [Theory]
+        [InlineData("a/b/SymlinkToFrameworkDependentApp")]
+        [InlineData("a/SymlinkToFrameworkDependentApp")]
+        public void Symlink_split_files_fx(string symlinkRelativePath)
+        {
+            using var testDir = TestArtifact.Create("symlink");
+
+            // Split the app into two directories, one for the apphost and one for the rest of the files
+            var appHostDir = Path.Combine(testDir.Location, "apphost");
+            var appFilesDir = Path.Combine(testDir.Location, "appfiles");
+            Directory.CreateDirectory(appHostDir);
+            Directory.CreateDirectory(appFilesDir);
+
+            var appHostName = Path.GetFileName(sharedTestState.FrameworkDependentApp.AppExe);
+
+            File.Copy(
+                sharedTestState.FrameworkDependentApp.AppExe,
+                Path.Combine(appHostDir, appHostName));
+
+            foreach (var file in Directory.EnumerateFiles(sharedTestState.FrameworkDependentApp.Location))
+            {
+                var fileName = Path.GetFileName(file);
+                if (fileName != appHostName)
+                {
+                    File.Copy(file, Path.Combine(appFilesDir, fileName));
+                }
+            }
+
+            // Symlink all of the above into a single directory
+            var targetPath = Path.Combine(testDir.Location, symlinkRelativePath);
+            Directory.CreateDirectory(targetPath);
+            var symlinks = new List<SymLink>();
+            try
+            {
+                foreach (var file in Directory.EnumerateFiles(appFilesDir))
+                {
+                    var fileName = Path.GetFileName(file);
+                    var symlinkPath = Path.Combine(targetPath, fileName);
+                    Directory.CreateDirectory(Path.GetDirectoryName(symlinkPath));
+                    symlinks.Add(new SymLink(symlinkPath, file));
+                }
+                symlinks.Add(new SymLink(
+                    Path.Combine(targetPath, appHostName),
+                    Path.Combine(appHostDir, appHostName)));
+
+                Console.ReadLine();
+                var result = Command.Create(Path.Combine(targetPath, appHostName))
+                    .CaptureStdErr()
+                    .CaptureStdOut()
+                    .DotNetRoot(TestContext.BuiltDotNet.BinPath)
+                    .Execute();
+
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    // On Windows, the apphost will look next to the symlink for the app dll and find the symlinks
+                    result
+                        .Should().Pass()
+                        .And.HaveStdOutContaining("Hello World");
+                }
+                else
+                {
+                    // On Unix, the apphost will not find the app files next to the symlink
+                    result
+                        .Should().Fail()
+                        .And.HaveStdErrContaining("The application to execute does not exist");
+                }
+            }
+            finally
+            {
+                foreach (var symlink in symlinks)
+                {
+                    symlink.Dispose();
+                }
+            }
+        }
+
+        [Theory]
+        [InlineData("a/b/SymlinkToFrameworkDependentApp")]
+        [InlineData("a/SymlinkToFrameworkDependentApp")]
+        public void Symlink_all_files_self_contained(string symlinkRelativePath)
+        {
+            using var testDir = TestArtifact.Create("symlink");
+            Directory.CreateDirectory(Path.Combine(testDir.Location, Path.GetDirectoryName(symlinkRelativePath)));
+
+            // Symlink every file in the app directory
+            var symlinks = new List<SymLink>();
+            try
+            {
+                foreach (var file in Directory.EnumerateFiles(sharedTestState.SelfContainedApp.Location))
+                {
+                    var fileName = Path.GetFileName(file);
+                    var symlinkPath = Path.Combine(testDir.Location, symlinkRelativePath, fileName);
+                    Directory.CreateDirectory(Path.GetDirectoryName(symlinkPath));
+                    symlinks.Add(new SymLink(symlinkPath, file));
+                }
+
+                var result = Command.Create(Path.Combine(testDir.Location, symlinkRelativePath, Path.GetFileName(sharedTestState.FrameworkDependentApp.AppExe)))
+                    .CaptureStdErr()
+                    .CaptureStdOut()
+                    .DotNetRoot(TestContext.BuiltDotNet.BinPath)
+                    .Execute();
+
+                // This should succeed on all platforms, but for different reasons:
+                // * Windows: The apphost will look next to the symlink for the files and find the symlinks
+                // * Unix: The apphost will look next to the resolved apphost for the files and find the real thing
+                result
+                    .Should().Pass()
+                    .And.HaveStdOutContaining("Hello World");
+            }
+            finally
+            {
+                foreach (var symlink in symlinks)
+                {
+                    symlink.Dispose();
+                }
+            }
+        }
+
         [Theory]
         [InlineData ("a/b/SymlinkToApphost")]
         [InlineData ("a/SymlinkToApphost")]
@@ -33,12 +195,23 @@ public void Run_apphost_behind_symlink(string symlinkRelativePath)
                 var symlinkFullPath = Path.Combine(testDir.Location, symlinkRelativePath);
 
                 using var symlink = new SymLink(symlinkFullPath, sharedTestState.SelfContainedApp.AppExe);
-                Command.Create(symlinkFullPath)
+                var result = Command.Create(symlinkFullPath)
                     .CaptureStdErr()
                     .CaptureStdOut()
-                    .Execute()
-                    .Should().Pass()
-                    .And.HaveStdOutContaining("Hello World");
+                    .Execute();
+
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    result
+                        .Should().Fail()
+                        .And.HaveStdErrContaining("The application to execute does not exist");
+                }
+                else
+                {
+                    result
+                        .Should().Pass()
+                        .And.HaveStdOutContaining("Hello World");
+                }
             }
         }
 
@@ -63,12 +236,23 @@ public void Run_apphost_behind_transitive_symlinks(string firstSymlinkRelativePa
                 Directory.CreateDirectory(Path.GetDirectoryName(symlink1Path));
                 using var symlink1 = new SymLink(symlink1Path, symlink2Path);
 
-                Command.Create(symlink1.SrcPath)
+                var result = Command.Create(symlink1.SrcPath)
                     .CaptureStdErr()
                     .CaptureStdOut()
-                    .Execute()
-                    .Should().Pass()
-                    .And.HaveStdOutContaining("Hello World");
+                    .Execute();
+
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    result
+                        .Should().Fail()
+                        .And.HaveStdErrContaining("The application to execute does not exist");
+                }
+                else
+                {
+                    result
+                        .Should().Pass()
+                        .And.HaveStdOutContaining("Hello World");
+                }
             }
         }
 
@@ -86,13 +270,24 @@ public void Run_framework_dependent_app_behind_symlink(string symlinkRelativePat
                 Directory.CreateDirectory(Path.Combine(testDir.Location, Path.GetDirectoryName(symlinkRelativePath)));
 
                 using var symlink = new SymLink(Path.Combine(testDir.Location, symlinkRelativePath), sharedTestState.FrameworkDependentApp.AppExe);
-                Command.Create(symlink.SrcPath)
+                var result = Command.Create(symlink.SrcPath)
                     .CaptureStdErr()
                     .CaptureStdOut()
                     .DotNetRoot(TestContext.BuiltDotNet.BinPath)
-                    .Execute()
-                    .Should().Pass()
-                    .And.HaveStdOutContaining("Hello World");
+                    .Execute();
+
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    result
+                        .Should().Fail()
+                        .And.HaveStdErrContaining("The application to execute does not exist");
+                }
+                else
+                {
+                    result
+                        .Should().Pass()
+                        .And.HaveStdOutContaining("Hello World");
+                }
             }
         }
 
@@ -144,12 +339,23 @@ public void Put_dotnet_behind_symlink()
                 var dotnetSymlink = Path.Combine(testDir.Location, Binaries.DotNet.FileName);
 
                 using var symlink = new SymLink(dotnetSymlink, TestContext.BuiltDotNet.DotnetExecutablePath);
-                Command.Create(symlink.SrcPath, sharedTestState.SelfContainedApp.AppDll)
+                var result = Command.Create(symlink.SrcPath, sharedTestState.SelfContainedApp.AppDll)
                     .CaptureStdErr()
                     .CaptureStdOut()
-                    .Execute()
-                    .Should().Pass()
-                    .And.HaveStdOutContaining("Hello World");
+                    .Execute();
+
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    result
+                        .Should().Fail()
+                        .And.HaveStdErrContaining($"[{Path.Combine(testDir.Location, "host", "fxr")}] does not exist");
+                }
+                else
+                {
+                    result
+                        .Should().Pass()
+                        .And.HaveStdOutContaining("Hello World");
+                }
             }
         }