protected override void AioCallback(IntPtr argument)
{
var res = Unit.Ok;
switch (State)
{
case AsyncState.Recv:
res = Aio.GetResult();
if (res.IsErr())
{
State = AsyncState.Init;
tcs.TrySetNngError(res.Err());
return;
}
State = AsyncState.Init;
var msg = Aio.GetMsg();
var message = Factory.CreateMessage(msg);
State = AsyncState.Init;
tcs.TrySetNngResult(message);
break;
case AsyncState.Init:
default:
tcs.TrySetException(new Exception(State.ToString()));
break;
}
}
public void DijkstraBus()
{
sockets = new Socket[n];
potentials = new int[n];
dialers = new Dialer[n, 2];
receivers = new Aio[n];
senders = new Aio[n];
listeners = new Listener[n];
random = new Random(1);
for (int i = 0; i < n; i++)
{
Protocols.Bus0(out sockets[i]);
listeners[i] = new Listener(sockets[i], "ipc:///Dijkstra" + i.ToString());
potentials[i] = int.MaxValue;
}
// every node connects to two other random nodes
for (int i = 0; i < n; i++)
{
int target = random.Next(n);
dialers[i, 0] = new Dialer(sockets[i], "ipc:///Dijkstra" + target.ToString());
target = random.Next(n);
dialers[i, 1] = new Dialer(sockets[i], "ipc:///Dijkstra" + target.ToString());
}
// arm the aios
for (int i = 0; i < n; i++)
{
senders[i] = new Aio(Whatever, i);
receivers[i] = new Aio(Received, i);
sockets[i].Receive(receivers[i]);
}
Msg msg = new Msg(0);
msg.AppendU32(0);
potentials[0] = 0;
sockets[0].Send(msg);
//msg.Dispose();
int oldCount = 0;
for (;;)
{
System.Threading.Thread.Sleep(100);
if (countReceived > oldCount)
{
oldCount = countReceived;
}
else
{
break;
}
}
for (int i = 0; i < n; i++)
{
sockets[i].Close();
}
return;
}
protected override void AioCallback(IntPtr argument)
{
var res = Unit.Ok;
switch (State)
{
case AsyncState.Send:
res = Aio.GetResult();
if (res.IsErr())
{
HandleFailedSend();
State = AsyncState.Init;
tcs.TrySetNngError(res.Err());
return;
}
State = AsyncState.Init;
tcs.SetNngResult();
break;
case AsyncState.Init:
default:
tcs.SetException(new Exception(State.ToString()));
break;
}
}
void Received(object o)
{
System.Threading.Interlocked.Increment(ref countReceived);
int j = (int)o;
Aio aio = receivers[j];
Errno errno = aio.Result();
if (errno != 0)
{
return;
}
Msg msg = aio.GetMsg();
sockets[j].Receive(receivers[j]);
uint receivedValue2;
msg.ChopU32(out receivedValue2);
int receivedValue = (int)receivedValue2;
bool valueHasChanged = false;
for (;;)
{
int oldValue = potentials[j];
if (receivedValue + 1 < oldValue)
{
int beforeExchange = System.Threading.Interlocked.CompareExchange(ref potentials[j], receivedValue + 1, oldValue);
if (beforeExchange == oldValue)
{
valueHasChanged = true;
break;
}
}
else
{
break;
}
}
if (valueHasChanged)
{
msg.Clear();
msg.AppendU32((uint)potentials[j]);
//sockets[j].Send(msg);
lock (senders[j])
{
senders[j].Wait();
senders[j].SetMsg(msg);
sockets[j].Send(senders[j]);
}
}
else
{
msg.Dispose();
}
}
void Whatever(object o)
{
int j = (int)o;
Aio aio = senders[j];
Errno errno = aio.Result();
if (errno != Errno.ok)
{
aio.GetMsg().Free();
}
}
/// <summary>
/// Send the specified message.
/// </summary>
/// <returns>The send.</returns>
/// <param name="message">Message.</param>
public Task <NngResult <T> > Send(T message)
{
lock (sync)
{
CheckState();
State = AsyncState.Send;
tcs = Extensions.CreateSource <T>();
Aio.SetMsg(Factory.Take(ref message));
Ctx.Send(Aio);
return(tcs.Task);
}
}
public Task <NngResult <Unit> > Send(T message)
{
lock (sync)
{
CheckState();
sendTcs = Extensions.CreateSendResultSource();
State = AsyncState.Send;
Aio.SetMsg(Factory.Take(ref message));
socket.Send(Aio);
return(sendTcs.Task);
}
}
void RPCServerStart()
{
Errno errno;
errno = Protocols.Rep0(out rep0);
Assert.IsTrue(errno == Errno.ok);
errno = rep0.SetOptInt("raw", 1);
Assert.IsTrue(errno == Errno.ok);
errno = Listener.Listen(rep0, "ipc:///myfirstpipe12345", out listener, 0);
Assert.IsTrue(errno == Errno.ok);
errno = Aio.Alloc(out serverAio, RPCServerCallback, null);
rep0.Receive(serverAio);
}
/// <summary>
/// Reply with the specified message.
/// </summary>
/// <returns>The reply.</returns>
/// <param name="message">Message.</param>
public Task <NngResult <Unit> > Reply(T message)
{
lock (sync)
{
System.Diagnostics.Debug.Assert(State == AsyncState.Wait);
State = AsyncState.Send;
// Save response TCS here to avoid race where send completes and asyncMessage replaced before we
// can return it
var ret = asyncMessage.replyTcs.Task;
Aio.SetMsg(Factory.Take(ref message));
Ctx.Send(Aio);
return(ret);
}
}
void RPCClientStart()
{
Errno errno;
errno = Protocols.Req0(out req0);
Assert.IsTrue(errno == Errno.ok);
errno = req0.SetOptInt("raw", 1);
Assert.IsTrue(errno == Errno.ok);
errno = Dialer.Dial(req0, "ipc:///myfirstpipe12345", out dialer, 0);
Assert.IsTrue(errno == Errno.ok);
errno = Aio.Alloc(out clientAio, RPCClientCallback, null);
Assert.IsTrue(errno == Errno.ok);
req0.Receive(clientAio);
}
protected override void AioCallback(IntPtr argument)
{
var res = Unit.Ok;
switch (State)
{
case AsyncState.Init:
init();
break;
case AsyncState.Recv:
res = Aio.GetResult();
if (res.IsErr())
{
asyncMessage.requestTcs.TrySetNngError(res.Err());
State = AsyncState.Recv;
return;
}
State = AsyncState.Wait;
nng_msg msg = Aio.GetMsg();
var message = Factory.CreateMessage(msg);
asyncMessage.requestTcs.SetNngResult(message);
break;
case AsyncState.Wait:
break;
case AsyncState.Send:
res = Aio.GetResult();
if (res.IsErr())
{
HandleFailedSend();
asyncMessage.replyTcs.TrySetNngError(res.Err());
}
var currentReq = asyncMessage;
init();
currentReq.replyTcs.SetNngResult();
break;
}
}
protected override void AioCallback(IntPtr argument)
{
var res = Unit.Ok;
switch (State)
{
case AsyncState.Send:
res = Aio.GetResult();
if (res.IsErr())
{
HandleFailedSend();
State = AsyncState.Init;
sendTcs.TrySetNngError(res.Err());
return;
}
State = AsyncState.Init;
sendTcs.TrySetNngResult();
break;
case AsyncState.Recv:
res = Aio.GetResult();
if (res.IsErr())
{
State = AsyncState.Init;
receiveTcs.TrySetNngError(res.Err());
return;
}
State = AsyncState.Init;
nng_msg msg = Aio.GetMsg();
var message = Factory.CreateMessage(msg);
receiveTcs.TrySetNngResult(message);
break;
case AsyncState.Init:
default:
Console.Error.WriteLine("SendReceive::AioCallback: " + State);
State = AsyncState.Init;
break;
}
}
public void Cancel() => Aio.Cancel();
public void SetTimeout(int msTimeout) => Aio.SetTimeout(msTimeout);
