commit 1d61efb7f177f7b70c467ab4940fde0a3481d4dc · pyrox.dev/nixpkgs

+5 -8

nixos/modules/config/i18n.nix

···

       80
        
           };

     

       81
        
       

     

       82
        
           # ‘/etc/locale.conf’ is used by systemd.

     

       83
       -
           environment.etc = singleton

     

       84
       -
             { target = "locale.conf";

     

       85
       -
               source = pkgs.writeText "locale.conf"

     

       86
       -
                 ''

     

       87
       -
                   LANG=${config.i18n.defaultLocale}

     

       88
       -
                   ${concatStringsSep "\n" (mapAttrsToList (n: v: ''${n}=${v}'') config.i18n.extraLocaleSettings)}

     

       89
       -
                 '';

     

       90
       -
             };

     

       91
        
       

     

       92
        
         };

     

       93
        
       }

···

       80
        
           };

     

       81
        
       

     

       82
        
           # ‘/etc/locale.conf’ is used by systemd.

     

       83
       +
           environment.etc."locale.conf".source = pkgs.writeText "locale.conf"

     

       84
       +
             ''

     

       85
       +
               LANG=${config.i18n.defaultLocale}

     

       86
       +
               ${concatStringsSep "\n" (mapAttrsToList (n: v: ''${n}=${v}'') config.i18n.extraLocaleSettings)}

     

       87
       +
             '';

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       88
        
       

     

       89
        
         };

     

       90
        
       }

+3 -1

nixos/modules/config/ldap.nix

