Updates related to enabling modules.

Author: GregUtas

input/element.config.txt

@@ -1,4 +1,17 @@
-/ Parameters that use default values are commented out.
+/ CONFIGURATION PARAMETERS.
+/
+/ This file contains key-value pairs, one pair per line.  A line with a /
+/ in the first column is treated as a comment.
+/
+/ Legal characters in a key are A-Z, a-z, 0-9 and period (.), hyphen (-),
+/ and underscore (_). Leading blanks on a line are ignored, after which the
+/ key is the first string containing those legal characters.
+/
+/ The rest of the characters on the line are taken as the value after erasing
+/ leading and trailing blanks.  Legal characters in a value are those in a
+/ key, plus colon (:), slash (/), backslash (\), and internal space ( ).
+/
+/ Parameters that use default values have been commented out.
 /
 BreakEnabled             T
 CheckStack               T
@@ -31,7 +44,7 @@ NullifyObjectData        T
 / NumOfSmallBuffers        1
 / NumOfTimers              1
 / NumOfTinyBuffers         1
-  OptionalModules          an sn ct
+  OptionalModules          nt an sn ct
 ReinitOnSchedTimeout     F
 / RtcInterval              60
 / RtcLimit                 6

src/app/rscapp.cpp

@@ -67,7 +67,7 @@
 //  (a) create its module in CreateModules, below;
 //  (b) have its module pass a symbol to the base Module constructor; and
 //  (c) add that symbol to the OptionalModules configuration parameter in
-//      the configuration file rsc/input/element.config.txt
+//      the configuration file (by default, rsc/input/element.config.txt)
 //  (d) remove a symbol from OptionalModules if you don't create its module
 //
 //& #include "AnModule.h"

src/nb/Module.cpp

@@ -88,11 +88,16 @@ void Module::Display(ostream& stream,
 
 //------------------------------------------------------------------------------
 
+fn_name Module_Enable = "Module.Enable";
+
 void Module::Enable()
 {
-   Debug::ft("Module.Enable");
+   Debug::ft(Module_Enable);
 
-   enabled_ = true;
+   if(Restart::GetLevel() == RestartReboot)
+      enabled_ = true;
+   else
+      Debug::SwLog(Module_Enable, "reboot not in progress", 0);
 }
 
 //------------------------------------------------------------------------------

src/nb/Module.h

@@ -33,11 +33,14 @@
 
 namespace NodeBase
 {
+//  The purpose of modules is to avoid the type of totally unstructured
+//  main() that plagues so many systems.
+//
 //  A module--the term as used here predates C++20 and is unrelated to its
 //  usage--consists of interrelated software that provides some logical
-//  capability.  It is implemented within its own namespace, which should
-//  consist of a separate .h/.cpp pair for each major class.  One of these
-//  pairs is a Module subclass that is invoked during restarts.  The term
+//  capability.  The capability is often implemented in its own namespace
+//  and should have a separate .h/.cpp pair for each major class.  One such
+//  pair is a Module subclass that is invoked during restarts.  The term
 //  "restart" refers to both system initialization (when the executable is
 //  first launched) and reinitialization (to recover from a serious error).
 //
@@ -51,7 +54,7 @@ namespace NodeBase
 //    private:
 //       SomeModule() : Module()
 //       {
-//          //  Modules 1 to N are the ones on which this module depends.
+//          //  Modules 1 to N are the ones that this module requires.
 //          //  Creating their singletons ensures that they will exist in
 //          //  the module registry when the system initializes.  Because
 //          //  each module creates the modules on which it depends before
@@ -65,17 +68,27 @@ namespace NodeBase
 //       }
 //
 //       ~SomeModule() = default;
+//
+//       void Enable() override
+//       {
+//          //  Enable the modules that this one requires, followed by this
+//          //  module.  This must be public if other modules require this
+//          //  one.  The outline is similar to the constructor.
+//          //
+//          Singleton<Module1>::Instance()->Enable();
+//          //  ...
+//          Singleton<ModuleN>::Instance()->Enable();
+//          Module::Enable();
+//       }
+//
 //       void Startup(RestartLevel level) override;
 //       void Shutdown(RestartLevel level) override;
 //    };
 //
-//  Later during initialization, ModuleRegistry::Startup handles most of
-//  the system's initialization by invoking Startup on each module.  The
-//  Startup function initializes the data required by the module when
-//  the system starts to run.
-//
-//  The purpose of modules is to avoid the type of totally unstructured
-//  main() that plagues so many systems.
+//  Later during initialization, ModuleRegistry::Startup handles most of the
+//  system's initialization by invoking Startup on each module that has been
+//  enabled (see the Enable function, below).  A Startup function initializes
+//  the data required by its module when the system initializes or restarts.
 //
 class Module : public Immutable
 {
@@ -95,8 +108,18 @@ class Module : public Immutable
    static const ModuleId MaxId;
 
    //  Enables the module.  Overridden to invoke this function on modules
-   //  that this one requires, after which this version must be invoked.
-   //  May only be invoked during a RestartReboot (first initialization).
+   //  that this one requires (the same ones that its constructor created),
+   //  after which this version must be invoked.  Only invoked during a
+   //  RestartReboot (initial launch), when NodeBase (the lowest layer)
+   //  has initialized.  This function is invoked on each module whose
+   //  Symbol() appears in the configuration parameter OptionalModules,
+   //  which in turn causes it to enable the modules that it requires.
+   //  If a module is not enabled as the result of this procedure, its
+   //  Startup function is not invoked.  This allows a single executable
+   //  with various optiona capabilities to be built, and a subset of those
+   //  capabilities to be enabled by the OptionalModules parameter.  The
+   //  executable's capabilities can later be modified by editing that
+   //  parameter in the configuration file and performing a reboot restart.
    //
    virtual void Enable();
 

src/nb/ModuleRegistry.cpp

@@ -43,6 +43,7 @@
 #include "Memory.h"
 #include "Module.h"
 #include "NbLogs.h"
+#include "NbModule.h"
 #include "NbSignals.h"
 #include "Restart.h"
 #include "RootThread.h"
@@ -332,6 +333,12 @@ void ModuleRegistry::EnableModules() const
 
    if(Restart::GetLevel() != RestartReboot) return;
 
+   //  NbModule is enabled by default, and its Startup function actually
+   //  invokes us.  Enable it explicitly for cosmetic purposes, so that
+   //  it will be marked enabled in the output of the >modules command.
+   //
+   Singleton<NbModule>::Instance()->Enable();
+
    string enabled = modulesCfg_->CurrValue();
 
    for(auto sym = GetSymbol(enabled); !sym.empty(); sym = GetSymbol(enabled))