From 2808aa41736d241000f81f1f7147a72a4fbd47c5 Mon Sep 17 00:00:00 2001 From: "A. Jesse Jiryu Davis" Date: Thu, 21 Nov 2019 19:43:57 +0000 Subject: SERVER-43000 Remove typedefs for vectors of OplogEntry --- src/mongo/db/repl/apply_ops.cpp | 6 ++-- src/mongo/db/repl/apply_ops.h | 4 +-- .../repl/data_replicator_external_state_mock.cpp | 5 +-- .../db/repl/data_replicator_external_state_mock.h | 2 +- src/mongo/db/repl/initial_syncer.cpp | 7 ++-- src/mongo/db/repl/initial_syncer.h | 2 +- src/mongo/db/repl/initial_syncer_test.cpp | 2 +- src/mongo/db/repl/insert_group.cpp | 4 +-- src/mongo/db/repl/insert_group.h | 6 ++-- src/mongo/db/repl/multiapplier.cpp | 2 +- src/mongo/db/repl/multiapplier.h | 13 ++----- src/mongo/db/repl/multiapplier_test.cpp | 32 ++++++++--------- src/mongo/db/repl/oplog_applier.cpp | 7 ++-- src/mongo/db/repl/oplog_applier.h | 21 ++++++----- src/mongo/db/repl/oplog_applier_impl.cpp | 31 ++++++++-------- src/mongo/db/repl/oplog_applier_impl.h | 21 ++++++----- src/mongo/db/repl/oplog_applier_impl_test.cpp | 42 +++++++++++----------- .../db/repl/oplog_applier_impl_test_fixture.cpp | 2 +- src/mongo/db/repl/oplog_applier_test.cpp | 33 ++++++++--------- src/mongo/db/repl/oplog_entry_or_grouped_inserts.h | 7 ++-- src/mongo/db/repl/replication_recovery.cpp | 6 ++-- .../db/repl/transaction_oplog_application.cpp | 6 ++-- src/mongo/db/repl/transaction_oplog_application.h | 2 +- src/mongo/dbtests/storage_timestamp_tests.cpp | 8 ++--- 24 files changed, 132 insertions(+), 139 deletions(-) diff --git a/src/mongo/db/repl/apply_ops.cpp b/src/mongo/db/repl/apply_ops.cpp index fdc1d412f6d..8ab2dffb19b 100644 --- a/src/mongo/db/repl/apply_ops.cpp +++ b/src/mongo/db/repl/apply_ops.cpp @@ -494,8 +494,8 @@ Status applyOps(OperationContext* opCtx, } // static -MultiApplier::Operations ApplyOps::extractOperations(const OplogEntry& applyOpsOplogEntry) { - MultiApplier::Operations result; +std::vector ApplyOps::extractOperations(const OplogEntry& applyOpsOplogEntry) { + std::vector result; extractOperationsTo(applyOpsOplogEntry, applyOpsOplogEntry.toBSON(), &result); return result; } @@ -503,7 +503,7 @@ MultiApplier::Operations ApplyOps::extractOperations(const OplogEntry& applyOpsO // static void ApplyOps::extractOperationsTo(const OplogEntry& applyOpsOplogEntry, const BSONObj& topLevelDoc, - MultiApplier::Operations* operations) { + std::vector* operations) { uassert(ErrorCodes::TypeMismatch, str::stream() << "ApplyOps::extractOperations(): not a command: " << redact(applyOpsOplogEntry.toBSON()), diff --git a/src/mongo/db/repl/apply_ops.h b/src/mongo/db/repl/apply_ops.h index 7489c94a486..470692d8dfb 100644 --- a/src/mongo/db/repl/apply_ops.h +++ b/src/mongo/db/repl/apply_ops.h @@ -50,7 +50,7 @@ public: * Extracts CRUD operations from an atomic applyOps oplog entry. * Throws UserException on error. */ - static MultiApplier::Operations extractOperations(const OplogEntry& applyOpsOplogEntry); + static std::vector extractOperations(const OplogEntry& applyOpsOplogEntry); /** * This variant allows optimization for extracting multiple applyOps operations. The entry for @@ -60,7 +60,7 @@ public: */ static void extractOperationsTo(const OplogEntry& applyOpsOplogEntry, const BSONObj& topLevelDoc, - MultiApplier::Operations* operations); + std::vector* operations); }; /** diff --git a/src/mongo/db/repl/data_replicator_external_state_mock.cpp b/src/mongo/db/repl/data_replicator_external_state_mock.cpp index 68bf2798e06..10b4ae6fd3d 100644 --- a/src/mongo/db/repl/data_replicator_external_state_mock.cpp +++ b/src/mongo/db/repl/data_replicator_external_state_mock.cpp @@ -58,7 +58,8 @@ public: private: void _run(OplogBuffer* oplogBuffer) final {} - StatusWith _applyOplogBatch(OperationContext* opCtx, Operations ops) final { + StatusWith _applyOplogBatch(OperationContext* opCtx, + std::vector ops) final { return _externalState->applyOplogBatchFn(opCtx, ops, _observer); } @@ -70,7 +71,7 @@ private: DataReplicatorExternalStateMock::DataReplicatorExternalStateMock() : applyOplogBatchFn([](OperationContext*, - const MultiApplier::Operations& ops, + const std::vector& ops, OplogApplier::Observer*) { return ops.back().getOpTime(); }) {} executor::TaskExecutor* DataReplicatorExternalStateMock::getTaskExecutor() const { diff --git a/src/mongo/db/repl/data_replicator_external_state_mock.h b/src/mongo/db/repl/data_replicator_external_state_mock.h index 76aee22e70a..7aee165ce85 100644 --- a/src/mongo/db/repl/data_replicator_external_state_mock.h +++ b/src/mongo/db/repl/data_replicator_external_state_mock.h @@ -89,7 +89,7 @@ public: // Override to change applyOplogBatch behavior. using ApplyOplogBatchFn = std::function( - OperationContext*, MultiApplier::Operations, OplogApplier::Observer*)>; + OperationContext*, std::vector, OplogApplier::Observer*)>; ApplyOplogBatchFn applyOplogBatchFn; StatusWith replSetConfigResult = ReplSetConfig(); diff --git a/src/mongo/db/repl/initial_syncer.cpp b/src/mongo/db/repl/initial_syncer.cpp index bd8bdbbbf7e..363358dbe29 100644 --- a/src/mongo/db/repl/initial_syncer.cpp +++ b/src/mongo/db/repl/initial_syncer.cpp @@ -122,7 +122,6 @@ using namespace executor; using CallbackArgs = executor::TaskExecutor::CallbackArgs; using Event = executor::TaskExecutor::EventHandle; using Handle = executor::TaskExecutor::CallbackHandle; -using Operations = MultiApplier::Operations; using QueryResponseStatus = StatusWith; using UniqueLock = stdx::unique_lock; using LockGuard = stdx::lock_guard; @@ -1240,7 +1239,7 @@ void InitialSyncer::_getNextApplierBatchCallback( if (!ops.empty()) { _fetchCount.store(0); MultiApplier::MultiApplyFn applyBatchOfOperationsFn = [this](OperationContext* opCtx, - MultiApplier::Operations ops) { + std::vector ops) { return _oplogApplier->applyOplogBatch(opCtx, std::move(ops)); }; OpTime lastApplied = ops.back().getOpTime(); @@ -1688,12 +1687,12 @@ void InitialSyncer::_shutdownComponent_inlock(Component& component) { component->shutdown(); } -StatusWith InitialSyncer::_getNextApplierBatch_inlock() { +StatusWith> InitialSyncer::_getNextApplierBatch_inlock() { // If the fail-point is active, delay the apply batch by returning an empty batch so that // _getNextApplierBatchCallback() will reschedule itself at a later time. // See InitialSyncerOptions::getApplierBatchCallbackRetryWait. if (MONGO_unlikely(rsSyncApplyStop.shouldFail())) { - return Operations(); + return std::vector(); } // Obtain next batch of operations from OplogApplier. diff --git a/src/mongo/db/repl/initial_syncer.h b/src/mongo/db/repl/initial_syncer.h index 59d95acc506..6d3b1293b8d 100644 --- a/src/mongo/db/repl/initial_syncer.h +++ b/src/mongo/db/repl/initial_syncer.h @@ -527,7 +527,7 @@ private: void _appendInitialSyncProgressMinimal_inlock(BSONObjBuilder* bob) const; BSONObj _getInitialSyncProgress_inlock() const; - StatusWith _getNextApplierBatch_inlock(); + StatusWith> _getNextApplierBatch_inlock(); /** * Schedules a fetcher to get the last oplog entry from the sync source. diff --git a/src/mongo/db/repl/initial_syncer_test.cpp b/src/mongo/db/repl/initial_syncer_test.cpp index c1ee51b42b2..bc64db24df7 100644 --- a/src/mongo/db/repl/initial_syncer_test.cpp +++ b/src/mongo/db/repl/initial_syncer_test.cpp @@ -3712,7 +3712,7 @@ TEST_F(InitialSyncerTest, InitialSyncerPassesThroughMultiApplierCallbackError) { auto opCtx = makeOpCtx(); getExternalState()->applyOplogBatchFn = - [](OperationContext*, const MultiApplier::Operations&, OplogApplier::Observer*) { + [](OperationContext*, const std::vector&, OplogApplier::Observer*) { return Status(ErrorCodes::OperationFailed, "applyOplogBatch failed"); }; _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345)); diff --git a/src/mongo/db/repl/insert_group.cpp b/src/mongo/db/repl/insert_group.cpp index 4c4f1c2e513..24acf95b0d2 100644 --- a/src/mongo/db/repl/insert_group.cpp +++ b/src/mongo/db/repl/insert_group.cpp @@ -56,7 +56,7 @@ constexpr auto kInsertGroupMaxOpCount = 64; } // namespace -InsertGroup::InsertGroup(MultiApplier::OperationPtrs* ops, +InsertGroup::InsertGroup(std::vector* ops, OperationContext* opCtx, InsertGroup::Mode mode) : _doNotGroupBeforePoint(ops->cbegin()), _end(ops->cend()), _opCtx(opCtx), _mode(mode) {} @@ -86,7 +86,7 @@ StatusWith InsertGroup::groupAndApplyInserts(ConstIt // Make sure to include the first op in the group size. size_t groupSize = entry.getObject().objsize(); - auto opCount = MultiApplier::OperationPtrs::size_type(1); + auto opCount = std::vector::size_type(1); auto groupNamespace = entry.getNss(); /** diff --git a/src/mongo/db/repl/insert_group.h b/src/mongo/db/repl/insert_group.h index adc48753767..43b1b058c3f 100644 --- a/src/mongo/db/repl/insert_group.h +++ b/src/mongo/db/repl/insert_group.h @@ -40,7 +40,7 @@ namespace repl { /** * Groups consecutive insert operations on the same namespace and applies the combined operation * as a single oplog entry. - * Advances the the MultiApplier::OperationPtrs iterator if the grouped insert is applied + * Advances the the std::vector iterator if the grouped insert is applied * successfully. */ class InsertGroup { @@ -48,10 +48,10 @@ class InsertGroup { InsertGroup& operator=(const InsertGroup&) = delete; public: - using ConstIterator = MultiApplier::OperationPtrs::const_iterator; + using ConstIterator = std::vector::const_iterator; using Mode = OplogApplication::Mode; - InsertGroup(MultiApplier::OperationPtrs* ops, OperationContext* opCtx, Mode mode); + InsertGroup(std::vector* ops, OperationContext* opCtx, Mode mode); /** * Attempts to group insert operations starting at 'iter'. diff --git a/src/mongo/db/repl/multiapplier.cpp b/src/mongo/db/repl/multiapplier.cpp index 02c993a0e67..e4c9a20079f 100644 --- a/src/mongo/db/repl/multiapplier.cpp +++ b/src/mongo/db/repl/multiapplier.cpp @@ -42,7 +42,7 @@ namespace mongo { namespace repl { MultiApplier::MultiApplier(executor::TaskExecutor* executor, - const Operations& operations, + const std::vector& operations, const MultiApplyFn& multiApply, CallbackFn onCompletion) : _executor(executor), diff --git a/src/mongo/db/repl/multiapplier.h b/src/mongo/db/repl/multiapplier.h index 22023e6eafc..bd77a7a8ba8 100644 --- a/src/mongo/db/repl/multiapplier.h +++ b/src/mongo/db/repl/multiapplier.h @@ -56,20 +56,13 @@ class MultiApplier { MultiApplier& operator=(const MultiApplier&) = delete; public: - /** - * Operations sorted by timestamp in ascending order. - */ - using Operations = std::vector; - - using OperationPtrs = std::vector; - /** * Callback function to report final status of applying operations. */ using CallbackFn = unique_function; using MultiApplyFn = - std::function(OperationContext*, MultiApplier::Operations)>; + std::function(OperationContext*, std::vector)>; /** * Creates MultiApplier in inactive state. @@ -85,7 +78,7 @@ public: * contained in 'operations' are not validated. */ MultiApplier(executor::TaskExecutor* executor, - const Operations& operations, + const std::vector& operations, const MultiApplyFn& multiApply, CallbackFn onCompletion); @@ -144,7 +137,7 @@ private: // Not owned by us. executor::TaskExecutor* _executor; - Operations _operations; + std::vector _operations; MultiApplyFn _multiApply; CallbackFn _onCompletion; diff --git a/src/mongo/db/repl/multiapplier_test.cpp b/src/mongo/db/repl/multiapplier_test.cpp index 663f85db19e..a48decf298c 100644 --- a/src/mongo/db/repl/multiapplier_test.cpp +++ b/src/mongo/db/repl/multiapplier_test.cpp @@ -85,8 +85,8 @@ OplogEntry makeOplogEntry(int ts) { } TEST_F(MultiApplierTest, InvalidConstruction) { - const MultiApplier::Operations operations{makeOplogEntry(123)}; - auto multiApply = [](OperationContext*, MultiApplier::Operations) -> StatusWith { + const std::vector operations{makeOplogEntry(123)}; + auto multiApply = [](OperationContext*, std::vector) -> StatusWith { return Status(ErrorCodes::InternalError, "not implemented"); }; auto callback = [](const Status&) {}; @@ -99,7 +99,7 @@ TEST_F(MultiApplierTest, InvalidConstruction) { // Empty list of operations. ASSERT_THROWS_CODE_AND_WHAT( - MultiApplier(&getExecutor(), MultiApplier::Operations(), multiApply, callback), + MultiApplier(&getExecutor(), std::vector(), multiApply, callback), AssertionException, ErrorCodes::BadValue, "empty list of operations"); @@ -120,9 +120,9 @@ TEST_F(MultiApplierTest, InvalidConstruction) { } TEST_F(MultiApplierTest, MultiApplierTransitionsDirectlyToCompleteIfShutdownBeforeStarting) { - const MultiApplier::Operations operations{makeOplogEntry(123)}; + const std::vector operations{makeOplogEntry(123)}; - auto multiApply = [](OperationContext*, MultiApplier::Operations) -> StatusWith { + auto multiApply = [](OperationContext*, std::vector) -> StatusWith { return OpTime(); }; auto callback = [](const Status&) {}; @@ -135,11 +135,11 @@ TEST_F(MultiApplierTest, MultiApplierTransitionsDirectlyToCompleteIfShutdownBefo } TEST_F(MultiApplierTest, MultiApplierInvokesCallbackWithCallbackCanceledStatusUponCancellation) { - const MultiApplier::Operations operations{makeOplogEntry(123)}; + const std::vector operations{makeOplogEntry(123)}; bool multiApplyInvoked = false; auto multiApply = [&](OperationContext* opCtx, - MultiApplier::Operations operations) -> StatusWith { + std::vector operations) -> StatusWith { multiApplyInvoked = true; return operations.back().getOpTime(); }; @@ -171,11 +171,11 @@ TEST_F(MultiApplierTest, MultiApplierInvokesCallbackWithCallbackCanceledStatusUp } TEST_F(MultiApplierTest, MultiApplierPassesMultiApplyErrorToCallback) { - const MultiApplier::Operations operations{makeOplogEntry(123)}; + const std::vector operations{makeOplogEntry(123)}; bool multiApplyInvoked = false; Status multiApplyError(ErrorCodes::OperationFailed, "multi apply failed"); - auto multiApply = [&](OperationContext*, MultiApplier::Operations) -> StatusWith { + auto multiApply = [&](OperationContext*, std::vector) -> StatusWith { multiApplyInvoked = true; return multiApplyError; }; @@ -198,12 +198,12 @@ TEST_F(MultiApplierTest, MultiApplierPassesMultiApplyErrorToCallback) { } TEST_F(MultiApplierTest, MultiApplierCatchesMultiApplyExceptionAndConvertsToCallbackStatus) { - const MultiApplier::Operations operations{makeOplogEntry(123)}; + const std::vector operations{makeOplogEntry(123)}; bool multiApplyInvoked = false; Status multiApplyError(ErrorCodes::OperationFailed, "multi apply failed"); auto multiApply = [&](OperationContext* opCtx, - MultiApplier::Operations operations) -> StatusWith { + std::vector operations) -> StatusWith { multiApplyInvoked = true; uassertStatusOK(multiApplyError); return operations.back().getOpTime(); @@ -229,12 +229,12 @@ TEST_F(MultiApplierTest, MultiApplierCatchesMultiApplyExceptionAndConvertsToCall TEST_F( MultiApplierTest, MultiApplierProvidesOperationContextToMultiApplyFunctionButDisposesBeforeInvokingFinishCallback) { - const MultiApplier::Operations operations{makeOplogEntry(123)}; + const std::vector operations{makeOplogEntry(123)}; OperationContext* multiApplyTxn = nullptr; - MultiApplier::Operations operationsToApply; + std::vector operationsToApply; auto multiApply = [&](OperationContext* opCtx, - MultiApplier::Operations operations) -> StatusWith { + std::vector operations) -> StatusWith { multiApplyTxn = opCtx; operationsToApply = operations; return operationsToApply.back().getOpTime(); @@ -283,10 +283,10 @@ TEST_F(MultiApplierTest, MultiApplierResetsOnCompletionCallbackFunctionPointerUp bool sharedCallbackStateDestroyed = false; auto sharedCallbackData = std::make_shared(&sharedCallbackStateDestroyed); - const MultiApplier::Operations operations{makeOplogEntry(123)}; + const std::vector operations{makeOplogEntry(123)}; auto multiApply = [&](OperationContext*, - MultiApplier::Operations operations) -> StatusWith { + std::vector operations) -> StatusWith { return operations.back().getOpTime(); }; diff --git a/src/mongo/db/repl/oplog_applier.cpp b/src/mongo/db/repl/oplog_applier.cpp index 91936537985..8872664b0c1 100644 --- a/src/mongo/db/repl/oplog_applier.cpp +++ b/src/mongo/db/repl/oplog_applier.cpp @@ -96,8 +96,8 @@ void OplogApplier::waitForSpace(OperationContext* opCtx, std::size_t size) { * Pushes operations read from sync source into oplog buffer. */ void OplogApplier::enqueue(OperationContext* opCtx, - Operations::const_iterator begin, - Operations::const_iterator end) { + std::vector::const_iterator begin, + std::vector::const_iterator end) { OplogBuffer::Batch batch; for (auto i = begin; i != end; ++i) { batch.push_back(i->getRaw()); @@ -115,7 +115,8 @@ void OplogApplier::enqueue(OperationContext* opCtx, _oplogBuffer->push(opCtx, begin, end); } -StatusWith OplogApplier::applyOplogBatch(OperationContext* opCtx, Operations ops) { +StatusWith OplogApplier::applyOplogBatch(OperationContext* opCtx, + std::vector ops) { _observer->onBatchBegin(ops); auto lastApplied = _applyOplogBatch(opCtx, std::move(ops)); _observer->onBatchEnd(lastApplied, {}); diff --git a/src/mongo/db/repl/oplog_applier.h b/src/mongo/db/repl/oplog_applier.h index 474b66adf30..301757d2f4b 100644 --- a/src/mongo/db/repl/oplog_applier.h +++ b/src/mongo/db/repl/oplog_applier.h @@ -84,8 +84,6 @@ public: // Used to report oplog application progress. class Observer; - using Operations = std::vector; - /** * OpQueueBatcher is an implementation detail that should be abstracted from all levels above * the OplogApplier. Parts of the system that need to modify BatchLimits can do so through the @@ -134,13 +132,13 @@ public: /** * Pushes operations read into oplog buffer. - * Accepts both Operations (OplogEntry) and OplogBuffer::Batch (BSONObj) iterators. + * Accepts both std::vector and OplogBuffer::Batch (BSONObj) iterators. * This supports current implementations of OplogFetcher and OplogBuffer which work in terms of * BSONObj. */ void enqueue(OperationContext* opCtx, - Operations::const_iterator begin, - Operations::const_iterator end); + std::vector::const_iterator begin, + std::vector::const_iterator end); void enqueue(OperationContext* opCtx, OplogBuffer::Batch::const_iterator begin, OplogBuffer::Batch::const_iterator end); @@ -158,7 +156,7 @@ public: * * TODO: remove when enqueue() is implemented. */ - StatusWith applyOplogBatch(OperationContext* opCtx, Operations ops); + StatusWith applyOplogBatch(OperationContext* opCtx, std::vector ops); /** * Calls the OpQueueBatcher's getNextApplierBatch. @@ -180,7 +178,8 @@ private: * Called from applyOplogBatch() to apply a batch of operations in parallel. * Implemented in subclasses but not visible otherwise. */ - virtual StatusWith _applyOplogBatch(OperationContext* opCtx, Operations ops) = 0; + virtual StatusWith _applyOplogBatch(OperationContext* opCtx, + std::vector ops) = 0; // Used to schedule task for oplog application loop. // Not owned by us. @@ -217,7 +216,7 @@ public: * Called when the OplogApplier is ready to start applying a batch of operations read from the * OplogBuffer. **/ - virtual void onBatchBegin(const OplogApplier::Operations& operations) = 0; + virtual void onBatchBegin(const std::vector& operations) = 0; /** * When the OplogApplier has completed applying a batch of operations, it will call this @@ -225,13 +224,13 @@ public: * will also be here. */ virtual void onBatchEnd(const StatusWith& lastOpTimeApplied, - const OplogApplier::Operations& operations) = 0; + const std::vector& operations) = 0; }; class NoopOplogApplierObserver : public repl::OplogApplier::Observer { public: - void onBatchBegin(const repl::OplogApplier::Operations&) final {} - void onBatchEnd(const StatusWith&, const repl::OplogApplier::Operations&) final {} + void onBatchBegin(const std::vector&) final {} + void onBatchEnd(const StatusWith&, const std::vector&) final {} }; extern NoopOplogApplierObserver noopOplogApplierObserver; diff --git a/src/mongo/db/repl/oplog_applier_impl.cpp b/src/mongo/db/repl/oplog_applier_impl.cpp index 36e32743193..611a9215f3b 100644 --- a/src/mongo/db/repl/oplog_applier_impl.cpp +++ b/src/mongo/db/repl/oplog_applier_impl.cpp @@ -209,7 +209,7 @@ void processCrudOp(OperationContext* opCtx, * Adds a single oplog entry to the appropriate writer vector. */ void addToWriterVector(OplogEntry* op, - std::vector* writerVectors, + std::vector>* writerVectors, uint32_t hash) { const uint32_t numWriters = writerVectors->size(); auto& writer = (*writerVectors)[hash % numWriters]; @@ -223,8 +223,8 @@ void addToWriterVector(OplogEntry* op, * Adds a set of derivedOps to writerVectors. */ void addDerivedOps(OperationContext* opCtx, - MultiApplier::Operations* derivedOps, - std::vector* writerVectors, + std::vector* derivedOps, + std::vector>* writerVectors, CachedCollectionProperties* collPropertiesCache) { for (auto&& op : *derivedOps) { auto hashedNs = StringMapHasher().hashed_key(op.getNss().ns()); @@ -236,7 +236,7 @@ void addDerivedOps(OperationContext* opCtx, } } -void stableSortByNamespace(MultiApplier::OperationPtrs* oplogEntryPointers) { +void stableSortByNamespace(std::vector* oplogEntryPointers) { auto nssComparator = [](const OplogEntry* l, const OplogEntry* r) { return l->getNss() < r->getNss(); }; @@ -491,7 +491,7 @@ void OplogApplierImpl::_run(OplogBuffer* oplogBuffer) { void scheduleWritesToOplog(OperationContext* opCtx, StorageInterface* storageInterface, ThreadPool* writerPool, - const MultiApplier::Operations& ops) { + const std::vector& ops) { auto makeOplogWriterForRange = [storageInterface, &ops](size_t begin, size_t end) { // The returned function will be run in a separate thread after this returns. Therefore all // captures other than 'ops' must be by value since they will not be available. The caller @@ -554,7 +554,7 @@ void scheduleWritesToOplog(OperationContext* opCtx, } StatusWith OplogApplierImpl::_applyOplogBatch(OperationContext* opCtx, - MultiApplier::Operations ops) { + std::vector ops) { invariant(!ops.empty()); LOG(2) << "replication batch size is " << ops.size(); @@ -595,9 +595,10 @@ StatusWith OplogApplierImpl::_applyOplogBatch(OperationContext* opCtx, // - ops to update config.transactions. Normal writes to config.transactions in the // primary don't create an oplog entry, so extract info from writes with transactions // and create a pseudo oplog. - std::vector derivedOps; + std::vector> derivedOps; - std::vector writerVectors(_writerPool->getStats().numThreads); + std::vector> writerVectors( + _writerPool->getStats().numThreads); fillWriterVectors(opCtx, &ops, &writerVectors, &derivedOps); // Wait for writes to finish before applying ops. @@ -724,9 +725,9 @@ StatusWith OplogApplierImpl::_applyOplogBatch(OperationContext* opCtx, */ void OplogApplierImpl::_deriveOpsAndFillWriterVectors( OperationContext* opCtx, - MultiApplier::Operations* ops, - std::vector* writerVectors, - std::vector* derivedOps, + std::vector* ops, + std::vector>* writerVectors, + std::vector>* derivedOps, SessionUpdateTracker* sessionUpdateTracker) noexcept { LogicalSessionIdMap> partialTxnOps; @@ -827,9 +828,9 @@ void OplogApplierImpl::_deriveOpsAndFillWriterVectors( void OplogApplierImpl::fillWriterVectors( OperationContext* opCtx, - MultiApplier::Operations* ops, - std::vector* writerVectors, - std::vector* derivedOps) noexcept { + std::vector* ops, + std::vector>* writerVectors, + std::vector>* derivedOps) noexcept { SessionUpdateTracker sessionUpdateTracker; _deriveOpsAndFillWriterVectors(opCtx, ops, writerVectors, derivedOps, &sessionUpdateTracker); @@ -950,7 +951,7 @@ Status applyOplogEntryOrGroupedInserts(OperationContext* opCtx, } Status OplogApplierImpl::applyOplogBatchPerWorker(OperationContext* opCtx, - MultiApplier::OperationPtrs* ops, + std::vector* ops, WorkerMultikeyPathInfo* workerMultikeyPathInfo) { UnreplicatedWritesBlock uwb(opCtx); DisableDocumentValidation validationDisabler(opCtx); diff --git a/src/mongo/db/repl/oplog_applier_impl.h b/src/mongo/db/repl/oplog_applier_impl.h index 4cc5e717bc3..a43e18dc41f 100644 --- a/src/mongo/db/repl/oplog_applier_impl.h +++ b/src/mongo/db/repl/oplog_applier_impl.h @@ -96,12 +96,12 @@ private: * to at least the last optime of the batch. If 'minValid' is already greater than or equal * to the last optime of this batch, it will not be updated. */ - StatusWith _applyOplogBatch(OperationContext* opCtx, MultiApplier::Operations ops); + StatusWith _applyOplogBatch(OperationContext* opCtx, std::vector ops); void _deriveOpsAndFillWriterVectors(OperationContext* opCtx, - MultiApplier::Operations* ops, - std::vector* writerVectors, - std::vector* derivedOps, + std::vector* ops, + std::vector>* writerVectors, + std::vector>* derivedOps, SessionUpdateTracker* sessionUpdateTracker) noexcept; // Not owned by us. @@ -120,23 +120,22 @@ private: OpTime _beginApplyingOpTime = OpTime(); void fillWriterVectors(OperationContext* opCtx, - MultiApplier::Operations* ops, - std::vector* writerVectors, - std::vector* derivedOps) noexcept; + std::vector* ops, + std::vector>* writerVectors, + std::vector>* derivedOps) noexcept; protected: // Marked as protected for use in unit tests. /** * This function is used by the thread pool workers to write ops to the db. - * This consumes the passed in OperationPtrs and callers should not make any assumptions about - * the state of the container after calling. However, this function cannot modify the pointed-to - * operations because the OperationPtrs container contains const pointers. + * It modifies the passed-in vector, and callers should not make any assumptions about the + * state of the vector after calling. The OplogEntry objects themselves are not modified. * * This function has been marked as virtual to allow certain unit tests to skip oplog * application. */ virtual Status applyOplogBatchPerWorker(OperationContext* opCtx, - MultiApplier::OperationPtrs* ops, + std::vector* ops, WorkerMultikeyPathInfo* workerMultikeyPathInfo); }; diff --git a/src/mongo/db/repl/oplog_applier_impl_test.cpp b/src/mongo/db/repl/oplog_applier_impl_test.cpp index 9338da454d6..29dacb12728 100644 --- a/src/mongo/db/repl/oplog_applier_impl_test.cpp +++ b/src/mongo/db/repl/oplog_applier_impl_test.cpp @@ -298,14 +298,14 @@ public: using OplogApplierImpl::OplogApplierImpl; Status applyOplogBatchPerWorker(OperationContext* opCtx, - MultiApplier::OperationPtrs* ops, + std::vector* ops, WorkerMultikeyPathInfo* workerMultikeyPathInfo) override; - MultiApplier::Operations operationsApplied; + std::vector operationsApplied; }; Status TrackOpsAppliedApplier::applyOplogBatchPerWorker( OperationContext* opCtx, - MultiApplier::OperationPtrs* ops, + std::vector* ops, WorkerMultikeyPathInfo* workerMultikeyPathInfo) { for (auto&& opPtr : *ops) { operationsApplied.push_back(*opPtr); @@ -388,7 +388,7 @@ TEST_F(OplogApplierImplTest, NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName()); auto op = makeCreateCollectionOplogEntry({Timestamp(Seconds(1), 0), 1LL}, nss); - MultiApplier::OperationPtrs ops = {&op}; + std::vector ops = {&op}; WorkerMultikeyPathInfo pathInfo; TestApplyOplogGroupApplier oplogApplier( @@ -1307,7 +1307,7 @@ void testWorkerMultikeyPaths(OperationContext* opCtx, TestApplyOplogGroupApplier oplogApplier( nullptr, nullptr, OplogApplier::Options(OplogApplication::Mode::kSecondary)); WorkerMultikeyPathInfo pathInfo; - MultiApplier::OperationPtrs ops = {&op}; + std::vector ops = {&op}; ASSERT_OK(oplogApplier.applyOplogBatchPerWorker(opCtx, &ops, &pathInfo)); ASSERT_EQ(pathInfo.size(), numPaths); } @@ -1365,7 +1365,7 @@ TEST_F(OplogApplierImplTest, OplogApplicationThreadFuncAddsMultipleWorkerMultike TestApplyOplogGroupApplier oplogApplier( nullptr, nullptr, OplogApplier::Options(OplogApplication::Mode::kSecondary)); WorkerMultikeyPathInfo pathInfo; - MultiApplier::OperationPtrs ops = {&opA, &opB}; + std::vector ops = {&opA, &opB}; ASSERT_OK(oplogApplier.applyOplogBatchPerWorker(_opCtx.get(), &ops, &pathInfo)); ASSERT_EQ(pathInfo.size(), 2UL); } @@ -1410,7 +1410,7 @@ TEST_F(OplogApplierImplTest, OplogApplicationThreadFuncFailsWhenCollectionCreati TestApplyOplogGroupApplier oplogApplier( nullptr, nullptr, OplogApplier::Options(OplogApplication::Mode::kSecondary)); - MultiApplier::OperationPtrs ops = {&op}; + std::vector ops = {&op}; ASSERT_EQUALS(ErrorCodes::InvalidOptions, oplogApplier.applyOplogBatchPerWorker(_opCtx.get(), &ops, nullptr)); } @@ -1527,7 +1527,7 @@ TEST_F(OplogApplierImplTest, docsInserted.push_back(docs); }; - MultiApplier::Operations ops = { + std::vector ops = { createOp1, createOp2, insertOp1a, insertOp2a, insertOp1b, insertOp2b}; ASSERT_OK(runOpsSteadyState(ops)); @@ -1559,11 +1559,11 @@ TEST_F(OplogApplierImplTest, // Generate operations to apply: // {create}, {insert_1}, {insert_2}, .. {insert_(limit)}, {insert_(limit+1)} std::size_t limit = 64; - MultiApplier::Operations insertOps; + std::vector insertOps; for (std::size_t i = 0; i < limit + 1; ++i) { insertOps.push_back(makeOp(nss)); } - MultiApplier::Operations operationsToApply; + std::vector operationsToApply; operationsToApply.push_back(createOp); std::copy(insertOps.begin(), insertOps.end(), std::back_inserter(operationsToApply)); @@ -1614,13 +1614,13 @@ TEST_F(OplogApplierImplTest, int opSize = maxBatchSize / opsPerBatch - 500; // Leave some room for other oplog fields. // Create the insert ops. - MultiApplier::Operations insertOps; + std::vector insertOps; int numOps = 4; for (int i = 0; i < numOps; i++) { insertOps.push_back(makeSizedInsertOp(nss, opSize, seconds++)); } - MultiApplier::Operations operationsToApply; + std::vector operationsToApply; operationsToApply.push_back(createOp); std::copy(insertOps.begin(), insertOps.end(), std::back_inserter(operationsToApply)); @@ -1663,7 +1663,7 @@ TEST_F(OplogApplierImplTest, auto insertOpLarge = makeSizedInsertOp(nss, maxBatchSize, seconds++); auto insertOpSmall = makeSizedInsertOp(nss, 100, seconds++); - MultiApplier::Operations operationsToApply = {createOp, insertOpLarge, insertOpSmall}; + std::vector operationsToApply = {createOp, insertOpLarge, insertOpSmall}; // Each element in 'docsInserted' is a grouped insert operation. std::vector> docsInserted; @@ -1699,9 +1699,9 @@ TEST_F(OplogApplierImplTest, // Create a sequence of 3 'insert' ops that can't be grouped because they are from different // namespaces. - MultiApplier::Operations operationsToApply = {makeOp(NamespaceString(testNs + "_1")), - makeOp(NamespaceString(testNs + "_2")), - makeOp(NamespaceString(testNs + "_3"))}; + std::vector operationsToApply = {makeOp(NamespaceString(testNs + "_1")), + makeOp(NamespaceString(testNs + "_2")), + makeOp(NamespaceString(testNs + "_3"))}; for (const auto& oplogEntry : operationsToApply) { createCollectionWithUuid(_opCtx.get(), oplogEntry.getNss()); @@ -1740,11 +1740,11 @@ TEST_F(OplogApplierImplTest, // Generate operations to apply: // {create}, {insert_1}, {insert_2}, .. {insert_(limit)}, {insert_(limit+1)} std::size_t limit = 64; - MultiApplier::Operations insertOps; + std::vector insertOps; for (std::size_t i = 0; i < limit + 1; ++i) { insertOps.push_back(makeOp(nss)); } - MultiApplier::Operations operationsToApply; + std::vector operationsToApply; operationsToApply.push_back(createOp); std::copy(insertOps.begin(), insertOps.end(), std::back_inserter(operationsToApply)); @@ -1794,7 +1794,7 @@ TEST_F(OplogApplierImplTest, ApplyGroupIgnoresUpdateOperationIfDocumentIsMissing } auto op = makeUpdateDocumentOplogEntry( {Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), BSON("_id" << 0 << "x" << 2)); - MultiApplier::OperationPtrs ops = {&op}; + std::vector ops = {&op}; WorkerMultikeyPathInfo pathInfo; ASSERT_OK(oplogApplier.applyOplogBatchPerWorker(_opCtx.get(), &ops, &pathInfo)); @@ -1817,7 +1817,7 @@ TEST_F(OplogApplierImplTest, auto op1 = makeInsertDocumentOplogEntry({Timestamp(Seconds(2), 0), 1LL}, nss, doc1); auto op2 = makeInsertDocumentOplogEntry({Timestamp(Seconds(3), 0), 1LL}, badNss, doc2); auto op3 = makeInsertDocumentOplogEntry({Timestamp(Seconds(4), 0), 1LL}, nss, doc3); - MultiApplier::OperationPtrs ops = {&op0, &op1, &op2, &op3}; + std::vector ops = {&op0, &op1, &op2, &op3}; WorkerMultikeyPathInfo pathInfo; ASSERT_OK(oplogApplier.applyOplogBatchPerWorker(_opCtx.get(), &ops, &pathInfo)); @@ -1843,7 +1843,7 @@ TEST_F(OplogApplierImplTest, auto op2 = makeCreateIndexOplogEntry( {Timestamp(Seconds(3), 0), 1LL}, badNss, "a_1", keyPattern, kUuid); auto op3 = makeInsertDocumentOplogEntry({Timestamp(Seconds(4), 0), 1LL}, nss, doc3); - MultiApplier::OperationPtrs ops = {&op0, &op1, &op2, &op3}; + std::vector ops = {&op0, &op1, &op2, &op3}; WorkerMultikeyPathInfo pathInfo; ASSERT_OK(oplogApplier.applyOplogBatchPerWorker(_opCtx.get(), &ops, &pathInfo)); 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 7e5c0cb4569..523bb93f1a1 100644 --- a/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp +++ b/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp @@ -208,7 +208,7 @@ Status OplogApplierImplTest::runOpsSteadyState(std::vector ops) { getConsistencyMarkers(), getStorageInterface(), repl::OplogApplier::Options(repl::OplogApplication::Mode::kSecondary)); - MultiApplier::OperationPtrs opsPtrs; + std::vector opsPtrs; for (auto& op : ops) { opsPtrs.push_back(&op); } diff --git a/src/mongo/db/repl/oplog_applier_test.cpp b/src/mongo/db/repl/oplog_applier_test.cpp index 994a2cd02dd..efd8a75a421 100644 --- a/src/mongo/db/repl/oplog_applier_test.cpp +++ b/src/mongo/db/repl/oplog_applier_test.cpp @@ -55,7 +55,7 @@ public: explicit OplogApplierMock(OplogBuffer* oplogBuffer); void _run(OplogBuffer* oplogBuffer) final; - StatusWith _applyOplogBatch(OperationContext* opCtx, Operations ops) final; + StatusWith _applyOplogBatch(OperationContext* opCtx, std::vector ops) final; }; OplogApplierMock::OplogApplierMock(OplogBuffer* oplogBuffer) @@ -66,7 +66,8 @@ OplogApplierMock::OplogApplierMock(OplogBuffer* oplogBuffer) void OplogApplierMock::_run(OplogBuffer* oplogBuffer) {} -StatusWith OplogApplierMock::_applyOplogBatch(OperationContext* opCtx, Operations ops) { +StatusWith OplogApplierMock::_applyOplogBatch(OperationContext* opCtx, + std::vector ops) { return OpTime(); } @@ -185,9 +186,9 @@ OplogEntry makeCommitTransactionOplogEntry(int t, StringData dbName, bool prepar } /** - * Returns string representation of OplogApplier::Operations. + * Returns string representation of std::vector. */ -std::string toString(const OplogApplier::Operations& ops) { +std::string toString(const std::vector& ops) { StringBuilder sb; sb << "["; for (const auto& op : ops) { @@ -200,7 +201,7 @@ std::string toString(const OplogApplier::Operations& ops) { constexpr auto dbName = "test"_sd; TEST_F(OplogApplierTest, GetNextApplierBatchGroupsCrudOps) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "foo"))); srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar"))); _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend()); @@ -212,7 +213,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchGroupsCrudOps) { } TEST_F(OplogApplierTest, GetNextApplierBatchReturnsPreparedApplyOpsOpInOwnBatch) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeApplyOpsOplogEntry(1, true)); srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar"))); _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend()); @@ -223,7 +224,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchReturnsPreparedApplyOpsOpInOwnBatch) } TEST_F(OplogApplierTest, GetNextApplierBatchGroupsUnpreparedApplyOpsOpWithOtherOps) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeApplyOpsOplogEntry(1, false)); srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar"))); _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend()); @@ -235,7 +236,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchGroupsUnpreparedApplyOpsOpWithOtherO } TEST_F(OplogApplierTest, GetNextApplierBatchReturnsSystemDotViewsOpInOwnBatch) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeInsertOplogEntry( 1, NamespaceString(dbName, NamespaceString::kSystemDotViewsCollectionName))); srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar"))); @@ -247,7 +248,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchReturnsSystemDotViewsOpInOwnBatch) { } TEST_F(OplogApplierTest, GetNextApplierBatchReturnsServerConfigurationOpInOwnBatch) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeInsertOplogEntry(1, NamespaceString::kServerConfigurationNamespace)); srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar"))); _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend()); @@ -258,7 +259,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchReturnsServerConfigurationOpInOwnBat } TEST_F(OplogApplierTest, GetNextApplierBatchReturnsPreparedCommitTransactionOpInOwnBatch) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeCommitTransactionOplogEntry(1, dbName, true, 3)); srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar"))); _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend()); @@ -269,7 +270,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchReturnsPreparedCommitTransactionOpIn } TEST_F(OplogApplierTest, GetNextApplierBatchGroupsUnpreparedCommitTransactionOpWithOtherOps) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeCommitTransactionOplogEntry(1, dbName, false, 3)); srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar"))); _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend()); @@ -281,7 +282,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchGroupsUnpreparedCommitTransactionOpW } TEST_F(OplogApplierTest, GetNextApplierBatchChecksBatchLimitsForNumberOfOperations) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "bar"))); srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar"))); srcOps.push_back(makeInsertOplogEntry(3, NamespaceString(dbName, "bar"))); @@ -307,7 +308,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchChecksBatchLimitsForNumberOfOperatio } TEST_F(OplogApplierTest, GetNextApplierBatchChecksBatchLimitsForSizeOfOperations) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "bar"))); srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar"))); srcOps.push_back(makeInsertOplogEntry(3, NamespaceString(dbName, "bar"))); @@ -330,7 +331,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchChecksBatchLimitsForSizeOfOperations TEST_F(OplogApplierTest, GetNextApplierBatchChecksBatchLimitsUsingEmbededCountInUnpreparedCommitTransactionOp1) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "bar"))); srcOps.push_back(makeCommitTransactionOplogEntry(2, dbName, false, 3)); srcOps.push_back(makeInsertOplogEntry(3, NamespaceString(dbName, "bar"))); @@ -353,7 +354,7 @@ TEST_F(OplogApplierTest, TEST_F(OplogApplierTest, GetNextApplierBatchChecksBatchLimitsUsingEmbededCountInUnpreparedCommitTransactionOp2) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "bar"))); srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar"))); srcOps.push_back(makeCommitTransactionOplogEntry(3, dbName, false, 3)); @@ -379,7 +380,7 @@ TEST_F(OplogApplierTest, TEST_F(OplogApplierTest, GetNextApplierBatchChecksBatchLimitsUsingEmbededCountInUnpreparedCommitTransactionOp3) { - OplogApplier::Operations srcOps; + std::vector srcOps; srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "bar"))); srcOps.push_back(makeCommitTransactionOplogEntry(2, dbName, false, 5)); srcOps.push_back(makeInsertOplogEntry(3, NamespaceString(dbName, "bar"))); diff --git a/src/mongo/db/repl/oplog_entry_or_grouped_inserts.h b/src/mongo/db/repl/oplog_entry_or_grouped_inserts.h index d09a7f74f69..8b86fbd473f 100644 --- a/src/mongo/db/repl/oplog_entry_or_grouped_inserts.h +++ b/src/mongo/db/repl/oplog_entry_or_grouped_inserts.h @@ -41,8 +41,7 @@ namespace repl { */ class OplogEntryOrGroupedInserts { public: - using OperationPtrs = std::vector; - using ConstIterator = OperationPtrs::const_iterator; + using ConstIterator = std::vector::const_iterator; OplogEntryOrGroupedInserts() = delete; @@ -71,7 +70,7 @@ public: return _entryOrGroupedInserts.size() > 1; } - const OperationPtrs& getGroupedInserts() const { + const std::vector& getGroupedInserts() const { invariant(isGroupedInserts()); return _entryOrGroupedInserts; } @@ -81,7 +80,7 @@ public: private: // A single oplog entry or a batch of grouped insert oplog entries to be applied. - OperationPtrs _entryOrGroupedInserts; + std::vector _entryOrGroupedInserts; }; } // namespace repl } // namespace mongo diff --git a/src/mongo/db/repl/replication_recovery.cpp b/src/mongo/db/repl/replication_recovery.cpp index 7c48135808b..5be259ad537 100644 --- a/src/mongo/db/repl/replication_recovery.cpp +++ b/src/mongo/db/repl/replication_recovery.cpp @@ -65,7 +65,7 @@ const auto kRecoveryOperationLogLevel = logger::LogSeverity::Debug(3); */ class RecoveryOplogApplierStats : public OplogApplier::Observer { public: - void onBatchBegin(const OplogApplier::Operations& batch) final { + void onBatchBegin(const std::vector& batch) final { _numBatches++; LOG_FOR_RECOVERY(kRecoveryBatchLogLevel) << "Applying operations in batch: " << _numBatches << "(" << batch.size() @@ -86,7 +86,7 @@ public: } } - void onBatchEnd(const StatusWith&, const OplogApplier::Operations&) final {} + void onBatchEnd(const StatusWith&, const std::vector&) final {} void complete(const OpTime& applyThroughOpTime) const { log() << "Applied " << _numOpsApplied << " operations in " << _numBatches @@ -371,7 +371,7 @@ void ReplicationRecoveryImpl::_applyToEndOfOplog(OperationContext* opCtx, batchLimits.ops = getBatchLimitOplogEntries(); OpTime applyThroughOpTime; - OplogApplier::Operations batch; + std::vector batch; while ( !(batch = fassert(50763, oplogApplier.getNextApplierBatch(opCtx, batchLimits))).empty()) { applyThroughOpTime = uassertStatusOK(oplogApplier.applyOplogBatch(opCtx, std::move(batch))); diff --git a/src/mongo/db/repl/transaction_oplog_application.cpp b/src/mongo/db/repl/transaction_oplog_application.cpp index 4d887c90e27..71b344f7ac5 100644 --- a/src/mongo/db/repl/transaction_oplog_application.cpp +++ b/src/mongo/db/repl/transaction_oplog_application.cpp @@ -59,7 +59,7 @@ MONGO_FAIL_POINT_DEFINE(skipReconstructPreparedTransactions); // Apply the oplog entries for a prepare or a prepared commit during recovery/initial sync. Status _applyOperationsForTransaction(OperationContext* opCtx, - const repl::MultiApplier::Operations& ops, + const std::vector& ops, repl::OplogApplication::Mode oplogApplicationMode) { // Apply each the operations via repl::applyOperation. for (const auto& op : ops) { @@ -228,14 +228,14 @@ Status applyAbortTransaction(OperationContext* opCtx, MONGO_UNREACHABLE; } -repl::MultiApplier::Operations readTransactionOperationsFromOplogChain( +std::vector readTransactionOperationsFromOplogChain( OperationContext* opCtx, const OplogEntry& lastEntryInTxn, const std::vector& cachedOps) noexcept { // Traverse the oplog chain with its own snapshot and read timestamp. ReadSourceScope readSourceScope(opCtx); - repl::MultiApplier::Operations ops; + std::vector ops; // 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 diff --git a/src/mongo/db/repl/transaction_oplog_application.h b/src/mongo/db/repl/transaction_oplog_application.h index ad85ccca6fa..add871d6dac 100644 --- a/src/mongo/db/repl/transaction_oplog_application.h +++ b/src/mongo/db/repl/transaction_oplog_application.h @@ -60,7 +60,7 @@ const repl::OplogEntry getPreviousOplogEntry(OperationContext* opCtx, * Follow an oplog chain and copy the operations to destination. Operations will be copied in * forward oplog order (increasing optimes). */ -repl::MultiApplier::Operations readTransactionOperationsFromOplogChain( +std::vector readTransactionOperationsFromOplogChain( OperationContext* opCtx, const repl::OplogEntry& entry, const std::vector& cachedOps) noexcept; diff --git a/src/mongo/dbtests/storage_timestamp_tests.cpp b/src/mongo/dbtests/storage_timestamp_tests.cpp index 1c35aa31f09..8670b784130 100644 --- a/src/mongo/dbtests/storage_timestamp_tests.cpp +++ b/src/mongo/dbtests/storage_timestamp_tests.cpp @@ -145,8 +145,8 @@ BSONCollectionCatalogEntry::IndexMetaData getIndexMetaData( class DoNothingOplogApplierObserver : public repl::OplogApplier::Observer { public: - void onBatchBegin(const repl::OplogApplier::Operations&) final {} - void onBatchEnd(const StatusWith&, const repl::OplogApplier::Operations&) final {} + void onBatchBegin(const std::vector&) final {} + void onBatchEnd(const StatusWith&, const std::vector&) final {} }; class StorageTimestampTest { @@ -2513,7 +2513,7 @@ public: _taskFuture(taskFuture) {} Status applyOplogBatchPerWorker(OperationContext* opCtx, - repl::MultiApplier::OperationPtrs* operationsToApply, + std::vector* operationsToApply, WorkerMultikeyPathInfo* pathInfo) override; private: @@ -2530,7 +2530,7 @@ private: // and this test case fails without crashing the entire suite. Status SecondaryReadsDuringBatchApplicationAreAllowedApplier::applyOplogBatchPerWorker( OperationContext* opCtx, - repl::MultiApplier::OperationPtrs* operationsToApply, + std::vector* operationsToApply, WorkerMultikeyPathInfo* pathInfo) { if (!_testOpCtx->lockState()->isLockHeldForMode(resourceIdParallelBatchWriterMode, MODE_X)) { return {ErrorCodes::BadValue, "Batch applied was not holding PBWM lock in MODE_X"}; -- cgit v1.2.1