private static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: remote_thr <connect-to> <message-size> <message-count>");
return 1;
}
string connectTo = args[0];
int messageSize = int.Parse(args[1]);
int messageCount = int.Parse(args[2]);
using (var context = NetMQContext.Create())
using (var push = context.CreatePushSocket())
{
push.Connect(connectTo);
for (int i = 0; i != messageCount; i++)
{
var msg = new Msg();
msg.InitPool(messageSize);
push.Send(ref msg, SendReceiveOptions.None);
msg.Close();
}
}
return 0;
}
public bool sendAndReceive(ref NetMQMessage req_msg, ref NetMQ.Msg resp_msg)
{
if (socket == null)
{
reconnect();
}
bool ok = false;
NetMQMessage copy = new NetMQMessage(req_msg);
socket.SendMultipartMessage(copy);
// receive
if (socket.TryReceive(ref resp_msg, timeout))
{
ok = true;
//UnityEngine.Debug.Log("ReliableExternalClient: response received "
// + new StdMessage(resp_msg.Data[1], resp_msg.Data[2]).to_string());
}
copy.Clear();
socket.Dispose();
socket.Close();
socket = null;
if (socket == null)
{
UnityEngine.Debug.Log("ReliableExternalClient: socket closed and null");
}
return(ok);
}
/// <summary>
/// Transmit a byte-array of data over this socket, block until frame is sent.
/// </summary>
/// <param name="socket">the IOutgoingSocket to transmit on</param>
/// <param name="data">the byte-array of data to send</param>
/// <param name="length">the number of bytes to send from <paramref name="data"/>.</param>
/// <param name="more">set this flag to true to signal that you will be immediately sending another frame (optional: default is false)</param>
public static void SendFrame( this IOutgoingSocket socket, byte[] data, int length, bool more = false)
{
var msg = new Msg();
msg.InitPool(length);
Buffer.BlockCopy(data, 0, msg.Data, msg.Offset, length);
socket.Send(ref msg, more);
msg.Close();
}
public bool sendAndReceive(ref NetMQ.Msg req_msg, ref NetMQ.Msg resp_msg)
{
if (socket == null)
{
reconnect();
}
StdMessage m = new StdMessage(req_msg.Data[1], req_msg.Data[2]);
NetMQ.Msg copy = new NetMQ.Msg();
bool ok = false;
for (uint i = 0; i < retries; i++)
{
copy.Copy(ref req_msg);
// send
if (!socket.TrySend(ref copy, TimeSpan.FromMilliseconds(min_trysend_ms), false))
{
ok = false;
UnityEngine.Debug.Log("ReliableExternalClient: could not send");
break;
//TODO: clear enqueued messages when server is offline
}
//UnityEngine.Debug.Log("ReliableExternalClient: request sent " + m.to_string());
// receive
if (socket.TryReceive(ref resp_msg, timeout))
{
ok = true;
// UnityEngine.Debug.Log("ReliableExternalClient: response received "
//+ new StdMessage(resp_msg.Data[1], resp_msg.Data[2]).to_string());
break;
}
//UnityEngine.Debug.Log(String.Format("ReliableExternalClient: no response from server {0}. Retrying", srvAddress));
reconnect();
}
if (!ok)
{
UnityEngine.Debug.Log(String.Format("ReliableExternalClient: server {0} seems to be offline. Abandoning", srvAddress));
}
copy.Close();
socket.Dispose(); //call Dispose on all sockets before cleanup the netmq context
socket.Close();
socket = null;
if (socket == null)
{
UnityEngine.Debug.Log("ReliableExternalClient: socket closed and null");
}
return(ok);
}
public void Register()
{
NetMQ.Msg msg = new NetMQ.Msg();
msg.InitGC(new byte[] { 1 }, 1);
_socket.TrySend(ref msg, TimeSpan.FromMilliseconds(100), false);
_state = MachineState.Registered;
#if DEBUG
//GetProgramData();
#endif
}
public void Heartbeat()
{
if (DateTime.Now - _lastHeart > TimeSpan.FromMilliseconds(100))
{
NetMQ.Msg msg = new NetMQ.Msg();
msg.InitGC(new byte[] { 2 }, 1);
_socket.TrySend(ref msg, TimeSpan.FromMilliseconds(100), false);
_lastHeart = DateTime.Now;
}
}
private void Awake()
{
_msg = new NetMQ.Msg();
cameraRig = GetComponent <AirVRCameraRig>();
_foveatedRenderer = GetComponent <OCSVRWorksCameraRig>();
liveMotionProvider = new MPPLiveMotionDataProvider();
predictedMotionProvider = new AirXRPredictedMotionProvider(this, liveMotionProvider);
gameEventEmitter = new AirXRGameEventEmitter(cameraRig);
}
public static void Send([NotNull] this IOutgoingSocket socket, [NotNull] byte[] data, int length, SendReceiveOptions options)
{
var msg = new Msg();
msg.InitPool(length);
Buffer.BlockCopy(data, 0, msg.Data, 0, length);
socket.Send(ref msg, options);
msg.Close();
}
public NetMQ.Msg to_Msg()
{
NetMQ.Msg msg = new NetMQ.Msg();
byte[] msg_bytes = new byte[3] {
airt, module, action
};
msg.InitPool(msg_bytes.Length); // num of bytes
msg.Put(msg_bytes, 0, msg_bytes.Length);
return(msg);
}
public void Connect(string endpoint)
{
if (_owner.bypassPrediction || _zmqPredictedMotion != null)
{
return;
}
_zmqPredictedMotion = new PullSocket();
_zmqPredictedMotion.Connect(endpoint);
_msgRecv = new NetMQ.Msg();
_msgRecv.InitPool(8 + 4 * 4);
}
private static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: local_thr <bind-to> <message-size> <message-count>");
return 1;
}
string bindTo = args[0];
int messageSize = int.Parse(args[1]);
int messageCount = int.Parse(args[2]);
using (var context = NetMQContext.Create())
using (var pullSocket = context.CreatePullSocket())
{
pullSocket.Bind(bindTo);
var msg = new Msg();
msg.InitEmpty();
pullSocket.Receive(ref msg);
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i != messageCount - 1; i++)
{
pullSocket.Receive(ref msg);
if (msg.Size != messageSize)
{
Console.WriteLine("message of incorrect size received. Received: " + msg.Size + " Expected: " + messageSize);
return -1;
}
}
stopWatch.Stop();
var millisecondsElapsed = stopWatch.ElapsedMilliseconds;
if (millisecondsElapsed == 0)
millisecondsElapsed = 1;
msg.Close();
double messagesPerSecond = (double)messageCount/millisecondsElapsed*1000;
double megabits = messagesPerSecond*messageSize*8/1000000;
Console.WriteLine("message size: {0} [B]", messageSize);
Console.WriteLine("message count: {0}", messageCount);
Console.WriteLine("mean throughput: {0:0.000} [msg/s]", messagesPerSecond);
Console.WriteLine("mean throughput: {0:0.000} [Mb/s]", megabits);
}
return 0;
}
public static byte[] ReceiveFrameBytes([NotNull] this IReceivingSocket socket, out bool more)
{
var msg = new Msg();
msg.InitEmpty();
socket.Receive(ref msg);
var data = msg.CloneData();
more = msg.HasMore;
msg.Close();
return data;
}
private static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: remote_lat remote_lat <connect-to> <message-size> <roundtrip-count>");
return 1;
}
string connectTo = args[0];
int messageSize = int.Parse(args[1]);
int roundtripCount = int.Parse(args[2]);
using (var context = NetMQContext.Create())
using (var req = context.CreateRequestSocket())
{
req.Connect(connectTo);
var msg = new Msg();
msg.InitPool(messageSize);
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i != roundtripCount; i++)
{
req.Send(ref msg, SendReceiveOptions.None);
req.Receive(ref msg);
if (msg.Size != messageSize)
{
Console.WriteLine("message of incorrect size received. Received: {0} Expected: {1}", msg.Size, messageSize);
return -1;
}
}
stopWatch.Stop();
msg.Close();
double elapsedMicroseconds = stopWatch.ElapsedTicks*1000000L/Stopwatch.Frequency;
double latency = elapsedMicroseconds/(roundtripCount*2);
Console.WriteLine("message size: {0} [B]", messageSize);
Console.WriteLine("roundtrip count: {0}", roundtripCount);
Console.WriteLine("average latency: {0:0.000} [µs]", latency);
}
return 0;
}
public override void OnRegistered(byte inDeviceID, string arguments)
{
base.OnRegistered(inDeviceID, arguments);
Arguments args = JsonUtility.FromJson <Arguments>(arguments);
Debug.Assert(string.IsNullOrEmpty(args.PredictedMotionOutputEndpoint) == false);
Debug.Assert(_zmqPredictedMotion == null);
_zmqPredictedMotion = new PullSocket();
_zmqPredictedMotion.Connect(args.PredictedMotionOutputEndpoint);
_msgRecv = new NetMQ.Msg();
_msgRecv.InitPool(8 + 4 * 4);
}
/// <summary>
/// Transmit a string over this socket, block until frame is sent.
/// </summary>
/// <param name="socket">the IOutgoingSocket to transmit on</param>
/// <param name="message">the string to send</param>
/// <param name="more">set this flag to true to signal that you will be immediately sending another frame (optional: default is false)</param>
public static void SendFrame([NotNull] this IOutgoingSocket socket, [NotNull] string message, bool more = false)
{
var msg = new Msg();
// Count the number of bytes required to encode the string.
// Note that non-ASCII strings may not have an equal number of characters
// and bytes. The encoding must be queried for this answer.
// With this number, request a buffer from the pool.
msg.InitPool(SendReceiveConstants.DefaultEncoding.GetByteCount(message));
// Encode the string into the buffer
SendReceiveConstants.DefaultEncoding.GetBytes(message, 0, message.Length, msg.Data, 0);
socket.Send(ref msg, more);
msg.Close();
}
private static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: local_lat <bind-to> <message-size> <roundtrip-count>");
return 1;
}
string bindTo = args[0];
int messageSize = int.Parse(args[1]);
int roundtripCount = int.Parse(args[2]);
using (var context = NetMQContext.Create())
using (var rep = context.CreateResponseSocket())
{
rep.Bind(bindTo);
var msg = new Msg();
msg.InitEmpty();
for (int i = 0; i != roundtripCount; i++)
{
rep.Receive(ref msg);
if (msg.Size != messageSize)
{
Console.WriteLine("message of incorrect size received. Received: " + msg.Size + " Expected: " + messageSize);
return -1;
}
rep.Send(ref msg, SendReceiveOptions.None);
}
msg.Close();
}
return 0;
}
/// <summary>
/// Attempt to transmit a single frame on <paramref cref="socket"/>.
/// If message cannot be sent within <paramref name="timeout"/>, return <c>false</c>.
/// </summary>
/// <param name="socket">the IOutgoingSocket to transmit on</param>
/// <param name="timeout">The maximum period of time to try to send a message.</param>
/// <param name="data">the byte-array of data to send</param>
/// <param name="length">the number of bytes to send from <paramref name="data"/>.</param>
/// <param name="more">set this flag to true to signal that you will be immediately sending another frame (optional: default is false)</param>
/// <returns><c>true</c> if a message was available, otherwise <c>false</c>.</returns>
public static bool TrySendFrame([NotNull] this IOutgoingSocket socket, TimeSpan timeout, [NotNull] byte[] data, int length, bool more = false)
{
var msg = new Msg();
msg.InitPool(length);
Buffer.BlockCopy(data, 0, msg.Data, 0, length);
if (!socket.TrySend(ref msg, timeout, more))
{
msg.Close();
return false;
}
msg.Close();
return true;
}
/// <summary>
/// Attempt to receive all frames of the next message from <paramref cref="socket"/>, and decode them as strings using <paramref name="encoding"/>.
/// If no message is available within <paramref name="timeout"/>, return <c>false</c>.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
/// <param name="timeout">The maximum period of time to wait for a message to become available.</param>
/// <param name="encoding">The encoding used to convert the frame's data to a string.</param>
/// <param name="frames">The frames of the received message as strings. Untouched if no message was available.</param>
/// <param name="expectedFrameCount">Specifies the initial capacity of the <see cref="List{T}"/> used
/// to buffer results. If the number of frames is known, set it here. If more frames arrive than expected,
/// an extra allocation will occur, but the result will still be correct.</param>
/// <returns><c>true</c> if a message was available, otherwise <c>false</c>.</returns>
public static bool TryReceiveMultipartStrings([NotNull] this IReceivingSocket socket, TimeSpan timeout, [NotNull] Encoding encoding, [CanBeNull] ref List<string> frames, int expectedFrameCount = 4)
{
var msg = new Msg();
msg.InitEmpty();
// Try to read the first frame
if (!socket.TryReceive(ref msg, timeout))
{
msg.Close();
return false;
}
// We have one, so prepare the container
if (frames == null)
frames = new List<string>(expectedFrameCount);
else
frames.Clear();
// Add the frame
frames.Add(encoding.GetString(msg.Data, msg.Offset, msg.Size));
// Rinse and repeat...
while (msg.HasMore)
{
socket.Receive(ref msg);
frames.Add(encoding.GetString(msg.Data, msg.Offset, msg.Size));
}
msg.Close();
return true;
}
/// <summary>
/// Block until the message can be sent.
/// </summary>
/// <remarks>
/// The call blocks until the message can be sent and cannot be interrupted.
/// Whether the message can be sent depends on the socket type.
/// </remarks>
/// <param name="socket">The socket to send the message on.</param>
/// <param name="msg">An object with message's data to send.</param>
/// <param name="more">Indicate if another frame is expected after this frame</param>
public static void Send(this IOutgoingSocket socket, ref Msg msg, bool more)
{
var result = socket.TrySend(ref msg, SendReceiveConstants.InfiniteTimeout, more);
Debug.Assert(result);
}
/// <summary>
/// Attempt to receive a single frame from <paramref cref="socket"/>, and decode as a string using <paramref name="encoding"/>.
/// If no message is available within <paramref name="timeout"/>, return <c>false</c>.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
/// <param name="timeout">The maximum period of time to wait for a message to become available.</param>
/// <param name="encoding">The encoding used to convert the frame's data to a string.</param>
/// <param name="frameString">The content of the received message frame as a string, or <c>null</c> if no message was available.</param>
/// <param name="more"><c>true</c> if another frame of the same message follows, otherwise <c>false</c>.</param>
/// <returns><c>true</c> if a message was available, otherwise <c>false</c>.</returns>
public static bool TryReceiveFrameString([NotNull] this IReceivingSocket socket, TimeSpan timeout, [NotNull] Encoding encoding, out string frameString, out bool more)
{
var msg = new Msg();
msg.InitEmpty();
if (socket.TryReceive(ref msg, timeout))
{
more = msg.HasMore;
frameString = msg.Size > 0
? encoding.GetString(msg.Data, msg.Offset, msg.Size)
: string.Empty;
msg.Close();
return true;
}
frameString = null;
more = false;
msg.Close();
return false;
}
/// <summary>
/// Block until the next message arrives, then make the message's data available via <paramref name="msg"/>.
/// </summary>
/// <remarks>
/// The call blocks until the next message arrives, and cannot be interrupted. This a convenient and safe when
/// you know a message is available, such as for code within a <see cref="NetMQSocket.ReceiveReady"/> callback.
/// </remarks>
/// <param name="socket">The socket to receive from.</param>
/// <param name="msg">An object to receive the message's data into.</param>
public static void Receive(this IReceivingSocket socket, ref Msg msg)
{
var result = socket.TryReceive(ref msg, SendReceiveConstants.InfiniteTimeout);
Debug.Assert(result);
}
/// <summary>
/// Receive all frames of the next message from <paramref cref="socket"/>, blocking until a message arrives.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
/// <param name="frames">Reference to a list for return values. If <c>null</c> a new instance will be assigned, otherwise the provided list will be cleared and populated.</param>
/// <param name="expectedFrameCount">Optional initial <see cref="List{T}.Capacity"/> for the returned <see cref="List{T}"/>.</param>
public static void ReceiveMultipartBytes([NotNull] this IReceivingSocket socket, ref List<byte[]> frames, int expectedFrameCount = 4)
{
if (frames == null)
frames = new List<byte[]>(expectedFrameCount);
else
frames.Clear();
var msg = new Msg();
msg.InitEmpty();
do
{
socket.Receive(ref msg);
frames.Add(msg.CloneData());
}
while (msg.HasMore);
msg.Close();
}
/// <summary>
/// Attempt to receive all frames of the next message from <paramref cref="socket"/>, then ignore their contents.
/// If no message is available within <paramref name="timeout"/>, return <c>false</c>.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
/// <param name="timeout">The maximum period of time to wait for a message to become available.</param>
/// <returns><c>true</c> if a frame was received and ignored, otherwise <c>false</c>.</returns>
public static bool TrySkipMultipartMessage([NotNull] this IReceivingSocket socket, TimeSpan timeout)
{
var msg = new Msg();
msg.InitEmpty();
// Try to read the first frame
if (!socket.TryReceive(ref msg, timeout))
{
msg.Close();
return false;
}
// Rinse and repeat...
while (msg.HasMore)
{
socket.Receive(ref msg);
}
msg.Close();
return true;
}
// utils
public static bool isStdNotification(ref NetMQ.Msg m)
{
return(m.Data[0] == (byte)'A' && m.Data[1] == (byte)Modules.STD_NOTIFICATIONS_MODULE);
}
public static byte getMessageAirtSignature(ref NetMQ.Msg m)
{
return(m.Data[0]);
}
public static byte getMessageModule(ref NetMQ.Msg m)
{
return((byte)(m.Data[1] & 0x7F));
}
public static byte getMessageAction(ref NetMQ.Msg m)
{
return(m.Data[2]);
}
// constructor
public StdMessage(ref NetMQ.Msg m)
: base(m.Data[1], m.Data[2])
{
}
/// <summary>
/// Transmit a status-signal over this socket.
/// </summary>
/// <param name="socket">the IOutgoingSocket to transmit on</param>
/// <param name="status">a byte that contains the status signal to send</param>
private static void Signal([NotNull] this IOutgoingSocket socket, byte status)
{
long signalValue = 0x7766554433221100L + status;
Msg msg = new Msg();
msg.InitPool(8);
NetworkOrderBitsConverter.PutInt64(signalValue, msg.Data);
socket.Send(ref msg, false);
msg.Close();
}
/// <summary>
/// Attempt to receive all frames of the next message from <paramref cref="socket"/>, then ignore their contents.
/// If no message is immediately available, return <c>false</c>.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
/// <returns><c>true</c> if a frame was received and ignored, otherwise <c>false</c>.</returns>
public static bool TrySkipMultipartMessage([NotNull] this IReceivingSocket socket)
{
var msg = new Msg();
msg.InitEmpty();
var received = socket.TryReceive(ref msg, TimeSpan.Zero);
msg.Close();
return received;
}
/// <summary>
/// Send a message if one is available within <paramref name="timeout"/>.
/// </summary>
/// <param name="msg">An object with message's data to send.</param>
/// <param name="timeout">The maximum length of time to try and send a message. If <see cref="TimeSpan.Zero"/>, no
/// wait occurs.</param>
/// <param name="more">Indicate if another frame is expected after this frame</param>
/// <returns><c>true</c> if a message was sent, otherwise <c>false</c>.</returns>
public virtual bool TrySend(ref Msg msg, TimeSpan timeout, bool more)
{
return(m_socketHandle.TrySend(ref msg, timeout, more));
}
public static byte[] Receive([NotNull] this IReceivingSocket socket, SendReceiveOptions options, out bool hasMore)
{
var msg = new Msg();
msg.InitEmpty();
socket.Receive(ref msg, options);
var data = msg.CloneData();
hasMore = msg.HasMore;
msg.Close();
return data;
}
/// <summary>
/// Receive a single frame from <paramref cref="socket"/>, blocking until one arrives, then ignore its content.
/// Indicate whether further frames exist via <paramref name="more"/>.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
/// <param name="more"><c>true</c> if another frame of the same message follows, otherwise <c>false</c>.</param>
public static void SkipFrame([NotNull] this IReceivingSocket socket, out bool more)
{
var msg = new Msg();
msg.InitEmpty();
socket.Receive(ref msg);
more = msg.HasMore;
msg.Close();
}
/// <summary>
/// Attempt to receive all frames of the next message from <paramref cref="socket"/>.
/// If no message is available within <paramref name="timeout"/>, return <c>false</c>.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
/// <param name="timeout">The maximum period of time to wait for a message to become available.</param>
/// <param name="frames">Reference to a list for return values. If <c>null</c> a new instance will be assigned, otherwise the provided list will be cleared and populated.</param>
/// <param name="expectedFrameCount">Optional initial <see cref="List{T}.Capacity"/> for the returned <see cref="List{T}"/>.</param>
public static bool TryReceiveMultipartBytes([NotNull] this IReceivingSocket socket, TimeSpan timeout, ref List<byte[]> frames, int expectedFrameCount = 4)
{
var msg = new Msg();
msg.InitEmpty();
// Try to read the first frame
if (!socket.TryReceive(ref msg, timeout))
{
msg.Close();
return false;
}
// We have one, so prepare the container
if (frames == null)
frames = new List<byte[]>(expectedFrameCount);
else
frames.Clear();
// Add the frame
frames.Add(msg.CloneData());
// Rinse and repeat...
while (msg.HasMore)
{
socket.Receive(ref msg);
frames.Add(msg.CloneData());
}
msg.Close();
return true;
}
/// <summary>
/// Attempt to receive a single frame from <paramref cref="socket"/>.
/// If no message is available within <paramref name="timeout"/>, return <c>false</c>.
/// Indicate whether further frames exist via <paramref name="more"/>.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
/// <param name="more"><c>true</c> if another frame of the same message follows, otherwise <c>false</c>.</param>
/// <param name="timeout">The maximum period of time to wait for a message to become available.</param>
/// <param name="bytes">The content of the received message frame, or <c>null</c> if no message was available.</param>
/// <returns><c>true</c> if a message was available, otherwise <c>false</c>.</returns>
public static bool TryReceiveFrameBytes([NotNull] this IReceivingSocket socket, TimeSpan timeout, out byte[] bytes, out bool more)
{
var msg = new Msg();
msg.InitEmpty();
if (!socket.TryReceive(ref msg, timeout))
{
msg.Close();
bytes = null;
more = false;
return false;
}
bytes = msg.CloneData();
more = msg.HasMore;
msg.Close();
return true;
}
public static string ReceiveFrameString([NotNull] this IReceivingSocket socket, [NotNull] Encoding encoding, out bool more)
{
var msg = new Msg();
msg.InitEmpty();
socket.Receive(ref msg);
more = msg.HasMore;
var str = msg.Size > 0
? encoding.GetString(msg.Data, msg.Offset, msg.Size)
: string.Empty;
msg.Close();
return str;
}
/// <summary>
/// Attempt to receive a single frame from <paramref cref="socket"/>, then ignore its content.
/// If no message is immediately available, return <c>false</c>.
/// Indicate whether further frames exist via <paramref name="more"/>.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
/// <param name="more"><c>true</c> if another frame of the same message follows, otherwise <c>false</c>.</param>
/// <returns><c>true</c> if a frame was received and ignored, otherwise <c>false</c>.</returns>
public static bool TrySkipFrame([NotNull] this IReceivingSocket socket, out bool more)
{
var msg = new Msg();
msg.InitEmpty();
var result = socket.TryReceive(ref msg, TimeSpan.Zero);
more = msg.HasMore;
msg.Close();
return result;
}
public static string ReceiveString([NotNull] this IReceivingSocket socket, [NotNull] Encoding encoding, SendReceiveOptions options, out bool hasMore)
{
if (encoding == null)
throw new ArgumentNullException("encoding");
var msg = new Msg();
msg.InitEmpty();
socket.Receive(ref msg, options);
hasMore = msg.HasMore;
string data = msg.Size > 0
? encoding.GetString(msg.Data, msg.Offset, msg.Size)
: string.Empty;
msg.Close();
return data;
}
/// <summary>
/// Attempt to receive a single frame from <paramref cref="socket"/>, then ignore its content.
/// If no message is available within <paramref name="timeout"/>, return <c>false</c>.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
/// <param name="timeout">The maximum period of time to wait for a message to become available.</param>
/// <returns><c>true</c> if a frame was received and ignored, otherwise <c>false</c>.</returns>
public static bool TrySkipFrame([NotNull] this IReceivingSocket socket, TimeSpan timeout)
{
var msg = new Msg();
msg.InitEmpty();
var received = socket.TryReceive(ref msg, timeout);
msg.Close();
return received;
}
public static List<string> ReceiveMultipartStrings([NotNull] this IReceivingSocket socket, [NotNull] Encoding encoding, int expectedFrameCount = 4)
{
var frames = new List<string>(expectedFrameCount);
var msg = new Msg();
msg.InitEmpty();
do
{
socket.Receive(ref msg);
frames.Add(encoding.GetString(msg.Data, msg.Offset, msg.Size));
}
while (msg.HasMore);
msg.Close();
return frames;
}
/// <summary>
/// Attempt to receive a single frame from <paramref cref="socket"/>, then ignore its content.
/// If no message is available within <paramref name="timeout"/>, return <c>false</c>.
/// Indicate whether further frames exist via <paramref name="more"/>.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
/// <param name="timeout">The maximum period of time to wait for a message to become available.</param>
/// <param name="more"><c>true</c> if another frame of the same message follows, otherwise <c>false</c>.</param>
/// <returns><c>true</c> if a frame was received and ignored, otherwise <c>false</c>.</returns>
public static bool TrySkipFrame([NotNull] this IReceivingSocket socket, TimeSpan timeout, out bool more)
{
var msg = new Msg();
msg.InitEmpty();
if (!socket.TryReceive(ref msg, timeout))
{
more = false;
msg.Close();
return false;
}
more = msg.HasMore;
msg.Close();
return true;
}
/// <summary>
/// Block until the message is can be sent.
/// </summary>
/// <remarks>
/// The call blocks until the message can be sent and cannot be interrupted.
/// Wether the message can be sent depends on the socket type.
/// </remarks>
/// <param name="socket">The socket to send the message on.</param>
/// <param name="msg">An object with message's data to send.</param>
/// <param name="more">Indicate if another frame is expected after this frame</param>
public static void Send(this IOutgoingSocket socket, ref Msg msg, bool more)
{
var result = socket.TrySend(ref msg, SendReceiveConstants.InfiniteTimeout, more);
Debug.Assert(result);
}
/// <summary>
/// Receive all frames of the next message from <paramref cref="socket"/>, blocking until a message arrives, then ignore their contents.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
public static void SkipMultipartMessage([NotNull] this IReceivingSocket socket)
{
var msg = new Msg();
msg.InitEmpty();
do
{
socket.Receive(ref msg);
}
while (msg.HasMore);
msg.Close();
}
/// <summary>
/// Receive a single frame from <paramref cref="socket"/>, blocking until one arrives, then ignore its content.
/// </summary>
/// <param name="socket">The socket to receive from.</param>
public static void SkipFrame([NotNull] this IReceivingSocket socket)
{
var msg = new Msg();
msg.InitEmpty();
socket.Receive(ref msg);
msg.Close();
}
public void MessagePoll()
{
NetMQ.Msg msg = new NetMQ.Msg();
msg.InitEmpty();
if (_socket.TryReceive(ref msg, TimeSpan.FromMilliseconds(1)))
{
switch ((MessageType)msg.Data[0])
{
case MessageType.Heartbeat: //heartbeat
break;
case MessageType.Debug: // debug
if (_socket.TryReceive(ref msg, TimeSpan.FromMilliseconds(1)))
{
string text = System.Text.Encoding.ASCII.GetString(msg.Data);
if (text == "{}")
{
break;
}
JObject jo = (JObject)JsonConvert.DeserializeObject(text);
var type = jo["type"].Value <string>();
if (type == "get-program")
{
GameState.Program = DreyProgram.FromJson(jo);
DataArrived?.Invoke(new GetProgramEventArgs()
{
Program = GameState.Program
});
}
else if (type == "announce")
{
var deserialized = JsonConvert.DeserializeObject <GameState>(text, new ObjectTypeDeserializer());
GameState.Announce(deserialized);
DataArrived?.Invoke(new AnnounceEventArgs()
{
State = GameState
});
}
else if (type == "set-breakpoint")
{
var address = jo["address"].Value <int>();
GameState.Breakpoints.Add(address);
DataArrived?.Invoke(new BreakPointEventArgs()
{
Address = address, Set = true
});
}
else if (type == "clear-breakpoint")
{
var address = jo["address"].Value <int>();
GameState.Breakpoints.Remove(address);
DataArrived?.Invoke(new BreakPointEventArgs()
{
Address = address, Set = false
});
}
else if (type == "debug-msg")
{
var msg2 = jo["message"].Value <string>();
DataArrived?.Invoke(new DebugMessageEventArgs()
{
Message = msg2
});
}
else if (type == "debug-msg-line")
{
var msg3 = jo["message"].Value <string>();
DataArrived?.Invoke(new DebugMessageEventArgs()
{
Message = msg3 + Environment.NewLine
});
}
}
break;
case MessageType.Data: // data
if (_socket.TryReceive(ref msg, TimeSpan.FromMilliseconds(1)))
{
string text = System.Text.Encoding.ASCII.GetString(msg.Data);
var ser = new Newtonsoft.Json.JsonSerializer();
using (var reader = new JsonTextReader(new StringReader(text)))
{
PendingChoice choice = ser.Deserialize <PendingChoice>(reader);
GameState.PendingChoice = choice;
}
DataArrived?.Invoke(new DataEventArgs()
{
Data = text
});
}
break;
}
}
}
/// <summary>
/// Attempt to transmit a status-signal over this socket.
/// If signal cannot be sent immediately, return <c>false</c>.
/// </summary>
/// <param name="socket">the IOutgoingSocket to transmit on</param>
/// <param name="status">a byte that contains the status signal to send</param>
private static bool TrySignal([NotNull] this IOutgoingSocket socket, byte status)
{
long signalValue = 0x7766554433221100L + status;
Msg msg = new Msg();
msg.InitPool(8);
NetworkOrderBitsConverter.PutInt64(signalValue, msg.Data);
if (!socket.TrySend(ref msg, TimeSpan.Zero, false))
{
msg.Close();
return false;
}
msg.Close();
return true;
}
/// <summary>Attempt to receive a message for the specified amount of time.</summary>
/// <param name="msg">A reference to a <see cref="Msg"/> instance into which the received message
/// data should be placed.</param>
/// <param name="timeout">The maximum amount of time the call should wait for a message before returning.</param>
/// <returns><c>true</c> if a message was received before <paramref name="timeout"/> elapsed,
/// otherwise <c>false</c>.</returns>
public virtual bool TryReceive(ref Msg msg, TimeSpan timeout)
{
return(m_socketHandle.TryRecv(ref msg, timeout));
}