public async Task <ulong> TerminateAsync(Guid eventID, string eventName, string streamName, ulong?expectedEventNumber, EventStoreState expectedState) { var eventData = new EventData(Uuid.FromGuid(eventID), "Delete", null, null); if (expectedEventNumber.HasValue) { var revision = new StreamRevision(expectedEventNumber.Value); var writeResult = await client.AppendToStreamAsync(streamName, revision, new EventData[] { eventData }); await client.TombstoneAsync(streamName, revision); return(writeResult.NextExpectedStreamRevision); } else { StreamState state; switch (expectedState) { case EventStoreState.Any: state = StreamState.Any; break; case EventStoreState.NotExisting: state = StreamState.NoStream; break; case EventStoreState.Existing: state = StreamState.StreamExists; break; default: throw new NotImplementedException(); } var writeResult = await client.AppendToStreamAsync(streamName, state, new EventData[] { eventData }); await client.TombstoneAsync(streamName, state); return(writeResult.NextExpectedStreamRevision); } }
private static async Task TestReadFromtombstoned(EventStoreClient client) { var idForTombstoneTest = Guid.NewGuid().ToString(); await client.AppendToStreamAsync(idForTombstoneTest, StreamRevision.FromInt64(-1), new[] { new EventData(Uuid.NewUuid(), "TestType", new byte[] { 0x00 }) }); await client.TombstoneAsync(idForTombstoneTest, StreamState.Any); var testResultNonExistent = client.ReadStreamAsync(Direction.Backwards, Guid.NewGuid().ToString(), StreamPosition.End); var testResult = client.ReadStreamAsync(Direction.Backwards, idForTombstoneTest, StreamPosition.End, configureOperationOptions: o => { o.ThrowOnAppendFailure = false; }); var testState = await testResultNonExistent.ReadState; testState = await testResult.ReadState; }
public static async Task CleanUp(String prefix, EventStoreClientSettings settings) { if (settings == null) { settings = EventStoreClientSettings.Create("esdb://127.0.0.1:2113?tls=false"); } var client = new EventStoreClient(settings); var result = client.ReadAllAsync(Direction.Backwards, Position.End); HashSet <String> streamsToDelete = new HashSet <string>(await result.Where(x => x.OriginalStreamId.StartsWith($"{prefix}-")).Select(x => x.OriginalStreamId).ToListAsync()); foreach (var item in streamsToDelete) { await client.TombstoneAsync(item, StreamState.Any); } }
public Task <DeleteResult> TombstoneAsync(string streamName, StreamRevision expectedRevision, Action <EventStoreClientOperationOptions> configureOperationOptions = null, UserCredentials userCredentials = null, CancellationToken cancellationToken = new CancellationToken()) { return(Client.TombstoneAsync(streamName, expectedRevision, configureOperationOptions, userCredentials, cancellationToken)); }
public async Task DeleteAsync <TAggregate>(TAggregate aggregate) where TAggregate : class, IAggregateRoot { string streamName = $"{aggregate.GetType().Name}:{aggregate.Id}"; await Policies.RedisFallbackPolicy.ExecuteAsync(() => _cache.KeyDeleteAsync(streamName)); var service = _context.GetService <IAggregateMap <TAggregate> >(); if (service != null) { await Policies.SqRetryPolicy.ExecuteAsync(() => service.DeleteAsync(aggregate)); } var result = await Policies.EventStoreRetryPolicy.ExecuteAndCaptureAsync(() => _eventStoreClient.TombstoneAsync(streamName, StreamRevision.FromInt64(aggregate.Version))); if (result.Outcome == OutcomeType.Successful) { await Policies.RedisFallbackPolicy.ExecuteAsync(() => _cache.KeyDeleteAsync(streamName)); return; } if (service != null) { var publishResult = await Policies.PublishRetryPolicy.ExecuteAndCaptureAsync(() => _publishEndpoint.Publish(new AggregateInOutOfSyncState() { AggregateId = aggregate.Id, Type = aggregate.GetType().FullName, Version = aggregate.Version })); if (publishResult.Outcome == OutcomeType.Failure) { throw new AggregateInOutOfSyncException(aggregate, result.FinalException); } throw result.FinalException; } }