commit dd0a47e7ae2f6f33298c61f75aff2652e0a2f6d6 · pyrox.dev/nixpkgs

+1

nixos/modules/programs/x2goserver.nix

···

       69
       69
        
           users.users.x2go = {

     

       70
       70
        
             home = "/var/lib/x2go/db";

     

       71
       71
        
             group = "x2go";

     

       72
       72
       +
             isSystemUser = true;

     

       72
       73
        
           };

     

       73
       74
        
       

     

       74
       75
        
           security.wrappers.x2gosqliteWrapper = {

+1

nixos/modules/services/admin/oxidized.nix

···

       89
       89
        
             group = cfg.group;

     

       90
       90
        
             home = cfg.dataDir;

     

       91
       91
        
             createHome = true;

     

       92
       92
       +
             isSystemUser = true;

     

       92
       93
        
           };

     

       93
       94
        
       

     

       94
       95
        
           systemd.services.oxidized = {

+1

nixos/modules/services/audio/jack.nix

···

       223
       223
        
               group = "jackaudio";

     

       224
       224
        
               extraGroups = [ "audio" ];

     

       225
       225
        
               description = "JACK Audio system service user";

     

       226
       226
       +
               isSystemUser = true;

     

       226
       227
        
             };

     

       227
       228
        
             # http://jackaudio.org/faq/linux_rt_config.html

     

       228
       229
        
             security.pam.loginLimits = [

+4 -1

nixos/modules/services/backup/automysqlbackup.nix

···

       99
       99
        
       

     

       100
       100
        
           environment.systemPackages = [ pkg ];

     

       101
       101
        
       

     

       102
       102
       -
           users.users.${user}.group = group;

     

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

     

       103
       103
       +
             group = group;

     

       104
       104
       +
             isSystemUser = true;

     

       105
       105
       +
           };

     

       103
       106
        
           users.groups.${group} = { };

     

       104
       107
        
       

     

       105
       108
        
           systemd.tmpfiles.rules = [

+1

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

···

       191
       191
        
               createHome = true;

     

       192
       192
        
               description = "Buildkite agent user";

     

       193
       193
        
               extraGroups = [ "keys" ];

     

       194
       194
       +
               isSystemUser = true;

     

       194
       195
        
             };

     

       195
       196
        
       

     

       196
       197
        
           environment.systemPackages = [ cfg.package ];

+4 -1

nixos/modules/services/databases/redis.nix

···

       194
       194
        
             allowedTCPPorts = [ cfg.port ];

     

       195
       195
        
           };

     

       196
       196
        
       

     

       197
       197
       -
           users.users.redis.description = "Redis database user";

     

       197
       197
       +
           users.users.redis = {

     

       198
       198
       +
             description = "Redis database user";

     

       199
       199
       +
             isSystemUser = true;

     

       200
       200
       +
           };

     

       198
       201
        
       

     

       199
       202
        
           environment.systemPackages = [ cfg.package ];

     

       200
       203

+1

nixos/modules/services/databases/rethinkdb.nix

···

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

     

       100
       100
        
             { name = "rethinkdb";

     

       101
       101
        
               description = "RethinkDB server user";

     

       102
       102
       +
               isSystemUser = true;

     

       102
       103
        
             };

     

       103
       104
        
       

     

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

+1

nixos/modules/services/editors/infinoted.nix

···

       115
       115
        
             { name = "infinoted";

     

       116
       116
        
               description = "Infinoted user";

     

       117
       117
        
               group = cfg.group;

     

       118
       118
       +
               isSystemUser = true;

     

       118
       119
        
             };

     

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

     

       120
       121
        
             { name = "infinoted";

+1

nixos/modules/services/hardware/trezord.nix

···

       61
       61
        
           users.users.trezord = {

     

       62
       62
        
             group = "trezord";

     

       63
       63
        
             description = "Trezor bridge daemon user";

     

       64
       64
       +
             isSystemUser = true;

     

       64
       65
        
           };

     

       65
       66
        
       

     

       66
       67
        
           users.groups.trezord = {};

+1

nixos/modules/services/hardware/usbmuxd.nix

···

       47
       47
        
             name = cfg.user;

     

       48
       48
        
             description = "usbmuxd user";

     

       49
       49
        
             group = cfg.group;

     

       50
       50
       +
             isSystemUser = true;

     

       50
       51
        
           };

     

       51
       52
        
       

     

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

