private Notifications.Notification[] NotificationsFrom(StoredEvent[] storedEvents) { Notifications.Notification[] notifications = new Notifications.Notification[storedEvents.Length]; for(int i = 0; i < storedEvents.Length; i++) { IDomainEvent domainEvent = storedEvents[i].ToDomainEvent(); Notifications.Notification notification = new Notifications.Notification(storedEvents[i].EventId, domainEvent); notifications[i] = notification; } return notifications; }
public async Task Should_ignore_old_events() { A.CallTo(() => formatter.Parse(eventData)) .Throws(new TypeNameNotFoundException()); var @event = new StoredEvent("Stream", Guid.NewGuid().ToString(), 123, eventData); await sut.ActivateAsync(consumerName); await sut.ActivateAsync(); await OnEventAsync(eventSubscription, @event); grainState.Value.Should().BeEquivalentTo(new EventConsumerState { IsStopped = false, Position = @event.EventPosition, Error = null }); A.CallTo(() => grainState.WriteAsync()) .MustHaveHappened(1, Times.Exactly); A.CallTo(() => eventConsumer.On(envelope)) .MustNotHaveHappened(); }
public async Task Should_stop_if_handling_failed() { var ex = new InvalidOperationException(); A.CallTo(() => eventConsumer.On(envelope)) .Throws(ex); var @event = new StoredEvent(Guid.NewGuid().ToString(), 123, eventData); await OnSubscribeAsync(); await OnEventAsync(eventSubscription, @event); sut.Dispose(); A.CallTo(() => eventConsumer.On(envelope)) .MustHaveHappened(); A.CallTo(() => eventConsumerInfoRepository.SetAsync(consumerName, consumerInfo.Position, true, ex.ToString())) .MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => eventSubscription.StopAsync()) .MustHaveHappened(Repeated.Exactly.Once); }
public async Task Should_not_invoke_but_update_position_when_consumer_does_not_want_to_handle() { var @event = new StoredEvent("Stream", Guid.NewGuid().ToString(), 123, eventData); A.CallTo(() => eventConsumer.Handles(@event)) .Returns(false); await sut.ActivateAsync(consumerName); await sut.ActivateAsync(); await OnEventAsync(eventSubscription, @event); grainState.Value.Should().BeEquivalentTo(new EventConsumerState { IsStopped = false, Position = @event.EventPosition, Error = null }); A.CallTo(() => grainState.WriteAsync()) .MustHaveHappened(1, Times.Exactly); A.CallTo(() => eventConsumer.On(envelope)) .MustNotHaveHappened(); }
public async Task <IEnumerable <StoredEvent> > ObterEventos(Guid aggregateId) { var eventos = await _eventStoreService.GetConnection() .ReadStreamEventsForwardAsync(aggregateId.ToString(), 0, 500, false); var listaEventos = new List <StoredEvent>(); foreach (var resolvedEvent in eventos.Events) { var dataEncoded = Encoding.UTF8.GetString(resolvedEvent.Event.Data); var jsonData = JsonConvert.DeserializeObject <BaseEvent>(dataEncoded); var evento = new StoredEvent( resolvedEvent.Event.EventId, resolvedEvent.Event.EventType, jsonData.Timestamp, dataEncoded); listaEventos.Add(evento); } return(listaEventos.OrderBy(e => e.DataOcorrencia)); }
public async Task Should_start_after_stop_when_handling_failed() { var exception = new InvalidOperationException(); A.CallTo(() => eventConsumer.On(envelope)) .Throws(exception); var @event = new StoredEvent("Stream", Guid.NewGuid().ToString(), 123, eventData); await sut.OnActivateAsync(consumerName); await sut.ActivateAsync(); await OnEventAsync(eventSubscription, @event); await sut.StopAsync(); await sut.StartAsync(); await sut.StartAsync(); state.Should().BeEquivalentTo(new EventConsumerState { IsStopped = false, Position = initialPosition, Error = null }); A.CallTo(() => eventConsumer.On(envelope)) .MustHaveHappened(); A.CallTo(() => persistence.WriteSnapshotAsync(A <EventConsumerState> .Ignored)) .MustHaveHappened(Repeated.Exactly.Twice); A.CallTo(() => eventSubscription.StopAsync()) .MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> .Ignored, A <string> .Ignored, A <string> .Ignored)) .MustHaveHappened(Repeated.Exactly.Twice); }
public async Task Should_start_after_stop_when_handling_failed() { var exception = new InvalidOperationException(); A.CallTo(() => eventConsumer.On(envelope)) .Throws(exception); var @event = new StoredEvent("Stream", Guid.NewGuid().ToString(), 123, eventData); await sut.ActivateAsync(consumerName); await sut.ActivateAsync(); await OnEventAsync(eventSubscription, @event); await sut.StopAsync(); await sut.StartAsync(); await sut.StartAsync(); AssetGrainState(new EventConsumerState { IsStopped = false, Position = initialPosition, Error = null }); A.CallTo(() => eventConsumer.On(envelope)) .MustHaveHappened(); A.CallTo(() => grainState.WriteAsync()) .MustHaveHappened(2, Times.Exactly); A.CallTo(() => eventSubscription.StopAsync()) .MustHaveHappened(1, Times.Exactly); A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> ._, A <string> ._, A <string> ._)) .MustHaveHappened(2, Times.Exactly); }
public async Task Should_ignore_old_events() { sut.ActivateAsync(consumerName, store).Wait(); sut.Activate(eventConsumer); A.CallTo(() => formatter.Parse(eventData, true)) .Throws(new TypeNameNotFoundException()); var @event = new StoredEvent(Guid.NewGuid().ToString(), 123, eventData); await OnEventAsync(eventSubscription, @event); sut.Dispose(); state.ShouldBeEquivalentTo(new EventConsumerState { IsStopped = false, Position = @event.EventPosition, Error = null }); A.CallTo(() => persistence.WriteSnapshotAsync(A <EventConsumerState> .Ignored)) .MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => eventConsumer.On(envelope)) .MustNotHaveHappened(); }
public void Add(StoredEvent entidade) { var sb = new System.Text.StringBuilder(277); sb.AppendLine(@"INSERT INTO [dbo].[StoredEvent]"); sb.AppendLine(@" ([Id]"); sb.AppendLine(@" ,[Dados]"); sb.AppendLine(@" ,[Usuario]"); sb.AppendLine(@" ,[MensagemTipo]"); sb.AppendLine(@" ,[AggregateId]"); sb.AppendLine(@" ,[DataCadastro])"); sb.AppendLine(@" VALUES"); sb.AppendLine(@" (@Id"); sb.AppendLine(@" ,@Dados"); sb.AppendLine(@" ,@Usuario"); sb.AppendLine(@" ,@MensagemTipo"); sb.AppendLine(@" ,@AggregateId"); sb.AppendLine(@" ,@DataCadastro)"); connection.Query(sb.ToString() , param: new { Id = entidade.Id , Dados = entidade.Dados , Usuario = entidade.Usuario , MensagemTipo = entidade.MensagemTipo , AggregateId = entidade.AggregateId , DataCadastro = entidade.DataCadastro } , transaction: transaction); }
public void Store(StoredEvent theEvent) { eventStore.InsertOne(theEvent); }
/// <summary> /// Upgrades an event to the latest version. /// </summary> /// <remarks> /// <para>This checks to see if an <see cref="IEventConverter"/> has been added for <see cref="StoredEvent{T}.EventName"/>.</para> /// <para>If there is an event converter for this event then that converter will be used to upgrade the event.</para> /// <para>If no converter has been added for this event then the event will be left un-modified.</para> /// </remarks> /// <param name="theEvent">The event to be upgraded.</param> /// <exception cref="ArgumentNullException">If <paramref name="theEvent"/> is <value>null</value>.</exception> /// <seealso cref="AddConverter"/> public void Upgrade(StoredEvent<JObject> theEvent) { IEventConverter converter; if (_converters.TryGetValue(theEvent.EventName, out converter)) converter.Upgrade(theEvent); }
private Task OnEventAsync(IEventSubscription subscription, StoredEvent ev) { return(sut.OnEventAsync(subscription, ev)); }
public Task OnEventAsync(IEventSubscription subscription, StoredEvent storedEvent) { return(Dispatch(() => grain.OnEventAsync(subscription.AsImmutable(), storedEvent.AsImmutable()))); }
public Task PersistAsync(Is4Event evt) { var es = new StoredEvent( evt.Category, (EventTypes)(int)evt.EventType, evt.Name, evt.LocalIpAddress, evt.RemoteIpAddress, evt.ToString() ).ReplaceTimeStamp(evt.TimeStamp); if (_user.IsAuthenticated()) { es.SetUser(_user.Username); } switch (evt) { case ApiAuthenticationFailureEvent apiAuthenticationFailureEvent: es.SetAggregate(apiAuthenticationFailureEvent.ApiName); break; case ApiAuthenticationSuccessEvent apiAuthenticationSuccessEvent: es.SetAggregate(apiAuthenticationSuccessEvent.ApiName); break; case ClientAuthenticationFailureEvent clientAuthenticationFailureEvent: es.SetAggregate(clientAuthenticationFailureEvent.ClientId); break; case ClientAuthenticationSuccessEvent clientAuthenticationSuccessEvent: es.SetAggregate(clientAuthenticationSuccessEvent.ClientId); break; case ConsentDeniedEvent consentDeniedEvent: es.SetAggregate(consentDeniedEvent.ClientId); break; case ConsentGrantedEvent consentGrantedEvent: es.SetAggregate(consentGrantedEvent.ClientId); break; case DeviceAuthorizationFailureEvent deviceAuthorizationFailureEvent: es.SetAggregate(deviceAuthorizationFailureEvent.ClientId); break; case DeviceAuthorizationSuccessEvent deviceAuthorizationSuccessEvent: es.SetAggregate(deviceAuthorizationSuccessEvent.ClientId); break; case GrantsRevokedEvent grantsRevokedEvent: es.SetAggregate(grantsRevokedEvent.ClientId); break; case InvalidClientConfigurationEvent invalidClientConfigurationEvent: es.SetAggregate(invalidClientConfigurationEvent.ClientId); break; case TokenIntrospectionFailureEvent tokenIntrospectionFailureEvent: es.SetAggregate(tokenIntrospectionFailureEvent.ApiName); break; case TokenIntrospectionSuccessEvent tokenIntrospectionSuccessEvent: es.SetAggregate(tokenIntrospectionSuccessEvent.ApiName); break; case TokenIssuedFailureEvent tokenIssuedFailureEvent: es.SetAggregate(tokenIssuedFailureEvent.ClientId); break; case TokenIssuedSuccessEvent tokenIssuedSuccessEvent: es.SetAggregate(tokenIssuedSuccessEvent.ClientId); break; case TokenRevokedSuccessEvent tokenRevokedSuccessEvent: es.SetAggregate(tokenRevokedSuccessEvent.ClientId); break; case UnhandledExceptionEvent unhandledExceptionEvent: break; case UserLoginFailureEvent userLoginFailureEvent: es.SetUser(userLoginFailureEvent.Username).SetAggregate(userLoginFailureEvent.ClientId); break; case UserLoginSuccessEvent userLoginSuccessEvent: es.SetUser(userLoginSuccessEvent.Username).SetAggregate(userLoginSuccessEvent.ClientId); break; case UserLogoutSuccessEvent userLogoutSuccessEvent: es.SetAggregate(userLogoutSuccessEvent.SubjectId); break; } return(_eventStoreRepository.Store(es)); }
public void Store(StoredEvent theEvent) { context.Set <StoredEvent>().Add(theEvent); context.SaveChanges(); }
public void Initialize_Identity() { var storedEvent = new StoredEvent(Guid.NewGuid().ToString(), new DepositedMoney(new Money(123m)), 1); Assert.IsNotNull(storedEvent.Id); }
public void Upgrade(StoredEvent<JObject> theEvent) { //do nothing }
private static BsonDocument ToBsonDocument(StoredEvent<string> rawEvent) { var doc = rawEvent.ToBsonDocument(); return doc; }
/// <summary>Saves the event to the data store.</summary> /// <param name="uncommittedEvent">The event to save.</param> /// <param name="transaction">The transaction.</param> private void SaveEvent(UncommittedEvent uncommittedEvent, SqlTransaction transaction) { Contract.Requires<ArgumentNullException>(uncommittedEvent != null, "The argument uncommittedEvent could not be null."); Contract.Requires<ArgumentNullException>(transaction != null, "The argument transaction could not be null."); string eventName; var document = _formatter.Serialize(uncommittedEvent.Payload, out eventName); var storedEvent = new StoredEvent<JObject>(uncommittedEvent.EventIdentifier, uncommittedEvent.EventTimeStamp, eventName, uncommittedEvent.EventVersion, uncommittedEvent.EventSourceId, uncommittedEvent.EventSequence, document); var raw = _translator.TranslateToRaw(storedEvent); using (var command = new SqlCommand(Queries.InsertNewEventQuery, transaction.Connection)) { command.Transaction = transaction; command.Parameters.AddWithValue("EventId", raw.EventIdentifier); command.Parameters.AddWithValue("TimeStamp", raw.EventTimeStamp); command.Parameters.AddWithValue("EventSourceId", raw.EventSourceId); command.Parameters.AddWithValue("Name", raw.EventName); command.Parameters.AddWithValue("Version", raw.EventVersion.ToString()); command.Parameters.AddWithValue("Sequence", raw.EventSequence); command.Parameters.AddWithValue("Data", raw.Data); command.ExecuteNonQuery(); } }
/// <summary> /// Saves the event to the data store. /// </summary> /// <param name="evnt">The event to save.</param> /// <param name="transaction">The transaction.</param> private void SaveEvent(UncommittedEvent evnt, NpgsqlTransaction transaction) { string eventName; var document = _formatter.Serialize(evnt.Payload, out eventName); var storedEvent = new StoredEvent<JObject>(evnt.EventIdentifier, evnt.EventTimeStamp, eventName, evnt.EventVersion, evnt.EventSourceId, evnt.EventSequence, document); var raw = _translator.TranslateToRaw(storedEvent); using (var command = new NpgsqlCommand(Queries.InsertNewEventQuery, transaction.Connection)) { command.Transaction = transaction; command.Parameters.AddWithValue("EventId", raw.EventIdentifier); command.Parameters.AddWithValue("TimeStamp", raw.EventTimeStamp); command.Parameters.AddWithValue("EventSourceId", raw.EventSourceId); command.Parameters.AddWithValue("Name", raw.EventName); command.Parameters.AddWithValue("Version", raw.EventVersion.ToString()); command.Parameters.AddWithValue("Sequence", raw.EventSequence); command.Parameters.AddWithValue("Data", raw.Data); command.ExecuteNonQuery(); } }
public void StoreData(StoredEvent data) { _context.Data.Add(data); _context.SaveChanges(); }
public bool Handles(StoredEvent @event) { return(true); }
private static BsonDocument ToBsonDocument(StoredEvent <string> rawEvent) { var doc = rawEvent.ToBsonDocument(); return(doc); }
public void Store(StoredEvent theEvent) { var events = cacheService.Get <IEnumerable <StoredEvent> >(eventStorePrefix + theEvent.EventId) ?? Enumerable.Empty <StoredEvent>(); cacheService.Store(theEvent.EventId, events.Concat(new[] { theEvent })); }
public bool Handles(StoredEvent @event) { return(@event.Data.Type == typeAssetDeleted || @event.Data.Type == typeContentDeleted); }
public void SaveEvent(StoredEvent storedEvent) { _context.StoredEvents.Add(storedEvent); _context.SaveChanges(); }
private Task OnEventAsync(IEventSubscription subscriber, StoredEvent ev) { return(sut.OnEventAsync(subscriber.AsImmutable(), ev.AsImmutable())); }
public async Task OnEventAsync(IEventSubscription subscription, StoredEvent storedEvent) { await eventSubscriber.OnEventAsync(subscription, storedEvent); }
public void Store(StoredEvent eventObj) { _context.StoredEvents.Add(eventObj); _context.SaveChanges(); }
public Task OnEventAsync(IEventSubscription subscription, StoredEvent storedEvent) { return(currentSubscriber !.OnEventAsync(subscription, storedEvent)); }
public bool Store(StoredEvent @event) { _context.EventStores.Add(@event); return(_context.SaveChanges() > 0); }
protected void Add(StoredEvent @event) { Events.TryAdd(@event.StoredEventId, new DeserializedStoredEvent(@event)); Persist(@event); }
public void Upgrade(StoredEvent<JObject> theEvent) { Contract.Requires<ArgumentNullException>(theEvent != null, "theEvent"); }
public static CompatibleStoredEvent V2(StoredEvent stored) { return(new CompatibleStoredEvent { NewEvent = NewEvent.V2(stored) }); }
public async Task Should_write_and_read_events_to_backup(BackupVersion version) { var stream = new MemoryStream(); var random = new Random(); var randomGuids = new List <Guid>(); for (var i = 0; i < 100; i++) { randomGuids.Add(Guid.NewGuid()); } Guid RandomGuid() { return(randomGuids[random.Next(randomGuids.Count)]); } var sourceEvents = new List <(string Stream, Envelope <IEvent> Event)>(); for (var i = 0; i < 200; i++) { var @event = new MyEvent { GuidNamed = NamedId.Of(RandomGuid(), $"name{i}"), GuidRaw = RandomGuid(), Values = new Dictionary <Guid, string> { [RandomGuid()] = "Key" } }; var envelope = Envelope.Create <IEvent>(@event); envelope.Headers.Add(RandomGuid().ToString(), i); envelope.Headers.Add("Id", RandomGuid().ToString()); envelope.Headers.Add("Index", i); sourceEvents.Add(($"My-{RandomGuid()}", envelope)); } using (var writer = new BackupWriter(serializer, stream, true, version)) { foreach (var(_, envelope) in sourceEvents) { var eventData = formatter.ToEventData(envelope, Guid.NewGuid(), true); var eventStored = new StoredEvent("S", "1", 2, eventData); var index = int.Parse(envelope.Headers["Index"].ToString()); if (index % 17 == 0) { await writer.WriteBlobAsync(index.ToString(), innerStream => { innerStream.WriteByte((byte)index); return(TaskHelper.Done); }); } else if (index % 37 == 0) { await writer.WriteJsonAsync(index.ToString(), $"JSON_{index}"); } writer.WriteEvent(eventStored); } } stream.Position = 0; var targetEvents = new List <(string Stream, Envelope <IEvent> Event)>(); using (var reader = new BackupReader(serializer, stream)) { await reader.ReadEventsAsync(streamNameResolver, formatter, async @event => { var index = int.Parse(@event.Event.Headers["Index"].ToString()); if (index % 17 == 0) { await reader.ReadBlobAsync(index.ToString(), innerStream => { var byteRead = innerStream.ReadByte(); Assert.Equal((byte)index, byteRead); return(TaskHelper.Done); }); } else if (index % 37 == 0) { var json = await reader.ReadJsonAttachmentAsync <string>(index.ToString()); Assert.Equal($"JSON_{index}", json); } targetEvents.Add(@event); }); void CompareGuid(Guid source, Guid target) { Assert.Equal(source, reader.OldGuid(target)); Assert.NotEqual(source, target); } for (var i = 0; i < targetEvents.Count; i++) { var target = targetEvents[i].Event.To <MyEvent>(); var source = sourceEvents[i].Event.To <MyEvent>(); CompareGuid(source.Payload.Values.First().Key, target.Payload.Values.First().Key); CompareGuid(source.Payload.GuidRaw, target.Payload.GuidRaw); CompareGuid(source.Payload.GuidNamed.Id, target.Payload.GuidNamed.Id); CompareGuid(source.Headers.GetGuid("Id"), target.Headers.GetGuid("Id")); Assert.Equal(Guid.Empty, target.Payload.GuidEmpty); } } }
public void Store(StoredEvent theEvent) { _context.StoredEvent.Add(theEvent); _context.SaveChanges(); }
public async Task Should_write_and_read_events_to_backup(BackupVersion version) { var randomGenerator = new Random(); var randomDomainIds = new List <DomainId>(); for (var i = 0; i < 100; i++) { randomDomainIds.Add(DomainId.NewGuid()); } DomainId RandomDomainId() { return(randomDomainIds[randomGenerator.Next(randomDomainIds.Count)]); } var sourceEvents = new List <(string Stream, Envelope <MyEvent> Event)>(); for (var i = 0; i < 200; i++) { var @event = new MyEvent(); var envelope = Envelope.Create(@event); envelope.Headers.Add("Id", JsonValue.Create(@event.Id)); envelope.Headers.Add("Index", JsonValue.Create(i)); sourceEvents.Add(($"My-{RandomDomainId()}", envelope)); } await TestReaderWriterAsync(version, async writer => { foreach (var(stream, envelope) in sourceEvents) { var eventData = formatter.ToEventData(envelope, Guid.NewGuid(), true); var eventStored = new StoredEvent(stream, "1", 2, eventData); var index = int.Parse(envelope.Headers["Index"].ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture); if (index % 17 == 0) { await WriteGuidAsync(writer, index.ToString(CultureInfo.InvariantCulture), envelope.Payload.Id); } else if (index % 37 == 0) { await WriteJsonGuidAsync(writer, index.ToString(CultureInfo.InvariantCulture), envelope.Payload.Id); } writer.WriteEvent(eventStored); } }, async reader => { var targetEvents = new List <(string Stream, Envelope <IEvent> Event)>(); await foreach (var @event in reader.ReadEventsAsync(streamNameResolver, formatter)) { var index = int.Parse(@event.Event.Headers["Index"].ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture); var id = Guid.Parse(@event.Event.Headers["Id"].ToString()); if (index % 17 == 0) { var guid = await ReadGuidAsync(reader, index.ToString(CultureInfo.InvariantCulture)); Assert.Equal(id, guid); } else if (index % 37 == 0) { var guid = await ReadJsonGuidAsync(reader, index.ToString(CultureInfo.InvariantCulture)); Assert.Equal(id, guid); } targetEvents.Add(@event); } for (var i = 0; i < targetEvents.Count; i++) { var targetEvent = targetEvents[i].Event.To <MyEvent>(); var targetStream = targetEvents[i].Stream; var sourceEvent = sourceEvents[i].Event.To <MyEvent>(); var sourceStream = sourceEvents[i].Stream; Assert.Equal(sourceEvent.Payload.Id, targetEvent.Payload.Id); Assert.Equal(sourceStream, targetStream); } }); }