SERVER-49730: Replace usages of waitForDrainFinish

16 files changed, 8 insertions, 172 deletions

diff --git a/jstests/replsets/drain.js b/jstests/replsets/drain.js
index 7a8bdea6a53..493709eee53 100644
--- a/jstests/replsets/drain.js
+++ b/jstests/replsets/drain.js
@@ -77,13 +77,7 @@ assert.eq(ErrorCodes.NotMasterNoSlaveOk,
 secondary.slaveOk = true;
 assert.commandWorked(secondary.getDB("foo").runCommand({find: "foo"}));
 
-assert.commandFailedWithCode(
-    secondary.adminCommand({
-        replSetTest: 1,
-        waitForDrainFinish: 5000,
-    }),
-    ErrorCodes.ExceededTimeLimit,
-    'replSetTest waitForDrainFinish should time out when draining is not allowed to complete');
+assert(!secondary.adminCommand({"isMaster": 1}).ismaster);
 
 // Allow draining to complete
 jsTestLog('Disabling fail point on new primary to allow draining to complete');
@@ -92,13 +86,6 @@ assert.commandWorked(
     'failed to disable fail point on new primary');
 primary = replSet.getPrimary();
 
-assert.commandWorked(
-    secondary.adminCommand({
-        replSetTest: 1,
-        waitForDrainFinish: 30000,
-    }),
-    'replSetTest waitForDrainFinish should work when draining is allowed to complete');
-
 // Ensure new primary is writable
 jsTestLog('New primary should be writable after draining is complete');
 assert.commandWorked(primary.getDB("foo").flag.insert({sentinel: 1}));
diff --git a/jstests/replsets/step_down_during_draining.js b/jstests/replsets/step_down_during_draining.js
index 3407ee34e08..13387a12610 100644
--- a/jstests/replsets/step_down_during_draining.js
+++ b/jstests/replsets/step_down_during_draining.js
@@ -85,14 +85,6 @@ replSet.stepUp(secondary, {awaitReplicationBeforeStepUp: false, awaitWritablePri
 var res = secondary.getDB("admin").runCommand({"isMaster": 1});
 assert(!res.ismaster);
 
-assert.commandFailedWithCode(
-    secondary.adminCommand({
-        replSetTest: 1,
-        waitForDrainFinish: 5000,
-    }),
-    ErrorCodes.ExceededTimeLimit,
-    'replSetTest waitForDrainFinish should time out when draining is not allowed to complete');
-
 // Original primary steps up.
 reconnect(primary);
 replSet.stepUp(primary, {awaitReplicationBeforeStepUp: false, awaitWritablePrimary: false});
@@ -103,18 +95,15 @@ replSet.stepUp(secondary, {awaitReplicationBeforeStepUp: false, awaitWritablePri
 // Disable fail point to allow replication.
 secondaries.forEach(disableFailPoint);
 
-assert.commandWorked(
-    secondary.adminCommand({
-        replSetTest: 1,
-        waitForDrainFinish: replSet.kDefaultTimeoutMS,
-    }),
-    'replSetTest waitForDrainFinish should work when draining is allowed to complete');
+// Wait for draining to complete.
+const newPrimary = replSet.getPrimary();
+assert.eq(secondary, newPrimary);
 
 // Ensure new primary is writable.
 jsTestLog('New primary should be writable after draining is complete');
-assert.commandWorked(secondary.getDB("foo").flag.insert({sentinel: 1}));
+assert.commandWorked(newPrimary.getDB("foo").flag.insert({sentinel: 1}));
 // Check that all writes reached the secondary's op queue prior to
 // stepping down the original primary and got applied.
-assert.eq(secondary.getDB("foo").foo.find().itcount(), numDocuments);
+assert.eq(newPrimary.getDB("foo").foo.find().itcount(), numDocuments);
 replSet.stopSet();
 })();
diff --git a/jstests/replsets/step_down_during_draining2.js b/jstests/replsets/step_down_during_draining2.js
index dc6c960de33..436590ecb80 100644
--- a/jstests/replsets/step_down_during_draining2.js
+++ b/jstests/replsets/step_down_during_draining2.js
@@ -88,14 +88,6 @@ replSet.stepUp(secondary, {awaitReplicationBeforeStepUp: false, awaitWritablePri
 var res = secondary.getDB("admin").runCommand({"isMaster": 1});
 assert(!res.ismaster);
 
-assert.commandFailedWithCode(
-    secondary.adminCommand({
-        replSetTest: 1,
-        waitForDrainFinish: 5000,
-    }),
-    ErrorCodes.ExceededTimeLimit,
-    'replSetTest waitForDrainFinish should time out when draining is not allowed to complete');
-
 // Prevent the current primary from stepping down
 jsTest.log("disallowing heartbeat stepdown " + secondary.host);
 var blockHeartbeatStepdownFailPoint = configureFailPoint(secondary, "blockHeartbeatStepdown");
diff --git a/jstests/replsets/step_down_during_draining3.js b/jstests/replsets/step_down_during_draining3.js
index 11a0d9e382d..71df8287150 100644
--- a/jstests/replsets/step_down_during_draining3.js
+++ b/jstests/replsets/step_down_during_draining3.js
@@ -77,14 +77,6 @@ replSet.stepUp(secondary, {awaitReplicationBeforeStepUp: false, awaitWritablePri
 var res = secondary.getDB("admin").runCommand({"isMaster": 1});
 assert(!res.ismaster);
 
-assert.commandFailedWithCode(
-    secondary.adminCommand({
-        replSetTest: 1,
-        waitForDrainFinish: 5000,
-    }),
-    ErrorCodes.ExceededTimeLimit,
-    'replSetTest waitForDrainFinish should time out when draining is not allowed to complete');
-
 assert.commandWorked(secondary.adminCommand({replSetStepDown: 60, force: true}));
 
 // Assert stepdown was successful.
diff --git a/jstests/replsets/test_command.js b/jstests/replsets/test_command.js
index a8228464cef..0becd2dc687 100644
--- a/jstests/replsets/test_command.js
+++ b/jstests/replsets/test_command.js
@@ -1,6 +1,5 @@
 // Tests 'replSetTest' command:
 //    waitForMemberState - waits for node's state to become 'expectedState'.
-//    waitForDrainFinish - waits for primary to finish draining its applier queue.
 
 (function() {
 'use strict';
@@ -111,32 +110,5 @@ assert.commandWorked(
     }),
     'replSetTest waitForMemberState(SECONDARY) failed on node 1 ' + secondary.host);
 
-// waitForDrainFinish tests.
-
-assert.commandFailedWithCode(primary.adminCommand({
-    replSetTest: 1,
-    waitForDrainFinish: 'what state',
-}),
-                             ErrorCodes.TypeMismatch,
-                             'replSetTest waitForDrainFinish should fail on non-numerical timeout');
-
-assert.commandFailedWithCode(primary.adminCommand({
-    replSetTest: 1,
-    waitForDrainFinish: -1000,
-}),
-                             ErrorCodes.BadValue,
-                             'replSetTest waitForDrainFinish should fail on negative timeout');
-
-assert.commandWorked(primary.adminCommand({
-    replSetTest: 1,
-    waitForDrainFinish: 1000,
-}),
-                     'node 0' + primary.host + ' failed to wait for drain to finish');
-
-assert.commandWorked(secondary.adminCommand({
-    replSetTest: 1,
-    waitForDrainFinish: 0,
-}),
-                     'node 1' + primary.host + ' failed to wait for drain to finish');
 replSet.stopSet();
 })();
diff --git a/src/mongo/db/repl/repl_set_commands.cpp b/src/mongo/db/repl/repl_set_commands.cpp
index 22a42f2da65..e35ff6199d5 100644
--- a/src/mongo/db/repl/repl_set_commands.cpp
+++ b/src/mongo/db/repl/repl_set_commands.cpp
@@ -134,20 +134,6 @@ public:
 
             uassertStatusOK(status);
             return true;
-        } else if (cmdObj.hasElement("waitForDrainFinish")) {
-            long long timeoutMillis;
-            auto status = bsonExtractIntegerField(cmdObj, "waitForDrainFinish", &timeoutMillis);
-            uassertStatusOK(status);
-            Milliseconds timeout(timeoutMillis);
-            LOGV2(21575,
-                  "replSetTest: waiting {timeout} for applier buffer to finish draining",
-                  "replSetTest: waiting for applier buffer to finish draining",
-                  "timeout"_attr = timeout);
-
-            status = replCoord->waitForDrainFinish(timeout);
-
-            uassertStatusOK(status);
-            return true;
         } else if (cmdObj.hasElement("getLastStableRecoveryTimestamp")) {
             boost::optional<Timestamp> ts =
                 StorageInterface::get(getGlobalServiceContext())
diff --git a/src/mongo/db/repl/replication_coordinator.h b/src/mongo/db/repl/replication_coordinator.h
index b24b9e6f1d0..695b248f0ad 100644
--- a/src/mongo/db/repl/replication_coordinator.h
+++ b/src/mongo/db/repl/replication_coordinator.h
@@ -578,15 +578,6 @@ public:
     virtual void signalDrainComplete(OperationContext* opCtx, long long termWhenBufferIsEmpty) = 0;
 
     /**
-     * Waits duration of 'timeout' for applier to finish draining its buffer of operations.
-     * Returns OK if we are not in drain mode.
-     * Returns ErrorCodes::ExceededTimeLimit if we timed out waiting for the applier to drain its
-     * buffer.
-     * Returns ErrorCodes::BadValue if timeout is negative.
-     */
-    virtual Status waitForDrainFinish(Milliseconds timeout) = 0;
-
-    /**
      * Signals the sync source feedback thread to wake up and send a handshake and
      * replSetUpdatePosition command to our sync source.
      */
diff --git a/src/mongo/db/repl/replication_coordinator_impl.cpp b/src/mongo/db/repl/replication_coordinator_impl.cpp
index 8354d81f085..ddf6fb2c4f9 100644
--- a/src/mongo/db/repl/replication_coordinator_impl.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl.cpp
@@ -1228,21 +1228,6 @@ void ReplicationCoordinatorImpl::signalDrainComplete(OperationContext* opCtx,
     _externalState->startNoopWriter(_getMyLastAppliedOpTime_inlock());
 }
 
-Status ReplicationCoordinatorImpl::waitForDrainFinish(Milliseconds timeout) {
-    if (timeout < Milliseconds(0)) {
-        return Status(ErrorCodes::BadValue, "Timeout duration cannot be negative");
-    }
-
-    stdx::unique_lock<Latch> lk(_mutex);
-    auto pred = [this]() { return _applierState != ApplierState::Draining; };
-    if (!_drainFinishedCond.wait_for(lk, timeout.toSystemDuration(), pred)) {
-        return Status(ErrorCodes::ExceededTimeLimit,
-                      "Timed out waiting to finish draining applier buffer");
-    }
-
-    return Status::OK();
-}
-
 void ReplicationCoordinatorImpl::signalUpstreamUpdater() {
     _externalState->forwardSlaveProgress();
 }
diff --git a/src/mongo/db/repl/replication_coordinator_impl.h b/src/mongo/db/repl/replication_coordinator_impl.h
index 825be575b62..810e35ade42 100644
--- a/src/mongo/db/repl/replication_coordinator_impl.h
+++ b/src/mongo/db/repl/replication_coordinator_impl.h
@@ -214,8 +214,6 @@ public:
     virtual void signalDrainComplete(OperationContext* opCtx,
                                      long long termWhenBufferIsEmpty) override;
 
-    virtual Status waitForDrainFinish(Milliseconds timeout) override;
-
     virtual void signalUpstreamUpdater() override;
 
     virtual StatusWith<BSONObj> prepareReplSetUpdatePositionCommand() const override;
diff --git a/src/mongo/db/repl/replication_coordinator_impl_test.cpp b/src/mongo/db/repl/replication_coordinator_impl_test.cpp
index 00ebb66e380..79556868b01 100644
--- a/src/mongo/db/repl/replication_coordinator_impl_test.cpp
+++ b/src/mongo/db/repl/replication_coordinator_impl_test.cpp
@@ -1690,8 +1690,8 @@ TEST_F(ReplCoordTest, DrainCompletionMidStepDown) {
     // Now wait for stepdown to complete
     getReplExec()->waitForEvent(updateTermEvh);
 
-    // By now drain mode should be cancelled.
-    ASSERT_OK(getReplCoord()->waitForDrainFinish(Milliseconds(0)));
+    // By now, the node should have left drain mode.
+    ASSERT(ReplicationCoordinator::ApplierState::Draining != getReplCoord()->getApplierState());
 
     ASSERT_TRUE(getReplCoord()->getMemberState().secondary());
     // ASSERT_EQUALS(2, getReplCoord()->getTerm()); // SERVER-28290
@@ -7279,43 +7279,6 @@ TEST_F(ReplCoordTest, WaitForMemberState) {
                   replCoord->waitForMemberState(MemberState::RS_ARBITER, Milliseconds(0)));
 }
 
-TEST_F(ReplCoordTest, WaitForDrainFinish) {
-    init("mySet");
-
-    assertStartSuccess(BSON("_id"
-                            << "mySet"
-                            << "version" << 1 << "members"
-                            << BSON_ARRAY(BSON("_id" << 0 << "host"
-                                                     << "test1:1234"))),
-                       HostAndPort("test1", 1234));
-    auto replCoord = getReplCoord();
-    auto initialTerm = replCoord->getTerm();
-    replCoordSetMyLastAppliedOpTime(OpTime(Timestamp(1, 1), 0), Date_t() + Seconds(100));
-    replCoordSetMyLastDurableOpTime(OpTime(Timestamp(1, 1), 0), Date_t() + Seconds(100));
-    ASSERT_OK(replCoord->setFollowerMode(MemberState::RS_SECONDARY));
-
-    // Single node cluster - this node should start election on setFollowerMode() completion.
-    replCoord->waitForElectionFinish_forTest();
-
-    // Successful dry run election increases term.
-    ASSERT_EQUALS(initialTerm + 1, replCoord->getTerm());
-
-    auto timeout = Milliseconds(1);
-    ASSERT_OK(replCoord->waitForMemberState(MemberState::RS_PRIMARY, timeout));
-
-    ASSERT(replCoord->getApplierState() == ReplicationCoordinator::ApplierState::Draining);
-    ASSERT_EQUALS(ErrorCodes::ExceededTimeLimit, replCoord->waitForDrainFinish(timeout));
-
-    ASSERT_EQUALS(ErrorCodes::BadValue, replCoord->waitForDrainFinish(Milliseconds(-1)));
-
-    const auto opCtx = makeOperationContext();
-    signalDrainComplete(opCtx.get());
-    ASSERT_OK(replCoord->waitForDrainFinish(timeout));
-
-    // Zero timeout is fine.
-    ASSERT_OK(replCoord->waitForDrainFinish(Milliseconds(0)));
-}
-
 TEST_F(
     ReplCoordTest,
     PopulateUnsetWriteConcernOptionsSyncModeReturnsInputWithSyncModeNoneIfUnsetAndWriteConcernMajorityJournalDefaultIsFalse) {
diff --git a/src/mongo/db/repl/replication_coordinator_mock.cpp b/src/mongo/db/repl/replication_coordinator_mock.cpp
index c741d932517..e033b375ff0 100644
--- a/src/mongo/db/repl/replication_coordinator_mock.cpp
+++ b/src/mongo/db/repl/replication_coordinator_mock.cpp
@@ -352,11 +352,6 @@ ReplicationCoordinator::ApplierState ReplicationCoordinatorMock::getApplierState
 
 void ReplicationCoordinatorMock::signalDrainComplete(OperationContext*, long long) {}
 
-Status ReplicationCoordinatorMock::waitForDrainFinish(Milliseconds timeout) {
-    MONGO_UNREACHABLE;
-    return Status::OK();
-}
-
 void ReplicationCoordinatorMock::signalUpstreamUpdater() {}
 
 StatusWith<BSONObj> ReplicationCoordinatorMock::prepareReplSetUpdatePositionCommand() const {
diff --git a/src/mongo/db/repl/replication_coordinator_mock.h b/src/mongo/db/repl/replication_coordinator_mock.h
index a46869e2998..8b2fb0e528a 100644
--- a/src/mongo/db/repl/replication_coordinator_mock.h
+++ b/src/mongo/db/repl/replication_coordinator_mock.h
@@ -181,8 +181,6 @@ public:
 
     virtual void signalDrainComplete(OperationContext*, long long);
 
-    virtual Status waitForDrainFinish(Milliseconds timeout) override;
-
     virtual void signalUpstreamUpdater();
 
     virtual StatusWith<BSONObj> prepareReplSetUpdatePositionCommand() const override;
diff --git a/src/mongo/db/repl/replication_coordinator_noop.cpp b/src/mongo/db/repl/replication_coordinator_noop.cpp
index 8574f078b64..27b3ac94760 100644
--- a/src/mongo/db/repl/replication_coordinator_noop.cpp
+++ b/src/mongo/db/repl/replication_coordinator_noop.cpp
@@ -191,10 +191,6 @@ void ReplicationCoordinatorNoOp::signalDrainComplete(OperationContext*, long lon
     MONGO_UNREACHABLE;
 }
 
-Status ReplicationCoordinatorNoOp::waitForDrainFinish(Milliseconds) {
-    MONGO_UNREACHABLE;
-}
-
 void ReplicationCoordinatorNoOp::signalUpstreamUpdater() {
     MONGO_UNREACHABLE;
 }
diff --git a/src/mongo/db/repl/replication_coordinator_noop.h b/src/mongo/db/repl/replication_coordinator_noop.h
index 0256dbe098a..d6066255c21 100644
--- a/src/mongo/db/repl/replication_coordinator_noop.h
+++ b/src/mongo/db/repl/replication_coordinator_noop.h
@@ -160,8 +160,6 @@ public:
 
     void signalDrainComplete(OperationContext*, long long) final;
 
-    Status waitForDrainFinish(Milliseconds) final;
-
     void signalUpstreamUpdater() final;
 
     StatusWith<BSONObj> prepareReplSetUpdatePositionCommand() const final;
diff --git a/src/mongo/embedded/replication_coordinator_embedded.cpp b/src/mongo/embedded/replication_coordinator_embedded.cpp
index 4f3d139b21a..6c7c5672efd 100644
--- a/src/mongo/embedded/replication_coordinator_embedded.cpp
+++ b/src/mongo/embedded/replication_coordinator_embedded.cpp
@@ -197,10 +197,6 @@ void ReplicationCoordinatorEmbedded::signalDrainComplete(OperationContext*, long
     UASSERT_NOT_IMPLEMENTED;
 }
 
-Status ReplicationCoordinatorEmbedded::waitForDrainFinish(Milliseconds) {
-    UASSERT_NOT_IMPLEMENTED;
-}
-
 void ReplicationCoordinatorEmbedded::signalUpstreamUpdater() {
     UASSERT_NOT_IMPLEMENTED;
 }
diff --git a/src/mongo/embedded/replication_coordinator_embedded.h b/src/mongo/embedded/replication_coordinator_embedded.h
index 3edb3dac0ae..068d0e23359 100644
--- a/src/mongo/embedded/replication_coordinator_embedded.h
+++ b/src/mongo/embedded/replication_coordinator_embedded.h
@@ -167,8 +167,6 @@ public:
 
     void signalDrainComplete(OperationContext*, long long) override;
 
-    Status waitForDrainFinish(Milliseconds) override;
-
     void signalUpstreamUpdater() override;
 
     StatusWith<BSONObj> prepareReplSetUpdatePositionCommand() const override;