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