SERVER-41470 Remove FCV checks for multiple-entry transaction format

Author: jasonjhchan

buildscripts/resmokeconfig/suites/replica_sets_kill_primary_jscore_passthrough.yml

@@ -79,9 +79,6 @@ selector:
   # Inserts enough data that recovery takes more than 8 seconds, so we never get a working primary.
   - jstests/core/geo_s2ordering.js
 
-  # Inserts enough data that the secondaries get too far behind to catch up.
-  - jstests/core/txns/large_transactions_require_fcv42.js
-
   exclude_with_any_tags:
   ##
   # The next four tags correspond to the special errors thrown by the auto_retry_on_network_error.js

buildscripts/resmokeconfig/suites/replica_sets_kill_secondaries_jscore_passthrough.yml

@@ -14,8 +14,6 @@ selector:
   # true. This causes the test to hang because the secondary is running with the "rsSyncStopApply"
   # failpoint enabled.
   - jstests/core/geo_update_btree.js
-  # Inserts enough data that the secondaries get too far behind to catch up.
-  - jstests/core/txns/large_transactions_require_fcv42.js
   # The following tests create large oplog entries, which can cause the secondary to fall off the
   # primary's oplog when run as a part of burn_in_tests.
   - jstests/core/max_doc_size.js

buildscripts/resmokeconfig/suites/sharded_causally_consistent_jscore_txns_passthrough.yml

@@ -13,8 +13,6 @@ selector:
 
   # No featureCompatibilityVersion parameter on mongos.
   - jstests/core/txns/abort_unprepared_transactions_on_FCV_downgrade.js
-  - jstests/core/txns/downgrade_fcv_while_large_partial_txn_in_progress.js
-  - jstests/core/txns/large_transactions_require_fcv42.js
 
   # Mongos doesn't upconvert from local or majority level readConcern to snapshot.
   - jstests/core/txns/upconvert_read_concern.js

buildscripts/resmokeconfig/suites/sharded_collections_causally_consistent_jscore_txns_passthrough.yml

@@ -9,8 +9,6 @@ selector:
 
   # No featureCompatibilityVersion parameter on mongos.
   - jstests/core/txns/abort_unprepared_transactions_on_FCV_downgrade.js
-  - jstests/core/txns/downgrade_fcv_while_large_partial_txn_in_progress.js
-  - jstests/core/txns/large_transactions_require_fcv42.js
 
   # Mongos doesn't upconvert from local or majority level readConcern to snapshot.
   - jstests/core/txns/upconvert_read_concern.js

buildscripts/resmokeconfig/suites/sharded_jscore_txns.yml

@@ -13,8 +13,6 @@ selector:
 
   # No featureCompatibilityVersion parameter on mongos.
   - jstests/core/txns/abort_unprepared_transactions_on_FCV_downgrade.js
-  - jstests/core/txns/downgrade_fcv_while_large_partial_txn_in_progress.js
-  - jstests/core/txns/large_transactions_require_fcv42.js
 
   # Mongos doesn't upconvert from local or majority level readConcern to snapshot.
   - jstests/core/txns/upconvert_read_concern.js

buildscripts/resmokeconfig/suites/sharded_jscore_txns_sharded_collections.yml

@@ -9,8 +9,6 @@ selector:
 
   # No featureCompatibilityVersion parameter on mongos.
   - jstests/core/txns/abort_unprepared_transactions_on_FCV_downgrade.js
-  - jstests/core/txns/downgrade_fcv_while_large_partial_txn_in_progress.js
-  - jstests/core/txns/large_transactions_require_fcv42.js
 
   # Mongos doesn't upconvert from local or majority level readConcern to snapshot.
   - jstests/core/txns/upconvert_read_concern.js

jstests/core/txns/downgrade_fcv_while_large_partial_txn_in_progress.js

