public async Task <Unit> Handle(PsesLaunchRequestArguments request, CancellationToken cancellationToken)
{
_debugEventHandlerService.RegisterEventHandlers();
// Determine whether or not the working directory should be set in the PowerShellContext.
if ((_powerShellContextService.CurrentRunspace.Location == RunspaceLocation.Local) &&
!_debugService.IsDebuggerStopped)
{
// Get the working directory that was passed via the debug config
// (either via launch.json or generated via no-config debug).
string workingDir = request.Cwd;
// Assuming we have a non-empty/null working dir, unescape the path and verify
// the path exists and is a directory.
if (!string.IsNullOrEmpty(workingDir))
{
try
{
if ((File.GetAttributes(workingDir) & FileAttributes.Directory) != FileAttributes.Directory)
{
workingDir = Path.GetDirectoryName(workingDir);
}
}
catch (Exception ex)
{
workingDir = null;
_logger.LogError(
$"The specified 'cwd' path is invalid: '{request.Cwd}'. Error: {ex.Message}");
}
}
// If we have no working dir by this point and we are running in a temp console,
// pick some reasonable default.
if (string.IsNullOrEmpty(workingDir) && request.CreateTemporaryIntegratedConsole)
{
workingDir = Environment.CurrentDirectory;
}
// At this point, we will either have a working dir that should be set to cwd in
// the PowerShellContext or the user has requested (via an empty/null cwd) that
// the working dir should not be changed.
if (!string.IsNullOrEmpty(workingDir))
{
await _powerShellContextService.SetWorkingDirectoryAsync(workingDir, isPathAlreadyEscaped : false).ConfigureAwait(false);
}
_logger.LogTrace($"Working dir " + (string.IsNullOrEmpty(workingDir) ? "not set." : $"set to '{workingDir}'"));
}
// Prepare arguments to the script - if specified
string arguments = null;
if ((request.Args != null) && (request.Args.Length > 0))
{
arguments = string.Join(" ", request.Args);
_logger.LogTrace("Script arguments are: " + arguments);
}
// Store the launch parameters so that they can be used later
_debugStateService.NoDebug = request.NoDebug;
_debugStateService.ScriptToLaunch = request.Script;
_debugStateService.Arguments = arguments;
_debugStateService.IsUsingTempIntegratedConsole = request.CreateTemporaryIntegratedConsole;
if (request.CreateTemporaryIntegratedConsole &&
!string.IsNullOrEmpty(request.Script) &&
ScriptFile.IsUntitledPath(request.Script))
{
throw new RpcErrorException(0, "Running an Untitled file in a temporary integrated console is currently not supported.");
}
// If the current session is remote, map the script path to the remote
// machine if necessary
if (_debugStateService.ScriptToLaunch != null &&
_powerShellContextService.CurrentRunspace.Location == RunspaceLocation.Remote)
{
_debugStateService.ScriptToLaunch =
_remoteFileManagerService.GetMappedPath(
_debugStateService.ScriptToLaunch,
_powerShellContextService.CurrentRunspace);
}
// If no script is being launched, mark this as an interactive
// debugging session
_debugStateService.IsInteractiveDebugSession = string.IsNullOrEmpty(_debugStateService.ScriptToLaunch);
// Send the InitializedEvent so that the debugger will continue
// sending configuration requests
_jsonRpcServer.SendNotification(EventNames.Initialized);
return(Unit.Value);
}
public override async Task <Unit> Handle(DidChangeConfigurationParams request, CancellationToken cancellationToken)
{
LanguageServerSettingsWrapper incomingSettings = request.Settings.ToObject <LanguageServerSettingsWrapper>();
if (incomingSettings == 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);
if (!this._cwdSet)
{
if (!string.IsNullOrEmpty(_configurationService.CurrentSettings.Cwd) &&
Directory.Exists(_configurationService.CurrentSettings.Cwd))
{
await _powerShellContextService.SetWorkingDirectoryAsync(
_configurationService.CurrentSettings.Cwd,
isPathAlreadyEscaped : false).ConfigureAwait(false);
}
else if (_workspaceService.WorkspacePath != null &&
Directory.Exists(_workspaceService.WorkspacePath))
{
await _powerShellContextService.SetWorkingDirectoryAsync(
_workspaceService.WorkspacePath,
isPathAlreadyEscaped : false).ConfigureAwait(false);
}
this._cwdSet = true;
}
// 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
if (_configurationService.CurrentSettings.EnableProfileLoading &&
(!this._profilesLoaded || !profileLoadingPreviouslyEnabled))
{
await _powerShellContextService.LoadHostProfilesAsync().ConfigureAwait(false);
this._profilesLoaded = true;
}
// Wait until after profiles are loaded (or not, if that's the
// case) before starting the interactive console.
if (!this._consoleReplStarted)
{
// Start the interactive terminal
_powerShellContextService.ConsoleReader.StartCommandLoop();
this._consoleReplStarted = true;
}
// Run any events subscribed to configuration updates
ConfigurationUpdated(this, _configurationService.CurrentSettings);
// Convert the editor file glob patterns into an array for the Workspace
// Both the files.exclude and search.exclude hash tables look like (glob-text, is-enabled):
// "files.exclude" : {
// "Makefile": true,
// "*.html": true,
// "build/*": true
// }
var excludeFilePatterns = new List <string>();
if (incomingSettings.Files?.Exclude != null)
{
foreach (KeyValuePair <string, bool> patternEntry in incomingSettings.Files.Exclude)
{
if (patternEntry.Value)
{
excludeFilePatterns.Add(patternEntry.Key);
}
}
}
if (incomingSettings.Search?.Exclude != null)
{
foreach (KeyValuePair <string, bool> patternEntry in incomingSettings.Search.Exclude)
{
if (patternEntry.Value && !excludeFilePatterns.Contains(patternEntry.Key))
{
excludeFilePatterns.Add(patternEntry.Key);
}
}
}
_workspaceService.ExcludeFilesGlob = excludeFilePatterns;
// Convert the editor file search options to Workspace properties
if (incomingSettings.Search?.FollowSymlinks != null)
{
_workspaceService.FollowSymlinks = incomingSettings.Search.FollowSymlinks;
}
return(await Unit.Task.ConfigureAwait(false));
}
