internal async Task HandleRequestAsyncNoResponse(IResonanceTransporter transporter, ResonanceMessage <CalculateRequest> message)
{
await Task.Delay(100);
transporter.SendResponse(new CalculateResponse()
{
Sum = message.Object.A + message.Object.B
}, message.Token);
}
/// <summary>
/// Sets the transporter encoding/decoding to compress/decompress data using the fast LZ4 compression algorithm.
/// </summary>
/// <param name="compressionBuilder">The compression builder.</param>
public static IBuildTransporter WithLZ4Compression(this ICompressionBuilder compressionBuilder)
{
IResonanceTransporter transporter = compressionBuilder.GetType().GetProperty("Transporter", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(compressionBuilder) as IResonanceTransporter;
transporter.Encoder.CompressionConfiguration.Compressor = new LZ4Compressor();
transporter.Decoder.CompressionConfiguration.Compressor = new LZ4Compressor();
transporter.Encoder.CompressionConfiguration.Enabled = true;
transporter.Decoder.CompressionConfiguration.Enabled = true;
return(compressionBuilder as ResonanceTransporterBuilder);
}
/// <summary>
/// Initializes a new instance of the <see cref="WebRTCAdapter"/> class.
/// </summary>
/// <param name="signalingTransporter">The signaling transporter.</param>
/// <param name="role">The adapter role.</param>
public WebRTCAdapterNative(IResonanceTransporter signalingTransporter, WebRTCAdapterRole role) : this()
{
Role = role;
_signalingTransporter = signalingTransporter;
if (_offerRequest == null)
{
_signalingTransporter.RegisterRequestHandler <WebRTCOfferRequest, WebRTCOfferResponse>(OnWebRTCOfferRequest);
}
}
internal async Task <ResonanceActionResult <CalculateResponse> > HandleRequestAsyncWithResponseWithTransporter(IResonanceTransporter transporter, CalculateRequest request)
{
_receivedTransporter = transporter;
await Task.Delay(100);
return(new CalculateResponse()
{
Sum = request.A + request.B
});
}
public static void Read_Write_Test(ResonanceTest test, IResonanceTransporter t1, IResonanceTransporter t2, bool enableCryptography, int count, int maxOutliersPercentage)
{
t1.CryptographyConfiguration.Enabled = enableCryptography;
t2.CryptographyConfiguration.Enabled = enableCryptography;
t2.Connect();
t1.Connect();
t2.RequestReceived += (s, e) =>
{
CalculateRequest receivedRequest = e.Message.Object as CalculateRequest;
t2.SendResponse(new CalculateResponse()
{
Sum = receivedRequest.A + receivedRequest.B
}, e.Message.Token);
};
Stopwatch watch = new Stopwatch();
List <double> measurements = new List <double>();
for (int i = 0; i < count; i++)
{
watch.Restart();
var request = new CalculateRequest()
{
A = 10, B = i
};
var response = t1.SendRequest <CalculateRequest, CalculateResponse>(request);
measurements.Add(watch.ElapsedMilliseconds);
Assert.AreEqual(response.Sum, request.A + request.B);
}
watch.Stop();
t1.Dispose(true);
t2.Dispose(true);
if (count > 1 && maxOutliersPercentage > 0)
{
var outliers = TestHelper.GetOutliers(measurements);
double percentageOfOutliers = outliers.Count / (double)measurements.Count * 100d;
if (!test.IsRunningOnAzurePipelines)
{
Assert.IsTrue(percentageOfOutliers < maxOutliersPercentage, $"Request/Response duration measurements contains {percentageOfOutliers}% outliers and is considered a performance issue.");
}
}
}
public void Transporter_Builder_With_WebRTC_Adapter()
{
IResonanceTransporter signaling = new ResonanceTransporter();
IResonanceTransporter webRtcAdapter = ResonanceTransporter.Builder
.Create()
.WithWebRTCAdapter()
.WithSignalingTransporter(signaling)
.WithRole(WebRTCAdapterRole.Connect)
.WithIceServer("some ice server")
.WithTranscoding <JsonEncoder, JsonDecoder>()
.NoKeepAlive()
.WithEncryption()
.WithCompression()
.Build();
Assert.IsNotNull(webRtcAdapter);
Assert.IsInstanceOfType(webRtcAdapter.Adapter, typeof(WebRTCAdapter));
Assert.IsTrue((webRtcAdapter.Adapter as WebRTCAdapter).IceServers[0].Url == "some ice server");
Assert.IsTrue((webRtcAdapter.Adapter as WebRTCAdapter).Role == WebRTCAdapterRole.Connect);
Assert.IsTrue((webRtcAdapter.Adapter as WebRTCAdapter).SignalingTransporter == signaling);
Assert.IsInstanceOfType(webRtcAdapter.Encoder, typeof(JsonEncoder));
Assert.IsInstanceOfType(webRtcAdapter.Decoder, typeof(JsonDecoder));
Assert.IsFalse(webRtcAdapter.KeepAliveConfiguration.Enabled);
Assert.IsTrue(webRtcAdapter.CryptographyConfiguration.Enabled);
Assert.IsTrue(webRtcAdapter.Encoder.CompressionConfiguration.Enabled);
Assert.IsTrue(webRtcAdapter.Decoder.CompressionConfiguration.Enabled);
webRtcAdapter = ResonanceTransporter.Builder
.Create()
.WithWebRTCAdapter()
.WithSignalingTransporter(signaling)
.WithOfferRequest(new WebRTCOfferRequest(), "token")
.WithIceServer("some ice server")
.WithTranscoding <JsonEncoder, JsonDecoder>()
.NoKeepAlive()
.WithEncryption()
.WithCompression()
.Build();
Assert.IsNotNull(webRtcAdapter);
Assert.IsInstanceOfType(webRtcAdapter.Adapter, typeof(WebRTCAdapter));
Assert.IsTrue((webRtcAdapter.Adapter as WebRTCAdapter).IceServers[0].Url == "some ice server");
Assert.IsTrue((webRtcAdapter.Adapter as WebRTCAdapter).Role == WebRTCAdapterRole.Accept);
Assert.IsTrue((webRtcAdapter.Adapter as WebRTCAdapter).InitializedByOffer);
Assert.IsTrue((webRtcAdapter.Adapter as WebRTCAdapter).SignalingTransporter == signaling);
Assert.IsInstanceOfType(webRtcAdapter.Encoder, typeof(JsonEncoder));
Assert.IsInstanceOfType(webRtcAdapter.Decoder, typeof(JsonDecoder));
Assert.IsFalse(webRtcAdapter.KeepAliveConfiguration.Enabled);
Assert.IsTrue(webRtcAdapter.CryptographyConfiguration.Enabled);
Assert.IsTrue(webRtcAdapter.Encoder.CompressionConfiguration.Enabled);
Assert.IsTrue(webRtcAdapter.Decoder.CompressionConfiguration.Enabled);
}
private void OnNotifyAvailableClientsRequest(IResonanceTransporter transporter, ResonanceMessage <NotifyAvailableClientsRequest> request)
{
InvokeUI(() =>
{
ConnectedClients.Clear();
foreach (var client in request.Object.Clients)
{
ConnectedClients.Add(client);
}
});
}
public void Auto_Decoding__Needs_A_Second_Run()
{
return;
//This test needs a second run. not sure why.
if (IsRunningOnAzurePipelines)
{
return; //Hangs when running in a sequence of tests for some reason.
}
IResonanceTransporter t1 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithTranscoding <BsonEncoder, AutoDecoder>()
.Build();
IResonanceTransporter t2 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithTranscoding <JsonEncoder, AutoDecoder>()
.Build();
t1.Connect();
t2.Connect();
t2.RequestReceived += (s, e) =>
{
CalculateRequest receivedRequest = e.Message.Object as CalculateRequest;
t2.SendResponse(new CalculateResponse()
{
Sum = receivedRequest.A + receivedRequest.B
}, e.Message.Token);
};
var request = new CalculateRequest()
{
A = 10, B = 15
};
var response = t1.SendRequest <CalculateRequest, CalculateResponse>(request, new ResonanceRequestConfig()
{
Timeout = TimeSpan.FromSeconds(20)
});
t1.Dispose(true);
t2.Dispose(true);
Assert.AreEqual(response.Sum, request.A + request.B);
}
private async void OnJoinSessionRequest(IResonanceTransporter transporter, ResonanceMessage <JoinSessionRequest> request)
{
if (await ShowQuestionMessage($"Client {request.Object.ClientID} wants to create a session. Confirm?"))
{
InSession = true;
SelectedClient = request.Object.ClientID;
await transporter.SendResponseAsync(new JoinSessionResponse(), request.Token);
}
else
{
await transporter.SendErrorResponseAsync("No thanks.", request.Token);
}
}
public void Bson_Transcoding_With_DateTime_Kind()
{
if (IsRunningOnAzurePipelines)
{
return; //Hangs when running in a sequence of tests for some reason.
}
IResonanceTransporter t1 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithBsonTranscoding()
.Build();
IResonanceTransporter t2 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithBsonTranscoding()
.Build();
t1.Connect();
t2.Connect();
t2.RequestReceived += (s, e) =>
{
CalculateRequestWithDate receivedRequest = e.Message.Object as CalculateRequestWithDate;
t2.SendResponse(new CalculateResponseWithDate()
{
Sum = receivedRequest.A + receivedRequest.B, Date = receivedRequest.Date
}, e.Message.Token);
};
for (int i = 0; i < 1000; i++)
{
var request = new CalculateRequestWithDate()
{
A = 10, B = 15, Date = DateTime.UtcNow
};
var response = t1.SendRequest <CalculateRequestWithDate, CalculateResponseWithDate>(request);
Assert.AreEqual(response.Sum, request.A + request.B);
Assert.AreEqual(request.Date.Kind, response.Date.Kind);
Assert.AreEqual(request.Date.ToString(), response.Date.ToString());
}
t1.Dispose(true);
t2.Dispose(true);
}
protected async override void OnApplicationReady()
{
base.OnApplicationReady();
_transporter = ResonanceTransporter.Builder
.Create()
.WithUdpAdapter()
.WithServer(TcpAdapter.GetLocalIPAddress(), 9999)
.WithJsonTranscoding()
.Build();
_transporter.ConnectionLost += (x, e) =>
{
e.FailTransporter = true;
Logger.LogError($"Remote server has closed. {e.Exception.Message}");
};
_client = _transporter.CreateClientProxy <IRemoteDrawingBoardService>();
_client.RectangleAdded += _client_RectangleAdded;
try
{
await _transporter.ConnectAsync();
}
catch (Exception ex)
{
Logger.LogError(ex, "Could not connect to the remote server. Please restart the application.");
return;
}
//This is just for testing async methods...
String welcomeMessage = await _client.GetWelcomeMessage("Roy", 99);
int countAsync = await _client.GetRectanglesCountAsync();
int sum = await _client.CalcAsync(10, 15);
try
{
foreach (var rect in _client.Rectangles)
{
Rectangles.Add(rect);
}
}
catch (Exception ex)
{
//TODO: Add log here that we could not fetch any server logs or something.
}
}
public void Transporter_Builder_With_InMemory_Adapter()
{
IResonanceTransporter transporter = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithTranscoding(new JsonEncoder(), new JsonDecoder())
.NoKeepAlive()
.NoEncryption()
.NoCompression()
.Build();
Assert.IsInstanceOfType(transporter.Adapter, typeof(InMemoryAdapter));
Assert.IsTrue((transporter.Adapter as InMemoryAdapter).Address == "TST");
}
private void SetAdapter()
{
IResonanceTransporter transporter = Info.builder.GetType().GetProperty("Transporter", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(Info.builder) as IResonanceTransporter;
if (Info.offerRequest != null)
{
transporter.Adapter = new WebRTCAdapter(Info.signalingTransporter, Info.offerRequest, Info.offerRequestToken);
}
else
{
transporter.Adapter = new WebRTCAdapter(Info.signalingTransporter, Info.role);
}
Info.adapter = transporter.Adapter as WebRTCAdapter;
}
static void Main(string[] args)
{
Console.WriteLine("Starting Resonance UDP Broadcast Demo...");
Console.WriteLine("Connecting transporter with UDP adapter on all addresses...");
//Initialize a transporter with UDP adapter. Listening and sending to all interfaces.
IResonanceTransporter transporter = ResonanceTransporter.Builder
.Create()
.WithUdpAdapter()
.Broadcast(1234)
.PreventLoopback()
.WithJsonTranscoding()
.Build();
//Connect the transporter.
transporter.Connect();
//Register the service to handle incoming messages from other clients.
transporter.RegisterService <IRPCBroadcastService, RPCBroadcastService>(RpcServiceCreationType.Singleton);
//Create a service client proxy to send messages to other clients.
IRPCBroadcastService client = transporter.CreateClientProxy <IRPCBroadcastService>();
Console.WriteLine("Now connected. Make sure at least one more client is also connected before sending messages.");
Console.WriteLine();
String input = String.Empty;
while (input.ToLower() != "exit")
{
Console.Write("Enter a message to broadcast: ");
input = Console.ReadLine();
try
{
client.BroadcastMessage(input);
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(ex.Message);
Console.ForegroundColor = ConsoleColor.Gray;
}
Console.WriteLine();
}
}
public void Protobuf_Transcoding_Type_Resolver()
{
if (IsRunningOnAzurePipelines)
{
return;
}
IResonanceTransporter t1 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithProtobufTranscoding()
.WithMessageTypeHeaderMethod(MessageTypeHeaderMethod.Name)
.WithTypeResolver <ProtobufTypeResolver>()
.Build();
IResonanceTransporter t2 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithProtobufTranscoding()
.WithMessageTypeHeaderMethod(MessageTypeHeaderMethod.Name)
.WithTypeResolver <ProtobufTypeResolver>()
.Build();
t1.Connect();
t2.Connect();
t2.RequestReceived += (s, e) =>
{
Messages.Proto.CalculateRequest receivedRequest = e.Message.Object as Messages.Proto.CalculateRequest;
t2.SendResponse(new Messages.Proto.CalculateResponse()
{
Sum = receivedRequest.A + receivedRequest.B
}, e.Message.Token);
};
var request = new Messages.Proto.CalculateRequest()
{
A = 10, B = 15
};
var response = t1.SendRequest <Messages.Proto.CalculateRequest, Messages.Proto.CalculateResponse>(request);
t1.Dispose(true);
t2.Dispose(true);
Assert.AreEqual(response.Sum, request.A + request.B);
}
/// <summary>
/// Handles clients login request.
/// </summary>
/// <param name="transporter">The transporter.</param>
/// <param name="request">The request.</param>
/// <returns></returns>
/// <exception cref="System.Exception">Client {request.ClientID} is already taken.</exception>
private ResonanceActionResult <LoginResponse> OnClientLoginRequest(IResonanceTransporter transporter, LoginRequest request)
{
ResonanceTcpClient client = transporter as ResonanceTcpClient;
if (_clients.Exists(x => x.ClientID == request.ClientID))
{
throw new Exception($"Client {request.ClientID} is already taken.");
}
client.ClientID = request.ClientID;
_clients.Add(client);
Logger.LogInformation($"{client.ClientID} is now connected.");
UpdateClientsList();
return(new LoginResponse());
}
public static void Read_Write_Test(ResonanceTest test, IResonanceAdapter adapter1, IResonanceAdapter adapter2, IResonanceEncoder encoder, IResonanceDecoder decoder, bool enableCryptography, int count, int maxOutliersPercentage)
{
IResonanceTransporter t1 = ResonanceTransporter.Builder
.Create()
.WithAdapter(adapter1)
.WithTranscoding(encoder, decoder)
.NoKeepAlive()
.Build();
IResonanceTransporter t2 = ResonanceTransporter.Builder
.Create()
.WithAdapter(adapter2)
.WithTranscoding(encoder, decoder)
.NoKeepAlive()
.Build();
Read_Write_Test(test, t1, t2, enableCryptography, count, maxOutliersPercentage);
}
private async void Connect()
{
if (!IsConnected)
{
try
{
IsFree = false;
_transporter = ResonanceTransporter.Builder
.Create()
.WithTcpAdapter()
.WithAddress(SelectedService.Address)
.WithPort(SelectedService.DiscoveryInfo.Port)
.WithJsonTranscoding()
.Build();
_transporter.ConnectionLost += ConnectionLost;
_transporter.RegisterRequestHandler <JoinSessionRequest>(OnJoinSessionRequest);
_transporter.RegisterRequestHandler <NotifyAvailableClientsRequest>(OnNotifyAvailableClientsRequest);
_transporter.RegisterRequestHandler <EchoTextRequest, EchoTextResponse>(OnEchoTextRequest);
_transporter.RegisterRequestHandler <LeaveSessionRequest>(OnLeaveSessionRequest);
await _transporter.ConnectAsync();
await _transporter.SendRequestAsync <LoginRequest, LoginResponse>(new LoginRequest()
{
ClientID = ClientID
});
await _discoveryClient.StopAsync();
IsConnected = true;
}
catch (Exception ex)
{
Logger.LogError(ex, ex.Message);
}
finally
{
IsFree = true;
}
}
}
private async void Connect()
{
try
{
using (UserDialogs.Instance.Loading("Connecting..."))
{
_transporter = ResonanceTransporter.Builder
.Create()
.WithAdapter(new BluetoothAdapter(SelectedDevice))
.WithJsonTranscoding()
.Build();
_transporter.StateChanged += (x, e) =>
{
InvokeUI(async() =>
{
SendCommand.ChangeCanExecute();
if (e.PreviousState == ResonanceComponentState.Connected && e.NewState == ResonanceComponentState.Failed)
{
await Navigation.PopAsync();
UserDialogs.Instance.Toast($"Connection lost.\n{_transporter.FailedStateException}");
}
});
};
_transporter.RegisterRequestHandler <ChatMessageRequest, ChatMessageResponse>(OnChatRequest);
await _transporter.ConnectAsync();
SelectedDevice.Refresh();
Logs.Clear();
}
await Navigation.PushAsync(new ChatPage(), true);
}
catch (Exception ex)
{
UserDialogs.Instance.Toast($"Error connecting to the selected device.\n{ex.Message}");
}
}
public void Transporter_Builder_With_MessagePack_Transcoding()
{
IResonanceTransporter transporter = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithMessagePackTranscoding()
.NoKeepAlive()
.WithEncryption()
.WithCompression()
.Build();
Assert.IsNotNull(transporter);
Assert.IsInstanceOfType(transporter.Adapter, typeof(InMemoryAdapter));
Assert.IsInstanceOfType(transporter.Encoder, typeof(MessagePackEncoder));
Assert.IsInstanceOfType(transporter.Decoder, typeof(MessagePackDecoder));
Assert.IsFalse(transporter.KeepAliveConfiguration.Enabled);
Assert.IsTrue(transporter.CryptographyConfiguration.Enabled);
Assert.IsTrue(transporter.Encoder.CompressionConfiguration.Enabled);
Assert.IsTrue(transporter.Decoder.CompressionConfiguration.Enabled);
}
/// <summary>
/// Handles clients "leave session" request.
/// </summary>
/// <param name="transporter">The transporter.</param>
/// <param name="request">The request.</param>
private async void OnClientLeaveSessionRequest(IResonanceTransporter transporter, ResonanceMessage <LeaveSessionRequest> request)
{
ResonanceTcpClient client = transporter as ResonanceTcpClient;
if (client.InSession)
{
Logger.LogWarning($"Client {client.ClientID} has closed the session.");
client.InSession = false;
client.RemoteClient.InSession = false;
await client.RemoteClient.SendAsync(new LeaveSessionRequest()
{
Reason = $"{client.RemoteClient.ClientID} has left the session"
});
client.RemoteClient.RemoteClient = null;
client.RemoteClient = null;
UpdateClientsList();
}
}
public void Protobuf_Encoding()
{
IResonanceTransporter t1 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithProtobufTranscoding()
.Build();
IResonanceTransporter t2 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithProtobufTranscoding()
.Build();
t1.ConnectAsync().Wait();
t2.ConnectAsync().Wait();
t2.RequestReceived += (s, e) =>
{
Messages.Proto.CalculateRequest receivedRequest = e.Message.Object as Messages.Proto.CalculateRequest;
t2.SendResponseAsync(new Messages.Proto.CalculateResponse()
{
Sum = receivedRequest.A + receivedRequest.B
}, e.Message.Token);
};
for (int i = 0; i < 1000; i++)
{
var request = new Messages.Proto.CalculateRequest()
{
A = 10, B = i
};
var response = t1.SendRequestAsync <Messages.Proto.CalculateRequest, Messages.Proto.CalculateResponse>(request).GetAwaiter().GetResult();
}
t1.Dispose(true);
t2.Dispose(true);
}
public void Transporter_Builder_With_Shared_Memory_Adapter()
{
IResonanceTransporter transporter = ResonanceTransporter.Builder
.Create()
.WithSharedMemoryAdapter()
.WithAddress("TEST")
.WithTranscoding <JsonEncoder, JsonDecoder>()
.NoKeepAlive()
.WithEncryption()
.WithCompression()
.Build();
Assert.IsNotNull(transporter);
Assert.IsInstanceOfType(transporter.Adapter, typeof(SharedMemoryAdapter));
Assert.IsTrue((transporter.Adapter as SharedMemoryAdapter).Address == "TEST");
Assert.IsInstanceOfType(transporter.Encoder, typeof(JsonEncoder));
Assert.IsInstanceOfType(transporter.Decoder, typeof(JsonDecoder));
Assert.IsFalse(transporter.KeepAliveConfiguration.Enabled);
Assert.IsTrue(transporter.CryptographyConfiguration.Enabled);
Assert.IsTrue(transporter.Encoder.CompressionConfiguration.Enabled);
Assert.IsTrue(transporter.Decoder.CompressionConfiguration.Enabled);
}
public void Transporter_Builder_With_Bluetooth_Adapter()
{
IResonanceTransporter usbTransporter = ResonanceTransporter.Builder
.Create()
.WithBluetoothAdapter()
.WithAddress("fake address")
.WithTranscoding <JsonEncoder, JsonDecoder>()
.NoKeepAlive()
.WithEncryption()
.WithCompression()
.Build();
Assert.IsNotNull(usbTransporter);
Assert.IsInstanceOfType(usbTransporter.Adapter, typeof(BluetoothAdapter));
Assert.IsTrue((usbTransporter.Adapter as BluetoothAdapter).Address == "fake address");
Assert.IsInstanceOfType(usbTransporter.Encoder, typeof(JsonEncoder));
Assert.IsInstanceOfType(usbTransporter.Decoder, typeof(JsonDecoder));
Assert.IsFalse(usbTransporter.KeepAliveConfiguration.Enabled);
Assert.IsTrue(usbTransporter.CryptographyConfiguration.Enabled);
Assert.IsTrue(usbTransporter.Encoder.CompressionConfiguration.Enabled);
Assert.IsTrue(usbTransporter.Decoder.CompressionConfiguration.Enabled);
}
private async void Connect()
{
if (!IsConnected)
{
try
{
IsFree = false;
_transporter = ResonanceTransporter.Builder
.Create()
.WithSignalRAdapter(SignalRMode.Legacy)
.WithCredentials(new DemoCredentials()
{
Name = ClientID
})
.WithServiceId(SelectedService.ServiceId)
.WithUrl(HubUrl)
.WithJsonTranscoding()
.Build();
_transporter.ConnectionLost += ConnectionLost;
await _transporter.ConnectAsync();
await _discoveryClient.StopAsync();
IsConnected = true;
}
catch (Exception ex)
{
Logger.LogError(ex, ex.Message);
}
finally
{
IsFree = true;
}
}
}
public void Transporter_Builder_With_Protobuf_Transcoding()
{
IResonanceTransporter transporter = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithProtobufTranscoding()
.WithMessageTypeHeaderMethod(MessageTypeHeaderMethod.FullName)
.NoKeepAlive()
.WithEncryption()
.WithCompression()
.Build();
Assert.IsNotNull(transporter);
Assert.IsInstanceOfType(transporter.Adapter, typeof(InMemoryAdapter));
Assert.IsInstanceOfType(transporter.Encoder, typeof(ProtobufEncoder));
Assert.IsInstanceOfType(transporter.Decoder, typeof(ProtobufDecoder));
Assert.IsTrue((transporter.Encoder as ProtobufEncoder).MessageTypeHeaderMethod == MessageTypeHeaderMethod.FullName);
Assert.IsFalse(transporter.KeepAliveConfiguration.Enabled);
Assert.IsTrue(transporter.CryptographyConfiguration.Enabled);
Assert.IsTrue(transporter.Encoder.CompressionConfiguration.Enabled);
Assert.IsTrue(transporter.Decoder.CompressionConfiguration.Enabled);
}
public void Transporter_Builder_With_Usb_Adapter()
{
IResonanceTransporter usbTransporter = ResonanceTransporter.Builder
.Create()
.WithUsbAdapter()
.WithPort("COM1")
.WithBaudRate(Adapters.Usb.BaudRates.BR_115200)
.WithTranscoding <JsonEncoder, JsonDecoder>()
.NoKeepAlive()
.WithEncryption()
.WithCompression()
.Build();
Assert.IsNotNull(usbTransporter);
Assert.IsInstanceOfType(usbTransporter.Adapter, typeof(UsbAdapter));
Assert.IsTrue((usbTransporter.Adapter as UsbAdapter).Port == "COM1");
Assert.IsTrue((usbTransporter.Adapter as UsbAdapter).BaudRate == (int)BaudRates.BR_115200);
Assert.IsInstanceOfType(usbTransporter.Encoder, typeof(JsonEncoder));
Assert.IsInstanceOfType(usbTransporter.Decoder, typeof(JsonDecoder));
Assert.IsFalse(usbTransporter.KeepAliveConfiguration.Enabled);
Assert.IsTrue(usbTransporter.CryptographyConfiguration.Enabled);
Assert.IsTrue(usbTransporter.Encoder.CompressionConfiguration.Enabled);
Assert.IsTrue(usbTransporter.Decoder.CompressionConfiguration.Enabled);
}
public void Message_Larger_Than_16_KB_Splits()
{
if (IsRunningOnAzurePipelines)
{
return;
}
IResonanceTransporter signal1 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithJsonTranscoding()
.Build();
IResonanceTransporter signal2 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithJsonTranscoding()
.Build();
signal1.Connect();
signal2.Connect();
WebRTCAdapter adapter1 = null;
signal1.RegisterRequestHandler <WebRTCOfferRequest>(async(_, request) =>
{
adapter1 = new WebRTCAdapter(signal1, request.Object, request.Token);
await adapter1.ConnectAsync();
});
WebRTCAdapter adapter2 = new WebRTCAdapter(signal2, WebRTCAdapterRole.Connect);
adapter2.Connect();
IResonanceTransporter t1 = ResonanceTransporter.Builder
.Create()
.WithAdapter(adapter1)
.WithJsonTranscoding()
.Build();
IResonanceTransporter t2 = ResonanceTransporter.Builder
.Create()
.WithAdapter(adapter2)
.WithJsonTranscoding()
.Build();
t2.RequestReceived += (x, e) =>
{
t2.SendResponseAsync(new LargeMessageResponse()
{
Data = (e.Message.Object as LargeMessageRequest).Data
}, e.Message.Token);
};
t1.Connect();
t2.Connect();
byte[] data = TestHelper.GetRandomByteArray(200);
var response = t1.SendRequest <LargeMessageRequest, LargeMessageResponse>(new LargeMessageRequest()
{
Data = data
});
Assert.IsTrue(data.SequenceEqual(response.Data));
t1.Dispose();
t2.Dispose();
signal1.Dispose();
signal2.Dispose();
}
public void Stress_Test_With_Small_Data_Volume()
{
if (IsRunningOnAzurePipelines)
{
return;
}
IResonanceTransporter signal1 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithJsonTranscoding()
.Build();
IResonanceTransporter signal2 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithJsonTranscoding()
.Build();
signal1.Connect();
signal2.Connect();
WebRTCAdapter adapter1 = null;
signal1.RegisterRequestHandler <WebRTCOfferRequest>(async(_, request) =>
{
adapter1 = new WebRTCAdapter(signal1, request.Object, request.Token);
await adapter1.ConnectAsync();
});
WebRTCAdapter adapter2 = new WebRTCAdapter(signal2, WebRTCAdapterRole.Connect);
adapter2.Connect();
IResonanceTransporter t1 = ResonanceTransporter.Builder
.Create()
.WithAdapter(adapter1)
.WithJsonTranscoding()
.Build();
IResonanceTransporter t2 = ResonanceTransporter.Builder
.Create()
.WithAdapter(adapter2)
.WithJsonTranscoding()
.Build();
t2.RequestReceived += (x, e) =>
{
t2.SendResponseAsync(new LargeMessageResponse()
{
Data = (e.Message.Object as LargeMessageRequest).Data
}, e.Message.Token);
};
t1.Connect();
t2.Connect();
t1.DefaultRequestTimeout = TimeSpan.FromSeconds(60);
for (int i = 0; i < 100; i++)
{
byte[] data = TestHelper.GetRandomByteArray(2);
var response = t1.SendRequest <LargeMessageRequest, LargeMessageResponse>(new LargeMessageRequest()
{
Data = data
});
Assert.IsTrue(data.SequenceEqual(response.Data));
}
t1.Dispose();
t2.Dispose();
signal1.Dispose();
signal2.Dispose();
}
public void Basic_Test()
{
if (IsRunningOnAzurePipelines)
{
return;
}
IResonanceTransporter signal1 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithJsonTranscoding()
.Build();
IResonanceTransporter signal2 = ResonanceTransporter.Builder
.Create()
.WithInMemoryAdapter()
.WithAddress("TST")
.WithJsonTranscoding()
.Build();
signal1.Connect();
signal2.Connect();
WebRTCAdapter adapter1 = new WebRTCAdapter(signal1, WebRTCAdapterRole.Accept);
Task.Factory.StartNew(() =>
{
adapter1.Connect();
});
Thread.Sleep(100);
WebRTCAdapter adapter2 = new WebRTCAdapter(signal2, WebRTCAdapterRole.Connect);
adapter2.Connect();
IResonanceTransporter t1 = ResonanceTransporter.Builder
.Create()
.WithAdapter(adapter1)
.WithJsonTranscoding()
.Build();
IResonanceTransporter t2 = ResonanceTransporter.Builder
.Create()
.WithAdapter(adapter2)
.WithJsonTranscoding()
.Build();
t2.RequestReceived += (x, e) =>
{
t2.SendResponseAsync(new CalculateResponse()
{
Sum = 15
}, e.Message.Token);
};
t1.Connect();
t2.Connect();
var response = t1.SendRequest <CalculateRequest, CalculateResponse>(new CalculateRequest()
{
A = 10, B = 5
});
Assert.IsTrue(response.Sum == 15);
t1.Dispose();
t2.Dispose();
signal1.Dispose();
signal2.Dispose();
}
