Auto-restart when project does not support Hot Reload

Author: tmat

src/BuiltInTools/HotReloadClient/DefaultHotReloadClient.cs

@@ -20,7 +20,7 @@
 
 namespace Microsoft.DotNet.HotReload
 {
-    internal sealed class DefaultHotReloadClient(ILogger logger, ILogger agentLogger, string startupHookPath, bool enableStaticAssetUpdates)
+    internal sealed class DefaultHotReloadClient(ILogger logger, ILogger agentLogger, string startupHookPath, bool handlesStaticAssetUpdates)
         : HotReloadClient(logger, agentLogger)
     {
         private readonly string _namedPipeName = Guid.NewGuid().ToString("N");
@@ -225,7 +225,7 @@ static ImmutableArray<RuntimeManagedCodeUpdate> ToRuntimeUpdates(IEnumerable<Hot
 
         public override async Task<Task<bool>> ApplyStaticAssetUpdatesAsync(ImmutableArray<HotReloadStaticAssetUpdate> updates, CancellationToken processExitedCancellationToken, CancellationToken cancellationToken)
         {
-            if (!enableStaticAssetUpdates)
+            if (!handlesStaticAssetUpdates)
             {
                 // The client has no concept of static assets.
                 return Task.FromResult(true);

src/BuiltInTools/HotReloadClient/HotReloadClients.cs

@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
@@ -16,13 +17,25 @@
 
 namespace Microsoft.DotNet.HotReload;
 
-internal sealed class HotReloadClients(ImmutableArray<(HotReloadClient client, string name)> clients, AbstractBrowserRefreshServer? browserRefreshServer) : IDisposable
+/// <summary>
+/// Facilitates Hot Reload updates across multiple clients/processes.
+/// </summary>
+/// <param name="clients">
+/// Clients that handle managed updates and static asset updates if <paramref name="useRefreshServerToApplyStaticAssets"/> is false.
+/// </param>
+/// <param name="browserRefreshServer">
+/// Browser refresh server used to communicate managed code update status and errors to the browser,
+/// and to apply static asset updates if <paramref name="useRefreshServerToApplyStaticAssets"/> is true.
+/// </param>
+/// <param name="useRefreshServerToApplyStaticAssets">
+/// True to use <paramref name="browserRefreshServer"/> to apply static asset updates (if available).
+/// False to use the <paramref name="clients"/> to apply static asset updates.
+/// </param>
+internal sealed class HotReloadClients(
+    ImmutableArray<(HotReloadClient client, string name)> clients,
+    AbstractBrowserRefreshServer? browserRefreshServer,
+    bool useRefreshServerToApplyStaticAssets) : IDisposable
 {
-    public HotReloadClients(HotReloadClient client, AbstractBrowserRefreshServer? browserRefreshServer)
-        : this([(client, "")], browserRefreshServer)
-    {
-    }
-
     /// <summary>
     /// Disposes all clients. Can occur unexpectedly whenever the process exits.
     /// </summary>
@@ -34,6 +47,16 @@ public void Dispose()
         }
     }
 
+    /// <summary>
+    /// True if Hot Reload is implemented via managed agents.
+    /// The update itself might not be managed code update, it may be a static asset update implemented via a managed agent.
+    /// </summary>
+    public bool IsManagedAgentSupported
+        => !clients.IsEmpty;
+
+    public bool UseRefreshServerToApplyStaticAssets
+        => useRefreshServerToApplyStaticAssets;
+
     public AbstractBrowserRefreshServer? BrowserRefreshServer
         => browserRefreshServer;
 
@@ -59,18 +82,6 @@ public event Action<int, string> OnRuntimeRudeEdit
         }
     }
 
-    /// <summary>
-    /// All clients share the same loggers.
-    /// </summary>
-    public ILogger ClientLogger
-        => clients.First().client.Logger;
-
-    /// <summary>
-    /// All clients share the same loggers.
-    /// </summary>
-    public ILogger AgentLogger
-        => clients.First().client.AgentLogger;
-
     internal void ConfigureLaunchEnvironment(IDictionary<string, string> environmentBuilder)
     {
         foreach (var (client, _) in clients)
@@ -99,6 +110,12 @@ internal async ValueTask WaitForConnectionEstablishedAsync(CancellationToken can
     /// <param name="cancellationToken">Cancellation token. The cancellation should trigger on process terminatation.</param>
     public async ValueTask<ImmutableArray<string>> GetUpdateCapabilitiesAsync(CancellationToken cancellationToken)
     {
+        if (!IsManagedAgentSupported)
+        {
+            // empty capabilities will cause rude edit ENC0097: NotSupportedByRuntime.
+            return [];
+        }
+
         if (clients is [var (singleClient, _)])
         {
             return await singleClient.GetUpdateCapabilitiesAsync(cancellationToken);
@@ -114,6 +131,9 @@ public async ValueTask<ImmutableArray<string>> GetUpdateCapabilitiesAsync(Cancel
     /// <param name="cancellationToken">Cancellation token. The cancellation should trigger on process terminatation.</param>
     public async Task<Task> ApplyManagedCodeUpdatesAsync(ImmutableArray<HotReloadManagedCodeUpdate> updates, CancellationToken applyOperationCancellationToken, CancellationToken cancellationToken)
     {
+        // shouldn't be called if there are no clients
+        Debug.Assert(IsManagedAgentSupported);
+
         // Apply to all processes.
         // The module the change is for does not need to be loaded to any of the processes, yet we still consider it successful if the application does not fail.
         // In each process we store the deltas for application when/if the module is loaded to the process later.
@@ -137,6 +157,9 @@ async Task CompleteApplyOperationAsync()
     /// <param name="cancellationToken">Cancellation token. The cancellation should trigger on process terminatation.</param>
     public async ValueTask InitialUpdatesAppliedAsync(CancellationToken cancellationToken)
     {
+        // shouldn't be called if there are no clients
+        Debug.Assert(IsManagedAgentSupported);
+
         if (clients is [var (singleClient, _)])
         {
             await singleClient.InitialUpdatesAppliedAsync(cancellationToken);
@@ -150,23 +173,26 @@ public async ValueTask InitialUpdatesAppliedAsync(CancellationToken cancellation
     /// <param name="cancellationToken">Cancellation token. The cancellation should trigger on process terminatation.</param>
     public async Task<Task> ApplyStaticAssetUpdatesAsync(IEnumerable<StaticWebAsset> assets, CancellationToken applyOperationCancellationToken, CancellationToken cancellationToken)
     {
-        if (browserRefreshServer != null)
+        if (useRefreshServerToApplyStaticAssets)
         {
+            Debug.Assert(browserRefreshServer != null);
             return browserRefreshServer.UpdateStaticAssetsAsync(assets.Select(static a => a.RelativeUrl), applyOperationCancellationToken).AsTask();
         }
 
+        // shouldn't be called if there are no clients
+        Debug.Assert(IsManagedAgentSupported);
+
         var updates = new List<HotReloadStaticAssetUpdate>();
 
         foreach (var asset in assets)
         {
             try
             {
-                ClientLogger.LogDebug("Loading asset '{Url}' from '{Path}'.", asset.RelativeUrl, asset.FilePath);
                 updates.Add(await HotReloadStaticAssetUpdate.CreateAsync(asset, cancellationToken));
             }
             catch (Exception e) when (e is not OperationCanceledException)
             {
-                ClientLogger.LogError("Failed to read file {FilePath}: {Message}", asset.FilePath, e.Message);
+                clients.First().client.Logger.LogError("Failed to read file {FilePath}: {Message}", asset.FilePath, e.Message);
                 continue;
             }
         }
@@ -177,6 +203,10 @@ public async Task<Task> ApplyStaticAssetUpdatesAsync(IEnumerable<StaticWebAsset>
     /// <param name="cancellationToken">Cancellation token. The cancellation should trigger on process terminatation.</param>
     public async ValueTask<Task> ApplyStaticAssetUpdatesAsync(ImmutableArray<HotReloadStaticAssetUpdate> updates, CancellationToken applyOperationCancellationToken, CancellationToken cancellationToken)
     {
+        // shouldn't be called if there are no clients
+        Debug.Assert(IsManagedAgentSupported);
+        Debug.Assert(!useRefreshServerToApplyStaticAssets);
+
         var applyTasks = await Task.WhenAll(clients.Select(c => c.client.ApplyStaticAssetUpdatesAsync(updates, applyOperationCancellationToken, cancellationToken)));
 
         return Task.WhenAll(applyTasks);

src/BuiltInTools/HotReloadClient/StaticAsset.cs

@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+
+namespace Microsoft.DotNet.HotReload;
+
+internal readonly struct StaticAsset(string filePath, string relativeUrl, string assemblyName, bool isApplicationProject)
+{
+    public string FilePath => filePath;
+    public string RelativeUrl => relativeUrl;
+    public string AssemblyName => assemblyName;
+    public bool IsApplicationProject => isApplicationProject;
+}

src/BuiltInTools/Watch/AppModels/BlazorWebAssemblyAppModel.cs

@@ -17,11 +17,11 @@ internal sealed class BlazorWebAssemblyAppModel(DotNetWatchContext context, Proj
 {
     public override ProjectGraphNode LaunchingProject => clientProject;
 
-    public override bool RequiresBrowserRefresh => true;
+    public override bool ManagedHotReloadRequiresBrowserRefresh => true;
 
-    protected override HotReloadClients CreateClients(ILogger clientLogger, ILogger agentLogger, BrowserRefreshServer? browserRefreshServer)
+    protected override ImmutableArray<(HotReloadClient client, string name)> CreateManagedClients(ILogger clientLogger, ILogger agentLogger, BrowserRefreshServer? browserRefreshServer)
     {
         Debug.Assert(browserRefreshServer != null);
-        return new(CreateWebAssemblyClient(clientLogger, agentLogger, browserRefreshServer, clientProject), browserRefreshServer);
+        return [(CreateWebAssemblyClient(clientLogger, agentLogger, browserRefreshServer, clientProject), "")];
     }
 }

src/BuiltInTools/Watch/AppModels/BlazorWebAssemblyHostedAppModel.cs

@@ -19,17 +19,16 @@ internal sealed class BlazorWebAssemblyHostedAppModel(DotNetWatchContext context
 {
     public override ProjectGraphNode LaunchingProject => serverProject;
 
-    public override bool RequiresBrowserRefresh => true;
+    public override bool ManagedHotReloadRequiresBrowserRefresh => true;
 
-    protected override HotReloadClients CreateClients(ILogger clientLogger, ILogger agentLogger, BrowserRefreshServer? browserRefreshServer)
+    protected override ImmutableArray<(HotReloadClient client, string name)> CreateManagedClients(ILogger clientLogger, ILogger agentLogger, BrowserRefreshServer? browserRefreshServer)
     {
         Debug.Assert(browserRefreshServer != null);
 
-        return new(
-            [
-                (CreateWebAssemblyClient(clientLogger, agentLogger, browserRefreshServer, clientProject), "client"),
-                (new DefaultHotReloadClient(clientLogger, agentLogger, GetStartupHookPath(serverProject), enableStaticAssetUpdates: false), "host")
-            ],
-            browserRefreshServer);
+        return
+        [
+            (CreateWebAssemblyClient(clientLogger, agentLogger, browserRefreshServer, clientProject), "client"),
+            (new DefaultHotReloadClient(clientLogger, agentLogger, GetStartupHookPath(serverProject), handlesStaticAssetUpdates: false), "host")
+        ];
     }
 }

src/BuiltInTools/Watch/AppModels/DefaultAppModel.cs

@@ -12,6 +12,11 @@ namespace Microsoft.DotNet.Watch;
 /// </summary>
 internal sealed class DefaultAppModel(ProjectGraphNode project) : HotReloadAppModel
 {
-    public override ValueTask<HotReloadClients?> TryCreateClientsAsync(ILogger clientLogger, ILogger agentLogger, CancellationToken cancellationToken)
-        => new(new HotReloadClients(new DefaultHotReloadClient(clientLogger, agentLogger, GetStartupHookPath(project), enableStaticAssetUpdates: true), browserRefreshServer: null));
+    public override ValueTask<HotReloadClients> CreateClientsAsync(ILogger clientLogger, ILogger agentLogger, CancellationToken cancellationToken)
+        => new(new HotReloadClients(
+            clients: IsManagedAgentSupported(project, clientLogger)
+                ? [(new DefaultHotReloadClient(clientLogger, agentLogger, GetStartupHookPath(project), handlesStaticAssetUpdates: true), "")]
+                : [],
+            browserRefreshServer: null,
+            useRefreshServerToApplyStaticAssets: false));
 }

src/BuiltInTools/Watch/AppModels/HotReloadAppModel.cs

@@ -9,7 +9,7 @@ namespace Microsoft.DotNet.Watch;
 
 internal abstract partial class HotReloadAppModel()
 {
-    public abstract ValueTask<HotReloadClients?> TryCreateClientsAsync(ILogger clientLogger, ILogger agentLogger, CancellationToken cancellationToken);
+    public abstract ValueTask<HotReloadClients> CreateClientsAsync(ILogger clientLogger, ILogger agentLogger, CancellationToken cancellationToken);
 
     protected static string GetInjectedAssemblyPath(string targetFramework, string assemblyName)
         => Path.Combine(Path.GetDirectoryName(typeof(HotReloadAppModel).Assembly.Location)!, "hotreload", targetFramework, assemblyName + ".dll");
@@ -45,4 +45,42 @@ public static HotReloadAppModel InferFromProject(DotNetWatchContext context, Pro
         context.Logger.Log(MessageDescriptor.ApplicationKind_Default);
         return new DefaultAppModel(projectNode);
     }
+
+    /// <summary>
+    /// True if a managed code agent can be injected into the target process.
+    /// The agent is injected either via dotnet startup hook, or via web server middleware for WASM clients.
+    /// </summary>
+    internal static bool IsManagedAgentSupported(ProjectGraphNode project, ILogger logger)
+    {
+        if (!project.IsNetCoreApp(Versions.Version6_0))
+        {
+            LogWarning("target framework is older than 6.0");
+            return false;
+        }
+
+        // If property is not specified startup hook is enabled:
+        // https://github.com/dotnet/runtime/blob/4b0b7238ba021b610d3963313b4471517108d2bc/src/libraries/System.Private.CoreLib/src/System/StartupHookProvider.cs#L22
+        // Startup hooks are not used for WASM projects.
+        //
+        // TODO: Remove once implemented: https://github.com/dotnet/runtime/issues/123778
+        if (!project.ProjectInstance.GetBooleanPropertyValue(PropertyNames.StartupHookSupport, defaultValue: true) &&
+            !project.GetCapabilities().Contains(ProjectCapability.WebAssembly))
+        {
+            // Report which property is causing lack of support for startup hooks:
+            var (propertyName, propertyValue) =
+                project.ProjectInstance.GetBooleanPropertyValue(PropertyNames.PublishAot)
+                ? (PropertyNames.PublishAot, true)
+                : project.ProjectInstance.GetBooleanPropertyValue(PropertyNames.PublishTrimmed)
+                ? (PropertyNames.PublishTrimmed, true)
+                : (PropertyNames.StartupHookSupport, false);
+
+            LogWarning(string.Format("'{0}' property is '{1}'", propertyName, propertyValue));
+            return false;
+        }
+
+        return true;
+
+        void LogWarning(string reason)
+            => logger.Log(MessageDescriptor.ProjectDoesNotSupportHotReload, reason);
+    }
 }

src/BuiltInTools/Watch/AppModels/WebApplicationAppModel.cs

@@ -16,25 +16,24 @@ internal abstract class WebApplicationAppModel(DotNetWatchContext context) : Hot
 
     public DotNetWatchContext Context => context;
 
-    public abstract bool RequiresBrowserRefresh { get; }
+    public abstract bool ManagedHotReloadRequiresBrowserRefresh { get; }
 
     /// <summary>
     /// Project that's used for launching the application.
     /// </summary>
     public abstract ProjectGraphNode LaunchingProject { get; }
 
-    protected abstract HotReloadClients CreateClients(ILogger clientLogger, ILogger agentLogger, BrowserRefreshServer? browserRefreshServer);
+    protected abstract ImmutableArray<(HotReloadClient client, string name)> CreateManagedClients(ILogger clientLogger, ILogger agentLogger, BrowserRefreshServer? browserRefreshServer);
 
-    public async sealed override ValueTask<HotReloadClients?> TryCreateClientsAsync(ILogger clientLogger, ILogger agentLogger, CancellationToken cancellationToken)
+    public async sealed override ValueTask<HotReloadClients> CreateClientsAsync(ILogger clientLogger, ILogger agentLogger, CancellationToken cancellationToken)
     {
         var browserRefreshServer = await context.BrowserRefreshServerFactory.GetOrCreateBrowserRefreshServerAsync(LaunchingProject, this, cancellationToken);
-        if (RequiresBrowserRefresh && browserRefreshServer == null)
-        {
-            // Error has been reported
-            return null;
-        }
 
-        return CreateClients(clientLogger, agentLogger, browserRefreshServer);
+        var managedClients = (!ManagedHotReloadRequiresBrowserRefresh || browserRefreshServer != null) && IsManagedAgentSupported(LaunchingProject, clientLogger)
+            ? CreateManagedClients(clientLogger, agentLogger, browserRefreshServer)
+            : [];
+
+        return new HotReloadClients(managedClients, browserRefreshServer, useRefreshServerToApplyStaticAssets: true);
     }
 
     protected WebAssemblyHotReloadClient CreateWebAssemblyClient(ILogger clientLogger, ILogger agentLogger, BrowserRefreshServer browserRefreshServer, ProjectGraphNode clientProject)
@@ -71,13 +70,29 @@ public bool IsServerSupported(ProjectGraphNode projectNode, ILogger logger)
     {
         if (context.EnvironmentOptions.SuppressBrowserRefresh)
         {
-            logger.Log(MessageDescriptor.SkippingConfiguringBrowserRefresh_SuppressedViaEnvironmentVariable.WithLevelWhen(LogLevel.Error, RequiresBrowserRefresh), EnvironmentVariables.Names.SuppressBrowserRefresh);
+            if (ManagedHotReloadRequiresBrowserRefresh)
+            {
+                logger.Log(MessageDescriptor.BrowserRefreshSuppressedViaEnvironmentVariable_ApplicationWillBeRestarted, EnvironmentVariables.Names.SuppressBrowserRefresh);
+            }
+            else
+            {
+                logger.Log(MessageDescriptor.BrowserRefreshSuppressedViaEnvironmentVariable_ManualRefreshRequired, EnvironmentVariables.Names.SuppressBrowserRefresh);
+            }
+
             return false;
         }
 
         if (!projectNode.IsNetCoreApp(minVersion: s_minimumSupportedVersion))
         {
-            logger.Log(MessageDescriptor.SkippingConfiguringBrowserRefresh_TargetFrameworkNotSupported.WithLevelWhen(LogLevel.Error, RequiresBrowserRefresh));
+            if (ManagedHotReloadRequiresBrowserRefresh)
+            {
+                logger.Log(MessageDescriptor.BrowserRefreshNotSupportedByProjectTargetFramework_ApplicationWillBeRestarted);
+            }
+            else
+            {
+                logger.Log(MessageDescriptor.BrowserRefreshNotSupportedByProjectTargetFramework_ManualRefreshRequired);
+            }
+
             return false;
         }
 

src/BuiltInTools/Watch/AppModels/WebServerAppModel.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Immutable;
 using Microsoft.Build.Graph;
 using Microsoft.DotNet.HotReload;
 using Microsoft.Extensions.Logging;
@@ -12,9 +13,9 @@ internal sealed class WebServerAppModel(DotNetWatchContext context, ProjectGraph
 {
     public override ProjectGraphNode LaunchingProject => serverProject;
 
-    public override bool RequiresBrowserRefresh
+    public override bool ManagedHotReloadRequiresBrowserRefresh
         => false;
 
-    protected override HotReloadClients CreateClients(ILogger clientLogger, ILogger agentLogger, BrowserRefreshServer? browserRefreshServer)
-        => new(new DefaultHotReloadClient(clientLogger, agentLogger, GetStartupHookPath(serverProject), enableStaticAssetUpdates: true), browserRefreshServer);
+    protected override ImmutableArray<(HotReloadClient client, string name)> CreateManagedClients(ILogger clientLogger, ILogger agentLogger, BrowserRefreshServer? browserRefreshServer)
+        => [(new DefaultHotReloadClient(clientLogger, agentLogger, GetStartupHookPath(serverProject), handlesStaticAssetUpdates: true), "")];
 }