Status SyncSourceResolver::_compareRequiredOpTimeWithQueryResponse(
const Fetcher::QueryResponse& queryResponse) {
if (queryResponse.documents.empty()) {
return Status(
ErrorCodes::NoMatchingDocument,
"remote oplog does not contain entry with optime matching our required optime");
}
const OplogEntry oplogEntry(queryResponse.documents.front());
const auto opTime = oplogEntry.getOpTime();
if (_requiredOpTime != opTime) {
return Status(ErrorCodes::BadValue,
str::stream() << "remote oplog contain entry with matching timestamp "
<< opTime.getTimestamp().toString()
<< " but optime "
<< opTime.toString()
<< " does not "
"match our required optime");
}
if (_requiredOpTime.getTerm() != opTime.getTerm()) {
return Status(ErrorCodes::BadValue,
str::stream() << "remote oplog contain entry with term " << opTime.getTerm()
<< " that does not "
"match the term in our required optime");
}
return Status::OK();
}
repl::MultiApplier::Operations readTransactionOperationsFromOplogChain(
OperationContext* opCtx,
const OplogEntry& commitOrPrepare,
const std::vector<OplogEntry*> cachedOps) {
repl::MultiApplier::Operations ops;
// Get the previous oplog entry.
auto currentOpTime = commitOrPrepare.getOpTime();
// The cachedOps are the ops for this transaction that are from the same oplog application batch
// as the commit or prepare, those which have not necessarily been written to the oplog. These
// ops are in order of increasing timestamp.
// The lastEntryOpTime is the OpTime of the last (latest OpTime) entry for this transaction
// which is expected to be present in the oplog. It is the entry before the first cachedOp,
// unless there are no cachedOps in which case it is the entry before the commit or prepare.
const auto lastEntryOpTime = (cachedOps.empty() ? commitOrPrepare : *cachedOps.front())
.getPrevWriteOpTimeInTransaction();
invariant(lastEntryOpTime < currentOpTime);
TransactionHistoryIterator iter(lastEntryOpTime.get());
// Empty commits are not allowed, but empty prepares are.
invariant(commitOrPrepare.getCommandType() != OplogEntry::CommandType::kCommitTransaction ||
!cachedOps.empty() || iter.hasNext());
auto commitOrPrepareObj = commitOrPrepare.toBSON();
// First retrieve and transform the ops from the oplog, which will be retrieved in reverse
// order.
while (iter.hasNext()) {
const auto& operationEntry = iter.next(opCtx);
invariant(operationEntry.isPartialTransaction());
auto prevOpsEnd = ops.size();
_reconstructPartialTxnEntryAtGivenTime(operationEntry, commitOrPrepareObj, &ops);
// Because BSONArrays do not have fast way of determining size without iterating through
// them, and we also have no way of knowing how many oplog entries are in a transaction
// without iterating, reversing each applyOps and then reversing the whole array is
// about as good as we can do to get the entire thing in chronological order. Fortunately
// STL arrays of BSON objects should be fast to reverse (just pointer copies).
std::reverse(ops.begin() + prevOpsEnd, ops.end());
}
std::reverse(ops.begin(), ops.end());
// Next retrieve and transform the ops from the current batch, which are in increasing timestamp
// order.
for (auto* cachedOp : cachedOps) {
const auto& operationEntry = *cachedOp;
invariant(operationEntry.isPartialTransaction());
_reconstructPartialTxnEntryAtGivenTime(operationEntry, commitOrPrepareObj, &ops);
}
return ops;
}
Status applyCommitTransaction(OperationContext* opCtx,
const OplogEntry& entry,
repl::OplogApplication::Mode mode) {
// Return error if run via applyOps command.
uassert(50987,
"commitTransaction is only used internally by secondaries.",
mode != repl::OplogApplication::Mode::kApplyOpsCmd);
IDLParserErrorContext ctx("commitTransaction");
auto commitOplogEntryOpTime = entry.getOpTime();
auto commitCommand = CommitTransactionOplogObject::parse(ctx, entry.getObject());
const bool prepared = !commitCommand.getPrepared() || *commitCommand.getPrepared();
if (!prepared)
return Status::OK();
invariant(commitCommand.getCommitTimestamp());
if (mode == repl::OplogApplication::Mode::kRecovering ||
mode == repl::OplogApplication::Mode::kInitialSync) {
return _applyTransactionFromOplogChain(opCtx,
entry,
mode,
*commitCommand.getCommitTimestamp(),
commitOplogEntryOpTime.getTimestamp());
}
invariant(mode == repl::OplogApplication::Mode::kSecondary);
// Transaction operations are in its own batch, so we can modify their opCtx.
invariant(entry.getSessionId());
invariant(entry.getTxnNumber());
opCtx->setLogicalSessionId(*entry.getSessionId());
opCtx->setTxnNumber(*entry.getTxnNumber());
// The write on transaction table may be applied concurrently, so refreshing state
// from disk may read that write, causing starting a new transaction on an existing
// txnNumber. Thus, we start a new transaction without refreshing state from disk.
MongoDOperationContextSessionWithoutRefresh sessionCheckout(opCtx);
auto transaction = TransactionParticipant::get(opCtx);
invariant(transaction);
transaction.unstashTransactionResources(opCtx, "commitTransaction");
transaction.commitPreparedTransaction(
opCtx, *commitCommand.getCommitTimestamp(), commitOplogEntryOpTime);
return Status::OK();
}