@@ -745,15 +745,11 @@ namespace {
 // field. Appends as many operations as possible until either the constructed object exceeds the
 // 16MB limit or the maximum number of transaction statements allowed in one entry.
 //
-// If 'limitSize' is false, then it attempts to include all given operations, regardless of whether
-// or not they fit. If the ops don't fit, TransactionTooLarge will be thrown in that case.
-//
 // Returns an iterator to the first statement that wasn't packed into the applyOps object.
 std::vector<repl::ReplOperation>::const_iterator packTransactionStatementsForApplyOps(
     BSONObjBuilder* applyOpsBuilder,
     std::vector<repl::ReplOperation>::const_iterator stmtBegin,
-    std::vector<repl::ReplOperation>::const_iterator stmtEnd,
-    bool limitSize) {
+    std::vector<repl::ReplOperation>::const_iterator stmtEnd) {
 
     std::vector<repl::ReplOperation>::const_iterator stmtIter;
     BSONArrayBuilder opsArray(applyOpsBuilder->subarrayStart("applyOps"_sd));
@@ -765,11 +761,9 @@ std::vector<repl::ReplOperation>::const_iterator packTransactionStatementsForApp
         // BSON overhead and the other applyOps fields.  But if the array with a single operation
         // exceeds BSONObjMaxUserSize, we still log it, as a single max-length operation
         // should be able to be applied.
-        if (limitSize &&
-            (opsArray.arrSize() == gMaxNumberOfTransactionOperationsInSingleOplogEntry ||
-             (opsArray.arrSize() > 0 &&
-              (opsArray.len() + OplogEntry::getDurableReplOperationSize(stmt) >
-               BSONObjMaxUserSize))))
+        if (opsArray.arrSize() == gMaxNumberOfTransactionOperationsInSingleOplogEntry ||
+            (opsArray.arrSize() > 0 &&
+             (opsArray.len() + OplogEntry::getDurableReplOperationSize(stmt) > BSONObjMaxUserSize)))
             break;
         opsArray.append(stmt.toBSON());
     }
@@ -880,8 +874,8 @@ int logOplogEntriesForTransaction(OperationContext* opCtx,
             while (stmtsIter != stmts.end()) {
 
                 BSONObjBuilder applyOpsBuilder;
-                auto nextStmt = packTransactionStatementsForApplyOps(
-                    &applyOpsBuilder, stmtsIter, stmts.end(), true /* limitSize */);
+                auto nextStmt =
+                    packTransactionStatementsForApplyOps(&applyOpsBuilder, stmtsIter, stmts.end());
 
                 // If we packed the last op, then the next oplog entry we log should be the implicit
                 // commit or implicit prepare, i.e. we omit the 'partialTxn' field.
@@ -999,41 +993,14 @@ void OpObserverImpl::onUnpreparedTransactionCommit(
         return;
 
     repl::OpTime commitOpTime;
-    // As FCV downgrade/upgrade is racey, we want to avoid performing a FCV check multiple times in
-    // a single call into the OpObserver. Therefore, we store the result here and pass it as an
-    // argument.
-    const auto fcv = serverGlobalParams.featureCompatibility.getVersion();
-    if (fcv < ServerGlobalParams::FeatureCompatibility::Version::kFullyUpgradedTo42) {
-        auto txnParticipant = TransactionParticipant::get(opCtx);
-        const auto lastWriteOpTime = txnParticipant.getLastWriteOpTime();
-        invariant(lastWriteOpTime.isNull());
-        MutableOplogEntry oplogEntry;
-        oplogEntry.setPrevWriteOpTimeInTransaction(lastWriteOpTime);
-        oplogEntry.setStatementId(StmtId(0));
-
-        BSONObjBuilder applyOpsBuilder;
-        // TODO(SERVER-41470): Remove limitSize==false once old transaction format is no longer
-        // needed.
-        packTransactionStatementsForApplyOps(
-            &applyOpsBuilder, statements.begin(), statements.end(), false /* limitSize */);
-        oplogEntry.setObject(applyOpsBuilder.done());
-
-        auto txnState = boost::make_optional(
-            fcv >= ServerGlobalParams::FeatureCompatibility::Version::kUpgradingTo42,
-            DurableTxnStateEnum::kCommitted);
-        commitOpTime = logApplyOpsForTransaction(
-                           opCtx, &oplogEntry, txnState, boost::none, true /* updateTxnTable */)
-                           .writeOpTime;
-    } else {
-        // Reserve all the optimes in advance, so we only need to get the optime mutex once.  We
-        // reserve enough entries for all statements in the transaction.
-        auto oplogSlots = repl::getNextOpTimes(opCtx, statements.size());
-        invariant(oplogSlots.size() == statements.size());
-
-        // Log in-progress entries for the transaction along with the implicit commit.
-        int numOplogEntries = logOplogEntriesForTransaction(opCtx, statements, oplogSlots, false);
-        commitOpTime = oplogSlots[numOplogEntries - 1];
-    }
+    // Reserve all the optimes in advance, so we only need to get the optime mutex once.  We
+    // reserve enough entries for all statements in the transaction.
+    auto oplogSlots = repl::getNextOpTimes(opCtx, statements.size());
+    invariant(oplogSlots.size() == statements.size());
+
+    // Log in-progress entries for the transaction along with the implicit commit.
+    int numOplogEntries = logOplogEntriesForTransaction(opCtx, statements, oplogSlots, false);
+    commitOpTime = oplogSlots[numOplogEntries - 1];
     invariant(!commitOpTime.isNull());
     shardObserveTransactionPrepareOrUnpreparedCommit(opCtx, statements, commitOpTime);
 }
@@ -1074,48 +1041,7 @@ void OpObserverImpl::onTransactionPrepare(OperationContext* opCtx,
         return;
     }
 
-    // As FCV downgrade/upgrade is racey, we want to avoid performing a FCV check multiple times in
-    // a single call into the OpObserver. Therefore, we store the result here and pass it as an
-    // argument.
-    const auto fcv = serverGlobalParams.featureCompatibility.getVersion();
-    if (fcv < ServerGlobalParams::FeatureCompatibility::Version::kFullyUpgradedTo42) {
-        // We write the oplog entry in a side transaction so that we do not commit the now-prepared
-        // transaction.
-        // We write an empty 'applyOps' entry if there were no writes to choose a prepare timestamp
-        // and allow this transaction to be continued on failover.
-        TransactionParticipant::SideTransactionBlock sideTxn(opCtx);
-
-        writeConflictRetry(
-            opCtx, "onTransactionPrepare", NamespaceString::kRsOplogNamespace.ns(), [&] {
-                // Writes to the oplog only require a Global intent lock. Guaranteed by
-                // OplogSlotReserver.
-                invariant(opCtx->lockState()->isWriteLocked());
-
-                WriteUnitOfWork wuow(opCtx);
-                auto txnParticipant = TransactionParticipant::get(opCtx);
-                const auto lastWriteOpTime = txnParticipant.getLastWriteOpTime();
-                invariant(lastWriteOpTime.isNull());
-
-                MutableOplogEntry oplogEntry;
-                oplogEntry.setOpTime(prepareOpTime);
-                oplogEntry.setPrevWriteOpTimeInTransaction(lastWriteOpTime);
-
-                BSONObjBuilder applyOpsBuilder;
-                // TODO(SERVER-41470): Remove limitSize==false once old transaction format is no
-                // longer needed.
-                packTransactionStatementsForApplyOps(
-                    &applyOpsBuilder, statements.begin(), statements.end(), false /* limitSize */);
-                applyOpsBuilder.append("prepare", true);
-                oplogEntry.setObject(applyOpsBuilder.done());
-
-                auto txnState = boost::make_optional(
-                    fcv >= ServerGlobalParams::FeatureCompatibility::Version::kUpgradingTo42,
-                    DurableTxnStateEnum::kPrepared);
-                logApplyOpsForTransaction(
-                    opCtx, &oplogEntry, txnState, prepareOpTime, true /* updateTxnTable */);
-                wuow.commit();
-            });
-    } else {
+    {
         // We should have reserved enough slots.
         invariant(reservedSlots.size() >= statements.size());
         TransactionParticipant::SideTransactionBlock sideTxn(opCtx);

jstests/core/txns/large_transactions_require_fcv42.js

@@ -1091,24 +1091,11 @@ Timestamp TransactionParticipant::Participant::prepareTransaction(
         o(lk).prepareOpTime = *prepareOptime;
         reservedSlots.push_back(prepareOplogSlot);
     } else {
-        // On primary, we reserve an optime, prepare the transaction and write the oplog entry.
-        //
-        // Reserve an optime for the 'prepareTimestamp'. This will create a hole in the oplog and
-        // cause 'snapshot' and 'afterClusterTime' readers to block until this transaction is done
-        // being prepared. When the OplogSlotReserver goes out of scope and is destroyed, the
-        // storage-transaction it uses to keep the hole open will abort and the slot (and
-        // corresponding oplog hole) will vanish.
-        // TODO(SERVER-41470): Remove the if-clause here.
-        if (serverGlobalParams.featureCompatibility.getVersion() <
-            ServerGlobalParams::FeatureCompatibility::Version::kFullyUpgradedTo42) {
-            oplogSlotReserver.emplace(opCtx);
-        } else {
-            // Even if the prepared transaction contained no statements, we always reserve at least
-            // 1 oplog slot for the prepare oplog entry.
-            const auto numSlotsToReserve = retrieveCompletedTransactionOperations(opCtx).size();
-            oplogSlotReserver.emplace(opCtx, std::max(1, static_cast<int>(numSlotsToReserve)));
-            invariant(oplogSlotReserver->getSlots().size() >= 1);
-        }
+        // Even if the prepared transaction contained no statements, we always reserve at least
+        // 1 oplog slot for the prepare oplog entry.
+        const auto numSlotsToReserve = retrieveCompletedTransactionOperations(opCtx).size();
+        oplogSlotReserver.emplace(opCtx, std::max(1, static_cast<int>(numSlotsToReserve)));
+        invariant(oplogSlotReserver->getSlots().size() >= 1);
         prepareOplogSlot = oplogSlotReserver->getLastSlot();
         reservedSlots = oplogSlotReserver->getSlots();
         invariant(o().prepareOpTime.isNull(),
@@ -1190,20 +1177,6 @@ void TransactionParticipant::Participant::addTransactionOperation(
                           << "server parameter 'transactionSizeLimitBytes' = "
                           << transactionSizeLimitBytes,
             p().transactionOperationBytes <= static_cast<size_t>(transactionSizeLimitBytes));
-
-    // Creating transactions larger than 16MB requires a new oplog format only available in FCV 4.2.
-    const auto isFCV42 = serverGlobalParams.featureCompatibility.getVersion() ==
-        ServerGlobalParams::FeatureCompatibility::Version::kFullyUpgradedTo42;
-    // _transactionOperationBytes is based on the in-memory size of the operation.  With overhead,
-    // we expect the BSON size of the operation to be larger, so it's possible to make a transaction
-    // just a bit too large and have it fail only in the commit.  It's still useful to fail early
-    // when possible (e.g. to avoid exhausting server memory).
-    uassert(ErrorCodes::TransactionTooLarge,
-            str::stream() << "Total size of all transaction operations must be less than "
-                          << BSONObjMaxInternalSize
-                          << " when using featureCompatibilityVersion < 4.2. Actual size is "
-                          << p().transactionOperationBytes,
-            isFCV42 || p().transactionOperationBytes <= BSONObjMaxInternalSize);
 }
 
 std::vector<repl::ReplOperation>&