private void ProcessCommitReplicated(StorageMessage.CommitAck message)
{
PendingTransaction transaction;
long lastEventNumber = message.LastEventNumber;
if (_pendingTransactions.TryRemove(message.TransactionPosition, out transaction))
{
var isTfEof = IsTfEof(transaction.PostPosition);
if (transaction.Prepares.Count > 0)
{
_indexCommitter.Commit(transaction.Prepares, isTfEof, true);
}
if (transaction.Commit != null)
{
lastEventNumber = _indexCommitter.Commit(transaction.Commit, isTfEof, true);
}
}
lastEventNumber = lastEventNumber == EventNumber.Invalid ? message.LastEventNumber : lastEventNumber;
_publisher.Publish(new ReplicationTrackingMessage.IndexedTo(message.LogPosition));
_publisher.Publish(new StorageMessage.CommitIndexed(message.CorrelationId, message.LogPosition,
message.TransactionPosition, message.FirstEventNumber, lastEventNumber));
}
public CommitAckNode AddCommitAck(StorageMessage.CommitAck message)
{
LinkedListNode <CommitAckNode> commitAckNode;
if (_commitAckNodes.TryGetValue(message.CorrelationId, out commitAckNode))
{
commitAckNode.Value.AddCommitAck(message);
}
else
{
var newCommitAck = new CommitAckNode(message.CorrelationId, message);
commitAckNode = _commitAcksLinkedList.AddLast(newCommitAck);
_commitAckNodes.Add(message.CorrelationId, commitAckNode);
}
// ensure commit acks are sorted
var currentNode = commitAckNode;
var previousNode = commitAckNode.Previous;
while (previousNode != null && previousNode.Value.LogPosition > currentNode.Value.LogPosition)
{
_commitAcksLinkedList.Remove(previousNode);
_commitAcksLinkedList.AddAfter(currentNode, previousNode);
previousNode = currentNode.Previous;
}
return(commitAckNode.Value);
}
private TcpPackage WrapCommitAck(StorageMessage.CommitAck msg)
{
var dto = new ReplicationMessageDto.CommitAck(msg.LogPosition, msg.TransactionPosition,
msg.FirstEventNumber, msg.LastEventNumber);
return(new TcpPackage(TcpCommand.CommitAck, msg.CorrelationId, dto.Serialize()));
}
public List <CommitAckNode> GetCommitAcksUpTo(StorageMessage.CommitAck message)
{
LinkedListNode <CommitAckNode> commitAckNode;
if (_commitAckNodes.TryGetValue(message.CorrelationId, out commitAckNode))
{
var currentNode = commitAckNode;
// Ensure that we have all nodes at this position
while (currentNode.Next != null && currentNode.Next.Value.LogPosition == currentNode.Value.LogPosition)
{
currentNode = currentNode.Next;
}
var result = new List <CommitAckNode>();
do
{
result.Add(currentNode.Value);
currentNode = currentNode.Previous;
} while (currentNode != null);
result.Reverse();
return(result);
}
else
{
throw new InvalidOperationException("Commit ack not present in node list.");
}
}
public void Handle(StorageMessage.CommitAck message)
{
lock (_commitAcks) {
_commitAcks.TryAdd(message.LogPosition, message);
}
EnqueueReplicatedCommits();
}
public void Handle(StorageMessage.CommitAck message)
{
if (_state == VNodeState.Slave)
{
Debug.Assert(_connection != null, "_connection == null");
SendTcpMessage(_connection, message);
}
}
private void CommitReplicated(StorageMessage.CommitAck message)
{
_replicatedQueue.Enqueue(message);
#if DEBUG
_queueStats.Enqueued();
#endif
_addMsgSignal.Set();
}
private void EnqueueCommitsUpToPosition(StorageMessage.CommitAck message)
{
var commits = _commitAcks.GetCommitAcksUpTo(message);
foreach (var commit in commits)
{
CommitReplicated(commit.CommitAcks[0]);
}
_commitAcks.RemoveCommitAcks(commits);
}
public void AddCommitAck(StorageMessage.CommitAck commitAck)
{
Ensure.Equal(true, CorrelationId == commitAck.CorrelationId, "correlationId should be equal");
CommitAcks.Add(commitAck);
if (commitAck.IsSelf)
{
_hadSelf = true;
}
}
public void Handle(StorageMessage.CommitAck message)
{
if (_completed)
{
return;
}
_awaitingCommit -= 1;
if (_awaitingCommit == 0)
{
CompleteSuccessRequest(message.CorrelationId, _eventStreamId, message.EventNumber);
}
}
public void Handle(StorageMessage.CommitAck message)
{
if (_completed)
{
return;
}
_awaitingCommit -= 1;
if (_awaitingCommit == 0)
{
CompleteSuccessRequest(message.FirstEventNumber, message.LastEventNumber, message.LogPosition, message.LogPosition);
}
}
public void Handle(StorageMessage.CommitAck message)
{
if (_completed)
{
return;
}
_awaitingCommit -= 1;
if (message.IsSelf)
{
_hadSelf = true;
}
if (_awaitingCommit <= 0 && _hadSelf)
{
CompleteSuccessRequest(message.FirstEventNumber, message.LastEventNumber, message.LogPosition, message.LogPosition);
}
}
public void Handle(StorageMessage.CommitAck message)
{
if (Interlocked.Read(ref _complete) == 1 || _commitReceived)
{
return;
}
NextTimeoutTime = DateTime.UtcNow + Timeout;
_commitReceived = true;
_allEventsWritten = _commitReceived && _allPreparesWritten;
if (message.LogPosition > LastEventPosition)
{
LastEventPosition = message.LogPosition;
}
FirstEventNumber = message.FirstEventNumber;
LastEventNumber = message.LastEventNumber;
CommitPosition = message.LogPosition;
if (_allEventsWritten)
{
AllEventsWritten();
}
}
public void Handle(StorageMessage.CommitAck message)
{
if (_state != VNodeState.Master || _commitCount == 1)
{
_replicatedQueue.Enqueue(message);
return;
}
var checkpoint = _replicationCheckpoint.ReadNonFlushed();
if (message.LogPosition <= checkpoint)
{
return;
}
var res = _commitAcks.AddCommitAck(message);
if (res.IsReplicated(_commitCount))
{
EnqueueCommitsUpToPosition(message);
}
}
public CommitAckNode(Guid correlationId, StorageMessage.CommitAck commitAck)
{
CorrelationId = correlationId;
LogPosition = commitAck.LogPosition;
AddCommitAck(commitAck);
}
private void CommitReplicated(StorageMessage.CommitAck message)
{
_replicatedQueue.Enqueue(message);
}
public void Handle(StorageMessage.CommitAck message)
{
DispatchInternal(message.CorrelationId, message);
}
