Fix repeated failure to load DSC module

src/PowerShellEditorServices/Services/DebugAdapter/BreakpointService.cs

@@ -40,7 +40,7 @@ public BreakpointService(
             _debugStateService = debugStateService;
         }
 
-        public async Task<List<Breakpoint>> GetBreakpointsAsync()
+        public async Task<IReadOnlyList<Breakpoint>> GetBreakpointsAsync()
         {
             if (BreakpointApiUtils.SupportsBreakpointApis(_editorServicesHost.CurrentRunspace))
             {
@@ -52,14 +52,12 @@ public async Task<List<Breakpoint>> GetBreakpointsAsync()
 
             // Legacy behavior
             PSCommand psCommand = new PSCommand().AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint");
-            IEnumerable<Breakpoint> breakpoints = await _executionService
+            return await _executionService
                 .ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None)
                 .ConfigureAwait(false);
-
-            return breakpoints.ToList();
         }
 
-        public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string escapedScriptPath, IEnumerable<BreakpointDetails> breakpoints)
+        public async Task<IReadOnlyList<BreakpointDetails>> SetBreakpointsAsync(string escapedScriptPath, IReadOnlyList<BreakpointDetails> breakpoints)
         {
             if (BreakpointApiUtils.SupportsBreakpointApis(_editorServicesHost.CurrentRunspace))
             {
@@ -147,7 +145,7 @@ public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string esc
             return configuredBreakpoints;
         }
 
-        public async Task<IEnumerable<CommandBreakpointDetails>> SetCommandBreakpointsAsync(IEnumerable<CommandBreakpointDetails> breakpoints)
+        public async Task<IReadOnlyList<CommandBreakpointDetails>> SetCommandBreakpointsAsync(IReadOnlyList<CommandBreakpointDetails> breakpoints)
         {
             if (BreakpointApiUtils.SupportsBreakpointApis(_editorServicesHost.CurrentRunspace))
             {
@@ -216,7 +214,7 @@ public async Task<IEnumerable<CommandBreakpointDetails>> SetCommandBreakpointsAs
             // If no PSCommand was created then there are no breakpoints to set.
             if (psCommand is not null)
             {
-                IEnumerable<Breakpoint> setBreakpoints = await _executionService
+                IReadOnlyList<Breakpoint> setBreakpoints = await _executionService
                     .ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None)
                     .ConfigureAwait(false);
                 configuredBreakpoints.AddRange(setBreakpoints.Select(CommandBreakpointDetails.Create));

src/PowerShellEditorServices/Services/DebugAdapter/DebugService.cs

@@ -130,12 +130,12 @@ public DebugService(
         /// <param name="breakpoints">BreakpointDetails for each breakpoint that will be set.</param>
         /// <param name="clearExisting">If true, causes all existing breakpoints to be cleared before setting new ones.</param>
         /// <returns>An awaitable Task that will provide details about the breakpoints that were set.</returns>
-        public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
+        public async Task<IReadOnlyList<BreakpointDetails>> SetLineBreakpointsAsync(
             ScriptFile scriptFile,
-            BreakpointDetails[] breakpoints,
+            IReadOnlyList<BreakpointDetails> breakpoints,
             bool clearExisting = true)
         {
-            DscBreakpointCapability dscBreakpoints = await _debugContext.GetDscBreakpointCapabilityAsync(CancellationToken.None).ConfigureAwait(false);
+            DscBreakpointCapability dscBreakpoints = await _debugContext.GetDscBreakpointCapabilityAsync().ConfigureAwait(false);
 
             string scriptPath = scriptFile.FilePath;
 
@@ -168,7 +168,7 @@ public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
                     await _breakpointService.RemoveAllBreakpointsAsync(scriptFile.FilePath).ConfigureAwait(false);
                 }
 
-                return (await _breakpointService.SetBreakpointsAsync(escapedScriptPath, breakpoints).ConfigureAwait(false)).ToArray();
+                return await _breakpointService.SetBreakpointsAsync(escapedScriptPath, breakpoints).ConfigureAwait(false);
             }
 
             return await dscBreakpoints
@@ -182,25 +182,20 @@ public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
         /// <param name="breakpoints">CommandBreakpointDetails for each command breakpoint that will be set.</param>
         /// <param name="clearExisting">If true, causes all existing function breakpoints to be cleared before setting new ones.</param>
         /// <returns>An awaitable Task that will provide details about the breakpoints that were set.</returns>
-        public async Task<CommandBreakpointDetails[]> SetCommandBreakpointsAsync(
-            CommandBreakpointDetails[] breakpoints,
+        public async Task<IReadOnlyList<CommandBreakpointDetails>> SetCommandBreakpointsAsync(
+            IReadOnlyList<CommandBreakpointDetails> breakpoints,
             bool clearExisting = true)
         {
-            CommandBreakpointDetails[] resultBreakpointDetails = null;
-
             if (clearExisting)
             {
                 // Flatten dictionary values into one list and remove them all.
-                IEnumerable<Breakpoint> existingBreakpoints = await _breakpointService.GetBreakpointsAsync().ConfigureAwait(false);
+                IReadOnlyList<Breakpoint> existingBreakpoints = await _breakpointService.GetBreakpointsAsync().ConfigureAwait(false);
                 await _breakpointService.RemoveBreakpointsAsync(existingBreakpoints.OfType<CommandBreakpoint>()).ConfigureAwait(false);
             }
 
-            if (breakpoints.Length > 0)
-            {
-                resultBreakpointDetails = (await _breakpointService.SetCommandBreakpointsAsync(breakpoints).ConfigureAwait(false)).ToArray();
-            }
-
-            return resultBreakpointDetails ?? Array.Empty<CommandBreakpointDetails>();
+            return breakpoints.Count > 0
+                ? await _breakpointService.SetCommandBreakpointsAsync(breakpoints).ConfigureAwait(false)
+                : Array.Empty<CommandBreakpointDetails>();
         }
 
         /// <summary>

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

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading;
@@ -51,7 +52,7 @@ public async Task<SetBreakpointsResponse> Handle(SetBreakpointsArguments request
             if (!_workspaceService.TryGetFile(request.Source.Path, out ScriptFile scriptFile))
             {
                 string message = _debugStateService.NoDebug ? string.Empty : "Source file could not be accessed, breakpoint not set.";
-                System.Collections.Generic.IEnumerable<Breakpoint> srcBreakpoints = request.Breakpoints
+                IEnumerable<Breakpoint> srcBreakpoints = request.Breakpoints
                     .Select(srcBkpt => LspDebugUtils.CreateBreakpoint(
                         srcBkpt, request.Source.Path, message, verified: _debugStateService.NoDebug));
 
@@ -70,7 +71,7 @@ public async Task<SetBreakpointsResponse> Handle(SetBreakpointsArguments request
 
                 string message = _debugStateService.NoDebug ? string.Empty : "Source is not a PowerShell script, breakpoint not set.";
 
-                System.Collections.Generic.IEnumerable<Breakpoint> srcBreakpoints = request.Breakpoints
+                IEnumerable<Breakpoint> srcBreakpoints = request.Breakpoints
                     .Select(srcBkpt => LspDebugUtils.CreateBreakpoint(
                         srcBkpt, request.Source.Path, message, verified: _debugStateService.NoDebug));
 
@@ -82,18 +83,17 @@ public async Task<SetBreakpointsResponse> Handle(SetBreakpointsArguments request
             }
 
             // At this point, the source file has been verified as a PowerShell script.
-            BreakpointDetails[] breakpointDetails = request.Breakpoints
+            IReadOnlyList<BreakpointDetails> breakpointDetails = request.Breakpoints
                 .Select((srcBreakpoint) => BreakpointDetails.Create(
                     scriptFile.FilePath,
                     srcBreakpoint.Line,
                     srcBreakpoint.Column,
                     srcBreakpoint.Condition,
                     srcBreakpoint.HitCondition,
-                    srcBreakpoint.LogMessage))
-                .ToArray();
+                    srcBreakpoint.LogMessage)).ToList();
 
             // If this is a "run without debugging (Ctrl+F5)" session ignore requests to set breakpoints.
-            BreakpointDetails[] updatedBreakpointDetails = breakpointDetails;
+            IReadOnlyList<BreakpointDetails> updatedBreakpointDetails = breakpointDetails;
             if (!_debugStateService.NoDebug)
             {
                 await _debugStateService.WaitForSetBreakpointHandleAsync().ConfigureAwait(false);
@@ -125,23 +125,20 @@ await _debugService.SetLineBreakpointsAsync(
 
         public async Task<SetFunctionBreakpointsResponse> Handle(SetFunctionBreakpointsArguments request, CancellationToken cancellationToken)
         {
-            CommandBreakpointDetails[] breakpointDetails = request.Breakpoints
+            IReadOnlyList<CommandBreakpointDetails> breakpointDetails = request.Breakpoints
                 .Select((funcBreakpoint) => CommandBreakpointDetails.Create(
                     funcBreakpoint.Name,
-                    funcBreakpoint.Condition))
-                .ToArray();
+                    funcBreakpoint.Condition)).ToList();
 
             // If this is a "run without debugging (Ctrl+F5)" session ignore requests to set breakpoints.
-            CommandBreakpointDetails[] updatedBreakpointDetails = breakpointDetails;
+            IReadOnlyList<CommandBreakpointDetails> updatedBreakpointDetails = breakpointDetails;
             if (!_debugStateService.NoDebug)
             {
                 await _debugStateService.WaitForSetBreakpointHandleAsync().ConfigureAwait(false);
 
                 try
                 {
-                    updatedBreakpointDetails =
-                        await _debugService.SetCommandBreakpointsAsync(
-                            breakpointDetails).ConfigureAwait(false);
+                    updatedBreakpointDetails = await _debugService.SetCommandBreakpointsAsync(breakpointDetails).ConfigureAwait(false);
                 }
                 catch (Exception e)
                 {
@@ -156,9 +153,7 @@ await _debugService.SetCommandBreakpointsAsync(
 
             return new SetFunctionBreakpointsResponse
             {
-                Breakpoints = updatedBreakpointDetails
-                    .Select(LspDebugUtils.CreateBreakpoint)
-                    .ToArray()
+                Breakpoints = updatedBreakpointDetails.Select(LspDebugUtils.CreateBreakpoint).ToList()
             };
         }
 

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

@@ -1,45 +1,38 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-using System.Linq;
-using System.Threading.Tasks;
-using Microsoft.Extensions.Logging;
-using Microsoft.PowerShell.EditorServices.Logging;
-using Microsoft.PowerShell.EditorServices.Services.DebugAdapter;
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
+using System.Linq;
 using System.Management.Automation;
 using System.Threading;
-using SMA = System.Management.Automation;
-using Microsoft.PowerShell.EditorServices.Services.PowerShell.Utility;
-using Microsoft.PowerShell.EditorServices.Services.PowerShell.Runspace;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.PowerShell.EditorServices.Services.DebugAdapter;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Execution;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Runspace;
 
 namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Debugging
 {
     internal class DscBreakpointCapability
     {
+        private static bool? isDscInstalled;
         private string[] dscResourceRootPaths = Array.Empty<string>();
+        private readonly Dictionary<string, int[]> breakpointsPerFile = new();
 
-        private readonly Dictionary<string, int[]> breakpointsPerFile =
-            new();
-
-        public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
+        public async Task<IReadOnlyList<BreakpointDetails>> SetLineBreakpointsAsync(
             IInternalPowerShellExecutionService executionService,
             string scriptPath,
-            BreakpointDetails[] breakpoints)
+            IReadOnlyList<BreakpointDetails> breakpoints)
         {
-            List<BreakpointDetails> resultBreakpointDetails =
-                new();
-
             // We always get the latest array of breakpoint line numbers
             // so store that for future use
-            if (breakpoints.Length > 0)
+            int[] lineNumbers = breakpoints.Select(b => b.LineNumber).ToArray();
+            if (lineNumbers.Length > 0)
             {
                 // Set the breakpoints for this scriptPath
-                breakpointsPerFile[scriptPath] =
-                    breakpoints.Select(b => b.LineNumber).ToArray();
+                breakpointsPerFile[scriptPath] = lineNumbers;
             }
             else
             {
@@ -72,7 +65,7 @@ await executionService.ExecutePSCommandAsync(
                 breakpoint.Verified = true;
             }
 
-            return breakpoints.ToArray();
+            return breakpoints;
         }
 
         public bool IsDscResourcePath(string scriptPath)
@@ -84,88 +77,57 @@ public bool IsDscResourcePath(string scriptPath)
                         StringComparison.CurrentCultureIgnoreCase));
         }
 
-        public static Task<DscBreakpointCapability> GetDscCapabilityAsync(
+        public static async Task<DscBreakpointCapability> GetDscCapabilityAsync(
             ILogger logger,
             IRunspaceInfo currentRunspace,
-            PsesInternalHost psesHost,
-            CancellationToken cancellationToken)
+            PsesInternalHost psesHost)
         {
             // DSC support is enabled only for Windows PowerShell.
             if ((currentRunspace.PowerShellVersionDetails.Version.Major >= 6) &&
                 (currentRunspace.RunspaceOrigin != RunspaceOrigin.DebuggedRunspace))
             {
-                return Task.FromResult<DscBreakpointCapability>(null);
+                return null;
             }
 
-            DscBreakpointCapability getDscBreakpointCapabilityFunc(SMA.PowerShell pwsh, CancellationToken _)
+            if (!isDscInstalled.HasValue)
             {
-                PSInvocationSettings invocationSettings = new()
-                {
-                    AddToHistory = false,
-                    ErrorActionPreference = ActionPreference.Stop
-                };
-
-                PSModuleInfo dscModule = null;
-                try
-                {
-                    dscModule = pwsh.AddCommand("Import-Module")
-                        .AddArgument(@"C:\Program Files\DesiredStateConfiguration\1.0.0.0\Modules\PSDesiredStateConfiguration\PSDesiredStateConfiguration.psd1")
-                        .AddParameter("PassThru")
-                        .InvokeAndClear<PSModuleInfo>(invocationSettings)
-                        .FirstOrDefault();
-                }
-                catch (RuntimeException e)
-                {
-                    logger.LogException("Could not load the DSC module!", e);
-                }
-
-                if (dscModule == null)
-                {
-                    logger.LogTrace("Side-by-side DSC module was not found.");
-                    return null;
-                }
-
-                logger.LogTrace("Side-by-side DSC module found, gathering DSC resource paths...");
-
-                // The module was loaded, add the breakpoint capability
-                DscBreakpointCapability capability = new();
-
-                pwsh.AddCommand("Microsoft.PowerShell.Utility\\Write-Host")
-                    .AddArgument("Gathering DSC resource paths, this may take a while...")
-                    .InvokeAndClear(invocationSettings);
-
-                Collection<string> resourcePaths = null;
-                try
-                {
-                    // Get the list of DSC resource paths
-                    resourcePaths = pwsh.AddCommand("Get-DscResource")
-                        .AddCommand("Select-Object")
-                        .AddParameter("ExpandProperty", "ParentPath")
-                        .InvokeAndClear<string>(invocationSettings);
-                }
-                catch (CmdletInvocationException e)
-                {
-                    logger.LogException("Get-DscResource failed!", e);
-                }
-
-                if (resourcePaths == null)
-                {
-                    logger.LogTrace("No DSC resources found.");
-                    return null;
-                }
+                PSCommand psCommand = new PSCommand()
+                    .AddCommand("Import-Module")
+                    .AddArgument(@"C:\Program Files\DesiredStateConfiguration\1.0.0.0\Modules\PSDesiredStateConfiguration\PSDesiredStateConfiguration.psd1")
+                    .AddParameter("PassThru");
+
+                IReadOnlyList<PSModuleInfo> dscModule =
+                    await psesHost.ExecutePSCommandAsync<PSModuleInfo>(
+                        psCommand,
+                        CancellationToken.None,
+                        new PowerShellExecutionOptions { ThrowOnError = false }).ConfigureAwait(false);
+
+                isDscInstalled = dscModule.Count > 0;
+                logger.LogTrace("Side-by-side DSC module found: " + isDscInstalled.Value);
+            }
 
-                capability.dscResourceRootPaths = resourcePaths.ToArray();
+            if (isDscInstalled.Value)
+            {
+                PSCommand psCommand = new PSCommand()
+                    .AddCommand("Get-DscResource")
+                    .AddCommand("Select-Object")
+                    .AddParameter("ExpandProperty", "ParentPath");
+
+                IReadOnlyList<string> resourcePaths =
+                    await psesHost.ExecutePSCommandAsync<string>(
+                        psCommand,
+                        CancellationToken.None,
+                        new PowerShellExecutionOptions { ThrowOnError = false }
+                    ).ConfigureAwait(false);
 
                 logger.LogTrace($"DSC resources found: {resourcePaths.Count}");
-
-                return capability;
+                return new DscBreakpointCapability
+                {
+                    dscResourceRootPaths = resourcePaths.ToArray()
+                };
             }
 
-            return psesHost.ExecuteDelegateAsync(
-                nameof(getDscBreakpointCapabilityFunc),
-                executionOptions: null,
-                getDscBreakpointCapabilityFunc,
-                cancellationToken);
+            return null;
         }
     }
 }

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

@@ -3,7 +3,6 @@
 
 using System;
 using System.Management.Automation;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Debugging
@@ -34,6 +33,6 @@ internal interface IPowerShellDebugContext
 
         void Abort();
 
-        Task<DscBreakpointCapability> GetDscBreakpointCapabilityAsync(CancellationToken cancellationToken);
+        Task<DscBreakpointCapability> GetDscBreakpointCapabilityAsync();
     }
 }