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