SERVER-44771 Introduce 2nd CatalogCache for filtering only

Only on ShardServer (not ReadOnly) use a second catalog cache for
filtering only in order to allow operations in transactions to safely
consult the CatalogCache.

10 files changed, 154 insertions, 21 deletions

diff --git a/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp b/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
index 29dfa758378..0a0de0577e8 100644
--- a/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
+++ b/src/mongo/db/repl/replication_coordinator_external_state_impl.cpp
@@ -82,6 +82,7 @@
 #include "mongo/db/s/migration_util.h"
 #include "mongo/db/s/periodic_balancer_config_refresher.h"
 #include "mongo/db/s/periodic_sharded_index_consistency_checker.h"
+#include "mongo/db/s/shard_filtering_metadata_refresh.h"
 #include "mongo/db/s/sharding_initialization_mongod.h"
 #include "mongo/db/s/sharding_state_recovery.h"
 #include "mongo/db/s/transaction_coordinator_service.h"
@@ -715,7 +716,7 @@ void ReplicationCoordinatorExternalStateImpl::shardingOnStepDownHook() {
         TransactionCoordinatorService::get(_service)->onStepDown();
     } else if (ShardingState::get(_service)->enabled()) {
         ChunkSplitter::get(_service).onStepDown();
-        CatalogCacheLoader::get(_service).onStepDown();
+        getCatalogCacheLoaderForFiltering(_service).onStepDown();
         PeriodicBalancerConfigRefresher::get(_service).onStepDown();
         TransactionCoordinatorService::get(_service)->onStepDown();
     }
@@ -818,7 +819,7 @@ void ReplicationCoordinatorExternalStateImpl::_shardingOnTransitionToPrimaryHook
         ShardingInitializationMongoD::get(opCtx)->updateShardIdentityConfigString(opCtx,
                                                                                   configsvrConnStr);
 
-        CatalogCacheLoader::get(_service).onStepUp();
+        getCatalogCacheLoaderForFiltering(_service).onStepUp();
         ChunkSplitter::get(_service).onStepUp();
         PeriodicBalancerConfigRefresher::get(_service).onStepUp(_service);
         TransactionCoordinatorService::get(_service)->onStepUp(opCtx);
diff --git a/src/mongo/db/s/flush_database_cache_updates_command.cpp b/src/mongo/db/s/flush_database_cache_updates_command.cpp
index e96159b3cbd..8b06a59c2cc 100644
--- a/src/mongo/db/s/flush_database_cache_updates_command.cpp
+++ b/src/mongo/db/s/flush_database_cache_updates_command.cpp
@@ -141,7 +141,7 @@ public:
                 forceDatabaseRefresh(opCtx, _dbName());
             }
 
-            CatalogCacheLoader::get(opCtx).waitForDatabaseFlush(opCtx, _dbName());
+            getCatalogCacheLoaderForFiltering(opCtx).waitForDatabaseFlush(opCtx, _dbName());
 
             repl::ReplClientInfo::forClient(opCtx->getClient()).setLastOpToSystemLastOpTime(opCtx);
         }
diff --git a/src/mongo/db/s/flush_routing_table_cache_updates_command.cpp b/src/mongo/db/s/flush_routing_table_cache_updates_command.cpp
index 2a2fd18a89f..3359431d84a 100644
--- a/src/mongo/db/s/flush_routing_table_cache_updates_command.cpp
+++ b/src/mongo/db/s/flush_routing_table_cache_updates_command.cpp
@@ -138,7 +138,7 @@ public:
                 forceShardFilteringMetadataRefresh(opCtx, ns());
             }
 
-            CatalogCacheLoader::get(opCtx).waitForCollectionFlush(opCtx, ns());
+            getCatalogCacheLoaderForFiltering(opCtx).waitForCollectionFlush(opCtx, ns());
 
             repl::ReplClientInfo::forClient(opCtx->getClient()).setLastOpToSystemLastOpTime(opCtx);
         }
