Preserve sticky module requirements during purge

Purge skips sticky and super-sticky modules but still attempts to unload
their non-sticky requirements. This reports an unrelated dependency error
without explaining why the requirement remains loaded.

Preserve requirements needed by retained sticky modules and apply the
sticky_purge reporting mode to their skipped unload.

Fixes #582

Assisted-by: Codex:gpt-6-astra
Signed-off-by: Adrien Cotte <adrien.cotte@asplus.fr>

Author: adrien-cotte

.hunspell.en.dic

@@ -497,6 +497,7 @@ gh
 ghcommit
 gitlog
 gmake
+gpt
 grp
 gz
 gzip

NEWS.rst

@@ -251,14 +251,16 @@ Modules 5.7.0 (not yet released)
 * Doc: add the :ref:`user-guide` document that explains a selection of
   useful but lesser known features through practical examples and common
   use cases.
+* Keep non-sticky requirements of sticky modules loaded during a
+  :subcmd:`purge` and explicitly report why their unload is skipped according
+  to the :mconfig:`sticky_purge` configuration. (fix issue #582)
 * Init: fix command injection in Bash completion when module names contain
   shell meta-characters. Completion candidates were passed to ``compgen -W``
   which evaluates command substitution syntax. (fix `CVE-2026-85013`_ found
   by AISLE in partnership with Red Hat)
 
 .. _CVE-2026-85013: https://github.com/envmodules/modules/security/advisories/GHSA-8hrw-p88g-qhmg
 
-
 .. _5.6 release notes:
 
 Modules 5.6.2 (2026-09-07)

doc/source/changes.rst

@@ -648,6 +648,15 @@ Module Sub-Commands
  these variables. Exception is made for :envvar:`MODULEPATH` environment
  variable where the mechanism still applies.
 
+:subcmd:`purge`
+
+ Starting with version 5.7, direct and indirect requirements of retained
+ sticky and super-sticky modules are kept loaded, even if those requirements
+ are not sticky themselves. The :mconfig:`sticky_purge` configuration
+ controls reporting for their skipped unload as well as for sticky modules.
+ With :option:`--force`, sticky modules and their requirements can be
+ unloaded, but super-sticky modules and their requirements remain loaded.
+
 :subcmd:`refresh`
 
  Sub-command evaluates all loaded modulefiles and re-apply the non-persistent

doc/source/cookbook/sticky-modules.rst

@@ -170,4 +170,56 @@ for load in the initialization RC file |file etcdir_initrc|:
     module load core
     module load compiler/compB
 
+Preserving requirements during purge
+------------------------------------
+
+Starting with Modules v5.7, :subcmd:`purge` also preserves the requirements
+of retained sticky or super-sticky modules.
+
+A base environment can group *core* and *compiler* under a single *env/base*
+module. In this example, *core* and *compiler* have no sticky tag. The
+:file:`env/base` modulefile declares both as requirements:
+
+.. code-block:: tcl
+
+    #%Module
+    prereq core
+    prereq compiler
+
+Only *env/base* is tagged *super-sticky*, in :file:`env/.modulerc`:
+
+.. code-block:: tcl
+
+    #%Module
+    module-tag super-sticky env/base
+
+With :mconfig:`sticky_purge` set to ``warning``, a purge explains why each
+module remains loaded:
+
+.. parsed-literal::
+
+    :ps:`$` module config sticky_purge warning
+    :ps:`$` module load env/base
+    :ps:`$` module purge
+    Unloading :sgrhi:`env/base`
+      :sgrwa:`WARNING`: Unload of super-sticky module skipped
+
+    Unloading :sgrhi:`compiler`
+      :sgrwa:`WARNING`: Unload of super-sticky module requirement skipped
+
+    Unloading :sgrhi:`core`
+      :sgrwa:`WARNING`: Unload of super-sticky module requirement skipped
+    :ps:`$` module list
+    Currently Loaded Modulefiles:
+     1) core   2) compiler   3) :sgrss:`env/base`
+
+    Key:
+    :sgrss:`super-sticky`
+
+Both requirements remain loaded even though they are not sticky themselves.
+The same protection applies to indirect requirements and to a forced purge
+because *env/base* is super-sticky. Setting ``sticky_purge`` to ``silent``
+suppresses these warnings; its default value, ``error``, reports errors for
+the skipped unloads.
+
 .. vim:set tabstop=2 shiftwidth=2 expandtab autoindent:

