SERVER-119757 Rename ShardingDDLCoordinator to ShardingCoordinator (#48662)

GitOrigin-RevId: 77f4bfd857b439c6894351fc9d66189c8ed84565

.clang-tidy.in

@@ -76,7 +76,7 @@ Checks:          '-*,
                   mongo-header-bracket-check,
                   mongo-header-include-path-check,
                   mongo-invariant-status-is-ok-check,
-                  mongo-invariant-ddl-coordinator-check,
+                  mongo-invariant-sharding-coordinator-check,
                   mongo-macro-definition-leaks-check,
                   mongo-mutex-check,
                   mongo-rand-check,

jstests/core_sharding/ddl/version_context_propagation.js

@@ -62,7 +62,7 @@ try {
             {
                 $match: {
                     shard: primaryShardName,
-                    desc: {$regex: "^ShardingDDLCoordinator"},
+                    desc: {$regex: "^Sharding(DDL)?Coordinator"},
                     "command.comment": jsTestName(),
                 },
             },

jstests/sharding/fsync_lock_fails_with_in_progress_ddl_op.js

@@ -39,8 +39,8 @@ ddlCoordinatorFailPoint.wait();
 
 // Run fsync command, should fail when DDL op is in progress
 let fsyncLockCommand = assert.commandFailed(st.s.adminCommand({fsync: 1, lock: true}));
-const errmsg = "Cannot take lock while DDL operation is in progress";
+const errmsgRegex = /Cannot take lock while (DDL operation is|sharding coordinators are) in progress/;
-assert.eq(fsyncLockCommand.errmsg.includes(errmsg), true);
+assert(errmsgRegex.test(fsyncLockCommand.errmsg), fsyncLockCommand.errmsg);
 
 ddlCoordinatorFailPoint.off();
 ddlOpThread.join();

src/mongo/db/BUILD.bazel

@@ -3557,7 +3557,7 @@ idl_generator(
     deps = [
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/commands:fle2_cleanup_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 
@@ -3568,7 +3568,7 @@ idl_generator(
         "//src/mongo/crypto:fle_field_schema_gen",
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/commands:fle2_compact_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 

src/mongo/db/README_version_context.md

@@ -1,7 +1,7 @@
 # VersionContext in MongoDB
 
 This document details the `VersionContext`, a crucial component for managing Feature Compatibility
-Version (FCV) during DDL operations in the MongoDB codebase.
+Version (FCV) in sharding coordinators in the MongoDB codebase.
 
 ## What is VersionContext?
 
@@ -10,7 +10,7 @@ with a given operation. The `VersionContext` serves as an indirection to store a
 making the code more flexible for future needs. It is defined as a decoration of the
 `OperationContext` class.
 
-> Please Note: The VersionContext is only available for use for DDL operations. SPM-4227 plans to
+> Please Note: The VersionContext is only available for use for sharding coordinators. SPM-4227 plans to
 > extend this concept to more operations (see [warnings section](#warnings-and-future-outlook)).
 
 ## How to Use VersionContext
@@ -29,9 +29,9 @@ The `VersionContext` provides the following methods:
 
 ### Initialization, Persistence, and Recovery
 
-The OFCV for a DDL operation is created within the
+The OFCV for a sharding coordinator is created within the
-`ShardingDDLCoordinatorService::getOrCreateInstance` function, where the node’s local FCV is
+`ShardingCoordinatorService::getOrCreateInstance` function, where the node’s local FCV is
-captured and set on a `VersionContext` instance. This value is then passed to a spawned DDL
+captured and set on a `VersionContext` instance. This value is then passed to a spawned sharding
 coordinator through a specific field within the coordinator state document, extending the
 `ForwardableOperationMetadata` definition to ensure propagation between subsequent coordinator
 phases. This mechanism ensures persistence across various stages and allows for recovery in case of
@@ -58,31 +58,32 @@ used by primaries and secondaries when applying related oplog entries.
 ### Feature Flag Checks
 
 The OFCV value in the `VersionContext` serves as the baseline for all feature flag checks during the
-execution of DDL coordinators and participants. FCV-gated feature flags (represented by
+execution of sharding coordinators and participants. FCV-gated feature flags (represented by
 `FCVGatedFeatureFlag`) will use an `isEnabled` method that incorporates a `VersionContext` parameter
 to accommodate OFCV-based checks. Non-FCV-gated feature flags (represented by
 `BinaryCompatibleFeatureFlag`) will use a parameterless `isEnabled()` method.
 
 ## Warnings and Future Outlook
 
-Currently, the OFCV is primarily applied to DDL operations. Non-DDL operations can run across FCV
+Currently, the OFCV is primarily applied to sharding coordinators. Other operations can run across FCV
 change boundaries, which requires careful handling. A transitional API is in place for FCV-gated
 feature flag checks, relying on `FCVSnapshot` if no OFCV is available.
 
-Future work aims to enable non-DDL operations to:
+Future work aims to enable non-ShardingCoordinator operations to:
 
 1. Store an FCV snapshot (OFCV) on the `VersionContext`.
 2. Check that the FCV has not transitioned when acquiring a write lock or `FixedFCVRegion`.
 3. If the FCV has transitioned, kill the operation or allow callers to decide the resolution.
 
-Once these capabilities are introduced for non-DDL operations, the feature flag API can be
+Once these capabilities are introduced for non-ShardingCoordinator operations, the feature flag API can be
 streamlined to directly use `VersionContext::getDecoration(opCtx)` for
 `FCVGatedFeatureFlag::isEnabled` calls.
 
 ## Multiversion Considerations
 
 Changes related to `VersionContext` are controlled by a `SnapshotFCVInDDLCoordinators` feature flag,
-enabled with FCV \>= 9.0. This flag determines if the OFCV is set upon DDL coordinator startup. DDL
+enabled with FCV \>= 9.0. Note that despite the flag name, it affects all sharding coordinators, not
+just DDL coordinators. This flag determines if the OFCV is set upon sharding coordinator startup. Sharding
 coordinators and participants will then distinguish between old and new behaviors based on the OFCV
 value itself:
 
@@ -94,6 +95,6 @@ binaries are involved.
 
 ## Diagnosis/Debuggability
 
-Information about the associated OFCV will be introduced to `config.changelog` logs for each DDL
+Information about the associated OFCV will be introduced to `config.changelog` logs for each sharding
-operation and to general sharding logs for DDL startup, participant requests, and other FCV-related
+coordinator and to general sharding logs for cordinator startup, participant requests, and other FCV-related
 cases. The OFCV for a given operation will also be added to the output of the `currentOp` command.

src/mongo/db/cleanup_structured_encryption_data_coordinator.cpp

@@ -38,8 +38,8 @@
 #include "mongo/db/dbdirectclient.h"
 #include "mongo/db/fle_crud.h"
 #include "mongo/db/generic_argument_util.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
 #include "mongo/db/router_role/router_role.h"
 #include "mongo/db/router_role/routing_cache/catalog_cache.h"
 #include "mongo/db/server_parameter.h"

src/mongo/db/cleanup_structured_encryption_data_coordinator.h

@@ -36,8 +36,8 @@
 #include "mongo/db/cleanup_structured_encryption_data_coordinator_gen.h"
 #include "mongo/db/commands/fle2_cleanup_gen.h"
 #include "mongo/db/commands/fle2_compact.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/pipeline/process_interface/mongo_process_interface.h"
@@ -65,7 +65,7 @@ public:
     using StateDoc = CleanupStructuredEncryptionDataState;
     using Phase = CleanupStructuredEncryptionDataPhaseEnum;
 
-    CleanupStructuredEncryptionDataCoordinator(ShardingDDLCoordinatorService* service,
+    CleanupStructuredEncryptionDataCoordinator(ShardingCoordinatorService* service,
                                                const BSONObj& doc)
         : RecoverableShardingDDLCoordinator(
               service, "CleanupStructuredEncryptionDataCoordinator", doc) {}

src/mongo/db/cleanup_structured_encryption_data_coordinator.idl

@@ -32,7 +32,7 @@ global:
 imports:
     - "mongo/db/basic_types.idl"
     - "mongo/db/commands/fle2_cleanup.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
 
 enums:
     CleanupStructuredEncryptionDataPhase:
@@ -54,7 +54,7 @@ structs:
         strict: false
         mod_visibility: pub
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 description: "Current phase"

src/mongo/db/commands/fsync.cpp

@@ -132,16 +132,16 @@ public:
         }
     }
 
-    void checkForInProgressDDLOperations(OperationContext* opCtx) {
+    void checkForInProgressCoordinators(OperationContext* opCtx) {
         DBDirectClient client(opCtx);
         const auto numDDLDocuments =
             client.count(NamespaceString::kShardingDDLCoordinatorsNamespace);
 
         if (numDDLDocuments != 0) {
-            LOGV2_WARNING(781541, "Cannot take lock while DDL operations is in progress");
+            LOGV2_WARNING(781541, "Cannot take lock while sharding coordinators are in progress");
             releaseLock();
             uasserted(ErrorCodes::IllegalOperation,
-                      "Cannot take lock while DDL operation is in progress");
+                      "Cannot take lock while sharding coordinators are in progress");
         }
     }
 
@@ -214,7 +214,7 @@ public:
             // The check must be performed only if the fsync+lock command has been issued for backup
             // purposes (through monogs). There are valid cases where fsync+lock can be invoked on
             // the mongod while DDLs are in progress.
-            checkForInProgressDDLOperations(opCtx);
+            checkForInProgressCoordinators(opCtx);
         }
 
         LOGV2(20462,

src/mongo/db/commands/set_feature_compatibility_version_command.cpp

@@ -58,8 +58,8 @@
 #include "mongo/db/global_catalog/ddl/drop_collection_coordinator.h"
 #include "mongo/db/global_catalog/ddl/placement_history_commands_gen.h"
 #include "mongo/db/global_catalog/ddl/sharding_catalog_manager.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
 #include "mongo/db/global_catalog/ddl/shardsvr_join_ddl_coordinators_request_gen.h"
 #include "mongo/db/global_catalog/type_shard_identity.h"
@@ -325,7 +325,7 @@ void handleDropPendingDBsGarbage(OperationContext* parentOpCtx) {
 
         ShardsvrJoinDDLCoordinators request;
         request.setDbName(DatabaseName::kAdmin);
-        request.setTypes({{idl::serialize(DDLCoordinatorTypeEnum::kDropDatabase)}});
+        request.setTypes({{idl::serialize(CoordinatorTypeEnum::kDropDatabase)}});
 
         const auto response = shard->runCommand(opCtx,
                                                 ReadPreferenceSetting{ReadPreference::PrimaryOnly},
@@ -752,18 +752,18 @@ public:
             if (role && role->has(ClusterRole::ConfigServer)) {
                 // Waiting for recovery here to avoid waiting for recovery while holding the
                 // fcvChangeRegion
-                ShardingDDLCoordinatorService::getService(opCtx)->waitForRecovery(opCtx);
+                ShardingCoordinatorService::getService(opCtx)->waitForRecovery(opCtx);
 
                 if (requestedVersion <= actualVersion) {
                     // A background initialization of config.placementHistory may be setting
                     // cluster parameters (a condition that may cause this command to fail with
                     // a CannotDowngrade error in the checks performed under the
                     // fcvChangeRegion); perform a best-effort drain to avoid the scenario.
-                    ShardingDDLCoordinatorService::getService(opCtx)
+                    ShardingCoordinatorService::getService(opCtx)
                         ->waitForOngoingCoordinatorsToFinish(
-                            opCtx, [](const ShardingDDLCoordinator& instance) -> bool {
+                            opCtx, [](const ShardingCoordinator& instance) -> bool {
                                 return instance.operationType() ==
-                                    DDLCoordinatorTypeEnum::kInitializePlacementHistory;
+                                    CoordinatorTypeEnum::kInitializePlacementHistory;
                             });
                 }
             }
@@ -796,9 +796,9 @@ public:
                     uassert(
                         ErrorCodes::ConflictingOperationInProgress,
                         "Failed to start FCV change because an addShardCoordinator is in progress",
-                        ShardingDDLCoordinatorService::getService(opCtx)
+                        ShardingCoordinatorService::getService(opCtx)
                             ->areAllCoordinatorsOfTypeFinished(opCtx,
-                                                               DDLCoordinatorTypeEnum::kAddShard));
+                                                               CoordinatorTypeEnum::kAddShard));
                 }
 
                 // If this is a config server, then there must be no active
@@ -867,7 +867,7 @@ public:
                 // This helper function is only for any actions that should be done specifically on
                 // shard servers during phase 1 of the 3-phase setFCV protocol for sharded clusters.
                 // For example, before completing phase 1, we must wait for backward incompatible
-                // ShardingDDLCoordinators to finish.
+                // ShardingCoordinators to finish.
                 // We do not expect any other feature-specific work to be done in the 'start' phase.
                 _shardServerPhase1Tasks(opCtx, requestedVersion);
             }
@@ -1006,12 +1006,12 @@ private:
     // This helper function is only for any actions that should be done specifically on
     // shard servers during phase 1 of the 3-phase setFCV protocol for sharded clusters.
     // For example, before completing phase 1, we must wait for backward incompatible
-    // ShardingDDLCoordinators to finish. This is important in order to ensure that no
+    // ShardingCoordinators to finish. This is important in order to ensure that no
     // shard that is currently a participant of such a backward-incompatible
-    // ShardingDDLCoordinator can transition to the fully downgraded state (and thus,
+    // ShardingCoordinator can transition to the fully downgraded state (and thus,
     // possibly downgrade its binary) while the coordinator is still in progress.
     // The fact that the FCV has already transitioned to kDowngrading ensures that no
-    // new backward-incompatible ShardingDDLCoordinators can start.
+    // new backward-incompatible ShardingCoordinators can start.
     // We do not expect any other feature-specific work to be done in the 'start' phase.
     void _shardServerPhase1Tasks(OperationContext* opCtx, FCV requestedVersion) {
         const auto fcvSnapshot = serverGlobalParams.featureCompatibility.acquireFCVSnapshot();
@@ -1031,7 +1031,7 @@ private:
             // TODO SERVER-99655: update once gSnapshotFCVInDDLCoordinators is enabled
             // on the lastLTS
             if (feature_flags::gSnapshotFCVInDDLCoordinators.isEnabledOnVersion(originalVersion)) {
-                ShardingDDLCoordinatorService::getService(opCtx)
+                ShardingCoordinatorService::getService(opCtx)
                     ->waitForCoordinatorsOfGivenOfcvToComplete(
                         opCtx, [originalVersion](boost::optional<FCV> ofcv) -> bool {
                             return ofcv == originalVersion;
@@ -1041,53 +1041,53 @@ private:
                 if (feature_flags::gTrackUnshardedCollectionsUponMoveCollection
                         .isDisabledOnTargetFCVButEnabledOnOriginalFCV(requestedVersion,
                                                                       originalVersion)) {
-                    ShardingDDLCoordinatorService::getService(opCtx)
+                    ShardingCoordinatorService::getService(opCtx)
                         ->waitForCoordinatorsOfGivenTypeToComplete(
-                            opCtx, DDLCoordinatorTypeEnum::kRenameCollection);
+                            opCtx, CoordinatorTypeEnum::kRenameCollection);
                 }
 
                 // TODO (SERVER-100309): Remove once 9.0 becomes last lts.
                 if (feature_flags::gSessionsCollectionCoordinatorOnConfigServer
                         .isDisabledOnTargetFCVButEnabledOnOriginalFCV(requestedVersion,
                                                                       originalVersion)) {
-                    ShardingDDLCoordinatorService::getService(opCtx)
+                    ShardingCoordinatorService::getService(opCtx)
                         ->waitForCoordinatorsOfGivenTypeToComplete(
-                            opCtx, DDLCoordinatorTypeEnum::kCreateCollection);
+                            opCtx, CoordinatorTypeEnum::kCreateCollection);
                 }
 
                 // TODO SERVER-77915: Remove once v8.0 branches out.
                 if (feature_flags::gTrackUnshardedCollectionsUponMoveCollection
                         .isDisabledOnTargetFCVButEnabledOnOriginalFCV(requestedVersion,
                                                                       originalVersion)) {
-                    ShardingDDLCoordinatorService::getService(opCtx)
+                    ShardingCoordinatorService::getService(opCtx)
-                        ->waitForCoordinatorsOfGivenTypeToComplete(
+                        ->waitForCoordinatorsOfGivenTypeToComplete(opCtx,
-                            opCtx, DDLCoordinatorTypeEnum::kCollMod);
+                                                                   CoordinatorTypeEnum::kCollMod);
                 }
 
                 // TODO (SERVER-76436) Remove once global balancing becomes last lts.
                 if (feature_flags::gBalanceUnshardedCollections
                         .isDisabledOnTargetFCVButEnabledOnOriginalFCV(requestedVersion,
                                                                       originalVersion)) {
-                    ShardingDDLCoordinatorService::getService(opCtx)
+                    ShardingCoordinatorService::getService(opCtx)
                         ->waitForCoordinatorsOfGivenTypeToComplete(
-                            opCtx, DDLCoordinatorTypeEnum::kMovePrimary);
+                            opCtx, CoordinatorTypeEnum::kMovePrimary);
                 }
 
                 // TODO (SERVER-97816): Remove once 9.0 becomes last lts.
                 if (feature_flags::gUseTopologyChangeCoordinators
                         .isDisabledOnTargetFCVButEnabledOnOriginalFCV(requestedVersion,
                                                                       originalVersion)) {
-                    ShardingDDLCoordinatorService::getService(opCtx)
+                    ShardingCoordinatorService::getService(opCtx)
                         ->waitForCoordinatorsOfGivenTypeToComplete(
-                            opCtx, DDLCoordinatorTypeEnum::kRemoveShardCommit);
+                            opCtx, CoordinatorTypeEnum::kRemoveShardCommit);
                 }
             }
         }
 
         if (isUpgrading) {
             if (feature_flags::gSnapshotFCVInDDLCoordinators.isEnabledOnVersion(requestedVersion)) {
-                // Wait until all DDL coordinators that run are on the kUpgrading* FCV
+                // Wait until all sharding coordinators that run are on the kUpgrading* FCV
-                ShardingDDLCoordinatorService::getService(opCtx)
+                ShardingCoordinatorService::getService(opCtx)
                     ->waitForCoordinatorsOfGivenOfcvToComplete(
                         opCtx, [fcvSnapshot](boost::optional<FCV> ofcv) -> bool {
                             return ofcv != fcvSnapshot.getVersion();
@@ -1101,13 +1101,13 @@ private:
                     // coordinators that started in FCV 8.0. waitForOngoingCoordinatorsToFinish may
                     // also wait for coordinators that started AFTER the transition to kUpgrading.
                     // That's OK, it's a performance penalty, but there is no correctness issue.
-                    ShardingDDLCoordinatorService::getService(opCtx)
+                    ShardingCoordinatorService::getService(opCtx)
                         ->waitForOngoingCoordinatorsToFinish(
-                            opCtx, [](const ShardingDDLCoordinator& coordinatorInstance) -> bool {
+                            opCtx, [](const ShardingCoordinator& coordinatorInstance) -> bool {
                                 static constexpr std::array drainCoordinatorTypes{
-                                    DDLCoordinatorTypeEnum::kMovePrimary,
+                                    CoordinatorTypeEnum::kMovePrimary,
-                                    DDLCoordinatorTypeEnum::kDropDatabase,
+                                    CoordinatorTypeEnum::kDropDatabase,
-                                    DDLCoordinatorTypeEnum::kCreateDatabase,
+                                    CoordinatorTypeEnum::kCreateDatabase,
                                 };
                                 const auto opType = coordinatorInstance.operationType();
                                 return std::ranges::any_of(drainCoordinatorTypes, [&](auto&& type) {
@@ -1988,11 +1988,10 @@ private:
             // TODO SERVER-99655: remove the comment below.
             // The draining logic relies on the OFCV infrastructure, which has been introduced in
             // FCV 8.2 and may behave sub-optimally when requestedVersion is lower than 8.2.
-            ShardingDDLCoordinatorService::getService(opCtx)
+            ShardingCoordinatorService::getService(opCtx)->waitForCoordinatorsOfGivenOfcvToComplete(
-                ->waitForCoordinatorsOfGivenOfcvToComplete(
+                opCtx, [requestedVersion](boost::optional<FCV> ofcv) -> bool {
-                    opCtx, [requestedVersion](boost::optional<FCV> ofcv) -> bool {
+                    return ofcv != requestedVersion;
-                        return ofcv != requestedVersion;
+                });
-                    });
         }
 
         // This wait serves as a barrier to gurantee that, from now on:
@@ -2074,11 +2073,9 @@ private:
                 feature_flags::gSnapshotFCVInDDLCoordinators.isEnabledOnVersion(requestedVersion)
                 ? boost::make_optional(requestedVersion)
                 : boost::none;
-            ShardingDDLCoordinatorService::getService(opCtx)
+            ShardingCoordinatorService::getService(opCtx)->waitForCoordinatorsOfGivenOfcvToComplete(
-                ->waitForCoordinatorsOfGivenOfcvToComplete(
+                opCtx,
-                    opCtx, [expectedOfcv](boost::optional<FCV> ofcv) -> bool {
+                [expectedOfcv](boost::optional<FCV> ofcv) -> bool { return ofcv != expectedOfcv; });
-                        return ofcv != expectedOfcv;
-                    });
         }
 
         // This wait serves as a barrier to guarantee that, from now on:

src/mongo/db/compact_structured_encryption_data_coordinator.cpp

@@ -39,8 +39,8 @@
 #include "mongo/db/dbdirectclient.h"
 #include "mongo/db/fle_crud.h"
 #include "mongo/db/generic_argument_util.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
 #include "mongo/db/server_parameter.h"
 #include "mongo/db/server_parameter_with_storage.h"
 #include "mongo/db/shard_role/ddl/create_gen.h"

src/mongo/db/compact_structured_encryption_data_coordinator.h

@@ -36,8 +36,8 @@
 #include "mongo/db/commands/fle2_compact.h"
 #include "mongo/db/commands/fle2_compact_gen.h"
 #include "mongo/db/compact_structured_encryption_data_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/pipeline/process_interface/mongo_process_interface.h"
@@ -66,7 +66,7 @@ public:
     using StateDoc = CompactStructuredEncryptionDataState;
     using Phase = CompactStructuredEncryptionDataPhaseEnum;
 
-    CompactStructuredEncryptionDataCoordinator(ShardingDDLCoordinatorService* service,
+    CompactStructuredEncryptionDataCoordinator(ShardingCoordinatorService* service,
                                                const BSONObj& doc)
         : RecoverableShardingDDLCoordinator(
               service, "CompactStructuredEncryptionDataCoordinator", doc) {}

src/mongo/db/compact_structured_encryption_data_coordinator.idl

@@ -33,7 +33,7 @@ imports:
     - "mongo/crypto/fle_field_schema.idl"
     - "mongo/db/basic_types.idl"
     - "mongo/db/commands/fle2_compact.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
 
 enums:
     CompactStructuredEncryptionDataPhase:
@@ -54,7 +54,7 @@ structs:
         strict: false
         mod_visibility: pub
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 description: "Current phase"
@@ -108,7 +108,7 @@ structs:
         description: "Represents the state of the compactStructuredEncryptionData pipeline"
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 description: "Current phase"

src/mongo/db/feature_flag.cpp

@@ -221,7 +221,7 @@ void OperationFCVOnlyFCVGatedFeatureFlag::assertCheckingAgainstOFCV(
         return;
     }
 
-    // This operation could be part of a ShardingDDLCoordinator started on FCV 8.0, which do not
+    // This operation could be part of a ShardingCoordinator started on FCV 8.0, which do not
     // have an OFCV. In this case, tolerate checking it against the global server FCV.
     if (!feature_flags::gStrictlyEnforceOperationFCVOnlyFCVGatedFeatureFlags
              .isEnabledUseLatestFCVWhenUninitialized(vCtx, globalFcv)) {

src/mongo/db/global_catalog/README_timeseries.md

@@ -161,7 +161,7 @@ in [query/timeseries/README](../query/timeseries/README.md).
 Users run DDL operations (`collMod`, `createIndexes`, `listIndexes`, `dropIndexes`, and etc...) on the
 **view** namespace. The buckets collection is meant to be invisible to the end user: special permissions are
 required to run DDL operations directly on it. The DDL coordinator translates the operation to the
-buckets namespace using the function `setBucketNss`, stores it in the `ShardingDDLCoordinatorMetadata`,
+buckets namespace using the function `setBucketNss`, stores it in the `ShardingCoordinatorMetadata`,
 and sets the `isTimeseriesNamespace` flag. Specific DDL coordinators will do further time-series rewrites
 as necessary. For example, the `CreateCollectionCoordinator` will check for the presence of `timeseriesFields`
 in the `ChunkManager` to decide if the shard key needs to be rewritten before forwarding the request to the shards.

src/mongo/db/global_catalog/ddl/BUILD.bazel

@@ -25,7 +25,7 @@ idl_generator(
     deps = [
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_ddl_commands_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 
@@ -34,7 +34,7 @@ idl_generator(
     src = "collmod_coordinator_document.idl",
     deps = [
         "//src/mongo/db:basic_types_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
         "//src/mongo/db/shard_role/ddl:coll_mod_gen",
         "//src/mongo/db/sharding_environment:sharding_types_gen",
     ],
@@ -75,7 +75,7 @@ idl_generator(
     deps = [
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_ddl_commands_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 
@@ -86,7 +86,7 @@ idl_generator(
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/global_catalog:type_collection_common_types_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_ddl_commands_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 
@@ -95,7 +95,7 @@ idl_generator(
     src = "create_database_coordinator_document.idl",
     deps = [
         "//src/mongo/db:basic_types_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
         "//src/mongo/db/sharding_environment:sharding_types_gen",
     ],
 )
@@ -105,7 +105,7 @@ idl_generator(
     src = "drop_collection_coordinator_document.idl",
     deps = [
         "//src/mongo/db:basic_types_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
         "//src/mongo/db/sharding_environment:sharding_types_gen",
     ],
 )
@@ -115,7 +115,7 @@ idl_generator(
     src = "drop_database_coordinator_document.idl",
     deps = [
         "//src/mongo/db:basic_types_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
         "//src/mongo/db/sharding_environment:sharding_types_gen",
     ],
 )
@@ -125,7 +125,7 @@ idl_generator(
     src = "drop_indexes_coordinator_document.idl",
     deps = [
         "//src/mongo/db:basic_types_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
         "//src/mongo/db/shard_role/ddl:drop_indexes_gen",
         "//src/mongo/db/sharding_environment:sharding_types_gen",
     ],
@@ -136,7 +136,7 @@ idl_generator(
     src = "migration_blocking_operation_coordinator.idl",
     deps = [
         "//src/mongo/db:basic_types_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 
@@ -145,7 +145,7 @@ idl_generator(
     src = "move_primary_coordinator_document.idl",
     deps = [
         "//src/mongo/db:basic_types_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
         "//src/mongo/db/sharding_environment:sharding_types_gen",
     ],
 )
@@ -165,7 +165,7 @@ idl_generator(
     deps = [
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_ddl_commands_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 
@@ -184,7 +184,7 @@ idl_generator(
     deps = [
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_ddl_commands_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 
@@ -203,7 +203,7 @@ idl_generator(
     deps = [
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_ddl_commands_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 
@@ -213,13 +213,13 @@ idl_generator(
     deps = [
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_ddl_commands_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 
 idl_generator(
-    name = "sharding_ddl_coordinator_gen",
+    name = "sharding_coordinator_gen",
-    src = "sharding_ddl_coordinator.idl",
+    src = "sharding_coordinator.idl",
     deps = [
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/session:logical_session_id_gen",
@@ -233,7 +233,7 @@ idl_generator(
     deps = [
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_ddl_commands_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 
@@ -336,7 +336,7 @@ idl_generator(
     deps = [
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_ddl_commands_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 
@@ -403,7 +403,7 @@ idl_generator(
     src = "initialize_placement_history_coordinator_document.idl",
     deps = [
         "//src/mongo/db:basic_types_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 

src/mongo/db/global_catalog/ddl/clone_authoritative_metadata_coordinator.h

@@ -43,7 +43,7 @@ public:
     using StateDoc = CloneAuthoritativeMetadataCoordinatorDocument;
     using Phase = CloneAuthoritativeMetadataCoordinatorPhaseEnum;
 
-    CloneAuthoritativeMetadataCoordinator(ShardingDDLCoordinatorService* service,
+    CloneAuthoritativeMetadataCoordinator(ShardingCoordinatorService* service,
                                           const BSONObj& initialStateDoc)
         : RecoverableShardingDDLCoordinator(
               service, "CloneAuthoritativeMetadataCoordinator", initialStateDoc) {};

src/mongo/db/global_catalog/ddl/clone_authoritative_metadata_coordinator.idl

@@ -32,7 +32,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
 
 enums:
     CloneAuthoritativeMetadataCoordinatorPhase:
@@ -49,7 +49,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 type: CloneAuthoritativeMetadataCoordinatorPhase

src/mongo/db/global_catalog/ddl/collmod_coordinator.cpp

@@ -38,7 +38,7 @@
 #include "mongo/db/commands.h"
 #include "mongo/db/generic_argument_util.h"
 #include "mongo/db/global_catalog/chunk_manager.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
 #include "mongo/db/global_catalog/sharding_catalog_client.h"
 #include "mongo/db/global_catalog/type_collection.h"
@@ -120,7 +120,7 @@ void _appendResponseCollModIndexChanges(
 
 }  // namespace
 
-CollModCoordinator::CollModCoordinator(ShardingDDLCoordinatorService* service,
+CollModCoordinator::CollModCoordinator(ShardingCoordinatorService* service,
                                        const BSONObj& initialState)
     : RecoverableShardingDDLCoordinator(service, "CollModCoordinator", initialState),
       _request{_doc.getCollModRequest()} {}

src/mongo/db/global_catalog/ddl/collmod_coordinator.h

@@ -36,8 +36,8 @@
 #include "mongo/db/global_catalog/ddl/collmod_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_collmod_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/query/write_ops/write_ops.h"
@@ -67,7 +67,7 @@ public:
     using StateDoc = CollModCoordinatorDocument;
     using Phase = CollModCoordinatorPhaseEnum;
 
-    CollModCoordinator(ShardingDDLCoordinatorService* service, const BSONObj& initialState);
+    CollModCoordinator(ShardingCoordinatorService* service, const BSONObj& initialState);
 
     void checkIfOptionsConflict(const BSONObj& doc) const override;
 

src/mongo/db/global_catalog/ddl/collmod_coordinator_document.idl

@@ -38,7 +38,7 @@ global:
 imports:
     - "mongo/db/basic_types.idl"
     - "mongo/db/shard_role/ddl/coll_mod.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/sharding_environment/sharding_types.idl"
 
 enums:
@@ -58,7 +58,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 type: CollModCoordinatorPhase

src/mongo/db/global_catalog/ddl/configsvr_coordinator.h

@@ -101,7 +101,7 @@ protected:
     void _removeStateDocument(OperationContext* opCtx);
 
     /**
-     * Create an `OperationContext`. Provided for consistency with `ShardingDDLCoordinator`,
+     * Create an `OperationContext`. Provided for consistency with `ShardingCoordinator`,
      * which provides a similar method which also sets the `ForwardableOperationMetadata`.
      * Prefer this to `cc().makeOperationContext()`.
      */

src/mongo/db/global_catalog/ddl/configsvr_coordinator_service.cpp

@@ -37,7 +37,7 @@
 #include "mongo/client/dbclient_cursor.h"
 #include "mongo/db/dbdirectclient.h"
 #include "mongo/db/global_catalog/ddl/configsvr_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/query/find_command.h"
 #include "mongo/db/repl/primary_only_service.h"
 #include "mongo/db/topology/cluster_parameters/set_cluster_parameter_coordinator.h"
@@ -161,7 +161,7 @@ void ConfigsvrCoordinatorService::checkIfConflictsWithOtherInstances(
         }
     }
 
-    const auto service = ShardingDDLCoordinatorService::getService(opCtx);
+    const auto service = ShardingCoordinatorService::getService(opCtx);
     if (!service) {
         return;
     }
@@ -169,7 +169,7 @@ void ConfigsvrCoordinatorService::checkIfConflictsWithOtherInstances(
     uassert(ErrorCodes::AddOrRemoveShardInProgress,
             fmt::format("Cannot start {} because a topology change is in progress",
                         idl::serialize(op.getId().getCoordinatorType())),
-            service->areAllCoordinatorsOfTypeFinished(opCtx, DDLCoordinatorTypeEnum::kAddShard));
+            service->areAllCoordinatorsOfTypeFinished(opCtx, CoordinatorTypeEnum::kAddShard));
 }
 
 }  // namespace mongo

src/mongo/db/global_catalog/ddl/configsvr_coordinator_service_test.cpp

@@ -33,7 +33,7 @@
 #include "mongo/bson/bsonobjbuilder.h"
 #include "mongo/db/client.h"
 #include "mongo/db/global_catalog/ddl/configsvr_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/repl/primary_only_service_test_fixture.h"
 #include "mongo/db/repl/storage_interface.h"
 #include "mongo/db/repl/storage_interface_mock.h"
@@ -67,7 +67,7 @@ public:
         repl::StorageInterface::set(serviceContext, std::move(storageMock));
 
         auto registry = repl::PrimaryOnlyServiceRegistry::get(serviceContext);
-        registry->registerService(std::make_unique<ShardingDDLCoordinatorService>(serviceContext));
+        registry->registerService(std::make_unique<ShardingCoordinatorService>(serviceContext));
     }
 
     void tearDown() override {

src/mongo/db/global_catalog/ddl/configsvr_create_database_command.cpp

@@ -163,15 +163,15 @@ public:
                     return Response(dbt.getVersion());
                 } else {
                     CreateDatabaseCoordinatorDocument coordinatorDoc;
-                    coordinatorDoc.setShardingDDLCoordinatorMetadata(
+                    coordinatorDoc.setShardingCoordinatorMetadata(
-                        {{NamespaceString(dbName), DDLCoordinatorTypeEnum::kCreateDatabase}});
+                        {{NamespaceString(dbName), CoordinatorTypeEnum::kCreateDatabase}});
                     coordinatorDoc.setPrimaryShard(optResolvedPrimaryShard);
                     coordinatorDoc.setUserSelectedPrimary(optResolvedPrimaryShard.is_initialized());
                     coordinatorDoc.setAuthoritativeMetadataAccessLevel(
                         authoritativeMetadataAccessLevel);
                     auto createDatabaseCoordinator =
                         checked_pointer_cast<CreateDatabaseCoordinator>(
-                            ShardingDDLCoordinatorService::getService(opCtx)->getOrCreateInstance(
+                            ShardingCoordinatorService::getService(opCtx)->getOrCreateInstance(
                                 opCtx, coordinatorDoc.toBSON(), *fixedFcvRegion));
 
                     fixedFcvRegion.reset();

src/mongo/db/global_catalog/ddl/configsvr_reset_placement_history_command.cpp

@@ -37,7 +37,7 @@
 #include "mongo/db/global_catalog/ddl/initialize_placement_history_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/placement_history_commands_gen.h"
 #include "mongo/db/global_catalog/ddl/sharding_catalog_manager.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/query/query_feature_flags_gen.h"
@@ -104,11 +104,11 @@ public:
             }
 
             InitializePlacementHistoryCoordinatorDocument coordinatorDoc;
-            coordinatorDoc.setShardingDDLCoordinatorMetadata(
+            coordinatorDoc.setShardingCoordinatorMetadata(
                 {{NamespaceString::kConfigsvrPlacementHistoryNamespace,
-                  DDLCoordinatorTypeEnum::kInitializePlacementHistory}});
+                  CoordinatorTypeEnum::kInitializePlacementHistory}});
 
-            auto service = ShardingDDLCoordinatorService::getService(opCtx);
+            auto service = ShardingCoordinatorService::getService(opCtx);
             auto initializePlacementHistoryCoordinator =
                 checked_pointer_cast<InitializePlacementHistoryCoordinator>(
                     service->getOrCreateInstance(

src/mongo/db/global_catalog/ddl/convert_to_capped_coordinator.h

@@ -43,8 +43,7 @@ public:
     using StateDoc = ConvertToCappedCoordinatorDocument;
     using Phase = ConvertToCappedCoordinatorPhaseEnum;
 
-    ConvertToCappedCoordinator(ShardingDDLCoordinatorService* service,
+    ConvertToCappedCoordinator(ShardingCoordinatorService* service, const BSONObj& initialStateDoc)
-                               const BSONObj& initialStateDoc)
         : RecoverableShardingDDLCoordinator(service, "ConvertToCappedCoordinator", initialStateDoc),
           _request(_doc.getShardsvrConvertToCappedRequest()),
           _critSecReason(BSON("convertToCapped" << NamespaceStringUtil::serialize(

src/mongo/db/global_catalog/ddl/convert_to_capped_coordinator_document.idl

@@ -34,7 +34,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/global_catalog/ddl/sharded_ddl_commands.idl"
 
 enums:
@@ -58,7 +58,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
             ShardsvrConvertToCappedRequest: ShardsvrConvertToCappedRequest
         fields:
             phase:

src/mongo/db/global_catalog/ddl/create_collection_coordinator.cpp

@@ -52,8 +52,8 @@
 #include "mongo/db/global_catalog/ddl/shard_key_index_util.h"
 #include "mongo/db/global_catalog/ddl/shard_key_util.h"
 #include "mongo/db/global_catalog/ddl/shard_util.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
 #include "mongo/db/global_catalog/ddl/sharding_recovery_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_util.h"

src/mongo/db/global_catalog/ddl/create_collection_coordinator.h

@@ -36,8 +36,8 @@
 #include "mongo/bson/bsonobjbuilder.h"
 #include "mongo/db/global_catalog/ddl/create_collection_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/global_catalog/shard_key_pattern.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
@@ -110,7 +110,7 @@ public:
     using CoordDoc = CreateCollectionCoordinatorDocument;
     using Phase = CreateCollectionCoordinatorPhaseEnum;
 
-    CreateCollectionCoordinator(ShardingDDLCoordinatorService* service, const BSONObj& initialState)
+    CreateCollectionCoordinator(ShardingCoordinatorService* service, const BSONObj& initialState)
         : RecoverableShardingDDLCoordinator(service, "CreateCollectionCoordinator", initialState),
           _request(_doc.getShardsvrCreateCollectionRequest()),
           _critSecReason(BSON("command"

src/mongo/db/global_catalog/ddl/create_collection_coordinator_document.idl

@@ -35,7 +35,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/global_catalog/ddl/sharded_ddl_commands.idl"
     - "mongo/db/global_catalog/type_collection_common_types.idl"
 
@@ -84,7 +84,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
             ShardsvrCreateCollectionRequest: ShardsvrCreateCollectionRequest
         fields:
             phase:

src/mongo/db/global_catalog/ddl/create_database_coordinator.h

@@ -31,8 +31,8 @@
 
 #include "mongo/db/global_catalog/ddl/create_database_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/global_catalog/type_database_gen.h"
 #include "mongo/util/modules.h"
 
@@ -44,7 +44,7 @@ public:
     using StateDoc = CreateDatabaseCoordinatorDocument;
     using Phase = CreateDatabaseCoordinatorPhaseEnum;
 
-    CreateDatabaseCoordinator(ShardingDDLCoordinatorService* service, const BSONObj& initialState)
+    CreateDatabaseCoordinator(ShardingCoordinatorService* service, const BSONObj& initialState)
         : RecoverableShardingDDLCoordinator(service, "CreateDatabaseCoordinator", initialState),
           _critSecReason(BSON("createDatabase" << DatabaseNameUtil::serialize(
                                   nss().dbName(), SerializationContext::stateCommandRequest()))) {}

src/mongo/db/global_catalog/ddl/create_database_coordinator_document.idl

@@ -32,7 +32,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/sharding_environment/sharding_types.idl"
 
 enums:
@@ -51,7 +51,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 type: CreateDatabaseCoordinatorPhase

src/mongo/db/global_catalog/ddl/drop_collection_coordinator.h

@@ -35,9 +35,9 @@
 #include "mongo/bson/bsonobj.h"
 #include "mongo/bson/bsonobjbuilder.h"
 #include "mongo/db/global_catalog/ddl/drop_collection_coordinator_document_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/query/write_ops/write_ops.h"
@@ -63,7 +63,7 @@ public:
     using StateDoc = DropCollectionCoordinatorDocument;
     using Phase = DropCollectionCoordinatorPhaseEnum;
 
-    DropCollectionCoordinator(ShardingDDLCoordinatorService* service, const BSONObj& initialState)
+    DropCollectionCoordinator(ShardingCoordinatorService* service, const BSONObj& initialState)
         : RecoverableShardingDDLCoordinator(service, "DropCollectionCoordinator", initialState),
           _critSecReason(BSON("command"
                               << "dropCollection"

src/mongo/db/global_catalog/ddl/drop_collection_coordinator_document.idl

@@ -37,7 +37,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/sharding_environment/sharding_types.idl"
 
 enums:
@@ -67,7 +67,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 type: DropCollectionCoordinatorPhase

src/mongo/db/global_catalog/ddl/drop_database_coordinator.h

@@ -35,9 +35,9 @@
 #include "mongo/bson/bsonobj.h"
 #include "mongo/bson/bsonobjbuilder.h"
 #include "mongo/db/global_catalog/ddl/drop_database_coordinator_document_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/global_catalog/type_collection.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
@@ -62,7 +62,7 @@ public:
     using StateDoc = DropDatabaseCoordinatorDocument;
     using Phase = DropDatabaseCoordinatorPhaseEnum;
 
-    DropDatabaseCoordinator(ShardingDDLCoordinatorService* service, const BSONObj& initialState)
+    DropDatabaseCoordinator(ShardingCoordinatorService* service, const BSONObj& initialState)
         : RecoverableShardingDDLCoordinator(service, "DropDatabaseCoordinator", initialState),
           _dbName(nss().dbName()),
           _critSecReason(BSON("dropDatabase" << DatabaseNameUtil::serialize(

src/mongo/db/global_catalog/ddl/drop_database_coordinator_document.idl

@@ -36,7 +36,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/sharding_environment/sharding_types.idl"
 
 enums:
@@ -62,7 +62,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 type: DropDatabaseCoordinatorPhase

src/mongo/db/global_catalog/ddl/drop_indexes_coordinator.cpp

@@ -37,7 +37,7 @@
 
 namespace mongo {
 
-DropIndexesCoordinator::DropIndexesCoordinator(ShardingDDLCoordinatorService* service,
+DropIndexesCoordinator::DropIndexesCoordinator(ShardingCoordinatorService* service,
                                                const BSONObj& initialState)
     : RecoverableShardingDDLCoordinator(service, "DropIndexesCoordinator", initialState),
       _request(_doc.getDropIndexesRequest()) {}

src/mongo/db/global_catalog/ddl/drop_indexes_coordinator.h

@@ -45,7 +45,7 @@ public:
     using StateDoc = DropIndexesCoordinatorDocument;
     using Phase = DropIndexesCoordinatorPhaseEnum;
 
-    DropIndexesCoordinator(ShardingDDLCoordinatorService* service, const BSONObj& initialState);
+    DropIndexesCoordinator(ShardingCoordinatorService* service, const BSONObj& initialState);
 
     void checkIfOptionsConflict(const BSONObj& doc) const override;
 

src/mongo/db/global_catalog/ddl/drop_indexes_coordinator_document.idl

@@ -38,7 +38,7 @@ global:
 imports:
     - "mongo/db/basic_types.idl"
     - "mongo/db/shard_role/ddl/drop_indexes.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/sharding_environment/sharding_types.idl"
 
 enums:
@@ -57,7 +57,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 type: DropIndexesCoordinatorPhase

src/mongo/db/global_catalog/ddl/initialize_placement_history_coordinator.h

@@ -41,7 +41,7 @@ class InitializePlacementHistoryCoordinator final
 public:
     using Phase = InitializePlacementHistoryPhaseEnum;
 
-    InitializePlacementHistoryCoordinator(ShardingDDLCoordinatorService* service,
+    InitializePlacementHistoryCoordinator(ShardingCoordinatorService* service,
                                           const BSONObj& initialState)
         : RecoverableShardingDDLCoordinator(
               service, "InitializePlacementHistoryCoordinator", initialState) {}

src/mongo/db/global_catalog/ddl/initialize_placement_history_coordinator_document.idl

@@ -36,7 +36,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
 
 enums:
     InitializePlacementHistoryPhase:
@@ -57,7 +57,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 type: InitializePlacementHistoryPhase

src/mongo/db/global_catalog/ddl/migration_blocking_operation_coordinator.cpp

@@ -73,12 +73,12 @@ MigrationBlockingOperationCoordinator::getOrCreate(OperationContext* opCtx,
                                                    const NamespaceString& nss) {
     auto coordinatorDoc = [&] {
         StateDoc doc;
-        doc.setShardingDDLCoordinatorMetadata(
+        doc.setShardingCoordinatorMetadata(
-            {{nss, DDLCoordinatorTypeEnum::kMigrationBlockingOperation}});
+            {{nss, CoordinatorTypeEnum::kMigrationBlockingOperation}});
         return doc.toBSON();
     }();
 
-    auto service = ShardingDDLCoordinatorService::getService(opCtx);
+    auto service = ShardingCoordinatorService::getService(opCtx);
     return checked_pointer_cast<MigrationBlockingOperationCoordinator>(
         service->getOrCreateInstance(opCtx, std::move(coordinatorDoc), FixedFCVRegion{opCtx}));
 }
@@ -86,11 +86,11 @@ MigrationBlockingOperationCoordinator::getOrCreate(OperationContext* opCtx,
 boost::optional<std::shared_ptr<MigrationBlockingOperationCoordinator>>
 MigrationBlockingOperationCoordinator::get(OperationContext* opCtx, const NamespaceString& nss) {
     auto coordinatorId = [&] {
-        ShardingDDLCoordinatorId id{nss, DDLCoordinatorTypeEnum::kMigrationBlockingOperation};
+        ShardingCoordinatorId id{nss, CoordinatorTypeEnum::kMigrationBlockingOperation};
         return BSON("_id" << id.toBSON());
     }();
-    auto service = ShardingDDLCoordinatorService::getService(opCtx);
+    auto service = ShardingCoordinatorService::getService(opCtx);
-    auto [maybeInstance, _] = ShardingDDLCoordinator::lookup(opCtx, service, coordinatorId);
+    auto [maybeInstance, _] = ShardingCoordinator::lookup(opCtx, service, coordinatorId);
     if (!maybeInstance) {
         return boost::none;
     }
@@ -98,7 +98,7 @@ MigrationBlockingOperationCoordinator::get(OperationContext* opCtx, const Namesp
 }
 
 MigrationBlockingOperationCoordinator::MigrationBlockingOperationCoordinator(
-    ShardingDDLCoordinatorService* service, const BSONObj& initialState)
+    ShardingCoordinatorService* service, const BSONObj& initialState)
     : RecoverableShardingDDLCoordinator(
           service, "MigrationBlockingOperationCoordinator", initialState),
       _operations{populateOperations(_getDoc())},

src/mongo/db/global_catalog/ddl/migration_blocking_operation_coordinator.h

@@ -43,14 +43,14 @@ public:
     using Phase = MigrationBlockingOperationCoordinatorPhaseEnum;
     using UUIDSet = stdx::unordered_set<UUID, UUID::Hash>;
     using StateDoc = MigrationBlockingOperationCoordinatorDocument;
-    using ShardingDDLCoordinator::getOrCreate;
+    using ShardingCoordinator::getOrCreate;
 
     static std::shared_ptr<MigrationBlockingOperationCoordinator> getOrCreate(
         OperationContext* opCtx, const NamespaceString& nss);
     static boost::optional<std::shared_ptr<MigrationBlockingOperationCoordinator>> get(
         OperationContext* opCtx, const NamespaceString& nss);
 
-    MigrationBlockingOperationCoordinator(ShardingDDLCoordinatorService* service,
+    MigrationBlockingOperationCoordinator(ShardingCoordinatorService* service,
                                           const BSONObj& initialState);
 
     void checkIfOptionsConflict(const BSONObj& stateDoc) const override;

src/mongo/db/global_catalog/ddl/migration_blocking_operation_coordinator.idl

@@ -32,7 +32,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
 
 enums:
     MigrationBlockingOperationCoordinatorPhase:
@@ -46,7 +46,7 @@ structs:
     MigrationBlockingOperationCoordinatorDocument:
         description: State documents for a MigrationBlockingOperationCoordinator.
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 type: MigrationBlockingOperationCoordinatorPhase

src/mongo/db/global_catalog/ddl/migration_blocking_operation_coordinator_test.cpp

@@ -30,7 +30,7 @@
 #include "mongo/db/global_catalog/ddl/migration_blocking_operation_coordinator.h"
 
 #include "mongo/db/global_catalog/ddl/migration_blocking_operation_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_external_state_for_test.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_external_state_for_test.h"
 #include "mongo/db/repl/primary_only_service_test_fixture.h"
 #include "mongo/db/shard_role/shard_catalog/catalog_raii.h"
 #include "mongo/stdx/thread.h"
@@ -50,7 +50,7 @@ constexpr auto kHangBeforeRemovingCoordinatorDocument = "hangBeforeRemovingCoord
 
 class MigrationBlockingOperationCoordinatorTest : public repl::PrimaryOnlyServiceMongoDTest {
 protected:
-    using Service = ShardingDDLCoordinatorService;
+    using Service = ShardingCoordinatorService;
     using Instance = MigrationBlockingOperationCoordinator;
 
     const NamespaceString kNamespace =
@@ -58,22 +58,21 @@ protected:
     const DatabaseVersion kDbVersion{UUID::gen(), Timestamp(1, 0)};
 
     MigrationBlockingOperationCoordinatorTest() {
-        _externalState = std::make_shared<ShardingDDLCoordinatorExternalStateForTest>();
+        _externalState = std::make_shared<ShardingCoordinatorExternalStateForTest>();
         _externalStateFactory =
-            std::make_unique<ShardingDDLCoordinatorExternalStateFactoryForTest>(_externalState);
+            std::make_unique<ShardingCoordinatorExternalStateFactoryForTest>(_externalState);
     }
 
     std::unique_ptr<repl::PrimaryOnlyService> makeService(ServiceContext* serviceContext) override {
         return std::make_unique<Service>(serviceContext, std::move(_externalStateFactory));
     }
 
-    ShardingDDLCoordinatorId getCoordinatorId() const {
+    ShardingCoordinatorId getCoordinatorId() const {
-        return ShardingDDLCoordinatorId{kNamespace,
+        return ShardingCoordinatorId{kNamespace, CoordinatorTypeEnum::kMigrationBlockingOperation};
-                                        DDLCoordinatorTypeEnum::kMigrationBlockingOperation};
     }
 
-    ShardingDDLCoordinatorMetadata createMetadata() const {
+    ShardingCoordinatorMetadata createMetadata() const {
-        ShardingDDLCoordinatorMetadata metadata(getCoordinatorId());
+        ShardingCoordinatorMetadata metadata(getCoordinatorId());
         metadata.setForwardableOpMetadata(ForwardableOperationMetadata(_opCtx));
         metadata.setDatabaseVersion(kDbVersion);
         return metadata;
@@ -82,7 +81,7 @@ protected:
     MigrationBlockingOperationCoordinatorDocument createStateDocument() const {
         MigrationBlockingOperationCoordinatorDocument doc;
         auto metadata = createMetadata();
-        doc.setShardingDDLCoordinatorMetadata(metadata);
+        doc.setShardingCoordinatorMetadata(metadata);
         return doc;
     }
 
@@ -214,8 +213,8 @@ protected:
     ServiceContext::UniqueOperationContext _opCtxHolder;
     OperationContext* _opCtx;
     std::vector<UUID> _operations;
-    std::unique_ptr<ShardingDDLCoordinatorExternalStateFactoryForTest> _externalStateFactory;
+    std::unique_ptr<ShardingCoordinatorExternalStateFactoryForTest> _externalStateFactory;
-    std::shared_ptr<ShardingDDLCoordinatorExternalStateForTest> _externalState;
+    std::shared_ptr<ShardingCoordinatorExternalStateForTest> _externalState;
 };
 
 TEST_F(MigrationBlockingOperationCoordinatorTest, CreateAndDeleteStateDocument) {

src/mongo/db/global_catalog/ddl/move_primary_coordinator.cpp

@@ -124,7 +124,7 @@ bool isMovableUnshardedCollection(const NamespaceString& nss, bool timeseriesRes
 
 }  // namespace
 
-MovePrimaryCoordinator::MovePrimaryCoordinator(ShardingDDLCoordinatorService* service,
+MovePrimaryCoordinator::MovePrimaryCoordinator(ShardingCoordinatorService* service,
                                                const BSONObj& initialState)
     : RecoverableShardingDDLCoordinator(service, "MovePrimaryCoordinator", initialState),
       _dbName(nss().dbName()),

src/mongo/db/global_catalog/ddl/move_primary_coordinator.h

@@ -35,8 +35,8 @@
 #include "mongo/bson/bsonobjbuilder.h"
 #include "mongo/db/database_name.h"
 #include "mongo/db/global_catalog/ddl/move_primary_coordinator_document_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/global_catalog/type_database_gen.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
@@ -66,7 +66,7 @@ public:
     using StateDoc = MovePrimaryCoordinatorDocument;
     using Phase = MovePrimaryCoordinatorPhaseEnum;
 
-    MovePrimaryCoordinator(ShardingDDLCoordinatorService* service, const BSONObj& initialState);
+    MovePrimaryCoordinator(ShardingCoordinatorService* service, const BSONObj& initialState);
     ~MovePrimaryCoordinator() override = default;
 
     void checkIfOptionsConflict(const BSONObj& doc) const override;

src/mongo/db/global_catalog/ddl/move_primary_coordinator_document.idl

@@ -34,7 +34,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/sharding_environment/sharding_types.idl"
 
 enums:
@@ -56,7 +56,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 type: MovePrimaryCoordinatorPhase

src/mongo/db/global_catalog/ddl/refine_collection_shard_key_coordinator.cpp

@@ -131,7 +131,7 @@ std::vector<ShardId> getShardsWithDataForCollection(OperationContext* opCtx,
 }  // namespace
 
 RefineCollectionShardKeyCoordinator::RefineCollectionShardKeyCoordinator(
-    ShardingDDLCoordinatorService* service, const BSONObj& initialState)
+    ShardingCoordinatorService* service, const BSONObj& initialState)
     : RecoverableShardingDDLCoordinator(
           service, "RefineCollectionShardKeyCoordinator", initialState),
       _request(_doc.getRefineCollectionShardKeyRequest()),

src/mongo/db/global_catalog/ddl/refine_collection_shard_key_coordinator.h

@@ -35,8 +35,8 @@
 #include "mongo/bson/bsonobjbuilder.h"
 #include "mongo/db/global_catalog/ddl/refine_collection_shard_key_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/keypattern.h"
 #include "mongo/db/query/write_ops/write_ops.h"
 #include "mongo/executor/scoped_task_executor.h"
@@ -60,7 +60,7 @@ public:
     using StateDoc = RefineCollectionShardKeyCoordinatorDocument;
     using Phase = RefineCollectionShardKeyCoordinatorPhaseEnum;
 
-    RefineCollectionShardKeyCoordinator(ShardingDDLCoordinatorService* service,
+    RefineCollectionShardKeyCoordinator(ShardingCoordinatorService* service,
                                         const BSONObj& initialState);
 
     void checkIfOptionsConflict(const BSONObj& coorDoc) const override;

src/mongo/db/global_catalog/ddl/refine_collection_shard_key_coordinator_document.idl

@@ -35,7 +35,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/global_catalog/ddl/sharded_ddl_commands.idl"
 
 enums:
@@ -56,7 +56,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
             RefineCollectionShardKeyRequest: RefineCollectionShardKeyRequest
         fields:
             phase:

src/mongo/db/global_catalog/ddl/rename_collection_coordinator.cpp

@@ -517,7 +517,7 @@ void checkExpectedTargetIndexesMatch(OperationContext* opCtx,
 }
 }  // namespace
 
-RenameCollectionCoordinator::RenameCollectionCoordinator(ShardingDDLCoordinatorService* service,
+RenameCollectionCoordinator::RenameCollectionCoordinator(ShardingCoordinatorService* service,
                                                          const BSONObj& initialState)
     : RecoverableShardingDDLCoordinator(service, "RenameCollectionCoordinator", initialState),
       _request(_doc.getRenameCollectionRequest()) {}

src/mongo/db/global_catalog/ddl/rename_collection_coordinator.h

@@ -35,8 +35,8 @@
 #include "mongo/bson/bsonobjbuilder.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_rename_collection_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/query/write_ops/write_ops.h"
@@ -61,8 +61,7 @@ public:
     using StateDoc = RenameCollectionCoordinatorDocument;
     using Phase = RenameCollectionCoordinatorPhaseEnum;
 
-    RenameCollectionCoordinator(ShardingDDLCoordinatorService* service,
+    RenameCollectionCoordinator(ShardingCoordinatorService* service, const BSONObj& initialState);
-                                const BSONObj& initialState);
 
     void checkIfOptionsConflict(const BSONObj& doc) const override;
 

src/mongo/db/global_catalog/ddl/rename_collection_participant_service.cpp

@@ -37,7 +37,6 @@
 #include "mongo/db/client.h"
 #include "mongo/db/generic_argument_util.h"
 #include "mongo/db/global_catalog/ddl/drop_collection_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
 #include "mongo/db/global_catalog/ddl/sharding_recovery_service.h"
 #include "mongo/db/global_catalog/sharding_catalog_client.h"

src/mongo/db/global_catalog/ddl/set_allow_migrations.idl

@@ -32,7 +32,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/global_catalog/ddl/sharded_ddl_commands.idl"
 
 commands:

src/mongo/db/global_catalog/ddl/set_allow_migrations_coordinator.h

@@ -34,8 +34,8 @@
 #include "mongo/db/global_catalog/ddl/set_allow_migrations_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/set_allow_migrations_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/executor/scoped_task_executor.h"
 #include "mongo/util/cancellation.h"
@@ -50,12 +50,12 @@
 namespace mongo {
 
 class SetAllowMigrationsCoordinator final
-    : public ShardingDDLCoordinatorImpl<SetAllowMigrationsCoordinatorDocument> {
+    : public NonRecoverableShardingDDLCoordinator<SetAllowMigrationsCoordinatorDocument> {
 
 public:
-    SetAllowMigrationsCoordinator(ShardingDDLCoordinatorService* service,
+    SetAllowMigrationsCoordinator(ShardingCoordinatorService* service, const BSONObj& initialState)
-                                  const BSONObj& initialState)
+        : NonRecoverableShardingDDLCoordinator(
-        : ShardingDDLCoordinatorImpl(service, "SetAllowMigrationsCoordinator", initialState),
+              service, "SetAllowMigrationsCoordinator", initialState),
           _allowMigrations(_doc.getAllowMigrations()) {}
 
     void checkIfOptionsConflict(const BSONObj& coorDoc) const override;

src/mongo/db/global_catalog/ddl/set_allow_migrations_coordinator_document.idl

@@ -35,7 +35,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/global_catalog/ddl/sharded_ddl_commands.idl"
 
 structs:
@@ -44,5 +44,5 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
             SetAllowMigrationsRequest: SetAllowMigrationsRequest

src/mongo/db/global_catalog/ddl/sharded_rename_collection.idl

@@ -37,7 +37,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/global_catalog/ddl/sharded_ddl_commands.idl"
 
 enums:
@@ -115,7 +115,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
             RenameCollectionRequest: RenameCollectionRequest
         fields:
             phase:

src/mongo/db/global_catalog/ddl/sharding_coordinator.cpp

@@ -28,13 +28,13 @@
  */
 
 
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator.h"
 
 #include "mongo/base/status_with.h"
 #include "mongo/bson/bsonelement.h"
 #include "mongo/db/database_name.h"
 #include "mongo/db/dbdirectclient.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
 #include "mongo/db/global_catalog/sharding_catalog_client.h"
 #include "mongo/db/query/write_ops/write_ops_gen.h"
@@ -85,7 +85,7 @@ const Backoff kExponentialBackoff(Seconds(1), Milliseconds::max());
 }  // namespace
 
 template <typename T>
-ExecutorFuture<void> ShardingDDLCoordinator::_acquireLockAsync(
+ExecutorFuture<void> ShardingCoordinator::_acquireLockAsync(
     std::shared_ptr<executor::ScopedTaskExecutor> executor,
     const CancellationToken& token,
     const T& resource,
@@ -113,22 +113,22 @@ ExecutorFuture<void> ShardingDDLCoordinator::_acquireLockAsync(
                                              "mode"_attr = modeName(lockMode),
                                              "error"_attr = redact(status)});
             }
-            // Sharding DDL operations are not rollbackable so in case we recovered a coordinator
+            // Coordinators can't generally be rolled back so in case we recovered a coordinator
-            // from disk we need to ensure eventual completion of the DDL operation, so we must
+            // from disk we need to ensure eventual completion of the operation, so we must retry
-            // retry until we manage to acquire the lock.
+            // until we manage to acquire the lock.
             return (!_recoveredFromDisk) || status.isOK();
         })
         .withBackoffBetweenIterations(kExponentialBackoff)
         .on(**executor, token);
 }
 
-ShardingDDLCoordinatorMetadata extractShardingDDLCoordinatorMetadata(const BSONObj& coorDoc) {
+ShardingCoordinatorMetadata extractShardingCoordinatorMetadata(const BSONObj& coorDoc) {
-    return ShardingDDLCoordinatorMetadata::parse(
+    return ShardingCoordinatorMetadata::parse(coorDoc,
-        coorDoc, IDLParserContext("ShardingDDLCoordinatorMetadata"));
+                                              IDLParserContext("ShardingCoordinatorMetadata"));
 }
 
-// Enables propagation of the versionContext (OFCV) to sub-operations of this ShardingDDLCoordinator
+// Enables propagation of the versionContext (OFCV) to sub-operations of this ShardingCoordinator
-// for network calls. For ShardingDDLCoordinators, this is safe since their metadata is persisted to
+// for network calls. For ShardingCoordinator, this is safe since their metadata is persisted to
 // disk, which allows setFCV to drain them before it proceeding to the metadata cleanup phase.
 ForwardableOperationMetadata enableVersionContextPropagation(
     ForwardableOperationMetadata forwardableOperationMetadata) {
@@ -140,19 +140,19 @@ ForwardableOperationMetadata enableVersionContextPropagation(
     return forwardableOperationMetadata;
 }
 
-ShardingDDLCoordinator::ShardingDDLCoordinator(ShardingDDLCoordinatorService* service,
+ShardingCoordinator::ShardingCoordinator(ShardingCoordinatorService* service,
-                                               const BSONObj& coorDoc)
+                                         const BSONObj& coorDoc)
     : _service(service),
-      _coordId(extractShardingDDLCoordinatorMetadata(coorDoc).getId()),
+      _coordId(extractShardingCoordinatorMetadata(coorDoc).getId()),
-      _recoveredFromDisk(extractShardingDDLCoordinatorMetadata(coorDoc).getRecoveredFromDisk()),
+      _recoveredFromDisk(extractShardingCoordinatorMetadata(coorDoc).getRecoveredFromDisk()),
       _forwardableOpMetadata(
-          extractShardingDDLCoordinatorMetadata(coorDoc).getForwardableOpMetadata().map(
+          extractShardingCoordinatorMetadata(coorDoc).getForwardableOpMetadata().map(
               enableVersionContextPropagation)),
-      _databaseVersion(extractShardingDDLCoordinatorMetadata(coorDoc).getDatabaseVersion()),
+      _databaseVersion(extractShardingCoordinatorMetadata(coorDoc).getDatabaseVersion()),
       _firstExecution(!_recoveredFromDisk),
       _externalState(_service->createExternalState()) {}
 
-ShardingDDLCoordinator::~ShardingDDLCoordinator() {
+ShardingCoordinator::~ShardingCoordinator() {
     tassert(10644519,
             "Expected _constructionCompletionPromise to be ready",
             _constructionCompletionPromise.getFuture().isReady());
@@ -161,7 +161,7 @@ ShardingDDLCoordinator::~ShardingDDLCoordinator() {
             _completionPromise.getFuture().isReady());
 }
 
-ExecutorFuture<bool> ShardingDDLCoordinator::_removeDocumentUntillSuccessOrStepdown(
+ExecutorFuture<bool> ShardingCoordinator::_removeDocumentUntillSuccessOrStepdown(
     std::shared_ptr<executor::TaskExecutor> executor) {
     return AsyncTry([this, anchor = shared_from_this()] {
                auto opCtxHolder = makeOperationContext();
@@ -181,7 +181,7 @@ ExecutorFuture<bool> ShardingDDLCoordinator::_removeDocumentUntillSuccessOrStepd
         .on(executor, CancellationToken::uncancelable());
 }
 
-bool ShardingDDLCoordinator::_removeDocument(OperationContext* opCtx) {
+bool ShardingCoordinator::_removeDocument(OperationContext* opCtx) {
     // Checkpoint configTime and topologyTime to guarantee causality with respect to DDL operations
     _getExternalState()->waitForVectorClockDurable(opCtx);
 
@@ -192,7 +192,7 @@ bool ShardingDDLCoordinator::_removeDocument(OperationContext* opCtx) {
 
         deleteOp.setDeletes({[&] {
             write_ops::DeleteOpEntry entry;
-            entry.setQ(BSON(ShardingDDLCoordinatorMetadata::kIdFieldName << _coordId.toBSON()));
+            entry.setQ(BSON(ShardingCoordinatorMetadata::kIdFieldName << _coordId.toBSON()));
             entry.setMulti(true);
             return entry;
         }()});
@@ -218,7 +218,7 @@ bool ShardingDDLCoordinator::_removeDocument(OperationContext* opCtx) {
 }
 
 
-ExecutorFuture<void> ShardingDDLCoordinator::_translateTimeseriesNss(
+ExecutorFuture<void> ShardingCoordinator::_translateTimeseriesNss(
     std::shared_ptr<executor::ScopedTaskExecutor> executor, const CancellationToken& token) {
 
     return AsyncTry([this] {
@@ -242,16 +242,16 @@ ExecutorFuture<void> ShardingDDLCoordinator::_translateTimeseriesNss(
                                   logAttrs(originalNss().makeTimeseriesBucketsNamespace()),
                                   "error"_attr = redact(status)});
             }
-            // Sharding DDL operations are not rollbackable so in case we recovered a coordinator
+            // Coordinators can't generally be rolled back so in case we recovered a coordinator
-            // from disk we need to ensure eventual completion of the operation, so we must
+            // from disk we need to ensure eventual completion of the operation, so we must keep
-            // retry keep retrying until success.
+            // retrying until success.
             return (!_recoveredFromDisk) || status.isOK();
         })
         .withBackoffBetweenIterations(kExponentialBackoff)
         .on(**executor, token);
 }
 
-ExecutorFuture<void> ShardingDDLCoordinator::_acquireAllLocksAsync(
+ExecutorFuture<void> ShardingCoordinator::_acquireAllLocksAsync(
     OperationContext* opCtx,
     std::shared_ptr<executor::ScopedTaskExecutor> executor,
     const CancellationToken& token) {
@@ -277,7 +277,7 @@ ExecutorFuture<void> ShardingDDLCoordinator::_acquireAllLocksAsync(
 
         // Acquiring the database DDL lock
         const auto normalizedDbName = [&] {
-            if (_coordId.getOperationType() != DDLCoordinatorTypeEnum::kCreateDatabase) {
+            if (_coordId.getOperationType() != CoordinatorTypeEnum::kCreateDatabase) {
                 // Already existing databases are not allowed to have their names differ just on
                 // case. Uses the requested database name directly.
                 return lockNss.dbName();
@@ -315,21 +315,21 @@ ExecutorFuture<void> ShardingDDLCoordinator::_acquireAllLocksAsync(
 }
 
 
-ExecutorFuture<void> ShardingDDLCoordinator::_cleanupOnAbort(
+ExecutorFuture<void> ShardingCoordinator::_cleanupOnAbort(
     std::shared_ptr<executor::ScopedTaskExecutor> executor,
     const CancellationToken& token,
     const Status& status) noexcept {
     return ExecutorFuture<void>(**executor);
 }
 
-boost::optional<Status> ShardingDDLCoordinator::getAbortReason() const {
+boost::optional<Status> ShardingCoordinator::getAbortReason() const {
     return boost::none;
 }
 
-void ShardingDDLCoordinator::interrupt(Status status) {
+void ShardingCoordinator::interrupt(Status status) {
     LOGV2_DEBUG(5390535,
                 1,
-                "Sharding DDL Coordinator received an interrupt",
+                "Sharding Coordinator received an interrupt",
                 logv2::DynamicAttributes{getCoordinatorLogAttrs(), "reason"_attr = redact(status)});
 
     // Resolve any unresolved promises to avoid hanging.
@@ -342,14 +342,14 @@ void ShardingDDLCoordinator::interrupt(Status status) {
     }
 }
 
-logv2::DynamicAttributes ShardingDDLCoordinator::getBasicCoordinatorAttrs() const {
+logv2::DynamicAttributes ShardingCoordinator::getBasicCoordinatorAttrs() const {
     logv2::DynamicAttributes attrs;
     attrs.add("coordinatorId", _coordId);
     return attrs;
 }
 
-SemiFuture<void> ShardingDDLCoordinator::run(std::shared_ptr<executor::ScopedTaskExecutor> executor,
+SemiFuture<void> ShardingCoordinator::run(std::shared_ptr<executor::ScopedTaskExecutor> executor,
-                                             const CancellationToken& token) noexcept {
+                                          const CancellationToken& token) noexcept {
     return ExecutorFuture<void>(**executor)
         .then([this, executor, token, anchor = shared_from_this()] {
             auto opCtxHolder = makeOperationContext();
@@ -378,7 +378,7 @@ SemiFuture<void> ShardingDDLCoordinator::run(std::shared_ptr<executor::ScopedTas
         })
         .then([this, executor, token, anchor = shared_from_this()] {
             if (!originalNss().isConfigDB() && !originalNss().isAdminDB() && !_recoveredFromDisk &&
-                operationType() != DDLCoordinatorTypeEnum::kCreateDatabase) {
+                operationType() != CoordinatorTypeEnum::kCreateDatabase) {
                 auto opCtxHolder = makeOperationContext();
                 auto* opCtx = opCtxHolder.get();
 
@@ -414,20 +414,20 @@ SemiFuture<void> ShardingDDLCoordinator::run(std::shared_ptr<executor::ScopedTas
             hangBeforeRunningCoordinatorInstance.pauseWhileSet();
         })
         .onError([this, token, anchor = shared_from_this()](const Status& status) {
-            // The construction of a DDL coordinator recovered from disk can only fail due to
+            // Coordinators that can't be aborted can only fail due to stepdown/shutdown.
-            // stepdown/shutdown.
             tassert(10644523,
-                    "Expected recovered sharding DDL coordinator to be reconstructed successfully",
+                    "Expected recovered coordinator to be reconstructed successfully",
                     !_recoveredFromDisk ||
                         (token.isCanceled() &&
                          (status.isA<ErrorCategory::CancellationError>() ||
                           status.isA<ErrorCategory::NotPrimaryError>())));
 
-            // Ensure coordinator cleanup if the document has not been saved.
+            // Ensure cleanup if the coordinator wasn't recovered from disk. Otherwise, it will be
+            // recovered again on step up, so don't clean up.
             _completeOnError = !_recoveredFromDisk;
 
             static constexpr auto& errorMsg =
-                "Failed to complete construction of sharding DDL coordinator";
+                "Failed to complete construction of sharding coordinator";
             LOGV2_ERROR(
                 5390530,
                 errorMsg,
@@ -492,7 +492,7 @@ SemiFuture<void> ShardingDDLCoordinator::run(std::shared_ptr<executor::ScopedTas
                     if (shouldRetry) {
                         _firstExecution = false;
                         LOGV2_INFO(5656000,
-                                   "Re-executing sharding DDL coordinator",
+                                   "Re-executing sharding coordinator",
                                    logv2::DynamicAttributes{getCoordinatorLogAttrs(),
                                                             "reason"_attr = redact(status)});
                     }
@@ -520,7 +520,7 @@ SemiFuture<void> ShardingDDLCoordinator::run(std::shared_ptr<executor::ScopedTas
 
             bool isSteppingDown = token.isCanceled();
 
-            // Remove the ddl coordinator and release locks if the execution was successfull or if
+            // Remove the coordinator and release locks if the execution was successful or if
             // there was any error and we have the _completeOnError flag set or if we are not
             // stepping down.
             auto cleanup = [&]() {
@@ -532,16 +532,15 @@ SemiFuture<void> ShardingDDLCoordinator::run(std::shared_ptr<executor::ScopedTas
                     if (!completionStatus.isOK()) {
                         LOGV2_ERROR(
                             7524000,
-                            "Failed sharding DDL coordinator",
+                            "Failed sharding coordinator",
                             logv2::DynamicAttributes{getCoordinatorLogAttrs(),
                                                      "reason"_attr = redact(completionStatus)});
                     }
 
                     hangBeforeRemovingCoordinatorDocument.pauseWhileSet();
 
-                    LOGV2(5565601,
+                    LOGV2(
-                          "Releasing sharding DDL coordinator",
+                        5565601, "Releasing sharding coordinator", "coordinatorId"_attr = _coordId);
-                          "coordinatorId"_attr = _coordId);
 
                     // We need to execute this in another executor to ensure the remove work is
                     // done.
@@ -552,7 +551,7 @@ SemiFuture<void> ShardingDDLCoordinator::run(std::shared_ptr<executor::ScopedTas
                     if (!docWasRemoved) {
                         // Release the instance without interrupting it.
                         _service->releaseInstance(
-                            BSON(ShardingDDLCoordinatorMetadata::kIdFieldName << _coordId.toBSON()),
+                            BSON(ShardingCoordinatorMetadata::kIdFieldName << _coordId.toBSON()),
                             Status::OK());
                     }
 
@@ -565,10 +564,9 @@ SemiFuture<void> ShardingDDLCoordinator::run(std::shared_ptr<executor::ScopedTas
                     isSteppingDown = completionStatus.isA<ErrorCategory::NotPrimaryError>() ||
                         completionStatus.isA<ErrorCategory::ShutdownError>() ||
                         completionStatus.isA<ErrorCategory::CancellationError>();
-                    tassert(
+                    tassert(10644525,
-                        10644525,
+                            "Sharding coordinator cleanup failed for a reason other than stepdown",
-                        "Sharding DDL coordinator cleanup failed for a reason other than stepdown",
+                            isSteppingDown);
-                        isSteppingDown);
                 }
             }
 
@@ -587,7 +585,7 @@ SemiFuture<void> ShardingDDLCoordinator::run(std::shared_ptr<executor::ScopedTas
         .semi();
 }
 
-bool ShardingDDLCoordinator::_isRetriableErrorForDDLCoordinator(const Status& status) {
+bool ShardingCoordinator::_isRetriableErrorForDDLCoordinator(const Status& status) {
     return status.isA<ErrorCategory::CursorInvalidatedError>() ||
         status.isA<ErrorCategory::ShutdownError>() || status.isA<ErrorCategory::RetriableError>() ||
         status.isA<ErrorCategory::Interruption>() ||
@@ -598,7 +596,7 @@ bool ShardingDDLCoordinator::_isRetriableErrorForDDLCoordinator(const Status& st
         status == ErrorCodes::CommandNotFound;
 }
 
-ShardingDDLCoordinatorExternalState* ShardingDDLCoordinator::_getExternalState() {
+ShardingCoordinatorExternalState* ShardingCoordinator::_getExternalState() {
     return _externalState.get();
 }
 

src/mongo/db/global_catalog/ddl/sharding_coordinator.h

@@ -0,0 +1,580 @@
+/**
+ *    Copyright (C) 2020-present MongoDB, Inc.
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the Server Side Public License, version 1,
+ *    as published by MongoDB, Inc.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    Server Side Public License for more details.
+ *
+ *    You should have received a copy of the Server Side Public License
+ *    along with this program. If not, see
+ *    <http://www.mongodb.com/licensing/server-side-public-license>.
+ *
+ *    As a special exception, the copyright holders give permission to link the
+ *    code of portions of this program with the OpenSSL library under certain
+ *    conditions as described in each individual source file and distribute
+ *    linked combinations including the program with the OpenSSL library. You
+ *    must comply with the Server Side Public License in all respects for
+ *    all of the code used other than as permitted herein. If you modify file(s)
+ *    with this exception, you may extend this exception to your version of the
+ *    file(s), but you are not obligated to do so. If you do not wish to do so,
+ *    delete this exception statement from your version. If you delete this
+ *    exception statement from all source files in the program, then also delete
+ *    it in the license file.
+ */
+
+#pragma once
+
+#include "mongo/base/error_codes.h"
+#include "mongo/base/status.h"
+#include "mongo/base/string_data.h"
+#include "mongo/bson/bsonmisc.h"
+#include "mongo/bson/bsonobj.h"
+#include "mongo/bson/bsonobjbuilder.h"
+#include "mongo/db/client.h"
+#include "mongo/db/generic_argument_util.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
+#include "mongo/db/namespace_string.h"
+#include "mongo/db/operation_context.h"
+#include "mongo/db/persistent_task_store.h"
+#include "mongo/db/pipeline/process_interface/mongo_process_interface.h"
+#include "mongo/db/repl/primary_only_service.h"
+#include "mongo/db/repl/replication_coordinator.h"
+#include "mongo/db/repl/wait_for_majority_service.h"
+#include "mongo/db/s/forwardable_operation_metadata.h"
+#include "mongo/db/s/primary_only_service_helpers/all_shards_and_config_causality_barrier.h"
+#include "mongo/db/s/primary_only_service_helpers/operation_session_tracker.h"
+#include "mongo/db/service_context.h"
+#include "mongo/db/session/logical_session_id_gen.h"
+#include "mongo/db/shard_role/ddl/ddl_lock_manager.h"
+#include "mongo/db/shard_role/lock_manager/lock_manager_defs.h"
+#include "mongo/db/shard_role/transaction_resources.h"
+#include "mongo/db/versioning_protocol/database_version.h"
+#include "mongo/executor/scoped_task_executor.h"
+#include "mongo/executor/task_executor.h"
+#include "mongo/idl/idl_parser.h"
+#include "mongo/logv2/log.h"
+#include "mongo/stdx/mutex.h"
+#include "mongo/util/assert_util.h"
+#include "mongo/util/cancellation.h"
+#include "mongo/util/future.h"
+#include "mongo/util/future_impl.h"
+#include "mongo/util/modules.h"
+#include "mongo/util/namespace_string_util.h"
+#include "mongo/util/version/releases.h"
+
+#include <memory>
+#include <set>
+#include <stack>
+#include <string>
+#include <utility>
+
+#include <boost/move/utility_core.hpp>
+#include <boost/optional/optional.hpp>
+
+#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kSharding
+
+namespace mongo {
+
+MONGO_MOD_NEEDS_REPLACEMENT ShardingCoordinatorMetadata
+extractShardingCoordinatorMetadata(const BSONObj& coorDoc);
+
+class MONGO_MOD_NEEDS_REPLACEMENT ShardingCoordinator
+    : public repl::PrimaryOnlyService::TypedInstance<ShardingCoordinator> {
+public:
+    explicit ShardingCoordinator(ShardingCoordinatorService* service, const BSONObj& coorDoc);
+
+    ~ShardingCoordinator() override;
+
+    /**
+     * Whether this coordinator is allowed to start when user write blocking is enabled, even if the
+     * writeBlockingBypass flag is not set. Coordinators that don't affect user data shall always be
+     * allowed to run even when user write blocking is enabled.
+     */
+    virtual bool canAlwaysStartWhenUserWritesAreDisabled() const {
+        return false;
+    }
+
+    /*
+     * Returns a future that will be completed when the construction of this coordinator instance
+     * is completed.
+     *
+     * In particular the returned future will be ready only after this coordinator successfully
+     * acquires the required locks.
+     */
+    SharedSemiFuture<void> getConstructionCompletionFuture() {
+        return _constructionCompletionPromise.getFuture();
+    }
+
+    /*
+     * Returns a future that will be ready when all the work associated with this coordinator
+     * instances will be completed.
+     *
+     * In particular the returned future will be ready after this coordinator will successfully
+     * release all the acquired locks.
+     */
+    SharedSemiFuture<void> getCompletionFuture() {
+        return _completionPromise.getFuture();
+    }
+
+    CoordinatorTypeEnum operationType() const {
+        return _coordId.getOperationType();
+    }
+
+    const ForwardableOperationMetadata& getForwardableOpMetadata() const {
+        tassert(10644500, "Expected _forwardableOpMetadata to be set", _forwardableOpMetadata);
+        return _forwardableOpMetadata.get();
+    }
+
+    // TODO SERVER-99655: update once the operationFCV is always present for sharded DDLs
+    boost::optional<multiversion::FeatureCompatibilityVersion> getOperationFCV() const {
+        const auto versionContext = getForwardableOpMetadata().getVersionContext();
+        tassert(10644501,
+                "Expected either no versionContext, or a versionContext with an operation FCV",
+                !versionContext || versionContext->getOperationFCV(VersionContext::Passkey()));
+        return versionContext
+            ? boost::make_optional(
+                  versionContext->getOperationFCV(VersionContext::Passkey())->getVersion())
+            : boost::none;
+    }
+
+    const boost::optional<mongo::DatabaseVersion>& getDatabaseVersion() const {
+        return _databaseVersion;
+    }
+
+protected:
+    const NamespaceString& originalNss() const {
+        return _coordId.getNss();
+    }
+
+    virtual const NamespaceString& nss() const {
+        if (const auto& bucketNss = metadata().getBucketNss()) {
+            return bucketNss.get();
+        }
+        return originalNss();
+    }
+
+    virtual std::set<NamespaceString> _getAdditionalLocksToAcquire(OperationContext* opCtx) {
+        return {};
+    }
+
+    virtual ShardingCoordinatorMetadata const& metadata() const = 0;
+    virtual void setMetadata(ShardingCoordinatorMetadata&& metadata) = 0;
+
+    /**
+     * Returns a set of basic coordinator attributes to be used for logging.
+     */
+    logv2::DynamicAttributes getBasicCoordinatorAttrs() const;
+
+    /**
+     * Returns the set of attributes to be used for coordinator logging. Implementations must be
+     * sure to return a DynamicAttributes object that starts with the attributes returned by
+     * getBasicCoordinatorAttrs().
+     */
+    virtual logv2::DynamicAttributes getCoordinatorLogAttrs() const {
+        return getBasicCoordinatorAttrs();
+    }
+
+    /*
+     * Specify if the coordinator must indefinitely be retried in case of exceptions. It is always
+     * expected for a coordinator to make progress after performing intermediate operations that
+     * can't be rolled back.
+     */
+    virtual bool _mustAlwaysMakeProgress() {
+        return false;
+    };
+
+    /*
+     * Specify if the given error will be retried by the coordinator infrastructure.
+     */
+    bool _isRetriableErrorForDDLCoordinator(const Status& status);
+
+    ShardingCoordinatorExternalState* _getExternalState();
+
+    /**
+     * Create an `OperationContext` with the `ForwardableOperationMetadata` from the coordinator
+     * document set on it. Use this instead of `cc().makeOperationContext()`.
+     */
+    ServiceContext::UniqueOperationContext makeOperationContext() {
+        auto opCtxHolder = cc().makeOperationContext();
+        getForwardableOpMetadata().setOn(opCtxHolder.get());
+        return opCtxHolder;
+    }
+
+    ShardingCoordinatorService* _service;
+    const ShardingCoordinatorId _coordId;
+
+    const bool _recoveredFromDisk;
+    const boost::optional<mongo::ForwardableOperationMetadata> _forwardableOpMetadata;
+    const boost::optional<mongo::DatabaseVersion> _databaseVersion;
+    boost::optional<NamespaceString> _bucketNss;
+
+    bool _firstExecution{
+        true};  // True only when executing the coordinator for the first time (meaning it's not a
+                // retry after a retryable error nor a recovered instance from a previous primary)
+    bool _completeOnError{false};
+
+private:
+    SemiFuture<void> run(std::shared_ptr<executor::ScopedTaskExecutor> executor,
+                         const CancellationToken& token) noexcept final;
+
+    virtual ExecutorFuture<void> _runImpl(std::shared_ptr<executor::ScopedTaskExecutor> executor,
+                                          const CancellationToken& token) noexcept = 0;
+
+    virtual ExecutorFuture<void> _cleanupOnAbort(
+        std::shared_ptr<executor::ScopedTaskExecutor> executor,
+        const CancellationToken& token,
+        const Status& status) noexcept;
+
+    virtual void _onCleanup(OperationContext* opCtx) {}
+
+    void interrupt(Status status) final;
+
+    bool _removeDocument(OperationContext* opCtx);
+
+    ExecutorFuture<bool> _removeDocumentUntillSuccessOrStepdown(
+        std::shared_ptr<executor::TaskExecutor> executor);
+
+    ExecutorFuture<void> _acquireAllLocksAsync(
+        OperationContext* opCtx,
+        std::shared_ptr<executor::ScopedTaskExecutor> executor,
+        const CancellationToken& token);
+
+    template <typename T>
+    ExecutorFuture<void> _acquireLockAsync(std::shared_ptr<executor::ScopedTaskExecutor> executor,
+                                           const CancellationToken& token,
+                                           const T& resource,
+                                           LockMode lockMode);
+
+    ExecutorFuture<void> _translateTimeseriesNss(
+        std::shared_ptr<executor::ScopedTaskExecutor> executor, const CancellationToken& token);
+
+    virtual boost::optional<Status> getAbortReason() const;
+
+    stdx::mutex _mutex;
+    SharedPromise<void> _constructionCompletionPromise;
+    SharedPromise<void> _completionPromise;
+
+    // A Locker object works attached to an opCtx and it's destroyed once the opCtx gets out of
+    // scope. However, we must keep alive a unique Locker object during the whole
+    // ShardingCoordinator life to preserve the lock state among all the executor tasks.
+    std::unique_ptr<Locker> _locker;
+
+    std::stack<DDLLockManager::ScopedBaseDDLLock> _scopedLocks;
+    std::shared_ptr<ShardingCoordinatorExternalState> _externalState;
+
+    friend class ShardingCoordinatorTest;
+};
+
+template <class StateDoc>
+class MONGO_MOD_NEEDS_REPLACEMENT NonRecoverableShardingCoordinator : public ShardingCoordinator {
+public:
+    boost::optional<BSONObj> reportForCurrentOp(
+        MongoProcessInterface::CurrentOpConnectionsMode connMode,
+        MongoProcessInterface::CurrentOpSessionsMode sessionMode) noexcept override {
+        return basicReportBuilder().obj();
+    }
+
+protected:
+    NonRecoverableShardingCoordinator(ShardingCoordinatorService* service,
+                                      const std::string& name,
+                                      const BSONObj& initialStateDoc)
+        : ShardingCoordinator(service, initialStateDoc),
+          _coordinatorName(name),
+          /*
+           * Force a deserialisation + serialisation of the initialStateDoc to ensure that
+           * _initialState is a full deep copy of the received parameter.
+           */
+          _initialState(
+              StateDoc::parse(initialStateDoc, IDLParserContext("CoordinatorInitialState"))
+                  .toBSON()),
+          _doc(StateDoc::parse(_initialState, IDLParserContext("CoordinatorDocument"))) {}
+
+    ShardingCoordinatorMetadata const& metadata() const override {
+        return _doc.getShardingCoordinatorMetadata();
+    }
+
+    void setMetadata(ShardingCoordinatorMetadata&& metadata) override {
+        stdx::lock_guard lk{_docMutex};
+        _doc.setShardingCoordinatorMetadata(std::move(metadata));
+    }
+
+    virtual void appendCommandInfo(BSONObjBuilder* cmdInfoBuilder) const {};
+
+    virtual BSONObjBuilder basicReportBuilder() const noexcept {
+        BSONObjBuilder bob;
+
+        // Append static info
+        bob.append("type", "op");
+        bob.append(
+            "ns",
+            NamespaceStringUtil::serialize(originalNss(), SerializationContext::stateDefault()));
+        bob.append("desc", _coordinatorName);
+        bob.append("op", "command");
+        bob.append("active", true);
+
+        // Append dynamic fields from the state doc
+        {
+            stdx::lock_guard lk{_docMutex};
+            if (const auto& bucketNss = _doc.getBucketNss()) {
+                // Bucket namespace is only present in case the collection is a sharded timeseries
+                bob.append("bucketNamespace",
+                           NamespaceStringUtil::serialize(bucketNss.get(),
+                                                          SerializationContext::stateDefault()));
+            }
+        }
+
+        // Create command description
+        BSONObjBuilder cmdInfoBuilder;
+        {
+            stdx::lock_guard lk{_docMutex};
+            if (const auto& optComment = getForwardableOpMetadata().getComment()) {
+                cmdInfoBuilder.append(optComment.get().firstElement());
+            }
+        }
+        appendCommandInfo(&cmdInfoBuilder);
+        bob.append("command", cmdInfoBuilder.obj());
+
+        return bob;
+    }
+
+    const std::string _coordinatorName;
+    const BSONObj _initialState;
+    mutable stdx::mutex _docMutex;
+    StateDoc _doc;
+};
+
+template <class StateDoc, class Phase>
+class MONGO_MOD_UNFORTUNATELY_OPEN RecoverableShardingCoordinator
+    : public NonRecoverableShardingCoordinator<StateDoc>,
+      public OperationSessionPersistence {
+protected:
+    using NonRecoverableShardingCoordinator<StateDoc>::_doc;
+    using NonRecoverableShardingCoordinator<StateDoc>::_docMutex;
+
+    RecoverableShardingCoordinator(ShardingCoordinatorService* service,
+                                   const std::string& name,
+                                   const BSONObj& initialStateDoc)
+        : NonRecoverableShardingCoordinator<StateDoc>(service, name, initialStateDoc),
+          _sessionTracker(this) {}
+
+    virtual StringData serializePhase(const Phase& phase) const = 0;
+
+    /**
+     * Advances and persists the txnNumber to ensure causality between requests, then returns the
+     * updated operation session information (OSI).
+     */
+    OperationSessionInfo getNewSession(OperationContext* opCtx) {
+        return _sessionTracker.getNextSession(opCtx);
+    }
+
+    /**
+     * Releases the current session back to the InternalSessionPool and clears the persisted
+     * session state. No-op if no session is currently held.
+     */
+    void releaseSession(OperationContext* opCtx) {
+        _sessionTracker.releaseSession(opCtx);
+    }
+
+    /**
+     * Advances the session and performs the given causality barrier, ensuring that subsequent
+     * reads on the barrier's participants will reflect all prior writes.
+     */
+    void performCausalityBarrier(OperationContext* opCtx, CausalityBarrier& barrier) {
+        _sessionTracker.performCausalityBarrier(opCtx, barrier);
+    }
+
+    std::function<void()> _buildPhaseHandler(const Phase& newPhase,
+                                             std::function<void(OperationContext*)>&& handlerFn) {
+        return _buildPhaseHandler(
+            newPhase, [](OperationContext*) { return true; }, std::move(handlerFn));
+    }
+
+    std::function<void()> _buildPhaseHandler(const Phase& newPhase,
+                                             std::function<bool(OperationContext*)>&& shouldExecute,
+                                             std::function<void(OperationContext*)>&& handlerFn) {
+        return [=, this] {
+            const auto currPhase = _getDoc().getPhase();
+
+            if (currPhase > newPhase) {
+                // Do not execute this phase if we already reached a subsequent one.
+                return;
+            }
+
+            auto opCtxHolder = this->makeOperationContext();
+            auto* opCtx = opCtxHolder.get();
+
+            if (!shouldExecute(opCtx)) {
+                // Do not execute the phase if the passed in condition is not met.
+                return;
+            }
+
+            if (currPhase < newPhase) {
+                // Persist the new phase if this is the first time we are executing it.
+                _enterPhase(newPhase);
+            }
+
+            return handlerFn(opCtx);
+        };
+    }
+
+    auto _getDoc() const {
+        stdx::lock_guard lk{_docMutex};
+        return _doc;
+    }
+
+    void _enterPhase(const Phase& newPhase) {
+        auto newDoc = _getDoc();
+
+        newDoc.setPhase(newPhase);
+
+        LOGV2_DEBUG(5390501,
+                    2,
+                    "sharding coordinator phase transition",
+                    "coordinatorId"_attr = _doc.getId(),
+                    "newPhase"_attr = serializePhase(newDoc.getPhase()),
+                    "oldPhase"_attr = serializePhase(_doc.getPhase()));
+
+        ServiceContext::UniqueOperationContext uniqueOpCtx;
+        auto opCtx = cc().getOperationContext();
+        if (!opCtx) {
+            uniqueOpCtx = this->makeOperationContext();
+            opCtx = uniqueOpCtx.get();
+        }
+
+        if (_doc.getPhase() == Phase::kUnset) {
+            _insertStateDocument(opCtx, std::move(newDoc));
+        } else {
+            _updateStateDocument(opCtx, std::move(newDoc));
+        }
+    }
+
+    BSONObjBuilder basicReportBuilder() const noexcept override {
+        auto baseReportBuilder = NonRecoverableShardingCoordinator<StateDoc>::basicReportBuilder();
+
+        const auto currPhase = [&]() {
+            stdx::lock_guard l{_docMutex};
+            return _doc.getPhase();
+        }();
+
+        baseReportBuilder.append("currentPhase", serializePhase(currPhase));
+        return baseReportBuilder;
+    }
+
+    void _insertStateDocument(OperationContext* opCtx, StateDoc&& newDoc) {
+        auto copyMetadata = newDoc.getShardingCoordinatorMetadata();
+        copyMetadata.setRecoveredFromDisk(true);
+        newDoc.setShardingCoordinatorMetadata(copyMetadata);
+
+        PersistentTaskStore<StateDoc> store(NamespaceString::kShardingDDLCoordinatorsNamespace);
+        try {
+            store.add(opCtx, newDoc, defaultMajorityWriteConcern());
+        } catch (const ExceptionFor<ErrorCodes::DuplicateKey>&) {
+            // A series of step-up and step-down events can cause a node to try and insert the
+            // document when it has already been persisted locally, but we must still wait for
+            // majority commit.
+            const auto replCoord = repl::ReplicationCoordinator::get(opCtx);
+            const auto lastLocalOpTime = replCoord->getMyLastAppliedOpTime();
+            WaitForMajorityService::get(opCtx->getServiceContext())
+                .waitUntilMajorityForWrite(lastLocalOpTime, opCtx->getCancellationToken())
+                .get(opCtx);
+        }
+
+        {
+            stdx::lock_guard lk{_docMutex};
+            _doc = std::move(newDoc);
+        }
+    }
+
+    void _updateStateDocument(OperationContext* opCtx, StateDoc&& newDoc) {
+        PersistentTaskStore<StateDoc> store(NamespaceString::kShardingDDLCoordinatorsNamespace);
+        tassert(10644540,
+                "Expected recoveredFromDisk to be set on the coordinator document metadata",
+                newDoc.getShardingCoordinatorMetadata().getRecoveredFromDisk());
+        store.update(opCtx,
+                     BSON(StateDoc::kIdFieldName << newDoc.getId().toBSON()),
+                     newDoc.toBSON(),
+                     defaultMajorityWriteConcern());
+
+        {
+            stdx::lock_guard lk{_docMutex};
+            _doc = std::move(newDoc);
+        }
+    }
+
+    boost::optional<Status> getAbortReason() const override {
+        const auto& status = _doc.getAbortReason();
+        tassert(10644541, "when persisted, status must be an error", !status || !status->isOK());
+        return status;
+    }
+
+    /**
+     * Persists the abort reason and throws it as an exception. This causes the coordinator to fail,
+     * and triggers the cleanup future chain since there is a persisted reason.
+     */
+    void triggerCleanup(OperationContext* opCtx, const Status& status) {
+        LOGV2_INFO(7418502,
+                   "Coordinator failed, persisting abort reason",
+                   "coordinatorId"_attr = _doc.getId(),
+                   "phase"_attr = serializePhase(_doc.getPhase()),
+                   "reason"_attr = redact(status));
+
+        auto newDoc = _getDoc();
+
+        auto coordinatorMetadata = newDoc.getShardingCoordinatorMetadata();
+
+        coordinatorMetadata.setAbortReason(sharding_ddl_util::possiblyTruncateErrorStatus(status));
+        newDoc.setShardingCoordinatorMetadata(std::move(coordinatorMetadata));
+
+        _updateStateDocument(opCtx, std::move(newDoc));
+
+        uassertStatusOK(status);
+    }
+
+private:
+    void _onCleanup(OperationContext* opCtx) override {
+        releaseSession(opCtx);
+    }
+
+    boost::optional<OperationSessionInfo> readSession(OperationContext* opCtx) const override {
+        auto optSession = [&] {
+            stdx::lock_guard lk{_docMutex};
+            return _doc.getShardingCoordinatorMetadata().getSession();
+        }();
+        if (!optSession) {
+            return boost::none;
+        }
+
+        OperationSessionInfo osi;
+        osi.setSessionId(optSession->getLsid());
+        osi.setTxnNumber(optSession->getTxnNumber());
+        return osi;
+    }
+
+    void writeSession(OperationContext* opCtx,
+                      const boost::optional<OperationSessionInfo>& osi) override {
+        if (!osi) {
+            // The tracker will call writeSession with boost::none after calling releaseSession; by
+            // the time the DDL coordinator does this, we've already deleted our state document.
+            return;
+        }
+        auto newDoc = _getDoc();
+        auto newMetadata = newDoc.getShardingCoordinatorMetadata();
+        newMetadata.setSession(
+            ShardingCoordinatorSession(*osi->getSessionId(), *osi->getTxnNumber()));
+        newDoc.setShardingCoordinatorMetadata(std::move(newMetadata));
+        _updateStateDocument(opCtx, std::move(newDoc));
+    }
+
+    OperationSessionTracker _sessionTracker;
+};
+
+#undef MONGO_LOGV2_DEFAULT_COMPONENT
+
+}  // namespace mongo

src/mongo/db/global_catalog/ddl/sharding_coordinator.idl

@@ -40,8 +40,8 @@ imports:
     - "mongo/db/versioning_protocol/database_version.idl"
 
 enums:
-    DDLCoordinatorType:
+    CoordinatorType:
-        description: "Type of the sharding DDL Operation."
+        description: "Type of the coordinator."
         type: string
         values:
             kMovePrimary: "movePrimary"
@@ -99,21 +99,21 @@ types:
         is_view: false
 
 structs:
-    ShardingDDLCoordinatorId:
+    ShardingCoordinatorId:
-        description: "Identifier for a specific sharding DDL Coordinator."
+        description: "Identifier for a specific sharding Coordinator."
         generate_comparison_operators: false
         strict: false
         fields:
             namespace:
-                description: "The target namespace of the DDL operation."
+                description: "The target namespace of the operation."
                 cpp_name: nss
                 type: namespacestring
             operationType:
-                description: "Type of the sharding DDL coordinator."
+                description: "Type of the sharding coordinator."
-                type: DDLCoordinatorType
+                type: CoordinatorType
 
-    ShardingDDLSession:
+    ShardingCoordinatorSession:
-        description: "Container for DDL coordinator session."
+        description: "Container for coordinator session."
         strict: true
         fields:
             lsid:
@@ -121,13 +121,13 @@ structs:
             txnNumber:
                 type: TxnNumber
 
-    ShardingDDLCoordinatorMetadata:
+    ShardingCoordinatorMetadata:
-        description: "Commong metadata for all sharding DDL coordinator."
+        description: "Common metadata for all sharding coordinator."
         generate_comparison_operators: false
         strict: false
         fields:
             _id:
-                type: ShardingDDLCoordinatorId
+                type: ShardingCoordinatorId
                 cpp_name: id
             recoveredFromDisk:
                 type: bool
@@ -139,7 +139,7 @@ structs:
                 type: DatabaseVersion
                 optional: true
             session:
-                type: ShardingDDLSession
+                type: ShardingCoordinatorSession
                 optional: true
             bucketNss:
                 description: "In case of sharded timeseries this variable will hold the underlying bucket namespace"

src/mongo/db/global_catalog/ddl/sharding_coordinator_external_state.cpp

@@ -27,7 +27,7 @@
  *    it in the license file.
  */
 
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_external_state.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_external_state.h"
 
 #include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
 #include "mongo/db/shard_role/shard_catalog/database_sharding_state.h"
@@ -37,23 +37,23 @@
 
 namespace mongo {
 
-void ShardingDDLCoordinatorExternalStateImpl::checkShardedDDLAllowedToStart(
+void ShardingCoordinatorExternalStateImpl::checkShardedDDLAllowedToStart(
     OperationContext* opCtx, const NamespaceString& nss) const {
     GlobalUserWriteBlockState::get(opCtx)->checkShardedDDLAllowedToStart(opCtx, nss);
 }
 
-void ShardingDDLCoordinatorExternalStateImpl::waitForVectorClockDurable(
+void ShardingCoordinatorExternalStateImpl::waitForVectorClockDurable(
     OperationContext* opCtx) const {
     VectorClockMutable::get(opCtx)->waitForDurable().get(opCtx);
 }
 
-void ShardingDDLCoordinatorExternalStateImpl::assertIsPrimaryShardForDb(
+void ShardingCoordinatorExternalStateImpl::assertIsPrimaryShardForDb(
     OperationContext* opCtx, const DatabaseName& dbName) const {
     const auto scopedDss = DatabaseShardingState::acquire(opCtx, dbName);
     scopedDss->assertIsPrimaryShardForDb(opCtx);
 }
 
-bool ShardingDDLCoordinatorExternalStateImpl::isTrackedTimeseries(
+bool ShardingCoordinatorExternalStateImpl::isTrackedTimeseries(
     OperationContext* opCtx, const NamespaceString& bucketNss) const {
     try {
         const auto bucketColl = Grid::get(opCtx)->catalogClient()->getCollection(
@@ -66,9 +66,9 @@ bool ShardingDDLCoordinatorExternalStateImpl::isTrackedTimeseries(
     }
 }
 
-void ShardingDDLCoordinatorExternalStateImpl::allowMigrations(OperationContext* opCtx,
+void ShardingCoordinatorExternalStateImpl::allowMigrations(OperationContext* opCtx,
-                                                              const NamespaceString& nss,
+                                                           const NamespaceString& nss,
-                                                              bool allowMigrations) {
+                                                           bool allowMigrations) {
     if (allowMigrations) {
         sharding_ddl_util::resumeMigrations(opCtx, nss, boost::none);
     } else {
@@ -76,14 +76,14 @@ void ShardingDDLCoordinatorExternalStateImpl::allowMigrations(OperationContext*
     }
 }
 
-bool ShardingDDLCoordinatorExternalStateImpl::checkAllowMigrations(OperationContext* opCtx,
+bool ShardingCoordinatorExternalStateImpl::checkAllowMigrations(OperationContext* opCtx,
-                                                                   const NamespaceString& nss) {
+                                                                const NamespaceString& nss) {
     return sharding_ddl_util::checkAllowMigrations(opCtx, nss);
 }
 
-std::shared_ptr<ShardingDDLCoordinatorExternalState>
+std::shared_ptr<ShardingCoordinatorExternalState>
-ShardingDDLCoordinatorExternalStateFactoryImpl::create() const {
+ShardingCoordinatorExternalStateFactoryImpl::create() const {
-    return std::make_shared<ShardingDDLCoordinatorExternalStateImpl>();
+    return std::make_shared<ShardingCoordinatorExternalStateImpl>();
 }
 
 }  // namespace mongo

src/mongo/db/global_catalog/ddl/sharding_coordinator_external_state.h

@@ -34,9 +34,9 @@
 #include "mongo/util/modules.h"
 
 namespace mongo {
-class ShardingDDLCoordinatorExternalState {
+class ShardingCoordinatorExternalState {
 public:
-    virtual ~ShardingDDLCoordinatorExternalState() = default;
+    virtual ~ShardingCoordinatorExternalState() = default;
     virtual void checkShardedDDLAllowedToStart(OperationContext* opCtx,
                                                const NamespaceString& nss) const = 0;
     virtual void waitForVectorClockDurable(OperationContext* opCtx) const = 0;
@@ -52,7 +52,7 @@ public:
 private:
 };
 
-class ShardingDDLCoordinatorExternalStateImpl : public ShardingDDLCoordinatorExternalState {
+class ShardingCoordinatorExternalStateImpl : public ShardingCoordinatorExternalState {
 public:
     void checkShardedDDLAllowedToStart(OperationContext* opCtx,
                                        const NamespaceString& nss) const override;
@@ -67,16 +67,15 @@ public:
     bool checkAllowMigrations(OperationContext* opCtx, const NamespaceString& nss) override;
 };
 
-class ShardingDDLCoordinatorExternalStateFactory {
+class ShardingCoordinatorExternalStateFactory {
 public:
-    virtual ~ShardingDDLCoordinatorExternalStateFactory() = default;
+    virtual ~ShardingCoordinatorExternalStateFactory() = default;
-    virtual std::shared_ptr<ShardingDDLCoordinatorExternalState> create() const = 0;
+    virtual std::shared_ptr<ShardingCoordinatorExternalState> create() const = 0;
 };
 
-class ShardingDDLCoordinatorExternalStateFactoryImpl
+class ShardingCoordinatorExternalStateFactoryImpl : public ShardingCoordinatorExternalStateFactory {
-    : public ShardingDDLCoordinatorExternalStateFactory {
 public:
-    std::shared_ptr<ShardingDDLCoordinatorExternalState> create() const override;
+    std::shared_ptr<ShardingCoordinatorExternalState> create() const override;
 };
 
 

src/mongo/db/global_catalog/ddl/sharding_coordinator_external_state_for_test.cpp

@@ -27,54 +27,53 @@
  *    it in the license file.
  */
 
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_external_state_for_test.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_external_state_for_test.h"
 
 namespace mongo {
 
-ShardingDDLCoordinatorExternalStateForTest::ShardingDDLCoordinatorExternalStateForTest() {
+ShardingCoordinatorExternalStateForTest::ShardingCoordinatorExternalStateForTest() {
     allowMigrationsResponse = MockCommandResponse();
     migrationsAllowedResponse = MockCommandResponse();
 }
 
-void ShardingDDLCoordinatorExternalStateForTest::checkShardedDDLAllowedToStart(
+void ShardingCoordinatorExternalStateForTest::checkShardedDDLAllowedToStart(
     OperationContext* opCtx, const NamespaceString& nss) const {}
 
-void ShardingDDLCoordinatorExternalStateForTest::waitForVectorClockDurable(
+void ShardingCoordinatorExternalStateForTest::waitForVectorClockDurable(
     OperationContext* opCtx) const {}
 
-void ShardingDDLCoordinatorExternalStateForTest::assertIsPrimaryShardForDb(
+void ShardingCoordinatorExternalStateForTest::assertIsPrimaryShardForDb(
     OperationContext* opCtx, const DatabaseName& dbName) const {}
 
-bool ShardingDDLCoordinatorExternalStateForTest::isTrackedTimeseries(
+bool ShardingCoordinatorExternalStateForTest::isTrackedTimeseries(
     OperationContext* opCtx, const NamespaceString& bucketNss) const {
     return false;
 }
 
-void ShardingDDLCoordinatorExternalStateForTest::allowMigrations(OperationContext* opCtx,
+void ShardingCoordinatorExternalStateForTest::allowMigrations(OperationContext* opCtx,
-                                                                 const NamespaceString& nss,
+                                                              const NamespaceString& nss,
-                                                                 bool allowMigrations) {
+                                                              bool allowMigrations) {
     allowMigrationsResponse.getNext();
     migrationsAllowed = allowMigrations;
 }
 
-bool ShardingDDLCoordinatorExternalStateForTest::checkAllowMigrations(OperationContext* opCtx,
+bool ShardingCoordinatorExternalStateForTest::checkAllowMigrations(OperationContext* opCtx,
-                                                                      const NamespaceString& nss) {
+                                                                   const NamespaceString& nss) {
     migrationsAllowedResponse.getNext();
     return migrationsAllowed;
 }
 
-ShardingDDLCoordinatorExternalStateFactoryForTest::
+ShardingCoordinatorExternalStateFactoryForTest::ShardingCoordinatorExternalStateFactoryForTest(
-    ShardingDDLCoordinatorExternalStateFactoryForTest(
+    std::shared_ptr<ShardingCoordinatorExternalStateForTest> externalState) {
-        std::shared_ptr<ShardingDDLCoordinatorExternalStateForTest> externalState) {
     _externalState = std::move(externalState);
 }
 
-std::shared_ptr<ShardingDDLCoordinatorExternalState>
+std::shared_ptr<ShardingCoordinatorExternalState>
-ShardingDDLCoordinatorExternalStateFactoryForTest::create() const {
+ShardingCoordinatorExternalStateFactoryForTest::create() const {
     if (_externalState != nullptr) {
-        return std::move(_externalState);
+        return _externalState;
     }
-    return std::make_shared<ShardingDDLCoordinatorExternalStateForTest>();
+    return std::make_shared<ShardingCoordinatorExternalStateForTest>();
 }
 
 }  // namespace mongo

src/mongo/db/global_catalog/ddl/sharding_coordinator_external_state_for_test.h

@@ -29,7 +29,7 @@
 
 #pragma once
 
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_external_state.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_external_state.h"
 #include "mongo/db/global_catalog/ddl/sharding_test_helpers.h"
 #include "mongo/util/modules.h"
 
@@ -38,9 +38,9 @@ namespace mongo {
 using Fault = sharding_test_helpers::Fault;
 using MockCommandResponse = sharding_test_helpers::FaultGenerator;
 
-class ShardingDDLCoordinatorExternalStateForTest : public ShardingDDLCoordinatorExternalState {
+class ShardingCoordinatorExternalStateForTest : public ShardingCoordinatorExternalState {
 public:
-    ShardingDDLCoordinatorExternalStateForTest();
+    ShardingCoordinatorExternalStateForTest();
     void checkShardedDDLAllowedToStart(OperationContext* opCtx,
                                        const NamespaceString& nss) const override;
     void waitForVectorClockDurable(OperationContext* opCtx) const override;
@@ -58,17 +58,17 @@ public:
     bool migrationsAllowed = true;
 };
 
-class ShardingDDLCoordinatorExternalStateFactoryForTest
+class ShardingCoordinatorExternalStateFactoryForTest
-    : public ShardingDDLCoordinatorExternalStateFactory {
+    : public ShardingCoordinatorExternalStateFactory {
 public:
-    ShardingDDLCoordinatorExternalStateFactoryForTest() {}
+    ShardingCoordinatorExternalStateFactoryForTest() {}
-    ShardingDDLCoordinatorExternalStateFactoryForTest(
+    ShardingCoordinatorExternalStateFactoryForTest(
-        std::shared_ptr<ShardingDDLCoordinatorExternalStateForTest> externalState);
+        std::shared_ptr<ShardingCoordinatorExternalStateForTest> externalState);
 
-    std::shared_ptr<ShardingDDLCoordinatorExternalState> create() const override;
+    std::shared_ptr<ShardingCoordinatorExternalState> create() const override;
 
 private:
-    std::shared_ptr<ShardingDDLCoordinatorExternalStateForTest> _externalState;
+    std::shared_ptr<ShardingCoordinatorExternalStateForTest> _externalState;
 };
 
 }  // namespace mongo

src/mongo/db/global_catalog/ddl/sharding_coordinator_service.cpp

@@ -28,7 +28,7 @@
  */
 
 
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 
 #include "mongo/base/checked_cast.h"
 #include "mongo/base/error_codes.h"
@@ -55,7 +55,7 @@
 #include "mongo/db/global_catalog/ddl/refine_collection_shard_key_coordinator.h"
 #include "mongo/db/global_catalog/ddl/rename_collection_coordinator.h"
 #include "mongo/db/global_catalog/ddl/set_allow_migrations_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator.h"
 #include "mongo/db/global_catalog/ddl/timeseries_upgrade_downgrade_coordinator.h"
 #include "mongo/db/global_catalog/ddl/untrack_unsplittable_collection_coordinator.h"
 #include "mongo/db/pipeline/aggregate_command_gen.h"
@@ -88,69 +88,68 @@
 namespace mongo {
 namespace {
 
-MONGO_FAIL_POINT_DEFINE(pauseShardingDDLCoordinatorServiceOnRecovery);
+MONGO_FAIL_POINT_DEFINE(pauseShardingCoordinatorServiceOnRecovery);
 
-std::shared_ptr<ShardingDDLCoordinator> constructShardingDDLCoordinatorInstance(
+std::shared_ptr<ShardingCoordinator> constructShardingCoordinatorInstance(
-    ShardingDDLCoordinatorService* service, BSONObj initialState) {
+    ShardingCoordinatorService* service, BSONObj initialState) {
-    const auto op = extractShardingDDLCoordinatorMetadata(initialState);
+    const auto op = extractShardingCoordinatorMetadata(initialState);
-    LOGV2(
+    LOGV2(5390510, "Constructing new sharding coordinator", "coordinatorDoc"_attr = op.toBSON());
-        5390510, "Constructing new sharding DDL coordinator", "coordinatorDoc"_attr = op.toBSON());
     switch (op.getId().getOperationType()) {
-        case DDLCoordinatorTypeEnum::kMovePrimary:
+        case CoordinatorTypeEnum::kMovePrimary:
             return std::make_shared<MovePrimaryCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kDropDatabase:
+        case CoordinatorTypeEnum::kDropDatabase:
             return std::make_shared<DropDatabaseCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kDropCollection:
+        case CoordinatorTypeEnum::kDropCollection:
             return std::make_shared<DropCollectionCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kDropIndexes:
+        case CoordinatorTypeEnum::kDropIndexes:
             return std::make_shared<DropIndexesCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kRenameCollection:
+        case CoordinatorTypeEnum::kRenameCollection:
             return std::make_shared<RenameCollectionCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kCreateCollection:
+        case CoordinatorTypeEnum::kCreateCollection:
             return std::make_shared<CreateCollectionCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kRefineCollectionShardKey:
+        case CoordinatorTypeEnum::kRefineCollectionShardKey:
             return std::make_shared<RefineCollectionShardKeyCoordinator>(service,
                                                                          std::move(initialState));
-        case DDLCoordinatorTypeEnum::kSetAllowMigrations:
+        case CoordinatorTypeEnum::kSetAllowMigrations:
             return std::make_shared<SetAllowMigrationsCoordinator>(service,
                                                                    std::move(initialState));
-        case DDLCoordinatorTypeEnum::kCollMod:
+        case CoordinatorTypeEnum::kCollMod:
             return std::make_shared<CollModCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kReshardCollection:
+        case CoordinatorTypeEnum::kReshardCollection:
             return std::make_shared<ReshardCollectionCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kCompactStructuredEncryptionData:
+        case CoordinatorTypeEnum::kCompactStructuredEncryptionData:
             return std::make_shared<CompactStructuredEncryptionDataCoordinator>(
                 service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kCleanupStructuredEncryptionData:
+        case CoordinatorTypeEnum::kCleanupStructuredEncryptionData:
             return std::make_shared<CleanupStructuredEncryptionDataCoordinator>(
                 service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kMigrationBlockingOperation:
+        case CoordinatorTypeEnum::kMigrationBlockingOperation:
             return std::make_shared<MigrationBlockingOperationCoordinator>(service,
                                                                            std::move(initialState));
-        case DDLCoordinatorTypeEnum::kConvertToCapped:
+        case CoordinatorTypeEnum::kConvertToCapped:
             return std::make_shared<ConvertToCappedCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kUntrackUnsplittableCollection:
+        case CoordinatorTypeEnum::kUntrackUnsplittableCollection:
             return std::make_shared<UntrackUnsplittableCollectionCoordinator>(
                 service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kCreateDatabase:
+        case CoordinatorTypeEnum::kCreateDatabase:
             return std::make_shared<CreateDatabaseCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kRemoveShardCommit:
+        case CoordinatorTypeEnum::kRemoveShardCommit:
             return std::make_shared<RemoveShardCommitCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kAddShard:
+        case CoordinatorTypeEnum::kAddShard:
             return std::make_shared<AddShardCoordinator>(service, std::move(initialState));
-        case DDLCoordinatorTypeEnum::kCloneAuthoritativeMetadata:
+        case CoordinatorTypeEnum::kCloneAuthoritativeMetadata:
             return std::make_shared<CloneAuthoritativeMetadataCoordinator>(service,
                                                                            std::move(initialState));
-        case DDLCoordinatorTypeEnum::kInitializePlacementHistory:
+        case CoordinatorTypeEnum::kInitializePlacementHistory:
             return std::make_shared<InitializePlacementHistoryCoordinator>(service,
                                                                            std::move(initialState));
         // TODO (SERVER-116499): Remove this once 9.0 becomes last LTS.
-        case DDLCoordinatorTypeEnum::kTimeseriesUpgradeDowngrade:
+        case CoordinatorTypeEnum::kTimeseriesUpgradeDowngrade:
             return std::make_shared<TimeseriesUpgradeDowngradeCoordinator>(service,
                                                                            std::move(initialState));
         default:
             uasserted(ErrorCodes::BadValue,
-                      str::stream() << "Encountered unknown Sharding DDL operation type: "
+                      str::stream() << "Encountered unknown Sharding Coordinator type: "
                                     << idl::serialize(op.getId().getOperationType()));
     }
 }
@@ -158,15 +157,15 @@ std::shared_ptr<ShardingDDLCoordinator> constructShardingDDLCoordinatorInstance(
 
 }  // namespace
 
-ShardingDDLCoordinatorService* ShardingDDLCoordinatorService::getService(OperationContext* opCtx) {
+ShardingCoordinatorService* ShardingCoordinatorService::getService(OperationContext* opCtx) {
     auto registry = repl::PrimaryOnlyServiceRegistry::get(opCtx->getServiceContext());
     auto service = registry->lookupServiceByName(kServiceName);
-    return checked_cast<ShardingDDLCoordinatorService*>(std::move(service));
+    return checked_cast<ShardingCoordinatorService*>(std::move(service));
 }
 
-std::shared_ptr<ShardingDDLCoordinatorService::Instance>
+std::shared_ptr<ShardingCoordinatorService::Instance> ShardingCoordinatorService::constructInstance(
-ShardingDDLCoordinatorService::constructInstance(BSONObj initialState) {
+    BSONObj initialState) {
-    auto coord = constructShardingDDLCoordinatorInstance(this, std::move(initialState));
+    auto coord = constructShardingCoordinatorInstance(this, std::move(initialState));
 
     {
         stdx::lock_guard lg(_mutex);
@@ -181,7 +180,7 @@ ShardingDDLCoordinatorService::constructInstance(BSONObj initialState) {
         }
     }
 
-    pauseShardingDDLCoordinatorServiceOnRecovery.pauseWhileSet();
+    pauseShardingCoordinatorServiceOnRecovery.pauseWhileSet();
 
     coord->getConstructionCompletionFuture()
         .thenRunOn(**getInstanceExecutor())
@@ -220,12 +219,12 @@ ShardingDDLCoordinatorService::constructInstance(BSONObj initialState) {
     return coord;
 }
 
-std::shared_ptr<ShardingDDLCoordinatorExternalState>
+std::shared_ptr<ShardingCoordinatorExternalState> ShardingCoordinatorService::createExternalState()
-ShardingDDLCoordinatorService::createExternalState() const {
+    const {
     return _externalStateFactory->create();
 }
 
-void ShardingDDLCoordinatorService::waitForCoordinatorsOfGivenOfcvToComplete(
+void ShardingCoordinatorService::waitForCoordinatorsOfGivenOfcvToComplete(
     OperationContext* opCtx, std::function<bool(boost::optional<FCV>)> pred) const {
     stdx::unique_lock lk(_mutex);
     opCtx->waitForConditionOrInterrupt(_recoveredOrCoordinatorCompletedCV, lk, [this, pred]() {
@@ -233,30 +232,30 @@ void ShardingDDLCoordinatorService::waitForCoordinatorsOfGivenOfcvToComplete(
                 "Should not wait on DDL Coordinators in kPaused state",
                 _state != State::kPaused);
         const auto numActiveCoords = _countActiveCoordinators(
-            [pred](DDLCoordinatorTypeEnum, boost::optional<FCV> ofcv) { return pred(ofcv); });
+            [pred](CoordinatorTypeEnum, boost::optional<FCV> ofcv) { return pred(ofcv); });
         return _state == State::kRecovered && numActiveCoords == 0;
     });
 }
 
-void ShardingDDLCoordinatorService::waitForCoordinatorsOfGivenTypeToComplete(
+void ShardingCoordinatorService::waitForCoordinatorsOfGivenTypeToComplete(
-    OperationContext* opCtx, DDLCoordinatorTypeEnum coordType) const {
+    OperationContext* opCtx, CoordinatorTypeEnum coordType) const {
     stdx::unique_lock lk(_mutex);
     opCtx->waitForConditionOrInterrupt(_recoveredOrCoordinatorCompletedCV, lk, [this, coordType]() {
         const auto numActiveCoords = _countActiveCoordinators(
-            [coordType](DDLCoordinatorTypeEnum activeCoordType, boost::optional<FCV>) {
+            [coordType](CoordinatorTypeEnum activeCoordType, boost::optional<FCV>) {
                 return coordType == activeCoordType;
             });
         return _state == State::kRecovered && numActiveCoords == 0;
     });
 }
 
-void ShardingDDLCoordinatorService::waitForOngoingCoordinatorsToFinish(
+void ShardingCoordinatorService::waitForOngoingCoordinatorsToFinish(
-    OperationContext* opCtx, std::function<bool(const ShardingDDLCoordinator&)> pred) {
+    OperationContext* opCtx, std::function<bool(const ShardingCoordinator&)> pred) {
     std::vector<SharedSemiFuture<void>> futuresToWait;
 
     const auto instances = getAllInstances(opCtx);
     for (const auto& instance : instances) {
-        auto typedInstance = checked_pointer_cast<ShardingDDLCoordinator>(instance);
+        auto typedInstance = checked_pointer_cast<ShardingCoordinator>(instance);
         if (pred(*typedInstance)) {
             futuresToWait.emplace_back(typedInstance->getCompletionFuture());
         }
@@ -267,7 +266,7 @@ void ShardingDDLCoordinatorService::waitForOngoingCoordinatorsToFinish(
     }
 }
 
-void ShardingDDLCoordinatorService::_onServiceInitialization() {
+void ShardingCoordinatorService::_onServiceInitialization() {
     stdx::lock_guard lg(_mutex);
     invariant(_state == State::kPaused);
     invariant(_numCoordinatorsToWait == 0);
@@ -275,7 +274,7 @@ void ShardingDDLCoordinatorService::_onServiceInitialization() {
     _state = State::kRecovering;
 }
 
-void ShardingDDLCoordinatorService::_onServiceTermination() {
+void ShardingCoordinatorService::_onServiceTermination() {
     stdx::lock_guard lg(_mutex);
     _state = State::kPaused;
     _numCoordinatorsToWait = 0;
@@ -283,8 +282,8 @@ void ShardingDDLCoordinatorService::_onServiceTermination() {
     _recoveredOrCoordinatorCompletedCV.notify_all();
 }
 
-size_t ShardingDDLCoordinatorService::_countActiveCoordinators(
+size_t ShardingCoordinatorService::_countActiveCoordinators(
-    std::function<bool(DDLCoordinatorTypeEnum, boost::optional<FCV>)> pred) const {
+    std::function<bool(CoordinatorTypeEnum, boost::optional<FCV>)> pred) const {
     size_t cnt = 0;
     for (const auto& [typeAndOfcvPair, numCoords] : _numActiveCoordinatorsPerTypeAndOfcv) {
         if (pred(typeAndOfcvPair.first, typeAndOfcvPair.second)) {
@@ -294,7 +293,7 @@ size_t ShardingDDLCoordinatorService::_countActiveCoordinators(
     return cnt;
 }
 
-size_t ShardingDDLCoordinatorService::_countCoordinatorDocs(OperationContext* opCtx) const {
+size_t ShardingCoordinatorService::_countCoordinatorDocs(OperationContext* opCtx) const {
     constexpr auto kNumCoordLabel = "numCoordinators"_sd;
     static const auto countStage = BSON("$count" << kNumCoordLabel);
 
@@ -316,29 +315,29 @@ size_t ShardingDDLCoordinatorService::_countCoordinatorDocs(OperationContext* op
     return numCoordField.numberLong();
 }
 
-void ShardingDDLCoordinatorService::_waitForRecovery(OperationContext* opCtx,
+void ShardingCoordinatorService::_waitForRecovery(OperationContext* opCtx,
-                                                     std::unique_lock<stdx::mutex>& lock) const {
+                                                  std::unique_lock<stdx::mutex>& lock) const {
     opCtx->waitForConditionOrInterrupt(_recoveredOrCoordinatorCompletedCV, lock, [this]() {
         return _state != State::kRecovering;
     });
 
     uassert(ErrorCodes::NotWritablePrimary,
-            "Not primary when trying to create a DDL coordinator",
+            "Not primary when trying to create a sharding coordinator",
             _state != State::kPaused);
 }
 
-void ShardingDDLCoordinatorService::waitForRecovery(OperationContext* opCtx) const {
+void ShardingCoordinatorService::waitForRecovery(OperationContext* opCtx) const {
     stdx::unique_lock lk(_mutex);
     _waitForRecovery(opCtx, lk);
 }
 
-bool ShardingDDLCoordinatorService::areAllCoordinatorsOfTypeFinished(
+bool ShardingCoordinatorService::areAllCoordinatorsOfTypeFinished(
-    OperationContext* opCtx, DDLCoordinatorTypeEnum coordinatorType) {
+    OperationContext* opCtx, CoordinatorTypeEnum coordinatorType) {
     // getAllInstances on the PrimaryOnlyServices will wait for recovery, so all coordinators should
     // have been loaded into memory by this point.
     const auto& instances = getAllInstances(opCtx);
     for (const auto& instance : instances) {
-        auto typedInstance = checked_pointer_cast<ShardingDDLCoordinator>(instance);
+        auto typedInstance = checked_pointer_cast<ShardingCoordinator>(instance);
         if (typedInstance->operationType() == coordinatorType) {
             if (!typedInstance->getCompletionFuture().isReady()) {
                 return false;
@@ -349,7 +348,7 @@ bool ShardingDDLCoordinatorService::areAllCoordinatorsOfTypeFinished(
     return true;
 }
 
-ExecutorFuture<void> ShardingDDLCoordinatorService::_rebuildService(
+ExecutorFuture<void> ShardingCoordinatorService::_rebuildService(
     std::shared_ptr<executor::ScopedTaskExecutor> executor, const CancellationToken& token) {
     return ExecutorFuture<void>(**executor)
         .then([this] {
@@ -358,11 +357,11 @@ ExecutorFuture<void> ShardingDDLCoordinatorService::_rebuildService(
             const auto numCoordinators = _countCoordinatorDocs(opCtx.get());
             if (numCoordinators > 0) {
                 LOGV2(5622500,
-                      "Found Sharding DDL Coordinators to rebuild",
+                      "Found Sharding Coordinators to rebuild",
                       "numCoordinators"_attr = numCoordinators);
             }
 
-            pauseShardingDDLCoordinatorServiceOnRecovery.pauseWhileSet();
+            pauseShardingCoordinatorServiceOnRecovery.pauseWhileSet();
 
             {
                 stdx::lock_guard lg(_mutex);
@@ -381,26 +380,25 @@ ExecutorFuture<void> ShardingDDLCoordinatorService::_rebuildService(
             }
         })
         .onError([this](const Status& status) {
-            LOGV2_ERROR(5469630,
+            LOGV2_ERROR(
-                        "Failed to rebuild Sharding DDL coordinator service",
+                5469630, "Failed to rebuild Sharding coordinator service", "error"_attr = status);
-                        "error"_attr = status);
             return status;
         });
 }
 
-std::shared_ptr<ShardingDDLCoordinatorService::Instance>
+std::shared_ptr<ShardingCoordinatorService::Instance>
-ShardingDDLCoordinatorService::getOrCreateInstance(OperationContext* opCtx,
+ShardingCoordinatorService::getOrCreateInstance(OperationContext* opCtx,
-                                                   BSONObj coorDoc,
+                                                BSONObj coorDoc,
-                                                   const FixedFCVRegion& fcvRegion,
+                                                const FixedFCVRegion& fcvRegion,
-                                                   bool checkOptions) {
+                                                bool checkOptions) {
     // Wait for all coordinators to be recovered before to allow the creation of new ones.
     waitForRecovery(opCtx);
 
-    auto coorMetadata = extractShardingDDLCoordinatorMetadata(coorDoc);
+    auto coorMetadata = extractShardingCoordinatorMetadata(coorDoc);
     const auto& nss = coorMetadata.getId().getNss();
 
     if (!nss.isConfigDB() && !nss.isAdminDB() &&
-        coorMetadata.getId().getOperationType() != DDLCoordinatorTypeEnum::kCreateDatabase) {
+        coorMetadata.getId().getOperationType() != CoordinatorTypeEnum::kCreateDatabase) {
         // Check that the operation context has a database version for this namespace
         const auto clientDbVersion = OperationShardingState::get(opCtx).getDbVersion(nss.dbName());
         uassert(ErrorCodes::IllegalOperation,
@@ -432,24 +430,24 @@ ShardingDDLCoordinatorService::getOrCreateInstance(OperationContext* opCtx,
                 auto [coordinator, created] =
                     PrimaryOnlyService::getOrCreateInstance(opCtx, patchedCoorDoc, checkOptions);
                 return std::make_pair(
-                    checked_pointer_cast<ShardingDDLCoordinator>(std::move(coordinator)),
+                    checked_pointer_cast<ShardingCoordinator>(std::move(coordinator)),
                     std::move(created));
             } catch (const ExceptionFor<ErrorCodes::AddOrRemoveShardInProgress>&) {
                 LOGV2_WARNING(5687900,
-                              "Cannot start sharding DDL coordinator because a topology change is "
+                              "Cannot start sharding coordinator because a topology change is "
                               "in progress. Will retry after backoff.");
                 // Backoff
                 opCtx->sleepFor(Seconds(1));
                 continue;
             } catch (const ExceptionFor<ErrorCodes::PlacementHistoryInitializationInProgress>&) {
                 LOGV2_WARNING(10899800,
-                              "Cannot start sharding DDL coordinator because an initialization of "
+                              "Cannot start sharding coordinator because an initialization of "
                               "config.placementHistory is in progress. Will retry after backoff.");
                 opCtx->sleepFor(Seconds(1));
                 continue;
             } catch (const DBException& ex) {
                 LOGV2_ERROR(5390512,
-                            "Failed to create instance of sharding DDL coordinator",
+                            "Failed to create instance of sharding coordinator",
                             "coordinatorId"_attr = coorMetadata.getId(),
                             "reason"_attr = redact(ex));
                 throw;
@@ -461,25 +459,25 @@ ShardingDDLCoordinatorService::getOrCreateInstance(OperationContext* opCtx,
 }
 
 
-std::shared_ptr<executor::TaskExecutor> ShardingDDLCoordinatorService::getInstanceCleanupExecutor()
+std::shared_ptr<executor::TaskExecutor> ShardingCoordinatorService::getInstanceCleanupExecutor()
     const {
     return PrimaryOnlyService::getInstanceCleanupExecutor();
 }
 
-void ShardingDDLCoordinatorService::_transitionToRecovered(WithLock lk, OperationContext* opCtx) {
+void ShardingCoordinatorService::_transitionToRecovered(WithLock lk, OperationContext* opCtx) {
     _state = State::kRecovered;
     _recoveredOrCoordinatorCompletedCV.notify_all();
 }
 
-void ShardingDDLCoordinatorService::checkIfConflictsWithOtherInstances(
+void ShardingCoordinatorService::checkIfConflictsWithOtherInstances(
     OperationContext* opCtx,
     BSONObj initialState,
     const std::vector<const PrimaryOnlyService::Instance*>& existingInstances) {
-    auto coorMetadata = extractShardingDDLCoordinatorMetadata(initialState);
+    auto coorMetadata = extractShardingCoordinatorMetadata(initialState);
     const auto& opType = coorMetadata.getId().getOperationType();
-    if (opType != DDLCoordinatorTypeEnum::kRemoveShardCommit &&
+    if (opType != CoordinatorTypeEnum::kRemoveShardCommit &&
-        opType != DDLCoordinatorTypeEnum::kAddShard &&
+        opType != CoordinatorTypeEnum::kAddShard &&
-        opType != DDLCoordinatorTypeEnum::kInitializePlacementHistory) {
+        opType != CoordinatorTypeEnum::kInitializePlacementHistory) {
 
         const auto addOrRemoveShardInProgress = [] {
             auto* clusterParameter =
@@ -490,7 +488,7 @@ void ShardingDDLCoordinatorService::checkIfConflictsWithOtherInstances(
         }();
 
         uassert(ErrorCodes::AddOrRemoveShardInProgress,
-                "Cannot start ShardingDDLCoordinator because a topology change is in progress",
+                "Cannot start ShardingCoordinator because a topology change is in progress",
                 !addOrRemoveShardInProgress);
 
         const auto placementHistoryInitializationInProgress = [] {
@@ -503,7 +501,7 @@ void ShardingDDLCoordinatorService::checkIfConflictsWithOtherInstances(
         }();
 
         uassert(ErrorCodes::PlacementHistoryInitializationInProgress,
-                "Cannot start ShardingDDLCoordinator because an initialization of "
+                "Cannot start ShardingCoordinator because an initialization of "
                 "config.placementHistory is in progress",
                 !placementHistoryInitializationInProgress);
     }

src/mongo/db/global_catalog/ddl/sharding_coordinator_service.h

@@ -32,8 +32,8 @@
 #include "mongo/base/string_data.h"
 #include "mongo/bson/bsonobj.h"
 #include "mongo/db/commands/feature_compatibility_version.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_external_state.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_external_state.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/repl/primary_only_service.h"
@@ -57,25 +57,25 @@
 
 namespace mongo {
 
-class ShardingDDLCoordinator;
+class ShardingCoordinator;
 
-class MONGO_MOD_NEEDS_REPLACEMENT ShardingDDLCoordinatorService final
+class MONGO_MOD_NEEDS_REPLACEMENT ShardingCoordinatorService final
     : public repl::PrimaryOnlyService,
       public DDLLockManager::Recoverable {
 public:
-    static constexpr StringData kServiceName = "ShardingDDLCoordinator"_sd;
+    static constexpr StringData kServiceName = "ShardingCoordinator"_sd;
 
-    explicit ShardingDDLCoordinatorService(
+    explicit ShardingCoordinatorService(
         ServiceContext* serviceContext,
-        std::unique_ptr<ShardingDDLCoordinatorExternalStateFactory> externalStateFactory =
+        std::unique_ptr<ShardingCoordinatorExternalStateFactory> externalStateFactory =
-            std::make_unique<ShardingDDLCoordinatorExternalStateFactoryImpl>())
+            std::make_unique<ShardingCoordinatorExternalStateFactoryImpl>())
         : PrimaryOnlyService(serviceContext),
           _externalStateFactory(std::move(externalStateFactory)) {}
 
 
-    ~ShardingDDLCoordinatorService() override = default;
+    ~ShardingCoordinatorService() override = default;
 
-    static ShardingDDLCoordinatorService* getService(OperationContext* opCtx);
+    static ShardingCoordinatorService* getService(OperationContext* opCtx);
 
     using repl::PrimaryOnlyService::getAllInstances;
     using FCV = multiversion::FeatureCompatibilityVersion;
@@ -85,6 +85,9 @@ public:
     }
 
     NamespaceString getStateDocumentsNS() const override {
+        // Even though the class is no longer named `ShardingDDLCoordinatorService` and the
+        // coordinator instances are not necessarily DDL coordinators, the namespace is still
+        // `config.system.sharding_ddl_coordinators` for backward compatibility reasons.
         return NamespaceString::kShardingDDLCoordinatorsNamespace;
     }
 
@@ -102,7 +105,7 @@ public:
 
     std::shared_ptr<Instance> constructInstance(BSONObj initialState) override;
 
-    std::shared_ptr<ShardingDDLCoordinatorExternalState> createExternalState() const;
+    std::shared_ptr<ShardingCoordinatorExternalState> createExternalState() const;
 
     std::shared_ptr<Instance> getOrCreateInstance(OperationContext* opCtx,
                                                   BSONObj initialState,
@@ -116,18 +119,17 @@ public:
 
     // TODO SERVER-99655: remove once gSnapshotFCVInDDLCoordinators is enabled on last LTS
     void waitForCoordinatorsOfGivenTypeToComplete(OperationContext* opCtx,
-                                                  DDLCoordinatorTypeEnum type) const;
+                                                  CoordinatorTypeEnum type) const;
 
     /**
      * Waits for all currently running coordinators matching the predicate 'pred' to finish. While
      * waiting here, new coordinators may start, but they will not be waited for.
      */
-    void waitForOngoingCoordinatorsToFinish(
+    void waitForOngoingCoordinatorsToFinish(OperationContext* opCtx,
-        OperationContext* opCtx,
+                                            std::function<bool(const ShardingCoordinator&)> pred = {
-        std::function<bool(const ShardingDDLCoordinator&)> pred = {
+                                                [](const ShardingCoordinator&) {
-            [](const ShardingDDLCoordinator&) {
+                                                    return true;
-                return true;
+                                                }});
-            }});
 
     void waitForRecovery(OperationContext* opCtx) const override;
 
@@ -138,10 +140,10 @@ public:
      * that stability if needed.
      */
     bool areAllCoordinatorsOfTypeFinished(OperationContext* opCtx,
-                                          DDLCoordinatorTypeEnum coordinatorType);
+                                          CoordinatorTypeEnum coordinatorType);
 
 private:
-    friend class ShardingDDLCoordinatorServiceTest;
+    friend class ShardingCoordinatorServiceTest;
 
     ExecutorFuture<void> _rebuildService(std::shared_ptr<executor::ScopedTaskExecutor> executor,
                                          const CancellationToken& token) override;
@@ -150,7 +152,7 @@ private:
     void _onServiceTermination() override;
 
     size_t _countActiveCoordinators(
-        std::function<bool(DDLCoordinatorTypeEnum, boost::optional<FCV>)> pred) const;
+        std::function<bool(CoordinatorTypeEnum, boost::optional<FCV>)> pred) const;
     size_t _countCoordinatorDocs(OperationContext* opCtx) const;
 
     void _transitionToRecovered(WithLock lk, OperationContext* opCtx);
@@ -178,10 +180,10 @@ private:
     size_t _numCoordinatorsToWait{0};
 
     // TODO SERVER-99655: make the 'FCV' key non-optional
-    stdx::unordered_map<std::pair<DDLCoordinatorTypeEnum, boost::optional<FCV>>, size_t>
+    stdx::unordered_map<std::pair<CoordinatorTypeEnum, boost::optional<FCV>>, size_t>
         _numActiveCoordinatorsPerTypeAndOfcv;
 
-    std::unique_ptr<ShardingDDLCoordinatorExternalStateFactory> _externalStateFactory;
+    std::unique_ptr<ShardingCoordinatorExternalStateFactory> _externalStateFactory;
 };
 
 }  // namespace mongo

src/mongo/db/global_catalog/ddl/sharding_coordinator_service_test.cpp

@@ -27,12 +27,12 @@
  *    it in the license file.
  */
 
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 
 #include "mongo/base/error_codes.h"
 #include "mongo/db/client.h"
 #include "mongo/db/global_catalog/ddl/migration_blocking_operation_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_external_state_for_test.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_external_state_for_test.h"
 #include "mongo/db/repl/primary_only_service_test_fixture.h"
 #include "mongo/db/s/forwardable_operation_metadata.h"
 #include "mongo/db/shard_role/ddl/ddl_lock_manager.h"
@@ -62,19 +62,19 @@
 
 namespace mongo {
 
-class ShardingDDLCoordinatorServiceTest : public repl::PrimaryOnlyServiceMongoDTest {
+class ShardingCoordinatorServiceTest : public repl::PrimaryOnlyServiceMongoDTest {
 public:
     using FCV = multiversion::FeatureCompatibilityVersion;
 
-    ShardingDDLCoordinatorServiceTest() {
+    ShardingCoordinatorServiceTest() {
-        _externalState = std::make_shared<ShardingDDLCoordinatorExternalStateForTest>();
+        _externalState = std::make_shared<ShardingCoordinatorExternalStateForTest>();
         _externalStateFactory =
-            std::make_unique<ShardingDDLCoordinatorExternalStateFactoryForTest>(_externalState);
+            std::make_unique<ShardingCoordinatorExternalStateFactoryForTest>(_externalState);
     }
 
     std::unique_ptr<repl::PrimaryOnlyService> makeService(ServiceContext* serviceContext) override {
-        return std::make_unique<ShardingDDLCoordinatorService>(serviceContext,
+        return std::make_unique<ShardingCoordinatorService>(serviceContext,
-                                                               std::move(_externalStateFactory));
+                                                            std::move(_externalStateFactory));
     }
 
     void setUp() override {
@@ -95,15 +95,15 @@ public:
         PrimaryOnlyServiceMongoDTest::tearDown();
     }
 
-    ShardingDDLCoordinatorService* ddlService() {
+    ShardingCoordinatorService* ddlService() {
-        return static_cast<ShardingDDLCoordinatorService*>(_service);
+        return static_cast<ShardingCoordinatorService*>(_service);
     }
 
     std::shared_ptr<executor::TaskExecutor> makeTestExecutor() {
         ThreadPool::Options threadPoolOptions;
         threadPoolOptions.maxThreads = 1;
-        threadPoolOptions.threadNamePrefix = "ShardingDDLCoordinatorServiceTest-";
+        threadPoolOptions.threadNamePrefix = "ShardingCoordinatorServiceTest-";
-        threadPoolOptions.poolName = "ShardingDDLCoordinatorServiceTestThreadPool";
+        threadPoolOptions.poolName = "ShardingCoordinatorServiceTestThreadPool";
         threadPoolOptions.onCreateThread = [](const std::string& threadName) {
             Client::initThread(threadName, getGlobalServiceContext()->getService());
         };
@@ -111,7 +111,7 @@ public:
         auto executor = executor::ThreadPoolTaskExecutor::create(
             std::make_unique<ThreadPool>(threadPoolOptions),
             executor::makeNetworkInterface(
-                "ShardingDDLCoordinatorServiceTestNetwork", nullptr, nullptr));
+                "ShardingCoordinatorServiceTestNetwork", nullptr, nullptr));
         executor->startup();
         return executor;
     }
@@ -119,27 +119,27 @@ public:
     void printState() {
         std::string stateStr;
         switch (ddlService()->_state) {
-            case ShardingDDLCoordinatorService::State::kPaused:
+            case ShardingCoordinatorService::State::kPaused:
                 stateStr = "kPaused";
                 break;
-            case ShardingDDLCoordinatorService::State::kRecovered:
+            case ShardingCoordinatorService::State::kRecovered:
                 stateStr = "kRecovered";
                 break;
-            case ShardingDDLCoordinatorService::State::kRecovering:
+            case ShardingCoordinatorService::State::kRecovering:
                 stateStr = "kRecovering";
                 break;
             default:
                 MONGO_UNREACHABLE;
         }
-        LOGV2(7646301, "ShardingDDLCoordinatorService::_state", "state"_attr = stateStr);
+        LOGV2(7646301, "ShardingCoordinatorService::_state", "state"_attr = stateStr);
     }
 
     void assertStateIsPaused() {
-        ASSERT_EQ(ShardingDDLCoordinatorService::State::kPaused, ddlService()->_state);
+        ASSERT_EQ(ShardingCoordinatorService::State::kPaused, ddlService()->_state);
     }
 
     void assertStateIsRecovered() {
-        ASSERT_EQ(ShardingDDLCoordinatorService::State::kRecovered, ddlService()->_state);
+        ASSERT_EQ(ShardingCoordinatorService::State::kRecovered, ddlService()->_state);
     }
 
     void assertNumActiveCoordinatorsWithGivenOfcv(boost::optional<FCV> ofcvToCount,
@@ -199,8 +199,8 @@ protected:
     MigrationBlockingOperationCoordinatorDocument createMBOCDoc(
         OperationContext* opCtx, NamespaceString nss, boost::optional<FCV> ofcv = boost::none) {
         const auto coordinatorId =
-            ShardingDDLCoordinatorId{nss, DDLCoordinatorTypeEnum::kMigrationBlockingOperation};
+            ShardingCoordinatorId{nss, CoordinatorTypeEnum::kMigrationBlockingOperation};
-        ShardingDDLCoordinatorMetadata metadata(coordinatorId);
+        ShardingCoordinatorMetadata metadata(coordinatorId);
         ForwardableOperationMetadata fom(opCtx);
         if (ofcv) {
             fom.setVersionContext(VersionContext{ofcv.value()});
@@ -208,7 +208,7 @@ protected:
         metadata.setForwardableOpMetadata(fom);
         metadata.setDatabaseVersion(DatabaseVersion{UUID::gen(), Timestamp(1, 0)});
         MigrationBlockingOperationCoordinatorDocument doc;
-        doc.setShardingDDLCoordinatorMetadata(metadata);
+        doc.setShardingCoordinatorMetadata(metadata);
         return doc;
     }
 
@@ -230,11 +230,11 @@ protected:
     }
 
     std::shared_ptr<executor::TaskExecutor> _testExecutor;
-    std::unique_ptr<ShardingDDLCoordinatorExternalStateFactoryForTest> _externalStateFactory;
+    std::unique_ptr<ShardingCoordinatorExternalStateFactoryForTest> _externalStateFactory;
-    std::shared_ptr<ShardingDDLCoordinatorExternalStateForTest> _externalState;
+    std::shared_ptr<ShardingCoordinatorExternalStateForTest> _externalState;
 };
 
-TEST_F(ShardingDDLCoordinatorServiceTest, StateTransitions) {
+TEST_F(ShardingCoordinatorServiceTest, StateTransitions) {
     auto opCtx = makeOperationContext();
 
     // Reaching a steady state to start the test
@@ -251,7 +251,7 @@ TEST_F(ShardingDDLCoordinatorServiceTest, StateTransitions) {
     assertStateIsRecovered();
 }
 
-TEST_F(ShardingDDLCoordinatorServiceTest, WaitingWhileKpaused) {
+TEST_F(ShardingCoordinatorServiceTest, WaitingWhileKpaused) {
     auto opCtx = makeOperationContext();
 
     // Reaching a steady state to start the test
@@ -270,7 +270,7 @@ TEST_F(ShardingDDLCoordinatorServiceTest, WaitingWhileKpaused) {
                        ErrorCodes::NotWritablePrimary);
 }
 
-TEST_F(ShardingDDLCoordinatorServiceTest,
+TEST_F(ShardingCoordinatorServiceTest,
        DDLLocksCanOnlyBeAcquiredOnceShardingDDLCoordinatorServiceIsRecovered) {
     auto opCtx = makeOperationContext();
     opCtx->setAlwaysInterruptAtStepDownOrUp_UNSAFE();
@@ -298,7 +298,7 @@ TEST_F(ShardingDDLCoordinatorServiceTest,
     // Only DDL coordinators can acquire DDL locks during recovery, otherwise trying to acquire a
     // DDL lock will throw a LockTimeout error
     auto pauseOnRecoveryFailPoint =
-        globalFailPointRegistry().find("pauseShardingDDLCoordinatorServiceOnRecovery");
+        globalFailPointRegistry().find("pauseShardingCoordinatorServiceOnRecovery");
     const auto fpCount = pauseOnRecoveryFailPoint->setMode(FailPoint::alwaysOn);
     stepUp(opCtx.get());
     pauseOnRecoveryFailPoint->waitForTimesEntered(fpCount + 1);
@@ -311,7 +311,7 @@ TEST_F(ShardingDDLCoordinatorServiceTest,
         opCtx.get(), nss, reason, MODE_X, 0 /*timeoutMillisec*/));
 
     // 3- Ending Recovery and enter on Recovered state
-    // Once ShardingDDLCoordinatorService is recovered, anyone can aquire a DDL lock
+    // Once ShardingCoordinatorService is recovered, anyone can aquire a DDL lock
     pauseOnRecoveryFailPoint->setMode(FailPoint::off);
     ddlService()->waitForRecovery(opCtx.get());
 
@@ -321,7 +321,7 @@ TEST_F(ShardingDDLCoordinatorServiceTest,
         opCtx.get(), nss, reason, MODE_X, 0 /*timeoutMillisec*/));
 }
 
-TEST_F(ShardingDDLCoordinatorServiceTest, DDLLockMustBeEventuallyAcquiredAfterAStepUp) {
+TEST_F(ShardingCoordinatorServiceTest, DDLLockMustBeEventuallyAcquiredAfterAStepUp) {
     auto opCtx = makeOperationContext();
     opCtx->setAlwaysInterruptAtStepDownOrUp_UNSAFE();
 
@@ -343,7 +343,7 @@ TEST_F(ShardingDDLCoordinatorServiceTest, DDLLockMustBeEventuallyAcquiredAfterAS
     // Start an async task to step up
     auto stepUpFuture = ExecutorFuture<void>(_testExecutor).then([this, &syncPoint]() {
         auto pauseOnRecoveryFailPoint =
-            globalFailPointRegistry().find("pauseShardingDDLCoordinatorServiceOnRecovery");
+            globalFailPointRegistry().find("pauseShardingCoordinatorServiceOnRecovery");
         const auto fpCount = pauseOnRecoveryFailPoint->setMode(FailPoint::alwaysOn);
 
 
@@ -366,7 +366,7 @@ TEST_F(ShardingDDLCoordinatorServiceTest, DDLLockMustBeEventuallyAcquiredAfterAS
     ASSERT(stepUpFuture.isReady());
 }
 
-TEST_F(ShardingDDLCoordinatorServiceTest, CoordinatorCreationMustFailOnSecondaries) {
+TEST_F(ShardingCoordinatorServiceTest, CoordinatorCreationMustFailOnSecondaries) {
     auto opCtx = makeOperationContext();
 
     // Reaching a steady state to start the test
@@ -383,7 +383,7 @@ TEST_F(ShardingDDLCoordinatorServiceTest, CoordinatorCreationMustFailOnSecondari
         ddlService()->waitForRecovery(opCtx.get()), DBException, ErrorCodes::NotWritablePrimary);
 }
 
-TEST_F(ShardingDDLCoordinatorServiceTest, StepdownDuringServiceRebuilding) {
+TEST_F(ShardingCoordinatorServiceTest, StepdownDuringServiceRebuilding) {
     auto opCtx = makeOperationContext();
 
     // Reaching a steady state to start the test
@@ -392,7 +392,7 @@ TEST_F(ShardingDDLCoordinatorServiceTest, StepdownDuringServiceRebuilding) {
     stepDown();
 
     auto pauseOnRecoveryFailPoint =
-        globalFailPointRegistry().find("pauseShardingDDLCoordinatorServiceOnRecovery");
+        globalFailPointRegistry().find("pauseShardingCoordinatorServiceOnRecovery");
     const auto fpCount = pauseOnRecoveryFailPoint->setMode(FailPoint::alwaysOn);
 
     stepUp(opCtx.get());
@@ -409,7 +409,7 @@ TEST_F(ShardingDDLCoordinatorServiceTest, StepdownDuringServiceRebuilding) {
     ddlService()->waitForRecovery(opCtx.get());
 }
 
-TEST_F(ShardingDDLCoordinatorServiceTest, StepdownStepupWhileCreatingCoordinator) {
+TEST_F(ShardingCoordinatorServiceTest, StepdownStepupWhileCreatingCoordinator) {
     auto opCtx = makeOperationContext();
 
     spawnMigrationBlockingOperationCoordinator(
@@ -423,7 +423,7 @@ TEST_F(ShardingDDLCoordinatorServiceTest, StepdownStepupWhileCreatingCoordinator
     ddlService()->waitForRecovery(opCtx.get());
 }
 
-TEST_F(ShardingDDLCoordinatorServiceTest, TrackCoordinatorsWithGivenOfcvAndType) {
+TEST_F(ShardingCoordinatorServiceTest, TrackCoordinatorsWithGivenOfcvAndType) {
     auto opCtxHolder = makeOperationContext();
     auto opCtx = opCtxHolder.get();
 

src/mongo/db/global_catalog/ddl/sharding_coordinator_test.cpp

@@ -27,9 +27,9 @@
  *    it in the license file.
  */
 
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator.h"
 
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_external_state_for_test.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_external_state_for_test.h"
 #include "mongo/db/shard_role/lock_manager/locker.h"
 #include "mongo/db/sharding_environment/shard_server_test_fixture.h"
 #include "mongo/executor/thread_pool_task_executor_test_fixture.h"
@@ -38,9 +38,9 @@
 
 namespace mongo {
 
-class ShardingDDLCoordinatorTest : public ShardServerTestFixture {
+class ShardingCoordinatorTest : public ShardServerTestFixture {
 public:
-    ShardingDDLCoordinatorTest() : ShardServerTestFixture(makeOptions()) {}
+    ShardingCoordinatorTest() : ShardServerTestFixture(makeOptions()) {}
 
     void setUp() override {
         ShardServerTestFixture::setUp();
@@ -49,17 +49,16 @@ public:
         _network = network.get();
         executor::ThreadPoolMock::Options thread_pool_options;
         thread_pool_options.onCreateThread = [] {
-            Client::initThread("ShardingDDLCoordinatorTest",
+            Client::initThread("ShardingCoordinatorTest", getGlobalServiceContext()->getService());
-                               getGlobalServiceContext()->getService());
         };
 
         _executor = makeThreadPoolTestExecutor(std::move(network), thread_pool_options);
         _executor->startup();
 
         _scopedExecutor = std::make_shared<executor::ScopedTaskExecutor>(_executor);
-        _service = std::make_unique<ShardingDDLCoordinatorService>(
+        _service = std::make_unique<ShardingCoordinatorService>(
             getServiceContext(),
-            std::make_unique<ShardingDDLCoordinatorExternalStateFactoryForTest>());
+            std::make_unique<ShardingCoordinatorExternalStateFactoryForTest>());
 
         DDLLockManager::get(getServiceContext())->setRecoverable(_service.get());
     }
@@ -76,22 +75,22 @@ protected:
     executor::NetworkInterfaceMock* _network;
     std::shared_ptr<executor::ThreadPoolTaskExecutor> _executor;
     std::shared_ptr<executor::ScopedTaskExecutor> _scopedExecutor;
-    std::unique_ptr<ShardingDDLCoordinatorService> _service;
+    std::unique_ptr<ShardingCoordinatorService> _service;
 
-    class TestShardingDDLCoordinator : public ShardingDDLCoordinator {
+    class TestShardingCoordinator : public ShardingCoordinator {
     public:
-        TestShardingDDLCoordinator(ShardingDDLCoordinatorService* service,
+        TestShardingCoordinator(ShardingCoordinatorService* service,
-                                   ShardingDDLCoordinatorMetadata coordinatorMetadata,
+                                ShardingCoordinatorMetadata coordinatorMetadata,
-                                   std::set<NamespaceString> additionalNss)
+                                std::set<NamespaceString> additionalNss)
-            : ShardingDDLCoordinator(service, coordinatorMetadata.toBSON()),
+            : ShardingCoordinator(service, coordinatorMetadata.toBSON()),
-              _shardingDDLCoordinatorMetadata(coordinatorMetadata),
+              _shardingCoordinatorMetadata(coordinatorMetadata),
               _additionalNss(additionalNss) {}
 
-        ShardingDDLCoordinatorMetadata const& metadata() const override {
+        ShardingCoordinatorMetadata const& metadata() const override {
-            return _shardingDDLCoordinatorMetadata;
+            return _shardingCoordinatorMetadata;
         }
 
-        void setMetadata(ShardingDDLCoordinatorMetadata&& metadata) override {}
+        void setMetadata(ShardingCoordinatorMetadata&& metadata) override {}
 
         boost::optional<BSONObj> reportForCurrentOp(
             MongoProcessInterface::CurrentOpConnectionsMode connMode,
@@ -110,8 +109,8 @@ protected:
             return ExecutorFuture<void>(**executor);
         }
 
-        using ShardingDDLCoordinator::_acquireAllLocksAsync;
+        using ShardingCoordinator::_acquireAllLocksAsync;
-        using ShardingDDLCoordinator::_locker;
+        using ShardingCoordinator::_locker;
 
         void fulfillPromises() {
             _constructionCompletionPromise.emplaceValue();
@@ -119,7 +118,7 @@ protected:
         }
 
     protected:
-        ShardingDDLCoordinatorMetadata _shardingDDLCoordinatorMetadata;
+        ShardingCoordinatorMetadata _shardingCoordinatorMetadata;
         std::set<NamespaceString> _additionalNss;
     };
 
@@ -141,24 +140,24 @@ protected:
     }
 };
 
-TEST_F(ShardingDDLCoordinatorTest, AcquiresDDLLocks) {
+TEST_F(ShardingCoordinatorTest, AcquiresDDLLocks) {
     auto testDDLLocksAcquired = [&](NamespaceString mainNss,
                                     std::set<NamespaceString> additionalNss,
                                     std::set<DatabaseName> expectedDbLocks,
                                     std::set<NamespaceString> expectedCollLocks) {
-        // Create a dummy ShardingDDLCoordinator.
+        // Create a dummy ShardingCoordinator.
-        ShardingDDLCoordinatorMetadata coordinatorMetadata(
+        ShardingCoordinatorMetadata coordinatorMetadata(
-            ShardingDDLCoordinatorId(mainNss, DDLCoordinatorTypeEnum::kDropCollection));
+            ShardingCoordinatorId(mainNss, CoordinatorTypeEnum::kDropCollection));
         coordinatorMetadata.setForwardableOpMetadata(ForwardableOperationMetadata{});
 
-        auto coordinator = std::make_shared<TestShardingDDLCoordinator>(
+        auto coordinator = std::make_shared<TestShardingCoordinator>(
             _service.get(), coordinatorMetadata, std::set<NamespaceString>({additionalNss}));
         coordinator->fulfillPromises();
         CancellationSource cancellationSource;
 
         coordinator->_locker = std::make_unique<Locker>(getServiceContext());
 
-        // Just run the '_acquireAllLocksAsync()' bit of ShardingDDLCoordinator::run().
+        // Just run the '_acquireAllLocksAsync()' bit of ShardingCoordinator::run().
         ExecutorFuture<void>(**_scopedExecutor)
             .then([scopedExecutor = _scopedExecutor,
                    coordinator = coordinator,

src/mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h

@@ -29,548 +29,26 @@
 
 #pragma once
 
-#include "mongo/base/error_codes.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator.h"
-#include "mongo/base/status.h"
-#include "mongo/base/string_data.h"
-#include "mongo/bson/bsonmisc.h"
-#include "mongo/bson/bsonobj.h"
-#include "mongo/bson/bsonobjbuilder.h"
-#include "mongo/db/client.h"
-#include "mongo/db/generic_argument_util.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
-#include "mongo/db/namespace_string.h"
-#include "mongo/db/operation_context.h"
-#include "mongo/db/persistent_task_store.h"
-#include "mongo/db/pipeline/process_interface/mongo_process_interface.h"
-#include "mongo/db/repl/primary_only_service.h"
-#include "mongo/db/repl/replication_coordinator.h"
-#include "mongo/db/repl/wait_for_majority_service.h"
-#include "mongo/db/s/forwardable_operation_metadata.h"
-#include "mongo/db/s/primary_only_service_helpers/all_shards_and_config_causality_barrier.h"
-#include "mongo/db/s/primary_only_service_helpers/operation_session_tracker.h"
-#include "mongo/db/service_context.h"
-#include "mongo/db/session/logical_session_id_gen.h"
-#include "mongo/db/shard_role/ddl/ddl_lock_manager.h"
-#include "mongo/db/shard_role/lock_manager/lock_manager_defs.h"
-#include "mongo/db/shard_role/transaction_resources.h"
-#include "mongo/db/versioning_protocol/database_version.h"
-#include "mongo/executor/scoped_task_executor.h"
-#include "mongo/executor/task_executor.h"
-#include "mongo/idl/idl_parser.h"
-#include "mongo/logv2/log.h"
-#include "mongo/stdx/mutex.h"
-#include "mongo/util/assert_util.h"
-#include "mongo/util/cancellation.h"
-#include "mongo/util/future.h"
-#include "mongo/util/future_impl.h"
-#include "mongo/util/modules.h"
-#include "mongo/util/namespace_string_util.h"
-#include "mongo/util/version/releases.h"
-
-#include <memory>
-#include <set>
-#include <stack>
-#include <string>
-#include <utility>
-
-#include <boost/move/utility_core.hpp>
-#include <boost/optional/optional.hpp>
 
 #define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kSharding
 
 namespace mongo {
 
-MONGO_MOD_NEEDS_REPLACEMENT ShardingDDLCoordinatorMetadata
-extractShardingDDLCoordinatorMetadata(const BSONObj& coorDoc);
-
-class MONGO_MOD_NEEDS_REPLACEMENT ShardingDDLCoordinator
-    : public repl::PrimaryOnlyService::TypedInstance<ShardingDDLCoordinator> {
-public:
-    explicit ShardingDDLCoordinator(ShardingDDLCoordinatorService* service, const BSONObj& coorDoc);
-
-    ~ShardingDDLCoordinator() override;
-
-    /**
-     * Whether this coordinator is allowed to start when user write blocking is enabled, even if the
-     * writeBlockingBypass flag is not set. Coordinators that don't affect user data shall always be
-     * allowed to run even when user write blocking is enabled.
-     */
-    virtual bool canAlwaysStartWhenUserWritesAreDisabled() const {
-        return false;
-    }
-
-    /*
-     * Returns a future that will be completed when the construction of this coordinator instance
-     * is completed.
-     *
-     * In particular the returned future will be ready only after this coordinator successfully
-     * acquires the required locks.
-     */
-    SharedSemiFuture<void> getConstructionCompletionFuture() {
-        return _constructionCompletionPromise.getFuture();
-    }
-
-    /*
-     * Returns a future that will be ready when all the work associated with this coordinator
-     * instances will be completed.
-     *
-     * In particular the returned future will be ready after this coordinator will successfully
-     * release all the acquired locks.
-     */
-    SharedSemiFuture<void> getCompletionFuture() {
-        return _completionPromise.getFuture();
-    }
-
-    DDLCoordinatorTypeEnum operationType() const {
-        return _coordId.getOperationType();
-    }
-
-    const ForwardableOperationMetadata& getForwardableOpMetadata() const {
-        tassert(10644500, "Expected _forwardableOpMetadata to be set", _forwardableOpMetadata);
-        return _forwardableOpMetadata.get();
-    }
-
-    // TODO SERVER-99655: update once the operationFCV is always present for sharded DDLs
-    boost::optional<multiversion::FeatureCompatibilityVersion> getOperationFCV() const {
-        const auto versionContext = getForwardableOpMetadata().getVersionContext();
-        tassert(10644501,
-                "Expected either no versionContext, or a versionContext with an operation FCV",
-                !versionContext || versionContext->getOperationFCV(VersionContext::Passkey()));
-        return versionContext
-            ? boost::make_optional(
-                  versionContext->getOperationFCV(VersionContext::Passkey())->getVersion())
-            : boost::none;
-    }
-
-    const boost::optional<mongo::DatabaseVersion>& getDatabaseVersion() const& {
-        return _databaseVersion;
-    }
-
-protected:
-    const NamespaceString& originalNss() const {
-        return _coordId.getNss();
-    }
-
-    virtual const NamespaceString& nss() const {
-        if (const auto& bucketNss = metadata().getBucketNss()) {
-            return bucketNss.get();
-        }
-        return originalNss();
-    }
-
-    virtual std::set<NamespaceString> _getAdditionalLocksToAcquire(OperationContext* opCtx) {
-        return {};
-    };
-
-    virtual ShardingDDLCoordinatorMetadata const& metadata() const = 0;
-    virtual void setMetadata(ShardingDDLCoordinatorMetadata&& metadata) = 0;
-
-    /**
-     * Returns a set of basic coordinator attributes to be used for logging.
-     */
-    logv2::DynamicAttributes getBasicCoordinatorAttrs() const;
-
-    /**
-     * Returns the set of attributes to be used for coordinator logging. Implementations must be
-     * sure to return a DynamicAttributes object that starts with the attributes returned by
-     * getBasicCoordinatorAttrs().
-     */
-    virtual logv2::DynamicAttributes getCoordinatorLogAttrs() const {
-        return getBasicCoordinatorAttrs();
-    }
-
-    /*
-     * Specify if the coordinator must indefinitely be retried in case of exceptions. It is always
-     * expected for a coordinator to make progress after performing intermediate operations that
-     * can't be rolled back.
-     */
-    virtual bool _mustAlwaysMakeProgress() {
-        return false;
-    };
-
-    /*
-     * Specify if the given error will be retried by the ddl coordinator infrastructure.
-     */
-    bool _isRetriableErrorForDDLCoordinator(const Status& status);
-
-    ShardingDDLCoordinatorExternalState* _getExternalState();
-
-    /**
-     * Create an `OperationContext` with the `ForwardableOperationMetadata` from the coordinator
-     * document set on it. Use this instead of `cc().makeOperationContext()`.
-     */
-    ServiceContext::UniqueOperationContext makeOperationContext() {
-        auto opCtxHolder = cc().makeOperationContext();
-        getForwardableOpMetadata().setOn(opCtxHolder.get());
-        return opCtxHolder;
-    }
-
-    ShardingDDLCoordinatorService* _service;
-    const ShardingDDLCoordinatorId _coordId;
-
-    const bool _recoveredFromDisk;
-    const boost::optional<mongo::ForwardableOperationMetadata> _forwardableOpMetadata;
-    const boost::optional<mongo::DatabaseVersion> _databaseVersion;
-    boost::optional<NamespaceString> _bucketNss;
-
-    bool _firstExecution{
-        true};  // True only when executing the coordinator for the first time (meaning it's not a
-                // retry after a retryable error nor a recovered instance from a previous primary)
-    bool _completeOnError{false};
-
-private:
-    SemiFuture<void> run(std::shared_ptr<executor::ScopedTaskExecutor> executor,
-                         const CancellationToken& token) noexcept final;
-
-    virtual ExecutorFuture<void> _runImpl(std::shared_ptr<executor::ScopedTaskExecutor> executor,
-                                          const CancellationToken& token) noexcept = 0;
-
-    virtual ExecutorFuture<void> _cleanupOnAbort(
-        std::shared_ptr<executor::ScopedTaskExecutor> executor,
-        const CancellationToken& token,
-        const Status& status) noexcept;
-
-    virtual void _onCleanup(OperationContext* opCtx) {}
-
-    void interrupt(Status status) final;
-
-    bool _removeDocument(OperationContext* opCtx);
-
-    ExecutorFuture<bool> _removeDocumentUntillSuccessOrStepdown(
-        std::shared_ptr<executor::TaskExecutor> executor);
-
-    ExecutorFuture<void> _acquireAllLocksAsync(
-        OperationContext* opCtx,
-        std::shared_ptr<executor::ScopedTaskExecutor> executor,
-        const CancellationToken& token);
-
-    template <typename T>
-    ExecutorFuture<void> _acquireLockAsync(std::shared_ptr<executor::ScopedTaskExecutor> executor,
-                                           const CancellationToken& token,
-                                           const T& resource,
-                                           LockMode lockMode);
-
-    ExecutorFuture<void> _translateTimeseriesNss(
-        std::shared_ptr<executor::ScopedTaskExecutor> executor, const CancellationToken& token);
-
-    virtual boost::optional<Status> getAbortReason() const;
-
-    stdx::mutex _mutex;
-    SharedPromise<void> _constructionCompletionPromise;
-    SharedPromise<void> _completionPromise;
-
-    // A Locker object works attached to an opCtx and it's destroyed once the opCtx gets out of
-    // scope. However, we must keep alive a unique Locker object during the whole
-    // ShardingDDLCoordinator life to preserve the lock state among all the executor tasks.
-    std::unique_ptr<Locker> _locker;
-
-    std::stack<DDLLockManager::ScopedBaseDDLLock> _scopedLocks;
-    std::shared_ptr<ShardingDDLCoordinatorExternalState> _externalState;
-
-    friend class ShardingDDLCoordinatorTest;
-};
-
 template <class StateDoc>
-class MONGO_MOD_NEEDS_REPLACEMENT ShardingDDLCoordinatorImpl : public ShardingDDLCoordinator {
+class MONGO_MOD_NEEDS_REPLACEMENT NonRecoverableShardingDDLCoordinator
-public:
+    : public NonRecoverableShardingCoordinator<StateDoc> {
-    boost::optional<BSONObj> reportForCurrentOp(
-        MongoProcessInterface::CurrentOpConnectionsMode connMode,
-        MongoProcessInterface::CurrentOpSessionsMode sessionMode) noexcept override {
-        return basicReportBuilder().obj();
-    }
-
 protected:
-    ShardingDDLCoordinatorImpl(ShardingDDLCoordinatorService* service,
+    using NonRecoverableShardingCoordinator<StateDoc>::NonRecoverableShardingCoordinator;
-                               const std::string& name,
-                               const BSONObj& initialStateDoc)
-        : ShardingDDLCoordinator(service, initialStateDoc),
-          _coordinatorName(name),
-          /*
-           * Force a deserialisation + serialisation of the initialStateDoc to ensure that
-           * _initialState is a full deep copy of the received parameter.
-           */
-          _initialState(
-              StateDoc::parse(initialStateDoc, IDLParserContext("CoordinatorInitialState"))
-                  .toBSON()),
-          _doc(StateDoc::parse(_initialState, IDLParserContext("CoordinatorDocument"))) {}
-
-    ShardingDDLCoordinatorMetadata const& metadata() const override {
-        return _doc.getShardingDDLCoordinatorMetadata();
-    }
-
-    void setMetadata(ShardingDDLCoordinatorMetadata&& metadata) override {
-        stdx::lock_guard lk{_docMutex};
-        _doc.setShardingDDLCoordinatorMetadata(std::move(metadata));
-    }
-
-    virtual void appendCommandInfo(BSONObjBuilder* cmdInfoBuilder) const {};
-
-    virtual BSONObjBuilder basicReportBuilder() const noexcept {
-        BSONObjBuilder bob;
-
-        // Append static info
-        bob.append("type", "op");
-        bob.append(
-            "ns",
-            NamespaceStringUtil::serialize(originalNss(), SerializationContext::stateDefault()));
-        bob.append("desc", _coordinatorName);
-        bob.append("op", "command");
-        bob.append("active", true);
-
-        // Append dynamic fields from the state doc
-        {
-            stdx::lock_guard lk{_docMutex};
-            if (const auto& bucketNss = _doc.getBucketNss()) {
-                // Bucket namespace is only present in case the collection is a sharded timeseries
-                bob.append("bucketNamespace",
-                           NamespaceStringUtil::serialize(bucketNss.get(),
-                                                          SerializationContext::stateDefault()));
-            }
-        }
-
-        // Create command description
-        BSONObjBuilder cmdInfoBuilder;
-        {
-            stdx::lock_guard lk{_docMutex};
-            if (const auto& optComment = getForwardableOpMetadata().getComment()) {
-                cmdInfoBuilder.append(optComment.get().firstElement());
-            }
-        }
-        appendCommandInfo(&cmdInfoBuilder);
-        bob.append("command", cmdInfoBuilder.obj());
-
-        return bob;
-    }
-
-    const std::string _coordinatorName;
-    const BSONObj _initialState;
-    mutable stdx::mutex _docMutex;
-    StateDoc _doc;
 };
 
 template <class StateDoc, class Phase>
 class MONGO_MOD_UNFORTUNATELY_OPEN RecoverableShardingDDLCoordinator
-    : public ShardingDDLCoordinatorImpl<StateDoc>,
+    : public RecoverableShardingCoordinator<StateDoc, Phase> {
-      public OperationSessionPersistence {
 protected:
-    using ShardingDDLCoordinatorImpl<StateDoc>::_doc;
+    using RecoverableShardingCoordinator<StateDoc, Phase>::RecoverableShardingCoordinator;
-    using ShardingDDLCoordinatorImpl<StateDoc>::_docMutex;
+    using RecoverableShardingCoordinator<StateDoc, Phase>::_doc;
-
+    using RecoverableShardingCoordinator<StateDoc, Phase>::_docMutex;
-    RecoverableShardingDDLCoordinator(ShardingDDLCoordinatorService* service,
-                                      const std::string& name,
-                                      const BSONObj& initialStateDoc)
-        : ShardingDDLCoordinatorImpl<StateDoc>(service, name, initialStateDoc),
-          _sessionTracker(this) {}
-
-    virtual StringData serializePhase(const Phase& phase) const = 0;
-
-    /**
-     * Advances and persists the txnNumber to ensure causality between requests, then returns the
-     * updated operation session information (OSI).
-     */
-    OperationSessionInfo getNewSession(OperationContext* opCtx) {
-        return _sessionTracker.getNextSession(opCtx);
-    }
-
-    /**
-     * Releases the current session back to the InternalSessionPool and clears the persisted
-     * session state. No-op if no session is currently held.
-     */
-    void releaseSession(OperationContext* opCtx) {
-        _sessionTracker.releaseSession(opCtx);
-    }
-
-    /**
-     * Advances the session and performs the given causality barrier, ensuring that subsequent
-     * reads on the barrier's participants will reflect all prior writes.
-     */
-    void performCausalityBarrier(OperationContext* opCtx, CausalityBarrier& barrier) {
-        _sessionTracker.performCausalityBarrier(opCtx, barrier);
-    }
-
-    std::function<void()> _buildPhaseHandler(const Phase& newPhase,
-                                             std::function<void(OperationContext*)>&& handlerFn) {
-        return _buildPhaseHandler(
-            newPhase, [](OperationContext*) { return true; }, std::move(handlerFn));
-    }
-
-    std::function<void()> _buildPhaseHandler(const Phase& newPhase,
-                                             std::function<bool(OperationContext*)>&& shouldExecute,
-                                             std::function<void(OperationContext*)>&& handlerFn) {
-        return [=, this] {
-            const auto currPhase = _getDoc().getPhase();
-
-            if (currPhase > newPhase) {
-                // Do not execute this phase if we already reached a subsequent one.
-                return;
-            }
-
-            auto opCtxHolder = this->makeOperationContext();
-            auto* opCtx = opCtxHolder.get();
-
-            if (!shouldExecute(opCtx)) {
-                // Do not execute the phase if the passed in condition is not met.
-                return;
-            }
-
-            if (currPhase < newPhase) {
-                // Persist the new phase if this is the first time we are executing it.
-                _enterPhase(newPhase);
-            }
-
-            return handlerFn(opCtx);
-        };
-    }
-
-    auto _getDoc() const {
-        stdx::lock_guard lk{_docMutex};
-        return _doc;
-    }
-
-    virtual void _enterPhase(const Phase& newPhase) {
-        auto newDoc = _getDoc();
-
-        newDoc.setPhase(newPhase);
-
-        LOGV2_DEBUG(5390501,
-                    2,
-                    "DDL coordinator phase transition",
-                    "coordinatorId"_attr = _doc.getId(),
-                    "newPhase"_attr = serializePhase(newDoc.getPhase()),
-                    "oldPhase"_attr = serializePhase(_doc.getPhase()));
-
-        ServiceContext::UniqueOperationContext uniqueOpCtx;
-        auto opCtx = cc().getOperationContext();
-        if (!opCtx) {
-            uniqueOpCtx = this->makeOperationContext();
-            opCtx = uniqueOpCtx.get();
-        }
-
-        if (_doc.getPhase() == Phase::kUnset) {
-            _insertStateDocument(opCtx, std::move(newDoc));
-        } else {
-            _updateStateDocument(opCtx, std::move(newDoc));
-        }
-    }
-
-    BSONObjBuilder basicReportBuilder() const noexcept override {
-        auto baseReportBuilder = ShardingDDLCoordinatorImpl<StateDoc>::basicReportBuilder();
-
-        const auto currPhase = [&]() {
-            stdx::lock_guard l{_docMutex};
-            return _doc.getPhase();
-        }();
-
-        baseReportBuilder.append("currentPhase", serializePhase(currPhase));
-        return baseReportBuilder;
-    }
-
-    void _insertStateDocument(OperationContext* opCtx, StateDoc&& newDoc) {
-        auto copyMetadata = newDoc.getShardingDDLCoordinatorMetadata();
-        copyMetadata.setRecoveredFromDisk(true);
-        newDoc.setShardingDDLCoordinatorMetadata(copyMetadata);
-
-        PersistentTaskStore<StateDoc> store(NamespaceString::kShardingDDLCoordinatorsNamespace);
-        try {
-            store.add(opCtx, newDoc, defaultMajorityWriteConcern());
-        } catch (const ExceptionFor<ErrorCodes::DuplicateKey>&) {
-            // A series of step-up and step-down events can cause a node to try and insert the
-            // document when it has already been persisted locally, but we must still wait for
-            // majority commit.
-            const auto replCoord = repl::ReplicationCoordinator::get(opCtx);
-            const auto lastLocalOpTime = replCoord->getMyLastAppliedOpTime();
-            WaitForMajorityService::get(opCtx->getServiceContext())
-                .waitUntilMajorityForWrite(lastLocalOpTime, opCtx->getCancellationToken())
-                .get(opCtx);
-        }
-
-        {
-            stdx::lock_guard lk{_docMutex};
-            _doc = std::move(newDoc);
-        }
-    }
-
-    void _updateStateDocument(OperationContext* opCtx, StateDoc&& newDoc) {
-        PersistentTaskStore<StateDoc> store(NamespaceString::kShardingDDLCoordinatorsNamespace);
-        tassert(10644540,
-                "Expected recoveredFromDisk to be set on the coordinator document metadata",
-                newDoc.getShardingDDLCoordinatorMetadata().getRecoveredFromDisk());
-        store.update(opCtx,
-                     BSON(StateDoc::kIdFieldName << newDoc.getId().toBSON()),
-                     newDoc.toBSON(),
-                     defaultMajorityWriteConcern());
-
-        {
-            stdx::lock_guard lk{_docMutex};
-            _doc = std::move(newDoc);
-        }
-    }
-
-    boost::optional<Status> getAbortReason() const override {
-        const auto& status = _doc.getAbortReason();
-        tassert(10644541, "when persisted, status must be an error", !status || !status->isOK());
-        return status;
-    }
-
-    /**
-     * Persists the abort reason and throws it as an exception. This causes the coordinator to fail,
-     * and triggers the cleanup future chain since there is a persisted reason.
-     */
-    void triggerCleanup(OperationContext* opCtx, const Status& status) {
-        LOGV2_INFO(7418502,
-                   "Coordinator failed, persisting abort reason",
-                   "coordinatorId"_attr = _doc.getId(),
-                   "phase"_attr = serializePhase(_doc.getPhase()),
-                   "reason"_attr = redact(status));
-
-        auto newDoc = _getDoc();
-
-        auto coordinatorMetadata = newDoc.getShardingDDLCoordinatorMetadata();
-
-        coordinatorMetadata.setAbortReason(sharding_ddl_util::possiblyTruncateErrorStatus(status));
-        newDoc.setShardingDDLCoordinatorMetadata(std::move(coordinatorMetadata));
-
-        _updateStateDocument(opCtx, std::move(newDoc));
-
-        uassertStatusOK(status);
-    }
-
-private:
-    void _onCleanup(OperationContext* opCtx) override {
-        releaseSession(opCtx);
-    }
-
-    boost::optional<OperationSessionInfo> readSession(OperationContext* opCtx) const override {
-        auto optSession = [&] {
-            stdx::lock_guard lk{_docMutex};
-            return _doc.getShardingDDLCoordinatorMetadata().getSession();
-        }();
-        if (!optSession) {
-            return boost::none;
-        }
-        OperationSessionInfo osi;
-        osi.setSessionId(optSession->getLsid());
-        osi.setTxnNumber(optSession->getTxnNumber());
-        return osi;
-    }
-
-    void writeSession(OperationContext* opCtx,
-                      const boost::optional<OperationSessionInfo>& osi) override {
-        if (!osi) {
-            // The tracker will call writeSession with boost::none after calling releaseSession; by
-            // the time the DDL coordinator does this, we've already deleted our state document.
-            return;
-        }
-        auto newDoc = _getDoc();
-        auto newMetadata = newDoc.getShardingDDLCoordinatorMetadata();
-        newMetadata.setSession(ShardingDDLSession(*osi->getSessionId(), *osi->getTxnNumber()));
-        newDoc.setShardingDDLCoordinatorMetadata(std::move(newMetadata));
-        _updateStateDocument(opCtx, std::move(newDoc));
-    }
-
-    OperationSessionTracker _sessionTracker;
 };
 
 #undef MONGO_LOGV2_DEFAULT_COMPONENT

src/mongo/db/global_catalog/ddl/sharding_ddl_util_detail.h

@@ -54,8 +54,7 @@ void preprocessCommand(OperationContext* opCtx, CommandType& cmd) {
     if (auto meta = rpc::getAuditAttrsToAuditMetadata(opCtx)) {
         cmd.setDollarAudit(*meta);
     }
-    // TODO SERVER-99655: hasOperationFCV() will always be true once DDL coordinators always use
+    // TODO SERVER-99655: hasOperationFCV() will always be true once coordinators always use OFCV
-    // OFCV
     if (auto& vCtx = VersionContext::getDecoration(opCtx); vCtx.hasOperationFCV()) {
         tassert(11144300,
                 "Expected VersionContext with propagation across shards",

src/mongo/db/global_catalog/ddl/shardsvr_change_primary_command.cpp

@@ -39,8 +39,8 @@
 #include "mongo/db/global_catalog/ddl/move_primary_coordinator.h"
 #include "mongo/db/global_catalog/ddl/move_primary_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/move_primary_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
@@ -127,15 +127,15 @@ public:
 
                 auto coordinatorDoc = [&] {
                     MovePrimaryCoordinatorDocument doc;
-                    doc.setShardingDDLCoordinatorMetadata(
+                    doc.setShardingCoordinatorMetadata(
-                        {{dbNss, DDLCoordinatorTypeEnum::kMovePrimary}});
+                        {{dbNss, CoordinatorTypeEnum::kMovePrimary}});
                     doc.setToShardId(toShard->getId());
                     doc.setAuthoritativeMetadataAccessLevel(authoritativeMetadataAccessLevel);
                     return doc.toBSON();
                 }();
 
                 const auto coordinator = [&] {
-                    auto service = ShardingDDLCoordinatorService::getService(opCtx);
+                    auto service = ShardingCoordinatorService::getService(opCtx);
                     return checked_pointer_cast<MovePrimaryCoordinator>(
                         service->getOrCreateInstance(opCtx, std::move(coordinatorDoc), fcvRegion));
                 }();

src/mongo/db/global_catalog/ddl/shardsvr_collmod_command.cpp

@@ -41,8 +41,8 @@
 #include "mongo/db/global_catalog/ddl/collmod_coordinator.h"
 #include "mongo/db/global_catalog/ddl/collmod_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/profile_settings.h"
@@ -127,9 +127,9 @@ public:
 
         auto coordinatorDoc = CollModCoordinatorDocument();
         coordinatorDoc.setCollModRequest(cmd.getCollModRequest());
-        coordinatorDoc.setShardingDDLCoordinatorMetadata(
+        coordinatorDoc.setShardingCoordinatorMetadata(
-            {{cmd.getNamespace(), DDLCoordinatorTypeEnum::kCollMod}});
+            {{cmd.getNamespace(), CoordinatorTypeEnum::kCollMod}});
-        auto service = ShardingDDLCoordinatorService::getService(opCtx);
+        auto service = ShardingCoordinatorService::getService(opCtx);
         auto collModCoordinator = checked_pointer_cast<CollModCoordinator>(
             service->getOrCreateInstance(opCtx, coordinatorDoc.toBSON(), FixedFCVRegion{opCtx}));
 

src/mongo/db/global_catalog/ddl/shardsvr_convert_to_capped_command.cpp

@@ -81,10 +81,10 @@ public:
             auto coordinatorDoc = ConvertToCappedCoordinatorDocument();
             coordinatorDoc.setShardsvrConvertToCappedRequest(
                 request().getShardsvrConvertToCappedRequest());
-            coordinatorDoc.setShardingDDLCoordinatorMetadata(
+            coordinatorDoc.setShardingCoordinatorMetadata(
-                {{nss, DDLCoordinatorTypeEnum::kConvertToCapped}});
+                {{nss, CoordinatorTypeEnum::kConvertToCapped}});
 
-            auto service = ShardingDDLCoordinatorService::getService(opCtx);
+            auto service = ShardingCoordinatorService::getService(opCtx);
             auto coordinator =
                 checked_pointer_cast<ConvertToCappedCoordinator>(service->getOrCreateInstance(
                     opCtx, coordinatorDoc.toBSON(), FixedFCVRegion{opCtx}));

src/mongo/db/global_catalog/ddl/shardsvr_create_collection_command.cpp

@@ -41,8 +41,8 @@
 #include "mongo/db/global_catalog/ddl/create_collection_coordinator.h"
 #include "mongo/db/global_catalog/ddl/create_collection_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
@@ -293,10 +293,9 @@ public:
                 }
 
                 auto coordinatorDoc = [&] {
-                    const DDLCoordinatorTypeEnum coordType =
+                    const CoordinatorTypeEnum coordType = CoordinatorTypeEnum::kCreateCollection;
-                        DDLCoordinatorTypeEnum::kCreateCollection;
                     auto doc = CreateCollectionCoordinatorDocument();
-                    doc.setShardingDDLCoordinatorMetadata({{ns(), coordType}});
+                    doc.setShardingCoordinatorMetadata({{ns(), coordType}});
                     doc.setShardsvrCreateCollectionRequest(requestToForward);
                     if (useNewCoordinatorPathForSessionsColl) {
                         doc.setCreateSessionsCollectionRemotelyOnFirstShard(true);
@@ -305,7 +304,7 @@ public:
                 }();
 
                 const auto coordinator = [&] {
-                    auto service = ShardingDDLCoordinatorService::getService(opCtx);
+                    auto service = ShardingCoordinatorService::getService(opCtx);
                     return checked_pointer_cast<CreateCollectionCoordinator>(
                         service->getOrCreateInstance(opCtx,
                                                      coordinatorDoc.copy(),

src/mongo/db/global_catalog/ddl/shardsvr_drop_collection_command.cpp

@@ -39,8 +39,8 @@
 #include "mongo/db/global_catalog/ddl/drop_collection_coordinator.h"
 #include "mongo/db/global_catalog/ddl/drop_collection_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/sharding_catalog_client.h"
 #include "mongo/db/global_catalog/type_collection.h"
 #include "mongo/db/namespace_string.h"
@@ -117,11 +117,11 @@ public:
                     .getDatabaseProfileLevel(ns().dbName()));
 
             auto coordinatorDoc = DropCollectionCoordinatorDocument();
-            coordinatorDoc.setShardingDDLCoordinatorMetadata(
+            coordinatorDoc.setShardingCoordinatorMetadata(
-                {{ns(), DDLCoordinatorTypeEnum::kDropCollection}});
+                {{ns(), CoordinatorTypeEnum::kDropCollection}});
             coordinatorDoc.setCollectionUUID(request().getCollectionUUID());
 
-            auto service = ShardingDDLCoordinatorService::getService(opCtx);
+            auto service = ShardingCoordinatorService::getService(opCtx);
             auto dropCollCoordinator =
                 checked_pointer_cast<DropCollectionCoordinator>(service->getOrCreateInstance(
                     opCtx, coordinatorDoc.toBSON(), FixedFCVRegion{opCtx}));

src/mongo/db/global_catalog/ddl/shardsvr_drop_database_command.cpp

@@ -36,8 +36,8 @@
 #include "mongo/db/global_catalog/ddl/drop_database_coordinator.h"
 #include "mongo/db/global_catalog/ddl/drop_database_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
@@ -101,7 +101,7 @@ public:
 
             const auto requestVersion =
                 OperationShardingState::get(opCtx).getDbVersion(ns().dbName());
-            const auto service = ShardingDDLCoordinatorService::getService(opCtx);
+            const auto service = ShardingCoordinatorService::getService(opCtx);
 
             const auto dropDatabaseCoordinatorFuture = [&] {
                 while (true) {
@@ -120,8 +120,8 @@ public:
                                 fcvRegion->acquireFCVSnapshot());
 
                         DropDatabaseCoordinatorDocument coordinatorDoc;
-                        coordinatorDoc.setShardingDDLCoordinatorMetadata(
+                        coordinatorDoc.setShardingCoordinatorMetadata(
-                            {{ns(), DDLCoordinatorTypeEnum::kDropDatabase}});
+                            {{ns(), CoordinatorTypeEnum::kDropDatabase}});
                         coordinatorDoc.setAuthoritativeMetadataAccessLevel(
                             authoritativeMetadataAccessLevel);
 

src/mongo/db/global_catalog/ddl/shardsvr_drop_indexes_command.cpp

@@ -161,14 +161,13 @@ ShardsvrDropIndexesCommand::Invocation::Response ShardsvrDropIndexesCommand::Inv
         if (useCoordinator) {
             auto coordinatorDoc = [&] {
                 auto doc = DropIndexesCoordinatorDocument();
-                doc.setShardingDDLCoordinatorMetadata(
+                doc.setShardingCoordinatorMetadata({{ns(), CoordinatorTypeEnum::kDropIndexes}});
-                    {{ns(), DDLCoordinatorTypeEnum::kDropIndexes}});
                 doc.setDropIndexesRequest(request().getDropIndexesRequest());
                 return doc;
             }();
 
             const auto coordinator = [&] {
-                auto service = ShardingDDLCoordinatorService::getService(opCtx);
+                auto service = ShardingCoordinatorService::getService(opCtx);
                 return checked_pointer_cast<DropIndexesCoordinator>(service->getOrCreateInstance(
                     opCtx, coordinatorDoc.toBSON(), *optFixedFcvRegion, false /*checkOptions*/));
             }();

src/mongo/db/global_catalog/ddl/shardsvr_join_ddl_coordinators_command.cpp

@@ -32,8 +32,8 @@
 #include "mongo/db/auth/authorization_session.h"
 #include "mongo/db/auth/resource_pattern.h"
 #include "mongo/db/commands.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/shardsvr_join_ddl_coordinators_request_gen.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/repl/member_state.h"
@@ -58,7 +58,7 @@ public:
     }
 
     std::string help() const override {
-        return "Internal command invoked by the config server to join any ShardingDDLCoordinator "
+        return "Internal command invoked by the config server to join any ShardingCoordinator "
                "activity other than add and remove shard executed by the shard";
     }
 
@@ -80,26 +80,26 @@ public:
             {
                 Lock::GlobalLock lk(opCtx, MODE_IX);
                 uassert(ErrorCodes::InterruptedDueToReplStateChange,
-                        "Not primary while trying to join ongoing DDL coordinators",
+                        "Not primary while trying to join ongoing coordinators",
                         repl::ReplicationCoordinator::get(opCtx)->getMemberState().primary());
             }
 
             const auto& types = request().getTypes();
             IDLParserContext parserContext(Request::kTypesFieldName);
 
-            ShardingDDLCoordinatorService::getService(opCtx)->waitForOngoingCoordinatorsToFinish(
+            ShardingCoordinatorService::getService(opCtx)->waitForOngoingCoordinatorsToFinish(
-                opCtx, [&](const ShardingDDLCoordinator& coordinatorInstance) -> bool {
+                opCtx, [&](const ShardingCoordinator& coordinatorInstance) -> bool {
                     const auto opType = coordinatorInstance.operationType();
                     // Disregard DDL types that use this command as part of their workflow.
-                    if (opType == DDLCoordinatorTypeEnum::kRemoveShardCommit ||
+                    if (opType == CoordinatorTypeEnum::kRemoveShardCommit ||
-                        opType == DDLCoordinatorTypeEnum::kAddShard ||
+                        opType == CoordinatorTypeEnum::kAddShard ||
-                        opType == DDLCoordinatorTypeEnum::kInitializePlacementHistory) {
+                        opType == CoordinatorTypeEnum::kInitializePlacementHistory) {
                         return false;
                     }
                     // If the submitter specified a subset of types, only join those.
                     if (types) {
                         return std::ranges::any_of(*types, [&](StringData type) {
-                            return idl::deserialize<DDLCoordinatorTypeEnum>(type, parserContext) ==
+                            return idl::deserialize<CoordinatorTypeEnum>(type, parserContext) ==
                                 opType;
                         });
                     }

src/mongo/db/global_catalog/ddl/shardsvr_join_ddl_coordinators_request.idl

@@ -37,7 +37,7 @@ commands:
     _shardsvrJoinDDLCoordinators:
         command_name: _shardsvrJoinDDLCoordinators
         cpp_name: ShardsvrJoinDDLCoordinators
-        description: "Waits for all ongoing ShardingDDLCoordinators on this shard to complete"
+        description: "Waits for all ongoing ShardingCoordinators on this shard to complete"
         namespace: ignored
         api_version: ""
         strict: false
@@ -45,6 +45,6 @@ commands:
             types:
                 type: array<string>
                 description: >-
-                    Array with values from the enumeration DDLCoordinatorTypeEnum. If present, only
+                    Array with values from the enumeration CoordinatorTypeEnum. If present, only
                     coordinators of these types will be waited for.
                 optional: true

src/mongo/db/global_catalog/ddl/shardsvr_move_primary_command.cpp

@@ -39,8 +39,8 @@
 #include "mongo/db/global_catalog/ddl/move_primary_coordinator.h"
 #include "mongo/db/global_catalog/ddl/move_primary_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/move_primary_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_util.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
@@ -117,15 +117,15 @@ public:
 
                 auto coordinatorDoc = [&] {
                     MovePrimaryCoordinatorDocument doc;
-                    doc.setShardingDDLCoordinatorMetadata(
+                    doc.setShardingCoordinatorMetadata(
-                        {{dbNss, DDLCoordinatorTypeEnum::kMovePrimary}});
+                        {{dbNss, CoordinatorTypeEnum::kMovePrimary}});
                     doc.setToShardId(toShard->getId());
                     doc.setAuthoritativeMetadataAccessLevel(authoritativeMetadataAccessLevel);
                     return doc.toBSON();
                 }();
 
                 const auto coordinator = [&] {
-                    auto service = ShardingDDLCoordinatorService::getService(opCtx);
+                    auto service = ShardingCoordinatorService::getService(opCtx);
                     return checked_pointer_cast<MovePrimaryCoordinator>(
                         service->getOrCreateInstance(opCtx, std::move(coordinatorDoc), fcvRegion));
                 }();

src/mongo/db/global_catalog/ddl/shardsvr_refine_collection_shard_key_command.cpp

@@ -34,8 +34,8 @@
 #include "mongo/db/global_catalog/ddl/refine_collection_shard_key_coordinator.h"
 #include "mongo/db/global_catalog/ddl/refine_collection_shard_key_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/service_context.h"
@@ -81,12 +81,12 @@ public:
 
             auto refineCoordinator = [&] {
                 auto coordinatorDoc = RefineCollectionShardKeyCoordinatorDocument();
-                coordinatorDoc.setShardingDDLCoordinatorMetadata(
+                coordinatorDoc.setShardingCoordinatorMetadata(
-                    {{ns(), DDLCoordinatorTypeEnum::kRefineCollectionShardKey}});
+                    {{ns(), CoordinatorTypeEnum::kRefineCollectionShardKey}});
                 coordinatorDoc.setRefineCollectionShardKeyRequest(
                     request().getRefineCollectionShardKeyRequest());
 
-                auto service = ShardingDDLCoordinatorService::getService(opCtx);
+                auto service = ShardingCoordinatorService::getService(opCtx);
                 return checked_pointer_cast<RefineCollectionShardKeyCoordinator>(
                     service->getOrCreateInstance(
                         opCtx, coordinatorDoc.toBSON(), FixedFCVRegion{opCtx}));

src/mongo/db/global_catalog/ddl/shardsvr_rename_collection_command.cpp

@@ -39,8 +39,8 @@
 #include "mongo/db/global_catalog/ddl/rename_collection_coordinator.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_rename_collection_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/service_context.h"
@@ -116,11 +116,11 @@ public:
             auto renameCollectionCoordinator = [&]() {
                 auto coordinatorDoc = RenameCollectionCoordinatorDocument();
                 coordinatorDoc.setRenameCollectionRequest(req.getRenameCollectionRequest());
-                coordinatorDoc.setShardingDDLCoordinatorMetadata(
+                coordinatorDoc.setShardingCoordinatorMetadata(
-                    {{fromNss, DDLCoordinatorTypeEnum::kRenameCollection}});
+                    {{fromNss, CoordinatorTypeEnum::kRenameCollection}});
                 coordinatorDoc.setAllowEncryptedCollectionRename(
                     req.getAllowEncryptedCollectionRename().value_or(false));
-                auto service = ShardingDDLCoordinatorService::getService(opCtx);
+                auto service = ShardingCoordinatorService::getService(opCtx);
                 auto coordinator =
                     checked_pointer_cast<RenameCollectionCoordinator>(service->getOrCreateInstance(
                         opCtx, coordinatorDoc.toBSON(), FixedFCVRegion{opCtx}));

src/mongo/db/global_catalog/ddl/shardsvr_set_allow_migrations_command.cpp

@@ -38,8 +38,8 @@
 #include "mongo/db/global_catalog/ddl/set_allow_migrations_coordinator.h"
 #include "mongo/db/global_catalog/ddl/set_allow_migrations_coordinator_document_gen.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/service_context.h"
@@ -96,11 +96,11 @@ public:
                 request().getSetAllowMigrationsRequest();
             auto nss = ns();
             auto coordinatorDoc = SetAllowMigrationsCoordinatorDocument();
-            coordinatorDoc.setShardingDDLCoordinatorMetadata(
+            coordinatorDoc.setShardingCoordinatorMetadata(
-                {{std::move(nss), DDLCoordinatorTypeEnum::kSetAllowMigrations}});
+                {{std::move(nss), CoordinatorTypeEnum::kSetAllowMigrations}});
             coordinatorDoc.setSetAllowMigrationsRequest(std::move(setAllowMigationsCmdRequest));
 
-            auto service = ShardingDDLCoordinatorService::getService(opCtx);
+            auto service = ShardingCoordinatorService::getService(opCtx);
             auto setAllowMigrationsCoordinator =
                 checked_pointer_cast<SetAllowMigrationsCoordinator>(service->getOrCreateInstance(
                     opCtx, coordinatorDoc.toBSON(), FixedFCVRegion{opCtx}));

src/mongo/db/global_catalog/ddl/shardsvr_untrack_unsplittable_collection_command.cpp

@@ -76,10 +76,10 @@ public:
             const auto& nss = ns();
 
             auto coordinatorDoc = UntrackUnsplittableCollectionCoordinatorDocument();
-            coordinatorDoc.setShardingDDLCoordinatorMetadata(
+            coordinatorDoc.setShardingCoordinatorMetadata(
-                {{nss, DDLCoordinatorTypeEnum::kUntrackUnsplittableCollection}});
+                {{nss, CoordinatorTypeEnum::kUntrackUnsplittableCollection}});
 
-            auto service = ShardingDDLCoordinatorService::getService(opCtx);
+            auto service = ShardingCoordinatorService::getService(opCtx);
             auto coordinator = checked_pointer_cast<UntrackUnsplittableCollectionCoordinator>(
                 service->getOrCreateInstance(
                     opCtx, coordinatorDoc.toBSON(), FixedFCVRegion{opCtx}));

src/mongo/db/global_catalog/ddl/shardsvr_upgrade_downgrade_viewless_timeseries_command.cpp

@@ -81,10 +81,10 @@ public:
             auto coordinatorDoc = TimeseriesUpgradeDowngradeCoordinatorDocument();
             coordinatorDoc.setTimeseriesUpgradeDowngradeRequest(
                 request().getTimeseriesUpgradeDowngradeRequest());
-            coordinatorDoc.setShardingDDLCoordinatorMetadata(
+            coordinatorDoc.setShardingCoordinatorMetadata(
-                {{nss, DDLCoordinatorTypeEnum::kTimeseriesUpgradeDowngrade}});
+                {{nss, CoordinatorTypeEnum::kTimeseriesUpgradeDowngrade}});
 
-            auto service = ShardingDDLCoordinatorService::getService(opCtx);
+            auto service = ShardingCoordinatorService::getService(opCtx);
             auto coordinator = checked_pointer_cast<TimeseriesUpgradeDowngradeCoordinator>(
                 service->getOrCreateInstance(
                     opCtx, coordinatorDoc.toBSON(), FixedFCVRegion{opCtx}));

src/mongo/db/global_catalog/ddl/timeseries_upgrade_downgrade_coordinator.h

@@ -34,8 +34,8 @@
 #include "mongo/base/string_data.h"
 #include "mongo/bson/bsonobj.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/timeseries_upgrade_downgrade_coordinator_document_gen.h"
 #include "mongo/executor/scoped_task_executor.h"
 #include "mongo/util/cancellation.h"
@@ -56,7 +56,7 @@ public:
     using StateDoc = TimeseriesUpgradeDowngradeCoordinatorDocument;
     using Phase = TimeseriesUpgradeDowngradeCoordinatorPhaseEnum;
 
-    TimeseriesUpgradeDowngradeCoordinator(ShardingDDLCoordinatorService* service,
+    TimeseriesUpgradeDowngradeCoordinator(ShardingCoordinatorService* service,
                                           const BSONObj& initialState)
         : RecoverableShardingDDLCoordinator(
               service, "TimeseriesUpgradeDowngradeCoordinator", initialState),

src/mongo/db/global_catalog/ddl/timeseries_upgrade_downgrade_coordinator_document.idl

@@ -36,7 +36,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/global_catalog/ddl/sharded_ddl_commands.idl"
 
 enums:
@@ -59,7 +59,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
             TimeseriesUpgradeDowngradeRequest: TimeseriesUpgradeDowngradeRequest
         fields:
             phase:

src/mongo/db/global_catalog/ddl/untrack_unsplittable_collection_coordinator.h

@@ -29,8 +29,8 @@
 
 #pragma once
 
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/untrack_unsplittable_collection_coordinator_document_gen.h"
 #include "mongo/util/modules.h"
 
@@ -42,7 +42,7 @@ class UntrackUnsplittableCollectionCoordinator final
 public:
     using CoordDoc = UntrackUnsplittableCollectionCoordinatorDocument;
     using Phase = UntrackUnsplittableCollectionCoordinatorPhaseEnum;
-    UntrackUnsplittableCollectionCoordinator(ShardingDDLCoordinatorService* service,
+    UntrackUnsplittableCollectionCoordinator(ShardingCoordinatorService* service,
                                              const BSONObj& initialState)
         : RecoverableShardingDDLCoordinator(
               service, "UntrackUnsplittableCollectionCoordinator", initialState),

src/mongo/db/global_catalog/ddl/untrack_unsplittable_collection_coordinator_document.idl

@@ -31,7 +31,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/global_catalog/ddl/sharded_ddl_commands.idl"
 
 enums:
@@ -50,7 +50,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
         fields:
             phase:
                 type: UntrackUnsplittableCollectionCoordinatorPhase

src/mongo/db/mongod_main.cpp

@@ -74,7 +74,7 @@
 #include "mongo/db/ftdc/util.h"
 #include "mongo/db/global_catalog/ddl/configsvr_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/rename_collection_participant_service.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/metadata_consistency_validation/periodic_sharded_index_consistency_checker.h"
 #include "mongo/db/global_settings.h"
 #include "mongo/db/index_builds/index_builds_coordinator.h"
@@ -443,11 +443,11 @@ void registerPrimaryOnlyServices(ServiceContext* serviceContext) {
     }
 
     if (serverGlobalParams.clusterRole.has(ClusterRole::ShardServer)) {
-        auto shardingDDLCoordinatorService =
+        auto shardingCoordinatorService =
-            std::make_unique<ShardingDDLCoordinatorService>(serviceContext);
+            std::make_unique<ShardingCoordinatorService>(serviceContext);
-        DDLLockManager::get(serviceContext)->setRecoverable(shardingDDLCoordinatorService.get());
+        DDLLockManager::get(serviceContext)->setRecoverable(shardingCoordinatorService.get());
 
-        services.emplace_back(std::move(shardingDDLCoordinatorService));
+        services.emplace_back(std::move(shardingCoordinatorService));
         services.push_back(std::make_unique<RenameCollectionParticipantService>(serviceContext));
         services.push_back(std::make_unique<ReshardingDonorService>(serviceContext));
         services.push_back(std::make_unique<ReshardingRecipientService>(serviceContext));

src/mongo/db/repl/FCV_AND_FEATURE_FLAG_README.md

@@ -421,12 +421,12 @@ local FCV document to the fully upgraded or downgraded version.
 `_shardServerPhase1Tasks`: This helper function is only for any actions that should be done specifically on
 shard servers during phase 1 of the 3-phase setFCV protocol for sharded clusters.
 For example, before completing phase 1, we must wait for backward incompatible
-ShardingDDLCoordinators to finish. This is important in order to ensure that no
+ShardingCoordinators to finish. This is important in order to ensure that no
 shard that is currently a participant of such a backward-incompatible
-ShardingDDLCoordinator can transition to the fully downgraded state (and thus,
+ShardingCoordinator can transition to the fully downgraded state (and thus,
 possibly downgrade its binary) while the coordinator is still in progress.
 The fact that the FCV has already transitioned to kDowngrading ensures that no
-new backward-incompatible ShardingDDLCoordinators can start.
+new backward-incompatible ShardingCoordinators can start.
 We do not expect any other feature-specific work to be done in the 'start' phase.
 
 `_prepareToUpgrade` performs all actions and checks that need to be done before proceeding to make
@@ -1061,10 +1061,10 @@ Under this model, the rules for feature flag checks are simplified as follows:
   - setFCV waits for `OperationContext`s with an old Operation FCV to complete before cleaning up Server metadata
     ([SERVER-111447](https://jira.mongodb.org/browse/SERVER-111447)).
 - For distributed operations, the result can be reused across multiple `OperationContext`s.
-  - setFCV waits for `ShardingDDLCoordinator`s with an old Operation FCV to complete before
+  - setFCV waits for `ShardingCoordinator`s with an old Operation FCV to complete before
     the config server coordinates Server metadata cleanup ([SERVER-101537](https://jira.mongodb.org/browse/SERVER-101537)).
 
-Operation FCV is currently only used by DDLs on a sharded cluster (`ShardingDDLCoordinator`) and
+Operation FCV is currently only used by coordinators on a sharded cluster (`ShardingCoordinator`) and
 by some replica set DDLs (e.g. `create`), but it's intended to eventually extend to all operations.
 
 ### Feature Flag Gating in Tests

src/mongo/db/router_role/README_router_role_api.md

@@ -41,7 +41,7 @@ return router.route(
 You can also find below two real usage examples for each case:
 
 - [CollectionRouter example](https://github.com/mongodb/mongo/blob/66405cdf815cdd2504ea4360f3317657e0dbda92/src/mongo/db/s/rename_collection_coordinator.cpp#L630-L642). In this case we need to create indexes for the `config.system.sessions` collection to on all the shards owning data for that collection.
-- [DBPrimaryRouter example](https://github.com/mongodb/mongo/blob/25ddfc96fc2adb2859e91f0401d95b32f3d7af40/src/mongo/db/s/resharding/resharding_manual_cleanup.cpp#L288-L304). In this example, we must target the DBPrimary of the collection’s database to drop the resharding temporary collection. On sharded clusters, it’s important to note that most DDL operations must be directed exclusively to the DBPrimary shard. This is because the DBPrimary is responsible for instantiating a ShardingDDLCoordinator, which coordinates the operation across all shards. To learn more about how DDL operations work in a sharded cluster, go [here](../global_catalog/ddl/README_ddl_operations.md).
+- [DBPrimaryRouter example](https://github.com/mongodb/mongo/blob/25ddfc96fc2adb2859e91f0401d95b32f3d7af40/src/mongo/db/s/resharding/resharding_manual_cleanup.cpp#L288-L304). In this example, we must target the DBPrimary of the collection’s database to drop the resharding temporary collection. On sharded clusters, it’s important to note that most DDL operations must be directed exclusively to the DBPrimary shard. This is because the DBPrimary is responsible for instantiating a ShardingCoordinator, which coordinates the operation across all shards. To learn more about how DDL operations work in a sharded cluster, go [here](../global_catalog/ddl/README_ddl_operations.md).
 
 These classes handle the following processes internally:
 

src/mongo/db/s/BUILD.bazel

@@ -625,10 +625,10 @@ mongo_cc_library(
         "//src/mongo/db/global_catalog/ddl:set_allow_migrations_coordinator_document_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_collmod_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_rename_collection_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator.cpp",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator.cpp",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_external_state.cpp",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_external_state.cpp",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_service.cpp",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_service.cpp",
         "//src/mongo/db/global_catalog/ddl:shardsvr_begin_migration_blocking_operation.cpp",
         "//src/mongo/db/global_catalog/ddl:shardsvr_change_primary_command.cpp",
         "//src/mongo/db/global_catalog/ddl:shardsvr_collmod_command.cpp",
@@ -863,7 +863,7 @@ mongo_cc_library(
 mongo_cc_library(
     name = "sharding_test_helpers",
     srcs = [
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_external_state_for_test.cpp",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_external_state_for_test.cpp",
         "//src/mongo/db/s/resharding:resharding_test_util.cpp",
     ],
     deps = [":db_s_shard_server_test_deps"],
@@ -919,8 +919,8 @@ mongo_cc_unit_test(
         "shardsvr_resolve_view_command_test.cpp",
         "split_vector_test.cpp",
         "start_chunk_clone_request_test.cpp",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_service_test.cpp",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_service_test.cpp",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_test.cpp",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_test.cpp",
         "//src/mongo/db/global_catalog/ddl:sharding_recovery_service_test.cpp",
         "//src/mongo/db/global_catalog/ddl:split_chunk_request_test.cpp",
         "//src/mongo/db/sharding_environment:sharding_initialization_mongod_test.cpp",

src/mongo/db/s/resharding/BUILD.bazel

@@ -34,7 +34,7 @@ idl_generator(
     deps = [
         "//src/mongo/db:basic_types_gen",
         "//src/mongo/db/global_catalog/ddl:sharded_ddl_commands_gen",
-        "//src/mongo/db/global_catalog/ddl:sharding_ddl_coordinator_gen",
+        "//src/mongo/db/global_catalog/ddl:sharding_coordinator_gen",
     ],
 )
 

src/mongo/db/s/resharding/reshard_collection_coordinator.cpp

@@ -88,11 +88,11 @@
 
 namespace mongo {
 
-ReshardCollectionCoordinator::ReshardCollectionCoordinator(ShardingDDLCoordinatorService* service,
+ReshardCollectionCoordinator::ReshardCollectionCoordinator(ShardingCoordinatorService* service,
                                                            const BSONObj& initialState)
     : ReshardCollectionCoordinator(service, initialState, true /* persistCoordinatorDocument */) {}
 
-ReshardCollectionCoordinator::ReshardCollectionCoordinator(ShardingDDLCoordinatorService* service,
+ReshardCollectionCoordinator::ReshardCollectionCoordinator(ShardingCoordinatorService* service,
                                                            const BSONObj& initialState,
                                                            bool persistCoordinatorDocument)
     : RecoverableShardingDDLCoordinator(service, "ReshardCollectionCoordinator", initialState),

src/mongo/db/s/resharding/reshard_collection_coordinator.h

@@ -34,8 +34,8 @@
 #include "mongo/bson/bsonobj.h"
 #include "mongo/bson/bsonobjbuilder.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
 #include "mongo/db/query/write_ops/write_ops.h"
 #include "mongo/db/s/resharding/reshard_collection_coordinator_document_gen.h"
 #include "mongo/executor/scoped_task_executor.h"
@@ -56,15 +56,14 @@ public:
     using StateDoc = ReshardCollectionCoordinatorDocument;
     using Phase = ReshardCollectionCoordinatorPhaseEnum;
 
-    ReshardCollectionCoordinator(ShardingDDLCoordinatorService* service,
+    ReshardCollectionCoordinator(ShardingCoordinatorService* service, const BSONObj& initialState);
-                                 const BSONObj& initialState);
 
     MONGO_MOD_PRIVATE void checkIfOptionsConflict(const BSONObj& coorDoc) const override;
 
     MONGO_MOD_PRIVATE void appendCommandInfo(BSONObjBuilder* cmdInfoBuilder) const override;
 
 protected:
-    ReshardCollectionCoordinator(ShardingDDLCoordinatorService* service,
+    ReshardCollectionCoordinator(ShardingCoordinatorService* service,
                                  const BSONObj& initialState,
                                  bool persistCoordinatorDocument);
 

src/mongo/db/s/resharding/reshard_collection_coordinator_document.idl

@@ -36,7 +36,7 @@ global:
 
 imports:
     - "mongo/db/basic_types.idl"
-    - "mongo/db/global_catalog/ddl/sharding_ddl_coordinator.idl"
+    - "mongo/db/global_catalog/ddl/sharding_coordinator.idl"
     - "mongo/db/global_catalog/ddl/sharded_ddl_commands.idl"
 
 enums:
@@ -53,7 +53,7 @@ structs:
         generate_comparison_operators: false
         strict: false
         chained_structs:
-            ShardingDDLCoordinatorMetadata: ShardingDDLCoordinatorMetadata
+            ShardingCoordinatorMetadata: ShardingCoordinatorMetadata
             ReshardCollectionRequest: ReshardCollectionRequest
         fields:
             phase:

src/mongo/db/s/resharding/shardsvr_reshard_collection_command.cpp

@@ -38,8 +38,8 @@
 #include "mongo/db/database_name.h"
 #include "mongo/db/global_catalog/ddl/cluster_ddl.h"
 #include "mongo/db/global_catalog/ddl/sharded_ddl_commands_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_gen.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_gen.h"
-#include "mongo/db/global_catalog/ddl/sharding_ddl_coordinator_service.h"
+#include "mongo/db/global_catalog/ddl/sharding_coordinator_service.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/s/resharding/reshard_collection_coordinator.h"
@@ -154,10 +154,10 @@ public:
                     request().getReshardCollectionRequest();
                 auto coordinatorDoc = ReshardCollectionCoordinatorDocument();
                 coordinatorDoc.setReshardCollectionRequest(std::move(reshardCollectionRequest));
-                coordinatorDoc.setShardingDDLCoordinatorMetadata(
+                coordinatorDoc.setShardingCoordinatorMetadata(
-                    {{ns(), DDLCoordinatorTypeEnum::kReshardCollection}});
+                    {{ns(), CoordinatorTypeEnum::kReshardCollection}});
 
-                auto service = ShardingDDLCoordinatorService::getService(opCtx);
+                auto service = ShardingCoordinatorService::getService(opCtx);
                 auto reshardCollectionCoordinator =
                     checked_pointer_cast<ReshardCollectionCoordinator>(service->getOrCreateInstance(
                         opCtx, coordinatorDoc.toBSON(), FixedFCVRegion{opCtx}));