コード例 #1
0
        private async Task FlushEvents(QueueTicket queueTicket)
        {
            IQueryable <StreamEvent> query = BuildStreamEventsQuery(queueTicket);

            await PublishStreamEvents(query, partitionKey : $"{queueTicket.StreamId}").ConfigureAwait(continueOnCapturedContext: false);
            await DeleteQueueTicket(queueTicket).ConfigureAwait(continueOnCapturedContext: false);
        }
コード例 #2
0
 public static IQueryable <StreamEvent> BuildStreamEventsQuery(
     this CloudTable table, QueueTicket queueTicket)
 {
     return(from e in table.CreateQuery <StreamEvent>()
            where e.PartitionKey == $"{queueTicket.StateType}:{queueTicket.StreamId}"
            where e.RowKey.CompareTo($"{queueTicket.StartVersion:D19}") >= 0
            where e.RowKey.CompareTo($"{queueTicket.StartVersion + queueTicket.EventCount:D19}") < 0
            where e.Transaction == queueTicket.Transaction
            select e);
 }
コード例 #3
0
        private async Task SaveAndPublish(string stateType,
                                          Guid transaction,
                                          Guid streamId,
                                          long startVersion,
                                          IReadOnlyList <object> events,
                                          TracingProperties tracingProperties)
        {
            if (events.Count == 0)
            {
                return;
            }

            await SaveQueueTicket().ConfigureAwait(continueOnCapturedContext: false);
            await SaveEvents().ConfigureAwait(continueOnCapturedContext: false);
            await PublishPendingEvents().ConfigureAwait(continueOnCapturedContext: false);

            Task SaveQueueTicket()
            {
                var queueTicket = new QueueTicket(stateType, streamId, startVersion, events.Count, transaction);

                return(_table.ExecuteAsync(TableOperation.Insert(queueTicket)));
            }

            Task SaveEvents()
            {
                var batch = new TableBatchOperation();

                for (int i = 0; i < events.Count; i++)
                {
                    object source = events[i];

                    var streamEvent = new StreamEvent(
                        stateType,
                        streamId,
                        version: startVersion + i,
                        raisedTimeUtc: DateTime.UtcNow,
                        eventType: _typeResolver.ResolveTypeName(source.GetType()),
                        payload: _jsonProcessor.ToJson(source),
                        messageId: $"{Guid.NewGuid()}",
                        tracingProperties.OperationId,
                        tracingProperties.Contributor,
                        tracingProperties.ParentId,
                        transaction);

                    batch.Insert(streamEvent);
                }

                return(_table.ExecuteBatchAsync(batch));
            }

            Task PublishPendingEvents() => _publisher.PublishEvents(stateType, streamId);
        }
コード例 #4
0
 private Task DeleteQueueTicket(QueueTicket queueTicket)
 {
     return(_table.ExecuteAsync(TableOperation.Delete(queueTicket)));
 }
コード例 #5
0
 private IQueryable <StreamEvent> BuildStreamEventsQuery(QueueTicket queueTicket)
 {
     return(_table.BuildStreamEventsQuery(queueTicket));
 }