void WiredTigerRecoveryUnit::setTimestampReadSource(ReadSource readSource,
boost::optional<Timestamp> provided) {
LOG(3) << "setting timestamp read source: " << static_cast<int>(readSource)
<< ", provided timestamp: " << ((provided) ? provided->toString() : "none");
invariant(!_isActive() || _timestampReadSource == readSource,
str::stream() << "Current state: " << toString(_state)
<< ". Invalid internal state while setting timestamp read source: "
<< static_cast<int>(readSource)
<< ", provided timestamp: "
<< (provided ? provided->toString() : "none"));
invariant(!provided == (readSource != ReadSource::kProvided));
invariant(!(provided && provided->isNull()));
_timestampReadSource = readSource;
_readAtTimestamp = (provided) ? *provided : Timestamp();
}
void ReplicationRecoveryImpl::recoverFromOplog(OperationContext* opCtx,
boost::optional<Timestamp> stableTimestamp) try {
if (_consistencyMarkers->getInitialSyncFlag(opCtx)) {
log() << "No recovery needed. Initial sync flag set.";
return; // Initial Sync will take over so no cleanup is needed.
}
const auto serviceCtx = getGlobalServiceContext();
inReplicationRecovery(serviceCtx) = true;
ON_BLOCK_EXIT([serviceCtx] {
invariant(
inReplicationRecovery(serviceCtx),
"replication recovery flag is unexpectedly unset when exiting recoverFromOplog()");
inReplicationRecovery(serviceCtx) = false;
});
const auto truncateAfterPoint = _consistencyMarkers->getOplogTruncateAfterPoint(opCtx);
if (!truncateAfterPoint.isNull()) {
log() << "Removing unapplied entries starting at: " << truncateAfterPoint.toBSON();
_truncateOplogTo(opCtx, truncateAfterPoint);
// Clear the truncateAfterPoint so that we don't truncate the next batch of oplog entries
// erroneously.
_consistencyMarkers->setOplogTruncateAfterPoint(opCtx, {});
opCtx->recoveryUnit()->waitUntilDurable();
}
auto topOfOplogSW = _getTopOfOplog(opCtx);
if (topOfOplogSW.getStatus() == ErrorCodes::CollectionIsEmpty ||
topOfOplogSW.getStatus() == ErrorCodes::NamespaceNotFound) {
// Oplog is empty. There are no oplog entries to apply, so we exit recovery and go into
// initial sync.
log() << "No oplog entries to apply for recovery. Oplog is empty.";
return;
}
fassert(40290, topOfOplogSW);
const auto topOfOplog = topOfOplogSW.getValue();
// If we were passed in a stable timestamp, we are in rollback recovery and should recover from
// that stable timestamp. Otherwise, we're recovering at startup. If this storage engine
// supports recover to stable timestamp or enableMajorityReadConcern=false, we ask it for the
// recovery timestamp. If the storage engine returns a timestamp, we recover from that point.
// However, if the storage engine returns "none", the storage engine does not have a stable
// checkpoint and we must recover from an unstable checkpoint instead.
const bool supportsRecoveryTimestamp =
_storageInterface->supportsRecoveryTimestamp(opCtx->getServiceContext());
if (!stableTimestamp && supportsRecoveryTimestamp) {
stableTimestamp = _storageInterface->getRecoveryTimestamp(opCtx->getServiceContext());
}
const auto appliedThrough = _consistencyMarkers->getAppliedThrough(opCtx);
invariant(!stableTimestamp || stableTimestamp->isNull() || appliedThrough.isNull() ||
*stableTimestamp == appliedThrough.getTimestamp(),
str::stream() << "Stable timestamp " << stableTimestamp->toString()
<< " does not equal appliedThrough timestamp "
<< appliedThrough.toString());
if (stableTimestamp) {
invariant(supportsRecoveryTimestamp);
_recoverFromStableTimestamp(opCtx, *stableTimestamp, appliedThrough, topOfOplog);
} else {
_recoverFromUnstableCheckpoint(opCtx, appliedThrough, topOfOplog);
}
_reconstructPreparedTransactions(opCtx);
} catch (...) {
severe() << "Caught exception during replication recovery: " << exceptionToStatus();
std::terminate();
}