static async Task Main(string[] args)
{
//esdb://localhost:2113?tls=false
var settings = EventStoreClientSettings
.Create("esdb://localhost:2113?tls=false");
var client = new EventStoreClient(settings);
//await TestReadFromtombstoned(client);
var projectionClient = new EventStoreProjectionManagementClient(settings);
var operationsClient = new EventStoreOperationsClient(settings);
await client.SoftDeleteAsync("dokimi-1", StreamState.Any);
await client.SoftDeleteAsync("dokimi-2", StreamState.Any);
await client.SoftDeleteAsync("dokimi-3", StreamState.Any);
//await projectionClient.DisableAsync("$by_category");
//var result = await operationsClient.StartScavengeAsync();
//await Task.Delay(TimeSpan.FromSeconds(20));
//await projectionClient.EnableAsync("$by_category");
//await projectionClient.ResetAsync("$by_category");
//var readDeltedStreamResult = client.ReadStreamAsync(Direction.Forwards, "test", StreamPosition.Start);
//Console.WriteLine("Stream existed: {0}\nSteam was empty: {1}",
// await readDeltedStreamResult.ReadState,
// await readDeltedStreamResult.CountAsync());
var data = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new Data()
{
Value = 5
}));
var writeResult = await client.AppendToStreamAsync("dokimi-1", StreamRevision.FromInt64(-1),
new[] { new EventData(Uuid.NewUuid(), "TestType", data) });
writeResult = await client.AppendToStreamAsync("dokimi-2", StreamRevision.FromInt64(-1),
new[] { new EventData(Uuid.NewUuid(), "TestType", data) });
writeResult = await client.AppendToStreamAsync("dokimi-3", StreamRevision.FromInt64(-1),
new[] { new EventData(Uuid.NewUuid(), "TestType", data) });
await Task.Delay(TimeSpan.FromSeconds(10));
var readResult = client.ReadStreamAsync(Direction.Forwards, "$ce-dokimi",
StreamPosition.Start,
resolveLinkTos: true);
var isSuccess = await readResult.ReadState;
var events = await readResult.Where(x => x.Event != null).ToListAsync();
var eventCount = events.Count;
var readResultStream = client.ReadStreamAsync(Direction.Forwards, "dokimi-2", StreamPosition.Start);
var isSuccessStream = await readResultStream.ReadState;
var eventsInStream = await readResultStream.ToListAsync();
var eventCountStream = eventsInStream.Count;
Console.WriteLine("Could read stream: {0}", isSuccess);
Console.WriteLine("Found {0} events", eventCount);
Console.WriteLine("Press any key to exit!");
Console.ReadKey();
}
public void FromInt64ExpectedResult(long value, StreamRevision expected) => Assert.AreEqual(expected, StreamRevision.FromInt64(value));
public static StreamRevision AsStreamRevision(this ExpectedStreamVersion version) => StreamRevision.FromInt64(version.Value);
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;
}
}
protected override async Task WriteEventsToStoreAsync(IEnumerable <IDomainEventDescriptor> events, CancellationToken cancellationToken)
{
var aggregateGroup = events.GroupBy(x => GenerateStreamId(x.AggregateType, x.AggregateId));
var eventDataGroups = aggregateGroup.Select(group =>
{
var eventList = group.ToList();
var eventDatas = eventList.Select(x =>
{
byte[] data;
byte[] metadata;
// serialize data
using (var ms = new MemoryStream())
using (var writer = new BsonDataWriter(ms))
{
JsonSerializer serializer = new JsonSerializer();
serializer.TypeNameHandling = TypeNameHandling.All;
serializer.Serialize(writer, x.Event);
data = ms.ToArray();
}
// serialize metadata
using (var ms = new MemoryStream())
using (var writer = new BsonDataWriter(ms))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(writer, x.Metadata);
metadata = ms.ToArray();
}
return(new EventData(
Uuid.FromGuid(x.EventId),
x.EventType,
data,
metadata,
"application/octet-stream"
));
});
if (eventList.Any(x => x.IsPublished))
{
throw new InvalidOperationException("Cannot publish events that have been published");
}
var firstEvent = eventList.First();
return(StreamId: group.Key, EventDatas: eventDatas, ExpectedVersionBeforeAppend: firstEvent.Version - 1L);
});
foreach (var group in eventDataGroups)
{
// expect no stream when there is not positive version
if (group.ExpectedVersionBeforeAppend == -1)
{
await EventStoreClient.AppendToStreamAsync(
group.StreamId,
StreamState.NoStream,
group.EventDatas,
cancellationToken : cancellationToken
);
}
// expect stream when there an unknow version
else if (group.ExpectedVersionBeforeAppend == DomainEventDescriptor.UnknowVersion - 1)
{
await EventStoreClient.AppendToStreamAsync(
group.StreamId,
StreamState.StreamExists,
group.EventDatas,
cancellationToken : cancellationToken
);
}
// expect stream when there is a valid version
else
{
await EventStoreClient.AppendToStreamAsync(
group.StreamId,
StreamRevision.FromInt64(group.ExpectedVersionBeforeAppend),
group.EventDatas,
cancellationToken : cancellationToken
);
}
}
}
public static StreamRevision ToRevision(this long version)
{
return(StreamRevision.FromInt64(version));
}
