Exemplo n.º 1
0
        void IHandle <StorageMessage.WriteTransactionData> .Handle(StorageMessage.WriteTransactionData message)
        {
            Interlocked.Decrement(ref FlushMessagesInQueue);
            try
            {
                var logPosition     = Writer.Checkpoint.ReadNonFlushed();
                var transactionInfo = _indexWriter.GetTransactionInfo(Writer.Checkpoint.Read(), message.TransactionId);
                if (!CheckTransactionInfo(message.TransactionId, transactionInfo))
                {
                    return;
                }

                if (message.Events.Length > 0)
                {
                    long lastLogPosition = -1;
                    for (int i = 0; i < message.Events.Length; ++i)
                    {
                        var evnt   = message.Events[i];
                        var record = LogRecord.TransactionWrite(logPosition,
                                                                message.CorrelationId,
                                                                evnt.EventId,
                                                                message.TransactionId,
                                                                transactionInfo.TransactionOffset + i + 1,
                                                                transactionInfo.EventStreamId,
                                                                evnt.EventType,
                                                                evnt.Data,
                                                                evnt.Metadata,
                                                                evnt.IsJson);
                        var res = WritePrepareWithRetry(record);
                        logPosition     = res.NewPos;
                        lastLogPosition = res.WrittenPos;
                    }
                    var info = new TransactionInfo(transactionInfo.TransactionOffset + message.Events.Length,
                                                   transactionInfo.EventStreamId);
                    _indexWriter.UpdateTransactionInfo(message.TransactionId, lastLogPosition, info);
                }
            }
            catch (Exception exc)
            {
                Log.ErrorException(exc, "Exception in writer.");
                throw;
            }
            finally
            {
                Flush();
            }
        }
Exemplo n.º 2
0
        void IHandle <StorageMessage.WriteTransactionData> .Handle(StorageMessage.WriteTransactionData message)
        {
            Interlocked.Decrement(ref FlushMessagesInQueue);
            try
            {
                Debug.Assert(message.Events.Length > 0);

                var logPosition       = Writer.Checkpoint.ReadNonFlushed();
                var transactionOffset = ReadIndex.GetLastTransactionOffset(logPosition, message.TransactionId);
                if (transactionOffset < -1)
                {
                    throw new Exception(
                              string.Format("Invalid transaction offset {0} found for transaction ID {1}. Possibly wrong transactionId provided.",
                                            transactionOffset,
                                            message.TransactionId));
                }
                for (int i = 0; i < message.Events.Length; ++i)
                {
                    var evnt   = message.Events[i];
                    var record = LogRecord.TransactionWrite(logPosition,
                                                            message.CorrelationId,
                                                            evnt.EventId,
                                                            message.TransactionId,
                                                            transactionOffset + i + 1,
                                                            message.EventStreamId,
                                                            evnt.EventType,
                                                            evnt.Data,
                                                            evnt.Metadata);
                    var res = WritePrepareWithRetry(record);
                    logPosition = res.NewPos;
                }
            }
            finally
            {
                Flush();
            }
        }