public async Task RunStressPingPongTest_Libuv()
{
var endpoint = new IPEndPoint(IPAddress.Loopback, 5040);
using (var thread = new UvThread())
using (var server = new UvTcpListener(thread, endpoint))
{
server.OnConnection(PongServer);
await server.StartAsync();
const int SendCount = 500, ClientCount = 5;
for (int loop = 0; loop < ClientCount; loop++)
{
using (var connection = await new UvTcpClient(thread, endpoint).ConnectAsync())
{
try
{
var tuple = await PingClient(connection, SendCount);
Assert.Equal(SendCount, tuple.Item1);
Assert.Equal(SendCount, tuple.Item2);
Console.WriteLine($"Ping: {tuple.Item1}; Pong: {tuple.Item2}; Time: {tuple.Item3}ms");
}
finally
{
await connection.DisposeAsync();
}
}
}
}
}
public void Stop()
{
listener?.Stop();
thread?.Dispose();
listener = null;
thread = null;
}
protected override async Task Start(IPEndPoint ipEndpoint)
{
thread = new UvThread();
listener = new UvTcpListener(thread, ipEndpoint);
listener.OnConnection(async connection => { await ProcessConnection(connection); });
await listener.StartAsync();
}
public void Start(IPEndPoint endpoint, Func <IDuplexPipe, Task> callback)
{
_uvThread = new UvThread();
_listener = new UvTcpListener(_uvThread, endpoint);
_listener.OnConnection((c) => callback(c));
_listener.StartAsync().GetAwaiter().GetResult();
}
public void Stop()
{
CloseAllConnections();
listener?.Stop();
thread?.Dispose();
listener = null;
thread = null;
}
internal async Task ConnectAsync(IPEndPoint endpoint)
{
thread = new UvThread();
client = new UvTcpClient(thread, endpoint);
connection = await client.ConnectAsync();
ReadLoop(); // will hand over to libuv thread
}
public override void Dispose()
{
_uvTcpListener?.Dispose();
_uvThread?.Dispose();
_uvTcpListener = null;
_uvThread = null;
}
public virtual void Init(UvThread thread)
{
#if DEBUG
// Store weak handles to all UvRequest objects so we can do leak detection
// while running tests
thread.Requests.Add(new WeakReference(this));
#endif
}
public UvDuplexPipeClient(IEndPointInformation endPoint)
{
_awaitingResponses = new Dictionary <int, TaskCompletionSource <IMemoryOwner <byte> > >();
_connectTcs = new TaskCompletionSource <UvConnection>();
_endPoint = endPoint;
_thread = new UvThread(Log);
_thread.Post(_startConnect, this);
}
public void Start(IPEndPoint endpoint)
{
if (listener == null)
{
thread = new UvThread();
listener = new UvTcpListener(thread, endpoint);
listener.OnConnection(OnConnection);
listener.Start();
}
}
public void Stop()
{
uvThread?.Dispose();
uvListener = null;
uvThread = null;
socketListener?.Stop();
socketListener?.Dispose();
socketListener = null;
}
public void Start(IPAddress ip, int port)
{
if (listener == null)
{
thread = new UvThread();
listener = new UvTcpListener(thread, new IPEndPoint(ip, port));
listener.OnConnection(OnConnection);
listener.Start();
}
}
public void StartLibuv(IPAddress ip, int port)
{
if (uvListener == null && socketListener == null)
{
uvThread = new UvThread();
uvListener = new UvTcpListener(uvThread, new IPEndPoint(ip, port));
uvListener.OnConnection(OnConnection);
uvListener.Start();
}
}
public void Close()
{
if (connection != null)
{
Close(connection);
}
connection = null;
// client.Dispose(); //
thread?.Dispose();
thread = null;
}
public Task StartLibuvAsync(IPAddress ip, int port)
{
if (uvListener == null && socketListener == null)
{
uvThread = new UvThread();
uvListener = new UvTcpListener(uvThread, new IPEndPoint(ip, port));
uvListener.OnConnection(OnConnection);
return(uvListener.StartAsync());
}
return(Task.CompletedTask);
}
private void StartAcceptingLibuvConnections <TContext>(IHttpApplication <TContext> application, IPAddress ip, int port)
{
_uvThread = new UvThread();
_uvTcpListener = new UvTcpListener(_uvThread, new IPEndPoint(ip, port));
_uvTcpListener.OnConnection(async connection =>
{
await ProcessClient(application, connection);
});
_uvTcpListener.StartAsync();
}
private static void RunRawLibuvHttpServer()
{
// This sample makes some assumptions
var ip = IPAddress.Any;
int port = 5000;
var thread = new UvThread();
var listener = new UvTcpListener(thread, new IPEndPoint(ip, port));
listener.OnConnection(async connection =>
{
// Wait for data
var input = await connection.Input;
if (input.IsEmpty && connection.Input.Completion.IsCompleted)
{
// No more data
return;
}
// Dump the request
Console.WriteLine(input.GetAsciiString());
var formatter = connection.Output.GetFormatter(FormattingData.InvariantUtf8);
unsafe
{
formatter.Append("HTTP/1.1 200 OK");
formatter.Append("\r\nConnection: close");
formatter.Append("\r\n\r\n");
formatter.Append("Hello World!");
}
await formatter.Buffer.FlushAsync();
// Consume the input
input.Consumed();
// Close the input channel, which will tell the producer to stop producing
connection.Input.CompleteReading();
// Close the output channel, which will close the connection
connection.Output.CompleteWriting();
});
listener.Start();
Console.WriteLine($"Listening on {ip} on port {port}");
Console.ReadKey();
listener.Stop();
thread.Dispose();
}
public void Dispose()
{
_rioTcpServer?.Stop();
_listenSocket?.Dispose();
_uvTcpListener?.Dispose();
_uvThread?.Dispose();
_rioTcpServer = null;
_listenSocket = null;
_uvTcpListener = null;
_uvThread = null;
}
private static void RunServerForNode()
{
UvThread uvThread = new UvThread();
var ip = IPAddress.Any;
UvTcpListener listener = new UvTcpListener(uvThread, new IPEndPoint(ip, port));
listener.OnConnection(async connection =>
{
Interlocked.Increment(ref connectionCounter);
var input = connection.Input;
var output = connection.Output;
var flag = false;
//Used for stop sending info to connected client.
await Task.Factory.StartNew(async() =>
{
//Wait for client disconnection.
var result = await input.ReadAsync();
flag = true;
});
while (!flag)
{
try
{
WritableBuffer oBuffer = output.Alloc();
oBuffer.WriteUtf8String(DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss:ms"));
await oBuffer.FlushAsync();
Interlocked.Increment(ref sendCounter);
await Task.Delay(r.Next(0, 500));
}
catch (Exception e)
{
break;
}
}
});
listener.Start();
var pid = System.Diagnostics.Process.GetCurrentProcess().Id;
Console.WriteLine($"Listening on {ip} on port {port} / PID {pid}");
Console.ReadKey();
listener.Stop();
uvThread.Dispose();
}
public async Task CanCreateWorkingEchoServer_PipelineLibuvServer_NonPipelineClient()
{
var endpoint = new IPEndPoint(IPAddress.Loopback, 5010);
const string MessageToSend = "Hello world!";
string reply = null;
using (var thread = new UvThread())
using (var server = new UvTcpListener(thread, endpoint))
{
server.OnConnection(Echo);
await server.StartAsync();
reply = SendBasicSocketMessage(endpoint, MessageToSend);
}
Assert.Equal(MessageToSend, reply);
}
private static void TestOpenAndCloseListener()
{
var thread = new UvThread();
var ep = new IPEndPoint(IPAddress.Loopback, 5003);
var listener = new UvTcpListener(thread, ep);
listener.OnConnection(_ => Console.WriteLine("Hi and bye"));
listener.Start();
Console.WriteLine("Listening...");
Thread.Sleep(1000);
Console.WriteLine("Stopping listener...");
listener.Stop();
Thread.Sleep(1000);
Console.WriteLine("Disposing thread...");
thread.Dispose();
}
private static void Start()
{
var thread = new UvThread();
var listener = new UvTcpListener(thread, new IPEndPoint(IPAddress.Any, 5000));
listener.OnConnection(async connection =>
{
while (true)
{
// Wait for data
var result = await connection.Input.ReadAsync();
var input = result.Buffer;
var consumed = input.Start;
if (input.IsEmpty && result.IsCompleted)
{
// No more data
if (s_trace)
{
Console.WriteLine("Connection closed by client");
}
break;
}
if (s_trace)
{
Console.WriteLine($"Received {input.Length} bytes");
}
// Send response
var output = connection.Output.Alloc(s_responseMessage.Length);
s_responseMessage.CopyTo(output.Buffer);
output.Advance(s_responseMessage.Length);
await output.FlushAsync();
// Consume the input
consumed = input.Move(consumed, input.Length);
connection.Input.Advance(consumed, consumed);
}
});
listener.StartAsync().GetAwaiter().GetResult();
}
//[Fact]
public void CanCreateWorkingEchoServer_ChannelLibuvServer_NonChannelClient()
{
var endpoint = new IPEndPoint(IPAddress.Loopback, 5010);
const string MessageToSend = "Hello world!";
string reply = null;
using (var thread = new UvThread())
{
var server = new UvTcpListener(thread, endpoint);
server.OnConnection(Echo);
server.Start();
try
{
reply = SendBasicSocketMessage(endpoint, MessageToSend);
}
finally
{
server.Stop();
}
}
Assert.Equal(MessageToSend, reply);
}
private static async Task RunRawHttpClient(IPAddress ip, int port)
{
var thread = new UvThread();
var client = new UvTcpClient(thread, new IPEndPoint(ip, port));
var consoleOutput = thread.ChannelFactory.MakeWriteableChannel(Console.OpenStandardOutput());
var connection = await client.ConnectAsync();
while (true)
{
var buffer = connection.Input.Alloc();
WritableBufferExtensions.WriteAsciiString(ref buffer, "GET / HTTP/1.1");
WritableBufferExtensions.WriteAsciiString(ref buffer, "\r\n\r\n");
await buffer.FlushAsync();
// Write the client output to the console
await CopyCompletedAsync(connection.Output, consoleOutput);
await Task.Delay(1000);
}
}
public static async Task Run()
{
var thread = new UvThread();
var client = new UvTcpClient(thread, new IPEndPoint(IPAddress.Loopback, 5000));
var consoleOutput = thread.PipelineFactory.CreateWriter(Console.OpenStandardOutput());
var connection = await client.ConnectAsync();
while (true)
{
var buffer = connection.Output.Alloc();
buffer.Append("GET / HTTP/1.1", TextEncoding.Utf8);
buffer.Append("\r\n\r\n", TextEncoding.Utf8);
await buffer.FlushAsync();
// Write the client output to the console
await CopyCompletedAsync(connection.Input, consoleOutput);
await Task.Delay(1000);
}
}
public static async Task Run()
{
var thread = new UvThread();
var client = new UvTcpClient(thread, new IPEndPoint(IPAddress.Loopback, 5000));
var consoleOutput = thread.ChannelFactory.MakeWriteableChannel(Console.OpenStandardOutput());
var connection = await client.ConnectAsync();
while (true)
{
var buffer = connection.Output.Alloc();
buffer.WriteAsciiString("GET / HTTP/1.1");
buffer.WriteAsciiString("\r\n\r\n");
await buffer.FlushAsync();
// Write the client output to the console
await CopyCompletedAsync(connection.Input, consoleOutput);
await Task.Delay(1000);
}
}
public RawLibuvHttpClientSample()
{
thread = new UvThread();
client = new UvTcpClient(thread, new IPEndPoint(IPAddress.Loopback, 5000));
}
public Task Run()
{
var ip = IPAddress.Any;
int port = 5000;
var thread = new UvThread();
var listener = new UvTcpListener(thread, new IPEndPoint(ip, port));
listener.OnConnection(async connection =>
{
var pipelineConnection = MakePipeline(connection);
var decoder = new LineDecoder();
var handler = new LineHandler();
// Initialize the handler with the connection
handler.Initialize(pipelineConnection);
try
{
while (true)
{
// Wait for data
var result = await pipelineConnection.Input.ReadAsync();
var input = result.Buffer;
try
{
if (input.IsEmpty && result.IsCompleted)
{
// No more data
break;
}
while (decoder.TryDecode(ref input, out Line line))
{
await handler.HandleAsync(line);
}
if (!input.IsEmpty && result.IsCompleted)
{
// Didn't get the whole frame and the connection ended
throw new EndOfStreamException();
}
}
finally
{
// Consume the input
pipelineConnection.Input.Advance(input.Start, input.End);
}
}
}
finally
{
// Close the input, which will tell the producer to stop producing
pipelineConnection.Input.Complete();
// Close the output, which will close the connection
pipelineConnection.Output.Complete();
}
});
listener.StartAsync().GetAwaiter().GetResult();
Console.WriteLine($"Listening on {ip} on port {port}");
Console.ReadKey();
listener.Dispose();
thread.Dispose();
return(Task.CompletedTask);
}
public WriteReqPool(UvThread thread)
{
_thread = thread;
}
public WriteReqPool(UvThread thread)
{
_thread = thread;
}
public static void Run()
{
var ip = IPAddress.Any;
int port = 5000;
var thread = new UvThread();
var listener = new UvTcpListener(thread, new IPEndPoint(ip, port));
listener.OnConnection(async connection =>
{
var httpParser = new HttpRequestParser();
while (true)
{
// Wait for data
var result = await connection.Input.ReadAsync();
var input = result.Buffer;
var consumed = input.Start;
var examined = input.Start;
try
{
if (input.IsEmpty && result.IsCompleted)
{
// No more data
break;
}
// Parse the input http request
var parseResult = httpParser.ParseRequest(input, out consumed, out examined);
switch (parseResult)
{
case HttpRequestParser.ParseResult.Incomplete:
if (result.IsCompleted)
{
// Didn't get the whole request and the connection ended
throw new EndOfStreamException();
}
// Need more data
continue;
case HttpRequestParser.ParseResult.Complete:
break;
case HttpRequestParser.ParseResult.BadRequest:
throw new Exception();
default:
break;
}
// Writing directly to pooled buffers
var output = connection.Output.Alloc();
var formatter = new OutputFormatter <WritableBuffer>(output, TextEncoder.Utf8);
formatter.Append("HTTP/1.1 200 OK");
formatter.Append("\r\nContent-Length: 13");
formatter.Append("\r\nContent-Type: text/plain");
formatter.Append("\r\n\r\n");
formatter.Append("Hello, World!");
await output.FlushAsync();
httpParser.Reset();
}
finally
{
// Consume the input
connection.Input.Advance(consumed, examined);
}
}
});
listener.StartAsync().GetAwaiter().GetResult();
Console.WriteLine($"Listening on {ip} on port {port}");
var wh = new ManualResetEventSlim();
Console.CancelKeyPress += (sender, e) =>
{
wh.Set();
};
wh.Wait();
listener.Dispose();
thread.Dispose();
}