SERVER-40811 reduce GlobalInitializerRegisterer constructors

11 files changed, 80 insertions, 217 deletions

diff --git a/src/mongo/base/global_initializer_registerer.cpp b/src/mongo/base/global_initializer_registerer.cpp
index f89462aa211..f12a05fdc58 100644
--- a/src/mongo/base/global_initializer_registerer.cpp
+++ b/src/mongo/base/global_initializer_registerer.cpp
@@ -38,10 +38,10 @@
 namespace mongo {
 
 GlobalInitializerRegisterer::GlobalInitializerRegisterer(std::string name,
-                                                         std::vector<std::string> prerequisites,
-                                                         std::vector<std::string> dependents,
                                                          InitializerFunction initFn,
-                                                         DeinitializerFunction deinitFn) {
+                                                         DeinitializerFunction deinitFn,
+                                                         std::vector<std::string> prerequisites,
+                                                         std::vector<std::string> dependents) {
     Status status = getGlobalInitializer().getInitializerDependencyGraph().addInitializer(
         std::move(name),
         std::move(initFn),
@@ -55,4 +55,14 @@ GlobalInitializerRegisterer::GlobalInitializerRegisterer(std::string name,
     }
 }
 
+const std::string& defaultInitializerName() {
+    static const auto& s = *new std::string("default");  // Leaked to be shutdown-safe.
+    return s;
+}
+
+namespace {
+GlobalInitializerRegisterer defaultInitializerRegisterer(
+    defaultInitializerName(), [](auto) { return Status::OK(); }, nullptr, {}, {});
+}  // namespace
+
 }  // namespace mongo
diff --git a/src/mongo/base/global_initializer_registerer.h b/src/mongo/base/global_initializer_registerer.h
index 088e6caf3a8..14345a3f98a 100644
--- a/src/mongo/base/global_initializer_registerer.h
+++ b/src/mongo/base/global_initializer_registerer.h
@@ -35,218 +35,66 @@
 #include "mongo/base/initializer_function.h"
 #include "mongo/base/status.h"
 
-/**
-* Convenience parameter representing the default set of dependents for initializer functions. Should
-* just be used internally, for MONGO_INITIALIZER macros, use MONGO_DEFAULT_PREREQUISITES from init.h
-* instead.
-*/
-#define MONGO_DEFAULT_PREREQUISITES_STR "default"
-
 namespace mongo {
 
+// The name of the "default" global initializer.
+// Global initializers with no explicit prerequisites depends on it by default.
+extern const std::string& defaultInitializerName();
+
 /**
- * Type representing the act of registering a process-global intialization function.
+ * Type representing the registration of a global intialization function.
  *
- * Create a module-global instance of this type to register a new initializer, to be run by a
- * call to a variant of mongo::runGlobalInitializers().  See mongo/base/initializer.h,
- * mongo/base/init.h and mongo/base/initializer_dependency_graph.h for details.
+ * Create a nonlocal static storage duration instance of this type to register a new initializer, to
+ * be run by a call to a variant of mongo::runGlobalInitializers().  See "mongo/base/initializer.h",
+ * "mongo/base/init.h', and "mongo/base/initializer_dependency_graph.h" for details.
  */
 class GlobalInitializerRegisterer {
-    GlobalInitializerRegisterer(const GlobalInitializerRegisterer&) = delete;
-    GlobalInitializerRegisterer& operator=(const GlobalInitializerRegisterer&) = delete;
-
 public:
     /**
-    * Defines an initializer function that depends on default prerequisites and has no explicit
-    * dependents.
+    * Constructor parameters:
     *
-    * Does not support deinitialization and will never be re-initialized.
+    *     - std::string name
     *
-    * Usage:
-    *    GlobalInitializerRegisterer myRegsisterer(
-    *            "myInitializer",
-    *            [](InitializerContext* context) {
-    *                // initialization code
-    *                return Status::OK();
-    *            }
-    *    );
-    */
-    GlobalInitializerRegisterer(std::string name, InitializerFunction initFn);
-
-    /**
-    * Defines an initializer function that depends on PREREQUISITES and has no explicit dependents.
+    *     - InitializerFunction initFn
+    *         Must be nonnull.
+    *         Example expression:
     *
-    * At run time, the full set of prerequisites for NAME will be computed as the union of the
-    * explicit PREREQUISITES.
-    *
-    * Does not support deinitialization and will never be re-initialized.
-    *
-    * Usage:
-    *    GlobalInitializerRegisterer myRegsisterer(
-    *            "myInitializer",
-    *            {"myPrereq1", "myPrereq2", ...},
     *            [](InitializerContext* context) {
     *                // initialization code
     *                return Status::OK();
     *            }
-    *    );
-    */
-    GlobalInitializerRegisterer(std::string name,
-                                std::vector<std::string> prerequisites,
-                                InitializerFunction initFn);
-
-    /**
-    * Defines an initializer function that depends on PREREQUISITES and has DEPENDENTS as explicit
-    * dependents.
-    *
-    * At run time, the full set of prerequisites for NAME will be computed as the union of the
-    * explicit PREREQUISITES and the set of all other mongo initializers that name NAME in their
-    * list of dependents.
-    *
-    * Does not support deinitialization and will never be re-initialized.
     *
-    * Usage:
-    *    GlobalInitializerRegisterer myRegsisterer(
-    *            "myInitializer",
-    *            {"myPrereq1", "myPrereq2", ...},
-    *            {"myDependent1", "myDependent2", ...},
-    *            [](InitializerContext* context) {
-    *                // initialization code
-    *                return Status::OK();
-    *            }
-    *    );
-    */
-    GlobalInitializerRegisterer(std::string name,
-                                std::vector<std::string> prerequisites,
-                                std::vector<std::string> dependents,
-                                InitializerFunction initFn);
-
-    /**
-    * Defines an initializer function that depends on default prerequisites and has no explicit
-    * dependents.
-    * It also provides a deinitialization that will execute in reverse order from initialization and
-    * support re-initialization.
+    *     - DeinitializerFunction deinitFn
+    *         A deinitialization that will execute in reverse order from initialization and
+    *         support re-initialization. If not specified, defaults to the `nullptr` function.
+    *         Example expression:
     *
-    * Usage:
-    *    GlobalInitializerRegisterer myRegsisterer(
-    *            "myInitializer",
-    *            [](InitializerContext* context) {
-    *                // initialization code
-    *                return Status::OK();
-    *            },
     *            [](DeinitializerContext* context) {
     *                // deinitialization code
     *                return Status::OK();
     *            }
-    *    );
-    */
-    GlobalInitializerRegisterer(std::string name,
-                                InitializerFunction initFn,
-                                DeinitializerFunction deinitFn);
-
-    /**
-    * Defines an initializer function that depends on PREREQUISITES and has no explicit dependents.
     *
-    * At run time, the full set of prerequisites for NAME will be computed as the union of the
-    * explicit PREREQUISITES.
+    *     - std::vector<std::string> prerequisites
+    *         If not specified, defaults to {"default"}.
     *
-    * It also provides a deinitialization that will execute in reverse order from initialization and
-    * support re-initialization.
-    *
-    * Usage:
-    *    GlobalInitializerRegisterer myRegsisterer(
-    *            "myInitializer",
-    *            {"myPrereq1", "myPrereq2", ...},
-    *            [](InitializerContext* context) {
-    *                // initialization code
-    *                return Status::OK();
-    *            },
-    *            [](DeinitializerContext* context) {
-    *                // deinitialization code
-    *                return Status::OK();
-    *            }
-    *    );
-    */
-    GlobalInitializerRegisterer(std::string name,
-                                std::vector<std::string> prerequisites,
-                                InitializerFunction initFn,
-                                DeinitializerFunction deinitFn);
-
-    /**
-    * Defines an initializer function that depends on PREREQUISITES and has DEPENDENTS as explicit
-    * dependents.
+    *     - std::vector<std::string> dependents
+    *         If not specified, defaults to {} (no dependents).
     *
-    * At run time, the full set of prerequisites for NAME will be computed as the union of the
-    * explicit PREREQUISITES and the set of all other mongo initializers that name NAME in their
-    * list of dependents.
     *
-    * It also provides a deinitialization that will execute in reverse order from initialization and
-    * support re-initialization.
+    * At run time, the full set of prerequisites for `name` will be computed as the union of the
+    * `prerequisites` (which can be defaulted) and all other mongo initializers that list `name` in
+    * their `dependents`.
     *
-    * Usage:
-    *    GlobalInitializerRegisterer myRegsisterer(
-    *            "myInitializer",
-    *            {"myPrereq1", "myPrereq2", ...},
-    *            {"myDependent1", "myDependent2", ...},
-    *            [](InitializerContext* context) {
-    *                // initialization code
-    *                return Status::OK();
-    *            },
-    *            [](DeinitializerContext* context) {
-    *                // deinitialization code
-    *                return Status::OK();
-    *            }
-    *    );
+    * A non-null `deinitFn` will tag the initializer as supporting re-initialization.
     */
     GlobalInitializerRegisterer(std::string name,
-                                std::vector<std::string> prerequisites,
-                                std::vector<std::string> dependents,
                                 InitializerFunction initFn,
-                                DeinitializerFunction deinitFn);
-};
-
-inline GlobalInitializerRegisterer::GlobalInitializerRegisterer(std::string name,
-                                                                InitializerFunction initFn)
-    : GlobalInitializerRegisterer(std::move(name),
-                                  {MONGO_DEFAULT_PREREQUISITES_STR},
-                                  {},
-                                  std::move(initFn),
-                                  DeinitializerFunction()) {}
-
-inline GlobalInitializerRegisterer::GlobalInitializerRegisterer(
-    std::string name, std::vector<std::string> prerequisites, InitializerFunction initFn)
-    : GlobalInitializerRegisterer(std::move(name),
-                                  std::move(prerequisites),
-                                  {},
-                                  std::move(initFn),
-                                  DeinitializerFunction()) {}
-
-inline GlobalInitializerRegisterer::GlobalInitializerRegisterer(
-    std::string name,
-    std::vector<std::string> prerequisites,
-    std::vector<std::string> dependents,
-    InitializerFunction initFn)
-    : GlobalInitializerRegisterer(std::move(name),
-                                  std::move(prerequisites),
-                                  std::move(dependents),
-                                  std::move(initFn),
-                                  DeinitializerFunction()) {}
+                                DeinitializerFunction deinitFn = nullptr,
+                                std::vector<std::string> prerequisites = {defaultInitializerName()},
+                                std::vector<std::string> dependents = {});
 
-inline GlobalInitializerRegisterer::GlobalInitializerRegisterer(std::string name,
-                                                                InitializerFunction initFn,
-                                                                DeinitializerFunction deinitFn)
-    : GlobalInitializerRegisterer(std::move(name),
-                                  {MONGO_DEFAULT_PREREQUISITES_STR},
-                                  {},
-                                  std::move(initFn),
-                                  std::move(deinitFn)) {}
-
-inline GlobalInitializerRegisterer::GlobalInitializerRegisterer(
-    std::string name,
-    std::vector<std::string> prerequisites,
-    InitializerFunction initFn,
-    DeinitializerFunction deinitFn)
-    : GlobalInitializerRegisterer(
-          std::move(name), std::move(prerequisites), {}, std::move(initFn), std::move(deinitFn)) {}
+    GlobalInitializerRegisterer(const GlobalInitializerRegisterer&) = delete;
+    GlobalInitializerRegisterer& operator=(const GlobalInitializerRegisterer&) = delete;
+};
 
 }  // namespace mongo
