diff options
Diffstat (limited to 'src/mongo')
20 files changed, 114 insertions, 56 deletions
diff --git a/src/mongo/db/index/index_build_interceptor.cpp b/src/mongo/db/index/index_build_interceptor.cpp index 6061ea3b90f..b27c7169d1a 100644 --- a/src/mongo/db/index/index_build_interceptor.cpp +++ b/src/mongo/db/index/index_build_interceptor.cpp @@ -162,6 +162,15 @@ Status IndexBuildInterceptor::drainWritesIntoIndex(OperationContext* opCtx, // Returns true if the cursor has reached the end of the table, false if there are more records, // and an error Status otherwise. auto applySingleBatch = [&]() -> StatusWith<bool> { + // This write is performed without a durable/commit timestamp. This transaction trips the + // ordered assertion for the side-table documents which are inserted with a timestamp and, + // in here, being deleted without a timestamp. Because the data being read is majority + // committed, there's no risk of needing to roll back the writes done by this "drain". + // + // Note that index builds will only "resume" once. A second resume results in the index + // build starting from scratch. A "resumed" index build does not use a majority read + // concern. And thus will observe data that can be rolled back via replication. + opCtx->recoveryUnit()->allowUntimestampedWrite(); WriteUnitOfWork wuow(opCtx); int32_t batchSize = 0; diff --git a/src/mongo/db/index_builds_coordinator.cpp b/src/mongo/db/index_builds_coordinator.cpp index 30b66e249b5..0c3cea6fc00 100644 --- a/src/mongo/db/index_builds_coordinator.cpp +++ b/src/mongo/db/index_builds_coordinator.cpp @@ -191,6 +191,11 @@ void removeIndexBuildEntryAfterCommitOrAbort(OperationContext* opCtx, return; } + if (replCoord->getSettings().shouldRecoverFromOplogAsStandalone()) { + // TODO SERVER-60753: Remove this mixed-mode write. + opCtx->recoveryUnit()->allowUntimestampedWrite(); + } + auto status = indexbuildentryhelpers::removeIndexBuildEntry( opCtx, indexBuildEntryCollection, replState.buildUUID); if (!status.isOK()) { @@ -545,6 +550,10 @@ Status IndexBuildsCoordinator::_startIndexBuildForRecovery(OperationContext* opC CollectionWriter collection(opCtx, nss); { + // TODO SERVER-64760: Remove this usage of `allowUntimestampedWrite`. We often have a valid + // timestamp for this write, but the callers of this function don't pass it through. + opCtx->recoveryUnit()->allowUntimestampedWrite(); + // These steps are combined into a single WUOW to ensure there are no commits without // the indexes. // 1) Drop all unfinished indexes. @@ -1880,6 +1889,12 @@ Status IndexBuildsCoordinator::_setUpIndexBuildForTwoPhaseRecovery( const UUID& buildUUID) { NamespaceStringOrUUID nssOrUuid{dbName.toString(), collectionUUID}; + if (opCtx->recoveryUnit()->isActive()) { + // This function is shared by multiple callers. Some of which have opened a transaction to + // perform reads. This function may make mixed-mode writes. Mixed-mode assertions can only + // be suppressed when beginning a fresh transaction. + opCtx->recoveryUnit()->abandonSnapshot(); + } // Don't use the AutoGet helpers because they require an open database, which may not be the // case when an index builds is restarted during recovery. @@ -2057,6 +2072,10 @@ IndexBuildsCoordinator::PostSetupAction IndexBuildsCoordinator::_setUpIndexBuild options.protocol = replState->protocol; try { + // TODO SERVER-64760: Remove this usage of `allowUntimestampedWrite`. There are cases where + // a timestamp is available to use, but the information is not passed through. + opCtx->recoveryUnit()->allowUntimestampedWrite(); + if (!replSetAndNotPrimary) { // On standalones and primaries, call setUpIndexBuild(), which makes the initial catalog // write. On primaries, this replicates the startIndexBuild oplog entry. diff --git a/src/mongo/db/repair.cpp b/src/mongo/db/repair.cpp index c880b32487b..a6f8029be24 100644 --- a/src/mongo/db/repair.cpp +++ b/src/mongo/db/repair.cpp @@ -71,6 +71,13 @@ using namespace fmt::literals; Status rebuildIndexesForNamespace(OperationContext* opCtx, const NamespaceString& nss, StorageEngine* engine) { + if (opCtx->recoveryUnit()->isActive()) { + // This function is shared by multiple callers. Some of which have opened a transaction to + // perform reads. This function may make mixed-mode writes. Mixed-mode assertions can only + // be suppressed when beginning a fresh transaction. + opCtx->recoveryUnit()->abandonSnapshot(); + } + opCtx->checkForInterrupt(); auto collection = CollectionCatalog::get(opCtx)->lookupCollectionByNamespace(opCtx, nss); auto swIndexNameObjs = getIndexNameObjs(collection); diff --git a/src/mongo/db/repl/oplog_applier_impl_test.cpp b/src/mongo/db/repl/oplog_applier_impl_test.cpp index 88eb0fb7fb7..ef1767ee934 100644 --- a/src/mongo/db/repl/oplog_applier_impl_test.cpp +++ b/src/mongo/db/repl/oplog_applier_impl_test.cpp @@ -2683,6 +2683,11 @@ public: void setUp() override { OplogApplierImplTest::setUp(); + // This fixture sets up some replication, but notably omits installing an + // OpObserverImpl. This state causes collection creation to timestamp catalog writes, but + // secondary index creation does not. We use an UnreplicatedWritesBlock to avoid + // timestamping any of the catalog setup. + repl::UnreplicatedWritesBlock noRep(_opCtx.get()); MongoDSessionCatalog::onStepUp(_opCtx.get()); DBDirectClient client(_opCtx.get()); diff --git a/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp b/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp index 72c93034d8b..7c3d062a545 100644 --- a/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp +++ b/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp @@ -503,6 +503,10 @@ void createIndex(OperationContext* opCtx, Lock::DBLock dbLk(opCtx, nss.dbName(), MODE_IX); Lock::CollectionLock collLk(opCtx, nss, MODE_X); auto indexBuildsCoord = IndexBuildsCoordinator::get(opCtx); + // This fixture sets up some replication, but notably omits installing an OpObserverImpl. This + // state causes collection creation to timestamp catalog writes, but secondary index creation + // does not. We use an UnreplicatedWritesBlock to avoid timestamping any of the catalog setup. + repl::UnreplicatedWritesBlock noRep(opCtx); indexBuildsCoord->createIndex( opCtx, collUUID, spec, IndexBuildsManager::IndexConstraints::kEnforce, false); } diff --git a/src/mongo/db/repl/oplog_applier_test.cpp b/src/mongo/db/repl/oplog_applier_test.cpp index cb35f041caa..d9eff0fced7 100644 --- a/src/mongo/db/repl/oplog_applier_test.cpp +++ b/src/mongo/db/repl/oplog_applier_test.cpp @@ -369,6 +369,7 @@ public: void setUp() override { OplogApplierTest::setUp(); auto* service = getServiceContext(); + _origThreadName = *getThreadNameRef().get(); Client::initThread("OplogApplierDelayTest", service, nullptr); _mockClock = std::make_shared<ClockSourceMock>(); @@ -387,6 +388,7 @@ public: _opCtxHolder = nullptr; Client::releaseCurrent(); OplogApplierTest::tearDown(); + setThreadName(_origThreadName); } OperationContext* opCtx() override { @@ -412,6 +414,9 @@ protected: std::shared_ptr<ClockSourceMock> _mockClock; ServiceContext::UniqueOperationContext _opCtxHolder; AtomicWord<bool> _failWaits{false}; + +private: + std::string _origThreadName; }; TEST_F(OplogApplierDelayTest, GetNextApplierBatchReturnsEmptyBatchImmediately) { diff --git a/src/mongo/db/repl/replication_recovery_test.cpp b/src/mongo/db/repl/replication_recovery_test.cpp index dc2287e9f03..b31925a330a 100644 --- a/src/mongo/db/repl/replication_recovery_test.cpp +++ b/src/mongo/db/repl/replication_recovery_test.cpp @@ -195,10 +195,17 @@ private: repl::createOplog(_opCtx.get()); - ASSERT_OK(_storageInterface->createCollection( - getOperationContext(), testNs, generateOptionsWithUuid())); - - MongoDSessionCatalog::onStepUp(_opCtx.get()); + { + // This fixture sets up some replication, but notably omits installing an + // OpObserverImpl. This state causes collection creation to timestamp catalog writes, + // but secondary index creation does not. We use an UnreplicatedWritesBlock to avoid + // timestamping any of the catalog setup. + repl::UnreplicatedWritesBlock noRep(_opCtx.get()); + ASSERT_OK(_storageInterface->createCollection( + getOperationContext(), testNs, generateOptionsWithUuid())); + + MongoDSessionCatalog::onStepUp(_opCtx.get()); + } auto observerRegistry = checked_cast<OpObserverRegistry*>(service->getOpObserver()); observerRegistry->addObserver(std::make_unique<ReplicationRecoveryTestObObserver>()); diff --git a/src/mongo/db/repl/rollback_impl.cpp b/src/mongo/db/repl/rollback_impl.cpp index 91893402542..613518af43b 100644 --- a/src/mongo/db/repl/rollback_impl.cpp +++ b/src/mongo/db/repl/rollback_impl.cpp @@ -524,6 +524,7 @@ void RollbackImpl::_restoreTxnsTableEntryFromRetryableWrites(OperationContext* o } const auto nss = NamespaceString::kSessionTransactionsTableNamespace; writeConflictRetry(opCtx, "updateSessionTransactionsTableInRollback", nss.ns(), [&] { + opCtx->recoveryUnit()->allowUntimestampedWrite(); AutoGetCollection collection(opCtx, nss, MODE_IX); auto filter = BSON(SessionTxnRecord::kSessionIdFieldName << sessionId.toBSON()); UnreplicatedWritesBlock uwb(opCtx); diff --git a/src/mongo/db/repl/storage_timestamp_test.cpp b/src/mongo/db/repl/storage_timestamp_test.cpp index 299bfcc2339..4f3f5bf0a18 100644 --- a/src/mongo/db/repl/storage_timestamp_test.cpp +++ b/src/mongo/db/repl/storage_timestamp_test.cpp @@ -137,7 +137,8 @@ Status createIndexFromSpec(OperationContext* opCtx, collection, spec, [opCtx, clock](const std::vector<BSONObj>& specs) -> Status { - if (opCtx->recoveryUnit()->getCommitTimestamp().isNull()) { + if (opCtx->writesAreReplicated() && + opCtx->recoveryUnit()->getCommitTimestamp().isNull()) { return opCtx->recoveryUnit()->setTimestamp( clock->tickClusterTime(1).asTimestamp()); } @@ -167,8 +168,10 @@ Status createIndexFromSpec(OperationContext* opCtx, collection.getWritableCollection(opCtx), MultiIndexBlock::kNoopOnCreateEachFn, MultiIndexBlock::kNoopOnCommitFn)); - LogicalTime indexTs = clock->tickClusterTime(1); - ASSERT_OK(opCtx->recoveryUnit()->setTimestamp(indexTs.asTimestamp())); + if (opCtx->writesAreReplicated()) { + LogicalTime indexTs = clock->tickClusterTime(1); + ASSERT_OK(opCtx->recoveryUnit()->setTimestamp(indexTs.asTimestamp())); + } wunit.commit(); abortOnExit.dismiss(); return Status::OK(); @@ -356,7 +359,8 @@ public: AutoGetCollection autoColl(_opCtx, nss, LockMode::MODE_IX); auto db = autoColl.ensureDbExists(_opCtx); WriteUnitOfWork wunit(_opCtx); - if (_opCtx->recoveryUnit()->getCommitTimestamp().isNull()) { + if (_opCtx->writesAreReplicated() && + _opCtx->recoveryUnit()->getCommitTimestamp().isNull()) { ASSERT_OK(_opCtx->recoveryUnit()->setTimestamp(Timestamp(1, 1))); } invariant(db->createCollection(_opCtx, nss)); @@ -1666,6 +1670,7 @@ TEST_F(StorageTimestampTest, PrimarySetIndexMultikeyOnInsert) { TEST_F(StorageTimestampTest, PrimarySetIndexMultikeyOnInsertUnreplicated) { // Use an unreplicated collection. + repl::UnreplicatedWritesBlock noRep(_opCtx); NamespaceString nss("unittests.system.profile"); create(nss); diff --git a/src/mongo/db/service_context_d_test_fixture.cpp b/src/mongo/db/service_context_d_test_fixture.cpp index 0e40005bde4..caef9950914 100644 --- a/src/mongo/db/service_context_d_test_fixture.cpp +++ b/src/mongo/db/service_context_d_test_fixture.cpp @@ -70,6 +70,11 @@ ServiceContextMongoDTest::ServiceContextMongoDTest(Options options) replSettings.setOplogSizeBytes(10 * 1024 * 1024); replSettings.setReplSetString("rs0"); setGlobalReplSettings(replSettings); + } else { + repl::ReplSettings replSettings; + // The empty string "disables" replication. + replSettings.setReplSetString(""); + setGlobalReplSettings(replSettings); } _stashedStorageParams.engine = diff --git a/src/mongo/db/storage/recovery_unit.h b/src/mongo/db/storage/recovery_unit.h index 6ac1a4375c6..fed9d478540 100644 --- a/src/mongo/db/storage/recovery_unit.h +++ b/src/mongo/db/storage/recovery_unit.h @@ -409,6 +409,12 @@ public: return {}; } + /** + * MongoDB must update documents with non-decreasing timestamp values. A storage engine is + * allowed to assert when this contract is violated. An untimestamped write is a subset of these + * violations, which may be necessary in limited circumstances. This API can be called before a + * transaction begins to suppress this subset of errors. + */ virtual void allowUntimestampedWrite() {} /** diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.cpp index e91b228505a..abb0617c124 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.cpp @@ -49,7 +49,7 @@ WiredTigerBeginTxnBlock::WiredTigerBeginTxnBlock( PrepareConflictBehavior prepareConflictBehavior, RoundUpPreparedTimestamps roundUpPreparedTimestamps, RoundUpReadTimestamp roundUpReadTimestamp, - bool allowUntimestampedWrite) + UntimestampedWriteAssertion allowUntimestampedWrite) : _session(session) { invariant(!_rollback); @@ -70,7 +70,7 @@ WiredTigerBeginTxnBlock::WiredTigerBeginTxnBlock( } builder << "),"; } - if (allowUntimestampedWrite) { + if (allowUntimestampedWrite == UntimestampedWriteAssertion::kSuppress) { builder << "no_timestamp=true,"; } diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.h b/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.h index ed9b7789be0..4faf831727e 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.h +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block.h @@ -58,12 +58,13 @@ public: // earlier. enum class RoundUpPreparedTimestamps { kNoRound, kRound }; - WiredTigerBeginTxnBlock( - WT_SESSION* session, - PrepareConflictBehavior prepareConflictBehavior, - RoundUpPreparedTimestamps roundUpPreparedTimestamps, - RoundUpReadTimestamp roundUpReadTimestamp, - bool allowUntimestampedWrite); + enum class UntimestampedWriteAssertion { kSuppress, kEnforce }; + + WiredTigerBeginTxnBlock(WT_SESSION* session, + PrepareConflictBehavior prepareConflictBehavior, + RoundUpPreparedTimestamps roundUpPreparedTimestamps, + RoundUpReadTimestamp roundUpReadTimestamp, + UntimestampedWriteAssertion allowUntimestampedWrite); WiredTigerBeginTxnBlock(WT_SESSION* session, const char* config); ~WiredTigerBeginTxnBlock(); diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block_bm.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block_bm.cpp index 7033ff3931a..3557b8d29fa 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block_bm.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_begin_transaction_block_bm.cpp @@ -127,13 +127,13 @@ using mongo::WiredTigerBeginTxnBlock; template <PrepareConflictBehavior behavior, RoundUpPreparedTimestamps round> void BM_WiredTigerBeginTxnBlockWithArgs(benchmark::State& state) { WiredTigerTestHelper helper; - const bool allowUntimestampedWrite = false; for (auto _ : state) { - WiredTigerBeginTxnBlock beginTxn(helper.wtSession(), - behavior, - round, - RoundUpReadTimestamp::kNoRoundError, - allowUntimestampedWrite); + WiredTigerBeginTxnBlock beginTxn( + helper.wtSession(), + behavior, + round, + RoundUpReadTimestamp::kNoRoundError, + WiredTigerBeginTxnBlock::UntimestampedWriteAssertion::kEnforce); } } diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp index 5714609a722..df275526c30 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp @@ -162,12 +162,7 @@ StatusWith<std::string> WiredTigerIndex::generateCreateString( ss << "prefix_compression=true,"; } - if ( // TODO (SERVER-60753): Remove special handling for index build during recovery. - collectionNamespace.ns() == "config.system.indexBuilds") { - ss << "write_timestamp_usage=mixed_mode,"; - } else { - ss << "write_timestamp_usage=ordered,"; - } + // Report errors on writes without ordered timestamps. ss << "assert=(write_timestamp=on),"; ss << "verbose=[write_timestamp],"; diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp index 5481f840590..e05ae7ae795 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp @@ -796,20 +796,7 @@ StatusWith<std::string> WiredTigerRecordStore::generateCreateString( ss << "split_pct=90,"; ss << "leaf_value_max=64MB,"; - if (nss.isOplog()) { - // For the above clauses we do not assert any particular `write_timestamp_usage`. In - // particular for the oplog, WT removes all timestamp information. There's nothing in - // MDB's control to assert against. - } else if ( - // Side table drains are not timestamped. - ident.startsWith("internal-") || - // TODO (SERVER-60753): Remove special handling for index build during recovery. This - // includes the following _mdb_catalog ident. - nss == NamespaceString::kIndexBuildEntryNamespace || ident.startsWith("_mdb_catalog")) { - ss << "write_timestamp_usage=mixed_mode,"; - } else { - ss << "write_timestamp_usage=ordered,"; - } + // Report errors on writes without ordered timestamps. ss << "assert=(write_timestamp=on),"; ss << "verbose=[write_timestamp],"; diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp index 4d93dbd3c17..e121856c916 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp @@ -520,7 +520,7 @@ void WiredTigerRecoveryUnit::_txnClose(bool commit) { _isOplogReader = false; _oplogVisibleTs = boost::none; _orderedCommit = true; // Default value is true; we assume all writes are ordered. - _allowUntimestampedWrite = false; + _untimestampedWriteAssertion = WiredTigerBeginTxnBlock::UntimestampedWriteAssertion::kEnforce; } Status WiredTigerRecoveryUnit::majorityCommittedSnapshotAvailable() const { @@ -611,7 +611,7 @@ void WiredTigerRecoveryUnit::_txnOpen() { _prepareConflictBehavior, _roundUpPreparedTimestamps, RoundUpReadTimestamp::kNoRoundError, - _allowUntimestampedWrite) + _untimestampedWriteAssertion) .done(); break; } @@ -620,7 +620,7 @@ void WiredTigerRecoveryUnit::_txnOpen() { session, _prepareConflictBehavior, _roundUpPreparedTimestamps, - _allowUntimestampedWrite); + _untimestampedWriteAssertion); break; } case ReadSource::kLastApplied: { @@ -643,7 +643,7 @@ void WiredTigerRecoveryUnit::_txnOpen() { _prepareConflictBehavior, _roundUpPreparedTimestamps, RoundUpReadTimestamp::kNoRoundError, - _allowUntimestampedWrite); + _untimestampedWriteAssertion); auto status = txnOpen.setReadSnapshot(_readAtTimestamp); if (!status.isOK() && status.code() == ErrorCodes::BadValue) { @@ -672,7 +672,7 @@ Timestamp WiredTigerRecoveryUnit::_beginTransactionAtAllDurableTimestamp(WT_SESS _prepareConflictBehavior, _roundUpPreparedTimestamps, RoundUpReadTimestamp::kRound, - _allowUntimestampedWrite); + _untimestampedWriteAssertion); Timestamp txnTimestamp = _sessionCache->getKVEngine()->getAllDurableTimestamp(); auto status = txnOpen.setReadSnapshot(txnTimestamp); fassert(50948, status); @@ -700,7 +700,7 @@ void WiredTigerRecoveryUnit::_beginTransactionAtLastAppliedTimestamp(WT_SESSION* _prepareConflictBehavior, _roundUpPreparedTimestamps, RoundUpReadTimestamp::kNoRoundError, - _allowUntimestampedWrite); + _untimestampedWriteAssertion); LOGV2_DEBUG(4847500, 2, "no read timestamp available for kLastApplied"); txnOpen.done(); return; @@ -710,7 +710,7 @@ void WiredTigerRecoveryUnit::_beginTransactionAtLastAppliedTimestamp(WT_SESSION* _prepareConflictBehavior, _roundUpPreparedTimestamps, RoundUpReadTimestamp::kRound, - _allowUntimestampedWrite); + _untimestampedWriteAssertion); auto status = txnOpen.setReadSnapshot(_readAtTimestamp); fassert(4847501, status); @@ -766,7 +766,7 @@ Timestamp WiredTigerRecoveryUnit::_beginTransactionAtNoOverlapTimestamp(WT_SESSI _prepareConflictBehavior, _roundUpPreparedTimestamps, RoundUpReadTimestamp::kNoRoundError, - _allowUntimestampedWrite); + _untimestampedWriteAssertion); LOGV2_DEBUG(4452900, 1, "no read timestamp available for kNoOverlap"); txnOpen.done(); return readTimestamp; @@ -776,7 +776,7 @@ Timestamp WiredTigerRecoveryUnit::_beginTransactionAtNoOverlapTimestamp(WT_SESSI _prepareConflictBehavior, _roundUpPreparedTimestamps, RoundUpReadTimestamp::kRound, - _allowUntimestampedWrite); + _untimestampedWriteAssertion); auto status = txnOpen.setReadSnapshot(readTimestamp); fassert(51066, status); diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h index c16a6ce9b29..5397b91fb91 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h @@ -150,7 +150,8 @@ public: void allowUntimestampedWrite() override { invariant(!_isActive()); - _allowUntimestampedWrite = true; + _untimestampedWriteAssertion = + WiredTigerBeginTxnBlock::UntimestampedWriteAssertion::kSuppress; } void setTimestampReadSource(ReadSource source, @@ -316,7 +317,8 @@ private: boost::optional<Timestamp> _lastTimestampSet; Timestamp _readAtTimestamp; Timestamp _catalogConflictTimestamp; - bool _allowUntimestampedWrite = false; + WiredTigerBeginTxnBlock::UntimestampedWriteAssertion _untimestampedWriteAssertion = + WiredTigerBeginTxnBlock::UntimestampedWriteAssertion::kEnforce; std::unique_ptr<Timer> _timer; bool _isOplogReader = false; boost::optional<int64_t> _oplogVisibleTs = boost::none; diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_snapshot_manager.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_snapshot_manager.cpp index 2e093d59ea1..819e19992ca 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_snapshot_manager.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_snapshot_manager.cpp @@ -84,7 +84,7 @@ Timestamp WiredTigerSnapshotManager::beginTransactionOnCommittedSnapshot( WT_SESSION* session, PrepareConflictBehavior prepareConflictBehavior, RoundUpPreparedTimestamps roundUpPreparedTimestamps, - bool allowUntimestampedWrite) const { + WiredTigerBeginTxnBlock::UntimestampedWriteAssertion untimestampedWriteAssertion) const { auto committedSnapshot = [this]() { stdx::lock_guard<Latch> lock(_committedSnapshotMutex); @@ -104,7 +104,7 @@ Timestamp WiredTigerSnapshotManager::beginTransactionOnCommittedSnapshot( prepareConflictBehavior, roundUpPreparedTimestamps, RoundUpReadTimestamp::kRound, - allowUntimestampedWrite); + untimestampedWriteAssertion); auto status = txnOpen.setReadSnapshot(committedSnapshot); fassert(30635, status); diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_snapshot_manager.h b/src/mongo/db/storage/wiredtiger/wiredtiger_snapshot_manager.h index 088bf7a50f9..b3cf9b4d030 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_snapshot_manager.h +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_snapshot_manager.h @@ -68,7 +68,7 @@ public: WT_SESSION* session, PrepareConflictBehavior prepareConflictBehavior, RoundUpPreparedTimestamps roundUpPreparedTimestamps, - bool allowUntimestampedWrite) const; + WiredTigerBeginTxnBlock::UntimestampedWriteAssertion untimestampedWriteAssertion) const; /** * Returns lowest SnapshotName that could possibly be used by a future call to |