commit fff5923686c21dd147bde62d08e9f1042deadb4f · pyrox.dev/nixpkgs

+2 -2

nixos/modules/config/ldap.nix

···

       215
       215
        
           );

     

       216
       216
        
       

     

       217
       217
        
           users = mkIf cfg.daemon.enable {

     

       218
       218
       -
             extraGroups.nslcd = {

     

       218
       218
       +
             groups.nslcd = {

     

       219
       219
        
               gid = config.ids.gids.nslcd;

     

       220
       220
        
             };

     

       221
       221
        
       

     

       222
       222
       -
             extraUsers.nslcd = {

     

       222
       222
       +
             users.nslcd = {

     

       223
       223
        
               uid = config.ids.uids.nslcd;

     

       224
       224
        
               description = "nslcd user.";

     

       225
       225
        
               group = "nslcd";

+2 -2

nixos/modules/config/pulseaudio.nix

···

       264
       264
        
           })

     

       265
       265
        
       

     

       266
       266
        
           (mkIf systemWide {

     

       267
       267
       -
             users.extraUsers.pulse = {

     

       267
       267
       +
             users.users.pulse = {

     

       268
       268
        
               # For some reason, PulseAudio wants UID == GID.

     

       269
       269
        
               uid = assert uid == gid; uid;

     

       270
       270
        
               group = "pulse";

     
···

       274
       274
        
               createHome = true;

     

       275
       275
        
             };

     

       276
       276
        
       

     

       277
       277
       -
             users.extraGroups.pulse.gid = gid;

     

       277
       277
       +
             users.groups.pulse.gid = gid;

     

       278
       278
        
       

     

       279
       279
        
             systemd.services.pulseaudio = {

     

       280
       280
        
               description = "PulseAudio System-Wide Server";

+1 -1

nixos/modules/hardware/nitrokey.nix

···

       36
       36
        
               { inherit (cfg) group; }

     

       37
       37
        
             ))

     

       38
       38
        
           ];

     

       39
       39
       -
           users.extraGroups."${cfg.group}" = {};

     

       39
       39
       +
           users.groups."${cfg.group}" = {};

     

       40
       40
        
         };

     

       41
       41
        
       }

+1 -1

nixos/modules/misc/locate.nix

···

       101
       101
        
         };

     

       102
       102
        
       

     

       103
       103
        
         config = mkIf cfg.enable {

     

       104
       104
       -
           users.extraGroups = mkIf isMLocate { mlocate = {}; };

     

       104
       104
       +
           users.groups = mkIf isMLocate { mlocate = {}; };

     

       105
       105
        
       

     

       106
       106
        
           security.wrappers = mkIf isMLocate {

     

       107
       107
        
             locate = {

+1 -1

nixos/modules/profiles/demo.nix

···

       3
       3
        
       {

     

       4
       4
        
         imports = [ ./graphical.nix ];

     

       5
       5
        
       

     

       6
       6
       -
         users.extraUsers.demo =

     

       6
       6
       +
         users.users.demo =

     

       7
       7
        
           { isNormalUser = true;

     

       8
       8
        
             description = "Demo user account";

     

       9
       9
        
             extraGroups = [ "wheel" ];

+2 -2

nixos/modules/programs/adb.nix

···

       14
       14
        
               description = ''

     

       15
       15
        
                 Whether to configure system to use Android Debug Bridge (adb).

     

       16
       16
        
                 To grant access to a user, it must be part of adbusers group:

     

       17
       17
       -
                 <code>users.extraUsers.alice.extraGroups = ["adbusers"];</code>

     

       17
       17
       +
                 <code>users.users.alice.extraGroups = ["adbusers"];</code>

     

       18
       18
        
               '';

     

       19
       19
        
               relatedPackages = [ ["androidenv" "platformTools"] ];

     

       20
       20
        
             };

     
···

       25
       25
        
         config = mkIf config.programs.adb.enable {

     

       26
       26
        
           services.udev.packages = [ pkgs.android-udev-rules ];

     

       27
       27
        
           environment.systemPackages = [ pkgs.androidenv.platformTools ];

     

       28
       28
       -
           users.extraGroups.adbusers = {};

     

       28
       28
       +
           users.groups.adbusers = {};

     

       29
       29
        
         };

     

       30
       30
        
       }

+2 -2

nixos/modules/programs/gphoto2.nix

···

       15
       15
        
                 Whether to configure system to use gphoto2.

     

       16
       16
        
                 To grant digital camera access to a user, the user must

     

       17
       17
        
                 be part of the camera group:

     

       18
       18
       -
                 <code>users.extraUsers.alice.extraGroups = ["camera"];</code>

     

       18
       18
       +
                 <code>users.users.alice.extraGroups = ["camera"];</code>

     

       19
       19
        
               '';

     

       20
       20
        
             };

     

       21
       21
        
           };

     
···

       25
       25
        
         config = mkIf config.programs.gphoto2.enable {

     

       26
       26
        
           services.udev.packages = [ pkgs.libgphoto2 ];

     

       27
       27
        
           environment.systemPackages = [ pkgs.gphoto2 ];

     

       28
       28
       -
           users.extraGroups.camera = {};

     

       28
       28
       +
           users.groups.camera = {};

     

       29
       29
        
         };

     

       30
       30
        
       }

+1 -1

nixos/modules/programs/sway.nix

···

       73
       73
        
             permissions = "u+rx,g+rx";

     

       74
       74
        
           };

     

       75
       75
        
       

     

       76
       76
       -
           users.extraGroups.sway = {};

     

       76
       76
       +
           users.groups.sway = {};

     

       77
       77
        
           security.pam.services.swaylock = {};

     

       78
       78
        
       

     

       79
       79
        
           hardware.opengl.enable = mkDefault true;

+1 -1

nixos/modules/programs/wireshark.nix

···

       29
       29
        
       

     

       30
       30
        
         config = mkIf cfg.enable {

     

       31
       31
        
           environment.systemPackages = [ wireshark ];

     

       32
       32
       -
           users.extraGroups.wireshark = {};

     

       32
       32
       +
           users.groups.wireshark = {};

     

       33
       33
        
       

     

       34
       34
        
           security.wrappers.dumpcap = {

     

       35
       35
        
             source = "${wireshark}/bin/dumpcap";

+1 -1

nixos/modules/security/pam_mount.nix

···

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

     

       41
       41
        
             source =

     

       42
       42
        
               let

     

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

     

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

     

       44
       44
        
                 userVolumeEntry = user: "<volume user=\"${user.name}\" path=\"${user.cryptHomeLuks}\" mountpoint=\"${user.home}\" />\n";

     

       45
       45
        
               in

     

       46
       46
        
                pkgs.writeText "pam_mount.conf.xml" ''

+1 -1

nixos/modules/security/polkit.nix

···

       94
       94
        
               rm -rf /var/lib/{polkit-1,PolicyKit}

     

       95
       95
        
             '';

     

       96
       96
        
       

     

       97
       97
       -
           users.extraUsers.polkituser = {

     

       97
       97
       +
           users.users.polkituser = {

     

       98
       98
        
             description = "PolKit daemon";

     

       99
       99
        
             uid = config.ids.uids.polkituser;

     

       100
       100
        
           };

+1 -1

nixos/modules/security/rtkit.nix

···

       34
       34
        
       

     

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

     

       36
       36
        
       

     

       37
       37
       -
           users.extraUsers = singleton

     

       37
       37
       +
           users.users = singleton

     

       38
       38
        
             { name = "rtkit";

     

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

     

       40
       40
        
               description = "RealtimeKit daemon";

+2 -2

nixos/modules/services/admin/oxidized.nix

···

       83
       83
        
         };

     

       84
       84
        
       

     

       85
       85
        
         config = mkIf cfg.enable {

     

       86
       86
       -
           users.extraGroups.${cfg.group} = { };

     

       87
       87
       -
           users.extraUsers.${cfg.user} = {

     

       86
       86
       +
           users.groups.${cfg.group} = { };

     

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

     

       88
       88
        
             description = "Oxidized service user";

     

       89
       89
        
             group = cfg.group;

     

       90
       90
        
             home = cfg.dataDir;

+2 -2

nixos/modules/services/amqp/activemq/default.nix

···

       93
       93
        
         };

     

       94
       94
        
       

     

       95
       95
        
         config = mkIf cfg.enable {

     

       96
       96
       -
           users.extraUsers.activemq = {

     

       96
       96
       +
           users.users.activemq = {

     

       97
       97
        
             description = "ActiveMQ server user";

     

       98
       98
        
             group = "activemq";

     

       99
       99
        
             uid = config.ids.uids.activemq;

     

       100
       100
        
           };

     

       101
       101
        
       

     

       102
       102
       -
           users.extraGroups.activemq.gid = config.ids.gids.activemq;

     

       102
       102
       +
           users.groups.activemq.gid = config.ids.gids.activemq;

     

       103
       103
        
       

     

       104
       104
        
           systemd.services.activemq_init = {

     

       105
       105
        
             wantedBy = [ "activemq.service" ];

+2 -2

nixos/modules/services/amqp/rabbitmq.nix

···

       83
       83
        
       

     

       84
       84
        
           environment.systemPackages = [ pkgs.rabbitmq_server ];

     

       85
       85
        
       

     

       86
       86
       -
           users.extraUsers.rabbitmq = {

     

       86
       86
       +
           users.users.rabbitmq = {

     

       87
       87
        
             description = "RabbitMQ server user";

     

       88
       88
        
             home = "${cfg.dataDir}";

     

       89
       89
        
             createHome = true;

     
···

       91
       91
        
             uid = config.ids.uids.rabbitmq;

     

       92
       92
        
           };

     

       93
       93
        
       

     

       94
       94
       -
           users.extraGroups.rabbitmq.gid = config.ids.gids.rabbitmq;

     

       94
       94
       +
           users.groups.rabbitmq.gid = config.ids.gids.rabbitmq;

     

       95
       95
        
       

     

       96
       96
        
           systemd.services.rabbitmq = {

     

       97
       97
        
             description = "RabbitMQ Server";

+2 -2

nixos/modules/services/audio/liquidsoap.nix

···

       57
       57
        
       

     

       58
       58
        
         config = mkIf (builtins.length streams != 0) {

     

       59
       59
        
       

     

       60
       60
       -
           users.extraUsers.liquidsoap = {

     

       60
       60
       +
           users.users.liquidsoap = {

     

       61
       61
        
             uid = config.ids.uids.liquidsoap;

     

       62
       62
        
             group = "liquidsoap";

     

       63
       63
        
             extraGroups = [ "audio" ];

     
···

       66
       66
        
             createHome = true;

     

       67
       67
        
           };

     

       68
       68
        
       

     

       69
       69
       -
           users.extraGroups.liquidsoap.gid = config.ids.gids.liquidsoap;

     

       69
       69
       +
           users.groups.liquidsoap.gid = config.ids.gids.liquidsoap;

     

       70
       70
        
       

     

       71
       71
        
           systemd.services = builtins.listToAttrs ( map streamService streams );

     

       72
       72
        
         };

+2 -2

nixos/modules/services/audio/mopidy.nix

···

       93
       93
        
             };

     

       94
       94
        
           };

     

       95
       95
        
       

     

       96
       96
       -
           users.extraUsers.mopidy = {

     

       96
       96
       +
           users.users.mopidy = {

     

       97
       97
        
             inherit uid;

     

       98
       98
        
             group = "mopidy";

     

       99
       99
        
             extraGroups = [ "audio" ];

     
···

       101
       101
        
             home = "${cfg.dataDir}";

     

       102
       102
        
           };

     

       103
       103
        
       

     

       104
       104
       -
           users.extraGroups.mopidy.gid = gid;

     

       104
       104
       +
           users.groups.mopidy.gid = gid;

     

       105
       105
        
       

     

       106
       106
        
         };

     

       107
       107

+2 -2

nixos/modules/services/audio/mpd.nix

···

       184
       184
        
             };

     

       185
       185
        
           };

     

       186
       186
        
       

     

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

     

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

     

       188
       188
        
             inherit uid;

     

       189
       189
        
             inherit name;

     

       190
       190
        
             group = cfg.group;

     
···

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

     

       194
       194
        
           });

     

       195
       195
        
       

     

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

     

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

     

       197
       197
        
             inherit name;

     

       198
       198
        
             gid = gid;

     

       199
       199
        
           });

+1 -1

nixos/modules/services/audio/squeezelite.nix

···

       54
       54
        
             };

     

       55
       55
        
           };

     

       56
       56
        
       

     

       57
       57
       -
           users.extraUsers.squeezelite= {

     

       57
       57
       +
           users.users.squeezelite= {

     

       58
       58
        
             inherit uid;

     

       59
       59
        
             group = "nogroup";

     

       60
       60
        
             extraGroups = [ "audio" ];

+2 -2

nixos/modules/services/backup/bacula.nix

···

       397
       397
        
       

     

       398
       398
        
           environment.systemPackages = [ pkgs.bacula ];

     

       399
       399
        
       

     

       400
       400
       -
           users.extraUsers.bacula = {

     

       400
       400
       +
           users.users.bacula = {

     

       401
       401
        
             group = "bacula";

     

       402
       402
        
             uid = config.ids.uids.bacula;

     

       403
       403
        
             home = "${libDir}";

     
···

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

     

       407
       407
        
           };

     

       408
       408
        
       

     

       409
       409
       -
           users.extraGroups.bacula.gid = config.ids.gids.bacula;

     

       409
       409
       +
           users.groups.bacula.gid = config.ids.gids.bacula;

     

       410
       410
        
         };

     

       411
       411
        
       }

+2 -2

nixos/modules/services/backup/duplicati.nix

···

       44
       44
        
             };

     

       45
       45
        
           };

     

       46
       46
        
       

     

       47
       47
       -
           users.extraUsers.duplicati = {

     

       47
       47
       +
           users.users.duplicati = {

     

       48
       48
        
             uid = config.ids.uids.duplicati;

     

       49
       49
        
             home = "/var/lib/duplicati";

     

       50
       50
        
             createHome = true;

     

       51
       51
        
             group = "duplicati";

     

       52
       52
        
           };

     

       53
       53
       -
           users.extraGroups.duplicati.gid = config.ids.gids.duplicati;

     

       53
       53
       +
           users.groups.duplicati.gid = config.ids.gids.duplicati;

     

       54
       54
        
       

     

       55
       55
        
         };

     

       56
       56
        
       }

+1 -1

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

···

       84
       84
        
         };

     

       85
       85
        
       

     

       86
       86
        
         config = mkIf cfg.enable {

     

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

     

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

     

       88
       88
        
             { name = defaultUser;

     

       89
       89
        
               isSystemUser = true;

     

       90
       90
        
               createHome = false;

+2 -2

nixos/modules/services/backup/restic-rest-server.nix

···

       95
       95
        
             };

     

       96
       96
        
           };

     

       97
       97
        
       

     

       98
       98
       -
           users.extraUsers.restic = {

     

       98
       98
       +
           users.users.restic = {

     

       99
       99
        
             group = "restic";

     

       100
       100
        
             home = cfg.dataDir;

     

       101
       101
        
             createHome = true;

     

       102
       102
        
             uid = config.ids.uids.restic;

     

       103
       103
        
           };

     

       104
       104
        
       

     

       105
       105
       -
           users.extraGroups.restic.gid = config.ids.uids.restic;

     

       105
       105
       +
           users.groups.restic.gid = config.ids.uids.restic;

     

       106
       106
        
         };

     

       107
       107
        
       }

+2 -2

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

···

       1145
       1145
        
             ];

     

       1146
       1146
        
       

     

       1147
       1147
        
             environment.systemPackages = [ cfg.package ];

     

       1148
       1148
       -
             users.extraUsers = singleton {

     

       1148
       1148
       +
             users.users = singleton {

     

       1149
       1149
        
               name = "kubernetes";

     

       1150
       1150
        
               uid = config.ids.uids.kubernetes;

     

       1151
       1151
        
               description = "Kubernetes user";

     
···

       1154
       1154
        
               home = cfg.dataDir;

     

       1155
       1155
        
               createHome = true;

     

       1156
       1156
        
             };

     

       1157
       1157
       -
             users.extraGroups.kubernetes.gid = config.ids.gids.kubernetes;

     

       1157
       1157
       +
             users.groups.kubernetes.gid = config.ids.gids.kubernetes;

     

       1158
       1158
        
       

     

       1159
       1159
        
       			# dns addon is enabled by default

     

       1160
       1160
        
             services.kubernetes.addons.dns.enable = mkDefault true;

+2 -2

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

···

       191
       191
        
         };

     

       192
       192
        
       

     

       193
       193
        
         config = mkIf cfg.enable {

     

       194
       194
       -
           users.extraGroups = optional (cfg.group == "buildbot") {

     

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

     

       195
       195
        
             name = "buildbot";

     

       196
       196
        
           };

     

       197
       197
        
       

     

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

     

       198
       198
       +
           users.users = optional (cfg.user == "buildbot") {

     

       199
       199
        
             name = "buildbot";

     

       200
       200
        
             description = "Buildbot User.";

     

       201
       201
        
             isNormalUser = true;

+2 -2

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

···

       84
       84
        
         };

     

       85
       85
        
       

     

       86
       86
        
         config = mkIf cfg.enable {

     

       87
       87
       -
           users.extraGroups = optional (cfg.group == "bbworker") {

     

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

     

       88
       88
        
             name = "bbworker";

     

       89
       89
        
           };

     

       90
       90
        
       

     

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

     

       91
       91
       +
           users.users = optional (cfg.user == "bbworker") {

     

       92
       92
        
             name = "bbworker";

     

       93
       93
        
             description = "Buildbot Worker User.";

     

       94
       94
        
             isNormalUser = true;

+1 -1

nixos/modules/services/continuous-integration/buildkite-agent.nix

···

       185
       185
        
         };

     

       186
       186
        
       

     

       187
       187
        
         config = mkIf config.services.buildkite-agent.enable {

     

       188
       188
       -
           users.extraUsers.buildkite-agent =

     

       188
       188
       +
           users.users.buildkite-agent =

     

       189
       189
        
             { name = "buildkite-agent";

     

       190
       190
        
               home = cfg.dataDir;

     

       191
       191
        
               createHome = true;

+2 -2

nixos/modules/services/continuous-integration/gitlab-runner.nix

···

       134
       134
        
           # Make the gitlab-runner command availabe so users can query the runner

     

       135
       135
        
           environment.systemPackages = [ cfg.package ];

     

       136
       136
        
       

     

       137
       137
       -
           users.extraUsers.gitlab-runner = {

     

       137
       137
       +
           users.users.gitlab-runner = {

     

       138
       138
        
             group = "gitlab-runner";

     

       139
       139
        
             extraGroups = optional hasDocker "docker";

     

       140
       140
        
             uid = config.ids.uids.gitlab-runner;

     
···

       142
       142
        
             createHome = true;

     

       143
       143
        
           };

     

       144
       144
        
       

     

       145
       145
       -
           users.extraGroups.gitlab-runner.gid = config.ids.gids.gitlab-runner;

     

       145
       145
       +
           users.groups.gitlab-runner.gid = config.ids.gids.gitlab-runner;

     

       146
       146
        
         };

     

       147
       147
        
       }

+2 -2

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

···

       135
       135
        
         };

     

       136
       136
        
       

     

       137
       137
        
         config = mkIf cfg.enable {

     

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

     

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

     

       139
       139
        
             name = "gocd-agent";

     

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

     

       141
       141
        
           };

     

       142
       142
        
       

     

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

     

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

     

       144
       144
        
             name = "gocd-agent";

     

       145
       145
        
             description = "gocd-agent user";

     

       146
       146
        
             createHome = true;

+4 -4

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

···

       113
       113
        
       

     

       114
       114
        
             extraOptions = mkOption {

     

       115
       115
        
               default = [ ];

     

       116
       116
       -
               example = [ 

     

       117
       117
       -
                 "-X debug" 

     

       116
       116
       +
               example = [

     

       117
       117
       +
                 "-X debug"

     

       118
       118
        
                 "-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005"

     

       119
       119
        
                 "-verbose:gc"

     

       120
       120
        
                 "-Xloggc:go-server-gc.log"

     
···

       143
       143
        
         };

     

       144
       144
        
       

     

       145
       145
        
         config = mkIf cfg.enable {

     

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

     

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

     

       147
       147
        
             name = "gocd-server";

     

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

     

       149
       149
        
           };

     

       150
       150
        
       

     

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

     

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

     

       152
       152
        
             name = "gocd-server";

     

       153
       153
        
             description = "gocd-server user";

     

       154
       154
        
             createHome = true;

+4 -4

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

···

       194
       194
        
       

     

       195
       195
        
         config = mkIf cfg.enable {

     

       196
       196
        
       

     

       197
       197
       -
           users.extraGroups.hydra = {

     

       197
       197
       +
           users.groups.hydra = {

     

       198
       198
        
             gid = config.ids.gids.hydra;

     

       199
       199
        
           };

     

       200
       200
        
       

     

       201
       201
       -
           users.extraUsers.hydra =

     

       201
       201
       +
           users.users.hydra =

     

       202
       202
        
             { description = "Hydra";

     

       203
       203
        
               group = "hydra";

     

       204
       204
        
               createHome = true;

     
···

       207
       207
        
               uid = config.ids.uids.hydra;

     

       208
       208
        
             };

     

       209
       209
        
       

     

       210
       210
       -
           users.extraUsers.hydra-queue-runner =

     

       210
       210
       +
           users.users.hydra-queue-runner =

     

       211
       211
        
             { description = "Hydra queue runner";

     

       212
       212
        
               group = "hydra";

     

       213
       213
        
               useDefaultShell = true;

     
···

       215
       215
        
               uid = config.ids.uids.hydra-queue-runner;

     

       216
       216
        
             };

     

       217
       217
        
       

     

       218
       218
       -
           users.extraUsers.hydra-www =

     

       218
       218
       +
           users.users.hydra-www =

     

       219
       219
        
             { description = "Hydra web server";

     

       220
       220
        
               group = "hydra";

     

       221
       221
        
               useDefaultShell = true;

+2 -2

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

···

       150
       150
        
             pkgs.dejavu_fonts

     

       151
       151
        
           ];

     

       152
       152
        
       

     

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

     

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

     

       154
       154
        
             name = "jenkins";

     

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

     

       156
       156
        
           };

     

       157
       157
        
       

     

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

     

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

     

       159
       159
        
             name = "jenkins";

     

       160
       160
        
             description = "jenkins user";

     

       161
       161
        
             createHome = true;

+2 -2

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

···

       50
       50
        
         };

     

       51
       51
        
       

     

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

     

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

     

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

     

       54
       54
        
             name = "jenkins";

     

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

     

       56
       56
        
           };

     

       57
       57
        
       

     

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

     

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

     

       59
       59
        
             name = "jenkins";

     

       60
       60
        
             description = "jenkins user";

     

       61
       61
        
             createHome = true;

+1 -1

nixos/modules/services/databases/4store-endpoint.nix

···

       52
       52
        
               message = "Must specify 4Store database name";

     

       53
       53
        
             };

     

       54
       54
        
       

     

       55
       55
       -
           users.extraUsers = singleton

     

       55
       55
       +
           users.users = singleton

     

       56
       56
        
             { name = endpointUser;

     

       57
       57
        
               uid = config.ids.uids.fourstorehttp;

     

       58
       58
        
               description = "4Store SPARQL endpoint user";

+1 -1

nixos/modules/services/databases/4store.nix

···

       43
       43
        
               message = "Must specify 4Store database name.";

     

       44
       44
        
             };

     

       45
       45
        
       

     

       46
       46
       -
           users.extraUsers = singleton

     

       46
       46
       +
           users.users = singleton

     

       47
       47
        
             { name = fourStoreUser;

     

       48
       48
        
               uid = config.ids.uids.fourstore;

     

       49
       49
        
               description = "4Store database user";

+1 -1

nixos/modules/services/databases/cassandra.nix

···

       420
       420
        
             9160

     

       421
       421
        
           ];

     

       422
       422
        
       

     

       423
       423
       -
           users.extraUsers.cassandra =

     

       423
       423
       +
           users.users.cassandra =

     

       424
       424
        
             if config.ids.uids ? "cassandra"

     

       425
       425
        
             then { uid = config.ids.uids.cassandra; } // cassandraUser

     

       426
       426
        
             else cassandraUser ;

+2 -2

nixos/modules/services/databases/clickhouse.nix

···

       27
       27
        
       

     

       28
       28
        
         config = mkIf cfg.enable {

     

       29
       29
        
       

     

       30
       30
       -
           users.extraUsers.clickhouse = {

     

       30
       30
       +
           users.users.clickhouse = {

     

       31
       31
        
             name = "clickhouse";

     

       32
       32
        
             uid = config.ids.uids.clickhouse;

     

       33
       33
        
             group = "clickhouse";

     

       34
       34
        
             description = "ClickHouse server user";

     

       35
       35
        
           };

     

       36
       36
        
       

     

       37
       37
       -
           users.extraGroups.clickhouse.gid = config.ids.gids.clickhouse;

     

       37
       37
       +
           users.groups.clickhouse.gid = config.ids.gids.clickhouse;

     

       38
       38
        
       

     

       39
       39
        
           systemd.services.clickhouse = {

     

       40
       40
        
             description = "ClickHouse server";

+2 -2

nixos/modules/services/databases/couchdb.nix

···

       198
       198
        
             };

     

       199
       199
        
           };

     

       200
       200
        
       

     

       201
       201
       -
           users.extraUsers.couchdb = {

     

       201
       201
       +
           users.users.couchdb = {

     

       202
       202
        
             description = "CouchDB Server user";

     

       203
       203
        
             group = "couchdb";

     

       204
       204
        
             uid = config.ids.uids.couchdb;

     

       205
       205
        
           };

     

       206
       206
        
       

     

       207
       207
       -
           users.extraGroups.couchdb.gid = config.ids.gids.couchdb;

     

       207
       207
       +
           users.groups.couchdb.gid = config.ids.gids.couchdb;

     

       208
       208
        
       

     

       209
       209
        
         };

     

       210
       210
        
       }

+2 -2

nixos/modules/services/databases/firebird.nix

···

       154
       154
        
             # there are some additional settings which should be reviewed

     

       155
       155
        
           '';

     

       156
       156
        
       

     

       157
       157
       -
           users.extraUsers.firebird = {

     

       157
       157
       +
           users.users.firebird = {

     

       158
       158
        
             description = "Firebird server user";

     

       159
       159
        
             group = "firebird";

     

       160
       160
        
             uid = config.ids.uids.firebird;

     

       161
       161
        
           };

     

       162
       162
        
       

     

       163
       163
       -
           users.extraGroups.firebird.gid = config.ids.gids.firebird;

     

       163
       163
       +
           users.groups.firebird.gid = config.ids.gids.firebird;

     

       164
       164
        
       

     

       165
       165
        
         };

     

       166
       166
        
       }

+2 -2

nixos/modules/services/databases/foundationdb.nix

···

       325
       325
        
       

     

       326
       326
        
           environment.systemPackages = [ pkg ];

     

       327
       327
        
       

     

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

     

       328
       328
       +
           users.users = optionalAttrs (cfg.user == "foundationdb") (singleton

     

       329
       329
        
             { name        = "foundationdb";

     

       330
       330
        
               description = "FoundationDB User";

     

       331
       331
        
               uid         = config.ids.uids.foundationdb;

     

       332
       332
        
               group       = cfg.group;

     

       333
       333
        
             });

     

       334
       334
        
       

     

       335
       335
       -
           users.extraGroups = optionalAttrs (cfg.group == "foundationdb") (singleton

     

       335
       335
       +
           users.groups = optionalAttrs (cfg.group == "foundationdb") (singleton

     

       336
       336
        
             { name = "foundationdb";

     

       337
       337
        
               gid  = config.ids.gids.foundationdb;

     

       338
       338
        
             });

+2 -2

nixos/modules/services/databases/hbase.nix

···

       122
       122
        
             };

     

       123
       123
        
           };

     

       124
       124
        
       

     

       125
       125
       -
           users.extraUsers.hbase = {

     

       125
       125
       +
           users.users.hbase = {

     

       126
       126
        
             description = "HBase Server user";

     

       127
       127
        
             group = "hbase";

     

       128
       128
        
             uid = config.ids.uids.hbase;

     

       129
       129
        
           };

     

       130
       130
        
       

     

       131
       131
       -
           users.extraGroups.hbase.gid = config.ids.gids.hbase;

     

       131
       131
       +
           users.groups.hbase.gid = config.ids.gids.hbase;

     

       132
       132
        
       

     

       133
       133
        
         };

     

       134
       134
        
       }