+1

nixos/modules/services/hardware/vdr.nix

···

       66
       66
        
           users.users.vdr = {

     

       67
       67
        
             group = "vdr";

     

       68
       68
        
             home = libDir;

     

       69
       69
       +
             isSystemUser = true;

     

       69
       70
        
           };

     

       70
       71
        
       

     

       71
       72
        
           users.groups.vdr = {};

+1

nixos/modules/services/mail/mailhog.nix

···

       27
       27
        
           users.users.mailhog = {

     

       28
       28
        
             name = cfg.user;

     

       29
       29
        
             description = "MailHog service user";

     

       30
       30
       +
             isSystemUser = true;

     

       30
       31
        
           };

     

       31
       32
        
       

     

       32
       33
        
           systemd.services.mailhog = {

+1

nixos/modules/services/misc/airsonic.nix

···

       148
       148
        
             name = cfg.user;

     

       149
       149
        
             home = cfg.home;

     

       150
       150
        
             createHome = true;

     

       151
       151
       +
             isSystemUser = true;

     

       151
       152
        
           };

     

       152
       153
        
         };

     

       153
       154
        
       }

+4 -2

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

···

       145
       145
        
           };

     

       146
       146
        
       

     

       147
       147
        
           users.users.docker-registry =

     

       148
       148
       -
             if cfg.storagePath != null

     

       148
       148
       +
             (if cfg.storagePath != null

     

       149
       149
        
             then {

     

       150
       150
        
               createHome = true;

     

       151
       151
        
               home = cfg.storagePath;

     

       152
       152
        
             }

     

       153
       153
       -
             else {};

     

       153
       153
       +
             else {}) // {

     

       154
       154
       +
               isSystemUser = true;

     

       155
       155
       +
             };

     

       154
       156
        
         };

     

       155
       157
        
       }

+4 -1

nixos/modules/services/misc/errbot.nix

···

       76
       76
        
         };

     

       77
       77
        
       

     

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

     

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

     

       79
       79
       +
           users.users.errbot = {

     

       80
       80
       +
             group = "errbot";

     

       81
       81
       +
             isSystemUser = true;

     

       82
       82
       +
           };

     

       80
       83
        
           users.groups.errbot = {};

     

       81
       84
        
       

     

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

+1

nixos/modules/services/misc/gitea.nix

···

       409
       409
        
               home = cfg.stateDir;

     

       410
       410
        
               useDefaultShell = true;

     

       411
       411
        
               group = "gitea";

     

       412
       412
       +
               isSystemUser = true;

     

       412
       413
        
             };

     

       413
       414
        
           };

     

       414
       415

+1

nixos/modules/services/misc/gollum.nix

···

       71
       71
        
             group = config.users.users.gollum.name;

     

       72
       72
        
             description = "Gollum user";

     

       73
       73
        
             createHome = false;

     

       74
       74
       +
             isSystemUser = true;

     

       74
       75
        
           };

     

       75
       76
        
       

     

       76
       77
        
           users.groups.gollum = { };

+4 -1

nixos/modules/services/misc/jellyfin.nix

···

       41
       41
        
           };

     

       42
       42
        
       

     

       43
       43
        
           users.users = mkIf (cfg.user == "jellyfin") {

     

       44
       44
       -
             jellyfin.group = cfg.group;

     

       44
       44
       +
             jellyfin = {

     

       45
       45
       +
               group = cfg.group;

     

       46
       46
       +
               isSystemUser = true;

     

       47
       47
       +
             };

     

       45
       48
        
           };

     

       46
       49
        
       

     

       47
       50
        
           users.groups = mkIf (cfg.group == "jellyfin") {

+1

nixos/modules/services/misc/osrm.nix

···

       59
       59
        
             group = config.users.users.osrm.name;

     

       60
       60
        
             description = "OSRM user";

     

       61
       61
        
             createHome = false;

     

       62
       62
       +
             isSystemUser = true;

     

       62
       63
        
           };

     

       63
       64
        
       

     

       64
       65
        
           users.groups.osrm = { };

