private void OnShimReady(object sender, NetMQSocketEventArgs e) { var command = _shim.ReceiveFrameString(); switch (command) { case NetMQActor.EndShimMessage: { _poll.Stop(); break; } case PublishCommand: { _publisher.SendMultipartMessage(_shim.ReceiveMultipartMessage()); break; } case GetHostAddressCommand: { _shim.SendFrame($"{_beacon.BoundTo}:{_port}"); break; } } }
private void OnShimReady(object sender, NetMQSocketEventArgs e) { // new actor command string command = m_shim.ReceiveFrameString(); // check if we received end shim command if (command == NetMQActor.EndShimMessage) { // we cancel the socket which dispose and exist the shim m_poller.Stop(); } else if (command == PublishCommand) { // it is a publish command // we just forward everything to the publisher until end of message NetMQMessage message = m_shim.ReceiveMultipartMessage(); m_publisher.SendMultipartMessage(message); } else if (command == GetHostAddressCommand) { var interfaceCollection = new InterfaceCollection(); var bindTo = interfaceCollection.Select(x => x.Address).First(); var address = bindTo + ":" + m_randomPort; m_shim.SendFrame(address); } }
/// <summary> /// Extension method that waits maximally timeoutMs for a string data on pair. /// </summary> public static bool ReceiveFrameStringTimeout(this PairSocket pair, out string result, int timeoutMs) { Stopwatch sw = Stopwatch.StartNew(); while (sw.ElapsedMilliseconds <= timeoutMs) { if (pair.HasIn) { result = pair.ReceiveFrameString(); return(true); } } sw.Stop(); result = null; return(false); }
private void OnShimReady(object sender, NetMQSocketEventArgs e) { // new actor command var command = shim.ReceiveFrameString(); // check if we received end shim command if (command == NetMQActor.EndShimMessage) { // we cancel the socket which dispose and exist the shim poller.Stop(); } else if (command == PublishCommand) { // it is a publish command // we just forward everything to the publisher until end of message var message = shim.ReceiveMultipartMessage(); publisher.SendMultipartMessage(message); } else if (command == GetHostAddressCommand) { var address = beacon.BoundTo + ":" + randomPort; shim.SendFrame(address); } }
private void OnShimReady(object sender, NetMQSocketEventArgs e) { // new actor command var command = _shim.ReceiveFrameString(); // check if we received end shim command if (command == NetMQActor.EndShimMessage) { // we cancel the socket which dispose and exist the shim _poller.Stop(); } else if (command == TaskSchedulerBusCommands.Publish.ToString()) { // it is a publish command // we just forward everything to the publisher until end of message var message = _shim.ReceiveMultipartMessage(); _publisher.SendMultipartMessage(message); } else if (command == TaskSchedulerBusCommands.GetHostAddress.ToString()) { var address = _beacon.HostName + ":" + _randomPort; _shim.SendFrame(address); } }
/// <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; } } } }
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); } } }
public string ReceiveFrameString() { return(m_messagesPipe.ReceiveFrameString()); }