···

       224
        
       

     

       225
        
         config = mkIf cfg.enable {

     

       226
        
       

     

       227
       -
           environment.etc = optional (!cfg.daemon.enable) ldapConfig;

     

       0
        
       
     

       0
        
       
     

       228
        
       

     

       229
        
           system.activationScripts = mkIf (!cfg.daemon.enable) {

     

       230
        
             ldap = stringAfter [ "etc" "groups" "users" ] ''

···

       224
        
       

     

       225
        
         config = mkIf cfg.enable {

     

       226
        
       

     

       227
       +
           environment.etc = optionalAttrs (!cfg.daemon.enable) {

     

       228
       +
             "ldap.conf" = ldapConfig;

     

       229
       +
           };

     

       230
        
       

     

       231
        
           system.activationScripts = mkIf (!cfg.daemon.enable) {

     

       232
        
             ldap = stringAfter [ "etc" "groups" "users" ] ''

+11 -16

nixos/modules/config/pulseaudio.nix

···

       215
        
       

     

       216
        
         config = mkMerge [

     

       217
        
           {

     

       218
       -
             environment.etc = singleton {

     

       219
       -
               target = "pulse/client.conf";

     

       220
       -
               source = clientConf;

     

       221
        
             };

     

       222
        
       

     

       223
        
             hardware.pulseaudio.configFile = mkDefault "${getBin overriddenPackage}/etc/pulse/default.pa";

     
···

       228
        
       

     

       229
        
             sound.enable = true;

     

       230
        
       

     

       231
       -
             environment.etc = [

     

       232
       -
               { target = "asound.conf";

     

       233
       -
                 source = alsaConf; }

     

       234
        
       

     

       235
       -
               { target = "pulse/daemon.conf";

     

       236
       -
                 source = writeText "daemon.conf" (lib.generators.toKeyValue {} cfg.daemon.config); }

     

       237
        
       

     

       238
       -
               { target = "openal/alsoft.conf";

     

       239
       -
                 source = writeText "alsoft.conf" "drivers=pulse"; }

     

       240
        
       

     

       241
       -
               { target = "libao.conf";

     

       242
       -
                 source = writeText "libao.conf" "default_driver=pulse"; }

     

       243
       -
             ];

     

       244
        
       

     

       245
        
             # Disable flat volumes to enable relative ones

     

       246
        
             hardware.pulseaudio.daemon.config.flat-volumes = mkDefault "no";

     
···

       275
        
           })

     

       276
        
       

     

       277
        
           (mkIf nonSystemWide {

     

       278
       -
             environment.etc = singleton {

     

       279
       -
               target = "pulse/default.pa";

     

       280
       -
               source = myConfigFile;

     

       281
        
             };

     

       282
        
             systemd.user = {

     

       283
        
               services.pulseaudio = {

···

       215
        
       

     

       216
        
         config = mkMerge [

     

       217
        
           {

     

       218
       +
             environment.etc = {

     

       219
       +
               "pulse/client.conf".source = clientConf;

     

       0
        
       
     

       220
        
             };

     

       221
        
       

     

       222
        
             hardware.pulseaudio.configFile = mkDefault "${getBin overriddenPackage}/etc/pulse/default.pa";

     
···

       227
        
       

     

       228
        
             sound.enable = true;

     

       229
        
       

     

       230
       +
             environment.etc = {

     

       231
       +
               "asound.conf".source = alsaConf;

     

       0
        
       
     

       232
        
       

     

       233
       +
               "pulse/daemon.conf".source = writeText "daemon.conf"

     

       234
       +
                 (lib.generators.toKeyValue {} cfg.daemon.config);

     

       235
        
       

     

       236
       +
               "openal/alsoft.conf".source = writeText "alsoft.conf" "drivers=pulse";

     

       0
        
       
     

       237
        
       

     

       238
       +
               "libao.conf".source = writeText "libao.conf" "default_driver=pulse";

     

       239
       +
             };

     

       0
        
       
     

       240
        
       

     

       241
        
             # Disable flat volumes to enable relative ones

     

       242
        
             hardware.pulseaudio.daemon.config.flat-volumes = mkDefault "no";

     
···

       271
        
           })

     

       272
        
       

     

       273
        
           (mkIf nonSystemWide {

     

       274
       +
             environment.etc = {

     

       275
       +
               "pulse/default.pa".source = myConfigFile;

     

       0
        
       
     

       276
        
             };

     

       277
        
             systemd.user = {

     

       278
        
               services.pulseaudio = {

+2 -3

nixos/modules/installer/cd-dvd/system-tarball-pc.nix

···

       122
        
       

     

       123
        
         /* fake entry, just to have a happy stage-1. Users

     

       124
        
            may boot without having stage-1 though */

     

       125
       -
         fileSystems = [

     

       126
        
           { mountPoint = "/";

     

       127
        
             device = "/dev/something";

     

       128
       -
             }

     

       129
       -
         ];

     

       130
        
       

     

       131
        
         nixpkgs.config = {

     

       132
        
           packageOverrides = p: {

···

       122
        
       

     

       123
        
         /* fake entry, just to have a happy stage-1. Users

     

       124
        
            may boot without having stage-1 though */

     

       125
       +
         fileSystems.fake =

     

       126
        
           { mountPoint = "/";

     

       127
        
             device = "/dev/something";

     

       128
       +
           };

     

       0
        
       
     

       129
        
       

     

       130
        
         nixpkgs.config = {

     

       131
        
           packageOverrides = p: {

+2 -3

nixos/modules/installer/cd-dvd/system-tarball-sheevaplug.nix

···

       117
        
       

     

       118
        
         /* fake entry, just to have a happy stage-1. Users

     

       119
        
            may boot without having stage-1 though */

     

       120
       -
         fileSystems = [

     

       121
        
           { mountPoint = "/";

     

       122
        
             device = "/dev/something";

     

       123
       -
             }

     

       124
       -
         ];

     

       125
        
       

     

       126
        
         services.mingetty = {

     

       127
        
           # Some more help text.

···

       117
        
       

     

       118
        
         /* fake entry, just to have a happy stage-1. Users

     

       119
        
            may boot without having stage-1 though */

     

       120
       +
         fileSystems.fake =

     

       121
        
           { mountPoint = "/";

     

       122
        
             device = "/dev/something";

     

       123
       +
           };

     

       0
        
       
     

       124
        
       

     

       125
        
         services.mingetty = {

     

       126
        
           # Some more help text.

+1 -1

nixos/modules/installer/cd-dvd/system-tarball.nix

···

       41
        
       

     

       42
        
           # In stage 1 of the boot, mount the CD/DVD as the root FS by label

     

       43
        
           # so that we don't need to know its device.

     

       44
       -
           fileSystems = [ ];

     

       45
        
       

     

       46
        
           # boot.initrd.availableKernelModules = [ "mvsdio" "reiserfs" "ext3" "ext4" ];

     

       47

···

       41
        
       

     

       42
        
           # In stage 1 of the boot, mount the CD/DVD as the root FS by label

     

       43
        
           # so that we don't need to know its device.

     

       44
       +
           fileSystems = { };

     

       45
        
       

     

       46
        
           # boot.initrd.availableKernelModules = [ "mvsdio" "reiserfs" "ext3" "ext4" ];

     

       47

+6 -3

nixos/modules/programs/dconf.nix

···

       6
        
         cfg = config.programs.dconf;

     

       7
        
       

     

       8
        
         mkDconfProfile = name: path:

     

       9
       -
           { source = path; target = "dconf/profile/${name}"; };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10
        
       

     

       11
        
       in

     

       12
        
       {

     
···

       29
        
         ###### implementation

     

       30
        
       

     

       31
        
         config = mkIf (cfg.profiles != {} || cfg.enable) {

     

       32
       -
           environment.etc = optionals (cfg.profiles != {})

     

       33
       -
             (mapAttrsToList mkDconfProfile cfg.profiles);

     

       34
        
       

     

       35
        
           services.dbus.packages = [ pkgs.dconf ];

     

       36

···

       6
        
         cfg = config.programs.dconf;

     

       7
        
       

     

       8
        
         mkDconfProfile = name: path:

     

       9
       +
           {

     

       10
       +
             name = "dconf/profile/${name}";

     

       11
       +
             value.source = path; 

     

       12
       +
           };

     

       13
        
       

     

       14
        
       in

     

       15
        
       {

     
···

       32
        
         ###### implementation

     

       33
        
       

     

       34
        
         config = mkIf (cfg.profiles != {} || cfg.enable) {

     

       35
       +
           environment.etc = optionalAttrs (cfg.profiles != {})

     

       36
       +
             (mapAttrs' mkDconfProfile cfg.profiles);

     

       37
        
       

     

       38
        
           services.dbus.packages = [ pkgs.dconf ];

     

       39

+11 -15

nixos/modules/programs/shadow.nix

···

       76
        
               config.users.defaultUserShell;

     

       77
        
       

     

       78
        
           environment.etc =

     

       79
       -
             [ { # /etc/login.defs: global configuration for pwdutils.  You

     

       80
       -
                 # cannot login without it!

     

       81
       -
                 source = pkgs.writeText "login.defs" loginDefs;

     

       82
       -
                 target = "login.defs";

     

       83
       -
               }

     

       84
        
       

     

       85
       -
               { # /etc/default/useradd: configuration for useradd.

     

       86
       -
                 source = pkgs.writeText "useradd"

     

       87
       -
                   ''

     

       88
       -
                     GROUP=100

     

       89
       -
                     HOME=/home

     

       90
       -
                     SHELL=${utils.toShellPath config.users.defaultUserShell}

     

       91
       -
                   '';

     

       92
       -
                 target = "default/useradd";

     

       93
       -
               }

     

       94
       -
             ];

     

       95
        
       

     

       96
        
           security.pam.services =

     

       97
        
             { chsh = { rootOK = true; };

···

       76
        
               config.users.defaultUserShell;

     

       77
        
       

     

       78
        
           environment.etc =

     

       79
       +
             { # /etc/login.defs: global configuration for pwdutils.  You

     

       80
       +
               # cannot login without it!

     

       81
       +
               "login.defs".source = pkgs.writeText "login.defs" loginDefs;

     

       0
        
       
     

       0
        
       
     

       82
        
       

     

       83
       +
               # /etc/default/useradd: configuration for useradd.

     

       84
       +
               "default/useradd".source = pkgs.writeText "useradd"

     

       85
       +
                 ''

     

       86
       +
                   GROUP=100

     

       87
       +
                   HOME=/home

     

       88
       +
                   SHELL=${utils.toShellPath config.users.defaultUserShell}

     

       89
       +
                 '';

     

       90
       +
             };

     

       0
        
       
     

       0
        
       
     

       91
        
       

     

       92
        
           security.pam.services =

     

       93
        
             { chsh = { rootOK = true; };

+15 -13

nixos/modules/security/duosec.nix

···

       25
        
           accept_env_factor=${boolToStr cfg.acceptEnvFactor}

     

       26
        
         '';

     

       27
        
       

     

       28
       -
         loginCfgFile = optional cfg.ssh.enable

     

       29
       -
           { source = pkgs.writeText "login_duo.conf" configFileLogin;

     

       30
       -
             mode   = "0600";

     

       31
       -
             user   = "sshd";

     

       32
       -
             target = "duo/login_duo.conf";

     

       33
       -
           };

     

       0
        
       
     

       34
        
       

     

       35
       -
         pamCfgFile = optional cfg.pam.enable

     

       36
       -
           { source = pkgs.writeText "pam_duo.conf" configFilePam;

     

       37
       -
             mode   = "0600";

     

       38
       -
             user   = "sshd";

     

       39
       -
             target = "duo/pam_duo.conf";

     

       40
       -
           };

     

       0
        
       
     

       41
        
       in

     

       42
        
       {

     

       43
        
         options = {

     
···

       186
        
            environment.systemPackages = [ pkgs.duo-unix ];

     

       187
        
       

     

       188
        
            security.wrappers.login_duo.source = "${pkgs.duo-unix.out}/bin/login_duo";

     

       189
       -
            environment.etc = loginCfgFile ++ pamCfgFile;

     

       190
        
       

     

       191
        
            /* If PAM *and* SSH are enabled, then don't do anything special.

     

       192
        
            If PAM isn't used, set the default SSH-only options. */

···

       25
        
           accept_env_factor=${boolToStr cfg.acceptEnvFactor}

     

       26
        
         '';

     

       27
        
       

     

       28
       +
         loginCfgFile = optionalAttrs cfg.ssh.enable {

     

       29
       +
           "duo/login_duo.conf" =

     

       30
       +
             { source = pkgs.writeText "login_duo.conf" configFileLogin;

     

       31
       +
               mode   = "0600";

     

       32
       +
               user   = "sshd";

     

       33
       +
             };

     

       34
       +
         };

     

       35
        
       

     

       36
       +
         pamCfgFile = optional cfg.pam.enable {

     

       37
       +
           "duo/pam_duo.conf" =

     

       38
       +
             { source = pkgs.writeText "pam_duo.conf" configFilePam;

     

       39
       +
               mode   = "0600";

     

       40
       +
               user   = "sshd";

     

       41
       +
             };

     

       42
       +
         };

     

       43
        
       in

     

       44
        
       {

     

       45
        
         options = {

     
···

       188
        
            environment.systemPackages = [ pkgs.duo-unix ];

     

       189
        
       

     

       190
        
            security.wrappers.login_duo.source = "${pkgs.duo-unix.out}/bin/login_duo";

     

       191
       +
            environment.etc = loginCfgFile // pamCfgFile;

     

       192
        
       

     

       193
        
            /* If PAM *and* SSH are enabled, then don't do anything special.

     

       194
        
            If PAM isn't used, set the default SSH-only options. */

+4 -5

nixos/modules/security/pam.nix

···

       475
        
       

     

       476
        
         motd = pkgs.writeText "motd" config.users.motd;

     

       477
        
       

     

       478
       -
         makePAMService = pamService:

     

       479
       -
           { source = pkgs.writeText "${pamService.name}.pam" pamService.text;

     

       480
       -
             target = "pam.d/${pamService.name}";

     

       481
        
           };

     

       482
        
       

     

       483
        
       in

     
···

       760
        
             };

     

       761
        
           };

     

       762
        
       

     

       763
       -
           environment.etc =

     

       764
       -
             mapAttrsToList (n: v: makePAMService v) config.security.pam.services;

     

       765
        
       

     

       766
        
           security.pam.services =

     

       767
        
             { other.text =

···

       475
        
       

     

       476
        
         motd = pkgs.writeText "motd" config.users.motd;

     

       477
        
       

     

       478
       +
         makePAMService = name: service:

     

       479
       +
           { name = "pam.d/${name}";

     

       480
       +
             value.source = pkgs.writeText "${name}.pam" service.text;

     

       481
        
           };

     

       482
        
       

     

       483
        
       in

     
···

       760
        
             };

     

       761
        
           };

     

       762
        
       

     

       763
       +
           environment.etc = mapAttrs' makePAMService config.security.pam.services;

     

       0
        
       
     

       764
        
       

     

       765
        
           security.pam.services =

     

       766
        
             { other.text =

+2 -3

nixos/modules/security/pam_mount.nix

···

       36
        
         config = mkIf (cfg.enable || anyPamMount) {

     

       37
        
       

     

       38
        
           environment.systemPackages = [ pkgs.pam_mount ];

     

       39
       -
           environment.etc = [{

     

       40
       -
             target = "security/pam_mount.conf.xml";

     

       41
        
             source =

     

       42
        
               let

     

       43
        
                 extraUserVolumes = filterAttrs (n: u: u.cryptHomeLuks != null) config.users.users;

     
···

       66
        
                 ${concatStringsSep "\n" cfg.extraVolumes}

     

       67
        
                 </pam_mount>

     

       68
        
                 '';

     

       69
       -
           }];

     

       70
        
       

     

       71
        
         };

     

       72
        
       }

···

       36
        
         config = mkIf (cfg.enable || anyPamMount) {

     

       37
        
       

     

       38
        
           environment.systemPackages = [ pkgs.pam_mount ];

     

       39
       +
           environment.etc."security/pam_mount.conf.xml" = {

     

       0
        
       
     

       40
        
             source =

     

       41
        
               let

     

       42
        
                 extraUserVolumes = filterAttrs (n: u: u.cryptHomeLuks != null) config.users.users;

     
···

       65
        
                 ${concatStringsSep "\n" cfg.extraVolumes}

     

       66
        
                 </pam_mount>

     

       67
        
                 '';

     

       68
       +
           };

     

       69
        
       

     

       70
        
         };

     

       71
        
       }

+2 -3

nixos/modules/security/rtkit.nix

···

       34
        
       

     

       35
        
           services.dbus.packages = [ pkgs.rtkit ];

     

       36
        
       

     

       37
       -
           users.users = singleton

     

       38
       -
             { name = "rtkit";

     

       39
       -
               uid = config.ids.uids.rtkit;

     

       40
        
               description = "RealtimeKit daemon";

     

       41
        
             };

     

       42

···

       34
        
       

     

       35
        
           services.dbus.packages = [ pkgs.rtkit ];

     

       36
        
       

     

       37
       +
           users.users.rtkit =

     

       38
       +
             { uid = config.ids.uids.rtkit;

     

       0
        
       
     

       39
        
               description = "RealtimeKit daemon";

     

       40
        
             };

     

       41

+1 -2

nixos/modules/security/sudo.nix

···

       212
        
       

     

       213
        
           security.pam.services.sudo = { sshAgentAuth = true; };

     

       214
        
       

     

       215
       -
           environment.etc = singleton

     

       216
        
             { source =

     

       217
        
                 pkgs.runCommand "sudoers"

     

       218
        
                 {

     
···

       222
        
                 # Make sure that the sudoers file is syntactically valid.

     

       223
        
                 # (currently disabled - NIXOS-66)

     

       224
        
                 "${pkgs.buildPackages.sudo}/sbin/visudo -f $src -c && cp $src $out";

     

       225
       -
               target = "sudoers";

     

       226
        
               mode = "0440";

     

       227
        
             };

     

       228

···

       212
        
       

     

       213
        
           security.pam.services.sudo = { sshAgentAuth = true; };

     

       214
        
       

     

       215
       +
           environment.etc.sudoers =

     

       216
        
             { source =

     

       217
        
                 pkgs.runCommand "sudoers"

     

       218
        
                 {

     
···

       222
        
                 # Make sure that the sudoers file is syntactically valid.

     

       223
        
                 # (currently disabled - NIXOS-66)

     

       224
        
                 "${pkgs.buildPackages.sudo}/sbin/visudo -f $src -c && cp $src $out";

     

       0
        
       
     

       225
        
               mode = "0440";

     

       226
        
             };

     

       227

+12 -12

nixos/modules/services/audio/mpd.nix

···

       184
        
             };

     

       185
        
           };

     

       186
        
       

     

       187
       -
           users.users = optionalAttrs (cfg.user == name) (singleton {

     

       188
       -
             inherit uid;

     

       189
       -
             inherit name;

     

       190
       -
             group = cfg.group;

     

       191
       -
             extraGroups = [ "audio" ];

     

       192
       -
             description = "Music Player Daemon user";

     

       193
       -
             home = "${cfg.dataDir}";

     

       194
       -
           });

     

       0
        
       
     

       195
        
       

     

       196
       -
           users.groups = optionalAttrs (cfg.group == name) (singleton {

     

       197
       -
             inherit name;

     

       198
       -
             gid = gid;

     

       199
       -
           });

     

       200
        
         };

     

       201
        
       

     

       202
        
       }

···

       184
        
             };

     

       185
        
           };

     

       186
        
       

     

       187
       +
           users.users = optionalAttrs (cfg.user == name) {

     

       188
       +
             ${name} = {

     

       189
       +
               inherit uid;

     

       190
       +
               group = cfg.group;

     

       191
       +
               extraGroups = [ "audio" ];

     

       192
       +
               description = "Music Player Daemon user";

     

       193
       +
               home = "${cfg.dataDir}";

     

       194
       +
             };

     

       195
       +
           };

     

       196
        
       

     

       197
       +
           users.groups = optionalAttrs (cfg.group == name) {

     

       198
       +
             ${name}.gid = gid;

     

       199
       +
           };

     

       0
        
       
     

       200
        
         };

     

       201
        
       

     

       202
        
       }

+4 -3

nixos/modules/services/backup/mysql-backup.nix

···

       84
        
         };

     

       85
        
       

     

       86
        
         config = mkIf cfg.enable {

     

       87
       -
           users.users = optionalAttrs (cfg.user == defaultUser) (singleton

     

       88
       -
             { name = defaultUser;

     

       89
        
               isSystemUser = true;

     

       90
        
               createHome = false;

     

       91
        
               home = cfg.location;

     

       92
        
               group = "nogroup";

     

       93
       -
             });

     

       0
        
       
     

       94
        
       

     

       95
        
           services.mysql.ensureUsers = [{

     

       96
        
             name = cfg.user;

···

       84
        
         };

     

       85
        
       

     

       86
        
         config = mkIf cfg.enable {

     

       87
       +
           users.users = optionalAttrs (cfg.user == defaultUser) {

     

       88
       +
             ${defaultUser} = {

     

       89
        
               isSystemUser = true;

     

       90
        
               createHome = false;

     

       91
        
               home = cfg.location;

     

       92
        
               group = "nogroup";

     

       93
       +
             };

     

       94
       +
           };

     

       95
        
       

     

       96
        
           services.mysql.ensureUsers = [{

     

       97
        
             name = cfg.user;

+1 -2

nixos/modules/services/cluster/kubernetes/default.nix

···

       266
        
               "d /var/lib/kubernetes 0755 kubernetes kubernetes -"

     

       267
        
             ];

     

       268
        
       

     

       269
       -
             users.users = singleton {

     

       270
       -
               name = "kubernetes";

     

       271
        
               uid = config.ids.uids.kubernetes;

     

       272
        
               description = "Kubernetes user";

     

       273
        
               extraGroups = [ "docker" ];

···

       266
        
               "d /var/lib/kubernetes 0755 kubernetes kubernetes -"

     

       267
        
             ];

     

       268
        
       

     

       269
       +
             users.users.kubernetes = {

     

       0
        
       
     

       270
        
               uid = config.ids.uids.kubernetes;

     

       271
        
               description = "Kubernetes user";

     

       272
        
               extraGroups = [ "docker" ];

+11 -10

nixos/modules/services/continuous-integration/buildbot/master.nix

···

       223
        
       

     

       224
        
         config = mkIf cfg.enable {

     

       225
        
           users.groups = optional (cfg.group == "buildbot") {

     

       226
       -
             name = "buildbot";

     

       227
        
           };

     

       228
        
       

     

       229
       -
           users.users = optional (cfg.user == "buildbot") {

     

       230
       -
             name = "buildbot";

     

       231
       -
             description = "Buildbot User.";

     

       232
       -
             isNormalUser = true;

     

       233
       -
             createHome = true;

     

       234
       -
             home = cfg.home;

     

       235
       -
             group = cfg.group;

     

       236
       -
             extraGroups = cfg.extraGroups;

     

       237
       -
             useDefaultShell = true;

     

       0
        
       
     

       238
        
           };

     

       239
        
       

     

       240
        
           systemd.services.buildbot-master = {

···

       223
        
       

     

       224
        
         config = mkIf cfg.enable {

     

       225
        
           users.groups = optional (cfg.group == "buildbot") {

     

       226
       +
             buildbot = { };

     

       227
        
           };

     

       228
        
       

     

       229
       +
           users.users = optionalAttrs (cfg.user == "buildbot") {

     

       230
       +
             buildbot = {

     

       231
       +
               description = "Buildbot User.";

     

       232
       +
               isNormalUser = true;

     

       233
       +
               createHome = true;

     

       234
       +
               home = cfg.home;

     

       235
       +
               group = cfg.group;

     

       236
       +
               extraGroups = cfg.extraGroups;

     

       237
       +
               useDefaultShell = true;

     

       238
       +
             };

     

       239
        
           };

     

       240
        
       

     

       241
        
           systemd.services.buildbot-master = {

+11 -10

nixos/modules/services/continuous-integration/buildbot/worker.nix

···

       137
        
           services.buildbot-worker.workerPassFile = mkDefault (pkgs.writeText "buildbot-worker-password" cfg.workerPass);

     

       138
        
       

     

       139
        
           users.groups = optional (cfg.group == "bbworker") {

     

       140
       -
             name = "bbworker";

     

       141
        
           };

     

       142
        
       

     

       143
       -
           users.users = optional (cfg.user == "bbworker") {

     

       144
       -
             name = "bbworker";

     

       145
       -
             description = "Buildbot Worker User.";

     

       146
       -
             isNormalUser = true;

     

       147
       -
             createHome = true;

     

       148
       -
             home = cfg.home;

     

       149
       -
             group = cfg.group;

     

       150
       -
             extraGroups = cfg.extraGroups;

     

       151
       -
             useDefaultShell = true;

     

       0
        
       
     

       152
        
           };

     

       153
        
       

     

       154
        
           systemd.services.buildbot-worker = {

···

       137
        
           services.buildbot-worker.workerPassFile = mkDefault (pkgs.writeText "buildbot-worker-password" cfg.workerPass);

     

       138
        
       

     

       139
        
           users.groups = optional (cfg.group == "bbworker") {

     

       140
       +
             bbworker = { };

     

       141
        
           };

     

       142
        
       

     

       143
       +
           users.users = optionalAttrs (cfg.user == "bbworker") {

     

       144
       +
             bbworker = {

     

       145
       +
               description = "Buildbot Worker User.";

     

       146
       +
               isNormalUser = true;

     

       147
       +
               createHome = true;

     

       148
       +
               home = cfg.home;

     

       149
       +
               group = cfg.group;

     

       150
       +
               extraGroups = cfg.extraGroups;

     

       151
       +
               useDefaultShell = true;

     

       152
       +
             };

     

       153
        
           };

     

       154
        
       

     

       155
        
           systemd.services.buildbot-worker = {

+12 -12

nixos/modules/services/continuous-integration/gocd-agent/default.nix

···

       135
        
         };

     

       136
        
       

     

       137
        
         config = mkIf cfg.enable {

     

       138
       -
           users.groups = optional (cfg.group == "gocd-agent") {

     

       139
       -
             name = "gocd-agent";

     

       140
       -
             gid = config.ids.gids.gocd-agent;

     

       141
        
           };

     

       142
        
       

     

       143
       -
           users.users = optional (cfg.user == "gocd-agent") {

     

       144
       -
             name = "gocd-agent";

     

       145
       -
             description = "gocd-agent user";

     

       146
       -
             createHome = true;

     

       147
       -
             home = cfg.workDir;

     

       148
       -
             group = cfg.group;

     

       149
       -
             extraGroups = cfg.extraGroups;

     

       150
       -
             useDefaultShell = true;

     

       151
       -
             uid = config.ids.uids.gocd-agent;

     

       0
        
       
     

       152
        
           };

     

       153
        
       

     

       154
        
           systemd.services.gocd-agent = {

···

       135
        
         };

     

       136
        
       

     

       137
        
         config = mkIf cfg.enable {

     

       138
       +
           users.groups = optionalAttrs (cfg.group == "gocd-agent") {

     

       139
       +
             gocd-agent.gid = config.ids.gids.gocd-agent;

     

       0
        
       
     

       140
        
           };

     

       141
        
       

     

       142
       +
           users.users = optionalAttrs (cfg.user == "gocd-agent") {

     

       143
       +
             gocd-agent = {

     

       144
       +
               description = "gocd-agent user";

     

       145
       +
               createHome = true;

     

       146
       +
               home = cfg.workDir;

     

       147
       +
               group = cfg.group;

     

       148
       +
               extraGroups = cfg.extraGroups;

     

       149
       +
               useDefaultShell = true;

     

       150
       +
               uid = config.ids.uids.gocd-agent;

     

       151
       +
             };

     

       152
        
           };

     

       153
        
       

     

       154
        
           systemd.services.gocd-agent = {

+12 -12

nixos/modules/services/continuous-integration/gocd-server/default.nix

···

       143
        
         };

     

       144
        
       

     

       145
        
         config = mkIf cfg.enable {

     

       146
       -
           users.groups = optional (cfg.group == "gocd-server") {

     

       147
       -
             name = "gocd-server";

     

       148
       -
             gid = config.ids.gids.gocd-server;

     

       149
        
           };

     

       150
        
       

     

       151
       -
           users.users = optional (cfg.user == "gocd-server") {

     

       152
       -
             name = "gocd-server";

     

       153
       -
             description = "gocd-server user";

     

       154
       -
             createHome = true;

     

       155
       -
             home = cfg.workDir;

     

       156
       -
             group = cfg.group;

     

       157
       -
             extraGroups = cfg.extraGroups;

     

       158
       -
             useDefaultShell = true;

     

       159
       -
             uid = config.ids.uids.gocd-server;

     

       0
        
       
     

       160
        
           };

     

       161
        
       

     

       162
        
           systemd.services.gocd-server = {

···

       143
        
         };

     

       144
        
       

     

       145
        
         config = mkIf cfg.enable {

     

       146
       +
           users.groups = optionalAttrs (cfg.group == "gocd-server") {

     

       147
       +
             gocd-server.gid = config.ids.gids.gocd-server;

     

       0
        
       
     

       148
        
           };

     

       149
        
       

     

       150
       +
           users.users = optionalAttrs (cfg.user == "gocd-server") {

     

       151
       +
             gocd-server = {

     

       152
       +
               description = "gocd-server user";

     

       153
       +
               createHome = true;

     

       154
       +
               home = cfg.workDir;

     

       155
       +
               group = cfg.group;

     

       156
       +
               extraGroups = cfg.extraGroups;

     

       157
       +
               useDefaultShell = true;

     

       158
       +
               uid = config.ids.uids.gocd-server;

     

       159
       +
             };

     

       160
        
           };

     

       161
        
       

     

       162
        
           systemd.services.gocd-server = {

+12 -12

nixos/modules/services/continuous-integration/jenkins/default.nix

···

       150
        
             pkgs.dejavu_fonts

     

       151
        
           ];

     

       152
        
       

     

       153
       -
           users.groups = optional (cfg.group == "jenkins") {

     

       154
       -
             name = "jenkins";

     

       155
       -
             gid = config.ids.gids.jenkins;

     

       156
        
           };

     

       157
        
       

     

       158
       -
           users.users = optional (cfg.user == "jenkins") {

     

       159
       -
             name = "jenkins";

     

       160
       -
             description = "jenkins user";

     

       161
       -
             createHome = true;

     

       162
       -
             home = cfg.home;

     

       163
       -
             group = cfg.group;

     

       164
       -
             extraGroups = cfg.extraGroups;

     

       165
       -
             useDefaultShell = true;

     

       166
       -
             uid = config.ids.uids.jenkins;

     

       0
        
       
     

       167
        
           };

     

       168
        
       

     

       169
        
           systemd.services.jenkins = {

···

       150
        
             pkgs.dejavu_fonts

     

       151
        
           ];

     

       152
        
       

     

       153
       +
           users.groups = optionalAttrs (cfg.group == "jenkins") {

     

       154
       +
             jenkins.gid = config.ids.gids.jenkins;

     

       0
        
       
     

       155
        
           };

     

       156
        
       

     

       157
       +
           users.users = optionalAttrs (cfg.user == "jenkins") {

     

       158
       +
             jenkins = {

     

       159
       +
               description = "jenkins user";

     

       160
       +
               createHome = true;

     

       161
       +
               home = cfg.home;

     

       162
       +
               group = cfg.group;

     

       163
       +
               extraGroups = cfg.extraGroups;

     

       164
       +
               useDefaultShell = true;

     

       165
       +
               uid = config.ids.uids.jenkins;

     

       166
       +
             };

     

       167
        
           };

     

       168
        
       

     

       169
        
           systemd.services.jenkins = {

+10 -10

nixos/modules/services/continuous-integration/jenkins/slave.nix

···

       51
        
       

     

       52
        
         config = mkIf (cfg.enable && !masterCfg.enable) {

     

       53
        
           users.groups = optional (cfg.group == "jenkins") {

     

       54
       -
             name = "jenkins";

     

       55
       -
             gid = config.ids.gids.jenkins;

     

       56
        
           };

     

       57
        
       

     

       58
       -
           users.users = optional (cfg.user == "jenkins") {

     

       59
       -
             name = "jenkins";

     

       60
       -
             description = "jenkins user";

     

       61
       -
             createHome = true;

     

       62
       -
             home = cfg.home;

     

       63
       -
             group = cfg.group;

     

       64
       -
             useDefaultShell = true;

     

       65
       -
             uid = config.ids.uids.jenkins;

     

       0
        
       
     

       66
        
           };

     

       67
        
         };

     

       68
        
       }

···

       51
        
       

     

       52
        
         config = mkIf (cfg.enable && !masterCfg.enable) {

     

       53
        
           users.groups = optional (cfg.group == "jenkins") {

     

       54
       +
             jenkins.gid = config.ids.gids.jenkins;

     

       0
        
       
     

       55
        
           };

     

       56
        
       

     

       57
       +
           users.users = optionalAttrs (cfg.user == "jenkins") {

     

       58
       +
             jenkins = {

     

       59
       +
               description = "jenkins user";

     

       60
       +
               createHome = true;

     

       61
       +
               home = cfg.home;

     

       62
       +
               group = cfg.group;

     

       63
       +
               useDefaultShell = true;

     

       64
       +
               uid = config.ids.uids.jenkins;

     

       65
       +
             };

     

       66
        
           };

     

       67
        
         };

     

       68
        
       }

+7 -7

nixos/modules/services/databases/cockroachdb.nix

···

       171
        
       

     

       172
        
           environment.systemPackages = [ crdb ];

     

       173
        
       

     

       174
       -
           users.users = optionalAttrs (cfg.user == "cockroachdb") (singleton

     

       175
       -
             { name        = "cockroachdb";

     

       176
        
               description = "CockroachDB Server User";

     

       177
        
               uid         = config.ids.uids.cockroachdb;

     

       178
        
               group       = cfg.group;

     

       179
       -
             });

     

       0
        
       
     

       180
        
       

     

       181
       -
           users.groups = optionalAttrs (cfg.group == "cockroachdb") (singleton

     

       182
       -
             { name = "cockroachdb";

     

       183
       -
               gid  = config.ids.gids.cockroachdb;

     

       184
       -
             });

     

       185
        
       

     

       186
        
           networking.firewall.allowedTCPPorts = lib.optionals cfg.openPorts

     

       187
        
             [ cfg.http.port cfg.listen.port ];

···

       171
        
       

     

       172
        
           environment.systemPackages = [ crdb ];

     

       173
        
       

     

       174
       +
           users.users = optionalAttrs (cfg.user == "cockroachdb") {

     

       175
       +
             cockroachdb = {

     

       176
        
               description = "CockroachDB Server User";

     

       177
        
               uid         = config.ids.uids.cockroachdb;

     

       178
        
               group       = cfg.group;

     

       179
       +
             };

     

       180
       +
           };

     

       181
        
       

     

       182
       +
           users.groups = optionalAttrs (cfg.group == "cockroachdb") {

     

       183
       +
             cockroachdb.gid = config.ids.gids.cockroachdb;

     

       184
       +
           };

     

       0
        
       
     

       185
        
       

     

       186
        
           networking.firewall.allowedTCPPorts = lib.optionals cfg.openPorts

     

       187
        
             [ cfg.http.port cfg.listen.port ];

+7 -7

nixos/modules/services/databases/foundationdb.nix

···

       341
        
       

     

       342
        
           environment.systemPackages = [ pkg ];

     

       343
        
       

     

       344
       -
           users.users = optionalAttrs (cfg.user == "foundationdb") (singleton

     

       345
       -
             { name        = "foundationdb";

     

       346
        
               description = "FoundationDB User";

     

       347
        
               uid         = config.ids.uids.foundationdb;

     

       348
        
               group       = cfg.group;

     

       349
       -
             });

     

       0
        
       
     

       350
        
       

     

       351
       -
           users.groups = optionalAttrs (cfg.group == "foundationdb") (singleton

     

       352
       -
             { name = "foundationdb";

     

       353
       -
               gid  = config.ids.gids.foundationdb;

     

       354
       -
             });

     

       355
        
       

     

       356
        
           networking.firewall.allowedTCPPortRanges = mkIf cfg.openFirewall

     

       357
        
             [ { from = cfg.listenPortStart;

···

       341
        
       

     

       342
        
           environment.systemPackages = [ pkg ];

     

       343
        
       

     

       344
       +
           users.users = optionalAttrs (cfg.user == "foundationdb") {

     

       345
       +
             foundationdb = {

     

       346
        
               description = "FoundationDB User";

     

       347
        
               uid         = config.ids.uids.foundationdb;

     

       348
        
               group       = cfg.group;

     

       349
       +
             };

     

       350
       +
           };

     

       351
        
       

     

       352
       +
           users.groups = optionalAttrs (cfg.group == "foundationdb") {

     

       353
       +
             foundationdb.gid = config.ids.gids.foundationdb;

     

       354
       +
           };

     

       0
        
       
     

       355
        
       

     

       356
        
           networking.firewall.allowedTCPPortRanges = mkIf cfg.openFirewall

     

       357
        
             [ { from = cfg.listenPortStart;

+7 -7

nixos/modules/services/databases/influxdb.nix

···

       182
        
               '';

     

       183
        
           };

     

       184
        
       

     

       185
       -
           users.users = optional (cfg.user == "influxdb") {

     

       186
       -
             name = "influxdb";

     

       187
       -
             uid = config.ids.uids.influxdb;

     

       188
       -
             description = "Influxdb daemon user";

     

       0
        
       
     

       189
        
           };

     

       190
        
       

     

       191
       -
           users.groups = optional (cfg.group == "influxdb") {

     

       192
       -
             name = "influxdb";

     

       193
       -
             gid = config.ids.gids.influxdb;

     

       194
        
           };

     

       195
        
         };

     

       196

···

       182
        
               '';

     

       183
        
           };

     

       184
        
       

     

       185
       +
           users.users = optionalAttrs (cfg.user == "influxdb") {

     

       186
       +
             influxdb = {

     

       187
       +
               uid = config.ids.uids.influxdb;

     

       188
       +
               description = "Influxdb daemon user";

     

       189
       +
             };

     

       190
        
           };

     

       191
        
       

     

       192
       +
           users.groups = optionalAttrs (cfg.group == "influxdb") {

     

       193
       +
             influxdb.gid = config.ids.gids.influxdb;

     

       0
        
       
     

       194
        
           };

     

       195
        
         };

     

       196

+3 -4

nixos/modules/services/databases/memcached.nix

···

       64
        
       

     

       65
        
         config = mkIf config.services.memcached.enable {

     

       66
        
       

     

       67
       -
           users.users = optional (cfg.user == "memcached") {

     

       68
       -
             name = "memcached";

     

       69
       -
             description = "Memcached server user";

     

       70
       -
             isSystemUser = true;

     

       71
        
           };

     

       72
        
       

     

       73
        
           environment.systemPackages = [ memcached ];

···

       64
        
       

     

       65
        
         config = mkIf config.services.memcached.enable {

     

       66
        
       

     

       67
       +
           users.users = optionalAttrs (cfg.user == "memcached") {

     

       68
       +
             memcached.description = "Memcached server user";

     

       69
       +
             memcached.isSystemUser = true;

     

       0
        
       
     

       70
        
           };

     

       71
        
       

     

       72
        
           environment.systemPackages = [ memcached ];

+1 -2

nixos/modules/services/databases/neo4j.nix

···

       650
        
       

     

       651
        
             environment.systemPackages = [ cfg.package ];

     

       652
        
       

     

       653
       -
             users.users = singleton {

     

       654
       -
               name = "neo4j";

     

       655
        
               uid = config.ids.uids.neo4j;

     

       656
        
               description = "Neo4j daemon user";

     

       657
        
               home = cfg.directories.home;

···

       650
        
       

     

       651
        
             environment.systemPackages = [ cfg.package ];

     

       652
        
       

     

       653
       +
             users.users.neo4j = {

     

       0
        
       
     

       654
        
               uid = config.ids.uids.neo4j;

     

       655
        
               description = "Neo4j daemon user";

     

       656
        
               home = cfg.directories.home;

+2 -3

nixos/modules/services/databases/virtuoso.nix

···

       54
        
       

     

       55
        
         config = mkIf cfg.enable {

     

       56
        
       

     

       57
       -
           users.users = singleton

     

       58
       -
             { name = virtuosoUser;

     

       59
       -
               uid = config.ids.uids.virtuoso;

     

       60
        
               description = "virtuoso user";

     

       61
        
               home = stateDir;

     

       62
        
             };

···

       54
        
       

     

       55
        
         config = mkIf cfg.enable {

     

       56
        
       

     

       57
       +
           users.users.${virtuosoUser} =

     

       58
       +
             { uid = config.ids.uids.virtuoso;

     

       0
        
       
     

       59
        
               description = "virtuoso user";

     

       60
        
               home = stateDir;

     

       61
        
             };

+8 -7

nixos/modules/services/editors/infinoted.nix

···

       111
        
         };

     

       112
        
       

     

       113
        
         config = mkIf (cfg.enable) {

     

       114
       -
           users.users = optional (cfg.user == "infinoted")

     

       115
       -
             { name = "infinoted";

     

       116
       -
               description = "Infinoted user";

     

       117
       -
               group = cfg.group;

     

       118
       -
               isSystemUser = true;

     

       0
        
       
     

       119
        
             };

     

       120
       -
           users.groups = optional (cfg.group == "infinoted")

     

       121
       -
             { name = "infinoted";

     

       122
        
             };

     

       123
        
       

     

       124
        
           systemd.services.infinoted =

···

       111
        
         };

     

       112
        
       

     

       113
        
         config = mkIf (cfg.enable) {

     

       114
       +
           users.users = optionalAttrs (cfg.user == "infinoted")

     

       115
       +
             { infinoted = {

     

       116
       +
                 description = "Infinoted user";

     

       117
       +
                 group = cfg.group;

     

       118
       +
                 isSystemUser = true;

     

       119
       +
               };

     

       120
        
             };

     

       121
       +
           users.groups = optionalAttrs (cfg.group == "infinoted")

     

       122
       +
             { infinoted = { };

     

       123
        
             };

     

       124
        
       

     

       125
        
           systemd.services.infinoted =

+3 -3

nixos/modules/services/hardware/bluetooth.nix

···

       74
        
       

     

       75
        
           environment.systemPackages = [ bluez-bluetooth ];

     

       76
        
       

     

       77
       -
           environment.etc = singleton {

     

       78
       -
             source = pkgs.writeText "main.conf" (generators.toINI { } cfg.config + optionalString (cfg.extraConfig != null) cfg.extraConfig);

     

       79
       -
             target = "bluetooth/main.conf";

     

       80
        
           };

     

       81
        
       

     

       82
        
           services.udev.packages = [ bluez-bluetooth ];

···

       74
        
       

     

       75
        
           environment.systemPackages = [ bluez-bluetooth ];

     

       76
        
       

     

       77
       +
           environment.etc."bluetooth/main.conf"= {

     

       78
       +
             source = pkgs.writeText "main.conf"

     

       79
       +
               (generators.toINI { } cfg.config + optionalString (cfg.extraConfig != null) cfg.extraConfig);

     

       80
        
           };

     

       81
        
       

     

       82
        
           services.udev.packages = [ bluez-bluetooth ];

+4 -7

nixos/modules/services/hardware/sane_extra_backends/brscan4.nix

···

       67
        
       {

     

       68
        
         options = {

     

       69
        
       

     

       70
       -
           hardware.sane.brscan4.enable = 

     

       71
        
             mkEnableOption "Brother's brscan4 scan backend" // {

     

       72
        
             description = ''

     

       73
        
               When enabled, will automatically register the "brscan4" sane

     

       74
       -
               backend and bring configuration files to their expected location. 

     

       75
        
             '';

     

       76
        
           };

     

       77
        
       

     
···

       95
        
             pkgs.brscan4

     

       96
        
           ];

     

       97
        
       

     

       98
       -
           environment.etc = singleton {

     

       99
       -
             target = "opt/brother/scanner/brscan4";

     

       100
       -
             source = "${etcFiles}/etc/opt/brother/scanner/brscan4";

     

       101
       -
           };

     

       102
        
       

     

       103
        
           assertions = [

     

       104
        
             { assertion = all (x: !(null != x.ip && null != x.nodename)) netDeviceList;

     

       105
       -
                 

     

       106
        
               message = ''

     

       107
        
                 When describing a network device as part of the attribute list

     

       108
        
                 `hardware.sane.brscan4.netDevices`, only one of its `ip` or `nodename`

···

       67
        
       {

     

       68
        
         options = {

     

       69
        
       

     

       70
       +
           hardware.sane.brscan4.enable =

     

       71
        
             mkEnableOption "Brother's brscan4 scan backend" // {

     

       72
        
             description = ''

     

       73
        
               When enabled, will automatically register the "brscan4" sane

     

       74
       +
               backend and bring configuration files to their expected location.

     

       75
        
             '';

     

       76
        
           };

     

       77
        
       

     
···

       95
        
             pkgs.brscan4

     

       96
        
           ];

     

       97
        
       

     

       98
       +
           environment.etc."opt/brother/scanner/brscan4" =

     

       99
       +
             { source = "${etcFiles}/etc/opt/brother/scanner/brscan4"; };

     

       0
        
       
     

       0
        
       
     

       100
        
       

     

       101
        
           assertions = [

     

       102
        
             { assertion = all (x: !(null != x.ip && null != x.nodename)) netDeviceList;

     

       0
        
       
     

       103
        
               message = ''

     

       104
        
                 When describing a network device as part of the attribute list

     

       105
        
                 `hardware.sane.brscan4.netDevices`, only one of its `ip` or `nodename`

+7 -7

nixos/modules/services/hardware/tcsd.nix

···

       137
        
             serviceConfig.ExecStart = "${pkgs.trousers}/sbin/tcsd -f -c ${tcsdConf}";

     

       138
        
           };

     

       139
        
       

     

       140
       -
           users.users = optionalAttrs (cfg.user == "tss") (singleton

     

       141
       -
             { name = "tss";

     

       142
        
               group = "tss";

     

       143
        
               uid = config.ids.uids.tss;

     

       144
       -
             });

     

       0
        
       
     

       145
        
       

     

       146
       -
           users.groups = optionalAttrs (cfg.group == "tss") (singleton

     

       147
       -
             { name = "tss";

     

       148
       -
               gid = config.ids.gids.tss;

     

       149
       -
             });

     

       150
        
         };

     

       151
        
       }

···

       137
        
             serviceConfig.ExecStart = "${pkgs.trousers}/sbin/tcsd -f -c ${tcsdConf}";

     

       138
        
           };

     

       139
        
       

     

       140
       +
           users.users = optionalAttrs (cfg.user == "tss") {

     

       141
       +
             tss = {

     

       142
        
               group = "tss";

     

       143
        
               uid = config.ids.uids.tss;

     

       144
       +
             };

     

       145
       +
           };

     

       146
        
       

     

       147
       +
           users.groups = optionalAttrs (cfg.group == "tss") {

     

       148
       +
             tss.gid = config.ids.gids.tss;

     

       149
       +
           };

     

       0
        
       
     

       150
        
         };

     

       151
        
       }

+8 -7

nixos/modules/services/hardware/tlp.nix

···

       103
        
       

     

       104
        
           services.udev.packages = [ tlp ];

     

       105
        
       

     

       106
       -
           environment.etc = [{ source = confFile;

     

       107
       -
                                target = "default/tlp";

     

       108
       -
                              }

     

       109
       -
                             ] ++ optional enableRDW {

     

       110
       -
                               source = "${tlp}/etc/NetworkManager/dispatcher.d/99tlp-rdw-nm";

     

       111
       -
                               target = "NetworkManager/dispatcher.d/99tlp-rdw-nm";

     

       112
       -
                             };

     

       0
        
       
     

       113
        
       

     

       114
        
           environment.systemPackages = [ tlp ];

     

       115

···

       103
        
       

     

       104
        
           services.udev.packages = [ tlp ];

     

       105
        
       

     

       106
       +
           environment.etc =

     

       107
       +
             {

     

       108
       +
               "default/tlp".source = confFile;

     

       109
       +
             } // optionalAttrs enableRDW {

     

       110
       +
               "NetworkManager/dispatcher.d/99tlp-rdw-nm" = {

     

       111
       +
                 source = "${tlp}/etc/NetworkManager/dispatcher.d/99tlp-rdw-nm";

     

       112
       +
               };

     

       113
       +
             };

     

       114
        
       

     

       115
        
           environment.systemPackages = [ tlp ];

     

       116

+4 -7

nixos/modules/services/hardware/udev.nix

···

       281
        
           boot.kernelParams = mkIf (!config.networking.usePredictableInterfaceNames) [ "net.ifnames=0" ];

     

       282
        
       

     

       283
        
           environment.etc =

     

       284
       -
             [ { source = udevRules;

     

       285
       -
                 target = "udev/rules.d";

     

       286
       -
               }

     

       287
       -
               { source = hwdbBin;

     

       288
       -
                 target = "udev/hwdb.bin";

     

       289
       -
               }

     

       290
       -
             ];

     

       291
        
       

     

       292
        
           system.requiredKernelConfig = with config.lib.kernelConfig; [

     

       293
        
             (isEnabled "UNIX")

···

       281
        
           boot.kernelParams = mkIf (!config.networking.usePredictableInterfaceNames) [ "net.ifnames=0" ];

     

       282
        
       

     

       283
        
           environment.etc =

     

       284
       +
             {

     

       285
       +
               "udev/rules.d".source = udevRules;

     

       286
       +
               "udev/hwdb.bin".source = hwdbBin;

     

       287
       +
             };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       288
        
       

     

       289
        
           system.requiredKernelConfig = with config.lib.kernelConfig; [

     

       290
        
             (isEnabled "UNIX")

+7 -6

nixos/modules/services/hardware/usbmuxd.nix

···

       43
        
       

     

       44
        
         config = mkIf cfg.enable {

     

       45
        
       

     

       46
       -
           users.users = optional (cfg.user == defaultUserGroup) {

     

       47
       -
             name = cfg.user;

     

       48
       -
             description = "usbmuxd user";

     

       49
       -
             group = cfg.group;

     

       50
       -
             isSystemUser = true;

     

       0
        
       
     

       51
        
           };

     

       52
        
       

     

       53
        
           users.groups = optional (cfg.group == defaultUserGroup) {

     

       54
       -
             name = cfg.group;

     

       55
        
           };

     

       56
        
       

     

       57
        
           # Give usbmuxd permission for Apple devices

···

       43
        
       

     

       44
        
         config = mkIf cfg.enable {

     

       45
        
       

     

       46
       +
           users.users = optionalAttrs (cfg.user == defaultUserGroup) {

     

       47
       +
             ${cfg.user} = {

     

       48
       +
               description = "usbmuxd user";

     

       49
       +
               group = cfg.group;

     

       50
       +
               isSystemUser = true;

     

       51
       +
             };

     

       52
        
           };

     

       53
        
       

     

       54
        
           users.groups = optional (cfg.group == defaultUserGroup) {

     

       55
       +
             ${cfg.group} = { };

     

       56
        
           };

     

       57
        
       

     

       58
        
           # Give usbmuxd permission for Apple devices

+4 -3

nixos/modules/services/logging/logcheck.nix

···

       213
        
               mapAttrsToList writeIgnoreRule cfg.ignore

     

       214
        
               ++ mapAttrsToList writeIgnoreCronRule cfg.ignoreCron;

     

       215
        
       

     

       216
       -
           users.users = optionalAttrs (cfg.user == "logcheck") (singleton

     

       217
       -
             { name = "logcheck";

     

       218
        
               uid = config.ids.uids.logcheck;

     

       219
        
               shell = "/bin/sh";

     

       220
        
               description = "Logcheck user account";

     

       221
        
               extraGroups = cfg.extraGroups;

     

       222
       -
             });

     

       0
        
       
     

       223
        
       

     

       224
        
           system.activationScripts.logcheck = ''

     

       225
        
             mkdir -m 700 -p /var/{lib,lock}/logcheck

···

       213
        
               mapAttrsToList writeIgnoreRule cfg.ignore

     

       214
        
               ++ mapAttrsToList writeIgnoreCronRule cfg.ignoreCron;

     

       215
        
       

     

       216
       +
           users.users = optionalAttrs (cfg.user == "logcheck") {

     

       217
       +
             logcheck = {

     

       218
        
               uid = config.ids.uids.logcheck;

     

       219
        
               shell = "/bin/sh";

     

       220
        
               description = "Logcheck user account";

     

       221
        
               extraGroups = cfg.extraGroups;

     

       222
       +
             };

     

       223
       +
           };

     

       224
        
       

     

       225
        
           system.activationScripts.logcheck = ''

     

       226
        
             mkdir -m 700 -p /var/{lib,lock}/logcheck

+23 -27

nixos/modules/services/mail/dovecot.nix

···

       310
        
            ++ optional cfg.enablePop3 "pop3"

     

       311
        
            ++ optional cfg.enableLmtp "lmtp";

     

       312
        
       

     

       313
       -
           users.users = [

     

       314
       -
             { name = "dovenull";

     

       315
       -
               uid = config.ids.uids.dovenull2;

     

       316
       -
               description = "Dovecot user for untrusted logins";

     

       317
       -
               group = "dovenull";

     

       318
       -
             }

     

       319
       -
           ] ++ optional (cfg.user == "dovecot2")

     

       320
       -
                { name = "dovecot2";

     

       321
       -
                  uid = config.ids.uids.dovecot2;

     

       322
        
                  description = "Dovecot user";

     

       323
        
                  group = cfg.group;

     

       324
       -
                }

     

       325
       -
             ++ optional (cfg.createMailUser && cfg.mailUser != null)

     

       326
       -
                ({ name = cfg.mailUser;

     

       327
       -
                   description = "Virtual Mail User";

     

       328
       -
                } // optionalAttrs (cfg.mailGroup != null) {

     

       329
       -
                  group = cfg.mailGroup;

     

       330
       -
                });

     

       331
        
       

     

       332
       -
           users.groups = optional (cfg.group == "dovecot2")

     

       333
       -
             { name = "dovecot2";

     

       334
       -
               gid = config.ids.gids.dovecot2;

     

       335
       -
             }

     

       336
       -
           ++ optional (cfg.createMailUser && cfg.mailGroup != null)

     

       337
       -
             { name = cfg.mailGroup;

     

       338
       -
             }

     

       339
       -
           ++ singleton

     

       340
       -
             { name = "dovenull";

     

       341
       -
               gid = config.ids.gids.dovenull2;

     

       342
       -
             };

     

       343
        
       

     

       344
        
           environment.etc."dovecot/modules".source = modulesDir;

     

       345
        
           environment.etc."dovecot/dovecot.conf".source = cfg.configFile;

···

       310
        
            ++ optional cfg.enablePop3 "pop3"

     

       311
        
            ++ optional cfg.enableLmtp "lmtp";

     

       312
        
       

     

       313
       +
           users.users = {

     

       314
       +
             dovenull =

     

       315
       +
               { uid = config.ids.uids.dovenull2;

     

       316
       +
                 description = "Dovecot user for untrusted logins";

     

       317
       +
                 group = "dovenull";

     

       318
       +
               };

     

       319
       +
           } // optionalAttrs (cfg.user == "dovecot2") {

     

       320
       +
             dovecot2 =

     

       321
       +
                { uid = config.ids.uids.dovecot2;

     

       322
        
                  description = "Dovecot user";

     

       323
        
                  group = cfg.group;

     

       324
       +
                };

     

       325
       +
           } // optionalAttrs (cfg.createMailUser && cfg.mailUser != null) {

     

       326
       +
             ${cfg.mailUser} =

     

       327
       +
               { description = "Virtual Mail User"; } //

     

       328
       +
               optionalAttrs (cfg.mailGroup != null)

     

       329
       +
                 { group = cfg.mailGroup; };

     

       330
       +
           };

     

       331
        
       

     

       332
       +
           users.groups = {

     

       333
       +
             dovenull.gid = config.ids.gids.dovenull2;

     

       334
       +
           } // optionalAttrs (cfg.group == "dovecot2") {

     

       335
       +
             dovecot2.gid = config.ids.gids.dovecot2;

     

       336
       +
           } // optionalAttrs (cfg.createMailUser && cfg.mailGroup != null) {

     

       337
       +
             ${cfg.mailgroup} = { };

     

       338
       +
           };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       339
        
       

     

       340
        
           environment.etc."dovecot/modules".source = modulesDir;

     

       341
        
           environment.etc."dovecot/dovecot.conf".source = cfg.configFile;

+7 -7

nixos/modules/services/mail/dspam.nix

···

       86
        
       

     

       87
        
         config = mkIf cfg.enable (mkMerge [

     

       88
        
           {

     

       89
       -
             users.users = optionalAttrs (cfg.user == "dspam") (singleton

     

       90
       -
               { name = "dspam";

     

       91
        
                 group = cfg.group;

     

       92
        
                 uid = config.ids.uids.dspam;

     

       93
       -
               });

     

       0
        
       
     

       94
        
       

     

       95
       -
             users.groups = optionalAttrs (cfg.group == "dspam") (singleton

     

       96
       -
               { name = "dspam";

     

       97
       -
                 gid = config.ids.gids.dspam;

     

       98
       -
               });

     

       99
        
       

     

       100
        
             environment.systemPackages = [ dspam ];

     

       101

···

       86
        
       

     

       87
        
         config = mkIf cfg.enable (mkMerge [

     

       88
        
           {

     

       89
       +
             users.users = optionalAttrs (cfg.user == "dspam") {

     

       90
       +
               dspam = {

     

       91
        
                 group = cfg.group;

     

       92
        
                 uid = config.ids.uids.dspam;

     

       93
       +
               };

     

       94
       +
             };

     

       95
        
       

     

       96
       +
             users.groups = optionalAttrs (cfg.group == "dspam") {

     

       97
       +
               dspam.gid = config.ids.gids.dspam;

     

       98
       +
             };

     

       0
        
       
     

       99
        
       

     

       100
        
             environment.systemPackages = [ dspam ];

     

       101

+2 -4

nixos/modules/services/mail/exim.nix

···

       87
        
             systemPackages = [ cfg.package ];

     

       88
        
           };

     

       89
        
       

     

       90
       -
           users.users = singleton {

     

       91
       -
             name = cfg.user;

     

       92
        
             description = "Exim mail transfer agent user";

     

       93
        
             uid = config.ids.uids.exim;

     

       94
        
             group = cfg.group;

     

       95
        
           };

     

       96
        
       

     

       97
       -
           users.groups = singleton {

     

       98
       -
             name = cfg.group;

     

       99
        
             gid = config.ids.gids.exim;

     

       100
        
           };

     

       101

···

       87
        
             systemPackages = [ cfg.package ];

     

       88
        
           };

     

       89
        
       

     

       90
       +
           users.users.${cfg.user} = {

     

       0
        
       
     

       91
        
             description = "Exim mail transfer agent user";

     

       92
        
             uid = config.ids.uids.exim;

     

       93
        
             group = cfg.group;

     

       94
        
           };

     

       95
        
       

     

       96
       +
           users.groups.${cfg.group} = {

     

       0
        
       
     

       97
        
             gid = config.ids.gids.exim;

     

       98
        
           };

     

       99

+2 -4

nixos/modules/services/mail/mlmmj.nix

···

       94
        
       

     

       95
        
         config = mkIf cfg.enable {

     

       96
        
       

     

       97
       -
           users.users = singleton {

     

       98
       -
             name = cfg.user;

     

       99
        
             description = "mlmmj user";

     

       100
        
             home = stateDir;

     

       101
        
             createHome = true;

     
···

       104
        
             useDefaultShell = true;

     

       105
        
           };

     

       106
        
       

     

       107
       -
           users.groups = singleton {

     

       108
       -
             name = cfg.group;

     

       109
        
             gid = config.ids.gids.mlmmj;

     

       110
        
           };

     

       111

···

       94
        
       

     

       95
        
         config = mkIf cfg.enable {

     

       96
        
       

     

       97
       +
           users.users.${cfg.user} = {

     

       0
        
       
     

       98
        
             description = "mlmmj user";

     

       99
        
             home = stateDir;

     

       100
        
             createHome = true;

     
···

       103
        
             useDefaultShell = true;

     

       104
        
           };

     

       105
        
       

     

       106
       +
           users.groups.${cfg.group} = {

     

       0
        
       
     

       107
        
             gid = config.ids.gids.mlmmj;

     

       108
        
           };

     

       109

+2 -5

nixos/modules/services/mail/nullmailer.nix

···

       201
        
           };

     

       202
        
       

     

       203
        
           users = {

     

       204
       -
             users = singleton {

     

       205
       -
               name = cfg.user;

     

       206
        
               description = "Nullmailer relay-only mta user";

     

       207
        
               group = cfg.group;

     

       208
        
             };

     

       209
        
       

     

       210
       -
             groups = singleton {

     

       211
       -
               name = cfg.group;

     

       212
       -
             };

     

       213
        
           };

     

       214
        
       

     

       215
        
           systemd.tmpfiles.rules = [

···

       201
        
           };

     

       202
        
       

     

       203
        
           users = {

     

       204
       +
             users.${cfg.user} = {

     

       0
        
       
     

       205
        
               description = "Nullmailer relay-only mta user";

     

       206
        
               group = cfg.group;

     

       207
        
             };

     

       208
        
       

     

       209
       +
             groups.${cfg.group} = { };

     

       0
        
       
     

       0
        
       
     

       210
        
           };

     

       211
        
       

     

       212
        
           systemd.tmpfiles.rules = [

+7 -7

nixos/modules/services/mail/opendkim.nix

···

       91
        
       

     

       92
        
         config = mkIf cfg.enable {

     

       93
        
       

     

       94
       -
           users.users = optionalAttrs (cfg.user == "opendkim") (singleton

     

       95
       -
             { name = "opendkim";

     

       96
        
               group = cfg.group;

     

       97
        
               uid = config.ids.uids.opendkim;

     

       98
       -
             });

     

       0
        
       
     

       99
        
       

     

       100
       -
           users.groups = optionalAttrs (cfg.group == "opendkim") (singleton

     

       101
       -
             { name = "opendkim";

     

       102
       -
               gid = config.ids.gids.opendkim;

     

       103
       -
             });

     

       104
        
       

     

       105
        
           environment.systemPackages = [ pkgs.opendkim ];

     

       106

···

       91
        
       

     

       92
        
         config = mkIf cfg.enable {

     

       93
        
       

     

       94
       +
           users.users = optionalAttrs (cfg.user == "opendkim") {

     

       95
       +
             opendkim = {

     

       96
        
               group = cfg.group;

     

       97
        
               uid = config.ids.uids.opendkim;

     

       98
       +
             };

     

       99
       +
           };

     

       100
        
       

     

       101
       +
           users.groups = optionalAttrs (cfg.group == "opendkim") {

     

       102
       +
             opendkimgid = config.ids.gids.opendkim;

     

       103
       +
           };

     

       0
        
       
     

       104
        
       

     

       105
        
           environment.systemPackages = [ pkgs.opendkim ];

     

       106

+10 -11

nixos/modules/services/mail/postfix.nix

···

       655
        
               setgid = true;

     

       656
        
             };

     

       657
        
       

     

       658
       -
             users.users = optional (user == "postfix")

     

       659
       -
               { name = "postfix";

     

       660
       -
                 description = "Postfix mail server user";

     

       661
       -
                 uid = config.ids.uids.postfix;

     

       662
       -
                 group = group;

     

       0
        
       
     

       663
        
               };

     

       664
        
       

     

       665
        
             users.groups =

     

       666
       -
               optional (group == "postfix")

     

       667
       -
               { name = group;

     

       668
       -
                 gid = config.ids.gids.postfix;

     

       669
        
               }

     

       670
       -
               ++ optional (setgidGroup == "postdrop")

     

       671
       -
               { name = setgidGroup;

     

       672
       -
                 gid = config.ids.gids.postdrop;

     

       673
        
               };

     

       674
        
       

     

       675
        
             systemd.services.postfix =

···

       655
        
               setgid = true;

     

       656
        
             };

     

       657
        
       

     

       658
       +
             users.users = optionalAttrs (user == "postfix")

     

       659
       +
               { postfix = {

     

       660
       +
                   description = "Postfix mail server user";

     

       661
       +
                   uid = config.ids.uids.postfix;

     

       662
       +
                   group = group;

     

       663
       +
                 };

     

       664
        
               };

     

       665
        
       

     

       666
        
             users.groups =

     

       667
       +
               optionalAttrs (group == "postfix")

     

       668
       +
               { group.gid = config.ids.gids.postfix;

     

       0
        
       
     

       669
        
               }

     

       670
       +
               ++ optionalAttrs (setgidGroup == "postdrop")

     

       671
       +
               { ${setgidGroup}.gid = config.ids.gids.postdrop;

     

       0
        
       
     

       672
        
               };

     

       673
        
       

     

       674
        
             systemd.services.postfix =

+7 -7

nixos/modules/services/mail/postsrsd.nix

···

       90
        
       

     

       91
        
           services.postsrsd.domain = mkDefault config.networking.hostName;

     

       92
        
       

     

       93
       -
           users.users = optionalAttrs (cfg.user == "postsrsd") (singleton

     

       94
       -
             { name = "postsrsd";

     

       95
        
               group = cfg.group;

     

       96
        
               uid = config.ids.uids.postsrsd;

     

       97
       -
             });

     

       0
        
       
     

       98
        
       

     

       99
       -
           users.groups = optionalAttrs (cfg.group == "postsrsd") (singleton

     

       100
       -
             { name = "postsrsd";

     

       101
       -
               gid = config.ids.gids.postsrsd;

     

       102
       -
             });

     

       103
        
       

     

       104
        
           systemd.services.postsrsd = {

     

       105
        
             description = "PostSRSd SRS rewriting server";

···

       90
        
       

     

       91
        
           services.postsrsd.domain = mkDefault config.networking.hostName;

     

       92
        
       

     

       93
       +
           users.users = optionalAttrs (cfg.user == "postsrsd") {

     

       94
       +
             postsrsd = {

     

       95
        
               group = cfg.group;

     

       96
        
               uid = config.ids.uids.postsrsd;

     

       97
       +
             };

     

       98
       +
           };

     

       99
        
       

     

       100
       +
           users.groups = optionalAttrs (cfg.group == "postsrsd") {

     

       101
       +
             postsrsd.gid = config.ids.gids.postsrsd;

     

       102
       +
           };

     

       0
        
       
     

       103
        
       

     

       104
        
           systemd.services.postsrsd = {

     

       105
        
             description = "PostSRSd SRS rewriting server";

+2 -4

nixos/modules/services/mail/rspamd.nix

···

       374
        
           # Allow users to run 'rspamc' and 'rspamadm'.

     

       375
        
           environment.systemPackages = [ pkgs.rspamd ];

     

       376
        
       

     

       377
       -
           users.users = singleton {

     

       378
       -
             name = cfg.user;

     

       379
        
             description = "rspamd daemon";

     

       380
        
             uid = config.ids.uids.rspamd;

     

       381
        
             group = cfg.group;

     

       382
        
           };

     

       383
        
       

     

       384
       -
           users.groups = singleton {

     

       385
       -
             name = cfg.group;

     

       386
        
             gid = config.ids.gids.rspamd;

     

       387
        
           };

     

       388

···

       374
        
           # Allow users to run 'rspamc' and 'rspamadm'.

     

       375
        
           environment.systemPackages = [ pkgs.rspamd ];

     

       376
        
       

     

       377
       +
           users.users.${cfg.user} = {

     

       0
        
       
     

       378
        
             description = "rspamd daemon";

     

       379
        
             uid = config.ids.uids.rspamd;

     

       380
        
             group = cfg.group;

     

       381
        
           };

     

       382
        
       

     

       383
       +
           users.groups.${cfg.group} = {

     

       0
        
       
     

       384
        
             gid = config.ids.gids.rspamd;

     

       385
        
           };

     

       386

+2 -4

nixos/modules/services/mail/spamassassin.nix

···

       128
        
             systemPackages = [ pkgs.spamassassin ];

     

       129
        
           };

     

       130
        
       

     

       131
       -
           users.users = singleton {

     

       132
       -
             name = "spamd";

     

       133
        
             description = "Spam Assassin Daemon";

     

       134
        
             uid = config.ids.uids.spamd;

     

       135
        
             group = "spamd";

     

       136
        
           };

     

       137
        
       

     

       138
       -
           users.groups = singleton {

     

       139
       -
             name = "spamd";

     

       140
        
             gid = config.ids.gids.spamd;

     

       141
        
           };

     

       142

···

       128
        
             systemPackages = [ pkgs.spamassassin ];

     

       129
        
           };

     

       130
        
       

     

       131
       +
           users.users.spamd = {

     

       0
        
       
     

       132
        
             description = "Spam Assassin Daemon";

     

       133
        
             uid = config.ids.uids.spamd;

     

       134
        
             group = "spamd";

     

       135
        
           };

     

       136
        
       

     

       137
       +
           users.groups.spamd = {

     

       0
        
       
     

       138
        
             gid = config.ids.gids.spamd;

     

       139
        
           };

     

       140

+1 -2

nixos/modules/services/misc/apache-kafka.nix

···

       124
        
       

     

       125
        
           environment.systemPackages = [cfg.package];

     

       126
        
       

     

       127
       -
           users.users = singleton {

     

       128
       -
             name = "apache-kafka";

     

       129
        
             uid = config.ids.uids.apache-kafka;

     

       130
        
             description = "Apache Kafka daemon user";

     

       131
        
             home = head cfg.logDirs;

···

       124
        
       

     

       125
        
           environment.systemPackages = [cfg.package];

     

       126
        
       

     

       127
       +
           users.users.apache-kafka = {

     

       0
        
       
     

       128
        
             uid = config.ids.uids.apache-kafka;

     

       129
        
             description = "Apache Kafka daemon user";

     

       130
        
             home = head cfg.logDirs;

+6 -10

nixos/modules/services/misc/bepasty.nix

···

       168
        
               })

     

       169
        
           ) cfg.servers;

     

       170
        
       

     

       171
       -
           users.users = [{

     

       172
       -
             uid = config.ids.uids.bepasty;

     

       173
       -
             name = user;

     

       174
       -
             group = group;

     

       175
       -
             home = default_home;

     

       176
       -
           }];

     

       177
        
       

     

       178
       -
           users.groups = [{

     

       179
       -
             name = group;

     

       180
       -
             gid = config.ids.gids.bepasty;

     

       181
       -
           }];

     

       182
        
         };

     

       183
        
       }

···

       168
        
               })

     

       169
        
           ) cfg.servers;

     

       170
        
       

     

       171
       +
           users.users.${user} =

     

       172
       +
             { uid = config.ids.uids.bepasty;

     

       173
       +
               group = group;

     

       174
       +
               home = default_home;

     

       175
       +
             };

     

       0
        
       
     

       176
        
       

     

       177
       +
           users.groups.${group}.gid = config.ids.gids.bepasty;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       178
        
         };

     

       179
        
       }

+4 -3

nixos/modules/services/misc/cgminer.nix

···

       110
        
       

     

       111
        
         config = mkIf config.services.cgminer.enable {

     

       112
        
       

     

       113
       -
           users.users = optionalAttrs (cfg.user == "cgminer") (singleton

     

       114
       -
             { name = "cgminer";

     

       115
        
               uid = config.ids.uids.cgminer;

     

       116
        
               description = "Cgminer user";

     

       117
       -
             });

     

       0
        
       
     

       118
        
       

     

       119
        
           environment.systemPackages = [ cfg.package ];

     

       120

···

       110
        
       

     

       111
        
         config = mkIf config.services.cgminer.enable {

     

       112
        
       

     

       113
       +
           users.users = optionalAttrs (cfg.user == "cgminer") {

     

       114
       +
             cgminer = {

     

       115
        
               uid = config.ids.uids.cgminer;

     

       116
        
               description = "Cgminer user";

     

       117
       +
             };

     

       118
       +
           };

     

       119
        
       

     

       120
        
           environment.systemPackages = [ cfg.package ];

     

       121

+4 -7

nixos/modules/services/misc/couchpotato.nix

···

       29
        
             };

     

       30
        
           };

     

       31
        
       

     

       32
       -
           users.users = singleton

     

       33
       -
             { name = "couchpotato";

     

       34
       -
               group = "couchpotato";

     

       35
        
               home = "/var/lib/couchpotato/";

     

       36
        
               description = "CouchPotato daemon user";

     

       37
        
               uid = config.ids.uids.couchpotato;

     

       38
        
             };

     

       39
        
       

     

       40
       -
           users.groups = singleton

     

       41
       -
             { name = "couchpotato";

     

       42
       -
               gid = config.ids.gids.couchpotato;

     

       43
       -
             };

     

       44
        
         };

     

       45
        
       }

···

       29
        
             };

     

       30
        
           };

     

       31
        
       

     

       32
       +
           users.users.couchpotato =

     

       33
       +
             { group = "couchpotato";

     

       0
        
       
     

       34
        
               home = "/var/lib/couchpotato/";

     

       35
        
               description = "CouchPotato daemon user";

     

       36
        
               uid = config.ids.uids.couchpotato;

     

       37
        
             };

     

       38
        
       

     

       39
       +
           users.groups.couchpotato =

     

       40
       +
             { gid = config.ids.gids.couchpotato; };

     

       0
        
       
     

       0
        
       
     

       41
        
         };

     

       42
        
       }

+3 -7

nixos/modules/services/misc/dictd.nix

···

       45
        
           # get the command line client on system path to make some use of the service

     

       46
        
           environment.systemPackages = [ pkgs.dict ];

     

       47
        
       

     

       48
       -
           users.users = singleton

     

       49
       -
             { name = "dictd";

     

       50
       -
               group = "dictd";

     

       51
        
               description = "DICT.org dictd server";

     

       52
        
               home = "${dictdb}/share/dictd";

     

       53
        
               uid = config.ids.uids.dictd;

     

       54
        
             };

     

       55
        
       

     

       56
       -
           users.groups = singleton

     

       57
       -
             { name = "dictd";

     

       58
       -
               gid = config.ids.gids.dictd;

     

       59
       -
             };

     

       60
        
       

     

       61
        
           systemd.services.dictd = {

     

       62
        
             description = "DICT.org Dictionary Server";

···

       45
        
           # get the command line client on system path to make some use of the service

     

       46
        
           environment.systemPackages = [ pkgs.dict ];

     

       47
        
       

     

       48
       +
           users.users.dictd =

     

       49
       +
             { group = "dictd";

     

       0
        
       
     

       50
        
               description = "DICT.org dictd server";

     

       51
        
               home = "${dictdb}/share/dictd";

     

       52
        
               uid = config.ids.uids.dictd;

     

       53
        
             };

     

       54
        
       

     

       55
       +
           users.groups.dictd.gid = config.ids.gids.dictd;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       56
        
       

     

       57
        
           systemd.services.dictd = {

     

       58
        
             description = "DICT.org Dictionary Server";

+1 -2

nixos/modules/services/misc/etcd.nix

···

       186
        
       

     

       187
        
           environment.systemPackages = [ pkgs.etcdctl ];

     

       188
        
       

     

       189
       -
           users.users = singleton {

     

       190
       -
             name = "etcd";

     

       191
        
             uid = config.ids.uids.etcd;

     

       192
        
             description = "Etcd daemon user";

     

       193
        
             home = cfg.dataDir;

···

       186
        
       

     

       187
        
           environment.systemPackages = [ pkgs.etcdctl ];

     

       188
        
       

     

       189
       +
           users.users.etcd = {

     

       0
        
       
     

       190
        
             uid = config.ids.uids.etcd;

     

       191
        
             description = "Etcd daemon user";

     

       192
        
             home = cfg.dataDir;

+1 -2

nixos/modules/services/misc/exhibitor.nix

···

       410
        
               sed -i 's/'"$replace_what"'/'"$replace_with"'/g' ${cfg.baseDir}/zookeeper/bin/zk*.sh

     

       411
        
             '';

     

       412
        
           };

     

       413
       -
           users.users = singleton {

     

       414
       -
             name = "zookeeper";

     

       415
        
             uid = config.ids.uids.zookeeper;

     

       416
        
             description = "Zookeeper daemon user";

     

       417
        
             home = cfg.baseDir;

···

       410
        
               sed -i 's/'"$replace_what"'/'"$replace_with"'/g' ${cfg.baseDir}/zookeeper/bin/zk*.sh

     

       411
        
             '';

     

       412
        
           };

     

       413
       +
           users.users.zookeeper = {

     

       0
        
       
     

       414
        
             uid = config.ids.uids.zookeeper;

     

       415
        
             description = "Zookeeper daemon user";

     

       416
        
             home = cfg.baseDir;

+3 -7

nixos/modules/services/misc/felix.nix

···

       47
        
         ###### implementation

     

       48
        
       

     

       49
        
         config = mkIf cfg.enable {

     

       50
       -
           users.groups = singleton

     

       51
       -
             { name = "osgi";

     

       52
       -
               gid = config.ids.gids.osgi;

     

       53
       -
             };

     

       54
        
       

     

       55
       -
           users.users = singleton

     

       56
       -
             { name = "osgi";

     

       57
       -
               uid = config.ids.uids.osgi;

     

       58
        
               description = "OSGi user";

     

       59
        
               home = "/homeless-shelter";

     

       60
        
             };

···

       47
        
         ###### implementation

     

       48
        
       

     

       49
        
         config = mkIf cfg.enable {

     

       50
       +
           users.groups.osgi.gid = config.ids.gids.osgi;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       51
        
       

     

       52
       +
           users.users.osgi =

     

       53
       +
             { uid = config.ids.uids.osgi;

     

       0
        
       
     

       54
        
               description = "OSGi user";

     

       55
        
               home = "/homeless-shelter";

     

       56
        
             };

+2 -3

nixos/modules/services/misc/folding-at-home.nix

···

       42
        
       

     

       43
        
         config = mkIf cfg.enable {

     

       44
        
       

     

       45
       -
           users.users = singleton

     

       46
       -
             { name = fahUser;

     

       47
       -
               uid = config.ids.uids.foldingathome;

     

       48
        
               description = "Folding@Home user";

     

       49
        
               home = stateDir;

     

       50
        
             };

···

       42
        
       

     

       43
        
         config = mkIf cfg.enable {

     

       44
        
       

     

       45
       +
           users.users.${fahUser} =

     

       46
       +
             { uid = config.ids.uids.foldingathome;

     

       0
        
       
     

       47
        
               description = "Folding@Home user";

     

       48
        
               home = stateDir;

     

       49
        
             };

+4 -10

nixos/modules/services/misc/gitlab.nix

···

       633
        
           # Use postfix to send out mails.

     

       634
        
           services.postfix.enable = mkDefault true;

     

       635
        
       

     

       636
       -
           users.users = [

     

       637
       -
             { name = cfg.user;

     

       638
       -
               group = cfg.group;

     

       639
        
               home = "${cfg.statePath}/home";

     

       640
        
               shell = "${pkgs.bash}/bin/bash";

     

       641
        
               uid = config.ids.uids.gitlab;

     

       642
       -
             }

     

       643
       -
           ];

     

       644
        
       

     

       645
       -
           users.groups = [

     

       646
       -
             { name = cfg.group;

     

       647
       -
               gid = config.ids.gids.gitlab;

     

       648
       -
             }

     

       649
       -
           ];

     

       650
        
       

     

       651
        
           systemd.tmpfiles.rules = [

     

       652
        
             "d /run/gitlab 0755 ${cfg.user} ${cfg.group} -"

···

       633
        
           # Use postfix to send out mails.

     

       634
        
           services.postfix.enable = mkDefault true;

     

       635
        
       

     

       636
       +
           users.users.${cfg.user} =

     

       637
       +
             { group = cfg.group;

     

       0
        
       
     

       638
        
               home = "${cfg.statePath}/home";

     

       639
        
               shell = "${pkgs.bash}/bin/bash";

     

       640
        
               uid = config.ids.uids.gitlab;

     

       641
       +
             };

     

       0
        
       
     

       642
        
       

     

       643
       +
           users.groups.${cfg.group}.gid = config.ids.gids.gitlab;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       644
        
       

     

       645
        
           systemd.tmpfiles.rules = [

     

       646
        
             "d /run/gitlab 0755 ${cfg.user} ${cfg.group} -"

+3 -7

nixos/modules/services/misc/gpsd.nix

···

       86
        
       

     

       87
        
         config = mkIf cfg.enable {

     

       88
        
       

     

       89
       -
           users.users = singleton

     

       90
       -
             { name = "gpsd";

     

       91
       -
               inherit uid;

     

       92
        
               description = "gpsd daemon user";

     

       93
        
               home = "/var/empty";

     

       94
        
             };

     

       95
        
       

     

       96
       -
           users.groups = singleton

     

       97
       -
             { name = "gpsd";

     

       98
       -
               inherit gid;

     

       99
       -
             };

     

       100
        
       

     

       101
        
           systemd.services.gpsd = {

     

       102
        
             description = "GPSD daemon";

···

       86
        
       

     

       87
        
         config = mkIf cfg.enable {

     

       88
        
       

     

       89
       +
           users.users.gpsd =

     

       90
       +
             { inherit uid;

     

       0
        
       
     

       91
        
               description = "gpsd daemon user";

     

       92
        
               home = "/var/empty";

     

       93
        
             };

     

       94
        
       

     

       95
       +
           users.groups.gpsd = { inherit gid; };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       96
        
       

     

       97
        
           systemd.services.gpsd = {

     

       98
        
             description = "GPSD daemon";

+12 -12

nixos/modules/services/misc/headphones.nix

···

       59
        
       

     

       60
        
         config = mkIf cfg.enable {

     

       61
        
       

     

       62
       -
           users.users = optionalAttrs (cfg.user == name) (singleton {

     

       63
       -
             name = name;

     

       64
       -
             uid = config.ids.uids.headphones;

     

       65
       -
             group = cfg.group;

     

       66
       -
             description = "headphones user";

     

       67
       -
             home = cfg.dataDir;

     

       68
       -
             createHome = true;

     

       69
       -
           });

     

       0
        
       
     

       70
        
       

     

       71
       -
           users.groups = optionalAttrs (cfg.group == name) (singleton {

     

       72
       -
             name = name;

     

       73
       -
             gid = config.ids.gids.headphones;

     

       74
       -
           });

     

       75
        
       

     

       76
        
           systemd.services.headphones = {

     

       77
        
               description = "Headphones Server";

···

       59
        
       

     

       60
        
         config = mkIf cfg.enable {

     

       61
        
       

     

       62
       +
           users.users = optionalAttrs (cfg.user == name) {

     

       63
       +
             ${name} = {

     

       64
       +
               uid = config.ids.uids.headphones;

     

       65
       +
               group = cfg.group;

     

       66
       +
               description = "headphones user";

     

       67
       +
               home = cfg.dataDir;

     

       68
       +
               createHome = true;

     

       69
       +
             };

     

       70
       +
           };

     

       71
        
       

     

       72
       +
           users.groups = optionalAttrs (cfg.group == name) {

     

       73
       +
             ${name}.gid = config.ids.gids.headphones;

     

       74
       +
           };

     

       0
        
       
     

       75
        
       

     

       76
        
           systemd.services.headphones = {

     

       77
        
               description = "Headphones Server";

+6 -7

nixos/modules/services/misc/matrix-synapse.nix

···

       657
        
         };

     

       658
        
       

     

       659
        
         config = mkIf cfg.enable {

     

       660
       -
           users.users = [

     

       661
       -
             { name = "matrix-synapse";

     

       662
        
               group = "matrix-synapse";

     

       663
        
               home = cfg.dataDir;

     

       664
        
               createHome = true;

     

       665
        
               shell = "${pkgs.bash}/bin/bash";

     

       666
        
               uid = config.ids.uids.matrix-synapse;

     

       667
       -
             } ];

     

       668
        
       

     

       669
       -
           users.groups = [

     

       670
       -
             { name = "matrix-synapse";

     

       671
       -
               gid = config.ids.gids.matrix-synapse;

     

       672
       -
             } ];

     

       673
        
       

     

       674
        
           services.postgresql = mkIf (usePostgresql && cfg.create_local_database) {

     

       675
        
             enable = mkDefault true;

···

       657
        
         };

     

       658
        
       

     

       659
        
         config = mkIf cfg.enable {

     

       660
       +
           users.users.matrix-synapse =

     

       661
       +
             { name = "";

     

       662
        
               group = "matrix-synapse";

     

       663
        
               home = cfg.dataDir;

     

       664
        
               createHome = true;

     

       665
        
               shell = "${pkgs.bash}/bin/bash";

     

       666
        
               uid = config.ids.uids.matrix-synapse;

     

       667
       +
             };

     

       668
        
       

     

       669
       +
           users.groups.matrix-synapse = {

     

       670
       +
             gid = config.ids.gids.matrix-synapse;

     

       671
       +
           };

     

       0
        
       
     

       672
        
       

     

       673
        
           services.postgresql = mkIf (usePostgresql && cfg.create_local_database) {

     

       674
        
             enable = mkDefault true;

+12 -12

nixos/modules/services/misc/mediatomb.nix

···

       266
        
             serviceConfig.User = "${cfg.user}";

     

       267
        
           };

     

       268
        
       

     

       269
       -
           users.groups = optionalAttrs (cfg.group == "mediatomb") (singleton {

     

       270
       -
             name = "mediatomb";

     

       271
       -
             gid = gid;

     

       272
       -
           });

     

       273
        
       

     

       274
       -
           users.users = optionalAttrs (cfg.user == "mediatomb") (singleton {

     

       275
       -
             name = "mediatomb";

     

       276
       -
             isSystemUser = true;

     

       277
       -
             group = cfg.group;

     

       278
       -
             home = "${cfg.dataDir}";

     

       279
       -
             createHome = true;

     

       280
       -
             description = "Mediatomb DLNA Server User";

     

       281
       -
           });

     

       0
        
       
     

       282
        
       

     

       283
        
           networking.firewall = {

     

       284
        
             allowedUDPPorts = [ 1900 cfg.port ];

···

       266
        
             serviceConfig.User = "${cfg.user}";

     

       267
        
           };

     

       268
        
       

     

       269
       +
           users.groups = optionalAttrs (cfg.group == "mediatomb") {

     

       270
       +
             mediatomb.gid = gid;

     

       271
       +
           };

     

       0
        
       
     

       272
        
       

     

       273
       +
           users.users = optionalAttrs (cfg.user == "mediatomb") {

     

       274
       +
             mediatomb = {

     

       275
       +
               isSystemUser = true;

     

       276
       +
               group = cfg.group;

     

       277
       +
               home = "${cfg.dataDir}";

     

       278
       +
               createHome = true;

     

       279
       +
               description = "Mediatomb DLNA Server User";

     

       280
       +
             };

     

       281
       +
           };

     

       282
        
       

     

       283
        
           networking.firewall = {

     

       284
        
             allowedUDPPorts = [ 1900 cfg.port ];

+6 -4

nixos/modules/services/misc/nix-daemon.nix

···

       12
        
       

     

       13
        
         isNix23 = versionAtLeast nixVersion "2.3pre";

     

       14
        
       

     

       15
       -
         makeNixBuildUser = nr:

     

       16
       -
           { name = "nixbld${toString nr}";

     

       0
        
       
     

       17
        
             description = "Nix build user ${toString nr}";

     

       18
        
       

     

       19
        
             /* For consistency with the setgid(2), setuid(2), and setgroups(2)

     
···

       23
        
             group = "nixbld";

     

       24
        
             extraGroups = [ "nixbld" ];

     

       25
        
           };

     

       0
        
       
     

       26
        
       

     

       27
       -
         nixbldUsers = map makeNixBuildUser (range 1 cfg.nrBuildUsers);

     

       28
        
       

     

       29
        
         nixConf =

     

       30
        
           assert versionAtLeast nixVersion "2.2";

     
···

       445
        
       

     

       446
        
           users.users = nixbldUsers;

     

       447
        
       

     

       448
       -
           services.xserver.displayManager.hiddenUsers = map ({ name, ... }: name) nixbldUsers;

     

       449
        
       

     

       450
        
           system.activationScripts.nix = stringAfter [ "etc" "users" ]

     

       451
        
             ''

···

       12
        
       

     

       13
        
         isNix23 = versionAtLeast nixVersion "2.3pre";

     

       14
        
       

     

       15
       +
         makeNixBuildUser = nr: {

     

       16
       +
           name  = "nixbld${toString nr}";

     

       17
       +
           value = {

     

       18
        
             description = "Nix build user ${toString nr}";

     

       19
        
       

     

       20
        
             /* For consistency with the setgid(2), setuid(2), and setgroups(2)

     
···

       24
        
             group = "nixbld";

     

       25
        
             extraGroups = [ "nixbld" ];

     

       26
        
           };

     

       27
       +
         };

     

       28
        
       

     

       29
       +
         nixbldUsers = listToAttrs (map makeNixBuildUser (range 1 cfg.nrBuildUsers));

     

       30
        
       

     

       31
        
         nixConf =

     

       32
        
           assert versionAtLeast nixVersion "2.2";

     
···

       447
        
       

     

       448
        
           users.users = nixbldUsers;

     

       449
        
       

     

       450
       +
           services.xserver.displayManager.hiddenUsers = attrNames nixbldUsers;

     

       451
        
       

     

       452
        
           system.activationScripts.nix = stringAfter [ "etc" "users" ]

     

       453
        
             ''

+7 -7

nixos/modules/services/misc/octoprint.nix

···

       86
        
       

     

       87
        
         config = mkIf cfg.enable {

     

       88
        
       

     

       89
       -
           users.users = optionalAttrs (cfg.user == "octoprint") (singleton

     

       90
       -
             { name = "octoprint";

     

       91
        
               group = cfg.group;

     

       92
        
               uid = config.ids.uids.octoprint;

     

       93
       -
             });

     

       0
        
       
     

       94
        
       

     

       95
       -
           users.groups = optionalAttrs (cfg.group == "octoprint") (singleton

     

       96
       -
             { name = "octoprint";

     

       97
       -
               gid = config.ids.gids.octoprint;

     

       98
       -
             });

     

       99
        
       

     

       100
        
           systemd.tmpfiles.rules = [

     

       101
        
             "d '${cfg.stateDir}' - ${cfg.user} ${cfg.group} - -"

···

       86
        
       

     

       87
        
         config = mkIf cfg.enable {

     

       88
        
       

     

       89
       +
           users.users = optionalAttrs (cfg.user == "octoprint") {

     

       90
       +
             octoprint = {

     

       91
        
               group = cfg.group;

     

       92
        
               uid = config.ids.uids.octoprint;

     

       93
       +
             };

     

       94
       +
           };

     

       95
        
       

     

       96
       +
           users.groups = optionalAttrs (cfg.group == "octoprint") {

     

       97
       +
             octoprint.gid = config.ids.gids.octoprint;

     

       98
       +
           };

     

       0
        
       
     

       99
        
       

     

       100
        
           systemd.tmpfiles.rules = [

     

       101
        
             "d '${cfg.stateDir}' - ${cfg.user} ${cfg.group} - -"

+7 -7

nixos/modules/services/misc/redmine.nix

···

       367
        
       

     

       368
        
           };

     

       369
        
       

     

       370
       -
           users.users = optionalAttrs (cfg.user == "redmine") (singleton

     

       371
       -
             { name = "redmine";

     

       372
        
               group = cfg.group;

     

       373
        
               home = cfg.stateDir;

     

       374
        
               uid = config.ids.uids.redmine;

     

       375
       -
             });

     

       0
        
       
     

       376
        
       

     

       377
       -
           users.groups = optionalAttrs (cfg.group == "redmine") (singleton

     

       378
       -
             { name = "redmine";

     

       379
       -
               gid = config.ids.gids.redmine;

     

       380
       -
             });

     

       381
        
       

     

       382
        
           warnings = optional (cfg.database.password != "")

     

       383
        
             ''config.services.redmine.database.password will be stored as plaintext

···

       367
        
       

     

       368
        
           };

     

       369
        
       

     

       370
       +
           users.users = optionalAttrs (cfg.user == "redmine") {

     

       371
       +
             redmine = {

     

       372
        
               group = cfg.group;

     

       373
        
               home = cfg.stateDir;

     

       374
        
               uid = config.ids.uids.redmine;

     

       375
       +
             };

     

       376
       +
           };

     

       377
        
       

     

       378
       +
           users.groups = optionalAttrs (cfg.group == "redmine") {

     

       379
       +
             redmine.gid = config.ids.gids.redmine;

     

       380
       +
           };

     

       0
        
       
     

       381
        
       

     

       382
        
           warnings = optional (cfg.database.password != "")

     

       383
        
             ''config.services.redmine.database.password will be stored as plaintext

+2 -3

nixos/modules/services/misc/ripple-data-api.nix

···

       185
        
             ];

     

       186
        
           };

     

       187
        
       

     

       188
       -
           users.users = singleton

     

       189
       -
             { name = "ripple-data-api";

     

       190
       -
               description = "Ripple data api user";

     

       191
        
               uid = config.ids.uids.ripple-data-api;

     

       192
        
             };

     

       193
        
         };

···

       185
        
             ];

     

       186
        
           };

     

       187
        
       

     

       188
       +
           users.users.ripple-data-api =

     

       189
       +
             { description = "Ripple data api user";

     

       0
        
       
     

       190
        
               uid = config.ids.uids.ripple-data-api;

     

       191
        
             };

     

       192
        
         };

+2 -3

nixos/modules/services/misc/rippled.nix

···

       406
        
       

     

       407
        
         config = mkIf cfg.enable {

     

       408
        
       

     

       409
       -
           users.users = singleton

     

       410
       -
             { name = "rippled";

     

       411
       -
               description = "Ripple server user";

     

       412
        
               uid = config.ids.uids.rippled;

     

       413
        
               home = cfg.databasePath;

     

       414
        
               createHome = true;

···

       406
        
       

     

       407
        
         config = mkIf cfg.enable {

     

       408
        
       

     

       409
       +
           users.users.rippled =

     

       410
       +
             { description = "Ripple server user";

     

       0
        
       
     

       411
        
               uid = config.ids.uids.rippled;

     

       412
        
               home = cfg.databasePath;

     

       413
        
               createHome = true;

+4 -9

nixos/modules/services/misc/serviio.nix

···

       63
        
             };

     

       64
        
           };

     

       65
        
       

     

       66
       -
           users.users = [

     

       67
       -
             {

     

       68
       -
               name = "serviio";

     

       69
       -
               group = "serviio";

     

       70
        
               home = cfg.dataDir;

     

       71
        
               description = "Serviio Media Server User";

     

       72
        
               createHome = true;

     

       73
        
               isSystemUser = true;

     

       74
       -
             }

     

       75
       -
           ];

     

       76
        
       

     

       77
       -
           users.groups = [

     

       78
       -
             { name = "serviio";}

     

       79
       -
           ];

     

       80
        
       

     

       81
        
           networking.firewall = {

     

       82
        
             allowedTCPPorts = [

···

       63
        
             };

     

       64
        
           };

     

       65
        
       

     

       66
       +
           users.users.serviio =

     

       67
       +
             { group = "serviio";

     

       0
        
       
     

       0
        
       
     

       68
        
               home = cfg.dataDir;

     

       69
        
               description = "Serviio Media Server User";

     

       70
        
               createHome = true;

     

       71
        
               isSystemUser = true;

     

       72
       +
             };

     

       0
        
       
     

       73
        
       

     

       74
       +
           users.groups.serviio = { };

     

       0
        
       
     

       0
        
       
     

       75
        
       

     

       76
        
           networking.firewall = {

     

       77
        
             allowedTCPPorts = [

+12 -12

nixos/modules/services/misc/sickbeard.nix

···

       63
        
       

     

       64
        
         config = mkIf cfg.enable {

     

       65
        
       

     

       66
       -
           users.users = optionalAttrs (cfg.user == name) (singleton {

     

       67
       -
             name = name;

     

       68
       -
             uid = config.ids.uids.sickbeard;

     

       69
       -
             group = cfg.group;

     

       70
       -
             description = "sickbeard user";

     

       71
       -
             home = cfg.dataDir;

     

       72
       -
             createHome = true;

     

       73
       -
           });

     

       0
        
       
     

       74
        
       

     

       75
       -
           users.groups = optionalAttrs (cfg.group == name) (singleton {

     

       76
       -
             name = name;

     

       77
       -
             gid = config.ids.gids.sickbeard;

     

       78
       -
           });

     

       79
        
       

     

       80
        
           systemd.services.sickbeard = {

     

       81
        
             description = "Sickbeard Server";

···

       63
        
       

     

       64
        
         config = mkIf cfg.enable {

     

       65
        
       

     

       66
       +
           users.users = optionalAttrs (cfg.user == name) {

     

       67
       +
             ${name} = {

     

       68
       +
               uid = config.ids.uids.sickbeard;

     

       69
       +
               group = cfg.group;

     

       70
       +
               description = "sickbeard user";

     

       71
       +
               home = cfg.dataDir;

     

       72
       +
               createHome = true;

     

       73
       +
             };

     

       74
       +
           };

     

       75
        
       

     

       76
       +
           users.groups = optionalAttrs (cfg.group == name) {

     

       77
       +
             ${name}.gid = config.ids.gids.sickbeard;

     

       78
       +
           };

     

       0
        
       
     

       79
        
       

     

       80
        
           systemd.services.sickbeard = {

     

       81
        
             description = "Sickbeard Server";

+1 -2

nixos/modules/services/misc/siproxd.nix

···

       161
        
       

     

       162
        
         config = mkIf cfg.enable {

     

       163
        
       

     

       164
       -
           users.users = singleton {

     

       165
       -
             name = "siproxyd";

     

       166
        
             uid = config.ids.uids.siproxd;

     

       167
        
           };

     

       168

···

       161
        
       

     

       162
        
         config = mkIf cfg.enable {

     

       163
        
       

     

       164
       +
           users.users.siproxyd = {

     

       0
        
       
     

       165
        
             uid = config.ids.uids.siproxd;

     

       166
        
           };

     

       167

+8 -8

nixos/modules/services/misc/taskserver/default.nix

···

       368
        
           (mkIf cfg.enable {

     

       369
        
             environment.systemPackages = [ nixos-taskserver ];

     

       370
        
       

     

       371
       -
             users.users = optional (cfg.user == "taskd") {

     

       372
       -
               name = "taskd";

     

       373
       -
               uid = config.ids.uids.taskd;

     

       374
       -
               description = "Taskserver user";

     

       375
       -
               group = cfg.group;

     

       0
        
       
     

       376
        
             };

     

       377
        
       

     

       378
       -
             users.groups = optional (cfg.group == "taskd") {

     

       379
       -
               name = "taskd";

     

       380
       -
               gid = config.ids.gids.taskd;

     

       381
        
             };

     

       382
        
       

     

       383
        
             services.taskserver.config = {

···

       368
        
           (mkIf cfg.enable {

     

       369
        
             environment.systemPackages = [ nixos-taskserver ];

     

       370
        
       

     

       371
       +
             users.users = optionalAttrs (cfg.user == "taskd") {

     

       372
       +
               taskd = {

     

       373
       +
                 uid = config.ids.uids.taskd;

     

       374
       +
                 description = "Taskserver user";

     

       375
       +
                 group = cfg.group;

     

       376
       +
               };

     

       377
        
             };

     

       378
        
       

     

       379
       +
             users.groups = optionalAttrs (cfg.group == "taskd") {

     

       380
       +
               taskd.gid = config.ids.gids.taskd;

     

       0
        
       
     

       381
        
             };

     

       382
        
       

     

       383
        
             services.taskserver.config = {

+9 -15

nixos/modules/services/misc/uhub.nix

···

       41
        
             enable = mkOption {

     

       42
        
               type = types.bool;

     

       43
        
               default = false;

     

       44
       -
       	description = "Whether to enable the uhub ADC hub.";

     

       45
        
             };

     

       46
        
       

     

       47
        
             port = mkOption {

     

       48
        
               type = types.int;

     

       49
        
               default = 1511;

     

       50
       -
       	description = "TCP port to bind the hub to.";

     

       51
        
             };

     

       52
        
       

     

       53
        
             address = mkOption {

     

       54
        
               type = types.str;

     

       55
        
               default = "any";

     

       56
       -
       	description = "Address to bind the hub to.";

     

       57
        
             };

     

       58
        
       

     

       59
        
             enableTLS = mkOption {

     

       60
        
               type = types.bool;

     

       61
        
               default = false;

     

       62
       -
       	description = "Whether to enable TLS support.";

     

       63
        
             };

     

       64
        
       

     

       65
        
             hubConfig = mkOption {

     

       66
        
               type = types.lines;

     

       67
        
               default = "";

     

       68
       -
       	description = "Contents of uhub configuration file.";

     

       69
        
             };

     

       70
        
       

     

       71
        
             aclConfig = mkOption {

     
···

       77
        
             plugins = {

     

       78
        
       

     

       79
        
               authSqlite = {

     

       80
       -
       	  enable = mkOption {

     

       81
        
                   type = types.bool;

     

       82
        
                   default = false;

     

       83
        
                   description = "Whether to enable the Sqlite authentication database plugin";

     

       84
       -
       	  };

     

       85
        
                 file = mkOption {

     

       86
        
                   type = types.path;

     

       87
        
                   example = "/var/db/uhub-users";

     
···

       161
        
         config = mkIf cfg.enable {

     

       162
        
       

     

       163
        
           users = {

     

       164
       -
             users = singleton {

     

       165
       -
               name = "uhub";

     

       166
       -
               uid = config.ids.uids.uhub;

     

       167
       -
             };

     

       168
       -
             groups = singleton {

     

       169
       -
               name = "uhub";

     

       170
       -
               gid = config.ids.gids.uhub;

     

       171
       -
             };

     

       172
        
           };

     

       173
        
       

     

       174
        
           systemd.services.uhub = {

···

       41
        
             enable = mkOption {

     

       42
        
               type = types.bool;

     

       43
        
               default = false;

     

       44
       +
               description = "Whether to enable the uhub ADC hub.";

     

       45
        
             };

     

       46
        
       

     

       47
        
             port = mkOption {

     

       48
        
               type = types.int;

     

       49
        
               default = 1511;

     

       50
       +
               description = "TCP port to bind the hub to.";

     

       51
        
             };

     

       52
        
       

     

       53
        
             address = mkOption {

     

       54
        
               type = types.str;

     

       55
        
               default = "any";

     

       56
       +
               description = "Address to bind the hub to.";

     

       57
        
             };

     

       58
        
       

     

       59
        
             enableTLS = mkOption {

     

       60
        
               type = types.bool;

     

       61
        
               default = false;

     

       62
       +
               description = "Whether to enable TLS support.";

     

       63
        
             };

     

       64
        
       

     

       65
        
             hubConfig = mkOption {

     

       66
        
               type = types.lines;

     

       67
        
               default = "";

     

       68
       +
               description = "Contents of uhub configuration file.";

     

       69
        
             };

     

       70
        
       

     

       71
        
             aclConfig = mkOption {

     
···

       77
        
             plugins = {

     

       78
        
       

     

       79
        
               authSqlite = {

     

       80
       +
                 enable = mkOption {

     

       81
        
                   type = types.bool;

     

       82
        
                   default = false;

     

       83
        
                   description = "Whether to enable the Sqlite authentication database plugin";

     

       84
       +
                 };

     

       85
        
                 file = mkOption {

     

       86
        
                   type = types.path;

     

       87
        
                   example = "/var/db/uhub-users";

     
···

       161
        
         config = mkIf cfg.enable {

     

       162
        
       

     

       163
        
           users = {

     

       164
       +
             users.uhub.uid = config.ids.uids.uhub;

     

       165
       +
             groups.uhub.gid = config.ids.gids.uhub;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       166
        
           };

     

       167
        
       

     

       168
        
           systemd.services.uhub = {

+1 -2

nixos/modules/services/misc/zookeeper.nix

···

       146
        
             '';

     

       147
        
           };

     

       148
        
       

     

       149
       -
           users.users = singleton {

     

       150
       -
             name = "zookeeper";

     

       151
        
             uid = config.ids.uids.zookeeper;

     

       152
        
             description = "Zookeeper daemon user";

     

       153
        
             home = cfg.dataDir;

···

       146
        
             '';

     

       147
        
           };

     

       148
        
       

     

       149
       +
           users.users.zookeeper = {

     

       0
        
       
     

       150
        
             uid = config.ids.uids.zookeeper;

     

       151
        
             description = "Zookeeper daemon user";

     

       152
        
             home = cfg.dataDir;

+4 -3

nixos/modules/services/monitoring/collectd.nix

···

       129
        
             };

     

       130
        
           };

     

       131
        
       

     

       132
       -
           users.users = optional (cfg.user == "collectd") {

     

       133
       -
             name = "collectd";

     

       134
       -
             isSystemUser = true;

     

       0
        
       
     

       135
        
           };

     

       136
        
         };

     

       137
        
       }

···

       129
        
             };

     

       130
        
           };

     

       131
        
       

     

       132
       +
           users.users = optionalAttrs (cfg.user == "collectd") {

     

       133
       +
             collectd = {

     

       134
       +
               isSystemUser = true;

     

       135
       +
             };

     

       136
        
           };

     

       137
        
         };

     

       138
        
       }

+11 -10

nixos/modules/services/monitoring/datadog-agent.nix

···

       22
        
         # Generate Datadog configuration files for each configured checks.

     

       23
        
         # This works because check configurations have predictable paths,

     

       24
        
         # and because JSON is a valid subset of YAML.

     

       25
       -
         makeCheckConfigs = entries: mapAttrsToList (name: conf: {

     

       26
       -
           source = pkgs.writeText "${name}-check-conf.yaml" (builtins.toJSON conf);

     

       27
       -
           target = "datadog-agent/conf.d/${name}.d/conf.yaml";

     

       28
        
         }) entries;

     

       29
        
       

     

       30
        
         defaultChecks = {

     
···

       34
        
       

     

       35
        
         # Assemble all check configurations and the top-level agent

     

       36
        
         # configuration.

     

       37
       -
         etcfiles = with pkgs; with builtins; [{

     

       38
       -
           source = writeText "datadog.yaml" (toJSON ddConf);

     

       39
       -
           target = "datadog-agent/datadog.yaml";

     

       40
       -
         }] ++ makeCheckConfigs (cfg.checks // defaultChecks);

     

       0
        
       
     

       41
        
       

     

       42
        
         # Apply the configured extraIntegrations to the provided agent

     

       43
        
         # package. See the documentation of `dd-agent/integrations-core.nix`

     
···

       204
        
         config = mkIf cfg.enable {

     

       205
        
           environment.systemPackages = [ datadogPkg pkgs.sysstat pkgs.procps pkgs.iproute ];

     

       206
        
       

     

       207
       -
           users.extraUsers.datadog = {

     

       208
        
             description = "Datadog Agent User";

     

       209
        
             uid = config.ids.uids.datadog;

     

       210
        
             group = "datadog";

     
···

       212
        
             createHome = true;

     

       213
        
           };

     

       214
        
       

     

       215
       -
           users.extraGroups.datadog.gid = config.ids.gids.datadog;

     

       216
        
       

     

       217
        
           systemd.services = let

     

       218
        
             makeService = attrs: recursiveUpdate {

     
···

       224
        
                 Restart = "always";

     

       225
        
                 RestartSec = 2;

     

       226
        
               };

     

       227
       -
               restartTriggers = [ datadogPkg ] ++ map (etc: etc.source) etcfiles;

     

       228
        
             } attrs;

     

       229
        
           in {

     

       230
        
             datadog-agent = makeService {

···

       22
        
         # Generate Datadog configuration files for each configured checks.

     

       23
        
         # This works because check configurations have predictable paths,

     

       24
        
         # and because JSON is a valid subset of YAML.

     

       25
       +
         makeCheckConfigs = entries: mapAttrs' (name: conf: {

     

       26
       +
           name = "datadog-agent/conf.d/${name}.d/conf.yaml";

     

       27
       +
           value.source = pkgs.writeText "${name}-check-conf.yaml" (builtins.toJSON conf);

     

       28
        
         }) entries;

     

       29
        
       

     

       30
        
         defaultChecks = {

     
···

       34
        
       

     

       35
        
         # Assemble all check configurations and the top-level agent

     

       36
        
         # configuration.

     

       37
       +
         etcfiles = with pkgs; with builtins;

     

       38
       +
         { "datadog-agent/datadog.yaml" = {

     

       39
       +
             source = writeText "datadog.yaml" (toJSON ddConf);

     

       40
       +
           };

     

       41
       +
         } // makeCheckConfigs (cfg.checks // defaultChecks);

     

       42
        
       

     

       43
        
         # Apply the configured extraIntegrations to the provided agent

     

       44
        
         # package. See the documentation of `dd-agent/integrations-core.nix`

     
···

       205
        
         config = mkIf cfg.enable {

     

       206
        
           environment.systemPackages = [ datadogPkg pkgs.sysstat pkgs.procps pkgs.iproute ];

     

       207
        
       

     

       208
       +
           users.users.datadog = {

     

       209
        
             description = "Datadog Agent User";

     

       210
        
             uid = config.ids.uids.datadog;

     

       211
        
             group = "datadog";

     
···

       213
        
             createHome = true;

     

       214
        
           };

     

       215
        
       

     

       216
       +
           users.groups.datadog.gid = config.ids.gids.datadog;

     

       217
        
       

     

       218
        
           systemd.services = let

     

       219
        
             makeService = attrs: recursiveUpdate {

     
···

       225
        
                 Restart = "always";

     

       226
        
                 RestartSec = 2;

     

       227
        
               };

     

       228
       +
               restartTriggers = [ datadogPkg ] ++ attrNames etcfiles;

     

       229
        
             } attrs;

     

       230
        
           in {

     

       231
        
             datadog-agent = makeService {

+29 -31

nixos/modules/services/monitoring/dd-agent/dd-agent.nix

···

       78
        
         etcfiles =

     

       79
        
           let

     

       80
        
             defaultConfd = import ./dd-agent-defaults.nix;

     

       81
       -
           in (map (f: { source = "${pkgs.dd-agent}/agent/conf.d-system/${f}";

     

       82
       -
                         target = "dd-agent/conf.d/${f}";

     

       83
       -
                       }) defaultConfd) ++ [

     

       84
       -
             { source = ddConf;

     

       85
       -
               target = "dd-agent/datadog.conf";

     

       86
       -
             }

     

       87
       -
             { source = diskConfig;

     

       88
       -
               target = "dd-agent/conf.d/disk.yaml";

     

       89
       -
             }

     

       90
       -
             { source = networkConfig;

     

       91
       -
               target = "dd-agent/conf.d/network.yaml";

     

       92
       -
             } ] ++

     

       93
       -
           (optional (cfg.postgresqlConfig != null)

     

       94
       -
             { source = postgresqlConfig;

     

       95
       -
               target = "dd-agent/conf.d/postgres.yaml";

     

       96
       -
             }) ++

     

       97
       -
           (optional (cfg.nginxConfig != null)

     

       98
       -
             { source = nginxConfig;

     

       99
       -
               target = "dd-agent/conf.d/nginx.yaml";

     

       100
       -
             }) ++

     

       101
       -
           (optional (cfg.mongoConfig != null)

     

       102
       -
             { source = mongoConfig;

     

       103
       -
               target = "dd-agent/conf.d/mongo.yaml";

     

       104
       -
             }) ++

     

       105
       -
           (optional (cfg.processConfig != null)

     

       106
       -
             { source = processConfig;

     

       107
       -
               target = "dd-agent/conf.d/process.yaml";

     

       108
       -
             }) ++

     

       109
       -
           (optional (cfg.jmxConfig != null)

     

       110
       -
             { source = jmxConfig;

     

       111
       -
               target = "dd-agent/conf.d/jmx.yaml";

     

       112
        
             });

     

       113
        
       

     

       114
        
       in {

···

       78
        
         etcfiles =

     

       79
        
           let

     

       80
        
             defaultConfd = import ./dd-agent-defaults.nix;

     

       81
       +
           in

     

       82
       +
             listToAttrs (map (f: {

     

       83
       +
               name = "dd-agent/conf.d/${f}";

     

       84
       +
               value.source = "${pkgs.dd-agent}/agent/conf.d-system/${f}";

     

       85
       +
             }) defaultConfd) //

     

       86
       +
             {

     

       87
       +
               "dd-agent/datadog.conf".source = ddConf;

     

       88
       +
               "dd-agent/conf.d/disk.yaml".source = diskConfig;

     

       89
       +
               "dd-agent/conf.d/network.yaml".source = networkConfig;

     

       90
       +
             } //

     

       91
       +
             (optionalAttrs (cfg.postgresqlConfig != null)

     

       92
       +
             {

     

       93
       +
               "dd-agent/conf.d/postgres.yaml".source = postgresqlConfig;

     

       94
       +
             }) //

     

       95
       +
             (optionalAttrs (cfg.nginxConfig != null)

     

       96
       +
             {

     

       97
       +
               "dd-agent/conf.d/nginx.yaml".source = nginxConfig;

     

       98
       +
             }) //

     

       99
       +
             (optionalAttrs (cfg.mongoConfig != null)

     

       100
       +
             { 

     

       101
       +
               "dd-agent/conf.d/mongo.yaml".source = mongoConfig;

     

       102
       +
             }) //

     

       103
       +
             (optionalAttrs (cfg.processConfig != null)

     

       104
       +
             { 

     

       105
       +
               "dd-agent/conf.d/process.yaml".source = processConfig;

     

       106
       +
             }) //

     

       107
       +
             (optionalAttrs (cfg.jmxConfig != null)

     

       108
       +
             {

     

       109
       +
               "dd-agent/conf.d/jmx.yaml".source = jmxConfig;

     

       0
        
       
     

       0
        
       
     

       110
        
             });

     

       111
        
       

     

       112
        
       in {

+1 -2

nixos/modules/services/monitoring/fusion-inventory.nix

···

       46
        
       

     

       47
        
         config = mkIf cfg.enable {

     

       48
        
       

     

       49
       -
           users.users = singleton {

     

       50
       -
             name = "fusion-inventory";

     

       51
        
             description = "FusionInventory user";

     

       52
        
             isSystemUser = true;

     

       53
        
           };

···

       46
        
       

     

       47
        
         config = mkIf cfg.enable {

     

       48
        
       

     

       49
       +
           users.users.fusion-inventory = {

     

       0
        
       
     

       50
        
             description = "FusionInventory user";

     

       51
        
             isSystemUser = true;

     

       52
        
           };

+1 -2

nixos/modules/services/monitoring/graphite.nix

···

       632
        
             cfg.web.enable || cfg.api.enable ||

     

       633
        
             cfg.seyren.enable || cfg.pager.enable || cfg.beacon.enable

     

       634
        
            ) {

     

       635
       -
             users.users = singleton {

     

       636
       -
               name = "graphite";

     

       637
        
               uid = config.ids.uids.graphite;

     

       638
        
               description = "Graphite daemon user";

     

       639
        
               home = dataDir;

···

       632
        
             cfg.web.enable || cfg.api.enable ||

     

       633
        
             cfg.seyren.enable || cfg.pager.enable || cfg.beacon.enable

     

       634
        
            ) {

     

       635
       +
             users.users.graphite = {

     

       0
        
       
     

       636
        
               uid = config.ids.uids.graphite;

     

       637
        
               description = "Graphite daemon user";

     

       638
        
               home = dataDir;

+1 -2

nixos/modules/services/monitoring/heapster.nix

···

       49
        
             };

     

       50
        
           };

     

       51
        
       

     

       52
       -
           users.users = singleton {

     

       53
       -
             name = "heapster";

     

       54
        
             uid = config.ids.uids.heapster;

     

       55
        
             description = "Heapster user";

     

       56
        
           };

···

       49
        
             };

     

       50
        
           };

     

       51
        
       

     

       52
       +
           users.users.heapsterrs = {

     

       0
        
       
     

       53
        
             uid = config.ids.uids.heapster;

     

       54
        
             description = "Heapster user";

     

       55
        
           };

+4 -6

nixos/modules/services/monitoring/munin.nix

···

       317
        
       

     

       318
        
           environment.systemPackages = [ pkgs.munin ];

     

       319
        
       

     

       320
       -
           users.users = [{

     

       321
       -
             name = "munin";

     

       322
        
             description = "Munin monitoring user";

     

       323
        
             group = "munin";

     

       324
        
             uid = config.ids.uids.munin;

     

       325
        
             home = "/var/lib/munin";

     

       326
       -
           }];

     

       327
        
       

     

       328
       -
           users.groups = [{

     

       329
       -
             name = "munin";

     

       330
        
             gid = config.ids.gids.munin;

     

       331
       -
           }];

     

       332
        
       

     

       333
        
         }) (mkIf nodeCfg.enable {

     

       334

···

       317
        
       

     

       318
        
           environment.systemPackages = [ pkgs.munin ];

     

       319
        
       

     

       320
       +
           users.users.munin = {

     

       0
        
       
     

       321
        
             description = "Munin monitoring user";

     

       322
        
             group = "munin";

     

       323
        
             uid = config.ids.uids.munin;

     

       324
        
             home = "/var/lib/munin";

     

       325
       +
           };

     

       326
        
       

     

       327
       +
           users.groups.munin = {

     

       0
        
       
     

       328
        
             gid = config.ids.gids.munin;

     

       329
       +
           };

     

       330
        
       

     

       331
        
         }) (mkIf nodeCfg.enable {

     

       332

+1 -5

nixos/modules/services/monitoring/nagios.nix

···

       184
        
       

     

       185
        
           # This isn't needed, it's just so that the user can type "nagiostats

     

       186
        
           # -c /etc/nagios.cfg".

     

       187
       -
           environment.etc = [

     

       188
       -
             { source = nagiosCfgFile;

     

       189
       -
               target = "nagios.cfg";

     

       190
       -
             }

     

       191
       -
           ];

     

       192
        
       

     

       193
        
           environment.systemPackages = [ pkgs.nagios ];

     

       194
        
           systemd.services.nagios = {

···

       184
        
       

     

       185
        
           # This isn't needed, it's just so that the user can type "nagiostats

     

       186
        
           # -c /etc/nagios.cfg".

     

       187
       +
           environment.etc."nagios.cfg".source = nagiosCfgFile;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       188
        
       

     

       189
        
           environment.systemPackages = [ pkgs.nagios ];

     

       190
        
           systemd.services.nagios = {

+6 -5

nixos/modules/services/monitoring/netdata.nix

···

       179
        
             { domain = "netdata"; type = "hard"; item = "nofile"; value = "30000"; }

     

       180
        
           ];

     

       181
        
       

     

       182
       -
           users.users = optional (cfg.user == defaultUser) {

     

       183
       -
             name = defaultUser;

     

       184
       -
             isSystemUser = true;

     

       0
        
       
     

       185
        
           };

     

       186
        
       

     

       187
       -
           users.groups = optional (cfg.group == defaultUser) {

     

       188
       -
             name = defaultUser;

     

       189
        
           };

     

       190
        
       

     

       191
        
         };

···

       179
        
             { domain = "netdata"; type = "hard"; item = "nofile"; value = "30000"; }

     

       180
        
           ];

     

       181
        
       

     

       182
       +
           users.users = optionalAttrs (cfg.user == defaultUser) {

     

       183
       +
             ${defaultUser} = {

     

       184
       +
               isSystemUser = true;

     

       185
       +
             };

     

       186
        
           };

     

       187
        
       

     

       188
       +
           users.groups = optionalAttrs (cfg.group == defaultUser) {

     

       189
       +
             ${defaultUser} = { };

     

       190
        
           };

     

       191
        
       

     

       192
        
         };

+1 -2

nixos/modules/services/monitoring/statsd.nix

···

       125
        
             message = "Only builtin backends (graphite, console, repeater) or backends enumerated in `pkgs.nodePackages` are allowed!";

     

       126
        
           }) cfg.backends;

     

       127
        
       

     

       128
       -
           users.users = singleton {

     

       129
       -
             name = "statsd";

     

       130
        
             uid = config.ids.uids.statsd;

     

       131
        
             description = "Statsd daemon user";

     

       132
        
           };

···

       125
        
             message = "Only builtin backends (graphite, console, repeater) or backends enumerated in `pkgs.nodePackages` are allowed!";

     

       126
        
           }) cfg.backends;

     

       127
        
       

     

       128
       +
           users.use.statsdrs = {

     

       0
        
       
     

       129
        
             uid = config.ids.uids.statsd;

     

       130
        
             description = "Statsd daemon user";

     

       131
        
           };

+2 -3

nixos/modules/services/monitoring/telegraf.nix

···

       63
        
             };

     

       64
        
           };

     

       65
        
       

     

       66
       -
           users.users = [{

     

       67
       -
             name = "telegraf";

     

       68
        
             uid = config.ids.uids.telegraf;

     

       69
        
             description = "telegraf daemon user";

     

       70
       -
           }];

     

       71
        
         };

     

       72
        
       }

···

       63
        
             };

     

       64
        
           };

     

       65
        
       

     

       66
       +
           users.users.telegraf = {

     

       0
        
       
     

       67
        
             uid = config.ids.uids.telegraf;

     

       68
        
             description = "telegraf daemon user";

     

       69
       +
           };

     

       70
        
         };

     

       71
        
       }

+13 -30

nixos/modules/services/monitoring/ups.nix

···

       214
        
             environment.NUT_STATEPATH = "/var/lib/nut/";

     

       215
        
           };

     

       216
        
       

     

       217
       -
           environment.etc = [

     

       218
       -
             { source = pkgs.writeText "nut.conf"

     

       219
        
               ''

     

       220
        
                 MODE = ${cfg.mode}

     

       221
        
               '';

     

       222
       -
               target = "nut/nut.conf";

     

       223
       -
             }

     

       224
       -
             { source = pkgs.writeText "ups.conf"

     

       225
        
               ''

     

       226
        
                 maxstartdelay = ${toString cfg.maxStartDelay}

     

       227
        
       

     
···

       229
        
       

     

       230
        
                 "}

     

       231
        
               '';

     

       232
       -
               target = "nut/ups.conf";

     

       233
       -
             }

     

       234
       -
             { source = cfg.schedulerRules;

     

       235
       -
               target = "nut/upssched.conf";

     

       236
       -
             }

     

       237
        
             # These file are containing private informations and thus should not

     

       238
        
             # be stored inside the Nix store.

     

       239
        
             /*

     

       240
       -
             { source = ;

     

       241
       -
               target = "nut/upsd.conf";

     

       242
       -
             }

     

       243
       -
             { source = ;

     

       244
       -
               target = "nut/upsd.users";

     

       245
       -
             }

     

       246
       -
             { source = ;

     

       247
       -
               target = "nut/upsmon.conf;

     

       248
       -
             }

     

       249
        
             */

     

       250
       -
           ];

     

       251
        
       

     

       252
        
           power.ups.schedulerRules = mkDefault "${pkgs.nut}/etc/upssched.conf.sample";

     

       253
        
       

     
···

       259
        
       

     

       260
        
       

     

       261
        
       /*

     

       262
       -
           users.users = [

     

       263
       -
             { name = "nut";

     

       264
       -
               uid = 84;

     

       265
        
               home = "/var/lib/nut";

     

       266
        
               createHome = true;

     

       267
        
               group = "nut";

     

       268
        
               description = "UPnP A/V Media Server user";

     

       269
       -
             }

     

       270
       -
           ];

     

       271
        
       

     

       272
       -
           users.groups = [

     

       273
       -
             { name = "nut";

     

       274
       -
               gid = 84;

     

       275
       -
             }

     

       276
       -
           ];

     

       277
        
       */

     

       278
        
       

     

       279
        
         };

···

       214
        
             environment.NUT_STATEPATH = "/var/lib/nut/";

     

       215
        
           };

     

       216
        
       

     

       217
       +
           environment.etc = {

     

       218
       +
             "nut/nut.conf".source = pkgs.writeText "nut.conf"

     

       219
        
               ''

     

       220
        
                 MODE = ${cfg.mode}

     

       221
        
               '';

     

       222
       +
             "nut/ups.conf".source = pkgs.writeText "ups.conf"

     

       0
        
       
     

       0
        
       
     

       223
        
               ''

     

       224
        
                 maxstartdelay = ${toString cfg.maxStartDelay}

     

       225
        
       

     
···

       227
        
       

     

       228
        
                 "}

     

       229
        
               '';

     

       230
       +
             "nut/upssched.conf".source = cfg.schedulerRules;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       231
        
             # These file are containing private informations and thus should not

     

       232
        
             # be stored inside the Nix store.

     

       233
        
             /*

     

       234
       +
             "nut/upsd.conf".source = "";

     

       235
       +
             "nut/upsd.users".source = "";

     

       236
       +
             "nut/upsmon.conf".source = "";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       237
        
             */

     

       238
       +
           };

     

       239
        
       

     

       240
        
           power.ups.schedulerRules = mkDefault "${pkgs.nut}/etc/upssched.conf.sample";

     

       241
        
       

     
···

       247
        
       

     

       248
        
       

     

       249
        
       /*

     

       250
       +
           users.users.nut =

     

       251
       +
             { uid = 84;

     

       0
        
       
     

       252
        
               home = "/var/lib/nut";

     

       253
        
               createHome = true;

     

       254
        
               group = "nut";

     

       255
        
               description = "UPnP A/V Media Server user";

     

       256
       +
             };

     

       0
        
       
     

       257
        
       

     

       258
       +
           users.groups."nut" =

     

       259
       +
             { gid = 84; };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       260
        
       */

     

       261
        
       

     

       262
        
         };

+3 -4

nixos/modules/services/network-filesystems/ceph.nix

···

       371
        
             in

     

       372
        
               generators.toINI {} totalConfig;

     

       373
        
       

     

       374
       -
           users.users = singleton {

     

       375
       -
             name = "ceph";

     

       376
        
             uid = config.ids.uids.ceph;

     

       377
        
             description = "Ceph daemon user";

     

       378
        
             group = "ceph";

     

       379
        
             extraGroups = [ "disk" ];

     

       380
        
           };

     

       381
       -
           users.groups = singleton {

     

       382
       -
             name = "ceph";

     

       383
        
             gid = config.ids.gids.ceph;

     

       384
        
           };

     

       385

···

       371
        
             in

     

       372
        
               generators.toINI {} totalConfig;

     

       373
        
       

     

       374
       +
           users.users.ceph = {

     

       0
        
       
     

       375
        
             uid = config.ids.uids.ceph;

     

       376
        
             description = "Ceph daemon user";

     

       377
        
             group = "ceph";

     

       378
        
             extraGroups = [ "disk" ];

     

       379
        
           };

     

       380
       +
       

     

       381
       +
           users.groups.ceph = {

     

       382
        
             gid = config.ids.gids.ceph;

     

       383
        
           };

     

       384

+12 -11

nixos/modules/services/network-filesystems/davfs2.nix

···

       57
        
           environment.systemPackages = [ pkgs.davfs2 ];

     

       58
        
           environment.etc."davfs2/davfs2.conf".source = cfgFile;

     

       59
        
       

     

       60
       -
           users.groups = optionalAttrs (cfg.davGroup == "davfs2") (singleton {

     

       61
       -
             name = "davfs2";

     

       62
       -
             gid = config.ids.gids.davfs2;

     

       63
       -
           });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       64
        
       

     

       65
       -
           users.users = optionalAttrs (cfg.davUser == "davfs2") (singleton {

     

       66
       -
             name = "davfs2";

     

       67
       -
             createHome = false;

     

       68
       -
             group = cfg.davGroup;

     

       69
       -
             uid = config.ids.uids.davfs2;

     

       70
       -
             description = "davfs2 user";

     

       71
       -
           });

     

       72
        
         };

     

       73
        
       

     

       74
        
       }

···

       57
        
           environment.systemPackages = [ pkgs.davfs2 ];

     

       58
        
           environment.etc."davfs2/davfs2.conf".source = cfgFile;

     

       59
        
       

     

       60
       +
           users.groups = optionalAttrs (cfg.davGroup == "davfs2") {

     

       61
       +
             davfs2.gid = config.ids.gids.davfs2;

     

       62
       +
           };

     

       63
       +
       

     

       64
       +
           users.users = optionalAttrs (cfg.davUser == "davfs2") {

     

       65
       +
             davfs2 = {

     

       66
       +
               createHome = false;

     

       67
       +
               group = cfg.davGroup;

     

       68
       +
               uid = config.ids.uids.davfs2;

     

       69
       +
               description = "davfs2 user";

     

       70
       +
             };

     

       71
       +
           };

     

       72
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       73
        
         };

     

       74
        
       

     

       75
        
       }

+2 -4

nixos/modules/services/network-filesystems/drbd.nix

···

       47
        
               options drbd usermode_helper=/run/current-system/sw/bin/drbdadm

     

       48
        
             '';

     

       49
        
       

     

       50
       -
           environment.etc = singleton

     

       51
       -
             { source = pkgs.writeText "drbd.conf" cfg.config;

     

       52
       -
               target = "drbd.conf";

     

       53
       -
             };

     

       54
        
       

     

       55
        
           systemd.services.drbd = {

     

       56
        
             after = [ "systemd-udev.settle.service" "network.target" ];

···

       47
        
               options drbd usermode_helper=/run/current-system/sw/bin/drbdadm

     

       48
        
             '';

     

       49
        
       

     

       50
       +
           environment.etc.drbd.conf =

     

       51
       +
             { source = pkgs.writeText "drbd.conf" cfg.config; };

     

       0
        
       
     

       0
        
       
     

       52
        
       

     

       53
        
           systemd.services.drbd = {

     

       54
        
             after = [ "systemd-udev.settle.service" "network.target" ];

+2 -3

nixos/modules/services/networking/bind.nix

···

       178
        
       

     

       179
        
           networking.resolvconf.useLocalResolver = mkDefault true;

     

       180
        
       

     

       181
       -
           users.users = singleton

     

       182
       -
             { name = bindUser;

     

       183
       -
               uid = config.ids.uids.bind;

     

       184
        
               description = "BIND daemon user";

     

       185
        
             };

     

       186

···

       178
        
       

     

       179
        
           networking.resolvconf.useLocalResolver = mkDefault true;

     

       180
        
       

     

       181
       +
           users.users.${bindUser} =

     

       182
       +
             { uid = config.ids.uids.bind;

     

       0
        
       
     

       183
        
               description = "BIND daemon user";

     

       184
        
             };

     

       185

+1 -2

nixos/modules/services/networking/bitlbee.nix

···

       161
        
       

     

       162
        
         config =  mkMerge [

     

       163
        
           (mkIf config.services.bitlbee.enable {

     

       164
       -
             users.users = singleton {

     

       165
       -
               name = "bitlbee";

     

       166
        
               uid = bitlbeeUid;

     

       167
        
               description = "BitlBee user";

     

       168
        
               home = "/var/lib/bitlbee";

···

       161
        
       

     

       162
        
         config =  mkMerge [

     

       163
        
           (mkIf config.services.bitlbee.enable {

     

       164
       +
             users.users.bitlbee = {

     

       0
        
       
     

       165
        
               uid = bitlbeeUid;

     

       166
        
               description = "BitlBee user";

     

       167
        
               home = "/var/lib/bitlbee";

+2 -4

nixos/modules/services/networking/charybdis.nix

···

       71
        
       

     

       72
        
         config = mkIf cfg.enable (lib.mkMerge [

     

       73
        
           {

     

       74
       -
             users.users = singleton {

     

       75
       -
               name = cfg.user;

     

       76
        
               description = "Charybdis IRC daemon user";

     

       77
        
               uid = config.ids.uids.ircd;

     

       78
        
               group = cfg.group;

     

       79
        
             };

     

       80
        
       

     

       81
       -
             users.groups = singleton {

     

       82
       -
               name = cfg.group;

     

       83
        
               gid = config.ids.gids.ircd;

     

       84
        
             };

     

       85

···

       71
        
       

     

       72
        
         config = mkIf cfg.enable (lib.mkMerge [

     

       73
        
           {

     

       74
       +
             users.users.${cfg.user} = {

     

       0
        
       
     

       75
        
               description = "Charybdis IRC daemon user";

     

       76
        
               uid = config.ids.uids.ircd;

     

       77
        
               group = cfg.group;

     

       78
        
             };

     

       79
        
       

     

       80
       +
             users.groups.${cfg.group} = {

     

       0
        
       
     

       81
        
               gid = config.ids.gids.ircd;

     

       82
        
             };

     

       83

+6 -8

nixos/modules/services/networking/coturn.nix

···

       294
        
         };

     

       295
        
       

     

       296
        
         config = mkIf cfg.enable {

     

       297
       -
           users.users = [

     

       298
       -
             { name = "turnserver";

     

       299
       -
               uid = config.ids.uids.turnserver;

     

       300
        
               description = "coturn TURN server user";

     

       301
       -
             } ];

     

       302
       -
           users.groups = [

     

       303
       -
             { name = "turnserver";

     

       304
       -
               gid = config.ids.gids.turnserver;

     

       305
        
               members = [ "turnserver" ];

     

       306
       -
             } ];

     

       307
        
       

     

       308
        
           systemd.services.coturn = {

     

       309
        
             description = "coturn TURN server";

···

       294
        
         };

     

       295
        
       

     

       296
        
         config = mkIf cfg.enable {

     

       297
       +
           users.users.turnserver =

     

       298
       +
             { uid = config.ids.uids.turnserver;

     

       0
        
       
     

       299
        
               description = "coturn TURN server user";

     

       300
       +
             };

     

       301
       +
           users.groups.turnserver =

     

       302
       +
             { gid = config.ids.gids.turnserver;

     

       0
        
       
     

       303
        
               members = [ "turnserver" ];

     

       304
       +
             };

     

       305
        
       

     

       306
        
           systemd.services.coturn = {

     

       307
        
             description = "coturn TURN server";

+1 -5

nixos/modules/services/networking/dhcpcd.nix

···

       185
        
       

     

       186
        
           environment.systemPackages = [ dhcpcd ];

     

       187
        
       

     

       188
       -
           environment.etc =

     

       189
       -
             [ { source = exitHook;

     

       190
       -
                 target = "dhcpcd.exit-hook";

     

       191
       -
               }

     

       192
       -
             ];

     

       193
        
       

     

       194
        
           powerManagement.resumeCommands = mkIf config.systemd.services.dhcpcd.enable

     

       195
        
             ''

···

       185
        
       

     

       186
        
           environment.systemPackages = [ dhcpcd ];

     

       187
        
       

     

       188
       +
           environment.etc."dhcpcd.exit-hook".source = exitHook;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       189
        
       

     

       190
        
           powerManagement.resumeCommands = mkIf config.systemd.services.dhcpcd.enable

     

       191
        
             ''

+1 -2

nixos/modules/services/networking/dnschain.nix

···

       147
        
             '';

     

       148
        
           };

     

       149
        
       

     

       150
       -
           users.users = singleton {

     

       151
       -
             name = username;

     

       152
        
             description = "DNSChain daemon user";

     

       153
        
             home = dataDir;

     

       154
        
             createHome = true;

···

       147
        
             '';

     

       148
        
           };

     

       149
        
       

     

       150
       +
           users.users.${username} = {

     

       0
        
       
     

       151
        
             description = "DNSChain daemon user";

     

       152
        
             home = dataDir;

     

       153
        
             createHome = true;

+1 -2

nixos/modules/services/networking/dnsmasq.nix

···

       86
        
       

     

       87
        
           services.dbus.packages = [ dnsmasq ];

     

       88
        
       

     

       89
       -
           users.users = singleton {

     

       90
       -
             name = "dnsmasq";

     

       91
        
             uid = config.ids.uids.dnsmasq;

     

       92
        
             description = "Dnsmasq daemon user";

     

       93
        
           };

···

       86
        
       

     

       87
        
           services.dbus.packages = [ dnsmasq ];

     

       88
        
       

     

       89
       +
           users.users.dnsmasq = {

     

       0
        
       
     

       90
        
             uid = config.ids.uids.dnsmasq;

     

       91
        
             description = "Dnsmasq daemon user";

     

       92
        
           };

+7 -7

nixos/modules/services/networking/ejabberd.nix

···

       94
        
         config = mkIf cfg.enable {

     

       95
        
           environment.systemPackages = [ cfg.package ];

     

       96
        
       

     

       97
       -
           users.users = optionalAttrs (cfg.user == "ejabberd") (singleton

     

       98
       -
             { name = "ejabberd";

     

       99
        
               group = cfg.group;

     

       100
        
               home = cfg.spoolDir;

     

       101
        
               createHome = true;

     

       102
        
               uid = config.ids.uids.ejabberd;

     

       103
       -
             });

     

       0
        
       
     

       104
        
       

     

       105
       -
           users.groups = optionalAttrs (cfg.group == "ejabberd") (singleton

     

       106
       -
             { name = "ejabberd";

     

       107
       -
               gid = config.ids.gids.ejabberd;

     

       108
       -
             });

     

       109
        
       

     

       110
        
           systemd.services.ejabberd = {

     

       111
        
             description = "ejabberd server";

···

       94
        
         config = mkIf cfg.enable {

     

       95
        
           environment.systemPackages = [ cfg.package ];

     

       96
        
       

     

       97
       +
           users.users = optionalAttrs (cfg.user == "ejabberd") {

     

       98
       +
             ejabberd = {

     

       99
        
               group = cfg.group;

     

       100
        
               home = cfg.spoolDir;

     

       101
        
               createHome = true;

     

       102
        
               uid = config.ids.uids.ejabberd;

     

       103
       +
             };

     

       104
       +
           };

     

       105
        
       

     

       106
       +
           users.groups = optionalAttrs (cfg.group == "ejabberd") {

     

       107
       +
             ejabberd.gid = config.ids.gids.ejabberd;

     

       108
       +
           };

     

       0
        
       
     

       109
        
       

     

       110
        
           systemd.services.ejabberd = {

     

       111
        
             description = "ejabberd server";

+2 -3

nixos/modules/services/networking/gale.nix

···

       104
        
                systemPackages = [ pkgs.gale ];

     

       105
        
              };

     

       106
        
       

     

       107
       -
              users.users = [{

     

       108
       -
                name = cfg.user;

     

       109
        
                description = "Gale daemon";

     

       110
        
                uid = config.ids.uids.gale;

     

       111
        
                group = cfg.group;

     

       112
        
                home = home;

     

       113
        
                createHome = true;

     

       114
       -
              }];

     

       115
        
       

     

       116
        
              users.groups = [{

     

       117
        
                name = cfg.group;

···

       104
        
                systemPackages = [ pkgs.gale ];

     

       105
        
              };

     

       106
        
       

     

       107
       +
              users.users.${cfg.user} = {

     

       0
        
       
     

       108
        
                description = "Gale daemon";

     

       109
        
                uid = config.ids.uids.gale;

     

       110
        
                group = cfg.group;

     

       111
        
                home = home;

     

       112
        
                createHome = true;

     

       113
       +
              };

     

       114
        
       

     

       115
        
              users.groups = [{

     

       116
        
                name = cfg.group;

+6 -6

nixos/modules/services/networking/git-daemon.nix

···

       104
        
       

     

       105
        
         config = mkIf cfg.enable {

     

       106
        
       

     

       107
       -
           users.users = if cfg.user != "git" then {} else singleton

     

       108
       -
             { name = "git";

     

       109
        
               uid = config.ids.uids.git;

     

       110
        
               description = "Git daemon user";

     

       111
        
             };

     

       0
        
       
     

       112
        
       

     

       113
       -
           users.groups = if cfg.group != "git" then {} else singleton

     

       114
       -
             { name = "git";

     

       115
       -
               gid = config.ids.gids.git;

     

       116
       -
             };

     

       117
        
       

     

       118
        
           systemd.services.git-daemon = {

     

       119
        
             after = [ "network.target" ];

···

       104
        
       

     

       105
        
         config = mkIf cfg.enable {

     

       106
        
       

     

       107
       +
           users.users = optionalAttrs (cfg.user != "git") {

     

       108
       +
             git = {

     

       109
        
               uid = config.ids.uids.git;

     

       110
        
               description = "Git daemon user";

     

       111
        
             };

     

       112
       +
           };

     

       113
        
       

     

       114
       +
           users.groups = optionalAttrs (cfg.group != "git") {

     

       115
       +
             git.gid = config.ids.gids.git;

     

       116
       +
           };

     

       0
        
       
     

       117
        
       

     

       118
        
           systemd.services.git-daemon = {

     

       119
        
             after = [ "network.target" ];

+1 -2

nixos/modules/services/networking/hans.nix

···

       135
        
             };

     

       136
        
           };

     

       137
        
       

     

       138
       -
           users.users = singleton {

     

       139
       -
             name = hansUser;

     

       140
        
             description = "Hans daemon user";

     

       141
        
             isSystemUser = true;

     

       142
        
           };

···

       135
        
             };

     

       136
        
           };

     

       137
        
       

     

       138
       +
           users.users.${hansUser} = {

     

       0
        
       
     

       139
        
             description = "Hans daemon user";

     

       140
        
             isSystemUser = true;

     

       141
        
           };

+9 -9

nixos/modules/services/networking/i2pd.nix

···

       158
        
             (sec "addressbook")

     

       159
        
             (strOpt "defaulturl" cfg.addressbook.defaulturl)

     

       160
        
           ] ++ (optionalEmptyList "subscriptions" cfg.addressbook.subscriptions)

     

       161
       -
             ++ (flip map

     

       162
       -
             (collect (proto: proto ? port && proto ? address && proto ? name) cfg.proto)

     

       163
        
             (proto: let protoOpts = [

     

       164
       -
               (sec proto.name)

     

       165
        
               (boolOpt "enabled" proto.enable)

     

       166
        
               (strOpt "address" proto.address)

     

       167
        
               (intOpt "port" proto.port)

     
···

       181
        
       

     

       182
        
         tunnelConf = let opts = [

     

       183
        
           notice

     

       184
       -
           (flip map

     

       185
       -
             (collect (tun: tun ? port && tun ? destination) cfg.outTunnels)

     

       186
        
             (tun: let outTunOpts = [

     

       187
       -
               (sec tun.name)

     

       188
        
               "type = client"

     

       189
        
               (intOpt "port" tun.port)

     

       190
        
               (strOpt "destination" tun.destination)

     
···

       204
        
               ++ (if tun ? crypto.tagsToSend then

     

       205
        
                   optionalNullInt "crypto.tagstosend" tun.crypto.tagsToSend else []);

     

       206
        
               in concatStringsSep "\n" outTunOpts))

     

       207
       -
           (flip map

     

       208
       -
             (collect (tun: tun ? port && tun ? address) cfg.inTunnels)

     

       209
        
             (tun: let inTunOpts = [

     

       210
       -
               (sec tun.name)

     

       211
        
               "type = server"

     

       212
        
               (intOpt "port" tun.port)

     

       213
        
               (strOpt "host" tun.address)

···

       158
        
             (sec "addressbook")

     

       159
        
             (strOpt "defaulturl" cfg.addressbook.defaulturl)

     

       160
        
           ] ++ (optionalEmptyList "subscriptions" cfg.addressbook.subscriptions)

     

       161
       +
             ++ (flip mapAttrs

     

       162
       +
             (collect (name: proto: proto ? port && proto ? address && proto ? name) cfg.proto)

     

       163
        
             (proto: let protoOpts = [

     

       164
       +
               (sec name)

     

       165
        
               (boolOpt "enabled" proto.enable)

     

       166
        
               (strOpt "address" proto.address)

     

       167
        
               (intOpt "port" proto.port)

     
···

       181
        
       

     

       182
        
         tunnelConf = let opts = [

     

       183
        
           notice

     

       184
       +
           (flip mapAttrs

     

       185
       +
             (collect (name: tun: tun ? port && tun ? destination) cfg.outTunnels)

     

       186
        
             (tun: let outTunOpts = [

     

       187
       +
               (sec name)

     

       188
        
               "type = client"

     

       189
        
               (intOpt "port" tun.port)

     

       190
        
               (strOpt "destination" tun.destination)

     
···

       204
        
               ++ (if tun ? crypto.tagsToSend then

     

       205
        
                   optionalNullInt "crypto.tagstosend" tun.crypto.tagsToSend else []);

     

       206
        
               in concatStringsSep "\n" outTunOpts))

     

       207
       +
           (flip mapAttrs

     

       208
       +
             (collect (name: tun: tun ? port && tun ? address) cfg.inTunnels)

     

       209
        
             (tun: let inTunOpts = [

     

       210
       +
               (sec name)

     

       211
        
               "type = server"

     

       212
        
               (intOpt "port" tun.port)

     

       213
        
               (strOpt "host" tun.address)

+1 -2

nixos/modules/services/networking/iodine.nix

···

       147
        
             };

     

       148
        
           };

     

       149
        
       

     

       150
       -
           users.users = singleton {

     

       151
       -
             name = iodinedUser;

     

       152
        
             uid = config.ids.uids.iodined;

     

       153
        
             description = "Iodine daemon user";

     

       154
        
           };

···

       147
        
             };

     

       148
        
           };

     

       149
        
       

     

       150
       +
           users.users.${iodinedUser} = {

     

       0
        
       
     

       151
        
             uid = config.ids.uids.iodined;

     

       152
        
             description = "Iodine daemon user";

     

       153
        
           };

+2 -3

nixos/modules/services/networking/ircd-hybrid/default.nix

···

       112
        
       

     

       113
        
         config = mkIf config.services.ircdHybrid.enable {

     

       114
        
       

     

       115
       -
           users.users = singleton

     

       116
       -
             { name = "ircd";

     

       117
       -
               description = "IRCD owner";

     

       118
        
               group = "ircd";

     

       119
        
               uid = config.ids.uids.ircd;

     

       120
        
             };

···

       112
        
       

     

       113
        
         config = mkIf config.services.ircdHybrid.enable {

     

       114
        
       

     

       115
       +
           users.users.ircd =

     

       116
       +
             { description = "IRCD owner";

     

       0
        
       
     

       117
        
               group = "ircd";

     

       118
        
               uid = config.ids.uids.ircd;

     

       119
        
             };

+2 -3

nixos/modules/services/networking/kippo.nix

···

       73
        
               ${cfg.extraConfig}

     

       74
        
           '';

     

       75
        
       

     

       76
       -
           users.users = singleton {

     

       77
       -
             name = "kippo";

     

       78
        
             description = "kippo web server privilege separation user";

     

       79
        
             uid = 108; # why does config.ids.uids.kippo give an error?

     

       80
        
           };

     

       81
       -
           users.groups = singleton { name = "kippo";gid=108; };

     

       82
        
       

     

       83
        
           systemd.services.kippo = with pkgs; {

     

       84
        
             description = "Kippo Web Server";

···

       73
        
               ${cfg.extraConfig}

     

       74
        
           '';

     

       75
        
       

     

       76
       +
           users.users.kippo = {

     

       0
        
       
     

       77
        
             description = "kippo web server privilege separation user";

     

       78
        
             uid = 108; # why does config.ids.uids.kippo give an error?

     

       79
        
           };

     

       80
       +
           users.groups.kippo.gid = 108;

     

       81
        
       

     

       82
        
           systemd.services.kippo = with pkgs; {

     

       83
        
             description = "Kippo Web Server";

+3 -7

nixos/modules/services/networking/kresd.nix

···

       74
        
         config = mkIf cfg.enable {

     

       75
        
           environment.etc."kresd.conf".source = configFile; # not required

     

       76
        
       

     

       77
       -
           users.users = singleton

     

       78
       -
             { name = "kresd";

     

       79
       -
               uid = config.ids.uids.kresd;

     

       80
        
               group = "kresd";

     

       81
        
               description = "Knot-resolver daemon user";

     

       82
        
             };

     

       83
       -
           users.groups = singleton

     

       84
       -
             { name = "kresd";

     

       85
       -
               gid = config.ids.gids.kresd;

     

       86
       -
             };

     

       87
        
       

     

       88
        
           systemd.sockets.kresd = rec {

     

       89
        
             wantedBy = [ "sockets.target" ];

···

       74
        
         config = mkIf cfg.enable {

     

       75
        
           environment.etc."kresd.conf".source = configFile; # not required

     

       76
        
       

     

       77
       +
           users.users.kresd =

     

       78
       +
             { uid = config.ids.uids.kresd;

     

       0
        
       
     

       79
        
               group = "kresd";

     

       80
        
               description = "Knot-resolver daemon user";

     

       81
        
             };

     

       82
       +
           users.groups.kresd.gid = config.ids.gids.kresd;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       83
        
       

     

       84
        
           systemd.sockets.kresd = rec {

     

       85
        
             wantedBy = [ "sockets.target" ];

+7 -6

nixos/modules/services/networking/matterbridge.nix

···

       92
        
           warnings = optional options.services.matterbridge.configFile.isDefined

     

       93
        
             "The option services.matterbridge.configFile is insecure and should be replaced with services.matterbridge.configPath";

     

       94
        
       

     

       95
       -
           users.users = optional (cfg.user == "matterbridge")

     

       96
       -
             { name = "matterbridge";

     

       97
       -
               group = "matterbridge";

     

       98
       -
               isSystemUser = true;

     

       0
        
       
     

       99
        
             };

     

       100
        
       

     

       101
       -
           users.groups = optional (cfg.group == "matterbridge")

     

       102
       -
             { name = "matterbridge";

     

       103
        
             };

     

       104
        
       

     

       105
        
           systemd.services.matterbridge = {

···

       92
        
           warnings = optional options.services.matterbridge.configFile.isDefined

     

       93
        
             "The option services.matterbridge.configFile is insecure and should be replaced with services.matterbridge.configPath";

     

       94
        
       

     

       95
       +
           users.users = optionalAttrs (cfg.user == "matterbridge")

     

       96
       +
             { matterbridge = {

     

       97
       +
                 group = "matterbridge";

     

       98
       +
                 isSystemUser = true;

     

       99
       +
               };

     

       100
        
             };

     

       101
        
       

     

       102
       +
           users.groups = optionalAttrs (cfg.group == "matterbridge")

     

       103
       +
             { matterbridge = { };

     

       104
        
             };

     

       105
        
       

     

       106
        
           systemd.services.matterbridge = {

+5 -4

nixos/modules/services/networking/mjpg-streamer.nix

···

       49
        
       

     

       50
        
         config = mkIf cfg.enable {

     

       51
        
       

     

       52
       -
           users.users = optional (cfg.user == "mjpg-streamer") {

     

       53
       -
             name = "mjpg-streamer";

     

       54
       -
             uid = config.ids.uids.mjpg-streamer;

     

       55
       -
             group = cfg.group;

     

       0
        
       
     

       56
        
           };

     

       57
        
       

     

       58
        
           systemd.services.mjpg-streamer = {

···

       49
        
       

     

       50
        
         config = mkIf cfg.enable {

     

       51
        
       

     

       52
       +
           users.users = optionalAttrs (cfg.user == "mjpg-streamer") {

     

       53
       +
             mjpg-streamer = {

     

       54
       +
               uid = config.ids.uids.mjpg-streamer;

     

       55
       +
               group = cfg.group;

     

       56
       +
             };

     

       57
        
           };

     

       58
        
       

     

       59
        
           systemd.services.mjpg-streamer = {

+3 -5

nixos/modules/services/networking/monero.nix

···

       197
        
       

     

       198
        
         config = mkIf cfg.enable {

     

       199
        
       

     

       200
       -
           users.users = singleton {

     

       201
       -
             name = "monero";

     

       202
        
             uid  = config.ids.uids.monero;

     

       203
        
             description = "Monero daemon user";

     

       204
        
             home = dataDir;

     

       205
        
             createHome = true;

     

       206
        
           };

     

       207
        
       

     

       208
       -
           users.groups = singleton {

     

       209
       -
             name = "monero";

     

       210
       -
             gid  = config.ids.gids.monero;

     

       211
        
           };

     

       212
        
       

     

       213
        
           systemd.services.monero = {

···

       197
        
       

     

       198
        
         config = mkIf cfg.enable {

     

       199
        
       

     

       200
       +
           users.users.monero = {

     

       0
        
       
     

       201
        
             uid  = config.ids.uids.monero;

     

       202
        
             description = "Monero daemon user";

     

       203
        
             home = dataDir;

     

       204
        
             createHome = true;

     

       205
        
           };

     

       206
        
       

     

       207
       +
           users.groups.monero = {

     

       208
       +
             gid = config.ids.gids.monero;

     

       0
        
       
     

       209
        
           };

     

       210
        
       

     

       211
        
           systemd.services.monero = {

+5 -8

nixos/modules/services/networking/mxisd.nix

···

       93
        
         };

     

       94
        
       

     

       95
        
         config = mkIf cfg.enable {

     

       96
       -
           users.users = [

     

       97
        
             {

     

       98
       -
               name = "mxisd";

     

       99
        
               group = "mxisd";

     

       100
        
               home = cfg.dataDir;

     

       101
        
               createHome = true;

     

       102
        
               shell = "${pkgs.bash}/bin/bash";

     

       103
        
               uid = config.ids.uids.mxisd;

     

       104
       -
             }

     

       105
       -
           ];

     

       106
        
       

     

       107
       -
           users.groups = [

     

       108
        
             {

     

       109
       -
               name = "mxisd";

     

       110
        
               gid = config.ids.gids.mxisd;

     

       111
       -
             }

     

       112
       -
           ];

     

       113
        
       

     

       114
        
           systemd.services.mxisd = {

     

       115
        
             description = "a federated identity server for the matrix ecosystem";

···

       93
        
         };

     

       94
        
       

     

       95
        
         config = mkIf cfg.enable {

     

       96
       +
           users.users.mxisd =

     

       97
        
             {

     

       0
        
       
     

       98
        
               group = "mxisd";

     

       99
        
               home = cfg.dataDir;

     

       100
        
               createHome = true;

     

       101
        
               shell = "${pkgs.bash}/bin/bash";

     

       102
        
               uid = config.ids.uids.mxisd;

     

       103
       +
             };

     

       0
        
       
     

       104
        
       

     

       105
       +
           users.groups.mxisd =

     

       106
        
             {

     

       107
       +
               name = "";

     

       108
        
               gid = config.ids.gids.mxisd;

     

       109
       +
             };

     

       0
        
       
     

       110
        
       

     

       111
        
           systemd.services.mxisd = {

     

       112
        
             description = "a federated identity server for the matrix ecosystem";

+2 -4

nixos/modules/services/networking/namecoind.nix

···

       154
        
             config = ${configFile}

     

       155
        
           '';

     

       156
        
       

     

       157
       -
           users.users = singleton {

     

       158
       -
             name = "namecoin";

     

       159
        
             uid  = config.ids.uids.namecoin;

     

       160
        
             description = "Namecoin daemon user";

     

       161
        
             home = dataDir;

     

       162
        
             createHome = true;

     

       163
        
           };

     

       164
        
       

     

       165
       -
           users.groups = singleton {

     

       166
       -
             name = "namecoin";

     

       167
        
             gid  = config.ids.gids.namecoin;

     

       168
        
           };

     

       169

···

       154
        
             config = ${configFile}

     

       155
        
           '';

     

       156
        
       

     

       157
       +
           users.users.namecoin = {

     

       0
        
       
     

       158
        
             uid  = config.ids.uids.namecoin;

     

       159
        
             description = "Namecoin daemon user";

     

       160
        
             home = dataDir;

     

       161
        
             createHome = true;

     

       162
        
           };

     

       163
        
       

     

       164
       +
           users.groups.namecoin = {

     

       0
        
       
     

       165
        
             gid  = config.ids.gids.namecoin;

     

       166
        
           };

     

       167

+49 -52

nixos/modules/services/networking/networkmanager.nix

···

       362
        
             }

     

       363
        
           ];

     

       364
        
       

     

       365
       -
           environment.etc = with pkgs; [

     

       366
       -
             { source = configFile;

     

       367
       -
               target = "NetworkManager/NetworkManager.conf";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       368
        
             }

     

       369
       -
             { source = "${networkmanager-openvpn}/lib/NetworkManager/VPN/nm-openvpn-service.name";

     

       370
       -
               target = "NetworkManager/VPN/nm-openvpn-service.name";

     

       371
       -
             }

     

       372
       -
             { source = "${networkmanager-vpnc}/lib/NetworkManager/VPN/nm-vpnc-service.name";

     

       373
       -
               target = "NetworkManager/VPN/nm-vpnc-service.name";

     

       374
       -
             }

     

       375
       -
             { source = "${networkmanager-openconnect}/lib/NetworkManager/VPN/nm-openconnect-service.name";

     

       376
       -
               target = "NetworkManager/VPN/nm-openconnect-service.name";

     

       377
       -
             }

     

       378
       -
             { source = "${networkmanager-fortisslvpn}/lib/NetworkManager/VPN/nm-fortisslvpn-service.name";

     

       379
       -
               target = "NetworkManager/VPN/nm-fortisslvpn-service.name";

     

       380
       -
             }

     

       381
       -
             { source = "${networkmanager-l2tp}/lib/NetworkManager/VPN/nm-l2tp-service.name";

     

       382
       -
               target = "NetworkManager/VPN/nm-l2tp-service.name";

     

       383
       -
             }

     

       384
       -
             { source = "${networkmanager-iodine}/lib/NetworkManager/VPN/nm-iodine-service.name";

     

       385
       -
               target = "NetworkManager/VPN/nm-iodine-service.name";

     

       386
       -
             }

     

       387
       -
           ] ++ optional (cfg.appendNameservers != [] || cfg.insertNameservers != [])

     

       388
       -
                  { source = overrideNameserversScript;

     

       389
       -
                    target = "NetworkManager/dispatcher.d/02overridedns";

     

       390
       -
                  }

     

       391
       -
             ++ lib.imap1 (i: s: {

     

       392
       -
               inherit (s) source;

     

       393
       -
               target = "NetworkManager/dispatcher.d/${dispatcherTypesSubdirMap.${s.type}}03userscript${lib.fixedWidthNumber 4 i}";

     

       394
       -
               mode = "0544";

     

       395
       -
             }) cfg.dispatcherScripts

     

       396
       -
             ++ optional cfg.enableStrongSwan

     

       397
       -
                  { source = "${pkgs.networkmanager_strongswan}/lib/NetworkManager/VPN/nm-strongswan-service.name";

     

       398
       -
                    target = "NetworkManager/VPN/nm-strongswan-service.name";

     

       399
       -
                  };

     

       400
        
       

     

       401
        
           environment.systemPackages = cfg.packages;

     

       402
        
       

     

       403
       -
           users.groups = [{

     

       404
       -
             name = "networkmanager";

     

       405
       -
             gid = config.ids.gids.networkmanager;

     

       406
       -
           }

     

       407
       -
           {

     

       408
       -
             name = "nm-openvpn";

     

       409
       -
             gid = config.ids.gids.nm-openvpn;

     

       410
       -
           }];

     

       411
       -
           users.users = [{

     

       412
       -
             name = "nm-openvpn";

     

       413
       -
             uid = config.ids.uids.nm-openvpn;

     

       414
       -
             extraGroups = [ "networkmanager" ];

     

       415
       -
           }

     

       416
       -
           {

     

       417
       -
             name = "nm-iodine";

     

       418
       -
             isSystemUser = true;

     

       419
       -
             group = "networkmanager";

     

       420
       -
           }];

     

       421
        
       

     

       422
        
           systemd.packages = cfg.packages;

     

       423

···

       362
        
             }

     

       363
        
           ];

     

       364
        
       

     

       365
       +
           environment.etc = with pkgs; {

     

       366
       +
             "NetworkManager/NetworkManager.conf".source = configFile;

     

       367
       +
       

     

       368
       +
             "NetworkManager/VPN/nm-openvpn-service.name".source =

     

       369
       +
               "${networkmanager-openvpn}/lib/NetworkManager/VPN/nm-openvpn-service.name";

     

       370
       +
       

     

       371
       +
             "NetworkManager/VPN/nm-vpnc-service.name".source =

     

       372
       +
               "${networkmanager-vpnc}/lib/NetworkManager/VPN/nm-vpnc-service.name";

     

       373
       +
       

     

       374
       +
             "NetworkManager/VPN/nm-openconnect-service.name".source =

     

       375
       +
               "${networkmanager-openconnect}/lib/NetworkManager/VPN/nm-openconnect-service.name";

     

       376
       +
       

     

       377
       +
             "NetworkManager/VPN/nm-fortisslvpn-service.name".source =

     

       378
       +
               "${networkmanager-fortisslvpn}/lib/NetworkManager/VPN/nm-fortisslvpn-service.name";

     

       379
       +
       

     

       380
       +
             "NetworkManager/VPN/nm-l2tp-service.name".source =

     

       381
       +
               "${networkmanager-l2tp}/lib/NetworkManager/VPN/nm-l2tp-service.name";

     

       382
       +
       

     

       383
       +
             "NetworkManager/VPN/nm-iodine-service.name".source =

     

       384
       +
               "${networkmanager-iodine}/lib/NetworkManager/VPN/nm-iodine-service.name";

     

       385
        
             }

     

       386
       +
             // optionalAttrs (cfg.appendNameservers != [] || cfg.insertNameservers != [])

     

       387
       +
                {

     

       388
       +
                  "NetworkManager/dispatcher.d/02overridedns".source = overrideNameserversScript;

     

       389
       +
                }

     

       390
       +
             // optionalAttrs cfg.enableStrongSwan

     

       391
       +
                {

     

       392
       +
                  "NetworkManager/VPN/nm-strongswan-service.name".source =

     

       393
       +
                    "${pkgs.networkmanager_strongswan}/lib/NetworkManager/VPN/nm-strongswan-service.name";

     

       394
       +
                }

     

       395
       +
             // listToAttrs (lib.imap1 (i: s:

     

       396
       +
                {

     

       397
       +
                   name = "NetworkManager/dispatcher.d/${dispatcherTypesSubdirMap.${s.type}}03userscript${lib.fixedWidthNumber 4 i}";

     

       398
       +
                   value = { mode = "0544"; inherit (s) source; };

     

       399
       +
                }) cfg.dispatcherScripts);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       400
        
       

     

       401
        
           environment.systemPackages = cfg.packages;

     

       402
        
       

     

       403
       +
           users.groups = {

     

       404
       +
             networkmanager.gid = config.ids.gids.networkmanager;

     

       405
       +
             nm-openvpn.gid = config.ids.gids.nm-openvpn;

     

       406
       +
           };

     

       407
       +
       

     

       408
       +
           users.users = {

     

       409
       +
             nm-openvpn = {

     

       410
       +
               uid = config.ids.uids.nm-openvpn;

     

       411
       +
               extraGroups = [ "networkmanager" ];

     

       412
       +
             };

     

       413
       +
             nm-iodine = {

     

       414
       +
               isSystemUser = true;

     

       415
       +
               group = "networkmanager";

     

       416
       +
             };

     

       417
       +
           };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       418
        
       

     

       419
        
           systemd.packages = cfg.packages;

     

       420

+2 -3

nixos/modules/services/networking/nntp-proxy.nix

···

       210
        
       

     

       211
        
         config = mkIf cfg.enable {

     

       212
        
       

     

       213
       -
           users.users = singleton

     

       214
       -
             { name = proxyUser;

     

       215
       -
               uid = config.ids.uids.nntp-proxy;

     

       216
        
               description = "NNTP-Proxy daemon user";

     

       217
        
             };

     

       218

···

       210
        
       

     

       211
        
         config = mkIf cfg.enable {

     

       212
        
       

     

       213
       +
           users.users.${proxyUser} =

     

       214
       +
             { uid = config.ids.uids.nntp-proxy;

     

       0
        
       
     

       215
        
               description = "NNTP-Proxy daemon user";

     

       216
        
             };

     

       217

+2 -6

nixos/modules/services/networking/nsd.nix

···

       899
        
       

     

       900
        
           environment.systemPackages = [ nsdPkg ];

     

       901
        
       

     

       902
       -
           users.groups = singleton {

     

       903
       -
             name = username;

     

       904
       -
             gid = config.ids.gids.nsd;

     

       905
       -
           };

     

       906
        
       

     

       907
       -
           users.users = singleton {

     

       908
       -
             name = username;

     

       909
        
             description = "NSD service user";

     

       910
        
             home = stateDir;

     

       911
        
             createHome  = true;

···

       899
        
       

     

       900
        
           environment.systemPackages = [ nsdPkg ];

     

       901
        
       

     

       902
       +
           users.groups.${username}.gid = config.ids.gids.nsd;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       903
        
       

     

       904
       +
           users.users.${username} = {

     

       0
        
       
     

       905
        
             description = "NSD service user";

     

       906
        
             home = stateDir;

     

       907
        
             createHome  = true;

+3 -7

nixos/modules/services/networking/ntp/chrony.nix

···

       79
        
       

     

       80
        
           environment.systemPackages = [ pkgs.chrony ];

     

       81
        
       

     

       82
       -
           users.groups = singleton

     

       83
       -
             { name = "chrony";

     

       84
       -
               gid = config.ids.gids.chrony;

     

       85
       -
             };

     

       86
        
       

     

       87
       -
           users.users = singleton

     

       88
       -
             { name = "chrony";

     

       89
       -
               uid = config.ids.uids.chrony;

     

       90
        
               group = "chrony";

     

       91
        
               description = "chrony daemon user";

     

       92
        
               home = stateDir;

···

       79
        
       

     

       80
        
           environment.systemPackages = [ pkgs.chrony ];

     

       81
        
       

     

       82
       +
           users.groups.chrony.gid = config.ids.gids.chrony;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       83
        
       

     

       84
       +
           users.users.chrony =

     

       85
       +
             { uid = config.ids.uids.chrony;

     

       0
        
       
     

       86
        
               group = "chrony";

     

       87
        
               description = "chrony daemon user";

     

       88
        
               home = stateDir;

+2 -3

nixos/modules/services/networking/ntp/ntpd.nix

···

       104
        
       

     

       105
        
           systemd.services.systemd-timedated.environment = { SYSTEMD_TIMEDATED_NTP_SERVICES = "ntpd.service"; };

     

       106
        
       

     

       107
       -
           users.users = singleton

     

       108
       -
             { name = ntpUser;

     

       109
       -
               uid = config.ids.uids.ntp;

     

       110
        
               description = "NTP daemon user";

     

       111
        
               home = stateDir;

     

       112
        
             };

···

       104
        
       

     

       105
        
           systemd.services.systemd-timedated.environment = { SYSTEMD_TIMEDATED_NTP_SERVICES = "ntpd.service"; };

     

       106
        
       

     

       107
       +
           users.users.${ntpUser} =

     

       108
       +
             { uid = config.ids.uids.ntp;

     

       0
        
       
     

       109
        
               description = "NTP daemon user";

     

       110
        
               home = stateDir;

     

       111
        
             };

+1 -2

nixos/modules/services/networking/ntp/openntpd.nix

···

       60
        
       

     

       61
        
           environment.etc."ntpd.conf".text = configFile;

     

       62
        
       

     

       63
       -
           users.users = singleton {

     

       64
       -
             name = "ntp";

     

       65
        
             uid = config.ids.uids.ntp;

     

       66
        
             description = "OpenNTP daemon user";

     

       67
        
             home = "/var/empty";

···

       60
        
       

     

       61
        
           environment.etc."ntpd.conf".text = configFile;

     

       62
        
       

     

       63
       +
           users.users.ntp = {

     

       0
        
       
     

       64
        
             uid = config.ids.uids.ntp;

     

       65
        
             description = "OpenNTP daemon user";

     

       66
        
             home = "/var/empty";

+2 -5

nixos/modules/services/networking/owamp.nix

···

       17
        
         ###### implementation

     

       18
        
       

     

       19
        
         config = mkIf cfg.enable {

     

       20
       -
           users.users = singleton {

     

       21
       -
             name = "owamp";

     

       22
        
             group = "owamp";

     

       23
        
             description = "Owamp daemon";

     

       24
        
             isSystemUser = true;

     

       25
        
           };

     

       26
        
       

     

       27
       -
           users.groups = singleton {

     

       28
       -
             name = "owamp";

     

       29
       -
           };

     

       30
        
       

     

       31
        
           systemd.services.owamp = {

     

       32
        
             description = "Owamp server";

···

       17
        
         ###### implementation

     

       18
        
       

     

       19
        
         config = mkIf cfg.enable {

     

       20
       +
           users.users.owamp = {

     

       0
        
       
     

       21
        
             group = "owamp";

     

       22
        
             description = "Owamp daemon";

     

       23
        
             isSystemUser = true;

     

       24
        
           };

     

       25
        
       

     

       26
       +
           users.groups.owamp = { };

     

       0
        
       
     

       0
        
       
     

       27
        
       

     

       28
        
           systemd.services.owamp = {

     

       29
        
             description = "Owamp server";

+2 -4

nixos/modules/services/networking/pdnsd.nix

···

       62
        
           };

     

       63
        
       

     

       64
        
         config = mkIf cfg.enable {

     

       65
       -
           users.users = singleton {

     

       66
       -
             name = pdnsdUser;

     

       67
        
             uid = config.ids.uids.pdnsd;

     

       68
        
             group = pdnsdGroup;

     

       69
        
             description = "pdnsd user";

     

       70
        
           };

     

       71
        
       

     

       72
       -
           users.groups = singleton {

     

       73
       -
             name = pdnsdGroup;

     

       74
        
             gid = config.ids.gids.pdnsd;

     

       75
        
           };

     

       76

···

       62
        
           };

     

       63
        
       

     

       64
        
         config = mkIf cfg.enable {

     

       65
       +
           users.users.${pdnsdUser} = {

     

       0
        
       
     

       66
        
             uid = config.ids.uids.pdnsd;

     

       67
        
             group = pdnsdGroup;

     

       68
        
             description = "pdnsd user";

     

       69
        
           };

     

       70
        
       

     

       71
       +
           users.groups.${pdnsdGroup} = {

     

       0
        
       
     

       72
        
             gid = config.ids.gids.pdnsd;

     

       73
        
           };

     

       74

+4 -6

nixos/modules/services/networking/polipo.nix

···

       85
        
       

     

       86
        
         config = mkIf cfg.enable {

     

       87
        
       

     

       88
       -
           users.users = singleton

     

       89
       -
             { name = "polipo";

     

       90
       -
               uid = config.ids.uids.polipo;

     

       91
        
               description = "Polipo caching proxy user";

     

       92
        
               home = "/var/cache/polipo";

     

       93
        
               createHome = true;

     

       94
        
             };

     

       95
        
       

     

       96
       -
           users.groups = singleton

     

       97
       -
             { name = "polipo";

     

       98
       -
               gid = config.ids.gids.polipo;

     

       99
        
               members = [ "polipo" ];

     

       100
        
             };

     

       101

···

       85
        
       

     

       86
        
         config = mkIf cfg.enable {

     

       87
        
       

     

       88
       +
           users.users.polipo =

     

       89
       +
             { uid = config.ids.uids.polipo;

     

       0
        
       
     

       90
        
               description = "Polipo caching proxy user";

     

       91
        
               home = "/var/cache/polipo";

     

       92
        
               createHome = true;

     

       93
        
             };

     

       94
        
       

     

       95
       +
           users.groups.polipo =

     

       96
       +
             { gid = config.ids.gids.polipo;

     

       0
        
       
     

       97
        
               members = [ "polipo" ];

     

       98
        
             };

     

       99

+6 -4

nixos/modules/services/networking/pppd.nix

···

       64
        
           enabledConfigs = filter (f: f.enable) (attrValues cfg.peers);

     

       65
        
       

     

       66
        
           mkEtc = peerCfg: {

     

       67
       -
             "ppp/peers/${peerCfg.name}".text = peerCfg.config;

     

       0
        
       
     

       68
        
           };

     

       69
        
       

     

       70
        
           mkSystemd = peerCfg: {

     

       71
       -
             "pppd-${peerCfg.name}" = {

     

       0
        
       
     

       72
        
               restartTriggers = [ config.environment.etc."ppp/peers/${peerCfg.name}".source ];

     

       73
        
               before = [ "network.target" ];

     

       74
        
               wants = [ "network.target" ];

     
···

       124
        
             };

     

       125
        
           };

     

       126
        
       

     

       127
       -
           etcFiles = map mkEtc enabledConfigs;

     

       128
       -
           systemdConfigs = map mkSystemd enabledConfigs;

     

       129
        
       

     

       130
        
         in mkIf cfg.enable {

     

       131
        
           environment.etc = mkMerge etcFiles;

···

       64
        
           enabledConfigs = filter (f: f.enable) (attrValues cfg.peers);

     

       65
        
       

     

       66
        
           mkEtc = peerCfg: {

     

       67
       +
             name = "ppp/peers/${peerCfg.name}";

     

       68
       +
             value.text = peerCfg.config;

     

       69
        
           };

     

       70
        
       

     

       71
        
           mkSystemd = peerCfg: {

     

       72
       +
             name = "pppd-${peerCfg.name}";

     

       73
       +
             value = {

     

       74
        
               restartTriggers = [ config.environment.etc."ppp/peers/${peerCfg.name}".source ];

     

       75
        
               before = [ "network.target" ];

     

       76
        
               wants = [ "network.target" ];

     
···

       126
        
             };

     

       127
        
           };

     

       128
        
       

     

       129
       +
           etcFiles = listToAttrs (map mkEtc enabledConfigs);

     

       130
       +
           systemdConfigs = listToAttrs (map mkSystemd enabledConfigs);

     

       131
        
       

     

       132
        
         in mkIf cfg.enable {

     

       133
        
           environment.etc = mkMerge etcFiles;

+4 -7

nixos/modules/services/networking/prayer.nix

···

       72
        
         config = mkIf config.services.prayer.enable {

     

       73
        
           environment.systemPackages = [ prayer ];

     

       74
        
       

     

       75
       -
           users.users = singleton

     

       76
       -
             { name = prayerUser;

     

       77
       -
               uid = config.ids.uids.prayer;

     

       78
        
               description = "Prayer daemon user";

     

       79
        
               home = stateDir;

     

       80
        
             };

     

       81
        
       

     

       82
       -
           users.groups = singleton

     

       83
       -
             { name = prayerGroup;

     

       84
       -
               gid = config.ids.gids.prayer;

     

       85
       -
             };

     

       86
        
       

     

       87
        
           systemd.services.prayer = {

     

       88
        
             wantedBy = [ "multi-user.target" ];

···

       72
        
         config = mkIf config.services.prayer.enable {

     

       73
        
           environment.systemPackages = [ prayer ];

     

       74
        
       

     

       75
       +
           users.users.${prayerUser} =

     

       76
       +
             { uid = config.ids.uids.prayer;

     

       0
        
       
     

       77
        
               description = "Prayer daemon user";

     

       78
        
               home = stateDir;

     

       79
        
             };

     

       80
        
       

     

       81
       +
           users.groups.${prayerGroup} =

     

       82
       +
             { gid = config.ids.gids.prayer; };

     

       0
        
       
     

       0
        
       
     

       83
        
       

     

       84
        
           systemd.services.prayer = {

     

       85
        
             wantedBy = [ "multi-user.target" ];

+4 -7

nixos/modules/services/networking/radicale.nix

···

       59
        
         config = mkIf cfg.enable {

     

       60
        
           environment.systemPackages = [ cfg.package ];

     

       61
        
       

     

       62
       -
           users.users = singleton

     

       63
       -
             { name = "radicale";

     

       64
       -
               uid = config.ids.uids.radicale;

     

       65
        
               description = "radicale user";

     

       66
        
               home = "/var/lib/radicale";

     

       67
        
               createHome = true;

     

       68
        
             };

     

       69
        
       

     

       70
       -
           users.groups = singleton

     

       71
       -
             { name = "radicale";

     

       72
       -
               gid = config.ids.gids.radicale;

     

       73
       -
             };

     

       74
        
       

     

       75
        
           systemd.services.radicale = {

     

       76
        
             description = "A Simple Calendar and Contact Server";

···

       59
        
         config = mkIf cfg.enable {

     

       60
        
           environment.systemPackages = [ cfg.package ];

     

       61
        
       

     

       62
       +
           users.users.radicale =

     

       63
       +
             { uid = config.ids.uids.radicale;

     

       0
        
       
     

       64
        
               description = "radicale user";

     

       65
        
               home = "/var/lib/radicale";

     

       66
        
               createHome = true;

     

       67
        
             };

     

       68
        
       

     

       69
       +
           users.groups.radicale =

     

       70
       +
             { gid = config.ids.gids.radicale; };

     

       0
        
       
     

       0
        
       
     

       71
        
       

     

       72
        
           systemd.services.radicale = {

     

       73
        
             description = "A Simple Calendar and Contact Server";

+2 -3

nixos/modules/services/networking/shairport-sync.nix

···

       55
        
           services.avahi.publish.enable = true;

     

       56
        
           services.avahi.publish.userServices = true;

     

       57
        
       

     

       58
       -
           users.users = singleton

     

       59
       -
             { name = cfg.user;

     

       60
       -
               description = "Shairport user";

     

       61
        
               isSystemUser = true;

     

       62
        
               createHome = true;

     

       63
        
               home = "/var/lib/shairport-sync";

···

       55
        
           services.avahi.publish.enable = true;

     

       56
        
           services.avahi.publish.userServices = true;

     

       57
        
       

     

       58
       +
           users.users.${cfg.user} =

     

       59
       +
             { description = "Shairport user";

     

       0
        
       
     

       60
        
               isSystemUser = true;

     

       61
        
               createHome = true;

     

       62
        
               home = "/var/lib/shairport-sync";

+1 -2

nixos/modules/services/networking/shout.nix

···

       82
        
         };

     

       83
        
       

     

       84
        
         config = mkIf cfg.enable {

     

       85
       -
           users.users = singleton {

     

       86
       -
             name = "shout";

     

       87
        
             uid = config.ids.uids.shout;

     

       88
        
             description = "Shout daemon user";

     

       89
        
             home = shoutHome;

···

       82
        
         };

     

       83
        
       

     

       84
        
         config = mkIf cfg.enable {

     

       85
       +
           users.users.shout = {

     

       0
        
       
     

       86
        
             uid = config.ids.uids.shout;

     

       87
        
             description = "Shout daemon user";

     

       88
        
             home = shoutHome;

+1 -2

nixos/modules/services/networking/smokeping.nix

···

       280
        
             fping6.source = "${pkgs.fping}/bin/fping6";

     

       281
        
           };

     

       282
        
           environment.systemPackages = [ pkgs.fping ];

     

       283
       -
           users.users = singleton {

     

       284
       -
             name = cfg.user;

     

       285
        
             isNormalUser = false;

     

       286
        
             isSystemUser = true;

     

       287
        
             uid = config.ids.uids.smokeping;

···

       280
        
             fping6.source = "${pkgs.fping}/bin/fping6";

     

       281
        
           };

     

       282
        
           environment.systemPackages = [ pkgs.fping ];

     

       283
       +
           users.users.${cfg.user} = {

     

       0
        
       
     

       284
        
             isNormalUser = false;

     

       285
        
             isSystemUser = true;

     

       286
        
             uid = config.ids.uids.smokeping;

+1 -3

nixos/modules/services/networking/supybot.nix

···

       45
        
       

     

       46
        
           environment.systemPackages = [ pkgs.pythonPackages.limnoria ];

     

       47
        
       

     

       48
       -
           users.users = singleton {

     

       49
       -
             name = "supybot";

     

       50
        
             uid = config.ids.uids.supybot;

     

       51
        
             group = "supybot";

     

       52
        
             description = "Supybot IRC bot user";

     
···

       55
        
           };

     

       56
        
       

     

       57
        
           users.groups.supybot = {

     

       58
       -
             name = "supybot";

     

       59
        
             gid = config.ids.gids.supybot;

     

       60
        
           };

     

       61

···

       45
        
       

     

       46
        
           environment.systemPackages = [ pkgs.pythonPackages.limnoria ];

     

       47
        
       

     

       48
       +
           users.users.supybotrs = {

     

       0
        
       
     

       49
        
             uid = config.ids.uids.supybot;

     

       50
        
             group = "supybot";

     

       51
        
             description = "Supybot IRC bot user";

     
···

       54
        
           };

     

       55
        
       

     

       56
        
           users.groups.supybot = {

     

       0
        
       
     

       57
        
             gid = config.ids.gids.supybot;

     

       58
        
           };

     

       59

+1 -2

nixos/modules/services/networking/tcpcrypt.nix

···

       29
        
       

     

       30
        
         config = mkIf cfg.enable {

     

       31
        
       

     

       32
       -
           users.users = singleton {

     

       33
       -
             name = "tcpcryptd";

     

       34
        
             uid = config.ids.uids.tcpcryptd;

     

       35
        
             description = "tcpcrypt daemon user";

     

       36
        
           };

···

       29
        
       

     

       30
        
         config = mkIf cfg.enable {

     

       31
        
       

     

       32
       +
           users.users.tcpcryptd = {

     

       0
        
       
     

       33
        
             uid = config.ids.uids.tcpcryptd;

     

       34
        
             description = "tcpcrypt daemon user";

     

       35
        
           };

+2 -3

nixos/modules/services/networking/tox-bootstrapd.nix

···

       56
        
       

     

       57
        
         config = mkIf config.services.toxBootstrapd.enable {

     

       58
        
       

     

       59
       -
           users.users = singleton

     

       60
       -
             { name = "tox-bootstrapd";

     

       61
       -
               uid = config.ids.uids.tox-bootstrapd;

     

       62
        
               description = "Tox bootstrap daemon user";

     

       63
        
               inherit home;

     

       64
        
               createHome = true;

···

       56
        
       

     

       57
        
         config = mkIf config.services.toxBootstrapd.enable {

     

       58
        
       

     

       59
       +
           users.users.tox-bootstrapd =

     

       60
       +
             { uid = config.ids.uids.tox-bootstrapd;

     

       0
        
       
     

       61
        
               description = "Tox bootstrap daemon user";

     

       62
        
               inherit home;

     

       63
        
               createHome = true;

+11 -10

nixos/modules/services/networking/vsftpd.nix

···

       279
        
               message = "vsftpd: If enableVirtualUsers is true, you need to setup both the userDbPath and localUsers options.";

     

       280
        
             }];

     

       281
        
       

     

       282
       -
           users.users =

     

       283
       -
             [ { name = "vsftpd";

     

       284
       -
                 uid = config.ids.uids.vsftpd;

     

       285
       -
                 description = "VSFTPD user";

     

       286
       -
                 home = if cfg.localRoot != null

     

       287
       -
                          then cfg.localRoot # <= Necessary for virtual users.

     

       288
       -
                          else "/homeless-shelter";

     

       289
       -
               }

     

       290
       -
             ] ++ optional cfg.anonymousUser

     

       291
       -
               { name = "ftp";

     

       292
        
                 uid = config.ids.uids.ftp;

     

       293
        
                 group = "ftp";

     

       294
        
                 description = "Anonymous FTP user";

     

       295
        
                 home = cfg.anonymousUserHome;

     

       296
        
               };

     

       0
        
       
     

       297
        
       

     

       298
        
           users.groups.ftp.gid = config.ids.gids.ftp;

     

       299

···

       279
        
               message = "vsftpd: If enableVirtualUsers is true, you need to setup both the userDbPath and localUsers options.";

     

       280
        
             }];

     

       281
        
       

     

       282
       +
           users.users = {

     

       283
       +
             "vsftpd" = {

     

       284
       +
               uid = config.ids.uids.vsftpd;

     

       285
       +
               description = "VSFTPD user";

     

       286
       +
               home = if cfg.localRoot != null

     

       287
       +
                      then cfg.localRoot # <= Necessary for virtual users.

     

       288
       +
                      else "/homeless-shelter";

     

       289
       +
             };

     

       290
       +
           } // optionalAttrs cfg.anonymousUser {

     

       291
       +
             "ftp" = { name = "ftp";

     

       292
        
                 uid = config.ids.uids.ftp;

     

       293
        
                 group = "ftp";

     

       294
        
                 description = "Anonymous FTP user";

     

       295
        
                 home = cfg.anonymousUserHome;

     

       296
        
               };

     

       297
       +
           };

     

       298
        
       

     

       299
        
           users.groups.ftp.gid = config.ids.gids.ftp;

     

       300

+14 -12

nixos/modules/services/networking/znc/default.nix

···

       287
        
             '';

     

       288
        
           };

     

       289
        
       

     

       290
       -
           users.users = optional (cfg.user == defaultUser)

     

       291
       -
             { name = defaultUser;

     

       292
       -
               description = "ZNC server daemon owner";

     

       293
       -
               group = defaultUser;

     

       294
       -
               uid = config.ids.uids.znc;

     

       295
       -
               home = cfg.dataDir;

     

       296
       -
               createHome = true;

     

       0
        
       
     

       297
        
             };

     

       298
        
       

     

       299
       -
           users.groups = optional (cfg.user == defaultUser)

     

       300
       -
             { name = defaultUser;

     

       301
       -
               gid = config.ids.gids.znc;

     

       302
       -
               members = [ defaultUser ];

     

       303
       -
             };

     

       0
        
       
     

       304
        
       

     

       305
        
         };

     

       306
        
       }

···

       287
        
             '';

     

       288
        
           };

     

       289
        
       

     

       290
       +
           users.users = optionalAttrs (cfg.user == defaultUser) {

     

       291
       +
             ${defaultUser} =

     

       292
       +
               { description = "ZNC server daemon owner";

     

       293
       +
                 group = defaultUser;

     

       294
       +
                 uid = config.ids.uids.znc;

     

       295
       +
                 home = cfg.dataDir;

     

       296
       +
                 createHome = true;

     

       297
       +
               };

     

       298
        
             };

     

       299
        
       

     

       300
       +
           users.groups = optionalAttrs (cfg.user == defaultUser) {

     

       301
       +
             ${defaultUser} =

     

       302
       +
               { gid = config.ids.gids.znc;

     

       303
       +
                 members = [ defaultUser ];

     

       304
       +
               };

     

       305
       +
           };

     

       306
        
       

     

       307
        
         };

     

       308
        
       }

+2 -3

nixos/modules/services/printing/cupsd.nix

···

       288
        
       

     

       289
        
         config = mkIf config.services.printing.enable {

     

       290
        
       

     

       291
       -
           users.users = singleton

     

       292
       -
             { name = "cups";

     

       293
       -
               uid = config.ids.uids.cups;

     

       294
        
               group = "lp";

     

       295
        
               description = "CUPS printing services";

     

       296
        
             };

···

       288
        
       

     

       289
        
         config = mkIf config.services.printing.enable {

     

       290
        
       

     

       291
       +
           users.users.cups =

     

       292
       +
             { uid = config.ids.uids.cups;

     

       0
        
       
     

       293
        
               group = "lp";

     

       294
        
               description = "CUPS printing services";

     

       295
        
             };

+3 -7

nixos/modules/services/scheduling/atd.nix

···

       57
        
       

     

       58
        
           security.pam.services.atd = {};

     

       59
        
       

     

       60
       -
           users.users = singleton

     

       61
       -
             { name = "atd";

     

       62
       -
               uid = config.ids.uids.atd;

     

       63
        
               description = "atd user";

     

       64
        
               home = "/var/empty";

     

       65
        
             };

     

       66
        
       

     

       67
       -
           users.groups = singleton

     

       68
       -
             { name = "atd";

     

       69
       -
               gid = config.ids.gids.atd;

     

       70
       -
             };

     

       71
        
       

     

       72
        
           systemd.services.atd = {

     

       73
        
             description = "Job Execution Daemon (atd)";

···

       57
        
       

     

       58
        
           security.pam.services.atd = {};

     

       59
        
       

     

       60
       +
           users.users.atd =

     

       61
       +
             { uid = config.ids.uids.atd;

     

       0
        
       
     

       62
        
               description = "atd user";

     

       63
        
               home = "/var/empty";

     

       64
        
             };

     

       65
        
       

     

       66
       +
           users.groups.atd.gid = config.ids.gids.atd;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       67
        
       

     

       68
        
           systemd.services.atd = {

     

       69
        
             description = "Job Execution Daemon (atd)";

+3 -2

nixos/modules/services/scheduling/fcron.nix

···

       86
        
       

     

       87
        
           services.fcron.systab = systemCronJobs;

     

       88
        
       

     

       89
       -
           environment.etc =

     

       0
        
       
     

       90
        
             [ (allowdeny "allow" (cfg.allow))

     

       91
        
               (allowdeny "deny" cfg.deny)

     

       92
        
               # see man 5 fcron.conf

     
···

       112
        
                 gid = config.ids.gids.fcron;

     

       113
        
                 mode = "0644";

     

       114
        
               }

     

       115
       -
             ];

     

       116
        
       

     

       117
        
           environment.systemPackages = [ pkgs.fcron ];

     

       118
        
           users.users.fcron = {

···

       86
        
       

     

       87
        
           services.fcron.systab = systemCronJobs;

     

       88
        
       

     

       89
       +
           environment.etc = listToAttrs

     

       90
       +
             (map (x: { name = x.target; value = x; })

     

       91
        
             [ (allowdeny "allow" (cfg.allow))

     

       92
        
               (allowdeny "deny" cfg.deny)

     

       93
        
               # see man 5 fcron.conf

     
···

       113
        
                 gid = config.ids.gids.fcron;

     

       114
        
                 mode = "0644";

     

       115
        
               }

     

       116
       +
             ]);

     

       117
        
       

     

       118
        
           environment.systemPackages = [ pkgs.fcron ];

     

       119
        
           users.users.fcron = {

+11 -11

nixos/modules/services/search/hound.nix

···

       88
        
         };

     

       89
        
       

     

       90
        
         config = mkIf cfg.enable {

     

       91
       -
           users.groups = optional (cfg.group == "hound") {

     

       92
       -
             name = "hound";

     

       93
       -
             gid = config.ids.gids.hound;

     

       94
        
           };

     

       95
        
       

     

       96
       -
           users.users = optional (cfg.user == "hound") {

     

       97
       -
             name = "hound";

     

       98
       -
             description = "hound code search";

     

       99
       -
             createHome = true;

     

       100
       -
             home = cfg.home;

     

       101
       -
             group = cfg.group;

     

       102
       -
             extraGroups = cfg.extraGroups;

     

       103
       -
             uid = config.ids.uids.hound;

     

       0
        
       
     

       104
        
           };

     

       105
        
       

     

       106
        
           systemd.services.hound = {

···

       88
        
         };

     

       89
        
       

     

       90
        
         config = mkIf cfg.enable {

     

       91
       +
           users.groups = optionalAttrs (cfg.group == "hound") {

     

       92
       +
             hound.gid = config.ids.gids.hound;

     

       0
        
       
     

       93
        
           };

     

       94
        
       

     

       95
       +
           users.users = optionalAttrs (cfg.user == "hound") {

     

       96
       +
             hound = {

     

       97
       +
               description = "hound code search";

     

       98
       +
               createHome = true;

     

       99
       +
               home = cfg.home;

     

       100
       +
               group = cfg.group;

     

       101
       +
               extraGroups = cfg.extraGroups;

     

       102
       +
               uid = config.ids.uids.hound;

     

       103
       +
             };

     

       104
        
           };

     

       105
        
       

     

       106
        
           systemd.services.hound = {

+1 -2

nixos/modules/services/search/kibana.nix

···

       198
        
       

     

       199
        
           environment.systemPackages = [ cfg.package ];

     

       200
        
       

     

       201
       -
           users.users = singleton {

     

       202
       -
             name = "kibana";

     

       203
        
             uid = config.ids.uids.kibana;

     

       204
        
             description = "Kibana service user";

     

       205
        
             home = cfg.dataDir;

···

       198
        
       

     

       199
        
           environment.systemPackages = [ cfg.package ];

     

       200
        
       

     

       201
       +
           users.users.kibana = {

     

       0
        
       
     

       202
        
             uid = config.ids.uids.kibana;

     

       203
        
             description = "Kibana service user";

     

       204
        
             home = cfg.dataDir;

+7 -7

nixos/modules/services/search/solr.nix

···

       100
        
             };

     

       101
        
           };

     

       102
        
       

     

       103
       -
           users.users = optionalAttrs (cfg.user == "solr") (singleton

     

       104
       -
             { name = "solr";

     

       105
        
               group = cfg.group;

     

       106
        
               home = cfg.stateDir;

     

       107
        
               createHome = true;

     

       108
        
               uid = config.ids.uids.solr;

     

       109
       -
             });

     

       0
        
       
     

       110
        
       

     

       111
       -
           users.groups = optionalAttrs (cfg.group == "solr") (singleton

     

       112
       -
             { name = "solr";

     

       113
       -
               gid = config.ids.gids.solr;

     

       114
       -
             });

     

       115
        
       

     

       116
        
         };

     

       117

···

       100
        
             };

     

       101
        
           };

     

       102
        
       

     

       103
       +
           users.users = optionalAttrs (cfg.user == "solr") {

     

       104
       +
             solr = {

     

       105
        
               group = cfg.group;

     

       106
        
               home = cfg.stateDir;

     

       107
        
               createHome = true;

     

       108
        
               uid = config.ids.uids.solr;

     

       109
       +
             };

     

       110
       +
           };

     

       111
        
       

     

       112
       +
           users.groups = optionalAttrs (cfg.group == "solr") {

     

       113
       +
             solr.gid = config.ids.gids.solr;

     

       114
       +
           };

     

       0
        
       
     

       115
        
       

     

       116
        
         };

     

       117

+3 -6

nixos/modules/services/security/clamav.nix

···

       83
        
         config = mkIf (cfg.updater.enable || cfg.daemon.enable) {

     

       84
        
           environment.systemPackages = [ pkg ];

     

       85
        
       

     

       86
       -
           users.users = singleton {

     

       87
       -
             name = clamavUser;

     

       88
        
             uid = config.ids.uids.clamav;

     

       89
        
             group = clamavGroup;

     

       90
        
             description = "ClamAV daemon user";

     

       91
        
             home = stateDir;

     

       92
        
           };

     

       93
        
       

     

       94
       -
           users.groups = singleton {

     

       95
       -
             name = clamavGroup;

     

       96
       -
             gid = config.ids.gids.clamav;

     

       97
       -
           };

     

       98
        
       

     

       99
        
           environment.etc."clamav/freshclam.conf".source = freshclamConfigFile;

     

       100
        
           environment.etc."clamav/clamd.conf".source = clamdConfigFile;

···

       83
        
         config = mkIf (cfg.updater.enable || cfg.daemon.enable) {

     

       84
        
           environment.systemPackages = [ pkg ];

     

       85
        
       

     

       86
       +
           users.users.${clamavUser} = {

     

       0
        
       
     

       87
        
             uid = config.ids.uids.clamav;

     

       88
        
             group = clamavGroup;

     

       89
        
             description = "ClamAV daemon user";

     

       90
        
             home = stateDir;

     

       91
        
           };

     

       92
        
       

     

       93
       +
           users.groups.${clamavGroup} =

     

       94
       +
             { gid = config.ids.gids.clamav; };

     

       0
        
       
     

       0
        
       
     

       95
        
       

     

       96
        
           environment.etc."clamav/freshclam.conf".source = freshclamConfigFile;

     

       97
        
           environment.etc."clamav/clamd.conf".source = clamdConfigFile;

+5 -9

nixos/modules/services/security/fprot.nix

···

       48
        
           services.fprot.updater.licenseKeyfile = mkDefault "${pkgs.fprot}/opt/f-prot/license.key";

     

       49
        
       

     

       50
        
           environment.systemPackages = [ pkgs.fprot ];

     

       51
       -
           environment.etc = singleton {

     

       52
        
             source = "${pkgs.fprot}/opt/f-prot/f-prot.conf";

     

       53
       -
             target = "f-prot.conf";

     

       54
        
           };

     

       55
        
       

     

       56
       -
           users.users = singleton

     

       57
       -
             { name = fprotUser;

     

       58
       -
               uid = config.ids.uids.fprot;

     

       59
        
               description = "F-Prot daemon user";

     

       60
        
               home = stateDir;

     

       61
        
             };

     

       62
        
       

     

       63
       -
           users.groups = singleton

     

       64
       -
             { name = fprotGroup;

     

       65
       -
               gid = config.ids.gids.fprot;

     

       66
       -
             };

     

       67
        
       

     

       68
        
           services.cron.systemCronJobs = [ "*/${toString cfg.updater.frequency} * * * * root start fprot-updater" ];

     

       69

···

       48
        
           services.fprot.updater.licenseKeyfile = mkDefault "${pkgs.fprot}/opt/f-prot/license.key";

     

       49
        
       

     

       50
        
           environment.systemPackages = [ pkgs.fprot ];

     

       51
       +
           environment.etc."f-prot.conf" = {

     

       52
        
             source = "${pkgs.fprot}/opt/f-prot/f-prot.conf";

     

       0
        
       
     

       53
        
           };

     

       54
        
       

     

       55
       +
           users.users.${fprotUser} =

     

       56
       +
             { uid = config.ids.uids.fprot;

     

       0
        
       
     

       57
        
               description = "F-Prot daemon user";

     

       58
        
               home = stateDir;

     

       59
        
             };

     

       60
        
       

     

       61
       +
           users.groups.${fprotGroup} =

     

       62
       +
             { gid = config.ids.gids.fprot; };

     

       0
        
       
     

       0
        
       
     

       63
        
       

     

       64
        
           services.cron.systemCronJobs = [ "*/${toString cfg.updater.frequency} * * * * root start fprot-updater" ];

     

       65

+4 -5

nixos/modules/services/security/torsocks.nix

···

       112
        
         config = mkIf cfg.enable {

     

       113
        
           environment.systemPackages = [ pkgs.torsocks (wrapTorsocks "torsocks-faster" cfg.fasterServer) ];

     

       114
        
       

     

       115
       -
           environment.etc =

     

       116
       -
             [ { source = pkgs.writeText "torsocks.conf" (configFile cfg.server);

     

       117
       -
                 target = "tor/torsocks.conf";

     

       118
       -
               }

     

       119
       -
             ];

     

       120
        
         };

     

       121
        
       }

···

       112
        
         config = mkIf cfg.enable {

     

       113
        
           environment.systemPackages = [ pkgs.torsocks (wrapTorsocks "torsocks-faster" cfg.fasterServer) ];

     

       114
        
       

     

       115
       +
           environment.etc."tor/torsocks.conf" =

     

       116
       +
             {

     

       117
       +
               source = pkgs.writeText "torsocks.conf" (configFile cfg.server);

     

       118
       +
             };

     

       0
        
       
     

       119
        
         };

     

       120
        
       }

+1 -4

nixos/modules/services/system/dbus.nix

···

       68
        
       

     

       69
        
           environment.systemPackages = [ pkgs.dbus.daemon pkgs.dbus ];

     

       70
        
       

     

       71
       -
           environment.etc = singleton

     

       72
       -
             { source = configDir;

     

       73
       -
               target = "dbus-1";

     

       74
       -
             };

     

       75
        
       

     

       76
        
           users.users.messagebus = {

     

       77
        
             uid = config.ids.uids.messagebus;

···

       68
        
       

     

       69
        
           environment.systemPackages = [ pkgs.dbus.daemon pkgs.dbus ];

     

       70
        
       

     

       71
       +
           environment.etc."dbus-1".source = configDir;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       72
        
       

     

       73
        
           users.users.messagebus = {

     

       74
        
             uid = config.ids.uids.messagebus;

+4

nixos/modules/services/system/localtime.nix

···

       35
        
           # Install the systemd unit.

     

       36
        
           systemd.packages = [ pkgs.localtime.out ];

     

       37
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       38
        
           systemd.services.localtime = {

     

       39
        
             wantedBy = [ "multi-user.target" ];

     

       40
        
             serviceConfig.Restart = "on-failure";

···

       35
        
           # Install the systemd unit.

     

       36
        
           systemd.packages = [ pkgs.localtime.out ];

     

       37
        
       

     

       38
       +
           users.users.localtimed = {

     

       39
       +
             description = "Taskserver user";

     

       40
       +
           };

     

       41
       +
       

     

       42
        
           systemd.services.localtime = {

     

       43
        
             wantedBy = [ "multi-user.target" ];

     

       44
        
             serviceConfig.Restart = "on-failure";

+1 -2

nixos/modules/services/ttys/agetty.nix

···

       102
        
               enable = mkDefault config.boot.isContainer;

     

       103
        
             };

     

       104
        
       

     

       105
       -
           environment.etc = singleton

     

       106
        
             { # Friendly greeting on the virtual consoles.

     

       107
        
               source = pkgs.writeText "issue" ''

     

       108
        
       

     
···

       110
        
                 ${config.services.mingetty.helpLine}

     

       111
        
       

     

       112
        
               '';

     

       113
       -
               target = "issue";

     

       114
        
             };

     

       115
        
       

     

       116
        
         };

···

       102
        
               enable = mkDefault config.boot.isContainer;

     

       103
        
             };

     

       104
        
       

     

       105
       +
           environment.etc.issue =

     

       106
        
             { # Friendly greeting on the virtual consoles.

     

       107
        
               source = pkgs.writeText "issue" ''

     

       108
        
       

     
···

       110
        
                 ${config.services.mingetty.helpLine}

     

       111
        
       

     

       112
        
               '';

     

       0
        
       
     

       113
        
             };

     

       114
        
       

     

       115
        
         };

+4 -6

nixos/modules/services/web-apps/frab.nix

···

       173
        
         config = mkIf cfg.enable {

     

       174
        
           environment.systemPackages = [ frab-rake ];

     

       175
        
       

     

       176
       -
           users.users = [

     

       177
       -
             { name = cfg.user;

     

       178
       -
               group = cfg.group;

     

       179
        
               home = "${cfg.statePath}";

     

       180
        
               isSystemUser = true;

     

       181
       -
             }

     

       182
       -
           ];

     

       183
        
       

     

       184
       -
           users.groups = [ { name = cfg.group; } ];

     

       185
        
       

     

       186
        
           systemd.tmpfiles.rules = [

     

       187
        
             "d '${cfg.statePath}/system/attachments' - ${cfg.user} ${cfg.group} - -"

···

       173
        
         config = mkIf cfg.enable {

     

       174
        
           environment.systemPackages = [ frab-rake ];

     

       175
        
       

     

       176
       +
           users.users.${cfg.user} =

     

       177
       +
             { group = cfg.group;

     

       0
        
       
     

       178
        
               home = "${cfg.statePath}";

     

       179
        
               isSystemUser = true;

     

       180
       +
             };

     

       0
        
       
     

       181
        
       

     

       182
       +
           users.groups.${cfg.group} = { };

     

       183
        
       

     

       184
        
           systemd.tmpfiles.rules = [

     

       185
        
             "d '${cfg.statePath}/system/attachments' - ${cfg.user} ${cfg.group} - -"

+10 -10

nixos/modules/services/web-apps/mattermost.nix

···

       146
        
       

     

       147
        
         config = mkMerge [

     

       148
        
           (mkIf cfg.enable {

     

       149
       -
             users.users = optionalAttrs (cfg.user == "mattermost") (singleton {

     

       150
       -
               name = "mattermost";

     

       151
       -
               group = cfg.group;

     

       152
       -
               uid = config.ids.uids.mattermost;

     

       153
       -
               home = cfg.statePath;

     

       154
       -
             });

     

       0
        
       
     

       155
        
       

     

       156
       -
             users.groups = optionalAttrs (cfg.group == "mattermost") (singleton {

     

       157
       -
               name = "mattermost";

     

       158
       -
               gid = config.ids.gids.mattermost;

     

       159
       -
             });

     

       160
        
       

     

       161
        
             services.postgresql.enable = cfg.localDatabaseCreate;

     

       162

···

       146
        
       

     

       147
        
         config = mkMerge [

     

       148
        
           (mkIf cfg.enable {

     

       149
       +
             users.users = optionalAttrs (cfg.user == "mattermost") {

     

       150
       +
               mattermost = {

     

       151
       +
                 group = cfg.group;

     

       152
       +
                 uid = config.ids.uids.mattermost;

     

       153
       +
                 home = cfg.statePath;

     

       154
       +
               };

     

       155
       +
             };

     

       156
        
       

     

       157
       +
             users.groups = optionalAttrs (cfg.group == "mattermost") {

     

       158
       +
               mattermost.gid = config.ids.gids.mattermost;

     

       159
       +
             };

     

       0
        
       
     

       160
        
       

     

       161
        
             services.postgresql.enable = cfg.localDatabaseCreate;

     

       162

+7 -7

nixos/modules/services/web-servers/apache-httpd/default.nix

···

       606
        
             }

     

       607
        
           ];

     

       608
        
       

     

       609
       -
           users.users = optionalAttrs (mainCfg.user == "wwwrun") (singleton

     

       610
       -
             { name = "wwwrun";

     

       611
        
               group = mainCfg.group;

     

       612
        
               description = "Apache httpd user";

     

       613
        
               uid = config.ids.uids.wwwrun;

     

       614
       -
             });

     

       0
        
       
     

       615
        
       

     

       616
       -
           users.groups = optionalAttrs (mainCfg.group == "wwwrun") (singleton

     

       617
       -
             { name = "wwwrun";

     

       618
       -
               gid = config.ids.gids.wwwrun;

     

       619
       -
             });

     

       620
        
       

     

       621
        
           security.acme.certs = mapAttrs (name: hostOpts: {

     

       622
        
             user = mainCfg.user;

···

       606
        
             }

     

       607
        
           ];

     

       608
        
       

     

       609
       +
           users.users = optionalAttrs (mainCfg.user == "wwwrun") {

     

       610
       +
             wwwrun = {

     

       611
        
               group = mainCfg.group;

     

       612
        
               description = "Apache httpd user";

     

       613
        
               uid = config.ids.uids.wwwrun;

     

       614
       +
             };

     

       615
       +
           };

     

       616
        
       

     

       617
       +
           users.groups = optionalAttrs (mainCfg.group == "wwwrun") {

     

       618
       +
             wwwrun.gid = config.ids.gids.wwwrun;

     

       619
       +
           };

     

       0
        
       
     

       620
        
       

     

       621
        
           security.acme.certs = mapAttrs (name: hostOpts: {

     

       622
        
             user = mainCfg.user;

+8 -7

nixos/modules/services/web-servers/nginx/default.nix

···

       740
        
               listToAttrs acmePairs

     

       741
        
           );

     

       742
        
       

     

       743
       -
           users.users = optionalAttrs (cfg.user == "nginx") (singleton

     

       744
       -
             { name = "nginx";

     

       745
        
               group = cfg.group;

     

       746
        
               uid = config.ids.uids.nginx;

     

       747
       -
             });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       748
        
       

     

       749
       -
           users.groups = optionalAttrs (cfg.group == "nginx") (singleton

     

       750
       -
             { name = "nginx";

     

       751
       -
               gid = config.ids.gids.nginx;

     

       752
       -
             });

     

       753
        
         };

     

       754
        
       }

···

       740
        
               listToAttrs acmePairs

     

       741
        
           );

     

       742
        
       

     

       743
       +
           users.users = optionalAttrs (cfg.user == "nginx") {

     

       744
       +
             nginx = {

     

       745
        
               group = cfg.group;

     

       746
        
               uid = config.ids.uids.nginx;

     

       747
       +
             };

     

       748
       +
           };

     

       749
       +
       

     

       750
       +
           users.groups = optionalAttrs (cfg.group == "nginx") {

     

       751
       +
             nginx.gid = config.ids.gids.nginx;

     

       752
       +
           };

     

       753
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       754
        
         };

     

       755
        
       }

+3 -7

nixos/modules/services/web-servers/tomcat.nix

···

       194
        
       

     

       195
        
         config = mkIf config.services.tomcat.enable {

     

       196
        
       

     

       197
       -
           users.groups = singleton

     

       198
       -
             { name = "tomcat";

     

       199
       -
               gid = config.ids.gids.tomcat;

     

       200
       -
             };

     

       201
        
       

     

       202
       -
           users.users = singleton

     

       203
       -
             { name = "tomcat";

     

       204
       -
               uid = config.ids.uids.tomcat;

     

       205
        
               description = "Tomcat user";

     

       206
        
               home = "/homeless-shelter";

     

       207
        
               extraGroups = cfg.extraGroups;

···

       194
        
       

     

       195
        
         config = mkIf config.services.tomcat.enable {

     

       196
        
       

     

       197
       +
           users.groups.tomcat.gid = config.ids.gids.tomcat;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       198
        
       

     

       199
       +
           users.users.tomcat =

     

       200
       +
             { uid = config.ids.uids.tomcat;

     

       0
        
       
     

       201
        
               description = "Tomcat user";

     

       202
        
               home = "/homeless-shelter";

     

       203
        
               extraGroups = cfg.extraGroups;

+7 -7

nixos/modules/services/web-servers/unit/default.nix

···

       129
        
             };

     

       130
        
           };

     

       131
        
       

     

       132
       -
           users.users = optionalAttrs (cfg.user == "unit") (singleton {

     

       133
       -
             name = "unit";

     

       134
       -
             group = cfg.group;

     

       135
        
             isSystemUser = true;

     

       136
       -
           });

     

       137
        
       

     

       138
       -
           users.groups = optionalAttrs (cfg.group == "unit") (singleton {

     

       139
       -
             name = "unit";

     

       140
       -
           });

     

       0
        
       
     

       141
        
         };

     

       142
        
       }

···

       129
        
             };

     

       130
        
           };

     

       131
        
       

     

       132
       +
           users.users = optionalAttrs (cfg.user == "unit") {

     

       133
       +
             unit.group = cfg.group;

     

       0
        
       
     

       134
        
             isSystemUser = true;

     

       135
       +
           };

     

       136
        
       

     

       137
       +
           users.groups = optionalAttrs (cfg.group == "unit") {

     

       138
       +
             unit = { };

     

       139
       +
           };

     

       140
       +
       

     

       141
        
         };

     

       142
        
       }

+7 -7

nixos/modules/services/web-servers/uwsgi.nix

···

       146
        
             };

     

       147
        
           };

     

       148
        
       

     

       149
       -
           users.users = optionalAttrs (cfg.user == "uwsgi") (singleton

     

       150
       -
             { name = "uwsgi";

     

       151
        
               group = cfg.group;

     

       152
        
               uid = config.ids.uids.uwsgi;

     

       153
       -
             });

     

       0
        
       
     

       154
        
       

     

       155
       -
           users.groups = optionalAttrs (cfg.group == "uwsgi") (singleton

     

       156
       -
             { name = "uwsgi";

     

       157
       -
               gid = config.ids.gids.uwsgi;

     

       158
       -
             });

     

       159
        
         };

     

       160
        
       }

···

       146
        
             };

     

       147
        
           };

     

       148
        
       

     

       149
       +
           users.users = optionalAttrs (cfg.user == "uwsgi") {

     

       150
       +
             uwsgi = {

     

       151
        
               group = cfg.group;

     

       152
        
               uid = config.ids.uids.uwsgi;

     

       153
       +
             };

     

       154
       +
           };

     

       155
        
       

     

       156
       +
           users.groups = optionalAttrs (cfg.group == "uwsgi") {

     

       157
       +
             uwsgi.gid = config.ids.gids.uwsgi;

     

       158
       +
           };

     

       0
        
       
     

       159
        
         };

     

       160
        
       }

+1 -4

nixos/modules/services/x11/desktop-managers/enlightenment.nix

···

       68
        
       

     

       69
        
           security.wrappers = (import "${e.enlightenment}/e-wrappers.nix").security.wrappers;

     

       70
        
       

     

       71
       -
           environment.etc = singleton

     

       72
       -
             { source = xcfg.xkbDir;

     

       73
       -
               target = "X11/xkb";

     

       74
       -
             };

     

       75
        
       

     

       76
        
           fonts.fonts = [ pkgs.dejavu_fonts pkgs.ubuntu_font_family ];

     

       77

···

       68
        
       

     

       69
        
           security.wrappers = (import "${e.enlightenment}/e-wrappers.nix").security.wrappers;

     

       70
        
       

     

       71
       +
           environment.etc."X11/xkb".source = xcfg.xkbDir;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       72
        
       

     

       73
        
           fonts.fonts = [ pkgs.dejavu_fonts pkgs.ubuntu_font_family ];

     

       74

+1 -4

nixos/modules/services/x11/desktop-managers/plasma5.nix

···

       183
        
               "/share"

     

       184
        
             ];

     

       185
        
       

     

       186
       -
             environment.etc = singleton {

     

       187
       -
               source = xcfg.xkbDir;

     

       188
       -
               target = "X11/xkb";

     

       189
       -
             };

     

       190
        
       

     

       191
        
             # Enable GTK applications to load SVG icons

     

       192
        
             services.xserver.gdk-pixbuf.modulePackages = [ pkgs.librsvg ];

···

       183
        
               "/share"

     

       184
        
             ];

     

       185
        
       

     

       186
       +
             environment.etc."X11/xkb".source = xcfg.xkbDir;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       187
        
       

     

       188
        
             # Enable GTK applications to load SVG icons

     

       189
        
             services.xserver.gdk-pixbuf.modulePackages = [ pkgs.librsvg ];

+7 -6

nixos/modules/services/x11/hardware/libinput.nix

···

       198
        
       

     

       199
        
           environment.systemPackages = [ pkgs.xorg.xf86inputlibinput ];

     

       200
        
       

     

       201
       -
           environment.etc = [

     

       202
       -
             (let cfgPath = "X11/xorg.conf.d/40-libinput.conf"; in {

     

       203
       -
               source = pkgs.xorg.xf86inputlibinput.out + "/share/" + cfgPath;

     

       204
       -
               target = cfgPath;

     

       205
       -
             })

     

       206
       -
           ];

     

       0
        
       
     

       207
        
       

     

       208
        
           services.udev.packages = [ pkgs.libinput.out ];

     

       209

···

       198
        
       

     

       199
        
           environment.systemPackages = [ pkgs.xorg.xf86inputlibinput ];

     

       200
        
       

     

       201
       +
           environment.etc =

     

       202
       +
             let cfgPath = "X11/xorg.conf.d/40-libinput.conf";

     

       203
       +
             in {

     

       204
       +
               ${cfgPath} = {

     

       205
       +
                 source = pkgs.xorg.xf86inputlibinput.out + "/share/" + cfgPath;

     

       206
       +
               };

     

       207
       +
             };

     

       208
        
       

     

       209
        
           services.udev.packages = [ pkgs.libinput.out ];

     

       210

+11 -19

nixos/modules/services/x11/xserver.nix

···

       590
        
           ];

     

       591
        
       

     

       592
        
           environment.etc =

     

       593
       -
             (optionals cfg.exportConfiguration

     

       594
       -
               [ { source = "${configFile}";

     

       595
       -
                   target = "X11/xorg.conf";

     

       596
       -
                 }

     

       597
        
                 # -xkbdir command line option does not seems to be passed to xkbcomp.

     

       598
       -
                 { source = "${cfg.xkbDir}";

     

       599
       -
                   target = "X11/xkb";

     

       600
       -
                 }

     

       601
       -
               ])

     

       602
        
             # localectl looks into 00-keyboard.conf

     

       603
       -
             ++ [

     

       604
       -
               {

     

       605
       -
                 text = ''

     

       606
        
                   Section "InputClass"

     

       607
        
                     Identifier "Keyboard catchall"

     

       608
        
                     MatchIsKeyboard "on"

     
···

       612
        
                     Option "XkbVariant" "${cfg.xkbVariant}"

     

       613
        
                   EndSection

     

       614
        
                 '';

     

       615
       -
                 target = "X11/xorg.conf.d/00-keyboard.conf";

     

       616
        
               }

     

       617
       -
             ]

     

       618
        
             # Needed since 1.18; see https://bugs.freedesktop.org/show_bug.cgi?id=89023#c5

     

       619
       -
             ++ (let cfgPath = "/X11/xorg.conf.d/10-evdev.conf"; in

     

       620
       -
               [{

     

       621
       -
                 source = xorg.xf86inputevdev.out + "/share" + cfgPath;

     

       622
       -
                 target = cfgPath;

     

       623
       -
               }]

     

       624
       -
             );

     

       625
        
       

     

       626
        
           environment.systemPackages =

     

       627
        
             [ xorg.xorgserver.out

···

       590
        
           ];

     

       591
        
       

     

       592
        
           environment.etc =

     

       593
       +
             (optionalAttrs cfg.exportConfiguration

     

       594
       +
               {

     

       595
       +
                 "X11/xorg.conf".source = "${configFile}";

     

       0
        
       
     

       596
        
                 # -xkbdir command line option does not seems to be passed to xkbcomp.

     

       597
       +
                 "X11/xkb".source = "${cfg.xkbDir}";

     

       598
       +
               })

     

       0
        
       
     

       0
        
       
     

       599
        
             # localectl looks into 00-keyboard.conf

     

       600
       +
             //{

     

       601
       +
                 "X11/xorg.conf.d/00-keyboard.conf".text = ''

     

       0
        
       
     

       602
        
                   Section "InputClass"

     

       603
        
                     Identifier "Keyboard catchall"

     

       604
        
                     MatchIsKeyboard "on"

     
···

       608
        
                     Option "XkbVariant" "${cfg.xkbVariant}"

     

       609
        
                   EndSection

     

       610
        
                 '';

     

       0
        
       
     

       611
        
               }

     

       0
        
       
     

       612
        
             # Needed since 1.18; see https://bugs.freedesktop.org/show_bug.cgi?id=89023#c5

     

       613
       +
             // (let cfgPath = "/X11/xorg.conf.d/10-evdev.conf"; in

     

       614
       +
               {

     

       615
       +
                 ${cfgPath}.source = xorg.xf86inputevdev.out + "/share" + cfgPath;

     

       616
       +
               });

     

       0
        
       
     

       0
        
       
     

       617
        
       

     

       618
        
           environment.systemPackages =

     

       619
        
             [ xorg.xorgserver.out

+2 -3

nixos/modules/system/boot/kernel.nix

···

       256
        
       

     

       257
        
           # Create /etc/modules-load.d/nixos.conf, which is read by

     

       258
        
           # systemd-modules-load.service to load required kernel modules.

     

       259
       -
           environment.etc = singleton

     

       260
       -
             { target = "modules-load.d/nixos.conf";

     

       261
       -
               source = kernelModulesConf;

     

       262
        
             };

     

       263
        
       

     

       264
        
           systemd.services.systemd-modules-load =

···

       256
        
       

     

       257
        
           # Create /etc/modules-load.d/nixos.conf, which is read by

     

       258
        
           # systemd-modules-load.service to load required kernel modules.

     

       259
       +
           environment.etc =

     

       260
       +
             { "modules-load.d/nixos.conf".source = kernelModulesConf;

     

       0
        
       
     

       261
        
             };

     

       262
        
       

     

       263
        
           systemd.services.systemd-modules-load =

+5 -5

nixos/modules/system/boot/networkd.nix

···

       872
        
               '';

     

       873
        
           };

     

       874
        
       

     

       875
       -
         unitFiles = map (name: {

     

       876
       -
           target = "systemd/network/${name}";

     

       877
       -
           source = "${cfg.units.${name}.unit}/${name}";

     

       878
       -
         }) (attrNames cfg.units);

     

       879
        
       in

     

       880
        
       

     

       881
        
       {

     
···

       938
        
       

     

       939
        
           systemd.services.systemd-networkd = {

     

       940
        
             wantedBy = [ "multi-user.target" ];

     

       941
       -
             restartTriggers = map (f: f.source) (unitFiles);

     

       942
        
             # prevent race condition with interface renaming (#39069)

     

       943
        
             requires = [ "systemd-udev-settle.service" ];

     

       944
        
             after = [ "systemd-udev-settle.service" ];

···

       872
        
               '';

     

       873
        
           };

     

       874
        
       

     

       875
       +
         unitFiles = listToAttrs (map (name: {

     

       876
       +
           name = "systemd/network/${name}";

     

       877
       +
           value.source = "${cfg.units.${name}.unit}/${name}";

     

       878
       +
         }) (attrNames cfg.units));

     

       879
        
       in

     

       880
        
       

     

       881
        
       {

     
···

       938
        
       

     

       939
        
           systemd.services.systemd-networkd = {

     

       940
        
             wantedBy = [ "multi-user.target" ];

     

       941
       +
             restartTriggers = attrNames unitFiles;

     

       942
        
             # prevent race condition with interface renaming (#39069)

     

       943
        
             requires = [ "systemd-udev-settle.service" ];

     

       944
        
             after = [ "systemd-udev-settle.service" ];

+11 -18

nixos/modules/virtualisation/xen-dom0.nix

···

       233
        
       

     

       234
        
       

     

       235
        
           environment.etc =

     

       236
       -
             [ { source = "${cfg.package}/etc/xen/xl.conf";

     

       237
       -
                 target = "xen/xl.conf";

     

       238
       -
               }

     

       239
       -
               { source = "${cfg.package}/etc/xen/scripts";

     

       240
       -
                 target = "xen/scripts";

     

       241
       -
               }

     

       242
       -
               { text = ''

     

       243
       -
                   source ${cfg.package}/etc/default/xendomains

     

       244
        
       

     

       245
       -
                   ${cfg.domains.extraConfig}

     

       246
       -
                 '';

     

       247
       -
                 target = "default/xendomains";

     

       248
       -
               }

     

       249
       -
             ]

     

       250
       -
             ++ lib.optionals (builtins.compareVersions cfg.package.version "4.10" >= 0) [

     

       251
        
               # in V 4.10 oxenstored requires /etc/xen/oxenstored.conf to start

     

       252
       -
               { source = "${cfg.package}/etc/xen/oxenstored.conf";

     

       253
       -
                 target = "xen/oxenstored.conf";

     

       254
       -
               }

     

       255
       -
             ];

     

       256
        
       

     

       257
        
           # Xen provides udev rules.

     

       258
        
           services.udev.packages = [ cfg.package ];

···

       233
        
       

     

       234
        
       

     

       235
        
           environment.etc =

     

       236
       +
             {

     

       237
       +
               "xen/xl.conf".source = "${cfg.package}/etc/xen/xl.conf";

     

       238
       +
               "xen/scripts".source = "${cfg.package}/etc/xen/scripts";

     

       239
       +
               "default/xendomains".text = ''

     

       240
       +
                 source ${cfg.package}/etc/default/xendomains

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       241
        
       

     

       242
       +
                 ${cfg.domains.extraConfig}

     

       243
       +
               '';

     

       244
       +
             }

     

       245
       +
             // optionalAttrs (builtins.compareVersions cfg.package.version "4.10" >= 0) {

     

       0
        
       
     

       0
        
       
     

       246
        
               # in V 4.10 oxenstored requires /etc/xen/oxenstored.conf to start

     

       247
       +
               "xen/oxenstored.conf".source = "${cfg.package}/etc/xen/oxenstored.conf";

     

       248
       +
             };

     

       0
        
       
     

       0
        
       
     

       249
        
       

     

       250
        
           # Xen provides udev rules.

     

       251
        
           services.udev.packages = [ cfg.package ];