SERVER-53420 Make transport Session source/sink/poll functions noexcept

1 files changed, 70 insertions, 56 deletions

diff --git a/src/mongo/transport/mock_session.h b/src/mongo/transport/mock_session.h
index b1ed38a9081..2b5eeefb35d 100644
--- a/src/mongo/transport/mock_session.h
+++ b/src/mongo/transport/mock_session.h
@@ -41,13 +41,67 @@
 namespace mongo {
 namespace transport {
 
-class MockSession : public Session {
+class MockSessionBase : public Session {
+public:
+    MockSessionBase() = default;
+
+    explicit MockSessionBase(HostAndPort remote,
+                             HostAndPort local,
+                             SockAddr remoteAddr,
+                             SockAddr localAddr)
+        : _remote(std::move(remote)),
+          _local(std::move(local)),
+          _remoteAddr(std::move(remoteAddr)),
+          _localAddr(std::move(localAddr)) {}
+
+    const HostAndPort& remote() const override {
+        return _remote;
+    }
+
+    const HostAndPort& local() const override {
+        return _local;
+    }
+
+    const SockAddr& remoteAddr() const override {
+        return _remoteAddr;
+    }
+
+    const SockAddr& localAddr() const override {
+        return _localAddr;
+    }
+
+    void cancelAsyncOperations(const BatonHandle& handle = nullptr) override {}
+
+    void setTimeout(boost::optional<Milliseconds>) override {}
+
+    bool isConnected() override {
+        return true;
+    }
+
+#ifdef MONGO_CONFIG_SSL
+    const SSLConfiguration* getSSLConfiguration() const override {
+        return nullptr;
+    }
+
+    const std::shared_ptr<SSLManagerInterface> getSSLManager() const override {
+        return nullptr;
+    }
+#endif
+
+private:
+    const HostAndPort _remote;
+    const HostAndPort _local;
+    const SockAddr _remoteAddr;
+    const SockAddr _localAddr;
+};
+
+class MockSession : public MockSessionBase {
     MockSession(const MockSession&) = delete;
     MockSession& operator=(const MockSession&) = delete;
 
 public:
     static std::shared_ptr<MockSession> create(TransportLayer* tl) {
-        std::shared_ptr<MockSession> handle(new MockSession(tl));
+        auto handle = std::make_shared<MockSession>(tl);
         return handle;
     }
 
@@ -56,8 +110,8 @@ public:
                                                SockAddr remoteAddr,
                                                SockAddr localAddr,
                                                TransportLayer* tl) {
-        std::shared_ptr<MockSession> handle(new MockSession(
-            std::move(remote), std::move(local), std::move(remoteAddr), std::move(localAddr), tl));
+        auto handle = std::make_shared<MockSession>(
+            std::move(remote), std::move(local), std::move(remoteAddr), std::move(localAddr), tl);
         return handle;
     }
 
@@ -65,29 +119,13 @@ public:
         return _tl;
     }
 
-    const HostAndPort& remote() const override {
-        return _remote;
-    }
-
-    const HostAndPort& local() const override {
-        return _local;
-    }
-
-    const SockAddr& remoteAddr() const override {
-        return _remoteAddr;
-    }
-
-    const SockAddr& localAddr() const override {
-        return _localAddr;
-    }
-
     void end() override {
         if (!_tl || !_tl->owns(id()))
             return;
         _tl->_sessions[id()].ended = true;
     }
 
-    StatusWith<Message> sourceMessage() override {
+    StatusWith<Message> sourceMessage() noexcept override {
         if (!_tl || _tl->inShutdown()) {
             return TransportLayer::ShutdownStatus;
         } else if (!_tl->owns(id())) {
@@ -99,15 +137,15 @@ public:
         return Message();  // Subclasses can do something different.
     }
 
-    Future<Message> asyncSourceMessage(const BatonHandle& handle = nullptr) override {
+    Future<Message> asyncSourceMessage(const BatonHandle& handle = nullptr) noexcept override {
         return Future<Message>::makeReady(sourceMessage());
     }
 
-    Status waitForData() override {
+    Status waitForData() noexcept override {
         return asyncWaitForData().getNoThrow();
     }
 
-    Future<void> asyncWaitForData() override {
+    Future<void> asyncWaitForData() noexcept override {
         auto fp = makePromiseFuture<void>();
         stdx::lock_guard<Latch> lk(_waitForDataMutex);
         _waitForDataQueue.emplace_back(std::move(fp.promise));
@@ -123,7 +161,7 @@ public:
         promise.emplaceValue();
     }
 
-    Status sinkMessage(Message message) override {
+    Status sinkMessage(Message message) noexcept override {
         if (!_tl || _tl->inShutdown()) {
             return TransportLayer::ShutdownStatus;
         } else if (!_tl->owns(id())) {
@@ -135,48 +173,24 @@ public:
         return Status::OK();
     }
 
-    Future<void> asyncSinkMessage(Message message, const BatonHandle& handle = nullptr) override {
+    Future<void> asyncSinkMessage(Message message,
+                                  const BatonHandle& handle = nullptr) noexcept override {
         return Future<void>::makeReady(sinkMessage(message));
     }
 
-    void cancelAsyncOperations(const BatonHandle& handle = nullptr) override {}
-
-    void setTimeout(boost::optional<Milliseconds>) override {}
-
-    bool isConnected() override {
-        return true;
-    }
-
-#ifdef MONGO_CONFIG_SSL
-    const SSLConfiguration* getSSLConfiguration() const override {
-        return nullptr;
-    }
-
-    const std::shared_ptr<SSLManagerInterface> getSSLManager() const override {
-        return nullptr;
-    }
-#endif
-
     explicit MockSession(TransportLayer* tl)
-        : _tl(checked_cast<TransportLayerMock*>(tl)), _remote(), _local() {}
+        : MockSessionBase(), _tl(checked_cast<TransportLayerMock*>(tl)) {}
     explicit MockSession(HostAndPort remote,
                          HostAndPort local,
                          SockAddr remoteAddr,
                          SockAddr localAddr,
                          TransportLayer* tl)
-        : _tl(checked_cast<TransportLayerMock*>(tl)),
-          _remote(std::move(remote)),
-          _local(std::move(local)),
-          _remoteAddr(std::move(remoteAddr)),
-          _localAddr(std::move(localAddr)) {}
+        : MockSessionBase(
+              std::move(remote), std::move(local), std::move(remoteAddr), std::move(localAddr)),
+          _tl(checked_cast<TransportLayerMock*>(tl)) {}
 
 protected:
-    TransportLayerMock* _tl;
-
-    HostAndPort _remote;
-    HostAndPort _local;
-    SockAddr _remoteAddr;
-    SockAddr _localAddr;
+    TransportLayerMock* const _tl;
 
     mutable Mutex _waitForDataMutex = MONGO_MAKE_LATCH("MockSession::_waitForDataMutex");
     std::list<Promise<void>> _waitForDataQueue;