public void BindAndConnect() { using (PairSocket bind = new PairSocket()) { bind.Bind("inproc://test"); Assert.That(!bind.HasOut); using (PairSocket connect = new PairSocket()) { connect.Connect("inproc://test"); Assert.That(connect.HasOut); Assert.That(bind.HasOut); Assert.That(!bind.HasIn); Assert.That(connect.TrySendFrame("Hello")); Assert.That(bind.HasIn); string message; Assert.That(bind.TryReceiveFrameString(out message)); Assert.That(message == "Hello"); } } }
public void Run(PairSocket shim) { shim.SignalOK(); shim.ReceiveReady += OnShimReady; m_messagesPipe = new PairSocket(); m_messagesPipe.Connect(string.Format("inproc://wsrouter-{0}", m_id)); m_messagesPipe.ReceiveReady += OnMessagePipeReady; m_stream = new StreamSocket(); m_stream.ReceiveReady += OnStreamReady; m_poller = new NetMQPoller(); m_poller.Add(m_messagesPipe); m_poller.Add(shim); m_poller.Add(m_stream); m_messagesPipe.SignalOK(); m_poller.Run(); m_messagesPipe.Dispose(); m_stream.Dispose(); }
/// <summary> /// Create new NetMQQueue. /// </summary> /// <param name="context">NetMQContext must be provided to the queue</param> /// <param name="capacity">The capacity of the queue, use zero for unlimited</param> public NetMQQueue(NetMQContext context, int capacity = 0) { m_context = context; m_queue = new ConcurrentQueue <T>(); m_writer = m_context.CreatePairSocket(); m_reader = m_context.CreatePairSocket(); if (capacity != 0) { m_writer.Options.SendHighWatermark = m_reader.Options.ReceiveHighWatermark = capacity / 2; } else { m_writer.Options.SendHighWatermark = m_reader.Options.ReceiveHighWatermark = 0; } m_eventDelegator = new EventDelegator <NetMQQueueEventArgs <T> >(() => { m_reader.ReceiveReady += OnReceiveReady; }, () => { m_reader.ReceiveReady -= OnReceiveReady; }); string address = string.Format("inproc://NetMQQueue#{0}", Interlocked.Increment(ref s_sequence)); m_reader.Bind(address); m_writer.Connect(address); m_dequeueMsg = new Msg(); m_dequeueMsg.InitEmpty(); }
void SocketThreadLoop() { while (true) { threadRunning = true; senderCancelled = false; AsyncIO.ForceDotNet.Force(); using (var sock = new PairSocket()) { sock.Connect("tcp://" + ip + ":" + port); while (!senderCancelled) { if (!framePending) { continue; } sock.SendFrame(msgBuffer); framesSent++; framePending = false; } sock.Close(); } NetMQConfig.Cleanup(); threadRunning = false; } }
private void ConnectionWork() { AsyncIO.ForceDotNet.Force(); using (var pairSocket = new PairSocket()) { pairSocket.Options.ReceiveHighWatermark = 1000; if (_createConnection) { pairSocket.Bind("tcp://*:12345"); } else { pairSocket.Connect("tcp://localhost:12345"); } //Do one more loop in-case we send out a closing msg and then cancel the connection bool flushedBuffer = true; while (!_connectionCancelled || !flushedBuffer) { string frameString; while (pairSocket.TryReceiveFrameString(out frameString)) { _incomingMessageQueue.Enqueue(frameString); } while (_outgoingMessageQueue.TryDequeue(out frameString)) { pairSocket.SendFrame(frameString); } flushedBuffer = _connectionCancelled; } pairSocket.Close(); } NetMQConfig.Cleanup(); }
private static void Node1(string url) { using (var s = new PairSocket()) { s.Connect(url); SendReceive(s); } }
private NetMQActor(PairSocket self, PairSocket shim, IShimHandler shimHandler) { m_shimHandler = shimHandler; m_self = self; m_shim = shim; EventHandler <NetMQSocketEventArgs> onReceive = (sender, e) => m_receiveEvent.Fire(this, new NetMQActorEventArgs(this)); EventHandler <NetMQSocketEventArgs> onSend = (sender, e) => m_sendEvent.Fire(this, new NetMQActorEventArgs(this)); m_receiveEvent = new EventDelegator <NetMQActorEventArgs>( () => m_self.ReceiveReady += onReceive, () => m_self.ReceiveReady -= onReceive); m_sendEvent = new EventDelegator <NetMQActorEventArgs>( () => m_self.SendReady += onSend, () => m_self.SendReady -= onSend); var random = new Random(); // Bind and connect pipe ends string actorName; string endPoint; while (true) { try { actorName = string.Format("NetMQActor-{0}-{1}", random.Next(0, 10000), random.Next(0, 10000)); endPoint = string.Format("inproc://{0}", actorName); m_self.Bind(endPoint); break; } catch (AddressAlreadyInUseException) { // Loop around and try another random address } } m_shim.Connect(endPoint); m_shimThread = new Thread(RunShim) { Name = actorName }; m_shimThread.Start(); // Mandatory handshake for new actor so that constructor returns only // when actor has also initialised. This eliminates timing issues at // application start up. m_self.ReceiveSignal(); }
private NetMQActor([NotNull] NetMQContext context, [NotNull] IShimHandler shimHandler) { m_shimHandler = shimHandler; m_self = context.CreatePairSocket(); m_shim = context.CreatePairSocket(); EventHandler <NetMQSocketEventArgs> onReceive = (sender, e) => m_receiveEvent.Fire(this, new NetMQActorEventArgs(this)); EventHandler <NetMQSocketEventArgs> onSend = (sender, e) => m_sendEvent.Fire(this, new NetMQActorEventArgs(this)); m_receiveEvent = new EventDelegator <NetMQActorEventArgs>( () => m_self.ReceiveReady += onReceive, () => m_self.ReceiveReady -= onReceive); m_sendEvent = new EventDelegator <NetMQActorEventArgs>( () => m_self.SendReady += onSend, () => m_self.SendReady -= onSend); var random = new Random(); //now binding and connect pipe ends string endPoint; while (true) { try { endPoint = string.Format("inproc://NetMQActor-{0}-{1}", random.Next(0, 10000), random.Next(0, 10000)); m_self.Bind(endPoint); break; } catch (AddressAlreadyInUseException) { // In case address already in use we continue searching for an address } } m_shim.Connect(endPoint); m_shimThread = new Thread(RunShim); m_shimThread.Start(); // Mandatory handshake for new actor so that constructor returns only // when actor has also initialised. This eliminates timing issues at // application start up. m_self.ReceiveSignal(); }
public void Run(PairSocket shim) { string shimAdd = $"inproc://wsrouter-{Id}"; Monitor.Enter(this); try { isRuning = true; shim.SignalOK(); shim.ReceiveReady += OnShimReady; MessagesPipe = new PairSocket(); MessagesPipe.Connect(shimAdd); MessagesPipe.ReceiveReady += OnMessagePipeReady; Stream = new StreamSocket(); Stream.Bind(Address); Stream.ReceiveReady += OnStreamReady; Poller = new NetMQPoller { MessagesPipe, shim, Stream }; MessagesPipe.SignalOK(); Poller.Run(); shim.Dispose(); } catch (Exception ex) { Console.WriteLine(ex); } finally { Monitor.Exit(this); } }
public void RunPipeline(PairSocket shim) { shim.SignalOK(); shim.ReceiveReady += OnShimReady; m_messagesPipe = m_context.CreatePairSocket(); m_messagesPipe.Connect(string.Format("inproc://wsrouter-{0}", m_id)); m_messagesPipe.ReceiveReady += OnMessagePipeReady; m_stream = m_context.CreateStreamSocket(); m_stream.ReceiveReady += OnStreamReady; m_poller = new Poller(m_messagesPipe, shim, m_stream); m_messagesPipe.SignalOK(); m_poller.Start(); m_messagesPipe.Dispose(); m_stream.Dispose(); }
/// <summary> /// <para>is the main thread of the broker</para> /// <para>it spawns threads handling titanic operations</para> /// <para>it receives GUID from Titanic Request Service and dispatches the requests /// to available workers via MDPBroker</para> /// <para>it also manages the appropriate changes in the file system as well as in queue</para> /// </summary> /// <param name="requestWorker">mdp worker processing the incoming requests for services</param> /// <param name="replyWorker">mdp worker processing incoming reply requests</param> /// <param name="closeWorker">mdp worker processing incoming close requests</param> /// <param name="serviceCallClient">mdp client forwarding requests to service providing mdp worker /// via mdp broker and collecting replies</param> /// <exception cref="TerminatingException">The socket has been stopped.</exception> /// <exception cref="AddressAlreadyInUseException">The specified address is already in use.</exception> /// <exception cref="NetMQException">No IO thread was found, or the protocol's listener encountered an /// error during initialization.</exception> /// <exception cref="ObjectDisposedException">thrown if the socket was already disposed</exception> public void Run( IMDPWorker requestWorker = null, IMDPWorker replyWorker = null, IMDPWorker closeWorker = null, IMDPClient serviceCallClient = null) { using (var pipeStart = new PairSocket ()) using (var pipeEnd = new PairSocket ()) using (var cts = new CancellationTokenSource ()) { // set up the inter thread communication pipe pipeStart.Bind (_titanic_internal_communication); pipeEnd.Connect (_titanic_internal_communication); // start the three child tasks var requestTask = Task.Run (() => ProcessTitanicRequest (pipeEnd, requestWorker), cts.Token); var replyTask = Task.Run (() => ProcessTitanicReply (replyWorker), cts.Token); var closeTask = Task.Run (() => ProcessTitanicClose (closeWorker), cts.Token); var tasks = new[] { requestTask, replyTask, closeTask }; while (true) { // wait for 1s for a new request from 'Request' to process var input = pipeStart.Poll (PollEvents.PollIn, TimeSpan.FromMilliseconds (1000)); // any message available? -> process it if ((input & PollEvents.PollIn) == PollEvents.PollIn) { // only one frame will be send [Guid] var msg = pipeStart.ReceiveFrameString (); Guid guid; if (!Guid.TryParse (msg, out guid)) Log ("[TITANIC BROKER] Received a malformed GUID via pipe - throw it away"); else { Log (string.Format ("[TITANIC BROKER] Received request GUID {0} via pipe", msg)); // now we have a valid GUID - save it to disk for further use m_io.SaveNewRequestEntry (guid); } } //! now dispatch (brute force) the requests -> SHOULD BE MORE INTELLIGENT (!) // dispatching will also worry about the handling of a potential reply // dispatch only requests which have not been closed foreach (var entry in m_io.GetNotClosedRequestEntries ().Where (entry => entry != default (RequestEntry))) { if (DispatchRequests (entry.RequestId, serviceCallClient)) m_io.SaveProcessedRequestEntry (entry); } //! should implement some sort of restart // beware of the silently dieing threads - must be detected! if (DidAnyTaskStopp (tasks)) { // stopp all threads cts.Cancel (); // stop processing! break; } } } }
/// <summary> /// <para>is the main thread of the broker</para> /// <para>it spawns threads handling titanic operations</para> /// <para>it receives GUID from Titanic Request Service and dispatches the requests /// to available workers via MDPBroker</para> /// <para>it also manages the appropriate changes in the file system as well as in queue</para> /// </summary> /// <param name="requestWorker">mdp worker processing the incoming requests for services</param> /// <param name="replyWorker">mdp worker processing incoming reply requests</param> /// <param name="closeWorker">mdp worker processing incoming close requests</param> /// <param name="serviceCallClient">mdp client forwarding requests to service providing mdp worker /// via mdp broker and collecting replies</param> /// <exception cref="TerminatingException">The socket has been stopped.</exception> /// <exception cref="AddressAlreadyInUseException">The specified address is already in use.</exception> /// <exception cref="NetMQException">No IO thread was found, or the protocol's listener encountered an /// error during initialization.</exception> /// <exception cref="ObjectDisposedException">thrown if the socket was already disposed</exception> public void Run([CanBeNull] IMDPWorker requestWorker = null, [CanBeNull] IMDPWorker replyWorker = null, [CanBeNull] IMDPWorker closeWorker = null, [CanBeNull] IMDPClient serviceCallClient = null) { using (var pipeStart = new PairSocket()) using (var pipeEnd = new PairSocket()) using (var cts = new CancellationTokenSource()) { // set up the inter thread communication pipe pipeStart.Bind(_titanic_internal_communication); pipeEnd.Connect(_titanic_internal_communication); // start the three child tasks var requestTask = Task.Run(() => ProcessTitanicRequest(pipeEnd, requestWorker), cts.Token); var replyTask = Task.Run(() => ProcessTitanicReply(replyWorker), cts.Token); var closeTask = Task.Run(() => ProcessTitanicClose(closeWorker), cts.Token); var tasks = new[] { requestTask, replyTask, closeTask }; while (true) { // wait for 1s for a new request from 'Request' to process var input = pipeStart.Poll(PollEvents.PollIn, TimeSpan.FromMilliseconds(1000)); // any message available? -> process it if ((input & PollEvents.PollIn) == PollEvents.PollIn) { // only one frame will be send [Guid] var msg = pipeStart.ReceiveFrameString(); Guid guid; if (!Guid.TryParse(msg, out guid)) { Log("[TITANIC BROKER] Received a malformed GUID via pipe - throw it away"); } else { Log($"[TITANIC BROKER] Received request GUID {msg} via pipe"); // now we have a valid GUID - save it to disk for further use m_io.SaveNewRequestEntry(guid); } } //! now dispatch (brute force) the requests -> SHOULD BE MORE INTELLIGENT (!) // dispatching will also worry about the handling of a potential reply // dispatch only requests which have not been closed foreach (var entry in m_io.GetNotClosedRequestEntries().Where(entry => entry != default(RequestEntry))) { if (DispatchRequests(entry.RequestId, serviceCallClient)) { m_io.SaveProcessedRequestEntry(entry); } } //! should implement some sort of restart // beware of the silently dieing threads - must be detected! if (DidAnyTaskStopp(tasks)) { // stop all threads cts.Cancel(); // stop processing! break; } } } }
public static void Execute() { Console.WriteLine("Executing Pair test"); _clientData = new byte[DataSize]; _serverData = new byte[DataSize]; var r = new Random(); r.NextBytes(_clientData); r.NextBytes(_serverData); var clientThread = new Thread( () => { var req = new PairSocket(); req.Connect(InprocAddress); byte[] streamOutput = new byte[BufferSize]; while (true) { var sw = Stopwatch.StartNew(); for (int i = 0; i < Iter; i++) { var result = req.SendImmediate(_clientData); Trace.Assert(result); int read = 0; using (var stream = req.ReceiveStream()) while (stream.Length != stream.Position) { read += stream.Read(streamOutput, 0, streamOutput.Length); } Trace.Assert(read == _serverData.Length); } sw.Stop(); var secondsPerSend = sw.Elapsed.TotalSeconds / (double)Iter; Console.WriteLine("Pair Time {0} us, {1} per second, {2} mb/s ", (int)(secondsPerSend * 1000d * 1000d), (int)(1d / secondsPerSend), (int)(DataSize * 2d / (1024d * 1024d * secondsPerSend))); } }); clientThread.Start(); { var rep = new PairSocket(); rep.Bind(InprocAddress); byte[] streamOutput = new byte[BufferSize]; var sw = Stopwatch.StartNew(); while (sw.Elapsed.TotalSeconds < 10) { int read = 0; using (var stream = rep.ReceiveStream()) while (stream.Length != stream.Position) { read += stream.Read(streamOutput, 0, streamOutput.Length); } rep.SendImmediate(_serverData); } clientThread.Abort(); } }
static void Main() { using (var client = new PairSocket()) { client.Connect("tcp://127.0.0.1:5556"); client.SendFrame("hello"); bool firstRun = true; // talk while (true) { // receive reward string reward = client.ReceiveFrameString(); if (reward == "-1") { reward = "-"; } else if (reward == "1") { reward = "+"; } else { reward = " "; } if (firstRun) { reward = string.Empty; firstRun = false; } else { if (!Interactive) { Learner.RegisterReward(reward); } } // receive teacher/env char string teacherChar = client.ReceiveFrameString(); Display.ShowStep(reward, teacherChar); // reply string reply; if (Interactive) { var key = Console.ReadKey(); reply = key.KeyChar.ToString(); } else { reply = Learner.Answer(teacherChar); } Display.ShowReply(reply); client.SendFrame(reply); } } }