public void Run_AsyncBarrier()
{
var asyncBarrier = new AsyncBarrier(InitialParticipantCount);
Assert.AreEqual(InitialParticipantCount, asyncBarrier.ParticipantCount);
var task = asyncBarrier.SignalAndWait();
while (task.IsCompleted == false)
{
if (IsDebugEnabled)
{
log.Debug("AsyncBarrier# RemainingCount={0}, ParticipantCount={1}, IsCompleted={2}",
asyncBarrier.RemainingCount, asyncBarrier.ParticipantCount, task.IsCompleted);
}
Assert.IsFalse(task.IsCanceled);
Assert.IsFalse(task.IsFaulted);
task = asyncBarrier.SignalAndWait();
}
// Participant가 모두 없어졌으면 Task는 완료되었다고 본다.
//
Assert.IsTrue(task.IsCompleted);
if (IsDebugEnabled)
{
log.Debug("AsyncBarrier# RemainingCount={0}, ParticipantCount={1}, IsCompleted={2}",
asyncBarrier.RemainingCount, asyncBarrier.ParticipantCount, task.IsCompleted);
}
}
Task DoReqRep(string url)
{
var barrier = new AsyncBarrier(2);
var dialUrl = string.Empty;
var rep = Task.Run(async() =>
{
using (var socket = Factory.ReplierOpen().ThenListenAs(out var listener, url).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await barrier.SignalAndWait();
var msg = await ctx.Receive();
(await ctx.Reply(Factory.CreateMessage())).Unwrap();
await WaitShort();
}
});
var req = Task.Run(async() =>
{
await barrier.SignalAndWait();
using (var socket = Factory.RequesterOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
var _response = await ctx.Send(Factory.CreateMessage());
}
});
return(Util.AssertWait(req, rep));
}
Task DoReqRep(string url)
{
var barrier = new AsyncBarrier(2);
var rep = Task.Run(async() =>
{
using (var repAioCtx = Factory.ReplierCreate(url).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await barrier.SignalAndWait();
var msg = await repAioCtx.Receive();
(await repAioCtx.Reply(Factory.CreateMessage())).Unwrap();
await WaitShort();
}
});
var req = Task.Run(async() =>
{
await barrier.SignalAndWait();
using (var reqAioCtx = Factory.RequesterCreate(url).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
var _response = await reqAioCtx.Send(Factory.CreateMessage());
}
});
return(Util.AssertWait(req, rep));
}
Task DoPubSub(string url)
{
var topic = TopicRandom();
var serverReady = new AsyncBarrier(2);
var clientReady = new AsyncBarrier(2);
var cts = new CancellationTokenSource();
var dialUrl = string.Empty;
var pubTask = Task.Run(async() =>
{
using (var socket = Factory.PublisherOpen().ThenListenAs(out var listener, url).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await serverReady.SignalAndWait();
await clientReady.SignalAndWait();
// Give receivers a chance to actually start receiving
await WaitShort();
(await ctx.Send(Factory.CreateTopicMessage(topic))).Unwrap();
}
});
var subTask = Task.Run(async() =>
{
await serverReady.SignalAndWait();
using (var socket = Factory.SubscriberOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
ctx.Subscribe(topic);
await clientReady.SignalAndWait();
await ctx.Receive(cts.Token);
}
});
return(CancelAfterAssertwait(cts, pubTask, subTask));
}
public void Run_AsyncBarrier() {
var asyncBarrier = new AsyncBarrier(InitialParticipantCount);
Assert.AreEqual(InitialParticipantCount, asyncBarrier.ParticipantCount);
var task = asyncBarrier.SignalAndWait();
while(task.IsCompleted == false) {
if(IsDebugEnabled)
log.Debug("AsyncBarrier# RemainingCount={0}, ParticipantCount={1}, IsCompleted={2}",
asyncBarrier.RemainingCount, asyncBarrier.ParticipantCount, task.IsCompleted);
Assert.IsFalse(task.IsCanceled);
Assert.IsFalse(task.IsFaulted);
task = asyncBarrier.SignalAndWait();
}
// Participant가 모두 없어졌으면 Task는 완료되었다고 본다.
//
Assert.IsTrue(task.IsCompleted);
if(IsDebugEnabled)
log.Debug("AsyncBarrier# RemainingCount={0}, ParticipantCount={1}, IsCompleted={2}",
asyncBarrier.RemainingCount, asyncBarrier.ParticipantCount, task.IsCompleted);
}
async Task DoSendRecvNonBlockTasks(string url)
{
var dialUrl = String.Empty;
var barrier = new AsyncBarrier(2);
var cts = new CancellationTokenSource();
var flags = Defines.NngFlag.NNG_FLAG_NONBLOCK;
var rep = Task.Run(async() => {
using (var rep = Factory.ReplierOpen().ThenListenAs(out var listener, url).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await barrier.SignalAndWait();
var msg = Factory.CreateMessage();
var request = (await RetryAgain(cts, () => rep.RecvMsg(flags))).Unwrap();
var res = await RetryAgain(cts, () => rep.SendMsg(request, flags));
res.Unwrap();
}
});
var req = Task.Run(async() => {
await barrier.SignalAndWait();
using (var req = Factory.RequesterOpen().ThenDial(dialUrl).Unwrap())
{
var msg = Factory.CreateMessage();
var res = await RetryAgain(cts, () => req.SendMsg(msg, flags));
res.Unwrap();
var reply = await RetryAgain(cts, () => req.RecvMsg(flags));
var _ = reply.Unwrap();
}
});
await Util.CancelAfterAssertwait(cts, req, rep);
}
Task DoPubSub(string url)
{
var topic = TopicRandom();
var serverReady = new AsyncBarrier(2);
var clientReady = new AsyncBarrier(2);
var cts = new CancellationTokenSource();
var pubTask = Task.Run(async() =>
{
using (var pubSocket = Factory.PublisherCreate(url).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await serverReady.SignalAndWait();
await clientReady.SignalAndWait();
await WaitReady();
Assert.True(await pubSocket.Send(Factory.CreateTopicMessage(topic)));
await WaitShort();
}
});
var subTask = Task.Run(async() =>
{
await serverReady.SignalAndWait();
using (var sub = Factory.SubscriberCreate(url).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
sub.Subscribe(topic);
await clientReady.SignalAndWait();
await sub.Receive(cts.Token);
}
});
cts.CancelAfter(DefaultTimeoutMs);
return(Task.WhenAll(pubTask, subTask));
}
Task DoPushPull(string url)
{
var serverReady = new AsyncBarrier(2);
var clientReady = new AsyncBarrier(2);
var cts = new CancellationTokenSource();
var dialUrl = string.Empty;
var push = Task.Run(async() =>
{
using (var socket = Factory.PusherOpen().ThenListenAs(out var listener, url).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await serverReady.SignalAndWait();
await clientReady.SignalAndWait();
(await ctx.Send(Factory.CreateMessage())).Unwrap();
}
});
var pull = Task.Run(async() =>
{
await serverReady.SignalAndWait();
using (var socket = Factory.PullerOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
var task = ctx.Receive(cts.Token);
await WaitShort();
await clientReady.SignalAndWait();
var _ = await task;
}
});
return(CancelAfterAssertwait(cts, pull, push));
}
static void TryAsyncBarrier()
{
const int participantCount = 5;
var asyncBarrier = new AsyncBarrier(participantCount, () => Console.WriteLine("AsyncBarrier is being reset!"));
for (int i = 0; i < participantCount + 1; i++)
{
var temp = i + 1;
Task.Factory.StartNew(async() =>
{
try
{
//await Task.Delay(temp * 1000);
Console.WriteLine($"Participant {temp} signalling and waiting!");
await asyncBarrier.SignalAndWait();
Console.WriteLine($"Participant {temp} is now awake!");
await Task.Delay(1000);
Console.WriteLine($"Participant {temp} signalling and waiting for the second time!");
await asyncBarrier.SignalAndWait();
Console.WriteLine($"Participant {temp} has awoken yet again!");
}
catch (Exception e)
{
Console.WriteLine($"Participant {temp} has encountered the following exception: {e.Message}");
}
});
}
}
async Task DoAdvanced(string url)
{
const int NumSurveyors = 1;
const int NumResponders = 2;
var readyToDial = new AsyncBarrier(NumSurveyors + NumResponders);
var readyToSend = new AsyncBarrier(NumSurveyors + NumResponders);
var numSurveyorReceive = new AsyncCountdownEvent(NumResponders);
var numResponderReceive = new AsyncCountdownEvent(NumResponders);
var cts = new CancellationTokenSource();
var tasks = new List <Task>();
var dialUrl = string.Empty;
var task = Task.Run(async() =>
{
using (var socket = Factory.SurveyorOpen().ThenListenAs(out var listener, url).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await readyToDial.SignalAndWait();
await readyToSend.SignalAndWait();
// Send survey and receive response
await WaitShort();
await ctx.Send(Factory.CreateMessage());
await WaitShort();
while (!cts.IsCancellationRequested)
{
var response = await ctx.Receive(cts.Token);
if (numSurveyorReceive.Signal() == 0)
{
break;
}
}
}
});
tasks.Add(task);
for (int i = 0; i < NumResponders; ++i)
{
task = Task.Run(async() =>
{
await readyToDial.SignalAndWait();
using (var socket = Factory.RespondentOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
await readyToSend.SignalAndWait();
// Receive survey and send response
var survey = await ctx.Receive(cts.Token);
numResponderReceive.Signal();
(await ctx.Send(survey.Unwrap())).Unwrap();
await numSurveyorReceive.WaitAsync();
}
});
tasks.Add(task);
}
await Util.AssertWait(tasks);
Assert.Equal(0, numSurveyorReceive.Count);
Assert.Equal(0, numResponderReceive.Count);
}
async Task DoAdvanced(string url)
{
var readyToDial = new AsyncBarrier(3);
var readyToSend = new AsyncBarrier(3);
var messageReceipt = new AsyncCountdownEvent(2);
var cts = new CancellationTokenSource();
var dialUrl = string.Empty;
var bus0Task = Task.Run(async() =>
{
using (var socket = Factory.BusOpen().ThenListenAs(out var listener, url).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await readyToDial.SignalAndWait();
await readyToSend.SignalAndWait();
await ctx.Send(Factory.CreateMessage());
// Give it a chance to actually send
await WaitReady();
}
});
var bus1Task = Task.Run(async() =>
{
await readyToDial.SignalAndWait();
using (var socket = Factory.BusOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
// Make sure receive has started before signalling ready
var recvFuture = ctx.Receive(cts.Token);
await WaitShort();
await readyToSend.SignalAndWait();
var _ = await recvFuture;
messageReceipt.Signal();
}
});
var bus2Task = Task.Run(async() =>
{
await readyToDial.SignalAndWait();
using (var socket = Factory.BusOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
// Make sure receive has started before signalling ready
var recvFuture = ctx.Receive(cts.Token);
await WaitShort();
await readyToSend.SignalAndWait();
var _ = await recvFuture;
messageReceipt.Signal();
}
});
await CancelAfterWait(cts, bus0Task, bus1Task, bus2Task);
Assert.Equal(0, messageReceipt.Count);
}
private async Task MultipleParticipantsHelperAsync(int participants, int steps)
{
Requires.Range(participants > 0, "participants");
Requires.Range(steps > 0, "steps");
var barrier = new AsyncBarrier(1 + participants); // 1 for test coordinator
int[] currentStepForActors = new int[participants];
Task[] actorsFinishedTasks = new Task[participants];
var actorReady = new AsyncAutoResetEvent();
for (int i = 0; i < participants; i++)
{
int participantIndex = i;
var progress = new Progress <int>(step =>
{
currentStepForActors[participantIndex] = step;
actorReady.Set();
});
actorsFinishedTasks[i] = this.ActorAsync(barrier, steps, progress);
}
for (int i = 1; i <= steps; i++)
{
// Wait until all actors report having completed this step.
while (!currentStepForActors.All(step => step == i))
{
// Wait for someone to signal a change has been made to the array.
await actorReady.WaitAsync();
}
// Give the last signal to proceed to the next step.
await barrier.SignalAndWait();
}
}
public async Task StressMultipleGroups(int players, int groupSize)
{
var barrier = new AsyncBarrier(groupSize);
var playerTasks = new Task[players];
int signalsCount = 0;
using (var cts = new CancellationTokenSource(300))
{
for (int i = 0; i < playerTasks.Length; i++)
{
playerTasks[i] = Task.Run(async delegate
{
while (!cts.Token.IsCancellationRequested)
{
Interlocked.Increment(ref signalsCount);
await barrier.SignalAndWait().WithCancellation(cts.Token).NoThrowAwaitable();
}
});
}
await Task.WhenAll(playerTasks).WithTimeout(UnexpectedTimeout);
}
this.Logger.WriteLine("Test reached {0} signals.", signalsCount);
}
async Task DoPubSubCtx(string url)
{
var topic = TopicRandom();
const int NUM_PUB = 1;
const int NUM_SUB = 2;
var serverReady = new AsyncBarrier(NUM_PUB + 1); // Shared by all subscribers
var clientReady = new AsyncBarrier(NUM_PUB + NUM_SUB);
var cts = new CancellationTokenSource();
var dialUrl = string.Empty;
var tasks = new List <Task>();
int numReceived = 0;
var task = Task.Run(async() =>
{
using (var socket = Factory.PublisherOpen().ThenListenAs(out var listener, url).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await serverReady.SignalAndWait();
await clientReady.SignalAndWait();
// Give receivers a chance to start receiving
await WaitShort();
(await ctx.Send(Factory.CreateTopicMessage(topic))).Unwrap();
}
});
tasks.Add(task);
await serverReady.SignalAndWait();
using (var socket = Factory.SubscriberOpen().ThenDial(dialUrl).Unwrap())
{
foreach (var _ in Enumerable.Range(0, NUM_SUB))
{
var subTask = Task.Run(async() =>
{
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
ctx.Subscribe(topic);
await clientReady.SignalAndWait();
await ctx.Receive(cts.Token);
Interlocked.Increment(ref numReceived);
}
});
}
await CancelAfterAssertwait(tasks, cts);
}
Assert.Equal(NUM_SUB, numReceived);
}
async Task DoAdvanced(string url)
{
var readyToDial = new AsyncBarrier(3);
var readyToSend = new AsyncBarrier(3);
var messageReceipt = new AsyncCountdownEvent(2);
var cts = new CancellationTokenSource();
var bus0Task = Task.Run(async() =>
{
using (var ctx = Factory.BusCreate(url, true).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await readyToDial.SignalAndWait();
await readyToSend.SignalAndWait();
await WaitShort();
await ctx.Send(Factory.CreateMessage());
await WaitShort();
}
});
var bus1Task = Task.Run(async() =>
{
await readyToDial.SignalAndWait();
using (var ctx = Factory.BusCreate(url, false).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await readyToSend.SignalAndWait();
var _ = await ctx.Receive(cts.Token);
messageReceipt.Signal();
}
});
var bus2Task = Task.Run(async() =>
{
await readyToDial.SignalAndWait();
using (var ctx = Factory.BusCreate(url, false).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await readyToSend.SignalAndWait();
var _ = await ctx.Receive(cts.Token);
messageReceipt.Signal();
}
});
await CancelAfterAssertwait(cts, bus0Task, bus1Task, bus2Task);
Assert.Equal(0, messageReceipt.Count);
}
public void ItCompletesTheTaskWhenSignalAnsWaitIsCalledSampleTimes()
{
var asyncBarrier = new AsyncBarrier(SampleTimes);
var tasks = new Task[SampleTimes];
for (int i = 0; i < SampleTimes; i++)
{
tasks[i] = asyncBarrier.SignalAndWait();
}
var task = Task.WhenAll(tasks);
task.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(task.IsCompleted);
}
private async Task ActorAsync(AsyncBarrier barrier, int steps, IProgress <int> progress)
{
Requires.NotNull(barrier, nameof(barrier));
Requires.Range(steps >= 0, "steps");
Requires.NotNull(progress, nameof(progress));
for (int i = 1; i <= steps; i++)
{
await Task.Yield();
progress.Report(i);
await barrier.SignalAndWait();
}
}
public void ItCompletesTheTaskWhenSignalAnsWaitIsCalledSampleTimes()
{
var asyncBarrier = new AsyncBarrier(SampleTimes);
var tasks = new Task[SampleTimes];
for (int i = 0; i < SampleTimes; i++)
{
tasks[i] = asyncBarrier.SignalAndWait();
}
var task = Task.WhenAll(tasks);
task.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(task.IsCompleted);
}
Task DoPushPull(string url)
{
var barrier = new AsyncBarrier(2);
var cts = new CancellationTokenSource();
var push = Task.Run(async() => {
using (var pushSocket = Factory.PusherCreate(url, true).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await barrier.SignalAndWait();
Assert.True(await pushSocket.Send(Factory.CreateMessage()));
await WaitShort();
}
});
var pull = Task.Run(async() => {
await barrier.SignalAndWait();
using (var pullSocket = Factory.PullerCreate(url, false).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await pullSocket.Receive(cts.Token);
}
});
cts.CancelAfter(DefaultTimeoutMs);
return(Task.WhenAll(pull, push));
}
async Task DoAdvanced(string url)
{
var readyToDial = new AsyncBarrier(2);
var readyToSend = new AsyncBarrier(2);
var messageReceipt = new AsyncCountdownEvent(2);
var cts = new CancellationTokenSource();
var surveyorTask = Task.Run(async() =>
{
using (var ctx = Factory.SurveyorCreate(url, true).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await readyToDial.SignalAndWait();
await readyToSend.SignalAndWait();
// Send survey and receive response
await WaitShort();
await ctx.Send(Factory.CreateMessage());
await WaitShort();
var response = await ctx.Receive(cts.Token);
messageReceipt.Signal();
}
});
var respondentTask = Task.Run(async() =>
{
await readyToDial.SignalAndWait();
using (var ctx = Factory.RespondentCreate(url, false).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await readyToSend.SignalAndWait();
// Receive survey and send response
var survey = await ctx.Receive(cts.Token);
messageReceipt.Signal();
await ctx.Send(survey.Unwrap());
}
});
await CancelAfterAssertwait(cts, surveyorTask, respondentTask);
Assert.Equal(0, messageReceipt.Count);
}
Task DoPair(string url)
{
var barrier = new AsyncBarrier(2);
var cts = new CancellationTokenSource();
var push = Task.Run(async() =>
{
using (var socket = Factory.PairCreate(url, true).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await barrier.SignalAndWait();
(await socket.Send(Factory.CreateMessage())).Unwrap();
await WaitShort();
}
});
var pull = Task.Run(async() =>
{
await barrier.SignalAndWait();
using (var socket = Factory.PairCreate(url, false).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await socket.Receive(cts.Token);
}
});
return(CancelAfterAssertwait(cts, pull, push));
}
public async Task <List <Task> > RunAsync(int numPushers, int numPullers, int numMessagesPerPusher, AsyncCountdownEvent counter, CancellationToken token)
{
var inUrl = UrlIpc();
var outUrl = UrlIpc();
const int numBrokers = 1;
var brokersReady = new AsyncBarrier(numBrokers + 1);
var clientsReady = new AsyncBarrier(numPushers + numPullers + numBrokers);
var numForwarded = 0;
var tasks = new List <Task>();
for (var i = 0; i < numBrokers; ++i)
{
var task = Task.Run(async() =>
{
var pullSocket = implementation.CreateInSocket(inUrl);
var pushSocket = implementation.CreateOutSocket(outUrl);
await brokersReady.SignalAndWait(); // Broker is ready
await clientsReady.SignalAndWait(); // Wait for clients
while (!token.IsCancellationRequested)
{
var msg = await pullSocket.Receive(token);
await pushSocket.Send(msg.Unwrap());
++numForwarded;
}
});
tasks.Add(task);
}
await brokersReady.SignalAndWait();
for (var i = 0; i < numPushers; ++i)
{
var task = Task.Run(async() =>
{
using (var socket = implementation.Factory.PusherOpen().ThenDial(inUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(implementation.Factory).Unwrap())
{
await clientsReady.SignalAndWait(); // This client ready, wait for rest
// Give all receivers a chance to actually start receiving
await WaitShort();
for (var m = 0; m < numMessagesPerPusher; ++m)
{
await ctx.Send(implementation.CreateMessage());
await WaitShort();
}
}
});
tasks.Add(task);
}
for (var i = 0; i < numPullers; ++i)
{
var task = Task.Run(async() =>
{
var pullSocket = implementation.CreateClient(outUrl);
await clientsReady.SignalAndWait(); // This client ready, wait for rest
while (!token.IsCancellationRequested)
{
var _ = await pullSocket.Receive(token);
counter.Signal();
}
});
tasks.Add(task);
}
return(tasks);
}
public void ItReturnsTaskWhenSignalAndWaitIsCalled()
{
var asyncBarrier = new AsyncBarrier(SampleTimes);
Assert.IsInstanceOfType(asyncBarrier.SignalAndWait(), typeof(Task));
}
async Task DoPairShared(string url)
{
int numListeners = 2;
int numDialers = 2;
var listenerReady = new AsyncBarrier(numListeners + 1);
var dialerReady = new AsyncBarrier(numListeners + numDialers);
var cts = new CancellationTokenSource();
using (var listenSocket = Factory.PairCreate(url, true).Unwrap())
using (var dialerSocket = Factory.PairCreate(url, false).Unwrap())
{
var tasks = new List <Task>();
// On listening socket create send/receive AIO
{
var task = Task.Run(async() =>
{
var ctx = listenSocket.CreateAsyncContext(Factory).Unwrap();
await listenerReady.SignalAndWait();
await dialerReady.SignalAndWait();
while (!cts.IsCancellationRequested)
{
var msg = await ctx.Receive(cts.Token);
}
});
tasks.Add(task);
task = Task.Run(async() =>
{
var ctx = listenSocket.CreateAsyncContext(Factory).Unwrap();
await listenerReady.SignalAndWait();
await dialerReady.SignalAndWait();
while (!cts.IsCancellationRequested)
{
var _ = await ctx.Send(Factory.CreateMessage());
}
});
tasks.Add(task);
}
await listenerReady.SignalAndWait();
// On dialing socket create send/receive AIO
{
var task = Task.Run(async() =>
{
var ctx = dialerSocket.CreateAsyncContext(Factory).Unwrap();
await dialerReady.SignalAndWait();
while (!cts.IsCancellationRequested)
{
var msg = await ctx.Receive(cts.Token);
}
});
tasks.Add(task);
task = Task.Run(async() =>
{
var ctx = dialerSocket.CreateAsyncContext(Factory).Unwrap();
await dialerReady.SignalAndWait();
while (!cts.IsCancellationRequested)
{
var _ = await ctx.Send(Factory.CreateMessage());
}
});
tasks.Add(task);
}
await Util.CancelAfterAndWait(tasks, cts, ShortTestMs);
}
}
public async Task OneParticipant()
{
var barrier = new AsyncBarrier(1);
await barrier.SignalAndWait();
}
async Task DoContexts(string url)
{
const int NumSurveyors = 1;
const int NumResponders = 3;
var readyToDial = new AsyncBarrier(NumSurveyors + NumResponders);
var readyToSend = new AsyncBarrier(NumSurveyors + NumResponders);
var numSurveyorReceive = new AsyncCountdownEvent(NumSurveyors);
var numResponderReceive = new AsyncCountdownEvent(NumSurveyors);
using (var surveySocket = Factory.SurveyorCreate(url, true).Unwrap())
using (var respondSocket = Factory.RespondentCreate(url, false).Unwrap())
{
var cts = new CancellationTokenSource();
var tasks = new List <Task>();
for (var i = 0; i < NumSurveyors; ++i)
{
var task = Task.Run(async() =>
{
using (var ctx = surveySocket.CreateAsyncContext(Factory).Unwrap())
{
(ctx as ICtx).Ctx.SetOpt(Native.Defines.NNG_OPT_SURVEYOR_SURVEYTIME, new nng_duration {
TimeMs = DefaultTimeoutMs
});
await readyToDial.SignalAndWait();
await readyToSend.SignalAndWait();
// Send survey and receive responses
var survey = Factory.CreateMessage();
//Assert.Equal(0, survey.Header.Append((uint)(0x8000000 | i))); // Protocol header contains "survey ID"
await ctx.Send(survey);
while (!cts.IsCancellationRequested)
{
try
{
var response = await ctx.Receive(cts.Token);
if (numSurveyorReceive.Signal() == 0)
{
break;
}
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.ToString());
throw ex;
}
}
}
});
tasks.Add(task);
}
for (var i = 0; i < NumResponders; ++i)
{
var task = Task.Run(async() =>
{
await readyToDial.SignalAndWait();
using (var ctx = respondSocket.CreateAsyncContext(Factory).Unwrap())
{
await readyToSend.SignalAndWait();
try
{
// Receive survey and send response
var survey = await ctx.Receive(cts.Token);
(await ctx.Send(survey.Unwrap())).Unwrap();
numResponderReceive.Signal();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
throw ex;
}
}
});
tasks.Add(task);
}
await Util.CancelAfterAssertwait(tasks, cts);
Assert.Equal(0, numSurveyorReceive.Count);
Assert.Equal(0, numResponderReceive.Count);
}
}
async Task DoPairShared(string url)
{
int numListeners = 2;
int numDialers = 2;
var listenerReady = new AsyncBarrier(numListeners + 1);
var dialerReady = new AsyncBarrier(numListeners + numDialers);
var cts = new CancellationTokenSource();
using (var listenSocket = Factory.Pair1Open().ThenListenAs(out var listener, url).Unwrap())
using (var dialerSocket = Factory.Pair1Open().ThenDial(GetDialUrl(listener, url)).Unwrap())
{
// Make sure sends can timeout since they aren't canceleable
listenSocket.SetOpt(nng.Native.Defines.NNG_OPT_SENDTIMEO, new nng_duration {
TimeMs = 50
});
dialerSocket.SetOpt(nng.Native.Defines.NNG_OPT_SENDTIMEO, new nng_duration {
TimeMs = 50
});
var tasks = new List <Task>();
// On listening socket create send/receive AIO
{
var task = Task.Run(async() =>
{
using (var ctx = listenSocket.CreateAsyncContext(Factory).Unwrap())
{
await listenerReady.SignalAndWait();
await dialerReady.SignalAndWait();
while (!cts.IsCancellationRequested)
{
var msg = await ctx.Receive(cts.Token);
}
}
});
tasks.Add(task);
task = Task.Run(async() =>
{
using (var ctx = listenSocket.CreateAsyncContext(Factory).Unwrap())
{
await listenerReady.SignalAndWait();
await dialerReady.SignalAndWait();
await WaitShort(); // Give receiver a chance to start receiving
while (!cts.IsCancellationRequested)
{
var _ = await ctx.Send(Factory.CreateMessage());
await WaitShort();
}
}
});
tasks.Add(task);
}
await listenerReady.SignalAndWait();
// On dialing socket create send/receive AIO
{
var task = Task.Run(async() =>
{
using (var ctx = dialerSocket.CreateAsyncContext(Factory).Unwrap())
{
await dialerReady.SignalAndWait();
while (!cts.IsCancellationRequested)
{
var msg = await ctx.Receive(cts.Token);
}
}
});
tasks.Add(task);
task = Task.Run(async() =>
{
using (var ctx = dialerSocket.CreateAsyncContext(Factory).Unwrap())
{
await dialerReady.SignalAndWait();
await WaitShort(); // Give receiver a chance to start receiving
while (!cts.IsCancellationRequested)
{
var _ = await ctx.Send(Factory.CreateMessage());
await WaitShort();
}
}
});
tasks.Add(task);
}
await Util.CancelAfterAssertwait(tasks, cts);
}
}
async Task DoContexts(string url)
{
const int NumSurveyors = 1;
const int NumResponders = 2;
var readyToDial = new AsyncBarrier(NumSurveyors + NumResponders);
var readyToSend = new AsyncBarrier(NumSurveyors + NumResponders);
var ready = readyToSend.WaitAsync();
var numSurveyorReceive = new AsyncCountdownEvent(NumSurveyors);
var numResponderReceive = new AsyncCountdownEvent(NumSurveyors);
using (var surveySocket = Factory.SurveyorOpen().ThenListen(url).Unwrap())
using (var respondSocket = Factory.RespondentOpen().ThenDial(url).Unwrap())
{
var duration = new nng_duration {
TimeMs = DefaultTimeoutMs
};
// Send() is not cancelable so need it to timeout
surveySocket.SetOpt(nng.Native.Defines.NNG_OPT_SENDTIMEO, new nng_duration {
TimeMs = 50
});
surveySocket.SetOpt(nng.Native.Defines.NNG_OPT_RECVTIMEO, nng_duration.Infinite);
surveySocket.SetOpt(Native.Defines.NNG_OPT_SURVEYOR_SURVEYTIME, nng_duration.Infinite);
respondSocket.SetOpt(nng.Native.Defines.NNG_OPT_SENDTIMEO, new nng_duration {
TimeMs = 50
});
var cts = new CancellationTokenSource();
var tasks = new List <Task>();
for (var i = 0; i < NumSurveyors; ++i)
{
var id = i;
var task = Task.Run(async() =>
{
using (var ctx = surveySocket.CreateAsyncContext(Factory).Unwrap())
{
ctx.Ctx.SetOpt(Native.Defines.NNG_OPT_RECVTIMEO, nng_duration.Infinite);
ctx.Ctx.SetOpt(Native.Defines.NNG_OPT_SURVEYOR_SURVEYTIME, nng_duration.Infinite);
await readyToDial.SignalAndWait();
await readyToSend.SignalAndWait();
// Send survey and receive responses
var survey = Factory.CreateMessage();
var val = (uint)rng.Next();
survey.Append(val);
//Assert.Equal(0, survey.Header.Append((uint)(0x8000000 | i))); // Protocol header contains "survey ID"
(await ctx.Send(survey)).Unwrap();
while (!cts.IsCancellationRequested)
{
try
{
var response = (await ctx.Receive(cts.Token)).Unwrap();
response.Trim(out uint respVal);
Assert.Equal(val, respVal);
if (numSurveyorReceive.Signal() == 0)
{
break;
}
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.ToString());
throw ex;
}
}
}
});
tasks.Add(task);
}
for (var i = 0; i < NumResponders; ++i)
{
var id = i;
var task = Task.Run(async() =>
{
await readyToDial.SignalAndWait();
using (var ctx = respondSocket.CreateAsyncContext(Factory).Unwrap())
{
// Receive survey and send response
try
{
// Receive is async, give it a chance to start before signaling we are ready.
// This to avoid race where surveyor sends before it actually starts receiving
var recvFuture = ctx.Receive(cts.Token);
await WaitShort();
await readyToSend.SignalAndWait();
var survey = (await recvFuture).Unwrap();
await Task.Delay(10); // Make sure surveyor has a chance to start receiving
(await ctx.Send(survey)).Unwrap();
numResponderReceive.Signal();
await numSurveyorReceive.WaitAsync();
cts.Cancel(); // Cancel any responders still receiving
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
throw ex;
}
}
});
tasks.Add(task);
}
await Task.WhenAny(ready, Task.WhenAll(tasks));
await Util.CancelAfterAssertwait(tasks, cts);
Assert.Equal(0, numSurveyorReceive.Count);
Assert.Equal(0, numResponderReceive.Count);
}
}
public void ItReturnsTaskWhenSignalAndWaitIsCalled()
{
var asyncBarrier = new AsyncBarrier(SampleTimes);
Assert.IsInstanceOfType(asyncBarrier.SignalAndWait(), typeof(Task));
}
