Revert "SERVER-53423: Make ConnectString::connect return a status instead of setting error message"

This reverts commit ad1169d34cbd457a4d0637230e615bdf1d177531.

14 files changed, 175 insertions, 128 deletions

diff --git a/src/mongo/client/connection_string.h b/src/mongo/client/connection_string.h
index f6ee47df22b..d505e1e5d24 100644
--- a/src/mongo/client/connection_string.h
+++ b/src/mongo/client/connection_string.h
@@ -146,8 +146,9 @@ public:
     bool operator==(const ConnectionString& other) const;
     bool operator!=(const ConnectionString& other) const;
 
-    StatusWith<std::unique_ptr<DBClientBase>> connect(
+    std::unique_ptr<DBClientBase> connect(
         StringData applicationName,
+        std::string& errmsg,
         double socketTimeout = 0,
         const MongoURI* uri = nullptr,
         const ClientAPIVersionParameters* apiParameters = nullptr,
diff --git a/src/mongo/client/connection_string_connect.cpp b/src/mongo/client/connection_string_connect.cpp
index a4fa3eafd91..28cc448639c 100644
--- a/src/mongo/client/connection_string_connect.cpp
+++ b/src/mongo/client/connection_string_connect.cpp
@@ -46,8 +46,9 @@ namespace mongo {
 Mutex ConnectionString::_connectHookMutex = MONGO_MAKE_LATCH();
 ConnectionString::ConnectionHook* ConnectionString::_connectHook = nullptr;
 
-StatusWith<std::unique_ptr<DBClientBase>> ConnectionString::connect(
+std::unique_ptr<DBClientBase> ConnectionString::connect(
     StringData applicationName,
+    std::string& errmsg,
     double socketTimeout,
     const MongoURI* uri,
     const ClientAPIVersionParameters* apiParameters,
@@ -59,9 +60,6 @@ StatusWith<std::unique_ptr<DBClientBase>> ConnectionString::connect(
 
     switch (_type) {
         case ConnectionType::kStandalone: {
-            Status lastError =
-                Status(ErrorCodes::BadValue,
-                       "Invalid standalone connection string with empty server list.");
             for (const auto& server : _servers) {
                 auto c = std::make_unique<DBClientConnection>(
                     true, 0, newURI, DBClientConnection::HandshakeValidationHook(), apiParameters);
@@ -72,17 +70,17 @@ StatusWith<std::unique_ptr<DBClientBase>> ConnectionString::connect(
                             "Creating new connection to: {hostAndPort}",
                             "Creating new connection",
                             "hostAndPort"_attr = server);
-                lastError = c->connect(
-                    server,
-                    applicationName,
-                    transientSSLParams ? boost::make_optional(*transientSSLParams) : boost::none);
-                if (!lastError.isOK()) {
+                if (!c->connect(server,
+                                applicationName,
+                                errmsg,
+                                transientSSLParams ? boost::make_optional(*transientSSLParams)
+                                                   : boost::none)) {
                     continue;
                 }
                 LOGV2_DEBUG(20110, 1, "Connected connection!");
                 return std::move(c);
             }
-            return lastError;
+            return nullptr;
         }
 
         case ConnectionType::kReplicaSet: {
@@ -92,9 +90,10 @@ StatusWith<std::unique_ptr<DBClientBase>> ConnectionString::connect(
                                                             socketTimeout,
                                                             std::move(newURI),
                                                             apiParameters);
-            auto status = set->connect();
-            if (!status.isOK()) {
-                return status.withReason(status.reason() + ", " + toString());
+            if (!set->connect()) {
+                errmsg = "connect failed to replica set ";
+                errmsg += toString();
+                return nullptr;
             }
             return std::move(set);
         }
@@ -111,7 +110,6 @@ StatusWith<std::unique_ptr<DBClientBase>> ConnectionString::connect(
                     _connectHook);
 
             // Double-checked lock, since this will never be active during normal operation
-            std::string errmsg;
             auto replacementConn =
                 _connectHook->connect(*this, errmsg, socketTimeout, apiParameters);
 
@@ -122,10 +120,7 @@ StatusWith<std::unique_ptr<DBClientBase>> ConnectionString::connect(
                   "newConnString"_attr =
                       (replacementConn ? replacementConn->getServerAddress() : "(empty)"));
 
-            if (replacementConn) {
-                return std::move(replacementConn);
-            }
-            return Status(ErrorCodes::HostUnreachable, "Connection hook error: " + errmsg);
+            return replacementConn;
         }
 
         case ConnectionType::kLocal:
diff --git a/src/mongo/client/connpool.cpp b/src/mongo/client/connpool.cpp
index 946c5b8741d..e3a5a925636 100644
--- a/src/mongo/client/connpool.cpp
+++ b/src/mongo/client/connpool.cpp
@@ -389,12 +389,10 @@ DBClientBase* DBConnectionPool::_finishCreate(const string& ident,
 
 DBClientBase* DBConnectionPool::get(const ConnectionString& url, double socketTimeout) {
     auto connect = [&]() {
-        auto c = url.connect(StringData(), socketTimeout);
-        uassert(13328,
-                fmt::format(
-                    "{}: connect failed {} : {}", _name, url.toString(), c.getStatus().reason()),
-                c.isOK());
-        return c.getValue().release();
+        string errmsg;
+        auto c = url.connect(StringData(), errmsg, socketTimeout).release();
+        uassert(13328, _name + ": connect failed " + url.toString() + " : " + errmsg, c);
+        return c;
     };
 
     return Detail::get(this, url.toString(), socketTimeout, connect);
@@ -404,14 +402,15 @@ DBClientBase* DBConnectionPool::get(const string& host, double socketTimeout) {
     auto connect = [&] {
         const ConnectionString cs(uassertStatusOK(ConnectionString::parse(host)));
 
-        auto swConn = cs.connect(StringData(), socketTimeout);
-        if (!swConn.isOK()) {
+        string errmsg;
+        auto c = cs.connect(StringData(), errmsg, socketTimeout).release();
+        if (!c) {
             throwSocketError(SocketErrorKind::CONNECT_ERROR,
                              host,
-                             fmt::format("{} error: {}", _name, swConn.getStatus().reason()));
+                             str::stream() << _name << " error: " << errmsg);
         }
 
-        return swConn.getValue().release();
+        return c;
     };
 
     return Detail::get(this, host, socketTimeout, connect);
@@ -421,7 +420,7 @@ DBClientBase* DBConnectionPool::get(const MongoURI& uri, double socketTimeout) {
     auto connect = [&] {
         string errmsg;
         std::unique_ptr<DBClientBase> c(uri.connect(uri.getAppName().get(), errmsg, socketTimeout));
-        uassert(40356, fmt::format("{}: connect failed {} : {}", _name, uri.toString(), errmsg), c);
+        uassert(40356, _name + ": connect failed " + uri.toString() + " : " + errmsg, c);
         return c.release();
     };
 
diff --git a/src/mongo/client/dbclient_connection_integration_test.cpp b/src/mongo/client/dbclient_connection_integration_test.cpp
index a8a84643a0d..0635047dd33 100644
--- a/src/mongo/client/dbclient_connection_integration_test.cpp
+++ b/src/mongo/client/dbclient_connection_integration_test.cpp
@@ -45,11 +45,15 @@ constexpr StringData kAppName = "DBClientConnectionTest"_sd;
 class DBClientConnectionFixture : public unittest::Test {
 public:
     static std::unique_ptr<DBClientConnection> makeConn(StringData name = kAppName) {
-        auto swConn = unittest::getFixtureConnectionString().connect(name);
-        uassertStatusOK(swConn.getStatus());
-
-        auto conn = dynamic_cast<DBClientConnection*>(swConn.getValue().release());
-        return std::unique_ptr<DBClientConnection>{conn};
+        std::string errMsg;
+        auto connHolder = std::unique_ptr<DBClientBase>(
+            unittest::getFixtureConnectionString().connect(name, errMsg));
+        uassert(ErrorCodes::SocketException, errMsg, connHolder);
+
+        auto conn = dynamic_cast<DBClientConnection*>(connHolder.get());
+        invariant(conn);
+        connHolder.release();
+        return std::unique_ptr<DBClientConnection>(conn);
     }
 
     void tearDown() override {
diff --git a/src/mongo/client/dbclient_rs.cpp b/src/mongo/client/dbclient_rs.cpp
index c0aa64f50d5..acd2f116d7f 100644
--- a/src/mongo/client/dbclient_rs.cpp
+++ b/src/mongo/client/dbclient_rs.cpp
@@ -419,13 +419,13 @@ DBClientConnection& DBClientReplicaSet::secondaryConn() {
     return *conn;
 }
 
-Status DBClientReplicaSet::connect() {
+bool DBClientReplicaSet::connect() {
     // Returns true if there are any up hosts.
     const ReadPreferenceSetting anyUpHost(ReadPreference::Nearest, TagSet());
     return _getMonitor()
         ->getHostOrRefresh(anyUpHost, CancelationToken::uncancelable())
         .getNoThrow()
-        .getStatus();
+        .isOK();
 }
 
 template <typename Authenticate>
diff --git a/src/mongo/client/dbclient_rs.h b/src/mongo/client/dbclient_rs.h
index 414e5190226..733eddb0dc3 100644
--- a/src/mongo/client/dbclient_rs.h
+++ b/src/mongo/client/dbclient_rs.h
@@ -71,11 +71,11 @@ public:
                        const ClientAPIVersionParameters* apiParameters = nullptr);
 
     /**
-     * Returns a non-OK status if no member of the set were reachable. This object
-     * can still be used even when non-OK status was returned as it will try to
+     * Returns false if no member of the set were reachable. This object
+     * can still be used even when false was returned as it will try to
      * reconnect when you use it later.
      */
-    Status connect();
+    bool connect();
 
     Status authenticateInternalUser(auth::StepDownBehavior stepDownBehavior) override;
 
diff --git a/src/mongo/client/mongo_uri_connect.cpp b/src/mongo/client/mongo_uri_connect.cpp
index 331ec055119..fc11a7eb9ce 100644
--- a/src/mongo/client/mongo_uri_connect.cpp
+++ b/src/mongo/client/mongo_uri_connect.cpp
@@ -51,29 +51,27 @@ DBClientBase* MongoURI::connect(StringData applicationName,
         }
     }
 
-    auto swConn = _connectString.connect(
-        applicationName, socketTimeoutSecs.value_or(0.0), this, apiParameters);
-    if (!swConn.isOK()) {
-        errmsg = swConn.getStatus().reason();
+    auto ret = std::unique_ptr<DBClientBase>(_connectString.connect(
+        applicationName, errmsg, socketTimeoutSecs.value_or(0.0), this, apiParameters));
+    if (!ret) {
         return nullptr;
     }
 
     if (!getSetName().empty()) {
         // When performing initial topology discovery, don't bother authenticating
         // since we will be immediately restarting our connect loop to a single node.
-        return swConn.getValue().release();
+        return ret.release();
     }
 
-    auto connection = std::move(swConn.getValue());
-    if (!connection->authenticatedDuringConnect()) {
-        auto optAuthObj = makeAuthObjFromOptions(connection->getMaxWireVersion(),
-                                                 connection->getIsPrimarySaslMechanisms());
+    if (!ret->authenticatedDuringConnect()) {
+        auto optAuthObj =
+            makeAuthObjFromOptions(ret->getMaxWireVersion(), ret->getIsPrimarySaslMechanisms());
         if (optAuthObj) {
-            connection->auth(optAuthObj.get());
+            ret->auth(optAuthObj.get());
         }
     }
 
-    return connection.release();
+    return ret.release();
 }
 
 }  // namespace mongo
diff --git a/src/mongo/db/cloner.cpp b/src/mongo/db/cloner.cpp
index a9b766af99e..20fd51253cf 100644
--- a/src/mongo/db/cloner.cpp
+++ b/src/mongo/db/cloner.cpp
@@ -462,11 +462,11 @@ Status Cloner::copyDb(OperationContext* opCtx,
     }
 
     // Set up connection.
-    auto swConn = cs.connect(StringData());
-    if (!swConn.isOK()) {
-        return swConn.getStatus();
+    std::string errmsg;
+    std::unique_ptr<DBClientBase> conn(cs.connect(StringData(), errmsg));
+    if (!conn.get()) {
+        return Status(ErrorCodes::HostUnreachable, errmsg);
     }
-    auto& conn = swConn.getValue();
 
     if (auth::isInternalAuthSet()) {
         auto authStatus = conn->authenticateInternalUser();
diff --git a/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp b/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp
index 600b7e465f7..a9f12041aad 100644
--- a/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp
+++ b/src/mongo/db/exhaust_cursor_currentop_integration_test.cpp
@@ -53,9 +53,10 @@ const NamespaceString testNSS{"exhaust_cursor_currentop.testColl"};
 
 const StringData testAppName = "curop_exhaust_cursor_test";
 std::unique_ptr<DBClientBase> connect(StringData appName = testAppName) {
-    auto swConn = unittest::getFixtureConnectionString().connect(appName.toString());
-    uassertStatusOK(swConn.getStatus());
-    return std::move(swConn.getValue());
+    std::string errMsg;
+    auto conn = unittest::getFixtureConnectionString().connect(appName.toString(), errMsg);
+    uassert(ErrorCodes::SocketException, errMsg, conn);
+    return conn;
 }
 const StringData testBackgroundAppName = "curop_exhaust_cursor_test_bg";
 
diff --git a/src/mongo/db/ops/write_ops_document_stream_integration_test.cpp b/src/mongo/db/ops/write_ops_document_stream_integration_test.cpp
index e27bc4fd5d3..4cd0a41a7d7 100644
--- a/src/mongo/db/ops/write_ops_document_stream_integration_test.cpp
+++ b/src/mongo/db/ops/write_ops_document_stream_integration_test.cpp
@@ -39,9 +39,10 @@
 namespace mongo {
 
 TEST(WriteOpsDocSeq, InsertDocStreamWorks) {
-    auto swConn = unittest::getFixtureConnectionString().connect("integration_test");
-    uassertStatusOK(swConn.getStatus());
-    auto conn = std::move(swConn.getValue());
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     NamespaceString ns("test", "doc_seq");
     conn->dropCollection(ns.ns());
diff --git a/src/mongo/db/repl/tenant_migration_recipient_service.cpp b/src/mongo/db/repl/tenant_migration_recipient_service.cpp
index 854192436bc..e2cf7f52888 100644
--- a/src/mongo/db/repl/tenant_migration_recipient_service.cpp
+++ b/src/mongo/db/repl/tenant_migration_recipient_service.cpp
@@ -271,27 +271,34 @@ std::unique_ptr<DBClientConnection> TenantMigrationRecipientService::Instance::_
     const HostAndPort& serverAddress,
     StringData applicationName,
     const TransientSSLParams* transientSSLParams) {
+    std::string errMsg;
     auto clientBase = ConnectionString(serverAddress)
                           .connect(applicationName,
+                                   errMsg,
                                    0 /* socketTimeout */,
                                    nullptr /* uri */,
                                    nullptr /* apiParameters */,
                                    transientSSLParams);
-    if (!clientBase.isOK()) {
+    if (!clientBase) {
         LOGV2_ERROR(4880400,
                     "Failed to connect to migration donor",
                     "tenantId"_attr = getTenantId(),
                     "migrationId"_attr = getMigrationUUID(),
                     "serverAddress"_attr = serverAddress,
                     "applicationName"_attr = applicationName,
-                    "error"_attr = clientBase.getStatus());
-        uassertStatusOK(clientBase.getStatus());
+                    "error"_attr = errMsg);
+        // TODO (SERVER-53423): Make ConnectString::connect return a status instead of setting error
+        // message
+        uasserted(errMsg.find("InvalidSSLConfiguration") != std::string::npos
+                      ? ErrorCodes::InvalidSSLConfiguration
+                      : ErrorCodes::HostUnreachable,
+                  errMsg);
     }
 
     // ConnectionString::connect() always returns a DBClientConnection in a unique_ptr of
     // DBClientBase type.
     std::unique_ptr<DBClientConnection> client(
-        checked_cast<DBClientConnection*>(clientBase.getValue().release()));
+        checked_cast<DBClientConnection*>(clientBase.release()));
 
     if (MONGO_likely(!skipTenantMigrationRecipientAuth.shouldFail())) {
         client->auth(auth::createInternalX509AuthDocument());
diff --git a/src/mongo/executor/task_executor_cursor_integration_test.cpp b/src/mongo/executor/task_executor_cursor_integration_test.cpp
index f145d67826e..f5ad9b62397 100644
--- a/src/mongo/executor/task_executor_cursor_integration_test.cpp
+++ b/src/mongo/executor/task_executor_cursor_integration_test.cpp
@@ -73,9 +73,8 @@ TEST_F(TaskExecutorCursorFixture, Basic) {
     auto opCtx = client->makeOperationContext();
 
     // Write 100 documents to "test.test" via dbclient
-    auto swConn = unittest::getFixtureConnectionString().connect("TaskExecutorCursorTest");
-    uassertStatusOK(swConn.getStatus());
-    auto dbclient = std::move(swConn.getValue());
+    std::string err;
+    auto dbclient = unittest::getFixtureConnectionString().connect("TaskExecutorCursorTest", err);
 
     const size_t numDocs = 100;
 
diff --git a/src/mongo/rpc/op_msg_integration_test.cpp b/src/mongo/rpc/op_msg_integration_test.cpp
index 6d3bb094720..c3f285e46c5 100644
--- a/src/mongo/rpc/op_msg_integration_test.cpp
+++ b/src/mongo/rpc/op_msg_integration_test.cpp
@@ -46,7 +46,6 @@
 #include "mongo/util/scopeguard.h"
 
 namespace mongo {
-namespace {
 
 template <typename F>
 bool waitForCondition(F&& f) {
@@ -64,13 +63,6 @@ bool waitForCondition(F&& f) {
     return false;
 }
 
-std::unique_ptr<DBClientBase> getIntegrationTestConnection() {
-    auto swConn = unittest::getFixtureConnectionString().connect("integration_test");
-    uassertStatusOK(swConn.getStatus());
-    return std::move(swConn.getValue());
-}
-
-
 // Returns the connection name by filtering on the appName of a $currentOp command. If no result is
 // found, return an empty string.
 std::string getThreadNameByAppName(DBClientBase* conn, StringData appName) {
@@ -86,7 +78,10 @@ std::string getThreadNameByAppName(DBClientBase* conn, StringData appName) {
 }
 
 TEST(OpMsg, UnknownRequiredFlagClosesConnection) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     auto request = OpMsgRequest::fromDBAndBody("admin", BSON("ping" << 1)).serialize();
     OpMsg::setFlag(&request, 1u << 15);  // This should be the last required flag to be assigned.
@@ -96,7 +91,10 @@ TEST(OpMsg, UnknownRequiredFlagClosesConnection) {
 }
 
 TEST(OpMsg, UnknownOptionalFlagIsIgnored) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     auto request = OpMsgRequest::fromDBAndBody("admin", BSON("ping" << 1)).serialize();
     OpMsg::setFlag(&request, 1u << 31);  // This should be the last optional flag to be assigned.
@@ -108,7 +106,10 @@ TEST(OpMsg, UnknownOptionalFlagIsIgnored) {
 }
 
 TEST(OpMsg, FireAndForgetInsertWorks) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     conn->dropCollection("test.collection");
 
@@ -124,7 +125,10 @@ TEST(OpMsg, FireAndForgetInsertWorks) {
 }
 
 TEST(OpMsg, DocumentSequenceLargeDocumentMultiInsertWorks) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     conn->dropCollection("test.collection");
 
@@ -155,7 +159,10 @@ TEST(OpMsg, DocumentSequenceLargeDocumentMultiInsertWorks) {
 }
 
 TEST(OpMsg, DocumentSequenceMaxWriteBatchWorks) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     conn->dropCollection("test.collection");
 
@@ -275,7 +282,10 @@ TEST(OpMsg, CloseConnectionOnFireAndForgetNotWritablePrimaryError) {
 }
 
 TEST(OpMsg, DocumentSequenceReturnsWork) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     auto opMsgRequest = OpMsgRequest::fromDBAndBody("admin", BSON("echo" << 1));
     opMsgRequest.sequences.push_back({"example", {BSON("a" << 1), BSON("b" << 2)}});
@@ -316,7 +326,10 @@ void enableClientChecksum() {
 }
 
 void exhaustGetMoreTest(bool enableChecksum) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     // Only test exhaust against a standalone.
     if (conn->isReplicaSetMember() || conn->isMongos()) {
@@ -408,7 +421,10 @@ TEST(OpMsg, ServerHandlesExhaustGetMoreCorrectlyWithChecksum) {
 }
 
 TEST(OpMsg, FindIgnoresExhaust) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     // Only test exhaust against a standalone.
     if (conn->isReplicaSetMember() || conn->isMongos()) {
@@ -440,7 +456,10 @@ TEST(OpMsg, FindIgnoresExhaust) {
 }
 
 TEST(OpMsg, ServerDoesNotSetMoreToComeOnErrorInGetMore) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     // Only test exhaust against a standalone.
     if (conn->isReplicaSetMember() || conn->isMongos()) {
@@ -487,7 +506,10 @@ TEST(OpMsg, ServerDoesNotSetMoreToComeOnErrorInGetMore) {
 }
 
 TEST(OpMsg, MongosIgnoresExhaustForGetMore) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     if (!conn->isMongos()) {
         return;
@@ -536,9 +558,10 @@ TEST(OpMsg, MongosIgnoresExhaustForGetMore) {
 }
 
 TEST(OpMsg, ServerHandlesExhaustIsMasterCorrectly) {
-    auto swConn = unittest::getFixtureConnectionString().connect("integration_test");
-    uassertStatusOK(swConn.getStatus());
-    auto fixtureConn = std::move(swConn.getValue());
+    std::string errMsg;
+    auto fixtureConn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, fixtureConn);
     DBClientBase* conn = fixtureConn.get();
 
     if (fixtureConn->isReplicaSetMember()) {
@@ -598,9 +621,10 @@ TEST(OpMsg, ServerHandlesExhaustIsMasterCorrectly) {
 }
 
 TEST(OpMsg, ServerHandlesExhaustIsMasterWithTopologyChange) {
-    auto swConn = unittest::getFixtureConnectionString().connect("integration_test");
-    uassertStatusOK(swConn.getStatus());
-    auto fixtureConn = std::move(swConn.getValue());
+    std::string errMsg;
+    auto fixtureConn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, fixtureConn);
     DBClientBase* conn = fixtureConn.get();
 
     if (fixtureConn->isReplicaSetMember()) {
@@ -663,9 +687,10 @@ TEST(OpMsg, ServerHandlesExhaustIsMasterWithTopologyChange) {
 }
 
 TEST(OpMsg, ServerRejectsExhaustIsMasterWithoutMaxAwaitTimeMS) {
-    auto swConn = unittest::getFixtureConnectionString().connect("integration_test");
-    uassertStatusOK(swConn.getStatus());
-    auto fixtureConn = std::move(swConn.getValue());
+    std::string errMsg;
+    auto fixtureConn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, fixtureConn);
     DBClientBase* conn = fixtureConn.get();
 
     if (fixtureConn->isReplicaSetMember()) {
@@ -687,7 +712,10 @@ TEST(OpMsg, ServerRejectsExhaustIsMasterWithoutMaxAwaitTimeMS) {
 }
 
 void serverStatusCorrectlyShowsExhaustMetrics(std::string commandName) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     if (conn->isReplicaSetMember()) {
         // Don't run on replica sets as the RSM will use the streamable hello or isMaster protocol
@@ -729,9 +757,10 @@ void serverStatusCorrectlyShowsExhaustMetrics(std::string commandName) {
     ASSERT_OK(getStatusFromCommandResult(res));
 
     // Start a new connection to the server to check the serverStatus metrics.
-    auto conn2 =
-        std::move(unittest::getFixtureConnectionString().connect("integration_test").getValue());
-    uassert(ErrorCodes::SocketException, "connection failed", conn2);
+    std::string newErrMsg;
+    auto conn2 = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", newErrMsg));
+    uassert(ErrorCodes::SocketException, newErrMsg, conn2);
 
     auto serverStatusCmd = BSON("serverStatus" << 1);
     BSONObj serverStatusReply;
@@ -759,10 +788,11 @@ TEST(OpMsg, ServerStatusCorrectlyShowsExhaustIsMasterMetricsWithIsMasterAlias) {
 }
 
 void exhaustMetricSwitchingCommandNames(bool useLegacyCommandNameAtStart) {
+    std::string errMsg;
     const auto conn1AppName = "integration_test";
-    auto swConn1 = unittest::getFixtureConnectionString().connect(conn1AppName);
-    uassertStatusOK(swConn1.getStatus());
-    auto conn1 = std::move(swConn1.getValue());
+    auto conn1 = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect(conn1AppName, errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn1);
 
     if (conn1->isReplicaSetMember()) {
         // Don't run on replica sets as the RSM will use the streamable hello or isMaster protocol
@@ -809,9 +839,10 @@ void exhaustMetricSwitchingCommandNames(bool useLegacyCommandNameAtStart) {
     ASSERT_OK(getStatusFromCommandResult(res));
 
     // Start a new connection to the server to check the serverStatus metrics.
-    auto conn2 =
-        std::move(unittest::getFixtureConnectionString().connect("integration_test2").getValue());
-    uassert(ErrorCodes::SocketException, "connection failed", conn2);
+    std::string newErrMsg;
+    auto conn2 = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test2", newErrMsg));
+    uassert(ErrorCodes::SocketException, newErrMsg, conn2);
 
     std::string threadName;
     ASSERT(waitForCondition([&] {
@@ -896,10 +927,11 @@ TEST(OpMsg, ExhaustHelloMetricSwitchingCommandNames) {
 
 
 void exhaustMetricDecrementsOnNewOpAfterTerminatingExhaustStream(bool useLegacyCommandName) {
+    std::string errMsg;
     const auto conn1AppName = "integration_test";
-    auto swConn1 = unittest::getFixtureConnectionString().connect(conn1AppName);
-    uassertStatusOK(swConn1.getStatus());
-    auto conn1 = std::move(swConn1.getValue());
+    auto conn1 = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect(conn1AppName, errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn1);
 
     if (conn1->isReplicaSetMember()) {
         // Don't run on replica sets as the RSM will use the streamable hello or isMaster protocol
@@ -945,9 +977,10 @@ void exhaustMetricDecrementsOnNewOpAfterTerminatingExhaustStream(bool useLegacyC
     ASSERT_OK(getStatusFromCommandResult(res));
 
     // Start a new connection to the server to check the serverStatus metrics.
-    auto conn2 =
-        std::move(unittest::getFixtureConnectionString().connect("integration_test2").getValue());
-    uassert(ErrorCodes::SocketException, "connection 2 failed", conn2);
+    std::string newErrMsg;
+    auto conn2 = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test2", newErrMsg));
+    uassert(ErrorCodes::SocketException, newErrMsg, conn2);
 
     std::string threadName;
     ASSERT(waitForCondition([&] {
@@ -1009,10 +1042,11 @@ TEST(OpMsg, ExhaustHelloMetricDecrementsOnNewOpAfterTerminatingExhaustStream) {
 }
 
 void exhaustMetricOnNewExhaustAfterTerminatingExhaustStream(bool useLegacyCommandName) {
+    std::string errMsg;
     const auto conn1AppName = "integration_test";
-    auto swConn1 = unittest::getFixtureConnectionString().connect(conn1AppName);
-    uassertStatusOK(swConn1.getStatus());
-    auto conn1 = std::move(swConn1.getValue());
+    auto conn1 = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect(conn1AppName, errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn1);
 
     if (conn1->isReplicaSetMember()) {
         // Don't run on replica sets as the RSM will use the streamable hello or isMaster protocol
@@ -1058,9 +1092,10 @@ void exhaustMetricOnNewExhaustAfterTerminatingExhaustStream(bool useLegacyComman
     ASSERT_OK(getStatusFromCommandResult(res));
 
     // Start a new connection to the server to check the serverStatus metrics.
-    auto conn2 =
-        std::move(unittest::getFixtureConnectionString().connect("integration_test2").getValue());
-    uassert(ErrorCodes::SocketException, "connection failed", conn2);
+    std::string newErrMsg;
+    auto conn2 = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test2", newErrMsg));
+    uassert(ErrorCodes::SocketException, newErrMsg, conn2);
 
     std::string threadName;
     ASSERT(waitForCondition([&] {
@@ -1140,7 +1175,10 @@ TEST(OpMsg, ExhaustWithDBClientCursorBehavesCorrectly) {
     // correctly. The externally visible behavior should technically be the same as a non-exhaust
     // cursor. The exhaust cursor should ideally provide a performance win over non-exhaust, but we
     // don't measure that here.
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     // Only test exhaust against a standalone.
     if (conn->isReplicaSetMember() || conn->isMongos()) {
@@ -1190,7 +1228,10 @@ TEST(OpMsg, ExhaustWithDBClientCursorBehavesCorrectly) {
 
 void checksumTest(bool enableChecksum) {
     // The server replies with a checksum if and only if the request has a checksum.
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = std::unique_ptr<DBClientBase>(
+        unittest::getFixtureConnectionString().connect("integration_test", errMsg));
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     if (!enableChecksum) {
         disableClientChecksum();
@@ -1217,7 +1258,9 @@ TEST(OpMsg, ServerRepliesWithChecksumToRequestWithChecksum) {
 }
 
 TEST(OpMsg, ServerHandlesReallyLargeMessagesGracefully) {
-    auto conn = getIntegrationTestConnection();
+    std::string errMsg;
+    auto conn = unittest::getFixtureConnectionString().connect("integration_test", errMsg);
+    uassert(ErrorCodes::SocketException, errMsg, conn);
 
     auto buildInfo = conn->runCommand(OpMsgRequest::fromDBAndBody("admin", BSON("buildInfo" << 1)))
                          ->getCommandReply();
@@ -1256,10 +1299,9 @@ public:
             uri.setHelloOk(helloOk.get());
         }
 
-        auto swConn = connStr.connect(_appName, 0, &uri);
-        uassertStatusOK(swConn.getStatus());
-        auto conn = std::move(swConn.getValue());
-        uassert(ErrorCodes::SocketException, "connection failed", conn);
+        std::string errMsg;
+        auto conn = connStr.connect(_appName, errMsg, 0, &uri);
+        uassert(ErrorCodes::SocketException, errMsg, conn);
 
         _configureFailPoint(conn.get());
         return conn;
@@ -1318,5 +1360,4 @@ TEST(OpMsg, HelloOkCanBeDisabled) {
     ASSERT(!isHelloOk);
 }
 
-}  // namespace
 }  // namespace mongo
diff --git a/src/mongo/shell/shell_utils.cpp b/src/mongo/shell/shell_utils.cpp
index c6e0126b4ff..4fe70659c20 100644
--- a/src/mongo/shell/shell_utils.cpp
+++ b/src/mongo/shell/shell_utils.cpp
@@ -131,9 +131,10 @@ namespace {
 std::unique_ptr<DBClientBase> benchRunConfigCreateConnectionImplProvider(
     const BenchRunConfig& config) {
     const ConnectionString connectionString = uassertStatusOK(ConnectionString::parse(config.host));
-    auto swConn{connectionString.connect("BenchRun")};
-    uassert(16158, swConn.getStatus().reason(), swConn.isOK());
-    return std::move(swConn.getValue());
+    std::string errorMessage;
+    std::unique_ptr<DBClientBase> connection(connectionString.connect("BenchRun", errorMessage));
+    uassert(16158, errorMessage, connection);
+    return connection;
 }
 
 auto benchRunConfigCreateConnectionImplRegistration = MONGO_WEAK_FUNCTION_REGISTRATION(