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