/// <summary>
/// Start the debug server listening.
/// </summary>
/// <returns>A task that completes when the server is ready.</returns>
public async Task StartAsync()
{
_debugAdapterServer = await DebugAdapterServer.From(options =>
{
// 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.
_psesHost = ServiceProvider.GetService <PsesInternalHost>();
_psesHost.DebugContext.IsDebugServerActive = true;
options
.WithInput(_inputStream)
.WithOutput(_outputStream)
.WithServices(serviceCollection =>
serviceCollection
.AddLogging()
.AddOptions()
.AddPsesDebugServices(ServiceProvider, this))
// TODO: Consider replacing all WithHandler with AddSingleton
.WithHandler <LaunchAndAttachHandler>()
.WithHandler <DisconnectHandler>()
.WithHandler <BreakpointHandlers>()
.WithHandler <ConfigurationDoneHandler>()
.WithHandler <ThreadsHandler>()
.WithHandler <StackTraceHandler>()
.WithHandler <ScopesHandler>()
.WithHandler <VariablesHandler>()
.WithHandler <ContinueHandler>()
.WithHandler <NextHandler>()
.WithHandler <PauseHandler>()
.WithHandler <StepInHandler>()
.WithHandler <StepOutHandler>()
.WithHandler <SourceHandler>()
.WithHandler <SetVariableHandler>()
.WithHandler <DebugEvaluateHandler>()
// 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
_psesHost.DebugContext.EnableDebugMode();
BreakpointService breakpointService = server.GetService <BreakpointService>();
// Clear any existing breakpoints before proceeding
await breakpointService.RemoveAllBreakpointsAsync().ConfigureAwait(false);
})
// The OnInitialized delegate gets run right before the server responds to the _Initialize_ request:
// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Initialize
.OnInitialized((server, request, response, cancellationToken) =>
{
response.SupportsConditionalBreakpoints = true;
response.SupportsConfigurationDoneRequest = true;
response.SupportsFunctionBreakpoints = true;
response.SupportsHitConditionalBreakpoints = true;
response.SupportsLogPoints = true;
response.SupportsSetVariable = true;
return(Task.CompletedTask);
});
}).ConfigureAwait(false);
}
public override async Task <Unit> Handle(DidChangeConfigurationParams request, CancellationToken cancellationToken)
{
LanguageServerSettingsWrapper incomingSettings = request.Settings.ToObject <LanguageServerSettingsWrapper>();
_logger.LogTrace("Handling DidChangeConfiguration");
if (incomingSettings is null || incomingSettings.Powershell is null)
{
_logger.LogTrace("Incoming settings were null");
return(await Unit.Task.ConfigureAwait(false));
}
SendFeatureChangesTelemetry(incomingSettings);
bool profileLoadingPreviouslyEnabled = _configurationService.CurrentSettings.EnableProfileLoading;
bool oldScriptAnalysisEnabled =
_configurationService.CurrentSettings.ScriptAnalysis.Enable ?? false;
string oldScriptAnalysisSettingsPath =
_configurationService.CurrentSettings.ScriptAnalysis?.SettingsPath;
_configurationService.CurrentSettings.Update(
incomingSettings.Powershell,
_workspaceService.WorkspacePath,
_logger);
// We need to load the profiles if:
// - Profile loading is configured, AND
// - Profiles haven't been loaded before, OR
// - The profile loading configuration just changed
bool loadProfiles = _configurationService.CurrentSettings.EnableProfileLoading &&
(!_profilesLoaded || !profileLoadingPreviouslyEnabled);
if (!_psesHost.IsRunning)
{
_logger.LogTrace("Starting command loop");
if (loadProfiles)
{
_logger.LogTrace("Loading profiles...");
}
await _psesHost.TryStartAsync(new HostStartOptions { LoadProfiles = loadProfiles }, CancellationToken.None).ConfigureAwait(false);
if (loadProfiles)
{
_profilesLoaded = true;
_logger.LogTrace("Loaded!");
}
}
// TODO: Load profiles when the host is already running
if (!_cwdSet)
{
if (!string.IsNullOrEmpty(_configurationService.CurrentSettings.Cwd) &&
Directory.Exists(_configurationService.CurrentSettings.Cwd))
{
_logger.LogTrace($"Setting CWD (from config) to {_configurationService.CurrentSettings.Cwd}");
await _psesHost.SetInitialWorkingDirectoryAsync(
_configurationService.CurrentSettings.Cwd,
CancellationToken.None).ConfigureAwait(false);
}
else if (_workspaceService.WorkspacePath is not null &&
Directory.Exists(_workspaceService.WorkspacePath))
{
_logger.LogTrace($"Setting CWD (from workspace) to {_workspaceService.WorkspacePath}");
await _psesHost.SetInitialWorkingDirectoryAsync(
_workspaceService.WorkspacePath,
CancellationToken.None).ConfigureAwait(false);
}
else
{
_logger.LogTrace("Tried to set CWD but in bad state");
}
_cwdSet = true;
}