static void Main(string[] args)
{
var debugMode = args.Any(a => a.Equals("--debug", StringComparison.OrdinalIgnoreCase));
#if WAIT_FOR_DEBUGGER
while (!Debugger.IsAttached)
{
Thread.Sleep(1000);
}
Debugger.Break();
#endif
StreamWriter logWriter = null;
if (debugMode)
{
logWriter = File.CreateText("messages-" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".log");
logWriter.AutoFlush = true;
}
using (logWriter)
using (var cin = Console.OpenStandardInput())
using (var bcin = new BufferedStream(cin))
using (var cout = Console.OpenStandardOutput())
using (var reader = new PartwiseStreamMessageReader(bcin))
using (var writer = new PartwiseStreamMessageWriter(cout))
{
var contractResolver = new JsonRpcContractResolver
{
NamingStrategy = new CamelCaseJsonRpcNamingStrategy(),
ParameterValueConverter = new LanguageServiceParameterValueConverter(),
};
var clientHandler = new StreamRpcClientHandler();
var client = new JsonRpcClient(clientHandler);
if (debugMode)
{
// We want to capture log all the LSP server-to-client calls as well
clientHandler.MessageSending += (_, e) =>
{
lock (logWriter) logWriter.WriteLine("{0} <C{1}", Utility.GetTimeStamp(), e.Message);
};
clientHandler.MessageReceiving += (_, e) =>
{
lock (logWriter) logWriter.WriteLine("{0} >C{1}", Utility.GetTimeStamp(), e.Message);
};
}
// Configure & build service host
var session = new LanguageServerSession(client, contractResolver);
var host = BuildServiceHost(logWriter, contractResolver, debugMode);
var serverHandler = new StreamRpcServerHandler(host,
StreamRpcServerHandlerOptions.ConsistentResponseSequence |
StreamRpcServerHandlerOptions.SupportsRequestCancellation);
serverHandler.DefaultFeatures.Set(session);
// If we want server to stop, just stop the "source"
using (serverHandler.Attach(reader, writer))
using (clientHandler.Attach(reader, writer))
{
// Wait for the "stop" request.
session.CancellationToken.WaitHandle.WaitOne();
}
logWriter?.WriteLine("Exited");
}
}
public void Connect(bool debugMode)
{
var logWriter = CreateLogWriter(true);
using (logWriter)
using (var cin = Console.OpenStandardInput())
using (var bcin = new BufferedStream(cin))
using (var cout = Console.OpenStandardOutput())
using (var reader = new PartwiseStreamMessageReader(bcin))
using (var writer = new PartwiseStreamMessageWriter(cout)) {
var contractResolver = new JsonRpcContractResolver {
NamingStrategy = new CamelCaseJsonRpcNamingStrategy(),
ParameterValueConverter = new CamelCaseJsonValueConverter(),
};
var clientHandler = new StreamRpcClientHandler();
var client = new JsonRpcClient(clientHandler);
if (debugMode)
{
// We want to capture log all the LSP server-to-client calls as well
clientHandler.MessageSending += (_, e) => {
lock (logWriter) {
logWriter.WriteLine("<C{0}", e.Message);
}
};
clientHandler.MessageReceiving += (_, e) => {
lock (logWriter) {
logWriter.WriteLine(">C{0}", e.Message);
}
};
}
var session = new LanguageServerSession(client, contractResolver);
_serviceManager.AddService(new SettingsManager(_serviceManager));
_serviceManager.AddService(new VsCodeClient(session.Client, _serviceManager));
_serviceManager.AddService(new Controller(_serviceManager));
// Configure & build service host
var host = BuildServiceHost(logWriter, contractResolver, debugMode);
var serverHandler = new StreamRpcServerHandler(host,
StreamRpcServerHandlerOptions.ConsistentResponseSequence |
StreamRpcServerHandlerOptions.SupportsRequestCancellation);
serverHandler.DefaultFeatures.Set(session);
var cts = new CancellationTokenSource();
// If we want server to stop, just stop the "source"
using (serverHandler.Attach(reader, writer))
using (clientHandler.Attach(reader, writer))
using (new RConnection(_serviceManager, cts.Token)) {
// Wait for the "stop" request.
session.CancellationToken.WaitHandle.WaitOne();
cts.Cancel();
}
logWriter?.WriteLine("Exited");
}
}
/// <param name="manualIo">Simply read messages from console, line by line,
/// instead of using language server protocol's specification.</param>
public ConsoleIoService(bool manualIo)
{
if (manualIo)
{
ConsoleMessageReader = new ByLineTextMessageReader(Console.In);
ConsoleMessageWriter = new ByLineTextMessageWriter(Console.Out);
}
else
{
var cin = Console.OpenStandardInput();
var bcin = new BufferedStream(cin);
var cout = Console.OpenStandardOutput();
ConsoleMessageReader = new PartwiseStreamMessageReader(bcin);
ConsoleMessageWriter = new PartwiseStreamMessageWriter(cout);
}
}
static void Main(string[] args)
{
using (Stream cin = Console.OpenStandardInput())
using (BufferedStream bcin = new BufferedStream(cin))
using (Stream cout = Console.OpenStandardOutput())
using (PartwiseStreamMessageReader reader = new PartwiseStreamMessageReader(bcin))
using (PartwiseStreamMessageWriter writer = new PartwiseStreamMessageWriter(cout))
{
JsonRpcContractResolver contractResolver = new JsonRpcContractResolver
{
NamingStrategy = new CamelCaseJsonRpcNamingStrategy(),
ParameterValueConverter = new CamelCaseJsonValueConverter(),
};
StreamRpcClientHandler clientHandler = new StreamRpcClientHandler();
JsonRpcClient client = new JsonRpcClient(clientHandler);
clientHandler.MessageSending += (_, e) =>
{
Console.Error.WriteLine("Sending: " + e.Message);
};
clientHandler.MessageReceiving += (_, e) =>
{
Console.Error.WriteLine("Receiving: " + e.Message);
};
LanguageServerSession session = new LanguageServerSession(client, contractResolver);
JsonRpcServiceHostBuilder builder = new JsonRpcServiceHostBuilder {
ContractResolver = contractResolver
};
builder.UseCancellationHandling();
builder.Register(typeof(Program).GetTypeInfo().Assembly);
builder.Intercept(async(context, next) =>
{
Console.Error.WriteLine("Request: " + context.Request);
await next();
Console.Error.WriteLine("Response: " + context.Response);
});
IJsonRpcServiceHost host = builder.Build();
StreamRpcServerHandler serverHandler = new StreamRpcServerHandler(host,
StreamRpcServerHandlerOptions.ConsistentResponseSequence | StreamRpcServerHandlerOptions.SupportsRequestCancellation);
serverHandler.DefaultFeatures.Set(session);
using (serverHandler.Attach(reader, writer))
using (clientHandler.Attach(reader, writer))
{
// Wait for the "stop" request.
session.CancellationToken.WaitHandle.WaitOne();
}
}
}
public async Task PartwiseStreamWriterTest()
{
using (var stream = new MemoryStream())
{
using (var writer = new PartwiseStreamMessageWriter(stream))
{
writer.LeaveStreamOpen = true;
await writer.WriteAsync(TestMessage, CancellationToken.None);
}
stream.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(stream))
{
var text = reader.ReadToEnd();
Output.WriteLine(text);
}
Assert.Equal(TestMessagePartwiseStreamContent, stream.ToArray());
}
}
