public TAggregate GetById <TAggregate>(Guid id, int version = int.MaxValue) where TAggregate : class, IEventSource
{
if (version <= 0)
{
throw new InvalidOperationException("Cannot get version <= 0");
}
var streamName = _streamNameBuilder.GenerateForAggregate(typeof(TAggregate), id);
var aggregate = ConstructAggregate <TAggregate>();
long sliceStart = 0;
StreamEventsSlice currentSlice;
var appliedEventCount = 0;
do
{
long sliceCount = sliceStart + ReadPageSize <= version
? ReadPageSize
: version - sliceStart;
currentSlice = _streamStoreConnection.ReadStreamForward(streamName, sliceStart, (int)sliceCount);
if (currentSlice is StreamNotFoundSlice)
{
throw new AggregateNotFoundException(id, typeof(TAggregate));
}
if (currentSlice is StreamDeletedSlice)
{
throw new AggregateDeletedException(id, typeof(TAggregate));
}
sliceStart = currentSlice.NextEventNumber;
appliedEventCount += currentSlice.Events.Length;
aggregate.RestoreFromEvents(currentSlice.Events.Select(evt => _eventSerializer.Deserialize(evt)));
} while (version > currentSlice.NextEventNumber && !currentSlice.IsEndOfStream);
if (version != Int32.MaxValue && version != appliedEventCount)
{
throw new AggregateVersionException(id, typeof(TAggregate), version, aggregate.ExpectedVersion);
}
if (version != Int32.MaxValue && aggregate.ExpectedVersion != version - 1)
{
throw new AggregateVersionException(id, typeof(TAggregate), version, aggregate.ExpectedVersion);
}
return(aggregate);
}
/// <summary>
/// Named Stream Reader
/// i.e. [StreamName]
/// </summary>
/// <param name="streamName">An exact stream name.</param>
/// <param name="checkpoint">The starting point to read from.</param>
/// <param name="count">The count of items to read</param>
/// <param name="readBackwards">Read the stream backwards</param>
/// <returns>Returns true if any events were read from the stream</returns>
public virtual bool Read(
string streamName,
long?checkpoint = null,
long?count = null,
bool readBackwards = false)
{
var eventsRead = false;
if (checkpoint != null)
{
Ensure.Nonnegative((long)checkpoint, nameof(checkpoint));
}
if (count != null)
{
Ensure.Positive((long)count, nameof(count));
}
if (!ValidateStreamName(streamName))
{
throw new ArgumentException("Stream not found.", streamName);
}
_cancelled = false;
firstEventRead = false;
StreamName = streamName;
long sliceStart = checkpoint ?? (readBackwards ? -1 : 0);
long remaining = count ?? long.MaxValue;
StreamEventsSlice currentSlice;
do
{
var page = remaining < ReadPageSize ? remaining: ReadPageSize;
currentSlice = !readBackwards
? _streamStoreConnection.ReadStreamForward(streamName, sliceStart, page)
: _streamStoreConnection.ReadStreamBackward(streamName, sliceStart, page);
if (!(currentSlice is StreamEventsSlice))
{
return(false);
}
remaining -= currentSlice.Events.Length;
sliceStart = currentSlice.NextEventNumber;
Array.ForEach(currentSlice.Events, EventRead);
} while (!currentSlice.IsEndOfStream && !_cancelled && remaining != 0);
return(eventsRead);
}
private async Task ReadEventsInternalAsync(IStreamStoreConnection connection, UserCredentials userCredentials, long?lastEventNumber)
{
StreamEventsSlice slice;
do
{
slice = connection.ReadStreamForward(
StreamId,
_nextReadEventNumber,
ReadBatchSize,
userCredentials);
}while (!await ReadEventsCallbackAsync(slice, lastEventNumber).ConfigureAwait(false));
}
internal static void WaitForStream(IStreamStoreConnection conn, string streamName)
{
//wait for the category projection to be written
AssertEx.IsOrBecomesTrue(
() =>
{
try
{
return(conn.ReadStreamForward(streamName, 0, 1) != null);
}
catch
{
return(false);
}
},
2000,
$"Stream '{streamName}' not created");
}
public void Connect(
UserCredentials credentials,
IPAddress server,
int tcpPort)
{
var tcpEndpoint = new IPEndPoint(server, tcpPort);
var settings = ConnectionSettings.Create()
.SetDefaultUserCredentials(new global::EventStore.ClientAPI.SystemData.UserCredentials(credentials.Username, credentials.Password))
.KeepReconnecting()
.KeepRetrying()
.UseConsoleLogger()
//.EnableVerboseLogging()
.Build();
Connection = new EventStoreConnectionWrapper(EventStoreConnection.Create(settings, tcpEndpoint, "Default Connection"));
if (Connection == null)
{
_log.Error("EventStore Connection is null - Diagnostic Monitoring will be unavailable.");
TeardownEventStore(false);
return;
}
Connection.Connect();
int retry = 8;
int count = 0;
do
{
try {
Connection.ReadStreamForward("by_event_type", 0, 1);
return;
}
catch {
//ignore
}
Thread.Sleep(100);
count++;
} while (count < retry);
throw new Exception("Unable to start Eventstore");
}
public static bool TryConfirmStream(this IStreamStoreConnection conn, string streamTypeName, int expectedEventCount)
{
int count = 0;
while (true)
{
try {
var slice = conn.ReadStreamForward(streamTypeName, StreamPosition.Start, 500);
if (slice.IsEndOfStream && slice.Events.Length == expectedEventCount)
{
return(true);
}
Thread.Sleep(10);
count++;
if (count > 100)
{
return(false);
}
}
catch {
//ignore
}
}
}
public bool ValidateStreamName(string streamName)
{
var isValid = _eventStoreConnection.ReadStreamForward(streamName, 0, 1) != null;
return(isValid);
}
/// <summary>
/// Named Stream Reader
/// i.e. [StreamName]
/// </summary>
/// <param name="streamName">An exact stream name.</param>
/// <param name="completionCheck">Read will block until true to ensure processing has completed, use '()=> true' to continue without blocking. If cancellation or timeout is required it should be implemented in the completion method</param>
/// <param name="checkpoint">The event number of the last received event. Reading will start with the next event.</param>
/// <param name="count">The count of items to read</param>
/// <param name="readBackwards">Read the stream backwards</param>
/// <returns>Returns true if any events were read from the stream</returns>
public virtual bool Read(
string streamName,
Func <bool> completionCheck,
long?checkpoint = null,
long?count = null,
bool readBackwards = false)
{
if (checkpoint != null)
{
Ensure.Nonnegative((long)checkpoint, nameof(checkpoint));
}
if (count != null)
{
Ensure.Positive((long)count, nameof(count));
}
if (!ValidateStreamName(streamName))
{
throw new ArgumentException("Stream not found.", streamName);
}
_cancelled = false;
FirstEventRead = false;
StreamName = streamName;
long sliceStart;
if (checkpoint is null)
{
sliceStart = readBackwards ? -1 : 0;
}
else
{
sliceStart = checkpoint.Value + (readBackwards ? -1 : 1);
}
long remaining = count ?? long.MaxValue;
StreamEventsSlice currentSlice;
do
{
var page = remaining < ReadPageSize ? remaining : ReadPageSize;
currentSlice = !readBackwards
? _streamStoreConnection.ReadStreamForward(streamName, sliceStart, page)
: _streamStoreConnection.ReadStreamBackward(streamName, sliceStart, page);
if (!(currentSlice is StreamEventsSlice))
{
break;
}
if (currentSlice.Events.Length > 0)
{
FirstEventRead = true;
}
remaining -= currentSlice.Events.Length;
sliceStart = currentSlice.NextEventNumber;
Array.ForEach(currentSlice.Events, EventRead);
} while (!currentSlice.IsEndOfStream && !_cancelled && remaining != 0);
if (FirstEventRead && completionCheck != null)
{
SpinWait.SpinUntil(() => { try { return(completionCheck()); } catch { return(true); } });
}
return(FirstEventRead);
}