diff --git a/src/mongo/base/init.cpp b/src/mongo/base/init.cpp
index 5e4316e0a4a..c13f2529157 100644
--- a/src/mongo/base/init.cpp
+++ b/src/mongo/base/init.cpp
@@ -28,5 +28,3 @@
  */
 
 #include "mongo/base/init.h"
-
-MONGO_INITIALIZER_GROUP(default, MONGO_NO_PREREQUISITES, MONGO_NO_DEPENDENTS)
diff --git a/src/mongo/base/init.h b/src/mongo/base/init.h
index 83ded1e2614..fcda0bf48d0 100644
--- a/src/mongo/base/init.h
+++ b/src/mongo/base/init.h
@@ -64,7 +64,7 @@
 /**
  * Convenience parameter representing the default set of dependents for initializer functions.
  */
-#define MONGO_DEFAULT_PREREQUISITES (MONGO_DEFAULT_PREREQUISITES_STR)
+#define MONGO_DEFAULT_PREREQUISITES (::mongo::defaultInitializerName().c_str())
 
 /**
  * Macro to define an initializer function named "NAME" with the default prerequisites, and
@@ -123,9 +123,10 @@
     namespace {                                                                           \
     ::mongo::GlobalInitializerRegisterer _mongoInitializerRegisterer_##NAME(              \
         std::string(#NAME),                                                               \
+        mongo::InitializerFunction(MONGO_INITIALIZER_FUNCTION_NAME_(NAME)),               \
+        mongo::DeinitializerFunction(nullptr),                                            \
         MONGO_MAKE_STRING_VECTOR PREREQUISITES,                                           \
-        MONGO_MAKE_STRING_VECTOR DEPENDENTS,                                              \
-        mongo::InitializerFunction(MONGO_INITIALIZER_FUNCTION_NAME_(NAME)));              \
+        MONGO_MAKE_STRING_VECTOR DEPENDENTS);                                             \
     }                                                                                     \
     ::mongo::Status MONGO_INITIALIZER_FUNCTION_NAME_(NAME)
 
diff --git a/src/mongo/base/shim.h b/src/mongo/base/shim.h
index 8c2a65a3669..a8d115d298a 100644
--- a/src/mongo/base/shim.h
+++ b/src/mongo/base/shim.h
@@ -220,9 +220,10 @@ const bool checkShimsViaTUHook = false;
         }                                                                                     \
         ::mongo::GlobalInitializerRegisterer _mongoInitializerRegisterer(                     \
             std::string(MONGO_SHIM_DEPENDENCY(__VA_ARGS__)),                                  \
+            mongo::InitializerFunction(initializerGroupStartup),                              \
+            mongo::DeinitializerFunction(nullptr),                                            \
             {},                                                                               \
-            {MONGO_SHIM_DEPENDENTS},                                                          \
-            mongo::InitializerFunction(initializerGroupStartup));                             \
+            {MONGO_SHIM_DEPENDENTS});                                                         \
     } /*namespace shim_namespace*/                                                            \
     } /*namespace*/                                                                           \
     shim_namespace##LN::ShimType::MongoShimImplGuts::LibTUHookTypeBase::LibTUHookTypeBase() = \
