public void MulticastLoopback() { UdpMessagingSystemFactory aMessaging = new UdpMessagingSystemFactory(new EasyProtocolFormatter()) { UnicastCommunication = false, MulticastGroupToReceive = "234.1.2.3", MulticastLoopback = true }; ManualResetEvent aMessageReceived = new ManualResetEvent(false); string aReceivedMessage = null; IDuplexOutputChannel anOutputChannel = aMessaging.CreateDuplexOutputChannel("udp://234.1.2.3:8090/", "udp://0.0.0.0:8090/"); anOutputChannel.ResponseMessageReceived += (x, y) => { aReceivedMessage = (string)y.Message; aMessageReceived.Set(); }; try { anOutputChannel.OpenConnection(); anOutputChannel.SendMessage("Hello"); aMessageReceived.WaitIfNotDebugging(1000); } finally { anOutputChannel.CloseConnection(); } Assert.AreEqual("Hello", aReceivedMessage); }
private bool InitializeWorkerConnection() { // Create TCP messaging IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory(); Worker4504OutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:4504/"); // Subscribe to response messages. Worker4504OutputChannel.ConnectionClosed += Worker4504OutputChannel_ConnectionClosed; Worker4504OutputChannel.ConnectionOpened += Worker4504OutputChannel_ConnectionOpened; Worker4504OutputChannel.ResponseMessageReceived += Worker4504OutputChannel_ResponseMessageReceived; // Open connection and be able to send messages and receive response messages. Worker4504OutputChannel.OpenConnection(); Log("Channel id : " + Worker4504OutputChannel.ChannelId); // Send a message. byte[] data = new byte[1048576]; // initialize 1MB data //byte[] data = new byte[10]; // initialize 1MB data Random random = new Random(); random.NextBytes(data); Worker4504OutputChannel.SendMessage(data); Log("Sent data length : " + data.Length); // Close connection. //Worker4504OutputChannel.CloseConnection(); return(true); }
public void ClientReceiveTimeout() { IMessagingSystemFactory aMessaging = new WebSocketMessagingSystemFactory() { ReceiveTimeout = TimeSpan.FromMilliseconds(1000) }; IDuplexOutputChannel anOutputChannel = aMessaging.CreateDuplexOutputChannel("ws://127.0.0.1:8046/"); IDuplexInputChannel anInputChannel = aMessaging.CreateDuplexInputChannel("ws://127.0.0.1:8046/"); try { ManualResetEvent aConnectionClosed = new ManualResetEvent(false); anOutputChannel.ConnectionClosed += (x, y) => { EneterTrace.Info("Connection closed."); aConnectionClosed.Set(); }; anInputChannel.StartListening(); anOutputChannel.OpenConnection(); EneterTrace.Info("Connection opened."); // According to set receive timeout the client should get disconnected within 1 second. //aConnectionClosed.WaitOne(); Assert.IsTrue(aConnectionClosed.WaitOne(3000)); } finally { anOutputChannel.CloseConnection(); anInputChannel.StopListening(); } }
// Client opens connection to a particular output. public void OpenOutputConnection(IMessagingSystemFactory messaging, string channelId) { using (EneterTrace.Entering()) { IDuplexOutputChannel anOutputChannel = null; try { using (ThreadLock.Lock(myOutputConnectionLock)) { anOutputChannel = messaging.CreateDuplexOutputChannel(channelId); anOutputChannel.ConnectionClosed += OnConnectionClosed; anOutputChannel.ResponseMessageReceived += OnResponseMessageReceived; anOutputChannel.OpenConnection(); // Connection is successfuly open so it can be stored. myOpenOutputConnections.Add(anOutputChannel); } } catch (Exception err) { EneterTrace.Warning("Failed to open connection to '" + channelId + "'.", err); if (anOutputChannel != null) { anOutputChannel.ConnectionClosed -= OnConnectionClosed; anOutputChannel.ResponseMessageReceived -= OnResponseMessageReceived; } throw; } } }
public void BroadcastFromClientToAllServices() { UdpMessagingSystemFactory anOutputChannelMessaging = new UdpMessagingSystemFactory(new EasyProtocolFormatter()) { UnicastCommunication = false, AllowSendingBroadcasts = true }; UdpMessagingSystemFactory anInputChannelMessaging = new UdpMessagingSystemFactory(new EasyProtocolFormatter()) { UnicastCommunication = false, ReuseAddress = true }; ManualResetEvent aMessage1Received = new ManualResetEvent(false); string aReceivedMessage1 = null; IDuplexInputChannel anInputChannel1 = anInputChannelMessaging.CreateDuplexInputChannel("udp://127.0.0.1:8095/"); anInputChannel1.MessageReceived += (x, y) => { aReceivedMessage1 = (string)y.Message; aMessage1Received.Set(); }; ManualResetEvent aMessage2Received = new ManualResetEvent(false); string aReceivedMessage2 = null; IDuplexInputChannel anInputChannel2 = anInputChannelMessaging.CreateDuplexInputChannel("udp://127.0.0.1:8095/"); anInputChannel2.MessageReceived += (x, y) => { aReceivedMessage2 = (string)y.Message; aMessage2Received.Set(); }; IDuplexOutputChannel anOutputChannel = anOutputChannelMessaging.CreateDuplexOutputChannel("udp://255.255.255.255:8095/", "udp://127.0.0.1"); try { anInputChannel1.StartListening(); anInputChannel2.StartListening(); anOutputChannel.OpenConnection(); anOutputChannel.SendMessage("Hello"); aMessage1Received.WaitIfNotDebugging(1000); aMessage2Received.WaitIfNotDebugging(1000); } finally { anOutputChannel.CloseConnection(); anInputChannel1.StopListening(); anInputChannel2.StopListening(); } Assert.AreEqual("Hello", aReceivedMessage1); Assert.AreEqual("Hello", aReceivedMessage2); }
public void MulticastFromServiceToClients() { UdpMessagingSystemFactory aMessaging = new UdpMessagingSystemFactory(new EasyProtocolFormatter()) { UnicastCommunication = false, ReuseAddress = true, MulticastGroupToReceive = "234.1.2.3", MulticastLoopback = true }; ManualResetEvent aMessage1Received = new ManualResetEvent(false); string aReceivedMessage1 = null; IDuplexOutputChannel anOutputChannel1 = aMessaging.CreateDuplexOutputChannel("udp://127.0.0.1:8090/", "udp://127.0.0.1:8092/"); anOutputChannel1.ResponseMessageReceived += (x, y) => { aReceivedMessage1 = (string)y.Message; aMessage1Received.Set(); }; ManualResetEvent aMessage2Received = new ManualResetEvent(false); string aReceivedMessage2 = null; IDuplexOutputChannel anOutputChannel2 = aMessaging.CreateDuplexOutputChannel("udp://127.0.0.1:8090/", "udp://127.0.0.1:8092/"); anOutputChannel2.ResponseMessageReceived += (x, y) => { aReceivedMessage2 = (string)y.Message; aMessage2Received.Set(); }; IDuplexInputChannel anInputChannel = aMessaging.CreateDuplexInputChannel("udp://127.0.0.1:8090/"); try { anInputChannel.StartListening(); anOutputChannel1.OpenConnection(); anOutputChannel2.OpenConnection(); anInputChannel.SendResponseMessage("udp://234.1.2.3:8092/", "Hello"); aMessage1Received.WaitIfNotDebugging(1000); aMessage2Received.WaitIfNotDebugging(1000); } finally { anInputChannel.StopListening(); anOutputChannel1.CloseConnection(); anOutputChannel2.CloseConnection(); } Assert.AreEqual("Hello", aReceivedMessage1); Assert.AreEqual("Hello", aReceivedMessage2); }
public virtual void A15_ResponseReceiverReconnects_AfterStopListening() { IDuplexOutputChannel aDuplexOutputChannel = MessagingSystem.CreateDuplexOutputChannel(ChannelId); IDuplexInputChannel aDuplexInputChannel = MessagingSystem.CreateDuplexInputChannel(ChannelId); AutoResetEvent aConnectionsCompletedEvent = new AutoResetEvent(false); List <string> anOpenConnections = new List <string>(); aDuplexInputChannel.ResponseReceiverConnected += (x, y) => { lock (anOpenConnections) { anOpenConnections.Add(y.ResponseReceiverId); aConnectionsCompletedEvent.Set(); } }; try { aDuplexInputChannel.StartListening(); aDuplexOutputChannel.OpenConnection(); // Wait until the client is connected. aConnectionsCompletedEvent.WaitOne(); // Stop listenig. aDuplexInputChannel.StopListening(); // Give some time to stop. Thread.Sleep(700); // Start listening again. aDuplexInputChannel.StartListening(); // The duplex output channel will try to connect again, therefore wait until connected. aConnectionsCompletedEvent.WaitOne(); Assert.IsTrue(aDuplexOutputChannel.IsConnected); } finally { aDuplexOutputChannel.CloseConnection(); aDuplexInputChannel.StopListening(); } Assert.AreEqual(2, anOpenConnections.Count); // Both connections should be same. Assert.AreEqual(aDuplexOutputChannel.ResponseReceiverId, anOpenConnections[0]); Assert.AreEqual(aDuplexOutputChannel.ResponseReceiverId, anOpenConnections[1]); }
public virtual void Duplex_07_OpenConnection_if_InputChannelNotStarted() { IDuplexOutputChannel anOutputChannel = MessagingSystemFactory.CreateDuplexOutputChannel(ChannelId); try { anOutputChannel.OpenConnection(); } catch { } Assert.IsFalse(anOutputChannel.IsConnected); }
public void A14_ResponseReceiverReconnects_AfterDisconnect() { // Duplex output channel without queue - it will not try to reconnect. IDuplexOutputChannel aDuplexOutputChannel = MessagingSystem.CreateDuplexOutputChannel(ChannelId); IDuplexInputChannel aDuplexInputChannel = MessagingSystem.CreateDuplexInputChannel(ChannelId); AutoResetEvent aConnectionsCompletedEvent = new AutoResetEvent(false); List <string> anOpenConnections = new List <string>(); aDuplexInputChannel.ResponseReceiverConnected += (x, y) => { lock (anOpenConnections) { anOpenConnections.Add(y.ResponseReceiverId); aConnectionsCompletedEvent.Set(); } }; try { aDuplexInputChannel.StartListening(); aDuplexOutputChannel.OpenConnection(); // Wait until the connection is open. aConnectionsCompletedEvent.WaitOne(); // Disconnect the response receiver. aDuplexInputChannel.DisconnectResponseReceiver(aDuplexOutputChannel.ResponseReceiverId); // The duplex output channel will try to connect again, therefore wait until connected. aConnectionsCompletedEvent.WaitOne(); } finally { aDuplexOutputChannel.CloseConnection(); aDuplexInputChannel.StopListening(); } Assert.AreEqual(2, anOpenConnections.Count); // Both connections should be same. Assert.AreEqual(aDuplexOutputChannel.ResponseReceiverId, anOpenConnections[0]); Assert.AreEqual(aDuplexOutputChannel.ResponseReceiverId, anOpenConnections[1]); }
public void MaxAmountOfConnections() { IMessagingSystemFactory aMessaging = new UdpMessagingSystemFactory() { MaxAmountOfConnections = 2 }; IDuplexOutputChannel anOutputChannel1 = aMessaging.CreateDuplexOutputChannel("udp://127.0.0.1:8049/"); IDuplexOutputChannel anOutputChannel2 = aMessaging.CreateDuplexOutputChannel("udp://127.0.0.1:8049/"); IDuplexOutputChannel anOutputChannel3 = aMessaging.CreateDuplexOutputChannel("udp://127.0.0.1:8049/"); IDuplexInputChannel anInputChannel = aMessaging.CreateDuplexInputChannel("udp://127.0.0.1:8049/"); try { ManualResetEvent aConnectionClosed = new ManualResetEvent(false); anOutputChannel3.ConnectionClosed += (x, y) => { EneterTrace.Info("Connection closed."); aConnectionClosed.Set(); }; anInputChannel.StartListening(); anOutputChannel1.OpenConnection(); anOutputChannel2.OpenConnection(); anOutputChannel3.OpenConnection(); if (!aConnectionClosed.WaitOne(1000)) { Assert.Fail("Third connection was not closed."); } Assert.IsTrue(anOutputChannel1.IsConnected); Assert.IsTrue(anOutputChannel2.IsConnected); Assert.IsFalse(anOutputChannel3.IsConnected); } finally { anOutputChannel1.CloseConnection(); anOutputChannel2.CloseConnection(); anOutputChannel3.CloseConnection(); anInputChannel.StopListening(); } }
public void B01_Pinging_StopListening() { IDuplexInputChannel aDuplexInputChannel = MessagingSystemFactory.CreateDuplexInputChannel(ChannelId); IDuplexOutputChannel aDuplexOutputChannel = MessagingSystemFactory.CreateDuplexOutputChannel(ChannelId); AutoResetEvent aDisconnectedEvent = new AutoResetEvent(false); bool aDisconnectedFlag = false; aDuplexOutputChannel.ConnectionClosed += (x, y) => { aDisconnectedFlag = true; aDisconnectedEvent.Set(); }; try { // Start listening. aDuplexInputChannel.StartListening(); // Start pinging and wait 5 seconds. aDuplexOutputChannel.OpenConnection(); Thread.Sleep(5000); Assert.IsFalse(aDisconnectedFlag); // Stop listener, therefore the ping response will not come and the channel should indicate the disconnection. aDuplexInputChannel.StopListening(); aDisconnectedEvent.WaitOne(); Assert.IsTrue(aDisconnectedFlag); Assert.IsFalse(aDuplexOutputChannel.IsConnected); } finally { aDuplexOutputChannel.CloseConnection(); aDuplexInputChannel.StopListening(); } }
public void ConnectionTimeout() { IMessagingSystemFactory aMessaging = new WebSocketMessagingSystemFactory() { ConnectTimeout = TimeSpan.FromMilliseconds(1000) }; // Nobody is listening on this address. IDuplexOutputChannel anOutputChannel = aMessaging.CreateDuplexOutputChannel("ws://109.74.151.135:8045/"); ManualResetEvent aConnectionCompleted = new ManualResetEvent(false); try { // Start opening in another thread to be able to measure // if the timeout occured with the specified time. Exception anException = null; ThreadPool.QueueUserWorkItem(x => { try { anOutputChannel.OpenConnection(); } catch (Exception err) { anException = err; } aConnectionCompleted.Set(); }); if (aConnectionCompleted.WaitOne(1500)) { } Assert.AreEqual(typeof(TimeoutException), anException); } finally { anOutputChannel.CloseConnection(); } }
private IDuplexOutputChannel GetAssociatedDuplexOutputChannel(string duplexInputChannelId, string responseReceiverId, string duplexOutputChannelId) { using (EneterTrace.Entering()) { using (ThreadLock.Lock(myDuplexInputChannelContextManipulatorLock)) { TDuplexInputChannelContext aDuplexInputChannelContext = myDuplexInputChannelContexts.FirstOrDefault(x => x.AttachedDuplexInputChannel.ChannelId == duplexInputChannelId); if (aDuplexInputChannelContext == null) { string anError = TracedObject + "failed to return the duplex output channel associated with the duplex input channel '" + duplexInputChannelId + "' because the duplex input channel was not attached."; EneterTrace.Error(anError); throw new InvalidOperationException(anError); } TConnection aConnection = aDuplexInputChannelContext.OpenConnections.FirstOrDefault(x => x.ResponseReceiverId == responseReceiverId && x.ConnectedDuplexOutputChannel.ChannelId == duplexOutputChannelId); if (aConnection == null) { IDuplexOutputChannel anAssociatedDuplexOutputChannel = MessagingSystemFactory.CreateDuplexOutputChannel(duplexOutputChannelId); try { anAssociatedDuplexOutputChannel.ResponseMessageReceived += OnResponseMessageReceived; anAssociatedDuplexOutputChannel.OpenConnection(); } catch (Exception err) { anAssociatedDuplexOutputChannel.ResponseMessageReceived -= OnResponseMessageReceived; EneterTrace.Error(TracedObject + "failed to open connection for the duplex output channel '" + duplexOutputChannelId + "'.", err); throw; } aConnection = new TConnection(responseReceiverId, anAssociatedDuplexOutputChannel); aDuplexInputChannelContext.OpenConnections.Add(aConnection); } return(aConnection.ConnectedDuplexOutputChannel); } } }
public void B04_Pinging_CloseConnection() { IDuplexInputChannel aDuplexInputChannel = MessagingSystemFactory.CreateDuplexInputChannel(ChannelId); IDuplexOutputChannel aDuplexOutputChannel = MessagingSystemFactory.CreateDuplexOutputChannel(ChannelId); AutoResetEvent aConnectionClosedEvent = new AutoResetEvent(false); string aClosedResponseReceiverId = ""; aDuplexInputChannel.ResponseReceiverDisconnected += (x, y) => { aClosedResponseReceiverId = y.ResponseReceiverId; aConnectionClosedEvent.Set(); }; try { // Start listening. aDuplexInputChannel.StartListening(); // Allow some time for pinging. aDuplexOutputChannel.OpenConnection(); Thread.Sleep(2000); Assert.AreEqual("", aClosedResponseReceiverId); // Close connection. Therefore the duplex input channel will not get any pings anymore. aDuplexOutputChannel.CloseConnection(); aConnectionClosedEvent.WaitOne(); Assert.AreEqual(aDuplexOutputChannel.ResponseReceiverId, aClosedResponseReceiverId); Assert.IsFalse(aDuplexOutputChannel.IsConnected); } finally { aDuplexOutputChannel.CloseConnection(); aDuplexInputChannel.StopListening(); } }
public void B02_Pinging_DisconnectResponseReceiver() { IDuplexInputChannel aDuplexInputChannel = MessagingSystemFactory.CreateDuplexInputChannel(ChannelId); IDuplexOutputChannel aDuplexOutputChannel = MessagingSystemFactory.CreateDuplexOutputChannel(ChannelId); AutoResetEvent aDisconnectedEvent = new AutoResetEvent(false); bool aDisconnectedFlag = false; aDuplexOutputChannel.ConnectionClosed += (x, y) => { aDisconnectedFlag = true; aDisconnectedEvent.Set(); }; try { // Start listening. aDuplexInputChannel.StartListening(); // Allow some time for pinging. aDuplexOutputChannel.OpenConnection(); Thread.Sleep(2000); Assert.IsFalse(aDisconnectedFlag); // Disconnect the duplex output channel. aDuplexInputChannel.DisconnectResponseReceiver(aDuplexOutputChannel.ResponseReceiverId); aDisconnectedEvent.WaitOne(); Assert.IsTrue(aDisconnectedFlag); Assert.IsFalse(aDuplexOutputChannel.IsConnected); } finally { aDuplexOutputChannel.CloseConnection(); aDuplexInputChannel.StopListening(); } }
private void StartCapturing() { // Use unique name for the pipe. string aVideoPipeName = Guid.NewGuid().ToString(); // Open pipe that will be read by VLC. myVideoPipe = new NamedPipeServerStream(@"\" + aVideoPipeName, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 0, 32764); ManualResetEvent aVlcConnectedPipe = new ManualResetEvent(false); ThreadPool.QueueUserWorkItem(x => { myVideoPipe.WaitForConnection(); // Indicate VLC has connected the pipe. aVlcConnectedPipe.Set(); }); // VLC connects the pipe and starts playing. using (VlcMedia aMedia = new VlcMedia(myVlcInstance, @"stream://\\\.\pipe\" + aVideoPipeName)) { // Setup VLC so that it can process raw h264 data (i.e. not in mp4 container) aMedia.AddOption(":demux=H264"); myPlayer = new VlcMediaPlayer(aMedia); myPlayer.Drawable = VideoWindow.Child.Handle; // Note: This will connect the pipe and read the video. myPlayer.Play(); } // Wait until VLC connects the pipe so that it is ready to receive the stream. if (!aVlcConnectedPipe.WaitOne(5000)) { throw new TimeoutException("VLC did not open connection with the pipe."); } // Open connection with service running on Raspberry. myVideoChannel.OpenConnection(); }
public void B03_Pinging_NoResponseForPing() { // Create duplex input channel which will not send ping messages. IDuplexInputChannel aDuplexInputChannel = UnderlyingMessaging.CreateDuplexInputChannel(ChannelId); IDuplexOutputChannel aDuplexOutputChannel = MessagingSystemFactory.CreateDuplexOutputChannel(ChannelId); AutoResetEvent aDisconnectedEvent = new AutoResetEvent(false); bool aDisconnectedFlag = false; aDuplexOutputChannel.ConnectionClosed += (x, y) => { aDisconnectedFlag = true; aDisconnectedEvent.Set(); }; try { // Start listening. aDuplexInputChannel.StartListening(); // Allow some time for pinging. aDuplexOutputChannel.OpenConnection(); Assert.IsTrue(aDuplexOutputChannel.IsConnected); Thread.Sleep(2000); aDisconnectedEvent.WaitOne(); Assert.IsTrue(aDisconnectedFlag); Assert.IsFalse(aDuplexOutputChannel.IsConnected); } finally { aDuplexOutputChannel.CloseConnection(); aDuplexInputChannel.StopListening(); } }
public virtual void AuthenticationTimeout() { IDuplexInputChannel anInputChannel = MessagingSystemFactory.CreateDuplexInputChannel(ChannelId); IDuplexOutputChannel anOutputChannel = MessagingSystemFactory.CreateDuplexOutputChannel(ChannelId); try { myAuthenticationSleep = TimeSpan.FromMilliseconds(3000); anInputChannel.StartListening(); // Client opens the connection. Assert.Throws <TimeoutException>(() => anOutputChannel.OpenConnection()); } finally { myAuthenticationSleep = TimeSpan.FromMilliseconds(0); anOutputChannel.CloseConnection(); anInputChannel.StopListening(); } }
public virtual void ConnectionNotGranted() { IDuplexInputChannel anInputChannel = MessagingSystemFactory.CreateDuplexInputChannel(ChannelId); IDuplexOutputChannel anOutputChannel = MessagingSystemFactory.CreateDuplexOutputChannel(ChannelId); try { myConnectionNotGranted = true; anInputChannel.StartListening(); // Client opens the connection. Assert.Throws <InvalidOperationException>(() => anOutputChannel.OpenConnection()); } finally { myConnectionNotGranted = false; anOutputChannel.CloseConnection(); anInputChannel.StopListening(); } }
private bool Worker4504_Initialize() { // Create TCP messaging IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory(); Worker4504_OutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://" + serverIP.Text + ":4504/"); // Subscribe to response messages. Worker4504_OutputChannel.ConnectionClosed += Worker4504_ConnectionClosed; Worker4504_OutputChannel.ConnectionOpened += Worker4504_ConnectionOpened; Worker4504_OutputChannel.ResponseMessageReceived += Worker4504_ResponseMessageReceived; // Open connection and be able to send messages and receive response messages. Worker4504_OutputChannel.OpenConnection(); if (Worker4504_OutputChannel.IsConnected) { return(true); } else { return(false); } }
public virtual void AuthenticationCancelledByClient() { IDuplexInputChannel anInputChannel = MessagingSystemFactory.CreateDuplexInputChannel(ChannelId); IDuplexOutputChannel anOutputChannel = MessagingSystemFactory.CreateDuplexOutputChannel(ChannelId); try { myClientCancelAuthentication = true; anInputChannel.StartListening(); Exception anException = null; try { // Client opens the connection. anOutputChannel.OpenConnection(); } catch (Exception err) { anException = err; } Assert.IsInstanceOf <InvalidOperationException>(anException); // Check that the AuthenticationCancelled calleback was called. Assert.IsTrue(myAuthenticationCancelled); } finally { myClientCancelAuthentication = false; myAuthenticationCancelled = false; anOutputChannel.CloseConnection(); anInputChannel.StopListening(); } }
private bool Worker4504_Initialize() { // Create TCP messaging IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory(); Worker4504_OutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://" + serverIP.Text + ":4504/"); // Subscribe to response messages. Worker4504_OutputChannel.ConnectionClosed += Worker4504_ConnectionClosed; Worker4504_OutputChannel.ConnectionOpened += Worker4504_ConnectionOpened; Worker4504_OutputChannel.ResponseMessageReceived += Worker4504_ResponseMessageReceived; // Open connection and be able to send messages and receive response messages. Worker4504_OutputChannel.OpenConnection(); if (Worker4504_OutputChannel.IsConnected) { return true; } else { return false; } }
public void A16_RequestResponse_100_ConstantlyInterrupted() { IDuplexOutputChannel aDuplexOutputChannel = MessagingSystem.CreateDuplexOutputChannel(ChannelId); IDuplexInputChannel aDuplexInputChannel = MessagingSystem.CreateDuplexInputChannel(ChannelId); IDuplexInputChannel anUnderlyingDuplexInputChannel = aDuplexInputChannel.GetField <IDuplexInputChannel>("myInputChannel"); Assert.NotNull(anUnderlyingDuplexInputChannel); AutoResetEvent anAllMessagesProcessedEvent = new AutoResetEvent(false); // Received messages. List <int> aReceivedMessages = new List <int>(); aDuplexInputChannel.MessageReceived += (x, y) => { lock (aReceivedMessages) { string aReceivedMessage = y.Message as string; EneterTrace.Info("Received message: " + aReceivedMessage); int k = int.Parse(aReceivedMessage); aReceivedMessages.Add(k); k += 1000; EneterTrace.Info("Sent response message: " + k.ToString()); aDuplexInputChannel.SendResponseMessage(y.ResponseReceiverId, k.ToString()); } }; aDuplexOutputChannel.ConnectionClosed += (x, y) => { EneterTrace.Info("ConnectionClosed invoked in duplex output channel"); // The buffered duplex output channel exceeded the max offline time. anAllMessagesProcessedEvent.Set(); }; // Received response messages. List <int> aReceivedResponseMessages = new List <int>(); aDuplexOutputChannel.ResponseMessageReceived += (x, y) => { lock (aReceivedResponseMessages) { string aReceivedMessage = y.Message as string; EneterTrace.Info("Received response message: " + aReceivedMessage); int k = int.Parse(aReceivedMessage); aReceivedResponseMessages.Add(k); if (aReceivedResponseMessages.Count == 100) { anAllMessagesProcessedEvent.Set(); } } }; try { bool aTestFinishedFlag = false; aDuplexInputChannel.StartListening(); aDuplexOutputChannel.OpenConnection(); Thread anInteruptingThread = new Thread(() => { for (int i = 0; i < 100 && !aTestFinishedFlag; ++i) { anUnderlyingDuplexInputChannel.DisconnectResponseReceiver(aDuplexOutputChannel.ResponseReceiverId); Thread.Sleep(ConnectionInterruptionFrequency); } }); // Start constant disconnecting. anInteruptingThread.Start(); for (int i = 0; i < 100; ++i) { aDuplexOutputChannel.SendMessage(i.ToString()); } // Wait until all messages are processed. //anAllMessagesProcessedEvent.WaitOne(); Assert.IsTrue(anAllMessagesProcessedEvent.WaitOne(20000), "The timeout occured."); aTestFinishedFlag = true; anInteruptingThread.Join(); } finally { aDuplexOutputChannel.CloseConnection(); aDuplexInputChannel.StopListening(); } aReceivedMessages.Sort(); Assert.AreEqual(100, aReceivedMessages.Count); for (int i = 0; i < 100; ++i) { Assert.AreEqual(i, aReceivedMessages[i]); } aReceivedResponseMessages.Sort(); Assert.AreEqual(100, aReceivedResponseMessages.Count); for (int i = 0; i < 100; ++i) { Assert.AreEqual(i + 1000, aReceivedResponseMessages[i]); } }
public void LoadBalancerConnectionLogic() { IMessagingSystemFactory aMessaging = new SynchronousMessagingSystemFactory(); string aReceiverChannelId = ""; EventHandler <DuplexChannelMessageEventArgs> aRequestReceived = (x, y) => { // Echo the message. IDuplexInputChannel anInputChannel = (IDuplexInputChannel)x; aReceiverChannelId = anInputChannel.ChannelId; anInputChannel.SendResponseMessage(y.ResponseReceiverId, y.Message); }; string aResponseReceiverId = ""; ResponseReceiverEventArgs aDisconnectedLoadBalancerConnection = null; EventHandler <ResponseReceiverEventArgs> aDisconnectedFromReceiver = (x, y) => { aResponseReceiverId = ((IDuplexInputChannel)x).ChannelId; aDisconnectedLoadBalancerConnection = y; }; // Receivers. IDuplexInputChannel[] aReceivers = new IDuplexInputChannel[3]; for (int i = 0; i < aReceivers.Length; ++i) { aReceivers[i] = aMessaging.CreateDuplexInputChannel((i + 1).ToString()); aReceivers[i].MessageReceived += aRequestReceived; aReceivers[i].ResponseReceiverDisconnected += aDisconnectedFromReceiver; } // Clients. IDuplexOutputChannel aClient1 = aMessaging.CreateDuplexOutputChannel("LB"); string aReceivedResponse1 = ""; aClient1.ResponseMessageReceived += (x, y) => { aReceivedResponse1 = (string)y.Message; }; IDuplexOutputChannel aClient2 = aMessaging.CreateDuplexOutputChannel("LB"); string aReceivedResponse2 = ""; aClient2.ResponseMessageReceived += (x, y) => { aReceivedResponse2 = (string)y.Message; }; // Load Balancer ILoadBalancerFactory aLoadBalancerFactory = new RoundRobinBalancerFactory(aMessaging); ILoadBalancer aLoadBalancer = aLoadBalancerFactory.CreateLoadBalancer(); AutoResetEvent aReceiverRemovedEvent = new AutoResetEvent(false); string aRemovedReceiverId = ""; aLoadBalancer.RequestReceiverRemoved += (x, y) => { aRemovedReceiverId = y.ChannelId; aReceiverRemovedEvent.Set(); }; try { // Receivers start listening. foreach (IDuplexInputChannel aReceiver in aReceivers) { aReceiver.StartListening(); } // Load Balancer starts listening. for (int i = 0; i < aReceivers.Length; ++i) { aLoadBalancer.AddDuplexOutputChannel((i + 1).ToString()); } aLoadBalancer.AttachDuplexInputChannel(aMessaging.CreateDuplexInputChannel("LB")); // Clients connect the load balancer. aClient1.OpenConnection(); aClient2.OpenConnection(); // It shall use the next (second) receiver. aClient1.SendMessage("Hello."); Assert.AreEqual("Hello.", aReceivedResponse1); Assert.AreEqual("", aReceivedResponse2); Assert.AreEqual("2", aReceiverChannelId); aReceivedResponse1 = ""; aReceivedResponse2 = ""; // It shall use the next (third) receiver. aClient2.SendMessage("Hello."); Assert.AreEqual("", aReceivedResponse1); Assert.AreEqual("Hello.", aReceivedResponse2); Assert.AreEqual("3", aReceiverChannelId); aReceivedResponse1 = ""; aReceivedResponse2 = ""; // It is at the end of the pool so it shall starts from the beginning. aClient2.SendMessage("Hello."); Assert.AreEqual("", aReceivedResponse1); Assert.AreEqual("Hello.", aReceivedResponse2); Assert.AreEqual("1", aReceiverChannelId); aReceivedResponse1 = ""; aReceivedResponse2 = ""; // Let's remove the second receiver. aLoadBalancer.RemoveDuplexOutputChannel("2"); Assert.IsNotNull(aDisconnectedLoadBalancerConnection); Assert.AreEqual("2", aResponseReceiverId); // The 2nd is removed so it shall use the 3rd one. aClient2.SendMessage("Hello."); Assert.AreEqual("", aReceivedResponse1); Assert.AreEqual("Hello.", aReceivedResponse2); Assert.AreEqual("3", aReceiverChannelId); aReceivedResponse1 = ""; aReceivedResponse2 = ""; // 1st receiver stops to listen. aReceivers[0].StopListening(); // It should start from the beginnng but 1st is not listening and 2nd was removed. // So it shall use the 3rd one. aClient1.SendMessage("Hello."); Assert.AreEqual("Hello.", aReceivedResponse1); Assert.AreEqual("", aReceivedResponse2); Assert.AreEqual("3", aReceiverChannelId); aReceivedResponse1 = ""; aReceivedResponse2 = ""; aReceiverRemovedEvent.WaitOne(); Assert.AreEqual("1", aRemovedReceiverId); aReceivers[2].StopListening(); aClient2.SendMessage("Hello."); Assert.AreEqual("", aReceivedResponse1); Assert.AreEqual("", aReceivedResponse2); aReceivedResponse1 = ""; aReceivedResponse2 = ""; aReceiverRemovedEvent.WaitOne(); Assert.AreEqual("3", aRemovedReceiverId); aReceivers[0].StartListening(); aReceivers[2].StartListening(); for (int i = 0; i < aReceivers.Length; ++i) { aLoadBalancer.AddDuplexOutputChannel((i + 1).ToString()); } aClient2.SendMessage("Hello."); Assert.AreEqual("", aReceivedResponse1); Assert.AreEqual("Hello.", aReceivedResponse2); Assert.AreEqual("2", aReceiverChannelId); aReceivedResponse1 = ""; aReceivedResponse2 = ""; } finally { aClient1.CloseConnection(); aClient2.CloseConnection(); aLoadBalancer.DetachDuplexInputChannel(); foreach (IDuplexInputChannel aReceiver in aReceivers) { aReceiver.StopListening(); } } }
private bool InitializeWorkerConnection() { // Create TCP messaging IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory(); Worker4504OutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:4504/"); // Subscribe to response messages. Worker4504OutputChannel.ConnectionClosed += Worker4504OutputChannel_ConnectionClosed; Worker4504OutputChannel.ConnectionOpened += Worker4504OutputChannel_ConnectionOpened; Worker4504OutputChannel.ResponseMessageReceived += Worker4504OutputChannel_ResponseMessageReceived; // Open connection and be able to send messages and receive response messages. Worker4504OutputChannel.OpenConnection(); Log("Channel id : " + Worker4504OutputChannel.ChannelId); // Send a message. byte[] data = new byte[1048576]; // initialize 1MB data //byte[] data = new byte[10]; // initialize 1MB data Random random = new Random(); random.NextBytes(data); Worker4504OutputChannel.SendMessage(data); Log("Sent data length : " + data.Length); // Close connection. //Worker4504OutputChannel.CloseConnection(); return true; }
// A message from a client is received. It must be forwarded to a request receiver from the pool. protected override void OnRequestMessageReceived(object sender, DuplexChannelMessageEventArgs e) { using (EneterTrace.Entering()) { while (true) { string aChannelId; // Get the next available receiver. using (ThreadLock.Lock(myReceiverManipulatorLock)) { if (myAvailableReceivers.Count == 0) { EneterTrace.Error(TracedObject + "failed to forward the message because there no receivers in the pool."); break; } // Move to the next receiver. ++myCurrentAvailableReceiverIdx; if (myCurrentAvailableReceiverIdx >= myAvailableReceivers.Count) { myCurrentAvailableReceiverIdx = 0; } aChannelId = myAvailableReceivers[myCurrentAvailableReceiverIdx]; // If there is not open connection for the current response receiver id, then open it. TConnection aConnection = myOpenConnections.FirstOrDefault(x => x.ResponseReceiverId == e.ResponseReceiverId && x.DuplexOutputChannel.ChannelId == aChannelId); if (aConnection == null) { IDuplexOutputChannel anOutputChannel = myOutputMessagingFactory.CreateDuplexOutputChannel(aChannelId); anOutputChannel.ResponseMessageReceived += OnResponseMessageReceived; anOutputChannel.ConnectionClosed += OnRequestReceiverClosedConnection; try { anOutputChannel.OpenConnection(); } catch (Exception err) { EneterTrace.Warning(TracedObject + ErrorHandler.FailedToOpenConnection, err); anOutputChannel.ResponseMessageReceived -= OnResponseMessageReceived; anOutputChannel.ConnectionClosed -= OnRequestReceiverClosedConnection; // It was not possible to open the connection with the given receiver. // So remove the receiver from available receivers. myAvailableReceivers.Remove(aChannelId); NotifyRequestRecieverRemoved(aChannelId); // Continue with the next receiver. continue; } aConnection = new TConnection(e.ResponseReceiverId, e.SenderAddress, anOutputChannel); myOpenConnections.Add(aConnection); } // Try to forward the message via the connection. try { aConnection.DuplexOutputChannel.SendMessage(e.Message); } catch (Exception err) { EneterTrace.Warning(TracedObject + ErrorHandler.FailedToSendMessage, err); try { // Remove the connection. aConnection.DuplexOutputChannel.CloseConnection(); } catch (Exception err2) { EneterTrace.Warning(TracedObject + ErrorHandler.FailedToCloseConnection, err2); } aConnection.DuplexOutputChannel.ResponseMessageReceived -= OnResponseMessageReceived; aConnection.DuplexOutputChannel.ConnectionClosed -= OnRequestReceiverClosedConnection; myOpenConnections.Remove(aConnection); // Try next receiver. continue; } break; } } } }
public void A01_SimpleRequestResponse() { IDuplexOutputChannel aDuplexOutputChannel = MessagingSystem.CreateDuplexOutputChannel(ChannelId); IDuplexInputChannel aDuplexInputChannel = MessagingSystem.CreateDuplexInputChannel(ChannelId); // Received messages. List <int> aReceivedMessages = new List <int>(); aDuplexInputChannel.MessageReceived += (x, y) => { //EneterTrace.Info("Message Received"); lock (aReceivedMessages) { string aReceivedMessage = y.Message as string; int k = int.Parse(aReceivedMessage); aReceivedMessages.Add(k); k += 1000; aDuplexInputChannel.SendResponseMessage(y.ResponseReceiverId, k.ToString()); } }; // Received response messages. List <int> aReceivedResponseMessages = new List <int>(); AutoResetEvent anAllMessagesProcessedEvent = new AutoResetEvent(false); aDuplexOutputChannel.ResponseMessageReceived += (x, y) => { //EneterTrace.Info("Response Received"); lock (aReceivedResponseMessages) { string aReceivedMessage = y.Message as string; int k = int.Parse(aReceivedMessage); aReceivedResponseMessages.Add(k); if (k == 1019) { anAllMessagesProcessedEvent.Set(); } } }; try { aDuplexInputChannel.StartListening(); aDuplexOutputChannel.OpenConnection(); for (int i = 0; i < 20; ++i) { aDuplexOutputChannel.SendMessage(i.ToString()); } // Wait untill all messages are processed. anAllMessagesProcessedEvent.WaitOne(); } finally { aDuplexOutputChannel.CloseConnection(); aDuplexInputChannel.StopListening(); } aReceivedMessages.Sort(); Assert.AreEqual(20, aReceivedMessages.Count); for (int i = 0; i < 20; ++i) { Assert.AreEqual(i, aReceivedMessages[i]); } aReceivedResponseMessages.Sort(); Assert.AreEqual(20, aReceivedResponseMessages.Count); for (int i = 0; i < 20; ++i) { Assert.AreEqual(i + 1000, aReceivedResponseMessages[i]); } }
public void B01_InactivityTimeout() { // Set the polling frequency slower // than inactivity timeout in the duplex input channel. // Therefore the timeout should occur before the polling - this is how the // inactivity is simulated in this test. IMessagingSystemFactory aMessagingSystem = new HttpMessagingSystemFactory(3000, 2000); IDuplexOutputChannel anOutputChannel1 = aMessagingSystem.CreateDuplexOutputChannel(ChannelId); IDuplexOutputChannel anOutputChannel2 = aMessagingSystem.CreateDuplexOutputChannel(ChannelId); IDuplexInputChannel anInputChannel = aMessagingSystem.CreateDuplexInputChannel(ChannelId); AutoResetEvent aConncetionEvent = new AutoResetEvent(false); AutoResetEvent aDisconncetionEvent = new AutoResetEvent(false); List <TConnectionEvent> aConnections = new List <TConnectionEvent>(); anInputChannel.ResponseReceiverConnected += (x, y) => { aConnections.Add(new TConnectionEvent(DateTime.Now, y.ResponseReceiverId)); aConncetionEvent.Set(); }; List <TConnectionEvent> aDisconnections = new List <TConnectionEvent>(); anInputChannel.ResponseReceiverDisconnected += (x, y) => { aDisconnections.Add(new TConnectionEvent(DateTime.Now, y.ResponseReceiverId)); aDisconncetionEvent.Set(); }; try { anInputChannel.StartListening(); Assert.IsTrue(anInputChannel.IsListening); // Create the 1st connection. anOutputChannel1.OpenConnection(); Assert.IsTrue(anOutputChannel1.IsConnected); aConncetionEvent.WaitOne(); Assert.AreEqual(1, aConnections.Count); Assert.IsFalse(string.IsNullOrEmpty(aConnections[0].ReceiverId)); Thread.Sleep(1000); // Create the 2nd connection. anOutputChannel2.OpenConnection(); Assert.IsTrue(anOutputChannel2.IsConnected); aConncetionEvent.WaitOne(); Assert.AreEqual(2, aConnections.Count); Assert.IsFalse(string.IsNullOrEmpty(aConnections[1].ReceiverId)); // Wait for the 1st disconnection aDisconncetionEvent.WaitOne(); Assert.AreEqual(1, aDisconnections.Count); Assert.AreEqual(aConnections[0].ReceiverId, aDisconnections[0].ReceiverId); Assert.IsTrue(aDisconnections[0].Time - aConnections[0].Time > TimeSpan.FromMilliseconds(1900)); // Wait for the 2nd disconnection aDisconncetionEvent.WaitOne(); Assert.AreEqual(2, aDisconnections.Count); Assert.AreEqual(aConnections[1].ReceiverId, aDisconnections[1].ReceiverId); Assert.IsTrue(aDisconnections[1].Time - aConnections[1].Time > TimeSpan.FromMilliseconds(1900)); } finally { anOutputChannel1.CloseConnection(); anOutputChannel2.CloseConnection(); anInputChannel.StopListening(); } }
protected override void OnRequestMessageReceived(object sender, DuplexChannelMessageEventArgs e) { using (EneterTrace.Entering()) { WrappedData aWrappedData = null; try { ISerializer aSerializer = mySerializer.ForResponseReceiver(e.ResponseReceiverId); // Unwrap the incoming message. aWrappedData = DataWrapper.Unwrap(e.Message, aSerializer); } catch (Exception err) { EneterTrace.Error(TracedObject + "failed to unwrap the message.", err); return; } // WrappedData.AddedData represents the channel id. // Therefore if everything is ok then it must be string. if (aWrappedData.AddedData is string) { string aMessageReceiverId = (string)aWrappedData.AddedData; TDuplexConnection aConectionToOutput = null; // Try to find if the output channel with the required channel id and for the incoming response receiver // already exists. using (ThreadLock.Lock(myConnections)) { aConectionToOutput = myConnections.FirstOrDefault(x => x.DuplexOutputChannel.ChannelId == aMessageReceiverId && x.ResponseReceiverId == e.ResponseReceiverId); // If it does not exist then create the duplex output channel and open connection. if (aConectionToOutput == null) { IDuplexOutputChannel aDuplexOutputChannel = null; try { aDuplexOutputChannel = myOutputMessagingFactory.CreateDuplexOutputChannel(aMessageReceiverId); aDuplexOutputChannel.ResponseMessageReceived += OnResponseMessageReceived; aDuplexOutputChannel.OpenConnection(); } catch (Exception err) { EneterTrace.Error(TracedObject + "failed to create and connect the duplex output channel '" + aMessageReceiverId + "'", err); if (aDuplexOutputChannel != null) { aDuplexOutputChannel.ResponseMessageReceived -= OnResponseMessageReceived; aDuplexOutputChannel.CloseConnection(); aDuplexOutputChannel = null; } } if (aDuplexOutputChannel != null) { aConectionToOutput = new TDuplexConnection(e.ResponseReceiverId, aDuplexOutputChannel); myConnections.Add(aConectionToOutput); } } } if (aConectionToOutput != null) { try { // Send the unwrapped message. aConectionToOutput.DuplexOutputChannel.SendMessage(aWrappedData.OriginalData); } catch (Exception err) { EneterTrace.Error(TracedObject + "failed to send the message to the output channel '" + aConectionToOutput.DuplexOutputChannel.ChannelId + "'.", err); } } } else { EneterTrace.Error(TracedObject + "detected that the unwrapped message contian the channel id as the string type."); } } }
private void ConnectHalovisionDevice() { try { Core.Initialize(); if (txtDeviceURL.Text.Contains("://")) { libvlc = new LibVLC(enableDebugLogs: true); libvlc.SetLogFile($"{lucidScribeDataPath}\\vlc.log"); using (Media media = new Media(libvlc, txtDeviceURL.Text, FromType.FromLocation)) { player = new MediaPlayer(media); player.Hwnd = pbDisplay.Handle; player.Play(); } return; } libvlc = new LibVLC(enableDebugLogs: false, "--rtsp-tcp"); // Use TCP messaging. videoChannel = new TcpMessagingSystemFactory().CreateDuplexOutputChannel("tcp://" + txtDeviceURL.Text + ":8093/"); videoChannel.ResponseMessageReceived += OnResponseMessageReceived; // Use unique name for the pipe. string aVideoPipeName = Guid.NewGuid().ToString(); // Open pipe that will be read by VLC. videoPipe = new NamedPipeServerStream(@"\" + aVideoPipeName, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 0, 65528); ManualResetEvent vlcConnectedPipe = new ManualResetEvent(false); ThreadPool.QueueUserWorkItem(x => { videoPipe.WaitForConnection(); // Indicate VLC has connected the pipe. vlcConnectedPipe.Set(); }); // VLC connects the pipe and starts playing. using (Media media = new Media(libvlc, @"stream://\\\.\pipe\" + aVideoPipeName, FromType.FromLocation)) { // Setup VLC so that it can process raw h264 data media.AddOption(":demux=H264"); player = new MediaPlayer(media); player.Hwnd = pbDisplay.Handle; // Note: This will connect the pipe and read the video. player.Play(); } // Wait until VLC connects the pipe so that it is ready to receive the stream. if (!vlcConnectedPipe.WaitOne(5000)) { throw new TimeoutException($"VLC did not open connection with {txtDeviceURL.Text}."); } // Open connection with service running on Raspberry. videoChannel.OpenConnection(); } catch (Exception ex) { MessageBox.Show(ex.Message, "LucidScribe.InitializePlugin()", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public void A01_Reconnect_DisconnectReceiver() { IDuplexInputChannel aDuplexInputChannel = MessagingSystemFactory.CreateDuplexInputChannel(ChannelId); IDuplexOutputChannel aDuplexOutputChannel = MessagingSystemFactory.CreateDuplexOutputChannel(ChannelId); Reconnecter aReconnecter = new Reconnecter(aDuplexOutputChannel, TimeSpan.FromMilliseconds(300), -1); AutoResetEvent aReconnectEvent = new AutoResetEvent(false); DuplexChannelEventArgs aReconnectEventArgs = null; aReconnecter.ConnectionOpened += (x, y) => { aReconnectEventArgs = y; aReconnectEvent.Set(); }; AutoResetEvent aDisconnectEvent = new AutoResetEvent(false); DuplexChannelEventArgs aDisconnectEventArgs = null; aReconnecter.ConnectionClosed += (x, y) => { aDisconnectEventArgs = y; aDisconnectEvent.Set(); }; AutoResetEvent aConnectionOpenedEvent = new AutoResetEvent(false); aDuplexOutputChannel.ConnectionOpened += (x, y) => { aConnectionOpenedEvent.Set(); }; AutoResetEvent aConnectionClosedEvent = new AutoResetEvent(false); aDuplexOutputChannel.ConnectionClosed += (x, y) => { aConnectionClosedEvent.Set(); }; try { aReconnecter.EnableReconnecting(); // Start listening. aDuplexInputChannel.StartListening(); aDuplexOutputChannel.OpenConnection(); Thread.Sleep(2000); Assert.IsTrue(aDuplexOutputChannel.IsConnected); aConnectionOpenedEvent.WaitOne(); // Disconnect the duplexoutput channel. aDuplexInputChannel.DisconnectResponseReceiver(aDuplexOutputChannel.ResponseReceiverId); // Wait until the disconnect is notified. aDisconnectEvent.WaitOne(); aConnectionClosedEvent.WaitOne(); Assert.AreEqual(aDuplexOutputChannel.ChannelId, aDisconnectEventArgs.ChannelId); Assert.AreEqual(aDuplexOutputChannel.ResponseReceiverId, aDisconnectEventArgs.ResponseReceiverId); // Wait until the reconnecter opens connection again. aReconnectEvent.WaitOne(); Assert.AreEqual(aDuplexOutputChannel.ChannelId, aReconnectEventArgs.ChannelId); Assert.AreEqual(aDuplexOutputChannel.ResponseReceiverId, aReconnectEventArgs.ResponseReceiverId); Assert.IsTrue(aDuplexOutputChannel.IsConnected); aConnectionOpenedEvent.WaitOne(); } finally { aReconnecter.DisableReconnecting(); aDuplexOutputChannel.CloseConnection(); aDuplexInputChannel.StopListening(); } }
public void A02_Reconnect_StopListening() { MonitoredMessagingFactory aConnectionMonitor = new MonitoredMessagingFactory(MessagingSystemFactory); IDuplexInputChannel aDuplexInputChannel = aConnectionMonitor.CreateDuplexInputChannel(ChannelId); IDuplexOutputChannel aDuplexOutputChannel = aConnectionMonitor.CreateDuplexOutputChannel(ChannelId); // Max 5 attempts to try to reconnect. Reconnecter aReconnecter = new Reconnecter(aDuplexOutputChannel, TimeSpan.FromMilliseconds(300), 5); AutoResetEvent aReconnectEvent = new AutoResetEvent(false); DuplexChannelEventArgs aReconnectEventArgs = null; aReconnecter.ConnectionOpened += (x, y) => { aReconnectEventArgs = y; aReconnectEvent.Set(); }; AutoResetEvent aDisconnectEvent = new AutoResetEvent(false); DuplexChannelEventArgs aDisconnectEventArgs = null; aReconnecter.ConnectionClosed += (x, y) => { aDisconnectEventArgs = y; aDisconnectEvent.Set(); }; AutoResetEvent aReconnecFailedEvent = new AutoResetEvent(false); DuplexChannelEventArgs aReconnectingFailedEventArgs = null; aReconnecter.ReconnectingFailed += (x, y) => { aReconnectingFailedEventArgs = y; aReconnecFailedEvent.Set(); }; try { aReconnecter.EnableReconnecting(); // Start listening. aDuplexInputChannel.StartListening(); aDuplexOutputChannel.OpenConnection(); Thread.Sleep(2000); Assert.IsTrue(aDuplexOutputChannel.IsConnected); Assert.IsNull(aReconnectingFailedEventArgs); Assert.IsNull(aDisconnectEventArgs); Assert.IsNull(aReconnectEventArgs); // Stop listening. // Note: The Reconnecter will try 5 times to reopen the connection, then it will notify, the reconnecion failed. aDuplexInputChannel.StopListening(); // Wait until the disconnect is notified. aDisconnectEvent.WaitOne(); Assert.AreEqual(aDuplexOutputChannel.ChannelId, aDisconnectEventArgs.ChannelId); Assert.AreEqual(aDuplexOutputChannel.ResponseReceiverId, aDisconnectEventArgs.ResponseReceiverId); Assert.IsFalse(aDuplexOutputChannel.IsConnected); Assert.IsNull(aReconnectEventArgs); // Wait until the reconnect fails after 5 failed reconnects. aReconnecFailedEvent.WaitOne(); Assert.AreEqual(aDuplexOutputChannel.ChannelId, aReconnectingFailedEventArgs.ChannelId); Assert.AreEqual(aDuplexOutputChannel.ResponseReceiverId, aReconnectingFailedEventArgs.ResponseReceiverId); Assert.IsFalse(aDuplexOutputChannel.IsConnected); Assert.IsNull(aReconnectEventArgs); } finally { aDuplexOutputChannel.CloseConnection(); aDuplexInputChannel.StopListening(); aReconnecter.DisableReconnecting(); } }