SERVER-27750 Attach LogicalTimeMetadata to globalConnPool and shardConnectionPool

This also include refactor work to cleanup ShardingEgressMetadataHook api and allow ShardingConnectionHook to take EgressMetadataHookList.

9 files changed, 45 insertions, 49 deletions

diff --git a/src/mongo/s/client/sharding_connection_hook.cpp b/src/mongo/s/client/sharding_connection_hook.cpp
index 36cb24bf9fc..057a9de1c4d 100644
--- a/src/mongo/s/client/sharding_connection_hook.cpp
+++ b/src/mongo/s/client/sharding_connection_hook.cpp
@@ -48,8 +48,8 @@ namespace mongo {
 
 using std::string;
 
-ShardingConnectionHook::ShardingConnectionHook(
-    bool shardedConnections, std::unique_ptr<rpc::ShardingEgressMetadataHook> egressHook)
+ShardingConnectionHook::ShardingConnectionHook(bool shardedConnections,
+                                               std::unique_ptr<rpc::EgressMetadataHook> egressHook)
     : _shardedConnections(shardedConnections), _egressHook(std::move(egressHook)) {}
 
 void ShardingConnectionHook::onCreate(DBClientBase* conn) {
@@ -77,11 +77,9 @@ void ShardingConnectionHook::onCreate(DBClientBase* conn) {
             return _egressHook->readReplyMetadata(target, metadataObj);
         });
     }
-    conn->setRequestMetadataWriter(
-        [this](OperationContext* opCtx, BSONObjBuilder* metadataBob, StringData hostStringData) {
-            return _egressHook->writeRequestMetadata(
-                _shardedConnections, opCtx, hostStringData, metadataBob);
-        });
+    conn->setRequestMetadataWriter([this](OperationContext* opCtx, BSONObjBuilder* metadataBob) {
+        return _egressHook->writeRequestMetadata(opCtx, metadataBob);
+    });
 
 
     if (conn->type() == ConnectionString::MASTER) {
diff --git a/src/mongo/s/client/sharding_connection_hook.h b/src/mongo/s/client/sharding_connection_hook.h
index 02c300b026b..c344a0ba6cb 100644
--- a/src/mongo/s/client/sharding_connection_hook.h
+++ b/src/mongo/s/client/sharding_connection_hook.h
@@ -43,7 +43,7 @@ class DBClientBase;
 class ShardingConnectionHook : public DBConnectionHook {
 public:
     ShardingConnectionHook(bool shardedConnections,
-                           std::unique_ptr<rpc::ShardingEgressMetadataHook> egressHook);
+                           std::unique_ptr<rpc::EgressMetadataHook> egressHook);
 
     void onCreate(DBClientBase* conn) override;
     void onDestroy(DBClientBase* conn) override;
@@ -54,7 +54,7 @@ private:
 
     // Use the implementation of the metadata readers and writers in ShardingEgressMetadataHook,
     // since that is the hook for Network Interface ASIO and this hook is to be deprecated.
-    std::unique_ptr<rpc::ShardingEgressMetadataHook> _egressHook;
+    std::unique_ptr<rpc::EgressMetadataHook> _egressHook;
 };
 
 }  // namespace mongo
diff --git a/src/mongo/s/commands/dbclient_multi_command.cpp b/src/mongo/s/commands/dbclient_multi_command.cpp
index 2bceb5a4993..131c40d0b13 100644
--- a/src/mongo/s/commands/dbclient_multi_command.cpp
+++ b/src/mongo/s/commands/dbclient_multi_command.cpp
@@ -90,8 +90,7 @@ static void sayAsCmd(DBClientBase* conn, StringData dbName, const BSONObj& cmdOb
     metadataBob.appendElements(upconvertedMetadata);
     if (conn->getRequestMetadataWriter()) {
         conn->getRequestMetadataWriter()((haveClient() ? cc().getOperationContext() : nullptr),
-                                         &metadataBob,
-                                         conn->getServerAddress());
+                                         &metadataBob);
     }
 
     requestBuilder->setDatabase(dbName);
