Method newRemoteEpoch

fdbserver/TagPartitionedLogSystem.actor.cpp:2546–2584

}

ACTOR Future<Void> TagPartitionedLogSystem::newRemoteEpoch(TagPartitionedLogSystem* self,
                                                           Reference<TagPartitionedLogSystem> oldLogSystem,
                                                           Future<RecruitRemoteFromConfigurationReply> fRemoteWorkers,
                                                           UID clusterId,
                                                           DatabaseConfiguration configuration,
                                                           LogEpoch recoveryCount,
                                                           Version recoveryTransactionVersion,
                                                           int8_t remoteLocality,
                                                           std::vector<Tag> allTags) {
	TraceEvent("RemoteLogRecruitment_WaitingForWorkers").log();
	state RecruitRemoteFromConfigurationReply remoteWorkers = wait(fRemoteWorkers);

	state Reference<LogSet> logSet(new LogSet());
	logSet->tLogReplicationFactor = configuration.getRemoteTLogReplicationFactor();
	logSet->tLogVersion = configuration.tLogVersion;
	logSet->tLogPolicy = configuration.getRemoteTLogPolicy();
	logSet->isLocal = false;
	logSet->locality = remoteLocality;

	logSet->startVersion = oldLogSystem->knownCommittedVersion + 1;
	state int lockNum = 0;
	while (lockNum < oldLogSystem->lockResults.size()) {
		if (oldLogSystem->lockResults[lockNum].logSet->locality == remoteLocality) {

			loop {
				auto versions =
				    TagPartitionedLogSystem::getDurableVersion(self->dbgid, oldLogSystem->lockResults[lockNum]);
				if (versions.present()) {
					logSet->startVersion =
					    std::min(std::min(std::get<0>(versions.get()) + 1, oldLogSystem->lockResults[lockNum].epochEnd),
					             logSet->startVersion);
					break;
				}
				wait(TagPartitionedLogSystem::getDurableVersionChanged(oldLogSystem->lockResults[lockNum]));
			}
			break;
		}
		lockNum++;
	}

	std::vector<LocalityData> localities;
	localities.resize(remoteWorkers.remoteTLogs.size());