public void EnsureReliability(OutboundDisruptorEntry disruptorEntry, IMessage message, IEnumerable<MessageSubscription> concernedSubscriptions, MessageWireData messageData)
{
var messageOptions = _messageOptions[message.GetType().FullName];
if (messageOptions.ReliabilityLevel != ReliabilityLevel.FireAndForget)
foreach (var wireMessage in disruptorEntry.NetworkSenderData.WireMessages)
{
int seqNum;
if (!_endpointToSequenceNumber.TryGetValue(wireMessage.Endpoint, out seqNum))
{
_endpointToSequenceNumber.Add(wireMessage.Endpoint, 0);
seqNum = 0;
}
wireMessage.MessageData.SequenceNumber = seqNum;
_endpointToSequenceNumber[wireMessage.Endpoint] = seqNum + 1;
}
if (disruptorEntry.MessageTargetHandlerData.IsAcknowledgement)
{
SendAcknowledgementShadowMessages(message, concernedSubscriptions, disruptorEntry, messageData);
}
else
{
if (messageOptions.ReliabilityLevel == ReliabilityLevel.Persisted)
{
SendShadowMessages(concernedSubscriptions, messageData, disruptorEntry);
}
}
}
public ShadowMessageCommand(MessageWireData message, PeerId primaryRecipient, bool primaryWasOnline, IEndpoint targetEndpoint)
{
Message = message;
PrimaryRecipient = primaryRecipient;
PrimaryWasOnline = primaryWasOnline;
TargetEndpoint = targetEndpoint;
}
public byte[] Serialize(MessageWireData data)
{
var guidLength = 16;
var length = data.Data.Length + guidLength + 4 + 4 + 4 + 4;
var finalArray = new byte[length];
var idByteArray = data.MessageIdentity.ToByteArray();
idByteArray.CopyTo(finalArray, 0);
ByteUtils.WriteInt(finalArray, guidLength, _serializationHelper.GetMessageTypeId(data.MessageType));
ByteUtils.WriteInt(finalArray, guidLength + 4, data.SendingPeerId.Id);
var sendingPeerOffset = guidLength + 4 + 4;
ByteUtils.WriteInt(finalArray, sendingPeerOffset, data.Data.Length);
data.Data.CopyTo(finalArray, sendingPeerOffset + 4);
if (data.SequenceNumber != null)
ByteUtils.WriteInt(finalArray, sendingPeerOffset + 4 + data.Data.Length, data.SequenceNumber.Value);
else
{
ByteUtils.WriteInt(finalArray, sendingPeerOffset + 4 + data.Data.Length, -1);
}
return finalArray;
}
public void serializationTestsCustom()
{
var serializer = new MessageWireDataSerializer(new SerializationHelper(new AssemblyScanner()));
using (var perfMeasure = new PerformanceMeasure(() =>
{
var instance = new MessageWireData();
var ser = serializer.Serialize(_testData);
using (var stream = new MemoryStream(ser))
serializer.Deserialize(stream, instance);
}, 1000000)) ;
}
public void should_serialize_deserialize()
{
var message = new MessageWireData(typeof(TestData.FakeCommand).FullName, Guid.NewGuid(), new PeerId(3), Encoding.ASCII.GetBytes("data"))
{SequenceNumber = 1234567};
var buffer = _serializer.Serialize(message);
var stream = new MemoryStream(buffer,0, buffer.Length);
var deserializedMessage = new MessageWireData();
_serializer.Deserialize(stream, deserializedMessage);
Assert.AreEqual(message.Data, deserializedMessage.Data);
Assert.AreEqual(message.MessageIdentity, deserializedMessage.MessageIdentity);
Assert.AreEqual(message.MessageType, deserializedMessage.MessageType);
Assert.AreEqual(message.SendingPeerId, deserializedMessage.SendingPeerId);
Assert.AreEqual(message.SequenceNumber, deserializedMessage.SequenceNumber);
}
public void Deserialize(Stream data, MessageWireData instance)
{
data.Read(_guidArray, 0, 16);
instance.MessageIdentity = new Guid(_guidArray);
var messageTypeId = ByteUtils.ReadIntFromStream(data);
instance.SendingPeerId = new PeerId(ByteUtils.ReadIntFromStream(data));
var dataLength = ByteUtils.ReadIntFromStream(data);
var binaryData = new byte[dataLength];
data.Read(binaryData, 0, dataLength);
instance.Data = binaryData;
int? sequenceNumber = null;
sequenceNumber = ByteUtils.ReadIntFromStream(data);
instance.SequenceNumber = sequenceNumber;
instance.MessageType = _serializationHelper.GetMessageTypeFromId(messageTypeId);
// return new MessageWireData(messageTypeFromId, id, new PeerId(sendingPeer), binaryData) { SequenceNumber = sequenceNumber == -1 ? null : sequenceNumber };
}
public void SendHeartbeat(IEndpoint endpoint)
{
var sequence = _ringBuffer.Next();
var data = _ringBuffer[sequence];
data.MessageTargetHandlerData = new MessageTargetHandlerData();
var heartbeatRequest = new HeartbeatRequest(DateTime.UtcNow, endpoint);
var serializedMessage = BusSerializer.Serialize(heartbeatRequest);
var messageWireData = new MessageWireData(typeof(HeartbeatRequest).FullName, Guid.NewGuid(), _peerConfiguration.PeerId, serializedMessage);
data.NetworkSenderData.WireMessages = new List<WireSendingMessage>();
data.NetworkSenderData.WireMessages.Add(new WireSendingMessage(messageWireData, endpoint));
_ringBuffer.Publish(sequence);
}
private MessageWireData CreateMessageWireData(IMessage message)
{
var serializedMessage = BusSerializer.Serialize(message);
var messageId = Guid.NewGuid();
var messageType = message.GetType().FullName;
var messageData = new MessageWireData(messageType, messageId, _peerConfiguration.PeerId, serializedMessage);
return messageData;
}
private void SendShadowMessages(IEnumerable<MessageSubscription> concernedSubscriptions, MessageWireData messageData, OutboundDisruptorEntry disruptorData)
{
foreach (var subscription in concernedSubscriptions)
{
HashSet<ServicePeer> targetShadows;
if (_peersToShadows.TryGetValue(subscription.Peer, out targetShadows))
{
var endpoints = targetShadows.Select(x => x.HandledMessages.Single(y => y.MessageType == typeof(ShadowMessageCommand)).Endpoint).Distinct();
foreach (var endpoint in endpoints)
{
var shadowMessage = new ShadowMessageCommand(messageData, subscription.Peer, true, subscription.Endpoint);
var shadowMessageData = CreateMessageWireData(shadowMessage);
var wireMessage = new WireSendingMessage(shadowMessageData, endpoint);
disruptorData.NetworkSenderData.WireMessages.Add(wireMessage);
}
}
}
}
private void SendAcknowledgementShadowMessages(IMessage message, IEnumerable<MessageSubscription> concernedSubscriptions, OutboundDisruptorEntry disruptorData, MessageWireData messageData)
{
var completionAcknowledgementMessage = (CompletionAcknowledgementMessage)message;
if (_messageOptions[completionAcknowledgementMessage.MessageType].ReliabilityLevel == ReliabilityLevel.Persisted)
{
SendToSelfShadows(completionAcknowledgementMessage.MessageId,
completionAcknowledgementMessage.ProcessingSuccessful,
disruptorData.MessageTargetHandlerData.TargetPeer,
completionAcknowledgementMessage.Endpoint,
completionAcknowledgementMessage.MessageType,
disruptorData);
SendShadowMessages(concernedSubscriptions, messageData, disruptorData);
}
}
public WireSendingMessage(MessageWireData messageData, IEndpoint endpoint)
: this()
{
MessageData = messageData;
Endpoint = endpoint;
}