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 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);
}
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>());
}
/// <summary>
/// The main asynchronous program entry-point.
/// </summary>
/// <returns>
/// A <see cref="Task"/> representing program operation.
/// </returns>
static async Task AsyncMain()
{
using (NamedPipeServerProcess serverProcess = new NamedPipeServerProcess("single-process-sample", Log.Logger))
{
await serverProcess.Start();
Task clientTask = RunLanguageClient(serverProcess);
Task serverTask = RunLanguageServer(input: serverProcess.ClientOutputStream, output: serverProcess.ClientInputStream);
await Task.WhenAll(clientTask, serverTask);
}
}
public async Task GH141_CrashesWithEmptyInitializeParams()
{
var process = new NamedPipeServerProcess(Guid.NewGuid().ToString("N"), LoggerFactory);
await process.Start();
var server = LanguageServer.PreInit(x => x
.WithInput(process.ClientOutputStream)
.WithOutput(process.ClientInputStream)
.ConfigureLogging(z => z.Services.AddSingleton(LoggerFactory))
.AddHandlers(TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"), "csharp"))
) as IRequestHandler <InitializeParams, InitializeResult>;
var handler = server as IRequestHandler <InitializeParams, InitializeResult>;
Func <Task> a = async() => await handler.Handle(new InitializeParams()
{
}, CancellationToken.None);
a.Should().NotThrow();
}
public async Task Test1()
{
var logFactory = LoggerFactory.Create(a => a.AddNLog().SetMinimumLevel(LogLevel.Trace));
var serverProcess = new NamedPipeServerProcess("test", logFactory);
var languageClient = new LanguageClient(logFactory, serverProcess);
var clientInit = languageClient.Initialize("/");
var serverInit = RhetosLanguageServer.BuildLanguageServer(serverProcess.ClientOutputStream, serverProcess.ClientInputStream, builder => builder.AddNLog().AddLanguageServer().AddConsole());
Task.WaitAll(clientInit, serverInit);
Console.WriteLine(languageClient.IsConnected.ToString());
var textDocument = new TextDocumentItem()
{
Text = @"// <rhetosRootPath="""" />\nble ble ble\nblelle",
Uri = new Uri("file://ble.rhe")
};
var opened = await languageClient.SendRequest <object>(DocumentNames.DidOpen, new DidOpenTextDocumentParams()
{
TextDocument = textDocument
});
Task.Delay(2500).Wait();
var result = await languageClient.SendRequest <CompletionList>(DocumentNames.Completion, new CompletionParams()
{
TextDocument = new TextDocumentIdentifier(textDocument.Uri), Position = new Position()
});
Console.WriteLine(JsonConvert.SerializeObject(result.Items, Formatting.Indented));
Task.Delay(3000).Wait();
languageClient.Dispose();
}
/// <summary>
/// Run a language client over the specified streams.
/// </summary>
/// <param name="serverProcess">
/// The <see cref="NamedPipeServerProcess"/> used to wire up the client and server streams.
/// </param>
/// <returns>
/// A <see cref="Task"/> representing the operation.
/// </returns>
static async Task RunLanguageClient(NamedPipeServerProcess serverProcess)
{
if (serverProcess == null)
{
throw new ArgumentNullException(nameof(serverProcess));
}
Log.Information("Starting client...");
LanguageClient client = new LanguageClient(Log.Logger, serverProcess)
{
ClientCapabilities =
{
Workspace =
{
DidChangeConfiguration = new DidChangeConfigurationCapability
{
DynamicRegistration = false
}
}
}
};
using (client)
{
// Listen for log messages from the language server.
client.Window.OnLogMessage((message, messageType) =>
{
Log.Information("Language server says: [{MessageType:l}] {Message}", messageType, message);
});
// Listen for our custom notification from the language server.
client.HandleNotification <DummyParams>("dummy/notify", notification =>
{
Log.Information("Received dummy notification from language server: {Message}",
notification.Message
);
});
JObject settings = new JObject(
new JProperty("setting1", true),
new JProperty("setting2", "Hello")
);
await client.Initialize(
workspaceRoot : @"C:\Foo",
initializationOptions : settings
);
Log.Information("Client started.");
// Update server configuration.
client.Workspace.DidChangeConfiguration(settings);
// Invoke our custom handler.
await client.SendRequest("dummy", new DummyParams
{
Message = "Hello, world!"
});
Log.Information("Shutting down language client...");
await client.Shutdown();
Log.Information("Language client has shut down.");
}
}
/// <summary>
/// Create a new <see cref="PipeServerTestBase"/>.
/// </summary>
/// <param name="testOutput">
/// Output for the current test.
/// </param>
protected PipeServerTestBase(ITestOutputHelper testOutput)
: base(testOutput)
{
_serverProcess = new NamedPipeServerProcess(Guid.NewGuid().ToString("N"), LoggerFactory);
Disposal.Add(_serverProcess);
}
