Ejemplo n.º 1
0
 /// <summary>
 /// Convert from <see cref="CommittedEventStreamWithContext"/> to <see cref="grpc.CommittedEventStream"/>.
 /// </summary>
 /// <param name="contextualEventStream"><see cref="CommittedEventStreamWithContext"/> to convert from.</param>
 /// <returns>Converted <see cref="grpc.CommittedEventStream"/>.</returns>
 public static grpc.CommittedEventStreamWithContext ToProtobuf(this CommittedEventStreamWithContext contextualEventStream)
 {
     return(new grpc.CommittedEventStreamWithContext
     {
         Commit = contextualEventStream.EventStream.ToProtobuf(),
         Context = contextualEventStream.Context.ToProtobuf()
     });
 }
Ejemplo n.º 2
0
        /// <summary>
        /// Convert from <see cref="Dolittle.Runtime.Events.Processing.CommittedEventStreamWithContext"/> to <see cref="Protobuf.CommittedEventStream"/>
        /// </summary>
        /// <param name="contextualEventStream"><see cref="Dolittle.Runtime.Events.Processing.CommittedEventStreamWithContext"/> to convert from</param>
        /// <returns>Converted <see cref="Protobuf.CommittedEventStream"/></returns>
        public static CommittedEventStreamWithContext ToProtobuf(this Dolittle.Runtime.Events.Processing.CommittedEventStreamWithContext contextualEventStream)
        {
            var protobuf = new CommittedEventStreamWithContext
            {
                Commit  = contextualEventStream.EventStream.ToProtobuf(),
                Context = contextualEventStream.Context.ToProtobuf()
            };

            return(protobuf);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Processes
        /// </summary>
        /// <param name="committedEventStreamWithContext"></param>
        /// <returns></returns>
        public Task <CommitSequenceNumber> Process(CommittedEventStreamWithContext committedEventStreamWithContext)
        {
            try
            {
                var originatingSequence    = committedEventStreamWithContext.EventStream.Sequence;
                var context                = committedEventStreamWithContext.Context;
                var particleStream         = committedEventStreamWithContext.EventStream;
                EventSourceVersion version = null;

                _executionContextManager.CurrentFor(context);
                using (var _ = _getEventStore())
                {
                    version = _.GetNextVersionFor(particleStream.Source.Key);
                }

                var versionedEventSource = new VersionedEventSource(version, new EventSourceKey(particleStream.Source.EventSource, particleStream.Source.Artifact));

                var eventEnvelopes = new List <EventEnvelope>();

                particleStream.Events.ForEach(_ =>
                {
                    _.Metadata.OriginalContext.CommitInOrigin = particleStream.Sequence;
                    var envelope = new EventEnvelope(
                        new EventMetadata(
                            _.Id,
                            new VersionedEventSource(version, new EventSourceKey(particleStream.Source.EventSource, particleStream.Source.Artifact)),
                            _.Metadata.CorrelationId,
                            _.Metadata.Artifact,
                            _.Metadata.Occurred,
                            _.Metadata.OriginalContext
                            ),
                        _.Event
                        );
                    eventEnvelopes.Add(envelope);

                    version = version.NextSequence();
                });

                var uncommittedEventStream = new Store.UncommittedEventStream(
                    particleStream.Id,
                    particleStream.CorrelationId,
                    versionedEventSource,
                    particleStream.Timestamp,
                    new Store.EventStream(eventEnvelopes)
                    );

                _logger.Information("Commit events to store");
                Store.CommittedEventStream committedEventStream = null;
                using (var _ = _getEventStore())
                {
                    committedEventStream = _.Commit(uncommittedEventStream);
                }
                SetOffset(_eventHorizonKey, originatingSequence);
                _logger.Information("Process committed events");
                _processingHub.Process(committedEventStream);
                return(Task.FromResult(committedEventStream.Sequence));
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "Couldn't handle incoming commit");
                return(Task.FromException <CommitSequenceNumber>(ex));
            }
        }
Ejemplo n.º 4
0
 protected override void ProcessStream(CommittedEventStreamWithContext committedEventStreamWithContext)
 {
     Processed.Add(committedEventStreamWithContext);
 }
Ejemplo n.º 5
0
 protected override void Enqueue(CommittedEventStreamWithContext committedEventStreamWithContext)
 {
     Queued.Add(committedEventStreamWithContext);
     base.Enqueue(committedEventStreamWithContext);
 }
Ejemplo n.º 6
0
        /// <summary>
        /// Convert from <see cref="CommittedEventStreamWithContext"/> to <see cref="Runtime.Grpc.Interaction.CommittedEventStream"/>
        /// </summary>
        /// <param name="contextualEventStream"><see cref="CommittedEventStreamWithContext"/> to convert from</param>
        /// <returns>Converted <see cref="Runtime.Grpc.Interaction.CommittedEventStream"/></returns>
        public static Runtime.Grpc.Interaction.CommittedEventStreamWithContext ToProtobuf(this CommittedEventStreamWithContext contextualEventStream)
        {
            var protobuf = new Runtime.Grpc.Interaction.CommittedEventStreamWithContext
            {
                Commit  = contextualEventStream.EventStream.ToProtobuf(),
                Context = contextualEventStream.Context.ToProtobuf()
            };

            return(protobuf);
        }