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(); }