commit d88721e4408988202a0ae3cea3f5551ebfa13168 · pyrox.dev/nixpkgs

+17 -7

lib/modules.nix

···

       20
        
                       , prefix ? []

     

       21
        
                       , # This should only be used for special arguments that need to be evaluated

     

       22
        
                         # when resolving module structure (like in imports). For everything else,

     

       23
       -
                         # there's _module.args.

     

       0
        
       
     

       24
        
                         specialArgs ? {}

     

       25
        
                       , # This would be remove in the future, Prefer _module.args option instead.

     

       26
        
                         args ? {}

     
···

       58
        
       

     

       59
        
             closed = closeModules (modules ++ [ internalModule ]) ({ inherit config options; lib = import ./.; } // specialArgs);

     

       60
        
       

     

       61
       -
             # Note: the list of modules is reversed to maintain backward

     

       62
       -
             # compatibility with the old module system.  Not sure if this is

     

       63
       -
             # the most sensible policy.

     

       64
       -
             options = mergeModules prefix (reverseList closed);

     

       65
        
       

     

       66
        
             # Traverse options and extract the option values into the final

     

       67
        
             # config set.  At the same time, check whether all option

     
···

       87
        
             result = { inherit options config; };

     

       88
        
           in result;

     

       89
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       90
        
         /* Close a set of modules under the ‘imports’ relation. */

     

       91
        
         closeModules = modules: args:

     

       92
        
           let

     
···

       111
        
             else {};

     

       112
        
           in

     

       113
        
           if m ? config || m ? options then

     

       114
       -
             let badAttrs = removeAttrs m ["imports" "options" "config" "key" "_file" "meta"]; in

     

       115
        
             if badAttrs != {} then

     

       116
        
               throw "Module `${key}' has an unsupported attribute `${head (attrNames badAttrs)}'. This is caused by assignments to the top-level attributes `config' or `options'."

     

       117
        
             else

     

       118
        
               { file = m._file or file;

     

       119
        
                 key = toString m.key or key;

     

       0
        
       
     

       120
        
                 imports = m.imports or [];

     

       121
        
                 options = m.options or {};

     

       122
        
                 config = mkMerge [ (m.config or {}) metaSet ];

     
···

       124
        
           else

     

       125
        
             { file = m._file or file;

     

       126
        
               key = toString m.key or key;

     

       0
        
       
     

       127
        
               imports = m.require or [] ++ m.imports or [];

     

       128
        
               options = {};

     

       129
       -
               config = mkMerge [ (removeAttrs m ["key" "_file" "require" "imports"]) metaSet ];

     

       130
        
             };

     

       131
        
       

     

       132
        
         applyIfFunction = key: f: args@{ config, options, lib, ... }: if isFunction f then

···

       20
        
                       , prefix ? []

     

       21
        
                       , # This should only be used for special arguments that need to be evaluated

     

       22
        
                         # when resolving module structure (like in imports). For everything else,

     

       23
       +
                         # there's _module.args. If specialArgs.modulesPath is defined it will be

     

       24
       +
                         # used as the base path for disabledModules.

     

       25
        
                         specialArgs ? {}

     

       26
        
                       , # This would be remove in the future, Prefer _module.args option instead.

     

       27
        
                         args ? {}

     
···

       59
        
       

     

       60
        
             closed = closeModules (modules ++ [ internalModule ]) ({ inherit config options; lib = import ./.; } // specialArgs);

     

       61
        
       

     

       62
       +
             options = mergeModules prefix (reverseList (filterModules (specialArgs.modulesPath or "") closed));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       63
        
       

     

       64
        
             # Traverse options and extract the option values into the final

     

       65
        
             # config set.  At the same time, check whether all option

     
···

       85
        
             result = { inherit options config; };

     

       86
        
           in result;

     

       87
        
       

     

       88
       +
       

     

       89
       +
        # Filter disabled modules. Modules can be disabled allowing

     

       90
       +
        # their implementation to be replaced.

     

       91
       +
        filterModules = modulesPath: modules:

     

       92
       +
          let

     

       93
       +
            moduleKey = m: if isString m then toString modulesPath + "/" + m else toString m;

     

       94
       +
            disabledKeys = map moduleKey (concatMap (m: m.disabledModules) modules);

     

       95
       +
          in

     

       96
       +
            filter (m: !(elem m.key disabledKeys)) modules;

     

       97
       +
       

     

       98
        
         /* Close a set of modules under the ‘imports’ relation. */

     

       99
        
         closeModules = modules: args:

     

       100
        
           let

     
···

       119
        
             else {};

     

       120
        
           in

     

       121
        
           if m ? config || m ? options then

     

       122
       +
             let badAttrs = removeAttrs m ["_file" "key" "disabledModules" "imports" "options" "config" "meta"]; in

     

       123
        
             if badAttrs != {} then

     

       124
        
               throw "Module `${key}' has an unsupported attribute `${head (attrNames badAttrs)}'. This is caused by assignments to the top-level attributes `config' or `options'."

     

       125
        
             else

     

       126
        
               { file = m._file or file;

     

       127
        
                 key = toString m.key or key;

     

       128
       +
                 disabledModules = m.disabledModules or [];

     

       129
        
                 imports = m.imports or [];

     

       130
        
                 options = m.options or {};

     

       131
        
                 config = mkMerge [ (m.config or {}) metaSet ];

     
···

       133
        
           else

     

       134
        
             { file = m._file or file;

     

       135
        
               key = toString m.key or key;

     

       136
       +
               disabledModules = m.disabledModules or [];

     

       137
        
               imports = m.require or [] ++ m.imports or [];

     

       138
        
               options = {};

     

       139
       +
               config = mkMerge [ (removeAttrs m ["_file" "key" "disabledModules" "require" "imports"]) metaSet ];

     

       140
        
             };

     

       141
        
       

     

       142
        
         applyIfFunction = key: f: args@{ config, options, lib, ... }: if isFunction f then

+8

lib/tests/modules.sh

···

       99
        
       checkConfigOutput 'true' "$@" ./define-enable.nix ./define-loaOfSub-foo-if-enable.nix

     

       100
        
       checkConfigOutput 'true' "$@" ./define-enable.nix ./define-loaOfSub-foo-enable-if.nix

     

       101
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       102
        
       # Check _module.args.

     

       103
        
       set -- config.enable ./declare-enable.nix ./define-enable-with-custom-arg.nix

     

       104
        
       checkConfigError 'while evaluating the module argument .*custom.* in .*define-enable-with-custom-arg.nix.*:' "$@"

···

       99
        
       checkConfigOutput 'true' "$@" ./define-enable.nix ./define-loaOfSub-foo-if-enable.nix

     

       100
        
       checkConfigOutput 'true' "$@" ./define-enable.nix ./define-loaOfSub-foo-enable-if.nix

     

       101
        
       

     

       102
       +
       # Check disabledModules with config definitions and option declarations.

     

       103
       +
       set -- config.enable ./define-enable.nix ./declare-enable.nix

     

       104
       +
       checkConfigOutput "true" "$@"

     

       105
       +
       checkConfigOutput "false" "$@" ./disable-define-enable.nix

     

       106
       +
       checkConfigError "The option .*enable.* defined in .* does not exist" "$@" ./disable-declare-enable.nix

     

       107
       +
       checkConfigError "attribute .*enable.* in selection path .*config.enable.* not found" "$@" ./disable-define-enable.nix ./disable-declare-enable.nix

     

       108
       +
       checkConfigError "attribute .*enable.* in selection path .*config.enable.* not found" "$@" ./disable-enable-modules.nix

     

       109
       +
       

     

       110
        
       # Check _module.args.

     

       111
        
       set -- config.enable ./declare-enable.nix ./define-enable-with-custom-arg.nix

     

       112
        
       checkConfigError 'while evaluating the module argument .*custom.* in .*define-enable-with-custom-arg.nix.*:' "$@"

+1

lib/tests/modules/default.nix

···

       3
        
       {

     

       4
        
         inherit (lib.evalModules {

     

       5
        
           inherit modules;

     

       0
        
       
     

       6
        
         }) config options;

     

       7
        
       }

···

       3
        
       {

     

       4
        
         inherit (lib.evalModules {

     

       5
        
           inherit modules;

     

       6
       +
           specialArgs.modulesPath = ./.;

     

       7
        
         }) config options;

     

       8
        
       }

+5

lib/tests/modules/disable-declare-enable.nix

···

       1
       +
       { lib, ... }:

     

       2
       +
       

     

       3
       +
       {

     

       4
       +
         disabledModules = [ ./declare-enable.nix ];

     

       5
       +
       }

+5

lib/tests/modules/disable-define-enable.nix

···

       1
       +
       { lib, ... }:

     

       2
       +
       

     

       3
       +
       {

     

       4
       +
         disabledModules = [ ./define-enable.nix ];

     

       5
       +
       }

+5

lib/tests/modules/disable-enable-modules.nix

···

       1
       +
       { lib, ... }:

     

       2
       +
       

     

       3
       +
       {

     

       4
       +
         disabledModules = [ "define-enable.nix" "declare-enable.nix" ];

     

       5
       +
       }

+75

nixos/doc/manual/development/replace-modules.xml

···

       1
       +
       <section xmlns="http://docbook.org/ns/docbook"

     

       2
       +
               xmlns:xlink="http://www.w3.org/1999/xlink"

     

       3
       +
               xmlns:xi="http://www.w3.org/2001/XInclude"

     

       4
       +
               version="5.0"

     

       5
       +
               xml:id="sec-replace-modules">

     

       6
       +
       

     

       7
       +
       <title>Replace Modules</title>

     

       8
       +
       

     

       9
       +
       <para>Modules that are imported can also be disabled.  The option

     

       10
       +
         declarations and config implementation of a disabled module will be

     

       11
       +
         ignored, allowing another to take it's place.  This can be used to

     

       12
       +
         import a set of modules from another channel while keeping the rest

     

       13
       +
         of the system on a stable release.</para>

     

       14
       +
       <para><literal>disabledModules</literal> is a top level attribute like

     

       15
       +
         <literal>imports</literal>, <literal>options</literal> and

     

       16
       +
         <literal>config</literal>.  It contains a list of modules that will

     

       17
       +
         be disabled. This can either be the full path to the module or a

     

       18
       +
         string with the filename relative to the modules path

     

       19
       +
         (eg. &lt;nixpkgs/nixos/modules&gt; for nixos).

     

       20
       +
         </para>

     

       21
       +
       

     

       22
       +
       <para>This example will replace the existing postgresql module with

     

       23
       +
         the version defined in the nixos-unstable channel while keeping the

     

       24
       +
         rest of the modules and packages from the original nixos channel.

     

       25
       +
         This only overrides the module definition, this won't use postgresql

     

       26
       +
         from nixos-unstable unless explicitly configured to do so.</para>

     

       27
       +
       

     

       28
       +
       <programlisting>

     

       29
       +
       { config, lib, pkgs, ... }:

     

       30
       +
       

     

       31
       +
       {

     

       32
       +
         disabledModules = [ "services/databases/postgresql.nix" ];

     

       33
       +
       

     

       34
       +
         imports =

     

       35
       +
           [ # Use postgresql service from nixos-unstable channel.

     

       36
       +
             # sudo nix-channel --add http://nixos.org/channels/nixos-unstable nixos-unstable

     

       37
       +
             &lt;nixos-unstable/nixos/modules/services/databases/postgresql.nix&gt;

     

       38
       +
           ];

     

       39
       +
       

     

       40
       +
         services.postgresql.enable = true;

     

       41
       +
       }

     

       42
       +
       </programlisting>

     

       43
       +
       

     

       44
       +
       <para>This example shows how to define a custom module as a

     

       45
       +
         replacement for an existing module. Importing this module will

     

       46
       +
         disable the original module without having to know it's

     

       47
       +
         implementation details.</para>

     

       48
       +
       

     

       49
       +
       <programlisting>

     

       50
       +
       { config, lib, pkgs, ... }:

     

       51
       +
       

     

       52
       +
       with lib;

     

       53
       +
       

     

       54
       +
       let

     

       55
       +
         cfg = config.programs.man;

     

       56
       +
       in

     

       57
       +
       

     

       58
       +
       {

     

       59
       +
         disabledModules = [ "services/programs/man.nix" ];

     

       60
       +
       

     

       61
       +
         options = {

     

       62
       +
           programs.man.enable = mkOption {

     

       63
       +
             type = types.bool;

     

       64
       +
             default = true;

     

       65
       +
             description = "Whether to enable manual pages.";

     

       66
       +
           };

     

       67
       +
         };

     

       68
       +
       

     

       69
       +
         config = mkIf cfg.enabled {

     

       70
       +
           warnings = [ "disabled manpages for production deployments." ];

     

       71
       +
         };

     

       72
       +
       }

     

       73
       +
       </programlisting>

     

       74
       +
       

     

       75
       +
       </section>

+1

nixos/doc/manual/development/writing-modules.xml

···

       179
        
       <xi:include href="option-types.xml" />

     

       180
        
       <xi:include href="option-def.xml" />

     

       181
        
       <xi:include href="meta-attributes.xml" />

     

       0
        
       
     

       182
        
       

     

       183
        
       </chapter>

···

       179
        
       <xi:include href="option-types.xml" />

     

       180
        
       <xi:include href="option-def.xml" />

     

       181
        
       <xi:include href="meta-attributes.xml" />

     

       182
       +
       <xi:include href="replace-modules.xml" />

     

       183
        
       

     

       184
        
       </chapter>

+10

nixos/doc/manual/release-notes/rl-1703.xml

···

       271
        
           </para>

     

       272
        
         </listitem>

     

       273
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       274
        
       </itemizedlist>

     

       275
        
       

     

       276

···

       271
        
           </para>

     

       272
        
         </listitem>

     

       273
        
       

     

       274
       +
         <listitem>

     

       275
       +
           <para>

     

       276
       +
             Modules can now be disabled by using <link

     

       277
       +
             xlink:href="https://nixos.org/nixpkgs/manual/#sec-replace-modules">

     

       278
       +
             disabledModules</link>, allowing another to take it's place.  This can be

     

       279
       +
             used to import a set of modules from another channel while keeping the

     

       280
       +
             rest of the system on a stable release.

     

       281
       +
           </para>

     

       282
       +
         </listitem>

     

       283
       +
       

     

       284
        
       </itemizedlist>

     

       285
        
       

     

       286