+2 -2

nixos/modules/services/databases/influxdb.nix

···

       182
       182
        
               '';

     

       183
       183
        
           };

     

       184
       184
        
       

     

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

     

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

     

       186
       186
        
             name = "influxdb";

     

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

     

       188
       188
        
             description = "Influxdb daemon user";

     

       189
       189
        
           };

     

       190
       190
        
       

     

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

     

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

     

       192
       192
        
             name = "influxdb";

     

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

     

       194
       194
        
           };

+1 -1

nixos/modules/services/databases/memcached.nix

···

       64
       64
        
       

     

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

     

       66
       66
        
       

     

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

     

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

     

       68
       68
        
             name = "memcached";

     

       69
       69
        
             description = "Memcached server user";

     

       70
       70
        
           };

+1 -1

nixos/modules/services/databases/mongodb.nix

···

       93
       93
        
       

     

       94
       94
        
         config = mkIf config.services.mongodb.enable {

     

       95
       95
        
       

     

       96
       96
       -
           users.extraUsers.mongodb = mkIf (cfg.user == "mongodb")

     

       96
       96
       +
           users.users.mongodb = mkIf (cfg.user == "mongodb")

     

       97
       97
        
             { name = "mongodb";

     

       98
       98
        
               uid = config.ids.uids.mongodb;

     

       99
       99
        
               description = "MongoDB server user";

+2 -2

nixos/modules/services/databases/mysql.nix

···

       221
       221
        
             mkDefault (if versionAtLeast config.system.nixos.stateVersion "17.09" then "/var/lib/mysql"

     

       222
       222
        
                        else "/var/mysql");

     

       223
       223
        
       

     

       224
       224
       -
           users.extraUsers.mysql = {

     

       224
       224
       +
           users.users.mysql = {

     

       225
       225
        
             description = "MySQL server user";

     

       226
       226
        
             group = "mysql";

     

       227
       227
        
             uid = config.ids.uids.mysql;

     

       228
       228
        
           };

     

       229
       229
        
       

     

       230
       230
       -
           users.extraGroups.mysql.gid = config.ids.gids.mysql;

     

       230
       230
       +
           users.groups.mysql.gid = config.ids.gids.mysql;

     

       231
       231
        
       

     

       232
       232
        
           environment.systemPackages = [mysql];

     

       233
       233

+1 -1

nixos/modules/services/databases/neo4j.nix

···

       139
       139
        
       

     

       140
       140
        
           environment.systemPackages = [ cfg.package ];

     

       141
       141
        
       

     

       142
       142
       -
           users.extraUsers = singleton {

     

       142
       142
       +
           users.users = singleton {

     

       143
       143
        
             name = "neo4j";

     

       144
       144
        
             uid = config.ids.uids.neo4j;

     

       145
       145
        
             description = "Neo4j daemon user";

+2 -2

nixos/modules/services/databases/openldap.nix

···

       145
       145
        
                 "${configOpts}";

     

       146
       146
        
           };

     

       147
       147
        
       

     

       148
       148
       -
           users.extraUsers.openldap =

     

       148
       148
       +
           users.users.openldap =

     

       149
       149
        
             { name = cfg.user;

     

       150
       150
        
               group = cfg.group;

     

       151
       151
        
               uid = config.ids.uids.openldap;

     

       152
       152
        
             };

     

       153
       153
        
       

     

       154
       154
       -
           users.extraGroups.openldap =

     

       154
       154
       +
           users.groups.openldap =

     

       155
       155
        
             { name = cfg.group;

     

       156
       156
        
               gid = config.ids.gids.openldap;

     

       157
       157
        
             };

+2 -2

nixos/modules/services/databases/opentsdb.nix

···

       97
       97
        
             };

     

       98
       98
        
           };

     

       99
       99
        
       

     

       100
       100
       -
           users.extraUsers.opentsdb = {

     

       100
       100
       +
           users.users.opentsdb = {

     

       101
       101
        
             description = "OpenTSDB Server user";

     

       102
       102
        
             group = "opentsdb";

     

       103
       103
        
             uid = config.ids.uids.opentsdb;

     

       104
       104
        
           };

     

       105
       105
        
       

     

       106
       106
       -
           users.extraGroups.opentsdb.gid = config.ids.gids.opentsdb;

     

       106
       106
       +
           users.groups.opentsdb.gid = config.ids.gids.opentsdb;

     

       107
       107
        
       

     

       108
       108
        
         };

     

       109
       109
        
       }

+2 -2

nixos/modules/services/databases/postgresql.nix

···

       183
       183
        
               host  all all ::1/128      md5

     

       184
       184
        
             '';

     

       185
       185
        
       

     

       186
       186
       -
           users.extraUsers.postgres =

     

       186
       186
       +
           users.users.postgres =

     

       187
       187
        
             { name = "postgres";

     

       188
       188
        
               uid = config.ids.uids.postgres;

     

       189
       189
        
               group = "postgres";

     

       190
       190
        
               description = "PostgreSQL server user";

     

       191
       191
        
             };

     

       192
       192
        
       

     

       193
       193
       -
           users.extraGroups.postgres.gid = config.ids.gids.postgres;

     

       193
       193
       +
           users.groups.postgres.gid = config.ids.gids.postgres;

     

       194
       194
        
       

     

       195
       195
        
           environment.systemPackages = [ postgresql ];

     

       196
       196

+1 -1

nixos/modules/services/databases/redis.nix

···

       217
       217
        
             allowedTCPPorts = [ cfg.port ];

     

       218
       218
        
           };

     

       219
       219
        
       

     

       220
       220
       -
           users.extraUsers.redis =

     

       220
       220
       +
           users.users.redis =

     

       221
       221
        
             { name = cfg.user;

     

       222
       222
        
               description = "Redis database user";

     

       223
       223
        
             };

+2 -2

nixos/modules/services/databases/rethinkdb.nix

