Allow watching project graph with multiple roots and no main project

Author: tmat

src/BuiltInTools/Watch.Aspire/DotNetWatchLauncher.cs

@@ -24,15 +24,12 @@ public static async Task<bool> RunAsync(string workingDirectory, DotNetWatchOpti
 
         commandArguments.AddRange(options.ApplicationArguments);
 
-        var rootProjectOptions = new ProjectOptions()
+        var mainProjectOptions = new ProjectOptions()
         {
-            IsRootProject = true,
+            IsMainProject = true,
             Representation = options.Project,
             WorkingDirectory = workingDirectory,
-            TargetFramework = null,
-            BuildArguments = [],
-            NoLaunchProfile = options.NoLaunchProfile,
-            LaunchProfileName = null,
+            LaunchProfileName = options.NoLaunchProfile ? default : null,
             Command = "run",
             CommandArguments = [.. commandArguments],
             LaunchEnvironmentVariables = [],
@@ -59,7 +56,10 @@ public static async Task<bool> RunAsync(string workingDirectory, DotNetWatchOpti
             ProcessRunner = processRunner,
             Options = globalOptions,
             EnvironmentOptions = environmentOptions,
-            RootProjectOptions = rootProjectOptions,
+            MainProjectOptions = mainProjectOptions,
+            RootProjects = [mainProjectOptions.Representation],
+            BuildArguments = [],
+            TargetFramework = null,
             BrowserRefreshServerFactory = new BrowserRefreshServerFactory(),
             BrowserLauncher = new BrowserLauncher(logger, reporter, environmentOptions),
         };

src/BuiltInTools/Watch/Aspire/AspireServiceFactory.cs

@@ -6,12 +6,11 @@
 using System.Globalization;
 using System.Threading.Channels;
 using Aspire.Tools.Service;
-using Microsoft.Build.Graph;
 using Microsoft.Extensions.Logging;
 
 namespace Microsoft.DotNet.Watch;
 
-internal class AspireServiceFactory : IRuntimeProcessLauncherFactory
+internal class AspireServiceFactory(ProjectOptions hostProjectOptions) : IRuntimeProcessLauncherFactory
 {
     internal sealed class SessionManager : IAspireServerEvents, IRuntimeProcessLauncher
     {
@@ -30,8 +29,8 @@ private readonly struct Session(string dcpId, string sessionId, RunningProject r
         };
 
         private readonly ProjectLauncher _projectLauncher;
-        private readonly AspireServerService _service;
         private readonly ProjectOptions _hostProjectOptions;
+        private readonly AspireServerService _service;
         private readonly ILogger _logger;
 
         /// <summary>
@@ -215,23 +214,16 @@ private async Task TerminateSessionAsync(Session session)
         }
 
         private ProjectOptions GetProjectOptions(ProjectLaunchRequest projectLaunchInfo)
-        {
-            var hostLaunchProfile = _hostProjectOptions.NoLaunchProfile ? null : _hostProjectOptions.LaunchProfileName;
-
-            return new()
+            => new()
             {
-                IsRootProject = false,
+                IsMainProject = false,
                 Representation = ProjectRepresentation.FromProjectOrEntryPointFilePath(projectLaunchInfo.ProjectPath),
                 WorkingDirectory = Path.GetDirectoryName(projectLaunchInfo.ProjectPath) ?? throw new InvalidOperationException(),
-                BuildArguments = _hostProjectOptions.BuildArguments,
                 Command = "run",
-                CommandArguments = GetRunCommandArguments(projectLaunchInfo, hostLaunchProfile),
+                CommandArguments = GetRunCommandArguments(projectLaunchInfo, _hostProjectOptions.LaunchProfileName.Value),
                 LaunchEnvironmentVariables = projectLaunchInfo.Environment?.Select(e => (e.Key, e.Value))?.ToArray() ?? [],
-                LaunchProfileName = projectLaunchInfo.LaunchProfile,
-                NoLaunchProfile = projectLaunchInfo.DisableLaunchProfile,
-                TargetFramework = _hostProjectOptions.TargetFramework,
+                LaunchProfileName = projectLaunchInfo.DisableLaunchProfile ? default : projectLaunchInfo.LaunchProfile,
             };
-        }
 
         // internal for testing
         internal static IReadOnlyList<string> GetRunCommandArguments(ProjectLaunchRequest projectLaunchInfo, string? hostLaunchProfile)
@@ -276,13 +268,9 @@ internal static IReadOnlyList<string> GetRunCommandArguments(ProjectLaunchReques
         }
     }
 
-    public static readonly AspireServiceFactory Instance = new();
-
     public const string AspireLogComponentName = "Aspire";
     public const string AppHostProjectCapability = ProjectCapability.Aspire;
 
-    public IRuntimeProcessLauncher? TryCreate(ProjectGraphNode projectNode, ProjectLauncher projectLauncher, ProjectOptions hostProjectOptions)
-        => projectNode.GetCapabilities().Contains(AppHostProjectCapability)
-            ? new SessionManager(projectLauncher, hostProjectOptions)
-            : null;
+    public IRuntimeProcessLauncher Create(ProjectLauncher projectLauncher)
+        => new SessionManager(projectLauncher, hostProjectOptions);
 }

src/BuiltInTools/Watch/Browser/BrowserLauncher.cs

@@ -38,7 +38,7 @@ public void InstallBrowserLaunchTrigger(
 
         WebServerProcessStateObserver.Observe(projectNode, processSpec, url =>
         {
-            if (projectOptions.IsRootProject &&
+            if (projectOptions.IsMainProject &&
                 ImmutableInterlocked.Update(ref _browserLaunchAttempted, static (set, key) => set.Add(key), projectNode.ProjectInstance.GetId()))
             {
                 // first build iteration of a root project:
@@ -127,7 +127,10 @@ private bool CanLaunchBrowser(ProjectOptions projectOptions, [NotNullWhen(true)]
 
     private LaunchSettingsProfile GetLaunchProfile(ProjectOptions projectOptions)
     {
-        return (projectOptions.NoLaunchProfile == true
-            ? null : LaunchSettingsProfile.ReadLaunchProfile(projectOptions.Representation, projectOptions.LaunchProfileName, logger)) ?? new();
+        var profile = projectOptions.LaunchProfileName.HasValue
+            ? LaunchSettingsProfile.ReadLaunchProfile(projectOptions.Representation, projectOptions.LaunchProfileName.Value, logger)
+            : null;
+
+        return profile ?? new();
     }
 }

src/BuiltInTools/Watch/Context/DotNetWatchContext.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.Extensions.Logging;
 
 namespace Microsoft.DotNet.Watch
@@ -18,7 +19,25 @@ internal sealed class DotNetWatchContext : IDisposable
         public required ILoggerFactory LoggerFactory { get; init; }
         public required ProcessRunner ProcessRunner { get; init; }
 
-        public required ProjectOptions RootProjectOptions { get; init; }
+        /// <summary>
+        /// Roots of the project graph to watch.
+        /// </summary>
+        public required ImmutableArray<ProjectRepresentation> RootProjects { get; init; }
+
+        /// <summary>
+        /// Options for launching a main project. If null no main project is being launched.
+        /// </summary>
+        public required ProjectOptions? MainProjectOptions { get; init; }
+
+        /// <summary>
+        /// Default target framework.
+        /// </summary>
+        public required string? TargetFramework { get; init; }
+
+        /// <summary>
+        /// Additional arguments passed to `dotnet build` when building projects.
+        /// </summary>
+        public required IReadOnlyList<string> BuildArguments { get; init; }
 
         public required BrowserRefreshServerFactory BrowserRefreshServerFactory { get; init; }
         public required BrowserLauncher BrowserLauncher { get; init; }

src/BuiltInTools/Watch/Context/ProjectOptions.cs

@@ -5,13 +5,20 @@ namespace Microsoft.DotNet.Watch;
 
 internal sealed record ProjectOptions
 {
-    public required bool IsRootProject { get; init; }
     public required ProjectRepresentation Representation { get; init; }
+
+    /// <summary>
+    /// True if the project has been launched by watch in the main iteration loop.
+    /// </summary>
+    public required bool IsMainProject { get; init; }
+
     public required string WorkingDirectory { get; init; }
-    public required string? TargetFramework { get; init; }
-    public required IReadOnlyList<string> BuildArguments { get; init; }
-    public required bool NoLaunchProfile { get; init; }
-    public required string? LaunchProfileName { get; init; }
+
+    /// <summary>
+    /// No value indicates that no launch profile should be used.
+    /// Null value indicates that the default launch profile should be used.
+    /// </summary>
+    public required Optional<string?> LaunchProfileName { get; init; }
 
     /// <summary>
     /// Command to use to launch the project.

src/BuiltInTools/Watch/FileWatcher/FileWatcher.cs

@@ -21,6 +21,7 @@ internal class FileWatcher(ILogger logger, EnvironmentOptions environmentOptions
         public event Action<ChangedPath>? OnFileChange;
 
         public bool SuppressEvents { get; set; }
+        public DateTime StartTime { get; set; }
 
         public void Dispose()
         {
@@ -205,20 +206,22 @@ void FileChangedCallback(ChangedPath change)
             return change;
         }
 
-        public static async ValueTask WaitForFileChangeAsync(string filePath, ILogger logger, EnvironmentOptions environmentOptions, Action? startedWatching, CancellationToken cancellationToken)
+        public static async ValueTask WaitForFileChangeAsync(IEnumerable<string> filePaths, ILogger logger, EnvironmentOptions environmentOptions, Action? startedWatching, CancellationToken cancellationToken)
         {
             using var watcher = new FileWatcher(logger, environmentOptions);
 
-            watcher.WatchContainingDirectories([filePath], includeSubdirectories: false);
+            watcher.WatchContainingDirectories(filePaths, includeSubdirectories: false);
+
+            var pathSet = filePaths.ToHashSet();
 
             var fileChange = await watcher.WaitForFileChangeAsync(
-                acceptChange: change => change.Path == filePath,
+                acceptChange: change => pathSet.Contains(change.Path),
                 startedWatching,
                 cancellationToken);
 
             if (fileChange != null)
             {
-                logger.LogInformation("File changed: {FilePath}", filePath);
+                logger.LogInformation("File changed: {FilePath}", fileChange.Value.Path);
             }
         }
     }

src/BuiltInTools/Watch/HotReload/CompilationHandler.cs

@@ -27,7 +27,7 @@ internal sealed class CompilationHandler : IDisposable
         private readonly object _runningProjectsAndUpdatesGuard = new();
 
         /// <summary>
-        /// Projects that have been launched and to which we apply changes. 
+        /// Projects that have been launched and to which we apply changes.
         /// </summary>
         private ImmutableDictionary<string, ImmutableArray<RunningProject>> _runningProjects = ImmutableDictionary<string, ImmutableArray<RunningProject>>.Empty;
 
@@ -61,10 +61,10 @@ public void Dispose()
         private ILogger Logger
             => _context.Logger;
 
-        public async ValueTask TerminateNonRootProcessesAndDispose(CancellationToken cancellationToken)
+        public async ValueTask TerminatePeripheralProcessesAndDispose(CancellationToken cancellationToken)
         {
             Logger.LogDebug("Terminating remaining child processes.");
-            await TerminateNonRootProcessesAsync(projectPaths: null, cancellationToken);
+            await TerminatePeripheralProcessesAsync(projectPaths: null, cancellationToken);
             Dispose();
         }
 
@@ -373,7 +373,7 @@ public async ValueTask GetManagedCodeUpdatesAsync(
             // except for the root process, which will terminate later on.
             if (!updates.ProjectsToRestart.IsEmpty)
             {
-                builder.ProjectsToRestart.AddRange(await TerminateNonRootProcessesAsync(updates.ProjectsToRestart.Select(e => currentSolution.GetProject(e.Key)!.FilePath!), cancellationToken));
+                builder.ProjectsToRestart.AddRange(await TerminatePeripheralProcessesAsync(updates.ProjectsToRestart.Select(e => currentSolution.GetProject(e.Key)!.FilePath!), cancellationToken));
             }
         }
 
@@ -802,15 +802,15 @@ public async ValueTask GetStaticAssetUpdatesAsync(
         }
 
         /// <summary>
-        /// Terminates all processes launched for non-root projects with <paramref name="projectPaths"/>,
-        /// or all running non-root project processes if <paramref name="projectPaths"/> is null.
+        /// Terminates all processes launched for peripheral projects with <paramref name="projectPaths"/>,
+        /// or all running peripheral project processes if <paramref name="projectPaths"/> is null.
         /// 
         /// Removes corresponding entries from <see cref="_runningProjects"/>.
         /// 
-        /// Does not terminate the root project.
+        /// Does not terminate the main project.
         /// </summary>
-        /// <returns>All processes (including root) to be restarted.</returns>
-        internal async ValueTask<ImmutableArray<RunningProject>> TerminateNonRootProcessesAsync(
+        /// <returns>All processes (including main) to be restarted.</returns>
+        internal async ValueTask<ImmutableArray<RunningProject>> TerminatePeripheralProcessesAsync(
             IEnumerable<string>? projectPaths, CancellationToken cancellationToken)
         {
             ImmutableArray<RunningProject> projectsToRestart = [];
@@ -825,7 +825,7 @@ internal async ValueTask<ImmutableArray<RunningProject>> TerminateNonRootProcess
             // Do not terminate root process at this time - it would signal the cancellation token we are currently using.
             // The process will be restarted later on.
             // Wait for all processes to exit to release their resources, so we can rebuild.
-            await Task.WhenAll(projectsToRestart.Where(p => !p.Options.IsRootProject).Select(p => p.TerminateForRestartAsync())).WaitAsync(cancellationToken);
+            await Task.WhenAll(projectsToRestart.Where(p => !p.Options.IsMainProject).Select(p => p.TerminateForRestartAsync())).WaitAsync(cancellationToken);
 
             return projectsToRestart;
         }
@@ -884,14 +884,14 @@ private static ImmutableDictionary<string, ImmutableArray<ProjectInstance>> Crea
                     keySelector: static group => group.Key,
                     elementSelector: static group => group.Select(static node => node.ProjectInstance).ToImmutableArray());
 
-        public async Task UpdateProjectConeAsync(ProjectGraph projectGraph, ProjectRepresentation project, CancellationToken cancellationToken)
+        public async Task UpdateProjectGraphAsync(ProjectGraph projectGraph, CancellationToken cancellationToken)
         {
             Logger.LogInformation("Loading projects ...");
             var stopwatch = Stopwatch.StartNew();
 
             _projectInstances = CreateProjectInstanceMap(projectGraph);
 
-            var solution = await Workspace.UpdateProjectConeAsync(project.ProjectGraphPath, cancellationToken);
+            var solution = await Workspace.UpdateProjectGraphAsync([.. projectGraph.EntryPointNodes.Select(n => n.ProjectInstance.FullPath)], cancellationToken);
             await SolutionUpdatedAsync(solution, "project update", cancellationToken);
 
             Logger.LogInformation("Projects loaded in {Time}s.", stopwatch.Elapsed.TotalSeconds.ToString("0.0"));