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);
}
}