+1

nixos/modules/services/monitoring/collectd.nix

···

       131
       131
        
       

     

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

     

       133
       133
        
             name = "collectd";

     

       134
       134
       +
             isSystemUser = true;

     

       134
       135
        
           };

     

       135
       136
        
         };

     

       136
       137
        
       }

+1

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

···

       49
       49
        
           users.users = singleton {

     

       50
       50
        
             name = "fusion-inventory";

     

       51
       51
        
             description = "FusionInventory user";

     

       52
       52
       +
             isSystemUser = true;

     

       52
       53
        
           };

     

       53
       54
        
       

     

       54
       55
        
           systemd.services.fusion-inventory = {

+1

nixos/modules/services/monitoring/netdata.nix

···

       181
       181
        
       

     

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

     

       183
       183
        
             name = defaultUser;

     

       184
       184
       +
             isSystemUser = true;

     

       184
       185
        
           };

     

       185
       186
        
       

     

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

+1

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

···

       131
       131
        
           users.users.${user} = {

     

       132
       132
        
             description = "Zabbix Agent daemon user";

     

       133
       133
        
             inherit group;

     

       134
       134
       +
             isSystemUser = true;

     

       134
       135
        
           };

     

       135
       136
        
       

     

       136
       137
        
           users.groups.${group} = { };

+1

nixos/modules/services/networking/bitcoind.nix

···

       187
       187
        
             group = cfg.group;

     

       188
       188
        
             description = "Bitcoin daemon user";

     

       189
       189
        
             home = cfg.dataDir;

     

       190
       190
       +
             isSystemUser = true;

     

       190
       191
        
           };

     

       191
       192
        
           users.groups.${cfg.group} = {

     

       192
       193
        
             name = cfg.group;

+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.users.dnscache = {};

     

       87
       87
       +
           users.users.dnscache.isSystemUser = true;

     

       88
       88
        
       

     

       89
       89
        
           systemd.services.dnscache = {

     

       90
       90
        
             description = "djbdns dnscache server";

+1

nixos/modules/services/networking/dnscrypt-wrapper.nix

···

       142
       142
        
             description = "dnscrypt-wrapper daemon user";

     

       143
       143
        
             home = "${dataDir}";

     

       144
       144
        
             createHome = true;

     

       145
       145
       +
             isSystemUser = true;

     

       145
       146
        
           };

     

       146
       147
        
           users.groups.dnscrypt-wrapper = { };

     

       147
       148

+1

nixos/modules/services/networking/hans.nix

···

       138
       138
        
           users.users = singleton {

     

       139
       139
        
             name = hansUser;

     

       140
       140
        
             description = "Hans daemon user";

     

       141
       141
       +
             isSystemUser = true;

     

       141
       142
        
           };

     

       142
       143
        
         };

     

       143
       144

+1

nixos/modules/services/networking/matterbridge.nix

···

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

     

       96
       96
        
             { name = "matterbridge";

     

       97
       97
        
               group = "matterbridge";

     

       98
       98
       +
               isSystemUser = true;

     

       98
       99
        
             };

     

       99
       100
        
       

     

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

+1

nixos/modules/services/networking/morty.nix

···

       74
       74
        
             { description = "Morty user";

     

       75
       75
        
               createHome = true;

     

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

     

       77
       77
       +
               isSystemUser = true;

     

       77
       78
        
             };

     

       78
       79
        
       

     

       79
       80
        
           systemd.services.morty =

+1

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

