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