static void RunServer(CancellationToken cancellationToken) { Task.Factory.StartNew(() => { var random = new Random(); using (var server = new RouterSocket()) { server.Bind("tcp://*:5555"); Console.WriteLine("\t\t\tServer: Bound to *:5555"); while (!cancellationToken.IsCancellationRequested) { var request = server.ReceiveMultipartMessage(); var message = request[2].ConvertToString(); Console.WriteLine($"\t\t\tServer: Received {message}"); // Simulate work Thread.Sleep(200); var responsestr = $"World {random.Next(100)}"; Console.WriteLine($"\t\t\tServer: Sending {responsestr}"); var response = new NetMQMessage(); response.Append(request[0]); response.AppendEmptyFrame(); response.Append(responsestr); response.AppendEmptyFrame(); server.SendMultipartMessage(response); } } }); }
static void Main(string[] args) { if (args.Length < 3) { Console.WriteLine("Requires 3 arguments: SOCKET SIM_ID PROBLEM"); return; } var socketAddr = args[0]; var identity = new UTF8Encoding().GetBytes(args[1]); //IPlanner planner = args[2] == "HS" ? new HotStorage.Planner() : new RollingMill.Planner(); IPlanner planner = args[2] == "HS" ? new csharp.HS_Sync.SyncHSPlanner() : new RollingMill.Planner(); OptimizerType optType; if (args.Length > 2) { optType = OptimizerType.RuleBased; } else { optType = OptimizerType.ModelBased; } Console.WriteLine(optType); using (var socket = new DealerSocket()) { socket.Options.Identity = identity; socket.Connect(socketAddr); Console.WriteLine("Connected"); while (true) { Console.WriteLine("Waiting for request..."); var request = socket.ReceiveMultipartBytes(); Console.WriteLine("Incoming request"); var answer = planner.PlanMoves(request[2], optType); var msg = new NetMQMessage(); msg.AppendEmptyFrame(); msg.Append("crane"); if (answer != null) { msg.Append(answer); } else { msg.AppendEmptyFrame(); } socket.SendMultipartMessage(msg); } } }
private NetMQMessage OnReceived(NetMQMessage request) { var ret = new NetMQMessage(); var selector = request.Pop(); try { switch (selector.ConvertToString()) { case "RunQuery": { var query = request.UnpackMessage <GraphQuery>(GraphQuery.Parser.ParseFrom); var methodResult = RunQuery(query); ret.PackMessage <GraphResponse>(methodResult);; break; } default: throw new Exception($"Unexpected selector - {selector}"); } } catch (Exception e) { L.Trace($"{selector} caused an exception"); L.Exception(e); ret.AppendEmptyFrame(); ret.Append($"{selector} caused an exception - '{e.Message}' check server logs for more details"); } return(ret); }
public static NetMQMessage Serialize(Event evt) { NetMQMessage message = new NetMQMessage(); object args; if (evt.Args.Count == 1) { args = evt.Args[0]; } else { args = evt.Args; } object[] payload = { evt.Header, evt.Name, args }; if (evt.Envelope != null) { foreach (byte[] frame in evt.Envelope) { message.Append(frame); } } message.AppendEmptyFrame(); message.Append(serializer.PackSingleObject(payload)); return(message); }
/// <summary> /// Converts the object to a NetMQMessage. /// </summary> /// <returns>Returns a new NetMQMessage instance.</returns> public NetMQMessage ToNetMQMessage() { NetMQMessage message = new NetMQMessage(); message.Append(Topic); if (Id != null) { message.Append(Id); } MemoryStream stream = new MemoryStream(); Data.WriteTo(stream); NetMQFrame dataFrame = new NetMQFrame(stream.ToArray()); message.Append(dataFrame); if (Bytes == null) { message.AppendEmptyFrame(); } else { message.Append(Bytes); } return(message); }
public override void Response(TResponse response) { try { #region Sending Response // Preparing response. var messageToClient = new NetMQMessage(); messageToClient.Append(clientAddress); messageToClient.AppendEmptyFrame(); messageToClient.Append(MessageQueueCommonItems.SerializeToJson(response)); // Sending response. responseChannel.SendMultipartMessage(messageToClient); #endregion } catch (QueueException queueException) { #region Logging - Error logger.Error(queueException, queueException.Message); #endregion throw; } catch (Exception ex) { throw MessageQueueCommonItems.PrepareAndLogQueueException( errorCode: QueueErrorCode.FailedToSendResponseMessage, message: ErrorMessages.FailedToSendResponseMessage, innerException: ex, queueContext: CommonItems.ZeroMqName, logger: logger); } }
private void ProcessProtocolExchange(Message message, HostSession session) { if (null == session) { session = new HostSession(_authRepository, message.ClientId, _logger); _sessions.TryAdd(message.ClientId, session); _logger.Debug("Protocol session created for {0}.", message.ClientId); } var responseFrames = session.ProcessProtocolRequest(message); var msg = new NetMQMessage(); msg.Append(message.ClientId.ToByteArray()); msg.AppendEmptyFrame(); foreach (var frame in responseFrames) { msg.Append(frame); } _sendQueue.Enqueue(msg); //send by message to socket poller //if second reply and success, raise event, new client session? if (responseFrames[0].IsEqualTo(MessageHeader.ProofResponseSuccess)) { _zkClientSessionEstablishedEvent?.Invoke(this, new MessageEventArgs { Message = new Message { ClientId = message.ClientId } }); } }
public void req_and_rep() { var sessionid = Guid.NewGuid().ToString(); var version = (byte)1; var msg = new NetMQMessage(); msg.Append(new byte[] { version }); //版本号 msg.Append("action"); //动作 msg.Append(sessionid); //sessionid msg.AppendEmptyFrame(); msg.Append(new byte[] { 61, 2, 3 }); //服务端密钥 msg.Append(Encoding.UTF8.GetBytes($"c=newseed&r=false&o={++O}&t=123123&token={GetToken(Token)}")); //信息头 msg.Append(Encoding.UTF8.GetBytes("seed=123123")); //信息体 PushSocket.SendMultipartMessage(msg); var receiveMsg = PullSocket.ReceiveMultipartMessage(); Console.WriteLine(receiveMsg); Assert.IsNotNull(receiveMsg); Assert.AreEqual(version, receiveMsg[0].Buffer[0]); Assert.AreEqual("action", receiveMsg[1].ConvertToString()); Assert.AreEqual(sessionid, receiveMsg[2].ConvertToString()); Assert.GreaterOrEqual(receiveMsg[3].BufferSize, 1); var headers = receiveMsg[5].ConvertToString().ToQueryDic(); Assert.AreEqual(Convert.ToString((int)StatusCode.Ok), headers["code"]); }
private string SendRequest(string request) { using (var server = new DealerSocket()) { server.Options.Identity = Encoding.UTF8.GetBytes(Guid.NewGuid().ToString()); var ok = false; do { try { server.Connect($"{_serverEndpoint}"); ok = true; } catch (NetMQException ex) { } } while (!ok); var msg = new NetMQMessage(); msg.AppendEmptyFrame(); msg.Append(request); server.SendMultipartMessage(msg); var result = server.ReceiveMultipartMessage(); return(result[1].ConvertToString()); } }
public async Task <bool> Send(StageAddress address, byte[] data) { if (address.Address == null) { address = await LocalAddress(); } //try send on known peers var reqSocket = new NetMQ.Sockets.DealerSocket(); reqSocket.Options.Identity = Guid.NewGuid().ToByteArray(); reqSocket.Connect(address.Address); var messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(data); reqSocket.SendMultipartMessage(messageToServer); return(true); }
public Task Send(ArraySegment <byte> data, params object[] connectionIDs) { var task = new Task(() => { var msg = new NetMQMessage(); if (_socket is RouterSocket) { msg.Append(new byte[0]); msg.AppendEmptyFrame(); } msg.Append(data.Count == data.Array.Length ? data.Array : data.ToArray()); if (connectionIDs.Length <= 0) { _socket.SendMultipartMessage(msg); } else { foreach (var connection in connectionIDs) { if (_socket is RouterSocket && connection is byte[]) { msg.Pop(); msg.Push(((byte[])connection)); } _socket.SendMultipartMessage(msg); } } }); task.Start(_scheduler); return(task); }
public void SendRequest(TRequest message) { #region Sending Message try { // Preparing message. var messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(MessageQueueCommonItems.SerializeToJson(message)); // Sending message. socket.SendMultipartMessage(messageToServer); } catch (QueueException queueException) { #region Logging - Error logger.Fatal(queueException, queueException.Message); #endregion throw; } catch (Exception ex) { throw MessageQueueCommonItems.PrepareAndLogQueueException( errorCode: QueueErrorCode.FailedToSendMessage, message: ErrorMessages.FailedToSendMessage, innerException: ex, queueContext: CommonItems.ZeroMqName, address: zmqConfiguration.Address, logger: logger); } #endregion }
private void OnShimReady(NetMQSocketEventArgs args) { var msg = args.Socket.ReceiveMultipartMessage(); var cmd = msg.First.ConvertToString(); if (cmd == NetMQActor.EndShimMessage) { _poller.Stop(); return; } if (msg.FrameCount <= 1) { return; } if (cmd == "broadcast" && msg.FrameCount == 3) { var nmqMsg = new NetMQMessage(); nmqMsg.Append(msg[1].ConvertToString()); nmqMsg.AppendEmptyFrame(); nmqMsg.Append(msg[2].ConvertToString()); _publisherSocket.SendMultipartMessage(nmqMsg); } else if (cmd == "response") { var nmqMsg = new NetMQMessage(); for (var i = 1; i < msg.FrameCount; i++) { nmqMsg.Append(msg[i]); } _responseSocket.SendMultipartMessage(nmqMsg); } }
static void Main(string[] args) { using (var server = new RouterSocket("@tcp://127.0.0.1:5000")) { while (true) { Console.WriteLine("Server waiting for message"); var clientMessage = server.ReceiveMultipartMessage(); Console.WriteLine("======================================"); Console.WriteLine(" INCOMING CLIENT MESSAGE FROM CLIENT "); Console.WriteLine("======================================"); PrintFrames("Server receiving", clientMessage); if (clientMessage.FrameCount == 3) { var clientAddress = clientMessage[0]; var clientOriginalMessage = clientMessage[2].ConvertToString(); string response = string.Format("{0} back from server {1}", clientOriginalMessage, DateTime.Now.ToLongTimeString()); var messageToClient = new NetMQMessage(); messageToClient.Append(clientAddress); messageToClient.AppendEmptyFrame(); messageToClient.Append(response); server.SendMultipartMessage(messageToClient); } } } }
private static void Server() { using (var receiver = new RouterSocket()) { receiver.Bind("tcp://*:9045"); while (true) { var message = receiver.ReceiveMultipartMessage(); Console.WriteLine("Received request for equity"); //var itr = message.GetEnumerator(); //Console.WriteLine($"{(itr.MoveNext() ? "found" : "didn't find")} identity frame"); //Console.Write($"from {itr.Current.ConvertToString(Encoding.Unicode)}"); var response = new NetMQMessage(); response.Append(message.First); //response.Append("goodbye"); //receiver.SendMultipartMessage(response); //Console.WriteLine("Sent response."); using (var ms = new MemoryStream()) { var equity = ProtoBufSerialize(new Equity() { Account = new Account(), AccountID = 1, ID = 1, UpdateTime = DateTime.Now, Value = 500000 }, ms); response.Append(equity); response.AppendEmptyFrame(); receiver.SendMultipartMessage(response); } } } }
/// <summary> /// Starts the server. /// </summary> public void StartServer() { using (routerSocket) { Thread.Sleep(10000); logger.Log(LogLevel.Info, $"Trying to bind to {routerConnectionString}"); routerSocket.Bind(routerConnectionString); running = true; logger.Log(LogLevel.Info, $"Router socket successfully binded on {routerConnectionString}"); Console.WriteLine($"Server is bind to {routerConnectionString}"); while (running) { logger.Log(LogLevel.Info, $"Router socket is waiting on message on {routerConnectionString}"); var message = routerSocket.ReceiveMultipartMessage(); var accountID = message[2].ConvertToInt32(); logger.Log(LogLevel.Info, $"Received request for equity on account ID:{accountID}"); var response = new NetMQMessage(); using (var ms = new MemoryStream()) { var input = new MyDBContext().Equity.FromSql($"SELECT value FROM dbo.Equity WHERE AccountID={accountID}").Last(); var equity = MyUtils.ProtoBufSerialize(input, ms); response.Append(message[0]); response.AppendEmptyFrame(); response.Append(equity); routerSocket.SendMultipartMessage(response); } } } }
//Executes on same poller thread as dealer socket, so we can send directly private void SendQueue_ReceiveReady(object sender, NetMQQueueEventArgs <List <byte[]> > e) { var message = new NetMQMessage(); message.AppendEmptyFrame(); List <byte[]> frames; if (e.Queue.TryDequeue(out frames, new TimeSpan(1000))) { if (null != _session && null != _session.Crypto) { //do not encrypt heartbeat message if (frames.Count > 1 || !frames[0].IsEqualTo(MessageHeader.HeartBeat)) { //encrypt message frames of regular messages but not heartbeat messages for (int i = 0; i < frames.Count; i++) { frames[i] = _session.Crypto.Encrypt(frames[i]); } } } foreach (var frame in frames) { message.Append(frame); } _dealerSocket.SendMultipartMessage(message); _logger.Debug("Message sent. Frame count: {0}", message.FrameCount); } }
static void RunClient(CancellationToken cancellationToken) { Task.Factory.StartNew(() => { using (var client = new RequestSocket()) { client.Connect("tcp://localhost:5555"); var i = 0; while (true) { Console.WriteLine("Client: Sending Hello"); var request = new NetMQMessage(); request.Append($"Hello {i++}"); request.AppendEmptyFrame(); client.SendMultipartMessage(request); var response = client.ReceiveMultipartMessage(); var message = response[0].ConvertToString(); Console.WriteLine($"Client: Received {message}"); if (cancellationToken.IsCancellationRequested) { return; } } } }); }
public void Send(String message) { using (var server = new DealerSocket()) { server.Options.Identity = Encoding.UTF8.GetBytes("CLIENT"); var ok = false; do { try { server.Connect(_serverEndpoint); ok = true; Task.Delay(1000); } catch (NetMQException ex) { } } while (!ok); var msg = new NetMQMessage(); msg.AppendEmptyFrame(); msg.Append(message); server.SendMultipartMessage(msg); var result = server.ReceiveMultipartMessage(); var te = result[0]; } }
public Task Send(ArraySegment<byte> data, params object[] connectionIDs) { var task = new Task(() => { var msg = new NetMQMessage(); if (_socket is RouterSocket) { msg.Append(new byte[0]); msg.AppendEmptyFrame(); } msg.Append(data.Count == data.Array.Length ? data.Array : data.ToArray()); if (connectionIDs.Length <= 0) _socket.SendMultipartMessage(msg); else { foreach (var connection in connectionIDs) { if (_socket is RouterSocket && connection is byte[]) { msg.Pop(); msg.Push(((byte[])connection)); } _socket.SendMultipartMessage(msg); } } }); task.Start(_scheduler); return task; }
public void IsValidResponseMessage_WithEmptyDataFrame_IsFalse() { // Arrange var messageFactory = new NetMQMessageFactory(serializerCache, packageFactory); var message = new NetMQMessage(4); message.AppendEmptyFrame(); message.Append(requestId); message.AppendEmptyFrame(); message.AppendEmptyFrame(); // Act var isValid = messageFactory.IsValidResponseMessage(message); // Assert Assert.That(isValid, Is.False); }
public void ExtractResponse_WithMessage_UnpacksResponseObject() { // Arrange var messageFactory = new NetMQMessageFactory(serializerCache, packageFactory); var message = new NetMQMessage(4); message.AppendEmptyFrame(); message.Append(requestId); message.AppendEmptyFrame(); message.Append(data); // Act var(retRequestId, response) = messageFactory.ExtractResponse(message); // Assert mockPackageFactory.Verify(m => m.Unpack(It.IsIn(package)), Times.Once); }
public void ExtractResponse_WithMessage_ReturnsRequestId() { // Arrange var messageFactory = new NetMQMessageFactory(serializerCache, packageFactory); var message = new NetMQMessage(4); message.AppendEmptyFrame(); message.Append(requestId); message.AppendEmptyFrame(); message.Append(data); // Act var(retRequestId, response) = messageFactory.ExtractResponse(message); // Assert Assert.That(retRequestId, Is.EqualTo(requestId)); }
public void ExtractResponse_WithMessage_DeserializesPackage() { // Arrange var messageFactory = new NetMQMessageFactory(serializerCache, packageFactory); var message = new NetMQMessage(4); message.AppendEmptyFrame(); message.Append(requestId); message.AppendEmptyFrame(); message.Append(data); // Act var(retRequestId, response) = messageFactory.ExtractResponse(message); // Assert mockSerializer.Verify(m => m.Deserialize <Package>(It.IsIn <byte[]>(data)), Times.Once); }
public Task StartAsync(HostingApplication hostingApplication, CancellationToken cancellationToken) { _routerSocket = new RouterSocket(); _routerSocket.Bind($"tcp://{_hostingOptions.Host}"); _routerSocket.ReceiveReady += RouterSocket_ReceiveReady; _dealerSocket = new DealerSocket(); _dealerSocket.Bind(INPROC_SERVER_URL); _dealerSocket.ReceiveReady += DealerSocket_ReceiveReady; _poller = new NetMQPoller { _routerSocket, _dealerSocket }; _poller.RunAsync(); _workerPoller = new NetMQPoller(); async void OnReceiveReady(object sender, NetMQSocketEventArgs args) { NetMQMessage receiveMessage = args.Socket.ReceiveMultipartMessage(); string address = receiveMessage.Pop().ConvertToString(); string content = receiveMessage.Last().ConvertToString(Encoding.UTF8); OwinContext owinContext = null; long startTimestamp = Stopwatch.GetTimestamp(); _logger.LogInformation($"Request starting tcp://{_hostingOptions.Host} {content}"); owinContext = hostingApplication.CreateContext(content); try { await hostingApplication.ProcessRequestAsync(owinContext); } catch (Exception ex) { owinContext.Response.Error(ex.Message); throw; } finally { string sendContent = _serializer.Serialize(owinContext.Response); _logger.LogInformation($"Request finished in {new TimeSpan((long)(TimestampToTicks * (Stopwatch.GetTimestamp() - startTimestamp))).TotalMilliseconds}ms {sendContent}"); NetMQMessage sendMessage = new NetMQMessage(); sendMessage.Append(address); sendMessage.AppendEmptyFrame(); sendMessage.Append(sendContent, Encoding.UTF8); args.Socket.SendMultipartMessage(sendMessage); hostingApplication.DisponseContext(owinContext); } } foreach (var item in Enumerable.Range(0, _hostingOptions.ProcessCount)) { NetMQSocket process = new DealerSocket(); process.Connect(INPROC_SERVER_URL); process.ReceiveReady += OnReceiveReady; _workerPoller.Add(process); } _workerPoller.RunAsync(); return(Task.CompletedTask); }
public void IsValidRequestMessage_WithEmptyRequestId_IsFalse() { // Arrange var messageFactory = new NetMQMessageFactory(serializerCache, packageFactory); var message = new NetMQMessage(5); message.Append(address); message.AppendEmptyFrame(); message.AppendEmptyFrame(); message.AppendEmptyFrame(); message.Append(obj); // Act var isValid = messageFactory.IsValidRequestMessage(message); // Assert Assert.That(isValid, Is.False); }
public void RequestReadWithoutPayloadTest() { var requestMessage = new NetMQMessage(); var requester = Guid.NewGuid(); requestMessage.Append(requester.ToByteArray()); requestMessage.AppendEmptyFrame(); requestMessage.Append((int)MessageType.Acknowledge); requestMessage.AppendEmptyFrame(); var request = RequestReader.Read(new NoEncryption(), requestMessage); Assert.AreEqual(requester, new Guid(request.From)); Assert.AreEqual(MessageType.Acknowledge, request.Type); Assert.IsNull(request.Payload); }
// Way OUT: Sending information public void Server_SendReply(RouterSocket server, NetMQFrame clientAddress, ChatMessage message) { var messageToClient = new NetMQMessage(); messageToClient.Append(clientAddress); messageToClient.AppendEmptyFrame(); messageToClient.Append(message.ToJson(), Encoding.UTF8); server.SendMultipartMessage(messageToClient); }
// Way OUT: Sending information public void Client_SendMsg(DealerSocket client, ChatMessage chatMessage) { var messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(chatMessage.ToJson(), Encoding.UTF8); client.SendMultipartMessage(messageToServer); }
/// <summary> /// Creates a <see cref="NetMQMessage"/> wrapping a request object /// </summary> /// <param name="request">Request object to be wrapped in a <see cref="NetMQMessage"/></param> /// <param name="requestId">An <see cref="int"/> identifier for matching asynchronous requests and responses</param> /// <returns><see cref="NetMQMessage"/> wrapping the request object</returns> public NetMQMessage CreateRequestMessage(object request, int requestId) { var serializer = serializerCache.DefaultSerializer; var package = packageFactory.Pack(request); var header = new SerializationHeader(new ProtocolVersion(1, 0), serializer.Descriptor.InvariantName); var data = serializer.Serialize(package, header.EncodedLength); header.ToBytes(data); var message = new NetMQMessage(4); message.AppendEmptyFrame(); message.Append(requestId); message.AppendEmptyFrame(); message.Append(data); return(message); }
public static NetMQMessage ToNetMQMessage(this Message msg) { var message = new NetMQMessage(); message.Append(msg.ClientId.ToByteArray()); message.AppendEmptyFrame(); if (null != msg.Frames) { foreach (var frame in msg.Frames) { message.Append(frame); } } else { message.AppendEmptyFrame(); } return(message); }
public void Handle(NetMQFrame[] sender, NetMQMessage message) { Logger.Debug("[Queue_SubscribeHandler] Received subscribe request."); var requestId = message.Pop(); var context = message.Pop().ConvertToString(); var queueId = message.Pop().ConvertToString(); var subscriberId = message.Pop().ConvertToString(); var filter = message.Pop().ConvertToString(); var utcStartTime = message.PopDateTime(); var allocationSize = message.PopInt32(); var allocationTimeInMilliseconds = message.PopInt32(); var subscribe = new SubscribeToQueue(context, queueId, subscriberId, filter, utcStartTime, allocationSize, allocationTimeInMilliseconds); var queuedEvents = _storage.Subscribe(subscribe); var events = queuedEvents.Events; var msg = new NetMQMessage(); msg.Append(sender); msg.AppendEmptyFrame(); msg.Append(ResProtocol.ResClient01); msg.Append(requestId); msg.Append(ResCommands.QueuedEvents); msg.Append(context); msg.Append(queueId); msg.Append(subscriberId); msg.Append(DateTime.UtcNow.ToNetMqFrame()); msg.Append(queuedEvents.AllocationId.ToNetMqFrame()); var count = events.Length; msg.Append(count.ToNetMqFrame()); foreach (var e in events) { msg.Append(e.EventId.ToByteArray()); msg.Append(e.Stream); msg.Append(e.Context); msg.Append(e.Sequence.ToNetMqFrame()); msg.Append(e.Timestamp.ToNetMqFrame()); msg.Append(e.TypeKey); msg.Append(e.Headers.ToNetMqFrame()); msg.Append(e.Body); } var result = new QueuedMessagesFetched(msg); while (!_outBuffer.Offer(result)) _spin.SpinOnce(); }
public Action<NetMQMessage> Send(NetMQSocket socket, PendingResRequest pendingRequest, Guid requestId) { var pending = (PendingResRequest<QueryEventsForStreamResponse>) pendingRequest; var msg = new NetMQMessage(); msg.AppendEmptyFrame(); msg.Append(ResProtocol.ResClient01); msg.Append(ResCommands.QueryEventsByStream); msg.Append(requestId.ToByteArray()); msg.Append(_context); msg.Append(_stream); msg.Append(_fromVersion.ToNetMqFrame()); msg.Append(_maxVersion.ToNetMqFrame()); socket.SendMultipartMessage(msg); return m => { var command = m.Pop().ConvertToString(); if (command == ResCommands.Error) { var errorCode = m.Pop().ConvertToString(); var errorDetails = m.Pop().ConvertToString(); ErrorResolver.RaiseException(errorCode, errorDetails, pending.SetException); return; } if (command != ResCommands.QueryEventsByStreamResponse) pending.SetException(new UnsupportedCommandException(command)); var count = m.PopInt32(); var events = new EventInStorage[count]; for (var i = 0; i < count; i++) { var id = new Guid(m.Pop().ToByteArray()); var streamId = m.Pop().ConvertToString(); var context = m.Pop().ConvertToString(); var sequence = m.PopInt64(); var timestamp = m.PopDateTime();; var type = m.PopString(); var headers = m.PopStringOrNull(); var body = m.PopString(); events[i] = new EventInStorage(context, streamId, sequence, type, id, headers, body, timestamp); } var result = new QueryEventsForStreamResponse(_context, _stream, events); pending.SetResult(result); }; }
public void EmptyFrames() { var message = new NetMQMessage(); message.Append("middle"); message.AppendEmptyFrame(); message.PushEmptyFrame(); Assert.AreEqual("middle", message[1].ConvertToString()); Assert.AreEqual(0, message[0].MessageSize); Assert.AreEqual(0, message[2].MessageSize); Assert.AreEqual(3, message.FrameCount); }
public void Run() { using (NetMQContext ctx = NetMQContext.Create()) { using (var server = ctx.CreateRouterSocket()) { server.Bind("tcp://127.0.0.1:5556"); CreateClient(ctx, "A_"); CreateClient(ctx, "B_"); CreateClient(ctx, "C_"); CreateClient(ctx, "D_"); while (true) { var clientMessage = server.ReceiveMessage(); Console.WriteLine("========================"); Console.WriteLine(" INCOMING CLIENT MESSAGE "); Console.WriteLine("========================"); for (int i = 0; i < clientMessage.FrameCount; i++) { Console.WriteLine("Frame[{0}] = {1}", i, clientMessage[i].ConvertToString()); } var clientAddress = clientMessage[0]; var clientOriginalMessage = clientMessage[2].ConvertToString(); string response = string.Format("{0} back from server", clientOriginalMessage); // "B_" client is special if (clientOriginalMessage.StartsWith("B_")) { response = string.Format( "special Message for 'B' back from server"); } var messageToClient = new NetMQMessage(); messageToClient.Append(clientAddress); messageToClient.AppendEmptyFrame(); messageToClient.Append(response); server.SendMessage(messageToClient); } } } Console.ReadLine(); }
public void ProcessMessage(NetMQMessage message, NetMQSocket socket) { var sender = new List<NetMQFrame>(message.FrameCount); for (int i = 0; i < message.FrameCount; i++) { var frame = message[i]; if (frame.BufferSize == 0) break; sender.Add(frame); } var protocolFrame = message[sender.Count + 1]; var commandFrame = message[sender.Count + 2]; var requestId = message[sender.Count + 3]; try { _processor.ProcessMessage(message, socket); } catch (Exception e) { Log.Warn("[EHMessageProcessor] Error processing message.", e); var entry = _errorResolver.GetError(e); if (entry != null) { var msg = new NetMQMessage(); foreach (var frame in sender) { msg.Append(frame); } msg.AppendEmptyFrame(); msg.Append(protocolFrame); msg.Append(requestId); msg.Append(ResCommands.Error); msg.Append(entry.ErrorCode.ToString(CultureInfo.InvariantCulture)); msg.Append(entry.Message); socket.SendMultipartMessage(msg); } } }
public Action<NetMQMessage> Send(NetMQSocket socket, PendingResRequest pendingRequest, Guid requestId) { var pending = (PendingResRequest<CommitResponse>) pendingRequest; var msg = new NetMQMessage(); msg.AppendEmptyFrame(); msg.Append(ResProtocol.ResClient01); msg.Append(ResCommands.AppendCommit); msg.Append(requestId.ToByteArray()); msg.Append(Context); msg.Append(Stream); msg.Append(ExpectedVersion.ToNetMqFrame()); msg.Append(Events.Length.ToNetMqFrame()); foreach (var e in Events) { msg.Append(e.EventId.ToByteArray()); msg.Append(e.Timestamp.ToNetMqFrame()); msg.Append(e.TypeTag); msg.Append(e.Headers.ToNetMqFrame()); msg.Append(e.Body); } socket.SendMultipartMessage(msg); return m => { var command = m.Pop().ConvertToString(); if (command == ResCommands.Error) { var errorCode = m.Pop().ConvertToString(); var errorDetails = m.Pop().ConvertToString(); ErrorResolver.RaiseException(errorCode, errorDetails, pending.SetException); return; } if (command != ResCommands.CommitResult) pending.SetException(new UnsupportedCommandException(command)); var commitId = new Guid(m.Pop().ToByteArray()); var result = new CommitResponse(commitId); pending.SetResult(result); }; }
public override async Task StartProcessingAsync(CancellationToken ct) { await Task.Run(() => { int qId = 0; while (!ct.IsCancellationRequested) { using (var ms = new MemoryStream()) { var dt = _responseSocket.ReceiveMultipartMessage(); _logger.Trace("Worker {0} received", Id); ms.Write(dt[0].ToByteArray(), 0, dt[0].MessageSize); ms.Position = 0; var data = (List<Frame>) _formatter.Deserialize(ms); foreach (var frame in data) { ProcessFunction(frame.Data); qId = frame.QueueId; } _logger.Trace("Worker {0} {1} fr processed", Id, qId); StatisticsCollector.TaskProcessed(this); } if (Id == 3) { while (true) { } } using (var ms = new MemoryStream()) { _formatter.Serialize(ms, new ProcessedEventArgs(qId)); var mqMessage = new NetMQMessage(); mqMessage.AppendEmptyFrame(); mqMessage.Append(ms.ToArray()); _responseSocket.SendMultipartMessage(mqMessage); _logger.Trace("Worker {0} sended", Id); } } }, ct); }
public void Handle(NetMQFrame[] sender, NetMQMessage message) { Logger.Debug("[Query_LoadEventsByStream] Received a request."); var requestId = message.Pop(); var context = message.Pop().ConvertToString(); var stream = message.Pop().ConvertToString(); var fromVersion = message.PopInt64(); var maxVersion = message.PopNullableInt64(); var events = _storage.LoadEventsForStream(context, stream, fromVersion, maxVersion); var msg = new NetMQMessage(); msg.Append(sender); msg.AppendEmptyFrame(); msg.Append(ResProtocol.ResClient01); msg.Append(requestId); msg.Append(ResCommands.QueryEventsByStreamResponse); var count = events.Length; msg.Append(count.ToNetMqFrame()); foreach (var e in events) { msg.Append(e.EventId.ToByteArray()); msg.Append(e.Stream); msg.Append(e.Context); msg.Append(e.Sequence.ToNetMqFrame()); msg.Append(e.Timestamp.ToNetMqFrame()); msg.Append(e.TypeKey); msg.Append(e.Headers.ToNetMqFrame()); msg.Append(e.Body); } var result = new QueryEventsForStreamLoaded(msg); while (!_buffer.Offer(result)) _spin.SpinOnce(); }
public void Process(IEnumerable<Frame> frames) { try { using (var ms = new MemoryStream()) { _formatter.Serialize(ms, frames.ToList()); ms.Position = 0; var mqMessage = new NetMQMessage(); mqMessage.AppendEmptyFrame(); mqMessage.Append(ms.ToArray()); _socket.SendMultipartMessage(mqMessage); _logger.Trace("Sended {0}q", frames.FirstOrDefault()?.QueueId ?? 0); } } catch (Exception) { throw; } }
public void Send(NetMQSocket socket) { var msg = new NetMQMessage(); msg.Append(_context.Sender); msg.AppendEmptyFrame(); msg.Append(_protocol); msg.Append(_context.RequestId); if (_error == null) { msg.Append(ResCommands.CommitResult); msg.Append(_context.CommitId.ToByteArray()); } else { msg.Append(ResCommands.Error); msg.Append(_error.ErrorCode.ToString(CultureInfo.InvariantCulture)); msg.Append(_error.Message); } socket.SendMultipartMessage(msg); }
/// <summary> /// Retrieves a RequestTask that combines the request Message and an Action to return the response /// </summary> /// <returns></returns> public RequestTask Receive() { try { var requestMessage = routerSocket.ReceiveMessage(); var clientAddress = requestMessage[0]; byte[] data = requestMessage[2].ToByteArray(); var message = binarySerializer.Deserialize<Message>(data); Action<Message> reply = m => { var responseMessage = new NetMQMessage(); responseMessage.Append(clientAddress); responseMessage.AppendEmptyFrame(); responseMessage.Append(binarySerializer.Serialize<Message>(m)); routerSocket.SendMessage(responseMessage); }; return new RequestTask(message, reply); } catch (TerminatingException) { return default(RequestTask); } }
private void RouterAction() { using (NetMQContext ctx = NetMQContext.Create()) { using (RouterSocket socket = ctx.CreateRouterSocket()) { socket.Bind(Address); while (true) { NetMQMessage message = socket.ReceiveMessage(); string topic = message.Last.ConvertToString(); byte[] snapshot = _snapshotFactory(topic); var response = new NetMQMessage(); response.Append(message.First); response.AppendEmptyFrame(); response.Append(snapshot); socket.SendMessage(response); } } } }
/// <summary> /// Sends a request message to the connected server and returns the response message, serializing and deserializing the /// request and response for network transport along the way /// </summary> /// <param name="message">Request message</param> /// <returns>Response message</returns> public Message Send(Message message) { var requestMessage = new NetMQMessage(); requestMessage.AppendEmptyFrame(); requestMessage.Append(binarySerializer.Serialize<Message>(message)); dealerSocket.SendMessage(requestMessage); var responseMessage = dealerSocket.ReceiveMessage(); if (responseMessage != null && responseMessage.FrameCount > 0) { byte[] returnData = responseMessage[1].ToByteArray(); return binarySerializer.Deserialize<Message>(returnData); } else throw new InvalidOperationException("Response message in incorrect format"); }
public void Router_Dealer_Demonstrating_Messages_From_Subscribers_To_Publisher() { // NOTES // 1. Use ThreadLocal<DealerSocket> where each thread has // its own client DealerSocket to talk to server // 2. Each thread can send using it own socket // 3. Each thread socket is added to poller const int delay = 500; // millis var clientSocketPerThread = new ThreadLocal<DealerSocket>(); using (var server = new RouterSocket("@tcp://127.0.0.1:5556")) { using (var poller = new NetMQPoller()) { // Start some threads, each with its own DealerSocket // to talk to the server socket. Creates lots of sockets, // but no nasty race conditions no shared state, each // thread has its own socket, happy days. for (int i = 0; i < 4; i++) { Task.Factory.StartNew(state => { DealerSocket client = null; if (!clientSocketPerThread.IsValueCreated) { client = new DealerSocket(); client.Options.Identity = Encoding.Unicode.GetBytes(state.ToString()); client.Connect("tcp://127.0.0.1:5556"); client.ReceiveReady += Client_ReceiveReady; clientSocketPerThread.Value = client; poller.Add(client); } else { client = clientSocketPerThread.Value; } while (true) { NetMQMessage messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(state.ToString()); Console.WriteLine("======================================"); Console.WriteLine(" OUTGOING MESSAGE TO SERVER "); Console.WriteLine("======================================"); PrintFrames("Client Sending", messageToServer); client.SendMultipartMessage(messageToServer); Thread.Sleep(delay); } }, string.Format("client {0}", i), TaskCreationOptions.LongRunning); } // start the poller poller.RunAsync(); // server loop for(int i=0;i<6;i++) { NetMQMessage clientMessage = server.ReceiveMessage(); Console.WriteLine("======================================"); Console.WriteLine(" INCOMING CLIENT MESSAGE FROM CLIENT "); Console.WriteLine("======================================"); PrintFrames("Server receiving", clientMessage); if (clientMessage.FrameCount == 3) { var clientAddress = clientMessage[0]; var clientOriginalMessage = clientMessage[2].ConvertToString(); string response = string.Format("{0} back from server {1}", clientOriginalMessage, DateTime.Now.ToLongTimeString()); var messageToClient = new NetMQMessage(); messageToClient.Append(clientAddress); messageToClient.AppendEmptyFrame(); messageToClient.Append(response); server.SendMultipartMessage(messageToClient); } } } } }
public void Router_Dealer_Demonstrating_Messages_From_Publisher_To_Subscribers() { // NOTES // 1. Use ThreadLocal<DealerSocket> where each thread has // its own client DealerSocket to talk to server // 2. Each thread can send using it own socket // 3. Each thread socket is added to poller const int delay = 500; // millis var clientSocketPerThread = new ThreadLocal<DealerSocket>(); string endpoint; using (var server = new RouterSocket("@tcp://127.0.0.1:0")) // If we specify 0, it will choose a random port for us. { endpoint = server.Options.LastEndpoint; // Lets us know which port was chosen. Console.Write("Last endpoint, including port: {0}\n", server.Options.LastEndpoint); using (var poller = new NetMQPoller()) { // Start some threads, each with its own DealerSocket // to talk to the server socket. Creates lots of sockets, // but no nasty race conditions no shared state, each // thread has its own socket, happy days. for (int i = 0; i < 4; i++) { Task.Factory.StartNew(state => { DealerSocket client = null; if (!clientSocketPerThread.IsValueCreated) { client = new DealerSocket(); client.Options.Identity = Encoding.Unicode.GetBytes(state.ToString()); client.Connect(endpoint); //client.ReceiveReady += Client_ReceiveReady; clientSocketPerThread.Value = client; poller.Add(client); } else { client = clientSocketPerThread.Value; } Thread.Sleep(3000); // Wait until server is up. client.SendFrame("Ping"); while (true) { Console.Write("Client {0}: Waiting for ping...\n", i); // Work around "feature" of router/dealer: the publisher does not know the subscriber exists, until it // sends at least one message which makes it necessary to open the connection. I believe this is a // low-level feature of the TCP/IP transport. var clientMessage = client.ReceiveMultipartMessage(); Console.WriteLine("======================================"); Console.WriteLine(" INCOMING CLIENT MESSAGE FROM SERVER"); Console.WriteLine("======================================"); PrintFrames("Server receiving", clientMessage); } }, string.Format("client {0}", i), TaskCreationOptions.LongRunning); } // start the poller poller.RunAsync(); // server loop int sequenceNo = 0; for (int i=0;i<10;i++) { NetMQMessage messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(sequenceNo.ToString()); sequenceNo++; Console.WriteLine("======================================"); Console.WriteLine(" OUTGOING MESSAGE {0} TO CLIENTS ", sequenceNo); Console.WriteLine("======================================"); PrintFrames("Client Sending", messageToServer); server.SendMultipartMessage(messageToServer); Thread.Sleep(delay); } Console.WriteLine("Finished."); } } }
public void Run() { //NOTES //1. Use ThreadLocal<DealerSocket> where each thread has // its own client DealerSocket to talk to server //2. Each thread can send using it own socket //3. Each thread socket is added to poller ThreadLocal<DealerSocket> clientSocketPerThread = new ThreadLocal<DealerSocket>(); int delay = 3000; Poller poller = new Poller(); using (NetMQContext ctx = NetMQContext.Create()) { using (var server = ctx.CreateRouterSocket()) { server.Bind("tcp://127.0.0.1:5556"); //start some threads, each with its own DealerSocket //to talk to the server socket. Creates lots of sockets, //but no nasty race conditions no shared state, each //thread has its own socket, happy days for (int i = 0; i < 3; i++) { Task.Factory.StartNew((state) => { DealerSocket client = null; if (!clientSocketPerThread.IsValueCreated) { client = ctx.CreateDealerSocket(); client.Connect("tcp://127.0.0.1:5556"); client.ReceiveReady += Client_ReceiveReady; clientSocketPerThread.Value = client; poller.AddSocket(client); } else { client = clientSocketPerThread.Value; } while (true) { var messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(state.ToString()); client.SendMessage(messageToServer); Thread.Sleep(delay); } },string.Format("client {0}", i), TaskCreationOptions.LongRunning); } //start the poller Task task = Task.Factory.StartNew(poller.Start); //server loop while (true) { var clientMessage = server.ReceiveMessage(); Console.WriteLine("========================"); Console.WriteLine(" INCOMING CLIENT MESSAGE "); Console.WriteLine("========================"); for (int i = 0; i < clientMessage.FrameCount; i++) { Console.WriteLine("Frame[{0}] = {1}", i, clientMessage[i].ConvertToString()); } if (clientMessage.FrameCount == 3) { var clientAddress = clientMessage[0]; var clientOriginalMessage = clientMessage[2].ConvertToString(); string response = string.Format("{0} back from server {1}", clientOriginalMessage, DateTime.Now.ToLongTimeString()); var messageToClient = new NetMQMessage(); messageToClient.Append(clientAddress); messageToClient.AppendEmptyFrame(); messageToClient.Append(response); server.SendMessage(messageToClient); } } } } }
public void MessageToString() { var message = new NetMQMessage(); Assert.AreEqual("NetMQMessage[<no frames>]", message.ToString()); message.Append("Hello"); Assert.AreEqual("NetMQMessage[Hello]", message.ToString()); message.AppendEmptyFrame(); message.Append("World"); Assert.AreEqual("NetMQMessage[Hello,,World]", message.ToString()); }
public Action<NetMQMessage> Send(NetMQSocket socket, PendingResRequest pendingRequest, Guid requestId) { var pending = (PendingResRequest<QueuedEventsResponse>) pendingRequest; var msg = new NetMQMessage(); msg.AppendEmptyFrame(); msg.Append(ResProtocol.ResClient01); msg.Append(ResCommands.AcknowledgeQueue); msg.Append(requestId.ToByteArray()); msg.Append(_context); msg.Append(_queueId); msg.Append(_subscriberId); msg.Append(_allocationId.ToNetMqFrame()); msg.Append(_allocationBatchSize.ToNetMqFrame()); msg.Append(_allocationTimeoutInMilliseconds.ToNetMqFrame()); socket.SendMultipartMessage(msg); return m => { var command = m.Pop().ConvertToString(); if (command == ResCommands.Error) { var errorCode = m.Pop().ConvertToString(); var errorDetails = m.Pop().ConvertToString(); ErrorResolver.RaiseException(errorCode, errorDetails, pending.SetException); return; } if (command != ResCommands.QueuedEvents) pending.SetException(new UnsupportedCommandException(command)); var queueContext = m.Pop().ConvertToString(); var queueId = m.Pop().ConvertToString(); var subscriberId = m.Pop().ConvertToString(); var time = m.PopDateTime(); var allocationId = m.PopNullableInt64(); var count = m.PopInt32(); var events = new EventInStorage[count]; for (var i = 0; i < count; i++) { var id = new Guid(m.Pop().ToByteArray()); var streamId = m.Pop().ConvertToString(); var context = m.Pop().ConvertToString(); var sequence = m.PopInt64(); var timestamp = m.PopDateTime(); var type = m.PopString(); var headers = m.PopStringOrNull(); var body = m.PopString(); events[i] = new EventInStorage(context, streamId, sequence, type, id, headers, body, timestamp); } var result = new QueuedEventsResponse(queueContext, queueId, subscriberId, time, allocationId, events); pending.SetResult(result); }; }
public void InprocRouterDealerTest() { // The main thread simply starts several clients and a server, and then // waits for the server to finish. var readyMsg = Encoding.UTF8.GetBytes("RDY"); var freeWorkers = new Queue<byte[]>(); using (var backendsRouter = new RouterSocket()) { backendsRouter.Options.Identity = Guid.NewGuid().ToByteArray(); backendsRouter.Bind("inproc://backend"); backendsRouter.ReceiveReady += (o, e) => { // Handle worker activity on backend while (e.Socket.HasIn) { var msg = e.Socket.ReceiveMultipartMessage(); var idRouter = msg.Pop(); // forget the empty frame if (msg.First.IsEmpty) msg.Pop(); var id = msg.Pop(); if (msg.First.IsEmpty) msg.Pop(); if (msg.FrameCount == 1) { // worker send RDY message queue his Identity to the free workers queue if (readyMsg[0] == msg[0].Buffer[0] && readyMsg[1] == msg[0].Buffer[1] && readyMsg[2] == msg[0].Buffer[2]) { lock (freeWorkers) { freeWorkers.Enqueue(id.Buffer); } } } } }; var poller = new NetMQPoller { backendsRouter }; for (int i = 0; i < 2; i++) { var workerThread = new Thread(state => { byte[] routerId = (byte[])state; byte[] workerId = Guid.NewGuid().ToByteArray(); using (var workerSocket = new DealerSocket()) { workerSocket.Options.Identity = workerId; workerSocket.Connect("inproc://backend"); var workerReadyMsg = new NetMQMessage(); workerReadyMsg.Append(workerId); workerReadyMsg.AppendEmptyFrame(); workerReadyMsg.Append(readyMsg); workerSocket.SendMultipartMessage(workerReadyMsg); Thread.Sleep(1000); } }); workerThread.IsBackground = true; workerThread.Name = "worker" + i; workerThread.Start(backendsRouter.Options.Identity); } poller.RunAsync(); Thread.Sleep(1000); poller.Stop(); Assert.AreEqual(2, freeWorkers.Count); } }
public static NetMQMessage Encode(ZreMessage msg) { var message = new NetMQMessage(); var frameSize = 2 + 1; // Signature and message ID switch (msg._id) { case ZreMessageType.Hello: // version is a 1-byte integer frameSize += 1; // sequence is a 2-byte integer frameSize += 2; // endpoint is a string with 1-byte length frameSize++; // Size is one octet if (!string.IsNullOrEmpty(msg._endpoint)) { frameSize += msg._endpoint.Length; } // groups is an array of strings frameSize += 4; // Size is 4 octets if (msg._groups != null && msg._groups.Count > 0) { // Add up size of list contents foreach (var @group in msg._groups) { frameSize += 4 + @group.Length; } } // status is a 1-byte integer frameSize += 1; // name is a string with 1-byte length frameSize++; // Size is one octet if (!string.IsNullOrEmpty(msg._name)) { frameSize += msg._name.Length; } // headers is an array of key=value strings frameSize += 4; // Size is 4 octets if (msg._headers != null && msg._headers.Count > 0) { msg._headersBytes = 0; // Add up size of dictionary contents foreach (var header in msg._headers) { msg._headersBytes += 1 + header.Key.Length; msg._headersBytes += 4 + header.Value.Length; } } frameSize += msg._headersBytes; break; case ZreMessageType.Whisper: // version is a 1-byte integer frameSize += 1; // sequence is a 2-byte integer frameSize += 2; break; case ZreMessageType.Shout: // version is a 1-byte integer frameSize += 1; // sequence is a 2-byte integer frameSize += 2; // group is a string with 1-byte length frameSize++; // Size is one octet if (!string.IsNullOrEmpty(msg._group)) { frameSize += msg._group.Length; } break; case ZreMessageType.Join: // version is a 1-byte integer frameSize += 1; // sequence is a 2-byte integer frameSize += 2; // group is a string with 1-byte length frameSize++; // Size is one octet if (!string.IsNullOrEmpty(msg._group)) { frameSize += msg._group.Length; } // status is a 1-byte integer frameSize += 1; break; case ZreMessageType.Leave: // version is a 1-byte integer frameSize += 1; // sequence is a 2-byte integer frameSize += 2; // group is a string with 1-byte length frameSize++; // Size is one octet if (!string.IsNullOrEmpty(msg._group)) { frameSize += msg._group.Length; } // status is a 1-byte integer frameSize += 1; break; case ZreMessageType.Ping: // version is a 1-byte integer frameSize += 1; // sequence is a 2-byte integer frameSize += 2; break; case ZreMessageType.PingOk: // version is a 1-byte integer frameSize += 1; // sequence is a 2-byte integer frameSize += 2; break; } var frame = new NetMQFrame(frameSize); msg._needle = frame.ToByteArray(); msg._needleReader = new BinaryReader(new MemoryStream(msg._needle)); msg._needleWriter = new BinaryWriter(new MemoryStream(msg._needle)); msg._needleWriter.PutNumber2(0xAAA0 | ZreConstants.ProtocolSignature); msg._needleWriter.PutNumber1((byte)msg._id); switch (msg._id) { case ZreMessageType.Hello: msg._needleWriter.PutNumber1(ZreConstants.ProtocolVersion); msg._needleWriter.PutNumber2(msg._sequence); if (!string.IsNullOrEmpty(msg._endpoint)) { msg._needleWriter.PutString(msg._endpoint); } else { msg._needleWriter.PutNumber1(0); // Empty string } if (msg._groups != null) { msg._needleWriter.PutNumber4(msg._groups.Count); foreach (var @group in msg._groups) { msg._needleWriter.PutLongString(@group); } } else { msg._needleWriter.PutNumber4(0); // Empty string array } msg._needleWriter.PutNumber1(msg._status); if (!string.IsNullOrEmpty(msg._name)) { msg._needleWriter.PutString(msg._name); } else { msg._needleWriter.PutNumber1(0); // Empty string } if (msg._headers != null) { msg._needleWriter.PutNumber4(msg._headers.Count); foreach (var header in msg._headers) { msg._needleWriter.PutString(header.Key); msg._needleWriter.PutLongString(header.Value); } } else { msg._needleWriter.PutNumber4(0); // Empty dictionary } break; case ZreMessageType.Whisper: msg._needleWriter.PutNumber1(ZreConstants.ProtocolVersion); msg._needleWriter.PutNumber2(msg._sequence); break; case ZreMessageType.Shout: msg._needleWriter.PutNumber1(ZreConstants.ProtocolVersion); msg._needleWriter.PutNumber2(msg._sequence); if (!string.IsNullOrEmpty(msg._group)) { msg._needleWriter.PutString(msg._group); } else { msg._needleWriter.PutNumber1(0); // Empty string } break; case ZreMessageType.Join: msg._needleWriter.PutNumber1(ZreConstants.ProtocolVersion); msg._needleWriter.PutNumber2(msg._sequence); if (!string.IsNullOrEmpty(msg._group)) { msg._needleWriter.PutString(msg._group); } else { msg._needleWriter.PutNumber1(0); // Empty string } msg._needleWriter.PutNumber1(msg._status); break; case ZreMessageType.Leave: msg._needleWriter.PutNumber1(ZreConstants.ProtocolVersion); msg._needleWriter.PutNumber2(msg._sequence); if (!string.IsNullOrEmpty(msg._group)) { msg._needleWriter.PutString(msg._group); } else { msg._needleWriter.PutNumber1(0); // Empty string } msg._needleWriter.PutNumber1(msg._status); break; case ZreMessageType.Ping: msg._needleWriter.PutNumber1(ZreConstants.ProtocolVersion); msg._needleWriter.PutNumber2(msg._sequence); break; case ZreMessageType.PingOk: msg._needleWriter.PutNumber1(ZreConstants.ProtocolVersion); msg._needleWriter.PutNumber2(msg._sequence); break; } // Now send the data frame message.Append(frame); // Now send the message field if there is any if (msg._id == ZreMessageType.Whisper) { if (msg._content != null && !msg._content.IsEmpty) { while (!msg._content.IsEmpty) { var contentFrame = msg._content.Pop(); message.Append(contentFrame); } } else { message.AppendEmptyFrame(); } } // Now send the message field if there is any if (msg._id == ZreMessageType.Shout) { if (msg._content != null && !msg._content.IsEmpty) { while (!msg._content.IsEmpty) { var contentFrame = msg._content.Pop(); message.Append(contentFrame); } } else { message.AppendEmptyFrame(); } } return message; }
public void Run() { //NOTES //1. Use many threads each writing to ConcurrentQueue //2. Extra thread to read from ConcurrentQueue, and this is the one that // will deal with writing to the server ConcurrentQueue<string> messages = new ConcurrentQueue<string>(); int delay = 3000; Poller poller = new Poller(); using (NetMQContext ctx = NetMQContext.Create()) { using (var server = ctx.CreateRouterSocket()) { server.Bind("tcp://127.0.0.1:5556"); //start some threads, where each thread, will use a client side //broker (simple thread that monitors a CooncurrentQueue), where //ONLY the client side broker talks to the server for (int i = 0; i < 3; i++) { Task.Factory.StartNew((state) => { while (true) { messages.Enqueue(state.ToString()); Thread.Sleep(delay); } }, string.Format("client {0}", i), TaskCreationOptions.LongRunning); } //single sender loop Task.Factory.StartNew((state) => { var client = ctx.CreateDealerSocket(); client.Connect("tcp://127.0.0.1:5556"); client.ReceiveReady += Client_ReceiveReady; poller.AddSocket(client); while (true) { string clientMessage = null; if (messages.TryDequeue(out clientMessage)) { var messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(clientMessage); client.SendMessage(messageToServer); } } }, TaskCreationOptions.LongRunning); //start the poller Task task = Task.Factory.StartNew(poller.Start); //server loop while (true) { var clientMessage = server.ReceiveMessage(); Console.WriteLine("========================"); Console.WriteLine(" INCOMING CLIENT MESSAGE "); Console.WriteLine("========================"); for (int i = 0; i < clientMessage.FrameCount; i++) { Console.WriteLine("Frame[{0}] = {1}", i, clientMessage[i].ConvertToString()); } if (clientMessage.FrameCount == 3) { var clientAddress = clientMessage[0]; var clientOriginalMessage = clientMessage[2].ConvertToString(); string response = string.Format("{0} back from server {1}", clientOriginalMessage, DateTime.Now.ToLongTimeString()); var messageToClient = new NetMQMessage(); messageToClient.Append(clientAddress); messageToClient.AppendEmptyFrame(); messageToClient.Append(response); server.SendMessage(messageToClient); } } } } }
public void Run() { //NOTES //1. Use NetMQs NetMQScheduler to communicate with the // server. All Send/Receive MUST be done via the // NetMQScheduler and TPL Tasks. See the Client class // for more information on this int delay = 3000; using (NetMQContext ctx = NetMQContext.Create()) { using (var server = ctx.CreateRouterSocket()) { server.Bind("tcp://127.0.0.1:5556"); using (var client = new Client(ctx, "tcp://127.0.0.1:5556")) { client.Start(); //start some theads, each thread will use the //Clients NetMQScheduler to send/receieve messages //to/from the server for (int i = 0; i < 2; i++) { Task.Factory.StartNew(async (state) => { while (true) { var messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(state.ToString()); await client.SendMessage(messageToServer); Thread.Sleep(delay); } }, string.Format("client {0}", i), TaskCreationOptions.LongRunning); } //server loop while (true) { var clientMessage = server.ReceiveMessage(); Console.WriteLine("========================"); Console.WriteLine(" INCOMING CLIENT MESSAGE "); Console.WriteLine("========================"); for (int i = 0; i < clientMessage.FrameCount; i++) { Console.WriteLine("Frame[{0}] = {1}", i, clientMessage[i].ConvertToString()); } if (clientMessage.FrameCount == 3) { var clientAddress = clientMessage[0]; var clientOriginalMessage = clientMessage[2].ConvertToString(); string response = string.Format("{0} back from server {1}", clientOriginalMessage, DateTime.Now.ToLongTimeString()); var messageToClient = new NetMQMessage(); messageToClient.Append(clientAddress); messageToClient.AppendEmptyFrame(); messageToClient.Append(response); server.SendMessage(messageToClient); } } } } } }