···

       96
       96
        
           users.groups.nghttpx = { };

     

       97
       97
        
           users.users.nghttpx = {

     

       98
       98
        
             group = config.users.groups.nghttpx.name;

     

       99
       99
       +
             isSystemUser = true;

     

       99
       100
        
           };

     

       100
       101
        
             

     

       101
       102

+1

nixos/modules/services/networking/owamp.nix

···

       21
       21
        
             name = "owamp";

     

       22
       22
        
             group = "owamp";

     

       23
       23
        
             description = "Owamp daemon";

     

       24
       24
       +
             isSystemUser = true;

     

       24
       25
        
           };

     

       25
       26
        
       

     

       26
       27
        
           users.groups = singleton {

+1

nixos/modules/services/networking/thelounge.nix

···

       56
       56
        
           users.users.thelounge = {

     

       57
       57
        
             description = "thelounge service user";

     

       58
       58
        
             group = "thelounge";

     

       59
       59
       +
             isSystemUser = true;

     

       59
       60
        
           };

     

       60
       61
        
           users.groups.thelounge = {};

     

       61
       62
        
           systemd.services.thelounge = {

+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.users.tinydns = {};

     

       35
       35
       +
           users.users.tinydns.isSystemUser = true;

     

       36
       36
        
       

     

       37
       37
        
           systemd.services.tinydns = {

     

       38
       38
        
             description = "djbdns tinydns server";

+1 -1

nixos/modules/services/scheduling/marathon.nix

···

       93
       93
        
             };

     

       94
       94
        
           };

     

       95
       95
        
       

     

       96
       96
       -
           users.users.${cfg.user} = { };

     

       96
       96
       +
           users.users.${cfg.user}.isSystemUser = true;

     

       97
       97
        
         };

     

       98
       98
        
       }

+4 -1

nixos/modules/services/security/bitwarden_rs/default.nix

···

       74
       74
        
             webVaultEnabled = mkDefault true;

     

       75
       75
        
           };

     

       76
       76
        
       

     

       77
       77
       -
           users.users.bitwarden_rs = { inherit group; };

     

       77
       77
       +
           users.users.bitwarden_rs = {

     

       78
       78
       +
             inherit group;

     

       79
       79
       +
             isSystemUser = true;

     

       80
       80
       +
           };

     

       78
       81
        
           users.groups.bitwarden_rs = { };

     

       79
       82
        
       

     

       80
       83
        
           systemd.services.bitwarden_rs = {

+1

nixos/modules/services/security/oauth2_proxy.nix

···

       546
       546
        
       

     

       547
       547
        
           users.users.oauth2_proxy = {

     

       548
       548
        
             description = "OAuth2 Proxy";

     

       549
       549
       +
             isSystemUser = true;

     

       549
       550
        
           };

     

       550
       551
        
       

     

       551
       552
        
           systemd.services.oauth2_proxy = {

+1

nixos/modules/services/torrent/magnetico.nix

···

       171
       171
        
       

     

       172
       172
        
           users.users.magnetico = {

     

       173
       173
        
             description = "Magnetico daemons user";

     

       174
       174
       +
             isSystemUser = true;

     

       174
       175
        
           };

     

       175
       176
        
       

     

       176
       177
        
           systemd.services.magneticod = {

+1

nixos/modules/services/web-apps/codimd.nix

···

       893
       893
        
             extraGroups = cfg.groups;

     

       894
       894
        
             home = cfg.workDir;

     

       895
       895
        
             createHome = true;

     

       896
       896
       +
             isSystemUser = true;

     

       896
       897
        
           };

     

       897
       898
        
       

     

       898
       899
        
           systemd.services.codimd = {

+1

nixos/modules/services/web-apps/frab.nix

···

       177
       177
        
             { name = cfg.user;

     

       178
       178
        
               group = cfg.group;

     

       179
       179
        
               home = "${cfg.statePath}";

     

       180
       180
       +
               isSystemUser = true;

     

       180
       181
        
             }

     

       181
       182
        
           ];

     

       182
       183

+4 -1

nixos/modules/services/web-apps/limesurvey.nix

···

       277
       277
        
       

     

       278
       278
        
           systemd.services.httpd.after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.service";

     

       279
       279
        
       

     

       280
       280
       -
           users.users.${user}.group = group;

     

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

     

       281
       281
       +
             group = group;

     

       282
       282
       +
             isSystemUser = true;

     

       283
       283
       +
           };

     

       281
       284
        
       

     

       282
       285
        
         };

     

       283
       286
        
       }

