public CheckpointTag MakeCheckpointTag(ProjectionMessage.Projections.CommittedEventDistributed committedEvent)
{
// this is the same tag that will be generated by Handle(CommittedEventDistributed)
var tag = _positionTagger.MakeCheckpointTag(_positionTracker.LastTag, committedEvent);
return(tag);
}
private void DistributeMessage(ProjectionMessage.Projections.CommittedEventDistributed message)
{
foreach (var subscriber in _headSubscribers.Values)
{
subscriber.Handle(message);
}
}
private bool TrySubscribeHeadingDistributionPoint(
ProjectionMessage.Projections.CommittedEventDistributed message, Guid projectionId)
{
if (_pausedProjections.Contains(projectionId))
{
return(false);
}
var projectionSubscription = _subscriptions[projectionId];
if (!_headingEventDistributionPoint.TrySubscribe(
projectionId, projectionSubscription, projectionSubscription.MakeCheckpointTag(message)))
{
return(false);
}
if (message.Data == null)
{
_logger.Trace("The '{0}' is subscribing to the heading distribution point with TF-EOF marker event at '{1}'", projectionId, message.Position);
}
Guid distributionPointId = message.CorrelationId;
_distributionPoints[distributionPointId].Dispose();
_distributionPoints.Remove(distributionPointId);
_distributionPointSubscriptions.Remove(distributionPointId);
_projectionDistributionPoints[projectionId] = Guid.Empty;
return(true);
}
public void Handle(ProjectionMessage.Projections.CommittedEventDistributed message)
{
Guid projectionId;
if (_stopped)
{
return;
}
if (_headingEventDistributionPoint.Handle(message))
{
return;
}
if (!_distributionPointSubscriptions.TryGetValue(message.CorrelationId, out projectionId))
{
return; // unsubscribed
}
if (TrySubscribeHeadingDistributionPoint(message, projectionId))
{
return;
}
if (message.Data != null) // means notification about the end of the stream/source
{
_subscriptions[projectionId].Handle(message);
}
}
public override CheckpointTag MakeCheckpointTag(CheckpointTag previous, ProjectionMessage.Projections.CommittedEventDistributed comittedEvent)
{
if (comittedEvent.PositionStreamId != _stream)
{
throw new InvalidOperationException(string.Format("Invalid stream '{0}'. Expected stream is '{1}'", comittedEvent.EventStreamId, _stream));
}
return(CheckpointTag.FromStreamPosition(comittedEvent.PositionStreamId, comittedEvent.PositionSequenceNumber, comittedEvent.Position.PreparePosition));
}
private void ValidateEventOrder(ProjectionMessage.Projections.CommittedEventDistributed message)
{
if (_lastEventPosition >= message.Position)
{
throw new InvalidOperationException(
string.Format(
"Invalid committed event order. Last: '{0}' Received: '{1}'", _lastEventPosition,
message.Position));
}
_lastEventPosition = message.Position;
}
private void CacheRecentMessage(ProjectionMessage.Projections.CommittedEventDistributed message)
{
_lastMessages.Enqueue(message);
if (_lastMessages.Count > _eventCacheSize)
{
_lastMessages.Dequeue();
}
var lastAvailableCommittedevent = _lastMessages.Peek();
_subscribeFromPosition = lastAvailableCommittedevent.Position;
}
public void Handle(ProjectionMessage.Projections.CommittedEventDistributed message)
{
if (message.Data == null)
{
throw new NotSupportedException();
}
// NOTE: we may receive here messages from heading event distribution point
// and they may not pass out source filter. Discard them first
if (!_eventFilter.PassesSource(message.ResolvedLinkTo, message.PositionStreamId))
{
return;
}
var eventCheckpointTag = _positionTagger.MakeCheckpointTag(_positionTracker.LastTag, message);
//TODO: when joining heading distribution point replayed events may cause invalid operation exception on comparison
if (eventCheckpointTag <= _positionTracker.LastTag)
{
_logger.Trace(
"Skipping replayed event {0}@{1} at position {2}. the last processed event checkpoint tag is: {3}",
message.PositionSequenceNumber, message.PositionStreamId, message.Position, _positionTracker.LastTag);
return;
}
_positionTracker.UpdateByCheckpointTagForward(eventCheckpointTag);
if (_eventFilter.Passes(message.ResolvedLinkTo, message.PositionStreamId, message.Data.EventType))
{
_lastPassedOrCheckpointedEventPosition = message.Position;
var convertedMessage =
ProjectionMessage.Projections.CommittedEventReceived.FromCommittedEventDistributed(message, eventCheckpointTag);
_eventHandler.Handle(convertedMessage);
}
else
{
if (_checkpointUnhandledBytesThreshold != null &&
message.Position.CommitPosition - _lastPassedOrCheckpointedEventPosition.CommitPosition
> _checkpointUnhandledBytesThreshold)
{
_lastPassedOrCheckpointedEventPosition = message.Position;
_checkpointHandler.Handle(
new ProjectionMessage.Projections.CheckpointSuggested(
_projectionCorrelationId, _positionTracker.LastTag));
}
}
}
public bool Handle(ProjectionMessage.Projections.CommittedEventDistributed message)
{
EnsureStarted();
if (message.CorrelationId != _distributionPointId)
{
return(false);
}
if (message.Data == null)
{
return(true);
}
ValidateEventOrder(message);
CacheRecentMessage(message);
DistributeMessage(message);
if (_headSubscribers.Count == 0 && !_headDistributionPointPaused)
{
_headDistributionPoint.Pause();
_headDistributionPointPaused = true;
}
return(true);
}
public CheckpointTag MakeCheckpointTag(ProjectionMessage.Projections.CommittedEventDistributed committedEvent)
{
return(CheckpointTag.FromStreamPosition(
committedEvent.PositionStreamId, committedEvent.EventSequenceNumber,
committedEvent.Position.PreparePosition));
}
public void Handle(ProjectionMessage.Projections.CommittedEventDistributed message)
{
_receivedEvents.Add(message);
}
public virtual CheckpointTag MakeCheckpointTag(CheckpointTag previous, ProjectionMessage.Projections.CommittedEventDistributed comittedEvent)
{
return(new CheckpointTag(comittedEvent.Position));
}
