private static RequestSocket CreateServerSocket()
{
Console.WriteLine("C: Connecting to server...");
var client = new RequestSocket();
client.Connect(ServerEndpoint);
client.Options.Linger = TimeSpan.Zero;
client.ReceiveReady += ClientOnReceiveReady;
return client;
}
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 req = new RequestSocket())
{
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, more: false);
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;
}
private static void Main()
{
using (var worker = new RequestSocket())
{
var random = new Random(DateTime.Now.Millisecond);
var guid = Guid.NewGuid();
worker.Options.Identity = Encoding.Unicode.GetBytes(guid.ToString());
worker.Connect(ServerEndpoint);
worker.ReceiveReady += (s, e) =>
{
// Read and save all frames until we get an empty frame
// In this example there is only 1 but it could be more
byte[] address = worker.ReceiveFrameBytes();
worker.ReceiveFrameBytes(); // empty
byte[] request = worker.ReceiveFrameBytes();
worker.SendMoreFrame(address);
worker.SendMoreFrame(Encoding.Unicode.GetBytes(""));
worker.SendFrame(Encoding.Unicode.GetBytes(Encoding.Unicode.GetString(request) + " WORLD!"));
};
Console.WriteLine("W: {0} worker ready", guid);
worker.SendFrame(Encoding.Unicode.GetBytes(LRUReady));
var cycles = 0;
while (true)
{
cycles += 1;
if (cycles > 3 && random.Next(0, 5) == 0)
{
Console.WriteLine("W: {0} simulating a crash", guid);
Thread.Sleep(5000);
}
else if (cycles > 3 && random.Next(0, 5) == 0)
{
Console.WriteLine("W: {0} simulating CPU overload", guid);
Thread.Sleep(3000);
}
Console.WriteLine("W: {0} normal reply", guid);
worker.Poll(TimeSpan.FromMilliseconds(1000));
}
}
}
private static void Main()
{
using (var client = new RequestSocket(">tcp://127.0.0.1:5559"))
{
for (var i = 0; i < 10; i++)
{
var msg = new NetMQMessage();
msg.Append("Message_" + i);
client.SendMultipartMessage(msg);
Console.WriteLine("Sent Message {0}", msg.Last.ConvertToString());
var response = client.ReceiveMultipartMessage();
Console.WriteLine("Received Message {0}", response.Last.ConvertToString());
}
Console.ReadKey();
}
}
private static RequestSocket CreateServerSocket()
{
Console.WriteLine("C: Connecting to server...");
var guid = Guid.NewGuid();
var client = new RequestSocket
{
Options =
{
Linger = TimeSpan.Zero,
Identity = Encoding.Unicode.GetBytes(guid.ToString())
}
};
client.Connect(ServerEndpoint);
client.ReceiveReady += ClientOnReceiveReady;
return client;
}
private static bool TryRequest(string endpoint, string requestString)
{
Console.WriteLine("Trying echo service at {0}", endpoint);
using (var client = new RequestSocket())
{
client.Options.Linger = TimeSpan.Zero;
client.Connect(endpoint);
client.SendFrame(requestString);
client.ReceiveReady += ClientOnReceiveReady;
bool pollResult = client.Poll(TimeSpan.FromMilliseconds(RequestTimeout));
client.ReceiveReady -= ClientOnReceiveReady;
client.Disconnect(endpoint);
return pollResult;
}
}
public void Run()
{
var rnd = new Random(m_id);
using (var worker = new RequestSocket())
{
worker.Connect(m_localBackendAddress);
Console.WriteLine("[WORKER {0}] Connected & READY", m_id);
// build READY message
var msg = new NetMQMessage();
var ready = NetMQFrame.Copy(new[] { Program.WorkerReady });
msg.Append(ready);
msg.Push(NetMQFrame.Empty);
msg.Push(new[] { m_id });
// and send to broker
worker.SendMultipartMessage(msg);
while (true)
{
// wait for a request - the REQ might be from a local client or a cloud request
var request = worker.ReceiveMultipartMessage();
if (request.FrameCount < 3)
{
Console.WriteLine("[WORKER {0}] ERR - received an empty message", m_id);
break; // something went wrong -> exit
}
Console.WriteLine("[WORKER {0}] received", m_id);
foreach (var frame in request)
Console.WriteLine("\t[{0}", frame.ConvertToString());
// simulate working for an arbitrary time < 2s
Thread.Sleep(rnd.Next(2000));
// simply send back what we received
worker.SendMultipartMessage(request);
}
}
}
private static void Main()
{
Console.Title = "NetMQ HelloWorld";
using (var server = new ResponseSocket("@tcp://localhost:5556"))
using (var client = new RequestSocket("tcp://localhost:5556"))
{
client.SendFrame("Hello");
Console.WriteLine("From Client: {0}", server.ReceiveFrameString());
server.SendFrame("Hi Back");
Console.WriteLine("From Server: {0}", client.ReceiveFrameString());
Console.WriteLine();
Console.Write("Press any key to exit...");
Console.ReadKey();
}
}
private static void WorkerTask(object portNumber)
{
var random = new Random(DateTime.Now.Millisecond);
using (var worker = new RequestSocket())
{
// We use a string identity for ease here
string id = ZHelpers.SetID(worker, Encoding.Unicode);
string cnn = $"tcp://localhost:{portNumber}";
worker.Connect(cnn);
Console.WriteLine("[W] ID {0} connect to {1}", id, cnn);
int total = 0;
bool end = false;
while (!end)
{
// Tell the router we're ready for work
worker.SendFrame("Ready");
//Console.WriteLine("[W] Message sent: {0}", msg);
// Get workload from router, until finished
string workload = worker.ReceiveFrameString();
//Console.WriteLine("[W] Workload received: {0}", workload);
if (workload == "END")
{
end = true;
}
else
{
total++;
Thread.Sleep(random.Next(1, 1000)); // Simulate 'work'
}
}
Console.WriteLine("ID ({0}) processed: {1} tasks", Encoding.Unicode.GetString(worker.Options.Identity), total);
}
}
private static void ClientRoutine(object clientId)
{
try
{
using (var req = new RequestSocket())
{
req.Connect("tcp://localhost:5555");
byte[] message = Encoding.Unicode.GetBytes(string.Format("{0} Hello", clientId));
Console.WriteLine("Client {0} sent \"{0} Hello\"", clientId);
req.SendFrame(message, message.Length);
var response = req.ReceiveFrameString(Encoding.Unicode);
Console.WriteLine("Client {0} received \"{1}\"", clientId, response);
}
}
catch (Exception ex)
{
Console.WriteLine("Exception on ClientRoutine: {0}", ex.Message);
}
}
private void SendFile(RequestSocket client, string path)
{
var filename = Path.GetFileName(path);
client.Send(filename);
//var answer = client.ReceiveString();
using (var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
{
int rest = (int)fileStream.Length;
while (rest >= PartSize)
{
rest -= PartSize;
var part = new byte[PartSize];
fileStream.Read(part, 0, PartSize);
client.Send(part, PartSize, false, true);
}
var lastPart = new byte[rest];
fileStream.Read(lastPart, 0, rest);
client.Send(lastPart, rest, false, false);
}
}
protected override void Run()
{
while (Running)
{
ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use, not sure why yet
using (RequestSocket client = new RequestSocket())
{
client.Connect("tcp://localhost:5555");
//Debug.Log("Sending Data over");
client.SendFrame(dataToSend.ToString());
// ReceiveFrameString() blocks the thread until you receive the string, but TryReceiveFrameString()
// do not block the thread, you can try commenting one and see what the other does, try to reason why
// unity freezes when you use ReceiveFrameString() and play and stop the scene without running the server
// string message = client.ReceiveFrameString();
// Debug.Log("Received: " + message);
string message = null;
bool gotMessage = false;
while (Running)
{
gotMessage = client.TryReceiveFrameString(out message); // this returns true if it's successful
if (gotMessage)
{
break;
}
}
//if (gotMessage) Debug.Log("Received " + message);
dataRecieved.FromString(message);
sending = false;
}
NetMQConfig.Cleanup(); // this line is needed to prevent unity freeze after one use, not sure why yet
}
}
public void StoppingProxyDisengagesFunctionality()
{
using (var front = new RouterSocket())
using (var back = new DealerSocket())
{
front.Bind("inproc://frontend");
back.Bind("inproc://backend");
var proxy = new Proxy(front, back);
Task.Factory.StartNew(proxy.Start);
// Send a message through to ensure the proxy has started
using (var client = new RequestSocket())
using (var server = new ResponseSocket())
{
client.Connect("inproc://frontend");
server.Connect("inproc://backend");
client.SendFrame("hello");
Assert.AreEqual("hello", server.ReceiveFrameString());
server.SendFrame("reply");
Assert.AreEqual("reply", client.ReceiveFrameString());
proxy.Stop(); // blocks until stopped
using (var poller = new NetMQPoller {
front, back
})
{
poller.RunAsync();
client.SendFrame("anyone there?");
// Should no longer receive any messages
Assert.IsFalse(server.TrySkipFrame(TimeSpan.FromMilliseconds(50)));
}
}
}
}
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) => Debug.WriteLine("C: {0} {1:ss.fff}", message[0].ConvertToString(), DateTime.Now));
var serverProactor = new NetMQProactor(server, (socket, message) =>
{
Debug.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 TestKeepAlive()
{
// there is no way to test tcp keep alive without disconnect the cable, we just testing that is not crashing the system
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
{
rep.Options.TcpKeepalive = true;
rep.Options.TcpKeepaliveIdle = TimeSpan.FromSeconds(5);
rep.Options.TcpKeepaliveInterval = TimeSpan.FromSeconds(1);
req.Options.TcpKeepalive = true;
req.Options.TcpKeepaliveIdle = TimeSpan.FromSeconds(5);
req.Options.TcpKeepaliveInterval = TimeSpan.FromSeconds(1);
var port = rep.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
bool more;
req.SendFrame("1");
Assert.AreEqual("1", rep.ReceiveFrameString(out more));
Assert.IsFalse(more);
rep.SendFrame("2");
Assert.AreEqual("2", req.ReceiveFrameString(out more));
Assert.IsFalse(more);
Assert.IsTrue(req.Options.TcpKeepalive);
Assert.AreEqual(TimeSpan.FromSeconds(5), req.Options.TcpKeepaliveIdle);
Assert.AreEqual(TimeSpan.FromSeconds(1), req.Options.TcpKeepaliveInterval);
Assert.IsTrue(rep.Options.TcpKeepalive);
Assert.AreEqual(TimeSpan.FromSeconds(5), rep.Options.TcpKeepaliveIdle);
Assert.AreEqual(TimeSpan.FromSeconds(1), rep.Options.TcpKeepaliveInterval);
}
}
public void Monitoring()
{
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
using (var monitor = new NetMQMonitor(rep, "inproc://rep.inproc", SocketEvents.Accepted | SocketEvents.Listening))
{
var listening = false;
var accepted = false;
monitor.Accepted += (s, a) => { accepted = true; };
monitor.Listening += (s, a) => { listening = true; };
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var monitorTask = Task.Factory.StartNew(monitor.Start);
var port = rep.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
req.SendFrame("a");
rep.SkipFrame();
rep.SendFrame("b");
req.SkipFrame();
Thread.Sleep(200);
Assert.IsTrue(listening);
Assert.IsTrue(accepted);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(monitorTask.IsCompleted);
}
}
static void Main(string[] args)
{
// 소켓 생성
using (var server = new RequestSocket())
{
// 연결 주소 입력
server.Bind("tcp://localhost:5555");
// 처리 코드 수행 구간
while (true)
{
// 메시지 전송
server.SendMoreFrame("test");
server.SendFrame("Hello");
// 메시지 수신
var message = server.ReceiveFrameString();
// 메시지 출력
Console.WriteLine(message);
}
}
}
// Send message to server, receive message from server, process message
public void Communicate(string output)
{
ForceDotNet.Force();
string input;
using (RequestSocket client = new RequestSocket())
{
// Connect
client.Connect("tcp://localhost:5555");
// Send
Send(client, output);
// Receive
input = Receive(client);
}
NetMQConfig.Cleanup();
// Process
Process(input);
}
private void Listen()
{
log.Info("Session manager is starting.");
requestSocket = new RequestSocket();
switch (sessionType)
{
case eSessionType.Local:
requestSocket.Connect("inproc://opendiablo2-session");
break;
case eSessionType.Server:
case eSessionType.Remote:
default:
throw new OpenDiablo2Exception("This session type is currently unsupported.");
}
running = true;
resetEvent.WaitOne();
running = false;
requestSocket.Dispose();
log.Info("Session manager has stopped.");
}
public Task <Work> DoWork()
{
if (!_isConnected.Value)
{
throw new Exception("lost connection to gateway");
}
using (var client = new RequestSocket())
{
client.Options.Identity = _id.ToByteArray();
client.Connect(_gatewayEndpoint);
client.SendFrame(Work.Ask.Serialize());
if (client.TryReceiveFrameBytes(TimeSpan.FromMilliseconds(1000), out var responseBytes))
{
var response = responseBytes.Deserialize <Work>();
return(Task.FromResult(response));
}
}
throw new Exception("something wrong happened");
}
public void TerminateAfterSocketsUse()
{
NetMQConfig.ContextCreate(true);
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
using (var poller = new NetMQPoller {
rep
})
{
var port = rep.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
rep.ReceiveReady += (s, e) =>
{
bool more;
Assert.AreEqual("Hello", e.Socket.ReceiveFrameString(out more));
Assert.False(more);
e.Socket.SendFrame("World");
};
poller.RunAsync();
req.SendFrame("Hello");
bool more2;
Assert.AreEqual("World", req.ReceiveFrameString(out more2));
Assert.IsFalse(more2);
poller.Stop();
}
NetMQConfig.ContextTerminate();
var isTerminated = VerifyTermination();
Assert.AreEqual(true, isTerminated);
}
void SendKartPosition()
{
while (true)
{
if (sending_flag)
{
String sendingPositionX = positionX;
String sendingPositionZ = positionZ;
sending_flag = false;
clientSocket.SendFrame(sendingPositionX + "," + sendingPositionZ);
TimeSpan receiveTimeout = TimeSpan.FromMilliseconds(500);
bool gotMessage = false;
String message;
gotMessage = clientSocket.TryReceiveFrameString(receiveTimeout, out message);
if (gotMessage)
{
float rewardCAPP = float.Parse(message);
AddReward(rewardCAPP);
}
else
{
// The below error happens after the message could not receive
// FiniteStateMachineException: Req.XSend - cannot send another request
Debug.Log("Message was not received!!!!");
clientSocket.Close();
clientSocket = new RequestSocket(); // Just Connect() function does not work. need to recreate the socket
clientSocket.Connect("tcp://localhost:" + sendingTcpPort);
// gotMessage = clientSocket.TryReceiveFrameString(receiveTimeout, out message);
// reset the connection
}
}
}
}
/// <summary>
/// Add an instrument to QDMS.
/// </summary>
/// <param name="instrument"></param>
/// <returns>The instrument with its ID set if successful, null otherwise.</returns>
public Instrument AddInstrument(Instrument instrument)
{
if (!Connected)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Could not add instrument - not connected."));
return(null);
}
if (instrument == null)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Could not add instrument - instrument is null."));
return(null);
}
using (var s = new RequestSocket(_instrumentServerConnectionString)) {
using (var ms = new MemoryStream()) {
s.SendMoreFrame("ADD"); // First we send an "ADD" request
// Then we need to serialize and send the instrument
s.SendFrame(MyUtils.ProtoBufSerialize(instrument, ms));
// Then get the reply
var result = s.ReceiveFrameString();
if (!result.Equals("SUCCESS", StringComparison.InvariantCultureIgnoreCase))
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Instrument addition failed: received no reply."));
return(null);
}
// Addition was successful, receive the instrument and return it
var serializedInstrument = s.ReceiveFrameBytes();
return(MyUtils.ProtoBufDeserialize <Instrument>(serializedInstrument, ms));
}
}
}
void establish(Action Connected)
{
ThreadPool.QueueUserWorkItem((o) => {
ConsoleEx.DebugLog("Request socket is Connecting...", ConsoleEx.RED);
var context = Core.ZeroMQ;
reqSock = context.CreateRequestSocket();
reqSock.Options.SendHighWatermark = EngCfg.HighWatermark;
reqSock.Options.ReceiveHighWatermark = EngCfg.HighWatermark;
//生成通讯地址和协议方式
ConnectingAddress = ConnectAddr(typeof(RequestSocket));
reqSock.Connect(ConnectingAddress);
connected = true;
//稍微等待一下
Thread.Sleep(100);
if (Connected != null)
{
Connected();
}
});
}
private void ListenerWork()
{
AsyncIO.ForceDotNet.Force();
using (var subSocket = new RequestSocket())
{
subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect("tcp://localhost:12345");
// subSocket.Subscribe("");
while (!_listenerCancelled)
{
string frameString = "blah";
bool success = false;
if (!sending)
{
success = subSocket.TryReceiveFrameString(out frameString);
if (success)
{
_messageQueue.Enqueue(frameString);
}
}
else
{
success = OutgoingSocketExtensions.TrySendFrame(subSocket, frameString);
}
// if the transaction was successful,
if (success)
{
sending = !sending;
}
}
subSocket.Close();
}
NetMQConfig.Cleanup();
}
protected override void Run()
{
ForceDotNet.Force();
using (RequestSocket client = new RequestSocket())
{
client.Connect("tcp://localhost:5555");
while (Running)
{
if (Send)
{
// Send both frequency and duration together here and split them in Python afterwards.
client.SendFrame(requesterfrequency.ToString() + "," + requesterDuration.ToString() + "," + requesterPlayAudio.ToString());
string message = null;
bool gotMessage = false;
while (Running)
{
gotMessage = client.TryReceiveFrameString(out message); // this returns true if it's successful
if (gotMessage)
{
break;
}
}
if (gotMessage)
{
//Debug.Log("Received " + message);
}
}
}
}
NetMQConfig.Cleanup();
}
public ReqReplyServiceSpecs()
{
Reply = string.Empty;
Replied = new ManualResetEvent(false);
Console.WriteLine("Start client fiber");
ClientFiber = PoolFiber.StartNew();
ClientContext = NetMQContext.Create();
ServerFiber = PoolFiber.StartNew();
ServerContext = NetMQContext.Create();
Func <byte[], string> unmarshaller = x => Encoding.Unicode.GetString(x);
Func <string, byte[]> marshaller = x => Encoding.Unicode.GetBytes(x);
Service = new RequestHandlerSocket <string, string>(ServerContext,
"tcp://Monster:9997",
unmarshaller,
marshaller);
Service.SetRequestHandler(ServerFiber, request => request.Reply(request.Request.ToUpper()));
Console.WriteLine("Start service");
Client = new RequestSocket <string, string>(ClientContext,
"tcp://Monster:9997",
marshaller,
unmarshaller);
Console.WriteLine("Start client");
}
private static List <HQItem> Query(string codes)
{
try
{
using (var client = new RequestSocket())
{
string cmd = string.Format("8001|{0}", codes);
string response;
client.Connect(query_server);
client.TrySendFrame(new TimeSpan(0, 0, 3), Encoding.UTF8.GetBytes(cmd));
bool result = client.TryReceiveFrameString(new TimeSpan(0, 0, 3), Encoding.UTF8, out response);
client.Close();
client.Dispose();
if (result && !string.IsNullOrWhiteSpace(response) && response.StartsWith("80001|"))
{
string[] datas = response.Substring(7).Replace("}", "").Split('{');
return(Deal(datas));
}
}
}
catch
{ }
return(new List <HQItem>());
}
public void SimulateClientInput(RequestSocket client, JsonData jsonData, NetMQMessage msg)
{
ResponseSocket server = GetServerForClient(client);
Avatar myAvatar = _avatars[server];
if (saveDebugImageFiles)
{
// Just save out the png data to the local filesystem(Debugging code only)
if (msg.FrameCount > 1)
{
for(int i = 0; i < myAvatar.shaders.Count; ++i)
Debug.LogFormat("Saving out: {0}", CameraStreamer.SaveOutImages(msg[msg.FrameCount + i - myAvatar.shaders.Count].ToByteArray(), i));
CameraStreamer.fileIndex++;
}
}
// Send input message
JsonData msgData = CreateMsgJson(MSG_R_FrameInput);
myAvatar.myInput.SimulateInputFromController(ref msgData);
_lastMessageSent.Clear();
_lastMessageSent.Append(msgData.ToJSON());
client.SendMultipartMessage(_lastMessageSent);
}
private static void TerminateClient(RequestSocket client)
{
client.Disconnect(SERVER_ENDPOINT);
client.Close();
}
private static void TerminateClient(RequestSocket client)
{
client.Disconnect(ServerEndpoint);
client.Close();
}
public void Init(string hostAddress, string portNumber, string portNumber_info, bool shouldCreateTestClient, bool shouldCreateServer, bool debugNetworkMessages,
bool logSimpleTimingInfo, bool logDetailedTimeInfo, string preferredImageFormat, bool saveDebugImageFiles, string environmentScene)
{
this.avatarPrefab = Resources.Load<Avatar>("Prefabs/Avatar");
if (this.avatarPrefab == null) {
Debug.Log ("it doesnt exist still!");
}
Debug.Log ("May have just printed something right here^");
Debug.Log (this.avatarPrefab.name);
// Read port number
this.portNumber = portNumber;
this.portNumber_info = portNumber_info;
this.hostAddress = hostAddress;
this.shouldCreateTestClient = shouldCreateTestClient;
this.shouldCreateServer = shouldCreateServer;
this.debugNetworkMessages = debugNetworkMessages;
logSimpleTimeInfo = logSimpleTimingInfo;
logTimingInfo = logDetailedTimeInfo;
CameraStreamer.preferredImageFormat = preferredImageFormat; // defaults to bmp
this.saveDebugImageFiles = saveDebugImageFiles; // defaults to False
this.environmentScene = environmentScene; // defaults to "Empty"
// Load Environment Scene
if (shouldCreateServer) {
SceneManager.LoadScene (environmentScene, LoadSceneMode.Additive);
if (!SceneManager.GetSceneByName (environmentScene).IsValid()) {
Debug.LogWarning ("Scene name \"" + environmentScene + "\" was not found.");
}
}
// Start up connections
_ctx = NetMQContext.Create();
clientInfo = _ctx.CreateRequestSocket();
clientInfo.Options.Linger = TimeSpan.Zero;
clientInfo.Connect("tcp://" + hostAddress + ":" + portNumber_info);
CreateNewSocketConnection();
Debug.Log ("Net Messenger Initialized!");
}
/// <summary>
/// just to create the REQ socket
/// </summary>
/// <param name="id">the name for the client</param>
/// <returns>the connected REQ socket</returns>
private static RequestSocket CreateSocket(string id)
{
var client = new RequestSocket
{
Options =
{
Identity = Encoding.UTF8.GetBytes(id),
Linger = TimeSpan.Zero
}
};
// set the event to be called upon arrival of a message
client.ReceiveReady += OnClientReceiveReady;
client.Connect(Commons.QueueFrontend);
return client;
}
public ResponseSocket GetServerForClient(RequestSocket client)
{
foreach(ResponseSocket server in _createdSockets)
{
if (_avatarClients.ContainsKey(server) && _avatarClients[server] == client)
return server;
}
return null;
}
// Used for debugging without an agent
public void HandleClientFrameMessage(RequestSocket client, NetMQMessage msg)
{
if (debugNetworkMessages)
Debug.LogFormat("Received Msg on Client: {0}", ReadOutMessage(msg));
string msgHeader = msg.First.ConvertToString();
// Hack to avoid slow parsing of long json values since we're not reading it anyways
JsonData jsonData = null;
if (msg.FrameCount > 0)
{
string jsonString = msg[0].ConvertToString();
if (jsonString != null && jsonString.Length > 1000)
{
msgHeader = MSG_S_FrameData;
jsonData = CreateMsgJson(msgHeader);
}
else
jsonData = msg.ReadJson(out msgHeader);
}
if (jsonData == null)
{
Debug.LogError("Invalid message from server! Cannot parse JSON!\n" + ReadOutMessage(msg));
return;
}
if (msgHeader == null)
{
Debug.LogError("Invalid message from server! No msg_type!\n" + jsonData.ToJSON());
return;
}
switch(msgHeader.ToString())
{
case MSG_S_ConfirmClientJoin:
SimulateClientInput(client, jsonData, msg);
break;
case MSG_S_FrameData:
SimulateClientInput(client, jsonData, msg);
break;
default:
Debug.LogWarningFormat("Invalid message from server! Unknown msg_type '{0}'\n{1}", msgHeader, jsonData.ToJSON());
break;
}
}
protected override void WritePort(byte[] buffer, int i, int length, string hwaddress)
{
try
{
byte[] data;
if (i > 0)
{
data = new byte[length];
Array.Copy(buffer, 0, data, 0, length);
}
else
{
data = buffer;
}
var req = new RequestSocket();
req.Connect(_endpoint);
req.SendFrame(data);
while (req.HasOut)
Thread.Sleep(500);
Log.Debug(string.Format("PortZMq.WritePort: " + length + " bytes sent to " + _endpoint));
}
catch (Exception ex)
{
Log.Error("PortZMq.WritePort: failed sending buffer", ex);
throw;
}
}
public NetClient(RequestSocket req)
{
_req = req;
}
public void Run()
{
Console.WriteLine("[CLIENT {0}] Starting", m_id);
var rnd = new Random(m_id);
// each request shall have an unique id in order to recognize an reply for a request
var messageId = new byte[5];
// create clientId for messages
var clientId = new[] { m_id };
// a flag to signal that an answer has arrived
bool messageAnswered = false;
// we use a poller because we have a socket and a timer to monitor
using (var clientPoller = new NetMQPoller())
using (var client = new RequestSocket())
using (var monitor = new PushSocket())
{
client.Connect(m_localFrontendAddress);
monitor.Connect(m_monitorAddress);
client.Options.Identity = new[] { m_id };
var timer = new NetMQTimer((int)TimeSpan.FromSeconds(10).TotalMilliseconds);
// use as flag to indicate exit
var exit = false;
// every 10 s check if message has been received, if not then send error message and ext
// and restart timer otherwise
timer.Elapsed += (s, e) =>
{
if (messageAnswered)
{
e.Timer.Enable = true;
}
else
{
var msg = string.Format("[CLIENT {0}] ERR - EXIT - lost message {1}", m_id, messageId);
// send an error message
monitor.SendFrame(msg);
// if poller is started than stop it
if (clientPoller.IsRunning)
clientPoller.Stop();
// mark the required exit
exit = true;
}
};
// process arriving answers
client.ReceiveReady += (s, e) =>
{
// mark the arrival of an answer
messageAnswered = true;
// worker is supposed to answer with our request id
var reply = e.Socket.ReceiveMultipartMessage();
if (reply.FrameCount == 0)
{
// something went wrong
monitor.SendFrame(string.Format("[CLIENT {0}] Received an empty message!", m_id));
// mark the exit flag to ensure the exit
exit = true;
}
else
{
var sb = new StringBuilder();
// create success message
foreach (var frame in reply)
sb.Append("[" + frame.ConvertToString() + "]");
// send the success message
monitor.SendFrame(string.Format("[CLIENT {0}] Received answer {1}",
m_id,
sb.ToString()));
}
};
// add socket & timer to poller
clientPoller.Add(client);
clientPoller.Add(timer);
// start poller in another thread to allow the continued processing
clientPoller.RunAsync();
// if true the message has been answered
// the 0th message is always answered
messageAnswered = true;
while (!exit)
{
// simulate sporadic activity by randomly delaying
Thread.Sleep((int)TimeSpan.FromSeconds(rnd.Next(5)).TotalMilliseconds);
// only send next message if the previous one has been replied to
if (messageAnswered)
{
// generate random 5 byte as identity for for the message
rnd.NextBytes(messageId);
messageAnswered = false;
// create message [client adr][empty][message id] and send it
var msg = new NetMQMessage();
msg.Push(messageId);
msg.Push(NetMQFrame.Empty);
msg.Push(clientId);
client.SendMultipartMessage(msg);
}
}
// stop poller if needed
if (clientPoller.IsRunning)
clientPoller.Stop();
}
}
private void OnDisable()
{
foreach(ResponseSocket server in _createdSockets)
{
if (_avatarClients.ContainsKey(server))
{
_avatarClients[server].Close();
_avatarClients[server].Dispose();
}
server.Close();
server.Dispose();
if (_avatars.ContainsKey(server))
{
Avatar avatar = _avatars[server];
if (avatar != null && avatar.gameObject != null)
GameObject.Destroy(_avatars[server].gameObject);
}
}
if (clientSimulation != null)
{
clientSimulation.Close();
clientSimulation.Dispose();
clientSimulation = null;
}
_avatars.Clear();
_createdSockets.Clear();
_avatarClients.Clear();
if (_ctx != null)
{
_ctx.Terminate();
_ctx.Dispose();
_ctx = null;
}
}