diff --git a/src/mongo/db/s/migration_source_manager.cpp b/src/mongo/db/s/migration_source_manager.cpp
index c94b0777ad2..05ef0b9f08e 100644
--- a/src/mongo/db/s/migration_source_manager.cpp
+++ b/src/mongo/db/s/migration_source_manager.cpp
@@ -745,7 +745,7 @@ void MigrationSourceManager::_cleanup() {
         // possible that the persisted metadata is rolled back after step down, but the write which
         // cleared the 'inMigration' flag is not, a secondary node will report itself at an older
         // shard version.
-        CatalogCacheLoader::get(_opCtx).waitForCollectionFlush(_opCtx, getNss());
+        getCatalogCacheLoaderForFiltering(_opCtx).waitForCollectionFlush(_opCtx, getNss());
 
         // Clear the 'minOpTime recovery' document so that the next time a node from this shard
         // becomes a primary, it won't have to recover the config server optime.
diff --git a/src/mongo/db/s/migration_util_test.cpp b/src/mongo/db/s/migration_util_test.cpp
index fa8b6197552..229577b55d0 100644
--- a/src/mongo/db/s/migration_util_test.cpp
+++ b/src/mongo/db/s/migration_util_test.cpp
@@ -61,7 +61,7 @@ protected:
 
         WaitForMajorityService::get(getServiceContext()).setUp(getServiceContext());
 
-        CatalogCacheLoader::get(operationContext()).initializeReplicaSetRole(true);
+        getCatalogCacheLoaderForFiltering(operationContext()).initializeReplicaSetRole(true);
 
         setupNShards(2);
     }
diff --git a/src/mongo/db/s/shard_filtering_metadata_refresh.cpp b/src/mongo/db/s/shard_filtering_metadata_refresh.cpp
index ed66137c3d4..9df640dc043 100644
--- a/src/mongo/db/s/shard_filtering_metadata_refresh.cpp
+++ b/src/mongo/db/s/shard_filtering_metadata_refresh.cpp
@@ -36,12 +36,15 @@
 #include "mongo/db/catalog/database_holder.h"
 #include "mongo/db/catalog_raii.h"
 #include "mongo/db/commands/feature_compatibility_version.h"
+#include "mongo/db/commands/test_commands_enabled.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/s/collection_sharding_runtime.h"
 #include "mongo/db/s/database_sharding_state.h"
 #include "mongo/db/s/operation_sharding_state.h"
 #include "mongo/db/s/sharding_state.h"
 #include "mongo/db/s/sharding_statistics.h"
+#include "mongo/db/server_options.h"
+#include "mongo/db/storage/storage_options.h"
 #include "mongo/logv2/log.h"
 #include "mongo/s/catalog_cache.h"
 #include "mongo/s/grid.h"
@@ -128,8 +131,63 @@ void onDbVersionMismatch(OperationContext* opCtx,
     forceDatabaseRefresh(opCtx, dbName);
 }
 
+const auto catalogCacheForFilteringDecoration =
+    ServiceContext::declareDecoration<std::unique_ptr<CatalogCache>>();
+
+const auto catalogCacheLoaderForFilteringDecoration =
+    ServiceContext::declareDecoration<std::unique_ptr<CatalogCacheLoader>>();
+
+CatalogCache& getCatalogCacheForFiltering(ServiceContext* serviceContext) {
+    if (hasAdditionalCatalogCacheForFiltering()) {
+        auto& catalogCacheForFiltering = catalogCacheForFilteringDecoration(serviceContext);
+        invariant(catalogCacheForFiltering);
+        return *catalogCacheForFiltering;
+    }
+    return *Grid::get(serviceContext)->catalogCache();
+}
+
+CatalogCache& getCatalogCacheForFiltering(OperationContext* opCtx) {
+    return getCatalogCacheForFiltering(opCtx->getServiceContext());
+}
+
 }  // namespace
 