@@ -256,9 +257,10 @@ const bool checkShimsViaTUHook = false;
                                                                                                 \
         const ::mongo::GlobalInitializerRegisterer registrationHook{                            \
             std::string(MONGO_SHIM_DEPENDENCY(__VA_ARGS__) "_registration"),                    \
+            mongo::InitializerFunction(createInitializerRegistration),                          \
+            mongo::DeinitializerFunction(nullptr),                                              \
             {},                                                                                 \
-            {MONGO_SHIM_DEPENDENCY(__VA_ARGS__), MONGO_SHIM_DEPENDENTS},                        \
-            mongo::InitializerFunction(createInitializerRegistration)};                         \
+            {MONGO_SHIM_DEPENDENCY(__VA_ARGS__), MONGO_SHIM_DEPENDENTS}};                       \
     } /*namespace shim_namespace*/                                                              \
     } /*namespace*/                                                                             \
                                                                                                 \
@@ -299,11 +301,13 @@ const bool checkShimsViaTUHook = false;
                                                                                                  \
         const ::mongo::GlobalInitializerRegisterer overrideHook{                                 \
             std::string(MONGO_SHIM_DEPENDENCY(__VA_ARGS__) "_override"),                         \
+            mongo::InitializerFunction(createInitializerOverride),                               \
+            mongo::DeinitializerFunction(nullptr),                                               \
             {MONGO_SHIM_DEPENDENCY(                                                              \
                 __VA_ARGS__) "_registration"},   /* Override happens after first registration */ \
             {MONGO_SHIM_DEPENDENCY(__VA_ARGS__), /* Provides impl for this shim */               \
-             MONGO_SHIM_DEPENDENTS},             /* Still a shim registration */                 \
-            mongo::InitializerFunction(createInitializerOverride)};                              \
+             MONGO_SHIM_DEPENDENTS}              /* Still a shim registration */                 \
+        };                                                                                       \
     } /*namespace shim_namespace*/                                                               \
     } /*namespace*/                                                                              \
                                                                                                  \
