public void ImplicitConversionFromStreamPositionReturnsExpectedResult()
{
const ulong value = 0UL;
ulong actual = new StreamPosition(value);
Assert.Equal(value, actual);
}
public void SubtractionOperator()
{
var sut = new StreamPosition(1);
Assert.Equal(new StreamPosition(0), sut - 1);
Assert.Equal(new StreamPosition(0), 1 - sut);
}
public void ImplicitConversionToStreamPositionReturnsExpectedResult()
{
const ulong value = 0UL;
var expected = new StreamPosition(value);
StreamPosition actual = value;
Assert.Equal(expected, actual);
}
public static StreamMetadataResult Create(string streamName, StreamPosition revision,
StreamMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
return(new StreamMetadataResult(streamName, revision, metadata));
}
public EventRecord(
string eventStreamId,
Uuid eventId,
StreamPosition eventNumber,
Position position,
IDictionary <string, string> metadata,
ReadOnlyMemory <byte> data,
ReadOnlyMemory <byte> customMetadata)
{
EventStreamId = eventStreamId;
EventId = eventId;
EventNumber = eventNumber;
Position = position;
Data = data;
Metadata = customMetadata;
EventType = metadata[Constants.Metadata.Type];
Created = Convert.ToInt64(metadata[Constants.Metadata.Created]).FromTicksSinceEpoch();
ContentType = metadata[Constants.Metadata.ContentType];
}
public PersistentSubscriptionSettings(bool resolveLinkTos = false, StreamPosition?startFrom = null,
bool extraStatistics = false, TimeSpan?messageTimeout = null, int maxRetryCount = 500,
int liveBufferSize = 500, int readBatchSize = 10, int historyBufferSize = 20,
TimeSpan?checkPointAfter = null, int minCheckPointCount = 10, int maxCheckPointCount = 1000,
int maxSubscriberCount = 0, string namedConsumerStrategy = SystemConsumerStrategies.RoundRobin)
{
messageTimeout ??= TimeSpan.FromSeconds(30);
checkPointAfter ??= TimeSpan.FromSeconds(2);
startFrom ??= StreamPosition.End;
if (messageTimeout.Value < TimeSpan.Zero || messageTimeout.Value.TotalMilliseconds > int.MaxValue)
{
throw new ArgumentOutOfRangeException(
nameof(messageTimeout),
$"{nameof(messageTimeout)} must be greater than {TimeSpan.Zero} and less than or equal to {TimeSpan.FromMilliseconds(int.MaxValue)}");
}
if (checkPointAfter.Value < TimeSpan.Zero || checkPointAfter.Value.TotalMilliseconds > int.MaxValue)
{
throw new ArgumentOutOfRangeException(
nameof(checkPointAfter),
$"{nameof(checkPointAfter)} must be greater than {TimeSpan.Zero} and less than or equal to {TimeSpan.FromMilliseconds(int.MaxValue)}");
}
ResolveLinkTos = resolveLinkTos;
StartFrom = startFrom.Value;
ExtraStatistics = extraStatistics;
MessageTimeout = messageTimeout.Value;
MaxRetryCount = maxRetryCount;
LiveBufferSize = liveBufferSize;
ReadBatchSize = readBatchSize;
HistoryBufferSize = historyBufferSize;
CheckPointAfter = checkPointAfter.Value;
MinCheckPointCount = minCheckPointCount;
MaxCheckPointCount = maxCheckPointCount;
MaxSubscriberCount = maxSubscriberCount;
NamedConsumerStrategy = namedConsumerStrategy;
}
public void Equality()
{
var sut = new StreamPosition(1);
Assert.Equal(new StreamPosition(1), sut);
}
public void AdditionOutOfBoundsThrows(StreamPosition StreamPosition, ulong operand)
{
Assert.Throws <OverflowException>(() => StreamPosition + operand);
Assert.Throws <OverflowException>(() => operand + StreamPosition);
}
public void InequalityOperator()
{
var sut = new StreamPosition(1);
Assert.True(new StreamPosition(2) != sut);
}
public static StreamMetadataResult Create(string streamName, StreamPosition revision,
StreamMetadata metadata) => new StreamMetadataResult(streamName, revision, metadata);
public void Comparability(StreamPosition left, StreamPosition right, int expected) => Assert.Equal(expected, left.CompareTo(right));
public void FromStreamPositionReturnsExpectedResult()
{
var result = StreamPosition.FromStreamRevision(new StreamRevision(0));
Assert.Equal(new StreamPosition(0), result);
}
public override StreamMetadata Read(ref Utf8JsonReader reader, Type typeToConvert,
JsonSerializerOptions options)
{
int? maxCount = null;
TimeSpan? maxAge = null, cacheControl = null;
StreamPosition?truncateBefore = null;
StreamAcl? acl = null;
using var stream = new MemoryStream();
using var customMetadataWriter = new Utf8JsonWriter(stream);
if (reader.TokenType != JsonTokenType.StartObject)
{
throw new InvalidOperationException();
}
customMetadataWriter.WriteStartObject();
while (reader.Read())
{
if (reader.TokenType == JsonTokenType.EndObject)
{
break;
}
if (reader.TokenType != JsonTokenType.PropertyName)
{
throw new InvalidOperationException();
}
switch (reader.GetString())
{
case SystemMetadata.MaxCount:
if (!reader.Read())
{
throw new InvalidOperationException();
}
maxCount = reader.GetInt32();
break;
case SystemMetadata.MaxAge:
if (!reader.Read())
{
throw new InvalidOperationException();
}
var int64 = reader.GetInt64();
maxAge = TimeSpan.FromSeconds(int64);
break;
case SystemMetadata.CacheControl:
if (!reader.Read())
{
throw new InvalidOperationException();
}
cacheControl = TimeSpan.FromSeconds(reader.GetInt64());
break;
case SystemMetadata.TruncateBefore:
if (!reader.Read())
{
throw new InvalidOperationException();
}
var value = reader.GetInt64();
truncateBefore = value == long.MaxValue
? StreamPosition.End
: StreamPosition.FromInt64(value);
break;
case SystemMetadata.Acl:
if (!reader.Read())
{
throw new InvalidOperationException();
}
acl = StreamAclJsonConverter.Instance.Read(ref reader, typeof(StreamAcl), options);
break;
default:
customMetadataWriter.WritePropertyName(reader.GetString() !);
reader.Read();
switch (reader.TokenType)
{
case JsonTokenType.Comment:
customMetadataWriter.WriteCommentValue(reader.GetComment());
break;
case JsonTokenType.String:
customMetadataWriter.WriteStringValue(reader.GetString());
break;
case JsonTokenType.Number:
customMetadataWriter.WriteNumberValue(reader.GetDouble());
break;
case JsonTokenType.True:
case JsonTokenType.False:
customMetadataWriter.WriteBooleanValue(reader.GetBoolean());
break;
case JsonTokenType.Null:
reader.Read();
customMetadataWriter.WriteNullValue();
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
}
}
customMetadataWriter.WriteEndObject();
customMetadataWriter.Flush();
stream.Position = 0;
return(new StreamMetadata(maxCount, maxAge, truncateBefore, cacheControl, acl,
JsonDocument.Parse(stream)));
}
private async Task <TAggregate> GetByIdOrDefaultAsync <TAggregate>(string aggregateId, int version)
where TAggregate : class, IAggregateRoot, new()
{
if (version <= 0)
{
throw new InvalidOperationException("Cannot get version <= 0");
}
var streamName = $"{typeof(TAggregate).Name}:{aggregateId}";
TAggregate aggregate = new TAggregate
{
Version = -1
};
RedisValue value = await Policies.RedisValueFallbackPolicy.ExecuteAsync(() => _cache.StringGetAsync(streamName));
if (value.HasValue)
{
aggregate = JsonSerializer.Deserialize <TAggregate>(value);
}
long sliceStart = aggregate.Version + 1;
EventStoreClient.ReadStreamResult stream = _eventStoreClient.ReadStreamAsync(Direction.Forwards, streamName, StreamPosition.FromInt64(sliceStart));
if (await stream.ReadState == ReadState.StreamNotFound)
{
return(null);
}
await foreach (var @event in stream)
{
object eventObject = DeserializeEvent(@event.Event.Metadata, @event.Event.Data);
Type applyType = typeof(IApply <>).MakeGenericType(eventObject.GetType());
var isAssignableFrom = applyType.IsAssignableFrom(aggregate.GetType());
if (isAssignableFrom)
{
((dynamic)aggregate).Apply((dynamic)eventObject);
}
aggregate.Version++;
}
aggregate.Context = _context;
return(aggregate);
}
public void SubtractionOutOfBoundsThrows(StreamPosition streamPosition, ulong operand)
{
Assert.Throws <OverflowException>(() => streamPosition - operand);
Assert.Throws <OverflowException>(() => (ulong)streamPosition - new StreamPosition(operand));
}
public static StreamRevision FromStreamPosition(StreamPosition position) => position.ToUInt64() switch
{
public void Inequality()
{
var sut = new StreamPosition(1);
Assert.NotEqual(new StreamPosition(2), sut);
}
private static CreateReq.Types.StreamOptions StreamOptionsForCreateProto(string streamName, StreamPosition position)
{
if (position == StreamPosition.Start)
{
return(new CreateReq.Types.StreamOptions {
StreamIdentifier = streamName,
Start = new Empty()
});
}
if (position == StreamPosition.End)
{
return(new CreateReq.Types.StreamOptions {
StreamIdentifier = streamName,
End = new Empty()
});
}
return(new CreateReq.Types.StreamOptions {
StreamIdentifier = streamName,
Revision = position.ToUInt64()
});
}
public static StreamPosition ParseStreamPosition(this ReadOnlyMemory <byte> json)
{
var checkPoint = json.ParseJson <string>();
return(StreamPosition.FromInt64(int.Parse(checkPoint)));
}