public DebugAdapter(ChannelBase serverChannel) : base(serverChannel)
{
this.editorSession = new EditorSession();
this.editorSession.StartSession();
this.editorSession.DebugService.DebuggerStopped += this.DebugService_DebuggerStopped;
this.editorSession.PowerShellContext.OutputWritten += this.powerShellContext_OutputWritten;
}
public DebugAdapter(ChannelBase serverChannel) : base(serverChannel)
{
this.editorSession = new EditorSession();
this.editorSession.StartSession();
this.editorSession.DebugService.DebuggerStopped += this.DebugService_DebuggerStopped;
this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
// Set up the output debouncer to throttle output event writes
this.outputDebouncer = new OutputDebouncer(this);
}
protected override void Shutdown()
{
Logger.Write(LogLevel.Normal, "Debug adapter is shutting down...");
if (this.editorSession != null)
{
this.editorSession.Dispose();
this.editorSession = null;
}
}
protected override void Shutdown()
{
Logger.Write(LogLevel.Normal, "Language service is shutting down...");
if (this.editorSession != null)
{
this.editorSession.Dispose();
this.editorSession = null;
}
}
public DebugAdapter(HostDetails hostDetails, ChannelBase serverChannel)
: base(serverChannel)
{
this.editorSession = new EditorSession();
this.editorSession.StartSession(hostDetails);
this.editorSession.DebugService.DebuggerStopped += this.DebugService_DebuggerStopped;
this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
// Set up the output debouncer to throttle output event writes
this.outputDebouncer = new OutputDebouncer(this);
}
private async void OnLanguageServiceClientConnectAsync(
object sender,
ChannelBase serverChannel)
{
MessageDispatcher messageDispatcher = new MessageDispatcher(this.logger);
ProtocolEndpoint protocolEndpoint =
new ProtocolEndpoint(
serverChannel,
messageDispatcher,
this.logger);
protocolEndpoint.UnhandledException += ProtocolEndpoint_UnhandledException;
this.editorSession =
CreateSession(
this.hostDetails,
this.profilePaths,
protocolEndpoint,
messageDispatcher,
this.enableConsoleRepl);
this.languageServer =
new LanguageServer(
this.editorSession,
messageDispatcher,
protocolEndpoint,
this.serverCompletedTask,
this.logger);
await this.editorSession.PowerShellContext.ImportCommandsModuleAsync(
Path.Combine(
Path.GetDirectoryName(this.GetType().GetTypeInfo().Assembly.Location),
@"..\Commands"));
this.languageServer.Start();
// TODO: This can be moved to the point after the $psEditor object
// gets initialized when that is done earlier than LanguageServer.Initialize
foreach (string module in this.additionalModules)
{
var command =
new System.Management.Automation.PSCommand()
.AddCommand("Microsoft.PowerShell.Core\\Import-Module")
.AddParameter("Name", module);
await this.editorSession.PowerShellContext.ExecuteCommandAsync <System.Management.Automation.PSObject>(
command,
sendOutputToHost : false,
sendErrorToHost : true);
}
protocolEndpoint.Start();
}
public LanguageServer(ChannelBase serverChannel) : base(serverChannel)
{
this.editorSession = new EditorSession();
this.editorSession.StartSession();
this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
// Always send console prompts through the UI in the language service
// TODO: This will change later once we have a general REPL available
// in VS Code.
this.editorSession.ConsoleService.PushPromptHandlerContext(
new ProtocolPromptHandlerContext(this));
}
public DocumentSymbolFeature(
EditorSession editorSession,
IMessageHandlers messageHandlers,
ILogger logger)
: base(logger)
{
this.editorSession = editorSession;
messageHandlers.SetRequestHandler(
DocumentSymbolRequest.Type,
this.HandleDocumentSymbolRequest);
}
private void OnDebugServiceClientConnect(object sender, TcpSocketServerChannel serverChannel)
{
MessageDispatcher messageDispatcher = new MessageDispatcher(this.logger);
ProtocolEndpoint protocolEndpoint =
new ProtocolEndpoint(
serverChannel,
messageDispatcher,
this.logger);
if (this.enableConsoleRepl)
{
this.debugAdapter =
new DebugAdapter(
this.editorSession,
false,
messageDispatcher,
protocolEndpoint,
this.logger);
}
else
{
EditorSession debugSession =
this.CreateDebugSession(
this.hostDetails,
profilePaths,
protocolEndpoint,
messageDispatcher,
this.languageServer?.EditorOperations,
false);
this.debugAdapter =
new DebugAdapter(
debugSession,
true,
messageDispatcher,
protocolEndpoint,
this.logger);
}
this.debugAdapter.SessionEnded +=
(obj, args) =>
{
this.logger.Write(
LogLevel.Normal,
"Previous debug session ended, restarting debug service listener...");
this.debugServiceListener.Start();
};
this.debugAdapter.Start();
protocolEndpoint.Start();
}
public void Work()
{
var types = TypeManifest.Construct(
new Type[]
{
typeof(int),
typeof(bool),
typeof(string),
},
new Type[]
{
typeof(RootModel),
typeof(ChildModel)
}
);
var manifest = new BehaviourManifest()
{
Nodes = null,
Types = types
};
var sourceObject = new RootModel()
{
FirstValue = "Lol",
AChild = new ChildModel()
{
},
BChild = null,
Children = new ChildModel[]
{
new ChildModel(),
null
},
MoreChildren = new Dictionary <string, ChildModel>()
{
["alpha"] = new ChildModel()
{
},
["beta"] = null
}
};
var editorSession = new EditorSession(manifest, sourceObject, new JsonSerializer());
DrawTree(editorSession.Root);
editorSession.Root["BChild"].SetValue(new ChildModel());
editorSession.Root["BChild"].ApplyModifiedProperties();
DrawTree(editorSession.Root);
}
protected async Task HandleInitializeRequest(
InitializeRequestArguments initializeParams,
EditorSession editorSession,
RequestContext <object, object> requestContext)
{
// Send the Initialized event first so that we get breakpoints
await requestContext.SendEvent(
InitializedEvent.Type,
null);
// Now send the Initialize response to continue setup
await requestContext.SendResult(new object());
}
protected override void Shutdown()
{
// Make sure remaining output is flushed before exiting
this.outputDebouncer.Flush().Wait();
Logger.Write(LogLevel.Normal, "Debug adapter is shutting down...");
if (this.editorSession != null)
{
this.editorSession.Dispose();
this.editorSession = null;
}
}
protected override async Task Shutdown()
{
// Make sure remaining output is flushed before exiting
await this.outputDebouncer.Flush();
Logger.Write(LogLevel.Normal, "Language service is shutting down...");
if (this.editorSession != null)
{
this.editorSession.Dispose();
this.editorSession = null;
}
}
public DebugAdapter(
EditorSession editorSession,
bool ownsEditorSession,
IMessageHandlers messageHandlers,
IMessageSender messageSender,
ILogger logger)
{
this.Logger = logger;
this.editorSession = editorSession;
this.messageSender = messageSender;
this.messageHandlers = messageHandlers;
this.ownsEditorSession = ownsEditorSession;
}
public DebugAdapter(
EditorSession editorSession,
bool ownsEditorSession,
IMessageHandlers messageHandlers,
IMessageSender messageSender,
ILogger logger)
{
Logger = logger;
_editorSession = editorSession;
_messageSender = messageSender;
_messageHandlers = messageHandlers;
_ownsEditorSession = ownsEditorSession;
}
public static void Open(EditorSession session, EditorField graphField)
{
var window = GetWindow <BehaviourEditor>();
window.Show();
window.GraphFrame = new BehaviourGraphFrame();
window.GraphFrame.View = new BehaviourEditorView();
window.GraphFrame.View.BeginSession(session, graphField);
window.GraphFrame.Window = window;
window.GraphFrame.OnEnable();
}
public EditorSessionFrame(EditorSession editorSession)
{
EditorSession = editorSession;
EditorSession.OnChanged += () =>
{
HasUnsavedChanges = true;
};
var feature = EditorSession.GetOrCreateFeature <FramedEditorSessionFeature>();
feature.Frame = this;
}
protected override void Shutdown()
{
// Make sure remaining output is flushed before exiting
this.outputDebouncer.Flush().Wait();
Logger.Write(LogLevel.Normal, "Debug adapter is shutting down...");
if (this.editorSession != null)
{
this.editorSession.Dispose();
this.editorSession = null;
}
}
public static void DrawEditor(EditorSession editor)
{
if (editor == null)
{
return;
}
EditorGUI.indentLevel++;
foreach (var field in editor.Root)
{
DrawField(field);
}
EditorGUI.indentLevel--;
}
protected async Task HandleSignatureHelpRequest(
TextDocumentPosition textDocumentPosition,
EditorSession editorSession,
RequestContext <SignatureHelp, object> requestContext)
{
ScriptFile scriptFile =
editorSession.Workspace.GetFile(
textDocumentPosition.Uri);
ParameterSetSignatures parameterSets =
await editorSession.LanguageService.FindParameterSetsInFile(
scriptFile,
textDocumentPosition.Position.Line + 1,
textDocumentPosition.Position.Character + 1);
SignatureInformation[] signatures = null;
int?activeParameter = null;
int?activeSignature = 0;
if (parameterSets != null)
{
signatures =
parameterSets
.Signatures
.Select(s =>
{
return(new SignatureInformation
{
Label = parameterSets.CommandName + " " + s.SignatureText,
Documentation = null,
Parameters =
s.Parameters
.Select(CreateParameterInfo)
.ToArray()
});
})
.ToArray();
}
else
{
signatures = new SignatureInformation[0];
}
await requestContext.SendResult(
new SignatureHelp
{
Signatures = signatures,
ActiveParameter = activeParameter,
ActiveSignature = activeSignature
});
}
public void WorkWithGenerics()
{
var manifest = BehaviourManifest.CreateFromAppDomain(AppDomain.CurrentDomain);
var generic = new GenericModel()
{
Data = JObject.FromObject(new ChildModel()),
Type = "ChildModel"
};
var editorSession = new EditorSession(manifest, generic, new JsonSerializer());
DrawTree(editorSession.Root);
}
public async Task <IActionResult> Create(EditorSession editorSession)
{
if (ModelState.IsValid)
{
//editorSession.Id = Guid.NewGuid();
editorSession.Teacher = await _userManager.GetUserAsync(User);
_context.Add(editorSession);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(editorSession));
}
protected async Task HandleHoverRequest(
TextDocumentPosition textDocumentPosition,
EditorSession editorSession,
RequestContext <Hover, object> requestContext)
{
ScriptFile scriptFile =
editorSession.Workspace.GetFile(
textDocumentPosition.Uri);
SymbolDetails symbolDetails =
await editorSession
.LanguageService
.FindSymbolDetailsAtLocation(
scriptFile,
textDocumentPosition.Position.Line + 1,
textDocumentPosition.Position.Character + 1);
List <MarkedString> symbolInfo = new List <MarkedString>();
Range?symbolRange = null;
if (symbolDetails != null)
{
symbolInfo.Add(
new MarkedString
{
Language = "PowerShell",
Value = symbolDetails.DisplayString
});
if (!string.IsNullOrEmpty(symbolDetails.Documentation))
{
symbolInfo.Add(
new MarkedString
{
Language = "markdown",
Value = symbolDetails.Documentation
});
}
symbolRange = GetRangeFromScriptRegion(symbolDetails.SymbolReference.ScriptRegion);
}
await requestContext.SendResult(
new Hover
{
Contents = symbolInfo.ToArray(),
Range = symbolRange
});
}
public EditorSessionFrame(IResource resource)
{
Resource = resource;
JObject editorTarget;
using (var editorTargetData = Resource.LoadStream())
using (var sr = new StreamReader(editorTargetData))
using (var reader = new JsonTextReader(sr))
{
editorTarget = JObject.Load(reader);
}
var manifest = BehaviourManifest.CreateFromAppDomain(AppDomain.CurrentDomain);
string typeName = null;
if (Resource.Tags.Contains("type-building"))
{
typeName = "BuildingTemplate";
}
else if (Resource.Tags.Contains("type-resource"))
{
typeName = "ResourceTemplate";
}
else if (Resource.Tags.Contains("type-buildingpack"))
{
typeName = "BuildingPackTemplate";
}
else if (Resource.Tags.Contains("gamerules"))
{
typeName = "GameRulesTemplate";
}
else
{
typeName = "ProceduralItemTemplate";
}
EditorSession = new EditorSession(manifest, editorTarget, typeName, serializer);
EditorSession.OnChanged += () =>
{
HasUnsavedChanges = true;
};
var feature = EditorSession.Root.GetOrCreateFeature <FramedEditorSessionFeature>();
feature.Frame = this;
}
public static void Open(EditorSession session, EditorObject editorObject)
{
var window = GetWindow <BehaviourEditor>();
window.Show();
window.GraphFrame = new BehaviourGraphFrame
{
View = new BehaviourEditorView()
};
window.GraphFrame.View.BeginSession(session, editorObject);
window.GraphFrame.Window = window;
window.GraphFrame.OnEnable();
}
public override async Task OnConnectedAsync()
{
string sessionId = Context.GetHttpContext().Request.Query["sessionid"];
EditorSession editorSession = await _dbContext.Sessions.Include(x => x.Teacher).SingleOrDefaultAsync(x => x.Id == Guid.Parse(sessionId)); // SingleOrDefault(x => x.Id == Guid.Parse(sessionId));
if (Context.User.Identity.Name != editorSession.Teacher.UserName)
{
await Groups.AddToGroupAsync(Context.ConnectionId, editorSession.SignalRStudentGroupName());
}
else
{
await Groups.AddToGroupAsync(Context.ConnectionId, editorSession.SignalRTeacherGroupName());
}
await base.OnConnectedAsync();
}
private async void OnLanguageServiceClientConnect(
object sender,
TcpSocketServerChannel serverChannel)
{
MessageDispatcher messageDispatcher = new MessageDispatcher(this.logger);
ProtocolEndpoint protocolEndpoint =
new ProtocolEndpoint(
serverChannel,
messageDispatcher,
this.logger);
protocolEndpoint.UnhandledException += ProtocolEndpoint_UnhandledException;
this.editorSession =
CreateSession(
this.hostDetails,
this.profilePaths,
protocolEndpoint,
messageDispatcher,
this.enableConsoleRepl);
this.languageServer =
new LanguageServer(
this.editorSession,
messageDispatcher,
protocolEndpoint,
this.logger);
await this.editorSession.PowerShellContext.ImportCommandsModule(
Path.Combine(
Path.GetDirectoryName(this.GetType().GetTypeInfo().Assembly.Location),
@"..\..\Commands"));
this.languageServer.Start();
// TODO: This can be moved to the point after the $psEditor object
// gets initialized when that is done earlier than LanguageServer.Initialize
foreach (string module in this.additionalModules)
{
await this.editorSession.PowerShellContext.ExecuteCommand <System.Management.Automation.PSObject>(
new System.Management.Automation.PSCommand().AddCommand("Import-Module").AddArgument(module),
false,
true);
}
protocolEndpoint.Start();
}
public CodeLensFeature(
EditorSession editorSession,
IMessageHandlers messageHandlers,
ILogger logger)
: base(logger)
{
this.editorSession = editorSession;
messageHandlers.SetRequestHandler(
CodeLensRequest.Type,
this.HandleCodeLensRequest);
messageHandlers.SetRequestHandler(
CodeLensResolveRequest.Type,
this.HandleCodeLensResolveRequest);
}
public DebugAdapter(
HostDetails hostDetails,
ProfilePaths profilePaths,
ChannelBase serverChannel,
IEditorOperations editorOperations)
: base(serverChannel)
{
this.editorSession = new EditorSession();
this.editorSession.StartDebugSession(hostDetails, profilePaths, editorOperations);
this.editorSession.PowerShellContext.RunspaceChanged += this.powerShellContext_RunspaceChanged;
this.editorSession.DebugService.DebuggerStopped += this.DebugService_DebuggerStopped;
this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
// Set up the output debouncer to throttle output event writes
this.outputDebouncer = new OutputDebouncer(this);
}
protected Task HandleDidCloseTextDocumentNotification(
TextDocumentIdentifier closeParams,
EditorSession editorSession,
EventContext eventContext)
{
// Find and close the file in the current session
var fileToClose = editorSession.Workspace.GetFile(closeParams.Uri);
if (fileToClose != null)
{
editorSession.Workspace.CloseFile(fileToClose);
}
Logger.Write(LogLevel.Verbose, "Finished closing document.");
return(Task.FromResult(true));
}
public LanguageServer(ChannelBase serverChannel) : base(serverChannel)
{
this.editorSession = new EditorSession();
this.editorSession.StartSession();
this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
// Always send console prompts through the UI in the language service
// TODO: This will change later once we have a general REPL available
// in VS Code.
this.editorSession.ConsoleService.PushPromptHandlerContext(
new ProtocolPromptHandlerContext(
this,
this.editorSession.ConsoleService));
// Set up the output debouncer to throttle output event writes
this.outputDebouncer = new OutputDebouncer(this);
}
protected async Task HandleDocumentSymbolRequest(
TextDocumentIdentifier textDocumentIdentifier,
EditorSession editorSession,
RequestContext <SymbolInformation[], object> requestContext)
{
ScriptFile scriptFile =
editorSession.Workspace.GetFile(
textDocumentIdentifier.Uri);
FindOccurrencesResult foundSymbols =
editorSession.LanguageService.FindSymbolsInFile(
scriptFile);
SymbolInformation[] symbols = null;
string containerName = Path.GetFileNameWithoutExtension(scriptFile.FilePath);
if (foundSymbols != null)
{
symbols =
foundSymbols
.FoundOccurrences
.Select(r =>
{
return(new SymbolInformation
{
ContainerName = containerName,
Kind = GetSymbolKind(r.SymbolType),
Location = new Location
{
Uri = new Uri(r.FilePath).AbsolutePath,
Range = GetRangeFromScriptRegion(r.ScriptRegion)
},
Name = GetDecoratedSymbolName(r)
});
})
.ToArray();
}
else
{
symbols = new SymbolInformation[0];
}
await requestContext.SendResult(symbols);
}
private static async Task DelayThenInvokeDiagnostics(
int delayMilliseconds,
ScriptFile[] filesToAnalyze,
EditorSession editorSession,
EventContext eventContext,
CancellationToken cancellationToken)
{
// First of all, wait for the desired delay period before
// analyzing the provided list of files
try
{
await Task.Delay(delayMilliseconds, cancellationToken);
}
catch (TaskCanceledException)
{
// If the task is cancelled, exit directly
return;
}
// If we've made it past the delay period then we don't care
// about the cancellation token anymore. This could happen
// when the user stops typing for long enough that the delay
// period ends but then starts typing while analysis is going
// on. It makes sense to send back the results from the first
// delay period while the second one is ticking away.
// Get the requested files
foreach (ScriptFile scriptFile in filesToAnalyze)
{
Logger.Write(LogLevel.Verbose, "Analyzing script file: " + scriptFile.FilePath);
var semanticMarkers =
editorSession.AnalysisService.GetSemanticMarkers(
scriptFile);
var allMarkers = scriptFile.SyntaxMarkers.Concat(semanticMarkers);
await PublishScriptDiagnostics(
scriptFile,
semanticMarkers,
eventContext);
}
Logger.Write(LogLevel.Verbose, "Analysis complete.");
}
public async Task PostComment(string questionId, JObject range, string comment)
{
string sessionId = Context.GetHttpContext().Request.Query["sessionid"];
SessionQuestion sessionQuestion;
if (string.IsNullOrWhiteSpace(questionId))
{
sessionQuestion = new SessionQuestion
{
StartLineNumber = range.Value <int>("startLineNumber"),
StartColumn = range.Value <int>("startColumn"),
EndLineNumber = range.Value <int>("endLineNumber"),
EndColumn = range.Value <int>("endColumn"),
AskedBy = await _userManager.GetUserAsync(Context.User)
};
EditorSession editorSession = await _dbContext.Sessions.FindAsync(Guid.Parse(sessionId));
editorSession.Questions.Add(sessionQuestion);
}
else
{
sessionQuestion = await _dbContext.SessionQuestions.FindAsync(Guid.Parse(questionId));
}
SessionQuestionComment sessionQuestionComment = new SessionQuestionComment
{
Text = comment,
User = await _userManager.GetUserAsync(Context.User)
};
sessionQuestion.Comments.Add(sessionQuestionComment);
_dbContext.SaveChanges();
if (string.IsNullOrWhiteSpace(questionId))
{
await Clients.Group($"{sessionId}_Teachers").SendCoreAsync("QuestionPosted", new object[] { sessionQuestion });
await Clients.Client(Context.ConnectionId).SendCoreAsync("QuestionPosted", new object[] { sessionQuestion });
}
else
{
await Clients.All.SendCoreAsync("CommentPosted", new object[] { sessionQuestion.Id, sessionQuestionComment });
}
}
protected async Task HandleScopesRequest(
ScopesRequestArguments scopesParams,
EditorSession editorSession,
RequestContext <ScopesResponseBody, object> requestContext)
{
VariableScope[] variableScopes =
editorSession.DebugService.GetVariableScopes(
scopesParams.FrameId);
await requestContext.SendResult(
new ScopesResponseBody
{
Scopes =
variableScopes
.Select(Scope.Create)
.ToArray()
});
}
public DebuggerService2(RunbookViewModel runbookViewModel)
{
Logger.Initialize(Path.Combine(AppHelper.CachePath, "PowerShellEditorServices.log"), LogLevel.Verbose);
/*_powerShell = new PowerShellContext();
* _workspace = new Workspace(_powerShell.PowerShellVersion);
*
* _debugService = new DebugService(_powerShell);
* _debugService.DebuggerStopped += OnDebugStopped;*/
_editorSession = new EditorSession();
_editorSession.StartSession();
_editorSession.DebugService.DebuggerStopped += OnDebugStopped;
_editorSession.ConsoleService.OutputWritten += OnConsoleOutputWritten;
_runbookViewModel = runbookViewModel;
_breakpoints = new List <LineBreakpoint>();
}
private static async Task DelayThenInvokeDiagnostics(
int delayMilliseconds,
ScriptFile[] filesToAnalyze,
EditorSession editorSession,
EventContext eventContext,
CancellationToken cancellationToken)
{
// First of all, wait for the desired delay period before
// analyzing the provided list of files
try
{
await Task.Delay(delayMilliseconds, cancellationToken);
}
catch (TaskCanceledException)
{
// If the task is cancelled, exit directly
return;
}
// If we've made it past the delay period then we don't care
// about the cancellation token anymore. This could happen
// when the user stops typing for long enough that the delay
// period ends but then starts typing while analysis is going
// on. It makes sense to send back the results from the first
// delay period while the second one is ticking away.
// Get the requested files
foreach (ScriptFile scriptFile in filesToAnalyze)
{
Logger.Write(LogLevel.Verbose, "Analyzing script file: " + scriptFile.FilePath);
var semanticMarkers =
editorSession.AnalysisService.GetSemanticMarkers(
scriptFile);
var allMarkers = scriptFile.SyntaxMarkers.Concat(semanticMarkers);
await PublishScriptDiagnostics(
scriptFile,
semanticMarkers,
eventContext);
}
Logger.Write(LogLevel.Verbose, "Analysis complete.");
}
private Task RunScriptDiagnostics(
ScriptFile[] filesToAnalyze,
EditorSession editorSession,
EventContext eventContext)
{
if (!this.currentSettings.ScriptAnalysis.Enable.Value)
{
// If the user has disabled script analysis, skip it entirely
return Task.FromResult(true);
}
// If there's an existing task, attempt to cancel it
try
{
if (existingRequestCancellation != null)
{
// Try to cancel the request
existingRequestCancellation.Cancel();
// If cancellation didn't throw an exception,
// clean up the existing token
existingRequestCancellation.Dispose();
existingRequestCancellation = null;
}
}
catch (Exception e)
{
// TODO: Catch a more specific exception!
Logger.Write(
LogLevel.Error,
string.Format(
"Exception while cancelling analysis task:\n\n{0}",
e.ToString()));
TaskCompletionSource<bool> cancelTask = new TaskCompletionSource<bool>();
cancelTask.SetCanceled();
return cancelTask.Task;
}
// Create a fresh cancellation token and then start the task.
// We create this on a different TaskScheduler so that we
// don't block the main message loop thread.
// TODO: Is there a better way to do this?
existingRequestCancellation = new CancellationTokenSource();
Task.Factory.StartNew(
() =>
DelayThenInvokeDiagnostics(
750,
filesToAnalyze,
editorSession,
eventContext,
existingRequestCancellation.Token),
CancellationToken.None,
TaskCreationOptions.None,
TaskScheduler.Default);
return Task.FromResult(true);
}
public Task ProcessMessage(
EditorSession editorSession,
MessageWriter messageWriter)
{
return Task.FromResult(false);
}
public LanguageServer(ChannelBase serverChannel) : base(serverChannel)
{
this.editorSession = new EditorSession();
this.editorSession.StartSession();
this.editorSession.PowerShellContext.OutputWritten += this.powerShellContext_OutputWritten;
}
async Task ListenForMessages()
{
this.messageLoopSyncContext = SynchronizationContext.Current;
// Ensure that the console is using UTF-8 encoding
System.Console.InputEncoding = Encoding.UTF8;
System.Console.OutputEncoding = Encoding.UTF8;
// Open the standard input/output streams
this.inputStream = System.Console.OpenStandardInput();
this.outputStream = System.Console.OpenStandardOutput();
IMessageSerializer messageSerializer = null;
IMessageProcessor messageProcessor = null;
// Use a different serializer and message processor based
// on whether this instance should host a language server
// debug adapter.
if (this.runDebugAdapter)
{
DebugAdapter debugAdapter = new DebugAdapter();
debugAdapter.Initialize();
messageProcessor = debugAdapter;
messageSerializer = new V8MessageSerializer();
}
else
{
// Set up the LanguageServer
LanguageServer languageServer = new LanguageServer();
languageServer.Initialize();
messageProcessor = languageServer;
messageSerializer = new JsonRpcMessageSerializer();
}
// Set up the reader and writer
this.messageReader =
new MessageReader(
this.inputStream,
messageSerializer);
this.messageWriter =
new MessageWriter(
this.outputStream,
messageSerializer);
// Set up the console host which will send events
// through the MessageWriter
this.consoleHost = new StdioConsoleHost(messageWriter);
// Set up the PowerShell session
this.editorSession = new EditorSession();
this.editorSession.StartSession(this.consoleHost);
this.editorSession.PowerShellContext.OutputWritten += powerShellContext_OutputWritten;
if (this.runDebugAdapter)
{
// Attach to debugger events from the PowerShell session
this.editorSession.DebugService.DebuggerStopped += DebugService_DebuggerStopped;
}
// Run the message loop
bool isRunning = true;
while (isRunning)
{
Message newMessage = null;
try
{
// Read a message from stdin
newMessage = await this.messageReader.ReadMessage();
}
catch (MessageParseException e)
{
// TODO: Write an error response
Logger.Write(
LogLevel.Error,
"Could not parse a message that was received:\r\n\r\n" +
e.ToString());
// Continue the loop
continue;
}
// Process the message
await messageProcessor.ProcessMessage(
newMessage,
this.editorSession,
this.messageWriter);
}
}
