Separate project-system-tools into a frontend and backend structure

src/Directory.Build.props

@@ -10,5 +10,7 @@
     <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
     <VSSDKTargetPlatformRegRootSuffix Condition="'$(RootSuffix)' != ''">$(RootSuffix)</VSSDKTargetPlatformRegRootSuffix>
     <VSSDKTargetPlatformRegRootSuffix Condition="'$(VSSDKTargetPlatformRegRootSuffix)' == ''">Exp</VSSDKTargetPlatformRegRootSuffix>
+    <!-- Workaround: https://github.com/dotnet/sdk/issues/12739 -->
+    <ImportFrameworkWinFXTargets>true</ImportFrameworkWinFXTargets>
   </PropertyGroup>
 </Project>

src/LogProviders/BuildLoggerProvider.cs

@@ -17,12 +17,12 @@ namespace Microsoft.VisualStudio.ProjectSystem.Tools.Providers
     [Export(typeof(IVsBuildLoggerProvider))]
     internal sealed class BuildLoggerProvider : IBuildLoggerProviderAsync, IVsBuildLoggerProvider
     {
-        private readonly IBuildTableDataSource _dataSource;
+        private readonly ILoggingController _loggingController;
 
         [ImportingConstructor]
-        public BuildLoggerProvider(IBuildTableDataSource dataSource)
+        public BuildLoggerProvider(ILoggingController loggingController)
         {
-            _dataSource = dataSource;
+            _loggingController = loggingController;
         }
 
         public LoggerVerbosity Verbosity => LoggerVerbosity.Diagnostic;
@@ -47,18 +47,18 @@ public BuildLoggerProvider(IBuildTableDataSource dataSource)
             BuildLoggerEvents.CustomEvent;
 
         public ILogger GetLogger(string projectPath, IEnumerable<string> targets, IDictionary<string, string> properties, bool isDesignTimeBuild) => 
-            _dataSource.IsLogging ? _dataSource.CreateLogger(isDesignTimeBuild) : null;
+            _loggingController.IsLogging ? _loggingController.CreateLogger(isDesignTimeBuild) : null;
 
         public Task<IImmutableSet<ILogger>> GetLoggersAsync(IReadOnlyList<string> targets, IImmutableDictionary<string, string> properties, CancellationToken cancellationToken)
         {
             var loggers = (IImmutableSet<ILogger>)ImmutableHashSet<ILogger>.Empty;
 
-            if (_dataSource.IsLogging)
+            if (_loggingController.IsLogging)
             {
                 var isDesignTime = properties.TryGetValue("DesignTimeBuild", out var value) &&
                    string.Equals(value, "true", StringComparison.OrdinalIgnoreCase);
 
-                loggers = loggers.Add(_dataSource.CreateLogger(isDesignTime));
+                loggers = loggers.Add(_loggingController.CreateLogger(isDesignTime));
             }
 
             return Task.FromResult(loggers);

src/LogProviders/ILoggingController.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using Microsoft.Build.Framework;
+
+namespace Microsoft.VisualStudio.ProjectSystem.Tools.Providers
+{
+    public interface ILoggingController
+    {
+        /// <summary>
+        /// Is this logging controller currently collecting logs?
+        /// true if yes, false if no.
+        /// </summary>
+        bool IsLogging { get; }
+
+        /// <summary>
+        /// Creates a new logger to collect builds and their logs
+        /// </summary>
+        /// <param name="isDesignTime">Is this for DesignTime build logging?</param>
+        /// <returns>Return newly created logger</returns>
+        ILogger CreateLogger(bool isDesignTime);
+    }
+}

src/ProjectSystemTools/BuildLogging/BuildLoggingToolWindow.cs

@@ -11,7 +11,7 @@
 using Microsoft.VisualStudio.OLE.Interop;
 using Microsoft.VisualStudio.PlatformUI;
 using Microsoft.VisualStudio.ProjectSystem.Tools.BuildLogging.Model;
-using Microsoft.VisualStudio.ProjectSystem.Tools.Providers;
+using Microsoft.VisualStudio.ProjectSystem.Tools.BuildLogging.Model.FrontEnd;
 using Microsoft.VisualStudio.ProjectSystem.Tools.TableControl;
 using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Shell.TableControl;
@@ -27,7 +27,7 @@ internal sealed class BuildLoggingToolWindow : TableToolWindow
         public const string BuildLogging = "BuildLogging";
         public const string BuildLoggingToolWindowGuidString = "391238ea-dad7-488c-94d1-e2b6b5172bf3";
 
-        private readonly IBuildTableDataSource _dataSource;
+        private readonly IFrontEndBuildTableDataSource _dataSource;
         private readonly IVsUIShellOpenDocument _openDocument;
 
         private BuildType _filterType = BuildType.All;
@@ -43,7 +43,7 @@ internal sealed class BuildLoggingToolWindow : TableToolWindow
         public BuildLoggingToolWindow()
         {
             var componentModel = (IComponentModel)GetService(typeof(SComponentModel));
-            _dataSource = componentModel.GetService<IBuildTableDataSource>();
+            _dataSource = componentModel.GetService<IFrontEndBuildTableDataSource>();
 
             _openDocument = (IVsUIShellOpenDocument)GetService(typeof(SVsUIShellOpenDocument));
 
@@ -194,11 +194,12 @@ private void SaveLogs()
 
             foreach (var entry in TableControl.SelectedEntries)
             {
-                if (!entry.TryGetValue(TableKeyNames.LogPath, out string logPath))
+                if (!entry.TryGetValue(TableKeyNames.BuildID, out int buildID))
                 {
                     continue;
                 }
 
+                string logPath = _dataSource.GetLogForBuild(buildID);
                 var filename = Path.GetFileName(logPath);
 
                 if (filename == null)
@@ -246,12 +247,13 @@ private void OpenLogs()
 
         public void OpenLog(ITableEntryHandle tableEntry)
         {
-            if (!tableEntry.TryGetValue(TableKeyNames.LogPath, out string logPath))
+            if (!tableEntry.TryGetValue(TableKeyNames.BuildID, out int buildID))
             {
                 return;
             }
 
             var guid = VSConstants.LOGVIEWID_Primary;
+            string logPath = _dataSource.GetLogForBuild(buildID);
             _openDocument.OpenDocumentViaProject(logPath, ref guid, out _, out _, out _, out var frame);
             frame?.Show();
         }
@@ -260,11 +262,12 @@ private void OpenLogsExternal()
         {
             foreach (var entry in TableControl.SelectedEntries)
             {
-                if (!entry.TryGetValue(TableKeyNames.LogPath, out string logPath))
+                if (!entry.TryGetValue(TableKeyNames.BuildID, out int buildID))
                 {
                     continue;
                 }
 
+                string logPath = _dataSource.GetLogForBuild(buildID);
                 try
                 {
                     Process.Start(logPath);
@@ -301,7 +304,6 @@ protected override int InnerQueryStatus(ref Guid commandGroupGuid, uint commandC
             var enabled = false;
             var visible = false;
             var latched = false;
-
             switch (cmd.cmdID)
             {
                 case ProjectSystemToolsPackage.StartLoggingCommandId:
@@ -350,7 +352,7 @@ protected override int InnerQueryStatus(ref Guid commandGroupGuid, uint commandC
         }
 
         private string[] GetBuildFilterComboItems() =>
-            (_dataSource as BuildTableDataSource)?.SupportRoslynLogging ?? false
+            (_dataSource as FrontEndBuildTableDataSource)?.SupportRoslynLogging ?? false
                 ? new[]
                 {
                     BuildLoggingResources.FilterBuildAll, BuildLoggingResources.FilterBuildEvaluations,
@@ -380,10 +382,12 @@ protected override int InnerExec(ref Guid commandGroupGuid, uint commandId, uint
             {
                 case ProjectSystemToolsPackage.StartLoggingCommandId:
                     _dataSource.Start();
+
                     break;
 
                 case ProjectSystemToolsPackage.StopLoggingCommandId:
                     _dataSource.Stop();
+
                     break;
 
                 case ProjectSystemToolsPackage.ClearCommandId:

src/ProjectSystemTools/BuildLogging/Model/Backend/BackendBuildTableDataSource.cs

@@ -0,0 +1,102 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Immutable;
+using System.ComponentModel.Composition;
+using System.Linq;
+using Microsoft.Build.Evaluation;
+using Microsoft.Build.Framework;
+using Microsoft.VisualStudio.ProjectSystem.Tools.Providers;
+
+namespace Microsoft.VisualStudio.ProjectSystem.Tools.BuildLogging.Model.BackEnd
+{
+    [Export(typeof(ILoggingController))]
+    [Export(typeof(ILoggingDataSource))]
+    internal sealed class BackEndBuildTableDataSource : ILoggingController, ILoggingDataSource
+    {
+        private const string BuildDataSourceDisplayName = "Build Data Source";
+        private const string BuildTableDataSourceIdentifier = nameof(BuildTableDataSourceIdentifier);
+        private const string BuildTableDataSourceSourceTypeIdentifier = nameof(BuildTableDataSourceSourceTypeIdentifier);
+
+        private readonly EvaluationLogger _evaluationLogger;
+        private readonly RoslynLogger _roslynLogger;
+
+        private ImmutableList<Build> _entries = ImmutableList<Build>.Empty;
+
+        public string SourceTypeIdentifier => BuildTableDataSourceSourceTypeIdentifier;
+
+        public string Identifier => BuildTableDataSourceIdentifier;
+
+        public string DisplayName => BuildDataSourceDisplayName;
+
+        public bool SupportRoslynLogging => _roslynLogger.Supported;
+
+        public bool IsLogging { get; private set; }
+
+        public bool SupportsRoslynLogging => _roslynLogger.Supported;
+
+        private Action NotifyUI { get; set; }
+
+        public BackEndBuildTableDataSource()
+        {
+            _evaluationLogger = new EvaluationLogger(this);
+            _roslynLogger = new RoslynLogger(this);
+        }
+
+        public void Start(Action notifyCallback)
+        {
+            NotifyUI = notifyCallback;
+
+            IsLogging = true;
+            ProjectCollection.GlobalProjectCollection.RegisterLogger(_evaluationLogger);
+            _roslynLogger.Start();
+        }
+
+        public void Stop()
+        {
+            NotifyUI = null;
+
+            IsLogging = false;
+            ProjectCollection.GlobalProjectCollection.UnregisterAllLoggers();
+            _roslynLogger.Stop();
+        }
+
+        public void Clear()
+        {
+            foreach (var build in _entries)
+            {
+                build.Dispose();
+            }
+            _entries = ImmutableList<Build>.Empty;
+        }
+
+        public ILogger CreateLogger(bool isDesignTime) => new ProjectLogger(this, isDesignTime);
+
+        /// <summary>
+        /// return log path on server for a given build
+        /// If buildID cannot be found, will return null
+        /// </summary>
+        /// <param name="buildID">ID to return build for</param>
+        /// <returns> returns filepath to log path (on server)</returns>
+        public string GetLogForBuild(int buildID)
+        {
+            return _entries.Find(x => x.BuildId == buildID).LogPath;
+        }
+
+        ImmutableList<BuildSummary> ILoggingDataSource.GetAllBuilds()
+        {
+            return _entries.Select(build => build.BuildSummary).ToImmutableList();
+        }
+
+        public void NotifyChange()
+        {
+            NotifyUI?.Invoke();
+        }
+
+        public void AddEntry(Build build)
+        {
+            _entries = _entries.Add(build);
+            NotifyChange();
+        }
+    }
+}

src/ProjectSystemTools/BuildLogging/Model/Backend/Build.cs

@@ -0,0 +1,76 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Threading;
+
+namespace Microsoft.VisualStudio.ProjectSystem.Tools.BuildLogging.Model.BackEnd
+{
+    /// <summary>
+    /// Represents a build collected by the loggers
+    /// Deals with data needed by the client as well as data related to log files
+    /// and the file system on the server.
+    /// 
+    /// Build should only be used on the server side,
+    /// where BuildSummary type (a subset of this type)
+    /// can be sent to the client side
+    /// </summary>
+    internal sealed class Build : IDisposable
+    {
+        public BuildSummary BuildSummary { get; set; }
+        public string ProjectPath { get; }
+        public string LogPath { get; private set; }
+        public int BuildId => BuildSummary.BuildId;
+        public BuildType BuildType => BuildSummary.BuildType;
+        public ImmutableArray<string> Dimensions => BuildSummary.Dimensions;
+        public ImmutableArray<string> Targets => BuildSummary.Targets;
+        public DateTime StartTime => BuildSummary.StartTime;
+        public TimeSpan Elapsed => BuildSummary.Elapsed;
+        public BuildStatus Status => BuildSummary.Status;
+        public string ProjectName => BuildSummary.ProjectName;
+        private static int SharedBuildId;
+        public Build(string projectPath, IEnumerable<string> dimensions, IEnumerable<string> targets, BuildType buildType, DateTime startTime)
+        {
+            int nextId = Interlocked.Increment(ref SharedBuildId);
+            BuildSummary = new BuildSummary(nextId, projectPath, dimensions, targets, buildType, startTime);
+        }
+
+        public void Finish(bool succeeded, DateTime time)
+        {
+            if (Status != BuildStatus.Running)
+            {
+                throw new InvalidOperationException();
+            }
+
+            BuildStatus newStatus = succeeded ? BuildStatus.Finished : BuildStatus.Failed;
+            var elapsedTime = time - StartTime;
+            BuildSummary = new BuildSummary(BuildSummary, newStatus, elapsedTime);
+        }
+
+        public void SetLogPath(string logPath)
+        {
+            LogPath = logPath;
+        }
+
+        public void Dispose()
+        {
+            if (LogPath == null)
+            {
+                return;
+            }
+
+            var logPath = LogPath;
+            LogPath = null;
+            try
+            {
+                File.Delete(logPath);
+            }
+            catch
+            {
+                // If it fails, it fails...
+            }
+        }
+    }
+}