public void CallDirectoryService() { ThreadPool.QueueUserWorkItem(state => { var req = new ServiceHostRequest() { Address = _ip, ServiceType = "intersect" }; var dirServiceSocket = new RequestSocket(); dirServiceSocket.Connect("tcp://" + _dirSerIp + ":8910"); while (!_stopLoops) { try { using (var reqStream = new MemoryStream()) { Serializer.Serialize(reqStream, req); dirServiceSocket.SendFrame(reqStream.ToArray()); } var receiveFrame = dirServiceSocket.ReceiveFrameBytes(); var request = Serializer.Deserialize <Message>(new MemoryStream(receiveFrame)) as BooleanResponse; Console.WriteLine(request.Ok); if (request.Ok) { return; } } catch (Exception e) { Console.WriteLine(e); } Thread.Sleep(1000); } }); }
// Create queue of requests in case multiple have to be handled private void SimpleRequest(string endpoint, string request) { // wait until socket is available while (!isAvailable) { // Debug.Log("Socket unavailable"); } isAvailable = false; if (request == null) { requestSocket.SendFrame(endpoint); } else { // Debug.Log(request); requestSocket.SendMoreFrame(endpoint); requestSocket.SendFrame(request); } var msg = requestSocket.ReceiveFrameBytes(); isAvailable = true; requestResult = System.Text.Encoding.UTF8.GetString(msg); //requestResult = JsonUtility.FromJson<T>(msgString); }
public void RequestReply_Intersect() { //ThreadPool.QueueUserWorkItem(state => //{ var client = new RequestSocket(); client.Connect("tcp://" + IntersectIP + ":5553"); try { var request = new Request() { UserId = Id }; using (var responseStream = new MemoryStream()) { Serializer.Serialize(responseStream, request); client.SendFrame(responseStream.ToArray()); } var receiveFrame = client.ReceiveFrameBytes(); var reply = Serializer.Deserialize <Response>(new MemoryStream(receiveFrame)); var mr = reply as BooleanResponse; } catch (Exception e) { Console.WriteLine(e); } //}); }
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)); } } }
static void Main(string[] args) { string addr = "tcp://localhost:6666"; Console.WriteLine("Client can connect to: {0}", addr); using (var rs = new RequestSocket()) // // REQ must be send/recv...send/recv in this order { rs.Connect(addr); while (true) { string str = Console.ReadLine(); rs.SendFrame(str); // read from network var msg = rs.ReceiveFrameBytes(); // get our Flat Buffer var order = Order.GetRootAsOrder(new ByteBuffer(msg)); // For C#, unlike other languages, most values (except for vectors and unions) are available as // properties instead of accessor methods. // Note: We did not set the `Mana` field explicitly, so we get back the default value. Console.WriteLine(order.Id); Console.WriteLine(order.Broker); Console.WriteLine(order.Stockcode); Console.WriteLine(order.Side); Console.WriteLine($"Price {order.Price.Value.Spot}, {order.Price.Value.Open}, {order.Price.Value.Close}"); // Contracts for (int i = 0; i < order.ContractsLength; i++) { Console.WriteLine($"Contract {order.Contracts(i).Value.Name}, {order.Contracts(i).Value.Price}"); } // Instruments for (int i = 0; i < order.InstrumentsLength; i++) { Console.WriteLine($"Instrument {order.Instruments(i).Value.Tag}, {order.Instruments(i).Value.Value}, {order.Instruments(i).Value.BlobLength}"); byte[] bb = order.Instruments(i).Value.GetBlobBytes().Value.Array; //foreach (byte b in bb) //{ // Console.Write($" {b.ToString()}"); //} //Console.WriteLine(); } // Get and test the `Equipped` FlatBuffer `union`. if (order.StrategyType == Strategies.Contract) { var strategy = order.Strategy <Contract>().Value; Console.WriteLine($"Strategy {strategy.Name}, {strategy.Price}"); } } } }
public ReplyData GetReply(InputData data) { var inputBuf = ByteArray.CreateFrom(data); request.SendFrame(inputBuf); var replyData = request.ReceiveFrameBytes(); return(replyData.ConvertTo <ReplyData>()); }
/// <summary> /// 长连接发送 /// </summary> /// <param name="buf"></param> /// <returns></returns> public byte[] Send(byte[] buf) { if (socket == null) { socket = new RequestSocket("tcp://" + Address); } socket.SendFrame(buf); return(socket.ReceiveFrameBytes()); }
public Mmind.Response sendReq(Mmind.Request req) { reqbuf = new byte[req.CalculateSize()]; Serialize(reqbuf, req); client.SendFrame(reqbuf); resbuf = client.ReceiveFrameBytes(); Mmind.Response rel = Mmind.Response.Parser.ParseFrom(resbuf); return(rel); }
private List <Instrument> ReceiveInstrumentSearchResults(RequestSocket s) { using (var ms = new MemoryStream()) { // First we receive the size of the final uncompressed byte[] array bool hasMore; var sizeBuffer = s.ReceiveFrameBytes(out hasMore); if (sizeBuffer.Length == 0) { RaiseEvent(Error, this, new ErrorArgs(-1, "Contract request failed, received no reply.")); return(new List <Instrument>()); } var outputSize = BitConverter.ToInt32(sizeBuffer, 0); // Then the actual data var buffer = s.ReceiveFrameBytes(out hasMore); if (buffer.Length == 0) { RaiseEvent(Error, this, new ErrorArgs(-1, "Contract request failed, received no data.")); return(new List <Instrument>()); } try { // Then we process it by first decompressing ms.SetLength(0); var decoded = LZ4Codec.Decode(buffer, 0, buffer.Length, outputSize); ms.Write(decoded, 0, decoded.Length); ms.Position = 0; // And finally deserializing return(Serializer.Deserialize <List <Instrument> >(ms)); } catch (Exception ex) { RaiseEvent(Error, this, new ErrorArgs(-1, "Error processing instrument data: " + ex.Message)); return(new List <Instrument>()); } } }
/// <summary> /// /// </summary> /// <param name="address"></param> /// <param name="buf"></param> /// <returns></returns> public byte[] Send(string address, byte[] buf) { var client = new RequestSocket(">tcp://" + address); // connect client.SendFrame(buf); byte[] result = client.ReceiveFrameBytes(); client.Close(); client.Dispose(); return(result); }
public Task <ServiceReply> CallService(ServiceRequest srq) { // Convert serviceRequest into byte array which is then sent to server as frame byte[] buffer = srq.ToByteArray(); socket.SendFrame(buffer); // Receive, return Task promise = new TaskCompletionSource <ServiceReply>(); promise.TrySetResult(ServiceReply.Parser.ParseFrom(socket.ReceiveFrameBytes())); return(promise.Task); }
public void ReceiveBeforeSending() { using (var rep = new ResponseSocket()) using (var req = new RequestSocket()) { var port = rep.BindRandomPort("tcp://localhost"); req.Connect("tcp://localhost:" + port); Assert.Throws <FiniteStateMachineException>(() => req.ReceiveFrameBytes()); } }
public Task <byte[]> RequestResponse(byte[] data) { return (Task <byte[]> .Factory.StartNew(() => { lock (_socketlock) { _client.SendFrame(data); return _client.ReceiveFrameBytes(); } })); }
private void ProcessMessageFrame <T>() where T : IMessageFrame, new() { if (!running) { throw new OpenDiablo2Exception("You have made a terrible mistake. Cannot get a message frame if you are not connected."); } using (var ms = new MemoryStream(requestSocket.ReceiveFrameBytes())) using (var br = new BinaryReader(ms)) { var messageFrame = getMessageFrame((eMessageFrameType)br.ReadByte()); if (messageFrame.GetType() != typeof(T)) { throw new OpenDiablo2Exception("Recieved unexpected message frame!"); } messageFrame.LoadFrom(br); lock (getGameState().ThreadLocker) messageFrame.Process(requestSocket.GetHashCode(), this); } }
private void ProcessMessageFrame <T>() where T : IMessageFrame, new() { if (!running) { throw new OpenDiablo2Exception("You have made a terrible mistake. Cannot get a message frame if you are not connected."); } var bytes = requestSocket.ReceiveFrameBytes(); var frameType = (eMessageFrameType)bytes[0]; var frameData = bytes.Skip(1).ToArray(); // TODO: Can we maybe use pointers? This seems wasteful var messageFrame = getMessageFrame(frameType); if (messageFrame.GetType() != typeof(T)) { throw new OpenDiablo2Exception("Recieved unexpected message frame!"); } messageFrame.Data = frameData; lock (getGameState().ThreadLocker) { messageFrame.Process(requestSocket.GetHashCode(), this); } }
static void Main(string[] args) { using (var client = new RequestSocket()) { client.Connect("tcp://localhost:5555"); int i = 1; while (i <= 100000000) { var data = new byte[i]; client.SendFrame(data); Console.WriteLine($"Send {i} bytes"); i *= 10; client.ReceiveFrameBytes(); } } }
public byte[] sendReq(string request) { try { reqbuf = System.Text.Encoding.Default.GetBytes(request);; client.SendFrame(reqbuf); resbuf = client.ReceiveFrameBytes(); return(resbuf); } catch (Exception e) { Console.WriteLine("Network Error. Please check your ip address and network connection!"); System.Environment.Exit(0); } return(null); }
private Out RequestToRemoteResponseSocket(In din) { try { //向远端Rep 服务器请求并获取数据 using (var req = new RequestSocket(ResponseHostString) { Options = { } }) { req.Options.Identity = Encoding.UTF8.GetBytes(Guid.NewGuid().ToString("N")); req.SendFrame(din.ToProtobuf()); return(req.ReceiveFrameBytes().FromProtobuf <Out>()); //if (req.TrySendFrame(TimeSpan.FromMilliseconds(200),din.ToProtobuf())) //{ // if (req.TryReceiveFrameBytes(DefaultTimeOuTimeSpan, out var responseBytes)) // return responseBytes.FromProtobuf<Out>(); // else // { // if (Logger.IsWarnEnabled) // Logger.Warn("request to remote TryReceive timeout"); // } //} //else //{ // if (Logger.IsWarnEnabled) // Logger.Warn("request to remote TrySend timeout"); //} } } catch (Exception e) { if (Logger.IsErrorEnabled) { Logger.Error(e); } return(null); } return(null); }
public Account RequestAccount(int strategyID) { using (var requestSocket = new RequestSocket(requestSocketConnectionString)) { var msg = new NetMQMessage(1); msg.Append(BitConverter.GetBytes((byte)RequestMessageType.AccountRequest)); msg.Append(BitConverter.GetBytes(strategyID)); requestSocket.SendMultipartMessage(msg); // requestSocket.SendFrame(BitConverter.GetBytes(strategyID)); logger.Info(() => "Waiting for account ID from server."); var response = requestSocket.ReceiveFrameBytes(); using (var ms = new MemoryStream(response)) { logger.Info(() => "Account ID received from server."); return(MyUtils.ProtoBufDeserialize <Account>(ms)); } } }
public byte[] SendData(byte[] data) { try { socket.SendFrame(data); if (!isAsync) { byte[] response = socket.ReceiveFrameBytes(); return(response); } } catch (NetMQException e) { Logger.Error("Error sending data to ZeroMQ Socket address : {0} : {1}", new object[] { address, e.Message }); Console.WriteLine(); } return(null); }
public void RequestReply_Render() { ThreadPool.QueueUserWorkItem(state => { List <int[]> players = new List <int[]>(); var client = new RequestSocket(); client.Connect("tcp://" + RenderIP + ":5558"); try { var request = new Request() { UserId = Id }; using (var responseStream = new MemoryStream()) { Serializer.Serialize(responseStream, request); client.SendFrame(responseStream.ToArray()); } var receiveFrame = client.ReceiveFrameBytes(); var reply = Serializer.Deserialize <RenderResponse>(new MemoryStream(receiveFrame)); var mr = reply as RenderResponse; //TODO: Change to render response for (int i = 0; i < mr.Players.Count; i++) { players.Add(mr.Players[i]); } _gw.players.Clear(); for (int i = 0; i < players.Count; i++) { _gw.players.Add(players[i]); } _gw.RefreshGame(); _gw.DrawPlayers(); } catch (Exception e) { Console.WriteLine(e); } }); }
/// <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(MessageType.AddInstrument); // 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(MessageType.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)); } } }
public MessageFrame <THeader, TPayload> SendRequest(MessageFrame <THeader, TPayload> requestMessage) { var endPoint = Binding + "://" + _ipAddress + ":" + _tcpPort.ToString(); using (var requester = new RequestSocket(endPoint)) { // Connect requester.Connect(endPoint); // Send requester.SendFrame(ObjectToByteArray(requestMessage), false); // Receive //TODO: Implement time-out byte[] response = requester.ReceiveFrameBytes(); requestMessage = Deserialize <MessageFrame <THeader, TPayload> >(response); requester.Disconnect(endPoint); } return(requestMessage); }
public void CallDirectoryService() { ThreadPool.QueueUserWorkItem(state => { var req = new ServiceProvideRequest() { ServiceType = "move" }; var dirServiceSocket = new RequestSocket(); dirServiceSocket.Connect("tcp://" + _dirSerIp + ":8910"); while (!_stopLoops) { try { using (var reqStream = new MemoryStream()) { Serializer.Serialize(reqStream, req); dirServiceSocket.SendFrame(reqStream.ToArray()); } var receiveFrame = dirServiceSocket.ReceiveFrameBytes(); var request = Serializer.Deserialize <Message>(new MemoryStream(receiveFrame)) as ServiceProviderResponse; //Console.WriteLine(request.Address); if (!String.IsNullOrEmpty(request.Address)) { IP = request.Address; PubSub(); RequestReply(); } } catch (Exception e) { Console.WriteLine(e); } Thread.Sleep(1000); } }); }
public static async Task <int> Main(string[] args) { if (args.Length != 1) { await Console.Error.WriteLineAsync("Please specify the client name!"); return(1); } string clientName = args[0]; using (RequestSocket client = new RequestSocket()) { await Console.Out.WriteLineAsync($"Starting client '{clientName}'"); Message message = new Message(); message.Name = clientName; client.Connect("tcp://localhost:5556"); while (true) { message.Timestamp = DateTime.UtcNow.Ticks; message.Body = "update received"; byte[] clientMsg = message.ToByteArray(); client.SendFrame(clientMsg); await Console.Out.WriteLineAsync($"{message.ShowString()}"); byte[] reply = client.ReceiveFrameBytes(); Message replyMsg = Message.Parser.ParseFrom(reply); await Console.Out.WriteLineAsync($"{replyMsg.ShowString()}"); Thread.Sleep(5000); } } }
// Continuously prompts the user for input and relays it to the echo server static async Task RelayConsoleToEchoServer() { // TODO Console.WriteLine("Relaying console prompts to echo server"); using var req = new RequestSocket(">" + echoAddress); // continuously prompt for user input while (true) { // Read the console without blocking var userInput = await Task.Run(() => Console.ReadLine()); var txBytes = Encoding.UTF8.GetBytes(userInput); req.SendFrame(txBytes); Console.WriteLine("console sent: " + userInput); // wait for echo response var rxBytes = req.ReceiveFrameBytes(); var rx = Encoding.UTF8.GetString(rxBytes); Console.WriteLine("console got: " + rx); await Task.Delay(200); } }
static void DoClientRequest(RequestSocket cl, int idx, long loopCount) { cl.SendFrame(i64tobytes(loopCount + 1)); cl.ReceiveFrameBytes(); }
public override bool ReceivePacket(out byte[] data) { data = Client.ReceiveFrameBytes(); return(true); }
//! //! receiver function, receiving the initial scene from the katana server (executed in separate thread) //! public void sceneReceiver() { AsyncIO.ForceDotNet.Force(); using (var sceneReceiver = new RequestSocket()) { print("Trying to receive scene."); OnProgress(0.1f, "Init Scene Receiver.."); sceneReceiver.Connect("tcp://" + VPETSettings.Instance.serverIP + ":5565"); print("Server set up."); byte[] byteStream; // HEader print("header"); sceneReceiver.SendFrame("header"); byteStream = sceneReceiver.ReceiveFrameBytes(); print("byteStreamHeader size: " + byteStream.Length); if (doWriteScene) { writeBinary(byteStream, "header"); } sceneLoader.SceneDataHandler.HeaderByteData = byteStream; OnProgress(0.15f, "..Received Header.."); #if TRUNK // Materials print("materials"); sceneReceiver.SendFrame("materials"); byteStream = sceneReceiver.ReceiveFrameBytes(); print("byteStreamMatrilas size: " + byteStream.Length); if (doWriteScene) { writeBinary(byteStream, "materials"); } sceneLoader.SceneDataHandler.MaterialsByteData = byteStream; OnProgress(0.20f, "..Received Materials.."); #endif // Textures if (VPETSettings.Instance.doLoadTextures) { print("textures"); sceneReceiver.SendFrame("textures"); byteStream = sceneReceiver.ReceiveFrameBytes(); print("byteStreamTextures size: " + byteStream.Length); if (doWriteScene) { writeBinary(byteStream, "textures"); } sceneLoader.SceneDataHandler.TexturesByteData = byteStream; OnProgress(0.33f, "..Received Texture.."); } // Objects print("objects"); sceneReceiver.SendFrame("objects"); byteStream = sceneReceiver.ReceiveFrameBytes(); print("byteStreamObjects size: " + byteStream.Length); if (doWriteScene) { writeBinary(byteStream, "objects"); } sceneLoader.SceneDataHandler.ObjectsByteData = byteStream; OnProgress(0.80f, "..Received Objects.."); // Nodes print("nodes"); sceneReceiver.SendFrame("nodes"); byteStream = sceneReceiver.ReceiveFrameBytes(); print("byteStreamNodes size: " + byteStream.Length); if (doWriteScene) { writeBinary(byteStream, "nodes"); } sceneLoader.SceneDataHandler.NodesByteData = byteStream; OnProgress(0.9f, "..Received Nodes.."); // Characters print("characters"); sceneReceiver.SendFrame("characters"); byteStream = sceneReceiver.ReceiveFrameBytes(); print("byteStreamCharacters size: " + byteStream.Length); if (doWriteScene) { writeBinary(byteStream, "characters"); } sceneLoader.SceneDataHandler.CharactersByteData = byteStream; OnProgress(0.9f, "..Received Characters.."); sceneReceiver.Disconnect("tcp://" + VPETSettings.Instance.serverIP + ":5565"); sceneReceiver.Close(); sceneReceiver.Dispose(); } //NetMQConfig.Cleanup(); print("done receive scene"); m_sceneTransferDirty = true; OnProgress(1.0f, "..Building Scene.."); }
public void RequestReply() { ThreadPool.QueueUserWorkItem(state => { var client = new RequestSocket(); client.Connect("tcp://" + IP + ":5555"); while (!_stopLoops) { var key = Console.ReadLine(); if (key == "w" || key == "a" || key == "s" || key == "d") { try { var request = new MoveRequest { }; switch (key) { case "w": request = new MoveRequest { UserId = Id, Direction = new List <int> { 1, -1, 0 } }; break; case "a": request = new MoveRequest { UserId = Id, Direction = new List <int> { 1, -1, 0 } }; break; case "s": request = new MoveRequest { UserId = Id, Direction = new List <int> { 1, 0, -1 } }; break; case "d": request = new MoveRequest { UserId = Id, Direction = new List <int> { 1, 1, 0 } }; break; default: break; } /*var request = new MoveRequest * { * UserId = Id, * Direction = new List<int> { * 1, * _random.Next(), * _random.Next() * } * };*/ using (var responseStream = new MemoryStream()) { Serializer.Serialize(responseStream, request); client.SendFrame(responseStream.ToArray()); } var receiveFrame = client.ReceiveFrameBytes(); var reply = Serializer.Deserialize <Response>(new MemoryStream(receiveFrame)); var mr = reply as BooleanResponse; if (++counter % 30000 == 0) { Console.WriteLine("response {1}; Client: {0}", mr != null && mr.Ok, counter); } } catch (Exception e) { Console.WriteLine(e); } } } }); }