Added support for debugging external test processes

samples/Microsoft.TestPlatform.TranslationLayer.E2ETest/Program.cs

@@ -243,7 +243,7 @@ public void HandleRawMessage(string rawMessage)
         }
     }
 
-    public class RunEventHandler : ITestRunEventsHandler
+    public class RunEventHandler : ITestRunEventsHandler2
     {
         private AutoResetEvent waitHandle;
 
@@ -293,5 +293,11 @@ public int LaunchProcessWithDebuggerAttached(TestProcessStartInfo testProcessSta
             // No op
             return -1;
         }
+
+        public bool AttachDebuggerToProcess(int pid)
+        {
+            // No op
+            return false;
+        }
     }
 }

src/Microsoft.TestPlatform.Client/DesignMode/DesignModeClient.cs

@@ -37,12 +37,16 @@ public class DesignModeClient : IDesignModeClient
 
         private object ackLockObject = new object();
 
+        private object responseLockObject = new object();
+
         private ProtocolConfig protocolConfig = Constants.DefaultProtocolConfig;
 
         private IEnvironment platformEnvironment;
 
         protected Action<Message> onAckMessageReceived;
 
+        protected Action<Message> onResponseMessageReceived;
+
         private TestSessionMessageLogger testSessionMessageLogger;
 
         /// <summary>
@@ -226,6 +230,10 @@ private void ProcessRequests(ITestRequestManager testRequestManager)
                                 break;
                             }
 
+                        case MessageType.VSAttachDebuggerToProcessCallback:
+                            this.onResponseMessageReceived?.Invoke(message);
+                            break;
+
                         case MessageType.SessionEnd:
                             {
                                 EqtTrace.Info("DesignModeClient: Session End message received from server. Closing the connection.");
@@ -301,6 +309,31 @@ public int LaunchCustomHost(TestProcessStartInfo testProcessStartInfo, Cancellat
             }
         }
 
+        /// <inheritdoc/>
+        public bool AttachDebuggerToProcess(int pid, CancellationToken cancellationToken)
+        {
+            lock (this.responseLockObject)
+            {
+                var waitHandle = new AutoResetEvent(false);
+                Message responseMessage = null;
+                this.onResponseMessageReceived = (responseRawMessage) =>
+                {
+                    responseMessage = responseRawMessage;
+                    waitHandle.Set();
+                };
+
+                this.communicationManager.SendMessage(MessageType.VSAttachDebuggerToProcess, pid);
+
+                WaitHandle.WaitAny(new WaitHandle[] { waitHandle, cancellationToken.WaitHandle });
+
+                cancellationToken.ThrowTestPlatformExceptionIfCancellationRequested();
+                this.onResponseMessageReceived = null;
+
+                var response = this.dataSerializer.DeserializePayload<bool>(responseMessage);
+                return response;
+            }
+        }
+
         /// <summary>
         /// Send the raw messages to IDE
         /// </summary>
@@ -416,7 +449,6 @@ public void Dispose()
             // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
             Dispose(true);
         }
-
         #endregion
     }
 }

src/Microsoft.TestPlatform.Client/DesignMode/DesignModeTestHostLauncher.cs

@@ -10,7 +10,7 @@ namespace Microsoft.VisualStudio.TestPlatform.Client.DesignMode
     /// <summary>
     /// DesignMode TestHost Launcher for hosting of test process
     /// </summary>
