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