public static NetMQMessage CreateMessage(string topic, byte[] data) { var message = new NetMQMessage(); if (!string.IsNullOrEmpty(topic)) message.Append(Encoding.Unicode.GetBytes(topic)); message.Append(data); return message; }
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 static NetMQMessage CreateMessage(string topic, string data) { var msg = new NetMQMessage(); msg.Append(topic); msg.Append(data); return(msg); }
protected static NetMQMessage GenerateBaseMessage(int serverModuleID, int callID) { NetMQMessage message = new NetMQMessage(); message.Append(GetFrame(serverModuleID)); message.Append(GetFrame(callID)); return(message); }
protected static NetMQMessage GenerateRegisterServermoduleMessage(NetMQMessage message, RegisterServermoduleMethod method) { message.Append(GetFrame(RegisterServermoduleMethod.METHOD_NAME)); message.Append(ConvertToJson(method.TargetType)); message.Append(ConvertToJson(method.ConnectionInfo)); return(message); }
/// <summary> /// 移动结束 /// </summary> public void MoveStop(string MoveStopInfo) { NetMQMessage msg = new NetMQMessage(); msg.Append(WarMsgConsts.MoveStopReq); msg.Append(MoveStopInfo); reqCli.send(msg); }
/// <summary> /// 加入战斗 /// </summary> /// <param name="ClientID">Client ID</param> public void Join(string ClientInfo) { NetMQMessage msg = new NetMQMessage(); msg.Append(WarMsgConsts.JOINReq); msg.Append(ClientInfo); reqCli.send(msg); }
/// <summary> /// 切换激活状态的英雄 /// </summary> /// <param name="active">Active.</param> public void Switch(string activeInfo) { NetMQMessage msg = new NetMQMessage(); msg.Append(WarMsgConsts.SwitchReq); msg.Append(activeInfo); reqCli.send(msg); }
public void StopDevice(string name) { var messageToServer = new NetMQMessage(); messageToServer.Append(name); messageToServer.Append("Stop"); commandSocket.SendMultipartMessage(messageToServer); }
/// <summary> /// 切换手动和自动 /// </summary> /// <param name="autoInfo">Auto info.</param> public void ManualAuto(string autoInfo) { NetMQMessage msg = new NetMQMessage(); msg.Append(WarMsgConsts.ManualOrAutoReq); msg.Append(autoInfo); reqCli.send(msg); }
public NetMQMessage ToNetMQMessage() { NetMQMessage msg = new NetMQMessage(); msg.Append(address.ToString()); //Origin msg.Append(value); //Message contents return(msg); }
public void AskForScenery() { var msg = new NetMQMessage(); msg.Append((int)NetworkMessageType.ask); msg.Append((int)NetworkContentType.scenery_name); socket.SendMultipartMessage(msg); }
//most basic method with no real purpose protected static NetMQMessage GenerateHelloWorldMessage(NetMQMessage message, HelloWorldMethod method) { message.Append(GetFrame(HelloWorldMethod.METHOD_NAME)); //AppendMethodIdFrame(message, method.MethodId); message.Append(GetFrame(method.param1)); return(message); }
private NetMQMessage GetSmallPayloadMessage() { var message = new NetMQMessage(); message.Append(BitConverter.GetBytes((int)RequestType.GetSmallPayload)); message.Append("API Version 1.0"); return(message); }
// 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); }
/// <summary> /// /// </summary> /// <param name="message"></param> public bool Send(NetMessage message) { var frames = new NetMQMessage(); frames.Append(Identity); frames.Append(message.Serialize()); FireSlaveOutgoingMessage(this, message); return(NetworkService.Instance.Send(frames)); }
/// <summary> /// Return a new NetMQMessage that holds three frames: /// 1. contains a byte with the <see cref="HandshakeType"/>, /// 2. contains the RandomNumber (a byte-array), /// 3. contains a 2-byte array containing zero, and a byte representing the CipherSuite. /// </summary> /// <returns>the resulting new NetMQMessage</returns> public override NetMQMessage ToNetMQMessage() { NetMQMessage message = base.ToNetMQMessage(); message.Append(RandomNumber); message.Append(new byte[] { 0, (byte)CipherSuite }); return(message); }
public static void Send(RequestSocket socket, int intent, string message) { NetMQMessage messageFrames = new NetMQMessage(2); messageFrames.Append(new byte[] { (byte)intent }); messageFrames.Append(message); socket.SendMultipartMessage(messageFrames); }
private static NetMQMessage GetAlertLayer(byte[] bytes, ref int offset) { NetMQMessage sslMessage = new NetMQMessage(); sslMessage.Append(new byte[] { bytes[offset] }); sslMessage.Append(new byte[] { bytes[offset + 1] }); offset += 2; return(sslMessage); }
/// <summary> /// Creates a <see cref="NetMQMessage"/> wrapping a topic event /// </summary> /// <param name="topicEvent">Topic event to be wrapped in a <see cref="NetMQMessage"/></param> /// <returns><see cref="NetMQMessage"/> wrapping a topic event</returns> public NetMQMessage CreateTopicMessage(object topicEvent) { var package = packageFactory.Pack(topicEvent); var message = new NetMQMessage(2); message.Append(topicEvent.GetType().FullName); message.Append(serializerCache.DefaultSerializer.Serialize(package)); return(message); }
public static void Send(this IOutgoingSocket socket, RawMessage message) { NetMQMessage mqMessage = new NetMQMessage(); mqMessage.Append(message.Topic); mqMessage.Append(message.Header); mqMessage.Append(message.Body, Encoding.UTF8); socket.SendMultipartMessage(mqMessage); }
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); }
protected internal override NetMQMessage ToNetMqMessage() { var msg = new NetMQMessage(); msg.Append(TypeFrame); msg.Append(Payload); return(msg); }
public override void PlugConnectionRequest(InputPlug input, OutputPlug output) { NetMQMessage msg = new NetMQMessage(3); msg.Append(Endpoint.Commands.PLUG_CONNECT.ToString()); msg.Append(input.Path.ToString()); msg.Append(output.Path.ToString()); Whisper(Uuid, msg); }
/// <summary> /// Creates the history request. /// </summary> /// <param name="subscriptionsRequest">The subscriptions.</param> /// <param name="start">The start.</param> /// <param name="end">The end.</param> /// <param name="isbackfilling">if set to <c>true</c> [is backfilling].</param> /// <returns></returns> internal static NetMQMessage CreateHistoryRequest(DataSubscriptionRequest[] subscriptionsRequest, DateTime start, DateTime end, bool isbackfilling) { var toreturn = new NetMQMessage(); toreturn.Append(isbackfilling ? Topic.BackfillingMessage : Topic.HistoryMessage); toreturn.Append(start.ToUnixTime().ToString()); toreturn.Append(end.ToUnixTime().ToString()); subscriptionsRequest.ForEach(x => toreturn.Append(x.Serialize())); return(toreturn); }
public void SendMessage(Guid clientId, string content) { var messageToClient = new NetMQMessage(); messageToClient.Append(clientId.ToByteArray()); messageToClient.AppendEmptyFrame(); messageToClient.Append(content); _router.SendMultipartMessage(messageToClient); }
public void SendRequestMessage(Dictionary <string, object> data) { NetMQMessage m = new NetMQMessage(); m.Append("notify." + data["subject"]); m.Append(MessagePackSerializer.Serialize <Dictionary <string, object> >(data)); requestSocket.SendMultipartMessage(m); ReceiveRequestResponse(); }
public void AppendInt32() { NetMQMessage message = new NetMQMessage(); message.Append("Hello"); message.Append(5); Assert.AreEqual(4, message[1].MessageSize); Assert.AreEqual(5, message[1].ConvertToInt32()); }
private NetMQMessage CreateRequest(TArgument argument) { var request = new NetMQMessage(); request.Append((int)MessageType.InvokeCapability); request.Append(_encryptor.Encrypt(JsonConvert.SerializeObject(_info))); request.Append(_encryptor.Encrypt(JsonConvert.SerializeObject(argument))); return(request); }
public void Send(NetMQSocket socket) { NetMQMessage message = new NetMQMessage(); message.Append(BitConverter.GetBytes(IndexStart)); message.Append(BitConverter.GetBytes(IndexCount)); message.Append(BitConverter.GetBytes(ByteStart)); message.Append(BitConverter.GetBytes(ByteCount)); socket.SendMessage(message); }
private NetMQMessage GetLargePayloadMessage(MeteoriteLandingList meteoriteLandings) { var message = new NetMQMessage(); message.Append(BitConverter.GetBytes((int)RequestType.PostLargePayload)); message.Append(meteoriteLandings.ToByteArray()); return(message); }
public void AppendInt32() { var message = new NetMQMessage(); message.Append("Hello"); message.Append(5); Assert.Equal(4, message[1].MessageSize); Assert.Equal(5, message[1].ConvertToInt32()); }
public void PushOrdersInfo(object objectToSend, PushMessageType messageType) { using (var ms = new MemoryStream()) { var messageToSend = new NetMQMessage(2); messageToSend.Append(BitConverter.GetBytes((byte)messageType)); messageToSend.Append(MyUtils.ProtoBufSerialize(objectToSend, ms)); pushSocket.SendMultipartMessage(messageToSend); } }
public void CallMethod_Using_NProxyWrapper_ReadMessageWithRawActor() { waitHandle.Reset(); using (var context = NetMQContext.Create()) { using (var exchange = new Exchange(context)) { exchange.Start(); var queueDevice = new QueueDevice( context, Pipe.PubSubControlBackAddressServer, Pipe.PubSubControlFrontAddressServer, DeviceMode.Threaded); queueDevice.Start(); Thread.Sleep(200); var task = Task.Run(() => { return RunSubscriber(context); }); using (var actor = new Actor(context, new BinarySerializer())) { using (var syncService = context.CreateResponseSocket()) { syncService.Connect(Pipe.PubSubControlFrontAddressClient); for (int i = 0; i < 1; i++) { syncService.Receive(); syncService.Send(string.Empty); } var order = actor.CreateInstance<IOrder>(typeof(Order)); Assert.IsInstanceOfType(order, typeof(IOrder)); order.UpdateDescription("XXX"); //called without exception waitHandle.WaitOne(); var netMqMessage = new NetMQMessage(); netMqMessage.Append(new NetMQFrame(string.Empty)); netMqMessage.Append(new NetMQFrame("shutdownallactors")); actor.OutputChannel.SendMessage(netMqMessage); //actor.SendKillSignal(actor.Serializer, actor.OutputChannel, string.Empty); } } Thread.Sleep(200); queueDevice.Stop(true); exchange.Stop(true); } } }
public void AppendInt64() { long num = (long)int.MaxValue + 1; NetMQMessage message = new NetMQMessage(); message.Append("Hello"); message.Append(num); Assert.AreEqual(8, message[1].MessageSize); Assert.AreEqual(num, message[1].ConvertToInt64()); }
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 virtual NetMQMessage ToNetMQMessage() { NetMQMessage message = new NetMQMessage(); message.Append(new byte[] { (byte)HandshakeType }); return message; }
public void RequestResponseMultipartMessageWithRetryFails() { const string address = "tcp://127.0.0.1:50002"; const string pubAddress = "tcp://127.0.0.1:60002"; 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 RouterSocket(address)) { progressSubscriber.SubscribeToAnyTopic(); var progressProactor = new NetMQProactor(progressSubscriber, (socket, message) => Console.WriteLine("C: {0} {1:ss.fff}", message[0].ConvertToString(), DateTime.Now)); var serverProactor = new NetMQProactor(server, (socket, message) => { Console.WriteLine("ResponseEcho recieved message {0} at {1:ss.fff}", message[2].ConvertToString(), DateTime.Now); }); using (serverProactor) using (progressProactor) { var responseMessage = RequestSocket.RequestResponseMultipartMessageWithRetry(address, requestMessage, numTries, requestTimeout, progressPublisher); Assert.IsNull(responseMessage); } } }
public void DesktopClient_WillAccept_SinglePartMessages() { Queue<Packet> packets = new Queue<Packet>(); // Mock the the message handler processor var messageHandler = new Mock<IDesktopMessageHandler>(); messageHandler.Setup(mh => mh.DisplayLogPacket(It.IsAny<LogPacket>())).Callback( (LogPacket packet) => { packets.Enqueue(packet); }).Verifiable(); // Setup Client StartClientThread(messageHandler.Object); using (PushSocket server = new PushSocket("@tcp://*:" + _port)) { var message = new NetMQMessage(); message.Append(JsonConvert.SerializeObject(new LogPacket())); server.SendMultipartMessage(message); } // Give NetMQ time to send the message Thread.Sleep(500); Assert.IsTrue(packets.Count == 1); }
private static void Main(string[] args) { using (NetMQContext context = NetMQContext.Create()) { ReliableServer server = new ReliableServer(context, "tcp://*:6669"); while (true) { NetMQMessage message = new NetMQMessage(); message.Append("A"); message.Append(new Random().Next().ToString()); server.Publish(message); Thread.Sleep(1000); } } }
public void SendMoreTest() { using (NetMQContext ctx = NetMQContext.Create()) { using (var server = ctx.CreateResponseSocket()) { server.Bind("tcp://127.0.0.1:5556"); using (var client = ctx.CreateRequestSocket()) { client.Connect("tcp://127.0.0.1:5556"); //client send message client.SendMore("A"); client.Send("Hello"); //server receive 1st part bool more; string m = server.ReceiveString(out more); Assert.AreEqual("A", m); Assert.IsTrue(more); //server receive 2nd part string m2 = server.ReceiveString(out more); Assert.AreEqual("Hello", m2); Assert.False(more); //server send message, this time use NetMqMessage //which will be sent as frames if the client calls //ReceieveMessage() var m3 = new NetMQMessage(); m3.Append("From"); m3.Append("Server"); server.SendMessage(m3); //client receive var m4 = client.ReceiveMessage(); Assert.AreEqual(2, m4.FrameCount); Assert.AreEqual("From", m4[0].ConvertToString()); Assert.AreEqual("Server", m4[1].ConvertToString()); } } } }
public void TwoFrames() { var message = new NetMQMessage(); Assert.AreEqual(0, message.FrameCount); Assert.True(message.IsEmpty); message.Append("Hello"); message.Append("Hello2"); Assert.AreEqual("Hello", message[0].ConvertToString()); Assert.AreEqual("Hello2", message[1].ConvertToString()); Assert.False(message.IsEmpty); Assert.AreSame(message[0], message.First); Assert.AreSame(message[1], message.Last); Assert.AreNotSame(message[0], message[1]); Assert.AreEqual(2, message.FrameCount); }
public static void ReceiveMessage(this IReceivingSocket socket, NetMQMessage message, bool dontWait = false) { message.Clear(); bool more = true; while (more) { byte[] buffer = socket.Receive(dontWait, out more); message.Append(buffer); } }
public void ClientToServerMessage() { NetMQMessage plainMessage = new NetMQMessage(); plainMessage.Append("Hello"); NetMQMessage cipherMessage = m_clientSecureChannel.EncryptApplicationMessage(plainMessage); NetMQMessage decryptedMessage = m_serverSecureChannel.DecryptApplicationMessage(cipherMessage); Assert.AreEqual(decryptedMessage[0].ConvertToString(), plainMessage[0].ConvertToString()); Assert.AreEqual(decryptedMessage[0].ConvertToString(), "Hello"); }
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 ChangeThePadding() { NetMQMessage plainMessage = new NetMQMessage(); plainMessage.Append("Hello"); NetMQMessage cipherMessage = m_serverSecureChannel.EncryptApplicationMessage(plainMessage); cipherMessage.Last.Buffer[15]++; NetMQSecurityException exception = Assert.Throws<NetMQSecurityException>(() => m_clientSecureChannel.DecryptApplicationMessage(cipherMessage)); Assert.AreEqual(NetMQSecurityErrorCode.MACNotMatched, exception.ErrorCode); }
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); }; }
/// <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); } } } }
public void ChangeEncryptedFrameLength() { NetMQMessage plainMessage = new NetMQMessage(); plainMessage.Append("Hello"); NetMQMessage cipherMessage = m_serverSecureChannel.EncryptApplicationMessage(plainMessage); cipherMessage.RemoveFrame(cipherMessage.Last); // appending new framew with length different then block size cipherMessage.Append("Hello"); NetMQSecurityException exception = Assert.Throws<NetMQSecurityException>(() => m_clientSecureChannel.DecryptApplicationMessage(cipherMessage)); Assert.AreEqual(NetMQSecurityErrorCode.EncryptedFrameInvalidLength, exception.ErrorCode); }
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 Run() { var rnd = new Random(m_id); using (var context = NetMQContext.Create()) using (var worker = context.CreateRequestSocket()) { 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.SendMessage(msg); while (true) { // wait for a request - the REQ might be from a local client or a cloud request var request = worker.ReceiveMessage(); 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.SendMessage(request); } } }
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(); } }
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); }
static void Main(string[] args) { using (var ctx = NetMQContext.Create()) { using (var client = ctx.CreateRequestSocket()) { client.Connect(CLIENT_ENDPOINT); for (var i = 0; i < 10; i++) { var msg = new NetMQMessage(); msg.Append("Message_" + i); client.SendMessage(msg); Console.WriteLine("Sent Message {0}", msg.Last.ConvertToString()); var response = client.ReceiveMessage(); Console.WriteLine("Received Message {0}", response.Last.ConvertToString()); } Console.ReadKey(); } } }
private static void Main() { using (var context = NetMQContext.Create()) using (var client = context.CreateRequestSocket()) { client.Connect(ClientEndpoint); for (var i = 0; i < 10; i++) { var msg = new NetMQMessage(); msg.Append("Message_" + i); client.SendMessage(msg); Console.WriteLine("Sent Message {0}", msg.Last.ConvertToString()); var response = client.ReceiveMessage(); Console.WriteLine("Received Message {0}", response.Last.ConvertToString()); } Console.ReadKey(); } }
static void Main(string[] args) { Console.Title = "NetMQ LazyPirate Client 2"; const string serverAddress = "tcp://127.0.0.1:5555"; const string requestString = "Hi"; var requestTimeout = TimeSpan.FromMilliseconds(2500); var requestRetries = 10; var requestMessage = new NetMQMessage(1); requestMessage.Append("Hi"); using (var progressPublisher = new PublisherSocket()) { const string pubSubAddress = "tcp://127.0.0.1:5556"; progressPublisher.Bind(pubSubAddress); SubscriberContinuousLoop(pubSubAddress, requestString); while (true) { var responseString = RequestSocket.RequestResponseMultipartMessageWithRetry(serverAddress, requestMessage, requestRetries, requestTimeout, progressPublisher); } } }
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 RouterDealerMessaging() { using (NetMQContext context = NetMQContext.Create()) { using (var server = context.CreateRouterSocket()) { server.Bind("tcp://127.0.0.1:5555"); using (var client = context.CreateDealerSocket()) { client.Connect("tcp://127.0.0.1:5555"); NetMQMessage clientOutgoingMessage = new NetMQMessage(); clientOutgoingMessage.Append("Hello"); client.SendMessage(clientOutgoingMessage); NetMQMessage serverIncomingMessage = server.ReceiveMessage(); // number of frames should be one because first message should be identity of client Assert.AreEqual(2, serverIncomingMessage.FrameCount); Assert.AreEqual("Hello", serverIncomingMessage[1].ConvertToString()); NetMQMessage serverOutgoingMessage = new NetMQMessage(); // first adding the identity serverOutgoingMessage.Append(serverIncomingMessage[0]); serverOutgoingMessage.Append("World"); server.SendMessage(serverOutgoingMessage); NetMQMessage incomingClientMessage = new NetMQMessage(); client.ReceiveMessage(incomingClientMessage); Assert.AreEqual(1, incomingClientMessage.FrameCount); Assert.AreEqual("World", incomingClientMessage[0].ConvertToString()); } } } }
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); } } }