diff --git a/src/mongo/s/server.cpp b/src/mongo/s/server.cpp
index bd177748fcf..d3a797b3a49 100644
--- a/src/mongo/s/server.cpp
+++ b/src/mongo/s/server.cpp
@@ -207,7 +207,7 @@ static Status initializeSharding(OperationContext* opCtx) {
             auto hookList = stdx::make_unique<rpc::EgressMetadataHookList>();
             hookList->addHook(
                 stdx::make_unique<rpc::LogicalTimeMetadataHook>(opCtx->getServiceContext()));
-            hookList->addHook(stdx::make_unique<rpc::ShardingEgressMetadataHookForMongos>());
+            hookList->addHook(stdx::make_unique<rpc::ShardingEgressMetadataHookForMongos>(false));
             return hookList;
         },
         [](ShardingCatalogClient* catalogClient, std::unique_ptr<executor::TaskExecutor> executor) {
@@ -257,12 +257,20 @@ static ExitCode runMongosServer() {
         return EXIT_NET_ERROR;
     }
 
+    auto unshardedHookList = stdx::make_unique<rpc::EgressMetadataHookList>();
+    unshardedHookList->addHook(
+        stdx::make_unique<rpc::LogicalTimeMetadataHook>(getGlobalServiceContext()));
+    unshardedHookList->addHook(stdx::make_unique<rpc::ShardingEgressMetadataHookForMongos>(false));
+
     // Add sharding hooks to both connection pools - ShardingConnectionHook includes auth hooks
-    globalConnPool.addHook(new ShardingConnectionHook(
-        false, stdx::make_unique<rpc::ShardingEgressMetadataHookForMongos>()));
+    globalConnPool.addHook(new ShardingConnectionHook(false, std::move(unshardedHookList)));
+
+    auto shardedHookList = stdx::make_unique<rpc::EgressMetadataHookList>();
+    shardedHookList->addHook(
+        stdx::make_unique<rpc::LogicalTimeMetadataHook>(getGlobalServiceContext()));
+    shardedHookList->addHook(stdx::make_unique<rpc::ShardingEgressMetadataHookForMongos>(true));
 
-    shardConnectionPool.addHook(new ShardingConnectionHook(
-        true, stdx::make_unique<rpc::ShardingEgressMetadataHookForMongos>()));
+    shardConnectionPool.addHook(new ShardingConnectionHook(true, std::move(shardedHookList)));
 
     ReplicaSetMonitor::setAsynchronousConfigChangeHook(
         &ShardRegistry::replicaSetChangeConfigServerUpdateHook);
diff --git a/src/mongo/s/sharding_egress_metadata_hook.cpp b/src/mongo/s/sharding_egress_metadata_hook.cpp
index af263360a0d..cc4823a3384 100644
--- a/src/mongo/s/sharding_egress_metadata_hook.cpp
+++ b/src/mongo/s/sharding_egress_metadata_hook.cpp
@@ -50,15 +50,16 @@ namespace rpc {
 
 using std::shared_ptr;
 
-Status ShardingEgressMetadataHook::writeRequestMetadata(bool shardedConnection,
-                                                        OperationContext* opCtx,
-                                                        const StringData target,
+ShardingEgressMetadataHook::ShardingEgressMetadataHook(bool shardedConnection)
+    : _isShardedConnection(shardedConnection) {}
+
+Status ShardingEgressMetadataHook::writeRequestMetadata(OperationContext* opCtx,
                                                         BSONObjBuilder* metadataBob) {
     try {
         audit::writeImpersonatedUsersToMetadata(opCtx, metadataBob);
 
         ClientMetadataIsMasterState::writeToMetadata(opCtx, metadataBob);
-        if (!shardedConnection) {
+        if (!_isShardedConnection) {
             return Status::OK();
         }
         rpc::ConfigServerMetadata(_getConfigServerOpTime()).writeToMetadata(metadataBob);
@@ -68,13 +69,7 @@ Status ShardingEgressMetadataHook::writeRequestMetadata(bool shardedConnection,
     }
 }
 
-Status ShardingEgressMetadataHook::writeRequestMetadata(OperationContext* opCtx,
-                                                        const HostAndPort& target,
-                                                        BSONObjBuilder* metadataBob) {
-    return writeRequestMetadata(true, opCtx, target.toString(), metadataBob);
-}
-
-Status ShardingEgressMetadataHook::readReplyMetadata(const StringData replySource,
+Status ShardingEgressMetadataHook::readReplyMetadata(StringData replySource,
                                                      const BSONObj& metadataObj) {
     try {
         _saveGLEStats(metadataObj, replySource);
@@ -84,11 +79,6 @@ Status ShardingEgressMetadataHook::readReplyMetadata(const StringData replySourc
     }
 }
 
-Status ShardingEgressMetadataHook::readReplyMetadata(const HostAndPort& replySource,
-                                                     const BSONObj& metadataObj) {
-    return readReplyMetadata(replySource.toString(), metadataObj);
-}
-
 Status ShardingEgressMetadataHook::_advanceConfigOptimeFromShard(ShardId shardId,
                                                                  const BSONObj& metadataObj) {
     try {
diff --git a/src/mongo/s/sharding_egress_metadata_hook.h b/src/mongo/s/sharding_egress_metadata_hook.h
index 1c8849dcea3..87442ebe0f3 100644
--- a/src/mongo/s/sharding_egress_metadata_hook.h
+++ b/src/mongo/s/sharding_egress_metadata_hook.h
@@ -43,23 +43,14 @@ namespace rpc {
 
 class ShardingEgressMetadataHook : public rpc::EgressMetadataHook {
 public:
+    /**
+     * Pass true to shardedConnection if the hook is intended for connections with shard versions.
+     */
+    ShardingEgressMetadataHook(bool shardedConnection);
     virtual ~ShardingEgressMetadataHook() = default;
 
-    Status readReplyMetadata(const HostAndPort& replySource, const BSONObj& metadataObj) override;
-    Status writeRequestMetadata(OperationContext* opCtx,
-                                const HostAndPort& target,
-                                BSONObjBuilder* metadataBob) override;
-
-    // These overloaded methods exist to allow ShardingConnectionHook, which is soon to be
-    // deprecated, to use the logic in ShardingEgressMetadataHook instead of duplicating the
-    // logic. ShardingConnectionHook must provide the replySource and target as strings rather than
-    // HostAndPorts, since DBClientReplicaSet uses the hook before it decides on the actual host to
-    // contact.
-    Status readReplyMetadata(const StringData replySource, const BSONObj& metadataObj);
-    Status writeRequestMetadata(bool shardedConnection,
-                                OperationContext* opCtx,
-                                const StringData target,
-                                BSONObjBuilder* metadataBob);
+    Status readReplyMetadata(StringData replySource, const BSONObj& metadataObj) override;
+    Status writeRequestMetadata(OperationContext* opCtx, BSONObjBuilder* metadataBob) override;
 
 protected:
     /**
@@ -83,6 +74,9 @@ protected:
      * metadata in the response object from running a command.
      */
     virtual Status _advanceConfigOptimeFromShard(ShardId shardId, const BSONObj& metadataObj);
+
+private:
+    bool _isShardedConnection;
 };
 
 }  // namespace rpc
diff --git a/src/mongo/s/sharding_egress_metadata_hook_for_mongos.cpp b/src/mongo/s/sharding_egress_metadata_hook_for_mongos.cpp
index f355054f92b..1ae82a7c64e 100644
--- a/src/mongo/s/sharding_egress_metadata_hook_for_mongos.cpp
+++ b/src/mongo/s/sharding_egress_metadata_hook_for_mongos.cpp
@@ -41,6 +41,9 @@
 namespace mongo {
 namespace rpc {
 
+ShardingEgressMetadataHookForMongos::ShardingEgressMetadataHookForMongos(bool shardedConnection)
+    : ShardingEgressMetadataHook(shardedConnection) {}
+
 void ShardingEgressMetadataHookForMongos::_saveGLEStats(const BSONObj& metadata,
                                                         StringData hostString) {
     if (!haveClient()) {
diff --git a/src/mongo/s/sharding_egress_metadata_hook_for_mongos.h b/src/mongo/s/sharding_egress_metadata_hook_for_mongos.h
index 9cba4226df2..2e5bfe62434 100644
--- a/src/mongo/s/sharding_egress_metadata_hook_for_mongos.h
+++ b/src/mongo/s/sharding_egress_metadata_hook_for_mongos.h
@@ -34,6 +34,9 @@ namespace mongo {
 namespace rpc {
 
 class ShardingEgressMetadataHookForMongos final : public ShardingEgressMetadataHook {
+public:
+    ShardingEgressMetadataHookForMongos(bool shardedConnection);
+
 private:
     void _saveGLEStats(const BSONObj& metadata, StringData hostString) override;
 
diff --git a/src/mongo/s/sharding_test_fixture.cpp b/src/mongo/s/sharding_test_fixture.cpp
index 59d3762925f..4068545c113 100644
--- a/src/mongo/s/sharding_test_fixture.cpp
+++ b/src/mongo/s/sharding_test_fixture.cpp
@@ -108,14 +108,15 @@ void ShardingTestFixture::setUp() {
 
     // Set up executor pool used for most operations.
     auto fixedNet = stdx::make_unique<executor::NetworkInterfaceMock>();
-    fixedNet->setEgressMetadataHook(stdx::make_unique<ShardingEgressMetadataHookForMongos>());
+    fixedNet->setEgressMetadataHook(stdx::make_unique<ShardingEgressMetadataHookForMongos>(false));
     _mockNetwork = fixedNet.get();
     auto fixedExec = makeThreadPoolTestExecutor(std::move(fixedNet));
     _networkTestEnv = stdx::make_unique<NetworkTestEnv>(fixedExec.get(), _mockNetwork);
     _executor = fixedExec.get();
 
     auto netForPool = stdx::make_unique<executor::NetworkInterfaceMock>();
-    netForPool->setEgressMetadataHook(stdx::make_unique<ShardingEgressMetadataHookForMongos>());
+    netForPool->setEgressMetadataHook(
+        stdx::make_unique<ShardingEgressMetadataHookForMongos>(false));
     auto execForPool = makeThreadPoolTestExecutor(std::move(netForPool));
     std::vector<std::unique_ptr<executor::TaskExecutor>> executorsForPool;
     executorsForPool.emplace_back(std::move(execForPool));