Fix testing for pipeline consumer branch

.vsts-ci/azure-pipelines-ci.yml

@@ -8,14 +8,6 @@ variables:
   - name: DOTNET_CLI_TELEMETRY_OPTOUT
     value: 'true'
 
-trigger:
-  branches:
-    include:
-      - master
-
-pr:
-- master
-
 jobs:
 - job: PS51_Win2016
   displayName: PowerShell 5.1 - Windows Server 2016

src/PowerShellEditorServices.Hosting/EditorServicesLoader.cs

@@ -120,6 +120,11 @@ public static EditorServicesLoader Create(
             {
                 AppDomain.CurrentDomain.AssemblyLoad += (object sender, AssemblyLoadEventArgs args) =>
                 {
+                    if (args.LoadedAssembly.IsDynamic)
+                    {
+                        return;
+                    }
+
                     logger.Log(
                         PsesLogLevel.Diagnostic,
                         $"Loaded '{args.LoadedAssembly.GetName()}' from '{args.LoadedAssembly.Location}'");

src/PowerShellEditorServices/Server/PsesDebugServer.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -28,7 +29,9 @@ internal class PsesDebugServer : IDisposable
 
         private DebugAdapterServer _debugAdapterServer;
 
-        private PowerShellDebugContext _debugContext;
+        private PsesInternalHost _psesHost;
+
+        private bool _startedPses;
 
         protected readonly ILoggerFactory _loggerFactory;
 
@@ -61,8 +64,8 @@ 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.
-                _debugContext = ServiceProvider.GetService<PsesInternalHost>().DebugContext;
-                _debugContext.IsDebugServerActive = true;
+                _psesHost = ServiceProvider.GetService<PsesInternalHost>();
+                _psesHost.DebugContext.IsDebugServerActive = true;
 
                 options
                     .WithInput(_inputStream)
@@ -88,8 +91,11 @@ 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) => {
+                        // We need to make sure the host has been started
+                        _startedPses = !(await _psesHost.TryStartAsync(new HostStartOptions(), CancellationToken.None).ConfigureAwait(false));
+
                         // Ensure the debugger mode is set correctly - this is required for remote debugging to work
-                        _debugContext.EnableDebugMode();
+                        _psesHost.DebugContext.EnableDebugMode();
 
                         var breakpointService = server.GetService<BreakpointService>();
                         // Clear any existing breakpoints before proceeding
@@ -115,7 +121,7 @@ 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;
+            _psesHost.DebugContext.IsDebugServerActive = false;
             _debugAdapterServer.Dispose();
             _inputStream.Dispose();
             _outputStream.Dispose();
@@ -126,6 +132,13 @@ public void Dispose()
         public async Task WaitForShutdown()
         {
             await _serverStopped.Task.ConfigureAwait(false);
+
+            // If we started the host, we need to ensure any errors are marshalled back to us like this
+            if (_startedPses)
+            {
+                _psesHost.TriggerShutdown();
+                await _psesHost.Shutdown.ConfigureAwait(false);
+            }
         }
 
         #region Events

src/PowerShellEditorServices/Server/PsesLanguageServer.cs

@@ -10,6 +10,7 @@
 using Microsoft.PowerShell.EditorServices.Hosting;
 using Microsoft.PowerShell.EditorServices.Services;
 using Microsoft.PowerShell.EditorServices.Services.Extension;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
 using Microsoft.PowerShell.EditorServices.Services.Template;
 using OmniSharp.Extensions.LanguageServer.Protocol.Server;
 using OmniSharp.Extensions.LanguageServer.Server;
@@ -32,6 +33,8 @@ internal class PsesLanguageServer
         private readonly HostStartupInfo _hostDetails;
         private readonly TaskCompletionSource<bool> _serverStart;
 
+        private PsesInternalHost _psesHost;
+
         /// <summary>
         /// Create a new language server instance.
         /// </summary>
@@ -75,8 +78,12 @@ public async Task StartAsync()
                 options
                     .WithInput(_inputStream)
                     .WithOutput(_outputStream)
-                    .WithServices(serviceCollection => serviceCollection
-                        .AddPsesLanguageServices(_hostDetails)) // NOTE: This adds a lot of services!
+                    .WithServices(serviceCollection =>
+                    {
+
+                        // NOTE: This adds a lot of services!
+                        serviceCollection.AddPsesLanguageServices(_hostDetails);
+                    })
                     .ConfigureLogging(builder => builder
                         .AddSerilog(Log.Logger) // TODO: Set dispose to true?
                         .AddLanguageProtocolLogging()
@@ -116,6 +123,8 @@ public async Task StartAsync()
 
                             IServiceProvider serviceProvider = languageServer.Services;
 
+                            _psesHost = serviceProvider.GetService<PsesInternalHost>();
+
                             var workspaceService = serviceProvider.GetService<WorkspaceService>();
 
                             // Grab the workspace path from the parameters
@@ -150,6 +159,10 @@ public async Task WaitForShutdown()
             Log.Logger.Debug("Shutting down OmniSharp Language Server");
             await _serverStart.Task.ConfigureAwait(false);
             await LanguageServer.WaitForExit.ConfigureAwait(false);
+
+            // Doing this means we're able to route through any exceptions experienced on the pipeline thread
+            _psesHost.TriggerShutdown();
+            await _psesHost.Shutdown.ConfigureAwait(false);
         }
     }
 }

src/PowerShellEditorServices/Services/DebugAdapter/Handlers/ConfigurationDoneHandler.cs

@@ -158,17 +158,16 @@ private static PSCommand BuildPSCommandFromArguments(string command, IReadOnlyLi
 
             // We are forced to use a hack here so that we can reuse PowerShell's parameter binding
             var sb = new StringBuilder()
-                .Append("& '")
-                .Append(command.Replace("'", "''"))
-                .Append("'");
+                .Append("& ")
+                .Append(StringEscaping.SingleQuoteAndEscape(command));
 
             foreach (string arg in arguments)
             {
                 sb.Append(' ');
 
-                if (ArgumentNeedsEscaping(arg))
+                if (StringEscaping.PowerShellArgumentNeedsEscaping(arg))
                 {
-                    sb.Append('\'').Append(arg.Replace("'", "''")).Append('\'');
+                    sb.Append(StringEscaping.SingleQuoteAndEscape(arg));
                 }
                 else
                 {
@@ -178,25 +177,5 @@ private static PSCommand BuildPSCommandFromArguments(string command, IReadOnlyLi
 
             return new PSCommand().AddScript(sb.ToString());
         }
-
-        private static bool ArgumentNeedsEscaping(string argument)
-        {
-            foreach (char c in argument)
-            {
-                switch (c)
-                {
-                    case '\'':
-                    case '"':
-                    case '|':
-                    case '&':
-                    case ';':
-                    case ':':
-                    case char w when char.IsWhiteSpace(w):
-                        return true;
-                }
-            }
-
-            return false;
-        }
     }
 }

src/PowerShellEditorServices/Services/PowerShell/Debugging/PowerShellDebugContext.cs

@@ -107,7 +107,12 @@ public void StepOver()
         public void SetDebugResuming(DebuggerResumeAction debuggerResumeAction)
         {
             _psesHost.SetExit();
-            LastStopEventArgs.ResumeAction = debuggerResumeAction;
+
+            if (LastStopEventArgs is not null)
+            {
+                LastStopEventArgs.ResumeAction = debuggerResumeAction;
+            }
+
             // We need to tell whatever is happening right now in the debug prompt to wrap up so we can continue
             _psesHost.CancelCurrentTask();
         }