commit ab0564bd10b6dbf9b172731ed1a286bf8c93e483 · pyrox.dev/nixpkgs

+1

nixos/modules/hardware/sensor/hddtemp.nix

···

       75
        
         config = mkIf cfg.enable {

     

       76
        
           systemd.services.hddtemp = {

     

       77
        
             description = "HDD/SSD temperature";

     

       0
        
       
     

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

     

       79
        
             serviceConfig = {

     

       80
        
               Type = "forking";

···

       75
        
         config = mkIf cfg.enable {

     

       76
        
           systemd.services.hddtemp = {

     

       77
        
             description = "HDD/SSD temperature";

     

       78
       +
             documentation = [ "man:hddtemp(8)" ];

     

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

     

       80
        
             serviceConfig = {

     

       81
        
               Type = "forking";

+1

nixos/modules/security/auditd.nix

···

       15
        
       

     

       16
        
           systemd.services.auditd = {

     

       17
        
             description = "Linux Audit daemon";

     

       0
        
       
     

       18
        
             wantedBy = [ "sysinit.target" ];

     

       19
        
             after = [

     

       20
        
               "local-fs.target"

···

       15
        
       

     

       16
        
           systemd.services.auditd = {

     

       17
        
             description = "Linux Audit daemon";

     

       18
       +
             documentation = [ "man:auditd(8)" ];

     

       19
        
             wantedBy = [ "sysinit.target" ];

     

       20
        
             after = [

     

       21
        
               "local-fs.target"

+1

nixos/modules/security/isolate.nix

···

       128
        
           systemd.services.isolate = {

     

       129
        
             description = "Isolate control group hierarchy daemon";

     

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

     

       0
        
       
     

       131
        
             serviceConfig = {

     

       132
        
               Type = "notify";

     

       133
        
               ExecStart = "${isolate}/bin/isolate-cg-keeper";

···

       128
        
           systemd.services.isolate = {

     

       129
        
             description = "Isolate control group hierarchy daemon";

     

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

     

       131
       +
             documentation = [ "man:isolate(1)" ];

     

       132
        
             serviceConfig = {

     

       133
        
               Type = "notify";

     

       134
        
               ExecStart = "${isolate}/bin/isolate-cg-keeper";

+2

nixos/modules/services/computing/torque/server.nix

···

       70
        
           };

     

       71
        
       

     

       72
        
           systemd.services.torque-server = {

     

       0
        
       
     

       73
        
             path = [ torque ];

     

       74
        
       

     

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

     
···

       93
        
           };

     

       94
        
       

     

       95
        
           systemd.services.torque-scheduler = {

     

       0
        
       
     

       96
        
             path = [ torque ];

     

       97
        
       

     

       98
        
             requires = [ "torque-server-init.service" ];

···

       70
        
           };

     

       71
        
       

     

       72
        
           systemd.services.torque-server = {

     

       73
       +
             documentation = [ "man:pbs_server(8)" ];

     

       74
        
             path = [ torque ];

     

       75
        
       

     

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

     
···

       94
        
           };

     

       95
        
       

     

       96
        
           systemd.services.torque-scheduler = {

     

       97
       +
             documentation = [ "man:pbs_sched(8)" ];

     

       98
        
             path = [ torque ];

     

       99
        
       

     

       100
        
             requires = [ "torque-server-init.service" ];

+2

nixos/modules/services/finance/libeufin/nexus.nix

···

       127
        
             services.libeufin.nexus.settings.libeufin-nexusdb-postgres.CONFIG = lib.mkIf (

     

       128
        
               cfgMain.bank.enable && cfgMain.bank.createLocalDatabase

     

       129
        
             ) "postgresql:///libeufin-bank";

     

       0
        
       
     

       0
        
       
     

       130
        
           };

     

       131
        
       }

···

       127
        
             services.libeufin.nexus.settings.libeufin-nexusdb-postgres.CONFIG = lib.mkIf (

     

       128
        
               cfgMain.bank.enable && cfgMain.bank.createLocalDatabase

     

       129
        
             ) "postgresql:///libeufin-bank";

     

       130
       +
       

     

       131
       +
             systemd.services.libeufin-nexus.documentation = [ "man:libeufin-nexus(1)" ];

     

       132
        
           };

     

       133
        
       }

+8

nixos/modules/services/finance/taler/common.nix

···

       68
        
               requires = [ "taler-${talerComponent}-dbinit.service" ];

     

       69
        
               after = [ "taler-${talerComponent}-dbinit.service" ];

     

       70
        
               wantedBy = [ "multi-user.target" ]; # TODO slice?

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       71
        
             }))

     

       72
        
             # Database Initialisation

     

       73
        
             {

     

       74
        
               "taler-${talerComponent}-dbinit" = {

     

       75
        
                 path = [ config.services.postgresql.package ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       76
        
                 serviceConfig = {

     

       77
        
                   Type = "oneshot";

     

       78
        
                   DynamicUser = true;

···

       68
        
               requires = [ "taler-${talerComponent}-dbinit.service" ];

     

       69
        
               after = [ "taler-${talerComponent}-dbinit.service" ];

     

       70
        
               wantedBy = [ "multi-user.target" ]; # TODO slice?

     

       71
       +
               documentation = [

     

       72
       +
                 "man:taler-${talerComponent}-${name}(1)"

     

       73
       +
                 "info:taler-${talerComponent}"

     

       74
       +
               ];

     

       75
        
             }))

     

       76
        
             # Database Initialisation

     

       77
        
             {

     

       78
        
               "taler-${talerComponent}-dbinit" = {

     

       79
        
                 path = [ config.services.postgresql.package ];

     

       80
       +
                 documentation = [

     

       81
       +
                   "man:taler-${talerComponent}-dbinit(1)"

     

       82
       +
                   "info:taler-${talerComponent}"

     

       83
       +
                 ];

     

       84
        
                 serviceConfig = {

     

       85
        
                   Type = "oneshot";

     

       86
        
                   DynamicUser = true;

+1

nixos/modules/services/hardware/thermald.nix

···

       49
        
       

     

       50
        
           systemd.services.thermald = {

     

       51
        
             description = "Thermal Daemon Service";

     

       0
        
       
     

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

     

       53
        
             serviceConfig = {

     

       54
        
               PrivateNetwork = true;

···

       49
        
       

     

       50
        
           systemd.services.thermald = {

     

       51
        
             description = "Thermal Daemon Service";

     

       52
       +
             documentation = [ "man:thermald(8)" ];

     

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

     

       54
        
             serviceConfig = {

     

       55
        
               PrivateNetwork = true;

+1

nixos/modules/services/hardware/triggerhappy.nix

···

       122
        
           systemd.services.triggerhappy = {

     

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

     

       124
        
             description = "Global hotkey daemon";

     

       0
        
       
     

       125
        
             serviceConfig = {

     

       126
        
               ExecStart = "${pkgs.triggerhappy}/bin/thd ${

     

       127
        
                 lib.optionalString (cfg.user != "root") "--user ${cfg.user}"

···

       122
        
           systemd.services.triggerhappy = {

     

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

     

       124
        
             description = "Global hotkey daemon";

     

       125
       +
             documentation = [ "man:thd(1)" ];

     

       126
        
             serviceConfig = {

     

       127
        
               ExecStart = "${pkgs.triggerhappy}/bin/thd ${

     

       128
        
                 lib.optionalString (cfg.user != "root") "--user ${cfg.user}"

+1

nixos/modules/services/mail/postfix.nix

···

       871
        
               systemd.services.postfix = {

     

       872
        
                 description = "Postfix mail server";

     

       873
        
       

     

       0
        
       
     

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

     

       875
        
                 after = [

     

       876
        
                   "network.target"

···

       871
        
               systemd.services.postfix = {

     

       872
        
                 description = "Postfix mail server";

     

       873
        
       

     

       874
       +
                 documentation = [ "man:postfix(1)" ];

     

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

     

       876
        
                 after = [

     

       877
        
                   "network.target"

+1

nixos/modules/services/monitoring/glances.nix

···

       68
        
       

     

       69
        
           systemd.services."glances" = {

     

       70
        
             description = "Glances";

     

       0
        
       
     

       71
        
             after = [ "network.target" ];

     

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

     

       73

···

       68
        
       

     

       69
        
           systemd.services."glances" = {

     

       70
        
             description = "Glances";

     

       71
       +
             documentation = [ "man:glances(1)" ];

     

       72
        
             after = [ "network.target" ];

     

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

     

       74

+2

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

···

       218
        
               in

     

       219
        
               lib.nameValuePair "tahoe.introducer-${node}" {

     

       220
        
                 description = "Tahoe LAFS node ${node}";

     

       0
        
       
     

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

     

       222
        
                 path = [ settings.package ];

     

       223
        
                 restartTriggers = [

     
···

       329
        
               in

     

       330
        
               lib.nameValuePair "tahoe.${node}" {

     

       331
        
                 description = "Tahoe LAFS node ${node}";

     

       0
        
       
     

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

     

       333
        
                 path = [ settings.package ];

     

       334
        
                 restartTriggers = [

···

       218
        
               in

     

       219
        
               lib.nameValuePair "tahoe.introducer-${node}" {

     

       220
        
                 description = "Tahoe LAFS node ${node}";

     

       221
       +
                 documentation = [ "info:tahoe-lafs" ];

     

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

     

       223
        
                 path = [ settings.package ];

     

       224
        
                 restartTriggers = [

     
···

       330
        
               in

     

       331
        
               lib.nameValuePair "tahoe.${node}" {

     

       332
        
                 description = "Tahoe LAFS node ${node}";

     

       333
       +
                 documentation = [ "info:tahoe-lafs" ];

     

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

     

       335
        
                 path = [ settings.package ];

     

       336
        
                 restartTriggers = [

+6

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

···

       305
        
             description = "Avahi mDNS/DNS-SD Stack";

     

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

     

       307
        
             requires = [ "avahi-daemon.socket" ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       308
        
       

     

       309
        
             # Make NSS modules visible so that `avahi_nss_support ()' can

     

       310
        
             # return a sensible value.

···

       305
        
             description = "Avahi mDNS/DNS-SD Stack";

     

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

     

       307
        
             requires = [ "avahi-daemon.socket" ];

     

       308
       +
             documentation = [

     

       309
       +
               "man:avahi-daemon(8)"

     

       310
       +
               "man:avahi-daemon.conf(5)"

     

       311
       +
               "man:avahi.hosts(5)"

     

       312
       +
               "man:avahi.service(5)"

     

       313
       +
             ];

     

       314
        
       

     

       315
        
             # Make NSS modules visible so that `avahi_nss_support ()' can

     

       316
        
             # return a sensible value.

+2

nixos/modules/services/networking/dhcpcd.nix

···

       209
        
           in

     

       210
        
             { description = "DHCP Client";

     

       211
        
       

     

       0
        
       
     

       0
        
       
     

       212
        
               wantedBy = [ "multi-user.target" ] ++ lib.optional (!hasDefaultGatewaySet) "network-online.target";

     

       213
        
               wants = [ "network.target"  "resolvconf.service" ];

     

       214
        
               after = [ "resolvconf.service" ];

···

       209
        
           in

     

       210
        
             { description = "DHCP Client";

     

       211
        
       

     

       212
       +
               documentation = [ "man:dhcpcd(8)" ];

     

       213
       +
       

     

       214
        
               wantedBy = [ "multi-user.target" ] ++ lib.optional (!hasDefaultGatewaySet) "network-online.target";

     

       215
        
               wants = [ "network.target"  "resolvconf.service" ];

     

       216
        
               after = [ "resolvconf.service" ];

+1

nixos/modules/services/networking/gnunet.nix

···

       149
        
       

     

       150
        
           systemd.services.gnunet = {

     

       151
        
             description = "GNUnet";

     

       0
        
       
     

       152
        
             after = [ "network.target" ];

     

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

     

       154
        
             restartTriggers = [ config.environment.etc."gnunet.conf".source ];

···

       149
        
       

     

       150
        
           systemd.services.gnunet = {

     

       151
        
             description = "GNUnet";

     

       152
       +
             documentation = [ "info:gnunet" ];

     

       153
        
             after = [ "network.target" ];

     

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

     

       155
        
             restartTriggers = [ config.environment.etc."gnunet.conf".source ];

+4

nixos/modules/services/networking/gvpe.nix

···

       114
        
         config = mkIf cfg.enable {

     

       115
        
           systemd.services.gvpe = {

     

       116
        
             description = "GNU Virtual Private Ethernet node";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       117
        
             after = [ "network.target" ];

     

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

     

       119

···

       114
        
         config = mkIf cfg.enable {

     

       115
        
           systemd.services.gvpe = {

     

       116
        
             description = "GNU Virtual Private Ethernet node";

     

       117
       +
             documentation = [

     

       118
       +
               "info:gvpe"

     

       119
       +
               "man:gvpe(8)"

     

       120
       +
             ];

     

       121
        
             after = [ "network.target" ];

     

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

     

       123

+1

nixos/modules/services/networking/privoxy.nix

···

       229
        
       

     

       230
        
           systemd.services.privoxy = {

     

       231
        
             description = "Filtering web proxy";

     

       0
        
       
     

       232
        
             after = [

     

       233
        
               "network.target"

     

       234
        
               "nss-lookup.target"

···

       229
        
       

     

       230
        
           systemd.services.privoxy = {

     

       231
        
             description = "Filtering web proxy";

     

       232
       +
             documentation = [ "man:privoxy(8)" ];

     

       233
        
             after = [

     

       234
        
               "network.target"

     

       235
        
               "nss-lookup.target"

+1

nixos/modules/services/networking/soju.nix

···

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

     

       143
        
             wants = [ "network-online.target" ];

     

       144
        
             after = [ "network-online.target" ];

     

       0
        
       
     

       145
        
             serviceConfig = {

     

       146
        
               DynamicUser = true;

     

       147
        
               Restart = "always";

···

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

     

       143
        
             wants = [ "network-online.target" ];

     

       144
        
             after = [ "network-online.target" ];

     

       145
       +
             documentation = [ "man:soju(1)" ];

     

       146
        
             serviceConfig = {

     

       147
        
               DynamicUser = true;

     

       148
        
               Restart = "always";

+4

nixos/modules/services/networking/tinc.nix

···

       366
        
               ("tinc.${network}")

     

       367
        
               (let version = getVersion data.package; in {

     

       368
        
                 description = "Tinc Daemon - ${network}";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       370
        
                 path = [ data.package ];

     

       371
        
                 reloadTriggers = mkIf (versionAtLeast version "1.1pre") [ (builtins.toJSON etcConfig) ];

···

       366
        
               ("tinc.${network}")

     

       367
        
               (let version = getVersion data.package; in {

     

       368
        
                 description = "Tinc Daemon - ${network}";

     

       369
       +
                 documentation = [

     

       370
       +
                   "info:tinc"

     

       371
       +
                   "man:tincd(8)"

     

       372
       +
                 ];

     

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

     

       374
        
                 path = [ data.package ];

     

       375
        
                 reloadTriggers = mkIf (versionAtLeast version "1.1pre") [ (builtins.toJSON etcConfig) ];

+1

nixos/modules/services/scheduling/atd.nix

···

       82
        
       

     

       83
        
           systemd.services.atd = {

     

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

     

       0
        
       
     

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

     

       86
        
       

     

       87
        
             path = [ at ];

···

       82
        
       

     

       83
        
           systemd.services.atd = {

     

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

     

       85
       +
             documentation = [ "man:atd(8)" ];

     

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

     

       87
        
       

     

       88
        
             path = [ at ];

+3

nixos/modules/services/security/clamav.nix

···

       169
        
       

     

       170
        
           systemd.services.clamav-daemon = lib.mkIf cfg.daemon.enable {

     

       171
        
             description = "ClamAV daemon (clamd)";

     

       0
        
       
     

       172
        
             after = lib.optionals cfg.updater.enable [ "clamav-freshclam.service" ];

     

       173
        
             wants = lib.optionals cfg.updater.enable [ "clamav-freshclam.service" ];

     

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

     
···

       199
        
       

     

       200
        
           systemd.services.clamav-freshclam = lib.mkIf cfg.updater.enable {

     

       201
        
             description = "ClamAV virus database updater (freshclam)";

     

       0
        
       
     

       202
        
             restartTriggers = [ freshclamConfigFile ];

     

       203
        
             requires = [ "network-online.target" ];

     

       204
        
             after = [ "network-online.target" ];

     
···

       276
        
       

     

       277
        
           systemd.services.clamdscan = lib.mkIf cfg.scanner.enable {

     

       278
        
             description = "ClamAV virus scanner";

     

       0
        
       
     

       279
        
             after = lib.optionals cfg.updater.enable [ "clamav-freshclam.service" ];

     

       280
        
             wants = lib.optionals cfg.updater.enable [ "clamav-freshclam.service" ];

     

       281

···

       169
        
       

     

       170
        
           systemd.services.clamav-daemon = lib.mkIf cfg.daemon.enable {

     

       171
        
             description = "ClamAV daemon (clamd)";

     

       172
       +
             documentation = [ "man:clamd(8)" ];

     

       173
        
             after = lib.optionals cfg.updater.enable [ "clamav-freshclam.service" ];

     

       174
        
             wants = lib.optionals cfg.updater.enable [ "clamav-freshclam.service" ];

     

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

     
···

       200
        
       

     

       201
        
           systemd.services.clamav-freshclam = lib.mkIf cfg.updater.enable {

     

       202
        
             description = "ClamAV virus database updater (freshclam)";

     

       203
       +
             documentation = [ "man:freshclam(1)" ];

     

       204
        
             restartTriggers = [ freshclamConfigFile ];

     

       205
        
             requires = [ "network-online.target" ];

     

       206
        
             after = [ "network-online.target" ];

     
···

       278
        
       

     

       279
        
           systemd.services.clamdscan = lib.mkIf cfg.scanner.enable {

     

       280
        
             description = "ClamAV virus scanner";

     

       281
       +
             documentation = [ "man:clamdscan(1)" ];

     

       282
        
             after = lib.optionals cfg.updater.enable [ "clamav-freshclam.service" ];

     

       283
        
             wants = lib.optionals cfg.updater.enable [ "clamav-freshclam.service" ];

     

       284

+1

nixos/modules/services/security/endlessh.nix

···

       48
        
         config = lib.mkIf cfg.enable {

     

       49
        
           systemd.services.endlessh = {

     

       50
        
             description = "SSH tarpit";

     

       0
        
       
     

       51
        
             requires = [ "network.target" ];

     

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

     

       53
        
             serviceConfig =

···

       48
        
         config = lib.mkIf cfg.enable {

     

       49
        
           systemd.services.endlessh = {

     

       50
        
             description = "SSH tarpit";

     

       51
       +
             documentation = [ "man:endlessh(1)" ];

     

       52
        
             requires = [ "network.target" ];

     

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

     

       54
        
             serviceConfig =

+4

nixos/modules/services/security/munge.nix

···

       46
        
           users.groups.munge = { };

     

       47
        
       

     

       48
        
           systemd.services.munged = {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       50
        
             wants = [

     

       51
        
               "network-online.target"

···

       46
        
           users.groups.munge = { };

     

       47
        
       

     

       48
        
           systemd.services.munged = {

     

       49
       +
             documentation = [

     

       50
       +
               "man:munged(8)"

     

       51
       +
               "man:mungekey(8)"

     

       52
       +
             ];

     

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

     

       54
        
             wants = [

     

       55
        
               "network-online.target"

+1

nixos/modules/services/security/physlock.nix

···

       116
        
       

     

       117
        
               systemd.services.physlock = {

     

       118
        
                 enable = true;

     

       0
        
       
     

       119
        
                 description = "Physlock";

     

       120
        
                 wantedBy =

     

       121
        
                   lib.optional cfg.lockOn.suspend "suspend.target"

···

       116
        
       

     

       117
        
               systemd.services.physlock = {

     

       118
        
                 enable = true;

     

       119
       +
                 documentation = [ "man:physlock(1)" ];

     

       120
        
                 description = "Physlock";

     

       121
        
                 wantedBy =

     

       122
        
                   lib.optional cfg.lockOn.suspend "suspend.target"

+1

nixos/modules/services/security/sks.nix

···

       119
        
             {

     

       120
        
               sks-db = {

     

       121
        
                 description = "SKS database server";

     

       0
        
       
     

       122
        
                 after = [ "network.target" ];

     

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

     

       124
        
                 preStart = ''

···

       119
        
             {

     

       120
        
               sks-db = {

     

       121
        
                 description = "SKS database server";

     

       122
       +
                 documentation = [ "man:sks(8)" ];

     

       123
        
                 after = [ "network.target" ];

     

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

     

       125
        
                 preStart = ''

+1

nixos/modules/services/security/tor.nix

···

       1324
        
       

     

       1325
        
           systemd.services.tor = {

     

       1326
        
             description = "Tor Daemon";

     

       0
        
       
     

       1327
        
             path = [ pkgs.tor ];

     

       1328
        
       

     

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

···

       1324
        
       

     

       1325
        
           systemd.services.tor = {

     

       1326
        
             description = "Tor Daemon";

     

       1327
       +
             documentation = [ "man:tor(8)" ];

     

       1328
        
             path = [ pkgs.tor ];

     

       1329
        
       

     

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

+5 -1

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

···

       128
        
             in

     

       129
        
             {

     

       130
        
               description = "hledger-web - web-app for the hledger accounting tool.";

     

       131
       -
               documentation = [ "https://hledger.org/hledger-web.html" ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       133
        
               after = [ "networking.target" ];

     

       134
        
               serviceConfig = mkMerge [

···

       128
        
             in

     

       129
        
             {

     

       130
        
               description = "hledger-web - web-app for the hledger accounting tool.";

     

       131
       +
               documentation = [

     

       132
       +
                 "info:hledger-web"

     

       133
       +
                 "man:hledger-web(1)"

     

       134
       +
                 "https://hledger.org/hledger-web.html"

     

       135
       +
               ];

     

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

     

       137
        
               after = [ "networking.target" ];

     

       138
        
               serviceConfig = mkMerge [

+1

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

···

       254
        
               after = [ "network.target" ];

     

       255
        
               wantedBy = [ "phpfpm.target" ];

     

       256
        
               partOf = [ "phpfpm.target" ];

     

       0
        
       
     

       257
        
               serviceConfig = let

     

       258
        
                 cfgFile = fpmCfgFile pool poolOpts;

     

       259
        
                 iniFile = phpIni poolOpts;

···

       254
        
               after = [ "network.target" ];

     

       255
        
               wantedBy = [ "phpfpm.target" ];

     

       256
        
               partOf = [ "phpfpm.target" ];

     

       257
       +
               documentation = [ "man:php-fpm(8)" ];

     

       258
        
               serviceConfig = let

     

       259
        
                 cfgFile = fpmCfgFile pool poolOpts;

     

       260
        
                 iniFile = phpIni poolOpts;

+1

nixos/modules/tasks/filesystems/btrfs.nix

···

       166
        
                   in

     

       167
        
                   nameValuePair "btrfs-scrub-${fs'}" {

     

       168
        
                     description = "btrfs scrub on ${fs}";

     

       0
        
       
     

       169
        
                     # scrub prevents suspend2ram or proper shutdown

     

       170
        
                     conflicts = [

     

       171
        
                       "shutdown.target"

···

       166
        
                   in

     

       167
        
                   nameValuePair "btrfs-scrub-${fs'}" {

     

       168
        
                     description = "btrfs scrub on ${fs}";

     

       169
       +
                     documentation = [ "man:btrfs-scrub(8)" ];

     

       170
        
                     # scrub prevents suspend2ram or proper shutdown

     

       171
        
                     conflicts = [

     

       172
        
                       "shutdown.target"

+1

nixos/modules/tasks/powertop.nix

···

       51
        
         config = mkIf (cfg.enable) {

     

       52
        
           systemd.services = {

     

       53
        
             powertop = {

     

       0
        
       
     

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

     

       55
        
               after = [ "multi-user.target" ];

     

       56
        
               description = "Powertop tunings";

···

       51
        
         config = mkIf (cfg.enable) {

     

       52
        
           systemd.services = {

     

       53
        
             powertop = {

     

       54
       +
               documentation = [ "man:powertop(8)" ];

     

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

     

       56
        
               after = [ "multi-user.target" ];

     

       57
        
               description = "Powertop tunings";