public async Task Works_With_IWorkspaceSymbolsHandler() { var process = new NamedPipeServerProcess(Guid.NewGuid().ToString("N"), LoggerFactory); await process.Start(); var client = new LanguageClient(LoggerFactory, process); var handler = Substitute.For <IWorkspaceSymbolsHandler>(); var cts = new CancellationTokenSource(); cts.CancelAfter(1000 * 60 * 5); var serverStart = LanguageServer.From(x => x .WithInput(process.ClientOutputStream) .WithOutput(process.ClientInputStream) .ConfigureLogging(z => z.Services.AddSingleton(LoggerFactory)), cts.Token ); await Task.WhenAll( client.Initialize( Directory.GetCurrentDirectory(), new object(), cts.Token), serverStart ); using var server = await serverStart; server.AddHandlers(handler); }
static async Task Main(string[] args) { var server = await LanguageServer.From(options => options .WithInput(Console.OpenStandardInput()) .WithOutput(Console.OpenStandardOutput()) .WithLoggerFactory(new LoggerFactory()) .AddDefaultLoggingProvider() .WithServices(ConfigureServices) .WithHandler <TextDocumentSyncHandler>() .WithHandler <CompletionHandler>() .WithHandler <DefinitionHandler>() .WithHandler <SignatureHelpHandler>() .WithHandler <HoverHandler>() .OnStarted(async(languageServer, result, token) => { var configuration = await languageServer.Configuration.GetConfiguration( new ConfigurationItem { Section = "pragma" } ).ConfigureAwait(false); TextDocumentSyncHandler.includeDirectory = configuration["pragma:includeDirectory"]; }) ).ConfigureAwait(false); await server.WaitForExit; }
static async Task MainAsync(string[] args) { Log.Logger = new LoggerConfiguration() .Enrich.FromLogContext() .WriteTo.File("log.txt", rollingInterval: RollingInterval.Day) .MinimumLevel.Verbose() .CreateLogger(); Log.Logger.Information("This only goes file..."); var server = await LanguageServer.From(options => options .WithInput(Console.OpenStandardInput()) .WithOutput(Console.OpenStandardOutput()) .ConfigureLogging(x => x .AddSerilog() .AddLanguageProtocolLogging() .SetMinimumLevel(LogLevel.Trace)) .WithHandler <TextDocumentSyncHandler>() .WithHandler <CompletionHandler>() .WithHandler <SemanticTokensHandlerDl>() .WithHandler <DiagnosticsHandler>() .WithServices(x => x.AddLogging(b => b.SetMinimumLevel(LogLevel.Trace))) .WithServices(services => { services.AddSingleton <BufferManager>(); }) ); await server.WaitForExit; }
public async Task Start() { var server = Server = await LanguageServer.From(_options); server.Exit.Subscribe(Observer.Create <int>(i => _cancellationTokenSource.Cancel())); WorkspaceInitializer.Initialize(_serviceProvider, _compositionHost); var environment = _compositionHost.GetExport <IOmniSharpEnvironment>(); var logger = _compositionHost.GetExport <ILoggerFactory>().CreateLogger <LanguageServerHost>(); logger.LogInformation($"Omnisharp server running using Lsp at location '{environment.TargetDirectory}' on host {environment.HostProcessId}."); Console.CancelKeyPress += (sender, e) => { _cancellationTokenSource.Cancel(); e.Cancel = true; }; if (environment.HostProcessId != -1) { try { var hostProcess = Process.GetProcessById(environment.HostProcessId); hostProcess.EnableRaisingEvents = true; hostProcess.OnExit(() => _cancellationTokenSource.Cancel()); } catch { // If the process dies before we get here then request shutdown // immediately _cancellationTokenSource.Cancel(); } } }
static async Task MainAsync(string[] args) { /*while (!System.Diagnostics.Debugger.IsAttached) * { * await Task.Delay(100); * }*/ var server = new LanguageServer( Console.OpenStandardInput(), Console.OpenStandardOutput(), new LoggerFactory()); var manager = new GherkinManager(); server.OnInitialize(request => { manager.HandleStartup(UrlSanitizer.SanitizeUrl(request.RootUri.OriginalString)); return(Task.CompletedTask); }); server.AddHandler(new GherkinDocumentHandler(server, manager)); //server.AddHandler(new CsharpDocumentHandler(server, manager)); await server.Initialize(); await server.WaitForExit; }
public async Task TriggersStartedTask() { var startedDelegate = Substitute.For <StartedDelegate>(); startedDelegate(Arg.Any <InitializeResult>()).Returns(Task.CompletedTask); var process = new NamedPipeServerProcess(Guid.NewGuid().ToString("N"), LoggerFactory); await process.Start(); var client = new LanguageClient(LoggerFactory, process); var cts = new CancellationTokenSource(); cts.CancelAfter(TimeSpan.FromSeconds(15)); var serverStart = LanguageServer.From(x => x .OnStarted(startedDelegate) .OnStarted(startedDelegate) .OnStarted(startedDelegate) .OnStarted(startedDelegate) .WithInput(process.ClientOutputStream) .WithOutput(process.ClientInputStream) .ConfigureLogging(z => z.Services.AddSingleton(LoggerFactory)) .AddHandlers(TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"), "csharp")) , cts.Token); await Task.WhenAll( client.Initialize( Directory.GetCurrentDirectory(), new object(), cts.Token), serverStart ); using var server = await serverStart; _ = startedDelegate.Received(4)(Arg.Any <InitializeResult>()); }
public async Task Works_With_IWorkspaceSymbolsHandler() { var process = new NamedPipeServerProcess(Guid.NewGuid().ToString("N"), LoggerFactory); await process.Start(); var client = new LanguageClient(LoggerFactory, process); var handler = Substitute.For <IWorkspaceSymbolsHandler>(); var cts = new CancellationTokenSource(); cts.CancelAfter(1000 * 60 * 5); var serverStart = LanguageServer.From(x => x //.WithHandler(handler) .WithInput(process.ClientOutputStream) .WithOutput(process.ClientInputStream), //.WithLoggerFactory(LoggerFactory) //.AddDefaultLoggingProvider() //.WithMinimumLogLevel(LogLevel.Trace), cts.Token ); await Task.WhenAll( client.Initialize( Directory.GetCurrentDirectory(), new object(), cts.Token), serverStart ); var server = await serverStart; server.AddHandlers(handler); }
public static LanguageServer AddHandlers(this LanguageServer langaugeServer, IEnumerable <IJsonRpcHandler> handlers) { foreach (var handler in handlers) { langaugeServer.AddHandler(handler); } return(langaugeServer); }
public void GetHoverTextFromDocument() { var server = new LanguageServer(); server.Initialize(new InitializeParams(0, Array.Empty <WorkspaceFolder>())); server.TextDocumentDidOpen(new DidOpenTextDocumentParams(new TextDocumentItem("file:///some-uri", "some-language-id", 1, "(setf sum (+ 1 1))"))); var hover = server.TextDocumentHover(new HoverParams(new TextDocumentIdentifier("file:///some-uri"), new Position(0, 3))); Assert.Contains("(DEFMACRO SETF (...) ...)", hover.Contents.Value); }
public static void Main(string[] args) { var server = new LanguageServer(Console.OpenStandardOutput(), Console.OpenStandardInput()); server.Start(); while (true) { Thread.Sleep(500); } }
public void AddProvider(LanguageServer server, OmniSharpEnvironment environment) { if (environment.LogLevel <= LogLevel.Debug) { _provider.SetProvider(server, (category, level) => true); } else { _provider.SetProvider(server, (category, level) => LogFilter(category, level, environment)); } }
public MainWindowViewModel() { this.languageServer = new LanguageServer(Console.OpenStandardOutput(), Console.OpenStandardInput()); this.languageServer.Disconnected += OnDisconnected; this.languageServer.PropertyChanged += OnLanguageServerPropertyChanged; Tags.Add(new DiagnosticTag()); this.LogMessage = string.Empty; this.ResponseText = string.Empty; }
protected override (Stream clientOutput, Stream serverInput) SetupServer() { var clientPipe = new Pipe(TestOptions.DefaultPipeOptions); var serverPipe = new Pipe(TestOptions.DefaultPipeOptions); var server = LanguageServer.PreInit(options => { options.WithInput(serverPipe.Reader).WithOutput(clientPipe.Writer); }); server.Initialize(CancellationToken); return(clientPipe.Reader.AsStream(), serverPipe.Writer.AsStream()); }
internal static async Task Main(string[] args) { ILanguageServer server = await LanguageServer.From(options => options .WithInput(Console.OpenStandardInput()) .WithOutput(Console.OpenStandardOutput()) .WithServices(ConfigureServices) .WithHandler <GameConstantsFileDocumentSyncHandler>() ); await server.WaitForExit; }
public static async Task <ILanguageServer> BuildLanguageServer(Stream inputStream, Stream outputStream, Action <ILoggingBuilder> logBuilderAction) { var server = await LanguageServer.From(options => options .WithInput(inputStream) .WithOutput(outputStream) .ConfigureLogging(logBuilderAction) .WithHandler <TextDocumentHandler>() .WithHandler <RhetosHoverHandler>() .WithHandler <RhetosSignatureHelpHandler>() .WithHandler <RhetosCompletionHandler>() .WithServices(services => { services.AddTransient <ServerEventHandler>(); services.AddSingleton <RhetosWorkspace>(); services.AddTransient <RhetosDocumentFactory>(); services.AddSingleton <RhetosAppContext>(); services.AddSingleton <XmlDocumentationProvider>(); services.AddSingleton <ILogProvider, RhetosNetCoreLogProvider>(); services.AddSingleton <PublishDiagnosticsRunner>(); services.AddSingleton <RhetosProjectMonitor>(); services.AddSingleton <ConceptQueries>(); }) .OnInitialize((languageServer, request) => { var log = languageServer.Services.GetRequiredService <ILoggerFactory>().CreateLogger("Init"); var logFileMessage = GetLogFilePath(); if (string.IsNullOrEmpty(logFileMessage)) { logFileMessage = "No log file configuration found. Edit 'NLog.config' to add log file target."; } else { logFileMessage = $"Log file: '{logFileMessage}'."; } var localPath = new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath; log.LogInformation($"Initialized. Running server '{localPath}'. {logFileMessage}"); log.LogDebug(JsonConvert.SerializeObject(request, Formatting.Indented)); return(Task.CompletedTask); }) .OnInitialized((languageServer, request, response) => { response.Capabilities.TextDocumentSync.Kind = TextDocumentSyncKind.Full; response.Capabilities.TextDocumentSync.Options.Change = TextDocumentSyncKind.Full; languageServer.Services.GetService <PublishDiagnosticsRunner>().Start(); languageServer.Services.GetService <RhetosProjectMonitor>().Start(); return(Task.CompletedTask); }) ); return(server); }
public void GetHoverTextAfterIncrementalUpdate() { var server = new LanguageServer(); server.Initialize(new InitializeParams(0, Array.Empty <WorkspaceFolder>())); server.TextDocumentDidOpen(new DidOpenTextDocumentParams(new TextDocumentItem("file:///some-uri", "some-language-id", 1, "(defun add (a b) (+ a b))"))); // incremental update sets `Range` and `RangeLength` to non-null values server.TextDocumentDidChange(new DidChangeTextDocumentParams(new VersionedTextDocumentIdentifier("file:///some-uri", 2), new[] { new TextDocumentContentChangeEvent(new Protocol.Range(new Position(0, 1), new Position(0, 6)), 5, "defmacro") })); var hover = server.TextDocumentHover(new HoverParams(new TextDocumentIdentifier("file:///some-uri"), new Position(0, 3))); Assert.Contains("(DEFMACRO DEFMACRO (...) ...)", hover.Contents.Value); }
public void DocumentIsUpdatedWithIncrementalChangeEvent() { var server = new LanguageServer(); server.Initialize(new InitializeParams(0, Array.Empty <WorkspaceFolder>())); server.TextDocumentDidOpen(new DidOpenTextDocumentParams(new TextDocumentItem("file:///some-uri", "some-language-id", 1, "(defun add (a b) (+ a b))"))); // incremental update sets `Range` and `RangeLength` to non-null values server.TextDocumentDidChange(new DidChangeTextDocumentParams(new VersionedTextDocumentIdentifier("file:///some-uri", 2), new[] { new TextDocumentContentChangeEvent(new Protocol.Range(new Position(0, 1), new Position(0, 6)), 5, "defmacro") })); var contents = server.GetDocumentContents("file:///some-uri"); Assert.Equal("(defmacro add (a b) (+ a b))", contents); }
ICollection IManager.GetByParentKey(int key) { ArrayList langs = new ArrayList(); DataSet ds = LanguageServer.GetByCampaignID(key); foreach (DataRow row in ds.Tables["tblLanguage"].Rows) { langs.Add(new LanguageBase(row)); } return(langs); }
public static ILanguageServer BuildLanguageServer(Stream inputStream, Stream outputStream) { var server = LanguageServer.Create(options => { options .WithInput(inputStream) .WithOutput(outputStream); ConfigureLanguageServer(options, ConfigureLoggingDefaults); }); return(server); }
private static Task <ILanguageServer> CreateLanguageServer() { return(LanguageServer.From(options => options .WithInput(Console.OpenStandardInput()) .WithOutput(Console.OpenStandardOutput()) .WithLoggerFactory(new LoggerFactory()) .AddDefaultLoggingProvider() .WithMinimumLogLevel(LogLevel.Trace) .WithHandler <CompletionProvider>() .WithHandler <TextDocumentHandler>() )); }
static async Task MainAsync(string[] args) { var server = await LanguageServer.From(options => options .WithInput(Console.OpenStandardInput()) .WithOutput(Console.OpenStandardOutput()) .WithHandler <TextDocumentHandler>() .OnStarted(OnStartedCallback) ); await server.WaitForExit; }
public LanguageServerHost( Stream input, Stream output, CommandLineApplication application, CancellationTokenSource cancellationTokenSource) { _services = new ServiceCollection(); _loggerFactory = new LanguageServerLoggerFactory(); _services.AddSingleton <ILoggerFactory>(_loggerFactory); _server = new LanguageServer(input, output, _loggerFactory); _server.OnInitialize(Initialize); _application = application; _cancellationTokenSource = cancellationTokenSource; }
static async Task Main(string[] args) { var server = new LanguageServer(Console.OpenStandardInput(), Console.OpenStandardOutput(), new LoggerFactory()); var parser = new SimpleIniParser(server); server.AddHandlers( new TextDocumentHandler(server, parser), new CompletionHandler(parser) ); await server.Initialize(); await server.WaitForExit; }
static async Task MainAsync(string[] args) { var server = await LanguageServer.From(options => options .WithInput(Console.OpenStandardInput()) .WithOutput(Console.OpenStandardOutput()) .WithLoggerFactory(new LoggerFactory()) .AddDefaultLoggingProvider() .WithMinimumLogLevel(LogLevel.Trace) .WithHandler <MarkdownDocumentHandler>() ); await server.WaitForExit; }
/// <summary> /// Run a language server over the specified streams. /// </summary> /// <param name="input"> /// The input stream. /// </param> /// <param name="output"> /// The output stream. /// </param> /// <returns> /// A <see cref="Task"/> representing the operation. /// </returns> static async Task RunLanguageServer(Stream input, Stream output) { if (input == null) { throw new ArgumentNullException(nameof(input)); } if (output == null) { throw new ArgumentNullException(nameof(output)); } Log.Information("Initialising language server..."); LanguageServer languageServer = new LanguageServer(input, output, loggerFactory: new MSLogging.LoggerFactory().AddSerilog(Log.Logger.ForContext <LanguageServer>()) ); languageServer.AddHandler( new ConfigurationHandler() ); languageServer.AddHandler( new HoverHandler() ); languageServer.AddHandler( new DummyHandler(languageServer) ); languageServer.OnInitialize(parameters => { JToken options = parameters.InitializationOptions as JToken; Log.Information("Server received initialisation options: {Options}", options?.ToString(Newtonsoft.Json.Formatting.None)); return(Task.CompletedTask); }); Log.Information("Starting language server..."); languageServer.Shutdown += shutdownRequested => { Log.Information("Language server shutdown (ShutDownRequested={ShutDownRequested}).", shutdownRequested); }; languageServer.Exit += exitCode => { Log.Information("Language server exit (ExitCode={ExitCode}).", exitCode); }; await languageServer.Initialize(); Log.Information("Language server has shut down."); }
/// <summary> /// Entry point for GSharp LanguageServer. /// </summary> /// <param name="args">Command line arguments.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> public static async Task Main(string[] args) { var server = await LanguageServer.From(options => options .WithInput(Console.OpenStandardInput()) .WithOutput(Console.OpenStandardOutput()) .WithLoggerFactory(new LoggerFactory()) .AddDefaultLoggingProvider() .WithMinimumLogLevel(LogLevel.Trace) .WithServices(ConfigureServices) .WithHandler <DocumentSyncHandler>() .WithHandler <FoldingHandler>()); await server.WaitForExit; }
static async Task MainAsync(string[] args) { //while (!System.Diagnostics.Debugger.IsAttached) //{ // await Task.Delay(100); //} var server = new LanguageServer(Console.OpenStandardInput(), Console.OpenStandardOutput(), new LoggerFactory()); server.AddHandler(new TextDocumentHandler(server)); await server.Initialize(); await server.WasShutDown; }
public static Task <ILanguageServer> From(Action <LanguageServerOptions, PapyrusLanguageServerOptions> optionsAction) { var papyrusOptions = new PapyrusLanguageServerOptions(); return(LanguageServer.From((options) => { optionsAction(options, papyrusOptions); options.WithServices((collection) => collection .AddSingleton <IFileSystem, LocalFileSystem>() .AddSingleton <IXmlProjectLocator, FileSystemXmlProjectLocator>() .AddSingleton <IXmlProjectDeserializer, XmlProjectDeserializer>() .AddSingleton <IXmlProjectLoader, FileSystemXmlProjectLoader>() .AddSingleton <IScriptTextProvider, TextDocumentScriptTextProvider>((provider) => { var textProvider = provider.CreateInstance <TextDocumentScriptTextProvider>( provider.CreateInstance <FileSystemScriptTextProvider>()); AntlrPatch.SetTextProvider(textProvider); return textProvider; }) .AddSingleton <ICreationKitInisLocator>(new CreationKitInisLocator(papyrusOptions.IniLocations)) .AddSingleton <ICreationKitConfigLoader, CreationKitInisConfigLoader>() .AddSingleton((provider) => provider.CreateInstance <CreationKitProgramOptionsProvider>( papyrusOptions.AmbientProjectName, papyrusOptions.FlagsFileName, papyrusOptions.DefaultCreationKitConfig)) .AddSingleton <IProgramOptionsProvider>((provider) => provider.CreateInstance <ProjectProgramOptionsProvider>(papyrusOptions.FlagsFileName)) .AddSingleton <ProjectManager>()) .WithHandler <WorkspaceManager>() .WithHandler <DefinitionHandler>() .WithHandler <DocumentSymbolHandler>() .WithHandler <DocumentSyntaxTreeHandler>() .WithHandler <HoverHandler>() .WithHandler <CompletionHandler>() .WithHandler <SignatureHelpHandler>() .WithHandler <ReferencesHandler>() .WithHandler <RenameHandler>() .WithHandler <DocumentScriptInfoHandler>() .WithHandler <DocumentAssemblyHandler>() .WithHandler <ProjectInfosHandler>(); HarmonyPatches.Apply(); })); }
static async Task Main(string[] args) { var server = await LanguageServer.From(options => options .WithInput(Console.OpenStandardInput()) .WithOutput(Console.OpenStandardOutput()) .WithLoggerFactory(new LoggerFactory()) .AddDefaultLoggingProvider() .WithMinimumLogLevel(LogLevel.Trace) .WithServices(serviceCollection => { serviceCollection.AddSingleton <BufferManager>(); }) .WithHandler <TextDocumentSyncHandler>() ); await server.WaitForExit; }
static async Task MainAsync(string[] args) { //Debugger.Launch(); //while (!System.Diagnostics.Debugger.IsAttached) //{ // await Task.Delay(100); //} Log.Logger = new LoggerConfiguration() .Enrich.FromLogContext() .WriteTo.File("log.txt", rollingInterval: RollingInterval.Day) .CreateLogger(); Log.Logger.Information("This only goes file..."); var server = await LanguageServer.From(options => options .WithInput(Console.OpenStandardInput()) .WithOutput(Console.OpenStandardOutput()) .ConfigureLogging(x => x .AddSerilog() .AddLanguageServer() .SetMinimumLevel(LogLevel.Debug)) .WithHandler <TextDocumentHandler>() .WithHandler <DidChangeWatchedFilesHandler>() .WithHandler <FoldingRangeHandler>() .WithServices(services => { services.AddSingleton <Foo>(provider => { var loggerFactory = provider.GetService <ILoggerFactory>(); var logger = loggerFactory.CreateLogger <Foo>(); logger.LogInformation("Configuring"); return(new Foo(logger)); }); }).OnInitialize((s, request) => { var serviceProvider = s.Services; var foo = serviceProvider.GetService <Foo>(); return(Task.CompletedTask); }) ); await server.WaitForExit; }
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); } }