public void soft_deleted_stream_allows_recreation_when_expver_any()
{
const string stream = "soft_deleted_stream_allows_recreation_when_expver_any";
Assert.AreEqual(1, _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).Result.NextExpectedVersion);
_conn.DeleteStreamAsync(stream, 1).Wait();
var events = new[] { TestEvent.NewTestEvent(), TestEvent.NewTestEvent(), TestEvent.NewTestEvent() };
Assert.AreEqual(4, _conn.AppendToStreamAsync(stream, ExpectedVersion.Any, events).Result.NextExpectedVersion);
Thread.Sleep(50); //TODO: This is a workaround until github issue #1744 is fixed
var res = _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false).Result;
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(4, res.LastEventNumber);
Assert.AreEqual(3, res.Events.Length);
Assert.AreEqual(events.Select(x => x.EventId), res.Events.Select(x => x.OriginalEvent.EventId));
Assert.AreEqual(new[] { 2, 3, 4 }, res.Events.Select(x => x.OriginalEvent.EventNumber));
var meta = _conn.GetStreamMetadataAsync(stream).Result;
Assert.AreEqual(2, meta.StreamMetadata.TruncateBefore);
Assert.AreEqual(1, meta.MetastreamVersion);
}
public override async Task <long> ReadHighestSequenceNrAsync(string persistenceId, long fromSequenceNr)
{
try
{
var slice = await _conn.ReadStreamEventsBackwardAsync(persistenceId, StreamPosition.End, 1, false);
long sequence = 0;
if (slice.Events.Any())
{
var @event = slice.Events.First();
var adapted = _eventAdapter.Adapt(@event);
sequence = adapted.SequenceNr;
}
else
{
var metadata = await _conn.GetStreamMetadataAsync(persistenceId);
if (metadata.StreamMetadata.TruncateBefore != null)
{
sequence = metadata.StreamMetadata.TruncateBefore.Value;
}
}
return(sequence);
}
catch (Exception e)
{
_log.Error(e, e.Message);
throw;
}
}
public static async Task SetEventMaxAgeIfNull(this IEventStoreConnection connection, string streamName, TimeSpan maxAge)
{
for (int i = 0; i < 3; ++i)
{
var readRes = await connection.GetStreamMetadataAsync(streamName);
if (readRes.IsStreamDeleted || readRes.StreamMetadata.MaxAge != null)
{
return;
}
var metadata = StreamMetadata.Create(maxAge: maxAge);
try
{
await connection.SetStreamMetadataAsync(streamName, readRes.MetastreamVersion, metadata);
return;
}
catch (WrongExpectedVersionException)
{
}
await Task.Delay((i + 1) * 100);
}
}
/// <inheritdoc />
protected override async Task UpdateStreamMetadata(IStream stream)
{
var metaVersion = (await _connection.GetStreamMetadataAsync(stream.Key)).MetastreamVersion;
await _connection.SetStreamMetadataAsync(
stream.Key,
metaVersion,
Encoding.UTF8.GetBytes(EncodeStreamMetadata(stream))); // JExtensions.JStreamMetadata(stream));
}
private static void GetStreamMetadata(IEventStoreConnection connection)
{
StreamMetadataResult metadata = connection.GetStreamMetadataAsync("test-stream").Result;
Console.WriteLine("cache control: " + metadata.StreamMetadata.CacheControl);
Console.WriteLine("custom value: " + metadata.StreamMetadata.GetValue<string>("key"));
Console.WriteLine("max age: " + metadata.StreamMetadata.MaxAge);
Console.WriteLine("max count: " + metadata.StreamMetadata.MaxCount);
}
public async Task <bool> AggregateExistsAsync <TIdentity, TAggregate>(
TIdentity id,
AggregateConfiguration <TIdentity, TAggregate> configuration,
CancellationToken cancellationToken = default
) where TAggregate : Aggregate <TIdentity, TAggregate>
{
var stream = _streamNameResolver.Stream(id, configuration);
var meta = await _connection.GetStreamMetadataAsync(stream);
return(meta.MetastreamVersion >= 0 && !meta.IsStreamDeleted);
}
public static async Task <StreamMeta> GetStreamMeta(
this IEventStoreConnection connection, string stream
)
{
var streamMeta = await
Metrics.Measure(
() => connection.GetStreamMetadataAsync(stream),
ReplicationMetrics.MetaReadsHistogram
).ConfigureAwait(false);
return(new StreamMeta(
streamMeta.IsStreamDeleted,
/// <summary>
/// Enrich the stream from store
/// </summary>
/// <remarks>
/// <para/>
/// Null if stream exists but some of the ancestors do not
/// </remarks>
/// <param name="connection">Stream store</param>
/// <param name="key">Stream key</param>
/// <param name="serializer">Serializer</param>
/// <returns>Stream info</returns>
public static async Task <IStream> GetStream(
this IEventStoreConnection connection, string key, ISerializer <IEvent> serializer)
{
var metadata = await connection.GetStreamMetadataAsync(key);
var stream = serializer.DecodeStreamMetadata(metadata.StreamMetadata.AsJsonString());
if (stream == null)
{
return(new Stream(key));
}
var count = await connection.DeletedCount(key);
stream.AddDeleted(count);
var parent = stream.Parent;
while (parent != null && parent.Version > ExpectedVersion.EmptyStream)
{
var parentMetadata = await connection.GetStreamMetadataAsync(parent.Key);
if (parentMetadata.StreamMetadata == null)
{
return(null);
}
count = await connection.DeletedCount(parent.Key);
parent.AddDeleted(count);
var grandParent = serializer.DecodeStreamMetadata(parentMetadata.StreamMetadata.AsJsonString())?.Parent;
parent.Parent = grandParent;
parent = grandParent;
}
return(stream);
}
protected override async Task DeleteAsync(SnapshotMetadata metadata)
{
var streamName = GetStreamName(metadata.PersistenceId);
var m = await _conn.GetStreamMetadataAsync(streamName);
if (m.IsStreamDeleted)
{
return;
}
var streamMetadata = m.StreamMetadata.Copy();
var timestamp = metadata.Timestamp != DateTime.MinValue ? metadata.Timestamp : default(DateTime?);
var result = await FindSnapshot(streamName, metadata.SequenceNr, timestamp);
if (result.Snapshot == null)
{
return;
}
streamMetadata = streamMetadata.SetTruncateBefore(result.EventNumber + 1);
await _conn.SetStreamMetadataAsync(streamName, ExpectedVersion.Any, streamMetadata.Build());
}
private static async Task <IEnumerable <string> > GetStreamIdsByCategoryBy(IEventStoreConnection conn, string category, bool includeDeleted = false)
{
var streamIds = await GetAllRawEvents(conn, "$category-" + category);
if (includeDeleted)
{
return(streamIds);
}
else
{
var undeletedStreamIds = new List <string>();
foreach (var id in streamIds)
{
var result = await conn.GetStreamMetadataAsync(id);
if (!result.IsStreamDeleted)
{
undeletedStreamIds.Add(id);
}
}
return(undeletedStreamIds);
}
}
public async Task setting_metadata_few_times_returns_last_metadata_info()
{
const string stream = "setting_metadata_few_times_returns_last_metadata_info";
var metadata =
StreamMetadata.Create(17, TimeSpan.FromSeconds(0xDEADBEEF), 10, TimeSpan.FromSeconds(0xABACABA));
await _connection.SetStreamMetadataAsync(stream, ExpectedVersion.NoStream, metadata);
var meta = await _connection.GetStreamMetadataAsync(stream);
Assert.AreEqual(stream, meta.Stream);
Assert.AreEqual(false, meta.IsStreamDeleted);
Assert.AreEqual(0, meta.MetastreamVersion);
Assert.AreEqual(metadata.MaxCount, meta.StreamMetadata.MaxCount);
Assert.AreEqual(metadata.MaxAge, meta.StreamMetadata.MaxAge);
Assert.AreEqual(metadata.TruncateBefore, meta.StreamMetadata.TruncateBefore);
Assert.AreEqual(metadata.CacheControl, meta.StreamMetadata.CacheControl);
metadata = StreamMetadata.Create(37, TimeSpan.FromSeconds(0xBEEFDEAD), 24,
TimeSpan.FromSeconds(0xDABACABAD));
await _connection.SetStreamMetadataAsync(stream, 0, metadata);
meta = await _connection.GetStreamMetadataAsync(stream);
Assert.AreEqual(stream, meta.Stream);
Assert.AreEqual(false, meta.IsStreamDeleted);
Assert.AreEqual(1, meta.MetastreamVersion);
Assert.AreEqual(metadata.MaxCount, meta.StreamMetadata.MaxCount);
Assert.AreEqual(metadata.MaxAge, meta.StreamMetadata.MaxAge);
Assert.AreEqual(metadata.TruncateBefore, meta.StreamMetadata.TruncateBefore);
Assert.AreEqual(metadata.CacheControl, meta.StreamMetadata.CacheControl);
}
public async Task WriteMetadata(string stream, int?maxCount = null, int?truncateBefore = null, TimeSpan?maxAge = null,
TimeSpan?cacheControl = null, bool?frozen = null, Guid?owner = null)
{
Logger.Write(LogLevel.Debug, () => $"Writing metadata to stream [{stream}] [ {nameof(maxCount)}: {maxCount}, {nameof(maxAge)}: {maxAge}, {nameof(cacheControl)}: {cacheControl}, {nameof(frozen)}: {frozen} ]");
var existing = await _client.GetStreamMetadataAsync(stream).ConfigureAwait(false);
if ((existing.StreamMetadata?.CustomKeys.Contains("frozen") ?? false) &&
existing.StreamMetadata?.GetValue <string>("owner") != Defaults.Instance.ToString())
{
FrozenExceptions.Mark();
throw new VersionException("Stream is frozen - we are not the owner");
}
if (frozen.HasValue && frozen == false && (
existing.StreamMetadata == null ||
(existing.StreamMetadata?.CustomKeys.Contains("frozen") ?? false) == false ||
existing.StreamMetadata?.GetValue <string>("owner") != Defaults.Instance.ToString()))
{
FrozenExceptions.Mark();
throw new FrozenException();
}
// If we are trying to freeze the stream that we've already frozen (to prevent multiple threads from attempting to process the same frozen data)
if (frozen.HasValue && frozen == true && (existing.StreamMetadata?.CustomKeys.Contains("frozen") ?? false) &&
existing.StreamMetadata?.GetValue <string>("owner") == Defaults.Instance.ToString())
{
FrozenExceptions.Mark();
throw new FrozenException();
}
var metadata = StreamMetadata.Build();
if ((maxCount ?? existing.StreamMetadata?.MaxCount).HasValue)
{
metadata.SetMaxCount((maxCount ?? existing.StreamMetadata?.MaxCount).Value);
}
if ((truncateBefore ?? existing.StreamMetadata?.TruncateBefore).HasValue)
{
metadata.SetTruncateBefore((truncateBefore ?? existing.StreamMetadata?.TruncateBefore).Value);
}
if ((maxAge ?? existing.StreamMetadata?.MaxAge).HasValue)
{
metadata.SetMaxAge((maxAge ?? existing.StreamMetadata?.MaxAge).Value);
}
if ((cacheControl ?? existing.StreamMetadata?.CacheControl).HasValue)
{
metadata.SetCacheControl((cacheControl ?? existing.StreamMetadata?.CacheControl).Value);
}
if (frozen.HasValue && frozen == true)
{
metadata.SetCustomProperty("frozen", DateTime.UtcNow.ToUnixTime());
}
if (owner.HasValue)
{
metadata.SetCustomProperty("owner", Defaults.Instance.ToString());
}
try
{
await _client.SetStreamMetadataAsync(stream, existing.MetastreamVersion, metadata).ConfigureAwait(false);
}
catch (WrongExpectedVersionException e)
{
throw new VersionException(e.Message, e);
}
catch (CannotEstablishConnectionException e)
{
throw new PersistenceException(e.Message, e);
}
catch (OperationTimedOutException e)
{
throw new PersistenceException(e.Message, e);
}
catch (EventStoreConnectionException e)
{
throw new PersistenceException(e.Message, e);
}
}
void AssertEventStoreAvailable(IEventStoreConnection Connection)
=> _ = Connection.GetStreamMetadataAsync("$ce-Any").Result;
public void setting_metadata_few_times_returns_last_metadata_info()
{
var metadata = StreamMetadata.Create(17, TimeSpan.FromSeconds(0xDEADBEEF), 10, TimeSpan.FromSeconds(0xABACABA));
_connection.SetStreamMetadataAsync(_stream, ExpectedVersion.Any, metadata).Wait();
var meta = _connection.GetStreamMetadataAsync(_stream).Result;
Assert.AreEqual(_stream, meta.Stream);
Assert.AreEqual(false, meta.IsStreamDeleted);
Assert.AreEqual(0, meta.MetastreamVersion);
Assert.AreEqual(metadata.MaxCount, meta.StreamMetadata.MaxCount);
Assert.AreEqual(metadata.MaxAge, meta.StreamMetadata.MaxAge);
Assert.AreEqual(metadata.TruncateBefore, meta.StreamMetadata.TruncateBefore);
Assert.AreEqual(metadata.CacheControl, meta.StreamMetadata.CacheControl);
metadata = StreamMetadata.Create(37, TimeSpan.FromSeconds(0xBEEFDEAD), 24, TimeSpan.FromSeconds(0xDABACABAD));
_connection.SetStreamMetadataAsync(_stream, 0, metadata).Wait();
meta = _connection.GetStreamMetadataAsync(_stream).Result;
Assert.AreEqual(_stream, meta.Stream);
Assert.AreEqual(false, meta.IsStreamDeleted);
Assert.AreEqual(1, meta.MetastreamVersion);
Assert.AreEqual(metadata.MaxCount, meta.StreamMetadata.MaxCount);
Assert.AreEqual(metadata.MaxAge, meta.StreamMetadata.MaxAge);
Assert.AreEqual(metadata.TruncateBefore, meta.StreamMetadata.TruncateBefore);
Assert.AreEqual(metadata.CacheControl, meta.StreamMetadata.CacheControl);
}
public async Task <T> GetStreamMetadata <T>(string id, string key)
{
var streamMetadata = await _connection.GetStreamMetadataAsync(id);
return(streamMetadata.StreamMetadata.GetValue <string>(key).ToObject <T>());
}