diff --git a/src/mongo/db/service_context.cpp b/src/mongo/db/service_context.cpp
index e83d983ca50..c7ed9d53083 100644
--- a/src/mongo/db/service_context.cpp
+++ b/src/mongo/db/service_context.cpp
@@ -377,7 +377,6 @@ ServiceContext::ConstructorActionRegisterer::ConstructorActionRegisterer(
     if (!destructor)
         destructor = [](ServiceContext*) {};
     _registerer.emplace(std::move(name),
-                        std::move(prereqs),
                         [this, constructor, destructor](InitializerContext* context) {
                             _iter = registeredConstructorActions().emplace(
                                 registeredConstructorActions().end(),
@@ -388,7 +387,8 @@ ServiceContext::ConstructorActionRegisterer::ConstructorActionRegisterer(
                         [this](DeinitializerContext* context) {
                             registeredConstructorActions().erase(_iter);
                             return Status::OK();
-                        });
+                        },
+                        std::move(prereqs));
 }
 
 ServiceContext::UniqueServiceContext ServiceContext::make() {
diff --git a/src/mongo/embedded/embedded.cpp b/src/mongo/embedded/embedded.cpp
index 13e9d4ddc75..705a620731c 100644
--- a/src/mongo/embedded/embedded.cpp
+++ b/src/mongo/embedded/embedded.cpp
@@ -127,8 +127,6 @@ MONGO_INITIALIZER(fsyncLockedForWriting)(InitializerContext* context) {
 
 GlobalInitializerRegisterer filterAllowedIndexFieldNamesEmbeddedInitializer(
     "FilterAllowedIndexFieldNamesEmbedded",
-    {},
-    {"FilterAllowedIndexFieldNames"},
     [](InitializerContext* service) {
         index_key_validate::filterAllowedIndexFieldNames =
             [](std::set<StringData>& allowedIndexFieldNames) {
@@ -136,7 +134,10 @@ GlobalInitializerRegisterer filterAllowedIndexFieldNamesEmbeddedInitializer(
                 allowedIndexFieldNames.erase(IndexDescriptor::kExpireAfterSecondsFieldName);
             };
         return Status::OK();
-    });
+    },
+    DeinitializerFunction(nullptr),
+    {},
+    {"FilterAllowedIndexFieldNames"});
 }  // namespace
 
 using logger::LogComponent;
diff --git a/src/mongo/embedded/embedded_options_init.cpp b/src/mongo/embedded/embedded_options_init.cpp
index 79a8bc1b125..dcb40582c9e 100644
--- a/src/mongo/embedded/embedded_options_init.cpp
+++ b/src/mongo/embedded/embedded_options_init.cpp
@@ -41,8 +41,6 @@ MONGO_GENERAL_STARTUP_OPTIONS_REGISTER(EmbeddedOptions)(InitializerContext* cont
 
 GlobalInitializerRegisterer embeddedOptionsInitializer(
     "EmbeddedOptions",
-    {"BeginStartupOptionValidation", "AllFailPointsRegistered"},
-    {"EndStartupOptionValidation"},
     [](InitializerContext* context) {
         // Run validation, but tell the Environment that we don't want it to be set as "valid",
         // since we may be making it invalid in the canonicalization process.
@@ -60,11 +58,11 @@ GlobalInitializerRegisterer embeddedOptionsInitializer(
         }
         return Status::OK();
     },
-    [](DeinitializerContext* context) { return Status::OK(); });
+    [](DeinitializerContext* context) { return Status::OK(); },
+    {"BeginStartupOptionValidation", "AllFailPointsRegistered"},
+    {"EndStartupOptionValidation"});
 
 GlobalInitializerRegisterer embeddedOptionsStore("EmbeddedOptions_Store",
-                                                 {"BeginStartupOptionStorage"},
-                                                 {"EndStartupOptionStorage"},
                                                  [](InitializerContext* context) {
                                                      return storeOptions(
                                                          optionenvironment::startupOptionsParsed);
@@ -72,7 +70,9 @@ GlobalInitializerRegisterer embeddedOptionsStore("EmbeddedOptions_Store",
                                                  [](DeinitializerContext* context) {
                                                      resetOptions();
                                                      return Status::OK();
-                                                 });
+                                                 },
+                                                 {"BeginStartupOptionStorage"},
+                                                 {"EndStartupOptionStorage"});
 
 }  // namespace embedded
 }  // namespace mongo
