private IEnumerable<byte[]> BuildMessageParts(Message message)
{
yield return GetSocketIdentity(message);
yield return EmptyFrame;
foreach (var hop in message.GetMessageHops())
{
yield return hop.Uri.ToSocketAddress().GetBytes();
yield return hop.Identity;
}
yield return EmptyFrame;
yield return GetTraceOptionsFrame(message);
yield return GetVersionFrame(message);
yield return GetMessageIdentityFrame(message);
yield return GetReceiverIdentityFrame(message);
yield return GetDistributionFrame(message);
yield return GetCorrelationIdFrame(message);
yield return GetCallbackIdentityFrame(message);
yield return GetCallbackReceiverIdentityFrame(message);
yield return GetTTLFrame(message);
yield return EmptyFrame;
yield return GetMessageBodyFrame(message);
}
public void ReceivedFromOtherNode(Message message)
{
if (message.TraceOptions.HasFlag(MessageTraceOptions.Routing))
{
var hops = string.Join("|",
message
.GetMessageHops()
.Select(h => $"{nameof(h.Uri)}:{h.Uri.ToSocketAddress()}/{h.Identity.GetString()}"));
logger.Trace("Message: " +
$"{nameof(message.Version)}:{message.Version.GetString()} " +
$"{nameof(message.Identity)}:{message.Identity.GetString()} " +
$"{nameof(message.Distribution)}:{message.Distribution} " +
$"received from other node via hops {hops}");
}
}
public void TestMessageHops_AreConsistentlyTransferredViaMultipartMessage()
{
var message = (Message) Message.CreateFlowStartMessage(new SimpleMessage(), SimpleMessage.MessageIdentity);
var socketEnpoints = new[]
{
new SocketEndpoint(new Uri("tcp://localhost:40"), Guid.NewGuid().ToByteArray()),
new SocketEndpoint(new Uri("tcp://localhost:40"), Guid.NewGuid().ToByteArray())
};
foreach (var socketEndpoint in socketEnpoints)
{
message.PushRouterAddress(socketEndpoint);
}
var multipart = new MultipartMessage(message);
message = new Message(multipart);
CollectionAssert.AreEqual(socketEnpoints, message.GetMessageHops());
}
private bool MessageCameFromLocalActor(Message message)
{
return !message.GetMessageHops().Any();
}
private void EnqueueTaskForCompletion(CancellationToken token, Task<IActorResult> task, Message messageIn)
{
var asyncMessageContext = new AsyncMessageContext
{
OutMessages = CreateTaskResultMessage(task).Messages,
CallbackIdentity = GetTaskCallbackIdentity(task, messageIn),
CallbackReceiverIdentity = messageIn.CallbackReceiverIdentity,
CorrelationId = messageIn.CorrelationId,
MessageHops = messageIn.GetMessageHops()
};
asyncQueue.Enqueue(asyncMessageContext, token);
}
private static void CallbackException(ISocket localSocket, Exception err, Message messageIn)
{
var messageOut = (Message) Message.Create(new ExceptionMessage {Exception = err}, ExceptionMessage.MessageIdentity);
messageOut.RegisterCallbackPoint(ExceptionMessage.MessageIdentity, messageIn.CallbackReceiverIdentity);
messageOut.SetCorrelationId(messageIn.CorrelationId);
messageOut.CopyMessageHops(messageIn.GetMessageHops());
localSocket.SendMessage(messageOut);
}
private void HandleTaskResult(CancellationToken token, Task<IActorResult> task, Message messageIn, ISocket localSocket)
{
if (task.IsCompleted)
{
var response = CreateTaskResultMessage(task).Messages;
messageTracer.MessageProcessed(messageIn, response.Count());
foreach (var messageOut in response.Cast<Message>())
{
messageOut.RegisterCallbackPoint(GetTaskCallbackIdentity(task, messageIn), messageIn.CallbackReceiverIdentity);
messageOut.SetCorrelationId(messageIn.CorrelationId);
messageOut.CopyMessageHops(messageIn.GetMessageHops());
localSocket.SendMessage(messageOut);
messageTracer.ResponseSent(messageOut, true);
}
}
else
{
task.ContinueWith(completed => SafeExecute(() => EnqueueTaskForCompletion(token, completed, messageIn)), token)
.ConfigureAwait(false);
}
}
