public virtual RaftMachine Build()
{
_termState.update(_term);
LeaderAvailabilityTimers leaderAvailabilityTimers = new LeaderAvailabilityTimers(Duration.ofMillis(_electionTimeout), Duration.ofMillis(_heartbeatInterval), _clock, _timerService, _logProvider);
SendToMyself leaderOnlyReplicator = new SendToMyself(_member, _outbound);
RaftMembershipManager membershipManager = new RaftMembershipManager(leaderOnlyReplicator, _memberSetBuilder, _raftLog, _logProvider, _expectedClusterSize, leaderAvailabilityTimers.ElectionTimeout, _clock, _catchupTimeout, _raftMembership);
membershipManager.RecoverFromIndexSupplier = () => 0;
RaftLogShippingManager logShipping = new RaftLogShippingManager(_outbound, _logProvider, _raftLog, _timerService, _clock, _member, membershipManager, _retryTimeMillis, _catchupBatchSize, _maxAllowedShippingLag, _inFlightCache);
RaftMachine raft = new RaftMachine(_member, _termStateStorage, _voteStateStorage, _raftLog, leaderAvailabilityTimers, _outbound, _logProvider, membershipManager, logShipping, _inFlightCache, false, false, _monitors);
_inbound.registerHandler(incomingMessage =>
{
try
{
ConsensusOutcome outcome = raft.Handle(incomingMessage);
_commitListener.notifyCommitted(outcome.CommitIndex);
}
catch (IOException e)
{
throw new Exception(e);
}
});
try
{
membershipManager.Start();
}
catch (IOException e)
{
throw new Exception(e);
}
return(raft);
}
public override void Handle <T1>(Org.Neo4j.causalclustering.core.consensus.RaftMessages_ReceivedInstantClusterIdAwareMessage <T1> wrappedMessage)
{
lock (this)
{
try
{
ConsensusOutcome outcome = _raftMachine.handle(wrappedMessage.message());
if (outcome.NeedsFreshSnapshot())
{
Optional <JobHandle> downloadJob = _downloadService.scheduleDownload(_catchupAddressProvider);
if (downloadJob.Present)
{
downloadJob.get().waitTermination();
}
}
else
{
NotifyCommitted(outcome.CommitIndex);
}
}
catch (Exception e)
{
_log.error("Error handling message", e);
_raftMachine.panic();
_localDatabase.panic(e);
}
}
}
