commit 5bd040e3c316322b4a49b8302a1102f4f9b9ed9d · pyrox.dev/nixpkgs

+5 -1

nixos/README-modular-services.md

···

       51
        
       Provide it as the first attribute in the module:

     

       52
        
       

     

       53
        
       ```nix

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       54
        
       { lib, config, ... }:

     

       55
        
       {

     

       56
        
         _class = "service";

     
···

       87
        
         passthru = {

     

       88
        
           services = {

     

       89
        
             default = {

     

       90
       -
               imports = [ ./service.nix ];

     

       91
        
               example.package = finalAttrs.finalPackage;

     

       92
        
               # ...

     

       93
        
             };

···

       51
        
       Provide it as the first attribute in the module:

     

       52
        
       

     

       53
        
       ```nix

     

       54
       +
       # Non-module dependencies (`importApply`)

     

       55
       +
       { writeScript, runtimeShell }:

     

       56
       +
       

     

       57
       +
       # Service module

     

       58
        
       { lib, config, ... }:

     

       59
        
       {

     

       60
        
         _class = "service";

     
···

       91
        
         passthru = {

     

       92
        
           services = {

     

       93
        
             default = {

     

       94
       +
               imports = [ (lib.modules.importApply ./service.nix { inherit pkgs; }) ];

     

       95
        
               example.package = finalAttrs.finalPackage;

     

       96
        
               # ...

     

       97
        
             };

+11 -1

nixos/doc/manual/default.nix

···

       25
        
           escapeShellArg

     

       26
        
           concatMapStringsSep

     

       27
        
           sourceFilesBySuffices

     

       0
        
       
     

       28
        
           ;

     

       29
        
       

     

       30
        
         common = import ./common.nix;

     
···

       129
        
         '';

     

       130
        
       

     

       131
        
         portableServiceOptions = buildPackages.nixosOptionsDoc {

     

       132
       -
           inherit (evalModules { modules = [ ../../modules/system/service/portable/service.nix ]; }) options;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       133
        
           inherit revision warningsAreErrors;

     

       134
        
           transformOptions =

     

       135
        
             opt:

···

       25
        
           escapeShellArg

     

       26
        
           concatMapStringsSep

     

       27
        
           sourceFilesBySuffices

     

       28
       +
           modules

     

       29
        
           ;

     

       30
        
       

     

       31
        
         common = import ./common.nix;

     
···

       130
        
         '';

     

       131
        
       

     

       132
        
         portableServiceOptions = buildPackages.nixosOptionsDoc {

     

       133
       +
           inherit

     

       134
       +
             (evalModules {

     

       135
       +
               modules = [

     

       136
       +
                 (modules.importApply ../../modules/system/service/portable/service.nix {

     

       137
       +
                   pkgs = throw "nixos docs / portableServiceOptions: Do not reference pkgs in docs";

     

       138
       +
                 })

     

       139
       +
               ];

     

       140
       +
             })

     

       141
       +
             options

     

       142
       +
             ;

     

       143
        
           inherit revision warningsAreErrors;

     

       144
        
           transformOptions =

     

       145
        
             opt:

+3 -1

nixos/doc/manual/development/modular-services.md

···

       85
        
       

     

       86
        
       ## Writing and Reviewing a Modular Service {#modular-service-review}

     

       87
        
       

     

       88
       -
       Refer to the contributor documentation in [`nixos/README-modular-services.md`](https://github.com/NixOS/nixpkgs/blob/master/nixos/README-modular-services.md).

     

       0
        
       
     

       0
        
       
     

       89
        
       

     

       90
        
       ## Portable Service Options {#modular-service-options-portable}

     

       91

···

       85
        
       

     

       86
        
       ## Writing and Reviewing a Modular Service {#modular-service-review}

     

       87
        
       

     

       88
       +
       A typical service module consists of the following:

     

       89
       +
       

     

       90
       +
       For more details, refer to the contributor documentation in [`nixos/README-modular-services.md`](https://github.com/NixOS/nixpkgs/blob/master/nixos/README-modular-services.md).

     

       91
        
       

     

       92
        
       ## Portable Service Options {#modular-service-options-portable}

     

       93

+90

nixos/modules/system/service/README.md

···

       53
        
       

     

       54
        
       - **Simple attribute structure**: Unlike `environment.etc`, `configData` uses a simpler structure with just `enable`, `name`, `text`, `source`, and `path` attributes. Complex ownership options were omitted for simplicity and portability.

     

       55
        
         Per-service user creation is still TBD.

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       53
        
       

     

       54
        
       - **Simple attribute structure**: Unlike `environment.etc`, `configData` uses a simpler structure with just `enable`, `name`, `text`, `source`, and `path` attributes. Complex ownership options were omitted for simplicity and portability.

     

       55
        
         Per-service user creation is still TBD.

     

       56
       +
       

     

       57
       +
       ## No `pkgs` module argument

     

       58
       +
       

     

       59
       +
       The modular service infrastructure avoids exposing `pkgs` as a module argument to service modules. Instead, derivations and builder functions are provided through lexical closure, making dependency relationships explicit and avoiding uncertainty about where dependencies come from.

     

       60
       +
       

     

       61
       +
       ### Benefits

     

       62
       +
       

     

       63
       +
       - **Explicit dependencies**: Services declare what they need rather than implicitly depending on `pkgs`

     

       64
       +
       - **No interference**: Service modules can be reused in different contexts without assuming a specific `pkgs` instance. An unexpected `pkgs` version is not a failure mode anymore.

     

       65
       +
       - **Clarity**: With fewer ways to do things, there's no ambiguity about where dependencies come from (from the module, not the OS or service manager)

     

       66
       +
       

     

       67
       +
       ### Implementation

     

       68
       +
       

     

       69
       +
       - **Portable layer**: Service modules in `portable/` do not receive `pkgs` as a module argument. Any required derivations must be provided by the caller.

     

       70
       +
       

     

       71
       +
       - **Systemd integration**: The `systemd/system.nix` module imports `config-data.nix` as a function, providing `pkgs` in lexical closure:

     

       72
       +
         ```nix

     

       73
       +
         (import ../portable/config-data.nix { inherit pkgs; })

     

       74
       +
         ```

     

       75
       +
       

     

       76
       +
       - **Service modules**:

     

       77
       +
         1. Should explicitly declare their package dependencies as options rather than using `pkgs` defaults:

     

       78
       +
           ```nix

     

       79
       +
           {

     

       80
       +
             # Bad: uses pkgs module argument

     

       81
       +
             foo.package = mkOption {

     

       82
       +
               default = pkgs.python3;

     

       83
       +
               # ...

     

       84
       +
             };

     

       85
       +
           }

     

       86
       +
           ```

     

       87
       +
       

     

       88
       +
           ```nix

     

       89
       +
           {

     

       90
       +
             # Good: caller provides the package

     

       91
       +
             foo.package = mkOption {

     

       92
       +
               type = types.package;

     

       93
       +
               description = "Python package to use";

     

       94
       +
               defaultText = lib.literalMD "The package that provided this module.";

     

       95
       +
             };

     

       96
       +
           }

     

       97
       +
           ```

     

       98
       +
       

     

       99
       +
         2. `passthru.services` can still provide a complete module using the package's lexical scope, making the module truly self-contained:

     

       100
       +
       

     

       101
       +
           **Package (`package.nix`):**

     

       102
       +
           ```nix

     

       103
       +
           {

     

       104
       +
             lib,

     

       105
       +
             writeScript,

     

       106
       +
             runtimeShell,

     

       107
       +
           # ... other dependencies

     

       108
       +
           }:

     

       109
       +
           stdenv.mkDerivation (finalAttrs: {

     

       110
       +
             # ... package definition

     

       111
       +
       

     

       112
       +
             passthru.services.default = {

     

       113
       +
               imports = [

     

       114
       +
                 (lib.modules.importApply ./service.nix {

     

       115
       +
                   inherit writeScript runtimeShell;

     

       116
       +
                 })

     

       117
       +
               ];

     

       118
       +
               someService.package = finalAttrs.finalPackage;

     

       119
       +
             };

     

       120
       +
           })

     

       121
       +
           ```

     

       122
       +
       

     

       123
       +
           **Service module (`service.nix`):**

     

       124
       +
           ```nix

     

       125
       +
           # Non-module dependencies (importApply)

     

       126
       +
           { writeScript, runtimeShell }:

     

       127
       +
       

     

       128
       +
           # Service module

     

       129
       +
           {

     

       130
       +
             lib,

     

       131
       +
             config,

     

       132
       +
             options,

     

       133
       +
             ...

     

       134
       +
           }:

     

       135
       +
           {

     

       136
       +
             # Service definition using writeScript, runtimeShell from lexical scope

     

       137
       +
             process.argv = [

     

       138
       +
               (writeScript "wrapper" ''

     

       139
       +
                 #!${runtimeShell}

     

       140
       +
                 # ... wrapper logic

     

       141
       +
               '')

     

       142
       +
               # ... other args

     

       143
       +
             ];

     

       144
       +
           }

     

       145
       +
           ```

+4 -1

nixos/modules/system/service/portable/config-data.nix

···

       1
        
       # Tests in: ../../../../tests/modular-service-etc/test.nix

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2
        
       # Configuration data support for portable services

     

       3
        
       # This module provides configData for services, enabling configuration reloading

     

       4
        
       # without terminating and restarting the service process.

     

       5
        
       {

     

       6
        
         lib,

     

       7
       -
         pkgs,

     

       8
        
         ...

     

       9
        
       }:

     

       10
        
       let

···

       1
        
       # Tests in: ../../../../tests/modular-service-etc/test.nix

     

       2
       +
       

     

       3
       +
       # Non-modular context provided by the modular services integration.

     

       4
       +
       { pkgs }:

     

       5
       +
       

     

       6
        
       # Configuration data support for portable services

     

       7
        
       # This module provides configData for services, enabling configuration reloading

     

       8
        
       # without terminating and restarting the service process.

     

       9
        
       {

     

       10
        
         lib,

     

       0
        
       
     

       11
        
         ...

     

       12
        
       }:

     

       13
        
       let

+45 -1

nixos/modules/system/service/portable/lib.nix

···

       1
        
       { lib, ... }:

     

       2
        
       let

     

       3
       -
         inherit (lib) concatLists mapAttrsToList showOption;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4
        
       in

     

       5
        
       rec {

     

       6
        
         flattenMapServicesConfigToList =

     
···

       30
        
             assertion = ass.assertion;

     

       31
        
           }) config.assertions

     

       32
        
         );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       33
        
       }

···

       1
        
       { lib, ... }:

     

       2
        
       let

     

       3
       +
         inherit (lib)

     

       4
       +
           concatLists

     

       5
       +
           mapAttrsToList

     

       6
       +
           showOption

     

       7
       +
           types

     

       8
       +
           ;

     

       9
        
       in

     

       10
        
       rec {

     

       11
        
         flattenMapServicesConfigToList =

     
···

       35
        
             assertion = ass.assertion;

     

       36
        
           }) config.assertions

     

       37
        
         );

     

       38
       +
       

     

       39
       +
         /**

     

       40
       +
           This is the entrypoint for the portable part of modular services.

     

       41
       +
       

     

       42
       +
           It provides the various options that are consumed by service manager implementations.

     

       43
       +
       

     

       44
       +
           # Inputs

     

       45
       +
       

     

       46
       +
           `serviceManagerPkgs`: A Nixpkgs instance which will be used for built-in logic such as converting `configData.<path>.text` to a store path.

     

       47
       +
       

     

       48
       +
           `extraRootModules`: Modules to be loaded into the "root" service submodule, but not into its sub-`services`. That's the modules' own responsibility.

     

       49
       +
       

     

       50
       +
           `extraRootSpecialArgs`: Fixed module arguments that are provided in a similar manner to `extraRootModules`.

     

       51
       +
       

     

       52
       +
           # Output

     

       53
       +
       

     

       54
       +
           An attribute set.

     

       55
       +
       

     

       56
       +
           `serviceSubmodule`: a Module System option type which is a `submodule` with the portable modules and this function's inputs loaded into it.

     

       57
       +
         */

     

       58
       +
         configure =

     

       59
       +
           {

     

       60
       +
             serviceManagerPkgs,

     

       61
       +
             extraRootModules ? [ ],

     

       62
       +
             extraRootSpecialArgs ? { },

     

       63
       +
           }:

     

       64
       +
           let

     

       65
       +
             modules = [

     

       66
       +
               (lib.modules.importApply ./service.nix { pkgs = serviceManagerPkgs; })

     

       67
       +
             ];

     

       68
       +
             serviceSubmodule = types.submoduleWith {

     

       69
       +
               class = "service";

     

       70
       +
               modules = modules ++ extraRootModules;

     

       71
       +
               specialArgs = extraRootSpecialArgs;

     

       72
       +
             };

     

       73
       +
           in

     

       74
       +
           {

     

       75
       +
             inherit serviceSubmodule;

     

       76
       +
           };

     

       77
        
       }

+8 -2

nixos/modules/system/service/portable/service.nix

···

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1
        
       {

     

       2
        
         lib,

     

       3
        
         ...

     
···

       12
        
         imports = [

     

       13
        
           ../../../../../modules/generic/meta-maintainers.nix

     

       14
        
           ../../../misc/assertions.nix

     

       15
       -
           ./config-data.nix

     

       16
        
         ];

     

       17
        
         options = {

     

       18
        
           services = mkOption {

     

       19
        
             type = types.attrsOf (

     

       20
        
               types.submoduleWith {

     

       21
        
                 modules = [

     

       22
       -
                   ./service.nix

     

       23
        
                 ];

     

       24
        
               }

     

       25
        
             );

···

       1
       +
       # Non-module arguments

     

       2
       +
       # These are separate from the module arguments to avoid implicit dependencies.

     

       3
       +
       # This makes service modules self-contains, allowing mixing of Nixpkgs versions.

     

       4
       +
       { pkgs }:

     

       5
       +
       

     

       6
       +
       # The module

     

       7
        
       {

     

       8
        
         lib,

     

       9
        
         ...

     
···

       18
        
         imports = [

     

       19
        
           ../../../../../modules/generic/meta-maintainers.nix

     

       20
        
           ../../../misc/assertions.nix

     

       21
       +
           (lib.modules.importApply ./config-data.nix { inherit pkgs; })

     

       22
        
         ];

     

       23
        
         options = {

     

       24
        
           services = mkOption {

     

       25
        
             type = types.attrsOf (

     

       26
        
               types.submoduleWith {

     

       27
        
                 modules = [

     

       28
       +
                   (lib.modules.importApply ./service.nix { inherit pkgs; })

     

       29
        
                 ];

     

       30
        
               }

     

       31
        
             );

+17 -9

nixos/modules/system/service/portable/test.nix

···

       7
        
       

     

       8
        
         portable-lib = import ./lib.nix { inherit lib; };

     

       9
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10
        
         dummyPkg =

     

       11
        
           name:

     

       12
        
           derivation {

     
···

       79
        
           modules = [

     

       80
        
             {

     

       81
        
               options.services = mkOption {

     

       82
       -
                 type = types.attrsOf (

     

       83
       -
                   types.submoduleWith {

     

       84
       -
                     class = "service";

     

       85
       -
                     modules = [

     

       86
       -
                       ./service.nix

     

       87
       -
                     ];

     

       88
       -
                   }

     

       89
       -
                 );

     

       90
        
               };

     

       91
        
             }

     

       92
        
             exampleConfig

     

       93
        
           ];

     

       94
        
         };

     

       95
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       96
        
         test =

     

       97
        
           assert

     

       98
       -
             exampleEval.config == {

     

       99
        
               services = {

     

       100
        
                 service1 = {

     

       101
        
                   process = {

···

       7
        
       

     

       8
        
         portable-lib = import ./lib.nix { inherit lib; };

     

       9
        
       

     

       10
       +
         configured = portable-lib.configure {

     

       11
       +
           serviceManagerPkgs = throw "do not use pkgs in this test";

     

       12
       +
           extraRootModules = [ ];

     

       13
       +
           extraRootSpecialArgs = { };

     

       14
       +
         };

     

       15
       +
       

     

       16
        
         dummyPkg =

     

       17
        
           name:

     

       18
        
           derivation {

     
···

       85
        
           modules = [

     

       86
        
             {

     

       87
        
               options.services = mkOption {

     

       88
       +
                 type = types.attrsOf configured.serviceSubmodule;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       89
        
               };

     

       90
        
             }

     

       91
        
             exampleConfig

     

       92
        
           ];

     

       93
        
         };

     

       94
        
       

     

       95
       +
         filterEval =

     

       96
       +
           config:

     

       97
       +
           lib.optionalAttrs (config ? process) {

     

       98
       +
             inherit (config) assertions warnings process;

     

       99
       +
           }

     

       100
       +
           // {

     

       101
       +
             services = lib.mapAttrs (k: filterEval) config.services;

     

       102
       +
           };

     

       103
       +
       

     

       104
        
         test =

     

       105
        
           assert

     

       106
       +
             filterEval exampleEval.config == {

     

       107
        
               services = {

     

       108
        
                 service1 = {

     

       109
        
                   process = {

+3 -1

nixos/modules/system/service/systemd/service.nix

···

       52
        
       

     

       53
        
       in

     

       54
        
       {

     

       0
        
       
     

       55
        
         imports = [

     

       56
       -
           ../portable/service.nix

     

       57
        
           (lib.mkAliasOptionModule [ "systemd" "service" ] [ "systemd" "services" "" ])

     

       58
        
           (lib.mkAliasOptionModule [ "systemd" "socket" ] [ "systemd" "sockets" "" ])

     

       59
        
         ];

     
···

       101
        
                 };

     

       102
        
               }

     

       103
        
             );

     

       0
        
       
     

       0
        
       
     

       104
        
           };

     

       105
        
         };

     

       106
        
         config = {

···

       52
        
       

     

       53
        
       in

     

       54
        
       {

     

       55
       +
         _class = "service";

     

       56
        
         imports = [

     

       0
        
       
     

       57
        
           (lib.mkAliasOptionModule [ "systemd" "service" ] [ "systemd" "services" "" ])

     

       58
        
           (lib.mkAliasOptionModule [ "systemd" "socket" ] [ "systemd" "sockets" "" ])

     

       59
        
         ];

     
···

       101
        
                 };

     

       102
        
               }

     

       103
        
             );

     

       104
       +
             # Rendered by the portable docs instead.

     

       105
       +
             visible = false;

     

       106
        
           };

     

       107
        
         };

     

       108
        
         config = {

+14 -30

nixos/modules/system/service/systemd/system.nix

···

       59
        
           // concatMapAttrs (

     

       60
        
             subServiceName: subService: makeUnits unitType (dash prefix subServiceName) subService

     

       61
        
           ) service.services;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       62
        
       in

     

       63
        
       {

     

       0
        
       
     

       0
        
       
     

       64
        
         # First half of the magic: mix systemd logic into the otherwise abstract services

     

       65
        
         options = {

     

       66
        
           system.services = mkOption {

     

       67
        
             description = ''

     

       68
        
               A collection of NixOS [modular services](https://nixos.org/manual/nixos/unstable/#modular-services) that are configured as systemd services.

     

       69
        
             '';

     

       70
       -
             type = types.attrsOf (

     

       71
       -
               types.submoduleWith {

     

       72
       -
                 class = "service";

     

       73
       -
                 modules = [

     

       74
       -
                   ./service.nix

     

       75
       -
                   ./config-data-path.nix

     

       76
       -
       

     

       77
       -
                   # TODO: Consider removing pkgs. Service modules can provide their own

     

       78
       -
                   #       dependencies.

     

       79
       -
                   {

     

       80
       -
                     # Extend portable services option

     

       81
       -
                     options.services = lib.mkOption {

     

       82
       -
                       type = types.attrsOf (

     

       83
       -
                         types.submoduleWith {

     

       84
       -
                           specialArgs.pkgs = pkgs;

     

       85
       -
                           modules = [ ];

     

       86
       -
                         }

     

       87
       -
                       );

     

       88
       -
                     };

     

       89
       -
                   }

     

       90
       -
                 ];

     

       91
       -
                 specialArgs = {

     

       92
       -
                   # perhaps: features."systemd" = { };

     

       93
       -
                   # TODO: Consider removing pkgs. Service modules can provide their own

     

       94
       -
                   #       dependencies.

     

       95
       -
                   inherit pkgs;

     

       96
       -
                   systemdPackage = config.systemd.package;

     

       97
       -
                 };

     

       98
       -
               }

     

       99
       -
             );

     

       100
        
             default = { };

     

       101
        
             visible = "shallow";

     

       102
        
           };

···

       59
        
           // concatMapAttrs (

     

       60
        
             subServiceName: subService: makeUnits unitType (dash prefix subServiceName) subService

     

       61
        
           ) service.services;

     

       62
       +
       

     

       63
       +
         modularServiceConfiguration = portable-lib.configure {

     

       64
       +
           serviceManagerPkgs = pkgs;

     

       65
       +
           extraRootModules = [

     

       66
       +
             ./service.nix

     

       67
       +
             ./config-data-path.nix

     

       68
       +
           ];

     

       69
       +
           extraRootSpecialArgs = {

     

       70
       +
             systemdPackage = config.systemd.package;

     

       71
       +
           };

     

       72
       +
         };

     

       73
        
       in

     

       74
        
       {

     

       75
       +
         _class = "nixos";

     

       76
       +
       

     

       77
        
         # First half of the magic: mix systemd logic into the otherwise abstract services

     

       78
        
         options = {

     

       79
        
           system.services = mkOption {

     

       80
        
             description = ''

     

       81
        
               A collection of NixOS [modular services](https://nixos.org/manual/nixos/unstable/#modular-services) that are configured as systemd services.

     

       82
        
             '';

     

       83
       +
             type = types.attrsOf modularServiceConfiguration.serviceSubmodule;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       84
        
             default = { };

     

       85
        
             visible = "shallow";

     

       86
        
           };

+3 -17

nixos/tests/modular-service-etc/python-http-server.nix

···

       3
        
       {

     

       4
        
         config,

     

       5
        
         lib,

     

       6
       -
         pkgs,

     

       7
        
         ...

     

       8
        
       }:

     

       9
        
       let

     
···

       16
        
           python-http-server = {

     

       17
        
             package = mkOption {

     

       18
        
               type = types.package;

     

       19
       -
               default = pkgs.python3;

     

       20
        
               description = "Python package to use for the web server";

     

       21
        
             };

     

       22
        
       

     
···

       46
        
           ];

     

       47
        
       

     

       48
        
           configData = {

     

       49
       -
             # This should probably just be {} if we were to put this module in production.

     

       50
       -
             "webroot" = lib.mkDefault {

     

       51
       -
               source = pkgs.runCommand "default-webroot" { } ''

     

       52
       -
                 mkdir -p $out

     

       53
       -
                 cat > $out/index.html << 'EOF'

     

       54
       -
                 <!DOCTYPE html>

     

       55
       -
                 <html>

     

       56
       -
                 <head><title>Python Web Server</title></head>

     

       57
       -
                 <body>

     

       58
       -
                   <h1>Welcome to the Python Web Server</h1>

     

       59
       -
                   <p>Serving from port ${toString config.python-http-server.port}</p>

     

       60
       -
                 </body>

     

       61
       -
                 </html>

     

       62
       -
                 EOF

     

       63
       -
               '';

     

       64
        
             };

     

       65
        
           };

     

       66
        
         };

···

       3
        
       {

     

       4
        
         config,

     

       5
        
         lib,

     

       0
        
       
     

       6
        
         ...

     

       7
        
       }:

     

       8
        
       let

     
···

       15
        
           python-http-server = {

     

       16
        
             package = mkOption {

     

       17
        
               type = types.package;

     

       0
        
       
     

       18
        
               description = "Python package to use for the web server";

     

       19
        
             };

     

       20
        
       

     
···

       44
        
           ];

     

       45
        
       

     

       46
        
           configData = {

     

       47
       +
             "webroot" = {

     

       48
       +
               # Enable only if directory is set to use this path

     

       49
       +
               enable = lib.mkDefault (config.python-http-server.directory == config.configData."webroot".path);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       50
        
             };

     

       51
        
           };

     

       52
        
         };

+31 -4

nixos/tests/modular-service-etc/test.nix

···

       12
        
         nodes = {

     

       13
        
           server =

     

       14
        
             { pkgs, ... }:

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
             {

     

       16
        
               system.services.webserver = {

     

       17
        
                 # The python web server is simple enough that it doesn't need a reload signal.

     

       18
        
                 # Other services may need to receive a signal in order to re-read what's in `configData`.

     

       19
       -
                 imports = [ ./python-http-server.nix ];

     

       20
        
                 python-http-server = {

     

       21
        
                   port = 8080;

     

       22
        
                 };

     

       23
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
                 # Add a sub-service

     

       25
        
                 services.api = {

     

       26
       -
                   imports = [ ./python-http-server.nix ];

     

       27
        
                   python-http-server = {

     

       28
        
                     port = 8081;

     

       29
        
                   };

     
···

       147
        
           print(f"Before switch - webserver PID: {webserver_pid}, api PID: {api_pid}")

     

       148
        
       

     

       149
        
           # Switch to the specialisation with updated content

     

       150
       -
           switch_output = server.succeed("/run/current-system/specialisation/updated/bin/switch-to-configuration test")

     

       151
       -
           print(f"Switch output: {switch_output}")

     

       0
        
       
     

       152
        
       

     

       153
        
           # Verify services are not mentioned in the switch output (indicating they weren't touched)

     

       154
        
           assert "webserver.service" not in switch_output, f"webserver.service was mentioned in switch output: {switch_output}"

···

       12
        
         nodes = {

     

       13
        
           server =

     

       14
        
             { pkgs, ... }:

     

       15
       +
             let

     

       16
       +
               # Normally the package services.default attribute combines this, but we

     

       17
       +
               # don't have that, because this is not a production service. Should it be?

     

       18
       +
               python-http-server = {

     

       19
       +
                 imports = [ ./python-http-server.nix ];

     

       20
       +
                 python-http-server.package = pkgs.python3;

     

       21
       +
               };

     

       22
       +
             in

     

       23
        
             {

     

       24
        
               system.services.webserver = {

     

       25
        
                 # The python web server is simple enough that it doesn't need a reload signal.

     

       26
        
                 # Other services may need to receive a signal in order to re-read what's in `configData`.

     

       27
       +
                 imports = [ python-http-server ];

     

       28
        
                 python-http-server = {

     

       29
        
                   port = 8080;

     

       30
        
                 };

     

       31
        
       

     

       32
       +
                 configData = {

     

       33
       +
                   "webroot" = {

     

       34
       +
                     source = pkgs.runCommand "webroot" { } ''

     

       35
       +
                       mkdir -p $out

     

       36
       +
                       cat > $out/index.html << 'EOF'

     

       37
       +
                       <!DOCTYPE html>

     

       38
       +
                       <html>

     

       39
       +
                       <head><title>Python Web Server</title></head>

     

       40
       +
                       <body>

     

       41
       +
                         <h1>Welcome to the Python Web Server</h1>

     

       42
       +
                         <p>Serving from port 8080</p>

     

       43
       +
                       </body>

     

       44
       +
                       </html>

     

       45
       +
                       EOF

     

       46
       +
                     '';

     

       47
       +
                   };

     

       48
       +
                 };

     

       49
       +
       

     

       50
        
                 # Add a sub-service

     

       51
        
                 services.api = {

     

       52
       +
                   imports = [ python-http-server ];

     

       53
        
                   python-http-server = {

     

       54
        
                     port = 8081;

     

       55
        
                   };

     
···

       173
        
           print(f"Before switch - webserver PID: {webserver_pid}, api PID: {api_pid}")

     

       174
        
       

     

       175
        
           # Switch to the specialisation with updated content

     

       176
       +
           # Capture both stdout and stderr, and show stderr in real-time for debugging

     

       177
       +
           switch_output = server.succeed("/run/current-system/specialisation/updated/bin/switch-to-configuration test 2>&1 | tee /dev/stderr")

     

       178
       +
           print(f"Switch output (stdout+stderr): {switch_output}")

     

       179
        
       

     

       180
        
           # Verify services are not mentioned in the switch output (indicating they weren't touched)

     

       181
        
           assert "webserver.service" not in switch_output, f"webserver.service was mentioned in switch output: {switch_output}"

nixos/tests/php/fpm-modular.nix

···

       0
        
       
     

       0
        
       
     

       1
        
       { lib, php, ... }:

     

       2
        
       {

     

       3
        
         name = "php-${php.version}-fpm-modular-nginx-test";

···

       1
       +
       # Run with:

     

       2
       +
       #   nix-build -A nixosTests.php.fpm-modular

     

       3
        
       { lib, php, ... }:

     

       4
        
       {

     

       5
        
         name = "php-${php.version}-fpm-modular-nginx-test";

+7 -1

pkgs/by-name/gh/ghostunnel/package.nix

···

       7
        
         ghostunnel,

     

       8
        
         apple-sdk_12,

     

       9
        
         darwinMinVersionHook,

     

       0
        
       
     

       0
        
       
     

       10
        
       }:

     

       11
        
       

     

       12
        
       buildGoModule rec {

     
···

       41
        
         };

     

       42
        
       

     

       43
        
         passthru.services.default = {

     

       44
       -
           imports = [ ./service.nix ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       45
        
           ghostunnel.package = ghostunnel; # FIXME: finalAttrs.finalPackage

     

       46
        
         };

     

       47

···

       7
        
         ghostunnel,

     

       8
        
         apple-sdk_12,

     

       9
        
         darwinMinVersionHook,

     

       10
       +
         writeScript,

     

       11
       +
         runtimeShell,

     

       12
        
       }:

     

       13
        
       

     

       14
        
       buildGoModule rec {

     
···

       43
        
         };

     

       44
        
       

     

       45
        
         passthru.services.default = {

     

       46
       +
           imports = [

     

       47
       +
             (lib.modules.importApply ./service.nix {

     

       48
       +
               inherit writeScript runtimeShell;

     

       49
       +
             })

     

       50
       +
           ];

     

       51
        
           ghostunnel.package = ghostunnel; # FIXME: finalAttrs.finalPackage

     

       52
        
         };

     

       53

+7 -3

pkgs/by-name/gh/ghostunnel/service.nix

···

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1
        
       {

     

       2
        
         lib,

     

       3
        
         config,

     

       4
        
         options,

     

       5
       -
         pkgs,

     

       6
        
         ...

     

       7
        
       }:

     

       8
        
       let

     
···

       25
        
           ghostunnel = {

     

       26
        
             package = mkOption {

     

       27
        
               description = "Package to use for ghostunnel";

     

       0
        
       
     

       28
        
               type = types.package;

     

       29
        
             };

     

       30
        
       

     
···

       191
        
                   cfg.cacert

     

       192
        
                 ])

     

       193
        
                 (

     

       194
       -
                   pkgs.writeScript "load-credentials" ''

     

       195
       -
                     #!${pkgs.runtimeShell}

     

       196
        
                     exec $@ ${

     

       197
        
                       concatStringsSep " " (

     

       198
        
                         optional (cfg.keystore != null) "--keystore=$CREDENTIALS_DIRECTORY/keystore"

···

       1
       +
       # Non-module dependencies (`importApply`)

     

       2
       +
       { writeScript, runtimeShell }:

     

       3
       +
       

     

       4
       +
       # Service module

     

       5
        
       {

     

       6
        
         lib,

     

       7
        
         config,

     

       8
        
         options,

     

       0
        
       
     

       9
        
         ...

     

       10
        
       }:

     

       11
        
       let

     
···

       28
        
           ghostunnel = {

     

       29
        
             package = mkOption {

     

       30
        
               description = "Package to use for ghostunnel";

     

       31
       +
               defaultText = "The ghostunnel package that provided this module.";

     

       32
        
               type = types.package;

     

       33
        
             };

     

       34
        
       

     
···

       195
        
                   cfg.cacert

     

       196
        
                 ])

     

       197
        
                 (

     

       198
       +
                   writeScript "load-credentials" ''

     

       199
       +
                     #!${runtimeShell}

     

       200
        
                     exec $@ ${

     

       201
        
                       concatStringsSep " " (

     

       202
        
                         optional (cfg.keystore != null) "--keystore=$CREDENTIALS_DIRECTORY/keystore"

+7 -1

pkgs/development/interpreters/php/generic.nix

···

       32
        
             common-updater-scripts,

     

       33
        
             curl,

     

       34
        
             jq,

     

       0
        
       
     

       0
        
       
     

       35
        
       

     

       36
        
             version,

     

       37
        
             phpSrc ? null,

     
···

       390
        
                   inherit ztsSupport;

     

       391
        
       

     

       392
        
                   services.default = {

     

       393
       -
                     imports = [ ./service.nix ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       394
        
                     php-fpm.package = lib.mkDefault finalAttrs.finalPackage;

     

       395
        
                   };

     

       396
        
                 };

···

       32
        
             common-updater-scripts,

     

       33
        
             curl,

     

       34
        
             jq,

     

       35
       +
             coreutils,

     

       36
       +
             formats,

     

       37
        
       

     

       38
        
             version,

     

       39
        
             phpSrc ? null,

     
···

       392
        
                   inherit ztsSupport;

     

       393
        
       

     

       394
        
                   services.default = {

     

       395
       +
                     imports = [

     

       396
       +
                       (lib.modules.importApply ./service.nix {

     

       397
       +
                         inherit formats coreutils;

     

       398
       +
                       })

     

       399
       +
                     ];

     

       400
        
                     php-fpm.package = lib.mkDefault finalAttrs.finalPackage;

     

       401
        
                   };

     

       402
        
                 };

+14 -6

pkgs/development/interpreters/php/service.nix

···

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1
        
       {

     

       2
        
         options,

     

       3
        
         config,

     

       4
       -
         pkgs,

     

       5
        
         lib,

     

       6
        
         ...

     

       7
        
       }:

     

       8
        
       let

     

       9
        
         cfg = config.php-fpm;

     

       10
       -
         format = pkgs.formats.iniWithGlobalSection { };

     

       11
        
         configFile = format.generate "php-fpm.conf" {

     

       12
        
           globalSection = lib.filterAttrs (_: v: !lib.isAttrs v) cfg.settings;

     

       13
        
           sections = lib.filterAttrs (_: lib.isAttrs) cfg.settings;

     
···

       76
        
         _class = "service";

     

       77
        
       

     

       78
        
         options.php-fpm = {

     

       79
       -
           package = lib.mkPackageOption pkgs "php" {

     

       80
       -
             example = ''

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       81
        
               php.buildEnv {

     

       82
        
                 extensions =

     

       83
        
                   { all, ... }:

     
···

       163
        
       

     

       164
        
             serviceConfig = {

     

       165
        
               Type = "notify";

     

       166
       -
               ExecReload = "${pkgs.coreutils}/bin/kill -USR2 $MAINPID";

     

       167
        
               RuntimeDirectory = "php-fpm";

     

       168
        
               RuntimeDirectoryPreserve = true;

     

       169
        
               Restart = "always";

     
···

       175
        
       

     

       176
        
           finit.service = {

     

       177
        
             conditions = [ "service/syslogd/ready" ];

     

       178
       -
             reload = "${pkgs.coreutils}/bin/kill -USR2 $MAINPID";

     

       179
        
             notify = "systemd";

     

       180
        
           };

     

       181
        
         };

···

       1
       +
       # Tests in: nixos/tests/php/fpm-modular.nix

     

       2
       +
       

     

       3
       +
       # Non-module dependencies (importApply)

     

       4
       +
       { formats, coreutils }:

     

       5
       +
       

     

       6
       +
       # Service module

     

       7
        
       {

     

       8
        
         options,

     

       9
        
         config,

     

       0
        
       
     

       10
        
         lib,

     

       11
        
         ...

     

       12
        
       }:

     

       13
        
       let

     

       14
        
         cfg = config.php-fpm;

     

       15
       +
         format = formats.iniWithGlobalSection { };

     

       16
        
         configFile = format.generate "php-fpm.conf" {

     

       17
        
           globalSection = lib.filterAttrs (_: v: !lib.isAttrs v) cfg.settings;

     

       18
        
           sections = lib.filterAttrs (_: lib.isAttrs) cfg.settings;

     
···

       81
        
         _class = "service";

     

       82
        
       

     

       83
        
         options.php-fpm = {

     

       84
       +
           package = lib.mkOption {

     

       85
       +
             type = lib.types.package;

     

       86
       +
             description = "PHP package to use for php-fpm";

     

       87
       +
             defaultText = lib.literalMD ''The PHP package that provided this module.'';

     

       88
       +
             example = lib.literalExpression ''

     

       89
        
               php.buildEnv {

     

       90
        
                 extensions =

     

       91
        
                   { all, ... }:

     
···

       171
        
       

     

       172
        
             serviceConfig = {

     

       173
        
               Type = "notify";

     

       174
       +
               ExecReload = "${coreutils}/bin/kill -USR2 $MAINPID";

     

       175
        
               RuntimeDirectory = "php-fpm";

     

       176
        
               RuntimeDirectoryPreserve = true;

     

       177
        
               Restart = "always";

     
···

       183
        
       

     

       184
        
           finit.service = {

     

       185
        
             conditions = [ "service/syslogd/ready" ];

     

       186
       +
             reload = "${coreutils}/bin/kill -USR2 $MAINPID";

     

       187
        
             notify = "systemd";

     

       188
        
           };

     

       189
        
         };