summaryrefslogtreecommitdiff
path: root/src/mongo/db/repl
diff options
context:
space:
mode:
authorMaria van Keulen <maria@mongodb.com>2017-03-07 12:00:08 -0500
committerMaria van Keulen <maria@mongodb.com>2017-03-07 12:00:08 -0500
commit589a5c169ced8f6e9ddcd3d182ae1b75db6b7d79 (patch)
treec7a090ffdd56a91ae677e2492c61b820af44f964 /src/mongo/db/repl
parent3cba97198638df3750e3b455e2ad57af7ee536ae (diff)
downloadmongo-589a5c169ced8f6e9ddcd3d182ae1b75db6b7d79.tar.gz
SERVER-27938 Rename all OperationContext variables to opCtx
This commit is an automated rename of all whole word instances of txn, _txn, and txnPtr to opCtx, _opCtx, and opCtxPtr, respectively in all .cpp and .h files in src/mongo.
Diffstat (limited to 'src/mongo/db/repl')
-rw-r--r--src/mongo/db/repl/bgsync.cpp79
-rw-r--r--src/mongo/db/repl/bgsync.h22
-rw-r--r--src/mongo/db/repl/collection_bulk_loader_impl.cpp50
-rw-r--r--src/mongo/db/repl/collection_bulk_loader_impl.h4
-rw-r--r--src/mongo/db/repl/collection_cloner.cpp11
-rw-r--r--src/mongo/db/repl/collection_cloner_test.cpp20
-rw-r--r--src/mongo/db/repl/data_replicator.cpp50
-rw-r--r--src/mongo/db/repl/data_replicator.h6
-rw-r--r--src/mongo/db/repl/data_replicator_external_state.h6
-rw-r--r--src/mongo/db/repl/data_replicator_external_state_impl.cpp12
-rw-r--r--src/mongo/db/repl/data_replicator_external_state_impl.h6
-rw-r--r--src/mongo/db/repl/data_replicator_external_state_mock.cpp8
-rw-r--r--src/mongo/db/repl/data_replicator_external_state_mock.h6
-rw-r--r--src/mongo/db/repl/data_replicator_test.cpp311
-rw-r--r--src/mongo/db/repl/database_task.cpp38
-rw-r--r--src/mongo/db/repl/database_task_test.cpp28
-rw-r--r--src/mongo/db/repl/databases_cloner.cpp12
-rw-r--r--src/mongo/db/repl/databases_cloner_test.cpp16
-rw-r--r--src/mongo/db/repl/initial_sync.cpp14
-rw-r--r--src/mongo/db/repl/initial_sync.h4
-rw-r--r--src/mongo/db/repl/master_slave.cpp274
-rw-r--r--src/mongo/db/repl/master_slave.h34
-rw-r--r--src/mongo/db/repl/multiapplier.cpp4
-rw-r--r--src/mongo/db/repl/multiapplier_test.cpp8
-rw-r--r--src/mongo/db/repl/noop_writer.cpp27
-rw-r--r--src/mongo/db/repl/oplog.cpp268
-rw-r--r--src/mongo/db/repl/oplog.h22
-rw-r--r--src/mongo/db/repl/oplog_buffer.h20
-rw-r--r--src/mongo/db/repl/oplog_buffer_blocking_queue.cpp4
-rw-r--r--src/mongo/db/repl/oplog_buffer_blocking_queue.h20
-rw-r--r--src/mongo/db/repl/oplog_buffer_collection.cpp56
-rw-r--r--src/mongo/db/repl/oplog_buffer_collection.h28
-rw-r--r--src/mongo/db/repl/oplog_buffer_collection_test.cpp360
-rw-r--r--src/mongo/db/repl/oplog_buffer_proxy.cpp38
-rw-r--r--src/mongo/db/repl/oplog_buffer_proxy.h20
-rw-r--r--src/mongo/db/repl/oplog_buffer_proxy_test.cpp106
-rw-r--r--src/mongo/db/repl/oplog_interface_local.cpp25
-rw-r--r--src/mongo/db/repl/oplog_interface_local.h4
-rw-r--r--src/mongo/db/repl/oplogreader.cpp2
-rw-r--r--src/mongo/db/repl/oplogreader.h2
-rw-r--r--src/mongo/db/repl/repl_client_info.cpp7
-rw-r--r--src/mongo/db/repl/repl_client_info.h2
-rw-r--r--src/mongo/db/repl/repl_set_commands.cpp62
-rw-r--r--src/mongo/db/repl/repl_set_request_votes.cpp6
-rw-r--r--src/mongo/db/repl/repl_set_web_handler.cpp6
-rw-r--r--src/mongo/db/repl/replication_coordinator.h57
-rw-r--r--src/mongo/db/repl/replication_coordinator_external_state.h51
-rw-r--r--src/mongo/db/repl/replication_coordinator_external_state_impl.cpp257
-rw-r--r--src/mongo/db/repl/replication_coordinator_external_state_impl.h56
-rw-r--r--src/mongo/db/repl/replication_coordinator_external_state_mock.cpp37
-rw-r--r--src/mongo/db/repl/replication_coordinator_external_state_mock.h44
-rw-r--r--src/mongo/db/repl/replication_coordinator_impl.cpp205
-rw-r--r--src/mongo/db/repl/replication_coordinator_impl.h59
-rw-r--r--src/mongo/db/repl/replication_coordinator_impl_elect_test.cpp34
-rw-r--r--src/mongo/db/repl/replication_coordinator_impl_elect_v1.cpp4
-rw-r--r--src/mongo/db/repl/replication_coordinator_impl_elect_v1_test.cpp112
-rw-r--r--src/mongo/db/repl/replication_coordinator_impl_heartbeat.cpp8
-rw-r--r--src/mongo/db/repl/replication_coordinator_impl_heartbeat_test.cpp8
-rw-r--r--src/mongo/db/repl/replication_coordinator_impl_heartbeat_v1_test.cpp12
-rw-r--r--src/mongo/db/repl/replication_coordinator_impl_reconfig_test.cpp81
-rw-r--r--src/mongo/db/repl/replication_coordinator_impl_test.cpp468
-rw-r--r--src/mongo/db/repl/replication_coordinator_mock.cpp56
-rw-r--r--src/mongo/db/repl/replication_coordinator_mock.h48
-rw-r--r--src/mongo/db/repl/replication_coordinator_test_fixture.cpp20
-rw-r--r--src/mongo/db/repl/replication_coordinator_test_fixture.h2
-rw-r--r--src/mongo/db/repl/replication_executor.cpp12
-rw-r--r--src/mongo/db/repl/replication_executor.h4
-rw-r--r--src/mongo/db/repl/replication_executor_test.cpp24
-rw-r--r--src/mongo/db/repl/replication_info.cpp36
-rw-r--r--src/mongo/db/repl/resync.cpp18
-rw-r--r--src/mongo/db/repl/rollback_source.h2
-rw-r--r--src/mongo/db/repl/rollback_source_impl.cpp4
-rw-r--r--src/mongo/db/repl/rollback_source_impl.h3
-rw-r--r--src/mongo/db/repl/rs_initialsync.cpp92
-rw-r--r--src/mongo/db/repl/rs_initialsync.h4
-rw-r--r--src/mongo/db/repl/rs_rollback.cpp120
-rw-r--r--src/mongo/db/repl/rs_rollback.h4
-rw-r--r--src/mongo/db/repl/rs_rollback_test.cpp231
-rw-r--r--src/mongo/db/repl/storage_interface.cpp4
-rw-r--r--src/mongo/db/repl/storage_interface.h42
-rw-r--r--src/mongo/db/repl/storage_interface_impl.cpp196
-rw-r--r--src/mongo/db/repl/storage_interface_impl.h45
-rw-r--r--src/mongo/db/repl/storage_interface_impl_test.cpp501
-rw-r--r--src/mongo/db/repl/storage_interface_mock.cpp20
-rw-r--r--src/mongo/db/repl/storage_interface_mock.h95
-rw-r--r--src/mongo/db/repl/sync_source_feedback.cpp31
-rw-r--r--src/mongo/db/repl/sync_tail.cpp211
-rw-r--r--src/mongo/db/repl/sync_tail.h28
-rw-r--r--src/mongo/db/repl/sync_tail_test.cpp273
-rw-r--r--src/mongo/db/repl/task_runner.cpp22
-rw-r--r--src/mongo/db/repl/task_runner.h2
-rw-r--r--src/mongo/db/repl/task_runner_test.cpp22
92 files changed, 2914 insertions, 2859 deletions
diff --git a/src/mongo/db/repl/bgsync.cpp b/src/mongo/db/repl/bgsync.cpp
index a0f646f6078..186903d0924 100644
--- a/src/mongo/db/repl/bgsync.cpp
+++ b/src/mongo/db/repl/bgsync.cpp
@@ -140,20 +140,20 @@ BackgroundSync::BackgroundSync(
bufferMaxSizeGauge.increment(_oplogBuffer->getMaxSize() - bufferMaxSizeGauge.get());
}
-void BackgroundSync::startup(OperationContext* txn) {
- _oplogBuffer->startup(txn);
+void BackgroundSync::startup(OperationContext* opCtx) {
+ _oplogBuffer->startup(opCtx);
invariant(!_producerThread);
_producerThread.reset(new stdx::thread(stdx::bind(&BackgroundSync::_run, this)));
}
-void BackgroundSync::shutdown(OperationContext* txn) {
+void BackgroundSync::shutdown(OperationContext* opCtx) {
stdx::lock_guard<stdx::mutex> lock(_mutex);
// Clear the buffer. This unblocks the OplogFetcher if it is blocked with a full queue, but
// ensures that it won't add anything. It will also unblock the OpApplier pipeline if it is
// waiting for an operation to be past the slaveDelay point.
- clearBuffer(txn);
+ clearBuffer(opCtx);
_state = ProducerState::Stopped;
if (_syncSourceResolver) {
@@ -167,9 +167,9 @@ void BackgroundSync::shutdown(OperationContext* txn) {
_inShutdown = true;
}
-void BackgroundSync::join(OperationContext* txn) {
+void BackgroundSync::join(OperationContext* opCtx) {
_producerThread->join();
- _oplogBuffer->shutdown(txn);
+ _oplogBuffer->shutdown(opCtx);
}
bool BackgroundSync::inShutdown() const {
@@ -225,15 +225,15 @@ void BackgroundSync::_runProducer() {
}
// we want to start when we're no longer primary
// start() also loads _lastOpTimeFetched, which we know is set from the "if"
- auto txn = cc().makeOperationContext();
+ auto opCtx = cc().makeOperationContext();
if (getState() == ProducerState::Starting) {
- start(txn.get());
+ start(opCtx.get());
}
- _produce(txn.get());
+ _produce(opCtx.get());
}
-void BackgroundSync::_produce(OperationContext* txn) {
+void BackgroundSync::_produce(OperationContext* opCtx) {
if (MONGO_FAIL_POINT(stopReplProducer)) {
// This log output is used in js tests so please leave it.
log() << "bgsync - stopReplProducer fail point "
@@ -271,7 +271,7 @@ void BackgroundSync::_produce(OperationContext* txn) {
HostAndPort source;
SyncSourceResolverResponse syncSourceResp;
{
- const OpTime minValidSaved = StorageInterface::get(txn)->getMinValid(txn);
+ const OpTime minValidSaved = StorageInterface::get(opCtx)->getMinValid(opCtx);
stdx::lock_guard<stdx::mutex> lock(_mutex);
const auto requiredOpTime = (minValidSaved > _lastOpTimeFetched) ? minValidSaved : OpTime();
@@ -358,8 +358,9 @@ void BackgroundSync::_produce(OperationContext* txn) {
// Set the applied point if unset. This is most likely the first time we've established a sync
// source since stepping down or otherwise clearing the applied point. We need to set this here,
// before the OplogWriter gets a chance to append to the oplog.
- if (StorageInterface::get(txn)->getAppliedThrough(txn).isNull()) {
- StorageInterface::get(txn)->setAppliedThrough(txn, _replCoord->getMyLastAppliedOpTime());
+ if (StorageInterface::get(opCtx)->getAppliedThrough(opCtx).isNull()) {
+ StorageInterface::get(opCtx)->setAppliedThrough(opCtx,
+ _replCoord->getMyLastAppliedOpTime());
}
// "lastFetched" not used. Already set in _enqueueDocuments.
@@ -472,7 +473,7 @@ void BackgroundSync::_produce(OperationContext* txn) {
}
}
- _rollback(txn, source, syncSourceResp.rbid, getConnection);
+ _rollback(opCtx, source, syncSourceResp.rbid, getConnection);
// Reset the producer to clear the sync source and the last optime fetched.
stop(true);
startProducerIfStopped();
@@ -540,10 +541,10 @@ Status BackgroundSync::_enqueueDocuments(Fetcher::Documents::const_iterator begi
return Status::OK(); // Nothing to do.
}
- auto txn = cc().makeOperationContext();
+ auto opCtx = cc().makeOperationContext();
// Wait for enough space.
- _oplogBuffer->waitForSpace(txn.get(), info.toApplyDocumentBytes);
+ _oplogBuffer->waitForSpace(opCtx.get(), info.toApplyDocumentBytes);
{
// Don't add more to the buffer if we are in shutdown. Continue holding the lock until we
@@ -560,7 +561,7 @@ Status BackgroundSync::_enqueueDocuments(Fetcher::Documents::const_iterator begi
}
// Buffer docs for later application.
- _oplogBuffer->pushAllNonBlocking(txn.get(), begin, end);
+ _oplogBuffer->pushAllNonBlocking(opCtx.get(), begin, end);
// Update last fetched info.
_lastFetchedHash = info.lastDocument.value;
@@ -585,8 +586,8 @@ Status BackgroundSync::_enqueueDocuments(Fetcher::Documents::const_iterator begi
return Status::OK();
}
-bool BackgroundSync::peek(OperationContext* txn, BSONObj* op) {
- return _oplogBuffer->peek(txn, op);
+bool BackgroundSync::peek(OperationContext* opCtx, BSONObj* op) {
+ return _oplogBuffer->peek(opCtx, op);
}
void BackgroundSync::waitForMore() {
@@ -594,11 +595,11 @@ void BackgroundSync::waitForMore() {
_oplogBuffer->waitForData(Seconds(1));
}
-void BackgroundSync::consume(OperationContext* txn) {
+void BackgroundSync::consume(OperationContext* opCtx) {
// this is just to get the op off the queue, it's been peeked at
// and queued for application already
BSONObj op;
- if (_oplogBuffer->tryPop(txn, &op)) {
+ if (_oplogBuffer->tryPop(opCtx, &op)) {
bufferCountGauge.decrement(1);
bufferSizeGauge.decrement(getSize(op));
} else {
@@ -609,7 +610,7 @@ void BackgroundSync::consume(OperationContext* txn) {
}
}
-void BackgroundSync::_rollback(OperationContext* txn,
+void BackgroundSync::_rollback(OperationContext* opCtx,
const HostAndPort& source,
boost::optional<int> requiredRBID,
stdx::function<DBClientBase*()> getConnection) {
@@ -635,7 +636,7 @@ void BackgroundSync::_rollback(OperationContext* txn,
// then.
{
log() << "rollback 0";
- Lock::GlobalWrite globalWrite(txn->lockState());
+ Lock::GlobalWrite globalWrite(opCtx->lockState());
if (!_replCoord->setFollowerMode(MemberState::RS_ROLLBACK)) {
log() << "Cannot transition from " << _replCoord->getMemberState().toString() << " to "
<< MemberState(MemberState::RS_ROLLBACK).toString();
@@ -644,8 +645,8 @@ void BackgroundSync::_rollback(OperationContext* txn,
}
try {
- auto status = syncRollback(txn,
- OplogInterfaceLocal(txn, rsOplogName),
+ auto status = syncRollback(opCtx,
+ OplogInterfaceLocal(opCtx, rsOplogName),
RollbackSourceImpl(getConnection, source, rsOplogName),
requiredRBID,
_replCoord);
@@ -668,7 +669,7 @@ void BackgroundSync::_rollback(OperationContext* txn,
warning() << "rollback cannot complete at this time (retrying later): " << redact(ex)
<< " appliedThrough=" << _replCoord->getMyLastAppliedOpTime()
- << " minvalid=" << StorageInterface::get(txn)->getMinValid(txn);
+ << " minvalid=" << StorageInterface::get(opCtx)->getMinValid(opCtx);
// Sleep a bit to allow upstream node to coalesce, if that was the cause of the failure. If
// we failed in a way that will keep failing, but wasn't flagged as a fatal failure, this
@@ -684,12 +685,12 @@ void BackgroundSync::_rollback(OperationContext* txn,
// so that if we wind up shutting down uncleanly in response to something we rolled back
// we know that we won't wind up right back in the same situation when we start back up
// because the rollback wasn't durable.
- txn->recoveryUnit()->waitUntilDurable();
+ opCtx->recoveryUnit()->waitUntilDurable();
// If we detected that we rolled back the shardIdentity document as part of this rollback
// then we must shut down to clear the in-memory ShardingState associated with the
// shardIdentity document.
- if (ShardIdentityRollbackNotifier::get(txn)->didRollbackHappen()) {
+ if (ShardIdentityRollbackNotifier::get(opCtx)->didRollbackHappen()) {
severe() << "shardIdentity document rollback detected. Shutting down to clear "
"in-memory sharding state. Restarting this process should safely return it "
"to a healthy state";
@@ -734,10 +735,10 @@ void BackgroundSync::stop(bool resetLastFetchedOptime) {
}
}
-void BackgroundSync::start(OperationContext* txn) {
+void BackgroundSync::start(OperationContext* opCtx) {
OpTimeWithHash lastAppliedOpTimeWithHash;
do {
- lastAppliedOpTimeWithHash = _readLastAppliedOpTimeWithHash(txn);
+ lastAppliedOpTimeWithHash = _readLastAppliedOpTimeWithHash(opCtx);
stdx::lock_guard<stdx::mutex> lk(_mutex);
// Double check the state after acquiring the mutex.
if (_state != ProducerState::Starting) {
@@ -762,28 +763,28 @@ void BackgroundSync::start(OperationContext* txn) {
LOG(1) << "bgsync fetch queue set to: " << _lastOpTimeFetched << " " << _lastFetchedHash;
}
-void BackgroundSync::clearBuffer(OperationContext* txn) {
- _oplogBuffer->clear(txn);
+void BackgroundSync::clearBuffer(OperationContext* opCtx) {
+ _oplogBuffer->clear(opCtx);
const auto count = bufferCountGauge.get();
bufferCountGauge.decrement(count);
const auto size = bufferSizeGauge.get();
bufferSizeGauge.decrement(size);
}
-OpTimeWithHash BackgroundSync::_readLastAppliedOpTimeWithHash(OperationContext* txn) {
+OpTimeWithHash BackgroundSync::_readLastAppliedOpTimeWithHash(OperationContext* opCtx) {
BSONObj oplogEntry;
try {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock lk(txn->lockState(), "local", MODE_X);
- bool success = Helpers::getLast(txn, rsOplogName.c_str(), oplogEntry);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock lk(opCtx->lockState(), "local", MODE_X);
+ bool success = Helpers::getLast(opCtx, rsOplogName.c_str(), oplogEntry);
if (!success) {
// This can happen when we are to do an initial sync. lastHash will be set
// after the initial sync is complete.
return OpTimeWithHash(0);
}
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "readLastAppliedHash", rsOplogName);
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "readLastAppliedHash", rsOplogName);
} catch (const DBException& ex) {
severe() << "Problem reading " << rsOplogName << ": " << redact(ex);
fassertFailed(18904);
@@ -817,8 +818,8 @@ bool BackgroundSync::shouldStopFetching() const {
return false;
}
-void BackgroundSync::pushTestOpToBuffer(OperationContext* txn, const BSONObj& op) {
- _oplogBuffer->push(txn, op);
+void BackgroundSync::pushTestOpToBuffer(OperationContext* opCtx, const BSONObj& op) {
+ _oplogBuffer->push(opCtx, op);
bufferCountGauge.increment();
bufferSizeGauge.increment(op.objsize());
}
diff --git a/src/mongo/db/repl/bgsync.h b/src/mongo/db/repl/bgsync.h
index 479caabaee8..85069066cdd 100644
--- a/src/mongo/db/repl/bgsync.h
+++ b/src/mongo/db/repl/bgsync.h
@@ -84,17 +84,17 @@ public:
/**
* Starts oplog buffer, task executor and producer thread, in that order.
*/
- void startup(OperationContext* txn);
+ void startup(OperationContext* opCtx);
/**
* Signals producer thread to stop.
*/
- void shutdown(OperationContext* txn);
+ void shutdown(OperationContext* opCtx);
/**
* Waits for producer thread to stop before shutting down the task executor and oplog buffer.
*/
- void join(OperationContext* txn);
+ void join(OperationContext* opCtx);
/**
* Returns true if shutdown() has been called.
@@ -109,8 +109,8 @@ public:
// Interface implementation
- bool peek(OperationContext* txn, BSONObj* op);
- void consume(OperationContext* txn);
+ bool peek(OperationContext* opCtx, BSONObj* op);
+ void consume(OperationContext* opCtx);
void clearSyncTarget();
void waitForMore();
@@ -118,7 +118,7 @@ public:
BSONObj getCounters();
// Clears any fetched and buffered oplog entries.
- void clearBuffer(OperationContext* txn);
+ void clearBuffer(OperationContext* opCtx);
/**
* Returns true if any of the following is true:
@@ -134,7 +134,7 @@ public:
void startProducerIfStopped();
// Adds a fake oplog entry to buffer. Used for testing only.
- void pushTestOpToBuffer(OperationContext* txn, const BSONObj& op);
+ void pushTestOpToBuffer(OperationContext* opCtx, const BSONObj& op);
private:
bool _inShutdown_inlock() const;
@@ -148,7 +148,7 @@ private:
void _run();
// Production thread inner loop.
void _runProducer();
- void _produce(OperationContext* txn);
+ void _produce(OperationContext* opCtx);
/**
* Checks current background sync state before pushing operations into blocking queue and
@@ -165,15 +165,15 @@ private:
* Executes a rollback.
* 'getConnection' returns a connection to the sync source.
*/
- void _rollback(OperationContext* txn,
+ void _rollback(OperationContext* opCtx,
const HostAndPort& source,
boost::optional<int> requiredRBID,
stdx::function<DBClientBase*()> getConnection);
// restart syncing
- void start(OperationContext* txn);
+ void start(OperationContext* opCtx);
- OpTimeWithHash _readLastAppliedOpTimeWithHash(OperationContext* txn);
+ OpTimeWithHash _readLastAppliedOpTimeWithHash(OperationContext* opCtx);
// Production thread
std::unique_ptr<OplogBuffer> _oplogBuffer;
diff --git a/src/mongo/db/repl/collection_bulk_loader_impl.cpp b/src/mongo/db/repl/collection_bulk_loader_impl.cpp
index ffc6b176032..9b1c96ec95b 100644
--- a/src/mongo/db/repl/collection_bulk_loader_impl.cpp
+++ b/src/mongo/db/repl/collection_bulk_loader_impl.cpp
@@ -51,7 +51,7 @@
namespace mongo {
namespace repl {
-CollectionBulkLoaderImpl::CollectionBulkLoaderImpl(OperationContext* txn,
+CollectionBulkLoaderImpl::CollectionBulkLoaderImpl(OperationContext* opCtx,
Collection* coll,
const BSONObj idIndexSpec,
std::unique_ptr<OldThreadPool> threadPool,
@@ -62,13 +62,13 @@ CollectionBulkLoaderImpl::CollectionBulkLoaderImpl(OperationContext* txn,
_runner(std::move(runner)),
_autoColl(std::move(autoColl)),
_autoDB(std::move(autoDb)),
- _txn(txn),
+ _opCtx(opCtx),
_coll(coll),
_nss{coll->ns()},
- _idIndexBlock(stdx::make_unique<MultiIndexBlock>(txn, coll)),
- _secondaryIndexesBlock(stdx::make_unique<MultiIndexBlock>(txn, coll)),
+ _idIndexBlock(stdx::make_unique<MultiIndexBlock>(opCtx, coll)),
+ _secondaryIndexesBlock(stdx::make_unique<MultiIndexBlock>(opCtx, coll)),
_idIndexSpec(idIndexSpec) {
- invariant(txn);
+ invariant(opCtx);
invariant(coll);
invariant(_runner);
invariant(_autoDB);
@@ -89,10 +89,10 @@ CollectionBulkLoaderImpl::~CollectionBulkLoaderImpl() {
Status CollectionBulkLoaderImpl::init(Collection* coll,
const std::vector<BSONObj>& secondaryIndexSpecs) {
return _runTaskReleaseResourcesOnFailure(
- [coll, &secondaryIndexSpecs, this](OperationContext* txn) -> Status {
- invariant(txn);
+ [coll, &secondaryIndexSpecs, this](OperationContext* opCtx) -> Status {
+ invariant(opCtx);
invariant(coll);
- invariant(txn->getClient() == &cc());
+ invariant(opCtx->getClient() == &cc());
std::vector<BSONObj> specs(secondaryIndexSpecs);
// This enforces the buildIndexes setting in the replica set configuration.
_secondaryIndexesBlock->removeExistingIndexes(&specs);
@@ -122,8 +122,8 @@ Status CollectionBulkLoaderImpl::insertDocuments(const std::vector<BSONObj>::con
const std::vector<BSONObj>::const_iterator end) {
int count = 0;
return _runTaskReleaseResourcesOnFailure(
- [begin, end, &count, this](OperationContext* txn) -> Status {
- invariant(txn);
+ [begin, end, &count, this](OperationContext* opCtx) -> Status {
+ invariant(opCtx);
for (auto iter = begin; iter != end; ++iter) {
std::vector<MultiIndexBlock*> indexers;
@@ -134,15 +134,15 @@ Status CollectionBulkLoaderImpl::insertDocuments(const std::vector<BSONObj>::con
indexers.push_back(_secondaryIndexesBlock.get());
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- WriteUnitOfWork wunit(txn);
- const auto status = _coll->insertDocument(txn, *iter, indexers, false);
+ WriteUnitOfWork wunit(opCtx);
+ const auto status = _coll->insertDocument(opCtx, *iter, indexers, false);
if (!status.isOK()) {
return status;
}
wunit.commit();
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
- _txn, "CollectionBulkLoaderImpl::insertDocuments", _nss.ns());
+ _opCtx, "CollectionBulkLoaderImpl::insertDocuments", _nss.ns());
++count;
}
@@ -152,11 +152,11 @@ Status CollectionBulkLoaderImpl::insertDocuments(const std::vector<BSONObj>::con
Status CollectionBulkLoaderImpl::commit() {
return _runTaskReleaseResourcesOnFailure(
- [this](OperationContext* txn) -> Status {
+ [this](OperationContext* opCtx) -> Status {
_stats.startBuildingIndexes = Date_t::now();
LOG(2) << "Creating indexes for ns: " << _nss.ns();
- invariant(txn->getClient() == &cc());
- invariant(txn == _txn);
+ invariant(opCtx->getClient() == &cc());
+ invariant(opCtx == _opCtx);
// Commit before deleting dups, so the dups will be removed from secondary indexes when
// deleted.
@@ -173,12 +173,12 @@ Status CollectionBulkLoaderImpl::commit() {
"MultiIndexBlock::ignoreUniqueConstraint set."};
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- WriteUnitOfWork wunit(txn);
+ WriteUnitOfWork wunit(opCtx);
_secondaryIndexesBlock->commit();
wunit.commit();
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
- _txn, "CollectionBulkLoaderImpl::commit", _nss.ns());
+ _opCtx, "CollectionBulkLoaderImpl::commit", _nss.ns());
}
if (_idIndexBlock) {
@@ -192,8 +192,8 @@ Status CollectionBulkLoaderImpl::commit() {
for (auto&& it : dups) {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- WriteUnitOfWork wunit(_txn);
- _coll->deleteDocument(_txn,
+ WriteUnitOfWork wunit(_opCtx);
+ _coll->deleteDocument(_opCtx,
it,
nullptr /** OpDebug **/,
false /* fromMigrate */,
@@ -201,17 +201,17 @@ Status CollectionBulkLoaderImpl::commit() {
wunit.commit();
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
- _txn, "CollectionBulkLoaderImpl::commit", _nss.ns());
+ _opCtx, "CollectionBulkLoaderImpl::commit", _nss.ns());
}
// Commit _id index, without dups.
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- WriteUnitOfWork wunit(txn);
+ WriteUnitOfWork wunit(opCtx);
_idIndexBlock->commit();
wunit.commit();
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
- _txn, "CollectionBulkLoaderImpl::commit", _nss.ns());
+ _opCtx, "CollectionBulkLoaderImpl::commit", _nss.ns());
}
_stats.endBuildingIndexes = Date_t::now();
LOG(2) << "Done creating indexes for ns: " << _nss.ns()
@@ -244,9 +244,9 @@ void CollectionBulkLoaderImpl::_releaseResources() {
Status CollectionBulkLoaderImpl::_runTaskReleaseResourcesOnFailure(
TaskRunner::SynchronousTask task, TaskRunner::NextAction nextAction) {
- auto newTask = [this, &task](OperationContext* txn) -> Status {
+ auto newTask = [this, &task](OperationContext* opCtx) -> Status {
ScopeGuard guard = MakeGuard(&CollectionBulkLoaderImpl::_releaseResources, this);
- const auto status = task(txn);
+ const auto status = task(opCtx);
if (status.isOK()) {
guard.Dismiss();
}
diff --git a/src/mongo/db/repl/collection_bulk_loader_impl.h b/src/mongo/db/repl/collection_bulk_loader_impl.h
index 61928e4c385..17b4741ec8f 100644
--- a/src/mongo/db/repl/collection_bulk_loader_impl.h
+++ b/src/mongo/db/repl/collection_bulk_loader_impl.h
@@ -61,7 +61,7 @@ public:
BSONObj toBSON() const;
};
- CollectionBulkLoaderImpl(OperationContext* txn,
+ CollectionBulkLoaderImpl(OperationContext* opCtx,
Collection* coll,
const BSONObj idIndexSpec,
std::unique_ptr<OldThreadPool> threadPool,
@@ -91,7 +91,7 @@ private:
std::unique_ptr<TaskRunner> _runner;
std::unique_ptr<AutoGetCollection> _autoColl;
std::unique_ptr<AutoGetOrCreateDb> _autoDB;
- OperationContext* _txn = nullptr;
+ OperationContext* _opCtx = nullptr;
Collection* _coll = nullptr;
NamespaceString _nss;
std::unique_ptr<MultiIndexBlock> _idIndexBlock;
diff --git a/src/mongo/db/repl/collection_cloner.cpp b/src/mongo/db/repl/collection_cloner.cpp
index ac1b34c1528..85c9f39169d 100644
--- a/src/mongo/db/repl/collection_cloner.cpp
+++ b/src/mongo/db/repl/collection_cloner.cpp
@@ -119,9 +119,9 @@ CollectionCloner::CollectionCloner(executor::TaskExecutor* executor,
_documents(),
_dbWorkTaskRunner(_dbWorkThreadPool),
_scheduleDbWorkFn([this](const executor::TaskExecutor::CallbackFn& work) {
- auto task = [work](OperationContext* txn,
+ auto task = [work](OperationContext* opCtx,
const Status& status) -> TaskRunner::NextAction {
- work(executor::TaskExecutor::CallbackArgs(nullptr, {}, status, txn));
+ work(executor::TaskExecutor::CallbackArgs(nullptr, {}, status, opCtx));
return TaskRunner::NextAction::kDisposeOperationContext;
};
_dbWorkTaskRunner.schedule(task);
@@ -337,9 +337,10 @@ void CollectionCloner::_listIndexesCallback(const Fetcher::QueryResponseStatus&
_finishCallback(cbd.status);
return;
}
- auto txn = cbd.txn;
- txn->setReplicatedWrites(false);
- auto&& createStatus = _storageInterface->createCollection(txn, _destNss, _options);
+ auto opCtx = cbd.opCtx;
+ opCtx->setReplicatedWrites(false);
+ auto&& createStatus =
+ _storageInterface->createCollection(opCtx, _destNss, _options);
_finishCallback(createStatus);
});
if (!scheduleResult.isOK()) {
diff --git a/src/mongo/db/repl/collection_cloner_test.cpp b/src/mongo/db/repl/collection_cloner_test.cpp
index 8c0ac71ba70..440b8dee232 100644
--- a/src/mongo/db/repl/collection_cloner_test.cpp
+++ b/src/mongo/db/repl/collection_cloner_test.cpp
@@ -405,8 +405,8 @@ TEST_F(CollectionClonerTest, ListIndexesReturnedNamespaceNotFound) {
bool writesAreReplicatedOnOpCtx = false;
NamespaceString collNss;
storageInterface->createCollFn = [&collNss, &collectionCreated, &writesAreReplicatedOnOpCtx](
- OperationContext* txn, const NamespaceString& nss, const CollectionOptions& options) {
- writesAreReplicatedOnOpCtx = txn->writesAreReplicated();
+ OperationContext* opCtx, const NamespaceString& nss, const CollectionOptions& options) {
+ writesAreReplicatedOnOpCtx = opCtx->writesAreReplicated();
collectionCreated = true;
collNss = nss;
return Status::OK();
@@ -458,14 +458,14 @@ TEST_F(CollectionClonerTest,
// Replace scheduleDbWork function to schedule the create collection task with an injected error
// status.
auto exec = &getExecutor();
- collectionCloner->setScheduleDbWorkFn_forTest(
- [exec](const executor::TaskExecutor::CallbackFn& workFn) {
- auto wrappedTask = [workFn](const executor::TaskExecutor::CallbackArgs& cbd) {
- workFn(executor::TaskExecutor::CallbackArgs(
- cbd.executor, cbd.myHandle, Status(ErrorCodes::CallbackCanceled, ""), cbd.txn));
- };
- return exec->scheduleWork(wrappedTask);
- });
+ collectionCloner->setScheduleDbWorkFn_forTest([exec](
+ const executor::TaskExecutor::CallbackFn& workFn) {
+ auto wrappedTask = [workFn](const executor::TaskExecutor::CallbackArgs& cbd) {
+ workFn(executor::TaskExecutor::CallbackArgs(
+ cbd.executor, cbd.myHandle, Status(ErrorCodes::CallbackCanceled, ""), cbd.opCtx));
+ };
+ return exec->scheduleWork(wrappedTask);
+ });
bool collectionCreated = false;
storageInterface->createCollFn = [&collectionCreated](
diff --git a/src/mongo/db/repl/data_replicator.cpp b/src/mongo/db/repl/data_replicator.cpp
index ee990aab967..92e64cbb993 100644
--- a/src/mongo/db/repl/data_replicator.cpp
+++ b/src/mongo/db/repl/data_replicator.cpp
@@ -252,9 +252,9 @@ bool DataReplicator::_isActive_inlock() const {
return State::kRunning == _state || State::kShuttingDown == _state;
}
-Status DataReplicator::startup(OperationContext* txn,
+Status DataReplicator::startup(OperationContext* opCtx,
std::uint32_t initialSyncMaxAttempts) noexcept {
- invariant(txn);
+ invariant(opCtx);
invariant(initialSyncMaxAttempts >= 1U);
stdx::lock_guard<stdx::mutex> lock(_mutex);
@@ -270,7 +270,7 @@ Status DataReplicator::startup(OperationContext* txn,
return Status(ErrorCodes::ShutdownInProgress, "data replicator completed");
}
- _setUp_inlock(txn, initialSyncMaxAttempts);
+ _setUp_inlock(opCtx, initialSyncMaxAttempts);
// Start first initial sync attempt.
std::uint32_t initialSyncAttempt = 0;
@@ -397,32 +397,32 @@ void DataReplicator::setScheduleDbWorkFn_forTest(const CollectionCloner::Schedul
_scheduleDbWorkFn = work;
}
-void DataReplicator::_setUp_inlock(OperationContext* txn, std::uint32_t initialSyncMaxAttempts) {
+void DataReplicator::_setUp_inlock(OperationContext* opCtx, std::uint32_t initialSyncMaxAttempts) {
// This will call through to the storageInterfaceImpl to ReplicationCoordinatorImpl.
- // 'txn' is passed through from startup().
- _storage->setInitialSyncFlag(txn);
+ // 'opCtx' is passed through from startup().
+ _storage->setInitialSyncFlag(opCtx);
LOG(1) << "Creating oplogBuffer.";
- _oplogBuffer = _dataReplicatorExternalState->makeInitialSyncOplogBuffer(txn);
- _oplogBuffer->startup(txn);
+ _oplogBuffer = _dataReplicatorExternalState->makeInitialSyncOplogBuffer(opCtx);
+ _oplogBuffer->startup(opCtx);
_stats.initialSyncStart = _exec->now();
_stats.maxFailedInitialSyncAttempts = initialSyncMaxAttempts;
_stats.failedInitialSyncAttempts = 0;
}
-void DataReplicator::_tearDown_inlock(OperationContext* txn,
+void DataReplicator::_tearDown_inlock(OperationContext* opCtx,
const StatusWith<OpTimeWithHash>& lastApplied) {
_stats.initialSyncEnd = _exec->now();
// This might not be necessary if we failed initial sync.
invariant(_oplogBuffer);
- _oplogBuffer->shutdown(txn);
+ _oplogBuffer->shutdown(opCtx);
if (!lastApplied.isOK()) {
return;
}
- _storage->clearInitialSyncFlag(txn);
+ _storage->clearInitialSyncFlag(opCtx);
_opts.setMyLastOptime(lastApplied.getValue().opTime);
log() << "initial sync done; took "
<< duration_cast<Seconds>(_stats.initialSyncEnd - _stats.initialSyncStart) << ".";
@@ -570,28 +570,28 @@ Status DataReplicator::_recreateOplogAndDropReplicatedDatabases() {
LOG(1) << "About to drop+create the oplog, if it exists, ns:" << _opts.localOplogNS
<< ", and drop all user databases (so that we can clone them).";
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// We are not replicating nor validating these writes.
- UnreplicatedWritesBlock unreplicatedWritesBlock(txn.get());
+ UnreplicatedWritesBlock unreplicatedWritesBlock(opCtx.get());
// 1.) Drop the oplog.
LOG(2) << "Dropping the existing oplog: " << _opts.localOplogNS;
- auto status = _storage->dropCollection(txn.get(), _opts.localOplogNS);
+ auto status = _storage->dropCollection(opCtx.get(), _opts.localOplogNS);
if (!status.isOK()) {
return status;
}
// 2.) Drop user databases.
LOG(2) << "Dropping user databases";
- status = _storage->dropReplicatedDatabases(txn.get());
+ status = _storage->dropReplicatedDatabases(opCtx.get());
if (!status.isOK()) {
return status;
}
// 3.) Create the oplog.
LOG(2) << "Creating the oplog: " << _opts.localOplogNS;
- return _storage->createOplog(txn.get(), _opts.localOplogNS);
+ return _storage->createOplog(opCtx.get(), _opts.localOplogNS);
}
void DataReplicator::_rollbackCheckerResetCallback(
@@ -833,12 +833,12 @@ void DataReplicator::_lastOplogEntryFetcherCallbackForStopTimestamp(
const auto& oplogSeedDoc = documents.front();
LOG(1) << "inserting oplog seed document: " << oplogSeedDoc;
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// StorageInterface::insertDocument() has to be called outside the lock because we may
// override its behavior in tests. See DataReplicatorReturnsCallbackCanceledAndDoesNot-
// ScheduleRollbackCheckerIfShutdownAfterInsertingInsertOplogSeedDocument in
// data_replicator_test.cpp
- auto status = _storage->insertDocument(txn.get(), _opts.localOplogNS, oplogSeedDoc);
+ auto status = _storage->insertDocument(opCtx.get(), _opts.localOplogNS, oplogSeedDoc);
if (!status.isOK()) {
stdx::lock_guard<stdx::mutex> lock(_mutex);
onCompletionGuard->setResultAndCancelRemainingWork_inlock(lock, status);
@@ -1048,7 +1048,7 @@ void DataReplicator::_finishInitialSyncAttempt(const StatusWith<OpTimeWithHash>&
// For example, if CollectionCloner fails while inserting documents into the
// CollectionBulkLoader, we will get here via one of CollectionCloner's TaskRunner callbacks
// which has an active OperationContext bound to the current Client. This would lead to an
- // invariant when we attempt to create a new OperationContext for _tearDown(txn).
+ // invariant when we attempt to create a new OperationContext for _tearDown(opCtx).
// To avoid this, we schedule _finishCallback against the TaskExecutor rather than calling it
// here synchronously.
@@ -1139,8 +1139,8 @@ void DataReplicator::_finishCallback(StatusWith<OpTimeWithHash> lastApplied) {
decltype(_onCompletion) onCompletion;
{
stdx::lock_guard<stdx::mutex> lock(_mutex);
- auto txn = makeOpCtx();
- _tearDown_inlock(txn.get(), lastApplied);
+ auto opCtx = makeOpCtx();
+ _tearDown_inlock(opCtx.get(), lastApplied);
invariant(_onCompletion);
std::swap(_onCompletion, onCompletion);
@@ -1395,8 +1395,8 @@ StatusWith<Operations> DataReplicator::_getNextApplierBatch_inlock() {
// * only OplogEntries from before the slaveDelay point
// * a single command OplogEntry (including index builds, which appear to be inserts)
// * consequently, commands bound the previous batch to be in a batch of their own
- auto txn = makeOpCtx();
- while (_oplogBuffer->peek(txn.get(), &op)) {
+ auto opCtx = makeOpCtx();
+ while (_oplogBuffer->peek(opCtx.get(), &op)) {
auto entry = OplogEntry(std::move(op));
// Check for oplog version change. If it is absent, its value is one.
@@ -1417,7 +1417,7 @@ StatusWith<Operations> DataReplicator::_getNextApplierBatch_inlock() {
if (ops.empty()) {
// Apply commands one-at-a-time.
ops.push_back(std::move(entry));
- invariant(_oplogBuffer->tryPop(txn.get(), &op));
+ invariant(_oplogBuffer->tryPop(opCtx.get(), &op));
dassert(SimpleBSONObjComparator::kInstance.evaluate(ops.back().raw == op));
}
@@ -1451,7 +1451,7 @@ StatusWith<Operations> DataReplicator::_getNextApplierBatch_inlock() {
// Add op to buffer.
ops.push_back(std::move(entry));
totalBytes += ops.back().raw.objsize();
- invariant(_oplogBuffer->tryPop(txn.get(), &op));
+ invariant(_oplogBuffer->tryPop(opCtx.get(), &op));
dassert(SimpleBSONObjComparator::kInstance.evaluate(ops.back().raw == op));
}
return std::move(ops);
diff --git a/src/mongo/db/repl/data_replicator.h b/src/mongo/db/repl/data_replicator.h
index 62a8f134988..e2b96a92f6a 100644
--- a/src/mongo/db/repl/data_replicator.h
+++ b/src/mongo/db/repl/data_replicator.h
@@ -186,7 +186,7 @@ public:
/**
* Starts initial sync process, with the provided number of attempts
*/
- Status startup(OperationContext* txn, std::uint32_t maxAttempts) noexcept;
+ Status startup(OperationContext* opCtx, std::uint32_t maxAttempts) noexcept;
/**
* Shuts down replication if "start" has been called, and blocks until shutdown has completed.
@@ -336,12 +336,12 @@ private:
/**
* Sets up internal state to begin initial sync.
*/
- void _setUp_inlock(OperationContext* txn, std::uint32_t initialSyncMaxAttempts);
+ void _setUp_inlock(OperationContext* opCtx, std::uint32_t initialSyncMaxAttempts);
/**
* Tears down internal state before reporting final status to caller.
*/
- void _tearDown_inlock(OperationContext* txn, const StatusWith<OpTimeWithHash>& lastApplied);
+ void _tearDown_inlock(OperationContext* opCtx, const StatusWith<OpTimeWithHash>& lastApplied);
/**
* Callback to start a single initial sync attempt.
diff --git a/src/mongo/db/repl/data_replicator_external_state.h b/src/mongo/db/repl/data_replicator_external_state.h
index 0102ddab533..a1b4bf61e87 100644
--- a/src/mongo/db/repl/data_replicator_external_state.h
+++ b/src/mongo/db/repl/data_replicator_external_state.h
@@ -110,13 +110,13 @@ public:
* This function creates an oplog buffer of the type specified at server startup.
*/
virtual std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(
- OperationContext* txn) const = 0;
+ OperationContext* opCtx) const = 0;
/**
* Creates an oplog buffer suitable for steady state replication.
*/
virtual std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(
- OperationContext* txn) const = 0;
+ OperationContext* opCtx) const = 0;
/**
* Returns the current replica set config if there is one, or an error why there isn't.
@@ -130,7 +130,7 @@ private:
*
* Used exclusively by the DataReplicator to construct a MultiApplier.
*/
- virtual StatusWith<OpTime> _multiApply(OperationContext* txn,
+ virtual StatusWith<OpTime> _multiApply(OperationContext* opCtx,
MultiApplier::Operations ops,
MultiApplier::ApplyOperationFn applyOperation) = 0;
diff --git a/src/mongo/db/repl/data_replicator_external_state_impl.cpp b/src/mongo/db/repl/data_replicator_external_state_impl.cpp
index eed85a8216e..e486cfd5278 100644
--- a/src/mongo/db/repl/data_replicator_external_state_impl.cpp
+++ b/src/mongo/db/repl/data_replicator_external_state_impl.cpp
@@ -106,13 +106,13 @@ bool DataReplicatorExternalStateImpl::shouldStopFetching(
}
std::unique_ptr<OplogBuffer> DataReplicatorExternalStateImpl::makeInitialSyncOplogBuffer(
- OperationContext* txn) const {
- return _replicationCoordinatorExternalState->makeInitialSyncOplogBuffer(txn);
+ OperationContext* opCtx) const {
+ return _replicationCoordinatorExternalState->makeInitialSyncOplogBuffer(opCtx);
}
std::unique_ptr<OplogBuffer> DataReplicatorExternalStateImpl::makeSteadyStateOplogBuffer(
- OperationContext* txn) const {
- return _replicationCoordinatorExternalState->makeSteadyStateOplogBuffer(txn);
+ OperationContext* opCtx) const {
+ return _replicationCoordinatorExternalState->makeSteadyStateOplogBuffer(opCtx);
}
StatusWith<ReplSetConfig> DataReplicatorExternalStateImpl::getCurrentConfig() const {
@@ -120,10 +120,10 @@ StatusWith<ReplSetConfig> DataReplicatorExternalStateImpl::getCurrentConfig() co
}
StatusWith<OpTime> DataReplicatorExternalStateImpl::_multiApply(
- OperationContext* txn,
+ OperationContext* opCtx,
MultiApplier::Operations ops,
MultiApplier::ApplyOperationFn applyOperation) {
- return _replicationCoordinatorExternalState->multiApply(txn, std::move(ops), applyOperation);
+ return _replicationCoordinatorExternalState->multiApply(opCtx, std::move(ops), applyOperation);
}
Status DataReplicatorExternalStateImpl::_multiSyncApply(MultiApplier::OperationPtrs* ops) {
diff --git a/src/mongo/db/repl/data_replicator_external_state_impl.h b/src/mongo/db/repl/data_replicator_external_state_impl.h
index 2c5518d7a1d..40a25bcaf67 100644
--- a/src/mongo/db/repl/data_replicator_external_state_impl.h
+++ b/src/mongo/db/repl/data_replicator_external_state_impl.h
@@ -59,14 +59,14 @@ public:
const rpc::ReplSetMetadata& replMetadata,
boost::optional<rpc::OplogQueryMetadata> oqMetadata) override;
- std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(OperationContext* txn) const override;
+ std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(OperationContext* opCtx) const override;
- std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(OperationContext* txn) const override;
+ std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(OperationContext* opCtx) const override;
StatusWith<ReplSetConfig> getCurrentConfig() const override;
private:
- StatusWith<OpTime> _multiApply(OperationContext* txn,
+ StatusWith<OpTime> _multiApply(OperationContext* opCtx,
MultiApplier::Operations ops,
MultiApplier::ApplyOperationFn applyOperation) override;
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 a5eb417b403..1f315aee521 100644
--- a/src/mongo/db/repl/data_replicator_external_state_mock.cpp
+++ b/src/mongo/db/repl/data_replicator_external_state_mock.cpp
@@ -81,12 +81,12 @@ bool DataReplicatorExternalStateMock::shouldStopFetching(
}
std::unique_ptr<OplogBuffer> DataReplicatorExternalStateMock::makeInitialSyncOplogBuffer(
- OperationContext* txn) const {
+ OperationContext* opCtx) const {
return stdx::make_unique<OplogBufferBlockingQueue>();
}
std::unique_ptr<OplogBuffer> DataReplicatorExternalStateMock::makeSteadyStateOplogBuffer(
- OperationContext* txn) const {
+ OperationContext* opCtx) const {
return stdx::make_unique<OplogBufferBlockingQueue>();
}
@@ -95,10 +95,10 @@ StatusWith<ReplSetConfig> DataReplicatorExternalStateMock::getCurrentConfig() co
}
StatusWith<OpTime> DataReplicatorExternalStateMock::_multiApply(
- OperationContext* txn,
+ OperationContext* opCtx,
MultiApplier::Operations ops,
MultiApplier::ApplyOperationFn applyOperation) {
- return multiApplyFn(txn, std::move(ops), applyOperation);
+ return multiApplyFn(opCtx, std::move(ops), applyOperation);
}
Status DataReplicatorExternalStateMock::_multiSyncApply(MultiApplier::OperationPtrs* ops) {
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 ea2943a0749..88ff0df26c5 100644
--- a/src/mongo/db/repl/data_replicator_external_state_mock.h
+++ b/src/mongo/db/repl/data_replicator_external_state_mock.h
@@ -56,9 +56,9 @@ public:
const rpc::ReplSetMetadata& replMetadata,
boost::optional<rpc::OplogQueryMetadata> oqMetadata) override;
- std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(OperationContext* txn) const override;
+ std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(OperationContext* opCtx) const override;
- std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(OperationContext* txn) const override;
+ std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(OperationContext* opCtx) const override;
StatusWith<ReplSetConfig> getCurrentConfig() const override;
@@ -97,7 +97,7 @@ public:
StatusWith<ReplSetConfig> replSetConfigResult = ReplSetConfig();
private:
- StatusWith<OpTime> _multiApply(OperationContext* txn,
+ StatusWith<OpTime> _multiApply(OperationContext* opCtx,
MultiApplier::Operations ops,
MultiApplier::ApplyOperationFn applyOperation) override;
diff --git a/src/mongo/db/repl/data_replicator_test.cpp b/src/mongo/db/repl/data_replicator_test.cpp
index 9a6efec3f83..61a5dcb8f2d 100644
--- a/src/mongo/db/repl/data_replicator_test.cpp
+++ b/src/mongo/db/repl/data_replicator_test.cpp
@@ -265,31 +265,32 @@ protected:
void setUp() override {
executor::ThreadPoolExecutorTest::setUp();
_storageInterface = stdx::make_unique<StorageInterfaceMock>();
- _storageInterface->createOplogFn = [this](OperationContext* txn,
+ _storageInterface->createOplogFn = [this](OperationContext* opCtx,
const NamespaceString& nss) {
LockGuard lock(_storageInterfaceWorkDoneMutex);
_storageInterfaceWorkDone.createOplogCalled = true;
return Status::OK();
};
_storageInterface->insertDocumentFn =
- [this](OperationContext* txn, const NamespaceString& nss, const BSONObj& doc) {
+ [this](OperationContext* opCtx, const NamespaceString& nss, const BSONObj& doc) {
LockGuard lock(_storageInterfaceWorkDoneMutex);
++_storageInterfaceWorkDone.documentsInsertedCount;
return Status::OK();
};
_storageInterface->insertDocumentsFn = [this](
- OperationContext* txn, const NamespaceString& nss, const std::vector<BSONObj>& ops) {
+ OperationContext* opCtx, const NamespaceString& nss, const std::vector<BSONObj>& ops) {
LockGuard lock(_storageInterfaceWorkDoneMutex);
_storageInterfaceWorkDone.insertedOplogEntries = true;
++_storageInterfaceWorkDone.oplogEntriesInserted;
return Status::OK();
};
- _storageInterface->dropCollFn = [this](OperationContext* txn, const NamespaceString& nss) {
+ _storageInterface->dropCollFn = [this](OperationContext* opCtx,
+ const NamespaceString& nss) {
LockGuard lock(_storageInterfaceWorkDoneMutex);
_storageInterfaceWorkDone.droppedCollections.push_back(nss.ns());
return Status::OK();
};
- _storageInterface->dropUserDBsFn = [this](OperationContext* txn) {
+ _storageInterface->dropUserDBsFn = [this](OperationContext* opCtx) {
LockGuard lock(_storageInterfaceWorkDoneMutex);
_storageInterfaceWorkDone.droppedUserDBs = true;
return Status::OK();
@@ -577,66 +578,66 @@ const std::uint32_t maxAttempts = 1U;
TEST_F(DataReplicatorTest, StartupReturnsIllegalOperationIfAlreadyActive) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
ASSERT_FALSE(dr->isActive());
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
ASSERT_TRUE(dr->isActive());
- ASSERT_EQUALS(ErrorCodes::IllegalOperation, dr->startup(txn.get(), maxAttempts));
+ ASSERT_EQUALS(ErrorCodes::IllegalOperation, dr->startup(opCtx.get(), maxAttempts));
ASSERT_TRUE(dr->isActive());
}
TEST_F(DataReplicatorTest, StartupReturnsShutdownInProgressIfDataReplicatorIsShuttingDown) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
ASSERT_FALSE(dr->isActive());
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
ASSERT_TRUE(dr->isActive());
// SyncSourceSelector returns an invalid sync source so DataReplicator is stuck waiting for
// another sync source in 'Options::syncSourceRetryWait' ms.
ASSERT_OK(dr->shutdown());
- ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(txn.get(), maxAttempts));
+ ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(opCtx.get(), maxAttempts));
}
TEST_F(DataReplicatorTest, StartupReturnsShutdownInProgressIfExecutorIsShutdown) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
getExecutor().shutdown();
- ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(txn.get(), maxAttempts));
+ ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(opCtx.get(), maxAttempts));
ASSERT_FALSE(dr->isActive());
// Cannot startup data replicator again since it's in the Complete state.
- ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(txn.get(), maxAttempts));
+ ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(opCtx.get(), maxAttempts));
}
TEST_F(DataReplicatorTest, ShutdownTransitionsStateToCompleteIfCalledBeforeStartup) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
ASSERT_OK(dr->shutdown());
- ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(txn.get(), maxAttempts));
+ ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, dr->startup(opCtx.get(), maxAttempts));
// Data replicator is inactive when it's in the Complete state.
ASSERT_FALSE(dr->isActive());
}
TEST_F(DataReplicatorTest, StartupSetsInitialSyncFlagOnSuccess) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// Initial sync flag should not be set before starting.
- ASSERT_FALSE(getStorage().getInitialSyncFlag(txn.get()));
+ ASSERT_FALSE(getStorage().getInitialSyncFlag(opCtx.get()));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
ASSERT_TRUE(dr->isActive());
// Initial sync flag should be set.
- ASSERT_TRUE(getStorage().getInitialSyncFlag(txn.get()));
+ ASSERT_TRUE(getStorage().getInitialSyncFlag(opCtx.get()));
}
TEST_F(DataReplicatorTest, DataReplicatorReturnsCallbackCanceledIfShutdownImmediatelyAfterStartup) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
// This will cancel the _startInitialSyncAttemptCallback() task scheduled by startup().
ASSERT_OK(dr->shutdown());
@@ -655,13 +656,13 @@ TEST_F(DataReplicatorTest, DataReplicatorReturnsCallbackCanceledIfShutdownImmedi
TEST_F(DataReplicatorTest,
DataReplicatorRetriesSyncSourceSelectionIfChooseNewSyncSourceReturnsInvalidSyncSource) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// Override chooseNewSyncSource() result in SyncSourceSelectorMock before calling startup()
// because DataReplicator will look for a valid sync source immediately after startup.
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
// Run first sync source selection attempt.
executor::NetworkInterfaceMock::InNetworkGuard(getNet())->runReadyNetworkOperations();
@@ -697,13 +698,13 @@ TEST_F(
DataReplicatorTest,
DataReplicatorReturnsInitialSyncOplogSourceMissingIfNoValidSyncSourceCanBeFoundAfterTenFailedChooseSyncSourceAttempts) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// Override chooseNewSyncSource() result in SyncSourceSelectorMock before calling startup()
// because DataReplicator will look for a valid sync source immediately after startup.
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
_simulateChooseSyncSourceFailure(getNet(), _options.syncSourceRetryWait);
@@ -718,12 +719,12 @@ TEST_F(
TEST_F(DataReplicatorTest,
DataReplicatorRetriesInitialSyncUpToMaxAttemptsAndReturnsLastAttemptError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
const std::uint32_t initialSyncMaxAttempts = 3U;
- ASSERT_OK(dr->startup(txn.get(), initialSyncMaxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), initialSyncMaxAttempts));
auto net = getNet();
for (std::uint32_t i = 0; i < initialSyncMaxAttempts; ++i) {
@@ -748,10 +749,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest,
DataReplicatorReturnsCallbackCanceledIfShutdownWhileRetryingSyncSourceSelection) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -774,11 +775,11 @@ TEST_F(
DataReplicatorTest,
DataReplicatorReturnsScheduleErrorIfTaskExecutorFailsToScheduleNextChooseSyncSourceCallback) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
_executorProxy->shouldFailScheduleWorkAt = true;
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
dr->join();
@@ -788,13 +789,13 @@ TEST_F(
TEST_F(DataReplicatorTest,
DataReplicatorReturnsScheduleErrorIfTaskExecutorFailsToScheduleNextInitialSyncAttempt) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
ASSERT_EQUALS(DataReplicator::State::kPreStart, dr->getState_forTest());
- ASSERT_OK(dr->startup(txn.get(), 2U));
+ ASSERT_OK(dr->startup(opCtx.get(), 2U));
ASSERT_EQUALS(DataReplicator::State::kRunning, dr->getState_forTest());
// Advance clock so that we run all but the last sync source callback.
@@ -816,7 +817,7 @@ TEST_F(DataReplicatorTest,
// the completion callback function throws an exception.
TEST_F(DataReplicatorTest, DataReplicatorTransitionsToCompleteWhenFinishCallbackThrowsException) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_onCompletion = [this](const StatusWith<OpTimeWithHash>& lastApplied) {
_lastApplied = lastApplied;
@@ -824,7 +825,7 @@ TEST_F(DataReplicatorTest, DataReplicatorTransitionsToCompleteWhenFinishCallback
};
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
ASSERT_OK(dr->shutdown());
dr->join();
@@ -862,9 +863,9 @@ TEST_F(DataReplicatorTest, DataReplicatorResetsOnCompletionCallbackFunctionPoint
});
ON_BLOCK_EXIT([this]() { getExecutor().shutdown(); });
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
sharedCallbackData.reset();
ASSERT_FALSE(sharedCallbackStateDestroyed);
@@ -891,17 +892,17 @@ TEST_F(DataReplicatorTest, DataReplicatorRecreatesOplogAndDropsReplicatedDatabas
// We are not interested in proceeding beyond the oplog creation stage so we inject a failure
// after setting '_storageInterfaceWorkDone.createOplogCalled' to true.
auto oldCreateOplogFn = _storageInterface->createOplogFn;
- _storageInterface->createOplogFn = [oldCreateOplogFn](OperationContext* txn,
+ _storageInterface->createOplogFn = [oldCreateOplogFn](OperationContext* opCtx,
const NamespaceString& nss) {
- oldCreateOplogFn(txn, nss);
+ oldCreateOplogFn(opCtx, nss);
return Status(ErrorCodes::OperationFailed, "oplog creation failed");
};
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
dr->join();
ASSERT_EQUALS(ErrorCodes::OperationFailed, _lastApplied);
@@ -913,7 +914,7 @@ TEST_F(DataReplicatorTest, DataReplicatorRecreatesOplogAndDropsReplicatedDatabas
TEST_F(DataReplicatorTest, DataReplicatorPassesThroughGetRollbackIdScheduleError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// replSetGetRBID is the first remote command to be scheduled by the data replicator after
// creating the oplog collection.
@@ -925,7 +926,7 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughGetRollbackIdScheduleError
HostAndPort syncSource("localhost", 12345);
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
dr->join();
ASSERT_EQUALS(ErrorCodes::OperationFailed, _lastApplied);
@@ -942,18 +943,18 @@ TEST_F(
// down before returning from createOplog() to make the scheduleRemoteCommand() call for
// replSetGetRBID fail.
auto oldCreateOplogFn = _storageInterface->createOplogFn;
- _storageInterface->createOplogFn = [oldCreateOplogFn, this](OperationContext* txn,
+ _storageInterface->createOplogFn = [oldCreateOplogFn, this](OperationContext* opCtx,
const NamespaceString& nss) {
- auto status = oldCreateOplogFn(txn, nss);
+ auto status = oldCreateOplogFn(opCtx, nss);
getExecutor().shutdown();
return status;
};
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
dr->join();
ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, _lastApplied);
@@ -964,14 +965,14 @@ TEST_F(
TEST_F(DataReplicatorTest, DataReplicatorCancelsRollbackCheckerOnShutdown) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
HostAndPort syncSource("localhost", 12345);
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
ASSERT_EQUALS(DataReplicator::State::kPreStart, dr->getState_forTest());
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
ASSERT_EQUALS(DataReplicator::State::kRunning, dr->getState_forTest());
auto net = getNet();
@@ -1000,10 +1001,10 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsRollbackCheckerOnShutdown) {
TEST_F(DataReplicatorTest, DataReplicatorPassesThroughRollbackCheckerCallbackError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1021,7 +1022,7 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughRollbackCheckerCallbackErr
TEST_F(DataReplicatorTest, DataReplicatorPassesThroughLastOplogEntryFetcherScheduleError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// The last oplog entry fetcher is the first component that sends a find command so we reject
// any find commands and save the request for inspection at the end of this test case.
@@ -1033,7 +1034,7 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughLastOplogEntryFetcherSched
HostAndPort syncSource("localhost", 12345);
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1056,10 +1057,10 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughLastOplogEntryFetcherSched
TEST_F(DataReplicatorTest, DataReplicatorPassesThroughLastOplogEntryFetcherCallbackError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1082,10 +1083,10 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughLastOplogEntryFetcherCallb
TEST_F(DataReplicatorTest, DataReplicatorCancelsLastOplogEntryFetcherOnShutdown) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1108,10 +1109,10 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsLastOplogEntryFetcherOnShutdown)
TEST_F(DataReplicatorTest,
DataReplicatorReturnsNoMatchingDocumentIfLastOplogEntryFetcherReturnsEmptyBatchOfDocuments) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1132,10 +1133,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest,
DataReplicatorResendsFindCommandIfLastOplogEntryFetcherReturnsRetriableError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
executor::NetworkInterfaceMock::InNetworkGuard guard(net);
@@ -1159,10 +1160,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest,
DataReplicatorReturnsNoSuchKeyIfLastOplogEntryFetcherReturnsEntryWithMissingHash) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1183,10 +1184,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest,
DataReplicatorReturnsNoSuchKeyIfLastOplogEntryFetcherReturnsEntryWithMissingTimestamp) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1207,12 +1208,12 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest,
DataReplicatorPassesThroughErrorFromDataReplicatorExternalStateGetCurrentConfig) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
getExternalState()->replSetConfigResult = Status(ErrorCodes::OperationFailed, "");
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1232,7 +1233,7 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest, DataReplicatorPassesThroughOplogFetcherScheduleError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// Make the tailable oplog query fail. Allow all other requests to be scheduled.
executor::RemoteCommandRequest request;
@@ -1247,7 +1248,7 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughOplogFetcherScheduleError)
HostAndPort syncSource("localhost", 12345);
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1273,10 +1274,10 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughOplogFetcherScheduleError)
TEST_F(DataReplicatorTest, DataReplicatorPassesThroughOplogFetcherCallbackError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1311,10 +1312,10 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughOplogFetcherCallbackError)
TEST_F(DataReplicatorTest,
DataReplicatorSucceedsOnEarlyOplogFetcherCompletionIfThereAreNoOperationsToApply) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1363,10 +1364,10 @@ TEST_F(
DataReplicatorTest,
DataReplicatorSucceedsOnEarlyOplogFetcherCompletionIfThereAreEnoughOperationsInTheOplogBufferToReachEndTimestamp) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1412,10 +1413,10 @@ TEST_F(
DataReplicatorTest,
DataReplicatorReturnsRemoteResultsUnavailableOnEarlyOplogFetcherCompletionIfThereAreNotEnoughOperationsInTheOplogBufferToReachEndTimestamp) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1456,7 +1457,7 @@ TEST_F(
TEST_F(DataReplicatorTest,
DataReplicatorPassesThroughDatabasesClonerScheduleErrorAndCancelsOplogFetcher) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// Make the listDatabases command fail. Allow all other requests to be scheduled.
executor::RemoteCommandRequest request;
@@ -1470,7 +1471,7 @@ TEST_F(DataReplicatorTest,
HostAndPort syncSource("localhost", 12345);
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1504,10 +1505,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest,
DataReplicatorPassesThroughDatabasesClonerCallbackErrorAndCancelsOplogFetcher) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1544,10 +1545,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest, DataReplicatorIgnoresLocalDatabasesWhenCloningDatabases) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1604,10 +1605,10 @@ TEST_F(DataReplicatorTest, DataReplicatorIgnoresLocalDatabasesWhenCloningDatabas
TEST_F(DataReplicatorTest,
DataReplicatorIgnoresDatabaseInfoDocumentWithoutNameFieldWhenCloningDatabases) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1670,10 +1671,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest, DataReplicatorCancelsBothOplogFetcherAndDatabasesClonerOnShutdown) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1697,7 +1698,7 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsBothOplogFetcherAndDatabasesClon
TEST_F(DataReplicatorTest,
DataReplicatorPassesThroughSecondLastOplogEntryFetcherScheduleErrorAndCancelsOplogFetcher) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// Make the second last oplog entry fetcher command fail. Allow all other requests to be
// scheduled.
@@ -1718,7 +1719,7 @@ TEST_F(DataReplicatorTest,
};
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1758,10 +1759,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest,
DataReplicatorPassesThroughSecondLastOplogEntryFetcherCallbackErrorAndCancelsOplogFetcher) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1810,10 +1811,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest,
DataReplicatorCancelsBothSecondLastOplogEntryFetcherAndOplogFetcherOnShutdown) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1857,10 +1858,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest,
DataReplicatorCancelsSecondLastOplogEntryFetcherOnOplogFetcherCallbackError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -1914,10 +1915,10 @@ TEST_F(
DataReplicatorTest,
DataReplicatorReturnsTypeMismatchErrorWhenSecondLastOplogEntryFetcherReturnsMalformedDocument) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto oplogEntry = makeOplogEntry(1);
auto net = getNet();
@@ -1963,10 +1964,10 @@ TEST_F(
TEST_F(DataReplicatorTest,
DataReplicatorReturnsOplogOutOfOrderIfStopTimestampPrecedesBeginTimestamp) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
{
@@ -2010,7 +2011,7 @@ TEST_F(
DataReplicatorTest,
DataReplicatorPassesThroughInsertOplogSeedDocumentErrorAfterDataCloningFinishesWithNoOperationsToApply) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
NamespaceString insertDocumentNss;
BSONObj insertDocumentDoc;
@@ -2022,7 +2023,7 @@ TEST_F(
};
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto oplogEntry = makeOplogEntry(1);
auto net = getNet();
@@ -2069,7 +2070,7 @@ TEST_F(
DataReplicatorTest,
DataReplicatorReturnsCallbackCanceledAndDoesNotScheduleRollbackCheckerIfShutdownAfterInsertingInsertOplogSeedDocument) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
NamespaceString insertDocumentNss;
BSONObj insertDocumentDoc;
@@ -2082,7 +2083,7 @@ TEST_F(
};
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto oplogEntry = makeOplogEntry(1);
auto net = getNet();
@@ -2129,7 +2130,7 @@ TEST_F(
DataReplicatorTest,
DataReplicatorPassesThroughRollbackCheckerScheduleErrorAfterCloningFinishesWithNoOperationsToApply) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// Make the second replSetGetRBID command fail. Allow all other requests to be scheduled.
executor::RemoteCommandRequest request;
@@ -2147,7 +2148,7 @@ TEST_F(
};
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto oplogEntry = makeOplogEntry(1);
auto net = getNet();
@@ -2192,10 +2193,10 @@ TEST_F(
DataReplicatorTest,
DataReplicatorPassesThroughRollbackCheckerCallbackErrorAfterCloningFinishesWithNoOperationsToApply) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto oplogEntry = makeOplogEntry(1);
auto net = getNet();
@@ -2245,10 +2246,10 @@ TEST_F(
TEST_F(DataReplicatorTest, DataReplicatorCancelsLastRollbackCheckerOnShutdown) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto oplogEntry = makeOplogEntry(1);
auto net = getNet();
@@ -2299,10 +2300,10 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsLastRollbackCheckerOnShutdown) {
TEST_F(DataReplicatorTest, DataReplicatorCancelsLastRollbackCheckerOnOplogFetcherCallbackError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto oplogEntry = makeOplogEntry(1);
auto net = getNet();
@@ -2357,10 +2358,10 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsLastRollbackCheckerOnOplogFetche
TEST_F(DataReplicatorTest,
DataReplicatorReturnsUnrecoverableRollbackErrorIfSyncSourceRolledBackAfterCloningData) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto oplogEntry = makeOplogEntry(1);
auto net = getNet();
@@ -2405,12 +2406,12 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest, LastOpTimeShouldBeSetEvenIfNoOperationsAreAppliedAfterCloning) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
- ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+ ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
auto oplogEntry = makeOplogEntry(1);
auto net = getNet();
@@ -2488,17 +2489,17 @@ TEST_F(DataReplicatorTest, LastOpTimeShouldBeSetEvenIfNoOperationsAreAppliedAfte
dr->join();
ASSERT_EQUALS(OplogEntry(oplogEntry).getOpTime(), unittest::assertGet(_lastApplied).opTime);
ASSERT_EQUALS(oplogEntry["h"].Long(), unittest::assertGet(_lastApplied).value);
- ASSERT_FALSE(_storageInterface->getInitialSyncFlag(txn.get()));
+ ASSERT_FALSE(_storageInterface->getInitialSyncFlag(opCtx.get()));
}
TEST_F(DataReplicatorTest, DataReplicatorPassesThroughGetNextApplierBatchScheduleError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
- ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+ ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
auto net = getNet();
int baseRollbackId = 1;
@@ -2547,12 +2548,12 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughGetNextApplierBatchSchedul
TEST_F(DataReplicatorTest, DataReplicatorPassesThroughSecondGetNextApplierBatchScheduleError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
- ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+ ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
auto net = getNet();
int baseRollbackId = 1;
@@ -2601,12 +2602,12 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughSecondGetNextApplierBatchS
TEST_F(DataReplicatorTest, DataReplicatorCancelsGetNextApplierBatchOnShutdown) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
- ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+ ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
auto net = getNet();
int baseRollbackId = 1;
@@ -2651,12 +2652,12 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsGetNextApplierBatchOnShutdown) {
TEST_F(DataReplicatorTest, DataReplicatorPassesThroughGetNextApplierBatchInLockError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
- ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+ ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
// _getNextApplierBatch_inlock() returns BadValue when it gets an oplog entry with an unexpected
// version (not OplogEntry::kOplogVersion).
@@ -2715,12 +2716,12 @@ TEST_F(
DataReplicatorTest,
DataReplicatorReturnsEmptyBatchFromGetNextApplierBatchInLockIfRsSyncApplyStopFailPointIsEnabled) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
- ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+ ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
// _getNextApplierBatch_inlock() returns BadValue when it gets an oplog entry with an unexpected
// version (not OplogEntry::kOplogVersion).
@@ -2790,12 +2791,12 @@ TEST_F(
TEST_F(DataReplicatorTest,
DataReplicatorReturnsNoSuchKeyIfApplierBatchContainsAnOplogEntryWithoutHash) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
- ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+ ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
// This oplog entry (without a required "h" field) will be read by OplogFetcher and inserted
// into OplogBuffer to be retrieved by _getNextApplierBatch_inlock().
@@ -2848,12 +2849,12 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest, DataReplicatorPassesThroughMultiApplierScheduleError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
- ASSERT_TRUE(_storageInterface->getInitialSyncFlag(txn.get()));
+ ASSERT_TRUE(_storageInterface->getInitialSyncFlag(opCtx.get()));
auto net = getNet();
int baseRollbackId = 1;
@@ -2920,14 +2921,14 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughMultiApplierScheduleError)
TEST_F(DataReplicatorTest, DataReplicatorPassesThroughMultiApplierCallbackError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
getExternalState()->multiApplyFn =
[](OperationContext*, const MultiApplier::Operations&, MultiApplier::ApplyOperationFn) {
return Status(ErrorCodes::OperationFailed, "multiApply failed");
};
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
int baseRollbackId = 1;
@@ -2975,10 +2976,10 @@ TEST_F(DataReplicatorTest, DataReplicatorPassesThroughMultiApplierCallbackError)
TEST_F(DataReplicatorTest, DataReplicatorCancelsGetNextApplierBatchCallbackOnOplogFetcherError) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
int baseRollbackId = 1;
@@ -3026,10 +3027,10 @@ TEST_F(DataReplicatorTest, DataReplicatorCancelsGetNextApplierBatchCallbackOnOpl
TEST_F(DataReplicatorTest,
DataReplicatorReturnsLastAppliedOnReachingStopTimestampAfterApplyingOneBatch) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto lastOp = makeOplogEntry(2);
@@ -3088,10 +3089,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest,
DataReplicatorReturnsLastAppliedOnReachingStopTimestampAfterApplyingMultipleBatches) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
// To make DataReplicator apply multiple batches, we make the third and last operation a command
// so that it will go into a separate batch from the second operation. First operation is the
@@ -3186,7 +3187,7 @@ TEST_F(
DataReplicatorTest,
DataReplicatorSchedulesLastOplogEntryFetcherToGetNewStopTimestampIfMissingDocumentsHaveBeenFetchedDuringMultiInitialSyncApply) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// Override DataReplicatorExternalState::_multiInitialSyncApply() so that it will also fetch a
// missing document.
@@ -3210,7 +3211,7 @@ TEST_F(
};
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
// Use command for third and last operation to ensure we have two batches to apply.
auto lastOp = makeOplogEntry(3, "c");
@@ -3281,7 +3282,7 @@ TEST_F(
TEST_F(DataReplicatorTest,
DataReplicatorReturnsInvalidSyncSourceWhenFailInitialSyncWithBadHostFailpointIsEnabled) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
// This fail point makes chooseSyncSourceCallback fail with an InvalidSyncSource error.
auto failPoint = getGlobalFailPointRegistry()->getFailPoint("failInitialSyncWithBadHost");
@@ -3289,7 +3290,7 @@ TEST_F(DataReplicatorTest,
ON_BLOCK_EXIT([failPoint]() { failPoint->setMode(FailPoint::off); });
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
dr->join();
ASSERT_EQUALS(ErrorCodes::InvalidSyncSource, _lastApplied);
@@ -3297,10 +3298,10 @@ TEST_F(DataReplicatorTest,
TEST_F(DataReplicatorTest, OplogOutOfOrderOnOplogFetchFinish) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
- ASSERT_OK(dr->startup(txn.get(), maxAttempts));
+ ASSERT_OK(dr->startup(opCtx.get(), maxAttempts));
auto net = getNet();
int baseRollbackId = 1;
@@ -3346,10 +3347,10 @@ TEST_F(DataReplicatorTest, OplogOutOfOrderOnOplogFetchFinish) {
TEST_F(DataReplicatorTest, GetInitialSyncProgressReturnsCorrectProgress) {
auto dr = &getDR();
- auto txn = makeOpCtx();
+ auto opCtx = makeOpCtx();
_syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 27017));
- ASSERT_OK(dr->startup(txn.get(), 2U));
+ ASSERT_OK(dr->startup(opCtx.get(), 2U));
auto net = getNet();
int baseRollbackId = 1;
diff --git a/src/mongo/db/repl/database_task.cpp b/src/mongo/db/repl/database_task.cpp
index b19bf201b5d..5c4f9422ea9 100644
--- a/src/mongo/db/repl/database_task.cpp
+++ b/src/mongo/db/repl/database_task.cpp
@@ -41,16 +41,16 @@ namespace repl {
// static
DatabaseTask::Task DatabaseTask::makeGlobalExclusiveLockTask(const Task& task) {
invariant(task);
- DatabaseTask::Task newTask = [task](OperationContext* txn, const Status& status) {
+ DatabaseTask::Task newTask = [task](OperationContext* opCtx, const Status& status) {
if (!status.isOK()) {
- return task(txn, status);
+ return task(opCtx, status);
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite lock(txn->lockState());
- return task(txn, status);
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite lock(opCtx->lockState());
+ return task(opCtx, status);
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "globalExclusiveLockTask", "global");
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "globalExclusiveLockTask", "global");
MONGO_UNREACHABLE;
};
return newTask;
@@ -61,17 +61,17 @@ DatabaseTask::Task DatabaseTask::makeDatabaseLockTask(const Task& task,
const std::string& databaseName,
LockMode mode) {
invariant(task);
- DatabaseTask::Task newTask = [=](OperationContext* txn, const Status& status) {
+ DatabaseTask::Task newTask = [=](OperationContext* opCtx, const Status& status) {
if (!status.isOK()) {
- return task(txn, status);
+ return task(opCtx, status);
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
LockMode permissiveLockMode = isSharedLockMode(mode) ? MODE_IS : MODE_IX;
- ScopedTransaction transaction(txn, permissiveLockMode);
- Lock::DBLock lock(txn->lockState(), databaseName, mode);
- return task(txn, status);
+ ScopedTransaction transaction(opCtx, permissiveLockMode);
+ Lock::DBLock lock(opCtx->lockState(), databaseName, mode);
+ return task(opCtx, status);
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "databaseLockTask", databaseName);
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "databaseLockTask", databaseName);
MONGO_UNREACHABLE;
};
return newTask;
@@ -82,18 +82,18 @@ DatabaseTask::Task DatabaseTask::makeCollectionLockTask(const Task& task,
const NamespaceString& nss,
LockMode mode) {
invariant(task);
- DatabaseTask::Task newTask = [=](OperationContext* txn, const Status& status) {
+ DatabaseTask::Task newTask = [=](OperationContext* opCtx, const Status& status) {
if (!status.isOK()) {
- return task(txn, status);
+ return task(opCtx, status);
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
LockMode permissiveLockMode = isSharedLockMode(mode) ? MODE_IS : MODE_IX;
- ScopedTransaction transaction(txn, permissiveLockMode);
- Lock::DBLock lock(txn->lockState(), nss.db(), permissiveLockMode);
- Lock::CollectionLock collectionLock(txn->lockState(), nss.toString(), mode);
- return task(txn, status);
+ ScopedTransaction transaction(opCtx, permissiveLockMode);
+ Lock::DBLock lock(opCtx->lockState(), nss.db(), permissiveLockMode);
+ Lock::CollectionLock collectionLock(opCtx->lockState(), nss.toString(), mode);
+ return task(opCtx, status);
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "collectionLockTask", nss.toString());
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "collectionLockTask", nss.toString());
MONGO_UNREACHABLE;
};
return newTask;
diff --git a/src/mongo/db/repl/database_task_test.cpp b/src/mongo/db/repl/database_task_test.cpp
index 5c004c466d7..beaa896acf0 100644
--- a/src/mongo/db/repl/database_task_test.cpp
+++ b/src/mongo/db/repl/database_task_test.cpp
@@ -49,8 +49,8 @@ class DatabaseTaskTest : public TaskRunnerTest {};
TEST_F(DatabaseTaskTest, TaskRunnerErrorStatus) {
// Should not attempt to acquire lock on error status from task runner.
- auto task = [](OperationContext* txn, const Status& status) {
- ASSERT_FALSE(txn);
+ auto task = [](OperationContext* opCtx, const Status& status) {
+ ASSERT_FALSE(opCtx);
ASSERT_EQUALS(ErrorCodes::BadValue, status.code());
return TaskRunner::NextAction::kInvalid;
};
@@ -66,15 +66,15 @@ TEST_F(DatabaseTaskTest, TaskRunnerErrorStatus) {
TEST_F(DatabaseTaskTest, RunGlobalExclusiveLockTask) {
stdx::mutex mutex;
bool called = false;
- OperationContext* txn = nullptr;
+ OperationContext* opCtx = nullptr;
bool lockIsW = false;
Status status = getDetectableErrorStatus();
// Task returning 'void' implies NextAction::NoAction.
auto task = [&](OperationContext* theTxn, const Status& theStatus) {
stdx::lock_guard<stdx::mutex> lk(mutex);
called = true;
- txn = theTxn;
- lockIsW = txn->lockState()->isW();
+ opCtx = theTxn;
+ lockIsW = opCtx->lockState()->isW();
status = theStatus;
return TaskRunner::NextAction::kCancel;
};
@@ -84,7 +84,7 @@ TEST_F(DatabaseTaskTest, RunGlobalExclusiveLockTask) {
stdx::lock_guard<stdx::mutex> lk(mutex);
ASSERT_TRUE(called);
- ASSERT(txn);
+ ASSERT(opCtx);
ASSERT_TRUE(lockIsW);
ASSERT_OK(status);
}
@@ -92,15 +92,15 @@ TEST_F(DatabaseTaskTest, RunGlobalExclusiveLockTask) {
void _testRunDatabaseLockTask(DatabaseTaskTest& test, LockMode mode) {
stdx::mutex mutex;
bool called = false;
- OperationContext* txn = nullptr;
+ OperationContext* opCtx = nullptr;
bool isDatabaseLockedForMode = false;
Status status = test.getDetectableErrorStatus();
// Task returning 'void' implies NextAction::NoAction.
auto task = [&](OperationContext* theTxn, const Status& theStatus) {
stdx::lock_guard<stdx::mutex> lk(mutex);
called = true;
- txn = theTxn;
- isDatabaseLockedForMode = txn->lockState()->isDbLockedForMode(databaseName, mode);
+ opCtx = theTxn;
+ isDatabaseLockedForMode = opCtx->lockState()->isDbLockedForMode(databaseName, mode);
status = theStatus;
return TaskRunner::NextAction::kCancel;
};
@@ -110,7 +110,7 @@ void _testRunDatabaseLockTask(DatabaseTaskTest& test, LockMode mode) {
stdx::lock_guard<stdx::mutex> lk(mutex);
ASSERT_TRUE(called);
- ASSERT(txn);
+ ASSERT(opCtx);
ASSERT_TRUE(isDatabaseLockedForMode);
ASSERT_OK(status);
}
@@ -134,16 +134,16 @@ TEST_F(DatabaseTaskTest, RunDatabaseLockTaskModeIS) {
void _testRunCollectionLockTask(DatabaseTaskTest& test, LockMode mode) {
stdx::mutex mutex;
bool called = false;
- OperationContext* txn = nullptr;
+ OperationContext* opCtx = nullptr;
bool isCollectionLockedForMode = false;
Status status = test.getDetectableErrorStatus();
// Task returning 'void' implies NextAction::NoAction.
auto task = [&](OperationContext* theTxn, const Status& theStatus) {
stdx::lock_guard<stdx::mutex> lk(mutex);
called = true;
- txn = theTxn;
+ opCtx = theTxn;
isCollectionLockedForMode =
- txn->lockState()->isCollectionLockedForMode(nss.toString(), mode);
+ opCtx->lockState()->isCollectionLockedForMode(nss.toString(), mode);
status = theStatus;
return TaskRunner::NextAction::kCancel;
};
@@ -153,7 +153,7 @@ void _testRunCollectionLockTask(DatabaseTaskTest& test, LockMode mode) {
stdx::lock_guard<stdx::mutex> lk(mutex);
ASSERT_TRUE(called);
- ASSERT(txn);
+ ASSERT(opCtx);
ASSERT_TRUE(isCollectionLockedForMode);
ASSERT_OK(status);
}
diff --git a/src/mongo/db/repl/databases_cloner.cpp b/src/mongo/db/repl/databases_cloner.cpp
index 3f7c1ce11e4..ff0c9170e15 100644
--- a/src/mongo/db/repl/databases_cloner.cpp
+++ b/src/mongo/db/repl/databases_cloner.cpp
@@ -354,13 +354,13 @@ void DatabasesCloner::_onEachDBCloneFinish(const Status& status, const std::stri
auto adminStatus = Status(ErrorCodes::NotYetInitialized, "");
{
// TODO: Move isAdminDbValid() out of the collection/database cloner code paths.
- OperationContext* txn = cc().getOperationContext();
- ServiceContext::UniqueOperationContext txnPtr;
- if (!txn) {
- txnPtr = cc().makeOperationContext();
- txn = txnPtr.get();
+ OperationContext* opCtx = cc().getOperationContext();
+ ServiceContext::UniqueOperationContext opCtxPtr;
+ if (!opCtx) {
+ opCtxPtr = cc().makeOperationContext();
+ opCtx = opCtxPtr.get();
}
- adminStatus = _storage->isAdminDbValid(txn);
+ adminStatus = _storage->isAdminDbValid(opCtx);
}
if (!adminStatus.isOK()) {
LOG(1) << "Validation failed on 'admin' db due to " << adminStatus;
diff --git a/src/mongo/db/repl/databases_cloner_test.cpp b/src/mongo/db/repl/databases_cloner_test.cpp
index 366e8c04a7c..777a4eedacd 100644
--- a/src/mongo/db/repl/databases_cloner_test.cpp
+++ b/src/mongo/db/repl/databases_cloner_test.cpp
@@ -142,27 +142,27 @@ protected:
executor::ThreadPoolExecutorTest::setUp();
launchExecutorThread();
- _storageInterface.createOplogFn = [this](OperationContext* txn,
+ _storageInterface.createOplogFn = [this](OperationContext* opCtx,
const NamespaceString& nss) {
_storageInterfaceWorkDone.createOplogCalled = true;
return Status::OK();
};
_storageInterface.insertDocumentFn =
- [this](OperationContext* txn, const NamespaceString& nss, const BSONObj& doc) {
+ [this](OperationContext* opCtx, const NamespaceString& nss, const BSONObj& doc) {
++_storageInterfaceWorkDone.documentsInsertedCount;
return Status::OK();
};
_storageInterface.insertDocumentsFn = [this](
- OperationContext* txn, const NamespaceString& nss, const std::vector<BSONObj>& ops) {
+ OperationContext* opCtx, const NamespaceString& nss, const std::vector<BSONObj>& ops) {
_storageInterfaceWorkDone.insertedOplogEntries = true;
++_storageInterfaceWorkDone.oplogEntriesInserted;
return Status::OK();
};
- _storageInterface.dropCollFn = [this](OperationContext* txn, const NamespaceString& nss) {
+ _storageInterface.dropCollFn = [this](OperationContext* opCtx, const NamespaceString& nss) {
_storageInterfaceWorkDone.droppedCollections.push_back(nss.ns());
return Status::OK();
};
- _storageInterface.dropUserDBsFn = [this](OperationContext* txn) {
+ _storageInterface.dropUserDBsFn = [this](OperationContext* opCtx) {
_storageInterfaceWorkDone.droppedUserDBs = true;
return Status::OK();
};
@@ -728,9 +728,9 @@ TEST_F(DBsClonerTest, DatabaseClonerChecksAdminDbUsingStorageInterfaceAfterCopyi
bool isAdminDbValidFnCalled = false;
OperationContext* isAdminDbValidFnOpCtx = nullptr;
_storageInterface.isAdminDbValidFn = [&isAdminDbValidFnCalled,
- &isAdminDbValidFnOpCtx](OperationContext* txn) {
+ &isAdminDbValidFnOpCtx](OperationContext* opCtx) {
isAdminDbValidFnCalled = true;
- isAdminDbValidFnOpCtx = txn;
+ isAdminDbValidFnOpCtx = opCtx;
return Status::OK();
};
@@ -770,7 +770,7 @@ TEST_F(DBsClonerTest, AdminDbValidationErrorShouldAbortTheCloner) {
Status result = getDetectableErrorStatus();
bool isAdminDbValidFnCalled = false;
- _storageInterface.isAdminDbValidFn = [&isAdminDbValidFnCalled](OperationContext* txn) {
+ _storageInterface.isAdminDbValidFn = [&isAdminDbValidFnCalled](OperationContext* opCtx) {
isAdminDbValidFnCalled = true;
return Status(ErrorCodes::OperationFailed, "admin db invalid");
};
diff --git a/src/mongo/db/repl/initial_sync.cpp b/src/mongo/db/repl/initial_sync.cpp
index 3c010185e64..ba5953f0035 100644
--- a/src/mongo/db/repl/initial_sync.cpp
+++ b/src/mongo/db/repl/initial_sync.cpp
@@ -52,26 +52,26 @@ InitialSync::~InitialSync() {}
/* initial oplog application, during initial sync, after cloning.
*/
-void InitialSync::oplogApplication(OperationContext* txn, const OpTime& endOpTime) {
+void InitialSync::oplogApplication(OperationContext* opCtx, const OpTime& endOpTime) {
if (replSetForceInitialSyncFailure > 0) {
log() << "test code invoked, forced InitialSync failure: "
<< replSetForceInitialSyncFailure;
replSetForceInitialSyncFailure--;
throw DBException("forced error", 0);
}
- _applyOplogUntil(txn, endOpTime);
+ _applyOplogUntil(opCtx, endOpTime);
}
/* applies oplog from "now" until endOpTime using the applier threads for initial sync*/
-void InitialSync::_applyOplogUntil(OperationContext* txn, const OpTime& endOpTime) {
+void InitialSync::_applyOplogUntil(OperationContext* opCtx, const OpTime& endOpTime) {
unsigned long long bytesApplied = 0;
unsigned long long entriesApplied = 0;
while (true) {
OpQueue ops;
- auto replCoord = repl::ReplicationCoordinator::get(txn);
- while (!tryPopAndWaitForMore(txn, &ops, BatchLimits{})) {
+ auto replCoord = repl::ReplicationCoordinator::get(opCtx);
+ while (!tryPopAndWaitForMore(opCtx, &ops, BatchLimits{})) {
if (globalInShutdownDeprecated()) {
return;
}
@@ -108,10 +108,10 @@ void InitialSync::_applyOplogUntil(OperationContext* txn, const OpTime& endOpTim
// Tally operation information and apply batch. Don't use ops again after these lines.
bytesApplied += ops.getBytes();
entriesApplied += ops.getCount();
- const OpTime lastOpTime = multiApply(txn, ops.releaseBatch());
+ const OpTime lastOpTime = multiApply(opCtx, ops.releaseBatch());
replCoord->setMyLastAppliedOpTime(lastOpTime);
- setNewTimestamp(txn->getServiceContext(), lastOpTime.getTimestamp());
+ setNewTimestamp(opCtx->getServiceContext(), lastOpTime.getTimestamp());
if (globalInShutdownDeprecated()) {
return;
diff --git a/src/mongo/db/repl/initial_sync.h b/src/mongo/db/repl/initial_sync.h
index 167038363a7..3afce50a11d 100644
--- a/src/mongo/db/repl/initial_sync.h
+++ b/src/mongo/db/repl/initial_sync.h
@@ -47,7 +47,7 @@ public:
/**
* applies up to endOpTime, fetching missing documents as needed.
*/
- void oplogApplication(OperationContext* txn, const OpTime& endOpTime);
+ void oplogApplication(OperationContext* opCtx, const OpTime& endOpTime);
private:
/**
@@ -55,7 +55,7 @@ private:
*
* NOTE:Will not transition or check states
*/
- void _applyOplogUntil(OperationContext* txn, const OpTime& endOpTime);
+ void _applyOplogUntil(OperationContext* opCtx, const OpTime& endOpTime);
};
// Used for ReplSetTest testing.
diff --git a/src/mongo/db/repl/master_slave.cpp b/src/mongo/db/repl/master_slave.cpp
index 7c48ec8671c..10540c0fd3c 100644
--- a/src/mongo/db/repl/master_slave.cpp
+++ b/src/mongo/db/repl/master_slave.cpp
@@ -95,7 +95,7 @@ const int restartSync = 0;
const int restartSyncAfterSleep = 1;
} // namespace
-void pretouchOperation(OperationContext* txn, const BSONObj& op);
+void pretouchOperation(OperationContext* opCtx, const BSONObj& op);
void pretouchN(vector<BSONObj>&, unsigned a, unsigned b);
/* if 1 sync() is running */
@@ -114,12 +114,12 @@ struct ReplInfo {
};
-ReplSource::ReplSource(OperationContext* txn) {
+ReplSource::ReplSource(OperationContext* opCtx) {
nClonedThisPass = 0;
- ensureMe(txn);
+ ensureMe(opCtx);
}
-ReplSource::ReplSource(OperationContext* txn, BSONObj o) : nClonedThisPass(0) {
+ReplSource::ReplSource(OperationContext* opCtx, BSONObj o) : nClonedThisPass(0) {
only = o.getStringField("only");
hostName = o.getStringField("host");
_sourceName = o.getStringField("source");
@@ -155,7 +155,7 @@ ReplSource::ReplSource(OperationContext* txn, BSONObj o) : nClonedThisPass(0) {
incompleteCloneDbs.insert(e.fieldName());
}
}
- ensureMe(txn);
+ ensureMe(opCtx);
}
/* Turn our C++ Source object into a BSONObj */
@@ -189,31 +189,31 @@ BSONObj ReplSource::jsobj() {
return b.obj();
}
-void ReplSource::ensureMe(OperationContext* txn) {
+void ReplSource::ensureMe(OperationContext* opCtx) {
string myname = getHostName();
// local.me is an identifier for a server for getLastError w:2+
- bool exists = Helpers::getSingleton(txn, "local.me", _me);
+ bool exists = Helpers::getSingleton(opCtx, "local.me", _me);
if (!exists || !_me.hasField("host") || _me["host"].String() != myname) {
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock dblk(txn->lockState(), "local", MODE_X);
- WriteUnitOfWork wunit(txn);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock dblk(opCtx->lockState(), "local", MODE_X);
+ WriteUnitOfWork wunit(opCtx);
// clean out local.me
- Helpers::emptyCollection(txn, "local.me");
+ Helpers::emptyCollection(opCtx, "local.me");
// repopulate
BSONObjBuilder b;
b.appendOID("_id", 0, true);
b.append("host", myname);
_me = b.obj();
- Helpers::putSingleton(txn, "local.me", _me);
+ Helpers::putSingleton(opCtx, "local.me", _me);
wunit.commit();
}
_me = _me.getOwned();
}
-void ReplSource::save(OperationContext* txn) {
+void ReplSource::save(OperationContext* opCtx) {
BSONObjBuilder b;
verify(!hostName.empty());
b.append("host", hostName);
@@ -226,7 +226,7 @@ void ReplSource::save(OperationContext* txn) {
LOG(1) << "Saving repl source: " << o << endl;
{
- OldClientContext ctx(txn, "local.sources", false);
+ OldClientContext ctx(opCtx, "local.sources", false);
const NamespaceString requestNs("local.sources");
UpdateRequest request(requestNs);
@@ -235,14 +235,14 @@ void ReplSource::save(OperationContext* txn) {
request.setUpdates(o);
request.setUpsert();
- UpdateResult res = update(txn, ctx.db(), request);
+ UpdateResult res = update(opCtx, ctx.db(), request);
verify(!res.modifiers);
verify(res.numMatched == 1 || !res.upserted.isEmpty());
}
}
-static void addSourceToList(OperationContext* txn,
+static void addSourceToList(OperationContext* opCtx,
ReplSource::SourceVector& v,
ReplSource& s,
ReplSource::SourceVector& old) {
@@ -263,9 +263,9 @@ static void addSourceToList(OperationContext* txn,
/* we reuse our existing objects so that we can keep our existing connection
and cursor in effect.
*/
-void ReplSource::loadAll(OperationContext* txn, SourceVector& v) {
+void ReplSource::loadAll(OperationContext* opCtx, SourceVector& v) {
const char* localSources = "local.sources";
- OldClientContext ctx(txn, localSources, false);
+ OldClientContext ctx(opCtx, localSources, false);
SourceVector old = v;
v.clear();
@@ -275,13 +275,16 @@ void ReplSource::loadAll(OperationContext* txn, SourceVector& v) {
// check that no items are in sources other than that
// add if missing
int n = 0;
- unique_ptr<PlanExecutor> exec(InternalPlanner::collectionScan(
- txn, localSources, ctx.db()->getCollection(localSources), PlanExecutor::YIELD_MANUAL));
+ unique_ptr<PlanExecutor> exec(
+ InternalPlanner::collectionScan(opCtx,
+ localSources,
+ ctx.db()->getCollection(localSources),
+ PlanExecutor::YIELD_MANUAL));
BSONObj obj;
PlanExecutor::ExecState state;
while (PlanExecutor::ADVANCED == (state = exec->getNext(&obj, NULL))) {
n++;
- ReplSource tmp(txn, obj);
+ ReplSource tmp(opCtx, obj);
if (tmp.hostName != replSettings.getSource()) {
log() << "--source " << replSettings.getSource() << " != " << tmp.hostName
<< " from local.sources collection" << endl;
@@ -303,10 +306,10 @@ void ReplSource::loadAll(OperationContext* txn, SourceVector& v) {
uassert(10002, "local.sources collection corrupt?", n < 2);
if (n == 0) {
// source missing. add.
- ReplSource s(txn);
+ ReplSource s(opCtx);
s.hostName = replSettings.getSource();
s.only = replSettings.getOnly();
- s.save(txn);
+ s.save(opCtx);
}
} else {
try {
@@ -317,41 +320,41 @@ void ReplSource::loadAll(OperationContext* txn, SourceVector& v) {
}
unique_ptr<PlanExecutor> exec(InternalPlanner::collectionScan(
- txn, localSources, ctx.db()->getCollection(localSources), PlanExecutor::YIELD_MANUAL));
+ opCtx, localSources, ctx.db()->getCollection(localSources), PlanExecutor::YIELD_MANUAL));
BSONObj obj;
PlanExecutor::ExecState state;
while (PlanExecutor::ADVANCED == (state = exec->getNext(&obj, NULL))) {
- ReplSource tmp(txn, obj);
+ ReplSource tmp(opCtx, obj);
if (tmp.syncedTo.isNull()) {
- DBDirectClient c(txn);
+ DBDirectClient c(opCtx);
BSONObj op = c.findOne("local.oplog.$main",
QUERY("op" << NE << "n").sort(BSON("$natural" << -1)));
if (!op.isEmpty()) {
tmp.syncedTo = op["ts"].timestamp();
}
}
- addSourceToList(txn, v, tmp, old);
+ addSourceToList(opCtx, v, tmp, old);
}
uassert(17066, "Internal error reading from local.sources", PlanExecutor::IS_EOF == state);
}
-bool ReplSource::throttledForceResyncDead(OperationContext* txn, const char* requester) {
+bool ReplSource::throttledForceResyncDead(OperationContext* opCtx, const char* requester) {
if (time(0) - lastForcedResync > 600) {
- forceResyncDead(txn, requester);
+ forceResyncDead(opCtx, requester);
lastForcedResync = time(0);
return true;
}
return false;
}
-void ReplSource::forceResyncDead(OperationContext* txn, const char* requester) {
+void ReplSource::forceResyncDead(OperationContext* opCtx, const char* requester) {
if (!replAllDead)
return;
SourceVector sources;
- ReplSource::loadAll(txn, sources);
+ ReplSource::loadAll(opCtx, sources);
for (SourceVector::iterator i = sources.begin(); i != sources.end(); ++i) {
log() << requester << " forcing resync from " << (*i)->hostName << endl;
- (*i)->forceResync(txn, requester);
+ (*i)->forceResync(opCtx, requester);
}
replAllDead = 0;
}
@@ -379,7 +382,7 @@ public:
out->push_back(Privilege(ResourcePattern::forClusterResource(), actions));
}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string& ns,
BSONObj& cmdObj,
int options,
@@ -391,9 +394,9 @@ public:
return appendCommandStatus(result, status);
}
- ReplClientInfo::forClient(txn->getClient()).setRemoteID(handshake.getRid());
+ ReplClientInfo::forClient(opCtx->getClient()).setRemoteID(handshake.getRid());
- status = getGlobalReplicationCoordinator()->processHandshake(txn, handshake);
+ status = getGlobalReplicationCoordinator()->processHandshake(opCtx, handshake);
return appendCommandStatus(result, status);
}
@@ -429,12 +432,12 @@ bool ReplSource::_connect(OplogReader* reader, const HostAndPort& host, const OI
}
-void ReplSource::forceResync(OperationContext* txn, const char* requester) {
+void ReplSource::forceResync(OperationContext* opCtx, const char* requester) {
BSONObj info;
{
// This is always a GlobalWrite lock (so no ns/db used from the context)
- invariant(txn->lockState()->isW());
- Lock::TempRelease tempRelease(txn->lockState());
+ invariant(opCtx->lockState()->isW());
+ Lock::TempRelease tempRelease(opCtx->lockState());
if (!_connect(&oplogReader,
HostAndPort(hostName),
@@ -456,14 +459,14 @@ void ReplSource::forceResync(OperationContext* txn, const char* requester) {
if (!e.embeddedObject().getBoolField("empty")) {
if (name != "local") {
if (only.empty() || only == name) {
- resyncDrop(txn, name);
+ resyncDrop(opCtx, name);
}
}
}
}
syncedTo = Timestamp();
addDbNextPass.clear();
- save(txn);
+ save(opCtx);
}
Status ReplSource::_updateIfDoneWithInitialSync() {
@@ -483,23 +486,23 @@ Status ReplSource::_updateIfDoneWithInitialSync() {
return Status::OK();
}
-void ReplSource::resyncDrop(OperationContext* txn, const string& dbName) {
+void ReplSource::resyncDrop(OperationContext* opCtx, const string& dbName) {
log() << "resync: dropping database " << dbName;
- invariant(txn->lockState()->isW());
+ invariant(opCtx->lockState()->isW());
- Database* const db = dbHolder().get(txn, dbName);
+ Database* const db = dbHolder().get(opCtx, dbName);
if (!db) {
log() << "resync: dropping database " << dbName
<< " - database does not exist. nothing to do.";
return;
}
- Database::dropDatabase(txn, db);
+ Database::dropDatabase(opCtx, db);
}
/* grab initial copy of a database from the master */
-void ReplSource::resync(OperationContext* txn, const std::string& dbName) {
+void ReplSource::resync(OperationContext* opCtx, const std::string& dbName) {
const std::string db(dbName); // need local copy of the name, we're dropping the original
- resyncDrop(txn, db);
+ resyncDrop(opCtx, db);
{
log() << "resync: cloning database " << db << " to get an initial copy" << endl;
@@ -512,11 +515,11 @@ void ReplSource::resync(OperationContext* txn, const std::string& dbName) {
cloneOptions.snapshot = true;
Cloner cloner;
- Status status = cloner.copyDb(txn, db, hostName.c_str(), cloneOptions, NULL);
+ Status status = cloner.copyDb(opCtx, db, hostName.c_str(), cloneOptions, NULL);
if (!status.isOK()) {
if (status.code() == ErrorCodes::DatabaseDifferCase) {
- resyncDrop(txn, db);
+ resyncDrop(opCtx, db);
log() << "resync: database " << db
<< " not valid on the master due to a name conflict, dropping.";
return;
@@ -552,12 +555,12 @@ bool DatabaseIgnorer::ignoreAt(const string& db, const Timestamp& currentOplogTi
}
}
-bool ReplSource::handleDuplicateDbName(OperationContext* txn,
+bool ReplSource::handleDuplicateDbName(OperationContext* opCtx,
const BSONObj& op,
const char* ns,
const char* db) {
// We are already locked at this point
- if (dbHolder().get(txn, ns) != NULL) {
+ if (dbHolder().get(opCtx, ns) != NULL) {
// Database is already present.
return true;
}
@@ -577,8 +580,8 @@ bool ReplSource::handleDuplicateDbName(OperationContext* txn,
bool dbOk = false;
{
// This is always a GlobalWrite lock (so no ns/db used from the context)
- invariant(txn->lockState()->isW());
- Lock::TempRelease tempRelease(txn->lockState());
+ invariant(opCtx->lockState()->isW());
+ Lock::TempRelease tempRelease(opCtx->lockState());
// We always log an operation after executing it (never before), so
// a database list will always be valid as of an oplog entry generated
@@ -634,8 +637,8 @@ bool ReplSource::handleDuplicateDbName(OperationContext* txn,
incompleteCloneDbs.erase(*i);
addDbNextPass.erase(*i);
- AutoGetDb autoDb(txn, *i, MODE_X);
- Database::dropDatabase(txn, autoDb.getDb());
+ AutoGetDb autoDb(opCtx, *i, MODE_X);
+ Database::dropDatabase(opCtx, autoDb.getDb());
}
massert(14034,
@@ -644,16 +647,16 @@ bool ReplSource::handleDuplicateDbName(OperationContext* txn,
return true;
}
-void ReplSource::applyCommand(OperationContext* txn, const BSONObj& op) {
+void ReplSource::applyCommand(OperationContext* opCtx, const BSONObj& op) {
try {
- Status status = applyCommand_inlock(txn, op, true);
+ Status status = applyCommand_inlock(opCtx, op, true);
if (!status.isOK()) {
SyncTail sync(nullptr, SyncTail::MultiSyncApplyFunc());
sync.setHostname(hostName);
- if (sync.shouldRetry(txn, op)) {
+ if (sync.shouldRetry(opCtx, op)) {
uassert(28639,
"Failure retrying initial sync update",
- applyCommand_inlock(txn, op, true).isOK());
+ applyCommand_inlock(opCtx, op, true).isOK());
}
}
} catch (UserException& e) {
@@ -667,16 +670,16 @@ void ReplSource::applyCommand(OperationContext* txn, const BSONObj& op) {
}
}
-void ReplSource::applyOperation(OperationContext* txn, Database* db, const BSONObj& op) {
+void ReplSource::applyOperation(OperationContext* opCtx, Database* db, const BSONObj& op) {
try {
- Status status = applyOperation_inlock(txn, db, op);
+ Status status = applyOperation_inlock(opCtx, db, op);
if (!status.isOK()) {
SyncTail sync(nullptr, SyncTail::MultiSyncApplyFunc());
sync.setHostname(hostName);
- if (sync.shouldRetry(txn, op)) {
+ if (sync.shouldRetry(opCtx, op)) {
uassert(15914,
"Failure retrying initial sync update",
- applyOperation_inlock(txn, db, op).isOK());
+ applyOperation_inlock(opCtx, db, op).isOK());
}
}
} catch (UserException& e) {
@@ -697,7 +700,7 @@ void ReplSource::applyOperation(OperationContext* txn, Database* db, const BSONO
@param alreadyLocked caller already put us in write lock if true
*/
-void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* txn,
+void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* opCtx,
BSONObj& op,
bool alreadyLocked) {
LOG(6) << "processing op: " << redact(op) << endl;
@@ -725,10 +728,10 @@ void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* txn,
if (!only.empty() && only != dbName)
return;
- // Push the CurOp stack for "txn" so each individual oplog entry application is separately
+ // Push the CurOp stack for "opCtx" so each individual oplog entry application is separately
// reported.
- CurOp individualOp(txn);
- txn->setReplicatedWrites(false);
+ CurOp individualOp(opCtx);
+ opCtx->setReplicatedWrites(false);
const ReplSettings& replSettings = getGlobalReplicationCoordinator()->getSettings();
if (replSettings.getPretouch() &&
!alreadyLocked /*doesn't make sense if in write lock already*/) {
@@ -759,16 +762,16 @@ void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* txn,
a += m;
}
// we do one too...
- pretouchOperation(txn, op);
+ pretouchOperation(opCtx, op);
tp->join();
countdown = v.size();
}
} else {
- pretouchOperation(txn, op);
+ pretouchOperation(opCtx, op);
}
}
- unique_ptr<Lock::GlobalWrite> lk(alreadyLocked ? 0 : new Lock::GlobalWrite(txn->lockState()));
+ unique_ptr<Lock::GlobalWrite> lk(alreadyLocked ? 0 : new Lock::GlobalWrite(opCtx->lockState()));
if (replAllDead) {
// hmmm why is this check here and not at top of this function? does it get set between top
@@ -777,20 +780,20 @@ void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* txn,
throw SyncException();
}
- if (!handleDuplicateDbName(txn, op, ns, dbName)) {
+ if (!handleDuplicateDbName(opCtx, op, ns, dbName)) {
return;
}
// special case apply for commands to avoid implicit database creation
if (*op.getStringField("op") == 'c') {
- applyCommand(txn, op);
+ applyCommand(opCtx, op);
return;
}
// This code executes on the slaves only, so it doesn't need to be sharding-aware since
// mongos will not send requests there. That's why the last argument is false (do not do
// version checking).
- OldClientContext ctx(txn, ns, false);
+ OldClientContext ctx(opCtx, ns, false);
bool empty = !ctx.db()->getDatabaseCatalogEntry()->hasUserData();
bool incompleteClone = incompleteCloneDbs.count(dbName) != 0;
@@ -813,16 +816,16 @@ void ReplSource::_sync_pullOpLog_applyOperation(OperationContext* txn,
log() << "An earlier initial clone of '" << dbName
<< "' did not complete, now resyncing." << endl;
}
- save(txn);
- OldClientContext ctx(txn, ns, false);
+ save(opCtx);
+ OldClientContext ctx(opCtx, ns, false);
nClonedThisPass++;
- resync(txn, ctx.db()->name());
+ resync(opCtx, ctx.db()->name());
addDbNextPass.erase(dbName);
incompleteCloneDbs.erase(dbName);
}
- save(txn);
+ save(opCtx);
} else {
- applyOperation(txn, ctx.db(), op);
+ applyOperation(opCtx, ctx.db(), op);
addDbNextPass.erase(dbName);
}
}
@@ -877,7 +880,7 @@ public:
0 ok, don't sleep
1 ok, sleep
*/
-int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
+int ReplSource::_sync_pullOpLog(OperationContext* opCtx, int& nApplied) {
int okResultCode = restartSyncAfterSleep;
string ns = string("local.oplog.$") + sourceName();
LOG(2) << "sync_pullOpLog " << ns << " syncedTo:" << syncedTo.toStringLong() << '\n';
@@ -911,9 +914,9 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
}
// obviously global isn't ideal, but non-repl set is old so
// keeping it simple
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite lk(txn->lockState());
- save(txn);
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite lk(opCtx->lockState());
+ save(opCtx);
}
BSONObjBuilder gte;
@@ -948,7 +951,7 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
b.append("ns", *i + '.');
b.append("op", "db");
BSONObj op = b.done();
- _sync_pullOpLog_applyOperation(txn, op, false);
+ _sync_pullOpLog_applyOperation(opCtx, op, false);
}
}
@@ -974,9 +977,9 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
log() << ns << " oplog is empty" << endl;
}
{
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite lk(txn->lockState());
- save(txn);
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite lk(opCtx->lockState());
+ save(opCtx);
}
return okResultCode;
}
@@ -1042,26 +1045,26 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
const bool moreInitialSyncsPending = !addDbNextPass.empty() && n;
if (moreInitialSyncsPending || !oplogReader.more()) {
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite lk(txn->lockState());
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite lk(opCtx->lockState());
if (tailing) {
okResultCode = restartSync; // don't sleep
}
syncedTo = nextOpTime;
- save(txn); // note how far we are synced up to now
+ save(opCtx); // note how far we are synced up to now
nApplied = n;
break;
}
OCCASIONALLY if (n > 0 && (n > 100000 || time(0) - saveLast > 60)) {
// periodically note our progress, in case we are doing a lot of work and crash
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite lk(txn->lockState());
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite lk(opCtx->lockState());
syncedTo = nextOpTime;
// can't update local log ts since there are pending operations from our peer
- save(txn);
+ save(opCtx);
log() << "checkpoint applied " << n << " operations" << endl;
log() << "syncedTo: " << syncedTo.toStringLong() << endl;
saveLast = time(0);
@@ -1072,7 +1075,8 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
int b = replApplyBatchSize.load();
bool justOne = b == 1;
- unique_ptr<Lock::GlobalWrite> lk(justOne ? 0 : new Lock::GlobalWrite(txn->lockState()));
+ unique_ptr<Lock::GlobalWrite> lk(justOne ? 0
+ : new Lock::GlobalWrite(opCtx->lockState()));
while (1) {
BSONElement ts = op.getField("ts");
if (!(ts.type() == Date || ts.type() == bsonTimestamp)) {
@@ -1104,11 +1108,11 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
oplogReader.putBack(op);
_sleepAdviceTime = nextOpTime.getSecs() +
durationCount<Seconds>(replSettings.getSlaveDelaySecs()) + 1;
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite lk(txn->lockState());
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite lk(opCtx->lockState());
if (n > 0) {
syncedTo = last;
- save(txn);
+ save(opCtx);
}
log() << "applied " << n << " operations" << endl;
log() << "syncedTo: " << syncedTo.toStringLong() << endl;
@@ -1116,7 +1120,7 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
return okResultCode;
}
- _sync_pullOpLog_applyOperation(txn, op, !justOne);
+ _sync_pullOpLog_applyOperation(opCtx, op, !justOne);
n++;
if (--b == 0)
@@ -1139,7 +1143,7 @@ int ReplSource::_sync_pullOpLog(OperationContext* txn, int& nApplied) {
returns >= 0 if ok. return -1 if you want to reconnect.
return value of zero indicates no sleep necessary before next call
*/
-int ReplSource::sync(OperationContext* txn, int& nApplied) {
+int ReplSource::sync(OperationContext* opCtx, int& nApplied) {
_sleepAdviceTime = 0;
ReplInfo r("sync");
if (!serverGlobalParams.quiet.load()) {
@@ -1167,7 +1171,7 @@ int ReplSource::sync(OperationContext* txn, int& nApplied) {
return -1;
}
- return _sync_pullOpLog(txn, nApplied);
+ return _sync_pullOpLog(opCtx, nApplied);
}
/* --------------------------------------------------------------*/
@@ -1184,12 +1188,12 @@ _ reuse that cursor when we can
0 = no sleep recommended
1 = special sentinel indicating adaptive sleep recommended
*/
-int _replMain(OperationContext* txn, ReplSource::SourceVector& sources, int& nApplied) {
+int _replMain(OperationContext* opCtx, ReplSource::SourceVector& sources, int& nApplied) {
{
ReplInfo r("replMain load sources");
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite lk(txn->lockState());
- ReplSource::loadAll(txn, sources);
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite lk(opCtx->lockState());
+ ReplSource::loadAll(opCtx, sources);
// only need this param for initial reset
_replMainStarted = true;
@@ -1208,7 +1212,7 @@ int _replMain(OperationContext* txn, ReplSource::SourceVector& sources, int& nAp
ReplSource* s = i->get();
int res = forceReconnect;
try {
- res = s->sync(txn, nApplied);
+ res = s->sync(opCtx, nApplied);
bool moreToSync = s->haveMoreDbsToSync();
if (res < 0) {
sleepAdvice = 3;
@@ -1245,17 +1249,17 @@ int _replMain(OperationContext* txn, ReplSource::SourceVector& sources, int& nAp
return sleepAdvice;
}
-static void replMain(OperationContext* txn) {
+static void replMain(OperationContext* opCtx) {
ReplSource::SourceVector sources;
while (1) {
auto s = restartSync;
{
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite lk(txn->lockState());
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite lk(opCtx->lockState());
if (replAllDead) {
// throttledForceResyncDead can throw
if (!getGlobalReplicationCoordinator()->getSettings().isAutoResyncEnabled() ||
- !ReplSource::throttledForceResyncDead(txn, "auto")) {
+ !ReplSource::throttledForceResyncDead(opCtx, "auto")) {
log() << "all sources dead: " << replAllDead << ", sleeping for 5 seconds"
<< endl;
break;
@@ -1268,7 +1272,7 @@ static void replMain(OperationContext* txn) {
try {
int nApplied = 0;
- s = _replMain(txn, sources, nApplied);
+ s = _replMain(opCtx, sources, nApplied);
if (s == restartSyncAfterSleep) {
if (nApplied == 0)
s = 2;
@@ -1284,8 +1288,8 @@ static void replMain(OperationContext* txn) {
}
{
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite lk(txn->lockState());
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite lk(opCtx->lockState());
invariant(syncing.swap(0) == 1);
}
@@ -1316,17 +1320,17 @@ static void replMasterThread() {
// Write a keep-alive like entry to the log. This will make things like
// printReplicationStatus() and printSlaveReplicationStatus() stay up-to-date even
// when things are idle.
- const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
- OperationContext& txn = *txnPtr;
- AuthorizationSession::get(txn.getClient())->grantInternalAuthorization();
+ const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+ OperationContext& opCtx = *opCtxPtr;
+ AuthorizationSession::get(opCtx.getClient())->grantInternalAuthorization();
- Lock::GlobalWrite globalWrite(txn.lockState(), 1);
+ Lock::GlobalWrite globalWrite(opCtx.lockState(), 1);
if (globalWrite.isLocked()) {
toSleep = 10;
try {
- WriteUnitOfWork wuow(&txn);
- getGlobalServiceContext()->getOpObserver()->onOpMessage(&txn, BSONObj());
+ WriteUnitOfWork wuow(&opCtx);
+ getGlobalServiceContext()->getOpObserver()->onOpMessage(&opCtx, BSONObj());
wuow.commit();
} catch (...) {
log() << "caught exception in replMasterThread()" << endl;
@@ -1342,14 +1346,14 @@ static void replSlaveThread() {
sleepsecs(1);
Client::initThread("replslave");
- const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
- OperationContext& txn = *txnPtr;
- AuthorizationSession::get(txn.getClient())->grantInternalAuthorization();
- DisableDocumentValidation validationDisabler(&txn);
+ const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+ OperationContext& opCtx = *opCtxPtr;
+ AuthorizationSession::get(opCtx.getClient())->grantInternalAuthorization();
+ DisableDocumentValidation validationDisabler(&opCtx);
while (1) {
try {
- replMain(&txn);
+ replMain(&opCtx);
sleepsecs(5);
} catch (AssertionException&) {
ReplInfo r("Assertion in replSlaveThread(): sleeping 5 minutes before retry");
@@ -1366,15 +1370,15 @@ static void replSlaveThread() {
}
}
-void startMasterSlave(OperationContext* txn) {
+void startMasterSlave(OperationContext* opCtx) {
const ReplSettings& replSettings = getGlobalReplicationCoordinator()->getSettings();
if (!replSettings.isSlave() && !replSettings.isMaster())
return;
- AuthorizationSession::get(txn->getClient())->grantInternalAuthorization();
+ AuthorizationSession::get(opCtx->getClient())->grantInternalAuthorization();
{
- ReplSource temp(txn); // Ensures local.me is populated
+ ReplSource temp(opCtx); // Ensures local.me is populated
}
if (replSettings.isSlave()) {
@@ -1385,7 +1389,7 @@ void startMasterSlave(OperationContext* txn) {
if (replSettings.isMaster()) {
LOG(1) << "master=true" << endl;
- createOplog(txn);
+ createOplog(opCtx);
stdx::thread t(replMasterThread);
t.detach();
}
@@ -1400,10 +1404,10 @@ int _dummy_z;
void pretouchN(vector<BSONObj>& v, unsigned a, unsigned b) {
Client::initThreadIfNotAlready("pretouchN");
- const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
- OperationContext& txn = *txnPtr; // XXX
- ScopedTransaction transaction(&txn, MODE_S);
- Lock::GlobalRead lk(txn.lockState());
+ const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+ OperationContext& opCtx = *opCtxPtr; // XXX
+ ScopedTransaction transaction(&opCtx, MODE_S);
+ Lock::GlobalRead lk(opCtx.lockState());
for (unsigned i = a; i <= b; i++) {
const BSONObj& op = v[i];
@@ -1425,8 +1429,8 @@ void pretouchN(vector<BSONObj>& v, unsigned a, unsigned b) {
BSONObjBuilder b;
b.append(_id);
BSONObj result;
- OldClientContext ctx(&txn, ns, false);
- if (Helpers::findById(&txn, ctx.db(), ns, b.done(), result))
+ OldClientContext ctx(&opCtx, ns, false);
+ if (Helpers::findById(&opCtx, ctx.db(), ns, b.done(), result))
_dummy_z += result.objsize(); // touch
}
} catch (DBException& e) {
@@ -1436,8 +1440,8 @@ void pretouchN(vector<BSONObj>& v, unsigned a, unsigned b) {
}
}
-void pretouchOperation(OperationContext* txn, const BSONObj& op) {
- if (txn->lockState()->isWriteLocked()) {
+void pretouchOperation(OperationContext* opCtx, const BSONObj& op) {
+ if (opCtx->lockState()->isWriteLocked()) {
// no point pretouching if write locked. not sure if this will ever fire, but just in case.
return;
}
@@ -1460,8 +1464,8 @@ void pretouchOperation(OperationContext* txn, const BSONObj& op) {
BSONObjBuilder b;
b.append(_id);
BSONObj result;
- AutoGetCollectionForRead ctx(txn, NamespaceString(ns));
- if (Helpers::findById(txn, ctx.getDb(), ns, b.done(), result)) {
+ AutoGetCollectionForRead ctx(opCtx, NamespaceString(ns));
+ if (Helpers::findById(opCtx, ctx.getDb(), ns, b.done(), result)) {
_dummy_z += result.objsize(); // touch
}
}
diff --git a/src/mongo/db/repl/master_slave.h b/src/mongo/db/repl/master_slave.h
index 3a869a750ba..627223efd16 100644
--- a/src/mongo/db/repl/master_slave.h
+++ b/src/mongo/db/repl/master_slave.h
@@ -50,7 +50,7 @@ class OperationContext;
namespace repl {
// Main entry point for master/slave at startup time.
-void startMasterSlave(OperationContext* txn);
+void startMasterSlave(OperationContext* opCtx);
// externed for use with resync.cpp
extern AtomicInt32 relinquishSyncingSome;
@@ -78,15 +78,15 @@ public:
class ReplSource {
std::shared_ptr<OldThreadPool> tp;
- void resync(OperationContext* txn, const std::string& dbName);
+ void resync(OperationContext* opCtx, const std::string& dbName);
/** @param alreadyLocked caller already put us in write lock if true */
- void _sync_pullOpLog_applyOperation(OperationContext* txn, BSONObj& op, bool alreadyLocked);
+ void _sync_pullOpLog_applyOperation(OperationContext* opCtx, BSONObj& op, bool alreadyLocked);
/* pull some operations from the master's oplog, and apply them.
calls sync_pullOpLog_applyOperation
*/
- int _sync_pullOpLog(OperationContext* txn, int& nApplied);
+ int _sync_pullOpLog(OperationContext* opCtx, int& nApplied);
/* we only clone one database per pass, even if a lot need done. This helps us
avoid overflowing the master's transaction log by doing too much work before going
@@ -106,7 +106,7 @@ class ReplSource {
*/
bool _doHandshake = false;
- void resyncDrop(OperationContext* txn, const std::string& dbName);
+ void resyncDrop(OperationContext* opCtx, const std::string& dbName);
// call without the db mutex
void syncToTailOfRemoteLog();
std::string ns() const {
@@ -120,16 +120,16 @@ class ReplSource {
* master.
* @return true iff an op with the specified ns may be applied.
*/
- bool handleDuplicateDbName(OperationContext* txn,
+ bool handleDuplicateDbName(OperationContext* opCtx,
const BSONObj& op,
const char* ns,
const char* db);
// populates _me so that it can be passed to oplogreader for handshakes
/// TODO(spencer): Remove this function once the LegacyReplicationCoordinator is gone.
- void ensureMe(OperationContext* txn);
+ void ensureMe(OperationContext* opCtx);
- void forceResync(OperationContext* txn, const char* requester);
+ void forceResync(OperationContext* opCtx, const char* requester);
bool _connect(OplogReader* reader, const HostAndPort& host, const OID& myRID);
@@ -138,8 +138,8 @@ class ReplSource {
public:
OplogReader oplogReader;
- void applyCommand(OperationContext* txn, const BSONObj& op);
- void applyOperation(OperationContext* txn, Database* db, const BSONObj& op);
+ void applyCommand(OperationContext* opCtx, const BSONObj& op);
+ void applyOperation(OperationContext* opCtx, Database* db, const BSONObj& op);
std::string hostName; // ip addr or hostname plus optionally, ":<port>"
std::string _sourceName; // a logical source name.
std::string sourceName() const {
@@ -156,18 +156,18 @@ public:
int nClonedThisPass;
typedef std::vector<std::shared_ptr<ReplSource>> SourceVector;
- static void loadAll(OperationContext* txn, SourceVector&);
+ static void loadAll(OperationContext* opCtx, SourceVector&);
- explicit ReplSource(OperationContext* txn, BSONObj);
+ explicit ReplSource(OperationContext* opCtx, BSONObj);
// This is not the constructor you are looking for. Always prefer the version that takes
// a BSONObj. This is public only as a hack so that the ReplicationCoordinator can find
// out the process's RID in master/slave setups.
- ReplSource(OperationContext* txn);
+ ReplSource(OperationContext* opCtx);
/* -1 = error */
- int sync(OperationContext* txn, int& nApplied);
+ int sync(OperationContext* opCtx, int& nApplied);
- void save(OperationContext* txn); // write ourself to local.sources
+ void save(OperationContext* opCtx); // write ourself to local.sources
// make a jsobj from our member fields of the form
// { host: ..., source: ..., syncedTo: ... }
@@ -190,8 +190,8 @@ public:
return wait > 0 ? wait : 0;
}
- static bool throttledForceResyncDead(OperationContext* txn, const char* requester);
- static void forceResyncDead(OperationContext* txn, const char* requester);
+ static bool throttledForceResyncDead(OperationContext* opCtx, const char* requester);
+ static void forceResyncDead(OperationContext* opCtx, const char* requester);
};
/**
diff --git a/src/mongo/db/repl/multiapplier.cpp b/src/mongo/db/repl/multiapplier.cpp
index 036ab4f0d4d..ac78a4f2c8c 100644
--- a/src/mongo/db/repl/multiapplier.cpp
+++ b/src/mongo/db/repl/multiapplier.cpp
@@ -159,8 +159,8 @@ void MultiApplier::_callback(const executor::TaskExecutor::CallbackArgs& cbd) {
StatusWith<OpTime> applyStatus(ErrorCodes::InternalError, "not mutated");
try {
- auto txn = cc().makeOperationContext();
- applyStatus = _multiApply(txn.get(), _operations, _applyOperation);
+ auto opCtx = cc().makeOperationContext();
+ applyStatus = _multiApply(opCtx.get(), _operations, _applyOperation);
} catch (...) {
applyStatus = exceptionToStatus();
}
diff --git a/src/mongo/db/repl/multiapplier_test.cpp b/src/mongo/db/repl/multiapplier_test.cpp
index 9df868384c2..dcbd6979adf 100644
--- a/src/mongo/db/repl/multiapplier_test.cpp
+++ b/src/mongo/db/repl/multiapplier_test.cpp
@@ -156,7 +156,7 @@ TEST_F(MultiApplierTest, MultiApplierInvokesCallbackWithCallbackCanceledStatusUp
const MultiApplier::Operations operations{OplogEntry(BSON("ts" << Timestamp(Seconds(123), 0)))};
bool multiApplyInvoked = false;
- auto multiApply = [&](OperationContext* txn,
+ auto multiApply = [&](OperationContext* opCtx,
MultiApplier::Operations operations,
MultiApplier::ApplyOperationFn) -> StatusWith<OpTime> {
multiApplyInvoked = true;
@@ -223,7 +223,7 @@ TEST_F(MultiApplierTest, MultiApplierCatchesMultiApplyExceptionAndConvertsToCall
bool multiApplyInvoked = false;
Status multiApplyError(ErrorCodes::OperationFailed, "multi apply failed");
- auto multiApply = [&](OperationContext* txn,
+ auto multiApply = [&](OperationContext* opCtx,
MultiApplier::Operations operations,
MultiApplier::ApplyOperationFn) -> StatusWith<OpTime> {
multiApplyInvoked = true;
@@ -255,10 +255,10 @@ TEST_F(
OperationContext* multiApplyTxn = nullptr;
MultiApplier::Operations operationsToApply;
- auto multiApply = [&](OperationContext* txn,
+ auto multiApply = [&](OperationContext* opCtx,
MultiApplier::Operations operations,
MultiApplier::ApplyOperationFn) -> StatusWith<OpTime> {
- multiApplyTxn = txn;
+ multiApplyTxn = opCtx;
operationsToApply = operations;
return operationsToApply.back().getOpTime();
};
diff --git a/src/mongo/db/repl/noop_writer.cpp b/src/mongo/db/repl/noop_writer.cpp
index c12425fd423..f127b236614 100644
--- a/src/mongo/db/repl/noop_writer.cpp
+++ b/src/mongo/db/repl/noop_writer.cpp
@@ -77,8 +77,8 @@ private:
void run(Seconds waitTime, NoopWriteFn noopWrite) {
Client::initThread("NoopWriter");
while (true) {
- const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
- OperationContext& txn = *txnPtr;
+ const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+ OperationContext& opCtx = *opCtxPtr;
{
stdx::unique_lock<stdx::mutex> lk(_mutex);
_cv.wait_for(lk, waitTime.toSystemDuration(), [&] { return _inShutdown; });
@@ -86,7 +86,7 @@ private:
if (_inShutdown)
return;
}
- noopWrite(&txn);
+ noopWrite(&opCtx);
}
}
@@ -126,7 +126,7 @@ Status NoopWriter::startWritingPeriodicNoops(OpTime lastKnownOpTime) {
invariant(!_noopRunner);
_noopRunner = stdx::make_unique<PeriodicNoopRunner>(
- _writeInterval, [this](OperationContext* txn) { _writeNoop(txn); });
+ _writeInterval, [this](OperationContext* opCtx) { _writeNoop(opCtx); });
return Status::OK();
}
@@ -135,20 +135,20 @@ void NoopWriter::stopWritingPeriodicNoops() {
_noopRunner.reset();
}
-void NoopWriter::_writeNoop(OperationContext* txn) {
- ScopedTransaction transaction(txn, MODE_IX);
+void NoopWriter::_writeNoop(OperationContext* opCtx) {
+ ScopedTransaction transaction(opCtx, MODE_IX);
// Use GlobalLock + lockMMAPV1Flush instead of DBLock to allow return when the lock is not
// available. It may happen when the primary steps down and a shared global lock is acquired.
- Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
+ Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
if (!lock.isLocked()) {
LOG(1) << "Global lock is not available skipping noopWrite";
return;
}
- txn->lockState()->lockMMAPV1Flush();
+ opCtx->lockState()->lockMMAPV1Flush();
- auto replCoord = ReplicationCoordinator::get(txn);
+ auto replCoord = ReplicationCoordinator::get(opCtx);
// Its a proxy for being a primary
- if (!replCoord->canAcceptWritesForDatabase(txn, "admin")) {
+ if (!replCoord->canAcceptWritesForDatabase(opCtx, "admin")) {
LOG(1) << "Not a primary, skipping the noop write";
return;
}
@@ -166,11 +166,12 @@ void NoopWriter::_writeNoop(OperationContext* txn) {
<< "Writing noop to oplog as there has been no writes to this replica set in over "
<< _writeInterval;
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- WriteUnitOfWork uow(txn);
- txn->getClient()->getServiceContext()->getOpObserver()->onOpMessage(txn, kMsgObj);
+ WriteUnitOfWork uow(opCtx);
+ opCtx->getClient()->getServiceContext()->getOpObserver()->onOpMessage(opCtx,
+ kMsgObj);
uow.commit();
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "writeNoop", rsOplogName);
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "writeNoop", rsOplogName);
}
}
diff --git a/src/mongo/db/repl/oplog.cpp b/src/mongo/db/repl/oplog.cpp
index e394df05efd..9db957bb00c 100644
--- a/src/mongo/db/repl/oplog.cpp
+++ b/src/mongo/db/repl/oplog.cpp
@@ -145,13 +145,13 @@ struct OplogSlot {
* function registers the new optime with the storage system and the replication coordinator,
* and provides no facility to revert those registrations on rollback.
*/
-void getNextOpTime(OperationContext* txn,
+void getNextOpTime(OperationContext* opCtx,
Collection* oplog,
ReplicationCoordinator* replCoord,
ReplicationCoordinator::Mode replicationMode,
unsigned count,
OplogSlot* slotsOut) {
- synchronizeOnCappedInFlightResource(txn->lockState(), oplog->ns());
+ synchronizeOnCappedInFlightResource(opCtx->lockState(), oplog->ns());
long long term = OpTime::kUninitializedTerm;
// Fetch term out of the newOpMutex.
@@ -163,10 +163,10 @@ void getNextOpTime(OperationContext* txn,
stdx::lock_guard<stdx::mutex> lk(newOpMutex);
- auto ts = LogicalClock::get(txn)->reserveTicks(count).asTimestamp();
+ auto ts = LogicalClock::get(opCtx)->reserveTicks(count).asTimestamp();
newTimestampNotifier.notify_all();
- fassert(28560, oplog->getRecordStore()->oplogDiskLocRegister(txn, ts));
+ fassert(28560, oplog->getRecordStore()->oplogDiskLocRegister(opCtx, ts));
// Set hash if we're in replset mode, otherwise it remains 0 in master/slave.
const bool needHash = (replicationMode == ReplicationCoordinator::modeReplSet);
@@ -229,11 +229,12 @@ void setOplogCollectionName() {
namespace {
-Collection* getLocalOplogCollection(OperationContext* txn, const std::string& oplogCollectionName) {
+Collection* getLocalOplogCollection(OperationContext* opCtx,
+ const std::string& oplogCollectionName) {
if (_localOplogCollection)
return _localOplogCollection;
- AutoGetCollection autoColl(txn, NamespaceString(oplogCollectionName), MODE_IX);
+ AutoGetCollection autoColl(opCtx, NamespaceString(oplogCollectionName), MODE_IX);
_localOplogCollection = autoColl.getCollection();
massert(13347,
"the oplog collection " + oplogCollectionName +
@@ -243,7 +244,7 @@ Collection* getLocalOplogCollection(OperationContext* txn, const std::string& op
return _localOplogCollection;
}
-bool oplogDisabled(OperationContext* txn,
+bool oplogDisabled(OperationContext* opCtx,
ReplicationCoordinator::Mode replicationMode,
const NamespaceString& nss) {
if (replicationMode == ReplicationCoordinator::modeNone)
@@ -255,15 +256,15 @@ bool oplogDisabled(OperationContext* txn,
if (nss.isSystemDotProfile())
return true;
- if (!txn->writesAreReplicated())
+ if (!opCtx->writesAreReplicated())
return true;
- fassert(28626, txn->recoveryUnit());
+ fassert(28626, opCtx->recoveryUnit());
return false;
}
-OplogDocWriter _logOpWriter(OperationContext* txn,
+OplogDocWriter _logOpWriter(OperationContext* opCtx,
const char* opstr,
const NamespaceString& nss,
const BSONObj& obj,
@@ -290,11 +291,11 @@ OplogDocWriter _logOpWriter(OperationContext* txn,
} // end anon namespace
// Truncates the oplog after and including the "truncateTimestamp" entry.
-void truncateOplogTo(OperationContext* txn, Timestamp truncateTimestamp) {
+void truncateOplogTo(OperationContext* opCtx, Timestamp truncateTimestamp) {
const NamespaceString oplogNss(rsOplogName);
- ScopedTransaction transaction(txn, MODE_IX);
- AutoGetDb autoDb(txn, oplogNss.db(), MODE_IX);
- Lock::CollectionLock oplogCollectionLoc(txn->lockState(), oplogNss.ns(), MODE_X);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ AutoGetDb autoDb(opCtx, oplogNss.db(), MODE_IX);
+ Lock::CollectionLock oplogCollectionLoc(opCtx->lockState(), oplogNss.ns(), MODE_X);
Collection* oplogCollection = autoDb.getDb()->getCollection(oplogNss);
if (!oplogCollection) {
fassertFailedWithStatusNoTrace(
@@ -305,7 +306,7 @@ void truncateOplogTo(OperationContext* txn, Timestamp truncateTimestamp) {
// Scan through oplog in reverse, from latest entry to first, to find the truncateTimestamp.
RecordId oldestIDToDelete; // Non-null if there is something to delete.
auto oplogRs = oplogCollection->getRecordStore();
- auto oplogReverseCursor = oplogRs->getCursor(txn, /*forward=*/false);
+ auto oplogReverseCursor = oplogRs->getCursor(opCtx, /*forward=*/false);
size_t count = 0;
while (auto next = oplogReverseCursor->next()) {
const BSONObj entry = next->data.releaseToBson();
@@ -325,7 +326,7 @@ void truncateOplogTo(OperationContext* txn, Timestamp truncateTimestamp) {
// oplog is < truncateTimestamp.
if (count != 1) {
invariant(!oldestIDToDelete.isNull());
- oplogCollection->cappedTruncateAfter(txn, oldestIDToDelete, /*inclusive=*/true);
+ oplogCollection->cappedTruncateAfter(opCtx, oldestIDToDelete, /*inclusive=*/true);
}
return;
}
@@ -356,7 +357,7 @@ void truncateOplogTo(OperationContext* txn, Timestamp truncateTimestamp) {
if not null, specifies a boolean to pass along to the other side as b: param.
used for "justOne" or "upsert" flags on 'd', 'u'
*/
-void _logOpsInner(OperationContext* txn,
+void _logOpsInner(OperationContext* opCtx,
const NamespaceString& nss,
const DocWriter* const* writers,
size_t nWriters,
@@ -366,79 +367,80 @@ void _logOpsInner(OperationContext* txn,
ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator();
if (nss.size() && replicationMode == ReplicationCoordinator::modeReplSet &&
- !replCoord->canAcceptWritesFor(txn, nss)) {
+ !replCoord->canAcceptWritesFor(opCtx, nss)) {
severe() << "logOp() but can't accept write to collection " << nss.ns();
fassertFailed(17405);
}
// we jump through a bunch of hoops here to avoid copying the obj buffer twice --
// instead we do a single copy to the destination in the record store.
- checkOplogInsert(oplogCollection->insertDocumentsForOplog(txn, writers, nWriters));
+ checkOplogInsert(oplogCollection->insertDocumentsForOplog(opCtx, writers, nWriters));
// Set replCoord last optime only after we're sure the WUOW didn't abort and roll back.
- txn->recoveryUnit()->onCommit([txn, replCoord, finalOpTime] {
+ opCtx->recoveryUnit()->onCommit([opCtx, replCoord, finalOpTime] {
replCoord->setMyLastAppliedOpTimeForward(finalOpTime);
- ReplClientInfo::forClient(txn->getClient()).setLastOp(finalOpTime);
+ ReplClientInfo::forClient(opCtx->getClient()).setLastOp(finalOpTime);
});
}
-void logOp(OperationContext* txn,
+void logOp(OperationContext* opCtx,
const char* opstr,
const char* ns,
const BSONObj& obj,
const BSONObj* o2,
bool fromMigrate) {
- ReplicationCoordinator::Mode replMode = ReplicationCoordinator::get(txn)->getReplicationMode();
+ ReplicationCoordinator::Mode replMode =
+ ReplicationCoordinator::get(opCtx)->getReplicationMode();
NamespaceString nss(ns);
- if (oplogDisabled(txn, replMode, nss))
+ if (oplogDisabled(opCtx, replMode, nss))
return;
ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator();
- Collection* oplog = getLocalOplogCollection(txn, _oplogCollectionName);
- Lock::DBLock lk(txn->lockState(), "local", MODE_IX);
- Lock::CollectionLock lock(txn->lockState(), _oplogCollectionName, MODE_IX);
+ Collection* oplog = getLocalOplogCollection(opCtx, _oplogCollectionName);
+ Lock::DBLock lk(opCtx->lockState(), "local", MODE_IX);
+ Lock::CollectionLock lock(opCtx->lockState(), _oplogCollectionName, MODE_IX);
OplogSlot slot;
- getNextOpTime(txn, oplog, replCoord, replMode, 1, &slot);
- auto writer = _logOpWriter(txn, opstr, nss, obj, o2, fromMigrate, slot.opTime, slot.hash);
+ getNextOpTime(opCtx, oplog, replCoord, replMode, 1, &slot);
+ auto writer = _logOpWriter(opCtx, opstr, nss, obj, o2, fromMigrate, slot.opTime, slot.hash);
const DocWriter* basePtr = &writer;
- _logOpsInner(txn, nss, &basePtr, 1, oplog, replMode, slot.opTime);
+ _logOpsInner(opCtx, nss, &basePtr, 1, oplog, replMode, slot.opTime);
}
-void logOps(OperationContext* txn,
+void logOps(OperationContext* opCtx,
const char* opstr,
const NamespaceString& nss,
std::vector<BSONObj>::const_iterator begin,
std::vector<BSONObj>::const_iterator end,
bool fromMigrate) {
- ReplicationCoordinator* replCoord = ReplicationCoordinator::get(txn);
+ ReplicationCoordinator* replCoord = ReplicationCoordinator::get(opCtx);
ReplicationCoordinator::Mode replMode = replCoord->getReplicationMode();
invariant(begin != end);
- if (oplogDisabled(txn, replMode, nss))
+ if (oplogDisabled(opCtx, replMode, nss))
return;
const size_t count = end - begin;
std::vector<OplogDocWriter> writers;
writers.reserve(count);
- Collection* oplog = getLocalOplogCollection(txn, _oplogCollectionName);
- Lock::DBLock lk(txn->lockState(), "local", MODE_IX);
- Lock::CollectionLock lock(txn->lockState(), _oplogCollectionName, MODE_IX);
+ Collection* oplog = getLocalOplogCollection(opCtx, _oplogCollectionName);
+ Lock::DBLock lk(opCtx->lockState(), "local", MODE_IX);
+ Lock::CollectionLock lock(opCtx->lockState(), _oplogCollectionName, MODE_IX);
std::unique_ptr<OplogSlot[]> slots(new OplogSlot[count]);
- getNextOpTime(txn, oplog, replCoord, replMode, count, slots.get());
+ getNextOpTime(opCtx, oplog, replCoord, replMode, count, slots.get());
for (size_t i = 0; i < count; i++) {
writers.emplace_back(_logOpWriter(
- txn, opstr, nss, begin[i], NULL, fromMigrate, slots[i].opTime, slots[i].hash));
+ opCtx, opstr, nss, begin[i], NULL, fromMigrate, slots[i].opTime, slots[i].hash));
}
std::unique_ptr<DocWriter const* []> basePtrs(new DocWriter const*[count]);
for (size_t i = 0; i < count; i++) {
basePtrs[i] = &writers[i];
}
- _logOpsInner(txn, nss, basePtrs.get(), count, oplog, replMode, slots[count - 1].opTime);
+ _logOpsInner(opCtx, nss, basePtrs.get(), count, oplog, replMode, slots[count - 1].opTime);
}
namespace {
-long long getNewOplogSizeBytes(OperationContext* txn, const ReplSettings& replSettings) {
+long long getNewOplogSizeBytes(OperationContext* opCtx, const ReplSettings& replSettings) {
if (replSettings.getOplogSizeBytes() != 0) {
return replSettings.getOplogSizeBytes();
}
@@ -459,7 +461,7 @@ long long getNewOplogSizeBytes(OperationContext* txn, const ReplSettings& replSe
#else
long long lowerBound = 0;
double bytes = 0;
- if (txn->getClient()->getServiceContext()->getGlobalStorageEngine()->isEphemeral()) {
+ if (opCtx->getClient()->getServiceContext()->getGlobalStorageEngine()->isEphemeral()) {
// in memory: 50MB minimum size
lowerBound = 50LL * 1024 * 1024;
bytes = pi.getMemSizeMB() * 1024 * 1024;
@@ -482,19 +484,19 @@ long long getNewOplogSizeBytes(OperationContext* txn, const ReplSettings& replSe
}
} // namespace
-void createOplog(OperationContext* txn, const std::string& oplogCollectionName, bool isReplSet) {
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite lk(txn->lockState());
+void createOplog(OperationContext* opCtx, const std::string& oplogCollectionName, bool isReplSet) {
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite lk(opCtx->lockState());
- const ReplSettings& replSettings = ReplicationCoordinator::get(txn)->getSettings();
+ const ReplSettings& replSettings = ReplicationCoordinator::get(opCtx)->getSettings();
- OldClientContext ctx(txn, oplogCollectionName);
+ OldClientContext ctx(opCtx, oplogCollectionName);
Collection* collection = ctx.db()->getCollection(oplogCollectionName);
if (collection) {
if (replSettings.getOplogSizeBytes() != 0) {
const CollectionOptions oplogOpts =
- collection->getCatalogEntry()->getCollectionOptions(txn);
+ collection->getCatalogEntry()->getCollectionOptions(opCtx);
int o = (int)(oplogOpts.cappedSize / (1024 * 1024));
int n = (int)(replSettings.getOplogSizeBytes() / (1024 * 1024));
@@ -508,12 +510,12 @@ void createOplog(OperationContext* txn, const std::string& oplogCollectionName,
}
if (!isReplSet)
- initTimestampFromOplog(txn, oplogCollectionName);
+ initTimestampFromOplog(opCtx, oplogCollectionName);
return;
}
/* create an oplog collection, if it doesn't yet exist. */
- const auto sz = getNewOplogSizeBytes(txn, replSettings);
+ const auto sz = getNewOplogSizeBytes(opCtx, replSettings);
log() << "******" << endl;
log() << "creating replication oplog of size: " << (int)(sz / (1024 * 1024)) << "MB..." << endl;
@@ -524,24 +526,24 @@ void createOplog(OperationContext* txn, const std::string& oplogCollectionName,
options.autoIndexId = CollectionOptions::NO;
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- WriteUnitOfWork uow(txn);
- invariant(ctx.db()->createCollection(txn, oplogCollectionName, options));
+ WriteUnitOfWork uow(opCtx);
+ invariant(ctx.db()->createCollection(opCtx, oplogCollectionName, options));
if (!isReplSet)
- getGlobalServiceContext()->getOpObserver()->onOpMessage(txn, BSONObj());
+ getGlobalServiceContext()->getOpObserver()->onOpMessage(opCtx, BSONObj());
uow.commit();
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "createCollection", oplogCollectionName);
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "createCollection", oplogCollectionName);
/* sync here so we don't get any surprising lag later when we try to sync */
StorageEngine* storageEngine = getGlobalServiceContext()->getGlobalStorageEngine();
- storageEngine->flushAllFiles(txn, true);
+ storageEngine->flushAllFiles(opCtx, true);
log() << "******" << endl;
}
-void createOplog(OperationContext* txn) {
- const auto isReplSet = ReplicationCoordinator::get(txn)->getReplicationMode() ==
+void createOplog(OperationContext* opCtx) {
+ const auto isReplSet = ReplicationCoordinator::get(opCtx)->getReplicationMode() ==
ReplicationCoordinator::modeReplSet;
- createOplog(txn, _oplogCollectionName, isReplSet);
+ createOplog(opCtx, _oplogCollectionName, isReplSet);
}
// -------------------------------------
@@ -575,13 +577,13 @@ struct ApplyOpMetadata {
std::map<std::string, ApplyOpMetadata> opsMap = {
{"create",
- {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+ {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
const NamespaceString nss(parseNs(ns, cmd));
if (auto idIndexElem = cmd["idIndex"]) {
// Remove "idIndex" field from command.
auto cmdWithoutIdIndex = cmd.removeField("idIndex");
return createCollection(
- txn, nss.db().toString(), cmdWithoutIdIndex, idIndexElem.Obj());
+ opCtx, nss.db().toString(), cmdWithoutIdIndex, idIndexElem.Obj());
}
// No _id index spec was provided, so we should build a v:1 _id index.
@@ -591,55 +593,55 @@ std::map<std::string, ApplyOpMetadata> opsMap = {
idIndexSpecBuilder.append(IndexDescriptor::kIndexNameFieldName, "_id_");
idIndexSpecBuilder.append(IndexDescriptor::kNamespaceFieldName, nss.ns());
idIndexSpecBuilder.append(IndexDescriptor::kKeyPatternFieldName, BSON("_id" << 1));
- return createCollection(txn, nss.db().toString(), cmd, idIndexSpecBuilder.done());
+ return createCollection(opCtx, nss.db().toString(), cmd, idIndexSpecBuilder.done());
},
{ErrorCodes::NamespaceExists}}},
{"collMod",
- {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+ {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
BSONObjBuilder resultWeDontCareAbout;
- return collMod(txn, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
+ return collMod(opCtx, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
},
{ErrorCodes::IndexNotFound, ErrorCodes::NamespaceNotFound}}},
{"dropDatabase",
- {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
- return dropDatabase(txn, NamespaceString(ns).db().toString());
+ {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
+ return dropDatabase(opCtx, NamespaceString(ns).db().toString());
},
{ErrorCodes::NamespaceNotFound}}},
{"drop",
- {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+ {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
BSONObjBuilder resultWeDontCareAbout;
- return dropCollection(txn, parseNs(ns, cmd), resultWeDontCareAbout);
+ return dropCollection(opCtx, parseNs(ns, cmd), resultWeDontCareAbout);
},
// IllegalOperation is necessary because in 3.0 we replicate drops of system.profile
// TODO(dannenberg) remove IllegalOperation once we no longer need 3.0 compatibility
{ErrorCodes::NamespaceNotFound, ErrorCodes::IllegalOperation}}},
// deleteIndex(es) is deprecated but still works as of April 10, 2015
{"deleteIndex",
- {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+ {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
BSONObjBuilder resultWeDontCareAbout;
- return dropIndexes(txn, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
+ return dropIndexes(opCtx, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
},
{ErrorCodes::NamespaceNotFound, ErrorCodes::IndexNotFound}}},
{"deleteIndexes",
- {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+ {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
BSONObjBuilder resultWeDontCareAbout;
- return dropIndexes(txn, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
+ return dropIndexes(opCtx, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
},
{ErrorCodes::NamespaceNotFound, ErrorCodes::IndexNotFound}}},
{"dropIndex",
- {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+ {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
BSONObjBuilder resultWeDontCareAbout;
- return dropIndexes(txn, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
+ return dropIndexes(opCtx, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
},
{ErrorCodes::NamespaceNotFound, ErrorCodes::IndexNotFound}}},
{"dropIndexes",
- {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+ {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
BSONObjBuilder resultWeDontCareAbout;
- return dropIndexes(txn, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
+ return dropIndexes(opCtx, parseNs(ns, cmd), cmd, &resultWeDontCareAbout);
},
{ErrorCodes::NamespaceNotFound, ErrorCodes::IndexNotFound}}},
{"renameCollection",
- {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+ {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
const auto sourceNsElt = cmd.firstElement();
const auto targetNsElt = cmd["to"];
uassert(ErrorCodes::TypeMismatch,
@@ -648,7 +650,7 @@ std::map<std::string, ApplyOpMetadata> opsMap = {
uassert(ErrorCodes::TypeMismatch,
"'to' must be of type String",
targetNsElt.type() == BSONType::String);
- return renameCollection(txn,
+ return renameCollection(opCtx,
NamespaceString(sourceNsElt.valueStringData()),
NamespaceString(targetNsElt.valueStringData()),
cmd["dropTarget"].trueValue(),
@@ -656,16 +658,16 @@ std::map<std::string, ApplyOpMetadata> opsMap = {
},
{ErrorCodes::NamespaceNotFound, ErrorCodes::NamespaceExists}}},
{"applyOps",
- {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
+ {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
BSONObjBuilder resultWeDontCareAbout;
- return applyOps(txn, nsToDatabase(ns), cmd, &resultWeDontCareAbout);
+ return applyOps(opCtx, nsToDatabase(ns), cmd, &resultWeDontCareAbout);
},
{ErrorCodes::UnknownError}}},
- {"convertToCapped", {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
- return convertToCapped(txn, parseNs(ns, cmd), cmd["size"].number());
+ {"convertToCapped", {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
+ return convertToCapped(opCtx, parseNs(ns, cmd), cmd["size"].number());
}}},
- {"emptycapped", {[](OperationContext* txn, const char* ns, BSONObj& cmd) -> Status {
- return emptyCapped(txn, parseNs(ns, cmd));
+ {"emptycapped", {[](OperationContext* opCtx, const char* ns, BSONObj& cmd) -> Status {
+ return emptyCapped(opCtx, parseNs(ns, cmd));
}}},
};
@@ -673,14 +675,14 @@ std::map<std::string, ApplyOpMetadata> opsMap = {
// @return failure status if an update should have happened and the document DNE.
// See replset initial sync code.
-Status applyOperation_inlock(OperationContext* txn,
+Status applyOperation_inlock(OperationContext* opCtx,
Database* db,
const BSONObj& op,
bool inSteadyStateReplication,
IncrementOpsAppliedStatsFn incrementOpsAppliedStats) {
LOG(3) << "applying op: " << redact(op);
- OpCounters* opCounters = txn->writesAreReplicated() ? &globalOpCounters : &replOpCounters;
+ OpCounters* opCounters = opCtx->writesAreReplicated() ? &globalOpCounters : &replOpCounters;
const char* names[] = {"o", "ns", "op", "b", "o2"};
BSONElement fields[5];
@@ -710,19 +712,19 @@ Status applyOperation_inlock(OperationContext* txn,
if (supportsDocLocking()) {
// WiredTiger, and others requires MODE_IX since the applier threads driving
// this allow writes to the same collection on any thread.
- dassert(txn->lockState()->isCollectionLockedForMode(ns, MODE_IX));
+ dassert(opCtx->lockState()->isCollectionLockedForMode(ns, MODE_IX));
} else {
// mmapV1 ensures that all operations to the same collection are executed from
// the same worker thread, so it takes an exclusive lock (MODE_X)
- dassert(txn->lockState()->isCollectionLockedForMode(ns, MODE_X));
+ dassert(opCtx->lockState()->isCollectionLockedForMode(ns, MODE_X));
}
}
Collection* collection = db->getCollection(ns);
IndexCatalog* indexCatalog = collection == nullptr ? nullptr : collection->getIndexCatalog();
- const bool haveWrappingWriteUnitOfWork = txn->lockState()->inAWriteUnitOfWork();
+ const bool haveWrappingWriteUnitOfWork = opCtx->lockState()->inAWriteUnitOfWork();
uassert(ErrorCodes::CommandNotSupportedOnView,
str::stream() << "applyOps not supported on view: " << ns,
- collection || !db->getViewCatalog()->lookup(txn, ns));
+ collection || !db->getViewCatalog()->lookup(opCtx, ns));
// operation type -- see logOp() comments for types
const char* opType = fieldOp.valuestrsafe();
@@ -768,15 +770,15 @@ Status applyOperation_inlock(OperationContext* txn,
}
bool relaxIndexConstraints =
- ReplicationCoordinator::get(txn)->shouldRelaxIndexConstraints(txn, indexNss);
+ ReplicationCoordinator::get(opCtx)->shouldRelaxIndexConstraints(opCtx, indexNss);
if (indexSpec["background"].trueValue()) {
- Lock::TempRelease release(txn->lockState());
- if (txn->lockState()->isLocked()) {
+ Lock::TempRelease release(opCtx->lockState());
+ if (opCtx->lockState()->isLocked()) {
// If TempRelease fails, background index build will deadlock.
LOG(3) << "apply op: building background index " << indexSpec
<< " in the foreground because temp release failed";
IndexBuilder builder(indexSpec, relaxIndexConstraints);
- Status status = builder.buildInForeground(txn, db);
+ Status status = builder.buildInForeground(opCtx, db);
uassertStatusOK(status);
} else {
IndexBuilder* builder = new IndexBuilder(indexSpec, relaxIndexConstraints);
@@ -785,10 +787,10 @@ Status applyOperation_inlock(OperationContext* txn,
// Wait for thread to start and register itself
IndexBuilder::waitForBgIndexStarting();
}
- txn->recoveryUnit()->abandonSnapshot();
+ opCtx->recoveryUnit()->abandonSnapshot();
} else {
IndexBuilder builder(indexSpec, relaxIndexConstraints);
- Status status = builder.buildInForeground(txn, db);
+ Status status = builder.buildInForeground(opCtx, db);
uassertStatusOK(status);
}
// Since this is an index operation we can return without falling through.
@@ -812,10 +814,10 @@ Status applyOperation_inlock(OperationContext* txn,
str::stream() << "Failed to apply insert due to empty array element: "
<< op.toString(),
!insertObjs.empty());
- WriteUnitOfWork wuow(txn);
+ WriteUnitOfWork wuow(opCtx);
OpDebug* const nullOpDebug = nullptr;
Status status = collection->insertDocuments(
- txn, insertObjs.begin(), insertObjs.end(), nullOpDebug, true);
+ opCtx, insertObjs.begin(), insertObjs.end(), nullOpDebug, true);
if (!status.isOK()) {
return status;
}
@@ -849,10 +851,10 @@ Status applyOperation_inlock(OperationContext* txn,
bool needToDoUpsert = haveWrappingWriteUnitOfWork;
if (!needToDoUpsert) {
- WriteUnitOfWork wuow(txn);
+ WriteUnitOfWork wuow(opCtx);
try {
OpDebug* const nullOpDebug = nullptr;
- status = collection->insertDocument(txn, o, nullOpDebug, true);
+ status = collection->insertDocument(opCtx, o, nullOpDebug, true);
} catch (DBException dbe) {
status = dbe.toStatus();
}
@@ -881,7 +883,7 @@ Status applyOperation_inlock(OperationContext* txn,
UpdateLifecycleImpl updateLifecycle(requestNs);
request.setLifecycle(&updateLifecycle);
- UpdateResult res = update(txn, db, request);
+ UpdateResult res = update(opCtx, db, request);
if (res.numMatched == 0 && res.upserted.isEmpty()) {
error() << "No document was updated even though we got a DuplicateKey "
"error when inserting";
@@ -912,7 +914,7 @@ Status applyOperation_inlock(OperationContext* txn,
UpdateLifecycleImpl updateLifecycle(requestNs);
request.setLifecycle(&updateLifecycle);
- UpdateResult ur = update(txn, db, request);
+ UpdateResult ur = update(opCtx, db, request);
if (ur.numMatched == 0 && ur.upserted.isEmpty()) {
if (ur.modifiers) {
@@ -929,11 +931,11 @@ Status applyOperation_inlock(OperationContext* txn,
// { _id:..., { x : {$size:...} }
// thus this is not ideal.
if (collection == NULL ||
- (indexCatalog->haveIdIndex(txn) &&
- Helpers::findById(txn, collection, updateCriteria).isNull()) ||
+ (indexCatalog->haveIdIndex(opCtx) &&
+ Helpers::findById(opCtx, collection, updateCriteria).isNull()) ||
// capped collections won't have an _id index
- (!indexCatalog->haveIdIndex(txn) &&
- Helpers::findOne(txn, collection, updateCriteria, false).isNull())) {
+ (!indexCatalog->haveIdIndex(opCtx) &&
+ Helpers::findOne(opCtx, collection, updateCriteria, false).isNull())) {
string msg = str::stream() << "couldn't find doc: " << redact(op);
error() << msg;
return Status(ErrorCodes::OperationFailed, msg);
@@ -963,7 +965,7 @@ Status applyOperation_inlock(OperationContext* txn,
o.hasField("_id"));
if (opType[1] == 0) {
- deleteObjects(txn, collection, ns, o, PlanExecutor::YIELD_MANUAL, /*justOne*/ valueB);
+ deleteObjects(opCtx, collection, ns, o, PlanExecutor::YIELD_MANUAL, /*justOne*/ valueB);
} else
verify(opType[1] == 'b'); // "db" advertisement
if (incrementOpsAppliedStats) {
@@ -984,15 +986,15 @@ Status applyOperation_inlock(OperationContext* txn,
// have a wrapping WUOW, the extra nexting is harmless. The logOp really should have been
// done in the WUOW that did the write, but this won't happen because applyOps turns off
// observers.
- WriteUnitOfWork wuow(txn);
+ WriteUnitOfWork wuow(opCtx);
getGlobalAuthorizationManager()->logOp(
- txn, opType, ns.toString().c_str(), o, fieldO2.isABSONObj() ? &o2 : NULL);
+ opCtx, opType, ns.toString().c_str(), o, fieldO2.isABSONObj() ? &o2 : NULL);
wuow.commit();
return Status::OK();
}
-Status applyCommand_inlock(OperationContext* txn,
+Status applyCommand_inlock(OperationContext* opCtx,
const BSONObj& op,
bool inSteadyStateReplication) {
const char* names[] = {"o", "ns", "op"};
@@ -1023,8 +1025,8 @@ Status applyCommand_inlock(OperationContext* txn,
return {ErrorCodes::InvalidNamespace, "invalid ns: " + std::string(nss.ns())};
}
{
- Database* db = dbHolder().get(txn, nss.ns());
- if (db && !db->getCollection(nss.ns()) && db->getViewCatalog()->lookup(txn, nss.ns())) {
+ Database* db = dbHolder().get(opCtx, nss.ns());
+ if (db && !db->getCollection(nss.ns()) && db->getViewCatalog()->lookup(opCtx, nss.ns())) {
return {ErrorCodes::CommandNotSupportedOnView,
str::stream() << "applyOps not supported on view:" << nss.ns()};
}
@@ -1040,7 +1042,7 @@ Status applyCommand_inlock(OperationContext* txn,
// Applying commands in repl is done under Global W-lock, so it is safe to not
// perform the current DB checks after reacquiring the lock.
- invariant(txn->lockState()->isW());
+ invariant(opCtx->lockState()->isW());
bool done = false;
@@ -1054,7 +1056,7 @@ Status applyCommand_inlock(OperationContext* txn,
ApplyOpMetadata curOpToApply = op->second;
Status status = Status::OK();
try {
- status = curOpToApply.applyFunc(txn, nss.ns().c_str(), o);
+ status = curOpToApply.applyFunc(opCtx, nss.ns().c_str(), o);
} catch (...) {
status = exceptionToStatus();
}
@@ -1065,21 +1067,21 @@ Status applyCommand_inlock(OperationContext* txn,
throw WriteConflictException();
}
case ErrorCodes::BackgroundOperationInProgressForDatabase: {
- Lock::TempRelease release(txn->lockState());
+ Lock::TempRelease release(opCtx->lockState());
BackgroundOperation::awaitNoBgOpInProgForDb(nss.db());
- txn->recoveryUnit()->abandonSnapshot();
- txn->checkForInterrupt();
+ opCtx->recoveryUnit()->abandonSnapshot();
+ opCtx->checkForInterrupt();
break;
}
case ErrorCodes::BackgroundOperationInProgressForNamespace: {
- Lock::TempRelease release(txn->lockState());
+ Lock::TempRelease release(opCtx->lockState());
Command* cmd = Command::findCommand(o.firstElement().fieldName());
invariant(cmd);
BackgroundOperation::awaitNoBgOpInProgForNs(cmd->parseNs(nss.db().toString(), o));
- txn->recoveryUnit()->abandonSnapshot();
- txn->checkForInterrupt();
+ opCtx->recoveryUnit()->abandonSnapshot();
+ opCtx->checkForInterrupt();
break;
}
default:
@@ -1101,8 +1103,8 @@ Status applyCommand_inlock(OperationContext* txn,
// AuthorizationManager's logOp method registers a RecoveryUnit::Change
// and to do so we need to have begun a UnitOfWork
- WriteUnitOfWork wuow(txn);
- getGlobalAuthorizationManager()->logOp(txn, opType, nss.ns().c_str(), o, nullptr);
+ WriteUnitOfWork wuow(opCtx);
+ getGlobalAuthorizationManager()->logOp(opCtx, opType, nss.ns().c_str(), o, nullptr);
wuow.commit();
return Status::OK();
@@ -1114,19 +1116,19 @@ void setNewTimestamp(ServiceContext* service, const Timestamp& newTime) {
newTimestampNotifier.notify_all();
}
-void initTimestampFromOplog(OperationContext* txn, const std::string& oplogNS) {
- DBDirectClient c(txn);
+void initTimestampFromOplog(OperationContext* opCtx, const std::string& oplogNS) {
+ DBDirectClient c(opCtx);
BSONObj lastOp = c.findOne(oplogNS, Query().sort(reverseNaturalObj), NULL, QueryOption_SlaveOk);
if (!lastOp.isEmpty()) {
LOG(1) << "replSet setting last Timestamp";
const OpTime opTime = fassertStatusOK(28696, OpTime::parseFromOplogEntry(lastOp));
- setNewTimestamp(txn->getServiceContext(), opTime.getTimestamp());
+ setNewTimestamp(opCtx->getServiceContext(), opTime.getTimestamp());
}
}
-void oplogCheckCloseDatabase(OperationContext* txn, Database* db) {
- invariant(txn->lockState()->isW());
+void oplogCheckCloseDatabase(OperationContext* opCtx, Database* db) {
+ invariant(opCtx->lockState()->isW());
_localOplogCollection = nullptr;
}
@@ -1213,8 +1215,8 @@ void SnapshotThread::run() {
}
try {
- auto txn = client.makeOperationContext();
- Lock::GlobalLock globalLock(txn->lockState(), MODE_IS, UINT_MAX);
+ auto opCtx = client.makeOperationContext();
+ Lock::GlobalLock globalLock(opCtx->lockState(), MODE_IS, UINT_MAX);
if (!replCoord->getMemberState().readable()) {
// If our MemberState isn't readable, we may not be in a consistent state so don't
@@ -1231,9 +1233,9 @@ void SnapshotThread::run() {
// Make sure there are no in-flight capped inserts while we create our snapshot.
// This lock cannot be aquired until all writes holding the resource commit/abort.
Lock::ResourceLock cappedInsertLockForOtherDb(
- txn->lockState(), resourceCappedInFlightForOtherDb, MODE_X);
+ opCtx->lockState(), resourceCappedInFlightForOtherDb, MODE_X);
Lock::ResourceLock cappedInsertLockForLocalDb(
- txn->lockState(), resourceCappedInFlightForLocalDb, MODE_X);
+ opCtx->lockState(), resourceCappedInFlightForLocalDb, MODE_X);
// Reserve the name immediately before we take our snapshot. This ensures that all
// names that compare lower must be from points in time visible to this named
@@ -1241,15 +1243,15 @@ void SnapshotThread::run() {
name = replCoord->reserveSnapshotName(nullptr);
// This establishes the view that we will name.
- _manager->prepareForCreateSnapshot(txn.get());
+ _manager->prepareForCreateSnapshot(opCtx.get());
}
auto opTimeOfSnapshot = OpTime();
{
- AutoGetCollectionForRead oplog(txn.get(), NamespaceString(rsOplogName));
+ AutoGetCollectionForRead oplog(opCtx.get(), NamespaceString(rsOplogName));
invariant(oplog.getCollection());
// Read the latest op from the oplog.
- auto cursor = oplog.getCollection()->getCursor(txn.get(), /*forward*/ false);
+ auto cursor = oplog.getCollection()->getCursor(opCtx.get(), /*forward*/ false);
auto record = cursor->next();
if (!record)
continue; // oplog is completely empty.
@@ -1259,7 +1261,7 @@ void SnapshotThread::run() {
invariant(!opTimeOfSnapshot.isNull());
}
- replCoord->createSnapshot(txn.get(), opTimeOfSnapshot, name);
+ replCoord->createSnapshot(opCtx.get(), opTimeOfSnapshot, name);
} catch (const WriteConflictException& wce) {
log() << "skipping storage snapshot pass due to write conflict";
continue;
diff --git a/src/mongo/db/repl/oplog.h b/src/mongo/db/repl/oplog.h
index dc61805e789..fcff70fb607 100644
--- a/src/mongo/db/repl/oplog.h
+++ b/src/mongo/db/repl/oplog.h
@@ -50,20 +50,20 @@ class ReplSettings;
/**
* Truncates the oplog after, and including, the "truncateTimestamp" entry.
*/
-void truncateOplogTo(OperationContext* txn, Timestamp truncateTimestamp);
+void truncateOplogTo(OperationContext* opCtx, Timestamp truncateTimestamp);
/**
* Create a new capped collection for the oplog if it doesn't yet exist.
* If the collection already exists (and isReplSet is false),
* set the 'last' Timestamp from the last entry of the oplog collection (side effect!)
*/
-void createOplog(OperationContext* txn, const std::string& oplogCollectionName, bool isReplSet);
+void createOplog(OperationContext* opCtx, const std::string& oplogCollectionName, bool isReplSet);
/*
* Shortcut for above function using oplogCollectionName = _oplogCollectionName,
* and replEnabled = replCoord::isReplSet();
*/
-void createOplog(OperationContext* txn);
+void createOplog(OperationContext* opCtx);
extern std::string rsOplogName;
extern std::string masterSlaveOplogName;
@@ -81,7 +81,7 @@ extern int OPLOG_VERSION;
* "db" declares presence of a database (ns is set to the db name + '.')
*/
-void logOps(OperationContext* txn,
+void logOps(OperationContext* opCtx,
const char* opstr,
const NamespaceString& nss,
std::vector<BSONObj>::const_iterator begin,
@@ -91,7 +91,7 @@ void logOps(OperationContext* txn,
/* For 'u' records, 'obj' captures the mutation made to the object but not
* the object itself. 'o2' captures the the criteria for the object that will be modified.
*/
-void logOp(OperationContext* txn,
+void logOp(OperationContext* opCtx,
const char* opstr,
const char* ns,
const BSONObj& obj,
@@ -100,7 +100,7 @@ void logOp(OperationContext* txn,
// Flush out the cached pointers to the local database and oplog.
// Used by the closeDatabase command to ensure we don't cache closed things.
-void oplogCheckCloseDatabase(OperationContext* txn, Database* db);
+void oplogCheckCloseDatabase(OperationContext* opCtx, Database* db);
using IncrementOpsAppliedStatsFn = stdx::function<void()>;
/**
@@ -110,7 +110,7 @@ using IncrementOpsAppliedStatsFn = stdx::function<void()>;
* @param incrementOpsAppliedStats is called whenever an op is applied.
* Returns failure status if the op was an update that could not be applied.
*/
-Status applyOperation_inlock(OperationContext* txn,
+Status applyOperation_inlock(OperationContext* opCtx,
Database* db,
const BSONObj& op,
bool inSteadyStateReplication = false,
@@ -123,17 +123,19 @@ Status applyOperation_inlock(OperationContext* txn,
* initial sync.
* Returns failure status if the op that could not be applied.
*/
-Status applyCommand_inlock(OperationContext* txn, const BSONObj& op, bool inSteadyStateReplication);
+Status applyCommand_inlock(OperationContext* opCtx,
+ const BSONObj& op,
+ bool inSteadyStateReplication);
/**
* Initializes the global Timestamp with the value from the timestamp of the last oplog entry.
*/
-void initTimestampFromOplog(OperationContext* txn, const std::string& oplogNS);
+void initTimestampFromOplog(OperationContext* opCtx, const std::string& oplogNS);
/**
* Sets the global Timestamp to be 'newTime'.
*/
-void setNewTimestamp(ServiceContext* txn, const Timestamp& newTime);
+void setNewTimestamp(ServiceContext* opCtx, const Timestamp& newTime);
/**
* Detects the current replication mode and sets the "_oplogCollectionName" accordingly.
diff --git a/src/mongo/db/repl/oplog_buffer.h b/src/mongo/db/repl/oplog_buffer.h
index 9695260c691..f177808a991 100644
--- a/src/mongo/db/repl/oplog_buffer.h
+++ b/src/mongo/db/repl/oplog_buffer.h
@@ -70,7 +70,7 @@ public:
* create backing storage, etc). This method may be called at most once for the lifetime of an
* oplog buffer.
*/
- virtual void startup(OperationContext* txn) = 0;
+ virtual void startup(OperationContext* opCtx) = 0;
/**
* Signals to the oplog buffer that it should shut down. This method may block. After
@@ -79,7 +79,7 @@ public:
* It is legal to call this method multiple times, but it should only be called after startup
* has been called.
*/
- virtual void shutdown(OperationContext* txn) = 0;
+ virtual void shutdown(OperationContext* opCtx) = 0;
/**
* Pushes operation into oplog buffer, ignoring any size constraints. Does not block.
@@ -87,26 +87,26 @@ public:
* the limit returned by getMaxSize() but should not otherwise adversely affect normal
* functionality such as pushing and popping operations from the oplog buffer.
*/
- virtual void pushEvenIfFull(OperationContext* txn, const Value& value) = 0;
+ virtual void pushEvenIfFull(OperationContext* opCtx, const Value& value) = 0;
/**
* Pushes operation into oplog buffer.
* If there are size constraints on the oplog buffer, this may block until sufficient space
* is made available (by popping) to complete this operation.
*/
- virtual void push(OperationContext* txn, const Value& value) = 0;
+ virtual void push(OperationContext* opCtx, const Value& value) = 0;
/**
* Pushes operations in the iterator range [begin, end) into the oplog buffer without blocking.
*/
- virtual void pushAllNonBlocking(OperationContext* txn,
+ virtual void pushAllNonBlocking(OperationContext* opCtx,
Batch::const_iterator begin,
Batch::const_iterator end) = 0;
/**
* Returns when enough space is available.
*/
- virtual void waitForSpace(OperationContext* txn, std::size_t size) = 0;
+ virtual void waitForSpace(OperationContext* opCtx, std::size_t size) = 0;
/**
* Returns true if oplog buffer is empty.
@@ -135,13 +135,13 @@ public:
/**
* Clears oplog buffer.
*/
- virtual void clear(OperationContext* txn) = 0;
+ virtual void clear(OperationContext* opCtx) = 0;
/**
* Returns false if oplog buffer is empty. "value" is left unchanged.
* Otherwise, removes last item (saves in "value") from the oplog buffer and returns true.
*/
- virtual bool tryPop(OperationContext* txn, Value* value) = 0;
+ virtual bool tryPop(OperationContext* opCtx, Value* value) = 0;
/**
* Waits "waitDuration" for an operation to be pushed into the oplog buffer.
@@ -154,12 +154,12 @@ public:
* Returns false if oplog buffer is empty.
* Otherwise, returns true and sets "value" to last item in oplog buffer.
*/
- virtual bool peek(OperationContext* txn, Value* value) = 0;
+ virtual bool peek(OperationContext* opCtx, Value* value) = 0;
/**
* Returns the item most recently added to the oplog buffer or nothing if the buffer is empty.
*/
- virtual boost::optional<Value> lastObjectPushed(OperationContext* txn) const = 0;
+ virtual boost::optional<Value> lastObjectPushed(OperationContext* opCtx) const = 0;
};
} // namespace repl
diff --git a/src/mongo/db/repl/oplog_buffer_blocking_queue.cpp b/src/mongo/db/repl/oplog_buffer_blocking_queue.cpp
index 9b9cdb82dac..72eb401ddb5 100644
--- a/src/mongo/db/repl/oplog_buffer_blocking_queue.cpp
+++ b/src/mongo/db/repl/oplog_buffer_blocking_queue.cpp
@@ -49,8 +49,8 @@ OplogBufferBlockingQueue::OplogBufferBlockingQueue() : _queue(kOplogBufferSize,
void OplogBufferBlockingQueue::startup(OperationContext*) {}
-void OplogBufferBlockingQueue::shutdown(OperationContext* txn) {
- clear(txn);
+void OplogBufferBlockingQueue::shutdown(OperationContext* opCtx) {
+ clear(opCtx);
}
void OplogBufferBlockingQueue::pushEvenIfFull(OperationContext*, const Value& value) {
diff --git a/src/mongo/db/repl/oplog_buffer_blocking_queue.h b/src/mongo/db/repl/oplog_buffer_blocking_queue.h
index b0fa36a8157..68c74779b0e 100644
--- a/src/mongo/db/repl/oplog_buffer_blocking_queue.h
+++ b/src/mongo/db/repl/oplog_buffer_blocking_queue.h
@@ -41,23 +41,23 @@ class OplogBufferBlockingQueue final : public OplogBuffer {
public:
OplogBufferBlockingQueue();
- void startup(OperationContext* txn) override;
- void shutdown(OperationContext* txn) override;
- void pushEvenIfFull(OperationContext* txn, const Value& value) override;
- void push(OperationContext* txn, const Value& value) override;
- void pushAllNonBlocking(OperationContext* txn,
+ void startup(OperationContext* opCtx) override;
+ void shutdown(OperationContext* opCtx) override;
+ void pushEvenIfFull(OperationContext* opCtx, const Value& value) override;
+ void push(OperationContext* opCtx, const Value& value) override;
+ void pushAllNonBlocking(OperationContext* opCtx,
Batch::const_iterator begin,
Batch::const_iterator end) override;
- void waitForSpace(OperationContext* txn, std::size_t size) override;
+ void waitForSpace(OperationContext* opCtx, std::size_t size) override;
bool isEmpty() const override;
std::size_t getMaxSize() const override;
std::size_t getSize() const override;
std::size_t getCount() const override;
- void clear(OperationContext* txn) override;
- bool tryPop(OperationContext* txn, Value* value) override;
+ void clear(OperationContext* opCtx) override;
+ bool tryPop(OperationContext* opCtx, Value* value) override;
bool waitForData(Seconds waitDuration) override;
- bool peek(OperationContext* txn, Value* value) override;
- boost::optional<Value> lastObjectPushed(OperationContext* txn) const override;
+ bool peek(OperationContext* opCtx, Value* value) override;
+ boost::optional<Value> lastObjectPushed(OperationContext* opCtx) const override;
private:
BlockingQueue<BSONObj> _queue;
diff --git a/src/mongo/db/repl/oplog_buffer_collection.cpp b/src/mongo/db/repl/oplog_buffer_collection.cpp
index 1c74963cc14..f738312a3eb 100644
--- a/src/mongo/db/repl/oplog_buffer_collection.cpp
+++ b/src/mongo/db/repl/oplog_buffer_collection.cpp
@@ -93,27 +93,27 @@ OplogBufferCollection::Options OplogBufferCollection::getOptions() const {
return _options;
}
-void OplogBufferCollection::startup(OperationContext* txn) {
- clear(txn);
+void OplogBufferCollection::startup(OperationContext* opCtx) {
+ clear(opCtx);
}
-void OplogBufferCollection::shutdown(OperationContext* txn) {
+void OplogBufferCollection::shutdown(OperationContext* opCtx) {
stdx::lock_guard<stdx::mutex> lk(_mutex);
- _dropCollection(txn);
+ _dropCollection(opCtx);
_size = 0;
_count = 0;
}
-void OplogBufferCollection::pushEvenIfFull(OperationContext* txn, const Value& value) {
+void OplogBufferCollection::pushEvenIfFull(OperationContext* opCtx, const Value& value) {
Batch valueBatch = {value};
- pushAllNonBlocking(txn, valueBatch.begin(), valueBatch.end());
+ pushAllNonBlocking(opCtx, valueBatch.begin(), valueBatch.end());
}
-void OplogBufferCollection::push(OperationContext* txn, const Value& value) {
- pushEvenIfFull(txn, value);
+void OplogBufferCollection::push(OperationContext* opCtx, const Value& value) {
+ pushEvenIfFull(opCtx, value);
}
-void OplogBufferCollection::pushAllNonBlocking(OperationContext* txn,
+void OplogBufferCollection::pushAllNonBlocking(OperationContext* opCtx,
Batch::const_iterator begin,
Batch::const_iterator end) {
if (begin == end) {
@@ -132,7 +132,7 @@ void OplogBufferCollection::pushAllNonBlocking(OperationContext* txn,
return doc;
});
- auto status = _storageInterface->insertDocuments(txn, _nss, docsToInsert);
+ auto status = _storageInterface->insertDocuments(opCtx, _nss, docsToInsert);
fassertStatusOK(40161, status);
_lastPushedTimestamp = ts;
@@ -144,7 +144,7 @@ void OplogBufferCollection::pushAllNonBlocking(OperationContext* txn,
_cvNoLongerEmpty.notify_all();
}
-void OplogBufferCollection::waitForSpace(OperationContext* txn, std::size_t size) {}
+void OplogBufferCollection::waitForSpace(OperationContext* opCtx, std::size_t size) {}
bool OplogBufferCollection::isEmpty() const {
stdx::lock_guard<stdx::mutex> lk(_mutex);
@@ -165,10 +165,10 @@ std::size_t OplogBufferCollection::getCount() const {
return _count;
}
-void OplogBufferCollection::clear(OperationContext* txn) {
+void OplogBufferCollection::clear(OperationContext* opCtx) {
stdx::lock_guard<stdx::mutex> lk(_mutex);
- _dropCollection(txn);
- _createCollection(txn);
+ _dropCollection(opCtx);
+ _createCollection(opCtx);
_size = 0;
_count = 0;
_sentinelCount = 0;
@@ -177,12 +177,12 @@ void OplogBufferCollection::clear(OperationContext* txn) {
_peekCache = std::queue<BSONObj>();
}
-bool OplogBufferCollection::tryPop(OperationContext* txn, Value* value) {
+bool OplogBufferCollection::tryPop(OperationContext* opCtx, Value* value) {
stdx::lock_guard<stdx::mutex> lk(_mutex);
if (_count == 0) {
return false;
}
- return _pop_inlock(txn, value);
+ return _pop_inlock(opCtx, value);
}
bool OplogBufferCollection::waitForData(Seconds waitDuration) {
@@ -194,24 +194,24 @@ bool OplogBufferCollection::waitForData(Seconds waitDuration) {
return _count != 0;
}
-bool OplogBufferCollection::peek(OperationContext* txn, Value* value) {
+bool OplogBufferCollection::peek(OperationContext* opCtx, Value* value) {
stdx::lock_guard<stdx::mutex> lk(_mutex);
if (_count == 0) {
return false;
}
- *value = _peek_inlock(txn, PeekMode::kExtractEmbeddedDocument);
+ *value = _peek_inlock(opCtx, PeekMode::kExtractEmbeddedDocument);
return true;
}
boost::optional<OplogBuffer::Value> OplogBufferCollection::lastObjectPushed(
- OperationContext* txn) const {
+ OperationContext* opCtx) const {
stdx::lock_guard<stdx::mutex> lk(_mutex);
if (_count == 0) {
return boost::none;
}
const auto docs =
fassertStatusOK(40348,
- _storageInterface->findDocuments(txn,
+ _storageInterface->findDocuments(opCtx,
_nss,
kIdIdxName,
StorageInterface::ScanDirection::kBackward,
@@ -222,9 +222,9 @@ boost::optional<OplogBuffer::Value> OplogBufferCollection::lastObjectPushed(
return extractEmbeddedOplogDocument(docs.front()).getOwned();
}
-bool OplogBufferCollection::_pop_inlock(OperationContext* txn, Value* value) {
+bool OplogBufferCollection::_pop_inlock(OperationContext* opCtx, Value* value) {
BSONObj docFromCollection =
- _peek_inlock(txn, PeekMode::kReturnUnmodifiedDocumentFromCollection);
+ _peek_inlock(opCtx, PeekMode::kReturnUnmodifiedDocumentFromCollection);
_lastPoppedKey = docFromCollection["_id"].wrap("");
*value = extractEmbeddedOplogDocument(docFromCollection).getOwned();
@@ -239,7 +239,7 @@ bool OplogBufferCollection::_pop_inlock(OperationContext* txn, Value* value) {
return true;
}
-BSONObj OplogBufferCollection::_peek_inlock(OperationContext* txn, PeekMode peekMode) {
+BSONObj OplogBufferCollection::_peek_inlock(OperationContext* opCtx, PeekMode peekMode) {
invariant(_count > 0);
BSONObj startKey;
@@ -259,7 +259,7 @@ BSONObj OplogBufferCollection::_peek_inlock(OperationContext* txn, PeekMode peek
std::size_t limit = isPeekCacheEnabled ? _options.peekCacheSize : 1U;
const auto docs = fassertStatusOK(
40163,
- _storageInterface->findDocuments(txn,
+ _storageInterface->findDocuments(opCtx,
_nss,
kIdIdxName,
StorageInterface::ScanDirection::kForward,
@@ -286,14 +286,14 @@ BSONObj OplogBufferCollection::_peek_inlock(OperationContext* txn, PeekMode peek
MONGO_UNREACHABLE;
}
-void OplogBufferCollection::_createCollection(OperationContext* txn) {
+void OplogBufferCollection::_createCollection(OperationContext* opCtx) {
CollectionOptions options;
options.temp = true;
- fassert(40154, _storageInterface->createCollection(txn, _nss, options));
+ fassert(40154, _storageInterface->createCollection(opCtx, _nss, options));
}
-void OplogBufferCollection::_dropCollection(OperationContext* txn) {
- fassert(40155, _storageInterface->dropCollection(txn, _nss));
+void OplogBufferCollection::_dropCollection(OperationContext* opCtx) {
+ fassert(40155, _storageInterface->dropCollection(opCtx, _nss));
}
std::size_t OplogBufferCollection::getSentinelCount_forTest() const {
diff --git a/src/mongo/db/repl/oplog_buffer_collection.h b/src/mongo/db/repl/oplog_buffer_collection.h
index cb4cbcac8b8..1636b5bc7b8 100644
--- a/src/mongo/db/repl/oplog_buffer_collection.h
+++ b/src/mongo/db/repl/oplog_buffer_collection.h
@@ -109,27 +109,27 @@ public:
*/
Options getOptions() const;
- void startup(OperationContext* txn) override;
- void shutdown(OperationContext* txn) override;
- void pushEvenIfFull(OperationContext* txn, const Value& value) override;
- void push(OperationContext* txn, const Value& value) override;
+ void startup(OperationContext* opCtx) override;
+ void shutdown(OperationContext* opCtx) override;
+ void pushEvenIfFull(OperationContext* opCtx, const Value& value) override;
+ void push(OperationContext* opCtx, const Value& value) override;
/**
* Pushing documents with 'pushAllNonBlocking' will not handle sentinel documents properly. If
* pushing sentinel documents is required, use 'push' or 'pushEvenIfFull'.
*/
- void pushAllNonBlocking(OperationContext* txn,
+ void pushAllNonBlocking(OperationContext* opCtx,
Batch::const_iterator begin,
Batch::const_iterator end) override;
- void waitForSpace(OperationContext* txn, std::size_t size) override;
+ void waitForSpace(OperationContext* opCtx, std::size_t size) override;
bool isEmpty() const override;
std::size_t getMaxSize() const override;
std::size_t getSize() const override;
std::size_t getCount() const override;
- void clear(OperationContext* txn) override;
- bool tryPop(OperationContext* txn, Value* value) override;
+ void clear(OperationContext* opCtx) override;
+ bool tryPop(OperationContext* opCtx, Value* value) override;
bool waitForData(Seconds waitDuration) override;
- bool peek(OperationContext* txn, Value* value) override;
- boost::optional<Value> lastObjectPushed(OperationContext* txn) const override;
+ bool peek(OperationContext* opCtx, Value* value) override;
+ boost::optional<Value> lastObjectPushed(OperationContext* opCtx) const override;
// ---- Testing API ----
std::size_t getSentinelCount_forTest() const;
@@ -141,19 +141,19 @@ private:
/*
* Creates a temporary collection with the _nss namespace.
*/
- void _createCollection(OperationContext* txn);
+ void _createCollection(OperationContext* opCtx);
/*
* Drops the collection with the _nss namespace.
*/
- void _dropCollection(OperationContext* txn);
+ void _dropCollection(OperationContext* opCtx);
enum class PeekMode { kExtractEmbeddedDocument, kReturnUnmodifiedDocumentFromCollection };
/**
* Returns the oldest oplog entry in the buffer.
* Assumes the buffer is not empty.
*/
- BSONObj _peek_inlock(OperationContext* txn, PeekMode peekMode);
+ BSONObj _peek_inlock(OperationContext* opCtx, PeekMode peekMode);
// Storage interface used to perform storage engine level functions on the collection.
StorageInterface* _storageInterface;
@@ -161,7 +161,7 @@ private:
/**
* Pops an entry off the buffer in a lock.
*/
- bool _pop_inlock(OperationContext* txn, Value* value);
+ bool _pop_inlock(OperationContext* opCtx, Value* value);
// The namespace for the oplog buffer collection.
const NamespaceString _nss;
diff --git a/src/mongo/db/repl/oplog_buffer_collection_test.cpp b/src/mongo/db/repl/oplog_buffer_collection_test.cpp
index ced9ab1f495..1ee2c3ccc8c 100644
--- a/src/mongo/db/repl/oplog_buffer_collection_test.cpp
+++ b/src/mongo/db/repl/oplog_buffer_collection_test.cpp
@@ -60,7 +60,7 @@ protected:
ServiceContext::UniqueOperationContext makeOperationContext() const;
StorageInterface* _storageInterface = nullptr;
- ServiceContext::UniqueOperationContext _txn;
+ ServiceContext::UniqueOperationContext _opCtx;
private:
void setUp() override;
@@ -82,11 +82,11 @@ void OplogBufferCollectionTest::setUp() {
_storageInterface = storageInterface.get();
StorageInterface::set(service, std::move(storageInterface));
- _txn = makeOperationContext();
+ _opCtx = makeOperationContext();
}
void OplogBufferCollectionTest::tearDown() {
- _txn.reset();
+ _opCtx.reset();
_storageInterface = nullptr;
ServiceContextMongoDTest::tearDown();
}
@@ -131,50 +131,50 @@ TEST_F(OplogBufferCollectionTest, GetNamespace) {
ASSERT_EQUALS(nss, OplogBufferCollection(_storageInterface, nss).getNamespace());
}
-void testStartupCreatesCollection(OperationContext* txn,
+void testStartupCreatesCollection(OperationContext* opCtx,
StorageInterface* storageInterface,
const NamespaceString& nss) {
OplogBufferCollection oplogBuffer(storageInterface, nss);
// Collection should not exist until startup() is called.
- ASSERT_FALSE(AutoGetCollectionForRead(txn, nss).getCollection());
+ ASSERT_FALSE(AutoGetCollectionForRead(opCtx, nss).getCollection());
- oplogBuffer.startup(txn);
- ASSERT_TRUE(AutoGetCollectionForRead(txn, nss).getCollection());
+ oplogBuffer.startup(opCtx);
+ ASSERT_TRUE(AutoGetCollectionForRead(opCtx, nss).getCollection());
}
TEST_F(OplogBufferCollectionTest, StartupWithDefaultNamespaceCreatesCollection) {
auto nss = OplogBufferCollection::getDefaultNamespace();
ASSERT_FALSE(nss.isOplog());
- testStartupCreatesCollection(_txn.get(), _storageInterface, nss);
+ testStartupCreatesCollection(_opCtx.get(), _storageInterface, nss);
}
TEST_F(OplogBufferCollectionTest, StartupWithUserProvidedNamespaceCreatesCollection) {
- testStartupCreatesCollection(_txn.get(), _storageInterface, makeNamespace(_agent));
+ testStartupCreatesCollection(_opCtx.get(), _storageInterface, makeNamespace(_agent));
}
TEST_F(OplogBufferCollectionTest, StartupDropsExistingCollectionBeforeCreatingNewCollection) {
auto nss = makeNamespace(_agent);
- ASSERT_OK(_storageInterface->createCollection(_txn.get(), nss, CollectionOptions()));
+ ASSERT_OK(_storageInterface->createCollection(_opCtx.get(), nss, CollectionOptions()));
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
- ASSERT_TRUE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
+ oplogBuffer.startup(_opCtx.get());
+ ASSERT_TRUE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
}
DEATH_TEST_F(OplogBufferCollectionTest,
StartupWithOplogNamespaceTriggersFatalAssertion,
"Fatal assertion 40154 Location28838: cannot create a non-capped oplog collection") {
- testStartupCreatesCollection(_txn.get(), _storageInterface, NamespaceString("local.oplog.Z"));
+ testStartupCreatesCollection(_opCtx.get(), _storageInterface, NamespaceString("local.oplog.Z"));
}
TEST_F(OplogBufferCollectionTest, ShutdownDropsCollection) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
- ASSERT_TRUE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
- oplogBuffer.shutdown(_txn.get());
- ASSERT_FALSE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
+ oplogBuffer.startup(_opCtx.get());
+ ASSERT_TRUE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
+ oplogBuffer.shutdown(_opCtx.get());
+ ASSERT_FALSE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
}
TEST_F(OplogBufferCollectionTest, extractEmbeddedOplogDocumentChangesIdToTimestamp) {
@@ -250,7 +250,7 @@ DEATH_TEST_F(OplogBufferCollectionTest,
/**
* Check collection contents. OplogInterface returns documents in reverse natural order.
*/
-void _assertDocumentsInCollectionEquals(OperationContext* txn,
+void _assertDocumentsInCollectionEquals(OperationContext* opCtx,
const NamespaceString& nss,
const std::vector<BSONObj>& docs) {
std::vector<BSONObj> reversedTransformedDocs;
@@ -269,7 +269,7 @@ void _assertDocumentsInCollectionEquals(OperationContext* txn,
ASSERT_GT(ts, previousTimestamp);
}
std::reverse(reversedTransformedDocs.begin(), reversedTransformedDocs.end());
- OplogInterfaceLocal oplog(txn, nss.ns());
+ OplogInterfaceLocal oplog(opCtx, nss.ns());
auto iter = oplog.makeIterator();
for (const auto& doc : reversedTransformedDocs) {
ASSERT_BSONOBJ_EQ(doc, unittest::assertGet(iter->next()).first);
@@ -281,13 +281,13 @@ TEST_F(OplogBufferCollectionTest, PushOneDocumentWithPushAllNonBlockingAddsDocum
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
const std::vector<BSONObj> oplog = {makeOplogEntry(1)};
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.begin(), oplog.end());
+ oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.begin(), oplog.end());
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
}
TEST_F(OplogBufferCollectionTest,
@@ -295,7 +295,7 @@ TEST_F(OplogBufferCollectionTest,
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
const std::vector<BSONObj> emptyOplogEntries;
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
oplogBuffer.pushAllNonBlocking(nullptr, emptyOplogEntries.begin(), emptyOplogEntries.end());
@@ -306,163 +306,163 @@ TEST_F(OplogBufferCollectionTest, PushOneDocumentWithPushAddsDocument) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
BSONObj oplog = makeOplogEntry(1);
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.push(_txn.get(), oplog);
+ oplogBuffer.push(_opCtx.get(), oplog);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog});
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog});
}
TEST_F(OplogBufferCollectionTest, PushOneDocumentWithPushEvenIfFullAddsDocument) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
BSONObj oplog = makeOplogEntry(1);
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
ASSERT_EQUALS(0UL, oplogBuffer.getSentinelCount_forTest());
- _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog});
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog});
}
TEST_F(OplogBufferCollectionTest, PeekDoesNotRemoveDocument) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
BSONObj oplog1 = makeOplogEntry(1);
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.push(_txn.get(), oplog1);
+ oplogBuffer.push(_opCtx.get(), oplog1);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
// _peekOneSide should provide correct bound inclusion to storage engine when collection has one
// document.
BSONObj doc;
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog1);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
BSONObj oplog2 = makeOplogEntry(2);
- oplogBuffer.push(_txn.get(), oplog2);
+ oplogBuffer.push(_opCtx.get(), oplog2);
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
// _peekOneSide should return same result after adding new oplog entry.
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog1);
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
- _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog1, oplog2});
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog1, oplog2});
}
TEST_F(OplogBufferCollectionTest, PeekWithNoDocumentsReturnsFalse) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
BSONObj doc;
- ASSERT_FALSE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_FALSE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- _assertDocumentsInCollectionEquals(_txn.get(), nss, {});
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {});
}
TEST_F(OplogBufferCollectionTest, PopDoesNotRemoveDocumentFromCollection) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
BSONObj oplog = makeOplogEntry(1);
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.push(_txn.get(), oplog);
+ oplogBuffer.push(_opCtx.get(), oplog);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
BSONObj doc;
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog);
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog});
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog});
}
TEST_F(OplogBufferCollectionTest, PopWithNoDocumentsReturnsFalse) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
BSONObj doc;
- ASSERT_FALSE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_FALSE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- _assertDocumentsInCollectionEquals(_txn.get(), nss, {});
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {});
}
TEST_F(OplogBufferCollectionTest, PopAndPeekReturnDocumentsInOrder) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
const std::vector<BSONObj> oplog = {
makeOplogEntry(1), makeOplogEntry(2), makeOplogEntry(3),
};
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.begin(), oplog.end());
+ oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.begin(), oplog.end());
ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
BSONObj doc;
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[0]);
ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[0]);
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[1]);
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[1]);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[2]);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[2]);
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
// tryPop does not remove documents from collection.
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
}
TEST_F(OplogBufferCollectionTest, LastObjectPushedReturnsNewestOplogEntry) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
const std::vector<BSONObj> oplog = {
makeOplogEntry(1), makeOplogEntry(2), makeOplogEntry(3),
};
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.begin(), oplog.end());
+ oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.begin(), oplog.end());
ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
- auto doc = oplogBuffer.lastObjectPushed(_txn.get());
+ auto doc = oplogBuffer.lastObjectPushed(_opCtx.get());
ASSERT_BSONOBJ_EQ(*doc, oplog[2]);
ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
}
@@ -471,9 +471,9 @@ TEST_F(OplogBufferCollectionTest, LastObjectPushedReturnsNoneWithNoEntries) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
- auto doc = oplogBuffer.lastObjectPushed(_txn.get());
+ auto doc = oplogBuffer.lastObjectPushed(_opCtx.get());
ASSERT_EQUALS(doc, boost::none);
}
@@ -481,10 +481,10 @@ TEST_F(OplogBufferCollectionTest, IsEmptyReturnsTrueWhenEmptyAndFalseWhenNot) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
BSONObj oplog = makeOplogEntry(1);
ASSERT_TRUE(oplogBuffer.isEmpty());
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog);
ASSERT_FALSE(oplogBuffer.isEmpty());
}
@@ -492,7 +492,7 @@ TEST_F(OplogBufferCollectionTest, ClearClearsCollection) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
ASSERT_EQUALS(oplogBuffer.getSize(), 0UL);
ASSERT_EQUALS(0U, oplogBuffer.getSentinelCount_forTest());
@@ -500,27 +500,27 @@ TEST_F(OplogBufferCollectionTest, ClearClearsCollection) {
ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
BSONObj oplog = makeOplogEntry(1);
- oplogBuffer.push(_txn.get(), oplog);
+ oplogBuffer.push(_opCtx.get(), oplog);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
ASSERT_EQUALS(oplogBuffer.getSize(), std::size_t(oplog.objsize()));
ASSERT_EQUALS(0U, oplogBuffer.getSentinelCount_forTest());
ASSERT_EQUALS(oplog["ts"].timestamp(), oplogBuffer.getLastPushedTimestamp_forTest());
ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
- _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog});
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog});
BSONObj sentinel;
- oplogBuffer.push(_txn.get(), sentinel);
+ oplogBuffer.push(_opCtx.get(), sentinel);
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
ASSERT_EQUALS(oplogBuffer.getSize(), std::size_t(oplog.objsize() + BSONObj().objsize()));
ASSERT_EQUALS(1U, oplogBuffer.getSentinelCount_forTest());
ASSERT_EQUALS(oplog["ts"].timestamp(), oplogBuffer.getLastPushedTimestamp_forTest());
ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
- _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog, sentinel});
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog, sentinel});
BSONObj oplog2 = makeOplogEntry(2);
- oplogBuffer.push(_txn.get(), oplog2);
+ oplogBuffer.push(_opCtx.get(), oplog2);
ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
ASSERT_EQUALS(oplogBuffer.getSize(),
std::size_t(oplog.objsize() + BSONObj().objsize() + oplog2.objsize()));
@@ -528,10 +528,10 @@ TEST_F(OplogBufferCollectionTest, ClearClearsCollection) {
ASSERT_EQUALS(oplog2["ts"].timestamp(), oplogBuffer.getLastPushedTimestamp_forTest());
ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
- _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog, sentinel, oplog2});
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog, sentinel, oplog2});
BSONObj poppedDoc;
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &poppedDoc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &poppedDoc));
ASSERT_BSONOBJ_EQ(oplog, poppedDoc);
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
ASSERT_EQUALS(oplogBuffer.getSize(), std::size_t(BSONObj().objsize() + oplog2.objsize()));
@@ -539,29 +539,29 @@ TEST_F(OplogBufferCollectionTest, ClearClearsCollection) {
ASSERT_EQUALS(oplog2["ts"].timestamp(), oplogBuffer.getLastPushedTimestamp_forTest());
ASSERT_EQUALS(oplog["ts"].timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
- _assertDocumentsInCollectionEquals(_txn.get(), nss, {oplog, sentinel, oplog2});
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {oplog, sentinel, oplog2});
- oplogBuffer.clear(_txn.get());
- ASSERT_TRUE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
+ oplogBuffer.clear(_opCtx.get());
+ ASSERT_TRUE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
ASSERT_EQUALS(oplogBuffer.getSize(), 0UL);
ASSERT_EQUALS(0U, oplogBuffer.getSentinelCount_forTest());
ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPushedTimestamp_forTest());
ASSERT_EQUALS(Timestamp(), oplogBuffer.getLastPoppedTimestamp_forTest());
- _assertDocumentsInCollectionEquals(_txn.get(), nss, {});
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, {});
BSONObj doc;
- ASSERT_FALSE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_FALSE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
- ASSERT_FALSE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_FALSE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
}
TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsDocument) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
unittest::Barrier barrier(2U);
BSONObj oplog = makeOplogEntry(1);
@@ -578,11 +578,11 @@ TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsDocument) {
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
barrier.countDownAndWait();
- oplogBuffer.push(_txn.get(), oplog);
+ oplogBuffer.push(_opCtx.get(), oplog);
peekingThread.join();
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
ASSERT_TRUE(success);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog);
ASSERT_EQUALS(count, 1UL);
}
@@ -590,7 +590,7 @@ TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsDocument) {
TEST_F(OplogBufferCollectionTest, TwoWaitForDataInvocationsBlockAndFindSameDocument) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
unittest::Barrier barrier(3U);
BSONObj oplog = makeOplogEntry(1);
@@ -616,13 +616,13 @@ TEST_F(OplogBufferCollectionTest, TwoWaitForDataInvocationsBlockAndFindSameDocum
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
barrier.countDownAndWait();
- oplogBuffer.push(_txn.get(), oplog);
+ oplogBuffer.push(_opCtx.get(), oplog);
peekingThread1.join();
peekingThread2.join();
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
ASSERT_TRUE(success1);
BSONObj doc;
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog);
ASSERT_EQUALS(count1, 1UL);
ASSERT_TRUE(success2);
@@ -632,7 +632,7 @@ TEST_F(OplogBufferCollectionTest, TwoWaitForDataInvocationsBlockAndFindSameDocum
TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndTimesOutWhenItDoesNotFindDocument) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
BSONObj doc;
bool success = false;
@@ -648,95 +648,95 @@ TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndTimesOutWhenItDoesNotFindD
peekingThread.join();
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
ASSERT_FALSE(success);
- ASSERT_FALSE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_FALSE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(count, 0UL);
}
void _testPushSentinelsProperly(
- OperationContext* txn,
+ OperationContext* opCtx,
const NamespaceString& nss,
StorageInterface* storageInterface,
- stdx::function<void(OperationContext* txn,
+ stdx::function<void(OperationContext* opCtx,
OplogBufferCollection* oplogBuffer,
const std::vector<BSONObj>& oplog)> pushDocsFn) {
OplogBufferCollection oplogBuffer(storageInterface, nss);
- oplogBuffer.startup(txn);
+ oplogBuffer.startup(opCtx);
const std::vector<BSONObj> oplog = {
BSONObj(), makeOplogEntry(1), BSONObj(), BSONObj(), makeOplogEntry(2), BSONObj(),
};
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- pushDocsFn(txn, &oplogBuffer, oplog);
+ pushDocsFn(opCtx, &oplogBuffer, oplog);
ASSERT_EQUALS(oplogBuffer.getCount(), 6UL);
- _assertDocumentsInCollectionEquals(txn, nss, oplog);
+ _assertDocumentsInCollectionEquals(opCtx, nss, oplog);
}
TEST_F(OplogBufferCollectionTest, PushPushesOnSentinelsProperly) {
auto nss = makeNamespace(_agent);
- _testPushSentinelsProperly(_txn.get(),
+ _testPushSentinelsProperly(_opCtx.get(),
nss,
_storageInterface,
- [](OperationContext* txn,
+ [](OperationContext* opCtx,
OplogBufferCollection* oplogBuffer,
const std::vector<BSONObj>& oplog) {
- oplogBuffer->push(txn, oplog[0]);
+ oplogBuffer->push(opCtx, oplog[0]);
ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
- oplogBuffer->push(txn, oplog[1]);
+ oplogBuffer->push(opCtx, oplog[1]);
ASSERT_EQUALS(0U, oplogBuffer->getSentinelCount_forTest());
- oplogBuffer->push(txn, oplog[2]);
+ oplogBuffer->push(opCtx, oplog[2]);
ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
- oplogBuffer->push(txn, oplog[3]);
+ oplogBuffer->push(opCtx, oplog[3]);
ASSERT_EQUALS(2U, oplogBuffer->getSentinelCount_forTest());
- oplogBuffer->push(txn, oplog[4]);
+ oplogBuffer->push(opCtx, oplog[4]);
ASSERT_EQUALS(0U, oplogBuffer->getSentinelCount_forTest());
- oplogBuffer->push(txn, oplog[5]);
+ oplogBuffer->push(opCtx, oplog[5]);
ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
});
}
TEST_F(OplogBufferCollectionTest, PushEvenIfFullPushesOnSentinelsProperly) {
auto nss = makeNamespace(_agent);
- _testPushSentinelsProperly(_txn.get(),
+ _testPushSentinelsProperly(_opCtx.get(),
nss,
_storageInterface,
- [](OperationContext* txn,
+ [](OperationContext* opCtx,
OplogBufferCollection* oplogBuffer,
const std::vector<BSONObj>& oplog) {
- oplogBuffer->pushEvenIfFull(txn, oplog[0]);
+ oplogBuffer->pushEvenIfFull(opCtx, oplog[0]);
ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
- oplogBuffer->pushEvenIfFull(txn, oplog[1]);
+ oplogBuffer->pushEvenIfFull(opCtx, oplog[1]);
ASSERT_EQUALS(0U, oplogBuffer->getSentinelCount_forTest());
- oplogBuffer->pushEvenIfFull(txn, oplog[2]);
+ oplogBuffer->pushEvenIfFull(opCtx, oplog[2]);
ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
- oplogBuffer->pushEvenIfFull(txn, oplog[3]);
+ oplogBuffer->pushEvenIfFull(opCtx, oplog[3]);
ASSERT_EQUALS(2U, oplogBuffer->getSentinelCount_forTest());
- oplogBuffer->pushEvenIfFull(txn, oplog[4]);
+ oplogBuffer->pushEvenIfFull(opCtx, oplog[4]);
ASSERT_EQUALS(0U, oplogBuffer->getSentinelCount_forTest());
- oplogBuffer->pushEvenIfFull(txn, oplog[5]);
+ oplogBuffer->pushEvenIfFull(opCtx, oplog[5]);
ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
});
}
TEST_F(OplogBufferCollectionTest, PushAllNonBlockingPushesOnSentinelsProperly) {
auto nss = makeNamespace(_agent);
- _testPushSentinelsProperly(_txn.get(),
+ _testPushSentinelsProperly(_opCtx.get(),
nss,
_storageInterface,
- [](OperationContext* txn,
+ [](OperationContext* opCtx,
OplogBufferCollection* oplogBuffer,
const std::vector<BSONObj>& oplog) {
oplogBuffer->pushAllNonBlocking(
- txn, oplog.cbegin(), oplog.cend());
+ opCtx, oplog.cbegin(), oplog.cend());
ASSERT_EQUALS(1U, oplogBuffer->getSentinelCount_forTest());
});
}
@@ -748,207 +748,207 @@ DEATH_TEST_F(
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
const std::vector<BSONObj> oplog = {
makeOplogEntry(2), makeOplogEntry(1),
};
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.begin(), oplog.end());
+ oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.begin(), oplog.end());
}
TEST_F(OplogBufferCollectionTest, SentinelInMiddleIsReturnedInOrder) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
const std::vector<BSONObj> oplog = {
makeOplogEntry(1), makeOplogEntry(2), BSONObj(), makeOplogEntry(3),
};
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog[0]);
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog[1]);
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog[2]);
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog[3]);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[0]);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[1]);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[2]);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[3]);
ASSERT_EQUALS(oplogBuffer.getCount(), 4UL);
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
BSONObj doc;
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[0]);
ASSERT_EQUALS(oplogBuffer.getCount(), 4UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[0]);
ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[1]);
ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[1]);
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[3]);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[3]);
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
// tryPop does not remove documents from collection.
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
}
TEST_F(OplogBufferCollectionTest, SentinelAtBeginningIsReturnedAtBeginning) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
const std::vector<BSONObj> oplog = {BSONObj(), makeOplogEntry(1)};
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog[0]);
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog[1]);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[0]);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[1]);
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
BSONObj doc;
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[1]);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[1]);
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
// tryPop does not remove documents from collection.
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
}
TEST_F(OplogBufferCollectionTest, SentinelAtEndIsReturnedAtEnd) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
const std::vector<BSONObj> oplog = {makeOplogEntry(1), BSONObj()};
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog[0]);
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog[1]);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[0]);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog[1]);
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
BSONObj doc;
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[0]);
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[0]);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
// tryPop does not remove documents from collection.
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
}
TEST_F(OplogBufferCollectionTest, MultipleSentinelsAreReturnedInOrder) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
const std::vector<BSONObj> oplog = {
BSONObj(), makeOplogEntry(1), BSONObj(), BSONObj(), makeOplogEntry(2), BSONObj(),
};
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
- oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.cbegin(), oplog.cend());
+ oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.cbegin(), oplog.cend());
ASSERT_EQUALS(oplogBuffer.getCount(), 6UL);
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
BSONObj doc;
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 6UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 5UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[1]);
ASSERT_EQUALS(oplogBuffer.getCount(), 5UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[1]);
ASSERT_EQUALS(oplogBuffer.getCount(), 4UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 4UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 3UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[4]);
ASSERT_EQUALS(oplogBuffer.getCount(), 2UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(doc, oplog[4]);
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
// tryPop does not remove documents from collection.
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
}
TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsSentinel) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
unittest::Barrier barrier(2U);
BSONObj oplog;
@@ -965,11 +965,11 @@ TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsSentinel) {
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
barrier.countDownAndWait();
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog);
peekingThread.join();
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
ASSERT_TRUE(success);
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(count, 1UL);
}
@@ -977,7 +977,7 @@ TEST_F(OplogBufferCollectionTest, WaitForDataBlocksAndFindsSentinel) {
TEST_F(OplogBufferCollectionTest, TwoWaitForDataInvocationsBlockAndFindSameSentinel) {
auto nss = makeNamespace(_agent);
OplogBufferCollection oplogBuffer(_storageInterface, nss);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
unittest::Barrier barrier(3U);
BSONObj oplog;
@@ -1003,13 +1003,13 @@ TEST_F(OplogBufferCollectionTest, TwoWaitForDataInvocationsBlockAndFindSameSenti
ASSERT_EQUALS(oplogBuffer.getCount(), 0UL);
barrier.countDownAndWait();
- oplogBuffer.pushEvenIfFull(_txn.get(), oplog);
+ oplogBuffer.pushEvenIfFull(_opCtx.get(), oplog);
peekingThread1.join();
peekingThread2.join();
ASSERT_EQUALS(oplogBuffer.getCount(), 1UL);
ASSERT_TRUE(success1);
BSONObj doc;
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_TRUE(doc.isEmpty());
ASSERT_EQUALS(count1, 1UL);
ASSERT_TRUE(success2);
@@ -1041,74 +1041,74 @@ TEST_F(OplogBufferCollectionTest, PeekFillsCacheWithDocumentsFromCollection) {
std::size_t peekCacheSize = 3U;
OplogBufferCollection oplogBuffer(_storageInterface, nss, _makeOptions(3));
ASSERT_EQUALS(peekCacheSize, oplogBuffer.getOptions().peekCacheSize);
- oplogBuffer.startup(_txn.get());
+ oplogBuffer.startup(_opCtx.get());
std::vector<BSONObj> oplog;
for (int i = 0; i < 5; ++i) {
oplog.push_back(makeOplogEntry(i + 1));
};
- oplogBuffer.pushAllNonBlocking(_txn.get(), oplog.cbegin(), oplog.cend());
- _assertDocumentsInCollectionEquals(_txn.get(), nss, oplog);
+ oplogBuffer.pushAllNonBlocking(_opCtx.get(), oplog.cbegin(), oplog.cend());
+ _assertDocumentsInCollectionEquals(_opCtx.get(), nss, oplog);
// Before any peek operations, peek cache should be empty.
_assertDocumentsEqualCache({}, oplogBuffer.getPeekCache_forTest());
// First peek operation should trigger a read of 'peekCacheSize' documents from the collection.
BSONObj doc;
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(oplog[0], doc);
_assertDocumentsEqualCache({oplog[0], oplog[1], oplog[2]}, oplogBuffer.getPeekCache_forTest());
// Repeated peek operation should not modify the cache.
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(oplog[0], doc);
_assertDocumentsEqualCache({oplog[0], oplog[1], oplog[2]}, oplogBuffer.getPeekCache_forTest());
// Pop operation should remove the first element in the cache
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(oplog[0], doc);
_assertDocumentsEqualCache({oplog[1], oplog[2]}, oplogBuffer.getPeekCache_forTest());
// Next peek operation should not modify the cache.
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(oplog[1], doc);
_assertDocumentsEqualCache({oplog[1], oplog[2]}, oplogBuffer.getPeekCache_forTest());
// Pop the rest of the items in the cache.
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(oplog[1], doc);
_assertDocumentsEqualCache({oplog[2]}, oplogBuffer.getPeekCache_forTest());
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(oplog[2], doc);
_assertDocumentsEqualCache({}, oplogBuffer.getPeekCache_forTest());
// Next peek operation should replenish the cache.
// Cache size will be less than the configured 'peekCacheSize' because
// there will not be enough documents left unread in the collection.
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(oplog[3], doc);
_assertDocumentsEqualCache({oplog[3], oplog[4]}, oplogBuffer.getPeekCache_forTest());
// Pop the remaining documents from the buffer.
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(oplog[3], doc);
_assertDocumentsEqualCache({oplog[4]}, oplogBuffer.getPeekCache_forTest());
// Verify state of cache between pops using peek.
- ASSERT_TRUE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.peek(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(oplog[4], doc);
_assertDocumentsEqualCache({oplog[4]}, oplogBuffer.getPeekCache_forTest());
- ASSERT_TRUE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_TRUE(oplogBuffer.tryPop(_opCtx.get(), &doc));
ASSERT_BSONOBJ_EQ(oplog[4], doc);
_assertDocumentsEqualCache({}, oplogBuffer.getPeekCache_forTest());
// Nothing left in the collection.
- ASSERT_FALSE(oplogBuffer.peek(_txn.get(), &doc));
+ ASSERT_FALSE(oplogBuffer.peek(_opCtx.get(), &doc));
_assertDocumentsEqualCache({}, oplogBuffer.getPeekCache_forTest());
- ASSERT_FALSE(oplogBuffer.tryPop(_txn.get(), &doc));
+ ASSERT_FALSE(oplogBuffer.tryPop(_opCtx.get(), &doc));
_assertDocumentsEqualCache({}, oplogBuffer.getPeekCache_forTest());
}
diff --git a/src/mongo/db/repl/oplog_buffer_proxy.cpp b/src/mongo/db/repl/oplog_buffer_proxy.cpp
index e2080a94f19..675bb4d6186 100644
--- a/src/mongo/db/repl/oplog_buffer_proxy.cpp
+++ b/src/mongo/db/repl/oplog_buffer_proxy.cpp
@@ -44,33 +44,33 @@ OplogBuffer* OplogBufferProxy::getTarget() const {
return _target.get();
}
-void OplogBufferProxy::startup(OperationContext* txn) {
- _target->startup(txn);
+void OplogBufferProxy::startup(OperationContext* opCtx) {
+ _target->startup(opCtx);
}
-void OplogBufferProxy::shutdown(OperationContext* txn) {
+void OplogBufferProxy::shutdown(OperationContext* opCtx) {
{
stdx::lock_guard<stdx::mutex> backLock(_lastPushedMutex);
stdx::lock_guard<stdx::mutex> frontLock(_lastPeekedMutex);
_lastPushed.reset();
_lastPeeked.reset();
}
- _target->shutdown(txn);
+ _target->shutdown(opCtx);
}
-void OplogBufferProxy::pushEvenIfFull(OperationContext* txn, const Value& value) {
+void OplogBufferProxy::pushEvenIfFull(OperationContext* opCtx, const Value& value) {
stdx::lock_guard<stdx::mutex> lk(_lastPushedMutex);
_lastPushed = value;
- _target->pushEvenIfFull(txn, value);
+ _target->pushEvenIfFull(opCtx, value);
}
-void OplogBufferProxy::push(OperationContext* txn, const Value& value) {
+void OplogBufferProxy::push(OperationContext* opCtx, const Value& value) {
stdx::lock_guard<stdx::mutex> lk(_lastPushedMutex);
_lastPushed = value;
- _target->push(txn, value);
+ _target->push(opCtx, value);
}
-void OplogBufferProxy::pushAllNonBlocking(OperationContext* txn,
+void OplogBufferProxy::pushAllNonBlocking(OperationContext* opCtx,
Batch::const_iterator begin,
Batch::const_iterator end) {
if (begin == end) {
@@ -78,11 +78,11 @@ void OplogBufferProxy::pushAllNonBlocking(OperationContext* txn,
}
stdx::lock_guard<stdx::mutex> lk(_lastPushedMutex);
_lastPushed = *(end - 1);
- _target->pushAllNonBlocking(txn, begin, end);
+ _target->pushAllNonBlocking(opCtx, begin, end);
}
-void OplogBufferProxy::waitForSpace(OperationContext* txn, std::size_t size) {
- _target->waitForSpace(txn, size);
+void OplogBufferProxy::waitForSpace(OperationContext* opCtx, std::size_t size) {
+ _target->waitForSpace(opCtx, size);
}
bool OplogBufferProxy::isEmpty() const {
@@ -101,18 +101,18 @@ std::size_t OplogBufferProxy::getCount() const {
return _target->getCount();
}
-void OplogBufferProxy::clear(OperationContext* txn) {
+void OplogBufferProxy::clear(OperationContext* opCtx) {
stdx::lock_guard<stdx::mutex> backLock(_lastPushedMutex);
stdx::lock_guard<stdx::mutex> frontLock(_lastPeekedMutex);
_lastPushed.reset();
_lastPeeked.reset();
- _target->clear(txn);
+ _target->clear(opCtx);
}
-bool OplogBufferProxy::tryPop(OperationContext* txn, Value* value) {
+bool OplogBufferProxy::tryPop(OperationContext* opCtx, Value* value) {
stdx::lock_guard<stdx::mutex> backLock(_lastPushedMutex);
stdx::lock_guard<stdx::mutex> frontLock(_lastPeekedMutex);
- if (!_target->tryPop(txn, value)) {
+ if (!_target->tryPop(opCtx, value)) {
return false;
}
_lastPeeked.reset();
@@ -133,13 +133,13 @@ bool OplogBufferProxy::waitForData(Seconds waitDuration) {
return _target->waitForData(waitDuration);
}
-bool OplogBufferProxy::peek(OperationContext* txn, Value* value) {
+bool OplogBufferProxy::peek(OperationContext* opCtx, Value* value) {
stdx::lock_guard<stdx::mutex> lk(_lastPeekedMutex);
if (_lastPeeked) {
*value = *_lastPeeked;
return true;
}
- if (_target->peek(txn, value)) {
+ if (_target->peek(opCtx, value)) {
_lastPeeked = *value;
return true;
}
@@ -147,7 +147,7 @@ bool OplogBufferProxy::peek(OperationContext* txn, Value* value) {
}
boost::optional<OplogBuffer::Value> OplogBufferProxy::lastObjectPushed(
- OperationContext* txn) const {
+ OperationContext* opCtx) const {
stdx::lock_guard<stdx::mutex> lk(_lastPushedMutex);
if (!_lastPushed) {
return boost::none;
diff --git a/src/mongo/db/repl/oplog_buffer_proxy.h b/src/mongo/db/repl/oplog_buffer_proxy.h
index 2624a9bb68f..ae9be1340ff 100644
--- a/src/mongo/db/repl/oplog_buffer_proxy.h
+++ b/src/mongo/db/repl/oplog_buffer_proxy.h
@@ -55,23 +55,23 @@ public:
*/
OplogBuffer* getTarget() const;
- void startup(OperationContext* txn) override;
- void shutdown(OperationContext* txn) override;
- void pushEvenIfFull(OperationContext* txn, const Value& value) override;
- void push(OperationContext* txn, const Value& value) override;
- void pushAllNonBlocking(OperationContext* txn,
+ void startup(OperationContext* opCtx) override;
+ void shutdown(OperationContext* opCtx) override;
+ void pushEvenIfFull(OperationContext* opCtx, const Value& value) override;
+ void push(OperationContext* opCtx, const Value& value) override;
+ void pushAllNonBlocking(OperationContext* opCtx,
Batch::const_iterator begin,
Batch::const_iterator end) override;
- void waitForSpace(OperationContext* txn, std::size_t size) override;
+ void waitForSpace(OperationContext* opCtx, std::size_t size) override;
bool isEmpty() const override;
std::size_t getMaxSize() const override;
std::size_t getSize() const override;
std::size_t getCount() const override;
- void clear(OperationContext* txn) override;
- bool tryPop(OperationContext* txn, Value* value) override;
+ void clear(OperationContext* opCtx) override;
+ bool tryPop(OperationContext* opCtx, Value* value) override;
bool waitForData(Seconds waitDuration) override;
- bool peek(OperationContext* txn, Value* value) override;
- boost::optional<Value> lastObjectPushed(OperationContext* txn) const override;
+ bool peek(OperationContext* opCtx, Value* value) override;
+ boost::optional<Value> lastObjectPushed(OperationContext* opCtx) const override;
// ---- Testing API ----
boost::optional<Value> getLastPeeked_forTest() const;
diff --git a/src/mongo/db/repl/oplog_buffer_proxy_test.cpp b/src/mongo/db/repl/oplog_buffer_proxy_test.cpp
index a59a66f0979..a372eea8c85 100644
--- a/src/mongo/db/repl/oplog_buffer_proxy_test.cpp
+++ b/src/mongo/db/repl/oplog_buffer_proxy_test.cpp
@@ -57,17 +57,17 @@ public:
void shutdown(OperationContext*) override {
shutdownCalled = true;
}
- void pushEvenIfFull(OperationContext* txn, const Value& value) override {
- push(txn, value);
+ void pushEvenIfFull(OperationContext* opCtx, const Value& value) override {
+ push(opCtx, value);
}
void push(OperationContext*, const Value& value) override {
values.push_back(value);
}
- void pushAllNonBlocking(OperationContext* txn,
+ void pushAllNonBlocking(OperationContext* opCtx,
Batch::const_iterator begin,
Batch::const_iterator end) override {
for (auto i = begin; i != end; ++i) {
- push(txn, *i);
+ push(opCtx, *i);
}
}
void waitForSpace(OperationContext*, std::size_t) override {
@@ -92,9 +92,9 @@ public:
void clear(OperationContext*) override {
values.clear();
}
- bool tryPop(OperationContext* txn, Value* value) override {
+ bool tryPop(OperationContext* opCtx, Value* value) override {
tryPopCalled = true;
- if (!peek(txn, value)) {
+ if (!peek(opCtx, value)) {
return false;
}
values.pop_front();
@@ -140,7 +140,7 @@ private:
protected:
OplogBufferMock* _mock = nullptr;
std::unique_ptr<OplogBufferProxy> _proxy;
- OperationContext* _txn = nullptr; // Not dereferenced.
+ OperationContext* _opCtx = nullptr; // Not dereferenced.
};
void OplogBufferProxyTest::setUp() {
@@ -165,29 +165,29 @@ TEST_F(OplogBufferProxyTest, GetTarget) {
}
TEST_F(OplogBufferProxyTest, Startup) {
- _proxy->startup(_txn);
+ _proxy->startup(_opCtx);
ASSERT_TRUE(_mock->startupCalled);
}
TEST_F(OplogBufferProxyTest, ShutdownResetsCachedValues) {
auto pushValue = BSON("x" << 1);
- _proxy->push(_txn, pushValue);
+ _proxy->push(_opCtx, pushValue);
OplogBuffer::Value peekValue;
- ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+ ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
ASSERT_BSONOBJ_EQ(pushValue, peekValue);
- ASSERT_NOT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+ ASSERT_NOT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
ASSERT_NOT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
- _proxy->shutdown(_txn);
+ _proxy->shutdown(_opCtx);
ASSERT_TRUE(_mock->shutdownCalled);
- ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+ ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
}
TEST_F(OplogBufferProxyTest, WaitForSpace) {
- _proxy->waitForSpace(_txn, 100U);
+ _proxy->waitForSpace(_opCtx, 100U);
ASSERT_TRUE(_mock->waitForSpaceCalled);
}
@@ -199,7 +199,7 @@ TEST_F(OplogBufferProxyTest, MaxSize) {
TEST_F(OplogBufferProxyTest, EmptySizeAndCount) {
ASSERT_TRUE(_proxy->isEmpty());
OplogBuffer::Batch values = {BSON("x" << 1), BSON("x" << 2)};
- _proxy->pushAllNonBlocking(_txn, values.cbegin(), values.cend());
+ _proxy->pushAllNonBlocking(_opCtx, values.cbegin(), values.cend());
ASSERT_FALSE(_proxy->isEmpty());
ASSERT_EQUALS(values.size(), _mock->getCount());
ASSERT_EQUALS(_mock->getCount(), _proxy->getCount());
@@ -209,79 +209,79 @@ TEST_F(OplogBufferProxyTest, EmptySizeAndCount) {
TEST_F(OplogBufferProxyTest, ClearResetsCachedValues) {
OplogBuffer::Batch values = {BSON("x" << 1), BSON("x" << 2)};
- _proxy->pushAllNonBlocking(_txn, values.cbegin(), values.cend());
+ _proxy->pushAllNonBlocking(_opCtx, values.cbegin(), values.cend());
ASSERT_FALSE(_mock->isEmpty());
- auto lastObjPushed = _proxy->lastObjectPushed(_txn);
+ auto lastObjPushed = _proxy->lastObjectPushed(_opCtx);
ASSERT_NOT_EQUALS(boost::none, lastObjPushed);
ASSERT_BSONOBJ_EQ(values.back(), *lastObjPushed);
ASSERT_FALSE(_mock->lastObjectPushedCalled);
OplogBuffer::Value peekValue;
- ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+ ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
ASSERT_NOT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
- _proxy->clear(_txn);
+ _proxy->clear(_opCtx);
ASSERT_TRUE(_mock->isEmpty());
- ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+ ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
}
void _testPushFunctionUpdatesCachedLastObjectPushed(
- OperationContext* txn,
+ OperationContext* opCtx,
OplogBuffer* proxy,
OplogBufferMock* mock,
stdx::function<std::size_t(
- OperationContext* txn, OplogBuffer* proxy, const OplogBuffer::Value& value)> pushFn) {
- ASSERT_EQUALS(proxy->lastObjectPushed(txn), boost::none);
+ OperationContext* opCtx, OplogBuffer* proxy, const OplogBuffer::Value& value)> pushFn) {
+ ASSERT_EQUALS(proxy->lastObjectPushed(opCtx), boost::none);
ASSERT_FALSE(mock->lastObjectPushedCalled);
auto val = BSON("x" << 1);
- auto numPushed = pushFn(txn, proxy, val);
+ auto numPushed = pushFn(opCtx, proxy, val);
ASSERT_EQUALS(numPushed, mock->values.size());
ASSERT_BSONOBJ_EQ(val, mock->values.back());
- auto lastObjPushed = proxy->lastObjectPushed(txn);
+ auto lastObjPushed = proxy->lastObjectPushed(opCtx);
ASSERT_NOT_EQUALS(boost::none, lastObjPushed);
ASSERT_BSONOBJ_EQ(val, *lastObjPushed);
ASSERT_FALSE(mock->lastObjectPushedCalled);
}
TEST_F(OplogBufferProxyTest, PushEvenIfFullUpdatesCachedLastObjectPushed) {
- auto pushFn = [](OperationContext* txn, OplogBuffer* proxy, const OplogBuffer::Value& value) {
- proxy->pushEvenIfFull(txn, value);
+ auto pushFn = [](OperationContext* opCtx, OplogBuffer* proxy, const OplogBuffer::Value& value) {
+ proxy->pushEvenIfFull(opCtx, value);
return 1U;
};
- _testPushFunctionUpdatesCachedLastObjectPushed(_txn, _proxy.get(), _mock, pushFn);
+ _testPushFunctionUpdatesCachedLastObjectPushed(_opCtx, _proxy.get(), _mock, pushFn);
}
TEST_F(OplogBufferProxyTest, PushUpdatesCachedLastObjectPushed) {
- auto pushFn = [](OperationContext* txn, OplogBuffer* proxy, const OplogBuffer::Value& value) {
- proxy->push(txn, value);
+ auto pushFn = [](OperationContext* opCtx, OplogBuffer* proxy, const OplogBuffer::Value& value) {
+ proxy->push(opCtx, value);
return 1U;
};
- _testPushFunctionUpdatesCachedLastObjectPushed(_txn, _proxy.get(), _mock, pushFn);
+ _testPushFunctionUpdatesCachedLastObjectPushed(_opCtx, _proxy.get(), _mock, pushFn);
}
TEST_F(OplogBufferProxyTest, PushAllNonBlockingUpdatesCachedLastObjectPushed) {
- auto pushFn = [](OperationContext* txn, OplogBuffer* proxy, const OplogBuffer::Value& value) {
+ auto pushFn = [](OperationContext* opCtx, OplogBuffer* proxy, const OplogBuffer::Value& value) {
OplogBuffer::Batch values = {BSON("x" << 2), value};
- proxy->pushAllNonBlocking(txn, values.cbegin(), values.cend());
+ proxy->pushAllNonBlocking(opCtx, values.cbegin(), values.cend());
return values.size();
};
- _testPushFunctionUpdatesCachedLastObjectPushed(_txn, _proxy.get(), _mock, pushFn);
+ _testPushFunctionUpdatesCachedLastObjectPushed(_opCtx, _proxy.get(), _mock, pushFn);
}
TEST_F(OplogBufferProxyTest, PushAllNonBlockingDoesNotUpdateCachedLastObjectPushedOnEmptyBatch) {
OplogBuffer::Batch values;
- _proxy->pushAllNonBlocking(_txn, values.cbegin(), values.cend());
+ _proxy->pushAllNonBlocking(_opCtx, values.cbegin(), values.cend());
ASSERT_EQUALS(values.size(), _mock->values.size());
- ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+ ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
ASSERT_FALSE(_mock->lastObjectPushedCalled);
}
TEST_F(OplogBufferProxyTest, WaitForDataReturnsTrueImmediatelyIfLastObjectPushedIsCached) {
- _proxy->pushEvenIfFull(_txn, BSON("x" << 1));
+ _proxy->pushEvenIfFull(_opCtx, BSON("x" << 1));
ASSERT_TRUE(_proxy->waitForData(Seconds(10)));
ASSERT_FALSE(_mock->waitForDataCalled);
}
@@ -293,15 +293,15 @@ TEST_F(OplogBufferProxyTest, WaitForDataForwardsCallToTargetIfLastObjectPushedIs
TEST_F(OplogBufferProxyTest, TryPopResetsLastPushedObjectIfBufferIsEmpty) {
auto pushValue = BSON("x" << 1);
- _proxy->push(_txn, BSON("x" << 1));
- auto lastPushed = _proxy->lastObjectPushed(_txn);
- ASSERT_NOT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+ _proxy->push(_opCtx, BSON("x" << 1));
+ auto lastPushed = _proxy->lastObjectPushed(_opCtx);
+ ASSERT_NOT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
ASSERT_BSONOBJ_EQ(pushValue, *lastPushed);
OplogBuffer::Value poppedValue;
- ASSERT_TRUE(_proxy->tryPop(_txn, &poppedValue));
+ ASSERT_TRUE(_proxy->tryPop(_opCtx, &poppedValue));
ASSERT_BSONOBJ_EQ(pushValue, poppedValue);
- ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_txn));
+ ASSERT_EQUALS(boost::none, _proxy->lastObjectPushed(_opCtx));
// waitForData should forward call to underlying buffer.
ASSERT_FALSE(_proxy->waitForData(Seconds(10)));
@@ -311,41 +311,41 @@ TEST_F(OplogBufferProxyTest, TryPopResetsLastPushedObjectIfBufferIsEmpty) {
TEST_F(OplogBufferProxyTest, PeekCachesFrontOfBuffer) {
OplogBuffer::Value peekValue;
ASSERT_FALSE(_mock->peekCalled);
- ASSERT_FALSE(_proxy->peek(_txn, &peekValue));
+ ASSERT_FALSE(_proxy->peek(_opCtx, &peekValue));
ASSERT_TRUE(_mock->peekCalled);
ASSERT_TRUE(peekValue.isEmpty());
_mock->peekCalled = false;
OplogBuffer::Batch values = {BSON("x" << 1), BSON("x" << 2)};
- _proxy->pushAllNonBlocking(_txn, values.cbegin(), values.cend());
+ _proxy->pushAllNonBlocking(_opCtx, values.cbegin(), values.cend());
ASSERT_EQUALS(values.size(), _mock->values.size());
- ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+ ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
ASSERT_TRUE(_mock->peekCalled);
ASSERT_BSONOBJ_EQ(values.front(), peekValue);
_mock->peekCalled = false;
peekValue = OplogBuffer::Value();
- ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+ ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
ASSERT_FALSE(_mock->peekCalled);
ASSERT_BSONOBJ_EQ(values.front(), peekValue);
}
TEST_F(OplogBufferProxyTest, TryPopClearsCachedFrontValue) {
OplogBuffer::Batch values = {BSON("x" << 1), BSON("x" << 2)};
- _proxy->pushAllNonBlocking(_txn, values.cbegin(), values.cend());
+ _proxy->pushAllNonBlocking(_opCtx, values.cbegin(), values.cend());
ASSERT_EQUALS(values.size(), _mock->values.size());
// Peek and pop first value {x: 1}.
OplogBuffer::Value peekValue;
- ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+ ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
ASSERT_TRUE(_mock->peekCalled);
ASSERT_BSONOBJ_EQ(values.front(), peekValue);
_mock->peekCalled = false;
peekValue = OplogBuffer::Value();
OplogBuffer::Value poppedValue;
- ASSERT_TRUE(_proxy->tryPop(_txn, &poppedValue));
+ ASSERT_TRUE(_proxy->tryPop(_opCtx, &poppedValue));
ASSERT_TRUE(_mock->tryPopCalled);
ASSERT_BSONOBJ_EQ(values.front(), poppedValue);
ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
@@ -353,14 +353,14 @@ TEST_F(OplogBufferProxyTest, TryPopClearsCachedFrontValue) {
poppedValue = OplogBuffer::Value();
// Peek and pop second value {x: 2}.
- ASSERT_TRUE(_proxy->peek(_txn, &peekValue));
+ ASSERT_TRUE(_proxy->peek(_opCtx, &peekValue));
ASSERT_TRUE(_mock->peekCalled);
ASSERT_BSONOBJ_EQ(values.back(), peekValue);
ASSERT_NOT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
_mock->peekCalled = false;
peekValue = OplogBuffer::Value();
- ASSERT_TRUE(_proxy->tryPop(_txn, &poppedValue));
+ ASSERT_TRUE(_proxy->tryPop(_opCtx, &poppedValue));
ASSERT_TRUE(_mock->tryPopCalled);
ASSERT_BSONOBJ_EQ(values.back(), poppedValue);
ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
@@ -368,12 +368,12 @@ TEST_F(OplogBufferProxyTest, TryPopClearsCachedFrontValue) {
poppedValue = OplogBuffer::Value();
// Peek and pop empty buffer.
- ASSERT_FALSE(_proxy->peek(_txn, &peekValue));
+ ASSERT_FALSE(_proxy->peek(_opCtx, &peekValue));
ASSERT_TRUE(_mock->peekCalled);
ASSERT_TRUE(peekValue.isEmpty());
ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
- ASSERT_FALSE(_proxy->tryPop(_txn, &poppedValue));
+ ASSERT_FALSE(_proxy->tryPop(_opCtx, &poppedValue));
ASSERT_TRUE(_mock->tryPopCalled);
ASSERT_TRUE(poppedValue.isEmpty());
ASSERT_EQUALS(boost::none, _proxy->getLastPeeked_forTest());
diff --git a/src/mongo/db/repl/oplog_interface_local.cpp b/src/mongo/db/repl/oplog_interface_local.cpp
index 03b93892885..a68fd8db0d6 100644
--- a/src/mongo/db/repl/oplog_interface_local.cpp
+++ b/src/mongo/db/repl/oplog_interface_local.cpp
@@ -43,7 +43,7 @@ namespace {
class OplogIteratorLocal : public OplogInterface::Iterator {
public:
- OplogIteratorLocal(OperationContext* txn, const std::string& collectionName);
+ OplogIteratorLocal(OperationContext* opCtx, const std::string& collectionName);
StatusWith<Value> next() override;
@@ -55,12 +55,12 @@ private:
std::unique_ptr<PlanExecutor> _exec;
};
-OplogIteratorLocal::OplogIteratorLocal(OperationContext* txn, const std::string& collectionName)
- : _transaction(txn, MODE_IS),
- _dbLock(txn->lockState(), nsToDatabase(collectionName), MODE_IS),
- _collectionLock(txn->lockState(), collectionName, MODE_S),
- _ctx(txn, collectionName),
- _exec(InternalPlanner::collectionScan(txn,
+OplogIteratorLocal::OplogIteratorLocal(OperationContext* opCtx, const std::string& collectionName)
+ : _transaction(opCtx, MODE_IS),
+ _dbLock(opCtx->lockState(), nsToDatabase(collectionName), MODE_IS),
+ _collectionLock(opCtx->lockState(), collectionName, MODE_S),
+ _ctx(opCtx, collectionName),
+ _exec(InternalPlanner::collectionScan(opCtx,
collectionName,
_ctx.db()->getCollection(collectionName),
PlanExecutor::YIELD_MANUAL,
@@ -84,20 +84,21 @@ StatusWith<OplogInterface::Iterator::Value> OplogIteratorLocal::next() {
} // namespace
-OplogInterfaceLocal::OplogInterfaceLocal(OperationContext* txn, const std::string& collectionName)
- : _txn(txn), _collectionName(collectionName) {
- invariant(txn);
+OplogInterfaceLocal::OplogInterfaceLocal(OperationContext* opCtx, const std::string& collectionName)
+ : _opCtx(opCtx), _collectionName(collectionName) {
+ invariant(opCtx);
invariant(!collectionName.empty());
}
std::string OplogInterfaceLocal::toString() const {
return str::stream() << "LocalOplogInterface: "
"operation context: "
- << _txn->getOpID() << "; collection: " << _collectionName;
+ << _opCtx->getOpID() << "; collection: " << _collectionName;
}
std::unique_ptr<OplogInterface::Iterator> OplogInterfaceLocal::makeIterator() const {
- return std::unique_ptr<OplogInterface::Iterator>(new OplogIteratorLocal(_txn, _collectionName));
+ return std::unique_ptr<OplogInterface::Iterator>(
+ new OplogIteratorLocal(_opCtx, _collectionName));
}
} // namespace repl
diff --git a/src/mongo/db/repl/oplog_interface_local.h b/src/mongo/db/repl/oplog_interface_local.h
index 32c9adc4377..577dbe8d7fa 100644
--- a/src/mongo/db/repl/oplog_interface_local.h
+++ b/src/mongo/db/repl/oplog_interface_local.h
@@ -42,12 +42,12 @@ namespace repl {
class OplogInterfaceLocal : public OplogInterface {
public:
- OplogInterfaceLocal(OperationContext* txn, const std::string& collectionName);
+ OplogInterfaceLocal(OperationContext* opCtx, const std::string& collectionName);
std::string toString() const override;
std::unique_ptr<OplogInterface::Iterator> makeIterator() const override;
private:
- OperationContext* _txn;
+ OperationContext* _opCtx;
std::string _collectionName;
};
diff --git a/src/mongo/db/repl/oplogreader.cpp b/src/mongo/db/repl/oplogreader.cpp
index 92bc6648b8b..665554c25b2 100644
--- a/src/mongo/db/repl/oplogreader.cpp
+++ b/src/mongo/db/repl/oplogreader.cpp
@@ -152,7 +152,7 @@ Status OplogReader::_compareRequiredOpTimeWithQueryResponse(const OpTime& requir
return Status::OK();
}
-void OplogReader::connectToSyncSource(OperationContext* txn,
+void OplogReader::connectToSyncSource(OperationContext* opCtx,
const OpTime& lastOpTimeFetched,
const OpTime& requiredOpTime,
ReplicationCoordinator* replCoord) {
diff --git a/src/mongo/db/repl/oplogreader.h b/src/mongo/db/repl/oplogreader.h
index 1434125697a..641315b748f 100644
--- a/src/mongo/db/repl/oplogreader.h
+++ b/src/mongo/db/repl/oplogreader.h
@@ -155,7 +155,7 @@ public:
* sync source blacklist.
* This function may throw DB exceptions.
*/
- void connectToSyncSource(OperationContext* txn,
+ void connectToSyncSource(OperationContext* opCtx,
const OpTime& lastOpTimeFetched,
const OpTime& requiredOpTime,
ReplicationCoordinator* replCoord);
diff --git a/src/mongo/db/repl/repl_client_info.cpp b/src/mongo/db/repl/repl_client_info.cpp
index 3e98a0cb9d3..8064f8c5fc0 100644
--- a/src/mongo/db/repl/repl_client_info.cpp
+++ b/src/mongo/db/repl/repl_client_info.cpp
@@ -48,9 +48,10 @@ void ReplClientInfo::setLastOp(const OpTime& ot) {
_lastOp = ot;
}
-void ReplClientInfo::setLastOpToSystemLastOpTime(OperationContext* txn) {
- ReplicationCoordinator* replCoord = repl::ReplicationCoordinator::get(txn->getServiceContext());
- if (replCoord->isReplEnabled() && txn->writesAreReplicated()) {
+void ReplClientInfo::setLastOpToSystemLastOpTime(OperationContext* opCtx) {
+ ReplicationCoordinator* replCoord =
+ repl::ReplicationCoordinator::get(opCtx->getServiceContext());
+ if (replCoord->isReplEnabled() && opCtx->writesAreReplicated()) {
setLastOp(replCoord->getMyLastAppliedOpTime());
}
}
diff --git a/src/mongo/db/repl/repl_client_info.h b/src/mongo/db/repl/repl_client_info.h
index 3c81953d65f..3c3910cf78d 100644
--- a/src/mongo/db/repl/repl_client_info.h
+++ b/src/mongo/db/repl/repl_client_info.h
@@ -76,7 +76,7 @@ public:
* This is necessary when doing no-op writes, as we need to set the client's lastOp to a proper
* value for write concern wait to work.
*/
- void setLastOpToSystemLastOpTime(OperationContext* txn);
+ void setLastOpToSystemLastOpTime(OperationContext* opCtx);
private:
static const long long kUninitializedTerm = -1;
diff --git a/src/mongo/db/repl/repl_set_commands.cpp b/src/mongo/db/repl/repl_set_commands.cpp
index c2793e42764..f3a0cd748e2 100644
--- a/src/mongo/db/repl/repl_set_commands.cpp
+++ b/src/mongo/db/repl/repl_set_commands.cpp
@@ -93,7 +93,7 @@ public:
return Status::OK();
}
CmdReplSetTest() : ReplSetCommand("replSetTest") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -165,7 +165,7 @@ MONGO_INITIALIZER(RegisterReplSetTestCmd)(InitializerContext* context) {
class CmdReplSetGetRBID : public ReplSetCommand {
public:
CmdReplSetGetRBID() : ReplSetCommand("replSetGetRBID") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -188,14 +188,14 @@ public:
help << "\nhttp://dochub.mongodb.org/core/replicasetcommands";
}
CmdReplSetGetStatus() : ReplSetCommand("replSetGetStatus", true) {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
string& errmsg,
BSONObjBuilder& result) {
if (cmdObj["forShell"].trueValue())
- LastError::get(txn->getClient()).disable();
+ LastError::get(opCtx->getClient()).disable();
Status status = getGlobalReplicationCoordinator()->checkReplEnabledForCommand(&result);
if (!status.isOK())
@@ -230,7 +230,7 @@ public:
help << "\nhttp://dochub.mongodb.org/core/replicasetcommands";
}
CmdReplSetGetConfig() : ReplSetCommand("replSetGetConfig", true) {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -330,7 +330,7 @@ public:
h << "Initiate/christen a replica set.";
h << "\nhttp://dochub.mongodb.org/core/replicasetcommands";
}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -342,7 +342,7 @@ public:
}
std::string replSetString =
- ReplicationCoordinator::get(txn)->getSettings().getReplSetString();
+ ReplicationCoordinator::get(opCtx)->getSettings().getReplSetString();
if (replSetString.empty()) {
return appendCommandStatus(result,
Status(ErrorCodes::NoReplicationEnabled,
@@ -356,7 +356,7 @@ public:
result.append("info2", noConfigMessage);
log() << "initiate : " << noConfigMessage;
- ReplicationCoordinatorExternalStateImpl externalState(StorageInterface::get(txn));
+ ReplicationCoordinatorExternalStateImpl externalState(StorageInterface::get(opCtx));
std::string name;
std::vector<HostAndPort> seeds;
parseReplSetSeedList(&externalState, replSetString, &name, &seeds); // may throw...
@@ -386,7 +386,7 @@ public:
}
Status status =
- getGlobalReplicationCoordinator()->processReplSetInitiate(txn, configObj, &result);
+ getGlobalReplicationCoordinator()->processReplSetInitiate(opCtx, configObj, &result);
return appendCommandStatus(result, status);
}
@@ -404,7 +404,7 @@ public:
help << "\nhttp://dochub.mongodb.org/core/replicasetcommands";
}
CmdReplSetReconfig() : ReplSetCommand("replSetReconfig") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -424,15 +424,15 @@ public:
parsedArgs.newConfigObj = cmdObj["replSetReconfig"].Obj();
parsedArgs.force = cmdObj.hasField("force") && cmdObj["force"].trueValue();
status =
- getGlobalReplicationCoordinator()->processReplSetReconfig(txn, parsedArgs, &result);
+ getGlobalReplicationCoordinator()->processReplSetReconfig(opCtx, parsedArgs, &result);
- ScopedTransaction scopedXact(txn, MODE_X);
- Lock::GlobalWrite globalWrite(txn->lockState());
+ ScopedTransaction scopedXact(opCtx, MODE_X);
+ Lock::GlobalWrite globalWrite(opCtx->lockState());
- WriteUnitOfWork wuow(txn);
+ WriteUnitOfWork wuow(opCtx);
if (status.isOK() && !parsedArgs.force) {
getGlobalServiceContext()->getOpObserver()->onOpMessage(
- txn,
+ opCtx,
BSON("msg"
<< "Reconfig set"
<< "version"
@@ -462,7 +462,7 @@ public:
help << "\nhttp://dochub.mongodb.org/core/replicasetcommands";
}
CmdReplSetFreeze() : ReplSetCommand("replSetFreeze") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -494,7 +494,7 @@ public:
help << "http://dochub.mongodb.org/core/replicasetcommands";
}
CmdReplSetStepDown() : ReplSetCommand("replSetStepDown") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -543,7 +543,7 @@ public:
log() << "Attempting to step down in response to replSetStepDown command";
status = getGlobalReplicationCoordinator()->stepDown(
- txn, force, Seconds(secondaryCatchUpPeriodSecs), Seconds(stepDownForSecs));
+ opCtx, force, Seconds(secondaryCatchUpPeriodSecs), Seconds(stepDownForSecs));
return appendCommandStatus(result, status);
}
@@ -560,7 +560,7 @@ public:
help << "Enable or disable maintenance mode.";
}
CmdReplSetMaintenance() : ReplSetCommand("replSetMaintenance") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -589,7 +589,7 @@ public:
"in-progress initial sync.";
}
CmdReplSetSyncFrom() : ReplSetCommand("replSetSyncFrom") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -606,7 +606,7 @@ public:
return appendCommandStatus(result,
getGlobalReplicationCoordinator()->processReplSetSyncFrom(
- txn, targetHostAndPort, &result));
+ opCtx, targetHostAndPort, &result));
}
private:
@@ -618,13 +618,13 @@ private:
class CmdReplSetUpdatePosition : public ReplSetCommand {
public:
CmdReplSetUpdatePosition() : ReplSetCommand("replSetUpdatePosition") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
string& errmsg,
BSONObjBuilder& result) {
- auto replCoord = repl::ReplicationCoordinator::get(txn->getClient()->getServiceContext());
+ auto replCoord = repl::ReplicationCoordinator::get(opCtx->getClient()->getServiceContext());
Status status = replCoord->checkReplEnabledForCommand(&result);
if (!status.isOK())
@@ -684,7 +684,7 @@ namespace {
* The "local" database does NOT count except for "rs.oplog" collection.
* Used to set the hasData field on replset heartbeat command response.
*/
-bool replHasDatabases(OperationContext* txn) {
+bool replHasDatabases(OperationContext* opCtx) {
std::vector<string> names;
StorageEngine* storageEngine = getGlobalServiceContext()->getGlobalStorageEngine();
storageEngine->listDatabases(&names);
@@ -697,7 +697,7 @@ bool replHasDatabases(OperationContext* txn) {
// we have a local database. return true if oplog isn't empty
BSONObj o;
- if (Helpers::getSingleton(txn, repl::rsOplogName.c_str(), o)) {
+ if (Helpers::getSingleton(opCtx, repl::rsOplogName.c_str(), o)) {
return true;
}
}
@@ -718,7 +718,7 @@ MONGO_FP_DECLARE(rsDelayHeartbeatResponse);
class CmdReplSetHeartbeat : public ReplSetCommand {
public:
CmdReplSetHeartbeat() : ReplSetCommand("replSetHeartbeat") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -740,7 +740,7 @@ public:
/* we want to keep heartbeat connections open when relinquishing primary.
tag them here. */
transport::Session::TagMask originalTag = 0;
- auto session = txn->getClient()->session();
+ auto session = opCtx->getClient()->session();
if (session) {
originalTag = session->getTags();
session->replaceTags(originalTag | transport::Session::kKeepOpen);
@@ -777,7 +777,7 @@ public:
// ugh.
if (args.getCheckEmpty()) {
- result.append("hasData", replHasDatabases(txn));
+ result.append("hasData", replHasDatabases(opCtx));
}
ReplSetHeartbeatResponse response;
@@ -795,7 +795,7 @@ class CmdReplSetFresh : public ReplSetCommand {
public:
CmdReplSetFresh() : ReplSetCommand("replSetFresh") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -828,7 +828,7 @@ public:
CmdReplSetElect() : ReplSetCommand("replSetElect") {}
private:
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -862,7 +862,7 @@ class CmdReplSetStepUp : public ReplSetCommand {
public:
CmdReplSetStepUp() : ReplSetCommand("replSetStepUp") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
diff --git a/src/mongo/db/repl/repl_set_request_votes.cpp b/src/mongo/db/repl/repl_set_request_votes.cpp
index 02eb5311cb3..5577952807d 100644
--- a/src/mongo/db/repl/repl_set_request_votes.cpp
+++ b/src/mongo/db/repl/repl_set_request_votes.cpp
@@ -47,7 +47,7 @@ public:
CmdReplSetRequestVotes() : ReplSetCommand("replSetRequestVotes") {}
private:
- bool run(OperationContext* txn,
+ bool run(OperationContext* opCtx,
const std::string&,
BSONObj& cmdObj,
int,
@@ -67,7 +67,7 @@ private:
// We want to keep request vote connection open when relinquishing primary.
// Tag it here.
transport::Session::TagMask originalTag = 0;
- auto session = txn->getClient()->session();
+ auto session = opCtx->getClient()->session();
if (session) {
originalTag = session->getTags();
session->replaceTags(originalTag | transport::Session::kKeepOpen);
@@ -82,7 +82,7 @@ private:
ReplSetRequestVotesResponse response;
status = getGlobalReplicationCoordinator()->processReplSetRequestVotes(
- txn, parsedArgs, &response);
+ opCtx, parsedArgs, &response);
response.addToBSON(&result);
return appendCommandStatus(result, status);
}
diff --git a/src/mongo/db/repl/repl_set_web_handler.cpp b/src/mongo/db/repl/repl_set_web_handler.cpp
index 3f67cd9a45c..404dc659ae7 100644
--- a/src/mongo/db/repl/repl_set_web_handler.cpp
+++ b/src/mongo/db/repl/repl_set_web_handler.cpp
@@ -51,7 +51,7 @@ public:
return str::startsWith(url, "/_replSet");
}
- virtual void handle(OperationContext* txn,
+ virtual void handle(OperationContext* opCtx,
const char* rq,
const std::string& url,
BSONObj params,
@@ -59,12 +59,12 @@ public:
int& responseCode,
std::vector<std::string>& headers,
const SockAddr& from) {
- responseMsg = _replSet(txn);
+ responseMsg = _replSet(opCtx);
responseCode = 200;
}
/* /_replSet show replica set status in html format */
- std::string _replSet(OperationContext* txn) {
+ std::string _replSet(OperationContext* opCtx) {
std::stringstream s;
s << start("Replica Set Status " + prettyHostName());
s << p(a("/", "back", "Home") + " | " +
diff --git a/src/mongo/db/repl/replication_coordinator.h b/src/mongo/db/repl/replication_coordinator.h
index 1d3dda6f5b6..d5557213bb4 100644
--- a/src/mongo/db/repl/replication_coordinator.h
+++ b/src/mongo/db/repl/replication_coordinator.h
@@ -123,14 +123,14 @@ public:
* components of the replication system to start up whatever threads and do whatever
* initialization they need.
*/
- virtual void startup(OperationContext* txn) = 0;
+ virtual void startup(OperationContext* opCtx) = 0;
/**
* Does whatever cleanup is required to stop replication, including instructing the other
* components of the replication system to shut down and stop any threads they are using,
* blocking until all replication-related shutdown tasks are complete.
*/
- virtual void shutdown(OperationContext* txn) = 0;
+ virtual void shutdown(OperationContext* opCtx) = 0;
/**
* Returns a pointer to the ReplicationExecutor.
@@ -194,7 +194,7 @@ public:
* writeConcern.wTimeout of -1 indicates return immediately after checking. Return codes:
* ErrorCodes::WriteConcernFailed if the writeConcern.wTimeout is reached before
* the data has been sufficiently replicated
- * ErrorCodes::ExceededTimeLimit if the txn->getMaxTimeMicrosRemaining is reached before
+ * ErrorCodes::ExceededTimeLimit if the opCtx->getMaxTimeMicrosRemaining is reached before
* the data has been sufficiently replicated
* ErrorCodes::NotMaster if the node is not Primary/Master
* ErrorCodes::UnknownReplWriteConcern if the writeConcern.wMode contains a write concern
@@ -202,16 +202,16 @@ public:
* ErrorCodes::ShutdownInProgress if we are mid-shutdown
* ErrorCodes::Interrupted if the operation was killed with killop()
*/
- virtual StatusAndDuration awaitReplication(OperationContext* txn,
+ virtual StatusAndDuration awaitReplication(OperationContext* opCtx,
const OpTime& opTime,
const WriteConcernOptions& writeConcern) = 0;
/**
* Like awaitReplication(), above, but waits for the replication of the last operation
- * performed on the client associated with "txn".
+ * performed on the client associated with "opCtx".
*/
virtual StatusAndDuration awaitReplicationOfLastOpForClient(
- OperationContext* txn, const WriteConcernOptions& writeConcern) = 0;
+ OperationContext* opCtx, const WriteConcernOptions& writeConcern) = 0;
/**
* Causes this node to relinquish being primary for at least 'stepdownTime'. If 'force' is
@@ -222,7 +222,7 @@ public:
* ErrorCodes::SecondaryAheadOfPrimary if we are primary but there is another node that
* seems to be ahead of us in replication, and Status::OK otherwise.
*/
- virtual Status stepDown(OperationContext* txn,
+ virtual Status stepDown(OperationContext* opCtx,
bool force,
const Milliseconds& waitTime,
const Milliseconds& stepdownTime) = 0;
@@ -245,14 +245,14 @@ public:
* NOTE: This function can only be meaningfully called while the caller holds the global
* lock in some mode other than MODE_NONE.
*/
- virtual bool canAcceptWritesForDatabase(OperationContext* txn, StringData dbName) = 0;
+ virtual bool canAcceptWritesForDatabase(OperationContext* opCtx, StringData dbName) = 0;
/**
* Version which does not check for the global lock. Do not use in new code.
* Without the global lock held, the return value may be inaccurate by the time
* the function returns.
*/
- virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* txn, StringData dbName) = 0;
+ virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* opCtx, StringData dbName) = 0;
/**
* Returns true if it is valid for this node to accept writes on the given namespace.
@@ -260,14 +260,14 @@ public:
* The result of this function should be consistent with canAcceptWritesForDatabase()
* for the database the namespace refers to, with additional checks on the collection.
*/
- virtual bool canAcceptWritesFor(OperationContext* txn, const NamespaceString& ns) = 0;
+ virtual bool canAcceptWritesFor(OperationContext* opCtx, const NamespaceString& ns) = 0;
/**
* Version which does not check for the global lock. Do not use in new code.
* Without the global lock held, the return value may be inaccurate by the time
* the function returns.
*/
- virtual bool canAcceptWritesFor_UNSAFE(OperationContext* txn, const NamespaceString& ns) = 0;
+ virtual bool canAcceptWritesFor_UNSAFE(OperationContext* opCtx, const NamespaceString& ns) = 0;
/**
* Checks if the current replica set configuration can satisfy the given write concern.
@@ -284,7 +284,7 @@ public:
* Returns Status::OK() if it is valid for this node to serve reads on the given collection
* and an errorcode indicating why the node cannot if it cannot.
*/
- virtual Status checkCanServeReadsFor(OperationContext* txn,
+ virtual Status checkCanServeReadsFor(OperationContext* opCtx,
const NamespaceString& ns,
bool slaveOk) = 0;
@@ -293,7 +293,7 @@ public:
* Without the global lock held, the return value may be inaccurate by the time
* the function returns.
*/
- virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* txn,
+ virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* opCtx,
const NamespaceString& ns,
bool slaveOk) = 0;
@@ -303,7 +303,8 @@ public:
* The namespace "ns" is passed in because the "local" database is usually writable
* and we need to enforce the constraints for it.
*/
- virtual bool shouldRelaxIndexConstraints(OperationContext* txn, const NamespaceString& ns) = 0;
+ virtual bool shouldRelaxIndexConstraints(OperationContext* opCtx,
+ const NamespaceString& ns) = 0;
/**
* Updates our internal tracking of the last OpTime applied for the given slave
@@ -378,7 +379,7 @@ public:
*
* Returns whether the wait was successful.
*/
- virtual Status waitUntilOpTimeForRead(OperationContext* txn,
+ virtual Status waitUntilOpTimeForRead(OperationContext* opCtx,
const ReadConcernArgs& settings) = 0;
/**
@@ -486,7 +487,7 @@ public:
* steps down and steps up so quickly that the applier signals drain complete in the wrong
* term.
*/
- virtual void signalDrainComplete(OperationContext* txn, long long termWhenBufferIsEmpty) = 0;
+ virtual void signalDrainComplete(OperationContext* opCtx, long long termWhenBufferIsEmpty) = 0;
/**
* Waits duration of 'timeout' for applier to finish draining its buffer of operations.
@@ -527,7 +528,7 @@ public:
/**
* Does an initial sync of data, after dropping existing data.
*/
- virtual Status resyncData(OperationContext* txn, bool waitUntilCompleted) = 0;
+ virtual Status resyncData(OperationContext* opCtx, bool waitUntilCompleted) = 0;
/**
* Handles an incoming isMaster command for a replica set node. Should not be
@@ -592,7 +593,7 @@ public:
* returns Status::OK if the sync target could be set and an ErrorCode indicating why it
* couldn't otherwise.
*/
- virtual Status processReplSetSyncFrom(OperationContext* txn,
+ virtual Status processReplSetSyncFrom(OperationContext* opCtx,
const HostAndPort& target,
BSONObjBuilder* resultObj) = 0;
@@ -625,7 +626,7 @@ public:
* Handles an incoming replSetReconfig command. Adds BSON to 'resultObj';
* returns a Status with either OK or an error message.
*/
- virtual Status processReplSetReconfig(OperationContext* txn,
+ virtual Status processReplSetReconfig(OperationContext* opCtx,
const ReplSetReconfigArgs& args,
BSONObjBuilder* resultObj) = 0;
@@ -634,7 +635,7 @@ public:
* configuration to use.
* Adds BSON to 'resultObj'; returns a Status with either OK or an error message.
*/
- virtual Status processReplSetInitiate(OperationContext* txn,
+ virtual Status processReplSetInitiate(OperationContext* opCtx,
const BSONObj& configObj,
BSONObjBuilder* resultObj) = 0;
@@ -710,7 +711,7 @@ public:
*
* Returns ErrorCodes::IllegalOperation if we're not running with master/slave replication.
*/
- virtual Status processHandshake(OperationContext* txn, const HandshakeArgs& handshake) = 0;
+ virtual Status processHandshake(OperationContext* opCtx, const HandshakeArgs& handshake) = 0;
/**
* Returns a bool indicating whether or not this node builds indexes.
@@ -749,7 +750,7 @@ public:
* Loads the optime from the last op in the oplog into the coordinator's lastAppliedOpTime and
* lastDurableOpTime values.
*/
- virtual void resetLastOpTimesFromOplog(OperationContext* txn) = 0;
+ virtual void resetLastOpTimesFromOplog(OperationContext* opCtx) = 0;
/**
* Returns the OpTime of the latest replica set-committed op known to this server.
@@ -762,7 +763,7 @@ public:
* Handles an incoming replSetRequestVotes command.
* Adds BSON to 'resultObj'; returns a Status with either OK or an error message.
*/
- virtual Status processReplSetRequestVotes(OperationContext* txn,
+ virtual Status processReplSetRequestVotes(OperationContext* opCtx,
const ReplSetRequestVotesArgs& args,
ReplSetRequestVotesResponse* response) = 0;
@@ -803,7 +804,7 @@ public:
* the rest of the work, because the term is still the same).
* Returns StaleTerm if the supplied term was higher than the current term.
*/
- virtual Status updateTerm(OperationContext* txn, long long term) = 0;
+ virtual Status updateTerm(OperationContext* opCtx, long long term) = 0;
/**
* Reserves a unique SnapshotName.
@@ -819,7 +820,7 @@ public:
* A null OperationContext can be used in cases where the snapshot to wait for should not be
* adjusted.
*/
- virtual SnapshotName reserveSnapshotName(OperationContext* txn) = 0;
+ virtual SnapshotName reserveSnapshotName(OperationContext* opCtx) = 0;
/**
* Signals the SnapshotThread, if running, to take a forced snapshot even if the global
@@ -833,16 +834,16 @@ public:
* Creates a new snapshot in the storage engine and registers it for use in the replication
* coordinator.
*/
- virtual void createSnapshot(OperationContext* txn,
+ virtual void createSnapshot(OperationContext* opCtx,
OpTime timeOfSnapshot,
SnapshotName name) = 0;
/**
* Blocks until either the current committed snapshot is at least as high as 'untilSnapshot',
* or we are interrupted for any reason, including shutdown or maxTimeMs expiration.
- * 'txn' is used to checkForInterrupt and enforce maxTimeMS.
+ * 'opCtx' is used to checkForInterrupt and enforce maxTimeMS.
*/
- virtual void waitUntilSnapshotCommitted(OperationContext* txn,
+ virtual void waitUntilSnapshotCommitted(OperationContext* opCtx,
const SnapshotName& untilSnapshot) = 0;
/**
diff --git a/src/mongo/db/repl/replication_coordinator_external_state.h b/src/mongo/db/repl/replication_coordinator_external_state.h
index 66283518bfe..05f07b8aada 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state.h
+++ b/src/mongo/db/repl/replication_coordinator_external_state.h
@@ -60,7 +60,7 @@ class ReplSettings;
class ReplicationCoordinator;
class ReplicationExecutor;
-using OnInitialSyncFinishedFn = stdx::function<void(OperationContext* txn)>;
+using OnInitialSyncFinishedFn = stdx::function<void(OperationContext* opCtx)>;
using StartInitialSyncFn = stdx::function<void(OnInitialSyncFinishedFn callback)>;
using StartSteadyReplicationFn = stdx::function<void()>;
/**
@@ -94,33 +94,33 @@ public:
/**
* Returns true if an incomplete initial sync is detected.
*/
- virtual bool isInitialSyncFlagSet(OperationContext* txn) = 0;
+ virtual bool isInitialSyncFlagSet(OperationContext* opCtx) = 0;
/**
* Starts steady state sync for replica set member -- legacy impl not in DataReplicator.
*
* NOTE: Use either this or the Master/Slave version, but not both.
*/
- virtual void startSteadyStateReplication(OperationContext* txn,
+ virtual void startSteadyStateReplication(OperationContext* opCtx,
ReplicationCoordinator* replCoord) = 0;
- virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* txn)> run) = 0;
+ virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* opCtx)> run) = 0;
/**
* Stops the data replication threads = bgsync, applier, reporter.
*/
- virtual void stopDataReplication(OperationContext* txn) = 0;
+ virtual void stopDataReplication(OperationContext* opCtx) = 0;
/**
* Starts the Master/Slave threads and sets up logOp
*/
- virtual void startMasterSlave(OperationContext* txn) = 0;
+ virtual void startMasterSlave(OperationContext* opCtx) = 0;
/**
* Performs any necessary external state specific shutdown tasks, such as cleaning up
* the threads it started.
*/
- virtual void shutdown(OperationContext* txn) = 0;
+ virtual void shutdown(OperationContext* opCtx) = 0;
/**
* Returns task executor for scheduling tasks to be run asynchronously.
@@ -136,12 +136,12 @@ public:
* Runs the repair database command on the "local" db, if the storage engine is MMapV1.
* Note: Used after initial sync to compact the database files.
*/
- virtual Status runRepairOnLocalDB(OperationContext* txn) = 0;
+ virtual Status runRepairOnLocalDB(OperationContext* opCtx) = 0;
/**
* Creates the oplog, writes the first entry and stores the replica set config document.
*/
- virtual Status initializeReplSetStorage(OperationContext* txn, const BSONObj& config) = 0;
+ virtual Status initializeReplSetStorage(OperationContext* opCtx, const BSONObj& config) = 0;
/**
* Called when a node on way to becoming a primary is ready to leave drain mode. It is called
@@ -149,7 +149,7 @@ public:
*
* Throws on errors.
*/
- virtual void onDrainComplete(OperationContext* txn) = 0;
+ virtual void onDrainComplete(OperationContext* opCtx) = 0;
/**
* Called as part of the process of transitioning to primary and run with the global X lock and
@@ -163,7 +163,7 @@ public:
*
* Throws on errors.
*/
- virtual OpTime onTransitionToPrimary(OperationContext* txn, bool isV1ElectionProtocol) = 0;
+ virtual OpTime onTransitionToPrimary(OperationContext* opCtx, bool isV1ElectionProtocol) = 0;
/**
* Simple wrapper around SyncSourceFeedback::forwardSlaveProgress. Signals to the
@@ -188,22 +188,23 @@ public:
/**
* Gets the replica set config document from local storage, or returns an error.
*/
- virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* txn) = 0;
+ virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* opCtx) = 0;
/**
* Stores the replica set config document in local storage, or returns an error.
*/
- virtual Status storeLocalConfigDocument(OperationContext* txn, const BSONObj& config) = 0;
+ virtual Status storeLocalConfigDocument(OperationContext* opCtx, const BSONObj& config) = 0;
/**
* Gets the replica set lastVote document from local storage, or returns an error.
*/
- virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* txn) = 0;
+ virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* opCtx) = 0;
/**
* Stores the replica set lastVote document in local storage, or returns an error.
*/
- virtual Status storeLocalLastVoteDocument(OperationContext* txn, const LastVote& lastVote) = 0;
+ virtual Status storeLocalLastVoteDocument(OperationContext* opCtx,
+ const LastVote& lastVote) = 0;
/**
* Sets the global opTime to be 'newTime'.
@@ -214,20 +215,20 @@ public:
* Gets the last optime of an operation performed on this host, from stable
* storage.
*/
- virtual StatusWith<OpTime> loadLastOpTime(OperationContext* txn) = 0;
+ virtual StatusWith<OpTime> loadLastOpTime(OperationContext* opCtx) = 0;
/**
* Cleaning up the oplog, by potentially truncating:
* If we are recovering from a failed batch then minvalid.start though minvalid.end need
* to be removed from the oplog before we can start applying operations.
*/
- virtual void cleanUpLastApplyBatch(OperationContext* txn) = 0;
+ virtual void cleanUpLastApplyBatch(OperationContext* opCtx) = 0;
/**
* Returns the HostAndPort of the remote client connected to us that initiated the operation
- * represented by "txn".
+ * represented by "opCtx".
*/
- virtual HostAndPort getClientHostAndPort(const OperationContext* txn) = 0;
+ virtual HostAndPort getClientHostAndPort(const OperationContext* opCtx) = 0;
/**
* Closes all connections in the given TransportLayer except those marked with the
@@ -240,7 +241,7 @@ public:
* Kills all operations that have a Client that is associated with an incoming user
* connection. Used during stepdown.
*/
- virtual void killAllUserOperations(OperationContext* txn) = 0;
+ virtual void killAllUserOperations(OperationContext* opCtx) = 0;
/**
* Resets any active sharding metadata on this server and stops any sharding-related threads
@@ -279,7 +280,7 @@ public:
/**
* Creates a new snapshot.
*/
- virtual void createSnapshot(OperationContext* txn, SnapshotName name) = 0;
+ virtual void createSnapshot(OperationContext* opCtx, SnapshotName name) = 0;
/**
* Signals the SnapshotThread, if running, to take a forced snapshot even if the global
@@ -305,13 +306,13 @@ public:
/**
* Returns true if the current storage engine supports read committed.
*/
- virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* txn) const = 0;
+ virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* opCtx) const = 0;
/**
* Applies the operations described in the oplog entries contained in "ops" using the
* "applyOperation" function.
*/
- virtual StatusWith<OpTime> multiApply(OperationContext* txn,
+ virtual StatusWith<OpTime> multiApply(OperationContext* opCtx,
MultiApplier::Operations ops,
MultiApplier::ApplyOperationFn applyOperation) = 0;
@@ -333,13 +334,13 @@ public:
* This function creates an oplog buffer of the type specified at server startup.
*/
virtual std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(
- OperationContext* txn) const = 0;
+ OperationContext* opCtx) const = 0;
/**
* Creates an oplog buffer suitable for steady state replication.
*/
virtual std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(
- OperationContext* txn) const = 0;
+ OperationContext* opCtx) const = 0;
/**
* Returns true if the user specified to use the data replicator for initial sync.
diff --git a/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp b/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
index 70c74cc8942..36d8a84fd06 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
+++ b/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
@@ -195,46 +195,46 @@ ReplicationCoordinatorExternalStateImpl::ReplicationCoordinatorExternalStateImpl
}
ReplicationCoordinatorExternalStateImpl::~ReplicationCoordinatorExternalStateImpl() {}
-bool ReplicationCoordinatorExternalStateImpl::isInitialSyncFlagSet(OperationContext* txn) {
- return _storageInterface->getInitialSyncFlag(txn);
+bool ReplicationCoordinatorExternalStateImpl::isInitialSyncFlagSet(OperationContext* opCtx) {
+ return _storageInterface->getInitialSyncFlag(opCtx);
}
void ReplicationCoordinatorExternalStateImpl::startInitialSync(OnInitialSyncFinishedFn finished) {
- _initialSyncRunner.schedule([finished, this](OperationContext* txn, const Status& status) {
+ _initialSyncRunner.schedule([finished, this](OperationContext* opCtx, const Status& status) {
if (status == ErrorCodes::CallbackCanceled) {
return TaskRunner::NextAction::kDisposeOperationContext;
}
// Do initial sync.
- syncDoInitialSync(txn, this);
- finished(txn);
+ syncDoInitialSync(opCtx, this);
+ finished(opCtx);
return TaskRunner::NextAction::kDisposeOperationContext;
});
}
void ReplicationCoordinatorExternalStateImpl::runOnInitialSyncThread(
- stdx::function<void(OperationContext* txn)> run) {
+ stdx::function<void(OperationContext* opCtx)> run) {
_initialSyncRunner.cancel();
_initialSyncRunner.join();
- _initialSyncRunner.schedule([run, this](OperationContext* txn, const Status& status) {
+ _initialSyncRunner.schedule([run, this](OperationContext* opCtx, const Status& status) {
if (status == ErrorCodes::CallbackCanceled) {
return TaskRunner::NextAction::kDisposeOperationContext;
}
- invariant(txn);
- invariant(txn->getClient());
- run(txn);
+ invariant(opCtx);
+ invariant(opCtx->getClient());
+ run(opCtx);
return TaskRunner::NextAction::kDisposeOperationContext;
});
}
void ReplicationCoordinatorExternalStateImpl::startSteadyStateReplication(
- OperationContext* txn, ReplicationCoordinator* replCoord) {
+ OperationContext* opCtx, ReplicationCoordinator* replCoord) {
LockGuard lk(_threadMutex);
invariant(replCoord);
invariant(!_bgSync);
log() << "Starting replication fetcher thread";
- _bgSync = stdx::make_unique<BackgroundSync>(this, makeSteadyStateOplogBuffer(txn));
- _bgSync->startup(txn);
+ _bgSync = stdx::make_unique<BackgroundSync>(this, makeSteadyStateOplogBuffer(opCtx));
+ _bgSync->startup(opCtx);
log() << "Starting replication applier thread";
invariant(!_applierThread);
@@ -246,12 +246,12 @@ void ReplicationCoordinatorExternalStateImpl::startSteadyStateReplication(
&SyncSourceFeedback::run, &_syncSourceFeedback, _taskExecutor.get(), _bgSync.get())));
}
-void ReplicationCoordinatorExternalStateImpl::stopDataReplication(OperationContext* txn) {
+void ReplicationCoordinatorExternalStateImpl::stopDataReplication(OperationContext* opCtx) {
UniqueLock lk(_threadMutex);
- _stopDataReplication_inlock(txn, &lk);
+ _stopDataReplication_inlock(opCtx, &lk);
}
-void ReplicationCoordinatorExternalStateImpl::_stopDataReplication_inlock(OperationContext* txn,
+void ReplicationCoordinatorExternalStateImpl::_stopDataReplication_inlock(OperationContext* opCtx,
UniqueLock* lock) {
// Make sue no other _stopDataReplication calls are in progress.
_dataReplicationStopped.wait(*lock, [this]() { return !_stoppingDataReplication; });
@@ -270,7 +270,7 @@ void ReplicationCoordinatorExternalStateImpl::_stopDataReplication_inlock(Operat
if (oldBgSync) {
log() << "Stopping replication fetcher thread";
- oldBgSync->shutdown(txn);
+ oldBgSync->shutdown(opCtx);
}
if (oldApplier) {
@@ -279,7 +279,7 @@ void ReplicationCoordinatorExternalStateImpl::_stopDataReplication_inlock(Operat
}
if (oldBgSync) {
- oldBgSync->join(txn);
+ oldBgSync->join(opCtx);
}
_initialSyncRunner.cancel();
@@ -320,25 +320,25 @@ void ReplicationCoordinatorExternalStateImpl::startThreads(const ReplSettings& s
_startedThreads = true;
}
-void ReplicationCoordinatorExternalStateImpl::startMasterSlave(OperationContext* txn) {
- repl::startMasterSlave(txn);
+void ReplicationCoordinatorExternalStateImpl::startMasterSlave(OperationContext* opCtx) {
+ repl::startMasterSlave(opCtx);
}
-void ReplicationCoordinatorExternalStateImpl::shutdown(OperationContext* txn) {
+void ReplicationCoordinatorExternalStateImpl::shutdown(OperationContext* opCtx) {
UniqueLock lk(_threadMutex);
if (_startedThreads) {
- _stopDataReplication_inlock(txn, &lk);
+ _stopDataReplication_inlock(opCtx, &lk);
if (_snapshotThread) {
log() << "Stopping replication snapshot thread";
_snapshotThread->shutdown();
}
- if (_storageInterface->getOplogDeleteFromPoint(txn).isNull() &&
- loadLastOpTime(txn) == _storageInterface->getAppliedThrough(txn)) {
+ if (_storageInterface->getOplogDeleteFromPoint(opCtx).isNull() &&
+ loadLastOpTime(opCtx) == _storageInterface->getAppliedThrough(opCtx)) {
// Clear the appliedThrough marker to indicate we are consistent with the top of the
// oplog.
- _storageInterface->setAppliedThrough(txn, {});
+ _storageInterface->setAppliedThrough(opCtx, {});
}
if (_noopWriter) {
@@ -361,95 +361,95 @@ OldThreadPool* ReplicationCoordinatorExternalStateImpl::getDbWorkThreadPool() co
return _writerPool.get();
}
-Status ReplicationCoordinatorExternalStateImpl::runRepairOnLocalDB(OperationContext* txn) {
+Status ReplicationCoordinatorExternalStateImpl::runRepairOnLocalDB(OperationContext* opCtx) {
try {
- ScopedTransaction scopedXact(txn, MODE_X);
- Lock::GlobalWrite globalWrite(txn->lockState());
+ ScopedTransaction scopedXact(opCtx, MODE_X);
+ Lock::GlobalWrite globalWrite(opCtx->lockState());
StorageEngine* engine = getGlobalServiceContext()->getGlobalStorageEngine();
if (!engine->isMmapV1()) {
return Status::OK();
}
- txn->setReplicatedWrites(false);
- Status status = repairDatabase(txn, engine, localDbName, false, false);
+ opCtx->setReplicatedWrites(false);
+ Status status = repairDatabase(opCtx, engine, localDbName, false, false);
// Open database before returning
- dbHolder().openDb(txn, localDbName);
+ dbHolder().openDb(opCtx, localDbName);
} catch (const DBException& ex) {
return ex.toStatus();
}
return Status::OK();
}
-Status ReplicationCoordinatorExternalStateImpl::initializeReplSetStorage(OperationContext* txn,
+Status ReplicationCoordinatorExternalStateImpl::initializeReplSetStorage(OperationContext* opCtx,
const BSONObj& config) {
try {
- createOplog(txn);
+ createOplog(opCtx);
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction scopedXact(txn, MODE_X);
- Lock::GlobalWrite globalWrite(txn->lockState());
+ ScopedTransaction scopedXact(opCtx, MODE_X);
+ Lock::GlobalWrite globalWrite(opCtx->lockState());
- WriteUnitOfWork wuow(txn);
- Helpers::putSingleton(txn, configCollectionName, config);
+ WriteUnitOfWork wuow(opCtx);
+ Helpers::putSingleton(opCtx, configCollectionName, config);
const auto msgObj = BSON("msg"
<< "initiating set");
- getGlobalServiceContext()->getOpObserver()->onOpMessage(txn, msgObj);
+ getGlobalServiceContext()->getOpObserver()->onOpMessage(opCtx, msgObj);
wuow.commit();
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "initiate oplog entry", "local.oplog.rs");
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "initiate oplog entry", "local.oplog.rs");
// This initializes the minvalid document with a null "ts" because older versions (<=3.2)
// get angry if the minValid document is present but doesn't have a "ts" field.
// Consider removing this once we no longer need to support downgrading to 3.2.
- _storageInterface->setMinValidToAtLeast(txn, {});
+ _storageInterface->setMinValidToAtLeast(opCtx, {});
- FeatureCompatibilityVersion::setIfCleanStartup(txn, _storageInterface);
+ FeatureCompatibilityVersion::setIfCleanStartup(opCtx, _storageInterface);
} catch (const DBException& ex) {
return ex.toStatus();
}
return Status::OK();
}
-void ReplicationCoordinatorExternalStateImpl::onDrainComplete(OperationContext* txn) {
- invariant(!txn->lockState()->isLocked());
+void ReplicationCoordinatorExternalStateImpl::onDrainComplete(OperationContext* opCtx) {
+ invariant(!opCtx->lockState()->isLocked());
// If this is a config server node becoming a primary, ensure the balancer is ready to start.
if (serverGlobalParams.clusterRole == ClusterRole::ConfigServer) {
// We must ensure the balancer has stopped because it may still be in the process of
// stopping if this node was previously primary.
- Balancer::get(txn)->waitForBalancerToStop();
+ Balancer::get(opCtx)->waitForBalancerToStop();
}
}
-OpTime ReplicationCoordinatorExternalStateImpl::onTransitionToPrimary(OperationContext* txn,
+OpTime ReplicationCoordinatorExternalStateImpl::onTransitionToPrimary(OperationContext* opCtx,
bool isV1ElectionProtocol) {
- invariant(txn->lockState()->isW());
+ invariant(opCtx->lockState()->isW());
// Clear the appliedThrough marker so on startup we'll use the top of the oplog. This must be
// done before we add anything to our oplog.
- invariant(_storageInterface->getOplogDeleteFromPoint(txn).isNull());
- _storageInterface->setAppliedThrough(txn, {});
+ invariant(_storageInterface->getOplogDeleteFromPoint(opCtx).isNull());
+ _storageInterface->setAppliedThrough(opCtx, {});
if (isV1ElectionProtocol) {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction scopedXact(txn, MODE_X);
+ ScopedTransaction scopedXact(opCtx, MODE_X);
- WriteUnitOfWork wuow(txn);
- txn->getClient()->getServiceContext()->getOpObserver()->onOpMessage(
- txn,
+ WriteUnitOfWork wuow(opCtx);
+ opCtx->getClient()->getServiceContext()->getOpObserver()->onOpMessage(
+ opCtx,
BSON("msg"
<< "new primary"));
wuow.commit();
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
- txn, "logging transition to primary to oplog", "local.oplog.rs");
+ opCtx, "logging transition to primary to oplog", "local.oplog.rs");
}
- const auto opTimeToReturn = fassertStatusOK(28665, loadLastOpTime(txn));
+ const auto opTimeToReturn = fassertStatusOK(28665, loadLastOpTime(opCtx));
- _shardingOnTransitionToPrimaryHook(txn);
- _dropAllTempCollections(txn);
+ _shardingOnTransitionToPrimaryHook(opCtx);
+ _dropAllTempCollections(opCtx);
serverGlobalParams.featureCompatibility.validateFeaturesAsMaster.store(true);
@@ -460,28 +460,28 @@ void ReplicationCoordinatorExternalStateImpl::forwardSlaveProgress() {
_syncSourceFeedback.forwardSlaveProgress();
}
-OID ReplicationCoordinatorExternalStateImpl::ensureMe(OperationContext* txn) {
+OID ReplicationCoordinatorExternalStateImpl::ensureMe(OperationContext* opCtx) {
std::string myname = getHostName();
OID myRID;
{
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock lock(txn->lockState(), meDatabaseName, MODE_X);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock lock(opCtx->lockState(), meDatabaseName, MODE_X);
BSONObj me;
// local.me is an identifier for a server for getLastError w:2+
// TODO: handle WriteConflictExceptions below
- if (!Helpers::getSingleton(txn, meCollectionName, me) || !me.hasField("host") ||
+ if (!Helpers::getSingleton(opCtx, meCollectionName, me) || !me.hasField("host") ||
me["host"].String() != myname) {
myRID = OID::gen();
// clean out local.me
- Helpers::emptyCollection(txn, meCollectionName);
+ Helpers::emptyCollection(opCtx, meCollectionName);
// repopulate
BSONObjBuilder b;
b.append("_id", myRID);
b.append("host", myname);
- Helpers::putSingleton(txn, meCollectionName, b.done());
+ Helpers::putSingleton(opCtx, meCollectionName, b.done());
} else {
myRID = me["_id"].OID();
}
@@ -490,11 +490,11 @@ OID ReplicationCoordinatorExternalStateImpl::ensureMe(OperationContext* txn) {
}
StatusWith<BSONObj> ReplicationCoordinatorExternalStateImpl::loadLocalConfigDocument(
- OperationContext* txn) {
+ OperationContext* opCtx) {
try {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
BSONObj config;
- if (!Helpers::getSingleton(txn, configCollectionName, config)) {
+ if (!Helpers::getSingleton(opCtx, configCollectionName, config)) {
return StatusWith<BSONObj>(
ErrorCodes::NoMatchingDocument,
str::stream() << "Did not find replica set configuration document in "
@@ -502,33 +502,33 @@ StatusWith<BSONObj> ReplicationCoordinatorExternalStateImpl::loadLocalConfigDocu
}
return StatusWith<BSONObj>(config);
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "load replica set config", configCollectionName);
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "load replica set config", configCollectionName);
} catch (const DBException& ex) {
return StatusWith<BSONObj>(ex.toStatus());
}
}
-Status ReplicationCoordinatorExternalStateImpl::storeLocalConfigDocument(OperationContext* txn,
+Status ReplicationCoordinatorExternalStateImpl::storeLocalConfigDocument(OperationContext* opCtx,
const BSONObj& config) {
try {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock dbWriteLock(txn->lockState(), configDatabaseName, MODE_X);
- Helpers::putSingleton(txn, configCollectionName, config);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock dbWriteLock(opCtx->lockState(), configDatabaseName, MODE_X);
+ Helpers::putSingleton(opCtx, configCollectionName, config);
return Status::OK();
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "save replica set config", configCollectionName);
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "save replica set config", configCollectionName);
} catch (const DBException& ex) {
return ex.toStatus();
}
}
StatusWith<LastVote> ReplicationCoordinatorExternalStateImpl::loadLocalLastVoteDocument(
- OperationContext* txn) {
+ OperationContext* opCtx) {
try {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
BSONObj lastVoteObj;
- if (!Helpers::getSingleton(txn, lastVoteCollectionName, lastVoteObj)) {
+ if (!Helpers::getSingleton(opCtx, lastVoteCollectionName, lastVoteObj)) {
return StatusWith<LastVote>(ErrorCodes::NoMatchingDocument,
str::stream()
<< "Did not find replica set lastVote document in "
@@ -537,41 +537,41 @@ StatusWith<LastVote> ReplicationCoordinatorExternalStateImpl::loadLocalLastVoteD
return LastVote::readFromLastVote(lastVoteObj);
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
- txn, "load replica set lastVote", lastVoteCollectionName);
+ opCtx, "load replica set lastVote", lastVoteCollectionName);
} catch (const DBException& ex) {
return StatusWith<LastVote>(ex.toStatus());
}
}
Status ReplicationCoordinatorExternalStateImpl::storeLocalLastVoteDocument(
- OperationContext* txn, const LastVote& lastVote) {
+ OperationContext* opCtx, const LastVote& lastVote) {
BSONObj lastVoteObj = lastVote.toBSON();
try {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock dbWriteLock(txn->lockState(), lastVoteDatabaseName, MODE_X);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock dbWriteLock(opCtx->lockState(), lastVoteDatabaseName, MODE_X);
// If there is no last vote document, we want to store one. Otherwise, we only want to
// replace it if the new last vote document would have a higher term. We both check
// the term of the current last vote document and insert the new document under the
// DBLock to synchronize the two operations.
BSONObj result;
- bool exists = Helpers::getSingleton(txn, lastVoteCollectionName, result);
+ bool exists = Helpers::getSingleton(opCtx, lastVoteCollectionName, result);
if (!exists) {
- Helpers::putSingleton(txn, lastVoteCollectionName, lastVoteObj);
+ Helpers::putSingleton(opCtx, lastVoteCollectionName, lastVoteObj);
} else {
StatusWith<LastVote> oldLastVoteDoc = LastVote::readFromLastVote(result);
if (!oldLastVoteDoc.isOK()) {
return oldLastVoteDoc.getStatus();
}
if (lastVote.getTerm() > oldLastVoteDoc.getValue().getTerm()) {
- Helpers::putSingleton(txn, lastVoteCollectionName, lastVoteObj);
+ Helpers::putSingleton(opCtx, lastVoteCollectionName, lastVoteObj);
}
}
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
- txn, "save replica set lastVote", lastVoteCollectionName);
- txn->recoveryUnit()->waitUntilDurable();
+ opCtx, "save replica set lastVote", lastVoteCollectionName);
+ opCtx->recoveryUnit()->waitUntilDurable();
return Status::OK();
} catch (const DBException& ex) {
return ex.toStatus();
@@ -583,18 +583,18 @@ void ReplicationCoordinatorExternalStateImpl::setGlobalTimestamp(ServiceContext*
setNewTimestamp(ctx, newTime);
}
-void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationContext* txn) {
- if (_storageInterface->getInitialSyncFlag(txn)) {
+void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationContext* opCtx) {
+ if (_storageInterface->getInitialSyncFlag(opCtx)) {
return; // Initial Sync will take over so no cleanup is needed.
}
// This initializes the minvalid document with a null "ts" because older versions (<=3.2)
// get angry if the minValid document is present but doesn't have a "ts" field.
// Consider removing this once we no longer need to support downgrading to 3.2.
- _storageInterface->setMinValidToAtLeast(txn, {});
+ _storageInterface->setMinValidToAtLeast(opCtx, {});
- const auto deleteFromPoint = _storageInterface->getOplogDeleteFromPoint(txn);
- const auto appliedThrough = _storageInterface->getAppliedThrough(txn);
+ const auto deleteFromPoint = _storageInterface->getOplogDeleteFromPoint(opCtx);
+ const auto appliedThrough = _storageInterface->getAppliedThrough(opCtx);
const bool needToDeleteEndOfOplog = !deleteFromPoint.isNull() &&
// This version should never have a non-null deleteFromPoint with a null appliedThrough.
@@ -609,9 +609,9 @@ void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationCon
!(appliedThrough.getTimestamp() >= deleteFromPoint);
if (needToDeleteEndOfOplog) {
log() << "Removing unapplied entries starting at: " << deleteFromPoint;
- truncateOplogTo(txn, deleteFromPoint);
+ truncateOplogTo(opCtx, deleteFromPoint);
}
- _storageInterface->setOplogDeleteFromPoint(txn, {}); // clear the deleteFromPoint
+ _storageInterface->setOplogDeleteFromPoint(opCtx, {}); // clear the deleteFromPoint
if (appliedThrough.isNull()) {
// No follow-up work to do.
@@ -620,7 +620,7 @@ void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationCon
// Check if we have any unapplied ops in our oplog. It is important that this is done after
// deleting the ragged end of the oplog.
- const auto topOfOplog = fassertStatusOK(40290, loadLastOpTime(txn));
+ const auto topOfOplog = fassertStatusOK(40290, loadLastOpTime(opCtx));
if (appliedThrough == topOfOplog) {
return; // We've applied all the valid oplog we have.
} else if (appliedThrough > topOfOplog) {
@@ -632,7 +632,7 @@ void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationCon
log() << "Replaying stored operations from " << appliedThrough << " (exclusive) to "
<< topOfOplog << " (inclusive).";
- DBDirectClient db(txn);
+ DBDirectClient db(opCtx);
auto cursor = db.query(rsOplogName,
QUERY("ts" << BSON("$gte" << appliedThrough.getTimestamp())),
/*batchSize*/ 0,
@@ -658,28 +658,29 @@ void ReplicationCoordinatorExternalStateImpl::cleanUpLastApplyBatch(OperationCon
}
// Apply remaining ops one at at time, but don't log them because they are already logged.
- const bool wereWritesReplicated = txn->writesAreReplicated();
- ON_BLOCK_EXIT([&] { txn->setReplicatedWrites(wereWritesReplicated); });
- txn->setReplicatedWrites(false);
+ const bool wereWritesReplicated = opCtx->writesAreReplicated();
+ ON_BLOCK_EXIT([&] { opCtx->setReplicatedWrites(wereWritesReplicated); });
+ opCtx->setReplicatedWrites(false);
while (cursor->more()) {
auto entry = cursor->nextSafe();
- fassertStatusOK(40294, SyncTail::syncApply(txn, entry, true));
+ fassertStatusOK(40294, SyncTail::syncApply(opCtx, entry, true));
_storageInterface->setAppliedThrough(
- txn, fassertStatusOK(40295, OpTime::parseFromOplogEntry(entry)));
+ opCtx, fassertStatusOK(40295, OpTime::parseFromOplogEntry(entry)));
}
}
-StatusWith<OpTime> ReplicationCoordinatorExternalStateImpl::loadLastOpTime(OperationContext* txn) {
+StatusWith<OpTime> ReplicationCoordinatorExternalStateImpl::loadLastOpTime(
+ OperationContext* opCtx) {
// TODO: handle WriteConflictExceptions below
try {
// If we are doing an initial sync do not read from the oplog.
- if (_storageInterface->getInitialSyncFlag(txn)) {
+ if (_storageInterface->getInitialSyncFlag(opCtx)) {
return {ErrorCodes::InitialSyncFailure, "In the middle of an initial sync."};
}
BSONObj oplogEntry;
- if (!Helpers::getLast(txn, rsOplogName.c_str(), oplogEntry)) {
+ if (!Helpers::getLast(opCtx, rsOplogName.c_str(), oplogEntry)) {
return StatusWith<OpTime>(ErrorCodes::NoMatchingDocument,
str::stream() << "Did not find any entries in "
<< rsOplogName);
@@ -711,17 +712,17 @@ bool ReplicationCoordinatorExternalStateImpl::isSelf(const HostAndPort& host, Se
}
HostAndPort ReplicationCoordinatorExternalStateImpl::getClientHostAndPort(
- const OperationContext* txn) {
- return HostAndPort(txn->getClient()->clientAddress(true));
+ const OperationContext* opCtx) {
+ return HostAndPort(opCtx->getClient()->clientAddress(true));
}
void ReplicationCoordinatorExternalStateImpl::closeConnections() {
getGlobalServiceContext()->getTransportLayer()->endAllSessions(transport::Session::kKeepOpen);
}
-void ReplicationCoordinatorExternalStateImpl::killAllUserOperations(OperationContext* txn) {
- ServiceContext* environment = txn->getServiceContext();
- environment->killAllUserOperations(txn, ErrorCodes::InterruptedDueToReplStateChange);
+void ReplicationCoordinatorExternalStateImpl::killAllUserOperations(OperationContext* opCtx) {
+ ServiceContext* environment = opCtx->getServiceContext();
+ environment->killAllUserOperations(opCtx, ErrorCodes::InterruptedDueToReplStateChange);
}
void ReplicationCoordinatorExternalStateImpl::shardingOnStepDownHook() {
@@ -733,8 +734,8 @@ void ReplicationCoordinatorExternalStateImpl::shardingOnStepDownHook() {
}
void ReplicationCoordinatorExternalStateImpl::_shardingOnTransitionToPrimaryHook(
- OperationContext* txn) {
- auto status = ShardingStateRecovery::recover(txn);
+ OperationContext* opCtx) {
+ auto status = ShardingStateRecovery::recover(opCtx);
if (ErrorCodes::isShutdownError(status.code())) {
// Note: callers of this method don't expect exceptions, so throw only unexpected fatal
@@ -745,7 +746,7 @@ void ReplicationCoordinatorExternalStateImpl::_shardingOnTransitionToPrimaryHook
fassertStatusOK(40107, status);
if (serverGlobalParams.clusterRole == ClusterRole::ConfigServer) {
- status = Grid::get(txn)->catalogManager()->initializeConfigDatabaseIfNeeded(txn);
+ status = Grid::get(opCtx)->catalogManager()->initializeConfigDatabaseIfNeeded(opCtx);
if (!status.isOK() && status != ErrorCodes::AlreadyInitialized) {
if (ErrorCodes::isShutdownError(status.code())) {
// Don't fassert if we're mid-shutdown, let the shutdown happen gracefully.
@@ -768,8 +769,8 @@ void ReplicationCoordinatorExternalStateImpl::_shardingOnTransitionToPrimaryHook
// Since we *just* wrote the cluster ID to the config.version document (via
// ShardingCatalogManager::initializeConfigDatabaseIfNeeded), this should always
// succeed.
- status = ClusterIdentityLoader::get(txn)->loadClusterId(
- txn, repl::ReadConcernLevel::kLocalReadConcern);
+ status = ClusterIdentityLoader::get(opCtx)->loadClusterId(
+ opCtx, repl::ReadConcernLevel::kLocalReadConcern);
if (ErrorCodes::isShutdownError(status.code())) {
// Don't fassert if we're mid-shutdown, let the shutdown happen gracefully.
@@ -780,20 +781,20 @@ void ReplicationCoordinatorExternalStateImpl::_shardingOnTransitionToPrimaryHook
}
// Free any leftover locks from previous instantiations.
- auto distLockManager = Grid::get(txn)->catalogClient(txn)->getDistLockManager();
- distLockManager->unlockAll(txn, distLockManager->getProcessID());
+ auto distLockManager = Grid::get(opCtx)->catalogClient(opCtx)->getDistLockManager();
+ distLockManager->unlockAll(opCtx, distLockManager->getProcessID());
// If this is a config server node becoming a primary, start the balancer
- Balancer::get(txn)->initiateBalancer(txn);
+ Balancer::get(opCtx)->initiateBalancer(opCtx);
// Generate and upsert random 20 byte key for the LogicalClock's TimeProofService.
// TODO: SERVER-27768
- } else if (ShardingState::get(txn)->enabled()) {
+ } else if (ShardingState::get(opCtx)->enabled()) {
const auto configsvrConnStr =
- Grid::get(txn)->shardRegistry()->getConfigShard()->getConnString();
- auto status = ShardingState::get(txn)->updateShardIdentityConfigString(
- txn, configsvrConnStr.toString());
+ Grid::get(opCtx)->shardRegistry()->getConfigShard()->getConnString();
+ auto status = ShardingState::get(opCtx)->updateShardIdentityConfigString(
+ opCtx, configsvrConnStr.toString());
if (!status.isOK()) {
warning() << "error encountered while trying to update config connection string to "
<< configsvrConnStr << causedBy(status);
@@ -802,7 +803,7 @@ void ReplicationCoordinatorExternalStateImpl::_shardingOnTransitionToPrimaryHook
// There is a slight chance that some stale metadata might have been loaded before the latest
// optime has been recovered, so throw out everything that we have up to now
- ShardingState::get(txn)->markCollectionsNotShardedAtStepdown();
+ ShardingState::get(opCtx)->markCollectionsNotShardedAtStepdown();
}
void ReplicationCoordinatorExternalStateImpl::signalApplierToChooseNewSyncSource() {
@@ -826,7 +827,7 @@ void ReplicationCoordinatorExternalStateImpl::startProducerIfStopped() {
}
}
-void ReplicationCoordinatorExternalStateImpl::_dropAllTempCollections(OperationContext* txn) {
+void ReplicationCoordinatorExternalStateImpl::_dropAllTempCollections(OperationContext* opCtx) {
std::vector<std::string> dbNames;
StorageEngine* storageEngine = getGlobalServiceContext()->getGlobalStorageEngine();
storageEngine->listDatabases(&dbNames);
@@ -837,12 +838,12 @@ void ReplicationCoordinatorExternalStateImpl::_dropAllTempCollections(OperationC
if (*it == "local")
continue;
LOG(2) << "Removing temporary collections from " << *it;
- Database* db = dbHolder().get(txn, *it);
+ Database* db = dbHolder().get(opCtx, *it);
// Since we must be holding the global lock during this function, if listDatabases
// returned this dbname, we should be able to get a reference to it - it can't have
// been dropped.
invariant(db);
- db->clearTmpCollections(txn);
+ db->clearTmpCollections(opCtx);
}
}
@@ -857,11 +858,11 @@ void ReplicationCoordinatorExternalStateImpl::updateCommittedSnapshot(SnapshotNa
manager->setCommittedSnapshot(newCommitPoint);
}
-void ReplicationCoordinatorExternalStateImpl::createSnapshot(OperationContext* txn,
+void ReplicationCoordinatorExternalStateImpl::createSnapshot(OperationContext* opCtx,
SnapshotName name) {
auto manager = getGlobalServiceContext()->getGlobalStorageEngine()->getSnapshotManager();
invariant(manager); // This should never be called if there is no SnapshotManager.
- manager->createSnapshot(txn, name);
+ manager->createSnapshot(opCtx, name);
}
void ReplicationCoordinatorExternalStateImpl::forceSnapshotCreation() {
@@ -882,18 +883,18 @@ double ReplicationCoordinatorExternalStateImpl::getElectionTimeoutOffsetLimitFra
}
bool ReplicationCoordinatorExternalStateImpl::isReadCommittedSupportedByStorageEngine(
- OperationContext* txn) const {
- auto storageEngine = txn->getServiceContext()->getGlobalStorageEngine();
+ OperationContext* opCtx) const {
+ auto storageEngine = opCtx->getServiceContext()->getGlobalStorageEngine();
// This should never be called if the storage engine has not been initialized.
invariant(storageEngine);
return storageEngine->getSnapshotManager();
}
StatusWith<OpTime> ReplicationCoordinatorExternalStateImpl::multiApply(
- OperationContext* txn,
+ OperationContext* opCtx,
MultiApplier::Operations ops,
MultiApplier::ApplyOperationFn applyOperation) {
- return repl::multiApply(txn, _writerPool.get(), std::move(ops), applyOperation);
+ return repl::multiApply(opCtx, _writerPool.get(), std::move(ops), applyOperation);
}
Status ReplicationCoordinatorExternalStateImpl::multiSyncApply(MultiApplier::OperationPtrs* ops) {
@@ -915,20 +916,20 @@ Status ReplicationCoordinatorExternalStateImpl::multiInitialSyncApply(
}
std::unique_ptr<OplogBuffer> ReplicationCoordinatorExternalStateImpl::makeInitialSyncOplogBuffer(
- OperationContext* txn) const {
+ OperationContext* opCtx) const {
if (initialSyncOplogBuffer == kCollectionOplogBufferName) {
invariant(initialSyncOplogBufferPeekCacheSize >= 0);
OplogBufferCollection::Options options;
options.peekCacheSize = std::size_t(initialSyncOplogBufferPeekCacheSize);
return stdx::make_unique<OplogBufferProxy>(
- stdx::make_unique<OplogBufferCollection>(StorageInterface::get(txn), options));
+ stdx::make_unique<OplogBufferCollection>(StorageInterface::get(opCtx), options));
} else {
return stdx::make_unique<OplogBufferBlockingQueue>();
}
}
std::unique_ptr<OplogBuffer> ReplicationCoordinatorExternalStateImpl::makeSteadyStateOplogBuffer(
- OperationContext* txn) const {
+ OperationContext* opCtx) const {
return stdx::make_unique<OplogBufferBlockingQueue>();
}
diff --git a/src/mongo/db/repl/replication_coordinator_external_state_impl.h b/src/mongo/db/repl/replication_coordinator_external_state_impl.h
index b0d9487eaaf..16c5adf0be6 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state_impl.h
+++ b/src/mongo/db/repl/replication_coordinator_external_state_impl.h
@@ -64,47 +64,47 @@ public:
virtual ~ReplicationCoordinatorExternalStateImpl();
virtual void startThreads(const ReplSettings& settings) override;
virtual void startInitialSync(OnInitialSyncFinishedFn finished) override;
- virtual void startSteadyStateReplication(OperationContext* txn,
+ virtual void startSteadyStateReplication(OperationContext* opCtx,
ReplicationCoordinator* replCoord) override;
- virtual void stopDataReplication(OperationContext* txn) override;
- virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* txn)> run) override;
+ virtual void stopDataReplication(OperationContext* opCtx) override;
+ virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* opCtx)> run) override;
- virtual bool isInitialSyncFlagSet(OperationContext* txn) override;
+ virtual bool isInitialSyncFlagSet(OperationContext* opCtx) override;
- virtual void startMasterSlave(OperationContext* txn);
- virtual void shutdown(OperationContext* txn);
+ virtual void startMasterSlave(OperationContext* opCtx);
+ virtual void shutdown(OperationContext* opCtx);
virtual executor::TaskExecutor* getTaskExecutor() const override;
virtual OldThreadPool* getDbWorkThreadPool() const override;
- virtual Status runRepairOnLocalDB(OperationContext* txn) override;
- virtual Status initializeReplSetStorage(OperationContext* txn, const BSONObj& config);
- void onDrainComplete(OperationContext* txn) override;
- OpTime onTransitionToPrimary(OperationContext* txn, bool isV1ElectionProtocol) override;
+ virtual Status runRepairOnLocalDB(OperationContext* opCtx) override;
+ virtual Status initializeReplSetStorage(OperationContext* opCtx, const BSONObj& config);
+ void onDrainComplete(OperationContext* opCtx) override;
+ OpTime onTransitionToPrimary(OperationContext* opCtx, bool isV1ElectionProtocol) override;
virtual void forwardSlaveProgress();
- virtual OID ensureMe(OperationContext* txn);
+ virtual OID ensureMe(OperationContext* opCtx);
virtual bool isSelf(const HostAndPort& host, ServiceContext* service);
- virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* txn);
- virtual Status storeLocalConfigDocument(OperationContext* txn, const BSONObj& config);
- virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* txn);
- virtual Status storeLocalLastVoteDocument(OperationContext* txn, const LastVote& lastVote);
+ virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* opCtx);
+ virtual Status storeLocalConfigDocument(OperationContext* opCtx, const BSONObj& config);
+ virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* opCtx);
+ virtual Status storeLocalLastVoteDocument(OperationContext* opCtx, const LastVote& lastVote);
virtual void setGlobalTimestamp(ServiceContext* service, const Timestamp& newTime);
- virtual StatusWith<OpTime> loadLastOpTime(OperationContext* txn);
- virtual void cleanUpLastApplyBatch(OperationContext* txn);
- virtual HostAndPort getClientHostAndPort(const OperationContext* txn);
+ virtual StatusWith<OpTime> loadLastOpTime(OperationContext* opCtx);
+ virtual void cleanUpLastApplyBatch(OperationContext* opCtx);
+ virtual HostAndPort getClientHostAndPort(const OperationContext* opCtx);
virtual void closeConnections();
- virtual void killAllUserOperations(OperationContext* txn);
+ virtual void killAllUserOperations(OperationContext* opCtx);
virtual void shardingOnStepDownHook();
virtual void signalApplierToChooseNewSyncSource();
virtual void stopProducer();
virtual void startProducerIfStopped();
void dropAllSnapshots() final;
void updateCommittedSnapshot(SnapshotName newCommitPoint) final;
- void createSnapshot(OperationContext* txn, SnapshotName name) final;
+ void createSnapshot(OperationContext* opCtx, SnapshotName name) final;
void forceSnapshotCreation() final;
virtual bool snapshotsEnabled() const;
virtual void notifyOplogMetadataWaiters();
virtual double getElectionTimeoutOffsetLimitFraction() const;
- virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* txn) const;
- virtual StatusWith<OpTime> multiApply(OperationContext* txn,
+ virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* opCtx) const;
+ virtual StatusWith<OpTime> multiApply(OperationContext* opCtx,
MultiApplier::Operations ops,
MultiApplier::ApplyOperationFn applyOperation) override;
virtual Status multiSyncApply(MultiApplier::OperationPtrs* ops) override;
@@ -112,9 +112,9 @@ public:
const HostAndPort& source,
AtomicUInt32* fetchCount) override;
virtual std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(
- OperationContext* txn) const override;
+ OperationContext* opCtx) const override;
virtual std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(
- OperationContext* txn) const override;
+ OperationContext* opCtx) const override;
virtual bool shouldUseDataReplicatorInitialSync() const override;
virtual std::size_t getOplogFetcherMaxFetcherRestarts() const override;
@@ -130,7 +130,7 @@ private:
/**
* Stops data replication and returns with 'lock' locked.
*/
- void _stopDataReplication_inlock(OperationContext* txn, UniqueLock* lock);
+ void _stopDataReplication_inlock(OperationContext* opCtx, UniqueLock* lock);
/**
* Called when the instance transitions to primary in order to notify a potentially sharded host
@@ -138,15 +138,15 @@ private:
*
* Throws on errors.
*/
- void _shardingOnTransitionToPrimaryHook(OperationContext* txn);
+ void _shardingOnTransitionToPrimaryHook(OperationContext* opCtx);
/**
* Drops all temporary collections on all databases except "local".
*
* The implementation may assume that the caller has acquired the global exclusive lock
- * for "txn".
+ * for "opCtx".
*/
- void _dropAllTempCollections(OperationContext* txn);
+ void _dropAllTempCollections(OperationContext* opCtx);
// Guards starting threads and setting _startedThreads
stdx::mutex _threadMutex;
diff --git a/src/mongo/db/repl/replication_coordinator_external_state_mock.cpp b/src/mongo/db/repl/replication_coordinator_external_state_mock.cpp
index 274806326a6..87e0e8c6af6 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state_mock.cpp
+++ b/src/mongo/db/repl/replication_coordinator_external_state_mock.cpp
@@ -61,7 +61,7 @@ ReplicationCoordinatorExternalStateMock::ReplicationCoordinatorExternalStateMock
ReplicationCoordinatorExternalStateMock::~ReplicationCoordinatorExternalStateMock() {}
void ReplicationCoordinatorExternalStateMock::runOnInitialSyncThread(
- stdx::function<void(OperationContext* txn)> run) {
+ stdx::function<void(OperationContext* opCtx)> run) {
log() << "not running initial sync during test.";
}
@@ -83,13 +83,13 @@ void ReplicationCoordinatorExternalStateMock::stopDataReplication(OperationConte
void ReplicationCoordinatorExternalStateMock::startMasterSlave(OperationContext*) {}
-Status ReplicationCoordinatorExternalStateMock::runRepairOnLocalDB(OperationContext* txn) {
+Status ReplicationCoordinatorExternalStateMock::runRepairOnLocalDB(OperationContext* opCtx) {
return Status::OK();
}
-Status ReplicationCoordinatorExternalStateMock::initializeReplSetStorage(OperationContext* txn,
+Status ReplicationCoordinatorExternalStateMock::initializeReplSetStorage(OperationContext* opCtx,
const BSONObj& config) {
- return storeLocalConfigDocument(txn, config);
+ return storeLocalConfigDocument(opCtx, config);
}
void ReplicationCoordinatorExternalStateMock::shutdown(OperationContext*) {}
@@ -118,7 +118,7 @@ void ReplicationCoordinatorExternalStateMock::addSelf(const HostAndPort& host) {
}
HostAndPort ReplicationCoordinatorExternalStateMock::getClientHostAndPort(
- const OperationContext* txn) {
+ const OperationContext* opCtx) {
return _clientHostAndPort;
}
@@ -128,11 +128,11 @@ void ReplicationCoordinatorExternalStateMock::setClientHostAndPort(
}
StatusWith<BSONObj> ReplicationCoordinatorExternalStateMock::loadLocalConfigDocument(
- OperationContext* txn) {
+ OperationContext* opCtx) {
return _localRsConfigDocument;
}
-Status ReplicationCoordinatorExternalStateMock::storeLocalConfigDocument(OperationContext* txn,
+Status ReplicationCoordinatorExternalStateMock::storeLocalConfigDocument(OperationContext* opCtx,
const BSONObj& config) {
{
stdx::unique_lock<stdx::mutex> lock(_shouldHangConfigMutex);
@@ -153,12 +153,12 @@ void ReplicationCoordinatorExternalStateMock::setLocalConfigDocument(
}
StatusWith<LastVote> ReplicationCoordinatorExternalStateMock::loadLocalLastVoteDocument(
- OperationContext* txn) {
+ OperationContext* opCtx) {
return _localRsLastVoteDocument;
}
Status ReplicationCoordinatorExternalStateMock::storeLocalLastVoteDocument(
- OperationContext* txn, const LastVote& lastVote) {
+ OperationContext* opCtx, const LastVote& lastVote) {
{
stdx::unique_lock<stdx::mutex> lock(_shouldHangLastVoteMutex);
while (_storeLocalLastVoteDocumentShouldHang) {
@@ -180,9 +180,10 @@ void ReplicationCoordinatorExternalStateMock::setLocalLastVoteDocument(
void ReplicationCoordinatorExternalStateMock::setGlobalTimestamp(ServiceContext* service,
const Timestamp& newTime) {}
-void ReplicationCoordinatorExternalStateMock::cleanUpLastApplyBatch(OperationContext* txn) {}
+void ReplicationCoordinatorExternalStateMock::cleanUpLastApplyBatch(OperationContext* opCtx) {}
-StatusWith<OpTime> ReplicationCoordinatorExternalStateMock::loadLastOpTime(OperationContext* txn) {
+StatusWith<OpTime> ReplicationCoordinatorExternalStateMock::loadLastOpTime(
+ OperationContext* opCtx) {
return _lastOpTime;
}
@@ -222,7 +223,7 @@ void ReplicationCoordinatorExternalStateMock::closeConnections() {
_connectionsClosed = true;
}
-void ReplicationCoordinatorExternalStateMock::killAllUserOperations(OperationContext* txn) {}
+void ReplicationCoordinatorExternalStateMock::killAllUserOperations(OperationContext* opCtx) {}
void ReplicationCoordinatorExternalStateMock::shardingOnStepDownHook() {}
@@ -237,7 +238,7 @@ void ReplicationCoordinatorExternalStateMock::dropAllSnapshots() {}
void ReplicationCoordinatorExternalStateMock::updateCommittedSnapshot(SnapshotName newCommitPoint) {
}
-void ReplicationCoordinatorExternalStateMock::createSnapshot(OperationContext* txn,
+void ReplicationCoordinatorExternalStateMock::createSnapshot(OperationContext* opCtx,
SnapshotName name) {}
void ReplicationCoordinatorExternalStateMock::forceSnapshotCreation() {}
@@ -257,7 +258,7 @@ double ReplicationCoordinatorExternalStateMock::getElectionTimeoutOffsetLimitFra
}
bool ReplicationCoordinatorExternalStateMock::isReadCommittedSupportedByStorageEngine(
- OperationContext* txn) const {
+ OperationContext* opCtx) const {
return _isReadCommittedSupported;
}
@@ -276,12 +277,12 @@ Status ReplicationCoordinatorExternalStateMock::multiInitialSyncApply(
}
std::unique_ptr<OplogBuffer> ReplicationCoordinatorExternalStateMock::makeInitialSyncOplogBuffer(
- OperationContext* txn) const {
+ OperationContext* opCtx) const {
return stdx::make_unique<OplogBufferBlockingQueue>();
}
std::unique_ptr<OplogBuffer> ReplicationCoordinatorExternalStateMock::makeSteadyStateOplogBuffer(
- OperationContext* txn) const {
+ OperationContext* opCtx) const {
return stdx::make_unique<OplogBufferBlockingQueue>();
}
@@ -297,9 +298,9 @@ void ReplicationCoordinatorExternalStateMock::setIsReadCommittedEnabled(bool val
_isReadCommittedSupported = val;
}
-void ReplicationCoordinatorExternalStateMock::onDrainComplete(OperationContext* txn) {}
+void ReplicationCoordinatorExternalStateMock::onDrainComplete(OperationContext* opCtx) {}
-OpTime ReplicationCoordinatorExternalStateMock::onTransitionToPrimary(OperationContext* txn,
+OpTime ReplicationCoordinatorExternalStateMock::onTransitionToPrimary(OperationContext* opCtx,
bool isV1ElectionProtocol) {
if (isV1ElectionProtocol) {
_lastOpTime = OpTime(Timestamp(1, 0), 1);
diff --git a/src/mongo/db/repl/replication_coordinator_external_state_mock.h b/src/mongo/db/repl/replication_coordinator_external_state_mock.h
index 1b575ede697..c33044a2510 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state_mock.h
+++ b/src/mongo/db/repl/replication_coordinator_external_state_mock.h
@@ -58,46 +58,46 @@ public:
virtual ~ReplicationCoordinatorExternalStateMock();
virtual void startThreads(const ReplSettings& settings) override;
virtual void startInitialSync(OnInitialSyncFinishedFn finished) override;
- virtual void startSteadyStateReplication(OperationContext* txn,
+ virtual void startSteadyStateReplication(OperationContext* opCtx,
ReplicationCoordinator* replCoord) override;
- virtual void stopDataReplication(OperationContext* txn) override;
- virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* txn)> run) override;
- virtual bool isInitialSyncFlagSet(OperationContext* txn) override;
+ virtual void stopDataReplication(OperationContext* opCtx) override;
+ virtual void runOnInitialSyncThread(stdx::function<void(OperationContext* opCtx)> run) override;
+ virtual bool isInitialSyncFlagSet(OperationContext* opCtx) override;
virtual void startMasterSlave(OperationContext*);
- virtual void shutdown(OperationContext* txn);
+ virtual void shutdown(OperationContext* opCtx);
virtual executor::TaskExecutor* getTaskExecutor() const override;
virtual OldThreadPool* getDbWorkThreadPool() const override;
- virtual Status runRepairOnLocalDB(OperationContext* txn) override;
- virtual Status initializeReplSetStorage(OperationContext* txn, const BSONObj& config);
- void onDrainComplete(OperationContext* txn) override;
- OpTime onTransitionToPrimary(OperationContext* txn, bool isV1ElectionProtocol) override;
+ virtual Status runRepairOnLocalDB(OperationContext* opCtx) override;
+ virtual Status initializeReplSetStorage(OperationContext* opCtx, const BSONObj& config);
+ void onDrainComplete(OperationContext* opCtx) override;
+ OpTime onTransitionToPrimary(OperationContext* opCtx, bool isV1ElectionProtocol) override;
virtual void forwardSlaveProgress();
virtual OID ensureMe(OperationContext*);
virtual bool isSelf(const HostAndPort& host, ServiceContext* service);
- virtual HostAndPort getClientHostAndPort(const OperationContext* txn);
- virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* txn);
- virtual Status storeLocalConfigDocument(OperationContext* txn, const BSONObj& config);
- virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* txn);
- virtual Status storeLocalLastVoteDocument(OperationContext* txn, const LastVote& lastVote);
+ virtual HostAndPort getClientHostAndPort(const OperationContext* opCtx);
+ virtual StatusWith<BSONObj> loadLocalConfigDocument(OperationContext* opCtx);
+ virtual Status storeLocalConfigDocument(OperationContext* opCtx, const BSONObj& config);
+ virtual StatusWith<LastVote> loadLocalLastVoteDocument(OperationContext* opCtx);
+ virtual Status storeLocalLastVoteDocument(OperationContext* opCtx, const LastVote& lastVote);
virtual void setGlobalTimestamp(ServiceContext* service, const Timestamp& newTime);
- virtual StatusWith<OpTime> loadLastOpTime(OperationContext* txn);
- virtual void cleanUpLastApplyBatch(OperationContext* txn);
+ virtual StatusWith<OpTime> loadLastOpTime(OperationContext* opCtx);
+ virtual void cleanUpLastApplyBatch(OperationContext* opCtx);
virtual void closeConnections();
- virtual void killAllUserOperations(OperationContext* txn);
+ virtual void killAllUserOperations(OperationContext* opCtx);
virtual void shardingOnStepDownHook();
virtual void signalApplierToChooseNewSyncSource();
virtual void stopProducer();
virtual void startProducerIfStopped();
virtual void dropAllSnapshots();
virtual void updateCommittedSnapshot(SnapshotName newCommitPoint);
- virtual void createSnapshot(OperationContext* txn, SnapshotName name);
+ virtual void createSnapshot(OperationContext* opCtx, SnapshotName name);
virtual void forceSnapshotCreation();
virtual bool snapshotsEnabled() const;
virtual void notifyOplogMetadataWaiters();
virtual double getElectionTimeoutOffsetLimitFraction() const;
- virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* txn) const;
- virtual StatusWith<OpTime> multiApply(OperationContext* txn,
+ virtual bool isReadCommittedSupportedByStorageEngine(OperationContext* opCtx) const;
+ virtual StatusWith<OpTime> multiApply(OperationContext* opCtx,
MultiApplier::Operations ops,
MultiApplier::ApplyOperationFn applyOperation) override;
virtual Status multiSyncApply(MultiApplier::OperationPtrs* ops) override;
@@ -105,9 +105,9 @@ public:
const HostAndPort& source,
AtomicUInt32* fetchCount) override;
virtual std::unique_ptr<OplogBuffer> makeInitialSyncOplogBuffer(
- OperationContext* txn) const override;
+ OperationContext* opCtx) const override;
virtual std::unique_ptr<OplogBuffer> makeSteadyStateOplogBuffer(
- OperationContext* txn) const override;
+ OperationContext* opCtx) const override;
virtual bool shouldUseDataReplicatorInitialSync() const override;
virtual std::size_t getOplogFetcherMaxFetcherRestarts() const override;
diff --git a/src/mongo/db/repl/replication_coordinator_impl.cpp b/src/mongo/db/repl/replication_coordinator_impl.cpp
index 8ad99d7e24a..a238cee74de 100644
--- a/src/mongo/db/repl/replication_coordinator_impl.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl.cpp
@@ -411,8 +411,8 @@ void ReplicationCoordinatorImpl::appendConnectionStats(executor::ConnectionPoolS
_replExecutor.appendConnectionStats(stats);
}
-bool ReplicationCoordinatorImpl::_startLoadLocalConfig(OperationContext* txn) {
- StatusWith<LastVote> lastVote = _externalState->loadLocalLastVoteDocument(txn);
+bool ReplicationCoordinatorImpl::_startLoadLocalConfig(OperationContext* opCtx) {
+ StatusWith<LastVote> lastVote = _externalState->loadLocalLastVoteDocument(opCtx);
if (!lastVote.isOK()) {
if (lastVote.getStatus() == ErrorCodes::NoMatchingDocument) {
log() << "Did not find local voted for document at startup.";
@@ -426,7 +426,7 @@ bool ReplicationCoordinatorImpl::_startLoadLocalConfig(OperationContext* txn) {
_topCoord->loadLastVote(lastVote.getValue());
}
- StatusWith<BSONObj> cfg = _externalState->loadLocalConfigDocument(txn);
+ StatusWith<BSONObj> cfg = _externalState->loadLocalConfigDocument(opCtx);
if (!cfg.isOK()) {
log() << "Did not find local replica set configuration document at startup; "
<< cfg.getStatus();
@@ -443,8 +443,8 @@ bool ReplicationCoordinatorImpl::_startLoadLocalConfig(OperationContext* txn) {
}
// Read the last op from the oplog after cleaning up any partially applied batches.
- _externalState->cleanUpLastApplyBatch(txn);
- auto lastOpTimeStatus = _externalState->loadLastOpTime(txn);
+ _externalState->cleanUpLastApplyBatch(opCtx);
+ auto lastOpTimeStatus = _externalState->loadLastOpTime(opCtx);
// Use a callback here, because _finishLoadLocalConfig calls isself() which requires
// that the server's networking layer be up and running and accepting connections, which
@@ -546,12 +546,12 @@ void ReplicationCoordinatorImpl::_finishLoadLocalConfig(
_performPostMemberStateUpdateAction(action);
if (!isArbiter) {
_externalState->startThreads(_settings);
- invariant(cbData.txn);
- _startDataReplication(cbData.txn);
+ invariant(cbData.opCtx);
+ _startDataReplication(cbData.opCtx);
}
}
-void ReplicationCoordinatorImpl::_stopDataReplication(OperationContext* txn) {
+void ReplicationCoordinatorImpl::_stopDataReplication(OperationContext* opCtx) {
std::shared_ptr<DataReplicator> drCopy;
{
LockGuard lk(_mutex);
@@ -569,19 +569,20 @@ void ReplicationCoordinatorImpl::_stopDataReplication(OperationContext* txn) {
}
LOG(1) << "ReplicationCoordinatorImpl::_stopDataReplication calling "
"ReplCoordExtState::stopDataReplication.";
- _externalState->stopDataReplication(txn);
+ _externalState->stopDataReplication(opCtx);
}
-void ReplicationCoordinatorImpl::_startDataReplication(OperationContext* txn,
+void ReplicationCoordinatorImpl::_startDataReplication(OperationContext* opCtx,
stdx::function<void()> startCompleted) {
// Check to see if we need to do an initial sync.
const auto lastOpTime = getMyLastAppliedOpTime();
- const auto needsInitialSync = lastOpTime.isNull() || _externalState->isInitialSyncFlagSet(txn);
+ const auto needsInitialSync =
+ lastOpTime.isNull() || _externalState->isInitialSyncFlagSet(opCtx);
if (!needsInitialSync) {
stdx::lock_guard<stdx::mutex> lk(_mutex);
if (!_inShutdown) {
// Start steady replication, since we already have data.
- _externalState->startSteadyStateReplication(txn, this);
+ _externalState->startSteadyStateReplication(opCtx, this);
}
return;
}
@@ -624,9 +625,9 @@ void ReplicationCoordinatorImpl::_startDataReplication(OperationContext* txn,
startCompleted();
}
// Repair local db (to compact it).
- auto txn = cc().makeOperationContext();
- uassertStatusOK(_externalState->runRepairOnLocalDB(txn.get()));
- _externalState->startSteadyStateReplication(txn.get(), this);
+ auto opCtx = cc().makeOperationContext();
+ uassertStatusOK(_externalState->runRepairOnLocalDB(opCtx.get()));
+ _externalState->startSteadyStateReplication(opCtx.get(), this);
};
std::shared_ptr<DataReplicator> drCopy;
@@ -644,7 +645,7 @@ void ReplicationCoordinatorImpl::_startDataReplication(OperationContext* txn,
}
// DataReplicator::startup() must be called outside lock because it uses features (eg.
// setting the initial sync flag) which depend on the ReplicationCoordinatorImpl.
- uassertStatusOK(drCopy->startup(txn, numInitialSyncAttempts.load()));
+ uassertStatusOK(drCopy->startup(opCtx, numInitialSyncAttempts.load()));
} catch (...) {
auto status = exceptionToStatus();
log() << "Initial Sync failed to start: " << status;
@@ -655,19 +656,19 @@ void ReplicationCoordinatorImpl::_startDataReplication(OperationContext* txn,
fassertFailedWithStatusNoTrace(40354, status);
}
} else {
- _externalState->startInitialSync([this, startCompleted](OperationContext* txn) {
+ _externalState->startInitialSync([this, startCompleted](OperationContext* opCtx) {
stdx::lock_guard<stdx::mutex> lk(_mutex);
if (!_inShutdown) {
if (startCompleted) {
startCompleted();
}
- _externalState->startSteadyStateReplication(txn, this);
+ _externalState->startSteadyStateReplication(opCtx, this);
}
});
}
}
-void ReplicationCoordinatorImpl::startup(OperationContext* txn) {
+void ReplicationCoordinatorImpl::startup(OperationContext* opCtx) {
if (!isReplEnabled()) {
stdx::lock_guard<stdx::mutex> lk(_mutex);
_setConfigState_inlock(kConfigReplicationDisabled);
@@ -675,7 +676,7 @@ void ReplicationCoordinatorImpl::startup(OperationContext* txn) {
}
{
- OID rid = _externalState->ensureMe(txn);
+ OID rid = _externalState->ensureMe(opCtx);
stdx::lock_guard<stdx::mutex> lk(_mutex);
fassert(18822, !_inShutdown);
@@ -687,16 +688,16 @@ void ReplicationCoordinatorImpl::startup(OperationContext* txn) {
if (!_settings.usingReplSets()) {
// Must be Master/Slave
invariant(_settings.isMaster() || _settings.isSlave());
- _externalState->startMasterSlave(txn);
+ _externalState->startMasterSlave(opCtx);
return;
}
_replExecutor.startup();
_topCoord->setStorageEngineSupportsReadCommitted(
- _externalState->isReadCommittedSupportedByStorageEngine(txn));
+ _externalState->isReadCommittedSupportedByStorageEngine(opCtx));
- bool doneLoadingConfig = _startLoadLocalConfig(txn);
+ bool doneLoadingConfig = _startLoadLocalConfig(opCtx);
if (doneLoadingConfig) {
// If we're not done loading the config, then the config state will be set by
// _finishLoadLocalConfig.
@@ -706,7 +707,7 @@ void ReplicationCoordinatorImpl::startup(OperationContext* txn) {
}
}
-void ReplicationCoordinatorImpl::shutdown(OperationContext* txn) {
+void ReplicationCoordinatorImpl::shutdown(OperationContext* opCtx) {
// Shutdown must:
// * prevent new threads from blocking in awaitReplication
// * wake up all existing threads blocking in awaitReplication
@@ -759,7 +760,7 @@ void ReplicationCoordinatorImpl::shutdown(OperationContext* txn) {
drCopy->join();
drCopy.reset();
}
- _externalState->shutdown(txn);
+ _externalState->shutdown(opCtx);
_replExecutor.shutdown();
_replExecutor.join();
}
@@ -892,7 +893,7 @@ ReplicationCoordinator::ApplierState ReplicationCoordinatorImpl::getApplierState
return _applierState;
}
-void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* txn,
+void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* opCtx,
long long termWhenBufferIsEmpty) {
// This logic is a little complicated in order to avoid acquiring the global exclusive lock
// unnecessarily. This is important because the applier may call signalDrainComplete()
@@ -918,7 +919,7 @@ void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* txn,
// temp collection isn't introduced on the new primary before we drop all the temp collections.
// When we go to drop all temp collections, we must replicate the drops.
- invariant(txn->writesAreReplicated());
+ invariant(opCtx->writesAreReplicated());
stdx::unique_lock<stdx::mutex> lk(_mutex);
if (_applierState != ApplierState::Draining) {
@@ -926,7 +927,7 @@ void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* txn,
}
lk.unlock();
- _externalState->onDrainComplete(txn);
+ _externalState->onDrainComplete(opCtx);
if (MONGO_FAIL_POINT(transitionToPrimaryHangBeforeTakingGlobalExclusiveLock)) {
log() << "transition to primary - "
@@ -943,8 +944,8 @@ void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* txn,
}
}
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite globalWriteLock(txn->lockState());
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite globalWriteLock(opCtx->lockState());
lk.lock();
// Exit drain mode when the buffer is empty in the current term and we're in Draining mode.
@@ -959,7 +960,7 @@ void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* txn,
_canAcceptNonLocalWrites = true;
lk.unlock();
- _setFirstOpTimeOfMyTerm(_externalState->onTransitionToPrimary(txn, isV1ElectionProtocol()));
+ _setFirstOpTimeOfMyTerm(_externalState->onTransitionToPrimary(opCtx, isV1ElectionProtocol()));
lk.lock();
// Must calculate the commit level again because firstOpTimeOfMyTerm wasn't set when we logged
@@ -1232,11 +1233,11 @@ OpTime ReplicationCoordinatorImpl::getMyLastDurableOpTime() const {
return _getMyLastDurableOpTime_inlock();
}
-Status ReplicationCoordinatorImpl::waitUntilOpTimeForRead(OperationContext* txn,
+Status ReplicationCoordinatorImpl::waitUntilOpTimeForRead(OperationContext* opCtx,
const ReadConcernArgs& settings) {
// We should never wait for replication if we are holding any locks, because this can
// potentially block for long time while doing network activity.
- if (txn->lockState()->isLocked()) {
+ if (opCtx->lockState()->isLocked()) {
return {ErrorCodes::IllegalOperation,
"Waiting for replication not allowed while holding a lock"};
}
@@ -1291,10 +1292,10 @@ Status ReplicationCoordinatorImpl::waitUntilOpTimeForRead(OperationContext* txn,
// If we are doing a majority read concern we only need to wait for a new snapshot.
if (isMajorityReadConcern) {
// Wait for a snapshot that meets our needs (< targetOpTime).
- LOG(3) << "waitUntilOpTime: waiting for a new snapshot until " << txn->getDeadline();
+ LOG(3) << "waitUntilOpTime: waiting for a new snapshot until " << opCtx->getDeadline();
auto waitStatus =
- txn->waitForConditionOrInterruptNoAssert(_currentCommittedSnapshotCond, lock);
+ opCtx->waitForConditionOrInterruptNoAssert(_currentCommittedSnapshotCond, lock);
if (!waitStatus.isOK()) {
return waitStatus;
}
@@ -1305,12 +1306,12 @@ Status ReplicationCoordinatorImpl::waitUntilOpTimeForRead(OperationContext* txn,
// We just need to wait for the opTime to catch up to what we need (not majority RC).
stdx::condition_variable condVar;
WaiterInfoGuard waitInfo(
- &_opTimeWaiterList, txn->getOpID(), targetOpTime, nullptr, &condVar);
+ &_opTimeWaiterList, opCtx->getOpID(), targetOpTime, nullptr, &condVar);
LOG(3) << "waituntilOpTime: waiting for OpTime " << waitInfo.waiter << " until "
- << txn->getDeadline();
+ << opCtx->getDeadline();
- auto waitStatus = txn->waitForConditionOrInterruptNoAssert(condVar, lock);
+ auto waitStatus = opCtx->waitForConditionOrInterruptNoAssert(condVar, lock);
if (!waitStatus.isOK()) {
return waitStatus;
}
@@ -1591,37 +1592,37 @@ bool ReplicationCoordinatorImpl::_haveTaggedNodesReachedOpTime_inlock(
}
ReplicationCoordinator::StatusAndDuration ReplicationCoordinatorImpl::awaitReplication(
- OperationContext* txn, const OpTime& opTime, const WriteConcernOptions& writeConcern) {
+ OperationContext* opCtx, const OpTime& opTime, const WriteConcernOptions& writeConcern) {
Timer timer;
WriteConcernOptions fixedWriteConcern = populateUnsetWriteConcernOptionsSyncMode(writeConcern);
stdx::unique_lock<stdx::mutex> lock(_mutex);
auto status =
- _awaitReplication_inlock(&lock, txn, opTime, SnapshotName::min(), fixedWriteConcern);
+ _awaitReplication_inlock(&lock, opCtx, opTime, SnapshotName::min(), fixedWriteConcern);
return {std::move(status), duration_cast<Milliseconds>(timer.elapsed())};
}
ReplicationCoordinator::StatusAndDuration
ReplicationCoordinatorImpl::awaitReplicationOfLastOpForClient(
- OperationContext* txn, const WriteConcernOptions& writeConcern) {
+ OperationContext* opCtx, const WriteConcernOptions& writeConcern) {
Timer timer;
WriteConcernOptions fixedWriteConcern = populateUnsetWriteConcernOptionsSyncMode(writeConcern);
stdx::unique_lock<stdx::mutex> lock(_mutex);
- const auto& clientInfo = ReplClientInfo::forClient(txn->getClient());
+ const auto& clientInfo = ReplClientInfo::forClient(opCtx->getClient());
auto status = _awaitReplication_inlock(
- &lock, txn, clientInfo.getLastOp(), clientInfo.getLastSnapshot(), fixedWriteConcern);
+ &lock, opCtx, clientInfo.getLastOp(), clientInfo.getLastSnapshot(), fixedWriteConcern);
return {std::move(status), duration_cast<Milliseconds>(timer.elapsed())};
}
Status ReplicationCoordinatorImpl::_awaitReplication_inlock(
stdx::unique_lock<stdx::mutex>* lock,
- OperationContext* txn,
+ OperationContext* opCtx,
const OpTime& opTime,
SnapshotName minSnapshot,
const WriteConcernOptions& writeConcern) {
// We should never wait for replication if we are holding any locks, because this can
// potentially block for long time while doing network activity.
- if (txn->lockState()->isLocked()) {
+ if (opCtx->lockState()->isLocked()) {
return {ErrorCodes::IllegalOperation,
"Waiting for replication not allowed while holding a lock"};
}
@@ -1668,7 +1669,7 @@ Status ReplicationCoordinatorImpl::_awaitReplication_inlock(
return stepdownStatus;
}
- auto interruptStatus = txn->checkForInterruptNoAssert();
+ auto interruptStatus = opCtx->checkForInterruptNoAssert();
if (!interruptStatus.isOK()) {
return interruptStatus;
}
@@ -1681,7 +1682,7 @@ Status ReplicationCoordinatorImpl::_awaitReplication_inlock(
}
}
- auto clockSource = txn->getServiceContext()->getFastClockSource();
+ auto clockSource = opCtx->getServiceContext()->getFastClockSource();
const auto wTimeoutDate = [&]() -> const Date_t {
if (writeConcern.wDeadline != Date_t::max()) {
return writeConcern.wDeadline;
@@ -1696,14 +1697,14 @@ Status ReplicationCoordinatorImpl::_awaitReplication_inlock(
// Must hold _mutex before constructing waitInfo as it will modify _replicationWaiterList
stdx::condition_variable condVar;
WaiterInfoGuard waitInfo(
- &_replicationWaiterList, txn->getOpID(), opTime, &writeConcern, &condVar);
+ &_replicationWaiterList, opCtx->getOpID(), opTime, &writeConcern, &condVar);
while (!_doneWaitingForReplication_inlock(opTime, minSnapshot, writeConcern)) {
if (_inShutdown) {
return {ErrorCodes::ShutdownInProgress, "Replication is being shut down"};
}
- auto status = txn->waitForConditionOrInterruptNoAssertUntil(condVar, *lock, wTimeoutDate);
+ auto status = opCtx->waitForConditionOrInterruptNoAssertUntil(condVar, *lock, wTimeoutDate);
if (!status.isOK()) {
return status.getStatus();
}
@@ -1729,7 +1730,7 @@ Status ReplicationCoordinatorImpl::_awaitReplication_inlock(
return _checkIfWriteConcernCanBeSatisfied_inlock(writeConcern);
}
-Status ReplicationCoordinatorImpl::stepDown(OperationContext* txn,
+Status ReplicationCoordinatorImpl::stepDown(OperationContext* opCtx,
const bool force,
const Milliseconds& waitTime,
const Milliseconds& stepdownTime) {
@@ -1745,12 +1746,12 @@ Status ReplicationCoordinatorImpl::stepDown(OperationContext* txn,
return {ErrorCodes::NotMaster, "not primary so can't step down"};
}
- Lock::GlobalLock globalReadLock(txn->lockState(), MODE_S, Lock::GlobalLock::EnqueueOnly());
+ Lock::GlobalLock globalReadLock(opCtx->lockState(), MODE_S, Lock::GlobalLock::EnqueueOnly());
// We've requested the global shared lock which will stop new writes from coming in,
// but existing writes could take a long time to finish, so kill all user operations
// to help us get the global lock faster.
- _externalState->killAllUserOperations(txn);
+ _externalState->killAllUserOperations(opCtx);
globalReadLock.waitForLock(durationCount<Milliseconds>(stepdownTime));
@@ -1763,7 +1764,7 @@ Status ReplicationCoordinatorImpl::stepDown(OperationContext* txn,
try {
stdx::unique_lock<stdx::mutex> topoLock(_topoMutex);
bool restartHeartbeats = true;
- txn->checkForInterrupt();
+ opCtx->checkForInterrupt();
while (!_tryToStepDown(waitUntil, stepDownUntil, force)) {
if (restartHeartbeats) {
// We send out a fresh round of heartbeats because stepping down successfully
@@ -1773,7 +1774,7 @@ Status ReplicationCoordinatorImpl::stepDown(OperationContext* txn,
_restartHeartbeats_inlock();
restartHeartbeats = false;
}
- txn->waitForConditionOrInterruptUntil(
+ opCtx->waitForConditionOrInterruptUntil(
_stepDownWaiters, topoLock, std::min(stepDownUntil, waitUntil));
}
} catch (const DBException& ex) {
@@ -1864,14 +1865,14 @@ bool ReplicationCoordinatorImpl::isMasterForReportingPurposes() {
return false;
}
-bool ReplicationCoordinatorImpl::canAcceptWritesForDatabase(OperationContext* txn,
+bool ReplicationCoordinatorImpl::canAcceptWritesForDatabase(OperationContext* opCtx,
StringData dbName) {
// The answer isn't meaningful unless we hold the global lock.
- invariant(txn->lockState()->isLocked());
- return canAcceptWritesForDatabase_UNSAFE(txn, dbName);
+ invariant(opCtx->lockState()->isLocked());
+ return canAcceptWritesForDatabase_UNSAFE(opCtx, dbName);
}
-bool ReplicationCoordinatorImpl::canAcceptWritesForDatabase_UNSAFE(OperationContext* txn,
+bool ReplicationCoordinatorImpl::canAcceptWritesForDatabase_UNSAFE(OperationContext* opCtx,
StringData dbName) {
// _canAcceptNonLocalWrites is always true for standalone nodes, always false for nodes
// started with --slave, and adjusted based on primary+drain state in replica sets.
@@ -1889,32 +1890,32 @@ bool ReplicationCoordinatorImpl::canAcceptWritesForDatabase_UNSAFE(OperationCont
return !replAllDead && _settings.isMaster();
}
-bool ReplicationCoordinatorImpl::canAcceptWritesFor(OperationContext* txn,
+bool ReplicationCoordinatorImpl::canAcceptWritesFor(OperationContext* opCtx,
const NamespaceString& ns) {
- invariant(txn->lockState()->isLocked());
- return canAcceptWritesFor_UNSAFE(txn, ns);
+ invariant(opCtx->lockState()->isLocked());
+ return canAcceptWritesFor_UNSAFE(opCtx, ns);
}
-bool ReplicationCoordinatorImpl::canAcceptWritesFor_UNSAFE(OperationContext* txn,
+bool ReplicationCoordinatorImpl::canAcceptWritesFor_UNSAFE(OperationContext* opCtx,
const NamespaceString& ns) {
if (_memberState.rollback() && ns.isOplog()) {
return false;
}
StringData dbName = ns.db();
- return canAcceptWritesForDatabase_UNSAFE(txn, dbName);
+ return canAcceptWritesForDatabase_UNSAFE(opCtx, dbName);
}
-Status ReplicationCoordinatorImpl::checkCanServeReadsFor(OperationContext* txn,
+Status ReplicationCoordinatorImpl::checkCanServeReadsFor(OperationContext* opCtx,
const NamespaceString& ns,
bool slaveOk) {
- invariant(txn->lockState()->isLocked());
- return checkCanServeReadsFor_UNSAFE(txn, ns, slaveOk);
+ invariant(opCtx->lockState()->isLocked());
+ return checkCanServeReadsFor_UNSAFE(opCtx, ns, slaveOk);
}
-Status ReplicationCoordinatorImpl::checkCanServeReadsFor_UNSAFE(OperationContext* txn,
+Status ReplicationCoordinatorImpl::checkCanServeReadsFor_UNSAFE(OperationContext* opCtx,
const NamespaceString& ns,
bool slaveOk) {
- auto client = txn->getClient();
+ auto client = opCtx->getClient();
// Oplog reads are not allowed during STARTUP state, but we make an exception for internal
// reads and master-slave replication. Internel reads are required for cleaning up unfinished
// apply batches. Master-slave never sets the state so we make an exception for it as well.
@@ -1928,7 +1929,7 @@ Status ReplicationCoordinatorImpl::checkCanServeReadsFor_UNSAFE(OperationContext
if (client->isInDirectClient()) {
return Status::OK();
}
- if (canAcceptWritesFor_UNSAFE(txn, ns)) {
+ if (canAcceptWritesFor_UNSAFE(opCtx, ns)) {
return Status::OK();
}
if (_settings.isSlave() || _settings.isMaster()) {
@@ -1948,9 +1949,9 @@ bool ReplicationCoordinatorImpl::isInPrimaryOrSecondaryState() const {
return _canServeNonLocalReads.loadRelaxed();
}
-bool ReplicationCoordinatorImpl::shouldRelaxIndexConstraints(OperationContext* txn,
+bool ReplicationCoordinatorImpl::shouldRelaxIndexConstraints(OperationContext* opCtx,
const NamespaceString& ns) {
- return !canAcceptWritesFor(txn, ns);
+ return !canAcceptWritesFor(opCtx, ns);
}
OID ReplicationCoordinatorImpl::getElectionId() {
@@ -1977,8 +1978,8 @@ int ReplicationCoordinatorImpl::_getMyId_inlock() const {
return self.getId();
}
-Status ReplicationCoordinatorImpl::resyncData(OperationContext* txn, bool waitUntilCompleted) {
- _stopDataReplication(txn);
+Status ReplicationCoordinatorImpl::resyncData(OperationContext* opCtx, bool waitUntilCompleted) {
+ _stopDataReplication(opCtx);
auto finishedEvent = uassertStatusOK(_replExecutor.makeEvent());
stdx::function<void()> f;
if (waitUntilCompleted)
@@ -1987,7 +1988,7 @@ Status ReplicationCoordinatorImpl::resyncData(OperationContext* txn, bool waitUn
stdx::unique_lock<stdx::mutex> lk(_mutex);
_resetMyLastOpTimes_inlock();
lk.unlock(); // unlock before calling into replCoordExtState.
- _startDataReplication(txn, f);
+ _startDataReplication(opCtx, f);
if (waitUntilCompleted) {
_replExecutor.waitForEvent(finishedEvent);
}
@@ -2212,7 +2213,7 @@ Status ReplicationCoordinatorImpl::setMaintenanceMode(bool activate) {
return Status::OK();
}
-Status ReplicationCoordinatorImpl::processReplSetSyncFrom(OperationContext* txn,
+Status ReplicationCoordinatorImpl::processReplSetSyncFrom(OperationContext* opCtx,
const HostAndPort& target,
BSONObjBuilder* resultObj) {
Status result(ErrorCodes::InternalError, "didn't set status in prepareSyncFromResponse");
@@ -2227,7 +2228,7 @@ Status ReplicationCoordinatorImpl::processReplSetSyncFrom(OperationContext* txn,
}
if (doResync) {
- return resyncData(txn, false);
+ return resyncData(opCtx, false);
}
return result;
@@ -2292,7 +2293,7 @@ Status ReplicationCoordinatorImpl::processHeartbeat(const ReplSetHeartbeatArgs&
return result;
}
-Status ReplicationCoordinatorImpl::processReplSetReconfig(OperationContext* txn,
+Status ReplicationCoordinatorImpl::processReplSetReconfig(OperationContext* opCtx,
const ReplSetReconfigArgs& args,
BSONObjBuilder* resultObj) {
log() << "replSetReconfig admin command received from client";
@@ -2363,7 +2364,7 @@ Status ReplicationCoordinatorImpl::processReplSetReconfig(OperationContext* txn,
}
StatusWith<int> myIndex = validateConfigForReconfig(
- _externalState.get(), oldConfig, newConfig, txn->getServiceContext(), args.force);
+ _externalState.get(), oldConfig, newConfig, opCtx->getServiceContext(), args.force);
if (!myIndex.isOK()) {
error() << "replSetReconfig got " << myIndex.getStatus() << " while validating "
<< newConfigObj;
@@ -2382,7 +2383,7 @@ Status ReplicationCoordinatorImpl::processReplSetReconfig(OperationContext* txn,
}
}
- status = _externalState->storeLocalConfigDocument(txn, newConfig.toBSON());
+ status = _externalState->storeLocalConfigDocument(opCtx, newConfig.toBSON());
if (!status.isOK()) {
error() << "replSetReconfig failed to store config document; " << status;
return status;
@@ -2465,7 +2466,7 @@ void ReplicationCoordinatorImpl::_finishReplSetReconfig(
}
}
-Status ReplicationCoordinatorImpl::processReplSetInitiate(OperationContext* txn,
+Status ReplicationCoordinatorImpl::processReplSetInitiate(OperationContext* opCtx,
const BSONObj& configObj,
BSONObjBuilder* resultObj) {
log() << "replSetInitiate admin command received from client";
@@ -2508,7 +2509,7 @@ Status ReplicationCoordinatorImpl::processReplSetInitiate(OperationContext* txn,
}
StatusWith<int> myIndex =
- validateConfigForInitiate(_externalState.get(), newConfig, txn->getServiceContext());
+ validateConfigForInitiate(_externalState.get(), newConfig, opCtx->getServiceContext());
if (!myIndex.isOK()) {
error() << "replSet initiate got " << myIndex.getStatus() << " while validating "
<< configObj;
@@ -2525,7 +2526,7 @@ Status ReplicationCoordinatorImpl::processReplSetInitiate(OperationContext* txn,
return status;
}
- status = _externalState->initializeReplSetStorage(txn, newConfig.toBSON());
+ status = _externalState->initializeReplSetStorage(opCtx, newConfig.toBSON());
if (!status.isOK()) {
error() << "replSetInitiate failed to store config document or create the oplog; "
<< status;
@@ -2545,7 +2546,7 @@ Status ReplicationCoordinatorImpl::processReplSetInitiate(OperationContext* txn,
// will fail validation with a "replSet initiate got ... while validating" reason.
invariant(!newConfig.getMemberAt(myIndex.getValue()).isArbiter());
_externalState->startThreads(_settings);
- _startDataReplication(txn);
+ _startDataReplication(opCtx);
configStateGuard.Dismiss();
return Status::OK();
@@ -2949,7 +2950,7 @@ Status ReplicationCoordinatorImpl::processReplSetUpdatePosition(const UpdatePosi
return status;
}
-Status ReplicationCoordinatorImpl::processHandshake(OperationContext* txn,
+Status ReplicationCoordinatorImpl::processHandshake(OperationContext* opCtx,
const HandshakeArgs& handshake) {
LOG(2) << "Received handshake " << handshake.toBSON();
@@ -2968,7 +2969,7 @@ Status ReplicationCoordinatorImpl::processHandshake(OperationContext* txn,
SlaveInfo newSlaveInfo;
newSlaveInfo.rid = handshake.getRid();
newSlaveInfo.memberId = -1;
- newSlaveInfo.hostAndPort = _externalState->getClientHostAndPort(txn);
+ newSlaveInfo.hostAndPort = _externalState->getClientHostAndPort(opCtx);
// Don't call _addSlaveInfo_inlock as that would wake sleepers unnecessarily.
_slaveInfo.push_back(newSlaveInfo);
@@ -3121,8 +3122,8 @@ void ReplicationCoordinatorImpl::blacklistSyncSource(const HostAndPort& host, Da
host));
}
-void ReplicationCoordinatorImpl::resetLastOpTimesFromOplog(OperationContext* txn) {
- StatusWith<OpTime> lastOpTimeStatus = _externalState->loadLastOpTime(txn);
+void ReplicationCoordinatorImpl::resetLastOpTimesFromOplog(OperationContext* opCtx) {
+ StatusWith<OpTime> lastOpTimeStatus = _externalState->loadLastOpTime(opCtx);
OpTime lastOpTime;
if (!lastOpTimeStatus.isOK()) {
warning() << "Failed to load timestamp of most recently applied operation; "
@@ -3137,7 +3138,7 @@ void ReplicationCoordinatorImpl::resetLastOpTimesFromOplog(OperationContext* txn
_reportUpstream_inlock(std::move(lock));
// Unlocked below.
- _externalState->setGlobalTimestamp(txn->getServiceContext(), lastOpTime.getTimestamp());
+ _externalState->setGlobalTimestamp(opCtx->getServiceContext(), lastOpTime.getTimestamp());
}
bool ReplicationCoordinatorImpl::shouldChangeSyncSource(
@@ -3244,14 +3245,14 @@ OpTime ReplicationCoordinatorImpl::getLastCommittedOpTime() const {
}
Status ReplicationCoordinatorImpl::processReplSetRequestVotes(
- OperationContext* txn,
+ OperationContext* opCtx,
const ReplSetRequestVotesArgs& args,
ReplSetRequestVotesResponse* response) {
if (!isV1ElectionProtocol()) {
return {ErrorCodes::BadValue, "not using election protocol v1"};
}
- auto termStatus = updateTerm(txn, args.getTerm());
+ auto termStatus = updateTerm(opCtx, args.getTerm());
if (!termStatus.isOK() && termStatus.code() != ErrorCodes::StaleTerm)
return termStatus;
@@ -3264,7 +3265,7 @@ Status ReplicationCoordinatorImpl::processReplSetRequestVotes(
if (!args.isADryRun() && response->getVoteGranted()) {
LastVote lastVote{args.getTerm(), args.getCandidateIndex()};
- Status status = _externalState->storeLocalLastVoteDocument(txn, lastVote);
+ Status status = _externalState->storeLocalLastVoteDocument(opCtx, lastVote);
if (!status.isOK()) {
error() << "replSetRequestVotes failed to store LastVote document; " << status;
return status;
@@ -3405,7 +3406,7 @@ EventHandle ReplicationCoordinatorImpl::updateTerm_forTest(
return finishEvh;
}
-Status ReplicationCoordinatorImpl::updateTerm(OperationContext* txn, long long term) {
+Status ReplicationCoordinatorImpl::updateTerm(OperationContext* opCtx, long long term) {
// Term is only valid if we are replicating.
if (getReplicationMode() != modeReplSet) {
return {ErrorCodes::BadValue, "cannot supply 'term' without active replication"};
@@ -3417,7 +3418,7 @@ Status ReplicationCoordinatorImpl::updateTerm(OperationContext* txn, long long t
}
// Check we haven't acquired any lock, because potential stepdown needs global lock.
- dassert(!txn->lockState()->isLocked());
+ dassert(!opCtx->lockState()->isLocked());
TopologyCoordinator::UpdateTermResult updateTermResult;
EventHandle finishEvh;
@@ -3469,12 +3470,12 @@ EventHandle ReplicationCoordinatorImpl::_updateTerm_incallback(
return EventHandle();
}
-SnapshotName ReplicationCoordinatorImpl::reserveSnapshotName(OperationContext* txn) {
+SnapshotName ReplicationCoordinatorImpl::reserveSnapshotName(OperationContext* opCtx) {
auto reservedName = SnapshotName(_snapshotNameGenerator.addAndFetch(1));
dassert(reservedName > SnapshotName::min());
dassert(reservedName < SnapshotName::max());
- if (txn) {
- ReplClientInfo::forClient(txn->getClient()).setLastSnapshot(reservedName);
+ if (opCtx) {
+ ReplClientInfo::forClient(opCtx->getClient()).setLastSnapshot(reservedName);
}
return reservedName;
}
@@ -3483,12 +3484,12 @@ void ReplicationCoordinatorImpl::forceSnapshotCreation() {
_externalState->forceSnapshotCreation();
}
-void ReplicationCoordinatorImpl::waitUntilSnapshotCommitted(OperationContext* txn,
+void ReplicationCoordinatorImpl::waitUntilSnapshotCommitted(OperationContext* opCtx,
const SnapshotName& untilSnapshot) {
stdx::unique_lock<stdx::mutex> lock(_mutex);
while (!_currentCommittedSnapshot || _currentCommittedSnapshot->name < untilSnapshot) {
- txn->waitForConditionOrInterrupt(_currentCommittedSnapshotCond, lock);
+ opCtx->waitForConditionOrInterrupt(_currentCommittedSnapshotCond, lock);
}
}
@@ -3496,11 +3497,11 @@ size_t ReplicationCoordinatorImpl::getNumUncommittedSnapshots() {
return _uncommittedSnapshotsSize.load();
}
-void ReplicationCoordinatorImpl::createSnapshot(OperationContext* txn,
+void ReplicationCoordinatorImpl::createSnapshot(OperationContext* opCtx,
OpTime timeOfSnapshot,
SnapshotName name) {
stdx::lock_guard<stdx::mutex> lock(_mutex);
- _externalState->createSnapshot(txn, name);
+ _externalState->createSnapshot(opCtx, name);
auto snapshotInfo = SnapshotInfo{timeOfSnapshot, name};
if (timeOfSnapshot <= _lastCommittedOpTime) {
@@ -3588,10 +3589,10 @@ EventHandle ReplicationCoordinatorImpl::_resetElectionInfoOnProtocolVersionUpgra
if (cbData.status == ErrorCodes::CallbackCanceled) {
return;
}
- invariant(cbData.txn);
+ invariant(cbData.opCtx);
LastVote lastVote{OpTime::kInitialTerm, -1};
- auto status = _externalState->storeLocalLastVoteDocument(cbData.txn, lastVote);
+ auto status = _externalState->storeLocalLastVoteDocument(cbData.opCtx, lastVote);
invariant(status.isOK());
_replExecutor.signalEvent(evh);
});
diff --git a/src/mongo/db/repl/replication_coordinator_impl.h b/src/mongo/db/repl/replication_coordinator_impl.h
index 5b2722eaab2..1fa82993ff6 100644
--- a/src/mongo/db/repl/replication_coordinator_impl.h
+++ b/src/mongo/db/repl/replication_coordinator_impl.h
@@ -101,9 +101,9 @@ public:
// ================== Members of public ReplicationCoordinator API ===================
- virtual void startup(OperationContext* txn) override;
+ virtual void startup(OperationContext* opCtx) override;
- virtual void shutdown(OperationContext* txn) override;
+ virtual void shutdown(OperationContext* opCtx) override;
virtual ReplicationExecutor* getExecutor() override {
return &_replExecutor;
@@ -124,34 +124,34 @@ public:
virtual void clearSyncSourceBlacklist() override;
virtual ReplicationCoordinator::StatusAndDuration awaitReplication(
- OperationContext* txn, const OpTime& opTime, const WriteConcernOptions& writeConcern);
+ OperationContext* opCtx, const OpTime& opTime, const WriteConcernOptions& writeConcern);
virtual ReplicationCoordinator::StatusAndDuration awaitReplicationOfLastOpForClient(
- OperationContext* txn, const WriteConcernOptions& writeConcern);
+ OperationContext* opCtx, const WriteConcernOptions& writeConcern);
- virtual Status stepDown(OperationContext* txn,
+ virtual Status stepDown(OperationContext* opCtx,
bool force,
const Milliseconds& waitTime,
const Milliseconds& stepdownTime);
virtual bool isMasterForReportingPurposes();
- virtual bool canAcceptWritesForDatabase(OperationContext* txn, StringData dbName);
- virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* txn, StringData dbName);
+ virtual bool canAcceptWritesForDatabase(OperationContext* opCtx, StringData dbName);
+ virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* opCtx, StringData dbName);
- bool canAcceptWritesFor(OperationContext* txn, const NamespaceString& ns) override;
- bool canAcceptWritesFor_UNSAFE(OperationContext* txn, const NamespaceString& ns) override;
+ bool canAcceptWritesFor(OperationContext* opCtx, const NamespaceString& ns) override;
+ bool canAcceptWritesFor_UNSAFE(OperationContext* opCtx, const NamespaceString& ns) override;
virtual Status checkIfWriteConcernCanBeSatisfied(const WriteConcernOptions& writeConcern) const;
- virtual Status checkCanServeReadsFor(OperationContext* txn,
+ virtual Status checkCanServeReadsFor(OperationContext* opCtx,
const NamespaceString& ns,
bool slaveOk);
- virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* txn,
+ virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* opCtx,
const NamespaceString& ns,
bool slaveOk);
- virtual bool shouldRelaxIndexConstraints(OperationContext* txn, const NamespaceString& ns);
+ virtual bool shouldRelaxIndexConstraints(OperationContext* opCtx, const NamespaceString& ns);
virtual Status setLastOptimeForSlave(const OID& rid, const Timestamp& ts);
@@ -168,7 +168,7 @@ public:
virtual OpTime getMyLastAppliedOpTime() const override;
virtual OpTime getMyLastDurableOpTime() const override;
- virtual Status waitUntilOpTimeForRead(OperationContext* txn,
+ virtual Status waitUntilOpTimeForRead(OperationContext* opCtx,
const ReadConcernArgs& settings) override;
virtual OID getElectionId() override;
@@ -181,14 +181,14 @@ public:
virtual ApplierState getApplierState() override;
- virtual void signalDrainComplete(OperationContext* txn,
+ virtual void signalDrainComplete(OperationContext* opCtx,
long long termWhenBufferIsEmpty) override;
virtual Status waitForDrainFinish(Milliseconds timeout) override;
virtual void signalUpstreamUpdater() override;
- virtual Status resyncData(OperationContext* txn, bool waitUntilCompleted) override;
+ virtual Status resyncData(OperationContext* opCtx, bool waitUntilCompleted) override;
virtual StatusWith<BSONObj> prepareReplSetUpdatePositionCommand(
ReplSetUpdatePositionCommandStyle commandStyle) const override;
@@ -214,7 +214,7 @@ public:
virtual bool getMaintenanceMode() override;
- virtual Status processReplSetSyncFrom(OperationContext* txn,
+ virtual Status processReplSetSyncFrom(OperationContext* opCtx,
const HostAndPort& target,
BSONObjBuilder* resultObj) override;
@@ -223,11 +223,11 @@ public:
virtual Status processHeartbeat(const ReplSetHeartbeatArgs& args,
ReplSetHeartbeatResponse* response) override;
- virtual Status processReplSetReconfig(OperationContext* txn,
+ virtual Status processReplSetReconfig(OperationContext* opCtx,
const ReplSetReconfigArgs& args,
BSONObjBuilder* resultObj) override;
- virtual Status processReplSetInitiate(OperationContext* txn,
+ virtual Status processReplSetInitiate(OperationContext* opCtx,
const BSONObj& configObj,
BSONObjBuilder* resultObj) override;
@@ -246,7 +246,8 @@ public:
virtual Status processReplSetUpdatePosition(const UpdatePositionArgs& updates,
long long* configVersion) override;
- virtual Status processHandshake(OperationContext* txn, const HandshakeArgs& handshake) override;
+ virtual Status processHandshake(OperationContext* opCtx,
+ const HandshakeArgs& handshake) override;
virtual bool buildsIndexes() override;
@@ -265,7 +266,7 @@ public:
virtual void blacklistSyncSource(const HostAndPort& host, Date_t until) override;
- virtual void resetLastOpTimesFromOplog(OperationContext* txn) override;
+ virtual void resetLastOpTimesFromOplog(OperationContext* opCtx) override;
virtual bool shouldChangeSyncSource(
const HostAndPort& currentSource,
@@ -274,7 +275,7 @@ public:
virtual OpTime getLastCommittedOpTime() const override;
- virtual Status processReplSetRequestVotes(OperationContext* txn,
+ virtual Status processReplSetRequestVotes(OperationContext* opCtx,
const ReplSetRequestVotesArgs& args,
ReplSetRequestVotesResponse* response) override;
@@ -302,19 +303,19 @@ public:
return _service;
}
- virtual Status updateTerm(OperationContext* txn, long long term) override;
+ virtual Status updateTerm(OperationContext* opCtx, long long term) override;
- virtual SnapshotName reserveSnapshotName(OperationContext* txn) override;
+ virtual SnapshotName reserveSnapshotName(OperationContext* opCtx) override;
virtual void forceSnapshotCreation() override;
- virtual void createSnapshot(OperationContext* txn,
+ virtual void createSnapshot(OperationContext* opCtx,
OpTime timeOfSnapshot,
SnapshotName name) override;
virtual OpTime getCurrentCommittedSnapshotOpTime() const override;
- virtual void waitUntilSnapshotCommitted(OperationContext* txn,
+ virtual void waitUntilSnapshotCommitted(OperationContext* opCtx,
const SnapshotName& untilSnapshot) override;
virtual void appendConnectionStats(executor::ConnectionPoolStats* stats) const override;
@@ -622,7 +623,7 @@ private:
* operation timing to the caller.
*/
Status _awaitReplication_inlock(stdx::unique_lock<stdx::mutex>* lock,
- OperationContext* txn,
+ OperationContext* opCtx,
const OpTime& opTime,
SnapshotName minSnapshot,
const WriteConcernOptions& writeConcern);
@@ -793,7 +794,7 @@ private:
* config detected but more work is needed to set it as the local config (which will be
* handled by the callback to _finishLoadLocalConfig).
*/
- bool _startLoadLocalConfig(OperationContext* txn);
+ bool _startLoadLocalConfig(OperationContext* opCtx);
/**
* Callback that finishes the work started in _startLoadLocalConfig and sets _rsConfigState
@@ -807,13 +808,13 @@ private:
/**
* Start replicating data, and does an initial sync if needed first.
*/
- void _startDataReplication(OperationContext* txn,
+ void _startDataReplication(OperationContext* opCtx,
stdx::function<void()> startCompleted = nullptr);
/**
* Stops replicating data by stopping the applier, fetcher and such.
*/
- void _stopDataReplication(OperationContext* txn);
+ void _stopDataReplication(OperationContext* opCtx);
/**
* Finishes the work of processReplSetInitiate() while holding _topoMutex, in the event of
diff --git a/src/mongo/db/repl/replication_coordinator_impl_elect_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_elect_test.cpp
index 89325f7f424..5724fb43bf6 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_elect_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_elect_test.cpp
@@ -157,15 +157,15 @@ TEST_F(ReplCoordElectTest, ElectionSucceedsWhenNodeIsTheOnlyElectableNode) {
<< getReplCoord()->getMemberState().toString();
ASSERT(getReplCoord()->getApplierState() == ReplicationCoordinator::ApplierState::Draining);
- const auto txnPtr = makeOperationContext();
- auto& txn = *txnPtr;
+ const auto opCtxPtr = makeOperationContext();
+ auto& opCtx = *opCtxPtr;
// Since we're still in drain mode, expect that we report ismaster: false, issecondary:true.
IsMasterResponse imResponse;
getReplCoord()->fillIsMasterForReplSet(&imResponse);
ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
- getReplCoord()->signalDrainComplete(&txn, getReplCoord()->getTerm());
+ getReplCoord()->signalDrainComplete(&opCtx, getReplCoord()->getTerm());
getReplCoord()->fillIsMasterForReplSet(&imResponse);
ASSERT_TRUE(imResponse.isMaster()) << imResponse.toBSON().toString();
ASSERT_FALSE(imResponse.isSecondary()) << imResponse.toBSON().toString();
@@ -191,15 +191,15 @@ TEST_F(ReplCoordElectTest, ElectionSucceedsWhenNodeIsTheOnlyNode) {
<< getReplCoord()->getMemberState().toString();
ASSERT(getReplCoord()->getApplierState() == ReplicationCoordinator::ApplierState::Draining);
- const auto txnPtr = makeOperationContext();
- auto& txn = *txnPtr;
+ const auto opCtxPtr = makeOperationContext();
+ auto& opCtx = *opCtxPtr;
// Since we're still in drain mode, expect that we report ismaster: false, issecondary:true.
IsMasterResponse imResponse;
getReplCoord()->fillIsMasterForReplSet(&imResponse);
ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
- getReplCoord()->signalDrainComplete(&txn, getReplCoord()->getTerm());
+ getReplCoord()->signalDrainComplete(&opCtx, getReplCoord()->getTerm());
getReplCoord()->fillIsMasterForReplSet(&imResponse);
ASSERT_TRUE(imResponse.isMaster()) << imResponse.toBSON().toString();
ASSERT_FALSE(imResponse.isSecondary()) << imResponse.toBSON().toString();
@@ -218,7 +218,7 @@ TEST_F(ReplCoordElectTest, ElectionSucceedsWhenAllNodesVoteYea) {
<< BSON("_id" << 3 << "host"
<< "node3:12345")));
assertStartSuccess(configObj, HostAndPort("node1", 12345));
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
getReplCoord()->setMyLastAppliedOpTime(OpTime{{100, 1}, 0});
getExternalState()->setLastOpTime(OpTime{{100, 1}, 0});
@@ -246,7 +246,7 @@ TEST_F(ReplCoordElectTest, ElectionFailsWhenOneNodeVotesNay) {
assertStartSuccess(configObj, HostAndPort("node1", 12345));
ReplSetConfig config = assertMakeRSConfig(configObj);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime time1(Timestamp(100, 1), 0);
getReplCoord()->setMyLastAppliedOpTime(time1);
ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -293,7 +293,7 @@ TEST_F(ReplCoordElectTest, VotesWithStringValuesAreNotCountedAsYeas) {
assertStartSuccess(configObj, HostAndPort("node1", 12345));
ReplSetConfig config = assertMakeRSConfig(configObj);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime time1(Timestamp(100, 1), 0);
getReplCoord()->setMyLastAppliedOpTime(time1);
ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -341,7 +341,7 @@ TEST_F(ReplCoordElectTest, ElectionsAbortWhenNodeTransitionsToRollbackState) {
assertStartSuccess(configObj, HostAndPort("node1", 12345));
ReplSetConfig config = assertMakeRSConfig(configObj);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime time1(Timestamp(100, 1), 0);
getReplCoord()->setMyLastAppliedOpTime(time1);
ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -363,7 +363,7 @@ TEST_F(ReplCoordElectTest, ElectionsAbortWhenNodeTransitionsToRollbackState) {
TEST_F(ReplCoordElectTest, NodeWillNotStandForElectionDuringHeartbeatReconfig) {
// start up, receive reconfig via heartbeat while at the same time, become candidate.
// candidate state should be cleared.
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
assertStartSuccess(BSON("_id"
<< "mySet"
<< "version"
@@ -419,7 +419,7 @@ TEST_F(ReplCoordElectTest, NodeWillNotStandForElectionDuringHeartbeatReconfig) {
args.force = false;
args.newConfigObj = config.toBSON();
ASSERT_EQUALS(ErrorCodes::ConfigurationInProgress,
- getReplCoord()->processReplSetReconfig(&txn, args, &result));
+ getReplCoord()->processReplSetReconfig(&opCtx, args, &result));
logger::globalLogDomain()->setMinimumLoggedSeverity(logger::LogSeverity::Debug(2));
startCapturingLogMessages();
@@ -477,7 +477,7 @@ TEST_F(ReplCoordElectTest, StepsDownRemoteIfNodeHasHigherPriorityThanCurrentPrim
auto replCoord = getReplCoord();
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime time1(Timestamp(100, 1), 0);
getReplCoord()->setMyLastAppliedOpTime(time1);
ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -583,8 +583,8 @@ TEST_F(ReplCoordElectTest, NodeCancelsElectionUponReceivingANewConfigDuringFresh
true};
BSONObjBuilder result;
- const auto txn = makeOperationContext();
- ASSERT_OK(getReplCoord()->processReplSetReconfig(txn.get(), config, &result));
+ const auto opCtx = makeOperationContext();
+ ASSERT_OK(getReplCoord()->processReplSetReconfig(opCtx.get(), config, &result));
// Wait until election cancels.
net->enterNetwork();
net->runReadyNetworkOperations();
@@ -629,8 +629,8 @@ TEST_F(ReplCoordElectTest, NodeCancelsElectionUponReceivingANewConfigDuringElect
true};
BSONObjBuilder result;
- const auto txn = makeOperationContext();
- ASSERT_OK(getReplCoord()->processReplSetReconfig(txn.get(), config, &result));
+ const auto opCtx = makeOperationContext();
+ ASSERT_OK(getReplCoord()->processReplSetReconfig(opCtx.get(), config, &result));
// Wait until election cancels.
getNet()->enterNetwork();
getNet()->runReadyNetworkOperations();
diff --git a/src/mongo/db/repl/replication_coordinator_impl_elect_v1.cpp b/src/mongo/db/repl/replication_coordinator_impl_elect_v1.cpp
index 4484e3beead..e5d2dc214f7 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_elect_v1.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_elect_v1.cpp
@@ -210,9 +210,9 @@ void ReplicationCoordinatorImpl::_writeLastVoteForMyElection(
if (cbData.status == ErrorCodes::CallbackCanceled) {
return;
}
- invariant(cbData.txn);
+ invariant(cbData.opCtx);
- Status status = _externalState->storeLocalLastVoteDocument(cbData.txn, lastVote);
+ Status status = _externalState->storeLocalLastVoteDocument(cbData.opCtx, lastVote);
if (!status.isOK()) {
error() << "failed to store LastVote document when voting for myself: " << status;
return;
diff --git a/src/mongo/db/repl/replication_coordinator_impl_elect_v1_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_elect_v1_test.cpp
index e3660682e3c..be2370b7108 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_elect_v1_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_elect_v1_test.cpp
@@ -162,15 +162,15 @@ TEST_F(ReplCoordTest, ElectionSucceedsWhenNodeIsTheOnlyElectableNode) {
simulateCatchUpTimeout();
ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
- const auto txnPtr = makeOperationContext();
- auto& txn = *txnPtr;
+ const auto opCtxPtr = makeOperationContext();
+ auto& opCtx = *opCtxPtr;
// Since we're still in drain mode, expect that we report ismaster: false, issecondary:true.
IsMasterResponse imResponse;
getReplCoord()->fillIsMasterForReplSet(&imResponse);
ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
- getReplCoord()->signalDrainComplete(&txn, getReplCoord()->getTerm());
+ getReplCoord()->signalDrainComplete(&opCtx, getReplCoord()->getTerm());
getReplCoord()->fillIsMasterForReplSet(&imResponse);
ASSERT_TRUE(imResponse.isMaster()) << imResponse.toBSON().toString();
ASSERT_FALSE(imResponse.isSecondary()) << imResponse.toBSON().toString();
@@ -226,15 +226,15 @@ TEST_F(ReplCoordTest, ElectionSucceedsWhenNodeIsTheOnlyNode) {
simulateCatchUpTimeout();
ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
- const auto txnPtr = makeOperationContext();
- auto& txn = *txnPtr;
+ const auto opCtxPtr = makeOperationContext();
+ auto& opCtx = *opCtxPtr;
// Since we're still in drain mode, expect that we report ismaster: false, issecondary:true.
IsMasterResponse imResponse;
getReplCoord()->fillIsMasterForReplSet(&imResponse);
ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
- getReplCoord()->signalDrainComplete(&txn, getReplCoord()->getTerm());
+ getReplCoord()->signalDrainComplete(&opCtx, getReplCoord()->getTerm());
getReplCoord()->fillIsMasterForReplSet(&imResponse);
ASSERT_TRUE(imResponse.isMaster()) << imResponse.toBSON().toString();
ASSERT_FALSE(imResponse.isSecondary()) << imResponse.toBSON().toString();
@@ -255,7 +255,7 @@ TEST_F(ReplCoordTest, ElectionSucceedsWhenAllNodesVoteYea) {
<< "protocolVersion"
<< 1);
assertStartSuccess(configObj, HostAndPort("node1", 12345));
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
getReplCoord()->setMyLastAppliedOpTime(OpTime(Timestamp(100, 1), 0));
getReplCoord()->setMyLastDurableOpTime(OpTime(Timestamp(100, 1), 0));
ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -296,7 +296,7 @@ TEST_F(ReplCoordTest, ElectionSucceedsWhenMaxSevenNodesVoteYea) {
<< "protocolVersion"
<< 1);
assertStartSuccess(configObj, HostAndPort("node1", 12345));
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
getReplCoord()->setMyLastAppliedOpTime(OpTime(Timestamp(100, 1), 0));
getReplCoord()->setMyLastDurableOpTime(OpTime(Timestamp(100, 1), 0));
ASSERT(getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY));
@@ -332,7 +332,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenInsufficientVotesAreReceivedDuringDryRun)
assertStartSuccess(configObj, HostAndPort("node1", 12345));
ReplSetConfig config = assertMakeRSConfig(configObj);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime time1(Timestamp(100, 1), 0);
getReplCoord()->setMyLastAppliedOpTime(time1);
getReplCoord()->setMyLastDurableOpTime(time1);
@@ -391,7 +391,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenDryRunResponseContainsANewerTerm) {
assertStartSuccess(configObj, HostAndPort("node1", 12345));
ReplSetConfig config = assertMakeRSConfig(configObj);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime time1(Timestamp(100, 1), 0);
getReplCoord()->setMyLastAppliedOpTime(time1);
getReplCoord()->setMyLastDurableOpTime(time1);
@@ -439,7 +439,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenDryRunResponseContainsANewerTerm) {
TEST_F(ReplCoordTest, NodeWillNotStandForElectionDuringHeartbeatReconfig) {
// start up, receive reconfig via heartbeat while at the same time, become candidate.
// candidate state should be cleared.
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
assertStartSuccess(BSON("_id"
<< "mySet"
<< "version"
@@ -497,7 +497,7 @@ TEST_F(ReplCoordTest, NodeWillNotStandForElectionDuringHeartbeatReconfig) {
args.force = false;
args.newConfigObj = config.toBSON();
ASSERT_EQUALS(ErrorCodes::ConfigurationInProgress,
- getReplCoord()->processReplSetReconfig(&txn, args, &result));
+ getReplCoord()->processReplSetReconfig(&opCtx, args, &result));
logger::globalLogDomain()->setMinimumLoggedSeverity(logger::LogSeverity::Debug(2));
startCapturingLogMessages();
@@ -568,7 +568,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenInsufficientVotesAreReceivedDuringRequest
assertStartSuccess(configObj, HostAndPort("node1", 12345));
ReplSetConfig config = assertMakeRSConfig(configObj);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime time1(Timestamp(100, 1), 0);
getReplCoord()->setMyLastAppliedOpTime(time1);
getReplCoord()->setMyLastDurableOpTime(time1);
@@ -619,7 +619,7 @@ TEST_F(ReplCoordTest, ElectionsAbortWhenNodeTransitionsToRollbackState) {
assertStartSuccess(configObj, HostAndPort("node1", 12345));
ReplSetConfig config = assertMakeRSConfig(configObj);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime time1(Timestamp(100, 1), 0);
getReplCoord()->setMyLastAppliedOpTime(time1);
getReplCoord()->setMyLastDurableOpTime(time1);
@@ -657,7 +657,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenVoteRequestResponseContainsANewerTerm) {
assertStartSuccess(configObj, HostAndPort("node1", 12345));
ReplSetConfig config = assertMakeRSConfig(configObj);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime time1(Timestamp(100, 1), 0);
getReplCoord()->setMyLastAppliedOpTime(time1);
getReplCoord()->setMyLastDurableOpTime(time1);
@@ -713,7 +713,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenTermChangesDuringDryRun) {
assertStartSuccess(configObj, HostAndPort("node1", 12345));
ReplSetConfig config = assertMakeRSConfig(configObj);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime time1(Timestamp(100, 1), 0);
getReplCoord()->setMyLastAppliedOpTime(time1);
getReplCoord()->setMyLastDurableOpTime(time1);
@@ -752,7 +752,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenTermChangesDuringActualElection) {
assertStartSuccess(configObj, HostAndPort("node1", 12345));
ReplSetConfig config = assertMakeRSConfig(configObj);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime time1(Timestamp(100, 1), 0);
getReplCoord()->setMyLastAppliedOpTime(time1);
getReplCoord()->setMyLastDurableOpTime(time1);
@@ -761,7 +761,7 @@ TEST_F(ReplCoordTest, ElectionFailsWhenTermChangesDuringActualElection) {
simulateEnoughHeartbeatsForAllNodesUp();
simulateSuccessfulDryRun();
// update to a future term before the election completes
- getReplCoord()->updateTerm(&txn, 1000);
+ getReplCoord()->updateTerm(&opCtx, 1000);
NetworkInterfaceMock* net = getNet();
net->enterNetwork();
@@ -942,7 +942,7 @@ TEST_F(PriorityTakeoverTest, SchedulesPriorityTakeoverIfNodeHasHigherPriorityTha
auto replCoord = getReplCoord();
auto now = getNet()->now();
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime myOptime(Timestamp(100, 1), 0);
replCoord->setMyLastAppliedOpTime(myOptime);
replCoord->setMyLastDurableOpTime(myOptime);
@@ -963,7 +963,7 @@ TEST_F(PriorityTakeoverTest, SchedulesPriorityTakeoverIfNodeHasHigherPriorityTha
assertValidTakeoverDelay(config, now, priorityTakeoverTime, 0);
// Also make sure that updating the term cancels the scheduled priority takeover.
- ASSERT_EQUALS(ErrorCodes::StaleTerm, replCoord->updateTerm(&txn, replCoord->getTerm() + 1));
+ ASSERT_EQUALS(ErrorCodes::StaleTerm, replCoord->updateTerm(&opCtx, replCoord->getTerm() + 1));
ASSERT_FALSE(replCoord->getPriorityTakeover_forTest());
}
@@ -989,7 +989,7 @@ TEST_F(PriorityTakeoverTest, SuccessfulPriorityTakeover) {
auto replCoord = getReplCoord();
auto now = getNet()->now();
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime myOptime(Timestamp(100, 1), 0);
replCoord->setMyLastAppliedOpTime(myOptime);
replCoord->setMyLastDurableOpTime(myOptime);
@@ -1043,7 +1043,7 @@ TEST_F(PriorityTakeoverTest, DontCallForPriorityTakeoverWhenLaggedSameSecond) {
auto timeZero = getNet()->now();
auto now = getNet()->now();
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime currentOpTime(Timestamp(100, 5000), 0);
OpTime behindOpTime(Timestamp(100, 3999), 0);
OpTime closeEnoughOpTime(Timestamp(100, 4000), 0);
@@ -1119,7 +1119,7 @@ TEST_F(PriorityTakeoverTest, DontCallForPriorityTakeoverWhenLaggedDifferentSecon
auto timeZero = getNet()->now();
auto now = getNet()->now();
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
OpTime currentOpTime(Timestamp(100, 0), 0);
OpTime behindOpTime(Timestamp(97, 0), 0);
OpTime closeEnoughOpTime(Timestamp(98, 0), 0);
@@ -1218,8 +1218,8 @@ TEST_F(ReplCoordTest, NodeCancelsElectionUponReceivingANewConfigDuringDryRun) {
true};
BSONObjBuilder result;
- const auto txn = makeOperationContext();
- ASSERT_OK(getReplCoord()->processReplSetReconfig(txn.get(), config, &result));
+ const auto opCtx = makeOperationContext();
+ ASSERT_OK(getReplCoord()->processReplSetReconfig(opCtx.get(), config, &result));
// Wait until election cancels.
net->enterNetwork();
net->runReadyNetworkOperations();
@@ -1264,8 +1264,8 @@ TEST_F(ReplCoordTest, NodeCancelsElectionUponReceivingANewConfigDuringVotePhase)
true};
BSONObjBuilder result;
- const auto txn = makeOperationContext();
- ASSERT_OK(getReplCoord()->processReplSetReconfig(txn.get(), config, &result));
+ const auto opCtx = makeOperationContext();
+ ASSERT_OK(getReplCoord()->processReplSetReconfig(opCtx.get(), config, &result));
// Wait until election cancels.
getNet()->enterNetwork();
getNet()->runReadyNetworkOperations();
@@ -1429,10 +1429,10 @@ TEST_F(PrimaryCatchUpTest, PrimaryDoNotNeedToCatchUp) {
ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
stopCapturingLogMessages();
ASSERT_EQUALS(1, countLogLinesContaining("My optime is most up-to-date, skipping catch-up"));
- auto txn = makeOperationContext();
- getReplCoord()->signalDrainComplete(txn.get(), getReplCoord()->getTerm());
- Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
- ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+ auto opCtx = makeOperationContext();
+ getReplCoord()->signalDrainComplete(opCtx.get(), getReplCoord()->getTerm());
+ Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+ ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
}
TEST_F(PrimaryCatchUpTest, PrimaryFreshnessScanTimeout) {
@@ -1453,10 +1453,10 @@ TEST_F(PrimaryCatchUpTest, PrimaryFreshnessScanTimeout) {
ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
stopCapturingLogMessages();
ASSERT_EQUALS(1, countLogLinesContaining("Could not access any nodes within timeout"));
- auto txn = makeOperationContext();
- getReplCoord()->signalDrainComplete(txn.get(), getReplCoord()->getTerm());
- Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
- ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+ auto opCtx = makeOperationContext();
+ getReplCoord()->signalDrainComplete(opCtx.get(), getReplCoord()->getTerm());
+ Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+ ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
}
TEST_F(PrimaryCatchUpTest, PrimaryCatchUpSucceeds) {
@@ -1483,10 +1483,10 @@ TEST_F(PrimaryCatchUpTest, PrimaryCatchUpSucceeds) {
ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
stopCapturingLogMessages();
ASSERT_EQUALS(1, countLogLinesContaining("Finished catch-up oplog after becoming primary."));
- auto txn = makeOperationContext();
- getReplCoord()->signalDrainComplete(txn.get(), getReplCoord()->getTerm());
- Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
- ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+ auto opCtx = makeOperationContext();
+ getReplCoord()->signalDrainComplete(opCtx.get(), getReplCoord()->getTerm());
+ Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+ ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
}
TEST_F(PrimaryCatchUpTest, PrimaryCatchUpTimeout) {
@@ -1507,10 +1507,10 @@ TEST_F(PrimaryCatchUpTest, PrimaryCatchUpTimeout) {
ASSERT(getReplCoord()->getApplierState() == ApplierState::Draining);
stopCapturingLogMessages();
ASSERT_EQUALS(1, countLogLinesContaining("Cannot catch up oplog after becoming primary"));
- auto txn = makeOperationContext();
- getReplCoord()->signalDrainComplete(txn.get(), getReplCoord()->getTerm());
- Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
- ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+ auto opCtx = makeOperationContext();
+ getReplCoord()->signalDrainComplete(opCtx.get(), getReplCoord()->getTerm());
+ Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+ ASSERT_TRUE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
}
TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringFreshnessScan) {
@@ -1536,9 +1536,9 @@ TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringFreshnessScan) {
ASSERT(getReplCoord()->getApplierState() == ApplierState::Running);
stopCapturingLogMessages();
ASSERT_EQUALS(1, countLogLinesContaining("Stopped transition to primary"));
- auto txn = makeOperationContext();
- Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
- ASSERT_FALSE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+ auto opCtx = makeOperationContext();
+ Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+ ASSERT_FALSE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
}
TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringCatchUp) {
@@ -1564,15 +1564,15 @@ TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringCatchUp) {
net->enterNetwork();
net->runReadyNetworkOperations();
net->exitNetwork();
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
// Simulate the applier signaling replCoord to exit drain mode.
// At this point, we see the stepdown and reset the states.
- getReplCoord()->signalDrainComplete(txn.get(), getReplCoord()->getTerm());
+ getReplCoord()->signalDrainComplete(opCtx.get(), getReplCoord()->getTerm());
ASSERT(getReplCoord()->getApplierState() == ApplierState::Running);
stopCapturingLogMessages();
ASSERT_EQUALS(1, countLogLinesContaining("Cannot catch up oplog after becoming primary"));
- Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
- ASSERT_FALSE(getReplCoord()->canAcceptWritesForDatabase(txn.get(), "test"));
+ Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+ ASSERT_FALSE(getReplCoord()->canAcceptWritesForDatabase(opCtx.get(), "test"));
}
TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringDrainMode) {
@@ -1618,15 +1618,15 @@ TEST_F(PrimaryCatchUpTest, PrimaryStepsDownDuringDrainMode) {
getNet()->scheduleResponse(noi, getNet()->now(), makeFreshnessScanResponse(OpTime()));
});
ASSERT(replCoord->getApplierState() == ApplierState::Draining);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
{
- Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
- ASSERT_FALSE(replCoord->canAcceptWritesForDatabase(txn.get(), "test"));
+ Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
+ ASSERT_FALSE(replCoord->canAcceptWritesForDatabase(opCtx.get(), "test"));
}
- replCoord->signalDrainComplete(txn.get(), replCoord->getTerm());
- Lock::GlobalLock lock(txn->lockState(), MODE_IX, 1);
+ replCoord->signalDrainComplete(opCtx.get(), replCoord->getTerm());
+ Lock::GlobalLock lock(opCtx->lockState(), MODE_IX, 1);
ASSERT(replCoord->getApplierState() == ApplierState::Stopped);
- ASSERT_TRUE(replCoord->canAcceptWritesForDatabase(txn.get(), "test"));
+ ASSERT_TRUE(replCoord->canAcceptWritesForDatabase(opCtx.get(), "test"));
}
} // namespace
diff --git a/src/mongo/db/repl/replication_coordinator_impl_heartbeat.cpp b/src/mongo/db/repl/replication_coordinator_impl_heartbeat.cpp
index 602f3cb5f40..db42e12f13d 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_heartbeat.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_heartbeat.cpp
@@ -385,7 +385,7 @@ void ReplicationCoordinatorImpl::_stepDownFinish(
LockGuard topoLock(_topoMutex);
- invariant(cbData.txn);
+ invariant(cbData.opCtx);
// TODO Add invariant that we've got global shared or global exclusive lock, when supported
// by lock manager.
stdx::unique_lock<stdx::mutex> lk(_mutex);
@@ -496,7 +496,7 @@ void ReplicationCoordinatorImpl::_heartbeatReconfigStore(
"it is invalid: "
<< myIndex.getStatus();
} else {
- Status status = _externalState->storeLocalConfigDocument(cbd.txn, newConfig.toBSON());
+ Status status = _externalState->storeLocalConfigDocument(cbd.opCtx, newConfig.toBSON());
lk.lock();
if (!status.isOK()) {
@@ -518,7 +518,7 @@ void ReplicationCoordinatorImpl::_heartbeatReconfigStore(
newConfig.getMemberAt(myIndex.getValue()).isArbiter();
if (!isArbiter && isFirstConfig) {
_externalState->startThreads(_settings);
- _startDataReplication(cbd.txn);
+ _startDataReplication(cbd.opCtx);
}
}
@@ -558,7 +558,7 @@ void ReplicationCoordinatorImpl::_heartbeatReconfigFinish(
invariant(!_rsConfig.isInitialized() ||
_rsConfig.getConfigVersion() < newConfig.getConfigVersion());
- if (_getMemberState_inlock().primary() && !cbData.txn) {
+ if (_getMemberState_inlock().primary() && !cbData.opCtx) {
// Not having an OperationContext in the CallbackData means we definitely aren't holding
// the global lock. Since we're primary and this reconfig could cause us to stepdown,
// reschedule this work with the global exclusive lock so the stepdown is safe.
diff --git a/src/mongo/db/repl/replication_coordinator_impl_heartbeat_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_heartbeat_test.cpp
index 69c9b6541c6..2aee49fd3e4 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_heartbeat_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_heartbeat_test.cpp
@@ -139,10 +139,10 @@ TEST_F(ReplCoordHBTest, NodeJoinsExistingReplSetWhenReceivingAConfigContainingTh
noi = net->getNextReadyRequest();
assertMemberState(MemberState::RS_STARTUP2);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
ReplSetConfig storedConfig;
ASSERT_OK(storedConfig.initialize(
- unittest::assertGet(getExternalState()->loadLocalConfigDocument(&txn))));
+ unittest::assertGet(getExternalState()->loadLocalConfigDocument(&opCtx))));
ASSERT_OK(storedConfig.validate());
ASSERT_EQUALS(3, storedConfig.getConfigVersion());
ASSERT_EQUALS(3, storedConfig.getNumMembers());
@@ -205,9 +205,9 @@ TEST_F(ReplCoordHBTest,
noi = net->getNextReadyRequest();
assertMemberState(MemberState::RS_STARTUP, "2");
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
- StatusWith<BSONObj> loadedConfig(getExternalState()->loadLocalConfigDocument(&txn));
+ StatusWith<BSONObj> loadedConfig(getExternalState()->loadLocalConfigDocument(&opCtx));
ASSERT_NOT_OK(loadedConfig.getStatus()) << loadedConfig.getValue();
exitNetwork();
}
diff --git a/src/mongo/db/repl/replication_coordinator_impl_heartbeat_v1_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_heartbeat_v1_test.cpp
index ccc53d0bff9..5f4101e9eb2 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_heartbeat_v1_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_heartbeat_v1_test.cpp
@@ -138,10 +138,10 @@ TEST_F(ReplCoordHBV1Test,
noi = net->getNextReadyRequest();
assertMemberState(MemberState::RS_STARTUP2);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
ReplSetConfig storedConfig;
ASSERT_OK(storedConfig.initialize(
- unittest::assertGet(getExternalState()->loadLocalConfigDocument(&txn))));
+ unittest::assertGet(getExternalState()->loadLocalConfigDocument(&opCtx))));
ASSERT_OK(storedConfig.validate());
ASSERT_EQUALS(3, storedConfig.getConfigVersion());
ASSERT_EQUALS(3, storedConfig.getNumMembers());
@@ -207,10 +207,10 @@ TEST_F(ReplCoordHBV1Test,
noi = net->getNextReadyRequest();
assertMemberState(MemberState::RS_ARBITER);
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
ReplSetConfig storedConfig;
ASSERT_OK(storedConfig.initialize(
- unittest::assertGet(getExternalState()->loadLocalConfigDocument(&txn))));
+ unittest::assertGet(getExternalState()->loadLocalConfigDocument(&opCtx))));
ASSERT_OK(storedConfig.validate());
ASSERT_EQUALS(3, storedConfig.getConfigVersion());
ASSERT_EQUALS(3, storedConfig.getNumMembers());
@@ -276,9 +276,9 @@ TEST_F(ReplCoordHBV1Test,
noi = net->getNextReadyRequest();
assertMemberState(MemberState::RS_STARTUP, "2");
- OperationContextNoop txn;
+ OperationContextNoop opCtx;
- StatusWith<BSONObj> loadedConfig(getExternalState()->loadLocalConfigDocument(&txn));
+ StatusWith<BSONObj> loadedConfig(getExternalState()->loadLocalConfigDocument(&opCtx));
ASSERT_NOT_OK(loadedConfig.getStatus()) << loadedConfig.getValue();
exitNetwork();
}
diff --git a/src/mongo/db/repl/replication_coordinator_impl_reconfig_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_reconfig_test.cpp
index 69c5f2c6fb9..926b4a47a0f 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_reconfig_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_reconfig_test.cpp
@@ -60,9 +60,9 @@ TEST_F(ReplCoordTest, NodeReturnsNotYetInitializedWhenReconfigReceivedPriorToIni
BSONObjBuilder result;
ReplSetReconfigArgs args;
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::NotYetInitialized,
- getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+ getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
ASSERT_TRUE(result.obj().isEmpty());
}
@@ -87,9 +87,9 @@ TEST_F(ReplCoordTest, NodeReturnsNotMasterWhenReconfigReceivedWhileSecondary) {
BSONObjBuilder result;
ReplSetReconfigArgs args;
args.force = false;
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::NotMaster,
- getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+ getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
ASSERT_TRUE(result.obj().isEmpty());
}
@@ -128,10 +128,10 @@ TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenReconfigReceivedWith
<< "node2:12345"
<< "arbiterOnly"
<< true)));
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
// ErrorCodes::BadValue should be propagated from ReplSetConfig::initialize()
ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
- getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+ getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
ASSERT_TRUE(result.obj().isEmpty());
}
@@ -165,9 +165,9 @@ TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenReconfigReceivedWith
<< BSON("_id" << 2 << "host"
<< "node2:12345")));
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
- getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+ getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
ASSERT_TRUE(result.obj().isEmpty());
}
@@ -205,9 +205,9 @@ TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenReconfigReceivedWith
<< "settings"
<< BSON("replicaSetId" << OID::gen()));
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::NewReplicaSetConfigurationIncompatible,
- getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+ getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
ASSERT_TRUE(result.obj().isEmpty());
}
@@ -242,18 +242,18 @@ TEST_F(ReplCoordTest,
<< BSON("_id" << 2 << "host"
<< "node2:12345")));
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::NewReplicaSetConfigurationIncompatible,
- getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+ getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
ASSERT_TRUE(result.obj().isEmpty());
}
void doReplSetInitiate(ReplicationCoordinatorImpl* replCoord,
Status* status,
- OperationContext* txn) {
+ OperationContext* opCtx) {
BSONObjBuilder garbage;
*status =
- replCoord->processReplSetInitiate(txn,
+ replCoord->processReplSetInitiate(opCtx,
BSON("_id"
<< "mySet"
<< "version"
@@ -268,7 +268,7 @@ void doReplSetInitiate(ReplicationCoordinatorImpl* replCoord,
void doReplSetReconfig(ReplicationCoordinatorImpl* replCoord,
Status* status,
- OperationContext* txn) {
+ OperationContext* opCtx) {
BSONObjBuilder garbage;
ReplSetReconfigArgs args;
args.force = false;
@@ -284,7 +284,7 @@ void doReplSetReconfig(ReplicationCoordinatorImpl* replCoord,
<< "node2:12345"
<< "priority"
<< 3)));
- *status = replCoord->processReplSetReconfig(txn, args, &garbage);
+ *status = replCoord->processReplSetReconfig(opCtx, args, &garbage);
}
TEST_F(ReplCoordTest,
@@ -307,8 +307,9 @@ TEST_F(ReplCoordTest,
simulateSuccessfulV1Election();
Status status(ErrorCodes::InternalError, "Not Set");
- const auto txn = makeOperationContext();
- stdx::thread reconfigThread(stdx::bind(doReplSetReconfig, getReplCoord(), &status, txn.get()));
+ const auto opCtx = makeOperationContext();
+ stdx::thread reconfigThread(
+ stdx::bind(doReplSetReconfig, getReplCoord(), &status, opCtx.get()));
NetworkInterfaceMock* net = getNet();
getNet()->enterNetwork();
@@ -350,8 +351,9 @@ TEST_F(ReplCoordTest, NodeReturnsOutOfDiskSpaceWhenSavingANewConfigFailsDuringRe
Status status(ErrorCodes::InternalError, "Not Set");
getExternalState()->setStoreLocalConfigDocumentStatus(
Status(ErrorCodes::OutOfDiskSpace, "The test set this"));
- const auto txn = makeOperationContext();
- stdx::thread reconfigThread(stdx::bind(doReplSetReconfig, getReplCoord(), &status, txn.get()));
+ const auto opCtx = makeOperationContext();
+ stdx::thread reconfigThread(
+ stdx::bind(doReplSetReconfig, getReplCoord(), &status, opCtx.get()));
replyToReceivedHeartbeat();
reconfigThread.join();
@@ -377,9 +379,10 @@ TEST_F(ReplCoordTest,
simulateSuccessfulV1Election();
Status status(ErrorCodes::InternalError, "Not Set");
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
// first reconfig
- stdx::thread reconfigThread(stdx::bind(doReplSetReconfig, getReplCoord(), &status, txn.get()));
+ stdx::thread reconfigThread(
+ stdx::bind(doReplSetReconfig, getReplCoord(), &status, opCtx.get()));
getNet()->enterNetwork();
getNet()->blackHole(getNet()->getNextReadyRequest());
getNet()->exitNetwork();
@@ -398,10 +401,10 @@ TEST_F(ReplCoordTest,
<< BSON("_id" << 2 << "host"
<< "node2:12345")));
ASSERT_EQUALS(ErrorCodes::ConfigurationInProgress,
- getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+ getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
ASSERT_TRUE(result.obj().isEmpty());
- shutdown(txn.get());
+ shutdown(opCtx.get());
reconfigThread.join();
}
@@ -415,8 +418,8 @@ TEST_F(ReplCoordTest, NodeReturnsConfigurationInProgressWhenReceivingAReconfigWh
// initiate
Status status(ErrorCodes::InternalError, "Not Set");
- const auto txn = makeOperationContext();
- stdx::thread initateThread(stdx::bind(doReplSetInitiate, getReplCoord(), &status, txn.get()));
+ const auto opCtx = makeOperationContext();
+ stdx::thread initateThread(stdx::bind(doReplSetInitiate, getReplCoord(), &status, opCtx.get()));
getNet()->enterNetwork();
getNet()->blackHole(getNet()->getNextReadyRequest());
getNet()->exitNetwork();
@@ -435,10 +438,10 @@ TEST_F(ReplCoordTest, NodeReturnsConfigurationInProgressWhenReceivingAReconfigWh
<< BSON("_id" << 2 << "host"
<< "node2:12345")));
ASSERT_EQUALS(ErrorCodes::ConfigurationInProgress,
- getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+ getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
ASSERT_TRUE(result.obj().isEmpty());
- shutdown(txn.get());
+ shutdown(opCtx.get());
initateThread.join();
}
@@ -462,8 +465,9 @@ TEST_F(ReplCoordTest, PrimaryNodeAcceptsNewConfigWhenReceivingAReconfigWithAComp
simulateSuccessfulV1Election();
Status status(ErrorCodes::InternalError, "Not Set");
- const auto txn = makeOperationContext();
- stdx::thread reconfigThread(stdx::bind(doReplSetReconfig, getReplCoord(), &status, txn.get()));
+ const auto opCtx = makeOperationContext();
+ stdx::thread reconfigThread(
+ stdx::bind(doReplSetReconfig, getReplCoord(), &status, opCtx.get()));
NetworkInterfaceMock* net = getNet();
getNet()->enterNetwork();
@@ -541,9 +545,9 @@ TEST_F(
ReplSetReconfigArgs args;
args.force = false;
args.newConfigObj = config.toBSON();
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::ConfigurationInProgress,
- getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+ getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
getExternalState()->setStoreLocalConfigDocumentToHang(false);
}
@@ -568,8 +572,9 @@ TEST_F(ReplCoordTest, NodeDoesNotAcceptHeartbeatReconfigWhileInTheMidstOfReconfi
// start reconfigThread
Status status(ErrorCodes::InternalError, "Not Set");
- const auto txn = makeOperationContext();
- stdx::thread reconfigThread(stdx::bind(doReplSetReconfig, getReplCoord(), &status, txn.get()));
+ const auto opCtx = makeOperationContext();
+ stdx::thread reconfigThread(
+ stdx::bind(doReplSetReconfig, getReplCoord(), &status, opCtx.get()));
// wait for reconfigThread to create network requests to ensure the replication coordinator
// is in state kConfigReconfiguring
@@ -609,7 +614,7 @@ TEST_F(ReplCoordTest, NodeDoesNotAcceptHeartbeatReconfigWhileInTheMidstOfReconfi
stopCapturingLogMessages();
ASSERT_EQUALS(
1, countLogLinesContaining("because already in the midst of a configuration process"));
- shutdown(txn.get());
+ shutdown(opCtx.get());
reconfigThread.join();
logger::globalLogDomain()->setMinimumLoggedSeverity(logger::LogSeverity::Log());
}
@@ -644,13 +649,13 @@ TEST_F(ReplCoordTest, NodeAcceptsConfigFromAReconfigWithForceTrueWhileNotPrimary
<< "node1:12345")
<< BSON("_id" << 2 << "host"
<< "node2:12345")));
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::NotMaster,
- getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+ getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
// forced should succeed
args.force = true;
- ASSERT_OK(getReplCoord()->processReplSetReconfig(txn.get(), args, &result));
+ ASSERT_OK(getReplCoord()->processReplSetReconfig(opCtx.get(), args, &result));
getReplCoord()->processReplSetGetConfig(&result);
// ensure forced reconfig results in a random larger version
diff --git a/src/mongo/db/repl/replication_coordinator_impl_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_test.cpp
index 3cb0d2d9e3b..ae8d5b5fe92 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_test.cpp
@@ -100,7 +100,7 @@ struct OpTimeWithTermOne {
Timestamp timestamp;
};
-void runSingleNodeElection(ServiceContext::UniqueOperationContext txn,
+void runSingleNodeElection(ServiceContext::UniqueOperationContext opCtx,
ReplicationCoordinatorImpl* replCoord,
executor::NetworkInterfaceMock* net) {
replCoord->setMyLastAppliedOpTime(OpTime(Timestamp(1, 0), 0));
@@ -116,15 +116,15 @@ void runSingleNodeElection(ServiceContext::UniqueOperationContext txn,
ASSERT(replCoord->getApplierState() == ReplicationCoordinator::ApplierState::Draining);
ASSERT(replCoord->getMemberState().primary()) << replCoord->getMemberState().toString();
- replCoord->signalDrainComplete(txn.get(), replCoord->getTerm());
+ replCoord->signalDrainComplete(opCtx.get(), replCoord->getTerm());
}
/**
* Helper that kills an operation, taking the necessary locks.
*/
-void killOperation(OperationContext* txn) {
- stdx::lock_guard<Client> lkClient(*txn->getClient());
- txn->getServiceContext()->killOperation(txn);
+void killOperation(OperationContext* opCtx) {
+ stdx::lock_guard<Client> lkClient(*opCtx->getClient());
+ opCtx->getServiceContext()->killOperation(opCtx);
}
TEST_F(ReplCoordTest, NodeEntersStartup2StateWhenStartingUpWithValidLocalConfig) {
@@ -202,10 +202,10 @@ TEST_F(ReplCoordTest, NodeEntersStartupStateWhenStartingUpWithNoLocalConfig) {
TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenInitiatedWithAnEmptyConfig) {
init("mySet");
start(HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
BSONObjBuilder result;
ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
- getReplCoord()->processReplSetInitiate(txn.get(), BSONObj(), &result));
+ getReplCoord()->processReplSetInitiate(opCtx.get(), BSONObj(), &result));
ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
}
@@ -215,12 +215,12 @@ TEST_F(ReplCoordTest,
start(HostAndPort("node1", 12345));
ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
// Starting uninitialized, show that we can perform the initiate behavior.
BSONObjBuilder result1;
ASSERT_OK(
- getReplCoord()->processReplSetInitiate(txn.get(),
+ getReplCoord()->processReplSetInitiate(opCtx.get(),
BSON("_id"
<< "mySet"
<< "version"
@@ -236,7 +236,7 @@ TEST_F(ReplCoordTest,
BSONObjBuilder result2;
ASSERT_EQUALS(
ErrorCodes::AlreadyInitialized,
- getReplCoord()->processReplSetInitiate(txn.get(),
+ getReplCoord()->processReplSetInitiate(opCtx.get(),
BSON("_id"
<< "mySet"
<< "version"
@@ -254,14 +254,14 @@ TEST_F(ReplCoordTest,
NodeReturnsInvalidReplicaSetConfigWhenInitiatingViaANodeThatCannotBecomePrimary) {
init("mySet");
start(HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
// Starting uninitialized, show that we can perform the initiate behavior.
BSONObjBuilder result1;
auto status =
- getReplCoord()->processReplSetInitiate(txn.get(),
+ getReplCoord()->processReplSetInitiate(opCtx.get(),
BSON("_id"
<< "mySet"
<< "version"
@@ -283,16 +283,16 @@ TEST_F(ReplCoordTest,
InitiateShouldSucceedWithAValidConfigEvenIfItHasFailedWithAnInvalidConfigPreviously) {
init("mySet");
start(HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
BSONObjBuilder result;
ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
- getReplCoord()->processReplSetInitiate(txn.get(), BSONObj(), &result));
+ getReplCoord()->processReplSetInitiate(opCtx.get(), BSONObj(), &result));
ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
// Having failed to initiate once, show that we can now initiate.
BSONObjBuilder result1;
ASSERT_OK(
- getReplCoord()->processReplSetInitiate(txn.get(),
+ getReplCoord()->processReplSetInitiate(opCtx.get(),
BSON("_id"
<< "mySet"
<< "version"
@@ -309,10 +309,10 @@ TEST_F(ReplCoordTest,
BSONObjBuilder result;
init("mySet");
start(HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(
ErrorCodes::InvalidReplicaSetConfig,
- getReplCoord()->processReplSetInitiate(txn.get(),
+ getReplCoord()->processReplSetInitiate(opCtx.get(),
BSON("_id"
<< "mySet"
<< "version"
@@ -326,9 +326,9 @@ TEST_F(ReplCoordTest,
void doReplSetInitiate(ReplicationCoordinatorImpl* replCoord, Status* status) {
BSONObjBuilder garbage;
auto client = getGlobalServiceContext()->makeClient("rsi");
- auto txn = client->makeOperationContext();
+ auto opCtx = client->makeOperationContext();
*status =
- replCoord->processReplSetInitiate(txn.get(),
+ replCoord->processReplSetInitiate(opCtx.get(),
BSON("_id"
<< "mySet"
<< "version"
@@ -411,13 +411,13 @@ TEST_F(ReplCoordTest,
NodeReturnsInvalidReplicaSetConfigWhenInitiatingWithAConfigWithAMismatchedSetName) {
init("mySet");
start(HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
BSONObjBuilder result1;
ASSERT_EQUALS(
ErrorCodes::InvalidReplicaSetConfig,
- getReplCoord()->processReplSetInitiate(txn.get(),
+ getReplCoord()->processReplSetInitiate(opCtx.get(),
BSON("_id"
<< "wrongSet"
<< "version"
@@ -432,11 +432,11 @@ TEST_F(ReplCoordTest,
TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenInitiatingWithAnEmptyConfig) {
init("mySet");
start(HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
BSONObjBuilder result1;
- auto status = getReplCoord()->processReplSetInitiate(txn.get(), BSONObj(), &result1);
+ auto status = getReplCoord()->processReplSetInitiate(opCtx.get(), BSONObj(), &result1);
ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig, status);
ASSERT_STRING_CONTAINS(status.reason(), "Missing expected field \"_id\"");
ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
@@ -445,12 +445,12 @@ TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenInitiatingWithAnEmpt
TEST_F(ReplCoordTest, NodeReturnsInvalidReplicaSetConfigWhenInitiatingWithoutAn_idField) {
init("mySet");
start(HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
BSONObjBuilder result1;
auto status = getReplCoord()->processReplSetInitiate(
- txn.get(),
+ opCtx.get(),
BSON("version" << 1 << "members" << BSON_ARRAY(BSON("_id" << 0 << "host"
<< "node1:12345"))),
&result1);
@@ -463,12 +463,12 @@ TEST_F(ReplCoordTest,
NodeReturnsInvalidReplicaSetConfigWhenInitiatingWithAConfigVersionNotEqualToOne) {
init("mySet");
start(HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
BSONObjBuilder result1;
auto status =
- getReplCoord()->processReplSetInitiate(txn.get(),
+ getReplCoord()->processReplSetInitiate(opCtx.get(),
BSON("_id"
<< "mySet"
<< "version"
@@ -485,13 +485,13 @@ TEST_F(ReplCoordTest,
TEST_F(ReplCoordTest, InitiateFailsWithoutReplSetFlag) {
init("");
start(HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
BSONObjBuilder result1;
ASSERT_EQUALS(
ErrorCodes::NoReplicationEnabled,
- getReplCoord()->processReplSetInitiate(txn.get(),
+ getReplCoord()->processReplSetInitiate(opCtx.get(),
BSON("_id"
<< "mySet"
<< "version"
@@ -506,7 +506,7 @@ TEST_F(ReplCoordTest, InitiateFailsWithoutReplSetFlag) {
TEST_F(ReplCoordTest, NodeReturnsOutOfDiskSpaceWhenInitiateCannotWriteConfigToDisk) {
init("mySet");
start(HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(MemberState::RS_STARTUP, getReplCoord()->getMemberState().s);
BSONObjBuilder result1;
@@ -514,7 +514,7 @@ TEST_F(ReplCoordTest, NodeReturnsOutOfDiskSpaceWhenInitiateCannotWriteConfigToDi
Status(ErrorCodes::OutOfDiskSpace, "The test set this"));
ASSERT_EQUALS(
ErrorCodes::OutOfDiskSpace,
- getReplCoord()->processReplSetInitiate(txn.get(),
+ getReplCoord()->processReplSetInitiate(opCtx.get(),
BSON("_id"
<< "mySet"
<< "version"
@@ -602,7 +602,7 @@ TEST_F(ReplCoordTest, RollBackIDShouldIncreaseByOneWhenIncrementRollbackIDIsCall
TEST_F(ReplCoordTest, NodeReturnsImmediatelyWhenAwaitReplicationIsRanAgainstAStandaloneNode) {
init("");
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
OpTimeWithTermOne time(100, 1);
@@ -613,7 +613,7 @@ TEST_F(ReplCoordTest, NodeReturnsImmediatelyWhenAwaitReplicationIsRanAgainstASta
// Because we didn't set ReplSettings.replSet, it will think we're a standalone so
// awaitReplication will always work.
ReplicationCoordinator::StatusAndDuration statusAndDur =
- getReplCoord()->awaitReplication(txn.get(), time, writeConcern);
+ getReplCoord()->awaitReplication(opCtx.get(), time, writeConcern);
ASSERT_OK(statusAndDur.status);
}
@@ -621,7 +621,7 @@ TEST_F(ReplCoordTest, NodeReturnsImmediatelyWhenAwaitReplicationIsRanAgainstAMas
ReplSettings settings;
settings.setMaster(true);
init(settings);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
OpTimeWithTermOne time(100, 1);
@@ -631,7 +631,7 @@ TEST_F(ReplCoordTest, NodeReturnsImmediatelyWhenAwaitReplicationIsRanAgainstAMas
writeConcern.wMode = WriteConcernOptions::kMajority;
// w:majority always works on master/slave
ReplicationCoordinator::StatusAndDuration statusAndDur =
- getReplCoord()->awaitReplication(txn.get(), time, writeConcern);
+ getReplCoord()->awaitReplication(opCtx.get(), time, writeConcern);
ASSERT_OK(statusAndDur.status);
}
@@ -655,7 +655,7 @@ TEST_F(ReplCoordTest, NodeReturnsNotMasterWhenRunningAwaitReplicationAgainstASec
<< 2))),
HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
OpTimeWithTermOne time(100, 1);
@@ -666,7 +666,7 @@ TEST_F(ReplCoordTest, NodeReturnsNotMasterWhenRunningAwaitReplicationAgainstASec
// Node should fail to awaitReplication when not primary.
ReplicationCoordinator::StatusAndDuration statusAndDur =
- getReplCoord()->awaitReplication(txn.get(), time, writeConcern);
+ getReplCoord()->awaitReplication(opCtx.get(), time, writeConcern);
ASSERT_EQUALS(ErrorCodes::PrimarySteppedDown, statusAndDur.status);
}
@@ -704,10 +704,10 @@ TEST_F(ReplCoordTest, NodeReturnsOkWhenRunningAwaitReplicationAgainstPrimaryWith
simulateSuccessfulV1Election();
ASSERT(getReplCoord()->getMemberState().primary());
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ReplicationCoordinator::StatusAndDuration statusAndDur =
- getReplCoord()->awaitReplication(txn.get(), time, writeConcern);
+ getReplCoord()->awaitReplication(opCtx.get(), time, writeConcern);
ASSERT_OK(statusAndDur.status);
}
@@ -748,47 +748,47 @@ TEST_F(ReplCoordTest,
writeConcern.wNumNodes = 1;
writeConcern.syncMode = WriteConcernOptions::SyncMode::JOURNAL;
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
// 1 node waiting for time 1
ReplicationCoordinator::StatusAndDuration statusAndDur =
- getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+ getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
getReplCoord()->setMyLastAppliedOpTime(time1);
getReplCoord()->setMyLastDurableOpTime(time1);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
ASSERT_OK(statusAndDur.status);
// 2 nodes waiting for time1
writeConcern.wNumNodes = 2;
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
// Applied is not durable and will not satisfy WriteConcern with SyncMode JOURNAL.
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time1));
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 1, time1));
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
ASSERT_OK(statusAndDur.status);
// 2 nodes waiting for time2
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
getReplCoord()->setMyLastAppliedOpTime(time2);
getReplCoord()->setMyLastDurableOpTime(time2);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 2, time2));
ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 2, time2));
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
ASSERT_OK(statusAndDur.status);
// 3 nodes waiting for time2
writeConcern.wNumNodes = 3;
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 3, time2));
ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 3, time2));
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
ASSERT_OK(statusAndDur.status);
}
@@ -827,44 +827,44 @@ TEST_F(ReplCoordTest, NodeReturnsWriteConcernFailedUntilASufficientNumberOfNodes
writeConcern.wTimeout = WriteConcernOptions::kNoWaiting;
writeConcern.wNumNodes = 1;
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
// 1 node waiting for time 1
ReplicationCoordinator::StatusAndDuration statusAndDur =
- getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+ getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
getReplCoord()->setMyLastAppliedOpTime(time1);
getReplCoord()->setMyLastDurableOpTime(time1);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
ASSERT_OK(statusAndDur.status);
// 2 nodes waiting for time1
writeConcern.wNumNodes = 2;
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time1));
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, writeConcern);
ASSERT_OK(statusAndDur.status);
// 2 nodes waiting for time2
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
getReplCoord()->setMyLastAppliedOpTime(time2);
getReplCoord()->setMyLastDurableOpTime(time2);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 2, time2));
ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 2, time2));
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
ASSERT_OK(statusAndDur.status);
// 3 nodes waiting for time2
writeConcern.wNumNodes = 3;
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 3, time2));
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, writeConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern);
ASSERT_OK(statusAndDur.status);
}
@@ -872,7 +872,7 @@ TEST_F(ReplCoordTest,
NodeReturnsUnknownReplWriteConcernWhenAwaitReplicationReceivesAnInvalidWriteConcernMode) {
auto service = stdx::make_unique<ServiceContextNoop>();
auto client = service->makeClient("test");
- auto txn = client->makeOperationContext();
+ auto opCtx = client->makeOperationContext();
assertStartSuccess(BSON("_id"
<< "mySet"
@@ -904,7 +904,7 @@ TEST_F(ReplCoordTest,
invalidWriteConcern.wMode = "fakemode";
ReplicationCoordinator::StatusAndDuration statusAndDur =
- getReplCoord()->awaitReplication(txn.get(), time1, invalidWriteConcern);
+ getReplCoord()->awaitReplication(opCtx.get(), time1, invalidWriteConcern);
ASSERT_EQUALS(ErrorCodes::UnknownReplWriteConcern, statusAndDur.status);
}
@@ -913,7 +913,7 @@ TEST_F(
NodeReturnsWriteConcernFailedUntilASufficientSetOfNodesHaveTheWriteAndTheWriteIsInACommittedSnapshot) {
auto service = stdx::make_unique<ServiceContextNoop>();
auto client = service->makeClient("test");
- auto txn = client->makeOperationContext();
+ auto opCtx = client->makeOperationContext();
assertStartSuccess(
BSON("_id"
@@ -988,11 +988,11 @@ TEST_F(
getReplCoord()->setMyLastAppliedOpTime(time1);
getReplCoord()->setMyLastDurableOpTime(time1);
ReplicationCoordinator::StatusAndDuration statusAndDur =
- getReplCoord()->awaitReplication(txn.get(), time1, majorityWriteConcern);
+ getReplCoord()->awaitReplication(opCtx.get(), time1, majorityWriteConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiDCWriteConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiDCWriteConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiRackWriteConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiRackWriteConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
// Majority satisfied but not either custom mode
@@ -1000,56 +1000,57 @@ TEST_F(
getReplCoord()->setLastDurableOptime_forTest(2, 1, time1);
getReplCoord()->setLastAppliedOptime_forTest(2, 2, time1);
getReplCoord()->setLastDurableOptime_forTest(2, 2, time1);
- getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, majorityWriteConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, majorityWriteConcern);
ASSERT_OK(statusAndDur.status);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiDCWriteConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiDCWriteConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiRackWriteConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiRackWriteConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
// All modes satisfied
getReplCoord()->setLastAppliedOptime_forTest(2, 3, time1);
getReplCoord()->setLastDurableOptime_forTest(2, 3, time1);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, majorityWriteConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, majorityWriteConcern);
ASSERT_OK(statusAndDur.status);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiDCWriteConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiDCWriteConcern);
ASSERT_OK(statusAndDur.status);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time1, multiRackWriteConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time1, multiRackWriteConcern);
ASSERT_OK(statusAndDur.status);
// Majority also waits for the committed snapshot to be newer than all snapshots reserved by
// this operation. Custom modes not affected by this.
- while (getReplCoord()->reserveSnapshotName(txn.get()) <= SnapshotName(1)) {
+ while (getReplCoord()->reserveSnapshotName(opCtx.get()) <= SnapshotName(1)) {
// These unittests "cheat" and use SnapshotName(1) without advancing the counter. Reserve
// another name if we didn't get a high enough one.
}
auto zeroOpTimeInCurrentTerm = OpTime(Timestamp(0, 0), 1);
- ReplClientInfo::forClient(txn.get()->getClient()).setLastOp(zeroOpTimeInCurrentTerm);
+ ReplClientInfo::forClient(opCtx.get()->getClient()).setLastOp(zeroOpTimeInCurrentTerm);
statusAndDur =
- getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), majorityWriteConcern);
+ getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), majorityWriteConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
statusAndDur =
- getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), multiDCWriteConcern);
+ getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), multiDCWriteConcern);
ASSERT_OK(statusAndDur.status);
statusAndDur =
- getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), multiRackWriteConcern);
+ getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), multiRackWriteConcern);
ASSERT_OK(statusAndDur.status);
// All modes satisfied
- getReplCoord()->createSnapshot(txn.get(), time1, getReplCoord()->reserveSnapshotName(nullptr));
+ getReplCoord()->createSnapshot(
+ opCtx.get(), time1, getReplCoord()->reserveSnapshotName(nullptr));
statusAndDur =
- getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), majorityWriteConcern);
+ getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), majorityWriteConcern);
ASSERT_OK(statusAndDur.status);
statusAndDur =
- getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), multiDCWriteConcern);
+ getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), multiDCWriteConcern);
ASSERT_OK(statusAndDur.status);
statusAndDur =
- getReplCoord()->awaitReplicationOfLastOpForClient(txn.get(), multiRackWriteConcern);
+ getReplCoord()->awaitReplicationOfLastOpForClient(opCtx.get(), multiRackWriteConcern);
ASSERT_OK(statusAndDur.status);
// multiDC satisfied but not majority or multiRack
@@ -1058,11 +1059,11 @@ TEST_F(
getReplCoord()->setLastAppliedOptime_forTest(2, 3, time2);
getReplCoord()->setLastDurableOptime_forTest(2, 3, time2);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, majorityWriteConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, majorityWriteConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, multiDCWriteConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, multiDCWriteConcern);
ASSERT_OK(statusAndDur.status);
- statusAndDur = getReplCoord()->awaitReplication(txn.get(), time2, multiRackWriteConcern);
+ statusAndDur = getReplCoord()->awaitReplication(opCtx.get(), time2, multiRackWriteConcern);
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed, statusAndDur.status);
}
@@ -1080,12 +1081,12 @@ public:
: _replCoord(replCoord),
_service(service),
_client(service->makeClient("replAwaiter")),
- _txn(_client->makeOperationContext()),
+ _opCtx(_client->makeOperationContext()),
_finished(false),
_result(ReplicationCoordinator::StatusAndDuration(Status::OK(), Milliseconds(0))) {}
OperationContext* getOperationContext() {
- return _txn.get();
+ return _opCtx.get();
}
void setOpTime(const OpTime& ot) {
@@ -1116,14 +1117,14 @@ public:
private:
void _awaitReplication() {
- _result = _replCoord->awaitReplication(_txn.get(), _optime, _writeConcern);
+ _result = _replCoord->awaitReplication(_opCtx.get(), _optime, _writeConcern);
_finished = true;
}
ReplicationCoordinatorImpl* _replCoord;
ServiceContext* _service;
ServiceContext::UniqueClient _client;
- ServiceContext::UniqueOperationContext _txn;
+ ServiceContext::UniqueOperationContext _opCtx;
bool _finished;
OpTime _optime;
WriteConcernOptions _writeConcern;
@@ -1286,8 +1287,8 @@ TEST_F(ReplCoordTest,
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time1));
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 2, time1));
{
- auto txn = makeOperationContext();
- shutdown(txn.get());
+ auto opCtx = makeOperationContext();
+ shutdown(opCtx.get());
}
ReplicationCoordinator::StatusAndDuration statusAndDur = awaiter.getResult();
ASSERT_EQUALS(ErrorCodes::ShutdownInProgress, statusAndDur.status);
@@ -1320,7 +1321,7 @@ TEST_F(ReplCoordTest, NodeReturnsNotMasterWhenSteppingDownBeforeSatisfyingAWrite
getReplCoord()->setMyLastDurableOpTime(OpTimeWithTermOne(100, 0));
simulateSuccessfulV1Election();
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
ReplicationAwaiter awaiter(getReplCoord(), getServiceContext());
OpTimeWithTermOne time1(100, 1);
@@ -1336,7 +1337,7 @@ TEST_F(ReplCoordTest, NodeReturnsNotMasterWhenSteppingDownBeforeSatisfyingAWrite
awaiter.start();
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time1));
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 2, time1));
- ASSERT_OK(getReplCoord()->stepDown(txn.get(), true, Milliseconds(0), Milliseconds(1000)));
+ ASSERT_OK(getReplCoord()->stepDown(opCtx.get(), true, Milliseconds(0), Milliseconds(1000)));
ReplicationCoordinator::StatusAndDuration statusAndDur = awaiter.getResult();
ASSERT_EQUALS(ErrorCodes::PrimarySteppedDown, statusAndDur.status);
awaiter.reset();
@@ -1391,11 +1392,11 @@ protected:
static SharedClientAndOperation make(ServiceContext* serviceContext) {
SharedClientAndOperation result;
result.client = serviceContext->makeClient("StepDownThread");
- result.txn = result.client->makeOperationContext();
+ result.opCtx = result.client->makeOperationContext();
return result;
}
std::shared_ptr<Client> client;
- std::shared_ptr<OperationContext> txn;
+ std::shared_ptr<OperationContext> opCtx;
};
std::pair<SharedClientAndOperation, stdx::future<boost::optional<Status>>> stepDown_nonBlocking(
@@ -1405,7 +1406,7 @@ protected:
[=](PromisedClientAndOperation operationPromise) -> boost::optional<Status> {
auto result = SharedClientAndOperation::make(getServiceContext());
operationPromise.set_value(result);
- return getReplCoord()->stepDown(result.txn.get(), force, waitTime, stepDownTime);
+ return getReplCoord()->stepDown(result.opCtx.get(), force, waitTime, stepDownTime);
});
auto result = task.get_future();
PromisedClientAndOperation operationPromise;
@@ -1443,9 +1444,9 @@ private:
TEST_F(ReplCoordTest, NodeReturnsBadValueWhenUpdateTermIsRunAgainstANonReplNode) {
init(ReplSettings());
ASSERT_TRUE(ReplicationCoordinator::modeNone == getReplCoord()->getReplicationMode());
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
- ASSERT_EQUALS(ErrorCodes::BadValue, getReplCoord()->updateTerm(txn.get(), 0).code());
+ ASSERT_EQUALS(ErrorCodes::BadValue, getReplCoord()->updateTerm(opCtx.get(), 0).code());
}
TEST_F(ReplCoordTest, NodeChangesTermAndStepsDownWhenAndOnlyWhenUpdateTermSuppliesAHigherTerm) {
@@ -1471,31 +1472,31 @@ TEST_F(ReplCoordTest, NodeChangesTermAndStepsDownWhenAndOnlyWhenUpdateTermSuppli
ASSERT_TRUE(getReplCoord()->getMemberState().secondary());
simulateSuccessfulV1Election();
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(1, getReplCoord()->getTerm());
ASSERT_TRUE(getReplCoord()->getMemberState().primary());
// lower term, no change
- ASSERT_OK(getReplCoord()->updateTerm(txn.get(), 0));
+ ASSERT_OK(getReplCoord()->updateTerm(opCtx.get(), 0));
ASSERT_EQUALS(1, getReplCoord()->getTerm());
ASSERT_TRUE(getReplCoord()->getMemberState().primary());
// same term, no change
- ASSERT_OK(getReplCoord()->updateTerm(txn.get(), 1));
+ ASSERT_OK(getReplCoord()->updateTerm(opCtx.get(), 1));
ASSERT_EQUALS(1, getReplCoord()->getTerm());
ASSERT_TRUE(getReplCoord()->getMemberState().primary());
// higher term, step down and change term
executor::TaskExecutor::CallbackHandle cbHandle;
- ASSERT_EQUALS(ErrorCodes::StaleTerm, getReplCoord()->updateTerm(txn.get(), 2).code());
+ ASSERT_EQUALS(ErrorCodes::StaleTerm, getReplCoord()->updateTerm(opCtx.get(), 2).code());
// Term hasn't been incremented yet, as we need another try to update it after stepdown.
ASSERT_EQUALS(1, getReplCoord()->getTerm());
ASSERT_TRUE(getReplCoord()->getMemberState().secondary());
// Now update term should actually update the term, as stepdown is complete.
- ASSERT_EQUALS(ErrorCodes::StaleTerm, getReplCoord()->updateTerm(txn.get(), 2).code());
+ ASSERT_EQUALS(ErrorCodes::StaleTerm, getReplCoord()->updateTerm(opCtx.get(), 2).code());
ASSERT_EQUALS(2, getReplCoord()->getTerm());
}
@@ -1576,7 +1577,7 @@ TEST_F(ReplCoordTest, ConcurrentStepDownShouldNotSignalTheSameFinishEventMoreTha
}
TEST_F(StepDownTest, NodeReturnsNotMasterWhenAskedToStepDownAsANonPrimaryNode) {
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
OpTimeWithTermOne optime1(100, 1);
// All nodes are caught up
@@ -1585,7 +1586,7 @@ TEST_F(StepDownTest, NodeReturnsNotMasterWhenAskedToStepDownAsANonPrimaryNode) {
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(1, 1, optime1));
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(1, 2, optime1));
- Status status = getReplCoord()->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(0));
+ Status status = getReplCoord()->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(0));
ASSERT_EQUALS(ErrorCodes::NotMaster, status);
ASSERT_TRUE(getReplCoord()->getMemberState().secondary());
}
@@ -1601,12 +1602,13 @@ TEST_F(StepDownTest,
simulateSuccessfulV1Election();
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
// Make sure stepDown cannot grab the global shared lock
- Lock::GlobalWrite lk(txn->lockState());
+ Lock::GlobalWrite lk(opCtx->lockState());
- Status status = getReplCoord()->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(1000));
+ Status status =
+ getReplCoord()->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(1000));
ASSERT_EQUALS(ErrorCodes::ExceededTimeLimit, status);
ASSERT_TRUE(getReplCoord()->getMemberState().primary());
}
@@ -1710,10 +1712,10 @@ TEST_F(
getNet()->runReadyNetworkOperations();
exitNetwork();
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
ASSERT_TRUE(getReplCoord()->getMemberState().primary());
- auto status = getReplCoord()->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(1000));
+ auto status = getReplCoord()->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(1000));
ASSERT_EQUALS(ErrorCodes::ExceededTimeLimit, status);
ASSERT_TRUE(getReplCoord()->getMemberState().primary());
}
@@ -1744,10 +1746,10 @@ TEST_F(StepDownTestFiveNode,
getNet()->runReadyNetworkOperations();
exitNetwork();
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
ASSERT_TRUE(getReplCoord()->getMemberState().primary());
- auto status = getReplCoord()->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(1000));
+ auto status = getReplCoord()->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(1000));
ASSERT_EQUALS(ErrorCodes::ExceededTimeLimit, status);
ASSERT_TRUE(getReplCoord()->getMemberState().primary());
}
@@ -1779,10 +1781,10 @@ TEST_F(
getNet()->runReadyNetworkOperations();
exitNetwork();
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
ASSERT_TRUE(getReplCoord()->getMemberState().primary());
- ASSERT_OK(getReplCoord()->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(1000)));
+ ASSERT_OK(getReplCoord()->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(1000)));
enterNetwork(); // So we can safely inspect the topology coordinator
ASSERT_EQUALS(getNet()->now() + Seconds(1), getTopoCoord().getStepDownTime());
ASSERT_TRUE(getTopoCoord().getMemberState().secondary());
@@ -1802,9 +1804,9 @@ TEST_F(ReplCoordTest, NodeBecomesPrimaryAgainWhenStepDownTimeoutExpiresInASingle
<< "test1:1234"))),
HostAndPort("test1", 1234));
runSingleNodeElection(makeOperationContext(), getReplCoord(), getNet());
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
- ASSERT_OK(getReplCoord()->stepDown(txn.get(), true, Milliseconds(0), Milliseconds(1000)));
+ ASSERT_OK(getReplCoord()->stepDown(opCtx.get(), true, Milliseconds(0), Milliseconds(1000)));
getNet()->enterNetwork(); // Must do this before inspecting the topocoord
Date_t stepdownUntil = getNet()->now() + Seconds(1);
ASSERT_EQUALS(stepdownUntil, getTopoCoord().getStepDownTime());
@@ -1833,10 +1835,10 @@ TEST_F(StepDownTest,
simulateSuccessfulV1Election();
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
// Try to stepDown but time out because no secondaries are caught up.
- auto status = repl->stepDown(txn.get(), false, Milliseconds(0), Milliseconds(1000));
+ auto status = repl->stepDown(opCtx.get(), false, Milliseconds(0), Milliseconds(1000));
ASSERT_EQUALS(ErrorCodes::ExceededTimeLimit, status);
ASSERT_TRUE(repl->getMemberState().primary());
@@ -1851,7 +1853,7 @@ TEST_F(StepDownTest,
}
getNet()->exitNetwork();
ASSERT_TRUE(repl->getMemberState().primary());
- status = repl->stepDown(txn.get(), true, Milliseconds(0), Milliseconds(1000));
+ status = repl->stepDown(opCtx.get(), true, Milliseconds(0), Milliseconds(1000));
ASSERT_OK(status);
ASSERT_TRUE(repl->getMemberState().secondary());
}
@@ -2004,7 +2006,7 @@ TEST_F(StepDownTest, NodeReturnsInterruptedWhenInterruptedDuringStepDown) {
// stepDown where the secondary actually has to catch up before the stepDown can succeed.
auto result = stepDown_nonBlocking(false, Seconds(10), Seconds(60));
- killOperation(result.first.txn.get());
+ killOperation(result.first.opCtx.get());
ASSERT_EQUALS(ErrorCodes::Interrupted, *result.second.get());
ASSERT_TRUE(repl->getMemberState().primary());
}
@@ -2347,11 +2349,11 @@ TEST_F(ReplCoordTest, DoNotAllowMaintenanceModeWhilePrimary) {
ASSERT_EQUALS(ErrorCodes::NotSecondary, status);
ASSERT_TRUE(getReplCoord()->getMemberState().primary());
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
// Step down from primary.
- getReplCoord()->updateTerm(txn.get(), getReplCoord()->getTerm() + 1);
+ getReplCoord()->updateTerm(opCtx.get(), getReplCoord()->getTerm() + 1);
ASSERT_OK(getReplCoord()->waitForMemberState(MemberState::RS_SECONDARY, Seconds(1)));
status = getReplCoord()->setMaintenanceMode(false);
@@ -2383,11 +2385,11 @@ TEST_F(ReplCoordTest, DoNotAllowSettingMaintenanceModeWhileConductingAnElection)
// TODO this election shouldn't have to happen.
simulateSuccessfulV1Election();
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
// Step down from primary.
- getReplCoord()->updateTerm(txn.get(), getReplCoord()->getTerm() + 1);
+ getReplCoord()->updateTerm(opCtx.get(), getReplCoord()->getTerm() + 1);
getReplCoord()->waitForMemberState(MemberState::RS_SECONDARY, Milliseconds(10 * 1000));
// Can't modify maintenance mode when running for election (before and after dry run).
@@ -2514,7 +2516,7 @@ TEST_F(ReplCoordTest, NodeDoesNotIncludeItselfWhenRunningGetHostsWrittenToInMast
settings.setMaster(true);
init(settings);
HostAndPort clientHost("node2:12345");
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
OID client = OID::gen();
@@ -2524,7 +2526,7 @@ TEST_F(ReplCoordTest, NodeDoesNotIncludeItselfWhenRunningGetHostsWrittenToInMast
getExternalState()->setClientHostAndPort(clientHost);
HandshakeArgs handshake;
ASSERT_OK(handshake.initialize(BSON("handshake" << client)));
- ASSERT_OK(getReplCoord()->processHandshake(txn.get(), handshake));
+ ASSERT_OK(getReplCoord()->processHandshake(opCtx.get(), handshake));
getReplCoord()->setMyLastAppliedOpTime(time2);
getReplCoord()->setMyLastDurableOpTime(time2);
@@ -2675,11 +2677,11 @@ TEST_F(ReplCoordTest, IsMasterWithCommittedSnapshot) {
time_t majorityWriteDate = 100;
OpTime majorityOpTime = OpTime(Timestamp(majorityWriteDate, 1), 1);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
getReplCoord()->setMyLastAppliedOpTime(opTime);
getReplCoord()->setMyLastDurableOpTime(opTime);
- getReplCoord()->createSnapshot(txn.get(), majorityOpTime, SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), majorityOpTime, SnapshotName(1));
ASSERT_EQUALS(majorityOpTime, getReplCoord()->getCurrentCommittedSnapshotOpTime());
IsMasterResponse response;
@@ -2695,8 +2697,8 @@ TEST_F(ReplCoordTest, LogAMessageWhenShutDownBeforeReplicationStartUpFinished) {
init();
startCapturingLogMessages();
{
- auto txn = makeOperationContext();
- getReplCoord()->shutdown(txn.get());
+ auto opCtx = makeOperationContext();
+ getReplCoord()->shutdown(opCtx.get());
}
stopCapturingLogMessages();
ASSERT_EQUALS(1, countLogLinesContaining("shutdown() called before startup() finished"));
@@ -2735,11 +2737,11 @@ TEST_F(ReplCoordTest, DoNotProcessSelfWhenUpdatePositionContainsInfoAboutSelf) {
writeConcern.wTimeout = WriteConcernOptions::kNoWaiting;
writeConcern.wNumNodes = 1;
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
// receive updatePosition containing ourself, should not process the update for self
UpdatePositionArgs args;
@@ -2757,7 +2759,7 @@ TEST_F(ReplCoordTest, DoNotProcessSelfWhenUpdatePositionContainsInfoAboutSelf) {
ASSERT_OK(getReplCoord()->processReplSetUpdatePosition(args, 0));
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
}
TEST_F(ReplCoordTest, DoNotProcessSelfWhenOldUpdatePositionContainsInfoAboutSelf) {
@@ -2794,11 +2796,11 @@ TEST_F(ReplCoordTest, DoNotProcessSelfWhenOldUpdatePositionContainsInfoAboutSelf
writeConcern.wTimeout = WriteConcernOptions::kNoWaiting;
writeConcern.wNumNodes = 1;
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
// receive updatePosition containing ourself, should not process the update for self
OldUpdatePositionArgs args;
@@ -2814,7 +2816,7 @@ TEST_F(ReplCoordTest, DoNotProcessSelfWhenOldUpdatePositionContainsInfoAboutSelf
ASSERT_OK(getReplCoord()->processReplSetUpdatePosition(args, 0));
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
}
TEST_F(ReplCoordTest, DoNotProcessUpdatePositionWhenItsConfigVersionIsIncorrect) {
@@ -2864,14 +2866,14 @@ TEST_F(ReplCoordTest, DoNotProcessUpdatePositionWhenItsConfigVersionIsIncorrect)
<< UpdatePositionArgs::kAppliedOpTimeFieldName
<< time2.toBSON())))));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
long long cfgver;
ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
getReplCoord()->processReplSetUpdatePosition(args, &cfgver));
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
}
TEST_F(ReplCoordTest, DoNotProcessOldUpdatePositionWhenItsConfigVersionIsIncorrect) {
@@ -2920,14 +2922,14 @@ TEST_F(ReplCoordTest, DoNotProcessOldUpdatePositionWhenItsConfigVersionIsIncorre
<< OldUpdatePositionArgs::kOpTimeFieldName
<< time2.timestamp)))));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
long long cfgver;
ASSERT_EQUALS(ErrorCodes::InvalidReplicaSetConfig,
getReplCoord()->processReplSetUpdatePosition(args, &cfgver));
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
}
TEST_F(ReplCoordTest, DoNotProcessUpdatePositionOfMembersWhoseIdsAreNotInTheConfig) {
@@ -2977,12 +2979,12 @@ TEST_F(ReplCoordTest, DoNotProcessUpdatePositionOfMembersWhoseIdsAreNotInTheConf
<< UpdatePositionArgs::kAppliedOpTimeFieldName
<< time2.toBSON())))));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::NodeNotFound, getReplCoord()->processReplSetUpdatePosition(args, 0));
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
}
TEST_F(ReplCoordTest, DoNotProcessOldUpdatePositionOfMembersWhoseIdsAreNotInTheConfig) {
@@ -3031,12 +3033,12 @@ TEST_F(ReplCoordTest, DoNotProcessOldUpdatePositionOfMembersWhoseIdsAreNotInTheC
<< OldUpdatePositionArgs::kOpTimeFieldName
<< time2.timestamp)))));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::NodeNotFound, getReplCoord()->processReplSetUpdatePosition(args, 0));
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
}
TEST_F(ReplCoordTest,
@@ -3095,19 +3097,19 @@ TEST_F(ReplCoordTest,
<< OldUpdatePositionArgs::kOpTimeFieldName
<< time2.timestamp)))));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_OK(getReplCoord()->processReplSetUpdatePosition(args, 0));
- ASSERT_OK(getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+ ASSERT_OK(getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
writeConcern.wNumNodes = 3;
- ASSERT_OK(getReplCoord()->awaitReplication(txn.get(), time2, writeConcern).status);
+ ASSERT_OK(getReplCoord()->awaitReplication(opCtx.get(), time2, writeConcern).status);
}
void doReplSetReconfig(ReplicationCoordinatorImpl* replCoord, Status* status) {
auto client = getGlobalServiceContext()->makeClient("rsr");
- auto txn = client->makeOperationContext();
+ auto opCtx = client->makeOperationContext();
BSONObjBuilder garbage;
ReplSetReconfigArgs args;
@@ -3125,7 +3127,7 @@ void doReplSetReconfig(ReplicationCoordinatorImpl* replCoord, Status* status) {
<< "node2:12345")
<< BSON("_id" << 2 << "host"
<< "node3:12345")));
- *status = replCoord->processReplSetReconfig(txn.get(), args, &garbage);
+ *status = replCoord->processReplSetReconfig(opCtx.get(), args, &garbage);
}
TEST_F(ReplCoordTest, AwaitReplicationShouldResolveAsNormalDuringAReconfig) {
@@ -3205,7 +3207,7 @@ TEST_F(ReplCoordTest, AwaitReplicationShouldResolveAsNormalDuringAReconfig) {
void doReplSetReconfigToFewer(ReplicationCoordinatorImpl* replCoord, Status* status) {
auto client = getGlobalServiceContext()->makeClient("rsr");
- auto txn = client->makeOperationContext();
+ auto opCtx = client->makeOperationContext();
BSONObjBuilder garbage;
ReplSetReconfigArgs args;
@@ -3219,7 +3221,7 @@ void doReplSetReconfigToFewer(ReplicationCoordinatorImpl* replCoord, Status* sta
<< "node1:12345")
<< BSON("_id" << 2 << "host"
<< "node3:12345")));
- *status = replCoord->processReplSetReconfig(txn.get(), args, &garbage);
+ *status = replCoord->processReplSetReconfig(opCtx.get(), args, &garbage);
}
TEST_F(
@@ -3323,11 +3325,11 @@ TEST_F(ReplCoordTest,
simulateSuccessfulV1Election();
OpTime time(Timestamp(100, 2), 1);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
getReplCoord()->setMyLastAppliedOpTime(time);
getReplCoord()->setMyLastDurableOpTime(time);
- getReplCoord()->createSnapshot(txn.get(), time, SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), time, SnapshotName(1));
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time));
@@ -3350,7 +3352,7 @@ TEST_F(ReplCoordTest,
writeConcern.syncMode = WriteConcernOptions::SyncMode::NONE;
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time, writeConcern2).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time, writeConcern2).status);
// reconfig to three nodes
Status status(ErrorCodes::InternalError, "Not Set");
@@ -3413,30 +3415,30 @@ TEST_F(ReplCoordTest,
majorityWriteConcern.wMode = WriteConcernOptions::kMajority;
majorityWriteConcern.syncMode = WriteConcernOptions::SyncMode::JOURNAL;
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time, majorityWriteConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time, majorityWriteConcern).status);
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 1, time));
ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 1, time));
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time, majorityWriteConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time, majorityWriteConcern).status);
// this member does not vote and as a result should not count towards write concern
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 3, time));
ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 3, time));
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time, majorityWriteConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time, majorityWriteConcern).status);
ASSERT_OK(getReplCoord()->setLastAppliedOptime_forTest(2, 2, time));
ASSERT_OK(getReplCoord()->setLastDurableOptime_forTest(2, 2, time));
ASSERT_EQUALS(ErrorCodes::WriteConcernFailed,
- getReplCoord()->awaitReplication(txn.get(), time, majorityWriteConcern).status);
+ getReplCoord()->awaitReplication(opCtx.get(), time, majorityWriteConcern).status);
- getReplCoord()->createSnapshot(txn.get(), time, SnapshotName(1));
- ASSERT_OK(getReplCoord()->awaitReplication(txn.get(), time, majorityWriteConcern).status);
+ getReplCoord()->createSnapshot(opCtx.get(), time, SnapshotName(1));
+ ASSERT_OK(getReplCoord()->awaitReplication(opCtx.get(), time, majorityWriteConcern).status);
}
TEST_F(ReplCoordTest,
@@ -3527,12 +3529,13 @@ TEST_F(ReplCoordTest, NodeReturnsShutdownInProgressWhenWaitingUntilAnOpTimeDurin
getReplCoord()->setMyLastAppliedOpTime(OpTimeWithTermOne(10, 0));
getReplCoord()->setMyLastDurableOpTime(OpTimeWithTermOne(10, 0));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
- shutdown(txn.get());
+ shutdown(opCtx.get());
auto status = getReplCoord()->waitUntilOpTimeForRead(
- txn.get(), ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
+ opCtx.get(),
+ ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
ASSERT_EQ(status, ErrorCodes::ShutdownInProgress);
}
@@ -3551,11 +3554,12 @@ TEST_F(ReplCoordTest, NodeReturnsInterruptedWhenWaitingUntilAnOpTimeIsInterrupte
getReplCoord()->setMyLastAppliedOpTime(OpTimeWithTermOne(10, 0));
getReplCoord()->setMyLastDurableOpTime(OpTimeWithTermOne(10, 0));
- const auto txn = makeOperationContext();
- killOperation(txn.get());
+ const auto opCtx = makeOperationContext();
+ killOperation(opCtx.get());
auto status = getReplCoord()->waitUntilOpTimeForRead(
- txn.get(), ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
+ opCtx.get(),
+ ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
ASSERT_EQ(status, ErrorCodes::Interrupted);
}
@@ -3571,9 +3575,9 @@ TEST_F(ReplCoordTest, NodeReturnsOkImmediatelyWhenWaitingUntilOpTimePassesNoOpTi
<< 0))),
HostAndPort("node1", 12345));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
- ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(txn.get(), ReadConcernArgs()));
+ ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(opCtx.get(), ReadConcernArgs()));
}
TEST_F(ReplCoordTest, NodeReturnsOkImmediatelyWhenWaitingUntilOpTimePassesAnOpTimePriorToOurLast) {
@@ -3591,10 +3595,11 @@ TEST_F(ReplCoordTest, NodeReturnsOkImmediatelyWhenWaitingUntilOpTimePassesAnOpTi
getReplCoord()->setMyLastAppliedOpTime(OpTimeWithTermOne(100, 0));
getReplCoord()->setMyLastDurableOpTime(OpTimeWithTermOne(100, 0));
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
- txn.get(), ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern)));
+ opCtx.get(),
+ ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern)));
}
TEST_F(ReplCoordTest, NodeReturnsOkImmediatelyWhenWaitingUntilOpTimePassesAnOpTimeEqualToOurLast) {
@@ -3614,20 +3619,21 @@ TEST_F(ReplCoordTest, NodeReturnsOkImmediatelyWhenWaitingUntilOpTimePassesAnOpTi
getReplCoord()->setMyLastAppliedOpTime(time);
getReplCoord()->setMyLastDurableOpTime(time);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
- txn.get(), ReadConcernArgs(time, ReadConcernLevel::kLocalReadConcern)));
+ opCtx.get(), ReadConcernArgs(time, ReadConcernLevel::kLocalReadConcern)));
}
TEST_F(ReplCoordTest,
NodeReturnsNotAReplicaSetWhenWaitUntilOpTimeIsRunWithoutMajorityReadConcernEnabled) {
init(ReplSettings());
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
auto status = getReplCoord()->waitUntilOpTimeForRead(
- txn.get(), ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
+ opCtx.get(),
+ ReadConcernArgs(OpTimeWithTermOne(50, 0), ReadConcernLevel::kLocalReadConcern));
ASSERT_EQ(status, ErrorCodes::NotAReplicaSet);
}
@@ -3636,10 +3642,10 @@ TEST_F(ReplCoordTest, NodeReturnsNotAReplicaSetWhenWaitUntilOpTimeIsRunAgainstAS
settings.setMajorityReadConcernEnabled(true);
init(settings);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
auto status = getReplCoord()->waitUntilOpTimeForRead(
- txn.get(),
+ opCtx.get(),
ReadConcernArgs(OpTime(Timestamp(50, 0), 0), ReadConcernLevel::kMajorityReadConcern));
ASSERT_EQ(status, ErrorCodes::NotAReplicaSet);
}
@@ -3662,11 +3668,11 @@ TEST_F(ReplCoordTest, ReadAfterCommittedWhileShutdown) {
getReplCoord()->setMyLastAppliedOpTime(OpTime(Timestamp(10, 0), 0));
getReplCoord()->setMyLastDurableOpTime(OpTime(Timestamp(10, 0), 0));
- auto txn = makeOperationContext();
- shutdown(txn.get());
+ auto opCtx = makeOperationContext();
+ shutdown(opCtx.get());
auto status = getReplCoord()->waitUntilOpTimeForRead(
- txn.get(),
+ opCtx.get(),
ReadConcernArgs(OpTime(Timestamp(50, 0), 0), ReadConcernLevel::kMajorityReadConcern));
ASSERT_EQUALS(status, ErrorCodes::ShutdownInProgress);
}
@@ -3683,13 +3689,13 @@ TEST_F(ReplCoordTest, ReadAfterCommittedInterrupted) {
<< 0))),
HostAndPort("node1", 12345));
runSingleNodeElection(makeOperationContext(), getReplCoord(), getNet());
- const auto txn = makeOperationContext();
+ const auto opCtx = makeOperationContext();
getReplCoord()->setMyLastAppliedOpTime(OpTime(Timestamp(10, 0), 0));
getReplCoord()->setMyLastDurableOpTime(OpTime(Timestamp(10, 0), 0));
- killOperation(txn.get());
+ killOperation(opCtx.get());
auto status = getReplCoord()->waitUntilOpTimeForRead(
- txn.get(),
+ opCtx.get(),
ReadConcernArgs(OpTime(Timestamp(50, 0), 0), ReadConcernLevel::kMajorityReadConcern));
ASSERT_EQUALS(status, ErrorCodes::Interrupted);
}
@@ -3707,13 +3713,13 @@ TEST_F(ReplCoordTest, ReadAfterCommittedGreaterOpTime) {
HostAndPort("node1", 12345));
runSingleNodeElection(makeOperationContext(), getReplCoord(), getNet());
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
getReplCoord()->setMyLastAppliedOpTime(OpTime(Timestamp(100, 0), 1));
getReplCoord()->setMyLastDurableOpTime(OpTime(Timestamp(100, 0), 1));
- getReplCoord()->createSnapshot(txn.get(), OpTime(Timestamp(100, 0), 1), SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), OpTime(Timestamp(100, 0), 1), SnapshotName(1));
ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
- txn.get(),
+ opCtx.get(),
ReadConcernArgs(OpTime(Timestamp(50, 0), 1), ReadConcernLevel::kMajorityReadConcern)));
}
@@ -3729,15 +3735,15 @@ TEST_F(ReplCoordTest, ReadAfterCommittedEqualOpTime) {
<< 0))),
HostAndPort("node1", 12345));
runSingleNodeElection(makeOperationContext(), getReplCoord(), getNet());
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
OpTime time(Timestamp(100, 0), 1);
getReplCoord()->setMyLastAppliedOpTime(time);
getReplCoord()->setMyLastDurableOpTime(time);
- getReplCoord()->createSnapshot(txn.get(), time, SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), time, SnapshotName(1));
ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
- txn.get(), ReadConcernArgs(time, ReadConcernLevel::kMajorityReadConcern)));
+ opCtx.get(), ReadConcernArgs(time, ReadConcernLevel::kMajorityReadConcern)));
}
TEST_F(ReplCoordTest, ReadAfterCommittedDeferredGreaterOpTime) {
@@ -3762,10 +3768,10 @@ TEST_F(ReplCoordTest, ReadAfterCommittedDeferredGreaterOpTime) {
getReplCoord()->createSnapshot(nullptr, committedOpTime, SnapshotName(1));
});
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
- txn.get(),
+ opCtx.get(),
ReadConcernArgs(OpTime(Timestamp(100, 0), 1), ReadConcernLevel::kMajorityReadConcern)));
}
@@ -3793,10 +3799,10 @@ TEST_F(ReplCoordTest, ReadAfterCommittedDeferredEqualOpTime) {
getReplCoord()->createSnapshot(nullptr, opTimeToWait, SnapshotName(1));
});
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ASSERT_OK(getReplCoord()->waitUntilOpTimeForRead(
- txn.get(), ReadConcernArgs(opTimeToWait, ReadConcernLevel::kMajorityReadConcern)));
+ opCtx.get(), ReadConcernArgs(opTimeToWait, ReadConcernLevel::kMajorityReadConcern)));
pseudoLogOp.get();
}
@@ -3880,13 +3886,13 @@ TEST_F(ReplCoordTest, UpdateLastCommittedOpTimeWhenTheLastCommittedOpTimeIsNewer
HostAndPort("node1", 12345));
getReplCoord()->setFollowerMode(MemberState::RS_SECONDARY);
ASSERT_EQUALS(OpTime(Timestamp(0, 0), 0), getReplCoord()->getLastCommittedOpTime());
- auto txn = makeOperationContext();
- getReplCoord()->updateTerm(txn.get(), 1);
+ auto opCtx = makeOperationContext();
+ getReplCoord()->updateTerm(opCtx.get(), 1);
ASSERT_EQUALS(1, getReplCoord()->getTerm());
OpTime time(Timestamp(10, 0), 1);
OpTime oldTime(Timestamp(9, 0), 1);
- getReplCoord()->createSnapshot(txn.get(), time, SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), time, SnapshotName(1));
// higher OpTime, should change
getReplCoord()->advanceCommitPoint(time);
@@ -3922,8 +3928,8 @@ TEST_F(ReplCoordTest, UpdateTermWhenTheTermFromMetadataIsNewerButNeverUpdateCurr
<< 1),
HostAndPort("node1", 12345));
ASSERT_EQUALS(OpTime(Timestamp(0, 0), 0), getReplCoord()->getLastCommittedOpTime());
- auto txn = makeOperationContext();
- getReplCoord()->updateTerm(txn.get(), 1);
+ auto opCtx = makeOperationContext();
+ getReplCoord()->updateTerm(opCtx.get(), 1);
ASSERT_EQUALS(1, getReplCoord()->getTerm());
// higher term, should change
@@ -4001,8 +4007,8 @@ TEST_F(ReplCoordTest,
<< 1),
HostAndPort("node1", 12345));
ASSERT_EQUALS(OpTime(Timestamp(0, 0), 0), getReplCoord()->getLastCommittedOpTime());
- auto txn = makeOperationContext();
- getReplCoord()->updateTerm(txn.get(), 1);
+ auto opCtx = makeOperationContext();
+ getReplCoord()->updateTerm(opCtx.get(), 1);
ASSERT_EQUALS(1, getReplCoord()->getTerm());
auto replCoord = getReplCoord();
@@ -4129,8 +4135,8 @@ TEST_F(ReplCoordTest, TermAndLastCommittedOpTimeUpdatedFromHeartbeatWhenArbiter)
<< 1),
HostAndPort("node1", 12345));
ASSERT_EQUALS(OpTime(Timestamp(0, 0), 0), getReplCoord()->getLastCommittedOpTime());
- auto txn = makeOperationContext();
- getReplCoord()->updateTerm(txn.get(), 1);
+ auto opCtx = makeOperationContext();
+ getReplCoord()->updateTerm(opCtx.get(), 1);
ASSERT_EQUALS(1, getReplCoord()->getTerm());
auto replCoord = getReplCoord();
@@ -4555,11 +4561,11 @@ TEST_F(ReplCoordTest, AdvanceCommittedSnapshotToMostRecentSnapshotPriorToOpTimeW
OpTime time4(Timestamp(100, 4), 1);
OpTime time5(Timestamp(100, 5), 1);
OpTime time6(Timestamp(100, 6), 1);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
- getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
- getReplCoord()->createSnapshot(txn.get(), time2, SnapshotName(2));
- getReplCoord()->createSnapshot(txn.get(), time5, SnapshotName(3));
+ getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), time2, SnapshotName(2));
+ getReplCoord()->createSnapshot(opCtx.get(), time5, SnapshotName(3));
// ensure current snapshot follows price is right rules (closest but not greater than)
getReplCoord()->setMyLastAppliedOpTime(time3);
@@ -4589,11 +4595,11 @@ TEST_F(ReplCoordTest, DoNotAdvanceCommittedSnapshotWhenAnOpTimeIsNewerThanOurLat
OpTime time4(Timestamp(100, 4), 1);
OpTime time5(Timestamp(100, 5), 1);
OpTime time6(Timestamp(100, 6), 1);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
- getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
- getReplCoord()->createSnapshot(txn.get(), time2, SnapshotName(2));
- getReplCoord()->createSnapshot(txn.get(), time5, SnapshotName(3));
+ getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), time2, SnapshotName(2));
+ getReplCoord()->createSnapshot(opCtx.get(), time5, SnapshotName(3));
// ensure current snapshot will not advance beyond existing snapshots
getReplCoord()->setMyLastAppliedOpTime(time6);
@@ -4621,18 +4627,18 @@ TEST_F(ReplCoordTest,
OpTime time4(Timestamp(100, 4), 1);
OpTime time5(Timestamp(100, 5), 1);
OpTime time6(Timestamp(100, 6), 1);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
- getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
- getReplCoord()->createSnapshot(txn.get(), time2, SnapshotName(2));
- getReplCoord()->createSnapshot(txn.get(), time5, SnapshotName(3));
+ getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), time2, SnapshotName(2));
+ getReplCoord()->createSnapshot(opCtx.get(), time5, SnapshotName(3));
getReplCoord()->setMyLastAppliedOpTime(time6);
getReplCoord()->setMyLastDurableOpTime(time6);
ASSERT_EQUALS(time5, getReplCoord()->getCurrentCommittedSnapshotOpTime());
// ensure current snapshot updates on new snapshot if we are that far
- getReplCoord()->createSnapshot(txn.get(), time6, SnapshotName(4));
+ getReplCoord()->createSnapshot(opCtx.get(), time6, SnapshotName(4));
ASSERT_EQUALS(time6, getReplCoord()->getCurrentCommittedSnapshotOpTime());
}
@@ -4655,11 +4661,11 @@ TEST_F(ReplCoordTest, ZeroCommittedSnapshotWhenAllSnapshotsAreDropped) {
OpTime time4(Timestamp(100, 4), 1);
OpTime time5(Timestamp(100, 5), 1);
OpTime time6(Timestamp(100, 6), 1);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
- getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
- getReplCoord()->createSnapshot(txn.get(), time2, SnapshotName(2));
- getReplCoord()->createSnapshot(txn.get(), time5, SnapshotName(3));
+ getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), time2, SnapshotName(2));
+ getReplCoord()->createSnapshot(opCtx.get(), time5, SnapshotName(3));
// ensure dropping all snapshots should reset the current committed snapshot
getReplCoord()->dropAllSnapshots();
@@ -4681,9 +4687,9 @@ TEST_F(ReplCoordTest, DoNotAdvanceCommittedSnapshotWhenAppliedOpTimeChanges) {
OpTime time1(Timestamp(100, 1), 1);
OpTime time2(Timestamp(100, 2), 1);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
- getReplCoord()->createSnapshot(txn.get(), time1, SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), time1, SnapshotName(1));
getReplCoord()->setMyLastAppliedOpTime(time1);
ASSERT_EQUALS(OpTime(), getReplCoord()->getCurrentCommittedSnapshotOpTime());
@@ -4842,13 +4848,13 @@ TEST_F(ReplCoordTest, NewStyleUpdatePositionCmdHasMetadata) {
OpTime optime(Timestamp(100, 2), 0);
getReplCoord()->setMyLastAppliedOpTime(optime);
getReplCoord()->setMyLastDurableOpTime(optime);
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
// Set last committed optime via metadata.
rpc::ReplSetMetadata syncSourceMetadata(optime.getTerm(), optime, optime, 1, OID(), -1, 1);
getReplCoord()->processReplSetMetadata(syncSourceMetadata);
getReplCoord()->advanceCommitPoint(optime);
- getReplCoord()->createSnapshot(txn.get(), optime, SnapshotName(1));
+ getReplCoord()->createSnapshot(opCtx.get(), optime, SnapshotName(1));
BSONObj cmd = unittest::assertGet(getReplCoord()->prepareReplSetUpdatePositionCommand(
ReplicationCoordinator::ReplSetUpdatePositionCommandStyle::kNewStyle));
@@ -5070,8 +5076,8 @@ TEST_F(ReplCoordTest, WaitForDrainFinish) {
ASSERT_EQUALS(ErrorCodes::BadValue, replCoord->waitForDrainFinish(Milliseconds(-1)));
- const auto txn = makeOperationContext();
- replCoord->signalDrainComplete(txn.get(), replCoord->getTerm());
+ const auto opCtx = makeOperationContext();
+ replCoord->signalDrainComplete(opCtx.get(), replCoord->getTerm());
ASSERT_OK(replCoord->waitForDrainFinish(timeout));
// Zero timeout is fine.
@@ -5346,7 +5352,7 @@ TEST_F(ReplCoordTest, NodeStoresElectionVotes) {
getReplCoord()->setMyLastDurableOpTime(time);
simulateSuccessfulV1Election();
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ReplSetRequestVotesArgs args;
ASSERT_OK(args.initialize(BSON("replSetRequestVotes" << 1 << "setName"
@@ -5363,11 +5369,11 @@ TEST_F(ReplCoordTest, NodeStoresElectionVotes) {
<< time.asOpTime().toBSON())));
ReplSetRequestVotesResponse response;
- ASSERT_OK(getReplCoord()->processReplSetRequestVotes(txn.get(), args, &response));
+ ASSERT_OK(getReplCoord()->processReplSetRequestVotes(opCtx.get(), args, &response));
ASSERT_EQUALS("", response.getReason());
ASSERT_TRUE(response.getVoteGranted());
- auto lastVote = getExternalState()->loadLocalLastVoteDocument(txn.get());
+ auto lastVote = getExternalState()->loadLocalLastVoteDocument(opCtx.get());
ASSERT_OK(lastVote.getStatus());
// This is not a dry-run election so the last vote should include the new term and candidate.
@@ -5400,7 +5406,7 @@ TEST_F(ReplCoordTest, NodeDoesNotStoreDryRunVotes) {
getReplCoord()->setMyLastDurableOpTime(time);
simulateSuccessfulV1Election();
- auto txn = makeOperationContext();
+ auto opCtx = makeOperationContext();
ReplSetRequestVotesArgs args;
ASSERT_OK(args.initialize(BSON("replSetRequestVotes" << 1 << "setName"
@@ -5417,11 +5423,11 @@ TEST_F(ReplCoordTest, NodeDoesNotStoreDryRunVotes) {
<< time.asOpTime().toBSON())));
ReplSetRequestVotesResponse response;
- ASSERT_OK(getReplCoord()->processReplSetRequestVotes(txn.get(), args, &response));
+ ASSERT_OK(getReplCoord()->processReplSetRequestVotes(opCtx.get(), args, &response));
ASSERT_EQUALS("", response.getReason());
ASSERT_TRUE(response.getVoteGranted());
- auto lastVote = getExternalState()->loadLocalLastVoteDocument(txn.get());
+ auto lastVote = getExternalState()->loadLocalLastVoteDocument(opCtx.get());
ASSERT_OK(lastVote.getStatus());
// This is a dry-run election so the last vote should not be updated with the new term and
diff --git a/src/mongo/db/repl/replication_coordinator_mock.cpp b/src/mongo/db/repl/replication_coordinator_mock.cpp
index e72083ef012..27d62c0af1e 100644
--- a/src/mongo/db/repl/replication_coordinator_mock.cpp
+++ b/src/mongo/db/repl/replication_coordinator_mock.cpp
@@ -50,7 +50,7 @@ ReplicationCoordinatorMock::ReplicationCoordinatorMock(ServiceContext* service,
ReplicationCoordinatorMock::~ReplicationCoordinatorMock() {}
-void ReplicationCoordinatorMock::startup(OperationContext* txn) {
+void ReplicationCoordinatorMock::startup(OperationContext* opCtx) {
// TODO
}
@@ -97,18 +97,18 @@ Seconds ReplicationCoordinatorMock::getSlaveDelaySecs() const {
void ReplicationCoordinatorMock::clearSyncSourceBlacklist() {}
ReplicationCoordinator::StatusAndDuration ReplicationCoordinatorMock::awaitReplication(
- OperationContext* txn, const OpTime& opTime, const WriteConcernOptions& writeConcern) {
+ OperationContext* opCtx, const OpTime& opTime, const WriteConcernOptions& writeConcern) {
// TODO
return StatusAndDuration(Status::OK(), Milliseconds(0));
}
ReplicationCoordinator::StatusAndDuration
ReplicationCoordinatorMock::awaitReplicationOfLastOpForClient(
- OperationContext* txn, const WriteConcernOptions& writeConcern) {
+ OperationContext* opCtx, const WriteConcernOptions& writeConcern) {
return StatusAndDuration(Status::OK(), Milliseconds(0));
}
-Status ReplicationCoordinatorMock::stepDown(OperationContext* txn,
+Status ReplicationCoordinatorMock::stepDown(OperationContext* opCtx,
bool force,
const Milliseconds& waitTime,
const Milliseconds& stepdownTime) {
@@ -120,7 +120,7 @@ bool ReplicationCoordinatorMock::isMasterForReportingPurposes() {
return true;
}
-bool ReplicationCoordinatorMock::canAcceptWritesForDatabase(OperationContext* txn,
+bool ReplicationCoordinatorMock::canAcceptWritesForDatabase(OperationContext* opCtx,
StringData dbName) {
// Return true if we allow writes explicitly even when not in primary state, as in sharding
// unit tests, so that the op observers can fire but the tests don't have to set all the states
@@ -131,38 +131,38 @@ bool ReplicationCoordinatorMock::canAcceptWritesForDatabase(OperationContext* tx
return dbName == "local" || _memberState.primary() || _settings.isMaster();
}
-bool ReplicationCoordinatorMock::canAcceptWritesForDatabase_UNSAFE(OperationContext* txn,
+bool ReplicationCoordinatorMock::canAcceptWritesForDatabase_UNSAFE(OperationContext* opCtx,
StringData dbName) {
- return canAcceptWritesForDatabase(txn, dbName);
+ return canAcceptWritesForDatabase(opCtx, dbName);
}
-bool ReplicationCoordinatorMock::canAcceptWritesFor(OperationContext* txn,
+bool ReplicationCoordinatorMock::canAcceptWritesFor(OperationContext* opCtx,
const NamespaceString& ns) {
// TODO
- return canAcceptWritesForDatabase(txn, ns.db());
+ return canAcceptWritesForDatabase(opCtx, ns.db());
}
-bool ReplicationCoordinatorMock::canAcceptWritesFor_UNSAFE(OperationContext* txn,
+bool ReplicationCoordinatorMock::canAcceptWritesFor_UNSAFE(OperationContext* opCtx,
const NamespaceString& ns) {
- return canAcceptWritesFor(txn, ns);
+ return canAcceptWritesFor(opCtx, ns);
}
-Status ReplicationCoordinatorMock::checkCanServeReadsFor(OperationContext* txn,
+Status ReplicationCoordinatorMock::checkCanServeReadsFor(OperationContext* opCtx,
const NamespaceString& ns,
bool slaveOk) {
// TODO
return Status::OK();
}
-Status ReplicationCoordinatorMock::checkCanServeReadsFor_UNSAFE(OperationContext* txn,
+Status ReplicationCoordinatorMock::checkCanServeReadsFor_UNSAFE(OperationContext* opCtx,
const NamespaceString& ns,
bool slaveOk) {
- return checkCanServeReadsFor(txn, ns, slaveOk);
+ return checkCanServeReadsFor(opCtx, ns, slaveOk);
}
-bool ReplicationCoordinatorMock::shouldRelaxIndexConstraints(OperationContext* txn,
+bool ReplicationCoordinatorMock::shouldRelaxIndexConstraints(OperationContext* opCtx,
const NamespaceString& ns) {
- return !canAcceptWritesFor(txn, ns);
+ return !canAcceptWritesFor(opCtx, ns);
}
Status ReplicationCoordinatorMock::setLastOptimeForSlave(const OID& rid, const Timestamp& ts) {
@@ -205,7 +205,7 @@ OpTime ReplicationCoordinatorMock::getMyLastDurableOpTime() const {
return _myLastDurableOpTime;
}
-Status ReplicationCoordinatorMock::waitUntilOpTimeForRead(OperationContext* txn,
+Status ReplicationCoordinatorMock::waitUntilOpTimeForRead(OperationContext* opCtx,
const ReadConcernArgs& settings) {
return Status::OK();
}
@@ -242,7 +242,7 @@ Status ReplicationCoordinatorMock::waitForDrainFinish(Milliseconds timeout) {
void ReplicationCoordinatorMock::signalUpstreamUpdater() {}
-Status ReplicationCoordinatorMock::resyncData(OperationContext* txn, bool waitUntilCompleted) {
+Status ReplicationCoordinatorMock::resyncData(OperationContext* opCtx, bool waitUntilCompleted) {
return Status::OK();
}
@@ -297,7 +297,7 @@ bool ReplicationCoordinatorMock::getMaintenanceMode() {
return false;
}
-Status ReplicationCoordinatorMock::processReplSetSyncFrom(OperationContext* txn,
+Status ReplicationCoordinatorMock::processReplSetSyncFrom(OperationContext* opCtx,
const HostAndPort& target,
BSONObjBuilder* resultObj) {
// TODO
@@ -314,13 +314,13 @@ Status ReplicationCoordinatorMock::processHeartbeat(const ReplSetHeartbeatArgs&
return Status::OK();
}
-Status ReplicationCoordinatorMock::processReplSetReconfig(OperationContext* txn,
+Status ReplicationCoordinatorMock::processReplSetReconfig(OperationContext* opCtx,
const ReplSetReconfigArgs& args,
BSONObjBuilder* resultObj) {
return Status::OK();
}
-Status ReplicationCoordinatorMock::processReplSetInitiate(OperationContext* txn,
+Status ReplicationCoordinatorMock::processReplSetInitiate(OperationContext* opCtx,
const BSONObj& configObj,
BSONObjBuilder* resultObj) {
return Status::OK();
@@ -355,7 +355,7 @@ Status ReplicationCoordinatorMock::processReplSetUpdatePosition(const UpdatePosi
return Status::OK();
}
-Status ReplicationCoordinatorMock::processHandshake(OperationContext* txn,
+Status ReplicationCoordinatorMock::processHandshake(OperationContext* opCtx,
const HandshakeArgs& handshake) {
return Status::OK();
}
@@ -394,7 +394,7 @@ HostAndPort ReplicationCoordinatorMock::chooseNewSyncSource(const OpTime& lastOp
void ReplicationCoordinatorMock::blacklistSyncSource(const HostAndPort& host, Date_t until) {}
-void ReplicationCoordinatorMock::resetLastOpTimesFromOplog(OperationContext* txn) {
+void ReplicationCoordinatorMock::resetLastOpTimesFromOplog(OperationContext* opCtx) {
invariant(false);
}
@@ -410,7 +410,7 @@ OpTime ReplicationCoordinatorMock::getLastCommittedOpTime() const {
}
Status ReplicationCoordinatorMock::processReplSetRequestVotes(
- OperationContext* txn,
+ OperationContext* opCtx,
const ReplSetRequestVotesArgs& args,
ReplSetRequestVotesResponse* response) {
return Status::OK();
@@ -439,17 +439,17 @@ long long ReplicationCoordinatorMock::getTerm() {
return OpTime::kInitialTerm;
}
-Status ReplicationCoordinatorMock::updateTerm(OperationContext* txn, long long term) {
+Status ReplicationCoordinatorMock::updateTerm(OperationContext* opCtx, long long term) {
return Status::OK();
}
-SnapshotName ReplicationCoordinatorMock::reserveSnapshotName(OperationContext* txn) {
+SnapshotName ReplicationCoordinatorMock::reserveSnapshotName(OperationContext* opCtx) {
return SnapshotName(_snapshotNameGenerator.addAndFetch(1));
}
void ReplicationCoordinatorMock::forceSnapshotCreation() {}
-void ReplicationCoordinatorMock::createSnapshot(OperationContext* txn,
+void ReplicationCoordinatorMock::createSnapshot(OperationContext* opCtx,
OpTime timeOfSnapshot,
SnapshotName name){};
@@ -459,7 +459,7 @@ OpTime ReplicationCoordinatorMock::getCurrentCommittedSnapshotOpTime() const {
return OpTime();
}
-void ReplicationCoordinatorMock::waitUntilSnapshotCommitted(OperationContext* txn,
+void ReplicationCoordinatorMock::waitUntilSnapshotCommitted(OperationContext* opCtx,
const SnapshotName& untilSnapshot) {}
size_t ReplicationCoordinatorMock::getNumUncommittedSnapshots() {
diff --git a/src/mongo/db/repl/replication_coordinator_mock.h b/src/mongo/db/repl/replication_coordinator_mock.h
index 4b3fd99d3ce..0e9109b1665 100644
--- a/src/mongo/db/repl/replication_coordinator_mock.h
+++ b/src/mongo/db/repl/replication_coordinator_mock.h
@@ -53,9 +53,9 @@ public:
ReplicationCoordinatorMock(ServiceContext* service, const ReplSettings& settings);
virtual ~ReplicationCoordinatorMock();
- virtual void startup(OperationContext* txn);
+ virtual void startup(OperationContext* opCtx);
- virtual void shutdown(OperationContext* txn);
+ virtual void shutdown(OperationContext* opCtx);
virtual ReplicationExecutor* getExecutor() override {
return nullptr;
@@ -78,36 +78,36 @@ public:
virtual void clearSyncSourceBlacklist();
virtual ReplicationCoordinator::StatusAndDuration awaitReplication(
- OperationContext* txn, const OpTime& opTime, const WriteConcernOptions& writeConcern);
+ OperationContext* opCtx, const OpTime& opTime, const WriteConcernOptions& writeConcern);
virtual ReplicationCoordinator::StatusAndDuration awaitReplicationOfLastOpForClient(
- OperationContext* txn, const WriteConcernOptions& writeConcern);
+ OperationContext* opCtx, const WriteConcernOptions& writeConcern);
- virtual Status stepDown(OperationContext* txn,
+ virtual Status stepDown(OperationContext* opCtx,
bool force,
const Milliseconds& waitTime,
const Milliseconds& stepdownTime);
virtual bool isMasterForReportingPurposes();
- virtual bool canAcceptWritesForDatabase(OperationContext* txn, StringData dbName);
+ virtual bool canAcceptWritesForDatabase(OperationContext* opCtx, StringData dbName);
- virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* txn, StringData dbName);
+ virtual bool canAcceptWritesForDatabase_UNSAFE(OperationContext* opCtx, StringData dbName);
- bool canAcceptWritesFor(OperationContext* txn, const NamespaceString& ns) override;
+ bool canAcceptWritesFor(OperationContext* opCtx, const NamespaceString& ns) override;
- bool canAcceptWritesFor_UNSAFE(OperationContext* txn, const NamespaceString& ns) override;
+ bool canAcceptWritesFor_UNSAFE(OperationContext* opCtx, const NamespaceString& ns) override;
virtual Status checkIfWriteConcernCanBeSatisfied(const WriteConcernOptions& writeConcern) const;
- virtual Status checkCanServeReadsFor(OperationContext* txn,
+ virtual Status checkCanServeReadsFor(OperationContext* opCtx,
const NamespaceString& ns,
bool slaveOk);
- virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* txn,
+ virtual Status checkCanServeReadsFor_UNSAFE(OperationContext* opCtx,
const NamespaceString& ns,
bool slaveOk);
- virtual bool shouldRelaxIndexConstraints(OperationContext* txn, const NamespaceString& ns);
+ virtual bool shouldRelaxIndexConstraints(OperationContext* opCtx, const NamespaceString& ns);
virtual Status setLastOptimeForSlave(const OID& rid, const Timestamp& ts);
@@ -124,7 +124,7 @@ public:
virtual OpTime getMyLastAppliedOpTime() const;
virtual OpTime getMyLastDurableOpTime() const;
- virtual Status waitUntilOpTimeForRead(OperationContext* txn,
+ virtual Status waitUntilOpTimeForRead(OperationContext* opCtx,
const ReadConcernArgs& settings) override;
virtual OID getElectionId();
@@ -143,7 +143,7 @@ public:
virtual void signalUpstreamUpdater();
- virtual Status resyncData(OperationContext* txn, bool waitUntilCompleted) override;
+ virtual Status resyncData(OperationContext* opCtx, bool waitUntilCompleted) override;
virtual StatusWith<BSONObj> prepareReplSetUpdatePositionCommand(
ReplSetUpdatePositionCommandStyle commandStyle) const override;
@@ -170,7 +170,7 @@ public:
virtual bool getMaintenanceMode();
- virtual Status processReplSetSyncFrom(OperationContext* txn,
+ virtual Status processReplSetSyncFrom(OperationContext* opCtx,
const HostAndPort& target,
BSONObjBuilder* resultObj);
@@ -179,11 +179,11 @@ public:
virtual Status processHeartbeat(const ReplSetHeartbeatArgs& args,
ReplSetHeartbeatResponse* response);
- virtual Status processReplSetReconfig(OperationContext* txn,
+ virtual Status processReplSetReconfig(OperationContext* opCtx,
const ReplSetReconfigArgs& args,
BSONObjBuilder* resultObj);
- virtual Status processReplSetInitiate(OperationContext* txn,
+ virtual Status processReplSetInitiate(OperationContext* opCtx,
const BSONObj& configObj,
BSONObjBuilder* resultObj);
@@ -200,7 +200,7 @@ public:
virtual Status processReplSetUpdatePosition(const UpdatePositionArgs& updates,
long long* configVersion);
- virtual Status processHandshake(OperationContext* txn, const HandshakeArgs& handshake);
+ virtual Status processHandshake(OperationContext* opCtx, const HandshakeArgs& handshake);
virtual bool buildsIndexes();
@@ -216,7 +216,7 @@ public:
virtual void blacklistSyncSource(const HostAndPort& host, Date_t until);
- virtual void resetLastOpTimesFromOplog(OperationContext* txn);
+ virtual void resetLastOpTimesFromOplog(OperationContext* opCtx);
virtual bool shouldChangeSyncSource(const HostAndPort& currentSource,
const rpc::ReplSetMetadata& replMetadata,
@@ -224,7 +224,7 @@ public:
virtual OpTime getLastCommittedOpTime() const;
- virtual Status processReplSetRequestVotes(OperationContext* txn,
+ virtual Status processReplSetRequestVotes(OperationContext* opCtx,
const ReplSetRequestVotesArgs& args,
ReplSetRequestVotesResponse* response);
@@ -243,13 +243,13 @@ public:
virtual long long getTerm();
- virtual Status updateTerm(OperationContext* txn, long long term);
+ virtual Status updateTerm(OperationContext* opCtx, long long term);
- virtual SnapshotName reserveSnapshotName(OperationContext* txn);
+ virtual SnapshotName reserveSnapshotName(OperationContext* opCtx);
virtual void forceSnapshotCreation() override;
- virtual void createSnapshot(OperationContext* txn,
+ virtual void createSnapshot(OperationContext* opCtx,
OpTime timeOfSnapshot,
SnapshotName name) override;
@@ -257,7 +257,7 @@ public:
virtual OpTime getCurrentCommittedSnapshotOpTime() const override;
- virtual void waitUntilSnapshotCommitted(OperationContext* txn,
+ virtual void waitUntilSnapshotCommitted(OperationContext* opCtx,
const SnapshotName& untilSnapshot) override;
virtual size_t getNumUncommittedSnapshots() override;
diff --git a/src/mongo/db/repl/replication_coordinator_test_fixture.cpp b/src/mongo/db/repl/replication_coordinator_test_fixture.cpp
index 43dff9b4c06..945455d4512 100644
--- a/src/mongo/db/repl/replication_coordinator_test_fixture.cpp
+++ b/src/mongo/db/repl/replication_coordinator_test_fixture.cpp
@@ -89,8 +89,8 @@ void ReplCoordTest::tearDown() {
_externalState->setStoreLocalConfigDocumentToHang(false);
}
if (_callShutdown) {
- auto txn = makeOperationContext();
- shutdown(txn.get());
+ auto opCtx = makeOperationContext();
+ shutdown(opCtx.get());
}
}
@@ -165,8 +165,8 @@ void ReplCoordTest::start() {
init();
}
- const auto txn = makeOperationContext();
- _repl->startup(txn.get());
+ const auto opCtx = makeOperationContext();
+ _repl->startup(opCtx.get());
_repl->waitForStartUpComplete_forTest();
_callShutdown = true;
}
@@ -362,8 +362,8 @@ void ReplCoordTest::simulateSuccessfulV1ElectionAt(Date_t electionTime) {
ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
{
- auto txn = makeOperationContext();
- replCoord->signalDrainComplete(txn.get(), replCoord->getTerm());
+ auto opCtx = makeOperationContext();
+ replCoord->signalDrainComplete(opCtx.get(), replCoord->getTerm());
}
ASSERT(replCoord->getApplierState() == ReplicationCoordinator::ApplierState::Stopped);
replCoord->fillIsMasterForReplSet(&imResponse);
@@ -425,8 +425,8 @@ void ReplCoordTest::simulateSuccessfulElection() {
ASSERT_FALSE(imResponse.isMaster()) << imResponse.toBSON().toString();
ASSERT_TRUE(imResponse.isSecondary()) << imResponse.toBSON().toString();
{
- auto txn = makeOperationContext();
- replCoord->signalDrainComplete(txn.get(), replCoord->getTerm());
+ auto opCtx = makeOperationContext();
+ replCoord->signalDrainComplete(opCtx.get(), replCoord->getTerm());
}
replCoord->fillIsMasterForReplSet(&imResponse);
ASSERT_TRUE(imResponse.isMaster()) << imResponse.toBSON().toString();
@@ -435,10 +435,10 @@ void ReplCoordTest::simulateSuccessfulElection() {
ASSERT(replCoord->getMemberState().primary()) << replCoord->getMemberState().toString();
}
-void ReplCoordTest::shutdown(OperationContext* txn) {
+void ReplCoordTest::shutdown(OperationContext* opCtx) {
invariant(_callShutdown);
_net->exitNetwork();
- _repl->shutdown(txn);
+ _repl->shutdown(opCtx);
_callShutdown = false;
}
diff --git a/src/mongo/db/repl/replication_coordinator_test_fixture.h b/src/mongo/db/repl/replication_coordinator_test_fixture.h
index b9b05e46172..5ffab24a8ef 100644
--- a/src/mongo/db/repl/replication_coordinator_test_fixture.h
+++ b/src/mongo/db/repl/replication_coordinator_test_fixture.h
@@ -233,7 +233,7 @@ protected:
/**
* Shuts down the objects under test.
*/
- void shutdown(OperationContext* txn);
+ void shutdown(OperationContext* opCtx);
/**
* Receive the heartbeat request from replication coordinator and reply with a response.
diff --git a/src/mongo/db/repl/replication_executor.cpp b/src/mongo/db/repl/replication_executor.cpp
index f4070ac5d9e..3f9f0c5836b 100644
--- a/src/mongo/db/repl/replication_executor.cpp
+++ b/src/mongo/db/repl/replication_executor.cpp
@@ -404,8 +404,8 @@ StatusWith<ReplicationExecutor::CallbackHandle> ReplicationExecutor::scheduleDBW
handle.getValue(),
&_dbWorkInProgressQueue,
nullptr);
- auto task = [doOp](OperationContext* txn, const Status& status) {
- makeNoExcept(stdx::bind(doOp, txn, status))();
+ auto task = [doOp](OperationContext* opCtx, const Status& status) {
+ makeNoExcept(stdx::bind(doOp, opCtx, status))();
return TaskRunner::NextAction::kDisposeOperationContext;
};
if (mode == MODE_NONE && nss.ns().empty()) {
@@ -418,7 +418,7 @@ StatusWith<ReplicationExecutor::CallbackHandle> ReplicationExecutor::scheduleDBW
return handle;
}
-void ReplicationExecutor::_doOperation(OperationContext* txn,
+void ReplicationExecutor::_doOperation(OperationContext* opCtx,
const Status& taskRunnerStatus,
const CallbackHandle& cbHandle,
WorkQueue* workQueue,
@@ -442,7 +442,7 @@ void ReplicationExecutor::_doOperation(OperationContext* txn,
(callback->_isCanceled || !taskRunnerStatus.isOK()
? Status(ErrorCodes::CallbackCanceled, "Callback canceled")
: Status::OK()),
- txn));
+ opCtx));
}
lk.lock();
signalEvent_inlock(callback->_finishedEvent);
@@ -461,8 +461,8 @@ ReplicationExecutor::scheduleWorkWithGlobalExclusiveLock(const CallbackFn& work)
&_exclusiveLockInProgressQueue,
&_terribleExLockSyncMutex);
_dblockExclusiveLockTaskRunner.schedule(DatabaseTask::makeGlobalExclusiveLockTask(
- [doOp](OperationContext* txn, const Status& status) {
- makeNoExcept(stdx::bind(doOp, txn, status))();
+ [doOp](OperationContext* opCtx, const Status& status) {
+ makeNoExcept(stdx::bind(doOp, opCtx, status))();
return TaskRunner::NextAction::kDisposeOperationContext;
}));
}
diff --git a/src/mongo/db/repl/replication_executor.h b/src/mongo/db/repl/replication_executor.h
index 26f8e522317..c5e20a8ac68 100644
--- a/src/mongo/db/repl/replication_executor.h
+++ b/src/mongo/db/repl/replication_executor.h
@@ -280,7 +280,7 @@ private:
* Executes the callback referenced by "cbHandle", and moves the underlying
* WorkQueue::iterator from "workQueue" into the _freeQueue.
*
- * "txn" is a pointer to the OperationContext.
+ * "opCtx" is a pointer to the OperationContext.
*
* "status" is the callback status from the task runner. Only possible values are
* Status::OK and ErrorCodes::CallbackCanceled (when task runner is canceled).
@@ -288,7 +288,7 @@ private:
* If "terribleExLockSyncMutex" is not null, serializes execution of "cbHandle" with the
* execution of other callbacks.
*/
- void _doOperation(OperationContext* txn,
+ void _doOperation(OperationContext* opCtx,
const Status& taskRunnerStatus,
const CallbackHandle& cbHandle,
WorkQueue* workQueue,
diff --git a/src/mongo/db/repl/replication_executor_test.cpp b/src/mongo/db/repl/replication_executor_test.cpp
index e630a4a2e30..831259951b4 100644
--- a/src/mongo/db/repl/replication_executor_test.cpp
+++ b/src/mongo/db/repl/replication_executor_test.cpp
@@ -72,12 +72,12 @@ TEST_F(ReplicationExecutorTest, ScheduleDBWorkAndExclusiveWorkConcurrently) {
NamespaceString nss("mydb", "mycoll");
ReplicationExecutor& executor = getReplExecutor();
Status status1 = getDetectableErrorStatus();
- OperationContext* txn = nullptr;
+ OperationContext* opCtx = nullptr;
using CallbackData = ReplicationExecutor::CallbackArgs;
ASSERT_OK(executor
.scheduleDBWork([&](const CallbackData& cbData) {
status1 = cbData.status;
- txn = cbData.txn;
+ opCtx = cbData.opCtx;
barrier.countDownAndWait();
if (cbData.status != ErrorCodes::CallbackCanceled)
cbData.executor->shutdown();
@@ -90,23 +90,23 @@ TEST_F(ReplicationExecutorTest, ScheduleDBWorkAndExclusiveWorkConcurrently) {
executor.startup();
executor.join();
ASSERT_OK(status1);
- ASSERT(txn);
+ ASSERT(opCtx);
}
TEST_F(ReplicationExecutorTest, ScheduleDBWorkWithCollectionLock) {
NamespaceString nss("mydb", "mycoll");
ReplicationExecutor& executor = getReplExecutor();
Status status1 = getDetectableErrorStatus();
- OperationContext* txn = nullptr;
+ OperationContext* opCtx = nullptr;
bool collectionIsLocked = false;
using CallbackData = ReplicationExecutor::CallbackArgs;
ASSERT_OK(executor
.scheduleDBWork(
[&](const CallbackData& cbData) {
status1 = cbData.status;
- txn = cbData.txn;
- collectionIsLocked = txn
- ? txn->lockState()->isCollectionLockedForMode(nss.ns(), MODE_X)
+ opCtx = cbData.opCtx;
+ collectionIsLocked = opCtx
+ ? opCtx->lockState()->isCollectionLockedForMode(nss.ns(), MODE_X)
: false;
if (cbData.status != ErrorCodes::CallbackCanceled)
cbData.executor->shutdown();
@@ -117,21 +117,21 @@ TEST_F(ReplicationExecutorTest, ScheduleDBWorkWithCollectionLock) {
executor.startup();
executor.join();
ASSERT_OK(status1);
- ASSERT(txn);
+ ASSERT(opCtx);
ASSERT_TRUE(collectionIsLocked);
}
TEST_F(ReplicationExecutorTest, ScheduleExclusiveLockOperation) {
ReplicationExecutor& executor = getReplExecutor();
Status status1 = getDetectableErrorStatus();
- OperationContext* txn = nullptr;
+ OperationContext* opCtx = nullptr;
bool lockIsW = false;
using CallbackData = ReplicationExecutor::CallbackArgs;
ASSERT_OK(executor
.scheduleWorkWithGlobalExclusiveLock([&](const CallbackData& cbData) {
status1 = cbData.status;
- txn = cbData.txn;
- lockIsW = txn ? txn->lockState()->isW() : false;
+ opCtx = cbData.opCtx;
+ lockIsW = opCtx ? opCtx->lockState()->isW() : false;
if (cbData.status != ErrorCodes::CallbackCanceled)
cbData.executor->shutdown();
})
@@ -139,7 +139,7 @@ TEST_F(ReplicationExecutorTest, ScheduleExclusiveLockOperation) {
executor.startup();
executor.join();
ASSERT_OK(status1);
- ASSERT(txn);
+ ASSERT(opCtx);
ASSERT_TRUE(lockIsW);
}
diff --git a/src/mongo/db/repl/replication_info.cpp b/src/mongo/db/repl/replication_info.cpp
index c75c7b38880..e0a49f5849f 100644
--- a/src/mongo/db/repl/replication_info.cpp
+++ b/src/mongo/db/repl/replication_info.cpp
@@ -66,7 +66,7 @@ using std::stringstream;
namespace repl {
-void appendReplicationInfo(OperationContext* txn, BSONObjBuilder& result, int level) {
+void appendReplicationInfo(OperationContext* opCtx, BSONObjBuilder& result, int level) {
ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator();
if (replCoord->getSettings().usingReplSets()) {
IsMasterResponse isMasterResponse;
@@ -95,9 +95,9 @@ void appendReplicationInfo(OperationContext* txn, BSONObjBuilder& result, int le
list<BSONObj> src;
{
const NamespaceString localSources{"local.sources"};
- AutoGetCollectionForRead ctx(txn, localSources);
+ AutoGetCollectionForRead ctx(opCtx, localSources);
unique_ptr<PlanExecutor> exec(InternalPlanner::collectionScan(
- txn, localSources.ns(), ctx.getCollection(), PlanExecutor::YIELD_MANUAL));
+ opCtx, localSources.ns(), ctx.getCollection(), PlanExecutor::YIELD_MANUAL));
BSONObj obj;
PlanExecutor::ExecState state;
while (PlanExecutor::ADVANCED == (state = exec->getNext(&obj, NULL))) {
@@ -124,7 +124,7 @@ void appendReplicationInfo(OperationContext* txn, BSONObjBuilder& result, int le
}
if (level > 1) {
- wassert(!txn->lockState()->isLocked());
+ wassert(!opCtx->lockState()->isLocked());
// note: there is no so-style timeout on this connection; perhaps we should have
// one.
ScopedDbConnection conn(s["host"].valuestr());
@@ -159,7 +159,7 @@ public:
return true;
}
- BSONObj generateSection(OperationContext* txn, const BSONElement& configElement) const {
+ BSONObj generateSection(OperationContext* opCtx, const BSONElement& configElement) const {
if (!getGlobalReplicationCoordinator()->isReplEnabled()) {
return BSONObj();
}
@@ -167,7 +167,7 @@ public:
int level = configElement.numberInt();
BSONObjBuilder result;
- appendReplicationInfo(txn, result, level);
+ appendReplicationInfo(opCtx, result, level);
getGlobalReplicationCoordinator()->processReplSetGetRBID(&result);
return result.obj();
@@ -182,7 +182,7 @@ public:
return false;
}
- BSONObj generateSection(OperationContext* txn, const BSONElement& configElement) const {
+ BSONObj generateSection(OperationContext* opCtx, const BSONElement& configElement) const {
ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator();
if (!replCoord->isReplEnabled()) {
return BSONObj();
@@ -199,7 +199,7 @@ public:
BSONObj o;
uassert(17347,
"Problem reading earliest entry from oplog",
- Helpers::getSingleton(txn, oplogNS.c_str(), o));
+ Helpers::getSingleton(opCtx, oplogNS.c_str(), o));
result.append("earliestOptime", o["ts"].timestamp());
return result.obj();
}
@@ -225,7 +225,7 @@ public:
const BSONObj& cmdObj,
std::vector<Privilege>* out) {} // No auth required
CmdIsMaster() : Command("isMaster", true, "ismaster") {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string&,
BSONObj& cmdObj,
int,
@@ -235,20 +235,20 @@ public:
authenticated.
*/
if (cmdObj["forShell"].trueValue()) {
- LastError::get(txn->getClient()).disable();
+ LastError::get(opCtx->getClient()).disable();
}
// Tag connections to avoid closing them on stepdown.
auto hangUpElement = cmdObj["hangUpOnStepDown"];
if (!hangUpElement.eoo() && !hangUpElement.trueValue()) {
- auto session = txn->getClient()->session();
+ auto session = opCtx->getClient()->session();
if (session) {
session->replaceTags(session->getTags() |
executor::NetworkInterface::kMessagingPortKeepOpen);
}
}
- auto& clientMetadataIsMasterState = ClientMetadataIsMasterState::get(txn->getClient());
+ auto& clientMetadataIsMasterState = ClientMetadataIsMasterState::get(opCtx->getClient());
bool seenIsMaster = clientMetadataIsMasterState.hasSeenIsMaster();
if (!seenIsMaster) {
clientMetadataIsMasterState.setSeenIsMaster();
@@ -271,13 +271,13 @@ public:
invariant(swParseClientMetadata.getValue());
- swParseClientMetadata.getValue().get().logClientMetadata(txn->getClient());
+ swParseClientMetadata.getValue().get().logClientMetadata(opCtx->getClient());
clientMetadataIsMasterState.setClientMetadata(
- txn->getClient(), std::move(swParseClientMetadata.getValue()));
+ opCtx->getClient(), std::move(swParseClientMetadata.getValue()));
}
- appendReplicationInfo(txn, result, 0);
+ appendReplicationInfo(opCtx, result, 0);
if (serverGlobalParams.clusterRole == ClusterRole::ConfigServer) {
// If we have feature compatibility version 3.4, use a config server mode that 3.2
@@ -302,10 +302,10 @@ public:
"automationServiceDescriptor",
static_cast<ServerParameter*>(nullptr));
if (parameter)
- parameter->append(txn, result, "automationServiceDescriptor");
+ parameter->append(opCtx, result, "automationServiceDescriptor");
- if (txn->getClient()->session()) {
- MessageCompressorManager::forSession(txn->getClient()->session())
+ if (opCtx->getClient()->session()) {
+ MessageCompressorManager::forSession(opCtx->getClient()->session())
.serverNegotiate(cmdObj, &result);
}
diff --git a/src/mongo/db/repl/resync.cpp b/src/mongo/db/repl/resync.cpp
index e45022440a3..848700d215a 100644
--- a/src/mongo/db/repl/resync.cpp
+++ b/src/mongo/db/repl/resync.cpp
@@ -72,7 +72,7 @@ public:
}
CmdResync() : Command(kResyncFieldName) {}
- virtual bool run(OperationContext* txn,
+ virtual bool run(OperationContext* opCtx,
const string& dbname,
BSONObj& cmdObj,
int,
@@ -100,16 +100,16 @@ public:
return appendCommandStatus(
result, Status(ErrorCodes::NotSecondary, "primaries cannot resync"));
}
- uassertStatusOKWithLocation(replCoord->resyncData(txn, waitForResync), "resync", 0);
+ uassertStatusOKWithLocation(replCoord->resyncData(opCtx, waitForResync), "resync", 0);
return true;
}
// Master/Slave resync.
- ScopedTransaction transaction(txn, MODE_X);
- Lock::GlobalWrite globalWriteLock(txn->lockState());
+ ScopedTransaction transaction(opCtx, MODE_X);
+ Lock::GlobalWrite globalWriteLock(opCtx->lockState());
// below this comment pertains only to master/slave replication
if (cmdObj.getBoolField("force")) {
- if (!waitForSyncToFinish(txn, errmsg))
+ if (!waitForSyncToFinish(opCtx, errmsg))
return false;
replAllDead = "resync forced";
}
@@ -118,16 +118,16 @@ public:
errmsg = "not dead, no need to resync";
return false;
}
- if (!waitForSyncToFinish(txn, errmsg))
+ if (!waitForSyncToFinish(opCtx, errmsg))
return false;
- ReplSource::forceResyncDead(txn, "client");
+ ReplSource::forceResyncDead(opCtx, "client");
result.append("info", "triggered resync for all sources");
return true;
}
- bool waitForSyncToFinish(OperationContext* txn, string& errmsg) const {
+ bool waitForSyncToFinish(OperationContext* opCtx, string& errmsg) const {
// Wait for slave thread to finish syncing, so sources will be be
// reloaded with new saved state on next pass.
Timer t;
@@ -135,7 +135,7 @@ public:
if (syncing.load() == 0 || t.millis() > 30000)
break;
{
- Lock::TempRelease t(txn->lockState());
+ Lock::TempRelease t(opCtx->lockState());
relinquishSyncingSome.store(1);
sleepmillis(1);
}
diff --git a/src/mongo/db/repl/rollback_source.h b/src/mongo/db/repl/rollback_source.h
index 3e8d6f55578..4e068d336ce 100644
--- a/src/mongo/db/repl/rollback_source.h
+++ b/src/mongo/db/repl/rollback_source.h
@@ -76,7 +76,7 @@ public:
/**
* Clones a single collection from the sync source.
*/
- virtual void copyCollectionFromRemote(OperationContext* txn,
+ virtual void copyCollectionFromRemote(OperationContext* opCtx,
const NamespaceString& nss) const = 0;
/**
diff --git a/src/mongo/db/repl/rollback_source_impl.cpp b/src/mongo/db/repl/rollback_source_impl.cpp
index 27513953dca..226edcc0a63 100644
--- a/src/mongo/db/repl/rollback_source_impl.cpp
+++ b/src/mongo/db/repl/rollback_source_impl.cpp
@@ -68,7 +68,7 @@ BSONObj RollbackSourceImpl::findOne(const NamespaceString& nss, const BSONObj& f
return _getConnection()->findOne(nss.toString(), filter, NULL, QueryOption_SlaveOk).getOwned();
}
-void RollbackSourceImpl::copyCollectionFromRemote(OperationContext* txn,
+void RollbackSourceImpl::copyCollectionFromRemote(OperationContext* opCtx,
const NamespaceString& nss) const {
std::string errmsg;
std::unique_ptr<DBClientConnection> tmpConn(new DBClientConnection());
@@ -82,7 +82,7 @@ void RollbackSourceImpl::copyCollectionFromRemote(OperationContext* txn,
uassert(15909,
str::stream() << "replSet rollback error resyncing collection " << nss.ns() << ' '
<< errmsg,
- cloner.copyCollection(txn, nss.ns(), BSONObj(), errmsg, true));
+ cloner.copyCollection(opCtx, nss.ns(), BSONObj(), errmsg, true));
}
StatusWith<BSONObj> RollbackSourceImpl::getCollectionInfo(const NamespaceString& nss) const {
diff --git a/src/mongo/db/repl/rollback_source_impl.h b/src/mongo/db/repl/rollback_source_impl.h
index fe4b7a8aad1..55f9237949b 100644
--- a/src/mongo/db/repl/rollback_source_impl.h
+++ b/src/mongo/db/repl/rollback_source_impl.h
@@ -64,7 +64,8 @@ public:
BSONObj findOne(const NamespaceString& nss, const BSONObj& filter) const override;
- void copyCollectionFromRemote(OperationContext* txn, const NamespaceString& nss) const override;
+ void copyCollectionFromRemote(OperationContext* opCtx,
+ const NamespaceString& nss) const override;
StatusWith<BSONObj> getCollectionInfo(const NamespaceString& nss) const override;
diff --git a/src/mongo/db/repl/rs_initialsync.cpp b/src/mongo/db/repl/rs_initialsync.cpp
index 073afcc73ec..a6a5cf78baf 100644
--- a/src/mongo/db/repl/rs_initialsync.cpp
+++ b/src/mongo/db/repl/rs_initialsync.cpp
@@ -84,16 +84,16 @@ MONGO_EXPORT_SERVER_PARAMETER(num3Dot2InitialSyncAttempts, int, 10);
* Also resets the bgsync thread so that it reconnects its sync source after the oplog has been
* truncated.
*/
-void truncateAndResetOplog(OperationContext* txn,
+void truncateAndResetOplog(OperationContext* opCtx,
ReplicationCoordinator* replCoord,
BackgroundSync* bgsync) {
// Add field to minvalid document to tell us to restart initial sync if we crash
- StorageInterface::get(txn)->setInitialSyncFlag(txn);
+ StorageInterface::get(opCtx)->setInitialSyncFlag(opCtx);
- AutoGetDb autoDb(txn, "local", MODE_X);
+ AutoGetDb autoDb(opCtx, "local", MODE_X);
massert(28585, "no local database found", autoDb.getDb());
- invariant(txn->lockState()->isCollectionLockedForMode(rsOplogName, MODE_X));
+ invariant(opCtx->lockState()->isCollectionLockedForMode(rsOplogName, MODE_X));
// Note: the following order is important.
// The bgsync thread uses an empty optime as a sentinel to know to wait
// for initial sync; thus, we must
@@ -104,7 +104,7 @@ void truncateAndResetOplog(OperationContext* txn,
replCoord->resetMyLastOpTimes();
bgsync->stop(true);
bgsync->startProducerIfStopped();
- bgsync->clearBuffer(txn);
+ bgsync->clearBuffer(opCtx);
replCoord->clearSyncSourceBlacklist();
@@ -112,15 +112,15 @@ void truncateAndResetOplog(OperationContext* txn,
Collection* collection = autoDb.getDb()->getCollection(rsOplogName);
fassert(28565, collection);
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- WriteUnitOfWork wunit(txn);
- Status status = collection->truncate(txn);
+ WriteUnitOfWork wunit(opCtx);
+ Status status = collection->truncate(opCtx);
fassert(28564, status);
wunit.commit();
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "truncate", collection->ns().ns());
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "truncate", collection->ns().ns());
}
-bool _initialSyncClone(OperationContext* txn,
+bool _initialSyncClone(OperationContext* opCtx,
Cloner& cloner,
const std::string& host,
const std::string& db,
@@ -144,10 +144,10 @@ bool _initialSyncClone(OperationContext* txn,
options.createCollections = false;
// Make database stable
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock dbWrite(txn->lockState(), db, MODE_X);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock dbWrite(opCtx->lockState(), db, MODE_X);
- Status status = cloner.copyDb(txn, db, host, options, nullptr, collections);
+ Status status = cloner.copyDb(opCtx, db, host, options, nullptr, collections);
if (!status.isOK()) {
log() << "initial sync: error while " << (dataPass ? "cloning " : "indexing ") << db
<< ". " << redact(status);
@@ -155,7 +155,7 @@ bool _initialSyncClone(OperationContext* txn,
}
if (dataPass && (db == "admin")) {
- fassertNoTrace(28619, checkAdminDatabase(txn, dbHolder().get(txn, db)));
+ fassertNoTrace(28619, checkAdminDatabase(opCtx, dbHolder().get(opCtx, db)));
}
return true;
}
@@ -167,7 +167,7 @@ bool _initialSyncClone(OperationContext* txn,
* @param r the oplog reader.
* @return if applying the oplog succeeded.
*/
-bool _initialSyncApplyOplog(OperationContext* txn,
+bool _initialSyncApplyOplog(OperationContext* opCtx,
repl::InitialSync* syncer,
OplogReader* r,
BackgroundSync* bgsync) {
@@ -178,7 +178,7 @@ bool _initialSyncApplyOplog(OperationContext* txn,
if (MONGO_FAIL_POINT(failInitSyncWithBufferedEntriesLeft)) {
log() << "adding fake oplog entry to buffer.";
bgsync->pushTestOpToBuffer(
- txn,
+ opCtx,
BSON("ts" << startOpTime.getTimestamp() << "t" << startOpTime.getTerm() << "v" << 1
<< "op"
<< "n"));
@@ -222,7 +222,7 @@ bool _initialSyncApplyOplog(OperationContext* txn,
// apply till stopOpTime
try {
LOG(2) << "Applying oplog entries from " << startOpTime << " until " << stopOpTime;
- syncer->oplogApplication(txn, stopOpTime);
+ syncer->oplogApplication(opCtx, stopOpTime);
if (globalInShutdownDeprecated()) {
return false;
@@ -262,15 +262,15 @@ bool _initialSyncApplyOplog(OperationContext* txn,
* ErrorCode::InitialSyncOplogSourceMissing if the node fails to find an sync source, Status::OK
* if everything worked, and ErrorCode::InitialSyncFailure for all other error cases.
*/
-Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
+Status _initialSync(OperationContext* opCtx, BackgroundSync* bgsync) {
log() << "initial sync pending";
- txn->setReplicatedWrites(false);
- DisableDocumentValidation validationDisabler(txn);
+ opCtx->setReplicatedWrites(false);
+ DisableDocumentValidation validationDisabler(opCtx);
ReplicationCoordinator* replCoord(getGlobalReplicationCoordinator());
// reset state for initial sync
- truncateAndResetOplog(txn, replCoord, bgsync);
+ truncateAndResetOplog(opCtx, replCoord, bgsync);
OplogReader r;
@@ -278,7 +278,7 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
while (r.getHost().empty()) {
// We must prime the sync source selector so that it considers all candidates regardless
// of oplog position, by passing in null OpTime as the last op fetched time.
- r.connectToSyncSource(txn, OpTime(), OpTime(), replCoord);
+ r.connectToSyncSource(opCtx, OpTime(), OpTime(), replCoord);
if (r.getHost().empty()) {
std::string msg =
@@ -306,7 +306,7 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
}
log() << "initial sync drop all databases";
- dropAllDatabasesExceptLocal(txn);
+ dropAllDatabasesExceptLocal(opCtx);
if (MONGO_FAIL_POINT(initialSyncHangBeforeCopyingDatabases)) {
log() << "initial sync - initialSyncHangBeforeCopyingDatabases fail point enabled. "
@@ -360,17 +360,17 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
createCollectionParams.push_back(params);
}
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock dbWrite(txn->lockState(), db, MODE_X);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock dbWrite(opCtx->lockState(), db, MODE_X);
- auto createStatus = cloner.createCollectionsForDb(txn, createCollectionParams, db);
+ auto createStatus = cloner.createCollectionsForDb(opCtx, createCollectionParams, db);
if (!createStatus.isOK()) {
return createStatus;
}
collectionsPerDb.emplace(db, std::move(collections));
}
for (auto&& dbCollsPair : collectionsPerDb) {
- if (!_initialSyncClone(txn,
+ if (!_initialSyncClone(opCtx,
cloner,
r.conn()->getServerAddress(),
dbCollsPair.first,
@@ -385,15 +385,15 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
// prime oplog, but don't need to actually apply the op as the cloned data already reflects it.
fassertStatusOK(
40142,
- StorageInterface::get(txn)->insertDocument(txn, NamespaceString(rsOplogName), lastOp));
+ StorageInterface::get(opCtx)->insertDocument(opCtx, NamespaceString(rsOplogName), lastOp));
OpTime lastOptime = OplogEntry(lastOp).getOpTime();
- ReplClientInfo::forClient(txn->getClient()).setLastOp(lastOptime);
+ ReplClientInfo::forClient(opCtx->getClient()).setLastOp(lastOptime);
replCoord->setMyLastAppliedOpTime(lastOptime);
setNewTimestamp(replCoord->getServiceContext(), lastOptime.getTimestamp());
std::string msg = "oplog sync 1 of 3";
log() << msg;
- if (!_initialSyncApplyOplog(txn, &init, &r, bgsync)) {
+ if (!_initialSyncApplyOplog(opCtx, &init, &r, bgsync)) {
return Status(ErrorCodes::InitialSyncFailure,
str::stream() << "initial sync failed: " << msg);
}
@@ -404,7 +404,7 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
// TODO: replace with "tail" instance below, since we don't need to retry/reclone missing docs.
msg = "oplog sync 2 of 3";
log() << msg;
- if (!_initialSyncApplyOplog(txn, &init, &r, bgsync)) {
+ if (!_initialSyncApplyOplog(opCtx, &init, &r, bgsync)) {
return Status(ErrorCodes::InitialSyncFailure,
str::stream() << "initial sync failed: " << msg);
}
@@ -413,7 +413,7 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
msg = "initial sync building indexes";
log() << msg;
for (auto&& dbCollsPair : collectionsPerDb) {
- if (!_initialSyncClone(txn,
+ if (!_initialSyncClone(opCtx,
cloner,
r.conn()->getServerAddress(),
dbCollsPair.first,
@@ -431,14 +431,14 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
log() << msg;
InitialSync tail(bgsync, multiSyncApply); // Use the non-initial sync apply code
- if (!_initialSyncApplyOplog(txn, &tail, &r, bgsync)) {
+ if (!_initialSyncApplyOplog(opCtx, &tail, &r, bgsync)) {
return Status(ErrorCodes::InitialSyncFailure,
str::stream() << "initial sync failed: " << msg);
}
// ---------
- Status status = getGlobalAuthorizationManager()->initialize(txn);
+ Status status = getGlobalAuthorizationManager()->initialize(opCtx);
if (!status.isOK()) {
warning() << "Failed to reinitialize auth data after initial sync. " << status;
return status;
@@ -448,7 +448,7 @@ Status _initialSync(OperationContext* txn, BackgroundSync* bgsync) {
// Initial sync is now complete.
// Clear the initial sync flag -- cannot be done under a db lock, or recursive.
- StorageInterface::get(txn)->clearInitialSyncFlag(txn);
+ StorageInterface::get(opCtx)->clearInitialSyncFlag(opCtx);
// Clear maint. mode.
while (replCoord->getMaintenanceMode()) {
@@ -463,20 +463,20 @@ stdx::mutex _initialSyncMutex;
const auto kInitialSyncRetrySleepDuration = Seconds{5};
} // namespace
-Status checkAdminDatabase(OperationContext* txn, Database* adminDb) {
- // Assumes txn holds MODE_X or MODE_S lock on "admin" database.
+Status checkAdminDatabase(OperationContext* opCtx, Database* adminDb) {
+ // Assumes opCtx holds MODE_X or MODE_S lock on "admin" database.
if (!adminDb) {
return Status::OK();
}
Collection* const usersCollection =
adminDb->getCollection(AuthorizationManager::usersCollectionNamespace);
const bool hasUsers =
- usersCollection && !Helpers::findOne(txn, usersCollection, BSONObj(), false).isNull();
+ usersCollection && !Helpers::findOne(opCtx, usersCollection, BSONObj(), false).isNull();
Collection* const adminVersionCollection =
adminDb->getCollection(AuthorizationManager::versionCollectionNamespace);
BSONObj authSchemaVersionDocument;
if (!adminVersionCollection ||
- !Helpers::findOne(txn,
+ !Helpers::findOne(opCtx,
adminVersionCollection,
AuthorizationManager::versionDocumentQuery,
authSchemaVersionDocument)) {
@@ -518,7 +518,7 @@ Status checkAdminDatabase(OperationContext* txn, Database* adminDb) {
return Status::OK();
}
-void syncDoInitialSync(OperationContext* txn,
+void syncDoInitialSync(OperationContext* opCtx,
ReplicationCoordinatorExternalState* replicationCoordinatorExternalState) {
stdx::unique_lock<stdx::mutex> lk(_initialSyncMutex, stdx::defer_lock);
if (!lk.try_lock()) {
@@ -530,21 +530,21 @@ void syncDoInitialSync(OperationContext* txn,
log() << "Starting replication fetcher thread for initial sync";
bgsync = stdx::make_unique<BackgroundSync>(
replicationCoordinatorExternalState,
- replicationCoordinatorExternalState->makeInitialSyncOplogBuffer(txn));
- bgsync->startup(txn);
- createOplog(txn);
+ replicationCoordinatorExternalState->makeInitialSyncOplogBuffer(opCtx));
+ bgsync->startup(opCtx);
+ createOplog(opCtx);
}
- ON_BLOCK_EXIT([txn, &bgsync]() {
+ ON_BLOCK_EXIT([opCtx, &bgsync]() {
log() << "Stopping replication fetcher thread for initial sync";
- bgsync->shutdown(txn);
- bgsync->join(txn);
+ bgsync->shutdown(opCtx);
+ bgsync->join(opCtx);
});
int failedAttempts = 0;
while (failedAttempts < num3Dot2InitialSyncAttempts.load()) {
try {
// leave loop when successful
- Status status = _initialSync(txn, bgsync.get());
+ Status status = _initialSync(opCtx, bgsync.get());
if (status.isOK()) {
break;
} else {
diff --git a/src/mongo/db/repl/rs_initialsync.h b/src/mongo/db/repl/rs_initialsync.h
index a7206ac5c2e..d621eb17954 100644
--- a/src/mongo/db/repl/rs_initialsync.h
+++ b/src/mongo/db/repl/rs_initialsync.h
@@ -41,13 +41,13 @@ class ReplicationCoordinatorExternalState;
* Begins an initial sync of a node. This drops all data, chooses a sync source,
* and runs the cloner from that sync source. The node's state is not changed.
*/
-void syncDoInitialSync(OperationContext* txn,
+void syncDoInitialSync(OperationContext* opCtx,
ReplicationCoordinatorExternalState* replicationCoordinatorExternalState);
/**
* Checks that the "admin" database contains a supported version of the auth data schema.
*/
-Status checkAdminDatabase(OperationContext* txn, Database* adminDb);
+Status checkAdminDatabase(OperationContext* opCtx, Database* adminDb);
} // namespace repl
} // namespace mongo
diff --git a/src/mongo/db/repl/rs_rollback.cpp b/src/mongo/db/repl/rs_rollback.cpp
index dc5894cafc8..dbfb3a51284 100644
--- a/src/mongo/db/repl/rs_rollback.cpp
+++ b/src/mongo/db/repl/rs_rollback.cpp
@@ -335,7 +335,7 @@ namespace {
* information from the upstream node. If any information is fetched from the upstream node after we
* have written locally, the function must be called again.
*/
-void checkRbidAndUpdateMinValid(OperationContext* txn,
+void checkRbidAndUpdateMinValid(OperationContext* opCtx,
const int rbid,
const RollbackSource& rollbackSource) {
// It is important that the steps are performed in order to avoid racing with upstream rollbacks
@@ -357,8 +357,8 @@ void checkRbidAndUpdateMinValid(OperationContext* txn,
// online until we get to that point in freshness.
OpTime minValid = fassertStatusOK(28774, OpTime::parseFromOplogEntry(newMinValidDoc));
log() << "Setting minvalid to " << minValid;
- StorageInterface::get(txn)->setAppliedThrough(txn, {}); // Use top of oplog.
- StorageInterface::get(txn)->setMinValid(txn, minValid);
+ StorageInterface::get(opCtx)->setAppliedThrough(opCtx, {}); // Use top of oplog.
+ StorageInterface::get(opCtx)->setMinValid(opCtx, minValid);
if (MONGO_FAIL_POINT(rollbackHangThenFailAfterWritingMinValid)) {
// This log output is used in js tests so please leave it.
@@ -373,7 +373,7 @@ void checkRbidAndUpdateMinValid(OperationContext* txn,
}
}
-void syncFixUp(OperationContext* txn,
+void syncFixUp(OperationContext* opCtx,
const FixUpInfo& fixUpInfo,
const RollbackSource& rollbackSource,
ReplicationCoordinator* replCoord) {
@@ -415,7 +415,7 @@ void syncFixUp(OperationContext* txn,
}
log() << "rollback 3.5";
- checkRbidAndUpdateMinValid(txn, fixUpInfo.rbid, rollbackSource);
+ checkRbidAndUpdateMinValid(opCtx, fixUpInfo.rbid, rollbackSource);
// update them
log() << "rollback 4 n:" << goodVersions.size();
@@ -435,25 +435,25 @@ void syncFixUp(OperationContext* txn,
{
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock dbLock(txn->lockState(), nss.db(), MODE_X);
- Database* db = dbHolder().openDb(txn, nss.db().toString());
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock dbLock(opCtx->lockState(), nss.db(), MODE_X);
+ Database* db = dbHolder().openDb(opCtx, nss.db().toString());
invariant(db);
- WriteUnitOfWork wunit(txn);
- fassertStatusOK(40359, db->dropCollectionEvenIfSystem(txn, nss));
+ WriteUnitOfWork wunit(opCtx);
+ fassertStatusOK(40359, db->dropCollectionEvenIfSystem(opCtx, nss));
wunit.commit();
}
- rollbackSource.copyCollectionFromRemote(txn, nss);
+ rollbackSource.copyCollectionFromRemote(opCtx, nss);
}
for (const string& ns : fixUpInfo.collectionsToResyncMetadata) {
log() << "rollback 4.1.2 coll metadata resync " << ns;
const NamespaceString nss(ns);
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock dbLock(txn->lockState(), nss.db(), MODE_X);
- auto db = dbHolder().openDb(txn, nss.db().toString());
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock dbLock(opCtx->lockState(), nss.db(), MODE_X);
+ auto db = dbHolder().openDb(opCtx, nss.db().toString());
invariant(db);
auto collection = db->getCollection(ns);
invariant(collection);
@@ -490,23 +490,23 @@ void syncFixUp(OperationContext* txn,
// Use default options.
}
- WriteUnitOfWork wuow(txn);
- if (options.flagsSet || cce->getCollectionOptions(txn).flagsSet) {
- cce->updateFlags(txn, options.flags);
+ WriteUnitOfWork wuow(opCtx);
+ if (options.flagsSet || cce->getCollectionOptions(opCtx).flagsSet) {
+ cce->updateFlags(opCtx, options.flags);
}
- auto status = collection->setValidator(txn, options.validator);
+ auto status = collection->setValidator(opCtx, options.validator);
if (!status.isOK()) {
throw RSFatalException(str::stream() << "Failed to set validator: "
<< status.toString());
}
- status = collection->setValidationAction(txn, options.validationAction);
+ status = collection->setValidationAction(opCtx, options.validationAction);
if (!status.isOK()) {
throw RSFatalException(str::stream() << "Failed to set validationAction: "
<< status.toString());
}
- status = collection->setValidationLevel(txn, options.validationLevel);
+ status = collection->setValidationLevel(opCtx, options.validationLevel);
if (!status.isOK()) {
throw RSFatalException(str::stream() << "Failed to set validationLevel: "
<< status.toString());
@@ -518,7 +518,7 @@ void syncFixUp(OperationContext* txn,
// we did more reading from primary, so check it again for a rollback (which would mess
// us up), and make minValid newer.
log() << "rollback 4.2";
- checkRbidAndUpdateMinValid(txn, fixUpInfo.rbid, rollbackSource);
+ checkRbidAndUpdateMinValid(opCtx, fixUpInfo.rbid, rollbackSource);
}
log() << "rollback 4.6";
@@ -530,16 +530,16 @@ void syncFixUp(OperationContext* txn,
invariant(!fixUpInfo.indexesToDrop.count(*it));
- ScopedTransaction transaction(txn, MODE_IX);
+ ScopedTransaction transaction(opCtx, MODE_IX);
const NamespaceString nss(*it);
- Lock::DBLock dbLock(txn->lockState(), nss.db(), MODE_X);
- Database* db = dbHolder().get(txn, nsToDatabaseSubstring(*it));
+ Lock::DBLock dbLock(opCtx->lockState(), nss.db(), MODE_X);
+ Database* db = dbHolder().get(opCtx, nsToDatabaseSubstring(*it));
if (db) {
Helpers::RemoveSaver removeSaver("rollback", "", *it);
// perform a collection scan and write all documents in the collection to disk
std::unique_ptr<PlanExecutor> exec(InternalPlanner::collectionScan(
- txn, *it, db->getCollection(*it), PlanExecutor::YIELD_AUTO));
+ opCtx, *it, db->getCollection(*it), PlanExecutor::YIELD_AUTO));
BSONObj curObj;
PlanExecutor::ExecState execState;
while (PlanExecutor::ADVANCED == (execState = exec->getNext(&curObj, NULL))) {
@@ -564,8 +564,8 @@ void syncFixUp(OperationContext* txn,
throw RSFatalException();
}
- WriteUnitOfWork wunit(txn);
- fassertStatusOK(40360, db->dropCollectionEvenIfSystem(txn, nss));
+ WriteUnitOfWork wunit(opCtx);
+ fassertStatusOK(40360, db->dropCollectionEvenIfSystem(opCtx, nss));
wunit.commit();
}
}
@@ -576,9 +576,9 @@ void syncFixUp(OperationContext* txn,
const string& indexName = it->second;
log() << "rollback drop index: collection: " << nss.toString() << ". index: " << indexName;
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock dbLock(txn->lockState(), nss.db(), MODE_X);
- auto db = dbHolder().get(txn, nss.db());
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock dbLock(opCtx->lockState(), nss.db(), MODE_X);
+ auto db = dbHolder().get(opCtx, nss.db());
if (!db) {
continue;
}
@@ -592,14 +592,14 @@ void syncFixUp(OperationContext* txn,
}
bool includeUnfinishedIndexes = false;
auto indexDescriptor =
- indexCatalog->findIndexByName(txn, indexName, includeUnfinishedIndexes);
+ indexCatalog->findIndexByName(opCtx, indexName, includeUnfinishedIndexes);
if (!indexDescriptor) {
warning() << "rollback failed to drop index " << indexName << " in " << nss.toString()
<< ": index not found";
continue;
}
- WriteUnitOfWork wunit(txn);
- auto status = indexCatalog->dropIndex(txn, indexDescriptor);
+ WriteUnitOfWork wunit(opCtx);
+ auto status = indexCatalog->dropIndex(opCtx, indexDescriptor);
if (!status.isOK()) {
severe() << "rollback failed to drop index " << indexName << " in " << nss.toString()
<< ": " << status;
@@ -637,9 +637,9 @@ void syncFixUp(OperationContext* txn,
// TODO: Lots of overhead in context. This can be faster.
const NamespaceString docNss(doc.ns);
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock docDbLock(txn->lockState(), docNss.db(), MODE_X);
- OldClientContext ctx(txn, doc.ns);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock docDbLock(opCtx->lockState(), docNss.db(), MODE_X);
+ OldClientContext ctx(opCtx, doc.ns);
Collection* collection = ctx.db()->getCollection(doc.ns);
@@ -651,7 +651,7 @@ void syncFixUp(OperationContext* txn,
// createCollection command and regardless, the document no longer exists.
if (collection && removeSaver) {
BSONObj obj;
- bool found = Helpers::findOne(txn, collection, pattern, obj, false);
+ bool found = Helpers::findOne(opCtx, collection, pattern, obj, false);
if (found) {
auto status = removeSaver->goingToDelete(obj);
if (!status.isOK()) {
@@ -680,9 +680,9 @@ void syncFixUp(OperationContext* txn,
// TODO: IIRC cappedTruncateAfter does not handle completely
// empty.
// this will crazy slow if no _id index.
- const auto clock = txn->getServiceContext()->getFastClockSource();
+ const auto clock = opCtx->getServiceContext()->getFastClockSource();
const auto findOneStart = clock->now();
- RecordId loc = Helpers::findOne(txn, collection, pattern, false);
+ RecordId loc = Helpers::findOne(opCtx, collection, pattern, false);
if (clock->now() - findOneStart > Milliseconds(200))
warning() << "roll back slow no _id index for " << doc.ns
<< " perhaps?";
@@ -690,17 +690,17 @@ void syncFixUp(OperationContext* txn,
// RecordId loc = Helpers::findById(nsd, pattern);
if (!loc.isNull()) {
try {
- collection->cappedTruncateAfter(txn, loc, true);
+ collection->cappedTruncateAfter(opCtx, loc, true);
} catch (const DBException& e) {
if (e.getCode() == 13415) {
// hack: need to just make cappedTruncate do this...
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- WriteUnitOfWork wunit(txn);
- uassertStatusOK(collection->truncate(txn));
+ WriteUnitOfWork wunit(opCtx);
+ uassertStatusOK(collection->truncate(opCtx));
wunit.commit();
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
- txn, "truncate", collection->ns().ns());
+ opCtx, "truncate", collection->ns().ns());
} else {
throw e;
}
@@ -717,7 +717,7 @@ void syncFixUp(OperationContext* txn,
<< ": " << redact(e);
}
} else {
- deleteObjects(txn,
+ deleteObjects(opCtx,
collection,
doc.ns,
pattern,
@@ -740,7 +740,7 @@ void syncFixUp(OperationContext* txn,
UpdateLifecycleImpl updateLifecycle(requestNs);
request.setLifecycle(&updateLifecycle);
- update(txn, ctx.db(), request);
+ update(opCtx, ctx.db(), request);
}
} catch (const DBException& e) {
log() << "exception in rollback ns:" << doc.ns << ' ' << pattern.toString() << ' '
@@ -757,10 +757,10 @@ void syncFixUp(OperationContext* txn,
LOG(2) << "rollback truncate oplog after " << fixUpInfo.commonPoint.toString();
{
const NamespaceString oplogNss(rsOplogName);
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock oplogDbLock(txn->lockState(), oplogNss.db(), MODE_IX);
- Lock::CollectionLock oplogCollectionLoc(txn->lockState(), oplogNss.ns(), MODE_X);
- OldClientContext ctx(txn, rsOplogName);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock oplogDbLock(opCtx->lockState(), oplogNss.db(), MODE_IX);
+ Lock::CollectionLock oplogCollectionLoc(opCtx->lockState(), oplogNss.ns(), MODE_X);
+ OldClientContext ctx(opCtx, rsOplogName);
Collection* oplogCollection = ctx.db()->getCollection(rsOplogName);
if (!oplogCollection) {
fassertFailedWithStatusNoTrace(13423,
@@ -768,10 +768,10 @@ void syncFixUp(OperationContext* txn,
str::stream() << "Can't find " << rsOplogName));
}
// TODO: fatal error if this throws?
- oplogCollection->cappedTruncateAfter(txn, fixUpInfo.commonPointOurDiskloc, false);
+ oplogCollection->cappedTruncateAfter(opCtx, fixUpInfo.commonPointOurDiskloc, false);
}
- Status status = getGlobalAuthorizationManager()->initialize(txn);
+ Status status = getGlobalAuthorizationManager()->initialize(opCtx);
if (!status.isOK()) {
severe() << "Failed to reinitialize auth data after rollback: " << status;
fassertFailedNoTrace(40366);
@@ -779,16 +779,16 @@ void syncFixUp(OperationContext* txn,
// Reload the lastAppliedOpTime and lastDurableOpTime value in the replcoord and the
// lastAppliedHash value in bgsync to reflect our new last op.
- replCoord->resetLastOpTimesFromOplog(txn);
+ replCoord->resetLastOpTimesFromOplog(opCtx);
log() << "rollback done";
}
-Status _syncRollback(OperationContext* txn,
+Status _syncRollback(OperationContext* opCtx,
const OplogInterface& localOplog,
const RollbackSource& rollbackSource,
boost::optional<int> requiredRBID,
ReplicationCoordinator* replCoord) {
- invariant(!txn->lockState()->isLocked());
+ invariant(!opCtx->lockState()->isLocked());
FixUpInfo how;
log() << "rollback 1";
@@ -833,7 +833,7 @@ Status _syncRollback(OperationContext* txn,
log() << "rollback 3 fixup";
try {
ON_BLOCK_EXIT([&] { replCoord->incrementRollbackID(); });
- syncFixUp(txn, how, rollbackSource, replCoord);
+ syncFixUp(opCtx, how, rollbackSource, replCoord);
} catch (const RSFatalException& e) {
return Status(ErrorCodes::UnrecoverableRollbackError, e.what(), 18753);
}
@@ -853,19 +853,19 @@ Status _syncRollback(OperationContext* txn,
} // namespace
-Status syncRollback(OperationContext* txn,
+Status syncRollback(OperationContext* opCtx,
const OplogInterface& localOplog,
const RollbackSource& rollbackSource,
boost::optional<int> requiredRBID,
ReplicationCoordinator* replCoord) {
- invariant(txn);
+ invariant(opCtx);
invariant(replCoord);
log() << "beginning rollback" << rsLog;
- DisableDocumentValidation validationDisabler(txn);
- UnreplicatedWritesBlock replicationDisabler(txn);
- Status status = _syncRollback(txn, localOplog, rollbackSource, requiredRBID, replCoord);
+ DisableDocumentValidation validationDisabler(opCtx);
+ UnreplicatedWritesBlock replicationDisabler(opCtx);
+ Status status = _syncRollback(opCtx, localOplog, rollbackSource, requiredRBID, replCoord);
log() << "rollback finished" << rsLog;
return status;
diff --git a/src/mongo/db/repl/rs_rollback.h b/src/mongo/db/repl/rs_rollback.h
index 8ee7dd04367..58dd4a27d4f 100644
--- a/src/mongo/db/repl/rs_rollback.h
+++ b/src/mongo/db/repl/rs_rollback.h
@@ -59,7 +59,7 @@ class RollbackSource;
* This function runs a command on the sync source to detect if the sync source rolls back
* while our rollback is in progress.
*
- * @param txn Used to read and write from this node's databases
+ * @param opCtx Used to read and write from this node's databases
* @param localOplog reads the oplog on this server.
* @param rollbackSource interface for sync source:
* provides oplog; and
@@ -73,7 +73,7 @@ class RollbackSource;
* fatally. All other errors should be considered recoverable regardless of whether reported as a
* status or exception.
*/
-Status syncRollback(OperationContext* txn,
+Status syncRollback(OperationContext* opCtx,
const OplogInterface& localOplog,
const RollbackSource& rollbackSource,
boost::optional<int> requiredRBID,
diff --git a/src/mongo/db/repl/rs_rollback_test.cpp b/src/mongo/db/repl/rs_rollback_test.cpp
index 988fe98face..22e7a677fea 100644
--- a/src/mongo/db/repl/rs_rollback_test.cpp
+++ b/src/mongo/db/repl/rs_rollback_test.cpp
@@ -79,7 +79,7 @@ class ReplicationCoordinatorRollbackMock : public ReplicationCoordinatorMock {
public:
ReplicationCoordinatorRollbackMock(ServiceContext* service)
: ReplicationCoordinatorMock(service, createReplSettings()) {}
- void resetLastOpTimesFromOplog(OperationContext* txn) override {}
+ void resetLastOpTimesFromOplog(OperationContext* opCtx) override {}
};
@@ -90,7 +90,8 @@ public:
const OplogInterface& getOplog() const override;
BSONObj getLastOperation() const override;
BSONObj findOne(const NamespaceString& nss, const BSONObj& filter) const override;
- void copyCollectionFromRemote(OperationContext* txn, const NamespaceString& nss) const override;
+ void copyCollectionFromRemote(OperationContext* opCtx,
+ const NamespaceString& nss) const override;
StatusWith<BSONObj> getCollectionInfo(const NamespaceString& nss) const override;
private:
@@ -119,7 +120,7 @@ BSONObj RollbackSourceMock::findOne(const NamespaceString& nss, const BSONObj& f
return BSONObj();
}
-void RollbackSourceMock::copyCollectionFromRemote(OperationContext* txn,
+void RollbackSourceMock::copyCollectionFromRemote(OperationContext* opCtx,
const NamespaceString& nss) const {}
StatusWith<BSONObj> RollbackSourceMock::getCollectionInfo(const NamespaceString& nss) const {
@@ -128,7 +129,7 @@ StatusWith<BSONObj> RollbackSourceMock::getCollectionInfo(const NamespaceString&
class RSRollbackTest : public ServiceContextMongoDTest {
protected:
- ServiceContext::UniqueOperationContext _txn;
+ ServiceContext::UniqueOperationContext _opCtx;
// Owned by service context
ReplicationCoordinator* _coordinator;
@@ -140,8 +141,8 @@ private:
void RSRollbackTest::setUp() {
ServiceContextMongoDTest::setUp();
- _txn = cc().makeOperationContext();
- _coordinator = new ReplicationCoordinatorRollbackMock(_txn->getServiceContext());
+ _opCtx = cc().makeOperationContext();
+ _coordinator = new ReplicationCoordinatorRollbackMock(_opCtx->getServiceContext());
auto serviceContext = getServiceContext();
ReplicationCoordinator::set(serviceContext,
@@ -149,22 +150,22 @@ void RSRollbackTest::setUp() {
StorageInterface::set(serviceContext, stdx::make_unique<StorageInterfaceMock>());
setOplogCollectionName();
- repl::StorageInterface::get(_txn.get())->setAppliedThrough(_txn.get(), OpTime{});
- repl::StorageInterface::get(_txn.get())->setMinValid(_txn.get(), OpTime{});
+ repl::StorageInterface::get(_opCtx.get())->setAppliedThrough(_opCtx.get(), OpTime{});
+ repl::StorageInterface::get(_opCtx.get())->setMinValid(_opCtx.get(), OpTime{});
}
void RSRollbackTest::tearDown() {
- _txn.reset();
+ _opCtx.reset();
ServiceContextMongoDTest::tearDown();
setGlobalReplicationCoordinator(nullptr);
}
TEST_F(RSRollbackTest, InconsistentMinValid) {
- repl::StorageInterface::get(_txn.get())
- ->setAppliedThrough(_txn.get(), OpTime(Timestamp(Seconds(0), 0), 0));
- repl::StorageInterface::get(_txn.get())
- ->setMinValid(_txn.get(), OpTime(Timestamp(Seconds(1), 0), 0));
- auto status = syncRollback(_txn.get(),
+ repl::StorageInterface::get(_opCtx.get())
+ ->setAppliedThrough(_opCtx.get(), OpTime(Timestamp(Seconds(0), 0), 0));
+ repl::StorageInterface::get(_opCtx.get())
+ ->setMinValid(_opCtx.get(), OpTime(Timestamp(Seconds(1), 0), 0));
+ auto status = syncRollback(_opCtx.get(),
OplogInterfaceMock(kEmptyMockOperations),
RollbackSourceMock(std::unique_ptr<OplogInterface>(
new OplogInterfaceMock(kEmptyMockOperations))),
@@ -180,7 +181,7 @@ TEST_F(RSRollbackTest, OplogStartMissing) {
std::make_pair(BSON("ts" << ts.getTimestamp() << "h" << ts.getTerm()), RecordId());
ASSERT_EQUALS(
ErrorCodes::OplogStartMissing,
- syncRollback(_txn.get(),
+ syncRollback(_opCtx.get(),
OplogInterfaceMock(kEmptyMockOperations),
RollbackSourceMock(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
operation,
@@ -194,7 +195,7 @@ TEST_F(RSRollbackTest, NoRemoteOpLog) {
OpTime ts(Timestamp(Seconds(1), 0), 0);
auto operation =
std::make_pair(BSON("ts" << ts.getTimestamp() << "h" << ts.getTerm()), RecordId());
- auto status = syncRollback(_txn.get(),
+ auto status = syncRollback(_opCtx.get(),
OplogInterfaceMock({operation}),
RollbackSourceMock(std::unique_ptr<OplogInterface>(
new OplogInterfaceMock(kEmptyMockOperations))),
@@ -216,7 +217,7 @@ TEST_F(RSRollbackTest, RemoteGetRollbackIdThrows) {
uassert(ErrorCodes::UnknownError, "getRollbackId() failed", false);
}
};
- ASSERT_THROWS_CODE(syncRollback(_txn.get(),
+ ASSERT_THROWS_CODE(syncRollback(_opCtx.get(),
OplogInterfaceMock({operation}),
RollbackSourceLocal(std::unique_ptr<OplogInterface>(
new OplogInterfaceMock(kEmptyMockOperations))),
@@ -239,7 +240,7 @@ TEST_F(RSRollbackTest, RemoteGetRollbackIdDiffersFromRequiredRBID) {
}
};
- ASSERT_THROWS_CODE(syncRollback(_txn.get(),
+ ASSERT_THROWS_CODE(syncRollback(_opCtx.get(),
OplogInterfaceMock({operation}),
RollbackSourceLocal(std::unique_ptr<OplogInterface>(
new OplogInterfaceMock(kEmptyMockOperations))),
@@ -250,12 +251,12 @@ TEST_F(RSRollbackTest, RemoteGetRollbackIdDiffersFromRequiredRBID) {
}
TEST_F(RSRollbackTest, BothOplogsAtCommonPoint) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
OpTime ts(Timestamp(Seconds(1), 0), 1);
auto operation =
std::make_pair(BSON("ts" << ts.getTimestamp() << "h" << ts.getTerm()), RecordId(1));
ASSERT_OK(
- syncRollback(_txn.get(),
+ syncRollback(_opCtx.get(),
OplogInterfaceMock({operation}),
RollbackSourceMock(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
operation,
@@ -268,24 +269,24 @@ TEST_F(RSRollbackTest, BothOplogsAtCommonPoint) {
* Create test collection.
* Returns collection.
*/
-Collection* _createCollection(OperationContext* txn,
+Collection* _createCollection(OperationContext* opCtx,
const NamespaceString& nss,
const CollectionOptions& options) {
- Lock::DBLock dbLock(txn->lockState(), nss.db(), MODE_X);
- mongo::WriteUnitOfWork wuow(txn);
- auto db = dbHolder().openDb(txn, nss.db());
+ Lock::DBLock dbLock(opCtx->lockState(), nss.db(), MODE_X);
+ mongo::WriteUnitOfWork wuow(opCtx);
+ auto db = dbHolder().openDb(opCtx, nss.db());
ASSERT_TRUE(db);
- db->dropCollection(txn, nss.ns());
- auto coll = db->createCollection(txn, nss.ns(), options);
+ db->dropCollection(opCtx, nss.ns());
+ auto coll = db->createCollection(opCtx, nss.ns(), options);
ASSERT_TRUE(coll);
wuow.commit();
return coll;
}
-Collection* _createCollection(OperationContext* txn,
+Collection* _createCollection(OperationContext* opCtx,
const std::string& nss,
const CollectionOptions& options) {
- return _createCollection(txn, NamespaceString(nss), options);
+ return _createCollection(opCtx, NamespaceString(nss), options);
}
/**
@@ -293,7 +294,7 @@ Collection* _createCollection(OperationContext* txn,
* Returns number of records in collection after rolling back delete operation.
* If collection does not exist after rolling back, returns -1.
*/
-int _testRollbackDelete(OperationContext* txn,
+int _testRollbackDelete(OperationContext* opCtx,
ReplicationCoordinator* coordinator,
const BSONObj& documentAtSource) {
auto commonOperation =
@@ -325,54 +326,54 @@ int _testRollbackDelete(OperationContext* txn,
std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
commonOperation,
})));
- ASSERT_OK(syncRollback(txn,
+ ASSERT_OK(syncRollback(opCtx,
OplogInterfaceMock({deleteOperation, commonOperation}),
rollbackSource,
{},
coordinator));
ASSERT_TRUE(rollbackSource.called);
- Lock::DBLock dbLock(txn->lockState(), "test", MODE_S);
- Lock::CollectionLock collLock(txn->lockState(), "test.t", MODE_S);
- auto db = dbHolder().get(txn, "test");
+ Lock::DBLock dbLock(opCtx->lockState(), "test", MODE_S);
+ Lock::CollectionLock collLock(opCtx->lockState(), "test.t", MODE_S);
+ auto db = dbHolder().get(opCtx, "test");
ASSERT_TRUE(db);
auto collection = db->getCollection("test.t");
if (!collection) {
return -1;
}
- return collection->getRecordStore()->numRecords(txn);
+ return collection->getRecordStore()->numRecords(opCtx);
}
TEST_F(RSRollbackTest, RollbackDeleteNoDocumentAtSourceCollectionDoesNotExist) {
- createOplog(_txn.get());
- ASSERT_EQUALS(-1, _testRollbackDelete(_txn.get(), _coordinator, BSONObj()));
+ createOplog(_opCtx.get());
+ ASSERT_EQUALS(-1, _testRollbackDelete(_opCtx.get(), _coordinator, BSONObj()));
}
TEST_F(RSRollbackTest, RollbackDeleteNoDocumentAtSourceCollectionExistsNonCapped) {
- createOplog(_txn.get());
- _createCollection(_txn.get(), "test.t", CollectionOptions());
- _testRollbackDelete(_txn.get(), _coordinator, BSONObj());
- ASSERT_EQUALS(0, _testRollbackDelete(_txn.get(), _coordinator, BSONObj()));
+ createOplog(_opCtx.get());
+ _createCollection(_opCtx.get(), "test.t", CollectionOptions());
+ _testRollbackDelete(_opCtx.get(), _coordinator, BSONObj());
+ ASSERT_EQUALS(0, _testRollbackDelete(_opCtx.get(), _coordinator, BSONObj()));
}
TEST_F(RSRollbackTest, RollbackDeleteNoDocumentAtSourceCollectionExistsCapped) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
CollectionOptions options;
options.capped = true;
- _createCollection(_txn.get(), "test.t", options);
- ASSERT_EQUALS(0, _testRollbackDelete(_txn.get(), _coordinator, BSONObj()));
+ _createCollection(_opCtx.get(), "test.t", options);
+ ASSERT_EQUALS(0, _testRollbackDelete(_opCtx.get(), _coordinator, BSONObj()));
}
TEST_F(RSRollbackTest, RollbackDeleteRestoreDocument) {
- createOplog(_txn.get());
- _createCollection(_txn.get(), "test.t", CollectionOptions());
+ createOplog(_opCtx.get());
+ _createCollection(_opCtx.get(), "test.t", CollectionOptions());
BSONObj doc = BSON("_id" << 0 << "a" << 1);
- _testRollbackDelete(_txn.get(), _coordinator, doc);
- ASSERT_EQUALS(1, _testRollbackDelete(_txn.get(), _coordinator, doc));
+ _testRollbackDelete(_opCtx.get(), _coordinator, doc);
+ ASSERT_EQUALS(1, _testRollbackDelete(_opCtx.get(), _coordinator, doc));
}
TEST_F(RSRollbackTest, RollbackInsertDocumentWithNoId) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
auto insertDocumentOperation =
@@ -400,7 +401,7 @@ TEST_F(RSRollbackTest, RollbackInsertDocumentWithNoId) {
commonOperation,
})));
startCapturingLogMessages();
- auto status = syncRollback(_txn.get(),
+ auto status = syncRollback(_opCtx.get(),
OplogInterfaceMock({insertDocumentOperation, commonOperation}),
rollbackSource,
{},
@@ -413,8 +414,8 @@ TEST_F(RSRollbackTest, RollbackInsertDocumentWithNoId) {
}
TEST_F(RSRollbackTest, RollbackCreateIndexCommand) {
- createOplog(_txn.get());
- auto collection = _createCollection(_txn.get(), "test.t", CollectionOptions());
+ createOplog(_opCtx.get());
+ auto collection = _createCollection(_opCtx.get(), "test.t", CollectionOptions());
auto indexSpec = BSON("ns"
<< "test.t"
<< "key"
@@ -424,15 +425,15 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommand) {
<< "v"
<< static_cast<int>(kIndexVersion));
{
- Lock::DBLock dbLock(_txn->lockState(), "test", MODE_X);
- MultiIndexBlock indexer(_txn.get(), collection);
+ Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_X);
+ MultiIndexBlock indexer(_opCtx.get(), collection);
ASSERT_OK(indexer.init(indexSpec).getStatus());
- WriteUnitOfWork wunit(_txn.get());
+ WriteUnitOfWork wunit(_opCtx.get());
indexer.commit();
wunit.commit();
auto indexCatalog = collection->getIndexCatalog();
ASSERT(indexCatalog);
- ASSERT_EQUALS(2, indexCatalog->numIndexesReady(_txn.get()));
+ ASSERT_EQUALS(2, indexCatalog->numIndexesReady(_opCtx.get()));
}
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
@@ -448,7 +449,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommand) {
public:
RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
: RollbackSourceMock(std::move(oplog)), called(false) {}
- void copyCollectionFromRemote(OperationContext* txn,
+ void copyCollectionFromRemote(OperationContext* opCtx,
const NamespaceString& nss) const override {
called = true;
}
@@ -464,7 +465,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommand) {
// This can happen when an index is re-created with different options.
startCapturingLogMessages();
ASSERT_OK(syncRollback(
- _txn.get(),
+ _opCtx.get(),
OplogInterfaceMock({insertDocumentOperation, insertDocumentOperation, commonOperation}),
rollbackSource,
{},
@@ -474,16 +475,16 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommand) {
countLogLinesContaining("rollback drop index: collection: test.t. index: a_1"));
ASSERT_FALSE(rollbackSource.called);
{
- Lock::DBLock dbLock(_txn->lockState(), "test", MODE_S);
+ Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_S);
auto indexCatalog = collection->getIndexCatalog();
ASSERT(indexCatalog);
- ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_txn.get()));
+ ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_opCtx.get()));
}
}
TEST_F(RSRollbackTest, RollbackCreateIndexCommandIndexNotInCatalog) {
- createOplog(_txn.get());
- auto collection = _createCollection(_txn.get(), "test.t", CollectionOptions());
+ createOplog(_opCtx.get());
+ auto collection = _createCollection(_opCtx.get(), "test.t", CollectionOptions());
auto indexSpec = BSON("ns"
<< "test.t"
<< "key"
@@ -492,10 +493,10 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandIndexNotInCatalog) {
<< "a_1");
// Skip index creation to trigger warning during rollback.
{
- Lock::DBLock dbLock(_txn->lockState(), "test", MODE_S);
+ Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_S);
auto indexCatalog = collection->getIndexCatalog();
ASSERT(indexCatalog);
- ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_txn.get()));
+ ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_opCtx.get()));
}
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
@@ -511,7 +512,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandIndexNotInCatalog) {
public:
RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
: RollbackSourceMock(std::move(oplog)), called(false) {}
- void copyCollectionFromRemote(OperationContext* txn,
+ void copyCollectionFromRemote(OperationContext* opCtx,
const NamespaceString& nss) const override {
called = true;
}
@@ -524,7 +525,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandIndexNotInCatalog) {
commonOperation,
})));
startCapturingLogMessages();
- ASSERT_OK(syncRollback(_txn.get(),
+ ASSERT_OK(syncRollback(_opCtx.get(),
OplogInterfaceMock({insertDocumentOperation, commonOperation}),
rollbackSource,
{},
@@ -535,15 +536,15 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandIndexNotInCatalog) {
ASSERT_EQUALS(1, countLogLinesContaining("rollback failed to drop index a_1 in test.t"));
ASSERT_FALSE(rollbackSource.called);
{
- Lock::DBLock dbLock(_txn->lockState(), "test", MODE_S);
+ Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_S);
auto indexCatalog = collection->getIndexCatalog();
ASSERT(indexCatalog);
- ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_txn.get()));
+ ASSERT_EQUALS(1, indexCatalog->numIndexesReady(_opCtx.get()));
}
}
TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingNamespace) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
auto insertDocumentOperation =
@@ -559,7 +560,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingNamespace) {
public:
RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
: RollbackSourceMock(std::move(oplog)), called(false) {}
- void copyCollectionFromRemote(OperationContext* txn,
+ void copyCollectionFromRemote(OperationContext* opCtx,
const NamespaceString& nss) const override {
called = true;
}
@@ -572,7 +573,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingNamespace) {
commonOperation,
})));
startCapturingLogMessages();
- auto status = syncRollback(_txn.get(),
+ auto status = syncRollback(_opCtx.get(),
OplogInterfaceMock({insertDocumentOperation, commonOperation}),
rollbackSource,
{},
@@ -586,7 +587,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingNamespace) {
}
TEST_F(RSRollbackTest, RollbackCreateIndexCommandInvalidNamespace) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
auto insertDocumentOperation =
@@ -606,7 +607,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandInvalidNamespace) {
public:
RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
: RollbackSourceMock(std::move(oplog)), called(false) {}
- void copyCollectionFromRemote(OperationContext* txn,
+ void copyCollectionFromRemote(OperationContext* opCtx,
const NamespaceString& nss) const override {
called = true;
}
@@ -619,7 +620,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandInvalidNamespace) {
commonOperation,
})));
startCapturingLogMessages();
- auto status = syncRollback(_txn.get(),
+ auto status = syncRollback(_opCtx.get(),
OplogInterfaceMock({insertDocumentOperation, commonOperation}),
rollbackSource,
{},
@@ -633,7 +634,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandInvalidNamespace) {
}
TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingIndexName) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
auto insertDocumentOperation =
@@ -651,7 +652,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingIndexName) {
public:
RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
: RollbackSourceMock(std::move(oplog)), called(false) {}
- void copyCollectionFromRemote(OperationContext* txn,
+ void copyCollectionFromRemote(OperationContext* opCtx,
const NamespaceString& nss) const override {
called = true;
}
@@ -664,7 +665,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingIndexName) {
commonOperation,
})));
startCapturingLogMessages();
- auto status = syncRollback(_txn.get(),
+ auto status = syncRollback(_opCtx.get(),
OplogInterfaceMock({insertDocumentOperation, commonOperation}),
rollbackSource,
{},
@@ -677,7 +678,7 @@ TEST_F(RSRollbackTest, RollbackCreateIndexCommandMissingIndexName) {
}
TEST_F(RSRollbackTest, RollbackUnknownCommand) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
auto unknownCommandOperation =
@@ -690,15 +691,15 @@ TEST_F(RSRollbackTest, RollbackUnknownCommand) {
<< "t")),
RecordId(2));
{
- Lock::DBLock dbLock(_txn->lockState(), "test", MODE_X);
- mongo::WriteUnitOfWork wuow(_txn.get());
- auto db = dbHolder().openDb(_txn.get(), "test");
+ Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_X);
+ mongo::WriteUnitOfWork wuow(_opCtx.get());
+ auto db = dbHolder().openDb(_opCtx.get(), "test");
ASSERT_TRUE(db);
- ASSERT_TRUE(db->getOrCreateCollection(_txn.get(), "test.t"));
+ ASSERT_TRUE(db->getOrCreateCollection(_opCtx.get(), "test.t"));
wuow.commit();
}
auto status =
- syncRollback(_txn.get(),
+ syncRollback(_opCtx.get(),
OplogInterfaceMock({unknownCommandOperation, commonOperation}),
RollbackSourceMock(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
commonOperation,
@@ -710,7 +711,7 @@ TEST_F(RSRollbackTest, RollbackUnknownCommand) {
}
TEST_F(RSRollbackTest, RollbackDropCollectionCommand) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
auto dropCollectionOperation =
@@ -726,7 +727,7 @@ TEST_F(RSRollbackTest, RollbackDropCollectionCommand) {
public:
RollbackSourceLocal(std::unique_ptr<OplogInterface> oplog)
: RollbackSourceMock(std::move(oplog)), called(false) {}
- void copyCollectionFromRemote(OperationContext* txn,
+ void copyCollectionFromRemote(OperationContext* opCtx,
const NamespaceString& nss) const override {
called = true;
}
@@ -735,8 +736,8 @@ TEST_F(RSRollbackTest, RollbackDropCollectionCommand) {
RollbackSourceLocal rollbackSource(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
commonOperation,
})));
- _createCollection(_txn.get(), "test.t", CollectionOptions());
- ASSERT_OK(syncRollback(_txn.get(),
+ _createCollection(_opCtx.get(), "test.t", CollectionOptions());
+ ASSERT_OK(syncRollback(_opCtx.get(),
OplogInterfaceMock({dropCollectionOperation, commonOperation}),
rollbackSource,
{},
@@ -745,7 +746,7 @@ TEST_F(RSRollbackTest, RollbackDropCollectionCommand) {
}
TEST_F(RSRollbackTest, RollbackDropCollectionCommandFailsIfRBIDChangesWhileSyncingCollection) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
auto dropCollectionOperation =
@@ -763,7 +764,7 @@ TEST_F(RSRollbackTest, RollbackDropCollectionCommandFailsIfRBIDChangesWhileSynci
int getRollbackId() const override {
return copyCollectionCalled ? 1 : 0;
}
- void copyCollectionFromRemote(OperationContext* txn,
+ void copyCollectionFromRemote(OperationContext* opCtx,
const NamespaceString& nss) const override {
copyCollectionCalled = true;
}
@@ -773,8 +774,8 @@ TEST_F(RSRollbackTest, RollbackDropCollectionCommandFailsIfRBIDChangesWhileSynci
commonOperation,
})));
- _createCollection(_txn.get(), "test.t", CollectionOptions());
- ASSERT_THROWS_CODE(syncRollback(_txn.get(),
+ _createCollection(_opCtx.get(), "test.t", CollectionOptions());
+ ASSERT_THROWS_CODE(syncRollback(_opCtx.get(),
OplogInterfaceMock({dropCollectionOperation, commonOperation}),
rollbackSource,
{0},
@@ -815,22 +816,22 @@ OpTime getOpTimeFromOplogEntry(const BSONObj& entry) {
}
TEST_F(RSRollbackTest, RollbackApplyOpsCommand) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
{
- AutoGetOrCreateDb autoDb(_txn.get(), "test", MODE_X);
- mongo::WriteUnitOfWork wuow(_txn.get());
+ AutoGetOrCreateDb autoDb(_opCtx.get(), "test", MODE_X);
+ mongo::WriteUnitOfWork wuow(_opCtx.get());
auto coll = autoDb.getDb()->getCollection("test.t");
if (!coll) {
- coll = autoDb.getDb()->createCollection(_txn.get(), "test.t");
+ coll = autoDb.getDb()->createCollection(_opCtx.get(), "test.t");
}
ASSERT(coll);
OpDebug* const nullOpDebug = nullptr;
ASSERT_OK(
- coll->insertDocument(_txn.get(), BSON("_id" << 1 << "v" << 2), nullOpDebug, false));
+ coll->insertDocument(_opCtx.get(), BSON("_id" << 1 << "v" << 2), nullOpDebug, false));
ASSERT_OK(
- coll->insertDocument(_txn.get(), BSON("_id" << 2 << "v" << 4), nullOpDebug, false));
- ASSERT_OK(coll->insertDocument(_txn.get(), BSON("_id" << 4), nullOpDebug, false));
+ coll->insertDocument(_opCtx.get(), BSON("_id" << 2 << "v" << 4), nullOpDebug, false));
+ ASSERT_OK(coll->insertDocument(_opCtx.get(), BSON("_id" << 4), nullOpDebug, false));
wuow.commit();
}
const auto commonOperation =
@@ -897,8 +898,8 @@ TEST_F(RSRollbackTest, RollbackApplyOpsCommand) {
mutable std::multiset<int> searchedIds;
} rollbackSource(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({commonOperation})));
- _createCollection(_txn.get(), "test.t", CollectionOptions());
- ASSERT_OK(syncRollback(_txn.get(),
+ _createCollection(_opCtx.get(), "test.t", CollectionOptions());
+ ASSERT_OK(syncRollback(_opCtx.get(),
OplogInterfaceMock({applyOpsOperation, commonOperation}),
rollbackSource,
{},
@@ -909,20 +910,20 @@ TEST_F(RSRollbackTest, RollbackApplyOpsCommand) {
ASSERT_EQUALS(1U, rollbackSource.searchedIds.count(3));
ASSERT_EQUALS(1U, rollbackSource.searchedIds.count(4));
- AutoGetCollectionForRead acr(_txn.get(), NamespaceString("test.t"));
+ AutoGetCollectionForRead acr(_opCtx.get(), NamespaceString("test.t"));
BSONObj result;
- ASSERT(Helpers::findOne(_txn.get(), acr.getCollection(), BSON("_id" << 1), result));
+ ASSERT(Helpers::findOne(_opCtx.get(), acr.getCollection(), BSON("_id" << 1), result));
ASSERT_EQUALS(1, result["v"].numberInt()) << result;
- ASSERT(Helpers::findOne(_txn.get(), acr.getCollection(), BSON("_id" << 2), result));
+ ASSERT(Helpers::findOne(_opCtx.get(), acr.getCollection(), BSON("_id" << 2), result));
ASSERT_EQUALS(3, result["v"].numberInt()) << result;
- ASSERT(Helpers::findOne(_txn.get(), acr.getCollection(), BSON("_id" << 3), result));
+ ASSERT(Helpers::findOne(_opCtx.get(), acr.getCollection(), BSON("_id" << 3), result));
ASSERT_EQUALS(5, result["v"].numberInt()) << result;
- ASSERT_FALSE(Helpers::findOne(_txn.get(), acr.getCollection(), BSON("_id" << 4), result))
+ ASSERT_FALSE(Helpers::findOne(_opCtx.get(), acr.getCollection(), BSON("_id" << 4), result))
<< result;
}
TEST_F(RSRollbackTest, RollbackCreateCollectionCommand) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
auto createCollectionOperation =
@@ -937,22 +938,22 @@ TEST_F(RSRollbackTest, RollbackCreateCollectionCommand) {
RollbackSourceMock rollbackSource(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
commonOperation,
})));
- _createCollection(_txn.get(), "test.t", CollectionOptions());
- ASSERT_OK(syncRollback(_txn.get(),
+ _createCollection(_opCtx.get(), "test.t", CollectionOptions());
+ ASSERT_OK(syncRollback(_opCtx.get(),
OplogInterfaceMock({createCollectionOperation, commonOperation}),
rollbackSource,
{},
_coordinator));
{
- Lock::DBLock dbLock(_txn->lockState(), "test", MODE_S);
- auto db = dbHolder().get(_txn.get(), "test");
+ Lock::DBLock dbLock(_opCtx->lockState(), "test", MODE_S);
+ auto db = dbHolder().get(_opCtx.get(), "test");
ASSERT_TRUE(db);
ASSERT_FALSE(db->getCollection("test.t"));
}
}
TEST_F(RSRollbackTest, RollbackCollectionModificationCommand) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
auto collectionModificationOperation =
@@ -979,9 +980,9 @@ TEST_F(RSRollbackTest, RollbackCollectionModificationCommand) {
RollbackSourceLocal rollbackSource(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
commonOperation,
})));
- _createCollection(_txn.get(), "test.t", CollectionOptions());
+ _createCollection(_opCtx.get(), "test.t", CollectionOptions());
startCapturingLogMessages();
- ASSERT_OK(syncRollback(_txn.get(),
+ ASSERT_OK(syncRollback(_opCtx.get(),
OplogInterfaceMock({collectionModificationOperation, commonOperation}),
rollbackSource,
{},
@@ -995,7 +996,7 @@ TEST_F(RSRollbackTest, RollbackCollectionModificationCommand) {
}
TEST_F(RSRollbackTest, RollbackCollectionModificationCommandInvalidCollectionOptions) {
- createOplog(_txn.get());
+ createOplog(_opCtx.get());
auto commonOperation =
std::make_pair(BSON("ts" << Timestamp(Seconds(1), 0) << "h" << 1LL), RecordId(1));
auto collectionModificationOperation =
@@ -1020,9 +1021,9 @@ TEST_F(RSRollbackTest, RollbackCollectionModificationCommandInvalidCollectionOpt
RollbackSourceLocal rollbackSource(std::unique_ptr<OplogInterface>(new OplogInterfaceMock({
commonOperation,
})));
- _createCollection(_txn.get(), "test.t", CollectionOptions());
+ _createCollection(_opCtx.get(), "test.t", CollectionOptions());
auto status =
- syncRollback(_txn.get(),
+ syncRollback(_opCtx.get(),
OplogInterfaceMock({collectionModificationOperation, commonOperation}),
rollbackSource,
{},
diff --git a/src/mongo/db/repl/storage_interface.cpp b/src/mongo/db/repl/storage_interface.cpp
index b9a1c25df45..5f9deb71a85 100644
--- a/src/mongo/db/repl/storage_interface.cpp
+++ b/src/mongo/db/repl/storage_interface.cpp
@@ -51,8 +51,8 @@ StorageInterface* StorageInterface::get(ServiceContext& service) {
return getStorageInterface(service).get();
}
-StorageInterface* StorageInterface::get(OperationContext* txn) {
- return get(txn->getClient()->getServiceContext());
+StorageInterface* StorageInterface::get(OperationContext* opCtx) {
+ return get(opCtx->getClient()->getServiceContext());
}
diff --git a/src/mongo/db/repl/storage_interface.h b/src/mongo/db/repl/storage_interface.h
index ae4f6f7eabf..2e87f23537d 100644
--- a/src/mongo/db/repl/storage_interface.h
+++ b/src/mongo/db/repl/storage_interface.h
@@ -91,7 +91,7 @@ public:
// Operation Context binding.
static StorageInterface* get(ServiceContext* service);
static StorageInterface* get(ServiceContext& service);
- static StorageInterface* get(OperationContext* txn);
+ static StorageInterface* get(OperationContext* opCtx);
static void set(ServiceContext* service, std::unique_ptr<StorageInterface> storageInterface);
// Constructor and Destructor.
@@ -105,7 +105,7 @@ public:
/**
* Returns true if initial sync was started but has not not completed.
*/
- virtual bool getInitialSyncFlag(OperationContext* txn) const = 0;
+ virtual bool getInitialSyncFlag(OperationContext* opCtx) const = 0;
/**
* Sets the the initial sync flag to record that initial sync has not completed.
@@ -113,7 +113,7 @@ public:
* This operation is durable and waits for durable writes (which will block on
*journaling/checkpointing).
*/
- virtual void setInitialSyncFlag(OperationContext* txn) = 0;
+ virtual void setInitialSyncFlag(OperationContext* opCtx) = 0;
/**
* Clears the the initial sync flag to record that initial sync has completed.
@@ -121,34 +121,34 @@ public:
* This operation is durable and waits for durable writes (which will block on
*journaling/checkpointing).
*/
- virtual void clearInitialSyncFlag(OperationContext* txn) = 0;
+ virtual void clearInitialSyncFlag(OperationContext* opCtx) = 0;
/**
* The minValid value is the earliest (minimum) Timestamp that must be applied in order to
* consider the dataset consistent.
*/
- virtual void setMinValid(OperationContext* txn, const OpTime& minValid) = 0;
- virtual OpTime getMinValid(OperationContext* txn) const = 0;
+ virtual void setMinValid(OperationContext* opCtx, const OpTime& minValid) = 0;
+ virtual OpTime getMinValid(OperationContext* opCtx) const = 0;
/**
* Sets minValid only if it is not already higher than endOpTime.
* Warning, this compares the term and timestamp independently. Do not use if the current
* minValid could be from the other fork of a rollback.
*/
- virtual void setMinValidToAtLeast(OperationContext* txn, const OpTime& endOpTime) = 0;
+ virtual void setMinValidToAtLeast(OperationContext* opCtx, const OpTime& endOpTime) = 0;
/**
* On startup all oplog entries with a value >= the oplog delete from point should be deleted.
* If null, no documents should be deleted.
*/
- virtual void setOplogDeleteFromPoint(OperationContext* txn, const Timestamp& timestamp) = 0;
- virtual Timestamp getOplogDeleteFromPoint(OperationContext* txn) = 0;
+ virtual void setOplogDeleteFromPoint(OperationContext* opCtx, const Timestamp& timestamp) = 0;
+ virtual Timestamp getOplogDeleteFromPoint(OperationContext* opCtx) = 0;
/**
* The applied through point is a persistent record of where we've applied through. If null, the
* applied through point is the top of the oplog.
*/
- virtual void setAppliedThrough(OperationContext* txn, const OpTime& optime) = 0;
+ virtual void setAppliedThrough(OperationContext* opCtx, const OpTime& optime) = 0;
/**
* You should probably be calling ReplicationCoordinator::getLastAppliedOpTime() instead.
@@ -156,7 +156,7 @@ public:
* This reads the value from storage which isn't always updated when the ReplicationCoordinator
* is.
*/
- virtual OpTime getAppliedThrough(OperationContext* txn) = 0;
+ virtual OpTime getAppliedThrough(OperationContext* opCtx) = 0;
// Collection creation and population for initial sync.
@@ -177,7 +177,7 @@ public:
* NOTE: If the collection doesn't exist, it will not be created, and instead
* an error is returned.
*/
- virtual Status insertDocument(OperationContext* txn,
+ virtual Status insertDocument(OperationContext* opCtx,
const NamespaceString& nss,
const BSONObj& doc) = 0;
@@ -185,14 +185,14 @@ public:
* Inserts the given documents into the collection.
* It is an error to call this function with an empty set of documents.
*/
- virtual Status insertDocuments(OperationContext* txn,
+ virtual Status insertDocuments(OperationContext* opCtx,
const NamespaceString& nss,
const std::vector<BSONObj>& docs) = 0;
/**
* Creates the initial oplog, errors if it exists.
*/
- virtual Status createOplog(OperationContext* txn, const NamespaceString& nss) = 0;
+ virtual Status createOplog(OperationContext* opCtx, const NamespaceString& nss) = 0;
/**
* Returns the configured maximum size of the oplog.
@@ -200,30 +200,30 @@ public:
* Implementations are allowed to be "fuzzy" and delete documents when the actual size is
* slightly above or below this, so callers should not rely on its exact value.
*/
- virtual StatusWith<size_t> getOplogMaxSize(OperationContext* txn,
+ virtual StatusWith<size_t> getOplogMaxSize(OperationContext* opCtx,
const NamespaceString& nss) = 0;
/**
* Creates a collection.
*/
- virtual Status createCollection(OperationContext* txn,
+ virtual Status createCollection(OperationContext* opCtx,
const NamespaceString& nss,
const CollectionOptions& options) = 0;
/**
* Drops a collection, like the oplog.
*/
- virtual Status dropCollection(OperationContext* txn, const NamespaceString& nss) = 0;
+ virtual Status dropCollection(OperationContext* opCtx, const NamespaceString& nss) = 0;
/**
* Drops all databases except "local".
*/
- virtual Status dropReplicatedDatabases(OperationContext* txn) = 0;
+ virtual Status dropReplicatedDatabases(OperationContext* opCtx) = 0;
/**
* Validates that the admin database is valid during initial sync.
*/
- virtual Status isAdminDbValid(OperationContext* txn) = 0;
+ virtual Status isAdminDbValid(OperationContext* opCtx) = 0;
/**
* Finds at most "limit" documents returned by a collection or index scan on the collection in
@@ -242,7 +242,7 @@ public:
kForward = 1,
kBackward = -1,
};
- virtual StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* txn,
+ virtual StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
@@ -257,7 +257,7 @@ public:
* will be kept open once this function returns.
* If "indexName" is null, a collection scan is used to locate the document.
*/
- virtual StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* txn,
+ virtual StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
diff --git a/src/mongo/db/repl/storage_interface_impl.cpp b/src/mongo/db/repl/storage_interface_impl.cpp
index ce03ab1629c..ff5aa7d4260 100644
--- a/src/mongo/db/repl/storage_interface_impl.cpp
+++ b/src/mongo/db/repl/storage_interface_impl.cpp
@@ -102,67 +102,67 @@ NamespaceString StorageInterfaceImpl::getMinValidNss() const {
return _minValidNss;
}
-BSONObj StorageInterfaceImpl::getMinValidDocument(OperationContext* txn) const {
+BSONObj StorageInterfaceImpl::getMinValidDocument(OperationContext* opCtx) const {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction transaction(txn, MODE_IS);
- Lock::DBLock dblk(txn->lockState(), _minValidNss.db(), MODE_IS);
- Lock::CollectionLock lk(txn->lockState(), _minValidNss.ns(), MODE_IS);
+ ScopedTransaction transaction(opCtx, MODE_IS);
+ Lock::DBLock dblk(opCtx->lockState(), _minValidNss.db(), MODE_IS);
+ Lock::CollectionLock lk(opCtx->lockState(), _minValidNss.ns(), MODE_IS);
BSONObj doc;
- bool found = Helpers::getSingleton(txn, _minValidNss.ns().c_str(), doc);
+ bool found = Helpers::getSingleton(opCtx, _minValidNss.ns().c_str(), doc);
invariant(found || doc.isEmpty());
return doc;
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
- txn, "StorageInterfaceImpl::getMinValidDocument", _minValidNss.ns());
+ opCtx, "StorageInterfaceImpl::getMinValidDocument", _minValidNss.ns());
MONGO_UNREACHABLE;
}
-void StorageInterfaceImpl::updateMinValidDocument(OperationContext* txn,
+void StorageInterfaceImpl::updateMinValidDocument(OperationContext* opCtx,
const BSONObj& updateSpec) {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction transaction(txn, MODE_IX);
+ ScopedTransaction transaction(opCtx, MODE_IX);
// For now this needs to be MODE_X because it sometimes creates the collection.
- Lock::DBLock dblk(txn->lockState(), _minValidNss.db(), MODE_X);
- Helpers::putSingleton(txn, _minValidNss.ns().c_str(), updateSpec);
+ Lock::DBLock dblk(opCtx->lockState(), _minValidNss.db(), MODE_X);
+ Helpers::putSingleton(opCtx, _minValidNss.ns().c_str(), updateSpec);
}
MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
- txn, "StorageInterfaceImpl::updateMinValidDocument", _minValidNss.ns());
+ opCtx, "StorageInterfaceImpl::updateMinValidDocument", _minValidNss.ns());
}
-bool StorageInterfaceImpl::getInitialSyncFlag(OperationContext* txn) const {
- const BSONObj doc = getMinValidDocument(txn);
+bool StorageInterfaceImpl::getInitialSyncFlag(OperationContext* opCtx) const {
+ const BSONObj doc = getMinValidDocument(opCtx);
const auto flag = doc[kInitialSyncFlagFieldName].trueValue();
LOG(3) << "returning initial sync flag value of " << flag;
return flag;
}
-void StorageInterfaceImpl::setInitialSyncFlag(OperationContext* txn) {
+void StorageInterfaceImpl::setInitialSyncFlag(OperationContext* opCtx) {
LOG(3) << "setting initial sync flag";
- updateMinValidDocument(txn, BSON("$set" << kInitialSyncFlag));
- txn->recoveryUnit()->waitUntilDurable();
+ updateMinValidDocument(opCtx, BSON("$set" << kInitialSyncFlag));
+ opCtx->recoveryUnit()->waitUntilDurable();
}
-void StorageInterfaceImpl::clearInitialSyncFlag(OperationContext* txn) {
+void StorageInterfaceImpl::clearInitialSyncFlag(OperationContext* opCtx) {
LOG(3) << "clearing initial sync flag";
- auto replCoord = repl::ReplicationCoordinator::get(txn);
+ auto replCoord = repl::ReplicationCoordinator::get(opCtx);
OpTime time = replCoord->getMyLastAppliedOpTime();
updateMinValidDocument(
- txn,
+ opCtx,
BSON("$unset" << kInitialSyncFlag << "$set"
<< BSON("ts" << time.getTimestamp() << "t" << time.getTerm()
<< kBeginFieldName
<< time.toBSON())));
if (getGlobalServiceContext()->getGlobalStorageEngine()->isDurable()) {
- txn->recoveryUnit()->waitUntilDurable();
+ opCtx->recoveryUnit()->waitUntilDurable();
replCoord->setMyLastDurableOpTime(time);
}
}
-OpTime StorageInterfaceImpl::getMinValid(OperationContext* txn) const {
- const BSONObj doc = getMinValidDocument(txn);
+OpTime StorageInterfaceImpl::getMinValid(OperationContext* opCtx) const {
+ const BSONObj doc = getMinValidDocument(opCtx);
const auto opTimeStatus = OpTime::parseFromOplogEntry(doc);
// If any of the keys (fields) are missing from the minvalid document, we return
// a null OpTime.
@@ -182,28 +182,29 @@ OpTime StorageInterfaceImpl::getMinValid(OperationContext* txn) const {
return minValid;
}
-void StorageInterfaceImpl::setMinValid(OperationContext* txn, const OpTime& minValid) {
+void StorageInterfaceImpl::setMinValid(OperationContext* opCtx, const OpTime& minValid) {
LOG(3) << "setting minvalid to exactly: " << minValid.toString() << "(" << minValid.toBSON()
<< ")";
updateMinValidDocument(
- txn, BSON("$set" << BSON("ts" << minValid.getTimestamp() << "t" << minValid.getTerm())));
+ opCtx, BSON("$set" << BSON("ts" << minValid.getTimestamp() << "t" << minValid.getTerm())));
}
-void StorageInterfaceImpl::setMinValidToAtLeast(OperationContext* txn, const OpTime& minValid) {
+void StorageInterfaceImpl::setMinValidToAtLeast(OperationContext* opCtx, const OpTime& minValid) {
LOG(3) << "setting minvalid to at least: " << minValid.toString() << "(" << minValid.toBSON()
<< ")";
updateMinValidDocument(
- txn, BSON("$max" << BSON("ts" << minValid.getTimestamp() << "t" << minValid.getTerm())));
+ opCtx, BSON("$max" << BSON("ts" << minValid.getTimestamp() << "t" << minValid.getTerm())));
}
-void StorageInterfaceImpl::setOplogDeleteFromPoint(OperationContext* txn,
+void StorageInterfaceImpl::setOplogDeleteFromPoint(OperationContext* opCtx,
const Timestamp& timestamp) {
LOG(3) << "setting oplog delete from point to: " << timestamp.toStringPretty();
- updateMinValidDocument(txn, BSON("$set" << BSON(kOplogDeleteFromPointFieldName << timestamp)));
+ updateMinValidDocument(opCtx,
+ BSON("$set" << BSON(kOplogDeleteFromPointFieldName << timestamp)));
}
-Timestamp StorageInterfaceImpl::getOplogDeleteFromPoint(OperationContext* txn) {
- const BSONObj doc = getMinValidDocument(txn);
+Timestamp StorageInterfaceImpl::getOplogDeleteFromPoint(OperationContext* opCtx) {
+ const BSONObj doc = getMinValidDocument(opCtx);
Timestamp out = {};
if (auto field = doc[kOplogDeleteFromPointFieldName]) {
out = field.timestamp();
@@ -213,17 +214,17 @@ Timestamp StorageInterfaceImpl::getOplogDeleteFromPoint(OperationContext* txn) {
return out;
}
-void StorageInterfaceImpl::setAppliedThrough(OperationContext* txn, const OpTime& optime) {
+void StorageInterfaceImpl::setAppliedThrough(OperationContext* opCtx, const OpTime& optime) {
LOG(3) << "setting appliedThrough to: " << optime.toString() << "(" << optime.toBSON() << ")";
if (optime.isNull()) {
- updateMinValidDocument(txn, BSON("$unset" << BSON(kBeginFieldName << 1)));
+ updateMinValidDocument(opCtx, BSON("$unset" << BSON(kBeginFieldName << 1)));
} else {
- updateMinValidDocument(txn, BSON("$set" << BSON(kBeginFieldName << optime.toBSON())));
+ updateMinValidDocument(opCtx, BSON("$set" << BSON(kBeginFieldName << optime.toBSON())));
}
}
-OpTime StorageInterfaceImpl::getAppliedThrough(OperationContext* txn) {
- const BSONObj doc = getMinValidDocument(txn);
+OpTime StorageInterfaceImpl::getAppliedThrough(OperationContext* opCtx) {
+ const BSONObj doc = getMinValidDocument(opCtx);
const auto opTimeStatus = OpTime::parseFromOplogEntry(doc.getObjectField(kBeginFieldName));
if (!opTimeStatus.isOK()) {
// Return null OpTime on any parse failure, including if "begin" is missing.
@@ -253,18 +254,18 @@ StorageInterfaceImpl::createCollectionForBulkLoading(
std::unique_ptr<CollectionBulkLoader> loaderToReturn;
Collection* collection;
- auto status = runner->runSynchronousTask([&](OperationContext* txn) -> Status {
+ auto status = runner->runSynchronousTask([&](OperationContext* opCtx) -> Status {
// We are not replicating nor validating writes under this OperationContext*.
// The OperationContext* is used for all writes to the (newly) cloned collection.
- txn->setReplicatedWrites(false);
- documentValidationDisabled(txn) = true;
+ opCtx->setReplicatedWrites(false);
+ documentValidationDisabled(opCtx) = true;
// Retry if WCE.
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
// Get locks and create the collection.
- ScopedTransaction transaction(txn, MODE_IX);
- auto db = stdx::make_unique<AutoGetOrCreateDb>(txn, nss.db(), MODE_IX);
- auto coll = stdx::make_unique<AutoGetCollection>(txn, nss, MODE_X);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ auto db = stdx::make_unique<AutoGetOrCreateDb>(opCtx, nss.db(), MODE_IX);
+ auto coll = stdx::make_unique<AutoGetCollection>(opCtx, nss, MODE_X);
collection = coll->getCollection();
if (collection) {
@@ -272,14 +273,14 @@ StorageInterfaceImpl::createCollectionForBulkLoading(
}
// Create the collection.
- WriteUnitOfWork wunit(txn);
- collection = db->getDb()->createCollection(txn, nss.ns(), options, false);
+ WriteUnitOfWork wunit(opCtx);
+ collection = db->getDb()->createCollection(opCtx, nss.ns(), options, false);
invariant(collection);
wunit.commit();
- coll = stdx::make_unique<AutoGetCollection>(txn, nss, MODE_IX);
+ coll = stdx::make_unique<AutoGetCollection>(opCtx, nss, MODE_IX);
// Move locks into loader, so it now controls their lifetime.
- auto loader = stdx::make_unique<CollectionBulkLoaderImpl>(txn,
+ auto loader = stdx::make_unique<CollectionBulkLoaderImpl>(opCtx,
collection,
idIndexSpec,
std::move(threadPool),
@@ -291,7 +292,7 @@ StorageInterfaceImpl::createCollectionForBulkLoading(
loaderToReturn = std::move(loader);
return Status::OK();
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "beginCollectionClone", nss.ns());
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "beginCollectionClone", nss.ns());
MONGO_UNREACHABLE;
});
@@ -308,20 +309,20 @@ StorageInterfaceImpl::createCollectionForBulkLoading(
}
-Status StorageInterfaceImpl::insertDocument(OperationContext* txn,
+Status StorageInterfaceImpl::insertDocument(OperationContext* opCtx,
const NamespaceString& nss,
const BSONObj& doc) {
- return insertDocuments(txn, nss, {doc});
+ return insertDocuments(opCtx, nss, {doc});
}
namespace {
-Status insertDocumentsSingleBatch(OperationContext* txn,
+Status insertDocumentsSingleBatch(OperationContext* opCtx,
const NamespaceString& nss,
std::vector<BSONObj>::const_iterator begin,
std::vector<BSONObj>::const_iterator end) {
- ScopedTransaction transaction(txn, MODE_IX);
- AutoGetCollection autoColl(txn, nss, MODE_IX);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ AutoGetCollection autoColl(opCtx, nss, MODE_IX);
auto collection = autoColl.getCollection();
if (!collection) {
return {ErrorCodes::NamespaceNotFound,
@@ -329,9 +330,9 @@ Status insertDocumentsSingleBatch(OperationContext* txn,
<< nss.ns()};
}
- WriteUnitOfWork wunit(txn);
+ WriteUnitOfWork wunit(opCtx);
OpDebug* const nullOpDebug = nullptr;
- auto status = collection->insertDocuments(txn, begin, end, nullOpDebug, false);
+ auto status = collection->insertDocuments(opCtx, begin, end, nullOpDebug, false);
if (!status.isOK()) {
return status;
}
@@ -342,12 +343,12 @@ Status insertDocumentsSingleBatch(OperationContext* txn,
} // namespace
-Status StorageInterfaceImpl::insertDocuments(OperationContext* txn,
+Status StorageInterfaceImpl::insertDocuments(OperationContext* opCtx,
const NamespaceString& nss,
const std::vector<BSONObj>& docs) {
if (docs.size() > 1U) {
try {
- if (insertDocumentsSingleBatch(txn, nss, docs.cbegin(), docs.cend()).isOK()) {
+ if (insertDocumentsSingleBatch(opCtx, nss, docs.cbegin(), docs.cend()).isOK()) {
return Status::OK();
}
} catch (...) {
@@ -359,83 +360,84 @@ Status StorageInterfaceImpl::insertDocuments(OperationContext* txn,
// Try to insert the batch one-at-a-time because the batch failed all-at-once inserting.
for (auto it = docs.cbegin(); it != docs.cend(); ++it) {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- auto status = insertDocumentsSingleBatch(txn, nss, it, it + 1);
+ auto status = insertDocumentsSingleBatch(opCtx, nss, it, it + 1);
if (!status.isOK()) {
return status;
}
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "StorageInterfaceImpl::insertDocuments", nss.ns());
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
+ opCtx, "StorageInterfaceImpl::insertDocuments", nss.ns());
}
return Status::OK();
}
-Status StorageInterfaceImpl::dropReplicatedDatabases(OperationContext* txn) {
- dropAllDatabasesExceptLocal(txn);
+Status StorageInterfaceImpl::dropReplicatedDatabases(OperationContext* opCtx) {
+ dropAllDatabasesExceptLocal(opCtx);
return Status::OK();
}
-Status StorageInterfaceImpl::createOplog(OperationContext* txn, const NamespaceString& nss) {
- mongo::repl::createOplog(txn, nss.ns(), true);
+Status StorageInterfaceImpl::createOplog(OperationContext* opCtx, const NamespaceString& nss) {
+ mongo::repl::createOplog(opCtx, nss.ns(), true);
return Status::OK();
}
-StatusWith<size_t> StorageInterfaceImpl::getOplogMaxSize(OperationContext* txn,
+StatusWith<size_t> StorageInterfaceImpl::getOplogMaxSize(OperationContext* opCtx,
const NamespaceString& nss) {
- AutoGetCollectionForRead collection(txn, nss);
+ AutoGetCollectionForRead collection(opCtx, nss);
if (!collection.getCollection()) {
return {ErrorCodes::NamespaceNotFound,
str::stream() << "Your oplog doesn't exist: " << nss.ns()};
}
- const auto options = collection.getCollection()->getCatalogEntry()->getCollectionOptions(txn);
+ const auto options = collection.getCollection()->getCatalogEntry()->getCollectionOptions(opCtx);
if (!options.capped)
return {ErrorCodes::BadValue, str::stream() << nss.ns() << " isn't capped"};
return options.cappedSize;
}
-Status StorageInterfaceImpl::createCollection(OperationContext* txn,
+Status StorageInterfaceImpl::createCollection(OperationContext* opCtx,
const NamespaceString& nss,
const CollectionOptions& options) {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction transaction(txn, MODE_IX);
- AutoGetOrCreateDb databaseWriteGuard(txn, nss.db(), MODE_X);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ AutoGetOrCreateDb databaseWriteGuard(opCtx, nss.db(), MODE_X);
auto db = databaseWriteGuard.getDb();
invariant(db);
if (db->getCollection(nss)) {
return {ErrorCodes::NamespaceExists,
str::stream() << "Collection " << nss.ns() << " already exists."};
}
- WriteUnitOfWork wuow(txn);
+ WriteUnitOfWork wuow(opCtx);
try {
- auto coll = db->createCollection(txn, nss.ns(), options);
+ auto coll = db->createCollection(opCtx, nss.ns(), options);
invariant(coll);
} catch (const UserException& ex) {
return ex.toStatus();
}
wuow.commit();
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "StorageInterfaceImpl::createCollection", nss.ns());
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "StorageInterfaceImpl::createCollection", nss.ns());
return Status::OK();
}
-Status StorageInterfaceImpl::dropCollection(OperationContext* txn, const NamespaceString& nss) {
+Status StorageInterfaceImpl::dropCollection(OperationContext* opCtx, const NamespaceString& nss) {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction transaction(txn, MODE_IX);
- AutoGetDb autoDB(txn, nss.db(), MODE_X);
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ AutoGetDb autoDB(opCtx, nss.db(), MODE_X);
if (!autoDB.getDb()) {
// Database does not exist - nothing to do.
return Status::OK();
}
- WriteUnitOfWork wunit(txn);
- const auto status = autoDB.getDb()->dropCollection(txn, nss.ns());
+ WriteUnitOfWork wunit(opCtx);
+ const auto status = autoDB.getDb()->dropCollection(opCtx, nss.ns());
if (status.isOK()) {
wunit.commit();
}
return status;
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "StorageInterfaceImpl::dropCollection", nss.ns());
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "StorageInterfaceImpl::dropCollection", nss.ns());
}
namespace {
@@ -455,7 +457,7 @@ DeleteStageParams makeDeleteStageParamsForDeleteDocuments() {
*/
enum class FindDeleteMode { kFind, kDelete };
StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
- OperationContext* txn,
+ OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
StorageInterface::ScanDirection scanDirection,
@@ -468,8 +470,8 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
auto collectionAccessMode = isFind ? MODE_IS : MODE_IX;
- ScopedTransaction transaction(txn, collectionAccessMode);
- AutoGetCollection collectionGuard(txn, nss, collectionAccessMode);
+ ScopedTransaction transaction(opCtx, collectionAccessMode);
+ AutoGetCollection collectionGuard(opCtx, nss, collectionAccessMode);
auto collection = collectionGuard.getCollection();
if (!collection) {
return {ErrorCodes::NamespaceNotFound,
@@ -493,9 +495,9 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
// Use collection scan.
planExecutor = isFind
? InternalPlanner::collectionScan(
- txn, nss.ns(), collection, PlanExecutor::YIELD_MANUAL, direction)
+ opCtx, nss.ns(), collection, PlanExecutor::YIELD_MANUAL, direction)
: InternalPlanner::deleteWithCollectionScan(
- txn,
+ opCtx,
collection,
makeDeleteStageParamsForDeleteDocuments(),
PlanExecutor::YIELD_MANUAL,
@@ -506,7 +508,7 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
invariant(indexCatalog);
bool includeUnfinishedIndexes = false;
IndexDescriptor* indexDescriptor =
- indexCatalog->findIndexByName(txn, *indexName, includeUnfinishedIndexes);
+ indexCatalog->findIndexByName(opCtx, *indexName, includeUnfinishedIndexes);
if (!indexDescriptor) {
return {ErrorCodes::IndexNotFound,
str::stream() << "Index not found, ns:" << nss.ns() << ", index: "
@@ -529,7 +531,7 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
bounds.first = startKey;
}
planExecutor = isFind
- ? InternalPlanner::indexScan(txn,
+ ? InternalPlanner::indexScan(opCtx,
collection,
indexDescriptor,
bounds.first,
@@ -538,7 +540,7 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
PlanExecutor::YIELD_MANUAL,
direction,
InternalPlanner::IXSCAN_FETCH)
- : InternalPlanner::deleteWithIndexScan(txn,
+ : InternalPlanner::deleteWithIndexScan(opCtx,
collection,
makeDeleteStageParamsForDeleteDocuments(),
indexDescriptor,
@@ -562,33 +564,39 @@ StatusWith<std::vector<BSONObj>> _findOrDeleteDocuments(
}
return docs;
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, opStr, nss.ns());
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, opStr, nss.ns());
MONGO_UNREACHABLE;
}
} // namespace
StatusWith<std::vector<BSONObj>> StorageInterfaceImpl::findDocuments(
- OperationContext* txn,
+ OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
const BSONObj& startKey,
BoundInclusion boundInclusion,
std::size_t limit) {
- return _findOrDeleteDocuments(
- txn, nss, indexName, scanDirection, startKey, boundInclusion, limit, FindDeleteMode::kFind);
+ return _findOrDeleteDocuments(opCtx,
+ nss,
+ indexName,
+ scanDirection,
+ startKey,
+ boundInclusion,
+ limit,
+ FindDeleteMode::kFind);
}
StatusWith<std::vector<BSONObj>> StorageInterfaceImpl::deleteDocuments(
- OperationContext* txn,
+ OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
const BSONObj& startKey,
BoundInclusion boundInclusion,
std::size_t limit) {
- return _findOrDeleteDocuments(txn,
+ return _findOrDeleteDocuments(opCtx,
nss,
indexName,
scanDirection,
@@ -598,10 +606,10 @@ StatusWith<std::vector<BSONObj>> StorageInterfaceImpl::deleteDocuments(
FindDeleteMode::kDelete);
}
-Status StorageInterfaceImpl::isAdminDbValid(OperationContext* txn) {
- ScopedTransaction transaction(txn, MODE_IX);
- AutoGetDb autoDB(txn, "admin", MODE_X);
- return checkAdminDatabase(txn, autoDB.getDb());
+Status StorageInterfaceImpl::isAdminDbValid(OperationContext* opCtx) {
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ AutoGetDb autoDB(opCtx, "admin", MODE_X);
+ return checkAdminDatabase(opCtx, autoDB.getDb());
}
} // namespace repl
diff --git a/src/mongo/db/repl/storage_interface_impl.h b/src/mongo/db/repl/storage_interface_impl.h
index 9edd37b44c8..b3bc5eeb617 100644
--- a/src/mongo/db/repl/storage_interface_impl.h
+++ b/src/mongo/db/repl/storage_interface_impl.h
@@ -62,19 +62,19 @@ public:
*/
NamespaceString getMinValidNss() const;
- bool getInitialSyncFlag(OperationContext* txn) const override;
+ bool getInitialSyncFlag(OperationContext* opCtx) const override;
- void setInitialSyncFlag(OperationContext* txn) override;
+ void setInitialSyncFlag(OperationContext* opCtx) override;
- void clearInitialSyncFlag(OperationContext* txn) override;
+ void clearInitialSyncFlag(OperationContext* opCtx) override;
- OpTime getMinValid(OperationContext* txn) const override;
- void setMinValid(OperationContext* txn, const OpTime& minValid) override;
- void setMinValidToAtLeast(OperationContext* txn, const OpTime& endOpTime) override;
- void setOplogDeleteFromPoint(OperationContext* txn, const Timestamp& timestamp) override;
- Timestamp getOplogDeleteFromPoint(OperationContext* txn) override;
- void setAppliedThrough(OperationContext* txn, const OpTime& optime) override;
- OpTime getAppliedThrough(OperationContext* txn) override;
+ OpTime getMinValid(OperationContext* opCtx) const override;
+ void setMinValid(OperationContext* opCtx, const OpTime& minValid) override;
+ void setMinValidToAtLeast(OperationContext* opCtx, const OpTime& endOpTime) override;
+ void setOplogDeleteFromPoint(OperationContext* opCtx, const Timestamp& timestamp) override;
+ Timestamp getOplogDeleteFromPoint(OperationContext* opCtx) override;
+ void setAppliedThrough(OperationContext* opCtx, const OpTime& optime) override;
+ OpTime getAppliedThrough(OperationContext* opCtx) override;
/**
* Allocates a new TaskRunner for use by the passed in collection.
@@ -85,26 +85,27 @@ public:
const BSONObj idIndexSpec,
const std::vector<BSONObj>& secondaryIndexSpecs) override;
- Status insertDocument(OperationContext* txn,
+ Status insertDocument(OperationContext* opCtx,
const NamespaceString& nss,
const BSONObj& doc) override;
- Status insertDocuments(OperationContext* txn,
+ Status insertDocuments(OperationContext* opCtx,
const NamespaceString& nss,
const std::vector<BSONObj>& docs) override;
- Status dropReplicatedDatabases(OperationContext* txn) override;
+ Status dropReplicatedDatabases(OperationContext* opCtx) override;
- Status createOplog(OperationContext* txn, const NamespaceString& nss) override;
- StatusWith<size_t> getOplogMaxSize(OperationContext* txn, const NamespaceString& nss) override;
+ Status createOplog(OperationContext* opCtx, const NamespaceString& nss) override;
+ StatusWith<size_t> getOplogMaxSize(OperationContext* opCtx,
+ const NamespaceString& nss) override;
- Status createCollection(OperationContext* txn,
+ Status createCollection(OperationContext* opCtx,
const NamespaceString& nss,
const CollectionOptions& options) override;
- Status dropCollection(OperationContext* txn, const NamespaceString& nss) override;
+ Status dropCollection(OperationContext* opCtx, const NamespaceString& nss) override;
- StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* txn,
+ StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
@@ -112,7 +113,7 @@ public:
BoundInclusion boundInclusion,
std::size_t limit) override;
- StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* txn,
+ StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
@@ -120,12 +121,12 @@ public:
BoundInclusion boundInclusion,
std::size_t limit) override;
- Status isAdminDbValid(OperationContext* txn) override;
+ Status isAdminDbValid(OperationContext* opCtx) override;
private:
// Returns empty document if not present.
- BSONObj getMinValidDocument(OperationContext* txn) const;
- void updateMinValidDocument(OperationContext* txn, const BSONObj& updateSpec);
+ BSONObj getMinValidDocument(OperationContext* opCtx) const;
+ void updateMinValidDocument(OperationContext* opCtx, const BSONObj& updateSpec);
const NamespaceString _minValidNss;
};
diff --git a/src/mongo/db/repl/storage_interface_impl_test.cpp b/src/mongo/db/repl/storage_interface_impl_test.cpp
index c44e281f012..2ee2cbf2259 100644
--- a/src/mongo/db/repl/storage_interface_impl_test.cpp
+++ b/src/mongo/db/repl/storage_interface_impl_test.cpp
@@ -87,17 +87,17 @@ NamespaceString makeNamespace(const T& t, const char* suffix = "") {
/**
* Returns min valid document.
*/
-BSONObj getMinValidDocument(OperationContext* txn, const NamespaceString& minValidNss) {
+BSONObj getMinValidDocument(OperationContext* opCtx, const NamespaceString& minValidNss) {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction transaction(txn, MODE_IS);
- Lock::DBLock dblk(txn->lockState(), minValidNss.db(), MODE_IS);
- Lock::CollectionLock lk(txn->lockState(), minValidNss.ns(), MODE_IS);
+ ScopedTransaction transaction(opCtx, MODE_IS);
+ Lock::DBLock dblk(opCtx->lockState(), minValidNss.db(), MODE_IS);
+ Lock::CollectionLock lk(opCtx->lockState(), minValidNss.ns(), MODE_IS);
BSONObj mv;
- if (Helpers::getSingleton(txn, minValidNss.ns().c_str(), mv)) {
+ if (Helpers::getSingleton(opCtx, minValidNss.ns().c_str(), mv)) {
return mv;
}
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "getMinValidDocument", minValidNss.ns());
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "getMinValidDocument", minValidNss.ns());
return BSONObj();
}
@@ -116,21 +116,21 @@ CollectionOptions createOplogCollectionOptions() {
* Create test collection.
* Returns collection.
*/
-void createCollection(OperationContext* txn,
+void createCollection(OperationContext* opCtx,
const NamespaceString& nss,
const CollectionOptions& options = CollectionOptions()) {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock dblk(txn->lockState(), nss.db(), MODE_X);
- OldClientContext ctx(txn, nss.ns());
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock dblk(opCtx->lockState(), nss.db(), MODE_X);
+ OldClientContext ctx(opCtx, nss.ns());
auto db = ctx.db();
ASSERT_TRUE(db);
- mongo::WriteUnitOfWork wuow(txn);
- auto coll = db->createCollection(txn, nss.ns(), options);
+ mongo::WriteUnitOfWork wuow(opCtx);
+ auto coll = db->createCollection(opCtx, nss.ns(), options);
ASSERT_TRUE(coll);
wuow.commit();
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "createCollection", nss.ns());
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "createCollection", nss.ns());
}
/**
@@ -158,11 +158,11 @@ ReplSettings createReplSettings() {
/**
* Counts the number of keys in an index using an IndexAccessMethod::validate call.
*/
-int64_t getIndexKeyCount(OperationContext* txn, IndexCatalog* cat, IndexDescriptor* desc) {
+int64_t getIndexKeyCount(OperationContext* opCtx, IndexCatalog* cat, IndexDescriptor* desc) {
auto idx = cat->getIndex(desc);
int64_t numKeys;
ValidateResults fullRes;
- idx->validate(txn, &numKeys, &fullRes);
+ idx->validate(opCtx, &numKeys, &fullRes);
return numKeys;
}
@@ -191,28 +191,28 @@ protected:
ServiceContextMongoDTest::setUp();
createOptCtx();
_coordinator =
- new ReplicationCoordinatorMock(_txn->getServiceContext(), createReplSettings());
+ new ReplicationCoordinatorMock(_opCtx->getServiceContext(), createReplSettings());
setGlobalReplicationCoordinator(_coordinator);
}
void tearDown() override {
- _txn.reset(nullptr);
+ _opCtx.reset(nullptr);
ServiceContextMongoDTest::tearDown();
}
void createOptCtx() {
- _txn = cc().makeOperationContext();
+ _opCtx = cc().makeOperationContext();
// We are not replicating nor validating these writes.
- _txn->setReplicatedWrites(false);
- DisableDocumentValidation validationDisabler(_txn.get());
+ _opCtx->setReplicatedWrites(false);
+ DisableDocumentValidation validationDisabler(_opCtx.get());
}
OperationContext* getOperationContext() {
- return _txn.get();
+ return _opCtx.get();
}
private:
- ServiceContext::UniqueOperationContext _txn;
+ ServiceContext::UniqueOperationContext _opCtx;
// Owned by service context
ReplicationCoordinator* _coordinator;
@@ -249,23 +249,23 @@ TEST_F(StorageInterfaceImplTest, InitialSyncFlag) {
NamespaceString nss("local.StorageInterfaceImplTest_InitialSyncFlag");
StorageInterfaceImpl storageInterface(nss);
- auto txn = getClient()->makeOperationContext();
+ auto opCtx = getClient()->makeOperationContext();
// Initial sync flag should be unset after initializing a new storage engine.
- ASSERT_FALSE(storageInterface.getInitialSyncFlag(txn.get()));
+ ASSERT_FALSE(storageInterface.getInitialSyncFlag(opCtx.get()));
// Setting initial sync flag should affect getInitialSyncFlag() result.
- storageInterface.setInitialSyncFlag(txn.get());
- ASSERT_TRUE(storageInterface.getInitialSyncFlag(txn.get()));
+ storageInterface.setInitialSyncFlag(opCtx.get());
+ ASSERT_TRUE(storageInterface.getInitialSyncFlag(opCtx.get()));
// Check min valid document using storage engine interface.
- auto minValidDocument = getMinValidDocument(txn.get(), nss);
+ auto minValidDocument = getMinValidDocument(opCtx.get(), nss);
ASSERT_TRUE(minValidDocument.hasField(StorageInterfaceImpl::kInitialSyncFlagFieldName));
ASSERT_TRUE(minValidDocument.getBoolField(StorageInterfaceImpl::kInitialSyncFlagFieldName));
// Clearing initial sync flag should affect getInitialSyncFlag() result.
- storageInterface.clearInitialSyncFlag(txn.get());
- ASSERT_FALSE(storageInterface.getInitialSyncFlag(txn.get()));
+ storageInterface.clearInitialSyncFlag(opCtx.get());
+ ASSERT_FALSE(storageInterface.getInitialSyncFlag(opCtx.get()));
}
TEST_F(StorageInterfaceImplTest, GetMinValidAfterSettingInitialSyncFlagWorks) {
@@ -273,53 +273,54 @@ TEST_F(StorageInterfaceImplTest, GetMinValidAfterSettingInitialSyncFlagWorks) {
"local.StorageInterfaceImplTest_GetMinValidAfterSettingInitialSyncFlagWorks");
StorageInterfaceImpl storageInterface(nss);
- auto txn = getClient()->makeOperationContext();
+ auto opCtx = getClient()->makeOperationContext();
// Initial sync flag should be unset after initializing a new storage engine.
- ASSERT_FALSE(storageInterface.getInitialSyncFlag(txn.get()));
+ ASSERT_FALSE(storageInterface.getInitialSyncFlag(opCtx.get()));
// Setting initial sync flag should affect getInitialSyncFlag() result.
- storageInterface.setInitialSyncFlag(txn.get());
- ASSERT_TRUE(storageInterface.getInitialSyncFlag(txn.get()));
+ storageInterface.setInitialSyncFlag(opCtx.get());
+ ASSERT_TRUE(storageInterface.getInitialSyncFlag(opCtx.get()));
- ASSERT(storageInterface.getMinValid(txn.get()).isNull());
- ASSERT(storageInterface.getAppliedThrough(txn.get()).isNull());
- ASSERT(storageInterface.getOplogDeleteFromPoint(txn.get()).isNull());
+ ASSERT(storageInterface.getMinValid(opCtx.get()).isNull());
+ ASSERT(storageInterface.getAppliedThrough(opCtx.get()).isNull());
+ ASSERT(storageInterface.getOplogDeleteFromPoint(opCtx.get()).isNull());
}
TEST_F(StorageInterfaceImplTest, MinValid) {
NamespaceString nss("local.StorageInterfaceImplTest_MinValid");
StorageInterfaceImpl storageInterface(nss);
- auto txn = getClient()->makeOperationContext();
+ auto opCtx = getClient()->makeOperationContext();
// MinValid boundaries should all be null after initializing a new storage engine.
- ASSERT(storageInterface.getMinValid(txn.get()).isNull());
- ASSERT(storageInterface.getAppliedThrough(txn.get()).isNull());
- ASSERT(storageInterface.getOplogDeleteFromPoint(txn.get()).isNull());
+ ASSERT(storageInterface.getMinValid(opCtx.get()).isNull());
+ ASSERT(storageInterface.getAppliedThrough(opCtx.get()).isNull());
+ ASSERT(storageInterface.getOplogDeleteFromPoint(opCtx.get()).isNull());
// Setting min valid boundaries should affect getMinValid() result.
OpTime startOpTime({Seconds(123), 0}, 1LL);
OpTime endOpTime({Seconds(456), 0}, 1LL);
- storageInterface.setAppliedThrough(txn.get(), startOpTime);
- storageInterface.setMinValid(txn.get(), endOpTime);
- storageInterface.setOplogDeleteFromPoint(txn.get(), endOpTime.getTimestamp());
+ storageInterface.setAppliedThrough(opCtx.get(), startOpTime);
+ storageInterface.setMinValid(opCtx.get(), endOpTime);
+ storageInterface.setOplogDeleteFromPoint(opCtx.get(), endOpTime.getTimestamp());
- ASSERT_EQ(storageInterface.getAppliedThrough(txn.get()), startOpTime);
- ASSERT_EQ(storageInterface.getMinValid(txn.get()), endOpTime);
- ASSERT_EQ(storageInterface.getOplogDeleteFromPoint(txn.get()), endOpTime.getTimestamp());
+ ASSERT_EQ(storageInterface.getAppliedThrough(opCtx.get()), startOpTime);
+ ASSERT_EQ(storageInterface.getMinValid(opCtx.get()), endOpTime);
+ ASSERT_EQ(storageInterface.getOplogDeleteFromPoint(opCtx.get()), endOpTime.getTimestamp());
// setMinValid always changes minValid, but setMinValidToAtLeast only does if higher.
- storageInterface.setMinValid(txn.get(), startOpTime); // Forcibly lower it.
- ASSERT_EQ(storageInterface.getMinValid(txn.get()), startOpTime);
- storageInterface.setMinValidToAtLeast(txn.get(), endOpTime); // Higher than current (sets it).
- ASSERT_EQ(storageInterface.getMinValid(txn.get()), endOpTime);
- storageInterface.setMinValidToAtLeast(txn.get(), startOpTime); // Lower than current (no-op).
- ASSERT_EQ(storageInterface.getMinValid(txn.get()), endOpTime);
+ storageInterface.setMinValid(opCtx.get(), startOpTime); // Forcibly lower it.
+ ASSERT_EQ(storageInterface.getMinValid(opCtx.get()), startOpTime);
+ storageInterface.setMinValidToAtLeast(opCtx.get(),
+ endOpTime); // Higher than current (sets it).
+ ASSERT_EQ(storageInterface.getMinValid(opCtx.get()), endOpTime);
+ storageInterface.setMinValidToAtLeast(opCtx.get(), startOpTime); // Lower than current (no-op).
+ ASSERT_EQ(storageInterface.getMinValid(opCtx.get()), endOpTime);
// Check min valid document using storage engine interface.
- auto minValidDocument = getMinValidDocument(txn.get(), nss);
+ auto minValidDocument = getMinValidDocument(opCtx.get(), nss);
ASSERT_TRUE(minValidDocument.hasField(StorageInterfaceImpl::kBeginFieldName));
ASSERT_TRUE(minValidDocument[StorageInterfaceImpl::kBeginFieldName].isABSONObj());
ASSERT_EQUALS(startOpTime,
@@ -330,45 +331,45 @@ TEST_F(StorageInterfaceImplTest, MinValid) {
endOpTime.getTimestamp(),
minValidDocument[StorageInterfaceImpl::kOplogDeleteFromPointFieldName].timestamp());
- // Recovery unit will be owned by "txn".
+ // Recovery unit will be owned by "opCtx".
RecoveryUnitWithDurabilityTracking* recoveryUnit = new RecoveryUnitWithDurabilityTracking();
- txn->setRecoveryUnit(recoveryUnit, OperationContext::kNotInUnitOfWork);
+ opCtx->setRecoveryUnit(recoveryUnit, OperationContext::kNotInUnitOfWork);
// Set min valid without waiting for the changes to be durable.
OpTime endOpTime2({Seconds(789), 0}, 1LL);
- storageInterface.setMinValid(txn.get(), endOpTime2);
- storageInterface.setAppliedThrough(txn.get(), {});
- ASSERT_EQUALS(storageInterface.getAppliedThrough(txn.get()), OpTime());
- ASSERT_EQUALS(storageInterface.getMinValid(txn.get()), endOpTime2);
+ storageInterface.setMinValid(opCtx.get(), endOpTime2);
+ storageInterface.setAppliedThrough(opCtx.get(), {});
+ ASSERT_EQUALS(storageInterface.getAppliedThrough(opCtx.get()), OpTime());
+ ASSERT_EQUALS(storageInterface.getMinValid(opCtx.get()), endOpTime2);
ASSERT_FALSE(recoveryUnit->waitUntilDurableCalled);
}
TEST_F(StorageInterfaceImplTest, SnapshotSupported) {
- auto txn = getClient()->makeOperationContext();
- Status status = txn->recoveryUnit()->setReadFromMajorityCommittedSnapshot();
+ auto opCtx = getClient()->makeOperationContext();
+ Status status = opCtx->recoveryUnit()->setReadFromMajorityCommittedSnapshot();
ASSERT(status.isOK());
}
TEST_F(StorageInterfaceImplTest, InsertDocumentsReturnsOKWhenNoOperationsAreGiven) {
- auto txn = getClient()->makeOperationContext();
+ auto opCtx = getClient()->makeOperationContext();
NamespaceString nss("local." + _agent.getTestName());
- createCollection(txn.get(), nss);
+ createCollection(opCtx.get(), nss);
StorageInterfaceImpl storageInterface(nss);
- ASSERT_OK(storageInterface.insertDocuments(txn.get(), nss, {}));
+ ASSERT_OK(storageInterface.insertDocuments(opCtx.get(), nss, {}));
}
TEST_F(StorageInterfaceImplTest,
InsertDocumentsReturnsInternalErrorWhenSavingOperationToNonOplogCollection) {
// Create fake non-oplog collection to ensure saving oplog entries (without _id field) will
// fail.
- auto txn = getClient()->makeOperationContext();
+ auto opCtx = getClient()->makeOperationContext();
NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
- createCollection(txn.get(), nss);
+ createCollection(opCtx.get(), nss);
// Non-oplog collection will enforce mandatory _id field requirement on insertion.
StorageInterfaceImpl storageInterface(nss);
auto op = makeOplogEntry({Timestamp(Seconds(1), 0), 1LL});
- auto status = storageInterface.insertDocuments(txn.get(), nss, {op});
+ auto status = storageInterface.insertDocuments(opCtx.get(), nss, {op});
ASSERT_EQUALS(ErrorCodes::InternalError, status);
ASSERT_STRING_CONTAINS(status.reason(), "Collection::insertDocument got document without _id");
}
@@ -376,12 +377,12 @@ TEST_F(StorageInterfaceImplTest,
TEST_F(StorageInterfaceImplTest,
InsertDocumentsInsertsDocumentsOneAtATimeWhenAllAtOnceInsertingFails) {
// Create a collection that does not support all-at-once inserting.
- auto txn = getClient()->makeOperationContext();
+ auto opCtx = getClient()->makeOperationContext();
NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
CollectionOptions options;
options.capped = true;
options.cappedSize = 1024 * 1024;
- createCollection(txn.get(), nss, options);
+ createCollection(opCtx.get(), nss, options);
// StorageInterfaceImpl::insertDocuments should fall back on inserting the batch one at a time.
StorageInterfaceImpl storageInterface(nss);
auto doc1 = BSON("_id" << 1);
@@ -389,16 +390,16 @@ TEST_F(StorageInterfaceImplTest,
std::vector<BSONObj> docs({doc1, doc2});
// Confirm that Collection::insertDocuments fails to insert the batch all at once.
{
- AutoGetCollection autoCollection(txn.get(), nss, MODE_IX);
- WriteUnitOfWork wunit(txn.get());
+ AutoGetCollection autoCollection(opCtx.get(), nss, MODE_IX);
+ WriteUnitOfWork wunit(opCtx.get());
ASSERT_EQUALS(ErrorCodes::OperationCannotBeBatched,
autoCollection.getCollection()->insertDocuments(
- txn.get(), docs.begin(), docs.cend(), nullptr, false));
+ opCtx.get(), docs.begin(), docs.cend(), nullptr, false));
}
- ASSERT_OK(storageInterface.insertDocuments(txn.get(), nss, docs));
+ ASSERT_OK(storageInterface.insertDocuments(opCtx.get(), nss, docs));
// Check collection contents. OplogInterface returns documents in reverse natural order.
- OplogInterfaceLocal oplog(txn.get(), nss.ns());
+ OplogInterfaceLocal oplog(opCtx.get(), nss.ns());
auto iter = oplog.makeIterator();
ASSERT_BSONOBJ_EQ(doc2, unittest::assertGet(iter->next()).first);
ASSERT_BSONOBJ_EQ(doc1, unittest::assertGet(iter->next()).first);
@@ -407,19 +408,19 @@ TEST_F(StorageInterfaceImplTest,
TEST_F(StorageInterfaceImplTest, InsertDocumentsSavesOperationsReturnsOpTimeOfLastOperation) {
// Create fake oplog collection to hold operations.
- auto txn = getClient()->makeOperationContext();
+ auto opCtx = getClient()->makeOperationContext();
NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
- createCollection(txn.get(), nss, createOplogCollectionOptions());
+ createCollection(opCtx.get(), nss, createOplogCollectionOptions());
// Insert operations using storage interface. Ensure optime return is consistent with last
// operation inserted.
StorageInterfaceImpl storageInterface(nss);
auto op1 = makeOplogEntry({Timestamp(Seconds(1), 0), 1LL});
auto op2 = makeOplogEntry({Timestamp(Seconds(1), 0), 1LL});
- ASSERT_OK(storageInterface.insertDocuments(txn.get(), nss, {op1, op2}));
+ ASSERT_OK(storageInterface.insertDocuments(opCtx.get(), nss, {op1, op2}));
// Check contents of oplog. OplogInterface iterates over oplog collection in reverse.
- repl::OplogInterfaceLocal oplog(txn.get(), nss.ns());
+ repl::OplogInterfaceLocal oplog(opCtx.get(), nss.ns());
auto iter = oplog.makeIterator();
ASSERT_BSONOBJ_EQ(op2, unittest::assertGet(iter->next()).first);
ASSERT_BSONOBJ_EQ(op1, unittest::assertGet(iter->next()).first);
@@ -431,46 +432,46 @@ TEST_F(StorageInterfaceImplTest,
auto op = makeOplogEntry({Timestamp(Seconds(1), 0), 1LL});
NamespaceString nss("local.nosuchcollection");
StorageInterfaceImpl storageInterface(nss);
- auto txn = getClient()->makeOperationContext();
- auto status = storageInterface.insertDocuments(txn.get(), nss, {op});
+ auto opCtx = getClient()->makeOperationContext();
+ auto status = storageInterface.insertDocuments(opCtx.get(), nss, {op});
ASSERT_EQUALS(ErrorCodes::NamespaceNotFound, status);
ASSERT_STRING_CONTAINS(status.reason(), "The collection must exist before inserting documents");
}
TEST_F(StorageInterfaceImplWithReplCoordTest, InsertMissingDocWorksOnExistingCappedCollection) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
NamespaceString nss("foo.bar");
CollectionOptions opts;
opts.capped = true;
opts.cappedSize = 1024 * 1024;
- createCollection(txn, nss, opts);
- ASSERT_OK(storage.insertDocument(txn, nss, BSON("_id" << 1)));
- AutoGetCollectionForRead autoColl(txn, nss);
+ createCollection(opCtx, nss, opts);
+ ASSERT_OK(storage.insertDocument(opCtx, nss, BSON("_id" << 1)));
+ AutoGetCollectionForRead autoColl(opCtx, nss);
ASSERT_TRUE(autoColl.getCollection());
}
TEST_F(StorageInterfaceImplWithReplCoordTest, InsertMissingDocWorksOnExistingCollection) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
NamespaceString nss("foo.bar");
- createCollection(txn, nss);
- ASSERT_OK(storage.insertDocument(txn, nss, BSON("_id" << 1)));
- AutoGetCollectionForRead autoColl(txn, nss);
+ createCollection(opCtx, nss);
+ ASSERT_OK(storage.insertDocument(opCtx, nss, BSON("_id" << 1)));
+ AutoGetCollectionForRead autoColl(opCtx, nss);
ASSERT_TRUE(autoColl.getCollection());
}
TEST_F(StorageInterfaceImplWithReplCoordTest, InsertMissingDocFailesIfCollectionIsMissing) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
NamespaceString nss("foo.bar");
- const auto status = storage.insertDocument(txn, nss, BSON("_id" << 1));
+ const auto status = storage.insertDocument(opCtx, nss, BSON("_id" << 1));
ASSERT_NOT_OK(status);
ASSERT_EQ(status.code(), ErrorCodes::NamespaceNotFound);
}
TEST_F(StorageInterfaceImplWithReplCoordTest, CreateCollectionWithIDIndexCommits) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
storage.startup();
NamespaceString nss("foo.bar");
@@ -484,18 +485,18 @@ TEST_F(StorageInterfaceImplWithReplCoordTest, CreateCollectionWithIDIndexCommits
ASSERT_OK(loader->insertDocuments(docs.begin(), docs.end()));
ASSERT_OK(loader->commit());
- AutoGetCollectionForRead autoColl(txn, nss);
+ AutoGetCollectionForRead autoColl(opCtx, nss);
auto coll = autoColl.getCollection();
ASSERT(coll);
- ASSERT_EQ(coll->getRecordStore()->numRecords(txn), 2LL);
+ ASSERT_EQ(coll->getRecordStore()->numRecords(opCtx), 2LL);
auto collIdxCat = coll->getIndexCatalog();
- auto idIdxDesc = collIdxCat->findIdIndex(txn);
- auto count = getIndexKeyCount(txn, collIdxCat, idIdxDesc);
+ auto idIdxDesc = collIdxCat->findIdIndex(opCtx);
+ auto count = getIndexKeyCount(opCtx, collIdxCat, idIdxDesc);
ASSERT_EQ(count, 2LL);
}
void _testDestroyUncommitedCollectionBulkLoader(
- OperationContext* txn,
+ OperationContext* opCtx,
std::vector<BSONObj> secondaryIndexes,
stdx::function<void(std::unique_ptr<CollectionBulkLoader> loader)> destroyLoaderFn) {
StorageInterfaceImpl storage;
@@ -513,23 +514,23 @@ void _testDestroyUncommitedCollectionBulkLoader(
// Collection and ID index should not exist after 'loader' is destroyed.
destroyLoaderFn(std::move(loader));
- AutoGetCollectionForRead autoColl(txn, nss);
+ AutoGetCollectionForRead autoColl(opCtx, nss);
auto coll = autoColl.getCollection();
// Bulk loader is used to create indexes. The collection is not dropped when the bulk loader is
// destroyed.
ASSERT_TRUE(coll);
- ASSERT_EQ(1LL, coll->getRecordStore()->numRecords(txn));
+ ASSERT_EQ(1LL, coll->getRecordStore()->numRecords(opCtx));
// IndexCatalog::numIndexesTotal() includes unfinished indexes. We need to ensure that
// the bulk loader drops the unfinished indexes.
auto collIdxCat = coll->getIndexCatalog();
- ASSERT_EQUALS(0, collIdxCat->numIndexesTotal(txn));
+ ASSERT_EQUALS(0, collIdxCat->numIndexesTotal(opCtx));
}
TEST_F(StorageInterfaceImplWithReplCoordTest,
DestroyingUncommittedCollectionBulkLoaderDropsIndexes) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
NamespaceString nss("foo.bar");
std::vector<BSONObj> indexes = {BSON("v" << 1 << "key" << BSON("x" << 1) << "name"
<< "x_1"
@@ -538,24 +539,24 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
auto destroyLoaderFn = [](std::unique_ptr<CollectionBulkLoader> loader) {
// Destroy 'loader' by letting it go out of scope.
};
- _testDestroyUncommitedCollectionBulkLoader(txn, indexes, destroyLoaderFn);
+ _testDestroyUncommitedCollectionBulkLoader(opCtx, indexes, destroyLoaderFn);
}
TEST_F(StorageInterfaceImplWithReplCoordTest,
DestructorInitializesClientBeforeDestroyingIdIndexBuilder) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
NamespaceString nss("foo.bar");
std::vector<BSONObj> indexes;
auto destroyLoaderFn = [](std::unique_ptr<CollectionBulkLoader> loader) {
// Destroy 'loader' in a new thread that does not have a Client.
stdx::thread([&loader]() { loader.reset(); }).join();
};
- _testDestroyUncommitedCollectionBulkLoader(txn, indexes, destroyLoaderFn);
+ _testDestroyUncommitedCollectionBulkLoader(opCtx, indexes, destroyLoaderFn);
}
TEST_F(StorageInterfaceImplWithReplCoordTest,
DestructorInitializesClientBeforeDestroyingSecondaryIndexesBuilder) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
NamespaceString nss("foo.bar");
std::vector<BSONObj> indexes = {BSON("v" << 1 << "key" << BSON("x" << 1) << "name"
<< "x_1"
@@ -565,15 +566,15 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// Destroy 'loader' in a new thread that does not have a Client.
stdx::thread([&loader]() { loader.reset(); }).join();
};
- _testDestroyUncommitedCollectionBulkLoader(txn, indexes, destroyLoaderFn);
+ _testDestroyUncommitedCollectionBulkLoader(opCtx, indexes, destroyLoaderFn);
}
TEST_F(StorageInterfaceImplWithReplCoordTest, CreateCollectionThatAlreadyExistsFails) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
storage.startup();
NamespaceString nss("test.system.indexes");
- createCollection(txn, nss);
+ createCollection(opCtx, nss);
const CollectionOptions opts;
const std::vector<BSONObj> indexes;
@@ -583,16 +584,16 @@ TEST_F(StorageInterfaceImplWithReplCoordTest, CreateCollectionThatAlreadyExistsF
}
TEST_F(StorageInterfaceImplWithReplCoordTest, CreateOplogCreateCappedCollection) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
NamespaceString nss("local.oplog.X");
{
- AutoGetCollectionForRead autoColl(txn, nss);
+ AutoGetCollectionForRead autoColl(opCtx, nss);
ASSERT_FALSE(autoColl.getCollection());
}
- ASSERT_OK(storage.createOplog(txn, nss));
+ ASSERT_OK(storage.createOplog(opCtx, nss));
{
- AutoGetCollectionForRead autoColl(txn, nss);
+ AutoGetCollectionForRead autoColl(opCtx, nss);
ASSERT_TRUE(autoColl.getCollection());
ASSERT_EQ(nss.toString(), autoColl.getCollection()->ns().toString());
ASSERT_TRUE(autoColl.getCollection()->isCapped());
@@ -601,78 +602,78 @@ TEST_F(StorageInterfaceImplWithReplCoordTest, CreateOplogCreateCappedCollection)
TEST_F(StorageInterfaceImplWithReplCoordTest,
CreateCollectionReturnsUserExceptionAsStatusIfCollectionCreationThrows) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
NamespaceString nss("local.oplog.Y");
{
- AutoGetCollectionForRead autoColl(txn, nss);
+ AutoGetCollectionForRead autoColl(opCtx, nss);
ASSERT_FALSE(autoColl.getCollection());
}
- auto status = storage.createCollection(txn, nss, CollectionOptions());
+ auto status = storage.createCollection(opCtx, nss, CollectionOptions());
ASSERT_EQUALS(ErrorCodes::fromInt(28838), status);
ASSERT_STRING_CONTAINS(status.reason(), "cannot create a non-capped oplog collection");
}
TEST_F(StorageInterfaceImplWithReplCoordTest, CreateCollectionFailsIfCollectionExists) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
{
- AutoGetCollectionForRead autoColl(txn, nss);
+ AutoGetCollectionForRead autoColl(opCtx, nss);
ASSERT_FALSE(autoColl.getCollection());
}
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
{
- AutoGetCollectionForRead autoColl(txn, nss);
+ AutoGetCollectionForRead autoColl(opCtx, nss);
ASSERT_TRUE(autoColl.getCollection());
ASSERT_EQ(nss.toString(), autoColl.getCollection()->ns().toString());
}
- auto status = storage.createCollection(txn, nss, CollectionOptions());
+ auto status = storage.createCollection(opCtx, nss, CollectionOptions());
ASSERT_EQUALS(ErrorCodes::NamespaceExists, status);
ASSERT_STRING_CONTAINS(status.reason(),
str::stream() << "Collection " << nss.ns() << " already exists");
}
TEST_F(StorageInterfaceImplWithReplCoordTest, DropCollectionWorksWithExistingWithDataCollection) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
NamespaceString nss("foo.bar");
- createCollection(txn, nss);
- ASSERT_OK(storage.insertDocument(txn, nss, BSON("_id" << 1)));
- ASSERT_OK(storage.dropCollection(txn, nss));
+ createCollection(opCtx, nss);
+ ASSERT_OK(storage.insertDocument(opCtx, nss, BSON("_id" << 1)));
+ ASSERT_OK(storage.dropCollection(opCtx, nss));
}
TEST_F(StorageInterfaceImplWithReplCoordTest, DropCollectionWorksWithExistingEmptyCollection) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
NamespaceString nss("foo.bar");
- createCollection(txn, nss);
- ASSERT_OK(storage.dropCollection(txn, nss));
- AutoGetCollectionForRead autoColl(txn, nss);
+ createCollection(opCtx, nss);
+ ASSERT_OK(storage.dropCollection(opCtx, nss));
+ AutoGetCollectionForRead autoColl(opCtx, nss);
ASSERT_FALSE(autoColl.getCollection());
}
TEST_F(StorageInterfaceImplWithReplCoordTest, DropCollectionWorksWithMissingCollection) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
NamespaceString nss("foo.bar");
- ASSERT_FALSE(AutoGetDb(txn, nss.db(), MODE_IS).getDb());
- ASSERT_OK(storage.dropCollection(txn, nss));
- ASSERT_FALSE(AutoGetCollectionForRead(txn, nss).getCollection());
+ ASSERT_FALSE(AutoGetDb(opCtx, nss.db(), MODE_IS).getDb());
+ ASSERT_OK(storage.dropCollection(opCtx, nss));
+ ASSERT_FALSE(AutoGetCollectionForRead(opCtx, nss).getCollection());
// Database should not be created after running dropCollection.
- ASSERT_FALSE(AutoGetDb(txn, nss.db(), MODE_IS).getDb());
+ ASSERT_FALSE(AutoGetDb(opCtx, nss.db(), MODE_IS).getDb());
}
TEST_F(StorageInterfaceImplWithReplCoordTest,
FindDocumentsReturnsInvalidNamespaceIfCollectionIsMissing) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
auto indexName = "_id_"_sd;
ASSERT_EQUALS(ErrorCodes::NamespaceNotFound,
storage
- .findDocuments(txn,
+ .findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -683,14 +684,14 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
}
TEST_F(StorageInterfaceImplWithReplCoordTest, FindDocumentsReturnsIndexNotFoundIfIndexIsMissing) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
auto indexName = "nonexistent"_sd;
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
ASSERT_EQUALS(ErrorCodes::IndexNotFound,
storage
- .findDocuments(txn,
+ .findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -702,7 +703,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest, FindDocumentsReturnsIndexNotFoundI
TEST_F(StorageInterfaceImplWithReplCoordTest,
FindDocumentsReturnsIndexOptionsConflictIfIndexIsAPartialIndex) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
storage.startup();
auto nss = makeNamespace(_agent);
@@ -720,7 +721,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
auto indexName = "x_1"_sd;
ASSERT_EQUALS(ErrorCodes::IndexOptionsConflict,
storage
- .findDocuments(txn,
+ .findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -731,12 +732,12 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
}
TEST_F(StorageInterfaceImplWithReplCoordTest, FindDocumentsReturnsEmptyVectorIfCollectionIsEmpty) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
auto indexName = "_id_"_sd;
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_TRUE(unittest::assertGet(storage.findDocuments(txn,
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_TRUE(unittest::assertGet(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -765,12 +766,12 @@ std::string _toString(const std::vector<BSONObj>& docs) {
/**
* Check collection contents. OplogInterface returns documents in reverse natural order.
*/
-void _assertDocumentsInCollectionEquals(OperationContext* txn,
+void _assertDocumentsInCollectionEquals(OperationContext* opCtx,
const NamespaceString& nss,
const std::vector<BSONObj>& docs) {
std::vector<BSONObj> reversedDocs(docs);
std::reverse(reversedDocs.begin(), reversedDocs.end());
- OplogInterfaceLocal oplog(txn, nss.ns());
+ OplogInterfaceLocal oplog(opCtx, nss.ns());
auto iter = oplog.makeIterator();
for (const auto& doc : reversedDocs) {
ASSERT_BSONOBJ_EQ(doc, unittest::assertGet(iter->next()).first);
@@ -805,12 +806,12 @@ BSONObj _assetGetFront(const StatusWith<std::vector<BSONObj>>& statusWithDocs) {
TEST_F(StorageInterfaceImplWithReplCoordTest,
FindDocumentsReturnsDocumentWithLowestKeyValueIfScanDirectionIsForward) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
auto indexName = "_id_"_sd;
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(storage.insertDocuments(txn,
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(opCtx,
nss,
{BSON("_id" << 0),
BSON("_id" << 1),
@@ -821,7 +822,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey not provided
ASSERT_BSONOBJ_EQ(
BSON("_id" << 0),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -830,7 +831,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
1U)));
// startKey not provided. limit is 0.
- _assertDocumentsEqual(storage.findDocuments(txn,
+ _assertDocumentsEqual(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -840,7 +841,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
{});
// startKey not provided. limit of 2.
- _assertDocumentsEqual(storage.findDocuments(txn,
+ _assertDocumentsEqual(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -852,7 +853,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; include start key
ASSERT_BSONOBJ_EQ(
BSON("_id" << 0),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -861,7 +862,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
1U)));
ASSERT_BSONOBJ_EQ(
BSON("_id" << 1),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -871,7 +872,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
ASSERT_BSONOBJ_EQ(
BSON("_id" << 1),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -882,7 +883,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; include both start and end keys
ASSERT_BSONOBJ_EQ(
BSON("_id" << 1),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -893,7 +894,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; exclude start key
ASSERT_BSONOBJ_EQ(
BSON("_id" << 2),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -903,7 +904,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
ASSERT_BSONOBJ_EQ(
BSON("_id" << 2),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -914,7 +915,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; exclude both start and end keys
ASSERT_BSONOBJ_EQ(
BSON("_id" << 2),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -924,7 +925,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; exclude both start and end keys.
// A limit of 3 should return 2 documents because we reached the end of the collection.
- _assertDocumentsEqual(storage.findDocuments(txn,
+ _assertDocumentsEqual(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -934,19 +935,19 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
{BSON("_id" << 3), BSON("_id" << 4)});
_assertDocumentsInCollectionEquals(
- txn,
+ opCtx,
nss,
{BSON("_id" << 0), BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 3), BSON("_id" << 4)});
}
TEST_F(StorageInterfaceImplWithReplCoordTest,
FindDocumentsReturnsDocumentWithHighestKeyValueIfScanDirectionIsBackward) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
auto indexName = "_id_"_sd;
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(storage.insertDocuments(txn,
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(opCtx,
nss,
{BSON("_id" << 0),
BSON("_id" << 1),
@@ -957,7 +958,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey not provided
ASSERT_BSONOBJ_EQ(
BSON("_id" << 4),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -966,7 +967,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
1U)));
// startKey not provided. limit is 0.
- _assertDocumentsEqual(storage.findDocuments(txn,
+ _assertDocumentsEqual(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -976,7 +977,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
{});
// startKey not provided. limit of 2.
- _assertDocumentsEqual(storage.findDocuments(txn,
+ _assertDocumentsEqual(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -988,7 +989,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; include start key
ASSERT_BSONOBJ_EQ(
BSON("_id" << 4),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -997,7 +998,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
1U)));
ASSERT_BSONOBJ_EQ(
BSON("_id" << 3),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -1008,7 +1009,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; include both start and end keys
ASSERT_BSONOBJ_EQ(
BSON("_id" << 4),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -1019,7 +1020,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; exclude start key
ASSERT_BSONOBJ_EQ(
BSON("_id" << 2),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -1030,7 +1031,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; exclude both start and end keys
ASSERT_BSONOBJ_EQ(
BSON("_id" << 2),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -1040,7 +1041,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; exclude both start and end keys.
// A limit of 3 should return 2 documents because we reached the beginning of the collection.
- _assertDocumentsEqual(storage.findDocuments(txn,
+ _assertDocumentsEqual(storage.findDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -1050,22 +1051,22 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
{BSON("_id" << 1), BSON("_id" << 0)});
_assertDocumentsInCollectionEquals(
- txn,
+ opCtx,
nss,
{BSON("_id" << 0), BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 3), BSON("_id" << 4)});
}
TEST_F(StorageInterfaceImplWithReplCoordTest,
FindDocumentsCollScanReturnsFirstDocumentInsertedIfScanDirectionIsForward) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(
- storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(
+ opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
ASSERT_BSONOBJ_EQ(
BSON("_id" << 1),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
boost::none,
StorageInterface::ScanDirection::kForward,
@@ -1074,7 +1075,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
1U)));
// Check collection contents. OplogInterface returns documents in reverse natural order.
- OplogInterfaceLocal oplog(txn, nss.ns());
+ OplogInterfaceLocal oplog(opCtx, nss.ns());
auto iter = oplog.makeIterator();
ASSERT_BSONOBJ_EQ(BSON("_id" << 0), unittest::assertGet(iter->next()).first);
ASSERT_BSONOBJ_EQ(BSON("_id" << 2), unittest::assertGet(iter->next()).first);
@@ -1084,15 +1085,15 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
TEST_F(StorageInterfaceImplWithReplCoordTest,
FindDocumentsCollScanReturnsLastDocumentInsertedIfScanDirectionIsBackward) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(
- storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(
+ opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
ASSERT_BSONOBJ_EQ(
BSON("_id" << 0),
- _assetGetFront(storage.findDocuments(txn,
+ _assetGetFront(storage.findDocuments(opCtx,
nss,
boost::none,
StorageInterface::ScanDirection::kBackward,
@@ -1101,20 +1102,20 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
1U)));
_assertDocumentsInCollectionEquals(
- txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)});
+ opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)});
}
TEST_F(StorageInterfaceImplWithReplCoordTest,
FindDocumentsCollScanReturnsNoSuchKeyIfStartKeyIsNotEmpty) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(
- storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(
+ opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
ASSERT_EQUALS(ErrorCodes::NoSuchKey,
storage
- .findDocuments(txn,
+ .findDocuments(opCtx,
nss,
boost::none,
StorageInterface::ScanDirection::kForward,
@@ -1126,15 +1127,15 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
TEST_F(StorageInterfaceImplWithReplCoordTest,
FindDocumentsCollScanReturnsInvalidOptionsIfBoundIsNotStartKeyOnly) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(
- storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(
+ opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
ASSERT_EQUALS(ErrorCodes::InvalidOptions,
storage
- .findDocuments(txn,
+ .findDocuments(opCtx,
nss,
boost::none,
StorageInterface::ScanDirection::kForward,
@@ -1146,13 +1147,13 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
TEST_F(StorageInterfaceImplWithReplCoordTest,
DeleteDocumentsReturnsInvalidNamespaceIfCollectionIsMissing) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
auto indexName = "_id_"_sd;
ASSERT_EQUALS(ErrorCodes::NamespaceNotFound,
storage
- .deleteDocuments(txn,
+ .deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -1163,14 +1164,14 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
}
TEST_F(StorageInterfaceImplWithReplCoordTest, DeleteDocumentsReturnsIndexNotFoundIfIndexIsMissing) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
auto indexName = "nonexistent"_sd;
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
ASSERT_EQUALS(ErrorCodes::IndexNotFound,
storage
- .deleteDocuments(txn,
+ .deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -1182,13 +1183,13 @@ TEST_F(StorageInterfaceImplWithReplCoordTest, DeleteDocumentsReturnsIndexNotFoun
TEST_F(StorageInterfaceImplWithReplCoordTest,
DeleteDocumentsReturnsEmptyVectorIfCollectionIsEmpty) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
auto indexName = "_id_"_sd;
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
ASSERT_TRUE(
- unittest::assertGet(storage.deleteDocuments(txn,
+ unittest::assertGet(storage.deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -1200,12 +1201,12 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
TEST_F(StorageInterfaceImplWithReplCoordTest,
DeleteDocumentsReturnsDocumentWithLowestKeyValueIfScanDirectionIsForward) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
auto indexName = "_id_"_sd;
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(storage.insertDocuments(txn,
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(opCtx,
nss,
{BSON("_id" << 0),
BSON("_id" << 1),
@@ -1219,7 +1220,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey not provided
ASSERT_BSONOBJ_EQ(
BSON("_id" << 0),
- _assetGetFront(storage.deleteDocuments(txn,
+ _assetGetFront(storage.deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -1227,7 +1228,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
BoundInclusion::kIncludeStartKeyOnly,
1U)));
- _assertDocumentsInCollectionEquals(txn,
+ _assertDocumentsInCollectionEquals(opCtx,
nss,
{BSON("_id" << 1),
BSON("_id" << 2),
@@ -1238,7 +1239,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
BSON("_id" << 7)});
// startKey not provided. limit is 0.
- _assertDocumentsEqual(storage.deleteDocuments(txn,
+ _assertDocumentsEqual(storage.deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -1247,7 +1248,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
0U),
{});
- _assertDocumentsInCollectionEquals(txn,
+ _assertDocumentsInCollectionEquals(opCtx,
nss,
{BSON("_id" << 1),
BSON("_id" << 2),
@@ -1260,7 +1261,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; include start key
ASSERT_BSONOBJ_EQ(
BSON("_id" << 2),
- _assetGetFront(storage.deleteDocuments(txn,
+ _assetGetFront(storage.deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -1268,7 +1269,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
BoundInclusion::kIncludeStartKeyOnly,
1U)));
- _assertDocumentsInCollectionEquals(txn,
+ _assertDocumentsInCollectionEquals(opCtx,
nss,
{BSON("_id" << 1),
BSON("_id" << 3),
@@ -1280,7 +1281,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; exclude start key
ASSERT_BSONOBJ_EQ(
BSON("_id" << 5),
- _assetGetFront(storage.deleteDocuments(txn,
+ _assetGetFront(storage.deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -1289,13 +1290,13 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
1U)));
_assertDocumentsInCollectionEquals(
- txn,
+ opCtx,
nss,
{BSON("_id" << 1), BSON("_id" << 3), BSON("_id" << 4), BSON("_id" << 6), BSON("_id" << 7)});
// startKey provided; exclude start key.
// A limit of 3 should return 2 documents because we reached the end of the collection.
- _assertDocumentsEqual(storage.deleteDocuments(txn,
+ _assertDocumentsEqual(storage.deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kForward,
@@ -1305,17 +1306,17 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
{BSON("_id" << 6), BSON("_id" << 7)});
_assertDocumentsInCollectionEquals(
- txn, nss, {BSON("_id" << 1), BSON("_id" << 3), BSON("_id" << 4)});
+ opCtx, nss, {BSON("_id" << 1), BSON("_id" << 3), BSON("_id" << 4)});
}
TEST_F(StorageInterfaceImplWithReplCoordTest,
DeleteDocumentsReturnsDocumentWithHighestKeyValueIfScanDirectionIsBackward) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
auto indexName = "_id_"_sd;
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(storage.insertDocuments(txn,
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(opCtx,
nss,
{BSON("_id" << 0),
BSON("_id" << 1),
@@ -1329,7 +1330,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey not provided
ASSERT_BSONOBJ_EQ(
BSON("_id" << 7),
- _assetGetFront(storage.deleteDocuments(txn,
+ _assetGetFront(storage.deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -1337,7 +1338,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
BoundInclusion::kIncludeStartKeyOnly,
1U)));
- _assertDocumentsInCollectionEquals(txn,
+ _assertDocumentsInCollectionEquals(opCtx,
nss,
{BSON("_id" << 0),
BSON("_id" << 1),
@@ -1348,7 +1349,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
BSON("_id" << 6)});
// startKey not provided. limit is 0.
- _assertDocumentsEqual(storage.deleteDocuments(txn,
+ _assertDocumentsEqual(storage.deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -1357,7 +1358,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
0U),
{});
- _assertDocumentsInCollectionEquals(txn,
+ _assertDocumentsInCollectionEquals(opCtx,
nss,
{BSON("_id" << 0),
BSON("_id" << 1),
@@ -1370,7 +1371,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; include start key
ASSERT_BSONOBJ_EQ(
BSON("_id" << 5),
- _assetGetFront(storage.deleteDocuments(txn,
+ _assetGetFront(storage.deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -1378,7 +1379,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
BoundInclusion::kIncludeStartKeyOnly,
1U)));
- _assertDocumentsInCollectionEquals(txn,
+ _assertDocumentsInCollectionEquals(opCtx,
nss,
{BSON("_id" << 0),
BSON("_id" << 1),
@@ -1390,7 +1391,7 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
// startKey provided; exclude start key
ASSERT_BSONOBJ_EQ(
BSON("_id" << 2),
- _assetGetFront(storage.deleteDocuments(txn,
+ _assetGetFront(storage.deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -1399,13 +1400,13 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
1U)));
_assertDocumentsInCollectionEquals(
- txn,
+ opCtx,
nss,
{BSON("_id" << 0), BSON("_id" << 1), BSON("_id" << 3), BSON("_id" << 4), BSON("_id" << 6)});
// startKey provided; exclude start key.
// A limit of 3 should return 2 documents because we reached the beginning of the collection.
- _assertDocumentsEqual(storage.deleteDocuments(txn,
+ _assertDocumentsEqual(storage.deleteDocuments(opCtx,
nss,
indexName,
StorageInterface::ScanDirection::kBackward,
@@ -1415,20 +1416,20 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
{BSON("_id" << 1), BSON("_id" << 0)});
_assertDocumentsInCollectionEquals(
- txn, nss, {BSON("_id" << 3), BSON("_id" << 4), BSON("_id" << 6)});
+ opCtx, nss, {BSON("_id" << 3), BSON("_id" << 4), BSON("_id" << 6)});
}
TEST_F(StorageInterfaceImplWithReplCoordTest,
DeleteDocumentsCollScanReturnsFirstDocumentInsertedIfScanDirectionIsForward) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(
- storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(
+ opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
ASSERT_BSONOBJ_EQ(
BSON("_id" << 1),
- _assetGetFront(storage.deleteDocuments(txn,
+ _assetGetFront(storage.deleteDocuments(opCtx,
nss,
boost::none,
StorageInterface::ScanDirection::kForward,
@@ -1436,20 +1437,20 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
BoundInclusion::kIncludeStartKeyOnly,
1U)));
- _assertDocumentsInCollectionEquals(txn, nss, {BSON("_id" << 2), BSON("_id" << 0)});
+ _assertDocumentsInCollectionEquals(opCtx, nss, {BSON("_id" << 2), BSON("_id" << 0)});
}
TEST_F(StorageInterfaceImplWithReplCoordTest,
DeleteDocumentsCollScanReturnsLastDocumentInsertedIfScanDirectionIsBackward) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(
- storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(
+ opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
ASSERT_BSONOBJ_EQ(
BSON("_id" << 0),
- _assetGetFront(storage.deleteDocuments(txn,
+ _assetGetFront(storage.deleteDocuments(opCtx,
nss,
boost::none,
StorageInterface::ScanDirection::kBackward,
@@ -1457,20 +1458,20 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
BoundInclusion::kIncludeStartKeyOnly,
1U)));
- _assertDocumentsInCollectionEquals(txn, nss, {BSON("_id" << 1), BSON("_id" << 2)});
+ _assertDocumentsInCollectionEquals(opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2)});
}
TEST_F(StorageInterfaceImplWithReplCoordTest,
DeleteDocumentsCollScanReturnsNoSuchKeyIfStartKeyIsNotEmpty) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(
- storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(
+ opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
ASSERT_EQUALS(ErrorCodes::NoSuchKey,
storage
- .deleteDocuments(txn,
+ .deleteDocuments(opCtx,
nss,
boost::none,
StorageInterface::ScanDirection::kForward,
@@ -1482,15 +1483,15 @@ TEST_F(StorageInterfaceImplWithReplCoordTest,
TEST_F(StorageInterfaceImplWithReplCoordTest,
DeleteDocumentsCollScanReturnsInvalidOptionsIfBoundIsNotStartKeyOnly) {
- auto txn = getOperationContext();
+ auto opCtx = getOperationContext();
StorageInterfaceImpl storage;
auto nss = makeNamespace(_agent);
- ASSERT_OK(storage.createCollection(txn, nss, CollectionOptions()));
- ASSERT_OK(
- storage.insertDocuments(txn, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
+ ASSERT_OK(storage.createCollection(opCtx, nss, CollectionOptions()));
+ ASSERT_OK(storage.insertDocuments(
+ opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)}));
ASSERT_EQUALS(ErrorCodes::InvalidOptions,
storage
- .deleteDocuments(txn,
+ .deleteDocuments(opCtx,
nss,
boost::none,
StorageInterface::ScanDirection::kForward,
diff --git a/src/mongo/db/repl/storage_interface_mock.cpp b/src/mongo/db/repl/storage_interface_mock.cpp
index ec870c1a0cc..4b534c05d6a 100644
--- a/src/mongo/db/repl/storage_interface_mock.cpp
+++ b/src/mongo/db/repl/storage_interface_mock.cpp
@@ -40,53 +40,53 @@ namespace mongo {
namespace repl {
void StorageInterfaceMock::startup() {}
void StorageInterfaceMock::shutdown() {}
-bool StorageInterfaceMock::getInitialSyncFlag(OperationContext* txn) const {
+bool StorageInterfaceMock::getInitialSyncFlag(OperationContext* opCtx) const {
stdx::lock_guard<stdx::mutex> lock(_initialSyncFlagMutex);
return _initialSyncFlag;
}
-void StorageInterfaceMock::setInitialSyncFlag(OperationContext* txn) {
+void StorageInterfaceMock::setInitialSyncFlag(OperationContext* opCtx) {
stdx::lock_guard<stdx::mutex> lock(_initialSyncFlagMutex);
_initialSyncFlag = true;
}
-void StorageInterfaceMock::clearInitialSyncFlag(OperationContext* txn) {
+void StorageInterfaceMock::clearInitialSyncFlag(OperationContext* opCtx) {
stdx::lock_guard<stdx::mutex> lock(_initialSyncFlagMutex);
_initialSyncFlag = false;
}
-OpTime StorageInterfaceMock::getMinValid(OperationContext* txn) const {
+OpTime StorageInterfaceMock::getMinValid(OperationContext* opCtx) const {
stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
return _minValid;
}
-void StorageInterfaceMock::setMinValid(OperationContext* txn, const OpTime& minValid) {
+void StorageInterfaceMock::setMinValid(OperationContext* opCtx, const OpTime& minValid) {
stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
_minValid = minValid;
}
-void StorageInterfaceMock::setMinValidToAtLeast(OperationContext* txn, const OpTime& minValid) {
+void StorageInterfaceMock::setMinValidToAtLeast(OperationContext* opCtx, const OpTime& minValid) {
stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
_minValid = std::max(_minValid, minValid);
}
-void StorageInterfaceMock::setOplogDeleteFromPoint(OperationContext* txn,
+void StorageInterfaceMock::setOplogDeleteFromPoint(OperationContext* opCtx,
const Timestamp& timestamp) {
stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
_oplogDeleteFromPoint = timestamp;
}
-Timestamp StorageInterfaceMock::getOplogDeleteFromPoint(OperationContext* txn) {
+Timestamp StorageInterfaceMock::getOplogDeleteFromPoint(OperationContext* opCtx) {
stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
return _oplogDeleteFromPoint;
}
-void StorageInterfaceMock::setAppliedThrough(OperationContext* txn, const OpTime& optime) {
+void StorageInterfaceMock::setAppliedThrough(OperationContext* opCtx, const OpTime& optime) {
stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
_appliedThrough = optime;
}
-OpTime StorageInterfaceMock::getAppliedThrough(OperationContext* txn) {
+OpTime StorageInterfaceMock::getAppliedThrough(OperationContext* opCtx) {
stdx::lock_guard<stdx::mutex> lock(_minValidBoundariesMutex);
return _appliedThrough;
}
diff --git a/src/mongo/db/repl/storage_interface_mock.h b/src/mongo/db/repl/storage_interface_mock.h
index 911244c2670..9f63764473b 100644
--- a/src/mongo/db/repl/storage_interface_mock.h
+++ b/src/mongo/db/repl/storage_interface_mock.h
@@ -92,17 +92,18 @@ public:
const BSONObj idIndexSpec,
const std::vector<BSONObj>& secondaryIndexSpecs)>;
using InsertDocumentFn = stdx::function<Status(
- OperationContext* txn, const NamespaceString& nss, const BSONObj& doc)>;
+ OperationContext* opCtx, const NamespaceString& nss, const BSONObj& doc)>;
using InsertDocumentsFn = stdx::function<Status(
- OperationContext* txn, const NamespaceString& nss, const std::vector<BSONObj>& docs)>;
- using DropUserDatabasesFn = stdx::function<Status(OperationContext* txn)>;
- using CreateOplogFn = stdx::function<Status(OperationContext* txn, const NamespaceString& nss)>;
+ OperationContext* opCtx, const NamespaceString& nss, const std::vector<BSONObj>& docs)>;
+ using DropUserDatabasesFn = stdx::function<Status(OperationContext* opCtx)>;
+ using CreateOplogFn =
+ stdx::function<Status(OperationContext* opCtx, const NamespaceString& nss)>;
using CreateCollectionFn = stdx::function<Status(
- OperationContext* txn, const NamespaceString& nss, const CollectionOptions& options)>;
+ OperationContext* opCtx, const NamespaceString& nss, const CollectionOptions& options)>;
using DropCollectionFn =
- stdx::function<Status(OperationContext* txn, const NamespaceString& nss)>;
+ stdx::function<Status(OperationContext* opCtx, const NamespaceString& nss)>;
using FindDocumentsFn =
- stdx::function<StatusWith<std::vector<BSONObj>>(OperationContext* txn,
+ stdx::function<StatusWith<std::vector<BSONObj>>(OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
@@ -110,31 +111,31 @@ public:
BoundInclusion boundInclusion,
std::size_t limit)>;
using DeleteDocumentsFn =
- stdx::function<StatusWith<std::vector<BSONObj>>(OperationContext* txn,
+ stdx::function<StatusWith<std::vector<BSONObj>>(OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
const BSONObj& startKey,
BoundInclusion boundInclusion,
std::size_t limit)>;
- using IsAdminDbValidFn = stdx::function<Status(OperationContext* txn)>;
+ using IsAdminDbValidFn = stdx::function<Status(OperationContext* opCtx)>;
StorageInterfaceMock() = default;
void startup() override;
void shutdown() override;
- bool getInitialSyncFlag(OperationContext* txn) const override;
- void setInitialSyncFlag(OperationContext* txn) override;
- void clearInitialSyncFlag(OperationContext* txn) override;
+ bool getInitialSyncFlag(OperationContext* opCtx) const override;
+ void setInitialSyncFlag(OperationContext* opCtx) override;
+ void clearInitialSyncFlag(OperationContext* opCtx) override;
- OpTime getMinValid(OperationContext* txn) const override;
- void setMinValid(OperationContext* txn, const OpTime& minValid) override;
- void setMinValidToAtLeast(OperationContext* txn, const OpTime& minValid) override;
- void setOplogDeleteFromPoint(OperationContext* txn, const Timestamp& timestamp) override;
- Timestamp getOplogDeleteFromPoint(OperationContext* txn) override;
- void setAppliedThrough(OperationContext* txn, const OpTime& optime) override;
- OpTime getAppliedThrough(OperationContext* txn) override;
+ OpTime getMinValid(OperationContext* opCtx) const override;
+ void setMinValid(OperationContext* opCtx, const OpTime& minValid) override;
+ void setMinValidToAtLeast(OperationContext* opCtx, const OpTime& minValid) override;
+ void setOplogDeleteFromPoint(OperationContext* opCtx, const Timestamp& timestamp) override;
+ Timestamp getOplogDeleteFromPoint(OperationContext* opCtx) override;
+ void setAppliedThrough(OperationContext* opCtx, const OpTime& optime) override;
+ OpTime getAppliedThrough(OperationContext* opCtx) override;
StatusWith<std::unique_ptr<CollectionBulkLoader>> createCollectionForBulkLoading(
const NamespaceString& nss,
@@ -144,51 +145,53 @@ public:
return createCollectionForBulkFn(nss, options, idIndexSpec, secondaryIndexSpecs);
};
- Status insertDocument(OperationContext* txn,
+ Status insertDocument(OperationContext* opCtx,
const NamespaceString& nss,
const BSONObj& doc) override {
- return insertDocumentFn(txn, nss, doc);
+ return insertDocumentFn(opCtx, nss, doc);
};
- Status insertDocuments(OperationContext* txn,
+ Status insertDocuments(OperationContext* opCtx,
const NamespaceString& nss,
const std::vector<BSONObj>& docs) override {
- return insertDocumentsFn(txn, nss, docs);
+ return insertDocumentsFn(opCtx, nss, docs);
}
- Status dropReplicatedDatabases(OperationContext* txn) override {
- return dropUserDBsFn(txn);
+ Status dropReplicatedDatabases(OperationContext* opCtx) override {
+ return dropUserDBsFn(opCtx);
};
- Status createOplog(OperationContext* txn, const NamespaceString& nss) override {
- return createOplogFn(txn, nss);
+ Status createOplog(OperationContext* opCtx, const NamespaceString& nss) override {
+ return createOplogFn(opCtx, nss);
};
- StatusWith<size_t> getOplogMaxSize(OperationContext* txn, const NamespaceString& nss) override {
+ StatusWith<size_t> getOplogMaxSize(OperationContext* opCtx,
+ const NamespaceString& nss) override {
return 1024 * 1024 * 1024;
}
- Status createCollection(OperationContext* txn,
+ Status createCollection(OperationContext* opCtx,
const NamespaceString& nss,
const CollectionOptions& options) override {
- return createCollFn(txn, nss, options);
+ return createCollFn(opCtx, nss, options);
}
- Status dropCollection(OperationContext* txn, const NamespaceString& nss) override {
- return dropCollFn(txn, nss);
+ Status dropCollection(OperationContext* opCtx, const NamespaceString& nss) override {
+ return dropCollFn(opCtx, nss);
};
- StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* txn,
+ StatusWith<std::vector<BSONObj>> findDocuments(OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
const BSONObj& startKey,
BoundInclusion boundInclusion,
std::size_t limit) override {
- return findDocumentsFn(txn, nss, indexName, scanDirection, startKey, boundInclusion, limit);
+ return findDocumentsFn(
+ opCtx, nss, indexName, scanDirection, startKey, boundInclusion, limit);
}
- StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* txn,
+ StatusWith<std::vector<BSONObj>> deleteDocuments(OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
@@ -196,11 +199,11 @@ public:
BoundInclusion boundInclusion,
std::size_t limit) override {
return deleteDocumentsFn(
- txn, nss, indexName, scanDirection, startKey, boundInclusion, limit);
+ opCtx, nss, indexName, scanDirection, startKey, boundInclusion, limit);
}
- Status isAdminDbValid(OperationContext* txn) override {
- return isAdminDbValidFn(txn);
+ Status isAdminDbValid(OperationContext* opCtx) override {
+ return isAdminDbValidFn(opCtx);
};
@@ -214,27 +217,27 @@ public:
return Status{ErrorCodes::IllegalOperation, "CreateCollectionForBulkFn not implemented."};
};
InsertDocumentFn insertDocumentFn =
- [](OperationContext* txn, const NamespaceString& nss, const BSONObj& doc) {
+ [](OperationContext* opCtx, const NamespaceString& nss, const BSONObj& doc) {
return Status{ErrorCodes::IllegalOperation, "InsertDocumentFn not implemented."};
};
InsertDocumentsFn insertDocumentsFn =
- [](OperationContext* txn, const NamespaceString& nss, const std::vector<BSONObj>& docs) {
+ [](OperationContext* opCtx, const NamespaceString& nss, const std::vector<BSONObj>& docs) {
return Status{ErrorCodes::IllegalOperation, "InsertDocumentsFn not implemented."};
};
- DropUserDatabasesFn dropUserDBsFn = [](OperationContext* txn) {
+ DropUserDatabasesFn dropUserDBsFn = [](OperationContext* opCtx) {
return Status{ErrorCodes::IllegalOperation, "DropUserDatabasesFn not implemented."};
};
- CreateOplogFn createOplogFn = [](OperationContext* txn, const NamespaceString& nss) {
+ CreateOplogFn createOplogFn = [](OperationContext* opCtx, const NamespaceString& nss) {
return Status{ErrorCodes::IllegalOperation, "CreateOplogFn not implemented."};
};
CreateCollectionFn createCollFn =
- [](OperationContext* txn, const NamespaceString& nss, const CollectionOptions& options) {
+ [](OperationContext* opCtx, const NamespaceString& nss, const CollectionOptions& options) {
return Status{ErrorCodes::IllegalOperation, "CreateCollectionFn not implemented."};
};
- DropCollectionFn dropCollFn = [](OperationContext* txn, const NamespaceString& nss) {
+ DropCollectionFn dropCollFn = [](OperationContext* opCtx, const NamespaceString& nss) {
return Status{ErrorCodes::IllegalOperation, "DropCollectionFn not implemented."};
};
- FindDocumentsFn findDocumentsFn = [](OperationContext* txn,
+ FindDocumentsFn findDocumentsFn = [](OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
@@ -243,7 +246,7 @@ public:
std::size_t limit) {
return Status{ErrorCodes::IllegalOperation, "FindOneFn not implemented."};
};
- DeleteDocumentsFn deleteDocumentsFn = [](OperationContext* txn,
+ DeleteDocumentsFn deleteDocumentsFn = [](OperationContext* opCtx,
const NamespaceString& nss,
boost::optional<StringData> indexName,
ScanDirection scanDirection,
diff --git a/src/mongo/db/repl/sync_source_feedback.cpp b/src/mongo/db/repl/sync_source_feedback.cpp
index 2633e058e44..b8c41b1e1fd 100644
--- a/src/mongo/db/repl/sync_source_feedback.cpp
+++ b/src/mongo/db/repl/sync_source_feedback.cpp
@@ -52,9 +52,9 @@ namespace {
* Calculates the keep alive interval based on the current configuration in the replication
* coordinator.
*/
-Milliseconds calculateKeepAliveInterval(OperationContext* txn, stdx::mutex& mtx) {
+Milliseconds calculateKeepAliveInterval(OperationContext* opCtx, stdx::mutex& mtx) {
stdx::lock_guard<stdx::mutex> lock(mtx);
- auto replCoord = repl::ReplicationCoordinator::get(txn);
+ auto replCoord = repl::ReplicationCoordinator::get(opCtx);
auto rsConfig = replCoord->getConfig();
auto keepAliveInterval = rsConfig.getElectionTimeoutPeriod() / 2;
return keepAliveInterval;
@@ -64,9 +64,9 @@ Milliseconds calculateKeepAliveInterval(OperationContext* txn, stdx::mutex& mtx)
* Returns function to prepare update command
*/
Reporter::PrepareReplSetUpdatePositionCommandFn makePrepareReplSetUpdatePositionCommandFn(
- OperationContext* txn, const HostAndPort& syncTarget, BackgroundSync* bgsync) {
- return [syncTarget, txn, bgsync](ReplicationCoordinator::ReplSetUpdatePositionCommandStyle
- commandStyle) -> StatusWith<BSONObj> {
+ OperationContext* opCtx, const HostAndPort& syncTarget, BackgroundSync* bgsync) {
+ return [syncTarget, opCtx, bgsync](ReplicationCoordinator::ReplSetUpdatePositionCommandStyle
+ commandStyle) -> StatusWith<BSONObj> {
auto currentSyncTarget = bgsync->getSyncTarget();
if (currentSyncTarget != syncTarget) {
if (currentSyncTarget.empty()) {
@@ -82,7 +82,7 @@ Reporter::PrepareReplSetUpdatePositionCommandFn makePrepareReplSetUpdatePosition
}
}
- auto replCoord = repl::ReplicationCoordinator::get(txn);
+ auto replCoord = repl::ReplicationCoordinator::get(opCtx);
if (replCoord->getMemberState().primary()) {
// Primary has no one to send updates to.
return Status(ErrorCodes::InvalidSyncSource,
@@ -149,10 +149,10 @@ void SyncSourceFeedback::run(executor::TaskExecutor* executor, BackgroundSync* b
Milliseconds keepAliveInterval(0);
while (true) { // breaks once _shutdownSignaled is true
- auto txn = cc().makeOperationContext();
+ auto opCtx = cc().makeOperationContext();
if (keepAliveInterval == Milliseconds(0)) {
- keepAliveInterval = calculateKeepAliveInterval(txn.get(), _mtx);
+ keepAliveInterval = calculateKeepAliveInterval(opCtx.get(), _mtx);
}
{
@@ -163,7 +163,7 @@ void SyncSourceFeedback::run(executor::TaskExecutor* executor, BackgroundSync* b
while (!_positionChanged && !_shutdownSignaled) {
if (_cond.wait_for(lock, keepAliveInterval.toSystemDuration()) ==
stdx::cv_status::timeout) {
- MemberState state = ReplicationCoordinator::get(txn.get())->getMemberState();
+ MemberState state = ReplicationCoordinator::get(opCtx.get())->getMemberState();
if (!(state.primary() || state.startup())) {
break;
}
@@ -179,7 +179,7 @@ void SyncSourceFeedback::run(executor::TaskExecutor* executor, BackgroundSync* b
{
stdx::lock_guard<stdx::mutex> lock(_mtx);
- MemberState state = ReplicationCoordinator::get(txn.get())->getMemberState();
+ MemberState state = ReplicationCoordinator::get(opCtx.get())->getMemberState();
if (state.primary() || state.startup()) {
continue;
}
@@ -201,17 +201,18 @@ void SyncSourceFeedback::run(executor::TaskExecutor* executor, BackgroundSync* b
// Update keepalive value from config.
auto oldKeepAliveInterval = keepAliveInterval;
- keepAliveInterval = calculateKeepAliveInterval(txn.get(), _mtx);
+ keepAliveInterval = calculateKeepAliveInterval(opCtx.get(), _mtx);
if (oldKeepAliveInterval != keepAliveInterval) {
LOG(1) << "new syncSourceFeedback keep alive duration = " << keepAliveInterval
<< " (previously " << oldKeepAliveInterval << ")";
}
}
- Reporter reporter(executor,
- makePrepareReplSetUpdatePositionCommandFn(txn.get(), syncTarget, bgsync),
- syncTarget,
- keepAliveInterval);
+ Reporter reporter(
+ executor,
+ makePrepareReplSetUpdatePositionCommandFn(opCtx.get(), syncTarget, bgsync),
+ syncTarget,
+ keepAliveInterval);
{
stdx::lock_guard<stdx::mutex> lock(_mtx);
if (_shutdownSignaled) {
diff --git a/src/mongo/db/repl/sync_tail.cpp b/src/mongo/db/repl/sync_tail.cpp
index 277df2f9a9d..8738b47d027 100644
--- a/src/mongo/db/repl/sync_tail.cpp
+++ b/src/mongo/db/repl/sync_tail.cpp
@@ -255,8 +255,8 @@ void ApplyBatchFinalizerForJournal::_run() {
_latestOpTime = OpTime();
}
- auto txn = cc().makeOperationContext();
- txn->recoveryUnit()->waitUntilDurable();
+ auto opCtx = cc().makeOperationContext();
+ opCtx->recoveryUnit()->waitUntilDurable();
_recordDurable(latestOpTime);
}
}
@@ -276,19 +276,19 @@ std::unique_ptr<OldThreadPool> SyncTail::makeWriterPool() {
return stdx::make_unique<OldThreadPool>(replWriterThreadCount, "repl writer worker ");
}
-bool SyncTail::peek(OperationContext* txn, BSONObj* op) {
- return _networkQueue->peek(txn, op);
+bool SyncTail::peek(OperationContext* opCtx, BSONObj* op) {
+ return _networkQueue->peek(opCtx, op);
}
// static
-Status SyncTail::syncApply(OperationContext* txn,
+Status SyncTail::syncApply(OperationContext* opCtx,
const BSONObj& op,
bool inSteadyStateReplication,
ApplyOperationInLockFn applyOperationInLock,
ApplyCommandInLockFn applyCommandInLock,
IncrementOpsAppliedStatsFn incrementOpsAppliedStats) {
// Count each log op application as a separate operation, for reporting purposes
- CurOp individualOp(txn);
+ CurOp individualOp(opCtx);
const char* ns = op.getStringField("ns");
verify(ns);
@@ -312,24 +312,24 @@ Status SyncTail::syncApply(OperationContext* txn,
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
// a command may need a global write lock. so we will conservatively go
// ahead and grab one here. suboptimal. :-(
- Lock::GlobalWrite globalWriteLock(txn->lockState());
+ Lock::GlobalWrite globalWriteLock(opCtx->lockState());
// special case apply for commands to avoid implicit database creation
- Status status = applyCommandInLock(txn, op, inSteadyStateReplication);
+ Status status = applyCommandInLock(opCtx, op, inSteadyStateReplication);
incrementOpsAppliedStats();
return status;
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "syncApply_command", ns);
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "syncApply_command", ns);
}
auto applyOp = [&](Database* db) {
// For non-initial-sync, we convert updates to upserts
// to suppress errors when replaying oplog entries.
- txn->setReplicatedWrites(false);
- DisableDocumentValidation validationDisabler(txn);
+ opCtx->setReplicatedWrites(false);
+ DisableDocumentValidation validationDisabler(opCtx);
Status status =
- applyOperationInLock(txn, db, op, inSteadyStateReplication, incrementOpsAppliedStats);
+ applyOperationInLock(opCtx, db, op, inSteadyStateReplication, incrementOpsAppliedStats);
if (!status.isOK() && status.code() == ErrorCodes::WriteConflict) {
throw WriteConflictException();
}
@@ -339,11 +339,11 @@ Status SyncTail::syncApply(OperationContext* txn,
if (isNoOp || (opType[0] == 'i' && nsToCollectionSubstring(ns) == "system.indexes")) {
auto opStr = isNoOp ? "syncApply_noop" : "syncApply_indexBuild";
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- Lock::DBLock dbLock(txn->lockState(), nsToDatabaseSubstring(ns), MODE_X);
- OldClientContext ctx(txn, ns);
+ Lock::DBLock dbLock(opCtx->lockState(), nsToDatabaseSubstring(ns), MODE_X);
+ OldClientContext ctx(opCtx, ns);
return applyOp(ctx.db());
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, opStr, ns);
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, opStr, ns);
}
if (isCrudOpType(opType)) {
@@ -361,29 +361,29 @@ Status SyncTail::syncApply(OperationContext* txn,
// drop the DB lock before acquiring
// the upgraded one.
dbLock.reset();
- dbLock.reset(new Lock::DBLock(txn->lockState(), dbName, mode));
- collectionLock.reset(new Lock::CollectionLock(txn->lockState(), ns, mode));
+ dbLock.reset(new Lock::DBLock(opCtx->lockState(), dbName, mode));
+ collectionLock.reset(new Lock::CollectionLock(opCtx->lockState(), ns, mode));
};
resetLocks(MODE_IX);
- if (!dbHolder().get(txn, dbName)) {
+ if (!dbHolder().get(opCtx, dbName)) {
// Need to create database, so reset lock to stronger mode.
resetLocks(MODE_X);
- ctx.reset(new OldClientContext(txn, ns));
+ ctx.reset(new OldClientContext(opCtx, ns));
} else {
- ctx.reset(new OldClientContext(txn, ns));
+ ctx.reset(new OldClientContext(opCtx, ns));
if (!ctx->db()->getCollection(ns)) {
// Need to implicitly create collection. This occurs for 'u' opTypes,
// but not for 'i' nor 'd'.
ctx.reset();
resetLocks(MODE_X);
- ctx.reset(new OldClientContext(txn, ns));
+ ctx.reset(new OldClientContext(opCtx, ns));
}
}
return applyOp(ctx->db());
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "syncApply_CRUD", ns);
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "syncApply_CRUD", ns);
}
// unknown opType
@@ -393,10 +393,10 @@ Status SyncTail::syncApply(OperationContext* txn,
return Status(ErrorCodes::BadValue, ss);
}
-Status SyncTail::syncApply(OperationContext* txn,
+Status SyncTail::syncApply(OperationContext* opCtx,
const BSONObj& op,
bool inSteadyStateReplication) {
- return SyncTail::syncApply(txn,
+ return SyncTail::syncApply(opCtx,
op,
inSteadyStateReplication,
applyOperation_inlock,
@@ -416,12 +416,12 @@ void prefetchOp(const BSONObj& op) {
try {
// one possible tweak here would be to stay in the read lock for this database
// for multiple prefetches if they are for the same database.
- const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
- OperationContext& txn = *txnPtr;
- AutoGetCollectionForRead ctx(&txn, NamespaceString(ns));
+ const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+ OperationContext& opCtx = *opCtxPtr;
+ AutoGetCollectionForRead ctx(&opCtx, NamespaceString(ns));
Database* db = ctx.getDb();
if (db) {
- prefetchPagesForReplicatedOp(&txn, db, op);
+ prefetchPagesForReplicatedOp(&opCtx, db, op);
}
} catch (const DBException& e) {
LOG(2) << "ignoring exception in prefetchOp(): " << redact(e) << endl;
@@ -468,7 +468,7 @@ void initializeWriterThread() {
// Schedules the writes to the oplog for 'ops' into threadPool. The caller must guarantee that 'ops'
// stays valid until all scheduled work in the thread pool completes.
-void scheduleWritesToOplog(OperationContext* txn,
+void scheduleWritesToOplog(OperationContext* opCtx,
OldThreadPool* threadPool,
const MultiApplier::Operations& ops) {
@@ -479,9 +479,9 @@ void scheduleWritesToOplog(OperationContext* txn,
return [&ops, begin, end] {
initializeWriterThread();
const auto txnHolder = cc().makeOperationContext();
- const auto txn = txnHolder.get();
- txn->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
- txn->setReplicatedWrites(false);
+ const auto opCtx = txnHolder.get();
+ opCtx->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
+ opCtx->setReplicatedWrites(false);
std::vector<BSONObj> docs;
docs.reserve(end - begin);
@@ -492,8 +492,8 @@ void scheduleWritesToOplog(OperationContext* txn,
}
fassertStatusOK(40141,
- StorageInterface::get(txn)->insertDocuments(
- txn, NamespaceString(rsOplogName), docs));
+ StorageInterface::get(opCtx)->insertDocuments(
+ opCtx, NamespaceString(rsOplogName), docs));
};
};
@@ -509,7 +509,7 @@ void scheduleWritesToOplog(OperationContext* txn,
// there would be no way to take advantage of multiple threads if a storage engine doesn't
// support document locking.
if (!enoughToMultiThread ||
- !txn->getServiceContext()->getGlobalStorageEngine()->supportsDocLocking()) {
+ !opCtx->getServiceContext()->getGlobalStorageEngine()->supportsDocLocking()) {
threadPool->schedule(makeOplogWriterForRange(0, ops.size()));
return;
@@ -536,24 +536,24 @@ public:
const CollatorInterface* collator = nullptr;
};
- CollectionProperties getCollectionProperties(OperationContext* txn,
+ CollectionProperties getCollectionProperties(OperationContext* opCtx,
const StringMapTraits::HashedKey& ns) {
auto it = _cache.find(ns);
if (it != _cache.end()) {
return it->second;
}
- auto collProperties = getCollectionPropertiesImpl(txn, ns.key());
+ auto collProperties = getCollectionPropertiesImpl(opCtx, ns.key());
_cache[ns] = collProperties;
return collProperties;
}
private:
- CollectionProperties getCollectionPropertiesImpl(OperationContext* txn, StringData ns) {
+ CollectionProperties getCollectionPropertiesImpl(OperationContext* opCtx, StringData ns) {
CollectionProperties collProperties;
- Lock::DBLock dbLock(txn->lockState(), nsToDatabaseSubstring(ns), MODE_IS);
- auto db = dbHolder().get(txn, ns);
+ Lock::DBLock dbLock(opCtx->lockState(), nsToDatabaseSubstring(ns), MODE_IS);
+ auto db = dbHolder().get(opCtx, ns);
if (!db) {
return collProperties;
}
@@ -573,7 +573,7 @@ private:
// This only modifies the isForCappedCollection field on each op. It does not alter the ops vector
// in any other way.
-void fillWriterVectors(OperationContext* txn,
+void fillWriterVectors(OperationContext* opCtx,
MultiApplier::Operations* ops,
std::vector<MultiApplier::OperationPtrs>* writerVectors) {
const bool supportsDocLocking =
@@ -587,7 +587,7 @@ void fillWriterVectors(OperationContext* txn,
uint32_t hash = hashedNs.hash();
if (op.isCrudOpType()) {
- auto collProperties = collPropertiesCache.getCollectionProperties(txn, hashedNs);
+ auto collProperties = collPropertiesCache.getCollectionProperties(opCtx, hashedNs);
// For doc locking engines, include the _id of the document in the hash so we get
// parallelism even if all writes are to a single collection.
@@ -620,7 +620,7 @@ void fillWriterVectors(OperationContext* txn,
// Applies a batch of oplog entries, by using a set of threads to apply the operations and then
// writes the oplog entries to the local oplog.
-OpTime SyncTail::multiApply(OperationContext* txn, MultiApplier::Operations ops) {
+OpTime SyncTail::multiApply(OperationContext* opCtx, MultiApplier::Operations ops) {
auto applyOperation = [this](MultiApplier::OperationPtrs* ops) -> Status {
_applyFunc(ops, this);
// This function is used by 3.2 initial sync and steady state data replication.
@@ -628,11 +628,11 @@ OpTime SyncTail::multiApply(OperationContext* txn, MultiApplier::Operations ops)
return Status::OK();
};
return fassertStatusOK(
- 34437, repl::multiApply(txn, _writerPool.get(), std::move(ops), applyOperation));
+ 34437, repl::multiApply(opCtx, _writerPool.get(), std::move(ops), applyOperation));
}
namespace {
-void tryToGoLiveAsASecondary(OperationContext* txn, ReplicationCoordinator* replCoord) {
+void tryToGoLiveAsASecondary(OperationContext* opCtx, ReplicationCoordinator* replCoord) {
if (replCoord->isInPrimaryOrSecondaryState()) {
return;
}
@@ -640,8 +640,8 @@ void tryToGoLiveAsASecondary(OperationContext* txn, ReplicationCoordinator* repl
// This needs to happen after the attempt so readers can be sure we've already tried.
ON_BLOCK_EXIT([] { attemptsToBecomeSecondary.increment(); });
- ScopedTransaction transaction(txn, MODE_S);
- Lock::GlobalRead readLock(txn->lockState());
+ ScopedTransaction transaction(opCtx, MODE_S);
+ Lock::GlobalRead readLock(opCtx->lockState());
if (replCoord->getMaintenanceMode()) {
LOG(1) << "Can't go live (tryToGoLiveAsASecondary) as maintenance mode is active.";
@@ -657,7 +657,7 @@ void tryToGoLiveAsASecondary(OperationContext* txn, ReplicationCoordinator* repl
}
// We can't go to SECONDARY until we reach minvalid.
- if (replCoord->getMyLastAppliedOpTime() < StorageInterface::get(txn)->getMinValid(txn)) {
+ if (replCoord->getMyLastAppliedOpTime() < StorageInterface::get(opCtx)->getMinValid(opCtx)) {
return;
}
@@ -697,13 +697,13 @@ public:
private:
void run() {
Client::initThread("ReplBatcher");
- const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
- OperationContext& txn = *txnPtr;
- const auto replCoord = ReplicationCoordinator::get(&txn);
- const auto fastClockSource = txn.getServiceContext()->getFastClockSource();
+ const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+ OperationContext& opCtx = *opCtxPtr;
+ const auto replCoord = ReplicationCoordinator::get(&opCtx);
+ const auto fastClockSource = opCtx.getServiceContext()->getFastClockSource();
const auto oplogMaxSize = fassertStatusOK(
40301,
- StorageInterface::get(&txn)->getOplogMaxSize(&txn, NamespaceString(rsOplogName)));
+ StorageInterface::get(&opCtx)->getOplogMaxSize(&opCtx, NamespaceString(rsOplogName)));
// Batches are limited to 10% of the oplog.
BatchLimits batchLimits;
@@ -720,7 +720,7 @@ private:
OpQueue ops;
// tryPopAndWaitForMore adds to ops and returns true when we need to end a batch early.
- while (!_syncTail->tryPopAndWaitForMore(&txn, &ops, batchLimits)) {
+ while (!_syncTail->tryPopAndWaitForMore(&opCtx, &ops, batchLimits)) {
}
if (ops.empty() && !ops.mustShutdown()) {
@@ -755,8 +755,8 @@ private:
void SyncTail::oplogApplication(ReplicationCoordinator* replCoord) {
OpQueueBatcher batcher(this);
- const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
- OperationContext& txn = *txnPtr;
+ const ServiceContext::UniqueOperationContext opCtxPtr = cc().makeOperationContext();
+ OperationContext& opCtx = *opCtxPtr;
std::unique_ptr<ApplyBatchFinalizer> finalizer{
getGlobalServiceContext()->getGlobalStorageEngine()->isDurable()
? new ApplyBatchFinalizerForJournal(replCoord)
@@ -774,7 +774,7 @@ void SyncTail::oplogApplication(ReplicationCoordinator* replCoord) {
sleepmillis(10);
}
- tryToGoLiveAsASecondary(&txn, replCoord);
+ tryToGoLiveAsASecondary(&opCtx, replCoord);
long long termWhenBufferIsEmpty = replCoord->getTerm();
// Blocks up to a second waiting for a batch to be ready to apply. If one doesn't become
@@ -788,7 +788,7 @@ void SyncTail::oplogApplication(ReplicationCoordinator* replCoord) {
continue;
}
// Signal drain complete if we're in Draining state and the buffer is empty.
- replCoord->signalDrainComplete(&txn, termWhenBufferIsEmpty);
+ replCoord->signalDrainComplete(&opCtx, termWhenBufferIsEmpty);
continue; // Try again.
}
@@ -813,13 +813,13 @@ void SyncTail::oplogApplication(ReplicationCoordinator* replCoord) {
stdx::lock_guard<SimpleMutex> fsynclk(filesLockedFsync);
// Do the work.
- multiApply(&txn, ops.releaseBatch());
+ multiApply(&opCtx, ops.releaseBatch());
// Update various things that care about our last applied optime. Tests rely on 2 happening
// before 3 even though it isn't strictly necessary. The order of 1 doesn't matter.
- setNewTimestamp(txn.getServiceContext(), lastOpTimeInBatch.getTimestamp()); // 1
- StorageInterface::get(&txn)->setAppliedThrough(&txn, lastOpTimeInBatch); // 2
- finalizer->record(lastOpTimeInBatch); // 3
+ setNewTimestamp(opCtx.getServiceContext(), lastOpTimeInBatch.getTimestamp()); // 1
+ StorageInterface::get(&opCtx)->setAppliedThrough(&opCtx, lastOpTimeInBatch); // 2
+ finalizer->record(lastOpTimeInBatch); // 3
}
}
@@ -830,13 +830,13 @@ void SyncTail::oplogApplication(ReplicationCoordinator* replCoord) {
// This function also blocks 1 second waiting for new ops to appear in the bgsync
// queue. We don't block forever so that we can periodically check for things like shutdown or
// reconfigs.
-bool SyncTail::tryPopAndWaitForMore(OperationContext* txn,
+bool SyncTail::tryPopAndWaitForMore(OperationContext* opCtx,
SyncTail::OpQueue* ops,
const BatchLimits& limits) {
{
BSONObj op;
// Check to see if there are ops waiting in the bgsync queue
- bool peek_success = peek(txn, &op);
+ bool peek_success = peek(opCtx, &op);
if (!peek_success) {
// If we don't have anything in the queue, wait a bit for something to appear.
if (ops->empty()) {
@@ -908,7 +908,7 @@ bool SyncTail::tryPopAndWaitForMore(OperationContext* txn,
(!entry.ns.empty() && nsToCollectionSubstring(entry.ns) == "system.indexes")) {
if (ops->getCount() == 1) {
// apply commands one-at-a-time
- _networkQueue->consume(txn);
+ _networkQueue->consume(opCtx);
} else {
// This op must be processed alone, but we already had ops in the queue so we can't
// include it in this batch. Since we didn't call consume(), we'll see this again next
@@ -921,7 +921,7 @@ bool SyncTail::tryPopAndWaitForMore(OperationContext* txn,
}
// We are going to apply this Op.
- _networkQueue->consume(txn);
+ _networkQueue->consume(opCtx);
// Go back for more ops, unless we've hit the limit.
return ops->getCount() >= limits.ops;
@@ -935,7 +935,7 @@ OldThreadPool* SyncTail::getWriterPool() {
return _writerPool.get();
}
-BSONObj SyncTail::getMissingDoc(OperationContext* txn, Database* db, const BSONObj& o) {
+BSONObj SyncTail::getMissingDoc(OperationContext* opCtx, Database* db, const BSONObj& o) {
OplogReader missingObjReader; // why are we using OplogReader to run a non-oplog query?
const char* ns = o.getStringField("ns");
@@ -1004,18 +1004,18 @@ BSONObj SyncTail::getMissingDoc(OperationContext* txn, Database* db, const BSONO
str::stream() << "Can no longer connect to initial sync source: " << _hostname);
}
-bool SyncTail::shouldRetry(OperationContext* txn, const BSONObj& o) {
+bool SyncTail::shouldRetry(OperationContext* opCtx, const BSONObj& o) {
const NamespaceString nss(o.getStringField("ns"));
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
// Take an X lock on the database in order to preclude other modifications.
// Also, the database might not exist yet, so create it.
- AutoGetOrCreateDb autoDb(txn, nss.db(), MODE_X);
+ AutoGetOrCreateDb autoDb(opCtx, nss.db(), MODE_X);
Database* const db = autoDb.getDb();
// we don't have the object yet, which is possible on initial sync. get it.
log() << "adding missing object" << endl; // rare enough we can log
- BSONObj missingObj = getMissingDoc(txn, db, o);
+ BSONObj missingObj = getMissingDoc(opCtx, db, o);
if (missingObj.isEmpty()) {
log() << "missing object not found on source."
@@ -1025,13 +1025,13 @@ bool SyncTail::shouldRetry(OperationContext* txn, const BSONObj& o) {
return false;
} else {
- WriteUnitOfWork wunit(txn);
+ WriteUnitOfWork wunit(opCtx);
- Collection* const coll = db->getOrCreateCollection(txn, nss.toString());
+ Collection* const coll = db->getOrCreateCollection(opCtx, nss.toString());
invariant(coll);
OpDebug* const nullOpDebug = nullptr;
- Status status = coll->insertDocument(txn, missingObj, nullOpDebug, true);
+ Status status = coll->insertDocument(opCtx, missingObj, nullOpDebug, true);
uassert(15917,
str::stream() << "failed to insert missing doc: " << status.toString(),
status.isOK());
@@ -1042,7 +1042,7 @@ bool SyncTail::shouldRetry(OperationContext* txn, const BSONObj& o) {
return true;
}
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "InsertRetry", nss.ns());
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "InsertRetry", nss.ns());
// fixes compile errors on GCC - see SERVER-18219 for details
MONGO_UNREACHABLE;
@@ -1051,22 +1051,22 @@ bool SyncTail::shouldRetry(OperationContext* txn, const BSONObj& o) {
// This free function is used by the writer threads to apply each op
void multiSyncApply(MultiApplier::OperationPtrs* ops, SyncTail*) {
initializeWriterThread();
- auto txn = cc().makeOperationContext();
- auto syncApply = [](OperationContext* txn, const BSONObj& op, bool inSteadyStateReplication) {
- return SyncTail::syncApply(txn, op, inSteadyStateReplication);
+ auto opCtx = cc().makeOperationContext();
+ auto syncApply = [](OperationContext* opCtx, const BSONObj& op, bool inSteadyStateReplication) {
+ return SyncTail::syncApply(opCtx, op, inSteadyStateReplication);
};
- fassertNoTrace(16359, multiSyncApply_noAbort(txn.get(), ops, syncApply));
+ fassertNoTrace(16359, multiSyncApply_noAbort(opCtx.get(), ops, syncApply));
}
-Status multiSyncApply_noAbort(OperationContext* txn,
+Status multiSyncApply_noAbort(OperationContext* opCtx,
MultiApplier::OperationPtrs* oplogEntryPointers,
SyncApplyFn syncApply) {
- txn->setReplicatedWrites(false);
- DisableDocumentValidation validationDisabler(txn);
+ opCtx->setReplicatedWrites(false);
+ DisableDocumentValidation validationDisabler(opCtx);
// allow us to get through the magic barrier
- txn->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
+ opCtx->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
if (oplogEntryPointers->size() > 1) {
std::stable_sort(oplogEntryPointers->begin(),
@@ -1125,7 +1125,7 @@ Status multiSyncApply_noAbort(OperationContext* txn,
try {
// Apply the group of inserts.
uassertStatusOK(
- syncApply(txn, groupedInsertBuilder.done(), inSteadyStateReplication));
+ syncApply(opCtx, groupedInsertBuilder.done(), inSteadyStateReplication));
// It succeeded, advance the oplogEntriesIterator to the end of the
// group of inserts.
oplogEntriesIterator = endOfGroupableOpsIterator - 1;
@@ -1145,7 +1145,7 @@ Status multiSyncApply_noAbort(OperationContext* txn,
try {
// Apply an individual (non-grouped) op.
- const Status status = syncApply(txn, entry->raw, inSteadyStateReplication);
+ const Status status = syncApply(opCtx, entry->raw, inSteadyStateReplication);
if (!status.isOK()) {
severe() << "Error applying operation (" << redact(entry->raw)
@@ -1165,28 +1165,28 @@ Status multiSyncApply_noAbort(OperationContext* txn,
// This free function is used by the initial sync writer threads to apply each op
void multiInitialSyncApply_abortOnFailure(MultiApplier::OperationPtrs* ops, SyncTail* st) {
initializeWriterThread();
- auto txn = cc().makeOperationContext();
+ auto opCtx = cc().makeOperationContext();
AtomicUInt32 fetchCount(0);
- fassertNoTrace(15915, multiInitialSyncApply_noAbort(txn.get(), ops, st, &fetchCount));
+ fassertNoTrace(15915, multiInitialSyncApply_noAbort(opCtx.get(), ops, st, &fetchCount));
}
Status multiInitialSyncApply(MultiApplier::OperationPtrs* ops,
SyncTail* st,
AtomicUInt32* fetchCount) {
initializeWriterThread();
- auto txn = cc().makeOperationContext();
- return multiInitialSyncApply_noAbort(txn.get(), ops, st, fetchCount);
+ auto opCtx = cc().makeOperationContext();
+ return multiInitialSyncApply_noAbort(opCtx.get(), ops, st, fetchCount);
}
-Status multiInitialSyncApply_noAbort(OperationContext* txn,
+Status multiInitialSyncApply_noAbort(OperationContext* opCtx,
MultiApplier::OperationPtrs* ops,
SyncTail* st,
AtomicUInt32* fetchCount) {
- txn->setReplicatedWrites(false);
- DisableDocumentValidation validationDisabler(txn);
+ opCtx->setReplicatedWrites(false);
+ DisableDocumentValidation validationDisabler(opCtx);
// allow us to get through the magic barrier
- txn->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
+ opCtx->lockState()->setShouldConflictWithSecondaryBatchApplication(false);
// This function is only called in initial sync, as its name suggests.
const bool inSteadyStateReplication = false;
@@ -1194,7 +1194,7 @@ Status multiInitialSyncApply_noAbort(OperationContext* txn,
for (auto it = ops->begin(); it != ops->end(); ++it) {
auto& entry = **it;
try {
- const Status s = SyncTail::syncApply(txn, entry.raw, inSteadyStateReplication);
+ const Status s = SyncTail::syncApply(opCtx, entry.raw, inSteadyStateReplication);
if (!s.isOK()) {
// Don't retry on commands.
if (entry.isCommand()) {
@@ -1205,8 +1205,9 @@ Status multiInitialSyncApply_noAbort(OperationContext* txn,
// We might need to fetch the missing docs from the sync source.
fetchCount->fetchAndAdd(1);
- if (st->shouldRetry(txn, entry.raw)) {
- const Status s2 = SyncTail::syncApply(txn, entry.raw, inSteadyStateReplication);
+ if (st->shouldRetry(opCtx, entry.raw)) {
+ const Status s2 =
+ SyncTail::syncApply(opCtx, entry.raw, inSteadyStateReplication);
if (!s2.isOK()) {
severe() << "Error applying operation (" << redact(entry.raw)
<< "): " << redact(s2);
@@ -1234,11 +1235,11 @@ Status multiInitialSyncApply_noAbort(OperationContext* txn,
return Status::OK();
}
-StatusWith<OpTime> multiApply(OperationContext* txn,
+StatusWith<OpTime> multiApply(OperationContext* opCtx,
OldThreadPool* workerPool,
MultiApplier::Operations ops,
MultiApplier::ApplyOperationFn applyOperation) {
- if (!txn) {
+ if (!opCtx) {
return {ErrorCodes::BadValue, "invalid operation context"};
}
@@ -1259,14 +1260,14 @@ StatusWith<OpTime> multiApply(OperationContext* txn,
prefetchOps(ops, workerPool);
}
- auto storage = StorageInterface::get(txn);
+ auto storage = StorageInterface::get(opCtx);
LOG(2) << "replication batch size is " << ops.size();
// Stop all readers until we're done. This also prevents doc-locking engines from deleting old
// entries from the oplog until we finish writing.
- Lock::ParallelBatchWriterMode pbwm(txn->lockState());
+ Lock::ParallelBatchWriterMode pbwm(opCtx->lockState());
- auto replCoord = ReplicationCoordinator::get(txn);
+ auto replCoord = ReplicationCoordinator::get(opCtx);
if (replCoord->getApplierState() == ReplicationCoordinator::ApplierState::Stopped) {
severe() << "attempting to replicate ops while primary";
return {ErrorCodes::CannotApplyOplogWhilePrimary,
@@ -1280,14 +1281,14 @@ StatusWith<OpTime> multiApply(OperationContext* txn,
std::vector<MultiApplier::OperationPtrs> writerVectors(workerPool->getNumThreads());
ON_BLOCK_EXIT([&] { workerPool->join(); });
- storage->setOplogDeleteFromPoint(txn, ops.front().ts.timestamp());
- scheduleWritesToOplog(txn, workerPool, ops);
- fillWriterVectors(txn, &ops, &writerVectors);
+ storage->setOplogDeleteFromPoint(opCtx, ops.front().ts.timestamp());
+ scheduleWritesToOplog(opCtx, workerPool, ops);
+ fillWriterVectors(opCtx, &ops, &writerVectors);
workerPool->join();
- storage->setOplogDeleteFromPoint(txn, Timestamp());
- storage->setMinValidToAtLeast(txn, ops.back().getOpTime());
+ storage->setOplogDeleteFromPoint(opCtx, Timestamp());
+ storage->setMinValidToAtLeast(opCtx, ops.back().getOpTime());
applyOps(writerVectors, workerPool, applyOperation, &statusVector);
}
diff --git a/src/mongo/db/repl/sync_tail.h b/src/mongo/db/repl/sync_tail.h
index 98485782868..1f4aa0e12c4 100644
--- a/src/mongo/db/repl/sync_tail.h
+++ b/src/mongo/db/repl/sync_tail.h
@@ -70,7 +70,7 @@ public:
* 'opCounter' is used to update server status metrics.
* Returns failure status if the op was an update that could not be applied.
*/
- using ApplyOperationInLockFn = stdx::function<Status(OperationContext* txn,
+ using ApplyOperationInLockFn = stdx::function<Status(OperationContext* opCtx,
Database* db,
const BSONObj& opObj,
bool inSteadyStateReplication,
@@ -100,17 +100,19 @@ public:
* Functions for applying operations/commands and increment server status counters may
* be overridden for testing.
*/
- static Status syncApply(OperationContext* txn,
+ static Status syncApply(OperationContext* opCtx,
const BSONObj& o,
bool inSteadyStateReplication,
ApplyOperationInLockFn applyOperationInLock,
ApplyCommandInLockFn applyCommandInLock,
IncrementOpsAppliedStatsFn incrementOpsAppliedStats);
- static Status syncApply(OperationContext* txn, const BSONObj& o, bool inSteadyStateReplication);
+ static Status syncApply(OperationContext* opCtx,
+ const BSONObj& o,
+ bool inSteadyStateReplication);
void oplogApplication(ReplicationCoordinator* replCoord);
- bool peek(OperationContext* txn, BSONObj* obj);
+ bool peek(OperationContext* opCtx, BSONObj* obj);
class OpQueue {
public:
@@ -195,17 +197,17 @@ public:
* If ops is empty on entry and nothing can be added yet, will wait up to a second before
* returning true.
*/
- bool tryPopAndWaitForMore(OperationContext* txn, OpQueue* ops, const BatchLimits& limits);
+ bool tryPopAndWaitForMore(OperationContext* opCtx, OpQueue* ops, const BatchLimits& limits);
/**
* Fetch a single document referenced in the operation from the sync source.
*/
- virtual BSONObj getMissingDoc(OperationContext* txn, Database* db, const BSONObj& o);
+ virtual BSONObj getMissingDoc(OperationContext* opCtx, Database* db, const BSONObj& o);
/**
* If applyOperation_inlock should be called again after an update fails.
*/
- virtual bool shouldRetry(OperationContext* txn, const BSONObj& o);
+ virtual bool shouldRetry(OperationContext* opCtx, const BSONObj& o);
void setHostname(const std::string& hostname);
/**
@@ -222,7 +224,7 @@ protected:
// Apply a batch of operations, using multiple threads.
// Returns the last OpTime applied during the apply batch, ops.end["ts"] basically.
- OpTime multiApply(OperationContext* txn, MultiApplier::Operations ops);
+ OpTime multiApply(OperationContext* opCtx, MultiApplier::Operations ops);
private:
class OpQueueBatcher;
@@ -247,7 +249,7 @@ private:
*
* Shared between here and MultiApplier.
*/
-StatusWith<OpTime> multiApply(OperationContext* txn,
+StatusWith<OpTime> multiApply(OperationContext* opCtx,
OldThreadPool* workerPool,
MultiApplier::Operations ops,
MultiApplier::ApplyOperationFn applyOperation);
@@ -271,9 +273,9 @@ Status multiInitialSyncApply(MultiApplier::OperationPtrs* ops,
* Accepts an external operation context and a function with the same argument list as
* SyncTail::syncApply.
*/
-using SyncApplyFn =
- stdx::function<Status(OperationContext* txn, const BSONObj& o, bool inSteadyStateReplication)>;
-Status multiSyncApply_noAbort(OperationContext* txn,
+using SyncApplyFn = stdx::function<Status(
+ OperationContext* opCtx, const BSONObj& o, bool inSteadyStateReplication)>;
+Status multiSyncApply_noAbort(OperationContext* opCtx,
MultiApplier::OperationPtrs* ops,
SyncApplyFn syncApply);
@@ -281,7 +283,7 @@ Status multiSyncApply_noAbort(OperationContext* txn,
* Testing-only version of multiInitialSyncApply that accepts an external operation context and
* returns an error instead of aborting.
*/
-Status multiInitialSyncApply_noAbort(OperationContext* txn,
+Status multiInitialSyncApply_noAbort(OperationContext* opCtx,
MultiApplier::OperationPtrs* ops,
SyncTail* st,
AtomicUInt32* fetchCount);
diff --git a/src/mongo/db/repl/sync_tail_test.cpp b/src/mongo/db/repl/sync_tail_test.cpp
index b6946a4edc2..b1e62a2efa5 100644
--- a/src/mongo/db/repl/sync_tail_test.cpp
+++ b/src/mongo/db/repl/sync_tail_test.cpp
@@ -69,7 +69,7 @@ using namespace mongo::repl;
class SyncTailTest : public ServiceContextMongoDTest {
protected:
void _testSyncApplyInsertDocument(LockMode expectedMode);
- ServiceContext::UniqueOperationContext _txn;
+ ServiceContext::UniqueOperationContext _opCtx;
unsigned int _opsApplied;
SyncTail::ApplyOperationInLockFn _applyOp;
SyncTail::ApplyCommandInLockFn _applyCmd;
@@ -91,7 +91,7 @@ protected:
class SyncTailWithLocalDocumentFetcher : public SyncTail {
public:
SyncTailWithLocalDocumentFetcher(const BSONObj& document);
- BSONObj getMissingDoc(OperationContext* txn, Database* db, const BSONObj& o) override;
+ BSONObj getMissingDoc(OperationContext* opCtx, Database* db, const BSONObj& o) override;
private:
BSONObj _document;
@@ -103,7 +103,7 @@ private:
class SyncTailWithOperationContextChecker : public SyncTail {
public:
SyncTailWithOperationContextChecker();
- bool shouldRetry(OperationContext* txn, const BSONObj& o) override;
+ bool shouldRetry(OperationContext* opCtx, const BSONObj& o) override;
};
void SyncTailTest::setUp() {
@@ -122,19 +122,19 @@ void SyncTailTest::setUp() {
const std::vector<BSONObj>&) { return Status::OK(); };
StorageInterface::set(service, std::move(storageInterface));
- _txn = cc().makeOperationContext();
+ _opCtx = cc().makeOperationContext();
_opsApplied = 0;
- _applyOp = [](OperationContext* txn,
+ _applyOp = [](OperationContext* opCtx,
Database* db,
const BSONObj& op,
bool inSteadyStateReplication,
stdx::function<void()>) { return Status::OK(); };
- _applyCmd = [](OperationContext* txn, const BSONObj& op, bool) { return Status::OK(); };
+ _applyCmd = [](OperationContext* opCtx, const BSONObj& op, bool) { return Status::OK(); };
_incOps = [this]() { _opsApplied++; };
}
void SyncTailTest::tearDown() {
- _txn.reset();
+ _opCtx.reset();
ServiceContextMongoDTest::tearDown();
_storageInterface = nullptr;
}
@@ -151,10 +151,10 @@ BSONObj SyncTailWithLocalDocumentFetcher::getMissingDoc(OperationContext*,
SyncTailWithOperationContextChecker::SyncTailWithOperationContextChecker()
: SyncTail(nullptr, SyncTail::MultiSyncApplyFunc(), nullptr) {}
-bool SyncTailWithOperationContextChecker::shouldRetry(OperationContext* txn, const BSONObj&) {
- ASSERT_FALSE(txn->writesAreReplicated());
- ASSERT_FALSE(txn->lockState()->shouldConflictWithSecondaryBatchApplication());
- ASSERT_TRUE(documentValidationDisabled(txn));
+bool SyncTailWithOperationContextChecker::shouldRetry(OperationContext* opCtx, const BSONObj&) {
+ ASSERT_FALSE(opCtx->writesAreReplicated());
+ ASSERT_FALSE(opCtx->lockState()->shouldConflictWithSecondaryBatchApplication());
+ ASSERT_TRUE(documentValidationDisabled(opCtx));
return false;
}
@@ -173,21 +173,21 @@ CollectionOptions createOplogCollectionOptions() {
* Create test collection.
* Returns collection.
*/
-void createCollection(OperationContext* txn,
+void createCollection(OperationContext* opCtx,
const NamespaceString& nss,
const CollectionOptions& options) {
MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
- ScopedTransaction transaction(txn, MODE_IX);
- Lock::DBLock dblk(txn->lockState(), nss.db(), MODE_X);
- OldClientContext ctx(txn, nss.ns());
+ ScopedTransaction transaction(opCtx, MODE_IX);
+ Lock::DBLock dblk(opCtx->lockState(), nss.db(), MODE_X);
+ OldClientContext ctx(opCtx, nss.ns());
auto db = ctx.db();
ASSERT_TRUE(db);
- mongo::WriteUnitOfWork wuow(txn);
- auto coll = db->createCollection(txn, nss.ns(), options);
+ mongo::WriteUnitOfWork wuow(opCtx);
+ auto coll = db->createCollection(opCtx, nss.ns(), options);
ASSERT_TRUE(coll);
wuow.commit();
}
- MONGO_WRITE_CONFLICT_RETRY_LOOP_END(txn, "createCollection", nss.ns());
+ MONGO_WRITE_CONFLICT_RETRY_LOOP_END(opCtx, "createCollection", nss.ns());
}
/**
@@ -250,7 +250,7 @@ OplogEntry makeUpdateDocumentOplogEntry(OpTime opTime,
return OplogEntry(bob.obj());
}
-Status failedApplyCommand(OperationContext* txn, const BSONObj& theOperation, bool) {
+Status failedApplyCommand(OperationContext* opCtx, const BSONObj& theOperation, bool) {
FAIL("applyCommand unexpectedly invoked.");
return Status::OK();
}
@@ -258,12 +258,12 @@ Status failedApplyCommand(OperationContext* txn, const BSONObj& theOperation, bo
TEST_F(SyncTailTest, SyncApplyNoNamespaceBadOp) {
const BSONObj op = BSON("op"
<< "x");
- ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, _applyOp, _applyCmd, _incOps));
+ ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, _applyOp, _applyCmd, _incOps));
ASSERT_EQUALS(0U, _opsApplied);
}
TEST_F(SyncTailTest, SyncApplyNoNamespaceNoOp) {
- ASSERT_OK(SyncTail::syncApply(_txn.get(),
+ ASSERT_OK(SyncTail::syncApply(_opCtx.get(),
BSON("op"
<< "n"),
false));
@@ -275,8 +275,9 @@ TEST_F(SyncTailTest, SyncApplyBadOp) {
<< "x"
<< "ns"
<< "test.t");
- ASSERT_EQUALS(ErrorCodes::BadValue,
- SyncTail::syncApply(_txn.get(), op, false, _applyOp, _applyCmd, _incOps).code());
+ ASSERT_EQUALS(
+ ErrorCodes::BadValue,
+ SyncTail::syncApply(_opCtx.get(), op, false, _applyOp, _applyCmd, _incOps).code());
ASSERT_EQUALS(0U, _opsApplied);
}
@@ -286,24 +287,24 @@ TEST_F(SyncTailTest, SyncApplyNoOp) {
<< "ns"
<< "test.t");
bool applyOpCalled = false;
- SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+ SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
Database* db,
const BSONObj& theOperation,
bool inSteadyStateReplication,
stdx::function<void()>) {
applyOpCalled = true;
- ASSERT_TRUE(txn);
- ASSERT_TRUE(txn->lockState()->isDbLockedForMode("test", MODE_X));
- ASSERT_FALSE(txn->writesAreReplicated());
- ASSERT_TRUE(documentValidationDisabled(txn));
+ ASSERT_TRUE(opCtx);
+ ASSERT_TRUE(opCtx->lockState()->isDbLockedForMode("test", MODE_X));
+ ASSERT_FALSE(opCtx->writesAreReplicated());
+ ASSERT_TRUE(documentValidationDisabled(opCtx));
ASSERT_TRUE(db);
ASSERT_BSONOBJ_EQ(op, theOperation);
ASSERT_FALSE(inSteadyStateReplication);
return Status::OK();
};
- ASSERT_TRUE(_txn->writesAreReplicated());
- ASSERT_FALSE(documentValidationDisabled(_txn.get()));
- ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, applyOp, failedApplyCommand, _incOps));
+ ASSERT_TRUE(_opCtx->writesAreReplicated());
+ ASSERT_FALSE(documentValidationDisabled(_opCtx.get()));
+ ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, applyOp, failedApplyCommand, _incOps));
ASSERT_TRUE(applyOpCalled);
}
@@ -313,7 +314,7 @@ TEST_F(SyncTailTest, SyncApplyNoOpApplyOpThrowsException) {
<< "ns"
<< "test.t");
int applyOpCalled = 0;
- SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+ SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
Database* db,
const BSONObj& theOperation,
bool inSteadyStateReplication,
@@ -324,7 +325,7 @@ TEST_F(SyncTailTest, SyncApplyNoOpApplyOpThrowsException) {
}
return Status::OK();
};
- ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, applyOp, failedApplyCommand, _incOps));
+ ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, applyOp, failedApplyCommand, _incOps));
ASSERT_EQUALS(5, applyOpCalled);
}
@@ -334,25 +335,25 @@ void SyncTailTest::_testSyncApplyInsertDocument(LockMode expectedMode) {
<< "ns"
<< "test.t");
bool applyOpCalled = false;
- SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+ SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
Database* db,
const BSONObj& theOperation,
bool inSteadyStateReplication,
stdx::function<void()>) {
applyOpCalled = true;
- ASSERT_TRUE(txn);
- ASSERT_TRUE(txn->lockState()->isDbLockedForMode("test", expectedMode));
- ASSERT_TRUE(txn->lockState()->isCollectionLockedForMode("test.t", expectedMode));
- ASSERT_FALSE(txn->writesAreReplicated());
- ASSERT_TRUE(documentValidationDisabled(txn));
+ ASSERT_TRUE(opCtx);
+ ASSERT_TRUE(opCtx->lockState()->isDbLockedForMode("test", expectedMode));
+ ASSERT_TRUE(opCtx->lockState()->isCollectionLockedForMode("test.t", expectedMode));
+ ASSERT_FALSE(opCtx->writesAreReplicated());
+ ASSERT_TRUE(documentValidationDisabled(opCtx));
ASSERT_TRUE(db);
ASSERT_BSONOBJ_EQ(op, theOperation);
ASSERT_TRUE(inSteadyStateReplication);
return Status::OK();
};
- ASSERT_TRUE(_txn->writesAreReplicated());
- ASSERT_FALSE(documentValidationDisabled(_txn.get()));
- ASSERT_OK(SyncTail::syncApply(_txn.get(), op, true, applyOp, failedApplyCommand, _incOps));
+ ASSERT_TRUE(_opCtx->writesAreReplicated());
+ ASSERT_FALSE(documentValidationDisabled(_opCtx.get()));
+ ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, true, applyOp, failedApplyCommand, _incOps));
ASSERT_TRUE(applyOpCalled);
}
@@ -362,9 +363,9 @@ TEST_F(SyncTailTest, SyncApplyInsertDocumentDatabaseMissing) {
TEST_F(SyncTailTest, SyncApplyInsertDocumentCollectionMissing) {
{
- Lock::GlobalWrite globalLock(_txn->lockState());
+ Lock::GlobalWrite globalLock(_opCtx->lockState());
bool justCreated = false;
- Database* db = dbHolder().openDb(_txn.get(), "test", &justCreated);
+ Database* db = dbHolder().openDb(_opCtx.get(), "test", &justCreated);
ASSERT_TRUE(db);
ASSERT_TRUE(justCreated);
}
@@ -373,12 +374,12 @@ TEST_F(SyncTailTest, SyncApplyInsertDocumentCollectionMissing) {
TEST_F(SyncTailTest, SyncApplyInsertDocumentCollectionExists) {
{
- Lock::GlobalWrite globalLock(_txn->lockState());
+ Lock::GlobalWrite globalLock(_opCtx->lockState());
bool justCreated = false;
- Database* db = dbHolder().openDb(_txn.get(), "test", &justCreated);
+ Database* db = dbHolder().openDb(_opCtx.get(), "test", &justCreated);
ASSERT_TRUE(db);
ASSERT_TRUE(justCreated);
- Collection* collection = db->createCollection(_txn.get(), "test.t");
+ Collection* collection = db->createCollection(_opCtx.get(), "test.t");
ASSERT_TRUE(collection);
}
_testSyncApplyInsertDocument(MODE_IX);
@@ -390,24 +391,24 @@ TEST_F(SyncTailTest, SyncApplyIndexBuild) {
<< "ns"
<< "test.system.indexes");
bool applyOpCalled = false;
- SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+ SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
Database* db,
const BSONObj& theOperation,
bool inSteadyStateReplication,
stdx::function<void()>) {
applyOpCalled = true;
- ASSERT_TRUE(txn);
- ASSERT_TRUE(txn->lockState()->isDbLockedForMode("test", MODE_X));
- ASSERT_FALSE(txn->writesAreReplicated());
- ASSERT_TRUE(documentValidationDisabled(txn));
+ ASSERT_TRUE(opCtx);
+ ASSERT_TRUE(opCtx->lockState()->isDbLockedForMode("test", MODE_X));
+ ASSERT_FALSE(opCtx->writesAreReplicated());
+ ASSERT_TRUE(documentValidationDisabled(opCtx));
ASSERT_TRUE(db);
ASSERT_BSONOBJ_EQ(op, theOperation);
ASSERT_FALSE(inSteadyStateReplication);
return Status::OK();
};
- ASSERT_TRUE(_txn->writesAreReplicated());
- ASSERT_FALSE(documentValidationDisabled(_txn.get()));
- ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, applyOp, failedApplyCommand, _incOps));
+ ASSERT_TRUE(_opCtx->writesAreReplicated());
+ ASSERT_FALSE(documentValidationDisabled(_opCtx.get()));
+ ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, applyOp, failedApplyCommand, _incOps));
ASSERT_TRUE(applyOpCalled);
}
@@ -417,7 +418,7 @@ TEST_F(SyncTailTest, SyncApplyCommand) {
<< "ns"
<< "test.t");
bool applyCmdCalled = false;
- SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+ SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
Database* db,
const BSONObj& theOperation,
bool inSteadyStateReplication,
@@ -426,18 +427,18 @@ TEST_F(SyncTailTest, SyncApplyCommand) {
return Status::OK();
};
SyncTail::ApplyCommandInLockFn applyCmd =
- [&](OperationContext* txn, const BSONObj& theOperation, bool inSteadyStateReplication) {
+ [&](OperationContext* opCtx, const BSONObj& theOperation, bool inSteadyStateReplication) {
applyCmdCalled = true;
- ASSERT_TRUE(txn);
- ASSERT_TRUE(txn->lockState()->isW());
- ASSERT_TRUE(txn->writesAreReplicated());
- ASSERT_FALSE(documentValidationDisabled(txn));
+ ASSERT_TRUE(opCtx);
+ ASSERT_TRUE(opCtx->lockState()->isW());
+ ASSERT_TRUE(opCtx->writesAreReplicated());
+ ASSERT_FALSE(documentValidationDisabled(opCtx));
ASSERT_BSONOBJ_EQ(op, theOperation);
return Status::OK();
};
- ASSERT_TRUE(_txn->writesAreReplicated());
- ASSERT_FALSE(documentValidationDisabled(_txn.get()));
- ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, applyOp, applyCmd, _incOps));
+ ASSERT_TRUE(_opCtx->writesAreReplicated());
+ ASSERT_FALSE(documentValidationDisabled(_opCtx.get()));
+ ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, applyOp, applyCmd, _incOps));
ASSERT_TRUE(applyCmdCalled);
ASSERT_EQUALS(1U, _opsApplied);
}
@@ -448,7 +449,7 @@ TEST_F(SyncTailTest, SyncApplyCommandThrowsException) {
<< "ns"
<< "test.t");
int applyCmdCalled = 0;
- SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* txn,
+ SyncTail::ApplyOperationInLockFn applyOp = [&](OperationContext* opCtx,
Database* db,
const BSONObj& theOperation,
bool inSteadyStateReplication,
@@ -457,14 +458,14 @@ TEST_F(SyncTailTest, SyncApplyCommandThrowsException) {
return Status::OK();
};
SyncTail::ApplyCommandInLockFn applyCmd =
- [&](OperationContext* txn, const BSONObj& theOperation, bool inSteadyStateReplication) {
+ [&](OperationContext* opCtx, const BSONObj& theOperation, bool inSteadyStateReplication) {
applyCmdCalled++;
if (applyCmdCalled < 5) {
throw WriteConflictException();
}
return Status::OK();
};
- ASSERT_OK(SyncTail::syncApply(_txn.get(), op, false, applyOp, applyCmd, _incOps));
+ ASSERT_OK(SyncTail::syncApply(_opCtx.get(), op, false, applyOp, applyCmd, _incOps));
ASSERT_EQUALS(5, applyCmdCalled);
ASSERT_EQUALS(1U, _opsApplied);
}
@@ -479,14 +480,14 @@ TEST_F(SyncTailTest, MultiApplyReturnsBadValueOnNullOperationContext) {
TEST_F(SyncTailTest, MultiApplyReturnsBadValueOnNullWriterPool) {
auto op = makeCreateCollectionOplogEntry({Timestamp(Seconds(1), 0), 1LL});
- auto status = multiApply(_txn.get(), nullptr, {op}, noopApplyOperationFn).getStatus();
+ auto status = multiApply(_opCtx.get(), nullptr, {op}, noopApplyOperationFn).getStatus();
ASSERT_EQUALS(ErrorCodes::BadValue, status);
ASSERT_STRING_CONTAINS(status.reason(), "invalid worker pool");
}
TEST_F(SyncTailTest, MultiApplyReturnsEmptyArrayOperationWhenNoOperationsAreGiven) {
auto writerPool = SyncTail::makeWriterPool();
- auto status = multiApply(_txn.get(), writerPool.get(), {}, noopApplyOperationFn).getStatus();
+ auto status = multiApply(_opCtx.get(), writerPool.get(), {}, noopApplyOperationFn).getStatus();
ASSERT_EQUALS(ErrorCodes::EmptyArrayOperation, status);
ASSERT_STRING_CONTAINS(status.reason(), "no operations provided to multiApply");
}
@@ -495,12 +496,13 @@ TEST_F(SyncTailTest, MultiApplyReturnsBadValueOnNullApplyOperation) {
auto writerPool = SyncTail::makeWriterPool();
MultiApplier::ApplyOperationFn nullApplyOperationFn;
auto op = makeCreateCollectionOplogEntry({Timestamp(Seconds(1), 0), 1LL});
- auto status = multiApply(_txn.get(), writerPool.get(), {op}, nullApplyOperationFn).getStatus();
+ auto status =
+ multiApply(_opCtx.get(), writerPool.get(), {op}, nullApplyOperationFn).getStatus();
ASSERT_EQUALS(ErrorCodes::BadValue, status);
ASSERT_STRING_CONTAINS(status.reason(), "invalid apply operation function");
}
-bool _testOplogEntryIsForCappedCollection(OperationContext* txn,
+bool _testOplogEntryIsForCappedCollection(OperationContext* opCtx,
const NamespaceString& nss,
const CollectionOptions& options) {
auto writerPool = SyncTail::makeWriterPool();
@@ -512,13 +514,13 @@ bool _testOplogEntryIsForCappedCollection(OperationContext* txn,
}
return Status::OK();
};
- createCollection(txn, nss, options);
+ createCollection(opCtx, nss, options);
auto op = makeInsertDocumentOplogEntry({Timestamp(Seconds(1), 0), 1LL}, nss, BSON("a" << 1));
ASSERT_FALSE(op.isForCappedCollection);
auto lastOpTime =
- unittest::assertGet(multiApply(txn, writerPool.get(), {op}, applyOperationFn));
+ unittest::assertGet(multiApply(opCtx, writerPool.get(), {op}, applyOperationFn));
ASSERT_EQUALS(op.getOpTime(), lastOpTime);
ASSERT_EQUALS(1U, operationsApplied.size());
@@ -532,14 +534,14 @@ TEST_F(
SyncTailTest,
MultiApplyDoesNotSetOplogEntryIsForCappedCollectionWhenProcessingNonCappedCollectionInsertOperation) {
NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
- ASSERT_FALSE(_testOplogEntryIsForCappedCollection(_txn.get(), nss, CollectionOptions()));
+ ASSERT_FALSE(_testOplogEntryIsForCappedCollection(_opCtx.get(), nss, CollectionOptions()));
}
TEST_F(SyncTailTest,
MultiApplySetsOplogEntryIsForCappedCollectionWhenProcessingCappedCollectionInsertOperation) {
NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
ASSERT_TRUE(
- _testOplogEntryIsForCappedCollection(_txn.get(), nss, createOplogCollectionOptions()));
+ _testOplogEntryIsForCappedCollection(_opCtx.get(), nss, createOplogCollectionOptions()));
}
TEST_F(SyncTailTest, MultiApplyAssignsOperationsToWriterThreadsBasedOnNamespaceHash) {
@@ -569,7 +571,7 @@ TEST_F(SyncTailTest, MultiApplyAssignsOperationsToWriterThreadsBasedOnNamespaceH
NamespaceString nssForInsert;
std::vector<BSONObj> operationsWrittenToOplog;
_storageInterface->insertDocumentsFn = [&mutex, &nssForInsert, &operationsWrittenToOplog](
- OperationContext* txn, const NamespaceString& nss, const std::vector<BSONObj>& docs) {
+ OperationContext* opCtx, const NamespaceString& nss, const std::vector<BSONObj>& docs) {
stdx::lock_guard<stdx::mutex> lock(mutex);
nssForInsert = nss;
operationsWrittenToOplog = docs;
@@ -577,7 +579,7 @@ TEST_F(SyncTailTest, MultiApplyAssignsOperationsToWriterThreadsBasedOnNamespaceH
};
auto lastOpTime =
- unittest::assertGet(multiApply(_txn.get(), &writerPool, {op1, op2}, applyOperationFn));
+ unittest::assertGet(multiApply(_opCtx.get(), &writerPool, {op1, op2}, applyOperationFn));
ASSERT_EQUALS(op2.getOpTime(), lastOpTime);
// Each writer thread should be given exactly one operation to apply.
@@ -606,28 +608,28 @@ TEST_F(SyncTailTest, MultiApplyAssignsOperationsToWriterThreadsBasedOnNamespaceH
TEST_F(SyncTailTest, MultiSyncApplyUsesSyncApplyToApplyOperation) {
NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
auto op = makeCreateCollectionOplogEntry({Timestamp(Seconds(1), 0), 1LL}, nss);
- _txn.reset();
+ _opCtx.reset();
MultiApplier::OperationPtrs ops = {&op};
multiSyncApply(&ops, nullptr);
// Collection should be created after SyncTail::syncApply() processes operation.
- _txn = cc().makeOperationContext();
- ASSERT_TRUE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
+ _opCtx = cc().makeOperationContext();
+ ASSERT_TRUE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
}
TEST_F(SyncTailTest, MultiSyncApplyDisablesDocumentValidationWhileApplyingOperations) {
NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
- auto syncApply = [](OperationContext* txn, const BSONObj&, bool convertUpdatesToUpserts) {
- ASSERT_FALSE(txn->writesAreReplicated());
- ASSERT_FALSE(txn->lockState()->shouldConflictWithSecondaryBatchApplication());
- ASSERT_TRUE(documentValidationDisabled(txn));
+ auto syncApply = [](OperationContext* opCtx, const BSONObj&, bool convertUpdatesToUpserts) {
+ ASSERT_FALSE(opCtx->writesAreReplicated());
+ ASSERT_FALSE(opCtx->lockState()->shouldConflictWithSecondaryBatchApplication());
+ ASSERT_TRUE(documentValidationDisabled(opCtx));
ASSERT_TRUE(convertUpdatesToUpserts);
return Status::OK();
};
auto op = makeUpdateDocumentOplogEntry(
{Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), BSON("_id" << 0 << "x" << 2));
MultiApplier::OperationPtrs ops = {&op};
- ASSERT_OK(multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+ ASSERT_OK(multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
}
TEST_F(SyncTailTest, MultiSyncApplyPassesThroughSyncApplyErrorAfterFailingToApplyOperation) {
@@ -640,7 +642,8 @@ TEST_F(SyncTailTest, MultiSyncApplyPassesThroughSyncApplyErrorAfterFailingToAppl
return {ErrorCodes::OperationFailed, ""};
};
MultiApplier::OperationPtrs ops = {&op};
- ASSERT_EQUALS(ErrorCodes::OperationFailed, multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+ ASSERT_EQUALS(ErrorCodes::OperationFailed,
+ multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
}
TEST_F(SyncTailTest, MultiSyncApplyPassesThroughSyncApplyException) {
@@ -654,7 +657,8 @@ TEST_F(SyncTailTest, MultiSyncApplyPassesThroughSyncApplyException) {
MONGO_UNREACHABLE;
};
MultiApplier::OperationPtrs ops = {&op};
- ASSERT_EQUALS(ErrorCodes::OperationFailed, multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+ ASSERT_EQUALS(ErrorCodes::OperationFailed,
+ multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
}
TEST_F(SyncTailTest, MultiSyncApplySortsOperationsStablyByNamespaceBeforeApplying) {
@@ -677,7 +681,7 @@ TEST_F(SyncTailTest, MultiSyncApplySortsOperationsStablyByNamespaceBeforeApplyin
return Status::OK();
};
MultiApplier::OperationPtrs ops = {&op4, &op1, &op3, &op2};
- ASSERT_OK(multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+ ASSERT_OK(multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
ASSERT_EQUALS(4U, operationsApplied.size());
ASSERT_EQUALS(op1, operationsApplied[0]);
ASSERT_EQUALS(op2, operationsApplied[1]);
@@ -707,7 +711,7 @@ TEST_F(SyncTailTest, MultiSyncApplyGroupsInsertOperationByNamespaceBeforeApplyin
MultiApplier::OperationPtrs ops = {
&createOp1, &createOp2, &insertOp1a, &insertOp2a, &insertOp1b, &insertOp2b};
- ASSERT_OK(multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+ ASSERT_OK(multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
ASSERT_EQUALS(4U, operationsApplied.size());
ASSERT_EQUALS(createOp1, operationsApplied[0]);
@@ -761,7 +765,7 @@ TEST_F(SyncTailTest, MultiSyncApplyUsesLimitWhenGroupingInsertOperation) {
for (auto&& op : operationsToApply) {
ops.push_back(&op);
}
- ASSERT_OK(multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+ ASSERT_OK(multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
// multiSyncApply should combine operations as follows:
// {create}, {grouped_insert}, {insert_(limit+1)}
@@ -820,7 +824,7 @@ TEST_F(SyncTailTest, MultiSyncApplyFallsBackOnApplyingInsertsIndividuallyWhenGro
for (auto&& op : operationsToApply) {
ops.push_back(&op);
}
- ASSERT_OK(multiSyncApply_noAbort(_txn.get(), &ops, syncApply));
+ ASSERT_OK(multiSyncApply_noAbort(_opCtx.get(), &ops, syncApply));
// On failing to apply the grouped insert operation, multiSyncApply should apply the operations
// as given in "operationsToApply":
@@ -845,7 +849,7 @@ TEST_F(SyncTailTest, MultiInitialSyncApplyDisablesDocumentValidationWhileApplyin
{Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), BSON("_id" << 0 << "x" << 2));
MultiApplier::OperationPtrs ops = {&op};
AtomicUInt32 fetchCount(0);
- ASSERT_OK(multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+ ASSERT_OK(multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
ASSERT_EQUALS(fetchCount.load(), 1U);
}
@@ -858,11 +862,11 @@ TEST_F(SyncTailTest,
{Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), BSON("_id" << 0 << "x" << 2));
MultiApplier::OperationPtrs ops = {&op};
AtomicUInt32 fetchCount(0);
- ASSERT_OK(multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+ ASSERT_OK(multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
// Since the missing document is not found on the sync source, the collection referenced by
// the failed operation should not be automatically created.
- ASSERT_FALSE(AutoGetCollectionForRead(_txn.get(), nss).getCollection());
+ ASSERT_FALSE(AutoGetCollectionForRead(_opCtx.get(), nss).getCollection());
ASSERT_EQUALS(fetchCount.load(), 1U);
}
@@ -880,10 +884,10 @@ TEST_F(SyncTailTest, MultiInitialSyncApplySkipsDocumentOnNamespaceNotFound) {
auto op3 = makeInsertDocumentOplogEntry({Timestamp(Seconds(4), 0), 1LL}, nss, doc3);
MultiApplier::OperationPtrs ops = {&op0, &op1, &op2, &op3};
AtomicUInt32 fetchCount(0);
- ASSERT_OK(multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+ ASSERT_OK(multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
ASSERT_EQUALS(fetchCount.load(), 0U);
- OplogInterfaceLocal collectionReader(_txn.get(), nss.ns());
+ OplogInterfaceLocal collectionReader(_opCtx.get(), nss.ns());
auto iter = collectionReader.makeIterator();
ASSERT_BSONOBJ_EQ(doc3, unittest::assertGet(iter->next()).first);
ASSERT_BSONOBJ_EQ(doc1, unittest::assertGet(iter->next()).first);
@@ -898,13 +902,13 @@ TEST_F(SyncTailTest, MultiInitialSyncApplyRetriesFailedUpdateIfDocumentIsAvailab
{Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), updatedDocument);
MultiApplier::OperationPtrs ops = {&op};
AtomicUInt32 fetchCount(0);
- ASSERT_OK(multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+ ASSERT_OK(multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
ASSERT_EQUALS(fetchCount.load(), 1U);
// The collection referenced by "ns" in the failed operation is automatically created to hold
// the missing document fetched from the sync source. We verify the contents of the collection
// with the OplogInterfaceLocal class.
- OplogInterfaceLocal collectionReader(_txn.get(), nss.ns());
+ OplogInterfaceLocal collectionReader(_opCtx.get(), nss.ns());
auto iter = collectionReader.makeIterator();
ASSERT_BSONOBJ_EQ(updatedDocument, unittest::assertGet(iter->next()).first);
ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
@@ -920,7 +924,7 @@ TEST_F(SyncTailTest, MultiInitialSyncApplyPassesThroughSyncApplyErrorAfterFailin
MultiApplier::OperationPtrs ops = {&op};
AtomicUInt32 fetchCount(0);
ASSERT_EQUALS(ErrorCodes::BadValue,
- multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+ multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
ASSERT_EQUALS(fetchCount.load(), 1U);
}
@@ -929,12 +933,13 @@ TEST_F(SyncTailTest, MultiInitialSyncApplyPassesThroughShouldSyncTailRetryError)
NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
auto op = makeUpdateDocumentOplogEntry(
{Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), BSON("_id" << 0 << "x" << 2));
- ASSERT_THROWS_CODE(
- syncTail.shouldRetry(_txn.get(), op.raw), mongo::UserException, ErrorCodes::FailedToParse);
+ ASSERT_THROWS_CODE(syncTail.shouldRetry(_opCtx.get(), op.raw),
+ mongo::UserException,
+ ErrorCodes::FailedToParse);
MultiApplier::OperationPtrs ops = {&op};
AtomicUInt32 fetchCount(0);
ASSERT_EQUALS(ErrorCodes::FailedToParse,
- multiInitialSyncApply_noAbort(_txn.get(), &ops, &syncTail, &fetchCount));
+ multiInitialSyncApply_noAbort(_opCtx.get(), &ops, &syncTail, &fetchCount));
ASSERT_EQUALS(fetchCount.load(), 1U);
}
@@ -970,7 +975,7 @@ Status IdempotencyTest::runOps(std::initializer_list<OplogEntry> ops) {
opsPtrs.push_back(&op);
}
AtomicUInt32 fetchCount(0);
- return multiInitialSyncApply_noAbort(_txn.get(), &opsPtrs, &syncTail, &fetchCount);
+ return multiInitialSyncApply_noAbort(_opCtx.get(), &opsPtrs, &syncTail, &fetchCount);
}
OplogEntry IdempotencyTest::createCollection() {
@@ -1002,21 +1007,21 @@ OplogEntry IdempotencyTest::dropIndex(const std::string& indexName) {
}
std::string IdempotencyTest::validate() {
- auto collection = AutoGetCollectionForRead(_txn.get(), nss).getCollection();
+ auto collection = AutoGetCollectionForRead(_opCtx.get(), nss).getCollection();
if (!collection) {
return "CollectionNotFound";
}
ValidateResults validateResults;
BSONObjBuilder bob;
- Lock::DBLock lk(_txn->lockState(), nss.db(), MODE_IS);
- Lock::CollectionLock lock(_txn->lockState(), nss.ns(), MODE_IS);
- ASSERT_OK(collection->validate(_txn.get(), kValidateFull, &validateResults, &bob));
+ Lock::DBLock lk(_opCtx->lockState(), nss.db(), MODE_IS);
+ Lock::CollectionLock lock(_opCtx->lockState(), nss.ns(), MODE_IS);
+ ASSERT_OK(collection->validate(_opCtx.get(), kValidateFull, &validateResults, &bob));
ASSERT_TRUE(validateResults.valid);
- IndexDescriptor* desc = collection->getIndexCatalog()->findIdIndex(_txn.get());
+ IndexDescriptor* desc = collection->getIndexCatalog()->findIdIndex(_opCtx.get());
ASSERT_TRUE(desc);
- auto exec = InternalPlanner::indexScan(_txn.get(),
+ auto exec = InternalPlanner::indexScan(_opCtx.get(),
collection,
desc,
BSONObj(),
@@ -1041,7 +1046,7 @@ std::string IdempotencyTest::validate() {
}
TEST_F(IdempotencyTest, Geo2dsphereIndexFailedOnUpdate) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
auto insertOp = insert(fromjson("{_id: 1, loc: 'hi'}"));
auto updateOp = update(1, fromjson("{$set: {loc: [1, 2]}}"));
@@ -1054,13 +1059,13 @@ TEST_F(IdempotencyTest, Geo2dsphereIndexFailedOnUpdate) {
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), 16755);
}
TEST_F(IdempotencyTest, Geo2dsphereIndexFailedOnIndexing) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
auto indexOp = buildIndex(fromjson("{loc: '2dsphere'}"), BSON("2dsphereIndexVersion" << 3));
auto dropIndexOp = dropIndex("loc_index");
@@ -1073,13 +1078,13 @@ TEST_F(IdempotencyTest, Geo2dsphereIndexFailedOnIndexing) {
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), 16755);
}
TEST_F(IdempotencyTest, Geo2dIndex) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
auto insertOp = insert(fromjson("{_id: 1, loc: [1]}"));
auto updateOp = update(1, fromjson("{$set: {loc: [1, 2]}}"));
@@ -1092,13 +1097,13 @@ TEST_F(IdempotencyTest, Geo2dIndex) {
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), 13068);
}
TEST_F(IdempotencyTest, UniqueKeyIndex) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
auto insertOp = insert(fromjson("{_id: 1, x: 5}"));
auto updateOp = update(1, fromjson("{$set: {x: 6}}"));
@@ -1112,13 +1117,13 @@ TEST_F(IdempotencyTest, UniqueKeyIndex) {
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), ErrorCodes::DuplicateKey);
}
TEST_F(IdempotencyTest, ParallelArrayError) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
ASSERT_OK(runOp(insert(fromjson("{_id: 1}"))));
@@ -1135,13 +1140,13 @@ TEST_F(IdempotencyTest, ParallelArrayError) {
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), ErrorCodes::CannotIndexParallelArrays);
}
TEST_F(IdempotencyTest, IndexKeyTooLongError) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
ASSERT_OK(runOp(insert(fromjson("{_id: 1}"))));
@@ -1161,13 +1166,13 @@ TEST_F(IdempotencyTest, IndexKeyTooLongError) {
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), ErrorCodes::KeyTooLong);
}
TEST_F(IdempotencyTest, IndexWithDifferentOptions) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
ASSERT_OK(runOp(insert(fromjson("{_id: 1, x: 'hi'}"))));
@@ -1183,13 +1188,13 @@ TEST_F(IdempotencyTest, IndexWithDifferentOptions) {
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), ErrorCodes::IndexOptionsConflict);
}
TEST_F(IdempotencyTest, TextIndexDocumentHasNonStringLanguageField) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
auto insertOp = insert(fromjson("{_id: 1, x: 'words to index', language: 1}"));
@@ -1203,13 +1208,13 @@ TEST_F(IdempotencyTest, TextIndexDocumentHasNonStringLanguageField) {
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), 17261);
}
TEST_F(IdempotencyTest, InsertDocumentWithNonStringLanguageFieldWhenTextIndexExists) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
auto indexOp = buildIndex(fromjson("{x: 'text'}"), BSONObj());
@@ -1223,13 +1228,13 @@ TEST_F(IdempotencyTest, InsertDocumentWithNonStringLanguageFieldWhenTextIndexExi
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), 17261);
}
TEST_F(IdempotencyTest, TextIndexDocumentHasNonStringLanguageOverrideField) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
auto insertOp = insert(fromjson("{_id: 1, x: 'words to index', y: 1}"));
@@ -1243,13 +1248,13 @@ TEST_F(IdempotencyTest, TextIndexDocumentHasNonStringLanguageOverrideField) {
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), 17261);
}
TEST_F(IdempotencyTest, InsertDocumentWithNonStringLanguageOverrideFieldWhenTextIndexExists) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
auto indexOp = buildIndex(fromjson("{x: 'text'}"), fromjson("{language_override: 'y'}"));
@@ -1263,13 +1268,13 @@ TEST_F(IdempotencyTest, InsertDocumentWithNonStringLanguageOverrideFieldWhenText
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), 17261);
}
TEST_F(IdempotencyTest, TextIndexDocumentHasUnknownLanguage) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
ASSERT_OK(runOp(createCollection()));
auto insertOp = insert(fromjson("{_id: 1, x: 'words to index', language: 'bad'}"));
@@ -1283,7 +1288,7 @@ TEST_F(IdempotencyTest, TextIndexDocumentHasUnknownLanguage) {
ASSERT_OK(runOps(ops));
ASSERT_EQUALS(hash, validate());
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_PRIMARY);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_PRIMARY);
auto status = runOps(ops);
ASSERT_EQ(status.code(), 17262);
}
@@ -1428,7 +1433,7 @@ TEST_F(IdempotencyTest, CollModIndexNotFound) {
}
TEST_F(IdempotencyTest, ResyncOnRenameCollection) {
- ReplicationCoordinator::get(_txn.get())->setFollowerMode(MemberState::RS_RECOVERING);
+ ReplicationCoordinator::get(_opCtx.get())->setFollowerMode(MemberState::RS_RECOVERING);
auto cmd = BSON("renameCollection" << nss.ns() << "to"
<< "test.bar"
diff --git a/src/mongo/db/repl/task_runner.cpp b/src/mongo/db/repl/task_runner.cpp
index 210718bba3e..d364151a228 100644
--- a/src/mongo/db/repl/task_runner.cpp
+++ b/src/mongo/db/repl/task_runner.cpp
@@ -60,10 +60,10 @@ using LockGuard = stdx::lock_guard<stdx::mutex>;
* next action of kCancel.
*/
TaskRunner::NextAction runSingleTask(const TaskRunner::Task& task,
- OperationContext* txn,
+ OperationContext* opCtx,
const Status& status) {
try {
- return task(txn, status);
+ return task(opCtx, status);
} catch (...) {
log() << "Unhandled exception in task runner: " << redact(exceptionToStatus());
}
@@ -74,7 +74,7 @@ TaskRunner::NextAction runSingleTask(const TaskRunner::Task& task,
// static
TaskRunner::Task TaskRunner::makeCancelTask() {
- return [](OperationContext* txn, const Status& status) { return NextAction::kCancel; };
+ return [](OperationContext* opCtx, const Status& status) { return NextAction::kCancel; };
}
TaskRunner::TaskRunner(OldThreadPool* threadPool)
@@ -132,10 +132,10 @@ void TaskRunner::join() {
void TaskRunner::_runTasks() {
Client* client = nullptr;
- ServiceContext::UniqueOperationContext txn;
+ ServiceContext::UniqueOperationContext opCtx;
while (Task task = _waitForNextTask()) {
- if (!txn) {
+ if (!opCtx) {
if (!client) {
// We initialize cc() because ServiceContextMongoD::_newOpCtx() expects cc()
// to be equal to the client used to create the operation context.
@@ -145,13 +145,13 @@ void TaskRunner::_runTasks() {
AuthorizationSession::get(client)->grantInternalAuthorization();
}
}
- txn = client->makeOperationContext();
+ opCtx = client->makeOperationContext();
}
- NextAction nextAction = runSingleTask(task, txn.get(), Status::OK());
+ NextAction nextAction = runSingleTask(task, opCtx.get(), Status::OK());
if (nextAction != NextAction::kKeepOperationContext) {
- txn.reset();
+ opCtx.reset();
}
if (nextAction == NextAction::kCancel) {
@@ -167,7 +167,7 @@ void TaskRunner::_runTasks() {
}
}
}
- txn.reset();
+ opCtx.reset();
std::list<Task> tasks;
UniqueLock lk{_mutex};
@@ -221,13 +221,13 @@ Status TaskRunner::runSynchronousTask(SynchronousTask func, TaskRunner::NextActi
stdx::condition_variable waitTillDoneCond;
Status returnStatus{Status::OK()};
- this->schedule([&](OperationContext* txn, const Status taskStatus) {
+ this->schedule([&](OperationContext* opCtx, const Status taskStatus) {
if (!taskStatus.isOK()) {
returnStatus = taskStatus;
} else {
// Run supplied function.
try {
- returnStatus = func(txn);
+ returnStatus = func(opCtx);
} catch (...) {
returnStatus = exceptionToStatus();
error() << "Exception thrown in runSynchronousTask: " << redact(returnStatus);
diff --git a/src/mongo/db/repl/task_runner.h b/src/mongo/db/repl/task_runner.h
index a8908660c44..b7dcf4c05d6 100644
--- a/src/mongo/db/repl/task_runner.h
+++ b/src/mongo/db/repl/task_runner.h
@@ -59,7 +59,7 @@ public:
};
using Task = stdx::function<NextAction(OperationContext*, const Status&)>;
- using SynchronousTask = stdx::function<Status(OperationContext* txn)>;
+ using SynchronousTask = stdx::function<Status(OperationContext* opCtx)>;
/**
* Returns the Status from the supplied function after running it..
diff --git a/src/mongo/db/repl/task_runner_test.cpp b/src/mongo/db/repl/task_runner_test.cpp
index dedb6269083..62b64513b37 100644
--- a/src/mongo/db/repl/task_runner_test.cpp
+++ b/src/mongo/db/repl/task_runner_test.cpp
@@ -58,12 +58,12 @@ TEST_F(TaskRunnerTest, GetDiagnosticString) {
TEST_F(TaskRunnerTest, CallbackValues) {
stdx::mutex mutex;
bool called = false;
- OperationContext* txn = nullptr;
+ OperationContext* opCtx = nullptr;
Status status = getDetectableErrorStatus();
auto task = [&](OperationContext* theTxn, const Status& theStatus) {
stdx::lock_guard<stdx::mutex> lk(mutex);
called = true;
- txn = theTxn;
+ opCtx = theTxn;
status = theStatus;
return TaskRunner::NextAction::kCancel;
};
@@ -73,7 +73,7 @@ TEST_F(TaskRunnerTest, CallbackValues) {
stdx::lock_guard<stdx::mutex> lk(mutex);
ASSERT_TRUE(called);
- ASSERT(txn);
+ ASSERT(opCtx);
ASSERT_OK(status);
}
@@ -149,7 +149,7 @@ TEST_F(TaskRunnerTest, RunTaskTwiceKeepOperationContext) {
TEST_F(TaskRunnerTest, SkipSecondTask) {
stdx::mutex mutex;
int i = 0;
- OperationContext* txn[2] = {nullptr, nullptr};
+ OperationContext* opCtx[2] = {nullptr, nullptr};
Status status[2] = {getDetectableErrorStatus(), getDetectableErrorStatus()};
stdx::condition_variable condition;
bool schedulingDone = false;
@@ -159,7 +159,7 @@ TEST_F(TaskRunnerTest, SkipSecondTask) {
if (j >= 2) {
return TaskRunner::NextAction::kCancel;
}
- txn[j] = theTxn;
+ opCtx[j] = theTxn;
status[j] = theStatus;
// Wait for the test code to schedule the second task.
@@ -182,16 +182,16 @@ TEST_F(TaskRunnerTest, SkipSecondTask) {
stdx::lock_guard<stdx::mutex> lk(mutex);
ASSERT_EQUALS(2, i);
- ASSERT(txn[0]);
+ ASSERT(opCtx[0]);
ASSERT_OK(status[0]);
- ASSERT_FALSE(txn[1]);
+ ASSERT_FALSE(opCtx[1]);
ASSERT_EQUALS(ErrorCodes::CallbackCanceled, status[1].code());
}
TEST_F(TaskRunnerTest, FirstTaskThrowsException) {
stdx::mutex mutex;
int i = 0;
- OperationContext* txn[2] = {nullptr, nullptr};
+ OperationContext* opCtx[2] = {nullptr, nullptr};
Status status[2] = {getDetectableErrorStatus(), getDetectableErrorStatus()};
stdx::condition_variable condition;
bool schedulingDone = false;
@@ -201,7 +201,7 @@ TEST_F(TaskRunnerTest, FirstTaskThrowsException) {
if (j >= 2) {
return TaskRunner::NextAction::kCancel;
}
- txn[j] = theTxn;
+ opCtx[j] = theTxn;
status[j] = theStatus;
// Wait for the test code to schedule the second task.
@@ -231,9 +231,9 @@ TEST_F(TaskRunnerTest, FirstTaskThrowsException) {
stdx::lock_guard<stdx::mutex> lk(mutex);
ASSERT_EQUALS(2, i);
- ASSERT(txn[0]);
+ ASSERT(opCtx[0]);
ASSERT_OK(status[0]);
- ASSERT_FALSE(txn[1]);
+ ASSERT_FALSE(opCtx[1]);
ASSERT_EQUALS(ErrorCodes::CallbackCanceled, status[1].code());
}