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;
}
StatusWith<std::set<NamespaceString>> RollbackImpl::_namespacesForOp(const OplogEntry& oplogEntry) {
NamespaceString opNss = oplogEntry.getNamespace();
OpTypeEnum opType = oplogEntry.getOpType();
std::set<NamespaceString> namespaces;
// No namespaces for a no-op.
if (opType == OpTypeEnum::kNoop) {
return std::set<NamespaceString>();
}
// CRUD ops have the proper namespace in the operation 'ns' field.
if (opType == OpTypeEnum::kInsert || opType == OpTypeEnum::kUpdate ||
opType == OpTypeEnum::kDelete) {
return std::set<NamespaceString>({opNss});
}
// If the operation is a command, then we need to extract the appropriate namespaces from the
// command object, as opposed to just using the 'ns' field of the oplog entry itself.
if (opType == OpTypeEnum::kCommand) {
auto obj = oplogEntry.getObject();
auto firstElem = obj.firstElement();
// Does not handle 'applyOps' entries.
invariant(oplogEntry.getCommandType() != OplogEntry::CommandType::kApplyOps,
"_namespacesForOp does not handle 'applyOps' oplog entries.");
switch (oplogEntry.getCommandType()) {
case OplogEntry::CommandType::kRenameCollection: {
// Add both the 'from' and 'to' namespaces.
namespaces.insert(NamespaceString(firstElem.valuestrsafe()));
namespaces.insert(NamespaceString(obj.getStringField("to")));
break;
}
case OplogEntry::CommandType::kDropDatabase: {
// There is no specific namespace to save for a drop database operation.
break;
}
case OplogEntry::CommandType::kDbCheck:
case OplogEntry::CommandType::kConvertToCapped:
case OplogEntry::CommandType::kEmptyCapped: {
// These commands do not need to be supported by rollback. 'convertToCapped' should
// always be converted to lower level DDL operations, and 'emptycapped' is a
// testing-only command.
std::string message = str::stream() << "Encountered unsupported command type '"
<< firstElem.fieldName()
<< "' during rollback.";
return Status(ErrorCodes::UnrecoverableRollbackError, message);
}
case OplogEntry::CommandType::kCreate:
case OplogEntry::CommandType::kDrop:
case OplogEntry::CommandType::kCreateIndexes:
case OplogEntry::CommandType::kDropIndexes:
case OplogEntry::CommandType::kCollMod: {
// For all other command types, we should be able to parse the collection name from
// the first command argument.
try {
auto cmdNss = CommandHelpers::parseNsCollectionRequired(opNss.db(), obj);
namespaces.insert(cmdNss);
} catch (const DBException& ex) {
return ex.toStatus();
}
break;
}
case OplogEntry::CommandType::kApplyOps:
default:
// Every possible command type should be handled above.
MONGO_UNREACHABLE
}
}