+4 -1

nixos/modules/services/web-apps/mediawiki.nix

···

       461
       461
        
       

     

       462
       462
        
           systemd.services.httpd.after = optional (cfg.database.createLocally && cfg.database.type == "mysql") "mysql.service";

     

       463
       463
        
       

     

       464
       464
       -
           users.users.${user}.group = group;

     

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

     

       465
       465
       +
             group = group;

     

       466
       466
       +
             isSystemUser = true;

     

       467
       467
       +
           };

     

       465
       468
        
       

     

       466
       469
        
           environment.systemPackages = [ mediawikiScripts ];

     

       467
       470
        
         };

+4 -2

nixos/modules/services/web-apps/moodle.nix

···

       309
       309
        
       

     

       310
       310
        
           systemd.services.httpd.after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.service";

     

       311
       311
        
       

     

       312
       312
       -
           users.users.${user}.group = group;

     

       313
       313
       -
       

     

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

     

       313
       313
       +
             group = group;

     

       314
       314
       +
             isSystemUser = true;

     

       315
       315
       +
           };

     

       314
       316
        
         };

     

       315
       317
        
       }

+1

nixos/modules/services/web-apps/virtlyst.nix

···

       54
       54
        
             home = stateDir;

     

       55
       55
        
             createHome = true;

     

       56
       56
        
             group = mkIf config.virtualisation.libvirtd.enable "libvirtd";

     

       57
       57
       +
             isSystemUser = true;

     

       57
       58
        
           };

     

       58
       59
        
       

     

       59
       60
        
           systemd.services.virtlyst = {

+4 -1

nixos/modules/services/web-apps/wordpress.nix

···

       367
       367
        
             })

     

       368
       368
        
           ];

     

       369
       369
        
       

     

       370
       370
       -
           users.users.${user}.group = group;

     

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

     

       371
       371
       +
             group = group;

     

       372
       372
       +
             isSystemUser = true;

     

       373
       373
       +
           };

     

       371
       374
        
       

     

       372
       375
        
         };

     

       373
       376
        
       }

+4 -1

nixos/modules/services/web-servers/hitch/default.nix

···

       102
       102
        
       

     

       103
       103
        
           environment.systemPackages = [ pkgs.hitch ];

     

       104
       104
        
       

     

       105
       105
       -
           users.users.hitch.group = "hitch";

     

       105
       105
       +
           users.users.hitch = {

     

       106
       106
       +
             group = "hitch";

     

       107
       107
       +
             isSystemUser = true;

     

       108
       108
       +
           };

     

       106
       109
        
           users.groups.hitch = {};

     

       107
       110
        
         };

     

       108
       111
        
       }

+1

nixos/modules/services/web-servers/traefik.nix

···

       117
       117
        
             group = "traefik";

     

       118
       118
        
             home = cfg.dataDir;

     

       119
       119
        
             createHome = true;

     

       120
       120
       +
             isSystemUser = true;

     

       120
       121
        
           };

     

       121
       122
        
       

     

       122
       123
        
           users.groups.traefik = {};

+1

nixos/modules/services/web-servers/unit/default.nix

···

       116
       116
        
           users.users = optionalAttrs (cfg.user == "unit") (singleton {

     

       117
       117
        
             name = "unit";

     

       118
       118
        
             group = cfg.group;

     

       119
       119
       +
             isSystemUser = true;

     

       119
       120
        
           });

     

       120
       121
        
       

     

       121
       122
        
           users.groups = optionalAttrs (cfg.group == "unit") (singleton {