···

       96
       96
        
             '';

     

       97
       97
        
           };

     

       98
       98
        
       

     

       99
       99
       -
           users.extraUsers.rethinkdb = mkIf (cfg.user == "rethinkdb")

     

       99
       99
       +
           users.users.rethinkdb = mkIf (cfg.user == "rethinkdb")

     

       100
       100
        
             { name = "rethinkdb";

     

       101
       101
        
               description = "RethinkDB server user";

     

       102
       102
        
             };

     

       103
       103
        
       

     

       104
       104
       -
           users.extraGroups = optionalAttrs (cfg.group == "rethinkdb") (singleton

     

       104
       104
       +
           users.groups = optionalAttrs (cfg.group == "rethinkdb") (singleton

     

       105
       105
        
             { name = "rethinkdb";

     

       106
       106
        
             });

     

       107
       107

+1 -1

nixos/modules/services/databases/riak-cs.nix

···

       145
       145
        
             ${cfg.extraAdvancedConfig}

     

       146
       146
        
           '';

     

       147
       147
        
       

     

       148
       148
       -
           users.extraUsers.riak-cs = {

     

       148
       148
       +
           users.users.riak-cs = {

     

       149
       149
        
             name = "riak-cs";

     

       150
       150
        
             uid = config.ids.uids.riak-cs;

     

       151
       151
        
             group = "riak";

+2 -2

nixos/modules/services/databases/riak.nix

···

       102
       102
        
             ${cfg.extraAdvancedConfig}

     

       103
       103
        
           '';

     

       104
       104
        
       

     

       105
       105
       -
           users.extraUsers.riak = {

     

       105
       105
       +
           users.users.riak = {

     

       106
       106
        
             name = "riak";

     

       107
       107
        
             uid = config.ids.uids.riak;

     

       108
       108
        
             group = "riak";

     

       109
       109
        
             description = "Riak server user";

     

       110
       110
        
           };

     

       111
       111
        
       

     

       112
       112
       -
           users.extraGroups.riak.gid = config.ids.gids.riak;

     

       112
       112
       +
           users.groups.riak.gid = config.ids.gids.riak;

     

       113
       113
        
       

     

       114
       114
        
           systemd.services.riak = {

     

       115
       115
        
             description = "Riak Server";

+2 -2

nixos/modules/services/databases/stanchion.nix

···

       143
       143
        
             ${cfg.extraConfig}

     

       144
       144
        
           '';

     

       145
       145
        
       

     

       146
       146
       -
           users.extraUsers.stanchion = {

     

       146
       146
       +
           users.users.stanchion = {

     

       147
       147
        
             name = "stanchion";

     

       148
       148
        
             uid = config.ids.uids.stanchion;

     

       149
       149
        
             group = "stanchion";

     

       150
       150
        
             description = "Stanchion server user";

     

       151
       151
        
           };

     

       152
       152
        
       

     

       153
       153
       -
           users.extraGroups.stanchion.gid = config.ids.gids.stanchion;

     

       153
       153
       +
           users.groups.stanchion.gid = config.ids.gids.stanchion;

     

       154
       154
        
       

     

       155
       155
        
           systemd.services.stanchion = {

     

       156
       156
        
             description = "Stanchion Server";

+1 -1

nixos/modules/services/databases/virtuoso.nix

···

       54
       54
        
       

     

       55
       55
        
         config = mkIf cfg.enable {

     

       56
       56
        
       

     

       57
       57
       -
           users.extraUsers = singleton

     

       57
       57
       +
           users.users = singleton

     

       58
       58
        
             { name = virtuosoUser;

     

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

     

       60
       60
        
               description = "virtuoso user";

+2 -2

nixos/modules/services/editors/infinoted.nix

···

       111
       111
        
         };

     

       112
       112
        
       

     

       113
       113
        
         config = mkIf (cfg.enable) {

     

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

     

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

     

       115
       115
        
             { name = "infinoted";

     

       116
       116
        
               description = "Infinoted user";

     

       117
       117
        
               group = cfg.group;

     

       118
       118
        
             };

     

       119
       119
       -
           users.extraGroups = optional (cfg.group == "infinoted")

     

       119
       119
       +
           users.groups = optional (cfg.group == "infinoted")

     

       120
       120
        
             { name = "infinoted";

     

       121
       121
        
             };

     

       122
       122

+1 -1

nixos/modules/services/games/minecraft-server.nix

···

       45
       45
        
         };

     

       46
       46
        
       

     

       47
       47
        
         config = mkIf cfg.enable {

     

       48
       48
       -
           users.extraUsers.minecraft = {

     

       48
       48
       +
           users.users.minecraft = {

     

       49
       49
        
             description     = "Minecraft Server Service user";

     

       50
       50
        
             home            = cfg.dataDir;

     

       51
       51
        
             createHome      = true;

+1 -1

nixos/modules/services/games/minetest-server.nix

···

       79
       79
        
         };

     

       80
       80
        
       

     

       81
       81
        
         config = mkIf cfg.enable {

     

       82
       82
       -
           users.extraUsers.minetest = {

     

       82
       82
       +
           users.users.minetest = {

     

       83
       83
        
             description     = "Minetest Server Service user";

     

       84
       84
        
             home            = "/var/lib/minetest";

     

       85
       85
        
             createHome      = true;

+2 -2

nixos/modules/services/games/terraria.nix

···

       105
       105
        
         };

     

       106
       106
        
       

     

       107
       107
        
         config = mkIf cfg.enable {

     

       108
       108
       -
           users.extraUsers.terraria = {

     

       108
       108
       +
           users.users.terraria = {

     

       109
       109
        
             description = "Terraria server service user";

     

       110
       110
        
             home        = "/var/lib/terraria";

     

       111
       111
        
             createHome  = true;

     

       112
       112
        
             uid         = config.ids.uids.terraria;

     

       113
       113
        
           };

     

       114
       114
        
       

     

       115
       115
       -
           users.extraGroups.terraria = {

     

       115
       115
       +
           users.groups.terraria = {

     

       116
       116
        
             gid = config.ids.gids.terraria;

     

       117
       117
        
             members = [ "terraria" ];

     

       118
       118
        
           };

+2 -2

nixos/modules/services/hardware/sane.nix

···

       124
       124
        
             environment.sessionVariables = env;

     

       125
       125
        
             services.udev.packages = backends;

     

       126
       126
        
       

     

       127
       127
       -
             users.extraGroups."scanner".gid = config.ids.gids.scanner;

     

       127
       127
       +
             users.groups."scanner".gid = config.ids.gids.scanner;

     

       128
       128
        
           })

     

       129
       129
        
       

     

       130
       130
        
           (mkIf config.services.saned.enable {

     
···

       152
       152
        
               };

     

       153
       153
        
             };

     

       154
       154
        
       

     

       155
       155
       -
             users.extraUsers."scanner" = {

     

       155
       155
       +
             users.users."scanner" = {

     

       156
       156
        
               uid = config.ids.uids.scanner;

     

       157
       157
        
               group = "scanner";

     

       158
       158
        
             };

+2 -2

nixos/modules/services/hardware/tcsd.nix

···

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

     

       138
       138
        
           };

     

       139
       139
        
       

     

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

     

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

     

       141
       141
        
             { name = "tss";

     

       142
       142
        
               group = "tss";

     

       143
       143
        
               uid = config.ids.uids.tss;

     

       144
       144
        
             });

     

       145
       145
        
       

     

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

     

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

     

       147
       147
        
             { name = "tss";

     

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

     

       149
       149
        
             });

+2 -2

nixos/modules/services/hardware/usbmuxd.nix

···

       43
       43
        
       

     

       44
       44
        
         config = mkIf cfg.enable {

     

       45
       45
        
       

     

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

     

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

     

       47
       47
        
             name = cfg.user;

     

       48
       48
        
             description = "usbmuxd user";

     

       49
       49
        
             group = cfg.group;

     

       50
       50
        
           };

     

       51
       51
        
       

     

       52
       52
       -
           users.extraGroups = optional (cfg.group == defaultUserGroup) {

     

       52
       52
       +
           users.groups = optional (cfg.group == defaultUserGroup) {

     

       53
       53
        
             name = cfg.group;

     

       54
       54
        
           };

     

       55
       55

+1 -1

nixos/modules/services/logging/graylog.nix

···

       127
       127
        
       

     

       128
       128
        
         config = mkIf cfg.enable {

     

       129
       129
        
       

     

       130
       130
       -
           users.extraUsers = mkIf (cfg.user == "graylog") {

     

       130
       130
       +
           users.users = mkIf (cfg.user == "graylog") {

     

       131
       131
        
             graylog = {

     

       132
       132
        
               uid = config.ids.uids.graylog;

     

       133
       133
        
               description = "Graylog server daemon user";

+1 -1

nixos/modules/services/logging/journalwatch.nix

···

       197
       197
        
       

     

       198
       198
        
         config = mkIf cfg.enable {

     

       199
       199
        
       

     

       200
       200
       -
           users.extraUsers.${user} = {

     

       200
       200
       +
           users.users.${user} = {

     

       201
       201
        
             isSystemUser = true;

     

       202
       202
        
             createHome = true;

     

       203
       203
        
             home = dataDir;

+1 -1

nixos/modules/services/logging/logcheck.nix

···

       213
       213
        
               mapAttrsToList writeIgnoreRule cfg.ignore

     

       214
       214
        
               ++ mapAttrsToList writeIgnoreCronRule cfg.ignoreCron;

     

       215
       215
        
       

     

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

     

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

     

       217
       217
        
             { name = "logcheck";

     

       218
       218
        
               uid = config.ids.uids.logcheck;

     

       219
       219
        
               shell = "/bin/sh";

+2 -2

nixos/modules/services/mail/dovecot.nix

···

       309
       309
        
            ++ optional cfg.enablePop3 "pop3"

     

       310
       310
        
            ++ optional cfg.enableLmtp "lmtp";

     

       311
       311
        
       

     

       312
       312
       -
           users.extraUsers = [

     

       312
       312
       +
           users.users = [

     

       313
       313
        
             { name = "dovenull";

     

       314
       314
        
               uid = config.ids.uids.dovenull2;

     

       315
       315
        
               description = "Dovecot user for untrusted logins";

     
···

       328
       328
        
                  group = cfg.mailGroup;

     

       329
       329
        
                });

     

       330
       330
        
       

     

       331
       331
       -
           users.extraGroups = optional (cfg.group == "dovecot2")

     

       331
       331
       +
           users.groups = optional (cfg.group == "dovecot2")

     

       332
       332
        
             { name = "dovecot2";

     

       333
       333
        
               gid = config.ids.gids.dovecot2;

     

       334
       334
        
             }

+2 -2

nixos/modules/services/mail/dspam.nix

···

       86
       86
        
       

     

       87
       87
        
         config = mkIf cfg.enable (mkMerge [

     

       88
       88
        
           {

     

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

     

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

     

       90
       90
        
               { name = "dspam";

     

       91
       91
        
                 group = cfg.group;

     

       92
       92
        
                 uid = config.ids.uids.dspam;

     

       93
       93
        
               });

     

       94
       94
        
       

     

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

     

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

     

       96
       96
        
               { name = "dspam";

     

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

     

       98
       98
        
               });

+2 -2

nixos/modules/services/mail/exim.nix

···

       77
       77
        
             systemPackages = [ exim ];

     

       78
       78
        
           };

     

       79
       79
        
       

     

       80
       80
       -
           users.extraUsers = singleton {

     

       80
       80
       +
           users.users = singleton {

     

       81
       81
        
             name = cfg.user;

     

       82
       82
        
             description = "Exim mail transfer agent user";

     

       83
       83
        
             uid = config.ids.uids.exim;

     

       84
       84
        
             group = cfg.group;

     

       85
       85
        
           };

     

       86
       86
        
       

     

       87
       87
       -
           users.extraGroups = singleton {

     

       87
       87
       +
           users.groups = singleton {

     

       88
       88
        
             name = cfg.group;

     

       89
       89
        
             gid = config.ids.gids.exim;

     

       90
       90
        
           };

+1 -1

nixos/modules/services/mail/mailhog.nix

···

       24
       24
        
       

     

       25
       25
        
         config = mkIf cfg.enable {

     

       26
       26
        
       

     

       27
       27
       -
           users.extraUsers.mailhog = {

     

       27
       27
       +
           users.users.mailhog = {

     

       28
       28
        
             name = cfg.user;

     

       29
       29
        
             description = "MailHog service user";

     

       30
       30
        
           };

+2 -2

nixos/modules/services/mail/mlmmj.nix

···

       94
       94
        
       

     

       95
       95
        
         config = mkIf cfg.enable {

     

       96
       96
        
       

     

       97
       97
       -
           users.extraUsers = singleton {

     

       97
       97
       +
           users.users = singleton {

     

       98
       98
        
             name = cfg.user;

     

       99
       99
        
             description = "mlmmj user";

     

       100
       100
        
             home = stateDir;

     
···

       104
       104
        
             useDefaultShell = true;

     

       105
       105
        
           };

     

       106
       106
        
       

     

       107
       107
       -
           users.extraGroups = singleton {

     

       107
       107
       +
           users.groups = singleton {

     

       108
       108
        
             name = cfg.group;

     

       109
       109
        
             gid = config.ids.gids.mlmmj;

     

       110
       110
        
           };

+2 -2

nixos/modules/services/mail/nullmailer.nix

···

       201
       201
        
           };

     

       202
       202
        
       

     

       203
       203
        
           users = {

     

       204
       204
       -
             extraUsers = singleton {

     

       204
       204
       +
             users = singleton {

     

       205
       205
        
               name = cfg.user;

     

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

     

       207
       207
        
               group = cfg.group;

     

       208
       208
        
             };

     

       209
       209
        
       

     

       210
       210
       -
             extraGroups = singleton {

     

       210
       210
       +
             groups = singleton {

     

       211
       211
        
               name = cfg.group;

     

       212
       212
        
             };

     

       213
       213
        
           };

+2 -2

nixos/modules/services/mail/opendkim.nix

···

       88
       88
        
       

     

       89
       89
        
         config = mkIf cfg.enable {

     

       90
       90
        
       

     

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

     

       91
       91
       +
           users.users = optionalAttrs (cfg.user == "opendkim") (singleton

     

       92
       92
        
             { name = "opendkim";

     

       93
       93
        
               group = cfg.group;

     

       94
       94
        
               uid = config.ids.uids.opendkim;

     

       95
       95
        
             });

     

       96
       96
        
       

     

       97
       97
       -
           users.extraGroups = optionalAttrs (cfg.group == "opendkim") (singleton

     

       97
       97
       +
           users.groups = optionalAttrs (cfg.group == "opendkim") (singleton

     

       98
       98
        
             { name = "opendkim";

     

       99
       99
        
               gid = config.ids.gids.opendkim;

     

       100
       100
        
             });

+2 -2

nixos/modules/services/mail/opensmtpd.nix

···

       83
       83
        
         ###### implementation

     

       84
       84
        
       

     

       85
       85
        
         config = mkIf cfg.enable {

     

       86
       86
       -
           users.extraGroups = {

     

       86
       86
       +
           users.groups = {

     

       87
       87
        
             smtpd.gid = config.ids.gids.smtpd;

     

       88
       88
        
             smtpq.gid = config.ids.gids.smtpq;

     

       89
       89
        
           };

     

       90
       90
        
       

     

       91
       91
       -
           users.extraUsers = {

     

       91
       91
       +
           users.users = {

     

       92
       92
        
             smtpd = {

     

       93
       93
        
               description = "OpenSMTPD process user";

     

       94
       94
        
               uid = config.ids.uids.smtpd;

+2 -2

nixos/modules/services/mail/postfix.nix

···

       616
       616
        
               setgid = true;

     

       617
       617
        
             };

     

       618
       618
        
       

     

       619
       619
       -
             users.extraUsers = optional (user == "postfix")

     

       619
       619
       +
             users.users = optional (user == "postfix")

     

       620
       620
        
               { name = "postfix";

     

       621
       621
        
                 description = "Postfix mail server user";

     

       622
       622
        
                 uid = config.ids.uids.postfix;

     

       623
       623
        
                 group = group;

     

       624
       624
        
               };

     

       625
       625
        
       

     

       626
       626
       -
             users.extraGroups =

     

       626
       626
       +
             users.groups =

     

       627
       627
        
               optional (group == "postfix")

     

       628
       628
        
               { name = group;

     

       629
       629
        
                 gid = config.ids.gids.postfix;

+2 -2

nixos/modules/services/mail/postgrey.nix

···

       136
       136
        
           environment.systemPackages = [ pkgs.postgrey ];

     

       137
       137
        
       

     

       138
       138
        
           users = {

     

       139
       139
       -
             extraUsers = {

     

       139
       139
       +
             users = {

     

       140
       140
        
               postgrey = {

     

       141
       141
        
                 description = "Postgrey Daemon";

     

       142
       142
        
                 uid = config.ids.uids.postgrey;

     

       143
       143
        
                 group = "postgrey";

     

       144
       144
        
               };

     

       145
       145
        
             };

     

       146
       146
       -
             extraGroups = {

     

       146
       146
       +
             groups = {

     

       147
       147
        
               postgrey = {

     

       148
       148
        
                 gid = config.ids.gids.postgrey;

     

       149
       149
        
               };

+2 -2

nixos/modules/services/mail/postsrsd.nix

···

       90
       90
        
       

     

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

     

       92
       92
        
       

     

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

     

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

     

       94
       94
        
             { name = "postsrsd";

     

       95
       95
        
               group = cfg.group;

     

       96
       96
        
               uid = config.ids.uids.postsrsd;

     

       97
       97
        
             });

     

       98
       98
        
       

     

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

     

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

     

       100
       100
        
             { name = "postsrsd";

     

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

     

       102
       102
        
             });

+4 -4

nixos/modules/services/mail/rmilter.nix

···

       194
       194
        
       

     

       195
       195
        
           (mkIf cfg.enable {

     

       196
       196
        
       

     

       197
       197
       -
             users.extraUsers = singleton {

     

       197
       197
       +
             users.users = singleton {

     

       198
       198
        
               name = cfg.user;

     

       199
       199
        
               description = "rmilter daemon";

     

       200
       200
        
               uid = config.ids.uids.rmilter;

     

       201
       201
        
               group = cfg.group;

     

       202
       202
        
             };

     

       203
       203
        
       

     

       204
       204
       -
             users.extraGroups = singleton {

     

       204
       204
       +
             users.groups = singleton {

     

       205
       205
        
               name = cfg.group;

     

       206
       206
        
               gid = config.ids.gids.rmilter;

     

       207
       207
        
             };

     
···

       238
       238
        
           })

     

       239
       239
        
       

     

       240
       240
        
           (mkIf (cfg.enable && cfg.rspamd.enable && rspamdCfg.enable) {

     

       241
       241
       -
             users.extraUsers.${cfg.user}.extraGroups = [ rspamdCfg.group ];

     

       241
       241
       +
             users.users.${cfg.user}.extraGroups = [ rspamdCfg.group ];

     

       242
       242
        
           })

     

       243
       243
        
       

     

       244
       244
        
           (mkIf (cfg.enable && cfg.postfix.enable) {

     

       245
       245
        
             services.postfix.extraConfig = cfg.postfix.configFragment;

     

       246
       246
       -
             users.extraUsers.${postfixCfg.user}.extraGroups = [ cfg.group ];

     

       246
       246
       +
             users.users.${postfixCfg.user}.extraGroups = [ cfg.group ];

     

       247
       247
        
           })

     

       248
       248
        
         ];

     

       249
       249
        
       }

+2 -2

nixos/modules/services/mail/rspamd.nix

···

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

     

       283
       283
        
           environment.systemPackages = [ pkgs.rspamd ];

     

       284
       284
        
       

     

       285
       285
       -
           users.extraUsers = singleton {

     

       285
       285
       +
           users.users = singleton {

     

       286
       286
        
             name = cfg.user;

     

       287
       287
        
             description = "rspamd daemon";

     

       288
       288
        
             uid = config.ids.uids.rspamd;

     

       289
       289
        
             group = cfg.group;

     

       290
       290
        
           };

     

       291
       291
        
       

     

       292
       292
       -
           users.extraGroups = singleton {

     

       292
       292
       +
           users.groups = singleton {

     

       293
       293
        
             name = cfg.group;

     

       294
       294
        
             gid = config.ids.gids.rspamd;

     

       295
       295
        
           };

+2 -2

nixos/modules/services/mail/spamassassin.nix

···

       128
       128
        
             systemPackages = [ pkgs.spamassassin ];

     

       129
       129
        
           };

     

       130
       130
        
       

     

       131
       131
       -
           users.extraUsers = singleton {

     

       131
       131
       +
           users.users = singleton {

     

       132
       132
        
             name = "spamd";

     

       133
       133
        
             description = "Spam Assassin Daemon";

     

       134
       134
        
             uid = config.ids.uids.spamd;

     

       135
       135
        
             group = "spamd";

     

       136
       136
        
           };

     

       137
       137
        
       

     

       138
       138
       -
           users.extraGroups = singleton {

     

       138
       138
       +
           users.groups = singleton {

     

       139
       139
        
             name = "spamd";

     

       140
       140
        
             gid = config.ids.gids.spamd;

     

       141
       141
        
           };

+1 -1

nixos/modules/services/misc/airsonic.nix

···

       107
       107
        
             };

     

       108
       108
        
           };

     

       109
       109
        
       

     

       110
       110
       -
           users.extraUsers.airsonic = {

     

       110
       110
       +
           users.users.airsonic = {

     

       111
       111
        
             description = "Airsonic service user";

     

       112
       112
        
             name = cfg.user;

     

       113
       113
        
             home = cfg.home;

+1 -1

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

···

       124
       124
        
       

     

       125
       125
        
           environment.systemPackages = [cfg.package];

     

       126
       126
        
       

     

       127
       127
       -
           users.extraUsers = singleton {

     

       127
       127
       +
           users.users = singleton {

     

       128
       128
        
             name = "apache-kafka";

     

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

     

       130
       130
        
             description = "Apache Kafka daemon user";

+2 -2

nixos/modules/services/misc/bepasty.nix

···

       168
       168
        
               })

     

       169
       169
        
           ) cfg.servers;

     

       170
       170
        
       

     

       171
       171
       -
           users.extraUsers = [{

     

       171
       171
       +
           users.users = [{

     

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

     

       173
       173
        
             name = user;

     

       174
       174
        
             group = group;

     

       175
       175
        
             home = default_home;

     

       176
       176
        
           }];

     

       177
       177
        
       

     

       178
       178
       -
           users.extraGroups = [{

     

       178
       178
       +
           users.groups = [{

     

       179
       179
        
             name = group;

     

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

     

       181
       181
        
           }];

+2 -2

nixos/modules/services/misc/calibre-server.nix

···

       49
       49
        
       

     

       50
       50
        
           environment.systemPackages = [ pkgs.calibre ];

     

       51
       51
        
       

     

       52
       52
       -
           users.extraUsers.calibre-server = {

     

       52
       52
       +
           users.users.calibre-server = {

     

       53
       53
        
               uid = config.ids.uids.calibre-server;

     

       54
       54
        
               group = "calibre-server";

     

       55
       55
        
             };

     

       56
       56
        
       

     

       57
       57
       -
           users.extraGroups.calibre-server = {

     

       57
       57
       +
           users.groups.calibre-server = {

     

       58
       58
        
               gid = config.ids.gids.calibre-server;

     

       59
       59
        
             };

     

       60
       60

+2 -2

nixos/modules/services/misc/cfdyndns.nix

···

       54
       54
        
             };

     

       55
       55
        
           };

     

       56
       56
        
       

     

       57
       57
       -
           users.extraUsers = {

     

       57
       57
       +
           users.users = {

     

       58
       58
        
             cfdyndns = {

     

       59
       59
        
               group = "cfdyndns";

     

       60
       60
        
               uid = config.ids.uids.cfdyndns;

     

       61
       61
        
             };

     

       62
       62
        
           };

     

       63
       63
        
       

     

       64
       64
       -
           users.extraGroups = {

     

       64
       64
       +
           users.groups = {

     

       65
       65
        
             cfdyndns = {

     

       66
       66
        
               gid = config.ids.gids.cfdyndns;

     

       67
       67
        
             };

+1 -1

nixos/modules/services/misc/cgminer.nix

···

       110
       110
        
       

     

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

     

       112
       112
        
       

     

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

     

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

     

       114
       114
        
             { name = "cgminer";

     

       115
       115
        
               uid = config.ids.uids.cgminer;

     

       116
       116
        
               description = "Cgminer user";

+2 -2

nixos/modules/services/misc/couchpotato.nix

···

       34
       34
        
             };

     

       35
       35
        
           };

     

       36
       36
        
       

     

       37
       37
       -
           users.extraUsers = singleton

     

       37
       37
       +
           users.users = singleton

     

       38
       38
        
             { name = "couchpotato";

     

       39
       39
        
               group = "couchpotato";

     

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

     
···

       42
       42
        
               uid = config.ids.uids.couchpotato;

     

       43
       43
        
             };

     

       44
       44
        
       

     

       45
       45
       -
           users.extraGroups = singleton

     

       45
       45
       +
           users.groups = singleton

     

       46
       46
        
             { name = "couchpotato";

     

       47
       47
        
               gid = config.ids.gids.couchpotato;

     

       48
       48
        
             };

+2 -2

nixos/modules/services/misc/dictd.nix

···

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

     

       46
       46
        
           environment.systemPackages = [ pkgs.dict ];

     

       47
       47
        
       

     

       48
       48
       -
           users.extraUsers = singleton

     

       48
       48
       +
           users.users = singleton

     

       49
       49
        
             { name = "dictd";

     

       50
       50
        
               group = "dictd";

     

       51
       51
        
               description = "DICT.org dictd server";

     
···

       53
       53
        
               uid = config.ids.uids.dictd;

     

       54
       54
        
             };

     

       55
       55
        
       

     

       56
       56
       -
           users.extraGroups = singleton

     

       56
       56
       +
           users.groups = singleton

     

       57
       57
        
             { name = "dictd";

     

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

     

       59
       59
        
             };

+1 -1

nixos/modules/services/misc/disnix.nix

···

       71
       71
        
             ++ optional cfg.useWebServiceInterface "${pkgs.dbus_java}/share/java/dbus.jar";

     

       72
       72
        
           services.tomcat.webapps = optional cfg.useWebServiceInterface pkgs.DisnixWebService;

     

       73
       73
        
       

     

       74
       74
       -
           users.extraGroups = singleton

     

       74
       74
       +
           users.groups = singleton

     

       75
       75
        
             { name = "disnix";

     

       76
       76
        
               gid = config.ids.gids.disnix;

     

       77
       77
        
             };

+1 -1

nixos/modules/services/misc/docker-registry.nix

···

       140
       140
        
             startAt = optional cfg.enableGarbageCollect cfg.garbageCollectDates;

     

       141
       141
        
           };

     

       142
       142
        
       

     

       143
       143
       -
           users.extraUsers.docker-registry = {

     

       143
       143
       +
           users.users.docker-registry = {

     

       144
       144
        
             createHome = true;

     

       145
       145
        
             home = cfg.storagePath;

     

       146
       146
        
           };

+2 -2

nixos/modules/services/misc/emby.nix

···

       54
       54
        
             };

     

       55
       55
        
           };

     

       56
       56
        
       

     

       57
       57
       -
           users.extraUsers = mkIf (cfg.user == "emby") {

     

       57
       57
       +
           users.users = mkIf (cfg.user == "emby") {

     

       58
       58
        
             emby = {

     

       59
       59
        
               group = cfg.group;

     

       60
       60
        
               uid = config.ids.uids.emby;

     

       61
       61
        
             };

     

       62
       62
        
           };

     

       63
       63
        
       

     

       64
       64
       -
           users.extraGroups = mkIf (cfg.group == "emby") {

     

       64
       64
       +
           users.groups = mkIf (cfg.group == "emby") {

     

       65
       65
        
             emby = {

     

       66
       66
        
               gid = config.ids.gids.emby;

     

       67
       67
        
             };

+2 -2

nixos/modules/services/misc/errbot.nix

···

       76
       76
        
         };

     

       77
       77
        
       

     

       78
       78
        
         config = mkIf (cfg.instances != {}) {

     

       79
       79
       -
           users.extraUsers.errbot.group = "errbot";

     

       80
       80
       -
           users.extraGroups.errbot = {};

     

       79
       79
       +
           users.users.errbot.group = "errbot";

     

       80
       80
       +
           users.groups.errbot = {};

     

       81
       81
        
       

     

       82
       82
        
           systemd.services = mapAttrs' (name: instanceCfg: nameValuePair "errbot-${name}" (

     

       83
       83
        
           let

+1 -1

nixos/modules/services/misc/etcd.nix

···

       188
       188
        
       

     

       189
       189
        
           environment.systemPackages = [ pkgs.etcdctl ];

     

       190
       190
        
       

     

       191
       191
       -
           users.extraUsers = singleton {

     

       191
       191
       +
           users.users = singleton {

     

       192
       192
        
             name = "etcd";

     

       193
       193
        
             uid = config.ids.uids.etcd;

     

       194
       194
        
             description = "Etcd daemon user";

+1 -1

nixos/modules/services/misc/exhibitor.nix

···

       408
       408
        
               chmod -R u+w ${cfg.baseDir}/zookeeper/conf

     

       409
       409
        
             '';

     

       410
       410
        
           };

     

       411
       411
       -
           users.extraUsers = singleton {

     

       411
       411
       +
           users.users = singleton {

     

       412
       412
        
             name = "zookeeper";

     

       413
       413
        
             uid = config.ids.uids.zookeeper;

     

       414
       414
        
             description = "Zookeeper daemon user";

+2 -2

nixos/modules/services/misc/felix.nix

···

       47
       47
        
         ###### implementation

     

       48
       48
        
       

     

       49
       49
        
         config = mkIf cfg.enable {

     

       50
       50
       -
           users.extraGroups = singleton

     

       50
       50
       +
           users.groups = singleton

     

       51
       51
        
             { name = "osgi";

     

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

     

       53
       53
        
             };

     

       54
       54
        
       

     

       55
       55
       -
           users.extraUsers = singleton

     

       55
       55
       +
           users.users = singleton

     

       56
       56
        
             { name = "osgi";

     

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

     

       58
       58
        
               description = "OSGi user";

+1 -1

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

···

       42
       42
        
       

     

       43
       43
        
         config = mkIf cfg.enable {

     

       44
       44
        
       

     

       45
       45
       -
           users.extraUsers = singleton

     

       45
       45
       +
           users.users = singleton

     

       46
       46
        
             { name = fahUser;

     

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

     

       48
       48
        
               description = "Folding@Home user";

+1 -1

nixos/modules/services/misc/gammu-smsd.nix

···

       200
       200
        
         };

     

       201
       201
        
       

     

       202
       202
        
         config = mkIf cfg.enable {

     

       203
       203
       -
           users.extraUsers.${cfg.user} = {

     

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

     

       204
       204
        
             description = "gammu-smsd user";

     

       205
       205
        
             uid = config.ids.uids.gammu-smsd;

     

       206
       206
        
             extraGroups = [ "${cfg.device.group}" ];

+1 -1

nixos/modules/services/misc/geoip-updater.nix

···

       251
       251
        
             }

     

       252
       252
        
           ];

     

       253
       253
        
       

     

       254
       254
       -
           users.extraUsers.geoip = {

     

       254
       254
       +
           users.users.geoip = {

     

       255
       255
        
             group = "root";

     

       256
       256
        
             description = "GeoIP database updater";

     

       257
       257
        
             uid = config.ids.uids.geoip;

+1 -1

nixos/modules/services/misc/gitea.nix

···

       337
       337
        
           };

     

       338
       338
        
       

     

       339
       339
        
           users = mkIf (cfg.user == "gitea") {

     

       340
       340
       -
             extraUsers.gitea = {

     

       340
       340
       +
             users.gitea = {

     

       341
       341
        
               description = "Gitea Service";

     

       342
       342
        
               home = cfg.stateDir;

     

       343
       343
        
               createHome = true;

+5 -5

nixos/modules/services/misc/gitit.nix

···

       645
       645
        
       

     

       646
       646
        
         config = mkIf cfg.enable {

     

       647
       647
        
       

     

       648
       648
       -
           users.extraUsers.gitit = {

     

       649
       649
       -
             group = config.users.extraGroups.gitit.name;

     

       648
       648
       +
           users.users.gitit = {

     

       649
       649
       +
             group = config.users.groups.gitit.name;

     

       650
       650
        
             description = "Gitit user";

     

       651
       651
        
             home = homeDir;

     

       652
       652
        
             createHome = true;

     

       653
       653
        
             uid = config.ids.uids.gitit;

     

       654
       654
        
           };

     

       655
       655
        
       

     

       656
       656
       -
           users.extraGroups.gitit.gid = config.ids.gids.gitit;

     

       656
       656
       +
           users.groups.gitit.gid = config.ids.gids.gitit;

     

       657
       657
        
       

     

       658
       658
        
           systemd.services.gitit = let

     

       659
       659
        
             uid = toString config.ids.uids.gitit;

     
···

       715
       715
        
             '';

     

       716
       716
        
       

     

       717
       717
        
             serviceConfig = {

     

       718
       718
       -
               User = config.users.extraUsers.gitit.name;

     

       719
       719
       -
               Group = config.users.extraGroups.gitit.name;

     

       718
       718
       +
               User = config.users.users.gitit.name;

     

       719
       719
       +
               Group = config.users.groups.gitit.name;

     

       720
       720
        
               ExecStart = with cfg; gititSh haskellPackages extraPackages;

     

       721
       721
        
             };

     

       722
       722
        
           };

+2 -2

nixos/modules/services/misc/gitlab.nix

···

       444
       444
        
           # Use postfix to send out mails.

     

       445
       445
        
           services.postfix.enable = mkDefault true;

     

       446
       446
        
       

     

       447
       447
       -
           users.extraUsers = [

     

       447
       447
       +
           users.users = [

     

       448
       448
        
             { name = cfg.user;

     

       449
       449
        
               group = cfg.group;

     

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

     
···

       453
       453
        
             }

     

       454
       454
        
           ];

     

       455
       455
        
       

     

       456
       456
       -
           users.extraGroups = [

     

       456
       456
       +
           users.groups = [

     

       457
       457
        
             { name = cfg.group;

     

       458
       458
        
               gid = config.ids.gids.gitlab;

     

       459
       459
        
             }

+2 -2

nixos/modules/services/misc/gitolite.nix

···

       140
       140
        
             push( @{$RC{ENABLE}}, 'git-annex-shell ua');

     

       141
       141
        
           '';

     

       142
       142
        
       

     

       143
       143
       -
           users.extraUsers.${cfg.user} = {

     

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

     

       144
       144
        
             description     = "Gitolite user";

     

       145
       145
        
             home            = cfg.dataDir;

     

       146
       146
        
             createHome      = true;

     
···

       148
       148
        
             group           = cfg.group;

     

       149
       149
        
             useDefaultShell = true;

     

       150
       150
        
           };

     

       151
       151
       -
           users.extraGroups."${cfg.group}".gid = config.ids.gids.gitolite;

     

       151
       151
       +
           users.groups."${cfg.group}".gid = config.ids.gids.gitolite;

     

       152
       152
        
       

     

       153
       153
        
           systemd.services."gitolite-init" = {

     

       154
       154
        
             description = "Gitolite initialization";

+2 -2

nixos/modules/services/misc/gogs.nix

···

       254
       254
        
           };

     

       255
       255
        
       

     

       256
       256
        
           users = mkIf (cfg.user == "gogs") {

     

       257
       257
       -
             extraUsers.gogs = {

     

       257
       257
       +
             users.gogs = {

     

       258
       258
        
               description = "Go Git Service";

     

       259
       259
        
               uid = config.ids.uids.gogs;

     

       260
       260
        
               group = "gogs";

     
···

       262
       262
        
               createHome = true;

     

       263
       263
        
               shell = pkgs.bash;

     

       264
       264
        
             };

     

       265
       265
       -
             extraGroups.gogs.gid = config.ids.gids.gogs;

     

       265
       265
       +
             groups.gogs.gid = config.ids.gids.gogs;

     

       266
       266
        
           };

     

       267
       267
        
       

     

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

+2 -2

nixos/modules/services/misc/gollum.nix

···

       93
       93
        
             '';

     

       94
       94
        
       

     

       95
       95
        
             serviceConfig = {

     

       96
       96
       -
               User = config.users.extraUsers.gollum.name;

     

       97
       97
       -
               Group = config.users.extraGroups.gollum.name;

     

       96
       96
       +
               User = config.users.users.gollum.name;

     

       97
       97
       +
               Group = config.users.groups.gollum.name;

     

       98
       98
        
               PermissionsStartOnly = true;

     

       99
       99
        
               ExecStart = ''

     

       100
       100
        
                 ${pkgs.gollum}/bin/gollum \

+2 -2

nixos/modules/services/misc/gpsd.nix

···

       78
       78
        
       

     

       79
       79
        
         config = mkIf cfg.enable {

     

       80
       80
        
       

     

       81
       81
       -
           users.extraUsers = singleton

     

       81
       81
       +
           users.users = singleton

     

       82
       82
        
             { name = "gpsd";

     

       83
       83
        
               inherit uid;

     

       84
       84
        
               description = "gpsd daemon user";

     

       85
       85
        
               home = "/var/empty";

     

       86
       86
        
             };

     

       87
       87
        
       

     

       88
       88
       -
           users.extraGroups = singleton

     

       88
       88
       +
           users.groups = singleton

     

       89
       89
        
             { name = "gpsd";

     

       90
       90
        
               inherit gid;

     

       91
       91
        
             };

+2 -2

nixos/modules/services/misc/home-assistant.nix

···

       170
       170
        
             after = wants;

     

       171
       171
        
           };

     

       172
       172
        
       

     

       173
       173
       -
           users.extraUsers.hass = {

     

       173
       173
       +
           users.users.hass = {

     

       174
       174
        
             home = cfg.configDir;

     

       175
       175
        
             createHome = true;

     

       176
       176
        
             group = "hass";

     

       177
       177
        
             uid = config.ids.uids.hass;

     

       178
       178
        
           };

     

       179
       179
        
       

     

       180
       180
       -
           users.extraGroups.hass.gid = config.ids.gids.hass;

     

       180
       180
       +
           users.groups.hass.gid = config.ids.gids.hass;

     

       181
       181
        
         };

     

       182
       182
        
       }

+5 -5

nixos/modules/services/misc/ihaskell.nix

···

       38
       38
        
       

     

       39
       39
        
         config = mkIf cfg.enable {

     

       40
       40
        
       

     

       41
       41
       -
           users.extraUsers.ihaskell = {

     

       42
       42
       -
             group = config.users.extraGroups.ihaskell.name;

     

       41
       41
       +
           users.users.ihaskell = {

     

       42
       42
       +
             group = config.users.groups.ihaskell.name;

     

       43
       43
        
             description = "IHaskell user";

     

       44
       44
        
             home = "/var/lib/ihaskell";

     

       45
       45
        
             createHome = true;

     

       46
       46
        
             uid = config.ids.uids.ihaskell;

     

       47
       47
        
           };

     

       48
       48
        
       

     

       49
       49
       -
           users.extraGroups.ihaskell.gid = config.ids.gids.ihaskell;

     

       49
       49
       +
           users.groups.ihaskell.gid = config.ids.gids.ihaskell;

     

       50
       50
        
       

     

       51
       51
        
           systemd.services.ihaskell = {

     

       52
       52
        
             description = "IHaskell notebook instance";

     

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

     

       54
       54
        
             after = [ "network.target" ];

     

       55
       55
        
             serviceConfig = {

     

       56
       56
       -
               User = config.users.extraUsers.ihaskell.name;

     

       57
       57
       -
               Group = config.users.extraGroups.ihaskell.name;

     

       56
       56
       +
               User = config.users.users.ihaskell.name;

     

       57
       57
       +
               Group = config.users.groups.ihaskell.name;

     

       58
       58
        
               ExecStart = "${pkgs.runtimeShell} -c \"cd $HOME;${ihaskell}/bin/ihaskell-notebook\"";

     

       59
       59
        
             };

     

       60
       60
        
           };

+2 -2

nixos/modules/services/misc/jackett.nix

···

       36
       36
        
             };

     

       37
       37
        
           };

     

       38
       38
        
       

     

       39
       39
       -
           users.extraUsers.jackett = {

     

       39
       39
       +
           users.users.jackett = {

     

       40
       40
        
             uid = config.ids.uids.jackett;

     

       41
       41
        
             home = "/var/lib/jackett";

     

       42
       42
        
             group = "jackett";

     

       43
       43
        
           };

     

       44
       44
       -
           users.extraGroups.jackett.gid = config.ids.gids.jackett;

     

       44
       44
       +
           users.groups.jackett.gid = config.ids.gids.jackett;

     

       45
       45
        
       

     

       46
       46
        
         };

     

       47
       47
        
       }

+5 -5

nixos/modules/services/misc/mathics.nix

···

       26
       26
        
       

     

       27
       27
        
         config = mkIf cfg.enable {

     

       28
       28
        
       

     

       29
       29
       -
           users.extraUsers.mathics = {

     

       30
       30
       -
             group = config.users.extraGroups.mathics.name;

     

       29
       29
       +
           users.users.mathics = {

     

       30
       30
       +
             group = config.users.groups.mathics.name;

     

       31
       31
        
             description = "Mathics user";

     

       32
       32
        
             home = "/var/lib/mathics";

     

       33
       33
        
             createHome = true;

     

       34
       34
        
             uid = config.ids.uids.mathics;

     

       35
       35
        
           };

     

       36
       36
        
       

     

       37
       37
       -
           users.extraGroups.mathics.gid = config.ids.gids.mathics;

     

       37
       37
       +
           users.groups.mathics.gid = config.ids.gids.mathics;

     

       38
       38
        
       

     

       39
       39
        
           systemd.services.mathics = {

     

       40
       40
        
             description = "Mathics notebook server";

     

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

     

       42
       42
        
             after = [ "network.target" ];

     

       43
       43
        
             serviceConfig = {

     

       44
       44
       -
               User = config.users.extraUsers.mathics.name;

     

       45
       45
       -
               Group = config.users.extraGroups.mathics.name;

     

       44
       44
       +
               User = config.users.users.mathics.name;

     

       45
       45
       +
               Group = config.users.groups.mathics.name;

     

       46
       46
        
               ExecStart = concatStringsSep " " [

     

       47
       47
        
                 "${pkgs.mathics}/bin/mathicsserver"

     

       48
       48
        
                 "--port" (toString cfg.port)

+2 -2

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

···

       635
       635
        
         };

     

       636
       636
        
       

     

       637
       637
        
         config = mkIf cfg.enable {

     

       638
       638
       -
           users.extraUsers = [

     

       638
       638
       +
           users.users = [

     

       639
       639
        
             { name = "matrix-synapse";

     

       640
       640
        
               group = "matrix-synapse";

     

       641
       641
        
               home = cfg.dataDir;

     
···

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

     

       645
       645
        
             } ];

     

       646
       646
        
       

     

       647
       647
       -
           users.extraGroups = [

     

       647
       647
       +
           users.groups = [

     

       648
       648
        
             { name = "matrix-synapse";

     

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

     

       650
       650
        
             } ];

+2 -2

nixos/modules/services/misc/mediatomb.nix

···

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

     

       268
       268
        
           };

     

       269
       269
        
       

     

       270
       270
       -
           users.extraGroups = optionalAttrs (cfg.group == "mediatomb") (singleton {

     

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

     

       271
       271
        
             name = "mediatomb";

     

       272
       272
        
             gid = gid;

     

       273
       273
        
           });

     

       274
       274
        
       

     

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

     

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

     

       276
       276
        
             name = "mediatomb";

     

       277
       277
        
             isSystemUser = true;

     

       278
       278
        
             group = cfg.group;

+5 -5

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

···

       131
       131
        
               description = "

     

       132
       132
        
                 If set, Nix will perform builds in a sandboxed environment that it

     

       133
       133
        
                 will set up automatically for each build. This prevents impurities

     

       134
       134
       -
                 in builds by disallowing access to dependencies outside of the Nix 

     

       135
       135
       -
                 store by using network and mount namespaces in a chroot environment. 

     

       136
       136
       -
                 This isn't enabled by default for possible performance impacts due to 

     

       137
       137
       -
                 the initial setup time of a sandbox for each build. It doesn't affect 

     

       134
       134
       +
                 in builds by disallowing access to dependencies outside of the Nix

     

       135
       135
       +
                 store by using network and mount namespaces in a chroot environment.

     

       136
       136
       +
                 This isn't enabled by default for possible performance impacts due to

     

       137
       137
       +
                 the initial setup time of a sandbox for each build. It doesn't affect

     

       138
       138
        
                 derivation hashes, so changing this option will not trigger a rebuild

     

       139
       139
        
                 of packages.

     

       140
       140
        
               ";

     
···

       450
       450
        
       

     

       451
       451
        
           nix.nrBuildUsers = mkDefault (lib.max 32 cfg.maxJobs);

     

       452
       452
        
       

     

       453
       453
       -
           users.extraUsers = nixbldUsers;

     

       453
       453
       +
           users.users = nixbldUsers;

     

       454
       454
        
       

     

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

     

       456
       456

+2 -2

nixos/modules/services/misc/nix-ssh-serve.nix

···

       36
       36
        
       

     

       37
       37
        
         config = mkIf cfg.enable {

     

       38
       38
        
       

     

       39
       39
       -
           users.extraUsers.nix-ssh = {

     

       39
       39
       +
           users.users.nix-ssh = {

     

       40
       40
        
             description = "Nix SSH store user";

     

       41
       41
        
             uid = config.ids.uids.nix-ssh;

     

       42
       42
        
             useDefaultShell = true;

     
···

       55
       55
        
             Match All

     

       56
       56
        
           '';

     

       57
       57
        
       

     

       58
       58
       -
           users.extraUsers.nix-ssh.openssh.authorizedKeys.keys = cfg.keys;

     

       58
       58
       +
           users.users.nix-ssh.openssh.authorizedKeys.keys = cfg.keys;

     

       59
       59
        
       

     

       60
       60
        
         };

     

       61
       61
        
       }

+2 -2

nixos/modules/services/misc/nzbget.nix

···

       86
       86
        
             };

     

       87
       87
        
           };

     

       88
       88
        
       

     

       89
       89
       -
           users.extraUsers = mkIf (cfg.user == "nzbget") {

     

       89
       89
       +
           users.users = mkIf (cfg.user == "nzbget") {

     

       90
       90
        
             nzbget = {

     

       91
       91
        
               group = cfg.group;

     

       92
       92
        
               uid = config.ids.uids.nzbget;

     

       93
       93
        
             };

     

       94
       94
        
           };

     

       95
       95
        
       

     

       96
       96
       -
           users.extraGroups = mkIf (cfg.group == "nzbget") {

     

       96
       96
       +
           users.groups = mkIf (cfg.group == "nzbget") {

     

       97
       97
        
             nzbget = {

     

       98
       98
        
               gid = config.ids.gids.nzbget;

     

       99
       99
        
             };

+2 -2

nixos/modules/services/misc/octoprint.nix

···

       86
       86
        
       

     

       87
       87
        
         config = mkIf cfg.enable {

     

       88
       88
        
       

     

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

     

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

     

       90
       90
        
             { name = "octoprint";

     

       91
       91
        
               group = cfg.group;

     

       92
       92
        
               uid = config.ids.uids.octoprint;

     

       93
       93
        
             });

     

       94
       94
        
       

     

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

     

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

     

       96
       96
        
             { name = "octoprint";

     

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

     

       98
       98
        
             });

+1 -1

nixos/modules/services/misc/osrm.nix

···

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

     

       70
       70
        
       

     

       71
       71
        
             serviceConfig = {

     

       72
       72
       -
               User = config.users.extraUsers.osrm.name;

     

       72
       72
       +
               User = config.users.users.osrm.name;

     

       73
       73
        
               ExecStart = ''

     

       74
       74
        
                 ${pkgs.osrm-backend}/bin/osrm-routed \

     

       75
       75
        
                   --ip ${cfg.address} \

+2 -2

nixos/modules/services/misc/plex.nix

···

       157
       157
        
             allowedUDPPorts = [ 1900 5353 32410 32412 32413 32414 ];

     

       158
       158
        
           };

     

       159
       159
        
       

     

       160
       160
       -
           users.extraUsers = mkIf (cfg.user == "plex") {

     

       160
       160
       +
           users.users = mkIf (cfg.user == "plex") {

     

       161
       161
        
             plex = {

     

       162
       162
        
               group = cfg.group;

     

       163
       163
        
               uid = config.ids.uids.plex;

     

       164
       164
        
             };

     

       165
       165
        
           };

     

       166
       166
        
       

     

       167
       167
       -
           users.extraGroups = mkIf (cfg.group == "plex") {

     

       167
       167
       +
           users.groups = mkIf (cfg.group == "plex") {

     

       168
       168
        
             plex = {

     

       169
       169
        
               gid = config.ids.gids.plex;

     

       170
       170
        
             };

+1 -1

nixos/modules/services/misc/plexpy.nix

···

       74
       74
        
             };

     

       75
       75
        
           };

     

       76
       76
        
       

     

       77
       77
       -
           users.extraUsers = mkIf (cfg.user == "plexpy") {

     

       77
       77
       +
           users.users = mkIf (cfg.user == "plexpy") {

     

       78
       78
        
             plexpy = { group = cfg.group; uid = config.ids.uids.plexpy; };

     

       79
       79
        
           };

     

       80
       80
        
         };

+2 -2

nixos/modules/services/misc/pykms.nix

···

       73
       73
        
           };

     

       74
       74
        
       

     

       75
       75
        
           users = {

     

       76
       76
       -
             extraUsers.pykms = {

     

       76
       76
       +
             users.pykms = {

     

       77
       77
        
               name = "pykms";

     

       78
       78
        
               group = "pykms";

     

       79
       79
        
               home  = home;

     
···

       82
       82
        
               description = "PyKMS daemon user";

     

       83
       83
        
             };

     

       84
       84
        
       

     

       85
       85
       -
             extraGroups.pykms = {

     

       85
       85
       +
             groups.pykms = {

     

       86
       86
        
               gid = config.ids.gids.pykms;

     

       87
       87
        
             };

     

       88
       88
        
           };

+2 -2

nixos/modules/services/misc/radarr.nix

···

       36
       36
        
             };

     

       37
       37
        
           };

     

       38
       38
        
       

     

       39
       39
       -
           users.extraUsers.radarr = {

     

       39
       39
       +
           users.users.radarr = {

     

       40
       40
        
             uid = config.ids.uids.radarr;

     

       41
       41
        
             home = "/var/lib/radarr";

     

       42
       42
        
             group = "radarr";

     

       43
       43
        
           };

     

       44
       44
       -
           users.extraGroups.radarr.gid = config.ids.gids.radarr;

     

       44
       44
       +
           users.groups.radarr.gid = config.ids.gids.radarr;

     

       45
       45
        
       

     

       46
       46
        
         };

     

       47
       47
        
       }

+2 -2

nixos/modules/services/misc/redmine.nix

···

       128
       128
        
             }

     

       129
       129
        
           ];

     

       130
       130
        
       

     

       131
       131
       -
           users.extraUsers = [

     

       131
       131
       +
           users.users = [

     

       132
       132
        
             { name = "redmine";

     

       133
       133
        
               group = "redmine";

     

       134
       134
        
               uid = config.ids.uids.redmine;

     

       135
       135
        
             } ];

     

       136
       136
        
       

     

       137
       137
       -
           users.extraGroups = [

     

       137
       137
       +
           users.groups = [

     

       138
       138
        
             { name = "redmine";

     

       139
       139
        
               gid = config.ids.gids.redmine;

     

       140
       140
        
             } ];

+1 -1

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

···

       185
       185
        
             ];

     

       186
       186
        
           };

     

       187
       187
        
       

     

       188
       188
       -
           users.extraUsers = singleton

     

       188
       188
       +
           users.users = singleton

     

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

     

       190
       190
        
               description = "Ripple data api user";

     

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

+1 -1

nixos/modules/services/misc/rippled.nix

···

       406
       406
        
       

     

       407
       407
        
         config = mkIf cfg.enable {

     

       408
       408
        
       

     

       409
       409
       -
           users.extraUsers = singleton

     

       409
       409
       +
           users.users = singleton

     

       410
       410
        
             { name = "rippled";

     

       411
       411
        
               description = "Ripple server user";

     

       412
       412
        
               uid = config.ids.uids.rippled;

+2 -2

nixos/modules/services/misc/serviio.nix

···

       63
       63
        
             };

     

       64
       64
        
           };

     

       65
       65
        
       

     

       66
       66
       -
           users.extraUsers = [

     

       66
       66
       +
           users.users = [

     

       67
       67
        
             { 

     

       68
       68
        
               name = "serviio";

     

       69
       69
        
               group = "serviio";

     
···

       74
       74
        
             }

     

       75
       75
        
           ];

     

       76
       76
        
       

     

       77
       77
       -
           users.extraGroups = [

     

       77
       77
       +
           users.groups = [

     

       78
       78
        
             { name = "serviio";} 

     

       79
       79
        
           ];

     

       80
       80

+1 -1

nixos/modules/services/misc/siproxd.nix

···

       161
       161
        
       

     

       162
       162
        
         config = mkIf cfg.enable {

     

       163
       163
        
       

     

       164
       164
       -
           users.extraUsers = singleton {

     

       164
       164
       +
           users.users = singleton {

     

       165
       165
        
             name = "siproxyd";

     

       166
       166
        
             uid = config.ids.uids.siproxd;

     

       167
       167
        
           };

+2 -2

nixos/modules/services/misc/sonarr.nix

···

       36
       36
        
             };

     

       37
       37
        
           };

     

       38
       38
        
       

     

       39
       39
       -
           users.extraUsers.sonarr = {

     

       39
       39
       +
           users.users.sonarr = {

     

       40
       40
        
             uid = config.ids.uids.sonarr;

     

       41
       41
        
             home = "/var/lib/sonarr";

     

       42
       42
        
             group = "sonarr";

     

       43
       43
        
           };

     

       44
       44
       -
           users.extraGroups.sonarr.gid = config.ids.gids.sonarr;

     

       44
       44
       +
           users.groups.sonarr.gid = config.ids.gids.sonarr;

     

       45
       45
        
       

     

       46
       46
        
         };

     

       47
       47
        
       }

+3 -3

nixos/modules/services/misc/subsonic.nix

···

       130
       130
        
                       ! [ -e "${cfg.home}" ] &&

     

       131
       131
        
                       [ -d "$oldHome" ] &&

     

       132
       132
        
                       [ $(${pkgs.coreutils}/bin/stat -c %u "$oldHome") -eq \

     

       133
       133
       -
                           ${toString config.users.extraUsers.subsonic.uid} ]; then

     

       133
       133
       +
                           ${toString config.users.users.subsonic.uid} ]; then

     

       134
       134
        
                   logger Moving "$oldHome" to "${cfg.home}"

     

       135
       135
        
                   ${pkgs.coreutils}/bin/mv -T "$oldHome" "${cfg.home}"

     

       136
       136
        
               fi

     
···

       152
       152
        
             };

     

       153
       153
        
           };

     

       154
       154
        
       

     

       155
       155
       -
           users.extraUsers.subsonic = {

     

       155
       155
       +
           users.users.subsonic = {

     

       156
       156
        
             description = "Subsonic daemon user";

     

       157
       157
        
             home = cfg.home;

     

       158
       158
        
             createHome = true;

     
···

       160
       160
        
             uid = config.ids.uids.subsonic;

     

       161
       161
        
           };

     

       162
       162
        
       

     

       163
       163
       -
           users.extraGroups.subsonic.gid = config.ids.gids.subsonic;

     

       163
       163
       +
           users.groups.subsonic.gid = config.ids.gids.subsonic;

     

       164
       164
        
         };

     

       165
       165
        
       }

+2 -2

nixos/modules/services/misc/uhub.nix

···

       161
       161
        
         config = mkIf cfg.enable {

     

       162
       162
        
       

     

       163
       163
        
           users = {

     

       164
       164
       -
             extraUsers = singleton {

     

       164
       164
       +
             users = singleton {

     

       165
       165
        
               name = "uhub";

     

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

     

       167
       167
        
             };

     

       168
       168
       -
             extraGroups = singleton {

     

       168
       168
       +
             groups = singleton {

     

       169
       169
        
               name = "uhub";

     

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

     

       171
       171
        
             };

+1 -1

nixos/modules/services/misc/zookeeper.nix

···

       144
       144
        
             '';

     

       145
       145
        
           };

     

       146
       146
        
       

     

       147
       147
       -
           users.extraUsers = singleton {

     

       147
       147
       +
           users.users = singleton {

     

       148
       148
        
             name = "zookeeper";

     

       149
       149
        
             uid = config.ids.uids.zookeeper;

     

       150
       150
        
             description = "Zookeeper daemon user";

+2 -2

nixos/modules/services/monitoring/bosun.nix

···

       153
       153
        
             };

     

       154
       154
        
           };

     

       155
       155
        
       

     

       156
       156
       -
           users.extraUsers.bosun = {

     

       156
       156
       +
           users.users.bosun = {

     

       157
       157
        
             description = "bosun user";

     

       158
       158
        
             group = "bosun";

     

       159
       159
        
             uid = config.ids.uids.bosun;

     

       160
       160
        
           };

     

       161
       161
        
       

     

       162
       162
       -
           users.extraGroups.bosun.gid = config.ids.gids.bosun;

     

       162
       162
       +
           users.groups.bosun.gid = config.ids.gids.bosun;

     

       163
       163
        
       

     

       164
       164
        
         };

     

       165
       165

+1 -1

nixos/modules/services/monitoring/collectd.nix

···

       97
       97
        
             '';

     

       98
       98
        
           };

     

       99
       99
        
       

     

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

     

       100
       100
       +
           users.users = optional (cfg.user == "collectd") {

     

       101
       101
        
             name = "collectd";

     

       102
       102
        
           };

     

       103
       103
        
         };

+2 -2

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

···

       178
       178
        
         config = mkIf cfg.enable {

     

       179
       179
        
           environment.systemPackages = [ pkgs."dd-agent" pkgs.sysstat pkgs.procps ];

     

       180
       180
        
       

     

       181
       181
       -
           users.extraUsers.datadog = {

     

       181
       181
       +
           users.users.datadog = {

     

       182
       182
        
             description = "Datadog Agent User";

     

       183
       183
        
             uid = config.ids.uids.datadog;

     

       184
       184
        
             group = "datadog";

     
···

       186
       186
        
             createHome = true;

     

       187
       187
        
           };

     

       188
       188
        
       

     

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

     

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

     

       190
       190
        
       

     

       191
       191
        
           systemd.services.dd-agent = {

     

       192
       192
        
             description = "Datadog agent monitor";

+1 -1

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

···

       46
       46
        
       

     

       47
       47
        
         config = mkIf cfg.enable {

     

       48
       48
        
       

     

       49
       49
       -
           users.extraUsers = singleton {

     

       49
       49
       +
           users.users = singleton {

     

       50
       50
        
             name = "fusion-inventory";

     

       51
       51
        
             description = "FusionInventory user";

     

       52
       52
        
           };

+1 -1

nixos/modules/services/monitoring/grafana.nix

···

       265
       265
        
             '';

     

       266
       266
        
           };

     

       267
       267
        
       

     

       268
       268
       -
           users.extraUsers.grafana = {

     

       268
       268
       +
           users.users.grafana = {

     

       269
       269
        
             uid = config.ids.uids.grafana;

     

       270
       270
        
             description = "Grafana user";

     

       271
       271
        
             home = cfg.dataDir;

+2 -2

nixos/modules/services/monitoring/graphite.nix

···

       638
       638
        
             cfg.web.enable || cfg.api.enable ||

     

       639
       639
        
             cfg.seyren.enable || cfg.pager.enable || cfg.beacon.enable

     

       640
       640
        
            ) {

     

       641
       641
       -
             users.extraUsers = singleton {

     

       641
       641
       +
             users.users = singleton {

     

       642
       642
        
               name = "graphite";

     

       643
       643
        
               uid = config.ids.uids.graphite;

     

       644
       644
        
               description = "Graphite daemon user";

     

       645
       645
        
               home = dataDir;

     

       646
       646
        
             };

     

       647
       647
       -
             users.extraGroups.graphite.gid = config.ids.gids.graphite;

     

       647
       647
       +
             users.groups.graphite.gid = config.ids.gids.graphite;

     

       648
       648
        
           })

     

       649
       649
        
         ];

     

       650
       650
        
       }

+1 -1

nixos/modules/services/monitoring/heapster.nix

···

       49
       49
        
             };

     

       50
       50
        
           };

     

       51
       51
        
       

     

       52
       52
       -
           users.extraUsers = singleton {

     

       52
       52
       +
           users.users = singleton {

     

       53
       53
        
             name = "heapster";

     

       54
       54
        
             uid = config.ids.uids.heapster;

     

       55
       55
        
             description = "Heapster user";

+2 -2

nixos/modules/services/monitoring/munin.nix

···

       150
       150
        
       

     

       151
       151
        
           environment.systemPackages = [ pkgs.munin ];

     

       152
       152
        
       

     

       153
       153
       -
           users.extraUsers = [{

     

       153
       153
       +
           users.users = [{

     

       154
       154
        
             name = "munin";

     

       155
       155
        
             description = "Munin monitoring user";

     

       156
       156
        
             group = "munin";

     

       157
       157
        
             uid = config.ids.uids.munin;

     

       158
       158
        
           }];

     

       159
       159
        
       

     

       160
       160
       -
           users.extraGroups = [{

     

       160
       160
       +
           users.groups = [{

     

       161
       161
        
             name = "munin";

     

       162
       162
        
             gid = config.ids.gids.munin;

     

       163
       163
        
           }];

+1 -1

nixos/modules/services/monitoring/nagios.nix

···

       143
       143
        
       

     

       144
       144
        
       

     

       145
       145
        
         config = mkIf cfg.enable {

     

       146
       146
       -
           users.extraUsers.nagios = {

     

       146
       146
       +
           users.users.nagios = {

     

       147
       147
        
             description = "Nagios user ";

     

       148
       148
        
             uid         = config.ids.uids.nagios;

     

       149
       149
        
             home        = nagiosState;

+2 -2

nixos/modules/services/monitoring/netdata.nix

···

       100
       100
        
           };

     

       101
       101
        
       

     

       102
       102
        
       

     

       103
       103
       -
           users.extraUsers = optional (cfg.user == defaultUser) {

     

       103
       103
       +
           users.users = optional (cfg.user == defaultUser) {

     

       104
       104
        
             name = defaultUser;

     

       105
       105
        
           };

     

       106
       106
        
       

     

       107
       107
       -
           users.extraGroups = optional (cfg.group == defaultUser) {

     

       107
       107
       +
           users.groups = optional (cfg.group == defaultUser) {

     

       108
       108
        
             name = defaultUser;

     

       109
       109
        
           };

     

       110
       110

+2 -2

nixos/modules/services/monitoring/prometheus/default.nix

···

       471
       471
        
         };

     

       472
       472
        
       

     

       473
       473
        
         config = mkIf cfg.enable {

     

       474
       474
       -
           users.extraGroups.${promGroup}.gid = config.ids.gids.prometheus;

     

       475
       475
       -
           users.extraUsers.${promUser} = {

     

       474
       474
       +
           users.groups.${promGroup}.gid = config.ids.gids.prometheus;

     

       475
       475
       +
           users.users.${promUser} = {

     

       476
       476
        
             description = "Prometheus daemon user";

     

       477
       477
        
             uid = config.ids.uids.prometheus;

     

       478
       478
        
             group = promGroup;

+2 -2

nixos/modules/services/monitoring/riemann-dash.nix

···

       51
       51
        
       

     

       52
       52
        
         config = mkIf cfg.enable {

     

       53
       53
        
       

     

       54
       54
       -
           users.extraGroups.riemanndash.gid = config.ids.gids.riemanndash;

     

       54
       54
       +
           users.groups.riemanndash.gid = config.ids.gids.riemanndash;

     

       55
       55
        
       

     

       56
       56
       -
           users.extraUsers.riemanndash = {

     

       56
       56
       +
           users.users.riemanndash = {

     

       57
       57
        
             description = "riemann-dash daemon user";

     

       58
       58
        
             uid = config.ids.uids.riemanndash;

     

       59
       59
        
             group = "riemanndash";

+2 -2

nixos/modules/services/monitoring/riemann-tools.nix

···

       40
       40
        
       

     

       41
       41
        
         config = mkIf cfg.enableHealth {

     

       42
       42
        
       

     

       43
       43
       -
           users.extraGroups.riemanntools.gid = config.ids.gids.riemanntools;

     

       43
       43
       +
           users.groups.riemanntools.gid = config.ids.gids.riemanntools;

     

       44
       44
        
       

     

       45
       45
       -
           users.extraUsers.riemanntools = {

     

       45
       45
       +
           users.users.riemanntools = {

     

       46
       46
        
             description = "riemann-tools daemon user";

     

       47
       47
        
             uid = config.ids.uids.riemanntools;

     

       48
       48
        
             group = "riemanntools";

+2 -2

nixos/modules/services/monitoring/riemann.nix

···

       69
       69
        
       

     

       70
       70
        
         config = mkIf cfg.enable {

     

       71
       71
        
       

     

       72
       72
       -
           users.extraGroups.riemann.gid = config.ids.gids.riemann;

     

       72
       72
       +
           users.groups.riemann.gid = config.ids.gids.riemann;

     

       73
       73
        
       

     

       74
       74
       -
           users.extraUsers.riemann = {

     

       74
       74
       +
           users.users.riemann = {

     

       75
       75
        
             description = "riemann daemon user";

     

       76
       76
        
             uid = config.ids.uids.riemann;

     

       77
       77
        
             group = "riemann";

+2 -2

nixos/modules/services/monitoring/scollector.nix

···

       123
       123
        
             };

     

       124
       124
        
           };

     

       125
       125
        
       

     

       126
       126
       -
           users.extraUsers.scollector = {

     

       126
       126
       +
           users.users.scollector = {

     

       127
       127
        
             description = "scollector user";

     

       128
       128
        
             group = "scollector";

     

       129
       129
        
             uid = config.ids.uids.scollector;

     

       130
       130
        
           };

     

       131
       131
        
       

     

       132
       132
       -
           users.extraGroups.scollector.gid = config.ids.gids.scollector;

     

       132
       132
       +
           users.groups.scollector.gid = config.ids.gids.scollector;

     

       133
       133
        
       

     

       134
       134
        
         };

     

       135
       135

+1 -1

nixos/modules/services/monitoring/statsd.nix

···

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

     

       126
       126
        
           }) cfg.backends;

     

       127
       127
        
       

     

       128
       128
       -
           users.extraUsers = singleton {

     

       128
       128
       +
           users.users = singleton {

     

       129
       129
        
             name = "statsd";

     

       130
       130
        
             uid = config.ids.uids.statsd;

     

       131
       131
        
             description = "Statsd daemon user";

+1 -1

nixos/modules/services/monitoring/telegraf.nix

···

       62
       62
        
             };

     

       63
       63
        
           };

     

       64
       64
        
       

     

       65
       65
       -
           users.extraUsers = [{

     

       65
       65
       +
           users.users = [{

     

       66
       66
        
             name = "telegraf";

     

       67
       67
        
             uid = config.ids.uids.telegraf;

     

       68
       68
        
             description = "telegraf daemon user";

+2 -2

nixos/modules/services/monitoring/ups.nix

···

       259
       259
        
       

     

       260
       260
        
       

     

       261
       261
        
       /*

     

       262
       262
       -
           users.extraUsers = [

     

       262
       262
       +
           users.users = [

     

       263
       263
        
             { name = "nut";

     

       264
       264
        
               uid = 84;

     

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

     
···

       269
       269
        
             }

     

       270
       270
        
           ];

     

       271
       271
        
       

     

       272
       272
       -
           users.extraGroups = [

     

       272
       272
       +
           users.groups = [

     

       273
       273
        
             { name = "nut";

     

       274
       274
        
               gid = 84;

     

       275
       275
        
             }

+1 -1

nixos/modules/services/monitoring/vnstat.nix

···

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         config = mkIf cfg.enable {

     

       19
       19
       -
           users.extraUsers.vnstatd = {

     

       19
       19
       +
           users.users.vnstatd = {

     

       20
       20
        
             isSystemUser = true;

     

       21
       21
        
             description = "vnstat daemon user";

     

       22
       22
        
             home = "/var/lib/vnstat";

+1 -1

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

···

       68
       68
        
       

     

       69
       69
        
         config = mkIf cfg.enable {

     

       70
       70
        
       

     

       71
       71
       -
           users.extraUsers = mkIf (!config.services.zabbixServer.enable) (singleton

     

       71
       71
       +
           users.users = mkIf (!config.services.zabbixServer.enable) (singleton

     

       72
       72
        
             { name = "zabbix";

     

       73
       73
        
               uid = config.ids.uids.zabbix;

     

       74
       74
        
               description = "Zabbix daemon user";

+1 -1

nixos/modules/services/monitoring/zabbix-server.nix

···

       85
       85
        
       

     

       86
       86
        
           services.postgresql.enable = useLocalPostgres;

     

       87
       87
        
       

     

       88
       88
       -
           users.extraUsers = singleton

     

       88
       88
       +
           users.users = singleton

     

       89
       89
        
             { name = "zabbix";

     

       90
       90
        
               uid = config.ids.uids.zabbix;

     

       91
       91
        
               description = "Zabbix daemon user";

+2 -2

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

···

       332
       332
        
             in

     

       333
       333
        
               generators.toINI {} totalConfig;

     

       334
       334
        
       

     

       335
       335
       -
           users.extraUsers = singleton {

     

       335
       335
       +
           users.users = singleton {

     

       336
       336
        
             name = "ceph";

     

       337
       337
        
             uid = config.ids.uids.ceph;

     

       338
       338
        
             description = "Ceph daemon user";

     

       339
       339
        
           };

     

       340
       340
        
       

     

       341
       341
       -
           users.extraGroups = singleton {

     

       341
       341
       +
           users.groups = singleton {

     

       342
       342
        
             name = "ceph";

     

       343
       343
        
             gid = config.ids.gids.ceph;

     

       344
       344
        
           };

+2 -2

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

···

       57
       57
        
           environment.systemPackages = [ pkgs.davfs2 ];

     

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

     

       59
       59
        
       

     

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

     

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

     

       61
       61
        
             name = "davfs2";

     

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

     

       63
       63
        
           });

     

       64
       64
        
       

     

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

     

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

     

       66
       66
        
             name = "davfs2";

     

       67
       67
        
             createHome = false;

     

       68
       68
        
             group = cfg.davGroup;

+2 -2

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

···

       212
       212
        
             user_allow_other

     

       213
       213
        
           ''; };

     

       214
       214
        
       

     

       215
       215
       -
           users.extraUsers = mkIf (cfg.user == "ipfs") {

     

       215
       215
       +
           users.users = mkIf (cfg.user == "ipfs") {

     

       216
       216
        
             ipfs = {

     

       217
       217
        
               group = cfg.group;

     

       218
       218
        
               home = cfg.dataDir;

     
···

       222
       222
        
             };

     

       223
       223
        
           };

     

       224
       224
        
       

     

       225
       225
       -
           users.extraGroups = mkIf (cfg.group == "ipfs") {

     

       225
       225
       +
           users.groups = mkIf (cfg.group == "ipfs") {

     

       226
       226
        
             ipfs.gid = config.ids.gids.ipfs;

     

       227
       227
        
           };

     

       228
       228

+2 -2

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

···

       255
       255
        
                     cp /etc/tahoe-lafs/introducer-"${node}".cfg ${lib.escapeShellArg nodedir}/tahoe.cfg

     

       256
       256
        
                   '';

     

       257
       257
        
                 });

     

       258
       258
       -
               users.extraUsers = flip mapAttrs' cfg.introducers (node: _:

     

       258
       258
       +
               users.users = flip mapAttrs' cfg.introducers (node: _:

     

       259
       259
        
                 nameValuePair "tahoe.introducer-${node}" {

     

       260
       260
        
                   description = "Tahoe node user for introducer ${node}";

     

       261
       261
        
                   isSystemUser = true;

     
···

       355
       355
        
                     cp /etc/tahoe-lafs/${lib.escapeShellArg node}.cfg ${lib.escapeShellArg nodedir}/tahoe.cfg

     

       356
       356
        
                   '';

     

       357
       357
        
                 });

     

       358
       358
       -
               users.extraUsers = flip mapAttrs' cfg.nodes (node: _:

     

       358
       358
       +
               users.users = flip mapAttrs' cfg.nodes (node: _:

     

       359
       359
        
                 nameValuePair "tahoe.${node}" {

     

       360
       360
        
                   description = "Tahoe node user for node ${node}";

     

       361
       361
        
                   isSystemUser = true;

+2 -2

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

···

       432
       432
        
       

     

       433
       433
        
           environment.systemPackages = [ xtreemfs ];

     

       434
       434
        
       

     

       435
       435
       -
           users.extraUsers.xtreemfs =

     

       435
       435
       +
           users.users.xtreemfs =

     

       436
       436
        
             { uid = config.ids.uids.xtreemfs;

     

       437
       437
        
               description = "XtreemFS user";

     

       438
       438
        
               createHome = true;

     

       439
       439
        
               home = home;

     

       440
       440
        
             };

     

       441
       441
        
       

     

       442
       442
       -
           users.extraGroups.xtreemfs =

     

       442
       442
       +
           users.groups.xtreemfs =

     

       443
       443
        
             { gid = config.ids.gids.xtreemfs;

     

       444
       444
        
             };

     

       445
       445

+1 -1

nixos/modules/services/network-filesystems/yandex-disk.nix

···

       73
       73
        
       

     

       74
       74
        
         config = mkIf cfg.enable {

     

       75
       75
        
       

     

       76
       76
       -
           users.extraUsers = mkIf (cfg.user == null) [ {

     

       76
       76
       +
           users.users = mkIf (cfg.user == null) [ {

     

       77
       77
        
             name = u;

     

       78
       78
        
             uid = config.ids.uids.yandexdisk;

     

       79
       79
        
             group = "nogroup";

+2 -2

nixos/modules/services/networking/amuled.nix

···

       45
       45
        
       

     

       46
       46
        
         config = mkIf cfg.enable {

     

       47
       47
        
       

     

       48
       48
       -
           users.extraUsers = mkIf (cfg.user == null) [

     

       48
       48
       +
           users.users = mkIf (cfg.user == null) [

     

       49
       49
        
             { name = "amule";

     

       50
       50
        
               description = "AMule daemon";

     

       51
       51
        
               group = "amule";

     

       52
       52
        
               uid = config.ids.uids.amule;

     

       53
       53
        
             } ];

     

       54
       54
        
       

     

       55
       55
       -
           users.extraGroups = mkIf (cfg.user == null) [

     

       55
       55
       +
           users.groups = mkIf (cfg.user == null) [

     

       56
       56
        
             { name = "amule";

     

       57
       57
        
               gid = config.ids.gids.amule;

     

       58
       58
        
             } ];

+2 -2

nixos/modules/services/networking/aria2.nix

···

       92
       92
        
             allowedTCPPorts = [ config.services.aria2.rpcListenPort ];

     

       93
       93
        
           };

     

       94
       94
        
       

     

       95
       95
       -
           users.extraUsers.aria2 = {

     

       95
       95
       +
           users.users.aria2 = {

     

       96
       96
        
             group = "aria2";

     

       97
       97
        
             uid = config.ids.uids.aria2;

     

       98
       98
        
             description = "aria2 user";

     
···

       100
       100
        
             createHome = false;

     

       101
       101
        
           };

     

       102
       102
        
       

     

       103
       103
       -
           users.extraGroups.aria2.gid = config.ids.gids.aria2;

     

       103
       103
       +
           users.groups.aria2.gid = config.ids.gids.aria2;

     

       104
       104
        
       

     

       105
       105
        
           systemd.services.aria2 = {

     

       106
       106
        
             description = "aria2 Service";

+2 -2

nixos/modules/services/networking/asterisk.nix

···

       211
       211
        
       

     

       212
       212
        
           environment.etc.asterisk.source = asteriskEtc;

     

       213
       213
        
       

     

       214
       214
       -
           users.extraUsers.asterisk =

     

       214
       214
       +
           users.users.asterisk =

     

       215
       215
        
             { name = asteriskUser;

     

       216
       216
        
               group = asteriskGroup;

     

       217
       217
        
               uid = config.ids.uids.asterisk;

     
···

       219
       219
        
               home = varlibdir;

     

       220
       220
        
             };

     

       221
       221
        
       

     

       222
       222
       -
           users.extraGroups.asterisk =

     

       222
       222
       +
           users.groups.asterisk =

     

       223
       223
        
             { name = asteriskGroup;

     

       224
       224
        
               gid = config.ids.gids.asterisk;

     

       225
       225
        
             };

+2 -2

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

···

       187
       187
        
       

     

       188
       188
        
           services.avahi.hostName = mkDefault config.networking.hostName;

     

       189
       189
        
       

     

       190
       190
       -
           users.extraUsers = singleton

     

       190
       190
       +
           users.users = singleton

     

       191
       191
        
             { name = "avahi";

     

       192
       192
        
               uid = config.ids.uids.avahi;

     

       193
       193
        
               description = "`avahi-daemon' privilege separation user";

     

       194
       194
        
               home = "/var/empty";

     

       195
       195
        
             };

     

       196
       196
        
       

     

       197
       197
       -
           users.extraGroups = singleton

     

       197
       197
       +
           users.groups = singleton

     

       198
       198
        
             { name = "avahi";

     

       199
       199
        
               gid = config.ids.gids.avahi;

     

       200
       200
        
             };

+1 -1

nixos/modules/services/networking/bind.nix

···

       170
       170
        
       

     

       171
       171
        
         config = mkIf config.services.bind.enable {

     

       172
       172
        
       

     

       173
       173
       -
           users.extraUsers = singleton

     

       173
       173
       +
           users.users = singleton

     

       174
       174
        
             { name = bindUser;

     

       175
       175
        
               uid = config.ids.uids.bind;

     

       176
       176
        
               description = "BIND daemon user";

+2 -2

nixos/modules/services/networking/bird.nix

···

       60
       60
        
                 };

     

       61
       61
        
               };

     

       62
       62
        
               users = {

     

       63
       63
       -
                 extraUsers.${variant} = {

     

       63
       63
       +
                 users.${variant} = {

     

       64
       64
        
                   description = "BIRD Internet Routing Daemon user";

     

       65
       65
        
                   group = variant;

     

       66
       66
        
                 };

     

       67
       67
       -
                 extraGroups.${variant} = {};

     

       67
       67
       +
                 groups.${variant} = {};

     

       68
       68
        
               };

     

       69
       69
        
             };

     

       70
       70
        
           };

+2 -2

nixos/modules/services/networking/bitlbee.nix

···

       149
       149
        
       

     

       150
       150
        
         config = mkIf config.services.bitlbee.enable {

     

       151
       151
        
       

     

       152
       152
       -
           users.extraUsers = singleton

     

       152
       152
       +
           users.users = singleton

     

       153
       153
        
             { name = "bitlbee";

     

       154
       154
        
               uid = bitlbeeUid;

     

       155
       155
        
               description = "BitlBee user";

     
···

       157
       157
        
               createHome = true;

     

       158
       158
        
             };

     

       159
       159
        
       

     

       160
       160
       -
           users.extraGroups = singleton

     

       160
       160
       +
           users.groups = singleton

     

       161
       161
        
             { name = "bitlbee";

     

       162
       162
        
               gid = config.ids.gids.bitlbee;

     

       163
       163
        
             };

+2 -2

nixos/modules/services/networking/btsync.nix

···

       284
       284
        
       

     

       285
       285
        
           services.btsync.package = mkOptionDefault pkgs.bittorrentSync14;

     

       286
       286
        
       

     

       287
       287
       -
           users.extraUsers.btsync = {

     

       287
       287
       +
           users.users.btsync = {

     

       288
       288
        
             description     = "Bittorrent Sync Service user";

     

       289
       289
        
             home            = cfg.storagePath;

     

       290
       290
        
             createHome      = true;

     
···

       292
       292
        
             group           = "btsync";

     

       293
       293
        
           };

     

       294
       294
        
       

     

       295
       295
       -
           users.extraGroups = [

     

       295
       295
       +
           users.groups = [

     

       296
       296
        
             { name = "btsync";

     

       297
       297
        
             }];

     

       298
       298

+2 -2

nixos/modules/services/networking/charybdis.nix

···

       71
       71
        
       

     

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

     

       73
       73
        
           {

     

       74
       74
       -
             users.extraUsers = singleton {

     

       74
       74
       +
             users.users = singleton {

     

       75
       75
        
               name = cfg.user;

     

       76
       76
        
               description = "Charybdis IRC daemon user";

     

       77
       77
        
               uid = config.ids.uids.ircd;

     

       78
       78
        
               group = cfg.group;

     

       79
       79
        
             };

     

       80
       80
        
       

     

       81
       81
       -
             users.extraGroups = singleton {

     

       81
       81
       +
             users.groups = singleton {

     

       82
       82
        
               name = cfg.group;

     

       83
       83
        
               gid = config.ids.gids.ircd;

     

       84
       84
        
             };

+2 -2

nixos/modules/services/networking/chrony.nix

···

       96
       96
        
           # Make chronyc available in the system path

     

       97
       97
        
           environment.systemPackages = [ pkgs.chrony ];

     

       98
       98
        
       

     

       99
       99
       -
           users.extraGroups = singleton

     

       99
       99
       +
           users.groups = singleton

     

       100
       100
        
             { name = "chrony";

     

       101
       101
        
               gid = config.ids.gids.chrony;

     

       102
       102
        
             };

     

       103
       103
        
       

     

       104
       104
       -
           users.extraUsers = singleton

     

       104
       104
       +
           users.users = singleton

     

       105
       105
        
             { name = "chrony";

     

       106
       106
        
               uid = config.ids.uids.chrony;

     

       107
       107
        
               group = "chrony";

+1 -1

nixos/modules/services/networking/cntlm.nix

···

       117
       117
        
             };

     

       118
       118
        
           };

     

       119
       119
        
       

     

       120
       120
       -
           users.extraUsers.cntlm = {

     

       120
       120
       +
           users.users.cntlm = {

     

       121
       121
        
             name = "cntlm";

     

       122
       122
        
             description = "cntlm system-wide daemon";

     

       123
       123
        
             isSystemUser = true;

+1 -1

nixos/modules/services/networking/consul.nix

···

       155
       155
        
         config = mkIf cfg.enable (

     

       156
       156
        
           mkMerge [{

     

       157
       157
        
       

     

       158
       158
       -
             users.extraUsers."consul" = {

     

       158
       158
       +
             users.users."consul" = {

     

       159
       159
        
               description = "Consul agent daemon user";

     

       160
       160
        
               uid = config.ids.uids.consul;

     

       161
       161
        
               # The shell is needed for health checks

+2 -2

nixos/modules/services/networking/coturn.nix

···

       294
       294
        
         };

     

       295
       295
        
       

     

       296
       296
        
         config = mkIf cfg.enable {

     

       297
       297
       -
           users.extraUsers = [

     

       297
       297
       +
           users.users = [

     

       298
       298
        
             { name = "turnserver";

     

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

     

       300
       300
        
               description = "coturn TURN server user";

     

       301
       301
        
             } ];

     

       302
       302
       -
           users.extraGroups = [

     

       302
       302
       +
           users.groups = [

     

       303
       303
        
             { name = "turnserver";

     

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

     

       305
       305
        
               members = [ "turnserver" ];

+1 -1

nixos/modules/services/networking/dhcpd.nix

···

       197
       197
        
         config = mkIf (cfg4.enable || cfg6.enable) {

     

       198
       198
        
       

     

       199
       199
        
           users = {

     

       200
       200
       -
             extraUsers.dhcpd = {

     

       200
       200
       +
             users.dhcpd = {

     

       201
       201
        
               uid = config.ids.uids.dhcpd;

     

       202
       202
        
               description = "DHCP daemon user";

     

       203
       203
        
             };

+1 -1

nixos/modules/services/networking/dnscache.nix

···

       84
       84
        
       

     

       85
       85
        
         config = mkIf config.services.dnscache.enable {

     

       86
       86
        
           environment.systemPackages = [ pkgs.djbdns ];

     

       87
       87
       -
           users.extraUsers.dnscache = {};

     

       87
       87
       +
           users.users.dnscache = {};

     

       88
       88
        
       

     

       89
       89
        
           systemd.services.dnscache = {

     

       90
       90
        
             description = "djbdns dnscache server";

+1 -1

nixos/modules/services/networking/dnschain.nix

···

       141
       141
        
               dns = "127.0.0.1:${toString cfg.dns.port}";

     

       142
       142
        
             };

     

       143
       143
        
       

     

       144
       144
       -
           users.extraUsers = singleton {

     

       144
       144
       +
           users.users = singleton {

     

       145
       145
        
             name = username;

     

       146
       146
        
             description = "DNSChain daemon user";

     

       147
       147
        
             home = dataDir;

+1 -1

nixos/modules/services/networking/dnsmasq.nix

···

       86
       86
        
       

     

       87
       87
        
           services.dbus.packages = [ dnsmasq ];

     

       88
       88
        
       

     

       89
       89
       -
           users.extraUsers = singleton {

     

       89
       89
       +
           users.users = singleton {

     

       90
       90
        
             name = "dnsmasq";

     

       91
       91
        
             uid = config.ids.uids.dnsmasq;

     

       92
       92
        
             description = "Dnsmasq daemon user";

+2 -2

nixos/modules/services/networking/ejabberd.nix

···

       94
       94
        
         config = mkIf cfg.enable {

     

       95
       95
        
           environment.systemPackages = [ cfg.package ];

     

       96
       96
        
       

     

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

     

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

     

       98
       98
        
             { name = "ejabberd";

     

       99
       99
        
               group = cfg.group;

     

       100
       100
        
               home = cfg.spoolDir;

     
···

       102
       102
        
               uid = config.ids.uids.ejabberd;

     

       103
       103
        
             });

     

       104
       104
        
       

     

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

     

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

     

       106
       106
        
             { name = "ejabberd";

     

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

     

       108
       108
        
             });

+2 -2

nixos/modules/services/networking/freenet.nix

···

       50
       50
        
             serviceConfig.Nice = cfg.nice;

     

       51
       51
        
           };

     

       52
       52
        
       

     

       53
       53
       -
           users.extraUsers.freenet = {

     

       53
       53
       +
           users.users.freenet = {

     

       54
       54
        
             group = "freenet";

     

       55
       55
        
             description = "Freenet daemon user";

     

       56
       56
        
             home = varDir;

     
···

       58
       58
        
             uid = config.ids.uids.freenet;

     

       59
       59
        
           };

     

       60
       60
        
       

     

       61
       61
       -
           users.extraGroups.freenet.gid = config.ids.gids.freenet;

     

       61
       61
       +
           users.groups.freenet.gid = config.ids.gids.freenet;

     

       62
       62
        
         };

     

       63
       63
        
       

     

       64
       64
        
       }

+1 -1

nixos/modules/services/networking/freeradius.nix

···

       59
       59
        
         config = mkIf (cfg.enable) {

     

       60
       60
        
       

     

       61
       61
        
           users = {

     

       62
       62
       -
             extraUsers.radius = {

     

       62
       62
       +
             users.radius = {

     

       63
       63
        
               /*uid = config.ids.uids.radius;*/

     

       64
       64
        
               description = "Radius daemon user";

     

       65
       65
        
             };

+2 -2

nixos/modules/services/networking/gale.nix

···

       104
       104
        
                systemPackages = [ pkgs.gale ];

     

       105
       105
        
              };

     

       106
       106
        
       

     

       107
       107
       -
              users.extraUsers = [{

     

       107
       107
       +
              users.users = [{

     

       108
       108
        
                name = cfg.user;

     

       109
       109
        
                description = "Gale daemon";

     

       110
       110
        
                uid = config.ids.uids.gale;

     
···

       113
       113
        
                createHome = true;

     

       114
       114
        
              }];

     

       115
       115
        
       

     

       116
       116
       -
              users.extraGroups = [{

     

       116
       116
       +
              users.groups = [{

     

       117
       117
        
                name = cfg.group;

     

       118
       118
        
                gid = config.ids.gids.gale;

     

       119
       119
        
              }];

+2 -2

nixos/modules/services/networking/gateone.nix

···

       23
       23
        
         environment.systemPackages = with pkgs.pythonPackages; [

     

       24
       24
        
           gateone pkgs.openssh pkgs.procps pkgs.coreutils pkgs.cacert];

     

       25
       25
        
       

     

       26
       26
       -
         users.extraUsers.gateone = {

     

       26
       26
       +
         users.users.gateone = {

     

       27
       27
        
           description = "GateOne privilege separation user";

     

       28
       28
        
           uid = config.ids.uids.gateone;

     

       29
       29
        
           home = cfg.settingsDir;

     

       30
       30
        
         };

     

       31
       31
       -
         users.extraGroups.gateone.gid = config.ids.gids.gateone;

     

       31
       31
       +
         users.groups.gateone.gid = config.ids.gids.gateone;

     

       32
       32
        
       

     

       33
       33
        
         systemd.services.gateone = with pkgs; {

     

       34
       34
        
           description = "GateOne web-based terminal";

+2 -2

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

···

       104
       104
        
       

     

       105
       105
        
         config = mkIf cfg.enable {

     

       106
       106
        
       

     

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

     

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

     

       108
       108
        
             { name = "git";

     

       109
       109
        
               uid = config.ids.uids.git;

     

       110
       110
        
               description = "Git daemon user";

     

       111
       111
        
             };

     

       112
       112
        
       

     

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

     

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

     

       114
       114
        
             { name = "git";

     

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

     

       116
       116
        
             };

+2 -2

nixos/modules/services/networking/gnunet.nix

···

       126
       126
        
       

     

       127
       127
        
         config = mkIf config.services.gnunet.enable {

     

       128
       128
        
       

     

       129
       129
       -
           users.extraUsers.gnunet = {

     

       129
       129
       +
           users.users.gnunet = {

     

       130
       130
        
             group = "gnunet";

     

       131
       131
        
             description = "GNUnet User";

     

       132
       132
        
             home = homeDir;

     
···

       134
       134
        
             uid = config.ids.uids.gnunet;

     

       135
       135
        
           };

     

       136
       136
        
       

     

       137
       137
       -
           users.extraGroups.gnunet.gid = config.ids.gids.gnunet;

     

       137
       137
       +
           users.groups.gnunet.gid = config.ids.gids.gnunet;

     

       138
       138
        
       

     

       139
       139
        
           # The user tools that talk to `gnunetd' should come from the same source,

     

       140
       140
        
           # so install them globally.

+1 -1

nixos/modules/services/networking/hans.nix

···

       135
       135
        
             };

     

       136
       136
        
           };

     

       137
       137
        
       

     

       138
       138
       -
           users.extraUsers = singleton {

     

       138
       138
       +
           users.users = singleton {

     

       139
       139
        
             name = hansUser;

     

       140
       140
        
             description = "Hans daemon user";

     

       141
       141
        
           };

+2 -2

nixos/modules/services/networking/haproxy.nix

···

       52
       52
        
       

     

       53
       53
        
           environment.systemPackages = [ pkgs.haproxy ];

     

       54
       54
        
       

     

       55
       55
       -
           users.extraUsers.haproxy = {

     

       55
       55
       +
           users.users.haproxy = {

     

       56
       56
        
             group = "haproxy";

     

       57
       57
        
             uid = config.ids.uids.haproxy;

     

       58
       58
        
           };

     

       59
       59
        
       

     

       60
       60
       -
           users.extraGroups.haproxy.gid = config.ids.uids.haproxy;

     

       60
       60
       +
           users.groups.haproxy.gid = config.ids.uids.haproxy;

     

       61
       61
        
         };

     

       62
       62
        
       }

+2 -2

nixos/modules/services/networking/i2p.nix

···

       11
       11
        
       

     

       12
       12
        
         ###### implementation

     

       13
       13
        
         config = mkIf cfg.enable {

     

       14
       14
       -
           users.extraUsers.i2p = {

     

       14
       14
       +
           users.users.i2p = {

     

       15
       15
        
             group = "i2p";

     

       16
       16
        
             description = "i2p User";

     

       17
       17
        
             home = homeDir;

     

       18
       18
        
             createHome = true;

     

       19
       19
        
             uid = config.ids.uids.i2p;

     

       20
       20
        
           };

     

       21
       21
       -
           users.extraGroups.i2p.gid = config.ids.gids.i2p;

     

       21
       21
       +
           users.groups.i2p.gid = config.ids.gids.i2p;

     

       22
       22
        
           systemd.services.i2p = {

     

       23
       23
        
             description = "I2P router with administration interface for hidden services";

     

       24
       24
        
             after = [ "network.target" ];

+2 -2

nixos/modules/services/networking/i2pd.nix

···

       456
       456
        
       

     

       457
       457
        
         config = mkIf cfg.enable {

     

       458
       458
        
       

     

       459
       459
       -
           users.extraUsers.i2pd = {

     

       459
       459
       +
           users.users.i2pd = {

     

       460
       460
        
             group = "i2pd";

     

       461
       461
        
             description = "I2Pd User";

     

       462
       462
        
             home = homeDir;

     
···

       464
       464
        
             uid = config.ids.uids.i2pd;

     

       465
       465
        
           };

     

       466
       466
        
       

     

       467
       467
       -
           users.extraGroups.i2pd.gid = config.ids.gids.i2pd;

     

       467
       467
       +
           users.groups.i2pd.gid = config.ids.gids.i2pd;

     

       468
       468
        
       

     

       469
       469
        
           systemd.services.i2pd = {

     

       470
       470
        
             description = "Minimal I2P router";

+2 -2

nixos/modules/services/networking/iodine.nix

···

       140
       140
        
             };

     

       141
       141
        
           };

     

       142
       142
        
       

     

       143
       143
       -
           users.extraUsers = singleton {

     

       143
       143
       +
           users.users = singleton {

     

       144
       144
        
             name = iodinedUser;

     

       145
       145
        
             uid = config.ids.uids.iodined;

     

       146
       146
        
             description = "Iodine daemon user";

     

       147
       147
        
           };

     

       148
       148
       -
           users.extraGroups.iodined.gid = config.ids.gids.iodined;

     

       148
       148
       +
           users.groups.iodined.gid = config.ids.gids.iodined;

     

       149
       149
        
         };

     

       150
       150
        
       }

+2 -2

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

···

       112
       112
        
       

     

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

     

       114
       114
        
       

     

       115
       115
       -
           users.extraUsers = singleton

     

       115
       115
       +
           users.users = singleton

     

       116
       116
        
             { name = "ircd";

     

       117
       117
        
               description = "IRCD owner";

     

       118
       118
        
               group = "ircd";

     

       119
       119
        
               uid = config.ids.uids.ircd;

     

       120
       120
        
             };

     

       121
       121
        
       

     

       122
       122
       -
           users.extraGroups.ircd.gid = config.ids.gids.ircd;

     

       122
       122
       +
           users.groups.ircd.gid = config.ids.gids.ircd;

     

       123
       123
        
       

     

       124
       124
        
           systemd.services."ircd-hybrid" = {

     

       125
       125
        
             description = "IRCD Hybrid server";

+2 -2

nixos/modules/services/networking/kippo.nix

···

       73
       73
        
               ${cfg.extraConfig}

     

       74
       74
        
           '';

     

       75
       75
        
       

     

       76
       76
       -
           users.extraUsers = singleton {

     

       76
       76
       +
           users.users = singleton {

     

       77
       77
        
             name = "kippo";

     

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

     

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

     

       80
       80
        
           };

     

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

     

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

     

       82
       82
        
       

     

       83
       83
        
           systemd.services.kippo = with pkgs; {

     

       84
       84
        
             description = "Kippo Web Server";

+2 -2

nixos/modules/services/networking/kresd.nix

···

       62
       62
        
         config = mkIf cfg.enable {

     

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

     

       64
       64
        
       

     

       65
       65
       -
           users.extraUsers = singleton

     

       65
       65
       +
           users.users = singleton

     

       66
       66
        
             { name = "kresd";

     

       67
       67
        
               uid = config.ids.uids.kresd;

     

       68
       68
        
               group = "kresd";

     

       69
       69
        
               description = "Knot-resolver daemon user";

     

       70
       70
        
             };

     

       71
       71
       -
           users.extraGroups = singleton

     

       71
       71
       +
           users.groups = singleton

     

       72
       72
        
             { name = "kresd";

     

       73
       73
        
               gid = config.ids.gids.kresd;

     

       74
       74
        
             };

+2 -2

nixos/modules/services/networking/lambdabot.nix

···

       67
       67
        
             };

     

       68
       68
        
           };

     

       69
       69
        
       

     

       70
       70
       -
           users.extraUsers.lambdabot = {

     

       70
       70
       +
           users.users.lambdabot = {

     

       71
       71
        
             group = "lambdabot";

     

       72
       72
        
             description = "Lambdabot daemon user";

     

       73
       73
        
             home = "/var/lib/lambdabot";

     
···

       75
       75
        
             uid = config.ids.uids.lambdabot;

     

       76
       76
        
           };

     

       77
       77
        
       

     

       78
       78
       -
           users.extraGroups.lambdabot.gid = config.ids.gids.lambdabot;

     

       78
       78
       +
           users.groups.lambdabot.gid = config.ids.gids.lambdabot;

     

       79
       79
        
       

     

       80
       80
        
         };

     

       81
       81

+2 -2

nixos/modules/services/networking/lldpd.nix

···

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         config = mkIf cfg.enable {

     

       23
       23
       -
           users.extraUsers._lldpd = {

     

       23
       23
       +
           users.users._lldpd = {

     

       24
       24
        
             description = "lldpd user";

     

       25
       25
        
             group = "_lldpd";

     

       26
       26
        
             home = "/var/run/lldpd";

     

       27
       27
        
             isSystemUser = true;

     

       28
       28
        
           };

     

       29
       29
       -
           users.extraGroups._lldpd = {};

     

       29
       29
       +
           users.groups._lldpd = {};

     

       30
       30
        
       

     

       31
       31
        
           environment.systemPackages = [ pkgs.lldpd ];

     

       32
       32
        
           systemd.packages = [ pkgs.lldpd ];

+2 -2

nixos/modules/services/networking/mailpile.nix

···

       41
       41
        
       

     

       42
       42
        
         config = mkIf config.services.mailpile.enable {

     

       43
       43
        
       

     

       44
       44
       -
           users.extraUsers.mailpile =

     

       44
       44
       +
           users.users.mailpile =

     

       45
       45
        
             { uid = config.ids.uids.mailpile;

     

       46
       46
        
               description = "Mailpile user";

     

       47
       47
        
               createHome = true;

     

       48
       48
        
               home = "/var/lib/mailpile";

     

       49
       49
        
             };

     

       50
       50
        
       

     

       51
       51
       -
           users.extraGroups.mailpile =

     

       51
       51
       +
           users.groups.mailpile =

     

       52
       52
        
             { gid = config.ids.gids.mailpile;

     

       53
       53
        
             };

     

       54
       54

+2 -2

nixos/modules/services/networking/matterbridge.nix

···

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

     

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

     

       94
       94
        
       

     

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

     

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

     

       96
       96
        
             { name = "matterbridge";

     

       97
       97
        
               group = "matterbridge";

     

       98
       98
        
             };

     

       99
       99
        
       

     

       100
       100
       -
           users.extraGroups = optional (cfg.group == "matterbridge")

     

       100
       100
       +
           users.groups = optional (cfg.group == "matterbridge")

     

       101
       101
        
             { name = "matterbridge";

     

       102
       102
        
             };

     

       103
       103

+2 -2

nixos/modules/services/networking/minidlna.nix

···

       84
       84
        
               '') cfg.mediaDirs}

     

       85
       85
        
             '';

     

       86
       86
        
       

     

       87
       87
       -
           users.extraUsers.minidlna = {

     

       87
       87
       +
           users.users.minidlna = {

     

       88
       88
        
             description = "MiniDLNA daemon user";

     

       89
       89
        
             group = "minidlna";

     

       90
       90
        
             uid = config.ids.uids.minidlna;

     

       91
       91
        
           };

     

       92
       92
        
       

     

       93
       93
       -
           users.extraGroups.minidlna.gid = config.ids.gids.minidlna;

     

       93
       93
       +
           users.groups.minidlna.gid = config.ids.gids.minidlna;

     

       94
       94
        
       

     

       95
       95
        
           systemd.services.minidlna =

     

       96
       96
        
             { description = "MiniDLNA Server";

+1 -1

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

···

       49
       49
        
       

     

       50
       50
        
         config = mkIf cfg.enable {

     

       51
       51
        
       

     

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

     

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

     

       53
       53
        
             name = "mjpg-streamer";

     

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

     

       55
       55
        
             group = cfg.group;

+2 -2

nixos/modules/services/networking/monero.nix

···

       197
       197
        
       

     

       198
       198
        
         config = mkIf cfg.enable {

     

       199
       199
        
       

     

       200
       200
       -
           users.extraUsers = singleton {

     

       200
       200
       +
           users.users = singleton {

     

       201
       201
        
             name = "monero";

     

       202
       202
        
             uid  = config.ids.uids.monero;

     

       203
       203
        
             description = "Monero daemon user";

     
···

       205
       205
        
             createHome = true;

     

       206
       206
        
           };

     

       207
       207
        
       

     

       208
       208
       -
           users.extraGroups = singleton {

     

       208
       208
       +
           users.groups = singleton {

     

       209
       209
        
             name = "monero";

     

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

     

       211
       211
        
           };

+1 -1

nixos/modules/services/networking/morty.nix

···

       72
       72
        
       

     

       73
       73
        
         config = mkIf config.services.morty.enable {

     

       74
       74
        
       

     

       75
       75
       -
           users.extraUsers.morty =

     

       75
       75
       +
           users.users.morty =

     

       76
       76
        
             { description = "Morty user";

     

       77
       77
        
               createHome = true;

     

       78
       78
        
               home = "/var/lib/morty";

+2 -2

nixos/modules/services/networking/mosquitto.nix

···

       218
       218
        
               ) cfg.users);

     

       219
       219
        
           };

     

       220
       220
        
       

     

       221
       221
       -
           users.extraUsers.mosquitto = {

     

       221
       221
       +
           users.users.mosquitto = {

     

       222
       222
        
             description = "Mosquitto MQTT Broker Daemon owner";

     

       223
       223
        
             group = "mosquitto";

     

       224
       224
        
             uid = config.ids.uids.mosquitto;

     
···

       226
       226
        
             createHome = true;

     

       227
       227
        
           };

     

       228
       228
        
       

     

       229
       229
       -
           users.extraGroups.mosquitto.gid = config.ids.gids.mosquitto;

     

       229
       229
       +
           users.groups.mosquitto.gid = config.ids.gids.mosquitto;

     

       230
       230
        
       

     

       231
       231
        
         };

     

       232
       232
        
       }

+1 -1

nixos/modules/services/networking/murmur.nix

···

       238
       238
        
         };

     

       239
       239
        
       

     

       240
       240
        
         config = mkIf cfg.enable {

     

       241
       241
       -
           users.extraUsers.murmur = {

     

       241
       241
       +
           users.users.murmur = {

     

       242
       242
        
             description     = "Murmur Service user";

     

       243
       243
        
             home            = "/var/lib/murmur";

     

       244
       244
        
             createHome      = true;

+2 -2

nixos/modules/services/networking/namecoind.nix

···

       153
       153
        
             config = ${configFile}

     

       154
       154
        
           '';

     

       155
       155
        
       

     

       156
       156
       -
           users.extraUsers = singleton {

     

       156
       156
       +
           users.users = singleton {

     

       157
       157
        
             name = "namecoin";

     

       158
       158
        
             uid  = config.ids.uids.namecoin;

     

       159
       159
        
             description = "Namecoin daemon user";

     
···

       161
       161
        
             createHome = true;

     

       162
       162
        
           };

     

       163
       163
        
       

     

       164
       164
       -
           users.extraGroups = singleton {

     

       164
       164
       +
           users.groups = singleton {

     

       165
       165
        
             name = "namecoin";

     

       166
       166
        
             gid  = config.ids.gids.namecoin;

     

       167
       167
        
           };

+2 -2

nixos/modules/services/networking/networkmanager.nix

···

       366
       366
        
       

     

       367
       367
        
           environment.systemPackages = cfg.packages;

     

       368
       368
        
       

     

       369
       369
       -
           users.extraGroups = [{

     

       369
       369
       +
           users.groups = [{

     

       370
       370
        
             name = "networkmanager";

     

       371
       371
        
             gid = config.ids.gids.networkmanager;

     

       372
       372
        
           }

     
···

       374
       374
        
             name = "nm-openvpn";

     

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

     

       376
       376
        
           }];

     

       377
       377
       -
           users.extraUsers = [{

     

       377
       377
       +
           users.users = [{

     

       378
       378
        
             name = "nm-openvpn";

     

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

     

       380
       380
        
             extraGroups = [ "networkmanager" ];

+1 -1

nixos/modules/services/networking/ngircd.nix

···

       51
       51
        
             serviceConfig.User = "ngircd";

     

       52
       52
        
           };

     

       53
       53
        
       

     

       54
       54
       -
           users.extraUsers.ngircd = {

     

       54
       54
       +
           users.users.ngircd = {

     

       55
       55
        
             uid = config.ids.uids.ngircd;

     

       56
       56
        
             description = "ngircd user.";

     

       57
       57
        
           };

+1 -1

nixos/modules/services/networking/nix-serve.nix

···

       64
       64
        
             };

     

       65
       65
        
           };

     

       66
       66
        
       

     

       67
       67
       -
           users.extraUsers.nix-serve = {

     

       67
       67
       +
           users.users.nix-serve = {

     

       68
       68
        
             description = "Nix-serve user";

     

       69
       69
        
             uid = config.ids.uids.nix-serve;

     

       70
       70
        
           };

+1 -1

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

···

       210
       210
        
       

     

       211
       211
        
         config = mkIf cfg.enable {

     

       212
       212
        
       

     

       213
       213
       -
           users.extraUsers = singleton

     

       213
       213
       +
           users.users = singleton

     

       214
       214
        
             { name = proxyUser;

     

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

     

       216
       216
        
               description = "NNTP-Proxy daemon user";

+2 -2

nixos/modules/services/networking/nsd.nix

···

       897
       897
        
       

     

       898
       898
        
           environment.systemPackages = [ nsdPkg ];

     

       899
       899
        
       

     

       900
       900
       -
           users.extraGroups = singleton {

     

       900
       900
       +
           users.groups = singleton {

     

       901
       901
        
             name = username;

     

       902
       902
        
             gid = config.ids.gids.nsd;

     

       903
       903
        
           };

     

       904
       904
        
       

     

       905
       905
       -
           users.extraUsers = singleton {

     

       905
       905
       +
           users.users = singleton {

     

       906
       906
        
             name = username;

     

       907
       907
        
             description = "NSD service user";

     

       908
       908
        
             home = stateDir;

+1 -1

nixos/modules/services/networking/ntpd.nix

···

       67
       67
        
           environment.systemPackages = [ pkgs.ntp ];

     

       68
       68
        
           services.timesyncd.enable = mkForce false;

     

       69
       69
        
       

     

       70
       70
       -
           users.extraUsers = singleton

     

       70
       70
       +
           users.users = singleton

     

       71
       71
        
             { name = ntpUser;

     

       72
       72
        
               uid = config.ids.uids.ntp;

     

       73
       73
        
               description = "NTP daemon user";

+2 -2

nixos/modules/services/networking/nylon.nix

···

       151
       151
        
       

     

       152
       152
        
         config = mkIf (length(enabledNylons) > 0) {

     

       153
       153
        
       

     

       154
       154
       -
           users.extraUsers.nylon = {

     

       154
       154
       +
           users.users.nylon = {

     

       155
       155
        
             group = "nylon";

     

       156
       156
        
             description = "Nylon SOCKS Proxy";

     

       157
       157
        
             home = homeDir;

     
···

       159
       159
        
             uid = config.ids.uids.nylon;

     

       160
       160
        
           };

     

       161
       161
        
       

     

       162
       162
       -
           users.extraGroups.nylon.gid = config.ids.gids.nylon;

     

       162
       162
       +
           users.groups.nylon.gid = config.ids.gids.nylon;

     

       163
       163
        
       

     

       164
       164
        
           systemd.services = fold (a: b: a // b) {} nylonUnits;

     

       165
       165

+2 -2

nixos/modules/services/networking/oidentd.nix

···

       32
       32
        
                 optionalString config.networking.enableIPv6 " -a ::";

     

       33
       33
        
           };

     

       34
       34
        
       

     

       35
       35
       -
           users.extraUsers.oidentd = {

     

       35
       35
       +
           users.users.oidentd = {

     

       36
       36
        
             description = "Ident Protocol daemon user";

     

       37
       37
        
             group = "oidentd";

     

       38
       38
        
             uid = config.ids.uids.oidentd;

     

       39
       39
        
           };

     

       40
       40
        
       

     

       41
       41
       -
           users.extraGroups.oidentd.gid = config.ids.gids.oidentd;

     

       41
       41
       +
           users.groups.oidentd.gid = config.ids.gids.oidentd;

     

       42
       42
        
       

     

       43
       43
        
         };

     

       44
       44

+1 -1

nixos/modules/services/networking/openntpd.nix

···

       59
       59
        
       

     

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

     

       61
       61
        
       

     

       62
       62
       -
           users.extraUsers = singleton {

     

       62
       62
       +
           users.users = singleton {

     

       63
       63
        
             name = "ntp";

     

       64
       64
        
             uid = config.ids.uids.ntp;

     

       65
       65
        
             description = "OpenNTP daemon user";

+2 -2

nixos/modules/services/networking/owamp.nix

···

       17
       17
        
         ###### implementation

     

       18
       18
        
       

     

       19
       19
        
         config = mkIf cfg.enable {

     

       20
       20
       -
           users.extraUsers = singleton {

     

       20
       20
       +
           users.users = singleton {

     

       21
       21
        
             name = "owamp";

     

       22
       22
        
             group = "owamp";

     

       23
       23
        
             description = "Owamp daemon";

     

       24
       24
        
           };

     

       25
       25
        
       

     

       26
       26
       -
           users.extraGroups = singleton {

     

       26
       26
       +
           users.groups = singleton {

     

       27
       27
        
             name = "owamp";

     

       28
       28
        
           };

     

       29
       29

+1 -1

nixos/modules/services/networking/pdns-recursor.nix

···

       128
       128
        
       

     

       129
       129
        
         config = mkIf cfg.enable {

     

       130
       130
        
       

     

       131
       131
       -
           users.extraUsers."${username}" = {

     

       131
       131
       +
           users.users."${username}" = {

     

       132
       132
        
             home = dataDir;

     

       133
       133
        
             createHome = true;

     

       134
       134
        
             uid = config.ids.uids.pdns-recursor;

+2 -2

nixos/modules/services/networking/pdnsd.nix

···

       62
       62
        
           };

     

       63
       63
        
       

     

       64
       64
        
         config = mkIf cfg.enable {

     

       65
       65
       -
           users.extraUsers = singleton {

     

       65
       65
       +
           users.users = singleton {

     

       66
       66
        
             name = pdnsdUser;

     

       67
       67
        
             uid = config.ids.uids.pdnsd;

     

       68
       68
        
             group = pdnsdGroup;

     

       69
       69
        
             description = "pdnsd user";

     

       70
       70
        
           };

     

       71
       71
        
       

     

       72
       72
       -
           users.extraGroups = singleton {

     

       72
       72
       +
           users.groups = singleton {

     

       73
       73
        
             name = pdnsdGroup;

     

       74
       74
        
             gid = config.ids.gids.pdnsd;

     

       75
       75
        
           };

+2 -2

nixos/modules/services/networking/polipo.nix

···

       85
       85
        
       

     

       86
       86
        
         config = mkIf cfg.enable {

     

       87
       87
        
       

     

       88
       88
       -
           users.extraUsers = singleton

     

       88
       88
       +
           users.users = singleton

     

       89
       89
        
             { name = "polipo";

     

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

     

       91
       91
        
               description = "Polipo caching proxy user";

     
···

       93
       93
        
               createHome = true;

     

       94
       94
        
             };

     

       95
       95
        
       

     

       96
       96
       -
           users.extraGroups = singleton

     

       96
       96
       +
           users.groups = singleton

     

       97
       97
        
             { name = "polipo";

     

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

     

       99
       99
        
               members = [ "polipo" ];

+2 -2

nixos/modules/services/networking/prayer.nix

···

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

     

       73
       73
        
           environment.systemPackages = [ prayer ];

     

       74
       74
        
       

     

       75
       75
       -
           users.extraUsers = singleton

     

       75
       75
       +
           users.users = singleton

     

       76
       76
        
             { name = prayerUser;

     

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

     

       78
       78
        
               description = "Prayer daemon user";

     

       79
       79
        
               home = stateDir;

     

       80
       80
        
             };

     

       81
       81
        
       

     

       82
       82
       -
           users.extraGroups = singleton

     

       82
       82
       +
           users.groups = singleton

     

       83
       83
        
             { name = prayerGroup;

     

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

     

       85
       85
        
             };

+2 -2

nixos/modules/services/networking/prosody.nix

···

       487
       487
        
               '') cfg.virtualHosts) }

     

       488
       488
        
           '';

     

       489
       489
        
       

     

       490
       490
       -
           users.extraUsers.prosody = mkIf (cfg.user == "prosody") {

     

       490
       490
       +
           users.users.prosody = mkIf (cfg.user == "prosody") {

     

       491
       491
        
             uid = config.ids.uids.prosody;

     

       492
       492
        
             description = "Prosody user";

     

       493
       493
        
             createHome = true;

     
···

       495
       495
        
             home = "${cfg.dataDir}";

     

       496
       496
        
           };

     

       497
       497
        
       

     

       498
       498
       -
           users.extraGroups.prosody = mkIf (cfg.group == "prosody") {

     

       498
       498
       +
           users.groups.prosody = mkIf (cfg.group == "prosody") {

     

       499
       499
        
             gid = config.ids.gids.prosody;

     

       500
       500
        
           };

     

       501
       501

+2 -2

nixos/modules/services/networking/quassel.nix

···

       72
       72
        
       

     

       73
       73
        
         config = mkIf cfg.enable {

     

       74
       74
        
       

     

       75
       75
       -
           users.extraUsers = mkIf (cfg.user == null) [

     

       75
       75
       +
           users.users = mkIf (cfg.user == null) [

     

       76
       76
        
             { name = "quassel";

     

       77
       77
        
               description = "Quassel IRC client daemon";

     

       78
       78
        
               group = "quassel";

     

       79
       79
        
               uid = config.ids.uids.quassel;

     

       80
       80
        
             }];

     

       81
       81
        
       

     

       82
       82
       -
           users.extraGroups = mkIf (cfg.user == null) [

     

       82
       82
       +
           users.groups = mkIf (cfg.user == null) [

     

       83
       83
        
             { name = "quassel";

     

       84
       84
        
               gid = config.ids.gids.quassel;

     

       85
       85
        
             }];

+2 -2

nixos/modules/services/networking/radicale.nix

···

       59
       59
        
         config = mkIf cfg.enable {

     

       60
       60
        
           environment.systemPackages = [ cfg.package ];

     

       61
       61
        
       

     

       62
       62
       -
           users.extraUsers = singleton

     

       62
       62
       +
           users.users = singleton

     

       63
       63
        
             { name = "radicale";

     

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

     

       65
       65
        
               description = "radicale user";

     
···

       67
       67
        
               createHome = true;

     

       68
       68
        
             };

     

       69
       69
        
       

     

       70
       70
       -
           users.extraGroups = singleton

     

       70
       70
       +
           users.groups = singleton

     

       71
       71
        
             { name = "radicale";

     

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

     

       73
       73
        
             };

+1 -1

nixos/modules/services/networking/radvd.nix

···

       52
       52
        
       

     

       53
       53
        
         config = mkIf cfg.enable {

     

       54
       54
        
       

     

       55
       55
       -
           users.extraUsers.radvd =

     

       55
       55
       +
           users.users.radvd =

     

       56
       56
        
             { uid = config.ids.uids.radvd;

     

       57
       57
        
               description = "Router Advertisement Daemon User";

     

       58
       58
        
             };

+1 -1

nixos/modules/services/networking/rdnssd.nix

···

       64
       64
        
             };

     

       65
       65
        
           };

     

       66
       66
        
       

     

       67
       67
       -
           users.extraUsers.rdnssd = {

     

       67
       67
       +
           users.users.rdnssd = {

     

       68
       68
        
             description = "RDNSSD Daemon User";

     

       69
       69
        
             uid = config.ids.uids.rdnssd;

     

       70
       70
        
           };

+2 -2

nixos/modules/services/networking/resilio.nix

···

       236
       236
        
               }

     

       237
       237
        
             ];

     

       238
       238
        
       

     

       239
       239
       -
           users.extraUsers.rslsync = {

     

       239
       239
       +
           users.users.rslsync = {

     

       240
       240
        
             description     = "Resilio Sync Service user";

     

       241
       241
        
             home            = cfg.storagePath;

     

       242
       242
        
             createHome      = true;

     
···

       244
       244
        
             group           = "rslsync";

     

       245
       245
        
           };

     

       246
       246
        
       

     

       247
       247
       -
           users.extraGroups = [ { name = "rslsync"; } ];

     

       247
       247
       +
           users.groups = [ { name = "rslsync"; } ];

     

       248
       248
        
       

     

       249
       249
        
           systemd.services.resilio = with pkgs; {

     

       250
       250
        
             description = "Resilio Sync Service";

+1 -1

nixos/modules/services/networking/rpcbind.nix

···

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

     

       38
       38
        
           };

     

       39
       39
        
       

     

       40
       40
       -
           users.extraUsers.rpc = {

     

       40
       40
       +
           users.users.rpc = {

     

       41
       41
        
             group = "nogroup";

     

       42
       42
        
             uid = config.ids.uids.rpc;

     

       43
       43
        
           };

+2 -2

nixos/modules/services/networking/sabnzbd.nix

···

       41
       41
        
       

     

       42
       42
        
         config = mkIf cfg.enable {

     

       43
       43
        
       

     

       44
       44
       -
           users.extraUsers.sabnzbd = {

     

       44
       44
       +
           users.users.sabnzbd = {

     

       45
       45
        
                 uid = config.ids.uids.sabnzbd;

     

       46
       46
        
                 group = "sabnzbd";

     

       47
       47
        
                 description = "sabnzbd user";

     
···

       49
       49
        
                 createHome = true;

     

       50
       50
        
           };

     

       51
       51
        
       

     

       52
       52
       -
           users.extraGroups.sabnzbd = {

     

       52
       52
       +
           users.groups.sabnzbd = {

     

       53
       53
        
             gid = config.ids.gids.sabnzbd;

     

       54
       54
        
           };

     

       55
       55

+2 -2

nixos/modules/services/networking/searx.nix

···

       47
       47
        
       

     

       48
       48
        
         config = mkIf config.services.searx.enable {

     

       49
       49
        
       

     

       50
       50
       -
           users.extraUsers.searx =

     

       50
       50
       +
           users.users.searx =

     

       51
       51
        
             { uid = config.ids.uids.searx;

     

       52
       52
        
               description = "Searx user";

     

       53
       53
        
               createHome = true;

     

       54
       54
        
               home = "/var/lib/searx";

     

       55
       55
        
             };

     

       56
       56
        
       

     

       57
       57
       -
           users.extraGroups.searx =

     

       57
       57
       +
           users.groups.searx =

     

       58
       58
        
             { gid = config.ids.gids.searx;

     

       59
       59
        
             };

     

       60
       60

+2 -2

nixos/modules/services/networking/seeks.nix

···

       46
       46
        
       

     

       47
       47
        
         config = mkIf config.services.seeks.enable {

     

       48
       48
        
       

     

       49
       49
       -
           users.extraUsers.seeks =

     

       49
       49
       +
           users.users.seeks =

     

       50
       50
        
             { uid = config.ids.uids.seeks;

     

       51
       51
        
               description = "Seeks user";

     

       52
       52
        
               createHome = true;

     

       53
       53
        
               home = "/var/lib/seeks";

     

       54
       54
        
             };

     

       55
       55
        
       

     

       56
       56
       -
           users.extraGroups.seeks =

     

       56
       56
       +
           users.groups.seeks =

     

       57
       57
        
             { gid = config.ids.gids.seeks;

     

       58
       58
        
             };

     

       59
       59

+1 -1

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

···

       55
       55
        
           services.avahi.publish.enable = true;

     

       56
       56
        
           services.avahi.publish.userServices = true;

     

       57
       57
        
       

     

       58
       58
       -
           users.extraUsers = singleton

     

       58
       58
       +
           users.users = singleton

     

       59
       59
        
             { name = cfg.user;

     

       60
       60
        
               description = "Shairport user";

     

       61
       61
        
               isSystemUser = true;

+1 -1

nixos/modules/services/networking/shout.nix

···

       82
       82
        
         };

     

       83
       83
        
       

     

       84
       84
        
         config = mkIf cfg.enable {

     

       85
       85
       -
           users.extraUsers = singleton {

     

       85
       85
       +
           users.users = singleton {

     

       86
       86
        
             name = "shout";

     

       87
       87
        
             uid = config.ids.uids.shout;

     

       88
       88
        
             description = "Shout daemon user";

+1 -1

nixos/modules/services/networking/smokeping.nix

···

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

     

       279
       279
        
           };

     

       280
       280
        
           environment.systemPackages = [ pkgs.fping ];

     

       281
       281
       -
           users.extraUsers = singleton {

     

       281
       281
       +
           users.users = singleton {

     

       282
       282
        
             name = cfg.user;

     

       283
       283
        
             isNormalUser = false;

     

       284
       284
        
             isSystemUser = true;

+2 -2

nixos/modules/services/networking/sniproxy.nix

···

       82
       82
        
             };

     

       83
       83
        
           };

     

       84
       84
        
       

     

       85
       85
       -
           users.extraUsers = mkIf (cfg.user == "sniproxy") {

     

       85
       85
       +
           users.users = mkIf (cfg.user == "sniproxy") {

     

       86
       86
        
             sniproxy = {

     

       87
       87
        
               group = cfg.group;

     

       88
       88
        
               uid = config.ids.uids.sniproxy;

     

       89
       89
        
             };

     

       90
       90
        
           };

     

       91
       91
        
       

     

       92
       92
       -
           users.extraGroups = mkIf (cfg.group == "sniproxy") {

     

       92
       92
       +
           users.groups = mkIf (cfg.group == "sniproxy") {

     

       93
       93
        
             sniproxy = {

     

       94
       94
        
               gid = config.ids.gids.sniproxy;

     

       95
       95
        
             };

+2 -2

nixos/modules/services/networking/spiped.nix

···

       171
       171
        
             message   = "A pipe must either encrypt or decrypt";

     

       172
       172
        
           }) cfg.config;

     

       173
       173
        
       

     

       174
       174
       -
           users.extraGroups.spiped.gid = config.ids.gids.spiped;

     

       175
       175
       -
           users.extraUsers.spiped = {

     

       174
       174
       +
           users.groups.spiped.gid = config.ids.gids.spiped;

     

       175
       175
       +
           users.users.spiped = {

     

       176
       176
        
             description = "Secure Pipe Service user";

     

       177
       177
        
             group       = "spiped";

     

       178
       178
        
             uid         = config.ids.uids.spiped;

+2 -2

nixos/modules/services/networking/ssh/sshd.nix

···

       49
       49
        
               ${concatMapStrings (f: readFile f + "\n") u.openssh.authorizedKeys.keyFiles}

     

       50
       50
        
             '';

     

       51
       51
        
           };

     

       52
       52
       -
           usersWithKeys = attrValues (flip filterAttrs config.users.extraUsers (n: u:

     

       52
       52
       +
           usersWithKeys = attrValues (flip filterAttrs config.users.users (n: u:

     

       53
       53
        
             length u.openssh.authorizedKeys.keys != 0 || length u.openssh.authorizedKeys.keyFiles != 0

     

       54
       54
        
           ));

     

       55
       55
        
         in listToAttrs (map mkAuthKeyFile usersWithKeys);

     
···

       326
       326
        
       

     

       327
       327
        
         config = mkIf cfg.enable {

     

       328
       328
        
       

     

       329
       329
       -
           users.extraUsers.sshd =

     

       329
       329
       +
           users.users.sshd =

     

       330
       330
        
             { isSystemUser = true;

     

       331
       331
        
               description = "SSH privilege separation user";

     

       332
       332
        
             };

+2 -2

nixos/modules/services/networking/supybot.nix

···

       45
       45
        
       

     

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

     

       47
       47
        
       

     

       48
       48
       -
           users.extraUsers = singleton {

     

       48
       48
       +
           users.users = singleton {

     

       49
       49
        
             name = "supybot";

     

       50
       50
        
             uid = config.ids.uids.supybot;

     

       51
       51
        
             group = "supybot";

     
···

       54
       54
        
             createHome = true;

     

       55
       55
        
           };

     

       56
       56
        
       

     

       57
       57
       -
           users.extraGroups.supybot = {

     

       57
       57
       +
           users.groups.supybot = {

     

       58
       58
        
             name = "supybot";

     

       59
       59
        
             gid = config.ids.gids.supybot;

     

       60
       60
        
           };

+2 -2

nixos/modules/services/networking/syncthing.nix

···

       103
       103
        
           systemd.packages = [ pkgs.syncthing ];

     

       104
       104
        
       

     

       105
       105
        
           users = mkIf (cfg.user == defaultUser) {

     

       106
       106
       -
             extraUsers."${defaultUser}" =

     

       106
       106
       +
             users."${defaultUser}" =

     

       107
       107
        
               { group = cfg.group;

     

       108
       108
        
                 home  = cfg.dataDir;

     

       109
       109
        
                 createHome = true;

     
···

       111
       111
        
                 description = "Syncthing daemon user";

     

       112
       112
        
               };

     

       113
       113
        
       

     

       114
       114
       -
             extraGroups."${defaultUser}".gid =

     

       114
       114
       +
             groups."${defaultUser}".gid =

     

       115
       115
        
               config.ids.gids.syncthing;

     

       116
       116
        
           };

     

       117
       117

+1 -1

nixos/modules/services/networking/tcpcrypt.nix

···

       29
       29
        
       

     

       30
       30
        
         config = mkIf cfg.enable {

     

       31
       31
        
       

     

       32
       32
       -
           users.extraUsers = singleton {

     

       32
       32
       +
           users.users = singleton {

     

       33
       33
        
             name = "tcpcryptd";

     

       34
       34
        
             uid = config.ids.uids.tcpcryptd;

     

       35
       35
        
             description = "tcpcrypt daemon user";

+1 -1

nixos/modules/services/networking/tinc.nix

···

       209
       209
        
             };

     

       210
       210
        
           in [ cli-wrappers ];

     

       211
       211
        
       

     

       212
       212
       -
           users.extraUsers = flip mapAttrs' cfg.networks (network: _:

     

       212
       212
       +
           users.users = flip mapAttrs' cfg.networks (network: _:

     

       213
       213
        
             nameValuePair ("tinc.${network}") ({

     

       214
       214
        
               description = "Tinc daemon user for ${network}";

     

       215
       215
        
               isSystemUser = true;

+1 -1

nixos/modules/services/networking/tinydns.nix

···

       32
       32
        
         config = mkIf config.services.tinydns.enable {

     

       33
       33
        
           environment.systemPackages = [ pkgs.djbdns ];

     

       34
       34
        
       

     

       35
       35
       -
           users.extraUsers.tinydns = {};

     

       35
       35
       +
           users.users.tinydns = {};

     

       36
       36
        
       

     

       37
       37
        
           systemd.services.tinydns = {

     

       38
       38
        
             description = "djbdns tinydns server";

+1 -1

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

···

       56
       56
        
       

     

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

     

       58
       58
        
       

     

       59
       59
       -
           users.extraUsers = singleton

     

       59
       59
       +
           users.users = singleton

     

       60
       60
        
             { name = "tox-bootstrapd";

     

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

     

       62
       62
        
               description = "Tox bootstrap daemon user";

+1 -1

nixos/modules/services/networking/toxvpn.nix

···

       57
       57
        
       

     

       58
       58
        
           environment.systemPackages = [ pkgs.toxvpn ];

     

       59
       59
        
       

     

       60
       60
       -
           users.extraUsers = {

     

       60
       60
       +
           users.users = {

     

       61
       61
        
             toxvpn = {

     

       62
       62
        
               uid        = config.ids.uids.toxvpn;

     

       63
       63
        
               home       = "/var/lib/toxvpn";

+2 -2

nixos/modules/services/networking/tvheadend.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       let cfg     = config.services.tvheadend;

     

       6
       6
       -
           pidFile = "${config.users.extraUsers.tvheadend.home}/tvheadend.pid";

     

       6
       6
       +
           pidFile = "${config.users.users.tvheadend.home}/tvheadend.pid";

     

       7
       7
        
       in

     

       8
       8
        
       

     

       9
       9
        
       {

     
···

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         config = mkIf cfg.enable {

     

       28
       28
       -
           users.extraUsers.tvheadend = {

     

       28
       28
       +
           users.users.tvheadend = {

     

       29
       29
        
             description = "Tvheadend Service user";

     

       30
       30
        
             home        = "/var/lib/tvheadend";

     

       31
       31
        
             createHome  = true;

+1 -1

nixos/modules/services/networking/unifi.nix

···

       114
       114
        
       

     

       115
       115
        
         config = mkIf cfg.enable {

     

       116
       116
        
       

     

       117
       117
       -
           users.extraUsers.unifi = {

     

       117
       117
       +
           users.users.unifi = {

     

       118
       118
        
             uid = config.ids.uids.unifi;

     

       119
       119
        
             description = "UniFi controller daemon user";

     

       120
       120
        
             home = "${stateDir}";

+2 -2

nixos/modules/services/networking/vsftpd.nix

···

       193
       193
        
               message = "vsftpd: If forceLocalLoginsSSL or forceLocalDataSSL is true then a rsaCertFile must be provided!";

     

       194
       194
        
             };

     

       195
       195
        
       

     

       196
       196
       -
           users.extraUsers =

     

       196
       196
       +
           users.users =

     

       197
       197
        
             [ { name = "vsftpd";

     

       198
       198
        
                 uid = config.ids.uids.vsftpd;

     

       199
       199
        
                 description = "VSFTPD user";

     
···

       207
       207
        
                 home = cfg.anonymousUserHome;

     

       208
       208
        
               };

     

       209
       209
        
       

     

       210
       210
       -
           users.extraGroups.ftp.gid = config.ids.gids.ftp;

     

       210
       210
       +
           users.groups.ftp.gid = config.ids.gids.ftp;

     

       211
       211
        
       

     

       212
       212
        
           # If you really have to access root via FTP use mkOverride or userlistDeny

     

       213
       213
        
           # = false and whitelist root

+2 -2

nixos/modules/services/networking/znc.nix

···

       402
       402
        
             script = "${pkgs.znc}/bin/znc --foreground --datadir ${cfg.dataDir} ${toString cfg.extraFlags}";

     

       403
       403
        
           };

     

       404
       404
        
       

     

       405
       405
       -
           users.extraUsers = optional (cfg.user == defaultUser)

     

       405
       405
       +
           users.users = optional (cfg.user == defaultUser)

     

       406
       406
        
             { name = defaultUser;

     

       407
       407
        
               description = "ZNC server daemon owner";

     

       408
       408
        
               group = defaultUser;

     
···

       411
       411
        
               createHome = true;

     

       412
       412
        
             };

     

       413
       413
        
       

     

       414
       414
       -
           users.extraGroups = optional (cfg.user == defaultUser)

     

       414
       414
       +
           users.groups = optional (cfg.user == defaultUser)

     

       415
       415
        
             { name = defaultUser;

     

       416
       416
        
               gid = config.ids.gids.znc;

     

       417
       417
        
               members = [ defaultUser ];

+1 -1

nixos/modules/services/printing/cupsd.nix

···

       268
       268
        
       

     

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

     

       270
       270
        
       

     

       271
       271
       -
           users.extraUsers = singleton

     

       271
       271
       +
           users.users = singleton

     

       272
       272
        
             { name = "cups";

     

       273
       273
        
               uid = config.ids.uids.cups;

     

       274
       274
        
               group = "lp";

+2 -2

nixos/modules/services/scheduling/atd.nix

···

       57
       57
        
       

     

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

     

       59
       59
        
       

     

       60
       60
       -
           users.extraUsers = singleton

     

       60
       60
       +
           users.users = singleton

     

       61
       61
        
             { name = "atd";

     

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

     

       63
       63
        
               description = "atd user";

     

       64
       64
        
               home = "/var/empty";

     

       65
       65
        
             };

     

       66
       66
        
       

     

       67
       67
       -
           users.extraGroups = singleton

     

       67
       67
       +
           users.groups = singleton

     

       68
       68
        
             { name = "atd";

     

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

     

       70
       70
        
             };

+1 -1

nixos/modules/services/scheduling/chronos.nix

···

       49
       49
        
             };

     

       50
       50
        
           };

     

       51
       51
        
       

     

       52
       52
       -
           users.extraUsers.chronos.uid = config.ids.uids.chronos;

     

       52
       52
       +
           users.users.chronos.uid = config.ids.uids.chronos;

     

       53
       53
        
         };

     

       54
       54
        
       }

+1 -1

nixos/modules/services/scheduling/fcron.nix

···

       115
       115
        
             ];

     

       116
       116
        
       

     

       117
       117
        
           environment.systemPackages = [ pkgs.fcron ];

     

       118
       118
       -
           users.extraUsers.fcron = {

     

       118
       118
       +
           users.users.fcron = {

     

       119
       119
        
             uid = config.ids.uids.fcron;

     

       120
       120
        
             home = "/var/spool/fcron";

     

       121
       121
        
             group = "fcron";

+1 -1

nixos/modules/services/scheduling/marathon.nix

···

       93
       93
        
             };

     

       94
       94
        
           };

     

       95
       95
        
       

     

       96
       96
       -
           users.extraUsers.${cfg.user} = { };

     

       96
       96
       +
           users.users.${cfg.user} = { };

     

       97
       97
        
         };

     

       98
       98
        
       }

+2 -2

nixos/modules/services/search/hound.nix

···

       88
       88
        
         };

     

       89
       89
        
       

     

       90
       90
        
         config = mkIf cfg.enable {

     

       91
       91
       -
           users.extraGroups = optional (cfg.group == "hound") {

     

       91
       91
       +
           users.groups = optional (cfg.group == "hound") {

     

       92
       92
        
             name = "hound";

     

       93
       93
        
             gid = config.ids.gids.hound;

     

       94
       94
        
           };

     

       95
       95
        
       

     

       96
       96
       -
           users.extraUsers = optional (cfg.user == "hound") {

     

       96
       96
       +
           users.users = optional (cfg.user == "hound") {

     

       97
       97
        
             name = "hound";

     

       98
       98
        
             description = "hound code search";

     

       99
       99
        
             createHome = true;

+1 -1

nixos/modules/services/search/kibana.nix

···

       193
       193
        
       

     

       194
       194
        
           environment.systemPackages = [ cfg.package ];

     

       195
       195
        
       

     

       196
       196
       -
           users.extraUsers = singleton {

     

       196
       196
       +
           users.users = singleton {

     

       197
       197
        
             name = "kibana";

     

       198
       198
        
             uid = config.ids.uids.kibana;

     

       199
       199
        
             description = "Kibana service user";

+2 -2

nixos/modules/services/security/clamav.nix

···

       79
       79
        
         config = mkIf (cfg.updater.enable || cfg.daemon.enable) {

     

       80
       80
        
           environment.systemPackages = [ pkg ];

     

       81
       81
        
       

     

       82
       82
       -
           users.extraUsers = singleton {

     

       82
       82
       +
           users.users = singleton {

     

       83
       83
        
             name = clamavUser;

     

       84
       84
        
             uid = config.ids.uids.clamav;

     

       85
       85
        
             group = clamavGroup;

     
···

       87
       87
        
             home = stateDir;

     

       88
       88
        
           };

     

       89
       89
        
       

     

       90
       90
       -
           users.extraGroups = singleton {

     

       90
       90
       +
           users.groups = singleton {

     

       91
       91
        
             name = clamavGroup;

     

       92
       92
        
             gid = config.ids.gids.clamav;

     

       93
       93
        
           };

+2 -2

nixos/modules/services/security/fprot.nix

···

       53
       53
        
             target = "f-prot.conf";

     

       54
       54
        
           };

     

       55
       55
        
       

     

       56
       56
       -
           users.extraUsers = singleton

     

       56
       56
       +
           users.users = singleton

     

       57
       57
        
             { name = fprotUser;

     

       58
       58
        
               uid = config.ids.uids.fprot;

     

       59
       59
        
               description = "F-Prot daemon user";

     

       60
       60
        
               home = stateDir;

     

       61
       61
        
             };

     

       62
       62
        
       

     

       63
       63
       -
           users.extraGroups = singleton

     

       63
       63
       +
           users.groups = singleton

     

       64
       64
        
             { name = fprotGroup;

     

       65
       65
        
               gid = config.ids.gids.fprot;

     

       66
       66
        
             };

+1 -1

nixos/modules/services/security/oauth2_proxy.nix

···

       544
       544
        
             cookie.secret = mkDefault null;

     

       545
       545
        
           };

     

       546
       546
        
       

     

       547
       547
       -
           users.extraUsers.oauth2_proxy = {

     

       547
       547
       +
           users.users.oauth2_proxy = {

     

       548
       548
        
             description = "OAuth2 Proxy";

     

       549
       549
        
           };

     

       550
       550

+2 -2

nixos/modules/services/security/tor.nix

···

       686
       686
        
               always create a container/VM with a separate Tor daemon instance.

     

       687
       687
        
             '';

     

       688
       688
        
       

     

       689
       689
       -
           users.extraGroups.tor.gid = config.ids.gids.tor;

     

       690
       690
       -
           users.extraUsers.tor =

     

       689
       689
       +
           users.groups.tor.gid = config.ids.gids.tor;

     

       690
       690
       +
           users.users.tor =

     

       691
       691
        
             { description = "Tor Daemon User";

     

       692
       692
        
               createHome  = true;

     

       693
       693
        
               home        = torDirectory;

+2 -2

nixos/modules/services/security/vault.nix

···

       97
       97
        
             }

     

       98
       98
        
           ];

     

       99
       99
        
       

     

       100
       100
       -
           users.extraUsers.vault = {

     

       100
       100
       +
           users.users.vault = {

     

       101
       101
        
             name = "vault";

     

       102
       102
        
             group = "vault";

     

       103
       103
        
             uid = config.ids.uids.vault;

     

       104
       104
        
             description = "Vault daemon user";

     

       105
       105
        
           };

     

       106
       106
       -
           users.extraGroups.vault.gid = config.ids.gids.vault;

     

       106
       106
       +
           users.groups.vault.gid = config.ids.gids.vault;

     

       107
       107
        
       

     

       108
       108
        
           systemd.services.vault = {

     

       109
       109
        
             description = "Vault server daemon";

+2 -2

nixos/modules/services/system/dbus.nix

···

       71
       71
        
               target = "dbus-1";

     

       72
       72
        
             };

     

       73
       73
        
       

     

       74
       74
       -
           users.extraUsers.messagebus = {

     

       74
       74
       +
           users.users.messagebus = {

     

       75
       75
        
             uid = config.ids.uids.messagebus;

     

       76
       76
        
             description = "D-Bus system message bus daemon user";

     

       77
       77
        
             home = homeDir;

     

       78
       78
        
             group = "messagebus";

     

       79
       79
        
           };

     

       80
       80
        
       

     

       81
       81
       -
           users.extraGroups.messagebus.gid = config.ids.gids.messagebus;

     

       81
       81
       +
           users.groups.messagebus.gid = config.ids.gids.messagebus;

     

       82
       82
        
       

     

       83
       83
        
           systemd.packages = [ pkgs.dbus.daemon ];

     

       84
       84

+1 -1

nixos/modules/services/system/nscd.nix

···

       41
       41
        
         config = mkIf cfg.enable {

     

       42
       42
        
           environment.etc."nscd.conf".text = cfg.config;

     

       43
       43
        
       

     

       44
       44
       -
           users.extraUsers.nscd =

     

       44
       44
       +
           users.users.nscd =

     

       45
       45
        
             { isSystemUser = true;

     

       46
       46
        
               description = "Name service cache daemon user";

     

       47
       47
        
             };

+1 -1

nixos/modules/services/system/uptimed.nix

···

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         config = mkIf cfg.enable {

     

       23
       23
       -
           users.extraUsers.uptimed = {

     

       23
       23
       +
           users.users.uptimed = {

     

       24
       24
        
             description = "Uptimed daemon user";

     

       25
       25
        
             home        = stateDir;

     

       26
       26
        
             createHome  = true;

+2 -2

nixos/modules/services/torrent/deluge.nix

···

       55
       55
        
       

     

       56
       56
        
           environment.systemPackages = [ pkgs.deluge ];

     

       57
       57
        
       

     

       58
       58
       -
           users.extraUsers.deluge = {

     

       58
       58
       +
           users.users.deluge = {

     

       59
       59
        
             group = "deluge";

     

       60
       60
        
             uid = config.ids.uids.deluge;

     

       61
       61
        
             home = "/var/lib/deluge/";

     
···

       63
       63
        
             description = "Deluge Daemon user";

     

       64
       64
        
           };

     

       65
       65
        
       

     

       66
       66
       -
           users.extraGroups.deluge.gid = config.ids.gids.deluge;

     

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

     

       67
       67
        
         };

     

       68
       68
        
       }

+1 -1

nixos/modules/services/torrent/peerflix.nix

···

       58
       58
        
             };

     

       59
       59
        
           };

     

       60
       60
        
       

     

       61
       61
       -
           users.extraUsers.peerflix.uid = config.ids.uids.peerflix;

     

       61
       61
       +
           users.users.peerflix.uid = config.ids.uids.peerflix;

     

       62
       62
        
         };

     

       63
       63
        
       }

+2 -2

nixos/modules/services/torrent/transmission.nix

···

       113
       113
        
           # It's useful to have transmission in path, e.g. for remote control

     

       114
       114
        
           environment.systemPackages = [ pkgs.transmission ];

     

       115
       115
        
       

     

       116
       116
       -
           users.extraGroups.transmission.gid = config.ids.gids.transmission;

     

       117
       117
       -
           users.extraUsers.transmission = {

     

       116
       116
       +
           users.groups.transmission.gid = config.ids.gids.transmission;

     

       117
       117
       +
           users.users.transmission = {

     

       118
       118
        
             group = "transmission";

     

       119
       119
        
             uid = config.ids.uids.transmission;

     

       120
       120
        
             description = "Transmission BitTorrent user";

+2 -2

nixos/modules/services/web-apps/atlassian/confluence.nix

···

       137
       137
        
         };

     

       138
       138
        
       

     

       139
       139
        
         config = mkIf cfg.enable {

     

       140
       140
       -
           users.extraUsers."${cfg.user}" = {

     

       140
       140
       +
           users.users."${cfg.user}" = {

     

       141
       141
        
             isSystemUser = true;

     

       142
       142
        
             group = cfg.group;

     

       143
       143
        
           };

     

       144
       144
        
       

     

       145
       145
       -
           users.extraGroups."${cfg.group}" = {};

     

       145
       145
       +
           users.groups."${cfg.group}" = {};

     

       146
       146
        
       

     

       147
       147
        
           systemd.services.confluence = {

     

       148
       148
        
             description = "Atlassian Confluence";

+2 -2

nixos/modules/services/web-apps/atlassian/crowd.nix

···

       103
       103
        
         };

     

       104
       104
        
       

     

       105
       105
        
         config = mkIf cfg.enable {

     

       106
       106
       -
           users.extraUsers."${cfg.user}" = {

     

       106
       106
       +
           users.users."${cfg.user}" = {

     

       107
       107
        
             isSystemUser = true;

     

       108
       108
        
             group = cfg.group;

     

       109
       109
        
           };

     

       110
       110
        
       

     

       111
       111
       -
           users.extraGroups."${cfg.group}" = {};

     

       111
       111
       +
           users.groups."${cfg.group}" = {};

     

       112
       112
        
       

     

       113
       113
        
           systemd.services.atlassian-crowd = {

     

       114
       114
        
             description = "Atlassian Crowd";

+2 -2

nixos/modules/services/web-apps/atlassian/jira.nix

···

       141
       141
        
         };

     

       142
       142
        
       

     

       143
       143
        
         config = mkIf cfg.enable {

     

       144
       144
       -
           users.extraUsers."${cfg.user}" = {

     

       144
       144
       +
           users.users."${cfg.user}" = {

     

       145
       145
        
             isSystemUser = true;

     

       146
       146
        
             group = cfg.group;

     

       147
       147
        
           };

     

       148
       148
        
       

     

       149
       149
       -
           users.extraGroups."${cfg.group}" = {};

     

       149
       149
       +
           users.groups."${cfg.group}" = {};

     

       150
       150
        
       

     

       151
       151
        
           systemd.services.atlassian-jira = {

     

       152
       152
        
             description = "Atlassian JIRA";

+2 -2

nixos/modules/services/web-apps/frab.nix

···

       174
       174
        
         config = mkIf cfg.enable {

     

       175
       175
        
           environment.systemPackages = [ frab-rake ];

     

       176
       176
        
       

     

       177
       177
       -
           users.extraUsers = [

     

       177
       177
       +
           users.users = [

     

       178
       178
        
             { name = cfg.user;

     

       179
       179
        
               group = cfg.group;

     

       180
       180
        
               home = "${cfg.statePath}";

     

       181
       181
        
             }

     

       182
       182
        
           ];

     

       183
       183
        
       

     

       184
       184
       -
           users.extraGroups = [ { name = cfg.group; } ];

     

       184
       184
       +
           users.groups = [ { name = cfg.group; } ];

     

       185
       185
        
       

     

       186
       186
        
           systemd.services.frab = {

     

       187
       187
        
             after = [ "network.target" "gitlab.service" ];

+2 -2

nixos/modules/services/web-apps/matomo.nix

···

       109
       109
        
               message = "Either services.matomo.nginx or services.matomo.nginx.webServerUser is mandatory";

     

       110
       110
        
           }];

     

       111
       111
        
       

     

       112
       112
       -
           users.extraUsers.${user} = {

     

       112
       112
       +
           users.users.${user} = {

     

       113
       113
        
             isSystemUser = true;

     

       114
       114
        
             createHome = true;

     

       115
       115
        
             home = dataDir;

     

       116
       116
        
             group  = user;

     

       117
       117
        
           };

     

       118
       118
       -
           users.extraGroups.${user} = {};

     

       118
       118
       +
           users.groups.${user} = {};

     

       119
       119
        
       

     

       120
       120
        
           systemd.services.matomo_setup_update = {

     

       121
       121
        
             # everything needs to set up and up to date before matomo php files are executed

+2 -2

nixos/modules/services/web-apps/mattermost.nix

···

       146
       146
        
       

     

       147
       147
        
         config = mkMerge [

     

       148
       148
        
           (mkIf cfg.enable {

     

       149
       149
       -
             users.extraUsers = optionalAttrs (cfg.user == "mattermost") (singleton {

     

       149
       149
       +
             users.users = optionalAttrs (cfg.user == "mattermost") (singleton {

     

       150
       150
        
               name = "mattermost";

     

       151
       151
        
               group = cfg.group;

     

       152
       152
        
               uid = config.ids.uids.mattermost;

     

       153
       153
        
               home = cfg.statePath;

     

       154
       154
        
             });

     

       155
       155
        
       

     

       156
       156
       -
             users.extraGroups = optionalAttrs (cfg.group == "mattermost") (singleton {

     

       156
       156
       +
             users.groups = optionalAttrs (cfg.group == "mattermost") (singleton {

     

       157
       157
        
               name = "mattermost";

     

       158
       158
        
               gid = config.ids.gids.mattermost;

     

       159
       159
        
             });

+2 -2

nixos/modules/services/web-apps/nexus.nix

···

       80
       80
        
         };

     

       81
       81
        
       

     

       82
       82
        
         config = mkIf cfg.enable {

     

       83
       83
       -
           users.extraUsers."${cfg.user}" = {

     

       83
       83
       +
           users.users."${cfg.user}" = {

     

       84
       84
        
             isSystemUser = true;

     

       85
       85
        
             group = cfg.group;

     

       86
       86
        
           };

     

       87
       87
        
       

     

       88
       88
       -
           users.extraGroups."${cfg.group}" = {};

     

       88
       88
       +
           users.groups."${cfg.group}" = {};

     

       89
       89
        
       

     

       90
       90
        
           systemd.services.nexus = {

     

       91
       91
        
             description = "Sonatype Nexus3";

+2 -2

nixos/modules/services/web-apps/restya-board.nix

···

       358
       358
        
             '';

     

       359
       359
        
           };

     

       360
       360
        
       

     

       361
       361
       -
           users.extraUsers.restya-board = {

     

       361
       361
       +
           users.users.restya-board = {

     

       362
       362
        
             isSystemUser = true;

     

       363
       363
        
             createHome = false;

     

       364
       364
        
             home = runDir;

     

       365
       365
        
             group  = "restya-board";

     

       366
       366
        
           };

     

       367
       367
       -
           users.extraGroups.restya-board = {};

     

       367
       367
       +
           users.groups.restya-board = {};

     

       368
       368
        
       

     

       369
       369
        
           services.postgresql.enable = mkIf (isNull cfg.database.host) true;

     

       370
       370

+2 -2

nixos/modules/services/web-apps/tt-rss.nix

···

       624
       624
        
           };

     

       625
       625
        
       

     

       626
       626
        
           users = optionalAttrs (cfg.user == "tt_rss") {

     

       627
       627
       -
             extraUsers.tt_rss.group = "tt_rss";

     

       628
       628
       -
             extraGroups.tt_rss = {};

     

       627
       627
       +
             users.tt_rss.group = "tt_rss";

     

       628
       628
       +
             groups.tt_rss = {};

     

       629
       629
        
           };

     

       630
       630
        
         };

     

       631
       631
        
       }

+1 -1

nixos/modules/services/web-apps/virtlyst.nix

···

       50
       50
        
         };

     

       51
       51
        
       

     

       52
       52
        
         config = mkIf cfg.enable {

     

       53
       53
       -
           users.extraUsers.virtlyst = {

     

       53
       53
       +
           users.users.virtlyst = {

     

       54
       54
        
             home = stateDir;

     

       55
       55
        
             createHome = true;

     

       56
       56
        
             group = mkIf config.virtualisation.libvirtd.enable "libvirtd";

+2 -2

nixos/modules/services/web-servers/apache-httpd/default.nix

···

       658
       658
        
       

     

       659
       659
        
           warnings = map (cfg: ''apache-httpd's port option is deprecated. Use listen = [{/*ip = "*"; */ port = ${toString cfg.port}";}]; instead'' ) (lib.filter (cfg: cfg.port != 0) allHosts);

     

       660
       660
        
       

     

       661
       661
       -
           users.extraUsers = optionalAttrs (mainCfg.user == "wwwrun") (singleton

     

       661
       661
       +
           users.users = optionalAttrs (mainCfg.user == "wwwrun") (singleton

     

       662
       662
        
             { name = "wwwrun";

     

       663
       663
        
               group = mainCfg.group;

     

       664
       664
        
               description = "Apache httpd user";

     

       665
       665
        
               uid = config.ids.uids.wwwrun;

     

       666
       666
        
             });

     

       667
       667
        
       

     

       668
       668
       -
           users.extraGroups = optionalAttrs (mainCfg.group == "wwwrun") (singleton

     

       668
       668
       +
           users.groups = optionalAttrs (mainCfg.group == "wwwrun") (singleton

     

       669
       669
        
             { name = "wwwrun";

     

       670
       670
        
               gid = config.ids.gids.wwwrun;

     

       671
       671
        
             });

+2 -2

nixos/modules/services/web-servers/caddy.nix

···

       93
       93
        
             };

     

       94
       94
        
           };

     

       95
       95
        
       

     

       96
       96
       -
           users.extraUsers.caddy = {

     

       96
       96
       +
           users.users.caddy = {

     

       97
       97
        
             group = "caddy";

     

       98
       98
        
             uid = config.ids.uids.caddy;

     

       99
       99
        
             home = cfg.dataDir;

     

       100
       100
        
             createHome = true;

     

       101
       101
        
           };

     

       102
       102
        
       

     

       103
       103
       -
           users.extraGroups.caddy.gid = config.ids.uids.caddy;

     

       103
       103
       +
           users.groups.caddy.gid = config.ids.uids.caddy;

     

       104
       104
        
         };

     

       105
       105
        
       }

+2 -2

nixos/modules/services/web-servers/hitch/default.nix

···

       102
       102
        
       

     

       103
       103
        
           environment.systemPackages = [ pkgs.hitch ];

     

       104
       104
        
       

     

       105
       105
       -
           users.extraUsers.hitch.group = "hitch";

     

       106
       106
       -
           users.extraGroups.hitch = {};

     

       105
       105
       +
           users.users.hitch.group = "hitch";

     

       106
       106
       +
           users.groups.hitch = {};

     

       107
       107
        
         };

     

       108
       108
        
       }

+2 -2

nixos/modules/services/web-servers/lighttpd/default.nix

···

       245
       245
        
             serviceConfig.KillSignal = "SIGINT";

     

       246
       246
        
           };

     

       247
       247
        
       

     

       248
       248
       -
           users.extraUsers.lighttpd = {

     

       248
       248
       +
           users.users.lighttpd = {

     

       249
       249
        
             group = "lighttpd";

     

       250
       250
        
             description = "lighttpd web server privilege separation user";

     

       251
       251
        
             uid = config.ids.uids.lighttpd;

     

       252
       252
        
           };

     

       253
       253
        
       

     

       254
       254
       -
           users.extraGroups.lighttpd.gid = config.ids.gids.lighttpd;

     

       254
       254
       +
           users.groups.lighttpd.gid = config.ids.gids.lighttpd;

     

       255
       255
        
         };

     

       256
       256
        
       }

+1 -1

nixos/modules/services/web-servers/lighttpd/inginious.nix

···

       194
       194
        
                 storageDriver = mkDefault "overlay";

     

       195
       195
        
               };

     

       196
       196
        
       

     

       197
       197
       -
               users.extraUsers."lighttpd".extraGroups = [ "docker" ];

     

       197
       197
       +
               users.users."lighttpd".extraGroups = [ "docker" ];

     

       198
       198
        
       

     

       199
       199
        
               # Ensure that docker has pulled the required images.

     

       200
       200
        
               systemd.services.inginious-prefetch = {

+2 -2

nixos/modules/services/web-servers/meguca.nix

···

       139
       139
        
           };

     

       140
       140
        
       

     

       141
       141
        
           users = {

     

       142
       142
       -
             extraUsers.meguca = {

     

       142
       142
       +
             users.meguca = {

     

       143
       143
        
               description = "meguca server service user";

     

       144
       144
        
               home = cfg.baseDir;

     

       145
       145
        
               createHome = true;

     
···

       147
       147
        
               uid = config.ids.uids.meguca;

     

       148
       148
        
             };

     

       149
       149
        
       

     

       150
       150
       -
             extraGroups.meguca = {

     

       150
       150
       +
             groups.meguca = {

     

       151
       151
        
               gid = config.ids.gids.meguca;

     

       152
       152
        
               members = [ "meguca" ];

     

       153
       153
        
             };

+2 -2

nixos/modules/services/web-servers/mighttpd2.nix

···

       119
       119
        
             };

     

       120
       120
        
           };

     

       121
       121
        
       

     

       122
       122
       -
           users.extraUsers.mighttpd2 = {

     

       122
       122
       +
           users.users.mighttpd2 = {

     

       123
       123
        
             group = "mighttpd2";

     

       124
       124
        
             uid = config.ids.uids.mighttpd2;

     

       125
       125
        
             isSystemUser = true;

     

       126
       126
        
           };

     

       127
       127
        
       

     

       128
       128
       -
           users.extraGroups.mighttpd2.gid = config.ids.gids.mighttpd2;

     

       128
       128
       +
           users.groups.mighttpd2.gid = config.ids.gids.mighttpd2;

     

       129
       129
        
         };

     

       130
       130
        
       

     

       131
       131
        
         meta.maintainers = with lib.maintainers; [ fgaz ];

+2 -2

nixos/modules/services/web-servers/minio.nix

···

       101
       101
        
             };

     

       102
       102
        
           };

     

       103
       103
        
       

     

       104
       104
       -
           users.extraUsers.minio = {

     

       104
       104
       +
           users.users.minio = {

     

       105
       105
        
             group = "minio";

     

       106
       106
        
             uid = config.ids.uids.minio;

     

       107
       107
        
           };

     

       108
       108
        
       

     

       109
       109
       -
           users.extraGroups.minio.gid = config.ids.uids.minio;

     

       109
       109
       +
           users.groups.minio.gid = config.ids.uids.minio;

     

       110
       110
        
         };

     

       111
       111
        
       }

+2 -2

nixos/modules/services/web-servers/nginx/default.nix

···

       613
       613
        
               listToAttrs acmePairs

     

       614
       614
        
           );

     

       615
       615
        
       

     

       616
       616
       -
           users.extraUsers = optionalAttrs (cfg.user == "nginx") (singleton

     

       616
       616
       +
           users.users = optionalAttrs (cfg.user == "nginx") (singleton

     

       617
       617
        
             { name = "nginx";

     

       618
       618
        
               group = cfg.group;

     

       619
       619
        
               uid = config.ids.uids.nginx;

     

       620
       620
        
             });

     

       621
       621
        
       

     

       622
       622
       -
           users.extraGroups = optionalAttrs (cfg.group == "nginx") (singleton

     

       622
       622
       +
           users.groups = optionalAttrs (cfg.group == "nginx") (singleton

     

       623
       623
        
             { name = "nginx";

     

       624
       624
        
               gid = config.ids.gids.nginx;

     

       625
       625
        
             });

+2 -2

nixos/modules/services/web-servers/tomcat.nix

···

       166
       166
        
       

     

       167
       167
        
         config = mkIf config.services.tomcat.enable {

     

       168
       168
        
       

     

       169
       169
       -
           users.extraGroups = singleton

     

       169
       169
       +
           users.groups = singleton

     

       170
       170
        
             { name = "tomcat";

     

       171
       171
        
               gid = config.ids.gids.tomcat;

     

       172
       172
        
             };

     

       173
       173
        
       

     

       174
       174
       -
           users.extraUsers = singleton

     

       174
       174
       +
           users.users = singleton

     

       175
       175
        
             { name = "tomcat";

     

       176
       176
        
               uid = config.ids.uids.tomcat;

     

       177
       177
        
               description = "Tomcat user";

+2 -2

nixos/modules/services/web-servers/traefik.nix

···

       114
       114
        
             };

     

       115
       115
        
           };

     

       116
       116
        
       

     

       117
       117
       -
           users.extraUsers.traefik = {

     

       117
       117
       +
           users.users.traefik = {

     

       118
       118
        
             group = "traefik";

     

       119
       119
        
             home = cfg.dataDir;

     

       120
       120
        
             createHome = true;

     

       121
       121
        
           };

     

       122
       122
        
       

     

       123
       123
       -
           users.extraGroups.traefik = {};

     

       123
       123
       +
           users.groups.traefik = {};

     

       124
       124
        
         };

     

       125
       125
        
       }

+2 -2

nixos/modules/services/web-servers/uwsgi.nix

···

       150
       150
        
             };

     

       151
       151
        
           };

     

       152
       152
        
       

     

       153
       153
       -
           users.extraUsers = optionalAttrs (cfg.user == "uwsgi") (singleton

     

       153
       153
       +
           users.users = optionalAttrs (cfg.user == "uwsgi") (singleton

     

       154
       154
        
             { name = "uwsgi";

     

       155
       155
        
               group = cfg.group;

     

       156
       156
        
               uid = config.ids.uids.uwsgi;

     

       157
       157
        
             });

     

       158
       158
        
       

     

       159
       159
       -
           users.extraGroups = optionalAttrs (cfg.group == "uwsgi") (singleton

     

       159
       159
       +
           users.groups = optionalAttrs (cfg.group == "uwsgi") (singleton

     

       160
       160
        
             { name = "uwsgi";

     

       161
       161
        
               gid = config.ids.gids.uwsgi;

     

       162
       162
        
             });

+2 -2

nixos/modules/services/web-servers/varnish/default.nix

···

       103
       103
        
             })

     

       104
       104
        
           ];

     

       105
       105
        
       

     

       106
       106
       -
           users.extraUsers.varnish = {

     

       106
       106
       +
           users.users.varnish = {

     

       107
       107
        
             group = "varnish";

     

       108
       108
        
             uid = config.ids.uids.varnish;

     

       109
       109
        
           };

     

       110
       110
        
       

     

       111
       111
       -
           users.extraGroups.varnish.gid = config.ids.uids.varnish;

     

       111
       111
       +
           users.groups.varnish.gid = config.ids.uids.varnish;

     

       112
       112
        
         };

     

       113
       113
        
       }

+1 -1

nixos/modules/services/web-servers/zope2.nix

···

       103
       103
        
       

     

       104
       104
        
         config = mkIf (cfg.instances != {}) {

     

       105
       105
        
       

     

       106
       106
       -
           users.extraUsers.zope2.uid = config.ids.uids.zope2;

     

       106
       106
       +
           users.users.zope2.uid = config.ids.uids.zope2;

     

       107
       107
        
       

     

       108
       108
        
           systemd.services =

     

       109
       109
        
             let

+2 -2

nixos/modules/services/x11/display-managers/gdm.nix

···

       89
       89
        
       

     

       90
       90
        
           services.xserver.displayManager.slim.enable = false;

     

       91
       91
        
       

     

       92
       92
       -
           users.extraUsers.gdm =

     

       92
       92
       +
           users.users.gdm =

     

       93
       93
        
             { name = "gdm";

     

       94
       94
        
               uid = config.ids.uids.gdm;

     

       95
       95
        
               group = "gdm";

     
···

       97
       97
        
               description = "GDM user";

     

       98
       98
        
             };

     

       99
       99
        
       

     

       100
       100
       -
           users.extraGroups.gdm.gid = config.ids.gids.gdm;

     

       100
       100
       +
           users.groups.gdm.gid = config.ids.gids.gdm;

     

       101
       101
        
       

     

       102
       102
        
           # GDM needs different xserverArgs, presumable because using wayland by default.

     

       103
       103
        
           services.xserver.tty = null;

+3 -3

nixos/modules/services/x11/display-managers/lightdm.nix

···

       42
       42
        
           ''

     

       43
       43
        
             [LightDM]

     

       44
       44
        
             ${optionalString cfg.greeter.enable ''

     

       45
       45
       -
               greeter-user = ${config.users.extraUsers.lightdm.name}

     

       45
       45
       +
               greeter-user = ${config.users.users.lightdm.name}

     

       46
       46
        
               greeters-directory = ${cfg.greeter.package}

     

       47
       47
        
             ''}

     

       48
       48
        
             sessions-directory = ${dmcfg.session.desktops}

     
···

       252
       252
        
               session  include   lightdm

     

       253
       253
        
           '';

     

       254
       254
        
       

     

       255
       255
       -
           users.extraUsers.lightdm = {

     

       255
       255
       +
           users.users.lightdm = {

     

       256
       256
        
             createHome = true;

     

       257
       257
        
             home = "/var/lib/lightdm-data";

     

       258
       258
        
             group = "lightdm";

     

       259
       259
        
             uid = config.ids.uids.lightdm;

     

       260
       260
        
           };

     

       261
       261
        
       

     

       262
       262
       -
           users.extraGroups.lightdm.gid = config.ids.gids.lightdm;

     

       262
       262
       +
           users.groups.lightdm.gid = config.ids.gids.lightdm;

     

       263
       263
        
           services.xserver.tty     = null; # We might start multiple X servers so let the tty increment themselves..

     

       264
       264
        
           services.xserver.display = null; # We specify our own display (and logfile) in xserver-wrapper up there

     

       265
       265
        
         };

+2 -2

nixos/modules/services/x11/display-managers/sddm.nix

···

       268
       268
        
             '';

     

       269
       269
        
           };

     

       270
       270
        
       

     

       271
       271
       -
           users.extraUsers.sddm = {

     

       271
       271
       +
           users.users.sddm = {

     

       272
       272
        
             createHome = true;

     

       273
       273
        
             home = "/var/lib/sddm";

     

       274
       274
        
             group = "sddm";

     
···

       277
       277
        
       

     

       278
       278
        
           environment.etc."sddm.conf".source = cfgFile;

     

       279
       279
        
       

     

       280
       280
       -
           users.extraGroups.sddm.gid = config.ids.gids.sddm;

     

       280
       280
       +
           users.groups.sddm.gid = config.ids.gids.sddm;

     

       281
       281
        
       

     

       282
       282
        
           environment.systemPackages = [ sddm ];

     

       283
       283
        
           services.dbus.packages = [ sddm ];

+1 -1

nixos/modules/system/boot/initrd-ssh.nix

···

       79
       79
        
       

     

       80
       80
        
           boot.initrd.network.ssh.authorizedKeys = mkOption {

     

       81
       81
        
             type = types.listOf types.str;

     

       82
       82
       -
             default = config.users.extraUsers.root.openssh.authorizedKeys.keys;

     

       82
       82
       +
             default = config.users.users.root.openssh.authorizedKeys.keys;

     

       83
       83
        
             description = ''

     

       84
       84
        
               Authorized keys for the root user on initrd.

     

       85
       85
        
             '';

+8 -8

nixos/modules/system/boot/systemd.nix

···

       798
       798
        
               mkdir -m 0700 -p /var/log/journal

     

       799
       799
        
             '';

     

       800
       800
        
       

     

       801
       801
       -
           users.extraUsers.systemd-network.uid = config.ids.uids.systemd-network;

     

       802
       802
       -
           users.extraGroups.systemd-network.gid = config.ids.gids.systemd-network;

     

       803
       803
       -
           users.extraUsers.systemd-resolve.uid = config.ids.uids.systemd-resolve;

     

       804
       804
       -
           users.extraGroups.systemd-resolve.gid = config.ids.gids.systemd-resolve;

     

       801
       801
       +
           users.users.systemd-network.uid = config.ids.uids.systemd-network;

     

       802
       802
       +
           users.groups.systemd-network.gid = config.ids.gids.systemd-network;

     

       803
       803
       +
           users.users.systemd-resolve.uid = config.ids.uids.systemd-resolve;

     

       804
       804
       +
           users.groups.systemd-resolve.gid = config.ids.gids.systemd-resolve;

     

       805
       805
        
       

     

       806
       806
        
           # Target for ‘charon send-keys’ to hook into.

     

       807
       807
       -
           users.extraGroups.keys.gid = config.ids.gids.keys;

     

       807
       807
       +
           users.groups.keys.gid = config.ids.gids.keys;

     

       808
       808
        
       

     

       809
       809
        
           systemd.targets.keys =

     

       810
       810
        
             { description = "Security Keys";

     
···

       840
       840
        
               "TMPFS_XATTR" "SECCOMP"

     

       841
       841
        
             ];

     

       842
       842
        
       

     

       843
       843
       -
           users.extraGroups.systemd-journal.gid = config.ids.gids.systemd-journal;

     

       844
       844
       -
           users.extraUsers.systemd-journal-gateway.uid = config.ids.uids.systemd-journal-gateway;

     

       845
       845
       -
           users.extraGroups.systemd-journal-gateway.gid = config.ids.gids.systemd-journal-gateway;

     

       843
       843
       +
           users.groups.systemd-journal.gid = config.ids.gids.systemd-journal;

     

       844
       844
       +
           users.users.systemd-journal-gateway.uid = config.ids.uids.systemd-journal-gateway;

     

       845
       845
       +
           users.groups.systemd-journal-gateway.gid = config.ids.gids.systemd-journal-gateway;

     

       846
       846
        
       

     

       847
       847
        
           # Generate timer units for all services that have a ‘startAt’ value.

     

       848
       848
        
           systemd.timers =

+2 -2

nixos/modules/system/boot/timesyncd.nix

···

       37
       37
        
             NTP=${concatStringsSep " " config.services.timesyncd.servers}

     

       38
       38
        
           '';

     

       39
       39
        
       

     

       40
       40
       -
           users.extraUsers.systemd-timesync.uid = config.ids.uids.systemd-timesync;

     

       41
       41
       -
           users.extraGroups.systemd-timesync.gid = config.ids.gids.systemd-timesync;

     

       40
       40
       +
           users.users.systemd-timesync.uid = config.ids.uids.systemd-timesync;

     

       41
       41
       +
           users.groups.systemd-timesync.gid = config.ids.gids.systemd-timesync;

     

       42
       42
        
       

     

       43
       43
        
         };

     

       44
       44

+1 -1

nixos/modules/testing/test-instrumentation.nix

···

       126
       126
        
           networking.usePredictableInterfaceNames = false;

     

       127
       127
        
       

     

       128
       128
        
           # Make it easy to log in as root when running the test interactively.

     

       129
       129
       -
           users.extraUsers.root.initialHashedPassword = mkOverride 150 "";

     

       129
       129
       +
           users.users.root.initialHashedPassword = mkOverride 150 "";

     

       130
       130
        
       

     

       131
       131
        
           services.xserver.displayManager.job.logToJournal = true;

     

       132
       132

+1 -1

nixos/modules/virtualisation/docker.nix

···

       141
       141
        
       

     

       142
       142
        
         config = mkIf cfg.enable (mkMerge [{

     

       143
       143
        
             environment.systemPackages = [ cfg.package ];

     

       144
       144
       -
             users.extraGroups.docker.gid = config.ids.gids.docker;

     

       144
       144
       +
             users.groups.docker.gid = config.ids.gids.docker;

     

       145
       145
        
             systemd.packages = [ cfg.package ];

     

       146
       146
        
       

     

       147
       147
        
             systemd.services.docker = {

+1 -1

nixos/modules/virtualisation/libvirtd.nix

···

       108
       108
        
       

     

       109
       109
        
           boot.kernelModules = [ "tun" ];

     

       110
       110
        
       

     

       111
       111
       -
           users.extraGroups.libvirtd.gid = config.ids.gids.libvirtd;

     

       111
       111
       +
           users.groups.libvirtd.gid = config.ids.gids.libvirtd;

     

       112
       112
        
       

     

       113
       113
        
           systemd.packages = [ pkgs.libvirt ];

     

       114
       114

+1 -1

nixos/modules/virtualisation/lxc-container.nix

···

       8
       8
        
         ];

     

       9
       9
        
       

     

       10
       10
        
         # Allow the user to login as root without password.

     

       11
       11
       -
         users.extraUsers.root.initialHashedPassword = mkOverride 150 "";

     

       11
       11
       +
         users.users.root.initialHashedPassword = mkOverride 150 "";

     

       12
       12
        
       

     

       13
       13
        
         # Some more help text.

     

       14
       14
        
         services.mingetty.helpLine =

+2 -2

nixos/modules/virtualisation/lxd.nix

···

       73
       73
        
       

     

       74
       74
        
           };

     

       75
       75
        
       

     

       76
       76
       -
           users.extraGroups.lxd.gid = config.ids.gids.lxd;

     

       76
       76
       +
           users.groups.lxd.gid = config.ids.gids.lxd;

     

       77
       77
        
       

     

       78
       78
       -
           users.extraUsers.root = {

     

       78
       78
       +
           users.users.root = {

     

       79
       79
        
             subUidRanges = [ { startUid = 1000000; count = 65536; } ];

     

       80
       80
        
             subGidRanges = [ { startGid = 1000000; count = 65536; } ];

     

       81
       81
        
           };

+1 -1

nixos/modules/virtualisation/rkt.nix

···

       59
       59
        
             };

     

       60
       60
        
           };

     

       61
       61
        
       

     

       62
       62
       -
           users.extraGroups.rkt = {};

     

       62
       62
       +
           users.groups.rkt = {};

     

       63
       63
        
         };

     

       64
       64
        
       }

+1 -1

nixos/modules/virtualisation/virtualbox-guest.nix

···

       44
       44
        
           boot.supportedFilesystems = [ "vboxsf" ];

     

       45
       45
        
           boot.initrd.supportedFilesystems = [ "vboxsf" ];

     

       46
       46
        
       

     

       47
       47
       -
           users.extraGroups.vboxsf.gid = config.ids.gids.vboxsf;

     

       47
       47
       +
           users.groups.vboxsf.gid = config.ids.gids.vboxsf;

     

       48
       48
        
       

     

       49
       49
        
           systemd.services.virtualbox =

     

       50
       50
        
             { description = "VirtualBox Guest Services";

+1 -1

nixos/modules/virtualisation/virtualbox-host.nix

···

       86
       86
        
             "VirtualBox"

     

       87
       87
        
           ]));

     

       88
       88
        
       

     

       89
       89
       -
           users.extraGroups.vboxusers.gid = config.ids.gids.vboxusers;

     

       89
       89
       +
           users.groups.vboxusers.gid = config.ids.gids.vboxusers;

     

       90
       90
        
       

     

       91
       91
        
           services.udev.extraRules =

     

       92
       92
        
             ''