public void Run()
{
DateTime currentTime = DateTime.Now;
foreach (KeyValuePair <object, MessageBarrier <T, K> > entry in _outer._barriers)
{
if (currentTime - entry.Value.Timestamp >= _outer._timeout)
{
MessageBarrier <T, K> barrier = entry.Value;
lock (barrier) {
_outer.RemoveBarrier(entry.Key);
if (_outer._sendPartialResultOnTimeout)
{
barrier.SetComplete();
_outer.ProcessBarrier(barrier);
}
else
{
foreach (IMessage message in barrier.Messages.Values)
{
if (_outer.logger.IsDebugEnabled)
{
_outer.logger.Debug("Handling of Message group with correlationId '" + entry.Key + "' has timed out.");
}
_outer.DiscardMessage(message);
}
}
}
}
}
}
protected override void ProcessBarrier(MessageBarrier <IDictionary <object, IMessage>, object> barrier)
{
IList <IMessage> messageList = new List <IMessage>(barrier.Messages.Values);
if (!barrier.IsComplete && messageList.Count > 0)
{
if (_completionStrategy.IsComplete(messageList))
{
barrier.SetComplete();
}
}
if (barrier.IsComplete)
{
RemoveBarrier(barrier.CorrelationId);
IMessage result = AggregateMessages(messageList);
if (result != null)
{
if (result.Headers.CorrelationId == null)
{
result = MessageBuilder.FromMessage(result).SetCorrelationId(barrier.CorrelationId).Build();
}
SendReply(result, ResolveReplyChannelFromMessage(messageList[0]));
}
}
}
protected override MessageBarrier <SortedDictionary <int, IMessage>, int> CreateMessageBarrier()
{
MessageBarrier <SortedDictionary <int, IMessage>, int> messageBarrier
= new MessageBarrier <SortedDictionary <int, IMessage>, int>(new SortedDictionary <int, IMessage>()); // TODO (new TreeMap<Integer, Message<?>>());
messageBarrier.Messages.Add(0, CreateFlagMessage(0));
return(messageBarrier);
}
/// <summary>
/// Verifies that a message can be added to the barrier. To be overridden by subclasses, which may add
/// their own verifications. Subclasses overriding this method must call the method from the superclass.
/// </summary>
protected virtual bool CanAddMessage(IMessage message, MessageBarrier <T, K> barrier)
{
if (barrier.IsComplete)
{
if (logger.IsDebugEnabled)
{
logger.Debug("Message received after aggregation has already completed: " + message);
}
return(false);
}
return(true);
}
protected override bool CanAddMessage(IMessage message, MessageBarrier <IDictionary <object, IMessage>, object> barrier)
{
if (!base.CanAddMessage(message, barrier))
{
return(false);
}
if (barrier.Messages.ContainsKey(message.Headers.Id))
{
logger.Debug("The barrier has received message: " + message + ", but it already contains a similar message: " + barrier.Messages[message.Headers.Id]);
return(false);
}
return(true);
}
protected override void ProcessBarrier(MessageBarrier <SortedDictionary <int, IMessage>, int> barrier)
{
if (HasReceivedAllMessages(barrier.Messages))
{
barrier.SetComplete();
}
IList <IMessage> releasedMessages = ReleaseAvailableMessages(barrier);
if (releasedMessages != null && releasedMessages.Count > 0)
{
IMessage lastMessage = releasedMessages[releasedMessages.Count - 1];
if (lastMessage.Headers.SequenceNumber.Equals(lastMessage.Headers.SequenceSize - 1))
{
RemoveBarrier(barrier.CorrelationId);
}
SendReplies(releasedMessages, ResolveReplyChannelFromMessage(releasedMessages[0]));
}
}
private IList <IMessage> ReleaseAvailableMessages(MessageBarrier <SortedDictionary <int, IMessage>, int> barrier)
{
if (_releasePartialSequences || barrier.IsComplete)
{
IList <IMessage> releasedMessages = new List <IMessage>();
IMessage flagMessage = null;
int lastReleasedSequenceNumber = 0;
foreach (IMessage msg in barrier.Messages.Values)
{
if (flagMessage == null)
{
flagMessage = msg;
lastReleasedSequenceNumber = flagMessage.Headers.SequenceNumber;
continue;
}
if (lastReleasedSequenceNumber == msg.Headers.SequenceNumber - 1)
{
releasedMessages.Add(msg);
lastReleasedSequenceNumber = msg.Headers.SequenceNumber;
}
else
{
break;
}
}
if (flagMessage != null)
{
// remove the flagMessage and all released messages form the barrier
barrier.Messages.Remove(flagMessage.Headers.SequenceNumber);
foreach (IMessage msg in releasedMessages)
{
barrier.Messages.Remove(msg.Headers.SequenceNumber);
}
//re-insert the flag so that we know where to start releasing next
barrier.Messages.Add(lastReleasedSequenceNumber, CreateFlagMessage(lastReleasedSequenceNumber));
return(releasedMessages);
}
}
return(new List <IMessage>());
}
protected override bool CanAddMessage(IMessage message, MessageBarrier <SortedDictionary <int, IMessage>, int> barrier)
{
if (!base.CanAddMessage(message, barrier))
{
return(false);
}
IMessage flagMessage = barrier.Messages[GetFirstKey(barrier.Messages)];
if (barrier.Messages.ContainsKey(message.Headers.SequenceNumber) || flagMessage.Headers.SequenceNumber >= message.Headers.SequenceNumber)
{
logger.Debug("A message with the same sequence number has been already received: " + message);
return(false);
}
IMessage lastMessage = barrier.Messages[GetLastKey(barrier.Messages)];
if (lastMessage != flagMessage && lastMessage.Headers.SequenceSize < message.Headers.SequenceNumber)
{
logger.Debug("The message has a sequence number which is larger than the sequence size: " + message);
return(false);
}
return(true);
}
/// <summary> /// A method implemented by subclasses to add the incoming message to the message barrier. This is deferred to subclasses, /// as they should have full control over how the messages are indexed in the MessageBarrier. /// </summary> protected abstract void DoAddMessage(IMessage message, MessageBarrier <T, K> barrier);
/// <summary>
/// A method for processing the information in the message barrier after a message has been added or on pruning.
/// The decision as to whether the messages from the {@link MessageBarrier}
/// can be released normally belongs here, although calling code may forcibly set the MessageBarrier's 'complete'
/// flag to true before invoking the method.
/// </summary>
/// <param name="barrier">the {@link MessageBarrier} to be processed</param>
protected abstract void ProcessBarrier(MessageBarrier <T, K> barrier);
protected override void DoAddMessage(IMessage message, MessageBarrier <SortedDictionary <int, IMessage>, int> barrier)
{
//add the message to the barrier, indexing it by its sequence number
barrier.Messages.Add(message.Headers.SequenceNumber, message);
}
protected override void DoAddMessage(IMessage message, MessageBarrier <IDictionary <object, IMessage>, object> barrier)
{
DictionaryUtils.Put(barrier.Messages, message.Headers.Id, message);
}
