public async Task T10_Receive_Observable() { var server = RxSocketServer.Create(SocketServerLogger); var endPoint = server.IPEndPoint; var acceptTask = server.AcceptAllAsync().FirstAsync(); var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger); var accept = await acceptTask; var sub = client.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().Subscribe(str => { Write(str); }); accept.Send("Welcome!".ToByteArray()); accept.Send("Welcome Again!".ToByteArray()); await Task.Delay(100); sub.Dispose(); await server.DisposeAsync(); await client.DisposeAsync(); }
public async Task T00_SendAndReceiveStringMessage() { // Create a socket server on the endpoint. var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger); // Start a task to allow the server to accept the next client connection. var acceptTask = server.AcceptObservable.FirstAsync().ToTask(); // Create a socket client by successfully connecting to the server at EndPoint. var client = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger); // Get the client socket accepted by the server. var accept = await acceptTask; Assert.True(accept.Connected && client.Connected); // start a task to receive the first string from the server. var dataTask = client.ReceiveObservable.ToStrings().FirstAsync().ToTask(); // The server sends a string to the client. accept.Send("Welcome!".ToByteArray()); Assert.Equal("Welcome!", await dataTask); client.Dispose(); server.Dispose(); }
public async Task T01_Send_And_Receive_String_Message() { var server = RxSocketServer.Create(SocketServerLogger); var ipEndPoint = server.IPEndPoint; // Start a task to allow the server to accept the next client connection. var acceptTask = server.AcceptAllAsync().FirstAsync(); // Create a socket client by successfully connecting to the server at EndPoint. var client = await ipEndPoint.CreateRxSocketClientAsync(SocketClientLogger); // Get the client socket accepted by the server. var accept = await acceptTask; Assert.True(accept.Connected && client.Connected); // start a task to receive the first string from the server. var dataTask = client.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().FirstAsync().ToTask(); // The server sends a string to the client. accept.Send("Welcome!".ToByteArray()); Assert.Equal("Welcome!", await dataTask); await client.DisposeAsync(); await server.DisposeAsync(); }
public async Task T20_Accept_Observable() { var s = String.Create <double>(10, 99, (span, state) => { //Span<char> xxx; span[1] = 's'; //span. return; }); var server = RxSocketServer.Create(SocketServerLogger); var endPoint = server.IPEndPoint; server.AcceptAllAsync().ToObservableFromAsyncEnumerable() .Subscribe(accepted => accepted.Send("Welcome!".ToByteArray())); var client1 = await endPoint.CreateRxSocketClientAsync(SocketClientLogger); var client2 = await endPoint.CreateRxSocketClientAsync(SocketClientLogger); var client3 = await endPoint.CreateRxSocketClientAsync(SocketClientLogger); Assert.Equal("Welcome!", await client1.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().Take(1).FirstAsync()); Assert.Equal("Welcome!", await client2.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().Take(1).FirstAsync()); Assert.Equal("Welcome!", await client3.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().Take(1).FirstAsync()); await client1.DisposeAsync(); await client2.DisposeAsync(); await client3.DisposeAsync(); await server.DisposeAsync(); }
public async Task Example() { // Create a server using a random available port on the local machine. IRxSocketServer server = RxSocketServer.Create(); // Start accepting connections from clients. server.AcceptAllAsync().ToObservableFromAsyncEnumerable().Subscribe(acceptClient => { // After the server accepts a client connection, // start receiving messages from the client and ... acceptClient.ReceiveAllAsync().ToObservableFromAsyncEnumerable().ToStrings().Subscribe(message => { // echo each message received back to the client. acceptClient.Send(message.ToByteArray()); }); }); // Find the address of the server. var ipEndPoint = server.IPEndPoint; // Create a client by connecting to the server. IRxSocketClient client = await ipEndPoint.CreateRxSocketClientAsync(); // Send the message "Hello" to the server, which the server will then echo back to the client. client.Send("Hello!".ToByteArray()); // Receive the message from the server. string message = await client.ReceiveAllAsync().ToStrings().FirstAsync(); Assert.Equal("Hello!", message); await client.DisposeAsync(); await server.DisposeAsync(); }
public async Task T00_Example() { // Create a socket server on the Endpoint. var server = RxSocketServer.Create(IPEndPoint); // Start accepting connections from clients. server.AcceptObservable.Subscribe(acceptClient => { acceptClient.ReceiveObservable.ToStrings().Subscribe(onNext: message => { // Echo each message received back to the client. acceptClient.Send(message.ToByteArray()); }); }); // Create a socket client by connecting to the server at EndPoint. var client = await RxSocketClient.ConnectAsync(IPEndPoint); client.ReceiveObservable.ToStrings().Subscribe(onNext: message => { Assert.Equal("Hello!", message); }); client.Send("Hello!".ToByteArray()); await Task.Delay(100); client.Dispose(); server.Dispose(); }
public async Task T30_Both() { var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger); //.AddDisconnectableTo(disconnectables); server.AcceptObservable.Subscribe(accepted => { "Welcome!".ToByteArray().SendTo(accepted); accepted .ReceiveObservable .ToStrings() .Subscribe(s => s.ToByteArray().SendTo(accepted)); }); var clients = new List <IRxSocketClient>(); for (var i = 0; i < 10; i++) { var client = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger); client.Send("Hello".ToByteArray()); clients.Add(client); } foreach (var client in clients) { Assert.Equal("Hello", await client.ReceiveObservable.ToStrings().Skip(1).Take(1).FirstAsync()); } foreach (var client in clients) { client.Dispose(); } server.Dispose(); }
public async Task T06_Dispose_During_Send() { var server = RxSocketServer.Create(SocketServerLogger); var endPoint = server.IPEndPoint; var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger); var sendTask = Task.Run(() => client.Send(new byte[100_000_000]));
public async Task T05_Dispose_Before_Send() { var server = RxSocketServer.Create(SocketServerLogger); var endPoint = server.IPEndPoint; var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger); await client.DisposeAsync(); Assert.ThrowsAny <Exception>(() => client.Send(new byte[] { 0 })); await server.DisposeAsync(); }
public async Task T01_Dispose_Before_Receive() { var server = RxSocketServer.Create(SocketServerLogger); var client = await server.IPEndPoint.CreateRxSocketClientAsync(SocketClientLogger); await client.DisposeAsync(); await Assert.ThrowsAsync <ObjectDisposedException>(async() => await client.ReceiveAllAsync().ToListAsync()); await server.DisposeAsync(); }
public async Task T04_DisconnectWhileAccept() { var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger); var acceptTask = server.AcceptObservable.LastOrDefaultAsync().ToTask(); await Task.Delay(100); server.Dispose(); //Assert.Equal(SocketError.Success, error); var result = await acceptTask; Assert.Null(result); }
public async Task T01_Handshake() { var server = RxSocketServer.Create(SocketServerLogger); var endPoint = server.IPEndPoint; server.AcceptAllAsync().ToObservableFromAsyncEnumerable().Subscribe(async acceptClient => { var message1 = await acceptClient.ReceiveAllAsync().ToStrings().FirstAsync(); Assert.Equal("Hello1FromClient", message1); acceptClient.Send(new[] { "Hello1FromServer" }.ToByteArray()); var messages = await acceptClient.ReceiveAllAsync().ToArraysFromBytesWithLengthPrefix().ToStringArrays().FirstAsync(); Assert.Equal("Hello2FromClient", messages[0]); acceptClient.Send(new[] { "Hello2FromServer" }.ToByteArray().ToByteArrayWithLengthPrefix()); acceptClient.Send(new[] { "Hello3FromServer" }.ToByteArray().ToByteArrayWithLengthPrefix()); }); var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger); // Send the first message without prefix. client.Send("Hello1FromClient".ToByteArray()); // Receive the response message without prefix. var message1 = await client.ReceiveAllAsync().ToStrings().FirstAsync(); Assert.Equal("Hello1FromServer", message1); // Start sending and receiving messages with an int32 message length prefix. client.Send(new[] { "Hello2FromClient" }.ToByteArray().ToByteArrayWithLengthPrefix()); var message3 = await client.ReceiveAllAsync().ToArraysFromBytesWithLengthPrefix().ToStringArrays().FirstAsync(); Assert.Equal("Hello2FromServer", message3.Single()); client.ReceiveAllAsync() .ToArraysFromBytesWithLengthPrefix() .ToStringArrays() .ToObservableFromAsyncEnumerable() .Subscribe(x => { Logger.LogInformation(x[0]); }); await Task.Delay(10); await client.DisposeAsync(); await server.DisposeAsync(); }
public async Task T00_All_Ok() { var server = RxSocketServer.Create(SocketServerLogger); var client = await server.IPEndPoint.CreateRxSocketClientAsync(Logger); //await server.AcceptObservable.FirstAsync(); //await server.AcceptAllAsync().ToObservableFromAsyncEnumerable().FirstAsync(); await server.AcceptAllAsync().FirstAsync(); await client.DisposeAsync(); await server.DisposeAsync(); }
public async Task T03_External_Dispose_Before_Receive() { var server = RxSocketServer.Create(SocketServerLogger); var client = await server.IPEndPoint.CreateRxSocketClientAsync(SocketClientLogger); var accept = await server.AcceptAllAsync().FirstAsync(); await accept.DisposeAsync(); await client.ReceiveAllAsync().LastOrDefaultAsync(); await client.DisposeAsync(); await server.DisposeAsync(); }
public async Task T02_Dispose_During_Receive() { var server = RxSocketServer.Create(SocketServerLogger); var client = await server.IPEndPoint.CreateRxSocketClientAsync(SocketClientLogger); var receiveTask = client.ReceiveAllAsync().LastOrDefaultAsync(); //await Task.Delay(100); await client.DisposeAsync(); //await Assert.ThrowsAsync<SocketException>(async () => // await receiveTask); await receiveTask; await server.DisposeAsync(); }
public async Task T04_External_Dispose_During_Receive() { var server = RxSocketServer.Create(SocketServerLogger); var client = await server.IPEndPoint.CreateRxSocketClientAsync(SocketClientLogger); var accept = await server.AcceptAllAsync().FirstAsync(); var receiveTask = client.ReceiveAllAsync().FirstAsync(); await accept.DisposeAsync(); await Assert.ThrowsAsync <InvalidOperationException>(async() => await receiveTask); await client.DisposeAsync(); await server.DisposeAsync(); }
public async Task T02_AcceptSuccess() { var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger); var acceptTask = server.AcceptObservable.FirstAsync().ToTask(); var clientSocket = Utilities.CreateSocket(); clientSocket.Connect(IPEndPoint); var acceptedSocket = await acceptTask; Assert.True(clientSocket.Connected && acceptedSocket.Connected); acceptedSocket.Dispose(); clientSocket.Disconnect(false); server.Dispose(); }
public async Task T02_ReceiveStringsFromPrefixedBytes() { var server = RxSocketServer.Create(); var endPoint = server.IPEndPoint; var acceptFirstClientTask = server.AcceptAllAsync().FirstAsync(); var client = await endPoint.CreateRxSocketClientAsync(); Assert.True(client.Connected); var countTask = client.ReceiveAllAsync().ToArraysFromBytesWithLengthPrefix().ToStringArrays().CountAsync(); var acceptClient = await acceptFirstClientTask; Assert.True(acceptClient.Connected); var message = new[] { "Welcome!" }.ToByteArray().ToByteArrayWithLengthPrefix(); var watch = new Stopwatch(); watch.Start(); for (var i = 0; i < numberOfMessages; i++) { acceptClient.Send(message); } // end count task await acceptClient.DisposeAsync(); int count = await countTask; watch.Stop(); Assert.Equal(numberOfMessages, count); var frequency = Stopwatch.Frequency * numberOfMessages / watch.ElapsedTicks; Write($"{frequency:N0} messages / second"); await client.DisposeAsync(); await server.DisposeAsync(); }
public async Task T02_ReceiveStringsFromPrefixedBytes() { //var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger); var server = RxSocketServer.Create(IPEndPoint); var acceptTask = server.AcceptObservable.FirstAsync().ToTask(); //var client = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger); var client = await RxSocketClient.ConnectAsync(IPEndPoint); Assert.True(client.Connected); var countTask = client.ReceiveObservable.ToByteArrayOfLengthPrefix().ToStringArray().Count().ToTask(); var accept = await acceptTask; Assert.True(accept.Connected); var message = new [] { "Welcome!" }.ToByteArrayWithLengthPrefix(); var watch = new Stopwatch(); watch.Start(); for (var i = 0; i < messages; i++) { accept.Send(message); } accept.Dispose(); int count = await countTask; watch.Stop(); Assert.Equal(messages, count); var frequency = Stopwatch.Frequency * messages / watch.ElapsedTicks; Write($"{frequency:N0} messages / second"); client.Dispose(); server.Dispose(); }
public async Task T40_Client_Disconnect() { var semaphore = new SemaphoreSlim(0, 1); var server = RxSocketServer.Create(SocketServerLogger); var endPoint = server.IPEndPoint; IRxSocketClient?acceptClient = null; server.AcceptAllAsync().ToObservableFromAsyncEnumerable().Subscribe(ac => { acceptClient = ac; semaphore.Release(); acceptClient.ReceiveAllAsync().ToObservableFromAsyncEnumerable().ToStrings().Subscribe(onNext: message => { acceptClient.Send(message.ToByteArray()); }); }); var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger); client.ReceiveAllAsync().ToObservableFromAsyncEnumerable().ToStrings().Subscribe(onNext: message => { Write(message); }); client.Send("Hello!".ToByteArray()); await semaphore.WaitAsync(); if (acceptClient is null) { throw new NullReferenceException(nameof(acceptClient)); } await server.DisposeAsync(); await client.DisposeAsync(); semaphore.Dispose(); }
public async Task T10_ReceiveObservable() { var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger); var acceptTask = server.AcceptObservable.FirstAsync().ToTask(); var client = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger); var accept = await acceptTask; Assert.True(accept.Connected && client.Connected); client.ReceiveObservable.ToStrings().Subscribe(str => { Write(str); }); accept.Send("Welcome!".ToByteArray()); "Welcome Again!".ToByteArray().SendTo(accept); // Note SendTo() extension method. client.Dispose(); server.Dispose(); }
public async Task T01_ReceiveStrings() { var server = RxSocketServer.Create(IPEndPoint); var acceptTask = server.AcceptObservable.FirstAsync().ToTask(); var client = await RxSocketClient.ConnectAsync(IPEndPoint); Assert.True(client.Connected); var countTask = client.ReceiveObservable.ToStrings().Count().ToTask(); var accept = await acceptTask; Assert.True(accept.Connected); var watch = new Stopwatch(); watch.Start(); // send messages from server to client var message = "Welcome!".ToByteArray(); for (var i = 0; i < messages; i++) { accept.Send(message); } accept.Dispose(); var count = await countTask; watch.Stop(); Assert.Equal(messages, count); var frequency = Stopwatch.Frequency * messages / watch.ElapsedTicks; Write($"{frequency:N0} messages / second"); client.Dispose(); server.Dispose(); }
public async Task T00_Example() { // Create a socket server. var server = RxSocketServer.Create(SocketServerLogger); // The IPEndPoint is chosen automatically. var ipEndPoint = server.IPEndPoint; // Start accepting connections from clients. server.AcceptAllAsync().ToObservableFromAsyncEnumerable().Subscribe(acceptClient => { // After the server accepts a client connection... acceptClient.ReceiveAllAsync().ToStrings().ToObservable().Subscribe(onNext: message => { // Echo each message received back to the client. acceptClient.Send(message.ToByteArray()); }); }); // Create a socket client by first connecting to the server at the EndPoint. var client = await ipEndPoint.CreateRxSocketClientAsync(SocketClientLogger); // Start receiving messages from the server. client.ReceiveAllAsync().ToStrings().ToObservableFromAsyncEnumerable().Subscribe(onNext: message => { // The message received from the server is "Hello!". Assert.Equal("Hello!", message); }); // Send the message "Hello" to the server (which will be echoed back to the client). client.Send("Hello!".ToByteArray()); await Task.Delay(100); // Disconnect and dispose. await client.DisposeAsync(); await server.DisposeAsync(); }
public async Task T01_ReceiveStrings() { var server = RxSocketServer.Create(); var endPoint = server.IPEndPoint; var acceptFirstClientTask = server.AcceptAllAsync().FirstAsync(); var client = await endPoint.CreateRxSocketClientAsync(); var acceptClient = await acceptFirstClientTask; var countTask = acceptClient.ReceiveAllAsync().ToStrings().CountAsync(); var watch = new Stopwatch(); watch.Start(); // send messages from server to client var message = "Welcome!".ToByteArray(); for (var i = 0; i < numberOfMessages; i++) { client.Send(message); } // end countTask await client.DisposeAsync(); var count = await countTask; watch.Stop(); Assert.Equal(numberOfMessages, count); var frequency = Stopwatch.Frequency * numberOfMessages / watch.ElapsedTicks; Write($"{frequency:N0} messages / second"); await server.DisposeAsync(); }
public async Task T30_Both() { var server = RxSocketServer.Create(SocketServerLogger); var endPoint = server.IPEndPoint; server.AcceptAllAsync().ToObservableFromAsyncEnumerable().Subscribe(accepted => { accepted.Send("Welcome!".ToByteArray()); accepted .ReceiveAllAsync() .ToObservableFromAsyncEnumerable() .ToStrings() .Subscribe(s => accepted.Send(s.ToByteArray())); }); var clients = new List <IRxSocketClient>(); for (var i = 0; i < 3; i++) { var client = await endPoint.CreateRxSocketClientAsync(SocketClientLogger); client.Send("Hello".ToByteArray()); clients.Add(client); } foreach (var client in clients) { Assert.Equal("Hello", await client.ReceiveAllAsync().ToObservableFromAsyncEnumerable().ToStrings().Skip(1).Take(1).FirstAsync()); } foreach (var client in clients) { await client.DisposeAsync(); } await server.DisposeAsync(); }
public async Task T20_AcceptObservable() { var server = RxSocketServer.Create(IPEndPoint, SocketServerLogger); server.AcceptObservable.Subscribe(accepted => { "Welcome!".ToByteArray().SendTo(accepted); }); var client1 = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger); var client2 = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger); var client3 = await RxSocketClient.ConnectAsync(IPEndPoint, SocketClientLogger); Assert.Equal("Welcome!", await client1.ReceiveObservable.ToStrings().Take(1).FirstAsync()); Assert.Equal("Welcome!", await client2.ReceiveObservable.ToStrings().Take(1).FirstAsync()); Assert.Equal("Welcome!", await client3.ReceiveObservable.ToStrings().Take(1).FirstAsync()); client1.Dispose(); client2.Dispose(); client3.Dispose(); server.Dispose(); }
/// <summary> /// Create an RxSocketServer on IPEndPoint. /// </summary> public static IRxSocketServer CreateRxSocketServer(this IPEndPoint ipEndPoint, ILogger logger, int backLog = 10) => RxSocketServer.Create(ipEndPoint, logger, backLog);
public void T01_InvalidEndPoint() { var endPoint = new IPEndPoint(IPAddress.Parse("111.111.111.111"), 1111); Assert.Throws <SocketException>(() => RxSocketServer.Create(endPoint, SocketServerLogger)); }
public RxSocketClientServerTest(ITestOutputHelper output) : base(output) { Server = RxSocketServer.Create(IPEndPoint, SocketServerLogger); AcceptTask = Server.AcceptObservable.FirstAsync().ToTask(); }
/// <summary> /// Create an RxSocketServer on IPEndPoint. /// </summary> public static IRxSocketServer CreateRxSocketServer(this IPEndPoint ipEndPoint, int backLog = 10) => RxSocketServer.Create(ipEndPoint, NullLogger.Instance, backLog);