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