public ITrackingToken AdvancedTo(ITrackingToken newToken)
{
if ((newToken.Covers(IWrappedToken.UnwrapUpperBound(_tokenAtReset)) &&
!_tokenAtReset.Covers(IWrappedToken.UnwrapLowerBound(newToken))))
{
// we're done replaying
// if the token at reset was a wrapped token itself, we'll need to use that one to maintain progress.
return(_tokenAtReset is IWrappedToken wrappedToken?wrappedToken.AdvancedTo(newToken) : newToken);
}
if (_tokenAtReset.Covers(IWrappedToken.UnwrapLowerBound(newToken)))
{
// we're still well behind
return(new ReplayToken(_tokenAtReset, newToken, true));
}
// we're getting an event that we didn't have before, but we haven't finished replaying either
if (_tokenAtReset is IWrappedToken token)
{
return(new ReplayToken(token.UpperBound(newToken),
token.AdvancedTo(newToken), false));
}
return(new ReplayToken(_tokenAtReset.UpperBound(newToken), newToken, false));
}
public AnnotatedSaga(string sagaId, ISet <AssociationValue> associationValues, T annotatedSaga, ITrackingToken trackingToken, ISagaModel metaModel)
{
_sagaInstance = annotatedSaga;
_metaModel = metaModel;
SagaIdentifier = sagaId;
AssociationValues = new AssociationValuesImpl(associationValues);
_trackingToken = trackingToken;
}
private ReplayToken(ITrackingToken tokenAtReset,
ITrackingToken?newRedeliveryToken,
bool lastMessageWasReplay)
{
_tokenAtReset = tokenAtReset;
_currentToken = newRedeliveryToken;
_lastMessageWasReplay = lastMessageWasReplay;
}
public bool Covers(ITrackingToken other)
{
if (other is ReplayToken)
{
return(CurrentToken != null && CurrentToken.Covers(((ReplayToken)other).CurrentToken));
}
return(CurrentToken != null && CurrentToken.Covers(other));
}
public ITrackingToken LowerBound(ITrackingToken other)
{
if (other is ReplayToken)
{
return(new ReplayToken(this, ((ReplayToken)other).CurrentToken));
}
return(new ReplayToken(this, other));
}
/// <summary>
/// Initialize a DomainEventMessage originating from an aggregate.
/// </summary>
/// <param name="trackingToken">Tracking token of the event</param>
/// <param name="type">The domain type</param>
/// <param name="aggregateIdentifier">The identifier of the aggregate generating this message</param>
/// <param name="sequenceNumber">The message's sequence number</param>
/// <param name="delegate">The delegate message providing the payload, metadata and identifier of the event</param>
/// <param name="timestamp">The event's timestamp</param>
protected GenericTrackedDomainEventMessage(
ITrackingToken trackingToken,
string type,
string aggregateIdentifier,
long sequenceNumber,
IMessage <T> @delegate,
InternalDateTimeOffset?timestamp
) : base(type, aggregateIdentifier, sequenceNumber, @delegate, timestamp)
{
_trackingToken = trackingToken;
}
/// <summary>
/// Initialize a DomainEventMessage originating from an aggregate.
/// </summary>
/// <param name="trackingToken">Tracking token of the event</param>
/// <param name="delegate">Delegate domain event containing other event data</param>
public GenericTrackedDomainEventMessage(
ITrackingToken trackingToken,
IDomainEventMessage <T> @delegate
) : this(
trackingToken,
@delegate.Type(),
@delegate.GetAggregateIdentifier(),
@delegate.GetSequenceNumber(),
@delegate,
@delegate.GetTimestamp()
)
{
}
public override ITrackingEventStream OpenStream(ITrackingToken trackingToken)
{
if (trackingToken != null)
{
throw new NotSupportedException("The simple event bus does not support non-null tracking tokens");
}
var eventStream = new EventConsumer(_queueCapacity, this);
_eventStreams.TryAdd(eventStream, null);
return(eventStream);
}
public static ITrackingToken CreateReplayToken(ITrackingToken tokenAtReset, ITrackingToken?startPosition)
{
while (true)
{
if (tokenAtReset is ReplayToken token)
{
tokenAtReset = token._tokenAtReset;
continue;
}
return(startPosition != null && startPosition.Covers(IWrappedToken.UnwrapLowerBound(tokenAtReset)) ?
startPosition : new ReplayToken(tokenAtReset, startPosition));
}
}
public static ITrackingToken CreateReplayToken(ITrackingToken tokenAtReset, ITrackingToken startPosition)
{
if (tokenAtReset == null)
{
return(null);
}
if (tokenAtReset is ReplayToken)
{
return(CreateReplayToken(((ReplayToken)tokenAtReset).TokenAtReset, startPosition));
}
if (startPosition != null && startPosition.Covers(tokenAtReset))
{
return(startPosition);
}
return(new ReplayToken(tokenAtReset, startPosition));
}
public ITrackingToken AdvancedTo(ITrackingToken newToken)
{
if (TokenAtReset == null ||
(newToken.Covers(this.TokenAtReset) && !TokenAtReset.Covers(newToken)))
{
// we're done replaying
return(newToken);
}
else if (TokenAtReset.Covers(newToken))
{
// we're still well behind
return(new ReplayToken(TokenAtReset, newToken));
}
else
{
// we're getting an event that we didn't have before, but we haven't finished replaying either
return(new ReplayToken(TokenAtReset.UpperBound(newToken), newToken));
}
}
public void UpdateSaga(Type sagaType, string sagaIdentifier, object saga, ITrackingToken token, IAssociationValues associationValues)
{
var entry = new SagaEntry(saga, sagaIdentifier, _serializer);
_logger.LogDebug($"Updating saga id {sagaIdentifier} as {Encoding.UTF8.GetString(entry.SerializedSaga)}");
int updateCount;
try
{
using (var conn = _connectionProvider())
{
conn.Open();
updateCount = _sqldef.SqlUpdateSaga(conn, entry.SagaId, entry.SerializedSaga, entry.SagaType, entry.Revision);
if (updateCount != 0)
{
foreach (var associationValue in associationValues.AddedAssociations)
{
_sqldef.SqlStoreAssocValue(conn, associationValue.PropertyKey, associationValue.PropertyValue, SagaTypeName(sagaType), sagaIdentifier);
}
foreach (var associationValue in associationValues.RemovedAssociations)
{
_sqldef.SqlRemoveAssocValue(conn, associationValue.PropertyKey, associationValue.PropertyValue, SagaTypeName(sagaType), sagaIdentifier);
}
}
}
}
catch (DataException e)
{
throw new SagaStorageException("Exception while loading a Saga", e);
}
if (updateCount == 0)
{
_logger.LogWarning("Expected to be able to update a Saga instance, but no rows were found. Inserting instead.");
InsertSaga(sagaType, sagaIdentifier, saga, token, associationValues.AsSet());
}
}
public void InsertSaga(Type sagaType, string sagaIdentifier, object saga, ITrackingToken token, ISet <AssociationValue> associationValues)
{
var entry = new SagaEntry(saga, sagaIdentifier, _serializer);
_logger.LogDebug($"Storing saga id {sagaIdentifier} as {Encoding.UTF8.GetString(entry.SerializedSaga)}");
try
{
using (var conn = _connectionProvider())
{
conn.Open();
_sqldef.SqlStoreSaga(conn, entry.SagaId, entry.Revision, entry.SagaType, entry.SerializedSaga);
foreach (var associationValue in associationValues)
{
_sqldef.SqlStoreAssocValue(conn, associationValue.PropertyKey, associationValue.PropertyValue, SagaTypeName(sagaType), sagaIdentifier);
}
}
}
catch (DataException e)
{
throw new SagaStorageException("Exception while loading a Saga", e);
}
}
public abstract ITrackingEventStream OpenStream(ITrackingToken trackingToken);
IMessageStream IStreamableMessageSource <ITrackedEventMessage> .OpenStream(ITrackingToken trackingToken)
{
return(OpenStream(trackingToken));
}
public GenericTrackedEventMessage(ITrackingToken trackingToken, IEventMessage @delegate) : base(trackingToken, @delegate)
{
}
public GenericTrackedEventMessage(ITrackingToken trackingToken, IMessage @delegate, Func <DateTime> timestamp) : base(trackingToken, @delegate, timestamp)
{
}
public ReplayToken(ITrackingToken tokenAtReset, ITrackingToken?newRedeliveryToken) : this(tokenAtReset,
newRedeliveryToken, true)
{
}
public void InsertSaga(Type sagaType, string sagaIdentifier, object saga, ITrackingToken token, ISet <AssociationValue> associationValues)
{
_managedSagas.AddOrUpdate(sagaIdentifier, new ManagedSaga(saga, associationValues), (s, managedSaga) => new ManagedSaga(saga, associationValues));
}
public ITrackingToken UpperBound(ITrackingToken other) => AdvancedTo(other);
public static bool IsReplay(ITrackingToken trackingToken)
{
return(IWrappedToken.Unwrap <ReplayToken>(trackingToken)?.IsReplay() ?? false);
}
public static ITrackingToken CreateReplayToken(ITrackingToken tokenAtReset)
{
return(CreateReplayToken(tokenAtReset, null));
}
public ITrackingToken UpperBound(ITrackingToken other)
{
return(AdvancedTo(other));
}
internal GenericTrackedEventMessage(ITrackingToken trackingToken, IMessage @delegate, DateTime timestamp) : base(trackingToken, @delegate, timestamp)
{
}
public GenericTrackedDomainEventMessage <T> WithTrackingToken(ITrackingToken trackingToken)
{
return(new GenericTrackedDomainEventMessage <T>(trackingToken, this));
}
public static long?GetTokenAtReset(ITrackingToken trackingToken)
{
return(IWrappedToken.Unwrap <ReplayToken>(trackingToken)?.GetTokenAtReset().Position());
}
protected GenericTrackedDomainEventMessage(ITrackingToken trackingToken, string type, string aggregateIdentifier, long sequenceNumber, IMessage @delegate, DateTime timestamp) : base(trackingToken, type, aggregateIdentifier, sequenceNumber, @delegate, timestamp)
{
}
public ReplayToken(ITrackingToken tokenAtReset) : this(tokenAtReset, null)
{
}
public static ITrackedEventMessage AsTrackedEventMessage(IEventMessage eventMessage, ITrackingToken trackingToken)
{
if (eventMessage is IDomainEventMessage)
{
return(new GenericTrackedDomainEventMessage(trackingToken, (IDomainEventMessage)eventMessage));
}
return(new GenericTrackedEventMessage(trackingToken, eventMessage));
}
public void UpdateSaga(Type sagaType, string sagaIdentifier, object saga, ITrackingToken token, IAssociationValues associationValues)
{
_managedSagas.AddOrUpdate(sagaIdentifier, new ManagedSaga(saga, associationValues.AsSet()), (s, managedSaga) => new ManagedSaga(saga, associationValues.AsSet()));
}