doc/source/design/evaluation-errors.rst

@@ -336,6 +336,13 @@ In case of error, *continue on error* behavior is applied. If purge is added
 in the value list of :mconfig:`abort_on_error` configuration option and if
 force mode is not set, *abort on error* behavior applies.
 
+Starting Modules 5.7, unload of a requirement needed by a retained sticky or
+super-sticky module is skipped according to :mconfig:`sticky_purge`.
+``error`` raises an error and follows the above abort or continue behavior.
+``warning`` and ``silent`` skip unload without an error exit code. This also
+applies to indirect requirements and, even in force mode, to requirements of
+super-sticky modules.
+
 Unload sub-command
 ------------------
 

doc/source/design/module-tags.rst

@@ -56,6 +56,13 @@ Specification
   - ``super-sticky``: loaded module cannot be unloaded even if forced, it stills can be unloaded if reloaded afterward (see :ref:`sticky-modules`)
   - ``keep-loaded``: auto_handling mechanism does not unload auto-loaded module
 
+- Starting Modules 5.7, :subcmd:`purge` also preserves the direct and
+  indirect requirements of retained ``sticky`` or ``super-sticky`` modules.
+  Requirements do not inherit these tags. Their unload is skipped according
+  to :mconfig:`sticky_purge`, including when a requirement has no sticky tag.
+  With :option:`--force`, only requirements needed by retained super-sticky
+  modules are protected by this mechanism.
+
 - Tags inherited from module state cannot be set with ``module-tag`` command
 
   - An error is otherwise thrown

doc/source/design/sticky-modules.rst

@@ -48,10 +48,16 @@ Specification
     - it means stickiness applies to the module version
     - thus these versions targeted specifically with ``module-tag`` cannot be swapped by another version from same module
 
-- When a super-sticky module depends on a non-super-sticky module
+- Starting Modules 5.7, ``purge`` preserves requirements of retained sticky
+  and super-sticky modules
 
-  - If a forced ``purge`` command occurs, the dependent module will be unloaded
-  - Which let the super-sticky module with a missing dependency
+  - Direct and indirect requirements are preserved, even without a sticky tag
+  - Only strong requirements are preserved: an alternative requirement may
+    be unloaded while another loaded module still satisfies it
+  - A forced ``purge`` unloads sticky modules and can unload their
+    requirements, but preserves super-sticky modules and their requirements
+  - Before version 5.7, a forced ``purge`` could unload a non-super-sticky
+    requirement and leave a super-sticky module with a missing dependency
 
 - Starting Modules 5.2, sticky modules are unloaded
 
@@ -88,6 +94,13 @@ Specification
       code
     - when set to ``silent``, no message reported, no error exit code
 
+  - Starting Modules 5.7, this configuration also applies to skipped unload
+    of requirements of retained sticky or super-sticky modules
+  - Requirement unload is reported as ``Unload of sticky module requirement
+    skipped`` or ``Unload of super-sticky module requirement skipped``
+  - If both sticky and super-sticky modules require a module, the
+    super-sticky tag takes precedence in this message
+
   - Even when ``sticky_purge`` is set to ``silent``, a warning message is
     reported when unload of sticky module is forced during a purge.
 

doc/source/module.rst

@@ -341,7 +341,8 @@ switches are accepted:
  On :subcmd:`clear` sub-command, skip the confirmation dialog and proceed.
 
  On :subcmd:`purge` sub-command also unload `sticky modules`_ and modulefiles
- that are depended by non-unloadable modules.
+ that are depended by non-unloadable modules, except requirements of retained
+ super-sticky modules.
 
  .. only:: html or latex
 
@@ -1772,6 +1773,9 @@ Module Sub-Commands
   Error behavior when unloading sticky or super-sticky module during a module
   :subcmd:`purge`.
 
+  Also applies to modules whose unload is skipped because they are required,
+  directly or indirectly, by a retained sticky or super-sticky module.
+
   Raise an ``error`` (default) or emit a ``warning`` or be ``silent``. It can
   be changed at installation time with :instopt:`--with-sticky-purge` option.
   The :envvar:`MODULES_STICKY_PURGE` environment variable is defined by
@@ -2379,9 +2383,15 @@ Module Sub-Commands
 
  Unload all loaded *modulefiles*.
 