-    internal class DesignModeTestHostLauncher : ITestHostLauncher
+    internal class DesignModeTestHostLauncher : ITestHostLauncher2
     {
         private readonly IDesignModeClient designModeClient;
 
@@ -26,6 +26,18 @@ public DesignModeTestHostLauncher(IDesignModeClient designModeClient)
         /// <inheritdoc/>
         public virtual bool IsDebug => false;
 
+        /// <inheritdoc/>
+        public bool AttachDebuggerToProcess(int pid)
+        {
+            return this.designModeClient.AttachDebuggerToProcess(pid, CancellationToken.None);
+        }
+
+        /// <inheritdoc/>
+        public bool AttachDebuggerToProcess(int pid, CancellationToken cancellationToken)
+        {
+            return this.designModeClient.AttachDebuggerToProcess(pid, cancellationToken);
+        }
+
         /// <inheritdoc/>
         public int LaunchTestHost(TestProcessStartInfo defaultTestHostStartInfo)
         {

src/Microsoft.TestPlatform.Client/DesignMode/DesignModeTestHostLauncherFactory.cs

@@ -12,12 +12,12 @@ namespace Microsoft.VisualStudio.TestPlatform.Client.DesignMode
     public static class DesignModeTestHostLauncherFactory
     {
         private static ITestHostLauncher defaultLauncher;
-
         private static ITestHostLauncher debugLauncher;
 
         public static ITestHostLauncher GetCustomHostLauncherForTestRun(IDesignModeClient designModeClient, TestRunRequestPayload testRunRequestPayload)
         {
             ITestHostLauncher testHostLauncher = null;
+
             if (!testRunRequestPayload.DebuggingEnabled)
             {
                 testHostLauncher = defaultLauncher = defaultLauncher ?? new DesignModeTestHostLauncher(designModeClient);

src/Microsoft.TestPlatform.Client/DesignMode/IDesignModeClient.cs

@@ -28,6 +28,14 @@ public interface IDesignModeClient : IDisposable
         /// <returns>Process id of the launched test host.</returns>
         int LaunchCustomHost(TestProcessStartInfo defaultTestHostStartInfo, CancellationToken cancellationToken);
 
+        /// <summary>
+        /// Attach debugger to an already running process.
+        /// </summary>
+        /// <param name="pid">Process ID of the process to which the debugger should be attached.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns><see cref="true"/> if the debugger was successfully attached to the requested process, <see cref="false"/> otherwise.</returns>
+        bool AttachDebuggerToProcess(int pid, CancellationToken cancellationToken);
+
         /// <summary>
         /// Handles parent process exit
         /// </summary>

src/Microsoft.TestPlatform.Client/Execution/TestRunRequest.cs

@@ -23,8 +23,9 @@ namespace Microsoft.VisualStudio.TestPlatform.Client.Execution
     using ClientResources = Microsoft.VisualStudio.TestPlatform.Client.Resources.Resources;
     using CommunicationObjectModel = Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.ObjectModel;
     using Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.ObjectModel;
+    using Microsoft.VisualStudio.TestPlatform.ObjectModel.Client.Interfaces;
 
-    public class TestRunRequest : ITestRunRequest, ITestRunEventsHandler
+    public class TestRunRequest : ITestRunRequest, ITestRunEventsHandler2
     {
         /// <summary>
         /// The criteria/config for this test run request.
@@ -659,6 +660,15 @@ public int LaunchProcessWithDebuggerAttached(TestProcessStartInfo testProcessSta
             return processId;
         }
 
+        /// <inheritdoc />
+        public bool AttachDebuggerToProcess(int pid)
+        {
+            if (!(this.testRunCriteria.TestHostLauncher is ITestHostLauncher2 launcher))
+                return false;
+
+            return launcher.AttachDebuggerToProcess(pid);
+        }
+
         /// <summary>
         /// Dispose the run
         /// </summary>

src/Microsoft.TestPlatform.CommunicationUtilities/EventHandlers/TestRunEventsHandler.cs

@@ -15,7 +15,7 @@ namespace Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.EventHandle
     /// <summary>
     /// The test run events handler.
     /// </summary>
-    public class TestRunEventsHandler : ITestRunEventsHandler
+    public class TestRunEventsHandler : ITestRunEventsHandler2
     {
         private ITestRequestHandler requestHandler;
 
@@ -97,5 +97,12 @@ public int LaunchProcessWithDebuggerAttached(TestProcessStartInfo testProcessSta
             EqtTrace.Info("Sending LaunchProcessWithDebuggerAttached on additional test process: {0}", testProcessStartInfo?.FileName);
             return this.requestHandler.LaunchProcessWithDebuggerAttached(testProcessStartInfo);
         }
+
+        /// <inheritdoc/>
+        public bool AttachDebuggerToProcess(int pid)
+        {
+            EqtTrace.Info("Sending TestRunEventsHandler.AttachDebuggerToProcess on additional test process with pid: {0}", pid);
+            return this.requestHandler.AttachDebuggerToProcess(pid);
+        }
     }
 }

src/Microsoft.TestPlatform.CommunicationUtilities/Interfaces/ITestRequestHandler.cs

@@ -86,5 +86,12 @@ public interface ITestRequestHandler : IDisposable
         /// <param name="testProcessStartInfo">Process start info</param>
         /// <returns>ProcessId of the launched process</returns>
         int LaunchProcessWithDebuggerAttached(TestProcessStartInfo testProcessStartInfo);
+
+        /// <summary>
+        /// Attach debugger to an already running process.
+        /// </summary>
+        /// <param name="pid">Process ID of the process to which the debugger should be attached.</param>
+        /// <returns><see cref="true"/> if the debugger was successfully attached to the requested process, <see cref="false"/> otherwise.</returns>
+        bool AttachDebuggerToProcess(int pid);
     }
 }

src/Microsoft.TestPlatform.CommunicationUtilities/Messages/MessageType.cs

@@ -148,6 +148,26 @@ public static class MessageType
         /// </summary>
         public const string LaunchAdapterProcessWithDebuggerAttachedCallback = "TestExecution.LaunchAdapterProcessWithDebuggerAttachedCallback";
 
+        /// <summary>
+        /// Attach debugger to process.
+        /// </summary>
+        public const string AttachDebuggerToProcess = "TestExecution.AttachDebuggerToProcess";
+
+        /// <summary>
+        /// Attach debugger to process callback.
+        /// </summary>
+        public const string AttachDebuggerToProcessCallback = "TestExecution.AttachDebuggerToProcessCallback";
+
+        /// <summary>
+        /// Attach debugger to process.
+        /// </summary>
+        public const string VSAttachDebuggerToProcess = "TestExecution.VSAttachDebuggerToProcess";
+
+        /// <summary>
+        /// Attach debugger to process callback.
+        /// </summary>
+        public const string VSAttachDebuggerToProcessCallback = "TestExecution.VSAttachDebuggerToProcessCallback";
+
         /// <summary>
         /// Data Collection Message
         /// </summary>

src/Microsoft.TestPlatform.CommunicationUtilities/TestRequestSender.cs

@@ -453,6 +453,28 @@ private void OnExecutionMessageReceived(object sender, MessageReceivedEventArgs
 
                         this.channel.Send(data);
                         break;
+
+                    case MessageType.AttachDebuggerToProcess:
+#pragma warning disable SA1119 // Statement must not use unnecessary parenthesis
+                        if (!(testRunEventsHandler is ITestRunEventsHandler2 handler))
+#pragma warning restore SA1119 // Statement must not use unnecessary parenthesis
+                        {
+                            throw new NotSupportedException(string.Format(
+                                CultureInfo.CurrentUICulture,
+                                "AttachDebuggerToProcess is only supported in ITestRunEventsHandler2, but it was called with {0}.",
+                                testRunEventsHandler.GetType()));
+                        }
+
+                        var testProcessPid = this.dataSerializer.DeserializePayload<TestProcessAttachDebuggerPayload>(message);
+                        bool result = handler.AttachDebuggerToProcess(testProcessPid.ProcessID);
+
+                        var resultMessage = this.dataSerializer.SerializePayload(
+                            MessageType.AttachDebuggerToProcessCallback,
+                            result,
+                            this.protocolVersion);
+
+                        this.channel.Send(resultMessage);
+                        break;
                 }
             }
             catch (Exception exception)

src/Microsoft.TestPlatform.CrossPlatEngine/Adapter/FrameworkHandle.cs

@@ -5,7 +5,7 @@ namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Adapter
 {
     using System;
     using System.Collections.Generic;
-
+    using System.Globalization;
     using Execution;
 
     using Microsoft.VisualStudio.TestPlatform.ObjectModel;
@@ -19,7 +19,7 @@ namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Adapter
     /// <summary>
     /// Handle to the framework which is passed to the test executors.
     /// </summary>
-    internal class FrameworkHandle : TestExecutionRecorder, IFrameworkHandle, IDisposable
+    internal class FrameworkHandle : TestExecutionRecorder, IFrameworkHandle2, IDisposable
     {
         /// <summary>
         /// boolean that gives the value of EnableShutdownAfterTestRun. 
@@ -110,6 +110,29 @@ public int LaunchProcessWithDebuggerAttached(string filePath, string workingDire
             return this.testRunEventsHandler.LaunchProcessWithDebuggerAttached(processInfo);
         }
 
+        /// <inheritdoc />
+        public bool AttachDebuggerToProcess(int pid)
+        {
+            if (pid < 0)
+            {
+                throw new ArgumentOutOfRangeException("FrameworkHandle.AttachDebuggerToProcess: PID cannot be negative.");
+            }
+            if (pid == 0)
+            {
+                EqtTrace.Warning("FrameworkHandle.AttachDebuggerToProcess: Attaching to a process with process id 0, is this intended ?");
+            }
+
+            var handler = this.testRunEventsHandler as ITestRunEventsHandler2;
+            if (handler == null)
+            {
+                throw new NotSupportedException(string.Format(
+                    CultureInfo.CurrentUICulture,
+                    "FrameworkHandle.AttachDebuggerToProcess is only supported in ITestRunEventsHandler2, but it was called with {0}.",
+                    this.testRunEventsHandler.GetType()));
+            }
+
+            return handler.AttachDebuggerToProcess(pid);
+        }
 
         public void Dispose()
         {

src/Microsoft.TestPlatform.CrossPlatEngine/Client/Parallel/ParallelRunEventsHandler.cs

@@ -3,9 +3,10 @@
 
 namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client.Parallel
 {
+    using System;
     using System.Collections.Generic;
     using System.Collections.ObjectModel;
-
+    using System.Globalization;
     using Microsoft.VisualStudio.TestPlatform.Common.Telemetry;
     using Microsoft.VisualStudio.TestPlatform.CommunicationUtilities;
     using Microsoft.VisualStudio.TestPlatform.CommunicationUtilities.Interfaces;
@@ -18,7 +19,7 @@ namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client.Parallel
     /// <summary>
     /// ParallelRunEventsHandler for handling the run events in case of parallel execution
     /// </summary>
-    internal class ParallelRunEventsHandler : ITestRunEventsHandler
+    internal class ParallelRunEventsHandler : ITestRunEventsHandler2
     {
         private IProxyExecutionManager proxyExecutionManager;
 
@@ -174,6 +175,20 @@ public int LaunchProcessWithDebuggerAttached(TestProcessStartInfo testProcessSta
             return this.actualRunEventsHandler.LaunchProcessWithDebuggerAttached(testProcessStartInfo);
         }
 
+        /// <inheritdoc />
+        public bool AttachDebuggerToProcess(int pid)
+        {
+            if (!(this.actualRunEventsHandler is ITestRunEventsHandler2 handler))
+            {
+                throw new NotSupportedException(string.Format(
+                    CultureInfo.CurrentUICulture,
+                    "AttachDebuggerToProcess is only supported in ITestRunEventsHandler2, but it was called with {0}.",
+                    this.actualRunEventsHandler.GetType()));
+            }
+
+            return handler.AttachDebuggerToProcess(pid);
+        }
+
         private void ConvertToRawMessageAndSend(string messageType, object payload)
         {
             var rawMessage = this.dataSerializer.SerializePayload(messageType, payload);

src/Microsoft.TestPlatform.CrossPlatEngine/Client/ProxyExecutionManager.cs

@@ -6,6 +6,7 @@ namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client
     using System;
     using System.Collections.Generic;
     using System.Collections.ObjectModel;
+    using System.Globalization;
     using System.Linq;
 
     using Microsoft.VisualStudio.TestPlatform.Common;
@@ -27,7 +28,7 @@ namespace Microsoft.VisualStudio.TestPlatform.CrossPlatEngine.Client
     /// <summary>
     /// Orchestrates test execution operations for the engine communicating with the client.
     /// </summary>
-    internal class ProxyExecutionManager : ProxyOperationManager, IProxyExecutionManager, ITestRunEventsHandler
+    internal class ProxyExecutionManager : ProxyOperationManager, IProxyExecutionManager, ITestRunEventsHandler2
     {
         private readonly ITestRuntimeProvider testHostManager;
         private IDataSerializer dataSerializer;
@@ -200,6 +201,20 @@ public virtual int LaunchProcessWithDebuggerAttached(TestProcessStartInfo testPr
             return this.baseTestRunEventsHandler.LaunchProcessWithDebuggerAttached(testProcessStartInfo);
         }
 
+        /// <inheritdoc />
+        public bool AttachDebuggerToProcess(int pid)
+        {
+            if (!(this.baseTestRunEventsHandler is ITestRunEventsHandler2 handler))
+            {
+                throw new NotSupportedException(string.Format(
+                    CultureInfo.CurrentUICulture,
+                    "AttachDebuggerToProcess is only supported in ITestRunEventsHandler2, but it was called with {0}.",
+                    this.baseTestRunEventsHandler.GetType()));
+            }
+
+            return handler.AttachDebuggerToProcess(pid);
+        }
+
         /// <summary>
         /// Aborts the test run.
         /// </summary>