private void OnSubscriberMessage(object sender, NetMQSocketEventArgs e)
{
NetMQMessage message = null;
while (_subscriber.TryReceiveMultipartMessage(ref message))
{
// Debug.WriteLine(message);
var topic = message[0].ConvertToString();
if (topic == WelcomeMessage)
{
SubscriberAddress = e.Socket.Options.LastEndpoint;
Debug.WriteLine($"Subsciber Address: {SubscriberAddress}");
_welcomeMessageHandler?.Invoke();
}
else if (topic == HeartbeatMessage)
{
// we got a heartbeat, lets postponed the timer
_timeoutTimer.EnableAndReset();
}
else
{
_shim.SendMultipartMessage(message);
}
}
}
public ZeroMqNotificationReader Init()
{
if (Initialized)
{
throw new InvalidOperationException($"{nameof(ZeroMqNotificationReader)} already initialized.");
}
var completionSource = new TaskCompletionSource <object>();
var token = _source.Token;
_receiveTask = Task.Factory.StartNew(() =>
{
var timeout = TimeSpan.FromSeconds(1);
using (var subSocket = new SubscriberSocket(EndPoint))
{
try
{
subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.SubscribeToAnyTopic();
while (!token.IsCancellationRequested)
{
var zMessage = new NetMQMessage(2);
var messageReceived = subSocket.TryReceiveMultipartMessage(timeout, ref zMessage, 2);
completionSource.TrySetResult(null);
if (!messageReceived)
{
continue;
}
var topic = zMessage.Pop().ConvertToString(Encoding.UTF8);
var json = zMessage.Pop().ConvertToString(Encoding.UTF8);
OnNotificationReceived?.Invoke(topic, json);
}
}
catch (Exception e)
{
OnError?.Invoke(e);
}
}
}, TaskCreationOptions.LongRunning);
_receiveTask.ContinueWith(t =>
{
// Propagate exception from initialization if occured
if (t.Exception != null)
{
completionSource.TrySetException(t.Exception);
}
});
completionSource.Task.GetAwaiter().GetResult();
Initialized = true;
return(this);
}
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);
}
}
protected void startReceiving()
{
elasticServerTimeout = serverTimeout;
done = false;
timer.Start();
lastMessageTS = timer.getElapsedMS();
UnityEngine.Debug.Log("Client: start processing incoming messages");
while (!done)
{
NetMQMessage msg = new NetMQMessage();
//If client receives any message, it means that the client is connected
if (subscriber.TryReceiveMultipartMessage(TimeSpan.FromMilliseconds(1), ref msg, 2))
{
isConnected = true;
lastMessageTS = timer.getElapsedMS();
elasticServerTimeout = serverTimeout;
System.Diagnostics.Debug.Assert(msg.First.Buffer[0] == (byte)'A');
UInt64 signature = messageSignature(msg.First.Buffer[1], msg.First.Buffer[2]);
Action <NetMQMessage> f = null;
try
{
f = messageHandlers[signature];
}
catch (KeyNotFoundException)
{
//UnityEngine.Debug.Log(
// String.Format("Client: key {0} was not present in messageHandlers, module {1}, action {2}",
// signature, msg.First.Buffer[1], msg.First.Buffer[2]));
}
if (f != null)
{
f(msg);
}
}
else
{
float elapsed = (timer.getElapsedMS() - lastMessageTS) * 0.001f;
if (elapsed > elasticServerTimeout)
{
isConnected = false;
UnityEngine.Debug.Log(String.Format("Connection to the server lost for {0} seconds", elapsed));
elasticServerTimeout *= 2;
}
Thread.Sleep(TimeSpan.FromMilliseconds(1));
}
}
UnityEngine.Debug.Log("Client: main-loop ends");
}
public static bool TryReceive(this SubscriberSocket socket, TimeSpan timeOut,
out string topic, out string typeName, out byte[] rawMessage)
{
typeName = null;
rawMessage = null;
topic = null;
var message = new NetMQMessage();
if (socket.TryReceiveMultipartMessage(timeOut, ref message, ExpectedFrameCount))
{
message.ParseFrames(out topic, out typeName, out rawMessage);
return(true);
}
return(false);
}
public bool TryReceive()
{
if (!IsConnected)
{
return(false);
}
//try to receive something from the network... if that succeeds get the distance from the given Erg
var message = new NetMQMessage();
if (subSocket.TryReceiveMultipartMessage(System.TimeSpan.Zero, ref message))
{
foreach (var frame in message.Skip(1)) //the first frame is always just the envelope/topic... let's ignore it by using Linq
{
HandleFrame(frame);
}
return(true);
}
return(false);
}
private void OnMessageReceived(object sender, NetMQSocketEventArgs e)
{
NetMQMessage message = null;
if (!socket.TryReceiveMultipartMessage(ref message, 2))
{
return;
}
// Move handling request off NetMQPoller thread and onto TaskPool as soon as possible
Task.Run(() =>
{
if (!messageFactory.IsValidTopicMessage(message))
{
return;
}
var package = messageFactory.ExtractTopic(message);
topicDispatcher.Handle(this, package);
});
}
private IList <Erg> ReceiveBoats()
{
//try to receive something from the network... return all the ergs we get
var message = new NetMQMessage();
IList <EasyErgsocket.Erg> receivedBoats = new List <EasyErgsocket.Erg>();
while (subSocket.TryReceiveMultipartMessage(System.TimeSpan.Zero, ref message))
{
foreach (var frame in message.Skip(1)) //the first frame is always just the envelope/topic... let's ignore it by using Linq
{
byte[] rawMessage = frame.Buffer;
using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(rawMessage))
{
var givenErg = Serializer.Deserialize <EasyErgsocket.Erg>(memoryStream);
receivedBoats.Add(givenErg);
}
}
}
return(receivedBoats);
}
private void HandleWork()
{
using (_cacheUpdateSocket = new SubscriberSocket())
{
_cacheUpdateSocket.Options.ReceiveHighWatermark = _configuration.ZmqHighWatermark;
_cacheUpdateSocket.Subscribe(_configuration.Subject);
_cacheUpdateSocket.Connect(_configuration.SubscriptionEndpoint);
while (!_cancel.IsCancellationRequested)
{
NetMQMessage message = null;
var hasMessage = _cacheUpdateSocket.TryReceiveMultipartMessage(_configuration.IsStaleTimeout, ref message);
if (_cancel.IsCancellationRequested)
{
return;
}
if (hasMessage)
{
var eventIdBytes = message[1].Buffer;
var eventMessageBytes = message[2].Buffer;
var eventId = _eventSerializer.Serializer.Deserialize <IEventId>(eventIdBytes);
var producerMessage = _eventSerializer.Serializer.Deserialize <IProducerMessage>(eventMessageBytes);
var @event = _eventSerializer.ToEvent <TKey, TAggregate>(eventId, producerMessage);
OnEventReceived(@event);
}
else
{
_state.OnNext(DynamicCacheState.Staled);
}
}
}
}
void NetMQClient()
{
//thanks for Yuta Itoh sample code to connect via NetMQ with Pupil Service
string IPHeader = ">tcp://" + ServerIP + ":";
var timeout = new System.TimeSpan(0, 0, 1); //1sec
// Necessary to handle this NetMQ issue on Unity editor
// https://github.com/zeromq/netmq/issues/526
AsyncIO.ForceDotNet.Force();
NetMQConfig.ManualTerminationTakeOver();
NetMQConfig.ContextCreate(true);
string subport = "";
print("Connect to the server: " + IPHeader + ServicePort + ".");
Thread.Sleep(ServiceStartupDelay);
_requestSocket = new RequestSocket(IPHeader + ServicePort);
_requestSocket.SendFrame("SUB_PORT");
_isconnected = _requestSocket.TryReceiveFrameString(timeout, out subport);
print(_isconnected + " isconnected");
_gazeFps.Reset();
_eyeFps [0].Reset();
_eyeFps [1].Reset();
if (_isconnected)
{
//_serviceStarted = true;
StartProcess();
var subscriberSocket = new SubscriberSocket(IPHeader + subport);
subscriberSocket.Subscribe("gaze"); //subscribe for gaze data
subscriberSocket.Subscribe("notify."); //subscribe for all notifications
_setStatus(EStatus.ProcessingGaze);
var msg = new NetMQMessage();
while (_isDone == false)
{
_isconnected = subscriberSocket.TryReceiveMultipartMessage(timeout, ref (msg));
if (_isconnected)
{
try
{
string msgType = msg[0].ConvertToString();
UnityEngine.Debug.Log(msgType);
if (msgType == "gaze")
{
var message = MsgPack.Unpacking.UnpackObject(msg[1].ToByteArray());
MsgPack.MessagePackObject mmap = message.Value;
lock (_dataLock)
{
_pupilData = JsonUtility.FromJson <Pupil.PupilData3D>(mmap.ToString());
if (_pupilData.confidence > 0.5f)
{
//UnityEngine.Debug.Log(_pupilData.base_data[0].id);
OnPacket(_pupilData);
}
}
}
else if (msgType == "notify.eye_process.started")
{
var message = MsgPack.Unpacking.UnpackObject(msg[1].ToByteArray());
MsgPack.MessagePackObject mmap = message.Value;
var id = JsonUtility.FromJson <Pupil.EyeStatus>(mmap.ToString());
UnityEngine.Debug.Log(id.eye_id);
}
//Debug.Log(message);
}
catch
{
// Debug.Log("Failed to unpack.");
}
}
else
{
print("Failed to receive a message.");
Thread.Sleep(500);
}
}
StopProcess();
subscriberSocket.Close();
}
else
{
print("Failed to connect the server.");
//If needed here could come a retry connection.
}
//Can only send request via IPC if the connection has been established, otherwise we are facing, errors and potential freezing.
if (_serviceStarted && _isconnected)
{
StopService();
}
//Kill process
if (serviceProcess != null)
{
UnityEngine.Debug.Log("Killing Pupil service");
serviceProcess.Kill();
serviceProcess.Close();
}
_requestSocket.Close();
// Necessary to handle this NetMQ issue on Unity editor
// https://github.com/zeromq/netmq/issues/526
print("ContextTerminate.");
NetMQConfig.ContextTerminate();
}
private void StartListeners()
{
var stratumsByUrl = clusterConfig.Pools.Where(x => x.Enabled && x.ExternalStratums?.Any() == true)
.SelectMany(x => x.ExternalStratums)
.Where(x => x.Url != null && x.Topic != null)
.GroupBy(x =>
{
var tmp = x.Url.Trim();
return(!tmp.EndsWith("/") ? tmp : tmp.Substring(0, tmp.Length - 1));
}, x => x.Topic.Trim())
.ToArray();
var serializer = new JsonSerializer
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
foreach (var item in stratumsByUrl)
{
var thread = new Thread(arg =>
{
var urlAndTopic = (IGrouping <string, string>)arg;
var url = urlAndTopic.Key;
var topics = new HashSet <string>(urlAndTopic.Distinct());
var receivedOnce = false;
while (true)
{
try
{
using (var subSocket = new SubscriberSocket())
{
subSocket.Connect(url);
// subscribe to all topics
foreach (var topic in topics)
{
subSocket.Subscribe(topic);
}
logger.Info($"Monitoring external stratum {url}/[{string.Join(", ", topics)}]");
while (true)
{
// receive
var msg = (NetMQMessage)null;
if (!subSocket.TryReceiveMultipartMessage(relayReceiveTimeout, ref msg, 3))
{
if (receivedOnce)
{
logger.Warn(() => $"Timeout receiving message from {url}. Reconnecting ...");
break;
}
// retry
continue;
}
// extract frames
var topic = msg.Pop().ConvertToString(Encoding.UTF8);
var flags = msg.Pop().ConvertToInt32();
var data = msg.Pop().ToByteArray();
receivedOnce = true;
// validate
if (!topics.Contains(topic))
{
logger.Warn(() => $"Received non-matching topic {topic} on ZeroMQ subscriber socket");
continue;
}
if (data?.Length == 0)
{
logger.Warn(() => $"Received empty data from {url}/{topic}");
continue;
}
// deserialize
var wireFormat = (ShareRelay.WireFormat)(flags & ShareRelay.WireFormatMask);
Share share = null;
switch (wireFormat)
{
case ShareRelay.WireFormat.Json:
using (var stream = new MemoryStream(data))
{
using (var reader = new StreamReader(stream, Encoding.UTF8))
{
using (var jreader = new JsonTextReader(reader))
{
share = serializer.Deserialize <Share>(jreader);
}
}
}
break;
case ShareRelay.WireFormat.ProtocolBuffers:
using (var stream = new MemoryStream(data))
{
share = Serializer.Deserialize <Share>(stream);
share.BlockReward = (decimal)share.BlockRewardDouble;
}
break;
default:
logger.Error(() => $"Unsupported wire format {wireFormat} of share received from {url}/{topic} ");
break;
}
if (share == null)
{
logger.Error(() => $"Unable to deserialize share received from {url}/{topic}");
continue;
}
// store
share.PoolId = topic;
share.Created = clock.Now;
messageBus.SendMessage(new ClientShare(null, share));
// update poolstats from shares
if (pools.TryGetValue(topic, out var poolContext))
{
var pool = poolContext.Pool;
poolContext.Logger.Info(() => $"External {(!string.IsNullOrEmpty(share.Source) ? $"[{share.Source.ToUpper()}] " : string.Empty)}share accepted: D={Math.Round(share.Difficulty, 3)}");
if (pool.NetworkStats != null)
{
pool.NetworkStats.BlockHeight = share.BlockHeight;
pool.NetworkStats.NetworkDifficulty = share.NetworkDifficulty;
if (poolContext.BlockHeight != share.BlockHeight)
{
pool.NetworkStats.LastNetworkBlockTime = clock.Now;
poolContext.BlockHeight = share.BlockHeight;
poolContext.LastBlock = clock.Now;
}
else
{
pool.NetworkStats.LastNetworkBlockTime = poolContext.LastBlock;
}
}
}
else
{
logger.Info(() => $"External {(!string.IsNullOrEmpty(share.Source) ? $"[{share.Source.ToUpper()}] " : string.Empty)}share accepted: D={Math.Round(share.Difficulty, 3)}");
}
}
}
}
catch (ObjectDisposedException)
{
logger.Info($"Exiting monitoring thread for external stratum {url}/[{string.Join(", ", topics)}]");
break;
}
catch (Exception ex)
{
logger.Error(ex);
}
}
});
thread.Start(item);
}
if (stratumsByUrl.Any())
{
logger.Info(() => "Online");
}
}
protected IObservable <string> BtStreamSubscribe(ZmqPubSubEndpointConfig config)
{
return(Observable.Defer(() => Observable.Create <string>(obs =>
{
var tcs = new CancellationTokenSource();
Task.Factory.StartNew(() =>
{
using (tcs)
{
while (!tcs.IsCancellationRequested)
{
try
{
using (var subSocket = new SubscriberSocket())
{
//subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect(config.Url);
subSocket.Subscribe(config.Topic);
logger.Debug($"Subscribed to {config.Url}/{config.Topic}");
while (!tcs.IsCancellationRequested)
{
var msg = (NetMQMessage)null;
if (!subSocket.TryReceiveMultipartMessage(btStreamReceiveTimeout, ref msg, 4))
{
logger.Warn(() => $"Timeout receiving message from {config.Url}. Reconnecting ...");
break;
}
// extract frames
var topic = msg.Pop().ConvertToString(Encoding.UTF8);
var flags = msg.Pop().ConvertToInt32();
var data = msg.Pop().ToByteArray();
var timestamp = msg.Pop().ConvertToInt64();
// compressed
if ((flags & 1) == 1)
{
using (var stm = new MemoryStream(data))
{
using (var stmOut = new MemoryStream())
{
using (var ds = new DeflateStream(stm, CompressionMode.Decompress))
{
ds.CopyTo(stmOut);
}
data = stmOut.ToArray();
}
}
}
// convert
var json = Encoding.UTF8.GetString(data);
// publish
obs.OnNext(json);
// telemetry
messageBus.SendMessage(new TelemetryEvent(clusterConfig.ClusterName ?? poolConfig.PoolName, poolConfig.Id,
TelemetryCategory.BtStream, DateTime.UtcNow - DateTimeOffset.FromUnixTimeSeconds(timestamp)));
}
}
}
catch (Exception ex)
{
logger.Error(ex);
}
// do not consume all CPU cycles in case of a long lasting error condition
Thread.Sleep(1000);
}
}
}, tcs.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
return Disposable.Create(() => { tcs.Cancel(); });
}))
.Publish()
.RefCount());
}
async Task <bool> Receive()
{
try
{
NetMQMessage msg = null;
// NOTE:
// After switching to async IO, when we close the socket in Dispose() the ReceiveMultipartMessage() wasn't returning.
// So, we TryReceive() with a timeout. If it times out the receive loop will check if we retry or exit.
// If we get an async-friendly version of NetMQ (or switch transports) we can probably go back to regular Receive().
if (socket.TryReceiveMultipartMessage(ReceiveTimeout, ref msg))
{
if (msg == null || ZeroMQ.PubSubUtil.IsStoppingMessage(msg))
{
PublisherLogger.Info("stopped by stpping message!");
return(false);
}
var topic = msg[0].ConvertToString();
var msgType = msg[1].ConvertToString();
if (MsgHandlers.TryGetValue(msgType, out Delegate mh))
{
var respBytes = msg[2].Buffer;
using (var proto = ThriftUtil.CreateReadProtocol(respBytes))
{
Type t = GeneratedTypeCache.GetType(msgType);
if (t == null)
{
throw new TargetInvocationException(new Exception("can't get type for: " + msgType));
}
TBase ret = Activator.CreateInstance(t) as TBase;
await ret.ReadAsync(proto, cts.Token);
mh.DynamicInvoke(topic, ret);
}
}
return(true);
}
else
{
// Receive timed out. Return true so receive loop can check if we should exit or try again.
return(true);
}
}
catch (Exception e)
{
if (e is TargetInvocationException ee)
{
Log($"invoke exception: {(ee).InnerException.Message} \n {ee.InnerException.StackTrace}", Logging.LogLevel.Warn);
return(true);
}
if (e is TerminatingException)
{
Log($"terminated: {e.Message}", Logging.LogLevel.Info);
return(false);
}
else
{
if (disposing)
{
Log("disposing exception: " + e.Message, Logging.LogLevel.Info);
}
else
{
Log($"receive exception: {e.Message} \n {e.StackTrace}", Logging.LogLevel.Error);
}
return(false);
}
}
}
// Client thread which does not block Update()
void NetMQClient()
{
string IPHeader = ">tcp://" + IP + ":";
var timeout = new System.TimeSpan(0, 0, 1); //1sec
// Necessary to handle this NetMQ issue on Unity editor
// https://github.com/zeromq/netmq/issues/526
AsyncIO.ForceDotNet.Force();
NetMQConfig.ManualTerminationTakeOver();
NetMQConfig.ContextCreate(true);
string subport = "";
Debug.Log("Connect to the server: " + IPHeader + PORT + ".");
var requestSocket = new RequestSocket(IPHeader + PORT);
double t = 0;
const int N = 1000;
bool is_connected = false;
for (int k = 0; k < N; k++)
{
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
requestSocket.SendFrame("SUB_PORT");
is_connected = requestSocket.TryReceiveFrameString(timeout, out subport);
sw.Stop();
t = t + sw.Elapsed.Milliseconds;
//Debug.Log("Round trip time:" + sw.Elapsed + "[sec].");
if (is_connected == false)
{
break;
}
}
Debug.Log("Round trip average time:" + t / N + "[msec].");
requestSocket.Close();
if (is_connected)
{
//
var subscriberSocket = new SubscriberSocket(IPHeader + subport);
subscriberSocket.Subscribe(ID);
var msg = new NetMQMessage();
while (is_connected && stop_thread_ == false)
{
Debug.Log("Receive a multipart message.");
is_connected = subscriberSocket.TryReceiveMultipartMessage(timeout, ref (msg));
if (is_connected)
{
Debug.Log("Unpack a received multipart message.");
try
{
//Debug.Log(msg[0].ConvertToString());
var message = MsgPack.Unpacking.UnpackObject(msg[1].ToByteArray());
MsgPack.MessagePackObject mmap = message.Value;
lock (thisLock_)
{
data_ = JsonUtility.FromJson <Pupil.PupilData3D>(mmap.ToString());
}
//Debug.Log(message);
}
catch
{
Debug.Log("Failed to unpack.");
}
}
else
{
Debug.Log("Failed to receive a message.");
Thread.Sleep(1000);
}
}
subscriberSocket.Close();
}
else
{
Debug.Log("Failed to connect the server.");
}
// Necessary to handle this NetMQ issue on Unity editor
// https://github.com/zeromq/netmq/issues/526
Debug.Log("ContextTerminate.");
NetMQConfig.ContextTerminate();
}
public async Task ShouldHandleIncomingEvent()
{
using (var publisher = new PublisherSocket())
{
publisher.Connect(ToPublishersEndpoint);
using (var subscriber = new SubscriberSocket())
{
subscriber.Connect(ToSubscribersEndpoint);
subscriber.SubscribeToAnyTopic();
var command = new ChangeCcyPairState("EUR/USD", "TEST", CcyPairState.Passive);
var message = _eventSerializer.ToProducerMessage(command);
await Task.Delay(200);
publisher.SendMoreFrame(message.Subject)
.SendFrame(_eventSerializer.Serializer.Serialize(message));
NetMQMessage msg = null;
var hasResponse = subscriber.TryReceiveMultipartMessage(TimeSpan.FromMilliseconds(1000), ref msg);
Assert.IsTrue(hasResponse);
var eventIdBytes = msg[1].Buffer;
var eventMessageBytes = msg[2].Buffer;
var eventId = _eventSerializer.Serializer.Deserialize <EventId>(eventIdBytes);
Assert.AreEqual("EUR/USD", eventId.EventStream);
Assert.AreEqual("EUR/USD.0", eventId.Id);
Assert.AreEqual(0, eventId.Version);
Assert.AreEqual(message.Subject, eventId.Subject);
var producerMessage = _eventSerializer.Serializer.Deserialize <ProducerMessage>(eventMessageBytes);
var @event = _serializer.Deserialize <ChangeCcyPairState>(producerMessage.MessageBytes);
Assert.AreEqual(message.Subject, producerMessage.Subject);
Assert.AreEqual(typeof(ChangeCcyPairState), producerMessage.MessageType);
Assert.AreEqual(command.EventStreamId, @event.EventStreamId);
Assert.AreEqual(command.Market, @event.Market);
Assert.AreEqual(command.State, @event.State);
command = new ChangeCcyPairState("EUR/USD", "TEST", CcyPairState.Active);
message = _eventSerializer.ToProducerMessage(command);
await Task.Delay(200);
publisher.SendMoreFrame(message.Subject)
.SendFrame(_eventSerializer.Serializer.Serialize(message));
await Task.Delay(50);
hasResponse = subscriber.TryReceiveMultipartMessage(TimeSpan.FromMilliseconds(1000), ref msg);
Assert.IsTrue(hasResponse);
eventIdBytes = msg[1].Buffer;
eventMessageBytes = msg[2].Buffer;
eventId = _eventSerializer.Serializer.Deserialize <EventId>(eventIdBytes);
Assert.AreEqual("EUR/USD", eventId.EventStream);
Assert.AreEqual("EUR/USD.1", eventId.Id);
Assert.AreEqual(1, eventId.Version);
Assert.AreEqual(message.Subject, eventId.Subject);
}
}
}
void NetMQClient()
{
//thanks for Yuta Itoh sample code to connect via NetMQ with Pupil Service
string IPHeader = ">tcp://" + ServerIP + ":";
var timeout = new System.TimeSpan(0, 0, 1); //1sec
// Necessary to handle this NetMQ issue on Unity editor
// https://github.com/zeromq/netmq/issues/526
AsyncIO.ForceDotNet.Force();
NetMQConfig.ManualTerminationTakeOver();
NetMQConfig.ContextCreate(true);
string subport = "";
Debug.Log("Connect to the server: " + IPHeader + ServicePort + ".");
_requestSocket = new RequestSocket(IPHeader + ServicePort);
_requestSocket.SendFrame("SUB_PORT");
_isconnected = _requestSocket.TryReceiveFrameString(timeout, out subport);
_lastT = DateTime.Now;
if (_isconnected)
{
StartProcess();
var subscriberSocket = new SubscriberSocket(IPHeader + subport);
subscriberSocket.Subscribe("gaze"); //subscribe for gaze data
subscriberSocket.Subscribe("notify."); //subscribe for all notifications
_setStatus(EStatus.ProcessingGaze);
var msg = new NetMQMessage();
while (_isDone == false)
{
_isconnected = subscriberSocket.TryReceiveMultipartMessage(timeout, ref (msg));
if (_isconnected)
{
try
{
string msgType = msg[0].ConvertToString();
//Debug.Log(msgType);
if (msgType == "gaze")
{
var message = MsgPack.Unpacking.UnpackObject(msg[1].ToByteArray());
MsgPack.MessagePackObject mmap = message.Value;
lock (_dataLock)
{
_pupilData = JsonUtility.FromJson <Pupil.PupilData3D>(mmap.ToString());
if (_pupilData.confidence > 0.5f)
{
OnPacket(_pupilData);
}
}
}
//Debug.Log(message);
}
catch
{
// Debug.Log("Failed to unpack.");
}
}
else
{
// Debug.Log("Failed to receive a message.");
Thread.Sleep(500);
}
}
StopProcess();
subscriberSocket.Close();
}
else
{
Debug.Log("Failed to connect the server.");
}
_requestSocket.Close();
// Necessary to handle this NetMQ issue on Unity editor
// https://github.com/zeromq/netmq/issues/526
Debug.Log("ContextTerminate.");
NetMQConfig.ContextTerminate();
}
private void SetupFakeBroker(
CancellationToken cancel,
IEventCache eventCache,
bool useHeartbeat = true,
bool useEventLoop = true,
bool useStateOfTheWorld = true)
{
if (useHeartbeat)
{
//heartbeat
Task.Run(() =>
{
using (var heartbeatSocket = new ResponseSocket(HeartbeatEndpoint))
{
while (!cancel.IsCancellationRequested)
{
var hasResponse = heartbeatSocket.TryReceiveFrameBytes(TimeSpan.FromSeconds(1), out var messageBytes);
if (hasResponse)
{
heartbeatSocket.SendFrame(_serializer.Serialize(Heartbeat.Response));
}
}
}
}, cancel);
}
if (useEventLoop)
{
//event loop
Task.Run(async() =>
{
using (var stateUpdate = new SubscriberSocket())
{
stateUpdate.SubscribeToAnyTopic();
stateUpdate.Bind(ToPublishersEndpoint);
while (!cancel.IsCancellationRequested)
{
NetMQMessage message = null;
var hasResponse = stateUpdate.TryReceiveMultipartMessage(TimeSpan.FromSeconds(1), ref message);
if (hasResponse)
{
var subject = message[0];
var payload = message[1];
await eventCache.AppendToStream(subject.Buffer, payload.Buffer);
}
}
}
}, cancel);
}
if (useStateOfTheWorld)
{
//stateOfTheWorld
Task.Run(async() =>
{
using (var stateRequestSocket = new RouterSocket())
{
stateRequestSocket.Bind(StateOfTheWorldEndpoint);
while (!cancel.IsCancellationRequested)
{
NetMQMessage message = null;
var hasResponse = stateRequestSocket.TryReceiveMultipartMessage(TimeSpan.FromSeconds(1), ref message);
if (hasResponse)
{
var sender = message[0].Buffer;
var request = _serializer.Deserialize <StateRequest>(message[1].Buffer);
var stream = await eventCache.GetStreamBySubject(request.Subject);
var response = new StateReply()
{
Subject = request.Subject,
Events = stream.ToList()
};
stateRequestSocket.SendMoreFrame(sender)
.SendFrame(_serializer.Serialize(response));
}
}
}
}, cancel);
}
}
private void receiveMessagesAsync(object sender, DoWorkEventArgs e)
{
Debug.Log("ZMQReceiver starting async worker");
// need to create ZMQ socket in thread that is going to use it
if (m_socket == null)
{
AsyncIO.ForceDotNet.Force();
m_socket = new SubscriberSocket();
m_socket.Connect(m_address);
Debug.Log("ZMQReceiver socket init ok");
}
const int messagePartsCount = 2;
while (!m_workerThread.CancellationPending)
{
while (m_pendingReceivePackets.Count > 0)
{
ReceivePacket recv = null;
if (m_pendingReceivePackets.TryDequeue(out recv))
{
if (recv == null)
{
continue;
}
if (recv.messageCallback == null)
{
Debug.LogError("ZMQReceiver: Object '" + recv.objectName + "' registered null Action<> callback. Ignoring this subscription.");
continue;
}
//recv.objectName;
m_socket.Subscribe(recv.subscriptionName);
m_receivePackets.Add(recv);
}
}
NetMQMessage multipartMessage = new NetMQMessage(messagePartsCount);
var hasMessage = m_socket.TryReceiveMultipartMessage(TimeSpan.FromMilliseconds(100), ref multipartMessage, messagePartsCount);
if (multipartMessage.IsEmpty)
{
log("ZMQReceiver: failed to receive message");
continue;
}
string address = multipartMessage[0].ConvertToString();
string message = multipartMessage[1].ConvertToString();
m_receivedValues.AddOrUpdate(address, message, (key, oldValue) => message);
log("ZMQReceiver: " + address + " / " + message);
}
m_socket.Disconnect(m_address);
m_socket.Dispose();
m_socket = null;
e.Cancel = true;
Debug.Log("ZMQReceiver: async thread finished");
}