+
+bool hasAdditionalCatalogCacheForFiltering() {
+    invariant(serverGlobalParams.clusterRole == ClusterRole::ShardServer);
+    return getTestCommandsEnabled() && !storageGlobalParams.readOnly;
+}
+
+void setCatalogCacheForFiltering(ServiceContext* serviceContext,
+                                 std::unique_ptr<CatalogCache> catalogCache) {
+    invariant(hasAdditionalCatalogCacheForFiltering());
+    auto& catalogCacheForFiltering = catalogCacheForFilteringDecoration(serviceContext);
+    invariant(!catalogCacheForFiltering);
+    catalogCacheForFiltering = std::move(catalogCache);
+}
+
+void setCatalogCacheLoaderForFiltering(ServiceContext* serviceContext,
+                                       std::unique_ptr<CatalogCacheLoader> loader) {
+    invariant(hasAdditionalCatalogCacheForFiltering());
+    auto& catalogCacheLoader = catalogCacheLoaderForFilteringDecoration(serviceContext);
+    invariant(!catalogCacheLoader);
+    catalogCacheLoader = std::move(loader);
+}
+
+CatalogCacheLoader& getCatalogCacheLoaderForFiltering(ServiceContext* serviceContext) {
+    if (hasAdditionalCatalogCacheForFiltering()) {
+        auto& catalogCacheLoader = catalogCacheLoaderForFilteringDecoration(serviceContext);
+        invariant(catalogCacheLoader);
+        return *catalogCacheLoader;
+    }
+    return CatalogCacheLoader::get(serviceContext);
+}
+
+CatalogCacheLoader& getCatalogCacheLoaderForFiltering(OperationContext* opCtx) {
+    return getCatalogCacheLoaderForFiltering(opCtx->getServiceContext());
+}
+
+
 Status onShardVersionMismatchNoExcept(OperationContext* opCtx,
                                       const NamespaceString& nss,
                                       ChunkVersion shardVersionReceived,
@@ -155,8 +213,15 @@ ChunkVersion forceShardFilteringMetadataRefresh(OperationContext* opCtx,
     auto* const shardingState = ShardingState::get(opCtx);
     invariant(shardingState->canAcceptShardedCommands());
 
+    if (hasAdditionalCatalogCacheForFiltering()) {
+        Grid::get(opCtx)
+            ->catalogCache()
+            ->getCollectionRoutingInfoWithRefresh(opCtx, nss, forceRefreshFromThisThread)
+            .getStatus()
+            .ignore();
+    }
     auto routingInfo =
-        uassertStatusOK(Grid::get(opCtx)->catalogCache()->getCollectionRoutingInfoWithRefresh(
+        uassertStatusOK(getCatalogCacheForFiltering(opCtx).getCollectionRoutingInfoWithRefresh(
             opCtx, nss, forceRefreshFromThisThread));
     auto cm = routingInfo.cm();
 
@@ -259,8 +324,16 @@ void forceDatabaseRefresh(OperationContext* opCtx, const StringData dbName) {
 
     DatabaseVersion refreshedDbVersion;
     try {
+        if (hasAdditionalCatalogCacheForFiltering()) {
+            Grid::get(opCtx)
+                ->catalogCache()
+                ->getDatabaseWithRefresh(opCtx, dbName)
+                .getStatus()
+                .ignore();
+        }
         refreshedDbVersion =
-            uassertStatusOK(Grid::get(opCtx)->catalogCache()->getDatabaseWithRefresh(opCtx, dbName))
+            uassertStatusOK(
+                getCatalogCacheForFiltering(opCtx).getDatabaseWithRefresh(opCtx, dbName))
                 .databaseVersion();
     } catch (const ExceptionFor<ErrorCodes::NamespaceNotFound>&) {
         // db has been dropped, set the db version to boost::none
diff --git a/src/mongo/db/s/shard_filtering_metadata_refresh.h b/src/mongo/db/s/shard_filtering_metadata_refresh.h
index f378c60622f..7ca5cf1b992 100644
--- a/src/mongo/db/s/shard_filtering_metadata_refresh.h
+++ b/src/mongo/db/s/shard_filtering_metadata_refresh.h
@@ -35,9 +35,36 @@
 
 namespace mongo {
 
+class CatalogCache;
+class CatalogCacheLoader;
+class ServiceContext;
 class OperationContext;
 
 /**
+ * Returns True when a separate CatalogCache must be used for filtering
+ */
+bool hasAdditionalCatalogCacheForFiltering();
+
+/**
+ * CatalogCacheForFiltering is only used on a shard for obtaining the orphan filtering metadata
+ */
+void setCatalogCacheForFiltering(ServiceContext* serviceContext,
+                                 std::unique_ptr<CatalogCache> catalogCache);
+
+
+/**
+ * CatalogCacheLoaderForFiltering is only used on a shard for obtaining the orphan filtering
+ * metadata
+ */
+void setCatalogCacheLoaderForFiltering(ServiceContext* serviceContext,
+                                       std::unique_ptr<CatalogCacheLoader> loader);
+
+// For routing use `CatalogCacheLoader::get()`
+CatalogCacheLoader& getCatalogCacheLoaderForFiltering(ServiceContext* serviceContext);
+CatalogCacheLoader& getCatalogCacheLoaderForFiltering(OperationContext* opCtx);
+
+
+/**
  * Must be invoked whenever code, which is executing on a shard encounters a StaleConfig exception
  * and should be passed the 'version received' from the exception. If the shard's current version is
  * behind 'shardVersionReceived', causes the shard's filtering metadata to be refreshed from the
diff --git a/src/mongo/db/s/shard_server_op_observer.cpp b/src/mongo/db/s/shard_server_op_observer.cpp
index c334a963b35..a9f8d1954e7 100644
--- a/src/mongo/db/s/shard_server_op_observer.cpp
+++ b/src/mongo/db/s/shard_server_op_observer.cpp
@@ -43,6 +43,7 @@
 #include "mongo/db/s/migration_util.h"
 #include "mongo/db/s/operation_sharding_state.h"
 #include "mongo/db/s/range_deletion_task_gen.h"
+#include "mongo/db/s/shard_filtering_metadata_refresh.h"
 #include "mongo/db/s/shard_identity_rollback_notifier.h"
 #include "mongo/db/s/sharding_initialization_mongod.h"
 #include "mongo/db/s/sharding_state.h"
@@ -80,7 +81,7 @@ public:
     void commit(boost::optional<Timestamp>) override {
         invariant(_opCtx->lockState()->isCollectionLockedForMode(_nss, MODE_IX));
 
-        CatalogCacheLoader::get(_opCtx).notifyOfCollectionVersionUpdate(_nss);
+        getCatalogCacheLoaderForFiltering(_opCtx).notifyOfCollectionVersionUpdate(_nss);
 
         // Force subsequent uses of the namespace to refresh the filtering metadata so they can
         // synchronize with any work happening on the primary (e.g., migration critical section).
diff --git a/src/mongo/db/s/sharding_initialization_mongod.cpp b/src/mongo/db/s/sharding_initialization_mongod.cpp
index ec320b06c07..44b31aed18e 100644
--- a/src/mongo/db/s/sharding_initialization_mongod.cpp
+++ b/src/mongo/db/s/sharding_initialization_mongod.cpp
@@ -49,6 +49,7 @@
 #include "mongo/db/s/chunk_splitter.h"
 #include "mongo/db/s/periodic_balancer_config_refresher.h"
 #include "mongo/db/s/read_only_catalog_cache_loader.h"
+#include "mongo/db/s/shard_filtering_metadata_refresh.h"
 #include "mongo/db/s/shard_server_catalog_cache_loader.h"
 #include "mongo/db/s/sharding_config_optime_gossip.h"
 #include "mongo/db/s/transaction_coordinator_service.h"
@@ -65,6 +66,7 @@
 #include "mongo/s/config_server_catalog_cache_loader.h"
 #include "mongo/s/grid.h"
 #include "mongo/s/sharding_initialization.h"
+#include "mongo/util/exit.h"
 #include "mongo/util/log.h"
 
 namespace mongo {
@@ -174,7 +176,7 @@ void ShardingInitializationMongoD::initializeShardingEnvironmentOnShardServer(
     bool isStandaloneOrPrimary =
         !isReplSet || (replCoord->getMemberState() == repl::MemberState::RS_PRIMARY);
 
-    CatalogCacheLoader::get(opCtx).initializeReplicaSetRole(isStandaloneOrPrimary);
+    getCatalogCacheLoaderForFiltering(opCtx).initializeReplicaSetRole(isStandaloneOrPrimary);
     ChunkSplitter::get(opCtx).onShardingInitialization(isStandaloneOrPrimary);
     PeriodicBalancerConfigRefresher::get(opCtx).onShardingInitialization(opCtx->getServiceContext(),
                                                                          isStandaloneOrPrimary);
@@ -436,18 +438,47 @@ void initializeGlobalShardingStateForMongoD(OperationContext* opCtx,
 
     auto const service = opCtx->getServiceContext();
 
-    if (serverGlobalParams.clusterRole == ClusterRole::ShardServer) {
-        if (storageGlobalParams.readOnly) {
-            CatalogCacheLoader::set(service, std::make_unique<ReadOnlyCatalogCacheLoader>());
-        } else {
-            CatalogCacheLoader::set(service,
-                                    std::make_unique<ShardServerCatalogCacheLoader>(
-                                        std::make_unique<ConfigServerCatalogCacheLoader>()));
-        }
-    } else {
-        CatalogCacheLoader::set(service, std::make_unique<ConfigServerCatalogCacheLoader>());
+
+    if (serverGlobalParams.clusterRole == ClusterRole::ShardServer &&
+        hasAdditionalCatalogCacheForFiltering()) {
+        // Setup additional CatalogCache for filtering only
+        setCatalogCacheLoaderForFiltering(service,
+                                          std::make_unique<ShardServerCatalogCacheLoader>(
+                                              std::make_unique<ConfigServerCatalogCacheLoader>()));
+        setCatalogCacheForFiltering(
+            service, std::make_unique<CatalogCache>(getCatalogCacheLoaderForFiltering(opCtx)));
+        registerShutdownTask(
+            [service]() { getCatalogCacheLoaderForFiltering(service).shutDown(); });
     }
 
+    // Make primary CatalogCacheLoader according to the cluster Role
+    auto makeCatalogCacheLoader = []() -> std::unique_ptr<CatalogCacheLoader> {
+        switch (serverGlobalParams.clusterRole) {
+            case ClusterRole::ShardServer:
+                if (storageGlobalParams.readOnly) {
+                    return std::make_unique<ReadOnlyCatalogCacheLoader>();
+                }
+                if (hasAdditionalCatalogCacheForFiltering()) {
+                    // The primary CatalogCache will be used only for routing
+                    return std::make_unique<ConfigServerCatalogCacheLoader>();
+                }
+
+                // Normal ShardServer without additional cache for filtering
+                return std::make_unique<ShardServerCatalogCacheLoader>(
+                    std::make_unique<ConfigServerCatalogCacheLoader>());
+                break;
+
+            case ClusterRole::ConfigServer:
+                return std::make_unique<ConfigServerCatalogCacheLoader>();
+                break;
+
+            default:
+                MONGO_UNREACHABLE;
+        }
+    };
+
+    CatalogCacheLoader::set(service, makeCatalogCacheLoader());
+
     auto validator = LogicalTimeValidator::get(service);
     if (validator) {  // The keyManager may be existing if the node was a part of a standalone RS.
         validator->stopKeyManager();
diff --git a/src/mongo/db/s/split_chunk_test.cpp b/src/mongo/db/s/split_chunk_test.cpp
index 563692cac50..b18275f72a9 100644
--- a/src/mongo/db/s/split_chunk_test.cpp
+++ b/src/mongo/db/s/split_chunk_test.cpp
@@ -69,7 +69,7 @@ public:
         ShardServerTestFixture::setUp();
 
         ShardingState::get(operationContext())->setInitialized(_shardId, OID::gen());
-        CatalogCacheLoader::get(getServiceContext()).initializeReplicaSetRole(true);
+        getCatalogCacheLoaderForFiltering(getServiceContext()).initializeReplicaSetRole(true);
 
         // Instantiate names.
         _epoch = OID::gen();