public async Task <IEnumerable <EventModel> > ReadAllEventsForwardAsync()
{
var records =
await eventStoreConnection.ReadAllEventsForwardAsync(Position.Start, PageSize, false,
CredentialsHelper.Default);
return(records.Events.Select(@event => @event.Event.ParseEvent()).ToList());
}
public static void ReadSavedEvents()
{
var allEvents = new List <ResolvedEvent>();
var nonStatEvents = new List <ResolvedEvent>();
AllEventsSlice currentSlice;
var nextSliceStart = Position.Start;
do
{
currentSlice =
connection.ReadAllEventsForwardAsync(nextSliceStart, 200, false).Result;
nextSliceStart = currentSlice.NextPosition;
allEvents.AddRange(currentSlice.Events);
} while (!currentSlice.IsEndOfStream);
foreach (var resolvedEvent in allEvents)
{
if (resolvedEvent.OriginalStreamId != "user-admin" &&
resolvedEvent.OriginalStreamId[0] != '$')
{
nonStatEvents.Add(resolvedEvent);
}
}
distrbuteSavedEvents(nonStatEvents);
}
public async IAsyncEnumerable <IEvent> GetAllEventsBetween(Position startPosition, Position endPosition, IReadOnlyCollection <Type> eventTypes)
{
await Connect();
var eventTypesByName = eventTypes.ToDictionary(x => x.Name);
AllEventsSlice currentSlice;
do
{
currentSlice = await _connection.ReadAllEventsForwardAsync(startPosition, EVENT_COUNT, false);
startPosition = currentSlice.NextPosition;
foreach (var @event in currentSlice.Events.Where(x => !x.Event.EventType.StartsWith("$")))
{
if (eventTypesByName.TryGetValue(@event.Event.EventType, out var eventType))
{
yield return(ConvertToDomainEvent(@event, eventType));
}
if (@event.OriginalPosition == endPosition)
{
yield break;
}
}
} while (!currentSlice.IsEndOfStream);
}
private async Task ReadEventsInternalAsync(IEventStoreConnection connection, bool resolveLinkTos,
UserCredentials userCredentials, long?lastCommitPosition, long?lastEventNumber)
{
var slice = await connection.ReadAllEventsForwardAsync(_nextReadPosition, ReadBatchSize, resolveLinkTos, userCredentials).ConfigureAwait(false);
await ReadEventsCallbackAsync(slice, connection, resolveLinkTos, userCredentials, lastCommitPosition, lastEventNumber).ConfigureAwait(false);
}
public static void ReadSavedEvents()
{
var log = Connection.Book.From("EventLog", new { Id = 1 }).ToObject <EventLog>().Execute();
if (log.EventCount == 0)
{
//Task<AllEventsSlice>
var allEvents = new List <ResolvedEvent>();
var nonStatEvents = new List <ResolvedEvent>();
AllEventsSlice currentSlice;
var nextSliceStart = Position.Start;
do
{
currentSlice =
connection.ReadAllEventsForwardAsync(nextSliceStart, 200, false).Result;
nextSliceStart = currentSlice.NextPosition;
allEvents.AddRange(currentSlice.Events);
} while (!currentSlice.IsEndOfStream);
foreach (var resolvedEvent in allEvents)
{
if (resolvedEvent.OriginalStreamId != "user-admin" &&
resolvedEvent.OriginalStreamId[0] != '$')
{
nonStatEvents.Add(resolvedEvent);
}
}
distrbuteSavedEvents(nonStatEvents);
}
}
/// <summary>
/// Read events until the given position.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="resolveLinkTos">Whether to resolve Link events.</param>
/// <param name="userCredentials">User credentials for the operation.</param>
/// <param name="lastCommitPosition">The commit position to read until.</param>
/// <param name="lastEventNumber">The event number to read until.</param>
protected override void ReadEventsTill(IEventStoreConnection connection, bool resolveLinkTos,
UserCredentials userCredentials, long?lastCommitPosition, int?lastEventNumber)
{
bool done;
do
{
AllEventsSlice slice = connection.ReadAllEventsForwardAsync(_nextReadPosition, ReadBatchSize, resolveLinkTos, userCredentials).Result;
foreach (var e in slice.Events)
{
if (e.OriginalPosition == null)
{
throw new Exception("Subscription event came up with no OriginalPosition.");
}
TryProcess(e);
}
_nextReadPosition = slice.NextPosition;
done = lastCommitPosition == null
? slice.IsEndOfStream
: slice.NextPosition >= new Position(lastCommitPosition.Value, lastCommitPosition.Value);
if (!done && slice.IsEndOfStream)
{
Thread.Sleep(1); // we are waiting for server to flush its data
}
} while (!done && !ShouldStop);
if (Verbose)
{
Log.Debug("Catch-up Subscription to {0}: finished reading events, nextReadPosition = {1}.",
IsSubscribedToAll ? "<all>" : StreamId, _nextReadPosition);
}
}
private void UpgradeProjectionPartitionCheckpoints()
{
Log("Looking for projection partition checkpoint streams");
var from = Position.Start;
_oldTfScanPercent = 0d;
var lastSlice = _connection.ReadAllEventsBackwardAsync(Position.End, 1, false, _credentials).Result;
if (lastSlice.Events.Length == 0)
{
throw new Exception("Empty TF");
}
_lastTfPosition = lastSlice.Events[0].OriginalPosition.Value.PreparePosition;
AllEventsSlice slice;
do
{
slice = _connection.ReadAllEventsForwardAsync(@from, 100, false, _credentials).Result;
DisplayTfScanProgress(slice);
foreach (var @event in slice.Events)
{
if (@event.OriginalEventNumber == 0)
{
UpgradeStreamIfPartitionCheckpoint(@event.OriginalStreamId);
}
}
from = slice.NextPosition;
} while (!slice.IsEndOfStream);
Log("Completed looking for partition checkpoint streams");
}
public static AllEventsSlice ReadAllEventsForward(this IEventStoreConnection con, Position position, int maxCount, bool resolveLinkTos, UserCredentials userCredentials = null)
{
var task = con.ReadAllEventsForwardAsync(position, maxCount, resolveLinkTos, userCredentials);
task.Wait();
return(task.Result);
}
public async Task ReplayAllEvents()
{
var result = await _connection.ReadAllEventsForwardAsync(Position.Start, 4096, false, _credentials);
foreach (var evnt in result.Events)
{
BroadcastEvent(evnt);
}
}
public async Task PerformAll(Action <Guid> actionToNotifyEventIsDone = null)
{
var currentposition = await _positionReaderService.GetCurrentPosition();
var position = new Position(currentposition.CommitPosition, currentposition.PreparePosition);
var maxCount = 4096;
var retrievedEvents = await _eventStoreConnection.ReadAllEventsForwardAsync(position, maxCount, false);
PerformEventHandlerInvoke(actionToNotifyEventIsDone, retrievedEvents.Events);
}
private async Task ReadEventsInternalAsync(IEventStoreConnection connection, bool resolveLinkTos,
UserCredentials userCredentials, long?lastCommitPosition)
{
bool shouldStopOrDone;
do
{
var slice = await connection.ReadAllEventsForwardAsync(_nextReadPosition, ReadBatchSize, resolveLinkTos, userCredentials).ConfigureAwait(false);
shouldStopOrDone = await ReadEventsCallbackAsync(slice, lastCommitPosition).ConfigureAwait(false);
} while (!shouldStopOrDone);
}
public async Task Load()
{
var readEvents = await _storeConnection.ReadAllEventsForwardAsync(new Position(0, 0), 4000, false);
foreach (var resolvedEvent in readEvents.Events)
{
Console.WriteLine("Processing event", resolvedEvent.Event.EventType);
ProcessEvent(resolvedEvent);
}
_storeConnection.SubscribeToAllAsync(false, EventAppeared);
}
public async Task <IEnumerable <EventWrapper> > GetEvents()
{
var eventStoreResponse = await _connection.ReadAllEventsForwardAsync(_position, 100, false);
_position = eventStoreResponse.NextPosition;
var events = eventStoreResponse
.Events
.Where(e => _cachedTypes.ContainsKey(e.Event.EventType))
.Select(e => new EventWrapper(
JsonConvert.DeserializeObject(Encoding.UTF8.GetString(e.Event.Data), _cachedTypes[e.Event.EventType]),
JsonConvert.DeserializeObject <Metadata>(Encoding.UTF8.GetString(e.Event.Metadata))));
return(events);
}
private async Task <ReactiveDomain.Testing.RecordedEvent[]> ReadThens(Position position)
{
var recorded = new List <ReactiveDomain.Testing.RecordedEvent>();
var slice = await _connection.ReadAllEventsForwardAsync(position, 1024, false, new UserCredentials("admin", "changeit"));
recorded.AddRange(
slice.Events
.Where(resolved =>
!resolved.OriginalStreamId.StartsWith("$") &&
resolved.OriginalStreamId.StartsWith(_prefix.ToString()) &&
resolved.OriginalEvent.IsJson)
.Select(resolved => new ReactiveDomain.Testing.RecordedEvent(
new StreamName(resolved.OriginalStreamId),
JsonConvert.DeserializeObject(
Encoding.UTF8.GetString(resolved.OriginalEvent.Data),
Type.GetType(resolved.OriginalEvent.EventType, true),
_settings))));
while (!slice.IsEndOfStream)
{
slice = await _connection.ReadAllEventsForwardAsync(slice.NextPosition, 1024, false, new UserCredentials("admin", "changeit"));
recorded.AddRange(
slice.Events
.Where(resolved =>
!resolved.OriginalStreamId.StartsWith("$") &&
resolved.OriginalStreamId.StartsWith(_prefix.ToString()) &&
resolved.OriginalEvent.IsJson)
.Select(resolved => new ReactiveDomain.Testing.RecordedEvent(
new StreamName(resolved.OriginalStreamId),
JsonConvert.DeserializeObject(
Encoding.UTF8.GetString(resolved.OriginalEvent.Data),
Type.GetType(resolved.OriginalEvent.EventType, true),
_settings))));
}
return(recorded.ToArray());
}
private void ReadEventsInternal(IEventStoreConnection connection, bool resolveLinkTos,
UserCredentials userCredentials, long?lastCommitPosition, int?lastEventNumber)
{
try {
connection.ReadAllEventsForwardAsync(_nextReadPosition, ReadBatchSize, resolveLinkTos, userCredentials)
.ContinueWith(_ =>
{
ReadEventsCallback(_, connection, resolveLinkTos, userCredentials, lastCommitPosition, lastEventNumber);
});
}
catch (Exception ex)
{
_completion.TrySetException(ex);
}
}
private async Task <IEnumerable <ResolvedEvent> > ReadAllEvents()
{
var streamEvents = new List <ResolvedEvent>();
AllEventsSlice currentSlice;
var nextSliceStart = Position.Start;
do
{
currentSlice = await _connection.ReadAllEventsForwardAsync(nextSliceStart, EVENT_COUNT, false);
nextSliceStart = currentSlice.NextPosition;
streamEvents.AddRange(currentSlice.Events);
} while (!currentSlice.IsEndOfStream);
return(streamEvents);
}
private static void ReadAllEventsForward(IEventStoreConnection connection)
{
UserCredentials credentials = new UserCredentials("admin", "changeit");
AllEventsSlice slice = connection.ReadAllEventsForwardAsync(Position.Start, 100, false, credentials).Result;
if (slice.Events.Length > 0)
{
Console.WriteLine("id: " + slice.Events[0].Event.EventId);
string data = Encoding.UTF8.GetString(slice.Events[0].Event.Data);
Console.WriteLine("data: " + data);
string metadata = Encoding.UTF8.GetString(slice.Events[0].Event.Metadata);
Console.WriteLine("metadata: " + metadata);
}
}
public async Task GetAllEvents()
{
var allEvents = new List <ResolvedEvent>();
AllEventsSlice currentSlice;
var nextSliceStart = Position.Start;
do
{
currentSlice = await _connection.ReadAllEventsForwardAsync(nextSliceStart, 200, false);
nextSliceStart = currentSlice.NextPosition;
allEvents.AddRange(currentSlice.Events);
} while (!currentSlice.IsEndOfStream);
Console.ReadLine();
}
private async Task <Position> ReadHistoricalEventsFrom(Position from)
{
var position = from;
AllEventsSlice slice;
while (!stop && (slice = await eventStoreConnection.ReadAllEventsForwardAsync(position, ReadPageSize, false)).Events.Length > 0)
{
foreach (var rawEvent in slice.Events)
{
historicalQueue.Enqueue(rawEvent);
}
EnsurePublishEvents(historicalQueue, historicalDone);
position = slice.NextPosition;
}
return(position);
}
public void RepublishAllEvents()
{
AllEventsSlice currentSlice;
var nextPosition = Position.Start;
do
{
currentSlice = _eventStoreConnection
.ReadAllEventsForwardAsync(nextPosition, ReadPageSize, false)
.Result;
nextPosition = currentSlice.NextPosition;
foreach (var evnt in currentSlice.Events)
{
DomainEvent aggrEvent = (DomainEvent)DeserializeEvent(evnt.OriginalEvent.Metadata, evnt.OriginalEvent.Data);
this._publisher.Publish(aggrEvent);
}
} while (!currentSlice.IsEndOfStream);
}
public IList <IEvent> GetStreamForAggregate(int aggregateId)
{
var serializedEvents = _connection.ReadAllEventsForwardAsync(Position.Start, 1000, false, credentials).GetAwaiter().GetResult();
var deserializeEvents = new List <IEvent>();
foreach (var serializeEvent in serializedEvents.Events)
{
var eventType = GetTypeFromName(serializeEvent.Event.EventType);
if (eventType == typeof(CleaningRequested))
{
deserializeEvents.Add(Utf8Json.JsonSerializer.Deserialize <CleaningRequested>(serializeEvent.Event.Data));
}
}
return(deserializeEvents);
Type GetTypeFromName(string typeName)
{
return(Type.GetType(typeName));
}
}
public async Task <AllCommittedEventsPage> LoadAllCommittedEvents(
GlobalPosition globalPosition,
int pageSize,
CancellationToken cancellationToken)
{
var nextPosition = ParsePosition(globalPosition);
var resolvedEvents = new List <ResolvedEvent>();
AllEventsSlice allEventsSlice;
do
{
allEventsSlice = await _connection.ReadAllEventsForwardAsync(nextPosition, pageSize, false).ConfigureAwait(false);
resolvedEvents.AddRange(allEventsSlice.Events.Where(e => !e.OriginalStreamId.StartsWith("$")));
nextPosition = allEventsSlice.NextPosition;
}while (resolvedEvents.Count < pageSize && !allEventsSlice.IsEndOfStream);
var eventStoreEvents = Map(resolvedEvents);
return(new AllCommittedEventsPage(
new GlobalPosition(string.Format("{0}-{1}", nextPosition.CommitPosition, nextPosition.PreparePosition)),
eventStoreEvents));
}
public static void DeleteAllStreams(this IEventStoreConnection connection)
{
var slice = connection.
ReadAllEventsForwardAsync(
Position.Start, Int32.MaxValue, false, EmbeddedEventStore.Credentials);
slice.Wait();
var streams = slice.Result.
Events.
Select(_ => _.OriginalStreamId).
Where(StreamNameIsNotReserved).
Distinct();
foreach (var stream in streams)
{
var streamStatusSlice = connection.ReadStreamEventsForwardAsync(stream, 0, 1, false);
streamStatusSlice.Wait();
if (streamStatusSlice.Result.Status != SliceReadStatus.StreamDeleted &&
streamStatusSlice.Result.Status != SliceReadStatus.StreamNotFound)
{
connection.DeleteStreamAsync(stream, ExpectedVersion.Any, EmbeddedEventStore.Credentials).Wait();
}
}
}
public async Task ReadAllEventsForward(StreamMessageReceived streamMessageReceived)
{
AllEventsSlice currentSlice;
var nextSliceStart = Position.Start;
do
{
currentSlice = await _eventSourcing.ReadAllEventsForwardAsync(nextSliceStart, 100, false)
.ConfigureAwait(false);
nextSliceStart = currentSlice.NextPosition;
foreach (var @event in currentSlice.Events)
{
await streamMessageReceived(new EventResponse(
@event.Event.EventStreamId,
@event.Event.EventId,
@event.Event.EventNumber,
@event.Event.EventType,
@event.Event.Data
));
}
} while (!currentSlice.IsEndOfStream);
}
/// <summary>
/// Read events until the given position async.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="resolveLinkTos">Whether to resolve Link events.</param>
/// <param name="userCredentials">User credentials for the operation.</param>
/// <param name="lastCommitPosition">The commit position to read until.</param>
/// <param name="lastEventNumber">The event number to read until.</param>
/// <returns></returns>
protected override Task ReadEventsTillAsync(IEventStoreConnection connection, bool resolveLinkTos,
UserCredentials userCredentials, long?lastCommitPosition, int?lastEventNumber)
{
return(connection.ReadAllEventsForwardAsync(_nextReadPosition, ReadBatchSize, resolveLinkTos, userCredentials)
.ContinueWith(_ =>
{
if (_.IsFaulted || _.IsCanceled)
{
_.Wait(); //force exception to be thrown
}
if (!ProcessEvents(lastCommitPosition, _.Result) && !ShouldStop)
{
ReadEventsTillAsync(connection, resolveLinkTos, userCredentials,
lastCommitPosition, lastEventNumber);
}
else if (Verbose)
{
Log.Debug(
"Catch-up Subscription to {0}: finished reading events, nextReadPosition = {1}.",
IsSubscribedToAll ? "<all>" : StreamId, _nextReadPosition);
}
}, TaskContinuationOptions.AttachedToParent));
}
public async Task ReadEvents(
Shared.Position fromPosition, Func <BaseOriginalEvent, ValueTask> next, CancellationToken cancellationToken
)
{
await _realtime.Start().ConfigureAwait(false);
Log.Info("Starting TCP reader");
var sequence = 0;
var start =
fromPosition != Shared.Position.Start
? new Position((long)fromPosition.EventPosition, (long)fromPosition.EventPosition)
: new Position(0, 0);
if (fromPosition != Shared.Position.Start)
{
// skip one
var e = await _connection.ReadAllEventsForwardAsync(start, 1, false).ConfigureAwait(false);
start = e.NextPosition;
}
while (!cancellationToken.IsCancellationRequested)
{
using var activity = new Activity("read");
activity.Start();
var slice = await ReplicationMetrics.Measure(
() => _connection.ReadAllEventsForwardAsync(start, _pageSize, false),
ReplicationMetrics.ReadsHistogram,
x => x.Events.Length,
ReplicationMetrics.ReadErrorsCount
).ConfigureAwait(false);
foreach (var sliceEvent in slice?.Events ?? Enumerable.Empty <ResolvedEvent>())
{
if (sliceEvent.Event.EventType.StartsWith('$') &&
sliceEvent.Event.EventType != Predefined.MetadataEventType)
{
await next(MapIgnored(sliceEvent, sequence++, activity)).ConfigureAwait(false);
continue;
}
if (Log.IsDebugEnabled())
{
Log.Debug(
"TCP: Read event with id {Id} of type {Type} from {Stream} at {Position}",
sliceEvent.Event.EventId,
sliceEvent.Event.EventType,
sliceEvent.OriginalStreamId,
sliceEvent.OriginalPosition
);
}
if (sliceEvent.Event.EventType == Predefined.MetadataEventType)
{
if (sliceEvent.Event.EventStreamId.StartsWith('$'))
{
continue;
}
if (Encoding.UTF8.GetString(sliceEvent.Event.Data) == StreamDeletedBody)
{
if (Log.IsDebugEnabled())
{
Log.Debug("Stream deletion {Stream}", sliceEvent.Event.EventStreamId);
}
await next(MapStreamDeleted(sliceEvent, sequence++, activity));
}
else
{
var meta = MapMetadata(sliceEvent, sequence++, activity);
if (Log.IsDebugEnabled())
{
Log.Debug("Stream meta {Stream}: {Meta}", sliceEvent.Event.EventStreamId, meta);
}
await next(meta);
}
}
else if (sliceEvent.Event.EventType[0] != '$')
{
var originalEvent = Map(sliceEvent, sequence++, activity);
await next(originalEvent).ConfigureAwait(false);
}
}
if (slice !.IsEndOfStream)
{
Log.Info("Reached the end of the stream at {Position}", slice.NextPosition);
break;
}
start = slice.NextPosition;
}
}
/// <summary>
/// Read events until the given position.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="resolveLinkTos">Whether to resolve Link events.</param>
/// <param name="userCredentials">User credentials for the operation.</param>
/// <param name="lastCommitPosition">The commit position to read until.</param>
/// <param name="lastEventNumber">The event number to read until.</param>
protected override void ReadEventsTill(IEventStoreConnection connection, bool resolveLinkTos,
UserCredentials userCredentials, long? lastCommitPosition, int? lastEventNumber)
{
bool done;
do
{
AllEventsSlice slice = connection.ReadAllEventsForwardAsync(_nextReadPosition, ReadBatchSize, resolveLinkTos, userCredentials).Result;
foreach (var e in slice.Events)
{
if (e.OriginalPosition == null) throw new Exception("Subscription event came up with no OriginalPosition.");
TryProcess(e);
}
_nextReadPosition = slice.NextPosition;
done = lastCommitPosition == null
? slice.IsEndOfStream
: slice.NextPosition >= new Position(lastCommitPosition.Value, lastCommitPosition.Value);
if (!done && slice.IsEndOfStream)
Thread.Sleep(1); // we are waiting for server to flush its data
} while (!done && !ShouldStop);
if (Verbose)
Log.Debug("Catch-up Subscription to {0}: finished reading events, nextReadPosition = {1}.",
IsSubscribedToAll ? "<all>" : StreamId, _nextReadPosition);
}
private void ReadEventsInternal(IEventStoreConnection connection, bool resolveLinkTos,
UserCredentials userCredentials, long? lastCommitPosition, int? lastEventNumber)
{
try {
connection.ReadAllEventsForwardAsync(_nextReadPosition, ReadBatchSize, resolveLinkTos, userCredentials)
.ContinueWith(_ =>
{
ReadEventsCallback(_, connection, resolveLinkTos, userCredentials, lastCommitPosition, lastEventNumber);
});
}
catch (Exception ex)
{
_completion.SetException(ex);
}
}
protected Task ReadAllForward(string login, string password)
{
return(Connection.ReadAllEventsForwardAsync(Position.Start, 1, false,
login == null && password == null ? null : new UserCredentials(login, password)));
}
/// <summary>
/// Read events until the given position async.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="resolveLinkTos">Whether to resolve Link events.</param>
/// <param name="userCredentials">User credentials for the operation.</param>
/// <param name="lastCommitPosition">The commit position to read until.</param>
/// <param name="lastEventNumber">The event number to read until.</param>
/// <returns></returns>
protected override Task ReadEventsTillAsync(IEventStoreConnection connection, bool resolveLinkTos,
UserCredentials userCredentials, long? lastCommitPosition, int? lastEventNumber)
{
return connection.ReadAllEventsForwardAsync(_nextReadPosition, ReadBatchSize, resolveLinkTos, userCredentials)
.ContinueWith(_ =>
{
if (_.IsFaulted || _.IsCanceled)
{
_.Wait(); //force exception to be thrown
}
if (!ProcessEvents(lastCommitPosition, _.Result) && !ShouldStop)
{
ReadEventsTillAsync(connection, resolveLinkTos, userCredentials,
lastCommitPosition, lastEventNumber);
}
else if (Verbose)
{
Log.Debug(
"Catch-up Subscription to {0}: finished reading events, nextReadPosition = {1}.",
IsSubscribedToAll ? "<all>" : StreamId, _nextReadPosition);
}
}, TaskContinuationOptions.AttachedToParent);
}
protected void ReadAllForward(string login, string password)
{
Connection.ReadAllEventsForwardAsync(Position.Start, 1, false,
login == null && password == null ? null : new UserCredentials(login, password))
.Wait();
}