diff --git a/src/mongo/embedded/embedded_options_parser_init.cpp b/src/mongo/embedded/embedded_options_parser_init.cpp
index 1a263574a5d..895fb94f9e0 100644
--- a/src/mongo/embedded/embedded_options_parser_init.cpp
+++ b/src/mongo/embedded/embedded_options_parser_init.cpp
@@ -43,8 +43,6 @@ namespace optionenvironment {
 
 GlobalInitializerRegisterer startupOptionsInitializer(
     "StartupOptions",
-    {"BeginStartupOptionParsing"},
-    {"EndStartupOptionParsing"},
     [](InitializerContext* context) {
         // Embedded uses a YAML config passed in argv to reuse the existing interface, extract it
         // from the first element otherwise use empty string.
@@ -60,7 +58,9 @@ GlobalInitializerRegisterer startupOptionsInitializer(
     [](DeinitializerContext* context) {
         startupOptionsParsed = Environment();
         return Status::OK();
-    });
+    },
+    {"BeginStartupOptionParsing"},
+    {"EndStartupOptionParsing"});
 
 }  // namespace optionenvironment
 }  // namespace mongo
diff --git a/src/mongo/tools/mongoebench_options_init.cpp b/src/mongo/tools/mongoebench_options_init.cpp
index 3a661e56b91..4ed8f4d75c5 100644
--- a/src/mongo/tools/mongoebench_options_init.cpp
+++ b/src/mongo/tools/mongoebench_options_init.cpp
@@ -42,14 +42,15 @@ MONGO_GENERAL_STARTUP_OPTIONS_REGISTER(MongoeBenchOptions)(InitializerContext* c
 
 GlobalInitializerRegisterer mongoeBenchOptionsStore(
     "MongoeBenchOptions_Store",
-    {"BeginStartupOptionStorage", "EmbeddedOptions_Store"},
-    {"EndStartupOptionStorage"},
     [](InitializerContext* context) {
         if (!handlePreValidationMongoeBenchOptions(moe::startupOptionsParsed)) {
             quickExit(EXIT_SUCCESS);
         }
         return storeMongoeBenchOptions(moe::startupOptionsParsed, context->args());
-    });
+    },
+    DeinitializerFunction(nullptr),
+    {"BeginStartupOptionStorage", "EmbeddedOptions_Store"},
+    {"EndStartupOptionStorage"});
 
 }  // namespace
 }  // namespace mongo
diff --git a/src/mongo/util/net/ssl_manager_windows.cpp b/src/mongo/util/net/ssl_manager_windows.cpp
index c5b8771f945..71c394da34b 100644
--- a/src/mongo/util/net/ssl_manager_windows.cpp
+++ b/src/mongo/util/net/ssl_manager_windows.cpp
@@ -344,8 +344,6 @@ private:
 
 GlobalInitializerRegisterer sslManagerInitializer(
     "SSLManager",
-    {"EndStartupOptionHandling"},
-    {},
     [](InitializerContext*) {
         if (!isSSLServer || (sslGlobalParams.sslMode.load() != SSLParams::SSLMode_disabled)) {
             theSSLManager = new SSLManagerWindows(sslGlobalParams, isSSLServer);
@@ -359,7 +357,9 @@ GlobalInitializerRegisterer sslManagerInitializer(
         }
 
         return Status::OK();
-    });
+    },
+    {"EndStartupOptionHandling"},
+    {});
 
 SSLConnectionWindows::SSLConnectionWindows(SCHANNEL_CRED* cred,
                                            Socket* sock,