+ Sticky and super-sticky modules are kept loaded, along with their required
+ modules, including indirect requirements. Unload attempts for these modules
+ are skipped according to the :mconfig:`sticky_purge` configuration: raise an
+ ``error`` (default), emit a ``warning`` or remain ``silent``.
+
  When the :option:`--force` option is set, also unload `sticky modules`_,
  modulefiles that are depended by non-unloadable modules and modulefiles
- raising an evaluation error.
+ raising an evaluation error. Super-sticky modules and their requirements
+ remain loaded even with :option:`--force`.
 
  If one modulefile unload evaluation raises an error, purge sequence
  continues: unloaded modules prior the evaluation error are kept unloaded and
@@ -2398,6 +2408,9 @@ Module Sub-Commands
     .. versionchanged:: 5.4
        Support for :mconfig:`abort_on_error` configuration option added
 
+    .. versionchanged:: 5.7
+       Preserve requirements of retained sticky and super-sticky modules
+
 .. subcmd:: refresh
 
  Force a refresh of all non-persistent components of currently loaded modules.
@@ -3542,6 +3555,14 @@ Modules are designated sticky by associating them the ``sticky`` or the
 ``super-sticky`` :ref:`module tag<Module tags>` with the :mfcmd:`module-tag`
 modulefile command.
 
+Starting with version 5.7, :subcmd:`purge` also preserves the direct and
+indirect requirements of retained sticky or super-sticky modules, even if
+these requirements have no sticky tag. The :mconfig:`sticky_purge`
+configuration applies to their skipped unload. With :option:`--force`,
+sticky modules can be unloaded, but super-sticky modules and their
+requirements remain loaded. If several loaded modules satisfy an alternative
+requirement, only the last necessary one is preserved.
+
 When stickiness is defined over the generic module name (and not over a
 specific module version, a version list or a version range), sticky or
 super-sticky module can be swapped by another version of module. For instance
@@ -6128,6 +6149,9 @@ ENVIRONMENT
  :subcmd:`purge`, raise an ``error`` or emit a ``warning`` message or be
  ``silent``.
 
+ Also applies to the skipped unload of modules required, directly or
+ indirectly, by a retained sticky or super-sticky module.
+
  This environment variable value supersedes the default value set in the
  :mconfig:`sticky_purge` configuration option. It can be defined with the
  :subcmd:`config` sub-command.
@@ -6433,4 +6457,3 @@ SEE ALSO
 --------
 
 :ref:`envml(1)`, :ref:`ml(1)`, :ref:`modulecmd(1)`, :ref:`modulefile(5)`
-

tcl/modeval.tcl

@@ -959,6 +959,19 @@ proc isModuleSticky {mod} {
       $mod sticky 1] && ![getState force])}]
 }
 
+proc getModuleStickyDependentTag {mod} {
+   set sticky_tag {}
+   foreach dep_mod [getDependentLoadedModuleList [list $mod] 1 0 0 0] {
+      if {[isModuleTagged $dep_mod super-sticky 1]} {
+         set sticky_tag super-sticky
+         break
+      } elseif {![getState force] && [isModuleTagged $dep_mod sticky 1]} {
+         set sticky_tag sticky
+      }
+   }
+   return $sticky_tag
+}
+
 proc saveLoadedReqOfUnloadingModule {unload_mod} {
    # fetch requirements of unloading module
    set ::g_savedLoReqOfUnloadMod($unload_mod)\
@@ -1172,6 +1185,21 @@ proc failOrSkipUnloadIfSticky {modname modfile} {
    return 0
 }
 
+proc failOrSkipUnloadIfRequiredBySticky {mod} {
+   set sticky_tag [getModuleStickyDependentTag $mod]
+   if {$sticky_tag eq {}} {
+      return 0
+   }
+
+   set msg [getStickyReqUnloadMsg $sticky_tag]
+   switch -- [getConf sticky_purge] {
+      error {knerror $msg}
+      warning {reportWarning $msg}
+   }
+
+   return 1
+}
+
 # ;;; Local Variables:
 # ;;; Mode: tcl-mode
 # ;;; tcl-indent-level: 3

tcl/report.tcl.in

@@ -1115,6 +1115,10 @@ proc getStickyUnloadMsg {{tag sticky}} {
    return "Unload of $tag module skipped"
 }
 
+proc getStickyReqUnloadMsg {{tag sticky}} {
+   return "Unload of $tag module requirement skipped"
+}
+
 proc getStickyForcedUnloadMsg {} {
    return {Unload of sticky module forced}
 }