Merge pull request #1574 from rjmholt/pipelinethread-fix-debugging

Fix debugging with PSES pipeline thread changes

Author: rjmholt

ex.js

@@ -130,7 +130,7 @@ private async Task CreateEditorServicesAndRunUntilShutdown()
                 _logger.Log(PsesLogLevel.Diagnostic, "Creating/running editor services");
 
                 bool creatingLanguageServer = _config.LanguageServiceTransport != null;
-                bool creatingDebugServer = false;// _config.DebugServiceTransport != null;
+                bool creatingDebugServer = _config.DebugServiceTransport != null;
                 bool isTempDebugSession = creatingDebugServer && !creatingLanguageServer;
 
                 // Set up information required to instantiate servers

src/PowerShellEditorServices.Hosting/Internal/EditorServicesRunner.cs

@@ -116,7 +116,9 @@ public async Task<string> PromptInputAsync(string message)
                 new ShowInputPromptRequest
                 {
                     Name = message,
-                }).Returning<ShowInputPromptResponse>(CancellationToken.None);
+                })
+                .Returning<ShowInputPromptResponse>(CancellationToken.None)
+                .ConfigureAwait(false);
 
             if (response.PromptCancelled)
             {
@@ -142,7 +144,9 @@ public async Task<IReadOnlyList<string>> PromptMultipleSelectionAsync(string mes
                     Message = message,
                     Choices = choiceDetails,
                     DefaultChoices = defaultChoiceIndexes?.ToArray(),
-                }).Returning<ShowChoicePromptResponse>(CancellationToken.None);
+                })
+                .Returning<ShowChoicePromptResponse>(CancellationToken.None)
+                .ConfigureAwait(false);
 
             if (response.PromptCancelled)
             {
@@ -168,7 +172,9 @@ public async Task<string> PromptSelectionAsync(string message, IReadOnlyList<Pro
                     Message = message,
                     Choices = choiceDetails,
                     DefaultChoices = defaultChoiceIndex > -1 ? new[] { defaultChoiceIndex } : null,
-                }).Returning<ShowChoicePromptResponse>(CancellationToken.None);
+                })
+                .Returning<ShowChoicePromptResponse>(CancellationToken.None)
+                .ConfigureAwait(false);
 
             if (response.PromptCancelled)
             {

src/PowerShellEditorServices/Extensions/Api/EditorUIService.cs

@@ -137,7 +137,7 @@ public EditorContext GetEditorContext()
         internal void SetAsStaticInstance()
         {
             EditorObject.Instance = this;
-            s_editorObjectReady.SetResult(true);
+            s_editorObjectReady.TrySetResult(true);
         }
     }
 }

src/PowerShellEditorServices/Extensions/EditorObject.cs

@@ -45,7 +45,6 @@
   <ItemGroup>
     <Compile Remove="Extensions\Api\DocumentSymbolService.cs" />
     <Compile Remove="Services\Extension\Templating\**" />
-    <Compile Remove="Services\PowerShellContext\**\*.cs" />
     <EmbeddedResource Remove="Services\Extension\Templating\**" />
     <None Remove="Services\Extension\Templating\**" />
   </ItemGroup>

src/PowerShellEditorServices/PowerShellEditorServices.csproj

@@ -11,12 +11,11 @@
 using Microsoft.PowerShell.EditorServices.Handlers;
 using Microsoft.PowerShell.EditorServices.Services;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell;
-using Microsoft.PowerShell.EditorServices.Services.PowerShell.Console;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Debugging;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Runspace;
 using Microsoft.PowerShell.EditorServices.Utility;
-using OmniSharp.Extensions.DebugAdapter.Protocol;
-using OmniSharp.Extensions.DebugAdapter.Protocol.Serialization;
 using OmniSharp.Extensions.DebugAdapter.Server;
-using OmniSharp.Extensions.JsonRpc;
 using OmniSharp.Extensions.LanguageServer.Server;
 
 namespace Microsoft.PowerShell.EditorServices.Server
