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; } }