//------------------------------------------------------------------------------------------------------------------------ public void Deinitialize() { lock (this) { try { //close socket #if NETFX try { _sock?.Disconnect(false); } catch { } try { _sock?.Close(); } catch { } #endif try { _sock?.Dispose(); } catch { } _sock = null; //stop tasks IsRunning = false; #if NETFX DiscoveryTask?.Join(200); BroadcastTask?.Join(200); #elif UNIVERSAL DiscoveryTask?.Wait(200); BroadcastTask?.Wait(200); #endif DiscoveryTask = null; BroadcastTask = null; } catch (Exception ex) { DebugEx.Assert(ex); } } }
//------------------------------------------------------------------------------------------------------------------------ public void Stop(bool CloseAllChannels = false) { try { lock (this) { //close all channels if (CloseAllChannels) { _Channels.ForEach(c => { try { c.Close("Server stopped"); } catch (Exception ex) { DebugEx.Assert(ex, "Error while closing channel"); } }); _Channels.Clear(); } //update flag if (!_IsRunning) { return; } else { _IsRunning = false; } //close my socket try { if (sock != null) { #if NETFX try { sock.Close(); } catch { } #endif try { sock.Dispose(); } catch { } } } catch (Exception ex) { DebugEx.TraceErrorException(ex); } sock = null; //wait for task finish #if NETFX PortListener?.Join(1000); #elif UNIVERSAL PortListener?.Wait(1000); #endif PortListener = null; } } catch (Exception ex) { DebugEx.Assert(ex, "YPChannel Server Stop() failed"); } }
public void TestWait() { var thread = Thread.CreateThread(); Assert.IsNotNull(thread); bool flag = false; thread.Post(() => { Thread.Sleep(10); flag = true; }); var rc = Thread.Wait(() => flag, 100); Assert.IsTrue(flag); Assert.IsTrue(rc); }
public JctTest Execute(JctRestartViaSmsAttempt jctMessageType) { // after five minutes, publish an event to check if the JCT logged in var jctLoggedInTimeOut = TimeSpan.FromMinutes(double.Parse(_appSettings["JctLogInTimeOut"])); var message = new JctRestartViaSmsValidate(jctMessageType.Imei); Thread.Wait(jctLoggedInTimeOut.Milliseconds); _queues.Publish(message); // reset test values return(new JctTest("6", jctMessageType.Imei, null, null, null)); }
private static void Run(ITestOutputHelper log, ushort port, Delivery delivery, int length, int count, int interval, int sleep, int duration) { Exception serverex = null, clientex = null; var server = new Thread(() => { try { Server(log, port, delivery, length, count, interval, sleep, duration); } catch (Exception e) { serverex = e; } }) { Name = "SERVER", IsBackground = true }; var client = new Thread(() => { try { Client(log, port, delivery, length, count, interval, sleep, duration); } catch (Exception e) { clientex = e; } }) { Name = "CLIENT", IsBackground = true }; server.Start(); client.Start(); server.Wait(); client.Wait(); if (clientex != null) { throw new Exception($"{client.Name} exception", clientex); } if (serverex != null) { throw new Exception($"{server.Name} exception", serverex); } }
public void TestMethod_ReceiveWaiter() { string testName = "ReceiveWaiter"; Connection connection = new Connection(testTarget.Address); Session session = new Session(connection); ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, testTarget.Path); #if NETFX || NETFX_CORE Task t = Task.Run(() => { Message message = receiver.Receive(); Trace.WriteLine(TraceLevel.Verbose, "receive: {0}", message.Properties.MessageId); receiver.Accept(message); }); #else Thread t = new Thread(() => { Message message = receiver.Receive(); Trace.WriteLine(TraceLevel.Verbose, "receive: {0}", message.Properties.MessageId); receiver.Accept(message); }); t.Start(); #endif SenderLink sender = new SenderLink(session, "sender-" + testName, testTarget.Path); Message msg = new Message() { Properties = new Properties() { MessageId = "123456" } }; sender.Send(msg, null, null); #if NETFX || NETFX_CORE t.Wait(10000); #else t.Join(10000); #endif sender.Close(); receiver.Close(); session.Close(); connection.Close(); }
public void TestTaskPost() { var pool = new ThreadPool(); checkCount = 0; pool.Post(new Task(postTaskUpdateFunc, pool)); pool.Post(new Task(postTaskAddFunc, pool)); var failed = false; pool.Post(() => { failed = true; }, 1000); Thread.Wait(() => checkCount >= 10, 1000); Assert.IsFalse(failed); Assert.AreEqual(checkCount, 10); pool.Stop(); }
public void Stop() { if (!_isRunning) { return; } _isRunning = false; #if UNITY_EDITOR _polster.Join(); #else _polster.Wait(); #endif LeapC.CloseConnection(_leapConnection); }
public void TesTimer() { bool ret = false; var timer = Timeout.Add(100, (id) => ret = true, (id) => Assert.Fail()); var rc = Thread.Wait(() => ret, 1000); Assert.IsTrue(rc); Assert.IsTrue(ret); rc = Timeout.Remove(timer); Assert.IsFalse(rc); ret = false; timer = Timeout.Add(1000, (id) => Assert.Fail(), (id) => ret = true); Thread.Sleep(10); rc = Timeout.Remove(timer); Assert.IsTrue(rc); Assert.IsTrue(ret); }
public void TestCacheMultiThread() { getCount = 0; setCount = 0; var cache = new Cache <int, string>(); Assert.IsNotNull(cache); cache.LockEnable = true; for (int i = 0; i < thread_count; i++) { var value = i; Thread.WorkThread.Post(() => thread_add_data(new object[] { cache, value })); } var ret = Thread.Wait(() => cache.Count == thread_count * cache_data_count, 1000); Assert.IsTrue(ret); for (int i = 0; i < thread_count; i++) { var value = i; Thread.WorkThread.Post(() => thread_cas_data(new object[] { cache, value })); } for (int i = 0; i < thread_count; i++) { var value = i; Thread.WorkThread.Post(() => thread_get_data(new object[] { cache, value + 1 })); } ret = Thread.Wait(() => setCount == thread_count * cache_data_count && getCount == thread_count * get_data_count, 2000); Assert.IsTrue(ret); // stats cache.StatsPrint(); }
public void TestMonitor() { var thread = Thread.CreateThread(); Assert.IsNotNull(thread); thread.Post(() => Thread.Sleep(100)); Thread.InitializeMonitor(); bool endless = false; Thread.OnEndless = (s) => endless = true; Thread.OnRecover = (s) => endless = false; var rc = Thread.Wait(() => endless, 1000); Assert.IsTrue(endless); Assert.IsTrue(rc); rc = Thread.Wait(() => endless == false, 1000); Assert.IsFalse(endless); Assert.IsTrue(rc); Thread.StopThread(thread); Thread.OnEndless = null; Thread.OnRecover = null; }
public void TestSocketPair() { var server = SocketBase.Create(SocketType.Pair); bool rc = server.Bind("127.0.0.1:" + port); Assert.IsTrue(rc); Thread.Sleep(10); var client = SocketBase.Create(SocketType.Pair); rc = client.Connect("127.0.0.1:" + port); Assert.IsTrue(rc); port++; Message empty = new Message(0); Assert.IsTrue(empty.IsBuffer); Assert.AreEqual(empty.Count, 0); rc = Thread.Wait(() => server.ConnectionCount == 1, -1); Assert.IsTrue(rc); rc = server.TrySend(ref empty, 1000); Assert.IsTrue(rc); Assert.IsTrue(empty.IsBuffer); Assert.AreEqual(empty.Count, 0); Message emptyRecv; rc = client.TryRecv(out emptyRecv, 1000); Assert.IsTrue(rc); Assert.IsTrue(emptyRecv.IsBuffer); Assert.AreEqual(emptyRecv.Count, 0); var checkData = generateCheckData(); for (int i = 0; i < checkCount; i++) { var msg = generateMessage(checkData); rc = server.TrySend(ref msg, 1000); Assert.IsTrue(rc); } for (int i = 0; i < checkCount; i++) { var msg = generateMessage(checkData); rc = client.TrySend(ref msg, 1000); Assert.IsTrue(rc); } int result = 0; for (int i = 0; i < checkCount; i++) { Message msg; rc = client.TryRecv(out msg, 1000); Assert.IsTrue(rc); checkMessage(ref msg, checkData); result++; } Assert.AreEqual(result, checkCount); result = 0; for (int i = 0; i < checkCount; i++) { Message msg; rc = server.TryRecv(out msg, 1000); Assert.IsTrue(rc); checkMessage(ref msg, checkData); result++; } Assert.AreEqual(result, checkCount); Assert.AreEqual(result, checkCount); client.Close(); rc = client.WaitClose(1000); Assert.IsTrue(rc); server.Close(); rc = server.WaitClose(1000); Assert.IsTrue(rc); }
public void TestSocketPubSubMultiple() { List <SocketBase> pubSet = new List <SocketBase>(); for (int i = 0; i < serverCount; i++) { var pub = SocketBase.Create(SocketType.Pub); bool rc = pub.Bind("127.0.0.1:" + (port + i)); Assert.IsTrue(rc); pubSet.Add(pub); } List <SocketBase> subSet = new List <SocketBase>(); for (int i = 0; i < clientCount; i++) { var sub = SocketBase.Create(SocketType.Sub); for (int p = 0; p < serverCount; p++) { bool rc = sub.Connect("127.0.0.1:" + (port + p)); Assert.IsTrue(rc); } subSet.Add(sub); } port += serverCount; var checkData = generateCheckData(); var threadPool = new ThreadPool(clientCount); for (int p = 0; p < serverCount; p++) { var pub = pubSet[p]; threadPool.Post(() => { bool rc = Thread.Wait(() => pub.ConnectionCount == clientCount, 1000); Assert.IsTrue(rc); for (int i = 0; i < checkCount; i++) { var msg = generateMessage(checkData); rc = pub.TrySend(ref msg, 1000); Assert.IsTrue(rc); } }); } int result = 0; for (int s = 0; s < clientCount; s++) { var sub = subSet[s]; var subId = s; threadPool.Post(() => { bool rc = Thread.Wait(() => sub.ConnectionCount == serverCount, 1000); Assert.IsTrue(rc); for (int i = 0; i < checkCount * serverCount; i++) { Message msg; rc = sub.TryRecv(out msg, 1000); Assert.IsTrue(rc, "message id: " + i + ", sub id: " + subId); checkMessage(ref msg, checkData); Atomic.Inc(ref result); } }); } bool ret = Thread.Wait(() => result == clientCount * checkCount * serverCount, 10000); Assert.IsTrue(ret); threadPool.Dispose(); Assert.AreEqual(result, clientCount * checkCount * serverCount); for (int i = 0; i < subSet.Count; i++) { subSet[i].Close(); bool rc = subSet[i].WaitClose(1000); Assert.IsTrue(rc); } for (int i = 0; i < pubSet.Count; i++) { pubSet[i].Close(); bool rc = pubSet[i].WaitClose(1000); Assert.IsTrue(rc); } }
public void TestMethod_ReceiveWaiter() { string testName = "ReceiveWaiter"; Connection connection = new Connection(address); Session session = new Session(connection); ReceiverLink receiver = new ReceiverLink(session, "receiver-" + testName, "q1"); #if NETFX || NETFX_CORE Task t = Task.Run(() => { Message message = receiver.Receive(); Trace.WriteLine(TraceLevel.Verbose, "receive: {0}", message.Properties.MessageId); receiver.Accept(message); }); #else Thread t = new Thread(() => { Message message = receiver.Receive(); Trace.WriteLine(TraceLevel.Verbose, "receive: {0}", message.Properties.MessageId); receiver.Accept(message); }); t.Start(); #endif SenderLink sender = new SenderLink(session, "sender-" + testName, "q1"); Message msg = new Message() { Properties = new Properties() { MessageId = "123456" } }; sender.Send(msg, null, null); #if NETFX || NETFX_CORE t.Wait(10000); #else t.Join(10000); #endif sender.Close(); receiver.Close(); session.Close(); connection.Close(); }
public void TestSocketServerClientThread() { var server = SocketBase.Create <SocketServer>(); bool rc = server.Bind("127.0.0.1:" + port); Assert.IsTrue(rc); List <SocketBase> clientSet = new List <SocketBase>(); for (int i = 0; i < clientCount; i++) { var client = SocketBase.Create(SocketType.Client); rc = client.Connect("127.0.0.1:" + port); Assert.IsTrue(rc); clientSet.Add(client); } port++; var checkData = generateCheckData(); rc = Thread.Wait(() => server.ConnectionCount == clientCount, 1000); Assert.IsTrue(rc); string hello = "Hello"; var writer = new ByteBufferWriter(16); writer.WriteString(hello); var helloMessage = new Message(writer); for (int i = 0; i < clientCount; i++) { rc = clientSet[i].TrySend(ref helloMessage, 1000); Assert.IsTrue(rc); } List <uint> clientIdSet = new List <uint>(clientCount); for (int i = 0; i < clientCount; i++) { Message msg; rc = server.TryRecv(out msg, 1000); Assert.IsTrue(rc); Assert.Less(0, msg.RouteId); Assert.IsFalse(clientIdSet.Contains(msg.RouteId)); clientIdSet.Add(msg.RouteId); var reader = msg.GetBufferReader(); var value = reader.ReadString(); Assert.AreEqual(value, hello); } var threadPool = new ThreadPool(clientCount); threadPool.Send(() => { for (int c = 0; c < clientCount; c++) { for (int i = 0; i < checkCount; i++) { var msg = generateMessage(checkData); rc = server.Send(clientIdSet[c], ref msg); Assert.IsTrue(rc, "client id: " + clientIdSet[c] + ", message id: " + i); } } }); int result = 0; for (int c = 0; c < clientCount; c++) { var client = clientSet[c]; var clientId = clientIdSet[c]; threadPool.Post(() => { for (int i = 0; i < checkCount; i++) { Message msg; rc = client.Recv(out msg); Assert.IsTrue(rc, "client id: " + clientId + ", message id: " + i); checkMessage(ref msg, checkData); Atomic.Inc(ref result); } }); } rc = Thread.Wait(() => result == clientCount * checkCount, -1); Assert.IsTrue(rc); threadPool.Dispose(); Assert.AreEqual(result, clientCount * checkCount); for (int i = 0; i < clientSet.Count; i++) { clientSet[i].Close(); rc = clientSet[i].WaitClose(1000); Assert.IsTrue(rc); } server.Close(); rc = server.WaitClose(1000); Assert.IsTrue(rc); }
private void checkINodeAsyncApi <T>() where T : class, INodeAsync, IThreadObject { var childThread = Thread.CreateThread(); var parentThread = Thread.CreateThread(); var hook = new INodeHook(); var rc = Service <T> .RegisterHook(hook); Assert.IsTrue(rc); T child = Service <T> .New(); checkInitialize(child); child.Attach(childThread); T parent = Service <T> .New(); checkInitialize(parent); parent.Attach(parentThread); var task = child.SetParentAsync(parent); Assert.IsNotNull(task); rc = task.Wait(1000); Assert.IsTrue(rc); checkParent(child, parent); checkNodeInfo(child, hook, 1, 0, 0); Thread.Wait(() => parent.Status == NodeAsyncState.Idle, 1000); checkChild(parent, child); checkNodeInfo(parent, hook, 0, 1, 0); task = child.SetParentAsync(null); Assert.IsNotNull(task); rc = task.Wait(1000); Assert.IsTrue(rc); checkParent(child, null); checkInitialize(child); checkNodeInfo(child, hook, 2, 0, 0); Thread.Wait(() => parent.Status == NodeAsyncState.Idle, 1000); checkNotChild(parent, child); checkInitialize(parent); checkNodeInfo(parent, hook, 0, 1, 1); task = parent.AddChildAsync(child); Assert.IsNotNull(task); rc = task.Wait(1000); Assert.IsTrue(rc); checkChild(parent, child); checkNodeInfo(parent, hook, 0, 2, 1); Thread.Wait(() => child.Status == NodeAsyncState.Idle, 1000); checkParent(child, parent); checkNodeInfo(child, hook, 3, 0, 0); task = parent.RemoveChildAsync(child); Assert.IsNotNull(task); rc = task.Wait(1000); Assert.IsTrue(rc); checkNotChild(parent, child); checkInitialize(parent); checkNodeInfo(parent, hook, 0, 2, 2); Thread.Wait(() => child.Status == NodeAsyncState.Idle, 1000); checkParent(child, null); checkInitialize(child); checkNodeInfo(child, hook, 4, 0, 0); task = child.SetParentAsync(parent); Assert.IsNotNull(task); rc = task.Wait(1000); Assert.IsTrue(rc); checkParent(child, parent); checkNodeInfo(child, hook, 5, 0, 0); Thread.Wait(() => parent.Status == NodeAsyncState.Idle, 1000); checkChild(parent, child); checkNodeInfo(parent, hook, 0, 3, 2); task = child.ClearAsync(); Assert.IsNotNull(task); rc = task.Wait(1000); Assert.IsTrue(rc); checkParent(child, null); checkInitialize(child); checkNodeInfo(child, hook, 6, 0, 0); Thread.Wait(() => parent.Status == NodeAsyncState.Idle, 1000); checkNotChild(parent, child); checkInitialize(parent); checkNodeInfo(parent, hook, 0, 3, 3); task = parent.AddChildAsync(child); Assert.IsNotNull(task); rc = task.Wait(1000); Assert.IsTrue(rc); checkChild(parent, child); checkNodeInfo(parent, hook, 0, 4, 3); Thread.Wait(() => child.Status == NodeAsyncState.Idle, 1000); checkParent(child, parent); checkNodeInfo(child, hook, 7, 0, 0); T subChild = Service <T> .New(); checkInitialize(subChild); task = child.AddChildAsync(subChild); Assert.IsNotNull(task); rc = task.Wait(1000); Assert.IsTrue(rc); checkChild(child, subChild); checkNodeInfo(child, hook, 7, 1, 0); checkParent(subChild, child); checkNodeInfo(subChild, hook, 1, 0, 0); task = parent.ClearAsync(); Assert.IsNotNull(task); rc = task.Wait(1000); Assert.IsTrue(rc); checkNotChild(parent, child); checkInitialize(parent); checkNodeInfo(parent, hook, 0, 4, 4); Thread.Wait(() => child.Status == NodeAsyncState.Idle, 1000); checkParent(child, null); checkNotChild(child, subChild); checkInitialize(child); checkNodeInfo(child, hook, 8, 1, 1); checkParent(subChild, null); checkInitialize(subChild); checkNodeInfo(subChild, hook, 2, 0, 0); childThread.Stop(); parentThread.Stop(); }
//------------------------------------------------------------------------------------------------------------------------ public void Stop(bool CloseAllChannels = false) { try { lock (this) { //close all channels if (CloseAllChannels) { var channelsToClose = _Channels.ToArray(); TaskEx.RunSafe(() => { var po = new ParallelOptions() { MaxDegreeOfParallelism = 8 }; Parallel.ForEach(channelsToClose, po, c => { { try { c.Close("Server stopped"); } catch (Exception ex) { DebugEx.TraceErrorException(ex, "Error while closing channel"); } }; }); }); } //update flag if (!_IsRunning) { return; } else { _IsRunning = false; } //close my socket try { if (sock != null) { #if NETFX try { sock.Close(); } catch { } #endif try { sock.Dispose(); } catch { } } } catch (Exception ex) { DebugEx.TraceErrorException(ex); } sock = null; //wait for task finish #if NETFX PortListener?.Join(1000); #elif UNIVERSAL PortListener?.Wait(1000); #endif PortListener = null; } } catch (Exception ex) { DebugEx.Assert(ex, "YPChannel Server Stop() failed"); } }
public void TestSocketPubSubThread() { var pub = SocketBase.Create(SocketType.Pub); bool rc = pub.Bind("127.0.0.1:" + port); Assert.IsTrue(rc); List <SocketBase> subSet = new List <SocketBase>(); for (int i = 0; i < clientCount; i++) { var sub = SocketBase.Create(SocketType.Sub); rc = sub.Connect("127.0.0.1:" + port); Assert.IsTrue(rc); subSet.Add(sub); } port++; var checkData = generateCheckData(); var threadPool = new ThreadPool(clientCount); threadPool.Post(() => { rc = Thread.Wait(() => pub.ConnectionCount == clientCount, 1000); Assert.IsTrue(rc); for (int i = 0; i < checkCount; i++) { var msg = generateMessage(checkData); rc = pub.TrySend(ref msg, 1000); Assert.IsTrue(rc); } }); int result = 0; for (int c = 0; c < clientCount; c++) { var sub = subSet[c]; threadPool.Post(() => { rc = Thread.Wait(() => sub.ConnectionCount == 1, 1000); Assert.IsTrue(rc); for (int i = 0; i < checkCount; i++) { Message msg; rc = sub.TryRecv(out msg, 1000); Assert.IsTrue(rc); checkMessage(ref msg, checkData); Atomic.Inc(ref result); } }); } var ret = Thread.Wait(() => result == clientCount * checkCount, 10000); Assert.IsTrue(ret); threadPool.Dispose(); Assert.AreEqual(result, clientCount * checkCount); for (int i = 0; i < subSet.Count; i++) { subSet[i].Close(); rc = subSet[i].WaitClose(1000); Assert.IsTrue(rc); } pub.Close(); rc = pub.WaitClose(1000); Assert.IsTrue(rc); }