@@ -29,7 +28,7 @@ internal class PsesDebugServer : IDisposable
         /// <summary>
         /// This is a bool but must be an int, since Interlocked.Exchange can't handle a bool
         /// </summary>
-        private static int s_hasRunPsrlStaticCtor = 0;
+        private static readonly IdempotentLatch s_psrlCtorLatch = new();
 
         private static readonly Lazy<CmdletInfo> s_lazyInvokeReadLineConstructorCmdletInfo = new Lazy<CmdletInfo>(() =>
         {
@@ -45,7 +44,7 @@ internal class PsesDebugServer : IDisposable
 
         private DebugAdapterServer _debugAdapterServer;
 
-        private PowerShellExecutionService _executionService;
+        private PowerShellDebugContext _debugContext;
 
         protected readonly ILoggerFactory _loggerFactory;
 
@@ -78,31 +77,17 @@ public async Task StartAsync()
             {
                 // We need to let the PowerShell Context Service know that we are in a debug session
                 // so that it doesn't send the powerShell/startDebugger message.
-                _executionService = ServiceProvider.GetService<PowerShellExecutionService>();
-
-                /*
-                // Needed to make sure PSReadLine's static properties are initialized in the pipeline thread.
-                // This is only needed for Temp sessions who only have a debug server.
-                if (_usePSReadLine && _useTempSession && Interlocked.Exchange(ref s_hasRunPsrlStaticCtor, 1) == 0)
-                {
-                    // This must be run synchronously to ensure debugging works
-                    _executionService
-                        .ExecuteDelegateAsync((cancellationToken) =>
-                        {
-                            // Is this needed now that we do things the cool way??
-                        }, "PSRL static constructor execution", CancellationToken.None)
-                        .GetAwaiter()
-                        .GetResult();
-                }
-                */
+                _debugContext = ServiceProvider.GetService<PsesInternalHost>().DebugContext;
+                _debugContext.IsDebugServerActive = true;
 
                 options
                     .WithInput(_inputStream)
                     .WithOutput(_outputStream)
-                    .WithServices(serviceCollection => serviceCollection
-                        .AddLogging()
-                        .AddOptions()
-                        .AddPsesDebugServices(ServiceProvider, this, _useTempSession))
+                    .WithServices(serviceCollection =>
+                        serviceCollection
+                            .AddLogging()
+                            .AddOptions()
+                            .AddPsesDebugServices(ServiceProvider, this, _useTempSession))
                     // TODO: Consider replacing all WithHandler with AddSingleton
                     .WithHandler<LaunchAndAttachHandler>()
                     .WithHandler<DisconnectHandler>()
@@ -119,6 +104,9 @@ public async Task StartAsync()
                     // The OnInitialize delegate gets run when we first receive the _Initialize_ request:
                     // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Initialize
                     .OnInitialize(async (server, request, cancellationToken) => {
+                        // Ensure the debugger mode is set correctly - this is required for remote debugging to work
+                        _debugContext.EnableDebugMode();
+
                         var breakpointService = server.GetService<BreakpointService>();
                         // Clear any existing breakpoints before proceeding
                         await breakpointService.RemoveAllBreakpointsAsync().ConfigureAwait(false);
@@ -140,6 +128,10 @@ public async Task StartAsync()
 
         public void Dispose()
         {
+            // Note that the lifetime of the DebugContext is longer than the debug server;
+            // It represents the debugger on the PowerShell process we're in,
+            // while a new debug server is spun up for every debugging session
+            _debugContext.IsDebugServerActive = false;
             _debugAdapterServer.Dispose();
             _inputStream.Dispose();
             _outputStream.Dispose();

src/PowerShellEditorServices/Server/PsesDebugServer.cs

@@ -28,14 +28,14 @@ public static IServiceCollection AddPsesLanguageServices(
                 .AddSingleton<HostStartupInfo>(hostStartupInfo)
                 .AddSingleton<WorkspaceService>()
                 .AddSingleton<SymbolsService>()
-                .AddSingleton<EditorServicesConsolePSHost>()
+                .AddSingleton<PsesInternalHost>()
                 .AddSingleton<IRunspaceContext>(
-                    (provider) => provider.GetService<EditorServicesConsolePSHost>())
-                .AddSingleton<PowerShellExecutionService>(
-                    (provider) => provider.GetService<EditorServicesConsolePSHost>().ExecutionService)
+                    (provider) => provider.GetService<PsesInternalHost>())
+                .AddSingleton<IInternalPowerShellExecutionService>(
+                    (provider) => provider.GetService<PsesInternalHost>())
                 .AddSingleton<ConfigurationService>()
                 .AddSingleton<IPowerShellDebugContext>(
-                    (provider) => provider.GetService<EditorServicesConsolePSHost>().DebugContext)
+                    (provider) => provider.GetService<PsesInternalHost>().DebugContext)
                 .AddSingleton<TemplateService>()
                 .AddSingleton<EditorOperationsService>()
                 .AddSingleton<RemoteFileManagerService>()
@@ -45,7 +45,7 @@ public static IServiceCollection AddPsesLanguageServices(
                             provider.GetService<ILanguageServerFacade>(),
                             provider,
                             provider.GetService<EditorOperationsService>(),
-                            provider.GetService<PowerShellExecutionService>());
+                            provider.GetService<IInternalPowerShellExecutionService>());
 
                         // This is where we create the $psEditor variable
                         // so that when the console is ready, it will be available
@@ -65,7 +65,13 @@ public static IServiceCollection AddPsesDebugServices(
             PsesDebugServer psesDebugServer,
             bool useTempSession)
         {
-            return collection.AddSingleton(languageServiceProvider.GetService<PowerShellExecutionService>())
+            PsesInternalHost internalHost = languageServiceProvider.GetService<PsesInternalHost>();
+
+            return collection
+                .AddSingleton<PsesInternalHost>(internalHost)
+                .AddSingleton<IRunspaceContext>(internalHost)
+                .AddSingleton<IPowerShellDebugContext>(internalHost.DebugContext)
+                .AddSingleton(languageServiceProvider.GetService<IInternalPowerShellExecutionService>())
                 .AddSingleton(languageServiceProvider.GetService<WorkspaceService>())
                 .AddSingleton(languageServiceProvider.GetService<RemoteFileManagerService>())
                 .AddSingleton<PsesDebugServer>(psesDebugServer)

src/PowerShellEditorServices/Server/PsesServiceCollectionExtensions.cs

@@ -19,8 +19,8 @@ namespace Microsoft.PowerShell.EditorServices.Services
     internal class BreakpointService
     {
         private readonly ILogger<BreakpointService> _logger;
-        private readonly PowerShellExecutionService _executionService;
-        private readonly EditorServicesConsolePSHost _editorServicesHost;
+        private readonly IInternalPowerShellExecutionService _executionService;
+        private readonly PsesInternalHost _editorServicesHost;
         private readonly DebugStateService _debugStateService;
 
         // TODO: This needs to be managed per nested session
@@ -32,8 +32,8 @@ internal class BreakpointService
 
         public BreakpointService(
             ILoggerFactory factory,
-            PowerShellExecutionService executionService,
-            EditorServicesConsolePSHost editorServicesHost,
+            IInternalPowerShellExecutionService executionService,
+            PsesInternalHost editorServicesHost,
             DebugStateService debugStateService)
         {
             _logger = factory.CreateLogger<BreakpointService>();
@@ -44,23 +44,23 @@ public BreakpointService(
 
         public async Task<List<Breakpoint>> GetBreakpointsAsync()
         {
-            if (BreakpointApiUtils.SupportsBreakpointApis)
+            if (BreakpointApiUtils.SupportsBreakpointApis(_editorServicesHost.CurrentRunspace))
             {
                 return BreakpointApiUtils.GetBreakpoints(
                     _editorServicesHost.Runspace.Debugger,
                     _debugStateService.RunspaceId);
             }
 
             // Legacy behavior
-            PSCommand psCommand = new PSCommand();
-            psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint");
-            IEnumerable<Breakpoint> breakpoints = await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, new PowerShellExecutionOptions(), CancellationToken.None);
+            PSCommand psCommand = new PSCommand()
+                .AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint");
+            IEnumerable<Breakpoint> breakpoints = await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None).ConfigureAwait(false);
             return breakpoints.ToList();
         }
 
         public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string escapedScriptPath, IEnumerable<BreakpointDetails> breakpoints)
         {
-            if (BreakpointApiUtils.SupportsBreakpointApis)
+            if (BreakpointApiUtils.SupportsBreakpointApis(_editorServicesHost.CurrentRunspace))
             {
                 foreach (BreakpointDetails breakpointDetails in breakpoints)
                 {
@@ -140,7 +140,7 @@ public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string esc
             if (psCommand != null)
             {
                 IEnumerable<Breakpoint> setBreakpoints =
-                    await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, new PowerShellExecutionOptions(), CancellationToken.None);
+                    await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None).ConfigureAwait(false);
                 configuredBreakpoints.AddRange(
                     setBreakpoints.Select(BreakpointDetails.Create));
             }
@@ -150,7 +150,7 @@ public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string esc
 
         public async Task<IEnumerable<CommandBreakpointDetails>> SetCommandBreakpoints(IEnumerable<CommandBreakpointDetails> breakpoints)
         {
-            if (BreakpointApiUtils.SupportsBreakpointApis)
+            if (BreakpointApiUtils.SupportsBreakpointApis(_editorServicesHost.CurrentRunspace))
             {
                 foreach (CommandBreakpointDetails commandBreakpointDetails in breakpoints)
                 {
@@ -217,7 +217,7 @@ public async Task<IEnumerable<CommandBreakpointDetails>> SetCommandBreakpoints(I
             if (psCommand != null)
             {
                 IEnumerable<Breakpoint> setBreakpoints =
-                    await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, new PowerShellExecutionOptions(), CancellationToken.None);
+                    await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None).ConfigureAwait(false);
                 configuredBreakpoints.AddRange(
                     setBreakpoints.Select(CommandBreakpointDetails.Create));
             }
@@ -232,7 +232,7 @@ public async Task RemoveAllBreakpointsAsync(string scriptPath = null)
         {
             try
             {
-                if (BreakpointApiUtils.SupportsBreakpointApis)
+                if (BreakpointApiUtils.SupportsBreakpointApis(_editorServicesHost.CurrentRunspace))
                 {
                     foreach (Breakpoint breakpoint in BreakpointApiUtils.GetBreakpoints(
                             _editorServicesHost.Runspace.Debugger,
@@ -262,7 +262,7 @@ public async Task RemoveAllBreakpointsAsync(string scriptPath = null)
 
                 psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Remove-PSBreakpoint");
 
-                await _executionService.ExecutePSCommandAsync<object>(psCommand, new PowerShellExecutionOptions(), CancellationToken.None).ConfigureAwait(false);
+                await _executionService.ExecutePSCommandAsync<object>(psCommand, CancellationToken.None).ConfigureAwait(false);
             }
             catch (Exception e)
             {
@@ -272,7 +272,7 @@ public async Task RemoveAllBreakpointsAsync(string scriptPath = null)
 
         public async Task RemoveBreakpointsAsync(IEnumerable<Breakpoint> breakpoints)
         {
-            if (BreakpointApiUtils.SupportsBreakpointApis)
+            if (BreakpointApiUtils.SupportsBreakpointApis(_editorServicesHost.CurrentRunspace))
             {
                 foreach (Breakpoint breakpoint in breakpoints)
                 {
@@ -308,7 +308,7 @@ public async Task RemoveBreakpointsAsync(IEnumerable<Breakpoint> breakpoints)
                 psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Remove-PSBreakpoint");
                 psCommand.AddParameter("Id", breakpoints.Select(b => b.Id).ToArray());
 
-                await _executionService.ExecutePSCommandAsync<object>(psCommand, new PowerShellExecutionOptions(), CancellationToken.None);
+                await _executionService.ExecutePSCommandAsync<object>(psCommand, CancellationToken.None).ConfigureAwait(false);
             }
         }