protected override async Task <SelectedSnapshot> LoadAsync(string persistenceId, SnapshotSelectionCriteria criteria) { if (criteria.Equals(SnapshotSelectionCriteria.None)) { return(null); } var streamName = GetStreamName(persistenceId); if (!criteria.Equals(SnapshotSelectionCriteria.Latest)) { var result = await FindSnapshot(streamName, criteria.MaxSequenceNr, criteria.MaxTimeStamp); return(result.Snapshot); } var slice = await _conn.ReadStreamEventsBackwardAsync(streamName, StreamPosition.End, 1, false); if (slice == null || slice.Status != SliceReadStatus.Success || !slice.Events.Any()) { return(null); } return(slice.Events.Select(_snapshotAdapter.Adapt).First()); }
protected void AssertStreamTail(string streamId, params string[] events) { #if DEBUG var result = _conn.ReadStreamEventsBackwardAsync(streamId, -1, events.Length, true, _admin).Result; switch (result.Status) { case SliceReadStatus.StreamDeleted: Assert.Fail("Stream '{0}' is deleted", streamId); break; case SliceReadStatus.StreamNotFound: Assert.Fail("Stream '{0}' does not exist", streamId); break; case SliceReadStatus.Success: var resultEventsReversed = result.Events.Reverse().ToArray(); if (resultEventsReversed.Length < events.Length) DumpFailed("Stream does not contain enough events", streamId, events, result.Events); else { for (var index = 0; index < events.Length; index++) { var parts = events[index].Split(new char[] { ':' }, 2); var eventType = parts[0]; var eventData = parts[1]; if (resultEventsReversed[index].Event.EventType != eventType) DumpFailed("Invalid event type", streamId, events, resultEventsReversed); else if (resultEventsReversed[index].Event.DebugDataView != eventData) DumpFailed("Invalid event body", streamId, events, resultEventsReversed); } } break; } #endif }
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 async Task read_stream_backward_respects_max_count() { var res = await _connection.ReadStreamEventsBackwardAsync(Stream, -1, 100, false); Assert.AreEqual(SliceReadStatus.Success, res.Status); Assert.AreEqual(3, res.Events.Length); Assert.AreEqual(_testEvents.Skip(2).Select(x => x.EventId).ToArray(), res.Events.Reverse().Select(x => x.Event.EventId).ToArray()); }
public async Task SaveAsync <T>(T aggregate) where T : AggregateRoot, new() { var changes = aggregate.GetChanges() .Select((change) => GetEventDataByEvent(change)) .ToArray(); if (!changes.Any()) { return; } var streamName = GetStreamName <T>(aggregate, aggregate.Id.ToString()); try { await _eventStoreConnection.AppendToStreamAsync(streamName, aggregate.Version, changes, null); } catch (WrongExpectedVersionException) { var page = await _eventStoreConnection.ReadStreamEventsBackwardAsync(streamName, -1, 1, false, null); _logger.LogError("Version failed. Stream: {Stream}. Expected Version: {Version}. Last Version: {LastEventNumber}", page.Stream, page.Status, aggregate.Version, page.LastEventNumber); throw new AggregateVersionFailedException(page.Stream, aggregate.Version, page.LastEventNumber); } }
protected IEnumerable <dynamic> GetDataByStreamName(string streamName) { StreamEventsSlice eventCollection; using (IEventStoreConnection connection = EventStoreConnectionHelper.GetEventStoreConnection()) { eventCollection = connection.ReadStreamEventsBackwardAsync(streamName, StreamPosition.End, 1, false).Result; } var jsonSerialiserSettings = EventDeserialiser.GetSerialisationSettings(); var encoder = new UTF8Encoding(); return (( ( (IEnumerable <dynamic>)eventCollection.Events .Select(e => JsonConvert.DeserializeObject(((dynamic)encoder.GetString(e.Event.Data)), jsonSerialiserSettings)) .SingleOrDefault() ) ?? ( Enumerable.Empty <dynamic>() ) ) .Select(x => x.Value)); }
public static async Task <(object Event, long Version)> ReadLastEvent(this IEventStoreConnection connection, string streamName, Func <string, Type> stringToType) { try { var slice = await connection .ReadStreamEventsBackwardAsync(streamName, StreamPosition.End, 1, true) .ConfigureAwait(false); if (slice.Status == SliceReadStatus.StreamDeleted || slice.Status == SliceReadStatus.StreamNotFound) { return(null, -1); } if (!slice.Events.Any()) { return(null, 0); } var @event = Deserialize(slice.Events.First(), stringToType); return(@event.@event, @event.index); } catch (Exception e) { Log.LogError(e, "Cannot read last event from stream {stream}: {message}", streamName, e.Message); throw; } }
/// <summary> /// Get the Last published event /// </summary> /// <param name="connection">connection to ES</param> /// <param name="accountStream">Name of the stream</param> /// <returns>json string of the last event</returns> public static string GetLastEvent(IEventStoreConnection connection, string accountStream) { if (AccountManager.StreamExits(connection, accountStream)) { var eventsStream = connection.ReadStreamEventsBackwardAsync(accountStream, 0, 1, true).Result; var lastEventNr = eventsStream.LastEventNumber; eventsStream = connection.ReadStreamEventsBackwardAsync(accountStream, lastEventNr, 1, true).Result; var lastEvent = eventsStream.Events[0].Event; var json = Encoding.UTF8.GetString(lastEvent.Data); return(json); } else { return(null); } }
public async Task <CompareablePosition> GetCheckpoint(string processId, CancellationToken ct, string bucketId = null) { int streamPosition = StreamPosition.End; var streamName = GetStreamId(processId, bucketId); do { if (ct.IsCancellationRequested) { return(new CompareablePosition()); } var slice = await _connection.ReadStreamEventsBackwardAsync(streamName, streamPosition, 1, false); if (slice.Status != SliceReadStatus.Success || slice.Events.Length == 0) { return(new CompareablePosition()); } var resolvedEvent = slice.Events[0]; var checkpointReached = _serializer.DeserializeEventData(resolvedEvent) as CheckpointReached; if (checkpointReached != null) { return(new CompareablePosition(checkpointReached.CheckpointToken.ParsePosition())); } streamPosition = resolvedEvent.Event.EventNumber - 1; } while(streamPosition >= 0); return(new CompareablePosition()); }
public static string GetLastEvent(this IEventStoreConnection connection, string streamName) { if (StreamExits(connection, streamName)) { var eventsStream = connection.ReadStreamEventsBackwardAsync(streamName, 0, 1, true).Result; var lastEventNr = eventsStream.LastEventNumber; eventsStream = connection.ReadStreamEventsBackwardAsync(streamName, lastEventNr, 1, true).Result; var lastEvent = eventsStream.Events[0].Event; var json = Encoding.UTF8.GetString(lastEvent.Data); return(json); } else { return(null); } }
public List <EventstoreEvent> ReadLastEvents(string streamName, int eventsToRead) { var result = _connection.ReadStreamEventsBackwardAsync(streamName, StreamPosition.End, eventsToRead, false).Result; var mappedEvents = result.Events.Select(MapEventstoreEvent); return(mappedEvents.Reverse().ToList()); }
public async Task TheExampleCanRun() { await _eventStoreConnection.ConnectAsync(); await WriteBytesToStream("test-stream", "testEvent", "some data"); var streamEvents = await _eventStoreConnection.ReadStreamEventsBackwardAsync("test-stream", StreamPosition.End, 1, false); var returnedEvent = streamEvents.Events[0].Event; var returnedData = Encoding.UTF8.GetString(returnedEvent.Data); var returnedMetaData = Encoding.UTF8.GetString(returnedEvent.Metadata); Assert.Equal("some data", returnedData); Assert.Equal("some metadata", returnedMetaData); }
public async Task <IEnumerable <EventLog> > LoadLogs <T>(int aggregateId, int take) where T : Aggregate, new() { if (aggregateId < 0) { throw new ArgumentException("Value cannot be below zero", nameof(aggregateId)); } var aggregate = new T(); var streamName = GetStreamName(aggregate, aggregateId); var results = new List <EventLog>(); var page = await _eventStore.ReadStreamEventsBackwardAsync( streamName, StreamPosition.End, take, false); if (page.Events.Length > 0) { results.AddRange(page.Events.Select(@event => { return(new EventLog { EventParameters = JsonSerializer.Deserialize( Encoding.UTF8.GetString(@event.OriginalEvent.Data), Type.GetType(Encoding.UTF8.GetString(@event.OriginalEvent.Metadata))), EventType = @event.Event.EventType, TimeStamp = @event.Event.Created }); })); } return(results); }
public T BuscarSnapshotPor <T>(Guid entidadeId) where T : Snapshot { var stream = string.Format("{0}-ss", entidadeId); var ev = conexao.ReadStreamEventsBackwardAsync(stream, StreamPosition.End, 1, false).Result; return(ev.Events.Any() ? (T)Deserialize(ev.Events.Single()) : null); }
private static async Task AppendToStream <T>(ConcurrentUnitOfWork uow, IEventStoreConnection connection, Now now, IStreamNameResolver getStreamName) where T : IAggregateRootEntity { foreach (Aggregate aggregate in uow.GetChanges()) { EventData[] changes = aggregate.Root.GetChanges() .Select(@event => new EventData( Guid.NewGuid(), @event.GetType().TypeQualifiedName(), true, Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(@event)), Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(new EventMetadata { TimeStamp = now(), AggregateType = typeof(T).Name, AggregateAssemblyQualifiedName = typeof(T).AssemblyQualifiedName, IsSnapshot = false })) )).ToArray(); try { await connection.AppendToStreamAsync(getStreamName.Resolve(aggregate.Identifier), aggregate.ExpectedVersion, changes); } catch (WrongExpectedVersionException) { StreamEventsSlice page = await connection.ReadStreamEventsBackwardAsync(aggregate.Identifier, -1, 1, false); throw new WrongExpectedStreamVersionException( $"Failed to append stream {aggregate.Identifier} with expected version {aggregate.ExpectedVersion}. " + $"{(page.Status == SliceReadStatus.StreamNotFound ? "Stream not found!" : $"Current Version: {page.LastEventNumber}")}"); } } }
private async IAsyncEnumerable <StoredEvent> QueryReverseAsync(string streamName, long sliceStart, long take = int.MaxValue, [EnumeratorCancellation] CancellationToken ct = default) { var taken = take; StreamEventsSlice currentSlice; do { currentSlice = await connection.ReadStreamEventsBackwardAsync(streamName, sliceStart, ReadPageSize, true); if (currentSlice.Status == SliceReadStatus.Success) { sliceStart = currentSlice.NextEventNumber; foreach (var resolved in currentSlice.Events.OrderByDescending(x => x.Event.EventNumber)) { var storedEvent = Formatter.Read(resolved, prefix, serializer); yield return(storedEvent); if (taken == take) { break; } taken++; } } }while (!currentSlice.IsEndOfStream && !ct.IsCancellationRequested && taken < take); }
/// <summary> /// Check if stream exists /// </summary> /// <param name="connection">connection to ES</param> /// <param name="streamName">Name of the stream</param> /// <returns>True if stream exists</returns> public static bool StreamExits(IEventStoreConnection connection, string streamName) { var lastEventsStream = connection.ReadStreamEventsBackwardAsync(streamName.ToLower(), 0, 1, false).Result; SliceReadStatus status = lastEventsStream.Status; return(status == 0); }
#pragma warning disable 1998 protected async Task AssertStreamTail(string streamId, params string[] events) { #pragma warning restore 1998 #if DEBUG await Task.Delay(TimeSpan.FromMilliseconds(500)); var result = await _conn.ReadStreamEventsBackwardAsync(streamId, -1, events.Length, true, _admin); switch (result.Status) { case SliceReadStatus.StreamDeleted: Assert.Fail("Stream '{0}' is deleted", streamId); break; case SliceReadStatus.StreamNotFound: Assert.Fail("Stream '{0}' does not exist", streamId); break; case SliceReadStatus.Success: var resultEventsReversed = result.Events.Reverse().ToArray(); if (resultEventsReversed.Length < events.Length) { DumpFailed("Stream does not contain enough events", streamId, events, result.Events); } else { for (var index = 0; index < events.Length; index++) { var parts = events[index].Split(new char[] { ':' }, 2); var eventType = parts[0]; var eventData = parts[1]; if (resultEventsReversed[index].Event.EventType != eventType) { DumpFailed("Invalid event type", streamId, events, resultEventsReversed); } else if (resultEventsReversed[index].Event.DebugDataView() != eventData) { DumpFailed("Invalid event body", streamId, events, resultEventsReversed); } } } break; } #endif }
public async Task Delete(TId selector) { var id = selector.ToString(); var eventsTail = await connection.ReadStreamEventsBackwardAsync(id, 0, 1, false); var expectedVersion = eventsTail.LastEventNumber; await connection.DeleteStreamAsync(id, expectedVersion); }
public Func <Task <SerializedEvent> > ReadEventsBackwards(string stream, int batchSize, long maxToRead, Action <string> onNotFound, bool resolveLinks = true) { return(new EventReader( position => _connection.ReadStreamEventsBackwardAsync(stream, position, batchSize, resolveLinks), () => onNotFound(stream), StreamPosition.End, maxToRead).Next); }
private static async Task <StreamEventsSlice> ReadStreamEventsBackwardsAsync(this IEventStoreConnection connection, string streamName, int lastEventNumber) { return(await connection.ReadStreamEventsBackwardAsync( streamName, lastEventNumber, PageSize, false, EventStoreCredentials.Default)); }
public async Task <StreamEventsSlice> GetCurrentSlice(IEventStoreConnection connection, long streamPosition, bool resolveLinkTos) { var currentSlice = await connection.ReadStreamEventsBackwardAsync(streamId, streamPosition, SliceSize, resolveLinkTos); nextSliceStart = currentSlice.NextEventNumber; return(currentSlice); }
private static long GetLatestStreamPosition(IEventStoreConnection connection, string streamId) { var position = connection .ReadStreamEventsBackwardAsync(streamId, StreamPosition.End, 1, true) .Result?.LastEventNumber ?? 0; return(position); }
public ActionResult CardData() { string NodeName = "none"; CardVM card = null; int cardNo; DateTime occurred; if (Session["Node"] != null) { NodeName = Session["Node"].ToString(); } if (NodeName != "none") { using (IEventStoreConnection connection = EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, 1113))) { connection.ConnectAsync(); var result = Task.Run(() => connection.ReadStreamEventsBackwardAsync(NodeName, StreamPosition.End, 1, false)); Task.WaitAll(); var resultData = result.Result; foreach (var Event in resultData.Events) { string strData = Encoding.UTF8.GetString(Event.Event.Data); string strMeta = Encoding.UTF8.GetString(Event.Event.Metadata); var datetimeConverter = new IsoDateTimeConverter { DateTimeFormat = "dd/MM/yyyy" }; dynamic Eventdata = JsonConvert.DeserializeObject(strData); dynamic EventMetadata = JsonConvert.DeserializeObject(strMeta); if (Event.Event.EventType == "checkIn" || Event.Event.EventType == "checkOut") { cardNo = (int)EventMetadata.SelectToken("CardNumber"); if (cardNo != 0) { using (DB db = new DB()) { card = new CardVM(); var cardInfo = db.CardInfoes.Where(x => x.CardNumber == cardNo).FirstOrDefault(); card.Id = cardInfo.Id; card.Name = cardInfo.Name; card.Title = cardInfo.Title; card.Department = cardInfo.Department; card.ImageName = cardInfo.ImageName; card.CardNumber = cardInfo.CardNumber; } } else { card = null; } occurred = (DateTime)Eventdata.SelectToken("occurred"); } } } } ViewBag.NodeName = NodeName; return(PartialView(card)); }
public static void EditJsonStream <T>(this IEventStoreConnection connection, IEventType <T> eventType) where T : class { var eventsStream = connection.ReadStreamEventsBackwardAsync(eventType.EditStreamName, 0, 1, true).Result; var lastEventNr = eventsStream.LastEventNumber; var json = Newtonsoft.Json.JsonConvert.SerializeObject(eventType.Data); var myEvent = new EventData(Guid.NewGuid(), eventType.EventType, true, Encoding.UTF8.GetBytes(json), null); connection.AppendToStreamAsync(eventType.EditStreamName, lastEventNr, myEvent).Wait(); }
public EventStoreRepository(IEventStoreConnection connection) { this.connection = connection; getStreamName = (type, guid) => $"{type.Name}-{guid}"; // todo make this a delegate log = LogManager.GetLogger(GetType()); eventStreamReaders = new Dictionary <ReadDirection, Func <string, int, int, Task <StreamEventsSlice> > >() { [ReadDirection.Forwards] = async(s, i, c) => await connection.ReadStreamEventsForwardAsync(s, i, c, resolveLinkTos : true).ConfigureAwait(false), [ReadDirection.Backwards] = async(s, i, c) => await connection.ReadStreamEventsBackwardAsync(s, i, c, true).ConfigureAwait(false) }; }
private async Task <ItemScanned> MostRecentItemScannedIntoBasket(Guid correlationId) { var slice = await _eventStoreConnection.ReadStreamEventsBackwardAsync($"basket-{correlationId}", StreamPosition.End, 1, false); Assert.Equal(SliceReadStatus.Success, slice.Status); var returnedEvent = slice.Events[0].Event; return(JsonConvert.DeserializeObject <ItemScanned>(Encoding.UTF8.GetString(returnedEvent.Data))); }
/// <summary> /// Update a message to show it is dispatched /// </summary> /// <param name="id">The id of the message to update</param> /// <param name="dispatchedAt">When was the message dispatched, defaults to UTC now</param> /// <param name="args">Additional parameters required for search, if any</param> /// <param name="cancellationToken">Allows the sender to cancel the request pipeline. Optional</param> public async Task MarkDispatchedAsync(Guid id, DateTime?dispatchedAt = null, Dictionary <string, object> args = null, CancellationToken cancellationToken = default) { var stream = GetStreamFromArgs(args); StreamEventsSlice slice; var startPos = (long)StreamPosition.End; long? nextEventNumber = null; RecordedEvent resolvedEvent; bool found = false; do { slice = await _eventStore.ReadStreamEventsBackwardAsync(stream, startPos, 100, true); startPos = slice.NextEventNumber; if (nextEventNumber is null) { nextEventNumber = (await _eventStore.ReadStreamEventsBackwardAsync(stream, StreamPosition.End, 1, true)).LastEventNumber; } resolvedEvent = slice.Events.FirstOrDefault(e => e.Event.EventId == id).Event; if (resolvedEvent != null) { found = true; } } while (!found && !slice.IsEndOfStream); if (resolvedEvent is null) { return; } var message = EventStoreMessageReader.ConvertEventToMessage(resolvedEvent, stream, dispatchedAt, nextEventNumber.Value); var eventData = EventStoreMessageWriter.CreateEventData(message); await _eventStore.AppendToStreamAsync(stream, nextEventNumber.Value, eventData); }
public static async Task <StreamSize> GetStreamSize( this IEventStoreConnection connection, string stream ) { var last = await connection.ReadStreamEventsBackwardAsync( stream, StreamPosition.End, 1, false ).ConfigureAwait(false); return(new StreamSize(last.LastEventNumber)); }
private async Task <Snapshot> GetSnapshot(string sku) { var streamName = GetSnapshotStreamName(sku); var slice = await _connection.ReadStreamEventsBackwardAsync(streamName, StreamPosition.End, 1, false); if (slice.Events.Any()) { var evnt = slice.Events.First(); var json = Encoding.UTF8.GetString(evnt.Event.Data); return(JsonConvert.DeserializeObject <Snapshot>(json)); } return(new Snapshot()); }
private static void ReadStreamEventsBackward(IEventStoreConnection connection) { StreamEventsSlice slice = connection.ReadStreamEventsBackwardAsync("test-stream", StreamPosition.End, 10, false).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); } }