working attach handler

Author: TylerLeonhardt

src/PowerShellEditorServices.Engine/Server/PsesDebugServer.cs

@@ -45,7 +45,8 @@ public async Task StartAsync(IServiceProvider languageServerServiceProvider)
                 options.Services = new ServiceCollection()
                     .AddSingleton(languageServerServiceProvider.GetService<PowerShellContextService>())
                     .AddSingleton<DebugService>()
-                    .AddSingleton<DebugStateService>();
+                    .AddSingleton<DebugStateService>()
+                    .AddSingleton<DebugEventHandlerService>();
 
                 options
                     .WithInput(_inputStream)
@@ -55,7 +56,8 @@ public async Task StartAsync(IServiceProvider languageServerServiceProvider)
 
                 options
                     .WithHandler<InitializeHandler>()
-                    .WithHandler<LaunchAndAttachHandler>();
+                    .WithHandler<LaunchHandler>()
+                    .WithHandler<AttachHandler>();
 
                 logger.LogInformation("Handlers added");
             });

src/PowerShellEditorServices.Engine/Services/DebugAdapter/DebugEventHandlerService.cs

@@ -0,0 +1,168 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Management.Automation;
+using Microsoft.Extensions.Logging;
+using Microsoft.PowerShell.EditorServices.Engine.Services.DebugAdapter;
+using Microsoft.PowerShell.EditorServices.Engine.Services.PowerShellContext;
+using Microsoft.PowerShell.EditorServices.Utility;
+using OmniSharp.Extensions.DebugAdapter.Protocol.Events;
+using OmniSharp.Extensions.JsonRpc;
+
+namespace Microsoft.PowerShell.EditorServices.Engine.Services
+{
+    public class DebugEventHandlerService
+    {
+        private readonly ILogger<DebugEventHandlerService> _logger;
+        private readonly PowerShellContextService _powerShellContextService;
+        private readonly DebugService _debugService;
+        private readonly DebugStateService _debugStateService;
+        private readonly IJsonRpcServer _jsonRpcServer;
+
+        public DebugEventHandlerService(
+            ILoggerFactory factory,
+            PowerShellContextService powerShellContextService,
+            DebugService debugService,
+            DebugStateService debugStateService,
+            IJsonRpcServer jsonRpcServer)
+        {
+            _logger = factory.CreateLogger<DebugEventHandlerService>();
+            _powerShellContextService = powerShellContextService;
+            _debugService = debugService;
+            _debugStateService = debugStateService;
+            _jsonRpcServer = jsonRpcServer;
+        }
+
+        internal void RegisterEventHandlers()
+        {
+            _powerShellContextService.RunspaceChanged += PowerShellContext_RunspaceChangedAsync;
+            _debugService.BreakpointUpdated += DebugService_BreakpointUpdatedAsync;
+            _debugService.DebuggerStopped += DebugService_DebuggerStoppedAsync;
+            _powerShellContextService.DebuggerResumed += PowerShellContext_DebuggerResumedAsync;
+        }
+
+        internal void UnregisterEventHandlers()
+        {
+            _powerShellContextService.RunspaceChanged -= PowerShellContext_RunspaceChangedAsync;
+            _debugService.BreakpointUpdated -= DebugService_BreakpointUpdatedAsync;
+            _debugService.DebuggerStopped -= DebugService_DebuggerStoppedAsync;
+            _powerShellContextService.DebuggerResumed -= PowerShellContext_DebuggerResumedAsync;
+        }
+
+        #region Event Handlers
+
+        private void DebugService_DebuggerStoppedAsync(object sender, DebuggerStoppedEventArgs e)
+        {
+            // Provide the reason for why the debugger has stopped script execution.
+            // See https://github.com/Microsoft/vscode/issues/3648
+            // The reason is displayed in the breakpoints viewlet.  Some recommended reasons are:
+            // "step", "breakpoint", "function breakpoint", "exception" and "pause".
+            // We don't support exception breakpoints and for "pause", we can't distinguish
+            // between stepping and the user pressing the pause/break button in the debug toolbar.
+            string debuggerStoppedReason = "step";
+            if (e.OriginalEvent.Breakpoints.Count > 0)
+            {
+                debuggerStoppedReason =
+                    e.OriginalEvent.Breakpoints[0] is CommandBreakpoint
+                        ? "function breakpoint"
+                        : "breakpoint";
+            }
+
+            _jsonRpcServer.SendNotification(EventNames.Stopped,
+                new StoppedEvent
+                {
+                    ThreadId = 1,
+                    Reason = debuggerStoppedReason
+                });
+        }
+
+        private void PowerShellContext_RunspaceChangedAsync(object sender, RunspaceChangedEventArgs e)
+        {
+            if (_debugStateService.WaitingForAttach &&
+                e.ChangeAction == RunspaceChangeAction.Enter &&
+                e.NewRunspace.Context == RunspaceContext.DebuggedRunspace)
+            {
+                // Send the InitializedEvent so that the debugger will continue
+                // sending configuration requests
+                _debugStateService.WaitingForAttach = false;
+                _jsonRpcServer.SendNotification(EventNames.Initialized);
+            }
+            else if (
+                e.ChangeAction == RunspaceChangeAction.Exit &&
+                (_powerShellContextService.IsDebuggerStopped))
+            {
+                // Exited the session while the debugger is stopped,
+                // send a ContinuedEvent so that the client changes the
+                // UI to appear to be running again
+                _jsonRpcServer.SendNotification(EventNames.Continued,
+                    new ContinuedEvent
+                    {
+                        ThreadId = 1,
+                        AllThreadsContinued = true
+                    });
+            }
+        }
+
+        private void PowerShellContext_DebuggerResumedAsync(object sender, DebuggerResumeAction e)
+        {
+            _jsonRpcServer.SendNotification(EventNames.Continued,
+                new ContinuedEvent
+                {
+                    AllThreadsContinued = true,
+                    ThreadId = 1
+                });
+        }
+
+        private void DebugService_BreakpointUpdatedAsync(object sender, BreakpointUpdatedEventArgs e)
+        {
+            string reason = "changed";
+
+            if (_debugStateService.SetBreakpointInProgress)
+            {
+                // Don't send breakpoint update notifications when setting
+                // breakpoints on behalf of the client.
+                return;
+            }
+
+            switch (e.UpdateType)
+            {
+                case BreakpointUpdateType.Set:
+                    reason = "new";
+                    break;
+
+                case BreakpointUpdateType.Removed:
+                    reason = "removed";
+                    break;
+            }
+
+            OmniSharp.Extensions.DebugAdapter.Protocol.Models.Breakpoint breakpoint;
+            if (e.Breakpoint is LineBreakpoint)
+            {
+                breakpoint = LspBreakpointUtils.CreateBreakpoint(BreakpointDetails.Create(e.Breakpoint));
+            }
+            else if (e.Breakpoint is CommandBreakpoint)
+            {
+                _logger.LogTrace("Function breakpoint updated event is not supported yet");
+                return;
+            }
+            else
+            {
+                _logger.LogError($"Unrecognized breakpoint type {e.Breakpoint.GetType().FullName}");
+                return;
+            }
+
+            breakpoint.Verified = e.UpdateType != BreakpointUpdateType.Disabled;
+
+            _jsonRpcServer.SendNotification(EventNames.Breakpoint,
+                new BreakpointEvent
+                {
+                    Reason = reason,
+                    Breakpoint = breakpoint
+                });
+        }
+
+        #endregion
+    }
+}