SERVER-78880 Remove special version-handling of routerWaitInHello and shardWaitInHello (#27488)

GitOrigin-RevId: 278571b2acf2ab45b1de3dfe6a232b7dd930871e

Author: gracicot

jstests/hooks/run_cleanup_hello_failures.js

@@ -1,15 +1,13 @@
 import {DiscoverTopology, Topology} from "jstests/libs/discover_topology.js";
-import {getFailPointName} from "jstests/libs/fail_point_util.js";
 import {FixtureHelpers} from "jstests/libs/fixture_helpers.js";
 
 function cleanupHelloFailInjection(connection) {
     jsTestLog(`Cleanup Hello fail injection in ${connection}`);
     let adminDB = connection.getDB('admin');
-    const fpName = getFailPointName("shardWaitInHello", connection.getMaxWireVersion());
-    assert.commandWorked(adminDB.runCommand({configureFailPoint: fpName, mode: "off"}));
-    const prefixedName = `failpoint.${fpName}`;
-    const res = assert.commandWorked(adminDB.runCommand({getParameter: 1, [prefixedName]: 1}));
-    assert.eq(res[`failpoint.${fpName}`].mode, 0);
+    assert.commandWorked(adminDB.runCommand({configureFailPoint: "shardWaitInHello", mode: "off"}));
+    const res = assert.commandWorked(
+        adminDB.runCommand({getParameter: 1, "failpoint.shardWaitInHello": 1}));
+    assert.eq(res[`failpoint.shardWaitInHello`].mode, 0);
 }
 
 function doFailInjectionCleanup(db) {

jstests/hooks/run_inject_hello_failures.js

@@ -1,5 +1,3 @@
-import {getFailPointName} from "jstests/libs/fail_point_util.js";
-
 // Interval between test loops.
 const kTestLoopPeriodMs = 20 * 1000;
 
@@ -76,16 +74,14 @@ function injectReduceRefreshPeriod(connection) {
 function injectHelloFail(connection) {
     jsTestLog(`Inject Hello fail to connection ${connection}`);
     const adminDB = getAdminDB(connection);
-    const fpName = getFailPointName("shardWaitInHello", connection.getMaxWireVersion());
     assert.commandWorked(adminDB.runCommand({
-        configureFailPoint: fpName,
+        configureFailPoint: "shardWaitInHello",
         mode: "alwaysOn",
         data: {internalClient: 1}  // No effect if client is mongo shell.
     }));
-    const prefixedName = `failpoint.${fpName}`;
-    const res = adminDB.runCommand({getParameter: 1, [prefixedName]: 1});
+    const res = adminDB.runCommand({getParameter: 1, "failpoint.shardWaitInHello": 1});
     assert.commandWorked(res);
-    assert.eq(res[`failpoint.${fpName}`].mode, 1);
+    assert.eq(res["failpoint.shardWaitInHello"].mode, 1);
 }
 
 function freeze(connection) {

jstests/libs/fail_point_util.js

@@ -9,12 +9,6 @@ export var configureFailPoint;
 export var configureFailPointForRS;
 export var kDefaultWaitForFailPointTimeout;
 
-/**
- * Utility to get the correct name of a fail point given the name of the fail point on the main
- * branch and the wire-version of the server you are speaking to.
- */
-export var getFailPointName;
-
 (function() {
 if (configureFailPoint) {
     return;  // Protect against this file being double-loaded.
@@ -127,27 +121,4 @@ configureFailPointForRS = function(conns, failPointName, data = {}, failPointMod
         }
     };
 };
-
-// Add an entry to this map if you are changing the name of an existing fail point.
-// Key is name of the failpoint on master. Value is a function taking wireVersion
-// that returns the correct name of the fail point on that wireVersion.
-const kWireVersion73 = 24;
-const failPointRenameTable = {
-    "routerWaitInHello": function(wireVersion) {
-        if (wireVersion >= kWireVersion73) {
-            return "routerWaitInHello";
-        }
-        return "waitInHello";
-    },
-    "shardWaitInHello": function(wireVersion) {
-        if (wireVersion >= kWireVersion73) {
-            return "shardWaitInHello";
-        }
-        return "waitInHello";
-    }
-};
-
-getFailPointName = function(failPointNameOnMain, wireVersion) {
-    return failPointRenameTable[failPointNameOnMain](wireVersion);
-};
 })();

jstests/noPassthrough/architecture/set_step_params.js

@@ -3,7 +3,7 @@
  */
 
 import {assertHasConnPoolStats, launchFinds} from "jstests/libs/conn_pool_helpers.js";
-import {configureFailPointForRS, getFailPointName} from "jstests/libs/fail_point_util.js";
+import {configureFailPointForRS} from "jstests/libs/fail_point_util.js";
 import {ShardingTest} from "jstests/libs/shardingtest.js";
 
 const kDbName = 'test';
@@ -33,7 +33,6 @@ const cfg = primary.getDB('local').system.replset.findOne();
 const allHosts = cfg.members.map(x => x.host);
 const mongosDB = mongos.getDB(kDbName);
 const primaryOnly = [primary.name];
-const waitInHelloFpName = getFailPointName("shardWaitInHello", mongos.getMaxWireVersion());
 
 var threads = [];
 var currentCheckNum = 0;
@@ -133,7 +132,7 @@ runSubTest("MaxConnecting", function() {
                                 "waitInFindBeforeMakingBatch",
                                 {shouldCheckForInterrupt: true, nss: kDbName + ".test"});
     const fpHelloRs =
-        configureFailPointForRS(st.rs0.nodes, waitInHelloFpName, {shouldCheckForInterrupt: true});
+        configureFailPointForRS(st.rs0.nodes, "shardWaitInHello", {shouldCheckForInterrupt: true});
     dropConnections();
 
     // Go to the limit of maxConnecting, so we're stuck here
@@ -202,7 +201,7 @@ runSubTest("Timeouts", function() {
 
     // Block refreshes and wait for the toRefresh timeout
     const fpHelloRs =
-        configureFailPointForRS(st.rs0.nodes, waitInHelloFpName, {shouldCheckForInterrupt: true});
+        configureFailPointForRS(st.rs0.nodes, "shardWaitInHello", {shouldCheckForInterrupt: true});
     sleep(toRefreshTimeoutMS);
 
     // Confirm that we're in pending for all of our conns

jstests/noPassthrough/replication/awaitable_hello.js

@@ -3,7 +3,7 @@
  * isMaster and ismaster.
  * @tags: [requires_replication]
  */
-import {configureFailPoint, getFailPointName} from "jstests/libs/fail_point_util.js";
+import {configureFailPoint} from "jstests/libs/fail_point_util.js";
 import {funWithArgs} from "jstests/libs/parallel_shell_helpers.js";
 import {ReplSetTest} from "jstests/libs/replsettest.js";
 import {ShardingTest} from "jstests/libs/shardingtest.js";
@@ -200,27 +200,26 @@ function runTest(db, cmd, logFailpoint, failpointName) {
 
 // Set command log verbosity to 0 to avoid logging *all* commands in the "slow query" log.
 const conn = MongoRunner.runMongod({setParameter: {logComponentVerbosity: tojson({command: 0})}});
-const shardWaitInHello = getFailPointName("shardWaitInHello", conn.getMaxWireVersion());
 assert.neq(null, conn, "mongod was unable to start up");
-runTest(conn.getDB("admin"), "hello", "waitForHelloCommandLogged", shardWaitInHello);
-runTest(conn.getDB("admin"), "isMaster", "waitForIsMasterCommandLogged", shardWaitInHello);
-runTest(conn.getDB("admin"), "ismaster", "waitForIsMasterCommandLogged", shardWaitInHello);
+runTest(conn.getDB("admin"), "hello", "waitForHelloCommandLogged", "shardWaitInHello");
+runTest(conn.getDB("admin"), "isMaster", "waitForIsMasterCommandLogged", "shardWaitInHello");
+runTest(conn.getDB("admin"), "ismaster", "waitForIsMasterCommandLogged", "shardWaitInHello");
 MongoRunner.stopMongod(conn);
 
 const replTest = new ReplSetTest(
     {nodes: 1, nodeOptions: {setParameter: {logComponentVerbosity: tojson({command: 0})}}});
 replTest.startSet();
 replTest.initiate();
 runTest(
-    replTest.getPrimary().getDB("admin"), "hello", "waitForHelloCommandLogged", shardWaitInHello);
+    replTest.getPrimary().getDB("admin"), "hello", "waitForHelloCommandLogged", "shardWaitInHello");
 runTest(replTest.getPrimary().getDB("admin"),
         "isMaster",
         "waitForIsMasterCommandLogged",
-        shardWaitInHello);
+        "shardWaitInHello");
 runTest(replTest.getPrimary().getDB("admin"),
         "ismaster",
         "waitForIsMasterCommandLogged",
-        shardWaitInHello);
+        "shardWaitInHello");
 replTest.stopSet();
 
 const st = new ShardingTest({
@@ -229,8 +228,7 @@ const st = new ShardingTest({
     config: 1,
     other: {mongosOptions: {setParameter: {logComponentVerbosity: tojson({command: 0})}}}
 });
-const fpName = getFailPointName("routerWaitInHello", st.s.getMaxWireVersion());
-runTest(st.s.getDB("admin"), "hello", "waitForHelloCommandLogged", fpName);
-runTest(st.s.getDB("admin"), "isMaster", "waitForIsMasterCommandLogged", fpName);
-runTest(st.s.getDB("admin"), "ismaster", "waitForIsMasterCommandLogged", fpName);
+runTest(st.s.getDB("admin"), "hello", "waitForHelloCommandLogged", "routerWaitInHello");
+runTest(st.s.getDB("admin"), "isMaster", "waitForIsMasterCommandLogged", "routerWaitInHello");
+runTest(st.s.getDB("admin"), "ismaster", "waitForIsMasterCommandLogged", "routerWaitInHello");
 st.stop();

jstests/noPassthrough/replication/waitInHello_failpoint.js

@@ -1,7 +1,6 @@
 // Tests the shardWaitInHello and routerWaitInHello failpoints.
 // @tags: [requires_replication]
 import {configureFailPoint} from "jstests/libs/fail_point_util.js";
-import {getFailPointName} from "jstests/libs/fail_point_util.js";
 import {ReplSetTest} from "jstests/libs/replsettest.js";
 import {ShardingTest} from "jstests/libs/shardingtest.js";
 
@@ -31,16 +30,15 @@ function runTest(conn, fpName) {
 
 const standalone = MongoRunner.runMongod({});
 assert.neq(null, standalone, "mongod was unable to start up");
-runTest(standalone, getFailPointName("shardWaitInHello", standalone.getMaxWireVersion()));
+runTest(standalone, "shardWaitInHello");
 MongoRunner.stopMongod(standalone);
 
 const rst = new ReplSetTest({nodes: 1});
 rst.startSet();
 rst.initiate();
-runTest(rst.getPrimary(),
-        getFailPointName("shardWaitInHello", rst.getPrimary().getMaxWireVersion()));
+runTest(rst.getPrimary(), "shardWaitInHello");
 rst.stopSet();
 
 const st = new ShardingTest({mongos: 1, shards: [{nodes: 1}], config: 1});
-runTest(st.s, getFailPointName("routerWaitInHello", st.s.getMaxWireVersion()));
+runTest(st.s, "routerWaitInHello");
 st.stop();

jstests/noPassthroughWithMongod/ingress_handshake_and_auth_metrics.js

@@ -3,7 +3,6 @@
  *
  * @tags: [requires_fcv_70]
  */
-import {getFailPointName} from "jstests/libs/fail_point_util.js";
 import {ingressHandshakeMetricsTest} from "jstests/libs/ingress_handshake_metrics_helpers.js";
 
 let runTest = (connectionHealthLoggingOn) => {
@@ -18,7 +17,7 @@ let runTest = (connectionHealthLoggingOn) => {
         helloProcessingDelayMillis: 50,
         helloResponseDelayMillis: 100,
         rootCredentials: rootCreds,
-        helloFailPointName: getFailPointName("shardWaitInHello", conn.getMaxWireVersion()),
+        helloFailPointName: "shardWaitInHello",
     });
 
     jsTestLog("Connecting to mongod and running the test.");

jstests/sharding/awaitable_hello_primary_failures.js

@@ -16,7 +16,6 @@ TestData.skipCheckShardFilteringMetadata = true;
 
 import {configureFailPoint} from "jstests/libs/fail_point_util.js";
 import {awaitRSClientHosts} from "jstests/replsets/rslib.js";
-import {getFailPointName} from "jstests/libs/fail_point_util.js";
 import {ShardingTest} from "jstests/libs/shardingtest.js";
 
 let st = new ShardingTest({shards: {rs0: {nodes: 1}}});
@@ -29,8 +28,7 @@ awaitRSClientHosts(mongos, {host: rsPrimary.name}, {ok: true, ismaster: true});
 // Turn on the shardWaitInHello failpoint. This will cause the primary node to cease sending "hello"
 // responses and the RSM should mark the node as down
 jsTestLog("Turning on shardWaitInHello failpoint. Node should stop sending hello responses.");
-const helloFailpoint = configureFailPoint(
-    rsPrimary, getFailPointName("shardWaitInHello", rsPrimary.getMaxWireVersion()));
+const helloFailpoint = configureFailPoint(rsPrimary, "shardWaitInHello");
 awaitRSClientHosts(mongos, {host: rsPrimary.name}, {ok: false, ismaster: false});
 helloFailpoint.off();
 

jstests/sharding/ingress_handshake_and_auth_metrics_mongos.js

@@ -8,7 +8,6 @@
  *   embedded_router_incompatible,
  * ]
  */
-import {getFailPointName} from "jstests/libs/fail_point_util.js";
 import {ingressHandshakeMetricsTest} from "jstests/libs/ingress_handshake_metrics_helpers.js";
 import {ShardingTest} from "jstests/libs/shardingtest.js";
 
@@ -23,7 +22,7 @@ let runTest = (connectionHealthLoggingOn) => {
         postAuthDelayMillis: 100,
         helloProcessingDelayMillis: 50,
         helloResponseDelayMillis: 100,
-        helloFailPointName: getFailPointName("routerWaitInHello", conn.getMaxWireVersion()),
+        helloFailPointName: "routerWaitInHello",
     });
 
     jsTestLog("Connecting to mongos and running the test.");