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); }