/// <summary>
/// Try to send request message and return the response as a message, or return null if not successful
/// </summary>
/// <param name="address">a string denoting the address to connect to</param>
/// <param name="requestMessage">The request message</param>
/// <param name="numTries">The number of times to try</param>
/// <param name="requestTimeout">The timeout for each request</param>
/// <param name="progressPublisher">Report topics: Failure, Retry, Send, Success</param>
/// <returns>the response message, or null if not successful</returns>
public static NetMQMessage RequestResponseMultipartMessageWithRetry([NotNull] string address, [NotNull] NetMQMessage requestMessage,
int numTries, TimeSpan requestTimeout, PublisherSocket progressPublisher = null)
{
var responseMessage = new NetMQMessage();
while (numTries-- > 0)
{
using (var requestSocket = new RequestSocket(address))
{
progressPublisher?.SendFrame(ProgressTopic.Send.ToString());
requestSocket.SendMultipartMessage(requestMessage);
if (requestSocket.TryReceiveMultipartMessage(requestTimeout, ref responseMessage))
{
progressPublisher?.SendFrame(ProgressTopic.Success.ToString());
return responseMessage;
}
progressPublisher?.SendFrame(ProgressTopic.Retry.ToString());
}
}
progressPublisher?.SendFrame(ProgressTopic.Failure.ToString());
return null;
}
public void BindRandomThenUnbind()
{
using (var pub = new PublisherSocket())
{
var port = pub.BindRandomPort("tcp://localhost");
pub.Unbind("tcp://localhost:" + port);
}
using (var pub = new PublisherSocket())
{
var port = pub.BindRandomPort("tcp://*");
pub.Unbind("tcp://*:" + port);
}
using (var pub = new PublisherSocket())
{
var port1 = pub.BindRandomPort("tcp://*");
var port2 = pub.BindRandomPort("tcp://*");
var port3 = pub.BindRandomPort("tcp://*");
pub.Unbind("tcp://*:" + port1);
pub.Unbind("tcp://*:" + port2);
pub.Unbind("tcp://*:" + port3);
}
}
public void RequestResponseMultipartMessageWithRetryFails()
{
const string address = "tcp://127.0.0.1:50002";
const string pubAddress = "tcp://127.0.0.1:60002";
const int numTries = 5;
var requestTimeout = TimeSpan.FromMilliseconds(100);
var requestMessage = new NetMQMessage(1);
requestMessage.Append("Hi");
using (var progressPublisher = new PublisherSocket(pubAddress))
using (var progressSubscriber = new SubscriberSocket(pubAddress))
using (var server = new RouterSocket(address))
{
progressSubscriber.SubscribeToAnyTopic();
var progressProactor = new NetMQProactor(progressSubscriber, (socket, message) =>
Console.WriteLine("C: {0} {1:ss.fff}", message[0].ConvertToString(), DateTime.Now));
var serverProactor = new NetMQProactor(server, (socket, message) =>
{
Console.WriteLine("ResponseEcho recieved message {0} at {1:ss.fff}", message[2].ConvertToString(),
DateTime.Now);
});
using (serverProactor)
using (progressProactor)
{
var responseMessage = RequestSocket.RequestResponseMultipartMessageWithRetry(address, requestMessage,
numTries, requestTimeout, progressPublisher);
Assert.IsNull(responseMessage);
}
}
}
/* =====================
* UNITY PLAYER EVENT HOOKS
* =====================
*/
// Function called when Unity Player is loaded.
public IEnumerator Start()
{
// Check if the program should use CLI arguments (with defaults)
if (!Application.isEditor)
{
pose_host = GetArg("-pose-host", pose_host_default);
video_host = GetArg("-video-host", video_host_default);
}
// Init simple splash screen
Text text_obj = splashScreen.GetComponentInChildren <Text>(true);
text_obj.text = "FlightGoggles Simulation Environment" + Environment.NewLine +
flight_goggles_version + Environment.NewLine + Environment.NewLine +
"Waiting for client connection..." + Environment.NewLine + Environment.NewLine +
"Pose input socket:" + Environment.NewLine + pose_host + Environment.NewLine + Environment.NewLine +
"Video output socket:" + Environment.NewLine + video_host;
splashScreen.SetActive(true);
// Fixes for Unity/NetMQ conflict stupidity.
AsyncIO.ForceDotNet.Force();
socket_lock = new object();
// Connect sockets
Debug.Log("Creating sockets.");
pull_socket = new NetMQ.Sockets.SubscriberSocket();
pull_socket.Options.ReceiveHighWatermark = 90;
pull_socket.Connect(pose_host);
// Setup subscriptions.
pull_socket.Subscribe("Pose");
push_socket = new NetMQ.Sockets.PublisherSocket();
push_socket.Connect(video_host);
Debug.Log("Sockets bound.");
// Initialize Internal State
internal_state = new UnityState_t();
// Do not try to do any processing this frame so that we can render our splash screen.
internal_state.screenSkipFrames = 1;
// Wait until end of frame to transmit images
while (true)
{
// Wait until all rendering + UI is done.
// Blocks until the frame is rendered.
yield return(new WaitForEndOfFrame());
// Check if this frame should be rendered.
if (internal_state.readyToRender)
{
// Read the frame from the GPU backbuffer and send it via ZMQ.
sendFrameOnWire();
}
}
}
void InstantiateSockets()
{
// Configure sockets
Debug.Log("Configuring sockets.");
pull_socket = new NetMQ.Sockets.SubscriberSocket();
pull_socket.Options.ReceiveHighWatermark = 90;
// Setup subscriptions.
pull_socket.Subscribe("Pose");
push_socket = new NetMQ.Sockets.PublisherSocket();
push_socket.Options.Linger = TimeSpan.Zero; // Do not keep unsent messages on hangup.
}
public void init(string address, int port)
{
this.address = address;
this.port = port;
//create context
context = NetMQContext.Create();
//create client
publisher = context.CreatePublisherSocket();
//connect publisher
publisher.Bind("tcp://" + address + ":" + port);
}
public void HandleMessage(Message message, RouterSocket serverSocket, PublisherSocket ioPub)
{
KernelInfoRequest kernelInfoRequest = JsonSerializer.Deserialize<KernelInfoRequest>(message.Content);
Message replyMessage = new Message()
{
UUID = message.Header.Session,
ParentHeader = message.Header,
Header = MessageBuilder.CreateHeader(MessageTypeValues.KernelInfoReply, message.Header.Session),
Content = JsonSerializer.Serialize(this.CreateKernelInfoReply())
};
this.logger.Info("Sending kernel_info_reply");
MessageSender.Send(replyMessage, serverSocket);
}
public void NotSubscribed()
{
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
var port = pub.BindRandomPort("tcp://127.0.0.1");
sub.Connect("tcp://127.0.0.1:" + port);
// let the subscriber connect to the publisher before sending a message
Thread.Sleep(500);
pub.SendFrame("Hello");
Assert.IsFalse(sub.TrySkipFrame());
}
}
public void ConnectBothSockets()
{
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
pub.Connect("pgm://224.0.0.1:5555");
sub.Connect("pgm://224.0.0.1:5555");
sub.Subscribe("");
pub.SendFrame("Hi");
bool more;
Assert.AreEqual("Hi", sub.ReceiveFrameString(out more));
Assert.IsFalse(more);
}
}
public void TopicPubSub()
{
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
var port = pub.BindRandomPort("tcp://127.0.0.1");
sub.Connect("tcp://127.0.0.1:" + port);
sub.Subscribe("A");
// let the subscriber connect to the publisher before sending a message
Thread.Sleep(500);
pub.SendMoreFrame("A").SendFrame("Hello");
CollectionAssert.AreEqual(
new[] {"A", "Hello"},
sub.ReceiveMultipartStrings());
}
}
public void HandleMessage(Message message, RouterSocket serverSocket, PublisherSocket ioPub)
{
this.logger.Debug(string.Format("Message Content {0}", message.Content));
ExecuteRequest executeRequest = JsonSerializer.Deserialize<ExecuteRequest>(message.Content);
this.logger.Info(string.Format("Execute Request received with code {0}", executeRequest.Code));
// 1: Send Busy status on IOPub
this.SendMessageToIOPub(message, ioPub, StatusValues.Busy);
// 2: Send execute input on IOPub
this.SendInputMessageToIOPub(message, ioPub, executeRequest.Code);
// 3: Evaluate the C# code
string code = executeRequest.Code;
ExecutionResult results = this.replEngine.Execute(code);
string codeOutput = this.GetCodeOutput(results);
string codeHtmlOutput = this.GetCodeHtmlOutput(results);
Dictionary<string, object> data = new Dictionary<string, object>()
{
{"text/plain", codeOutput},
{"text/html", codeHtmlOutput}
};
DisplayData displayData = new DisplayData()
{
Data = data,
};
// 4: Send execute reply to shell socket
this.SendExecuteReplyMessage(message, serverSocket);
// 5: Send execute result message to IOPub
this.SendOutputMessageToIOPub(message, ioPub, displayData);
// 6: Send IDLE status message to IOPub
this.SendMessageToIOPub(message, ioPub, StatusValues.Idle);
this.executionCount += 1;
}
public void LargeMessage()
{
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
var port = pub.BindRandomPort("tcp://127.0.0.1");
sub.Connect("tcp://127.0.0.1:" + port);
sub.Subscribe("");
Thread.Sleep(100);
var msg = new byte[300];
pub.SendFrame(msg);
byte[] msg2 = sub.ReceiveFrameBytes();
Assert.AreEqual(300, msg2.Length);
}
}
public void RequestResponseMultipartMessageWithRetrySucceedsFirstTry()
{
const string address = "tcp://127.0.0.1:50001";
const string pubAddress = "tcp://127.0.0.1:60001";
const int numTries = 5;
var requestTimeout = TimeSpan.FromMilliseconds(100);
var requestMessage = new NetMQMessage(1);
requestMessage.Append("Hi");
using (var progressPublisher = new PublisherSocket(pubAddress))
using (var progressSubscriber = new SubscriberSocket(pubAddress))
using (var server = new ResponseSocket(address))
{
progressSubscriber.SubscribeToAnyTopic();
var progressProactor = new NetMQProactor(progressSubscriber, (socket, message) =>
Console.WriteLine("C: {0} {1:ss.fff}", message[0].ConvertToString(), DateTime.Now));
var serverProactor = new NetMQProactor(server, (socket, message) =>
{
Console.WriteLine("ResponseEcho received message {0} at {1:ss.fff}", message.First.ConvertToString(),
DateTime.Now);
// reply same message
socket.SendMultipartMessage(message);
});
using (serverProactor)
using (progressProactor)
{
var responseMessage = RequestSocket.RequestResponseMultipartMessageWithRetry(address,
requestMessage, numTries, requestTimeout, progressPublisher);
Assert.IsNotNull(responseMessage);
Assert.AreEqual(1, responseMessage.FrameCount);
var responseString = responseMessage.First.ConvertToString();
Assert.AreEqual("Hi", responseString);
}
}
}
public void PubSub_Should_Not_Crash_If_No_Thread_Sleep()
{
NUnitUtils.PrintTestName();
var swAll = Stopwatch.StartNew();
using (var pub = new PublisherSocket())
{
using (var sub = new SubscriberSocket())
{
var freePort = NUnitUtils.TcpPortFree();
pub.Bind("tcp://127.0.0.1:" + freePort);
sub.Connect("tcp://127.0.0.1:" + freePort);
sub.Subscribe("*");
var sw = Stopwatch.StartNew();
{
for (var i = 0; i < 50; i++)
{
pub.SendFrame("*"); // Ping.
Console.Write("*");
string topic;
var gotTopic = sub.TryReceiveFrameString(TimeSpan.FromMilliseconds(100), out topic);
string ping;
var gotPing = sub.TryReceiveFrameString(TimeSpan.FromMilliseconds(100), out ping);
if (gotTopic)
{
Console.Write("\n");
break;
}
}
}
Console.WriteLine("Connected in {0} ms.", sw.ElapsedMilliseconds);
}
}
NUnitUtils.PrintElapsedTime(swAll.Elapsed);
}
public void MultipleSubscriptions()
{
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
var port = pub.BindRandomPort("tcp://127.0.0.1");
sub.Connect("tcp://127.0.0.1:" + port);
sub.Subscribe("C");
sub.Subscribe("B");
sub.Subscribe("A");
sub.Subscribe("D");
sub.Subscribe("E");
Thread.Sleep(500);
sub.Unsubscribe("C");
sub.Unsubscribe("B");
sub.Unsubscribe("A");
sub.Unsubscribe("D");
sub.Unsubscribe("E");
Thread.Sleep(500);
}
}
public void SetPgmSettings()
{
const int MegaBit = 1024;
const int MegaByte = 1024;
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
pub.Options.MulticastHops = 2;
pub.Options.MulticastRate = 40*MegaBit; // 40 megabit
pub.Options.MulticastRecoveryInterval = TimeSpan.FromMinutes(10);
pub.Options.SendBuffer = MegaByte*10; // 10 megabyte
pub.Connect("pgm://224.0.0.1:5555");
sub.Options.ReceiveBuffer = MegaByte*10;
sub.Bind("pgm://224.0.0.1:5555");
sub.Subscribe("");
pub.SendFrame("Hi");
bool more;
Assert.AreEqual("Hi", sub.ReceiveFrameString(out more));
Assert.IsFalse(more);
Assert.AreEqual(2, pub.Options.MulticastHops);
Assert.AreEqual(40*MegaBit, pub.Options.MulticastRate);
Assert.AreEqual(TimeSpan.FromMinutes(10), pub.Options.MulticastRecoveryInterval);
Assert.AreEqual(MegaByte*10, pub.Options.SendBuffer);
Assert.AreEqual(MegaByte*10, sub.Options.ReceiveBuffer);
}
}
public void MultiplePublishersAndSubscribersOnSameTopic()
{
using (var pub1 = new PublisherSocket())
using (var pub2 = new PublisherSocket())
using (var sub1 = new SubscriberSocket())
using (var sub2 = new SubscriberSocket())
{
int port1 = pub1.BindRandomPort("tcp://127.0.0.1");
int port2 = pub2.BindRandomPort("tcp://127.0.0.1");
sub1.Connect("tcp://127.0.0.1:" + port1);
sub1.Connect("tcp://127.0.0.1:" + port2);
sub2.Connect("tcp://127.0.0.1:" + port1);
sub2.Connect("tcp://127.0.0.1:" + port2);
// should subscribe to both
sub1.Subscribe("A");
sub2.Subscribe("A");
Thread.Sleep(500);
// Send from pub 1
pub1.SendMoreFrame("A").SendFrame("Hello from the first publisher");
CollectionAssert.AreEqual(new[] { "A", "Hello from the first publisher" }, sub1.ReceiveMultipartStrings());
CollectionAssert.AreEqual(new[] { "A", "Hello from the first publisher" }, sub2.ReceiveMultipartStrings());
// Send from pub 2
pub2.SendMoreFrame("A").SendFrame("Hello from the second publisher");
CollectionAssert.AreEqual(new[] { "A", "Hello from the second publisher" }, sub1.ReceiveMultipartStrings());
CollectionAssert.AreEqual(new[] { "A", "Hello from the second publisher" }, sub2.ReceiveMultipartStrings());
}
}
/// <summary>
/// Try to send request string and return the response string, or return null if not successful
/// </summary>
/// <param name="address">a string denoting the address to connect to</param>
/// <param name="requestString">The request string</param>
/// <param name="numTries">The number of times to try</param>
/// <param name="requestTimeout">The timeout for each request</param>
/// <param name="progressPublisher">Report topics: Failure, Retry, Send, Success</param>
/// <returns>the response message, or null if not successful</returns>
public static string RequestResponseStringWithRetry([NotNull] string address, [NotNull] string requestString,
int numTries, TimeSpan requestTimeout, PublisherSocket progressPublisher = null)
{
while (numTries-- > 0)
{
using (var requestSocket = new RequestSocket(address))
{
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Send.ToString());
}
requestSocket.SendFrame(requestString);
string frameString;
if (requestSocket.TryReceiveFrameString(requestTimeout, out frameString))
{
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Success.ToString());
}
return frameString;
}
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Retry.ToString());
}
}
}
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Failure.ToString());
}
return null;
}
public void ThroughXPubXSub()
{
using (var xpub = new XPublisherSocket())
using (var xsub = new XSubscriberSocket())
using (var proxyPoller = new NetMQPoller {xsub, xpub})
{
var xPubPort = (ushort)xpub.BindRandomPort("tcp://*");
var xSubPort = (ushort)xsub.BindRandomPort("tcp://*");
var proxy = new Proxy(xsub, xpub, poller: proxyPoller);
proxy.Start();
proxyPoller.RunAsync();
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
// Client 1
sub.Connect(string.Format("tcp://localhost:{0}", xPubPort));
pub.Connect(string.Format("tcp://localhost:{0}", xSubPort));
sub.Subscribe("A");
// Client 2
Thread.Sleep(500);
pub.SendMoreFrame("A").SendFrame("Hello");
var frames = new List<string>();
Assert.True(sub.TryReceiveMultipartStrings(TimeSpan.FromSeconds(1), ref frames));
CollectionAssert.AreEqual(
new[] { "A", "Hello" },
frames);
}
}
}
public void RequestResponseStringWithRetrySucceedsNotOnFirstTry()
{
const string address = "tcp://127.0.0.1:50001";
const string pubAddress = "tcp://127.0.0.1:60001";
const int numTries = 5;
var requestTimeout = TimeSpan.FromMilliseconds(100);
using (var progressPublisher = new PublisherSocket(pubAddress))
using (var progressSubscriber = new SubscriberSocket(pubAddress))
using (var server = new RouterSocket(address))
{
progressSubscriber.SubscribeToAnyTopic();
var progressProactor = new NetMQProactor(progressSubscriber, (socket, message) =>
Console.WriteLine("C: {0} {1:ss.fff}", message[0].ConvertToString(), DateTime.Now));
int attempt = 0;
var serverProactor = new NetMQProactor(server, (socket, message) =>
{
Console.WriteLine("ResponseEcho recieved message {0} at {1:ss.fff}", message[2].ConvertToString(),
DateTime.Now);
attempt++;
if (attempt > 1)
{
// reply same message
socket.SendMultipartMessage(message);
}
});
using (serverProactor)
using (progressProactor)
{
var responseMessage = RequestSocket.RequestResponseStringWithRetry(address,
"Hi", numTries, requestTimeout, progressPublisher);
Assert.AreEqual("Hi", responseMessage);
}
}
}
public void Sending1000Messages()
{
// creating two different context and sending 1000 messages
int count = 0;
var subReady = new ManualResetEvent(false);
Task subTask = Task.Factory.StartNew(() =>
{
using (var sub = new SubscriberSocket())
{
sub.Bind("pgm://224.0.0.1:5555");
sub.Subscribe("");
subReady.Set();
while (count < 1000)
{
bool more;
Assert.AreEqual(count, BitConverter.ToInt32(sub.ReceiveFrameBytes(out more), 0));
Assert.IsFalse(more);
count++;
}
}
});
subReady.WaitOne();
Task pubTask = Task.Factory.StartNew(() =>
{
using (var pub = new PublisherSocket())
{
pub.Connect("pgm://224.0.0.1:5555");
for (int i = 0; i < 1000; i++)
pub.SendFrame(BitConverter.GetBytes(i));
// if we close the socket before the subscriber receives all messages subscriber
// might miss messages, lets wait another second
Thread.Sleep(1000);
}
});
pubTask.Wait();
subTask.Wait();
Assert.AreEqual(1000, count);
}
public void ThroughXPubXSubWithReconnectingPublisher()
{
using (var xpub = new XPublisherSocket())
using (var xsub = new XSubscriberSocket())
using (var poller = new NetMQPoller {xsub, xpub})
{
var xPubPort = (ushort)xpub.BindRandomPort("tcp://*");
var xSubPort = (ushort)xsub.BindRandomPort("tcp://*");
var proxy = new Proxy(xsub, xpub, poller: poller);
proxy.Start();
poller.RunAsync();
// long running subscriber
using (var sub = new SubscriberSocket())
{
sub.Connect(string.Format("tcp://localhost:{0}", xPubPort));
sub.Subscribe("A");
// publisher 1
using (var pub = new PublisherSocket())
{
pub.Connect(string.Format("tcp://localhost:{0}", xSubPort));
// give the publisher a chance to learn of the subscription
Thread.Sleep(100);
pub.SendMoreFrame("A").SendFrame("1");
}
// publisher 2
using (var pub = new PublisherSocket())
{
pub.Connect(string.Format("tcp://localhost:{0}", xSubPort));
// give the publisher a chance to learn of the subscription
Thread.Sleep(100);
pub.SendMoreFrame("A").SendFrame("2");
}
var frames = new List<string>();
Assert.True(sub.TryReceiveMultipartStrings(TimeSpan.FromSeconds(1), ref frames));
CollectionAssert.AreEqual(new[] { "A", "1" }, frames);
Assert.True(sub.TryReceiveMultipartStrings(TimeSpan.FromSeconds(1), ref frames));
CollectionAssert.AreEqual(new[] { "A", "2" }, frames);
}
}
}
public void UseInterface()
{
#if NETCOREAPP1_0
var hostEntry = Dns.GetHostEntryAsync(Dns.GetHostName()).Result;
#else
var hostEntry = Dns.GetHostEntry(Dns.GetHostName());
#endif
string ip = hostEntry.AddressList
.Where(addr => addr.AddressFamily == AddressFamily.InterNetwork)
.Select(addr => addr.ToString())
.FirstOrDefault();
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
pub.Connect($"pgm://{ip};224.0.0.1:5555");
sub.Bind($"pgm://{ip};224.0.0.1:5555");
sub.Subscribe("");
pub.SendFrame("Hi");
bool more;
Assert.AreEqual("Hi", sub.ReceiveFrameString(out more));
Assert.IsFalse(more);
}
}
public void MultipleSubscribersOnDifferentTopics()
{
using (var pub = new PublisherSocket())
using (var sub1 = new SubscriberSocket())
using (var sub2 = new SubscriberSocket())
{
var port = pub.BindRandomPort("tcp://127.0.0.1");
sub1.Connect("tcp://127.0.0.1:" + port);
sub2.Connect("tcp://127.0.0.1:" + port);
sub1.Subscribe("1");
sub1.Subscribe("1&2");
sub2.Subscribe("2");
sub2.Subscribe("1&2");
Thread.Sleep(500);
pub.SendMoreFrame("1").SendFrame("A");
CollectionAssert.AreEqual(new[] { "1", "A" }, sub1.ReceiveMultipartStrings());
Assert.IsFalse(sub2.TrySkipFrame());
pub.SendMoreFrame("2").SendFrame("B");
Assert.IsFalse(sub1.TrySkipFrame());
CollectionAssert.AreEqual(new[] { "2", "B" }, sub2.ReceiveMultipartStrings());
pub.SendMoreFrame("1&2").SendFrame("C");
CollectionAssert.AreEqual(new[] { "1&2", "C" }, sub1.ReceiveMultipartStrings());
CollectionAssert.AreEqual(new[] { "1&2", "C" }, sub2.ReceiveMultipartStrings());
}
}
public void SendMessageToIOPub(Message message, PublisherSocket ioPub, string statusValue)
{
Dictionary<string,string> content = new Dictionary<string, string>();
content.Add("execution_state", statusValue);
Message ioPubMessage = MessageBuilder.CreateMessage(MessageTypeValues.Status,
JsonSerializer.Serialize(content), message.Header);
this.logger.Info(string.Format("Sending message to IOPub {0}", JsonSerializer.Serialize(ioPubMessage)));
MessageSender.Send(ioPubMessage, ioPub);
this.logger.Info("Message Sent");
}
public void LargerBufferLength()
{
var largerBuffer = new byte[256];
{
largerBuffer[124] = 0xD;
largerBuffer[125] = 0xE;
largerBuffer[126] = 0xE;
largerBuffer[127] = 0xD;
}
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
var port = pub.BindRandomPort("tcp://127.0.0.1");
sub.Connect("tcp://127.0.0.1:" + port);
sub.Subscribe("");
Thread.Sleep(100);
pub.SendFrame(largerBuffer, 128);
byte[] recvMesage = sub.ReceiveFrameBytes();
Assert.AreEqual(128, recvMesage.Length);
Assert.AreEqual(0xD, recvMesage[124]);
Assert.AreEqual(0xE, recvMesage[125]);
Assert.AreEqual(0xE, recvMesage[126]);
Assert.AreEqual(0xD, recvMesage[127]);
Assert.AreNotEqual(largerBuffer.Length, recvMesage.Length);
}
}
public void SendInputMessageToIOPub(Message message, PublisherSocket ioPub, string code)
{
Dictionary<string, object> content = new Dictionary<string, object>();
content.Add("execution_count", 1);
content.Add("code", code);
Message executeInputMessage = MessageBuilder.CreateMessage(MessageTypeValues.Input, JsonSerializer.Serialize(content),
message.Header);
this.logger.Info(string.Format("Sending message to IOPub {0}", JsonSerializer.Serialize(executeInputMessage)));
MessageSender.Send(executeInputMessage, ioPub);
}
private PublisherSocket GetNewPublisherSocket(string addressZeroMq)
{
PublisherSocket publisherSocket;
{
_loggerDelegate?.Invoke(string.Format("Publisher socket binding to: {0}\n", addressZeroMq));
publisherSocket = new PublisherSocket();
// Corner case: wait until publisher socket is ready (see code below that waits for
// "_publisherReadySignal").
NetMQMonitor monitor;
{
// Must ensure that we have a unique monitor name for every instance of this class.
string endPoint = string.Format("inproc://#SubjectNetMQ#Publisher#{0}#{1}", addressZeroMq, Guid.NewGuid().ToString());
monitor = new NetMQMonitor(publisherSocket,
endPoint,
SocketEvents.Accepted | SocketEvents.Listening
);
monitor.Accepted += Publisher_Event_Accepted;
monitor.Listening += Publisher_Event_Listening;
monitor.StartAsync();
}
publisherSocket.Options.SendHighWatermark = this.HighwaterMark;
try
{
publisherSocket.Bind(addressZeroMq);
}
catch (NetMQException ex)
{
// This is usually because the address is in use.
throw new Exception(string.Format("Error E56874. Cannot bind publisher to '{0}'. 95% probability that this is caused by trying to bind a publisher to a port already in use by another process. To fix, choose a unique publisher port for this process. For more on this error, see 'Readme.md' (or the GitHub homepage for NetMQ.ReactiveExtensions).", addressZeroMq), ex);
}
// Corner case: wait until publisher socket is ready (see code below that sets "_publisherReadySignal").
{
Stopwatch sw = Stopwatch.StartNew();
_publisherReadySignal.WaitOne(TimeSpan.FromMilliseconds(3000));
_loggerDelegate?.Invoke(string.Format("Publisher: Waited {0} ms for binding.\n", sw.ElapsedMilliseconds));
}
{
monitor.Accepted -= Publisher_Event_Accepted;
monitor.Listening -= Publisher_Event_Listening;
// Current issue with NegMQ: Cannot stop or dispose monitor, or else it stops the parent socket.
//monitor.Stop();
//monitor.Dispose();
}
}
// Otherwise, the first item we publish may get missed by the subscriber. 500 milliseconds consistently works
// locally, but occasionally fails on the AppVeyor build server. 650 milliseconds is optimal.
using (EventWaitHandle wait = new ManualResetEvent(false))
{
// Cannot use Thread.Sleep() here, as this is incompatible with .NET Core 1.0, Windows 8.0, 8.1, and 10.
wait.WaitOne(TimeSpan.FromMilliseconds(650));
}
return publisherSocket;
}
public void SendOutputMessageToIOPub(Message message, PublisherSocket ioPub, DisplayData data)
{
Dictionary<string,object> content = new Dictionary<string, object>();
content.Add("execution_count", this.executionCount);
content.Add("data", data.Data);
content.Add("metadata", data.MetaData);
Message outputMessage = MessageBuilder.CreateMessage(MessageTypeValues.Output,
JsonSerializer.Serialize(content), message.Header);
this.logger.Info(string.Format("Sending message to IOPub {0}", JsonSerializer.Serialize(outputMessage)));
MessageSender.Send(outputMessage, ioPub);
}
public void HandleMessage(Message message, RouterSocket serverSocket, PublisherSocket ioPub)
{
CompleteRequest completeRequest = JsonSerializer.Deserialize<CompleteRequest>(message.Content);
// TODO: Send reply
}
public void MultipleLargeMessages()
{
var largeMessage = new byte[12000];
for (int i = 0; i < 12000; i++)
{
largeMessage[i] = (byte)(i % 256);
}
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
var port = pub.BindRandomPort("tcp://127.0.0.1");
sub.Connect("tcp://127.0.0.1:" + port);
sub.Subscribe("");
Thread.Sleep(1000);
pub.SendFrame("");
sub.SkipFrame();
for (int i = 0; i < 100; i++)
{
pub.SendFrame(largeMessage);
byte[] recvMesage = sub.ReceiveFrameBytes();
for (int j = 0; j < 12000; j++)
{
Assert.AreEqual(largeMessage[j], recvMesage[j]);
}
}
}
}
/// <summary>
/// Try to send request message and return the response as a message, or return null if not successful
/// </summary>
/// <param name="address">a string denoting the address to connect to</param>
/// <param name="requestMessage">The request message</param>
/// <param name="numTries">The number of times to try</param>
/// <param name="requestTimeout">The timeout for each request</param>
/// <param name="progressPublisher">Report topics: Failure, Retry, Send, Success</param>
/// <returns>the response message, or null if not successful</returns>
public static NetMQMessage RequestResponseMultipartMessageWithRetry(string address, NetMQMessage requestMessage,
int numTries, TimeSpan requestTimeout, PublisherSocket progressPublisher = null)
{
var responseMessage = new NetMQMessage();
while (numTries-- > 0)
{
using (var requestSocket = new RequestSocket(address))
{
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Send.ToString());
}
requestSocket.SendMultipartMessage(requestMessage);
if (requestSocket.TryReceiveMultipartMessage(requestTimeout, ref responseMessage))
{
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Success.ToString());
}
return(responseMessage);
}
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Retry.ToString());
}
}
}
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Failure.ToString());
}
return(null);
}
public void ReceiveMessageWithTimeout()
{
{
var pubSync = new AutoResetEvent(false);
var payload = new byte[300];
const int waitTime = 500;
var t1 = new Task(() =>
{
using (var pubSocket = new PublisherSocket())
{
pubSocket.Bind("tcp://127.0.0.1:12345");
pubSync.WaitOne();
Thread.Sleep(waitTime);
pubSocket.SendFrame(payload);
pubSync.WaitOne();
}
}, TaskCreationOptions.LongRunning);
var t2 = new Task(() =>
{
using (var subSocket = new SubscriberSocket())
{
subSocket.Connect("tcp://127.0.0.1:12345");
subSocket.Subscribe("");
Thread.Sleep(100);
pubSync.Set();
NetMQMessage msg = null;
Assert.IsFalse(subSocket.TryReceiveMultipartMessage(TimeSpan.FromMilliseconds(100), ref msg));
Assert.IsTrue(subSocket.TryReceiveMultipartMessage(TimeSpan.FromMilliseconds(waitTime), ref msg));
Assert.NotNull(msg);
Assert.AreEqual(1, msg.FrameCount);
Assert.AreEqual(300, msg.First.MessageSize);
pubSync.Set();
}
}, TaskCreationOptions.LongRunning);
t1.Start();
t2.Start();
Task.WaitAll(t1, t2);
}
}
/// <summary>
/// Try to send request string and return the response string, or return null if not successful
/// </summary>
/// <param name="address">a string denoting the address to connect to</param>
/// <param name="requestString">The request string</param>
/// <param name="numTries">The number of times to try</param>
/// <param name="requestTimeout">The timeout for each request</param>
/// <param name="progressPublisher">Report topics: Failure, Retry, Send, Success</param>
/// <returns>the response message, or null if not successful</returns>
public static string RequestResponseStringWithRetry(string address, string requestString,
int numTries, TimeSpan requestTimeout, PublisherSocket progressPublisher = null)
{
while (numTries-- > 0)
{
using (var requestSocket = new RequestSocket(address))
{
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Send.ToString());
}
requestSocket.SendFrame(requestString);
string frameString;
if (requestSocket.TryReceiveFrameString(requestTimeout, out frameString))
{
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Success.ToString());
}
return(frameString);
}
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Retry.ToString());
}
}
}
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Failure.ToString());
}
return(null);
}
public void LargeMessage()
{
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
pub.Connect("pgm://224.0.0.1:5555");
sub.Bind("pgm://224.0.0.1:5555");
sub.Subscribe("");
var data = new byte[3200]; // this should be at least 3 packets
for (Int16 i = 0; i < 1600; i++)
Array.Copy(BitConverter.GetBytes(i), 0, data, i*2, 2);
pub.SendFrame(data);
byte[] message = sub.ReceiveFrameBytes();
Assert.AreEqual(3200, message.Length);
for (Int16 i = 0; i < 1600; i++)
Assert.AreEqual(i, BitConverter.ToInt16(message, i*2));
}
}
