commit b51f8036c2c4e887ce45372dc6b7a4c4a54a0ea0 · pyrox.dev/nixpkgs

+11 -11

nixos/modules/security/pam.nix

···

       773
       773
        
                 }

     

       774
       774
        
              ];

     

       775
       775
        
       

     

       776
       776
       -
            description =

     

       777
       777
       -
              '' Define resource limits that should apply to users or groups.

     

       778
       778
       -
                 Each item in the list should be an attribute set with a

     

       779
       779
       -
                 <varname>domain</varname>, <varname>type</varname>,

     

       780
       780
       -
                 <varname>item</varname>, and <varname>value</varname>

     

       781
       781
       -
                 attribute.  The syntax and semantics of these attributes

     

       782
       782
       -
                 must be that described in <citerefentry><refentrytitle>limits.conf</refentrytitle><manvolnum>5</manvolnum></citerefentry>.

     

       776
       776
       +
            description = ''

     

       777
       777
       +
              Define resource limits that should apply to users or groups.

     

       778
       778
       +
              Each item in the list should be an attribute set with a

     

       779
       779
       +
              <varname>domain</varname>, <varname>type</varname>,

     

       780
       780
       +
              <varname>item</varname>, and <varname>value</varname>

     

       781
       781
       +
              attribute.  The syntax and semantics of these attributes

     

       782
       782
       +
              must be that described in <citerefentry><refentrytitle>limits.conf</refentrytitle><manvolnum>5</manvolnum></citerefentry>.

     

       783
       783
        
       

     

       784
       784
       -
                 Note that these limits do not apply to systemd services,

     

       785
       785
       -
                 whose limits can be changed via <option>systemd.extraConfig</option>

     

       786
       786
       -
                 instead.

     

       787
       787
       -
              '';

     

       784
       784
       +
              Note that these limits do not apply to systemd services,

     

       785
       785
       +
              whose limits can be changed via <option>systemd.extraConfig</option>

     

       786
       786
       +
              instead.

     

       787
       787
       +
            '';

     

       788
       788
        
           };

     

       789
       789
        
       

     

       790
       790
        
           security.pam.services = mkOption {

+2 -2

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

···

       121
       121
        
             keepalive = mkOption {

     

       122
       122
        
               default = 600;

     

       123
       123
        
               type = types.int;

     

       124
       124
       -
               description = "

     

       124
       124
       +
               description = ''

     

       125
       125
        
                 This is a number that indicates how frequently keepalive messages should be sent

     

       126
       126
        
                 from the worker to the buildmaster, expressed in seconds.

     

       127
       127
       -
               ";

     

       127
       127
       +
               '';

     

       128
       128
        
             };

     

       129
       129
        
       

     

       130
       130
        
             package = mkOption {

+2 -2

nixos/modules/services/databases/mongodb.nix

···

       35
       35
        
               default = pkgs.mongodb;

     

       36
       36
        
               defaultText = literalExpression "pkgs.mongodb";

     

       37
       37
        
               type = types.package;

     

       38
       38
       -
               description = "

     

       38
       38
       +
               description = ''

     

       39
       39
        
                 Which MongoDB derivation to use.

     

       40
       40
       -
               ";

     

       40
       40
       +
               '';

     

       41
       41
        
             };

     

       42
       42
        
       

     

       43
       43
        
             user = mkOption {

+2 -2

nixos/modules/services/databases/mysql.nix

···

       36
       36
        
             package = mkOption {

     

       37
       37
        
               type = types.package;

     

       38
       38
        
               example = literalExpression "pkgs.mariadb";

     

       39
       39
       -
               description = "

     

       39
       39
       +
               description = ''

     

       40
       40
        
                 Which MySQL derivation to use. MariaDB packages are supported too.

     

       41
       41
       -
               ";

     

       41
       41
       +
               '';

     

       42
       42
        
             };

     

       43
       43
        
       

     

       44
       44
        
             user = mkOption {

+7 -6

nixos/modules/services/development/jupyter/default.nix

···

       149
       149
        
                 };

     

       150
       150
        
               }

     

       151
       151
        
             '';

     

       152
       152
       -
             description = "Declarative kernel config

     

       152
       152
       +
             description = ''

     

       153
       153
       +
               Declarative kernel config.

     

       153
       154
        
       

     

       154
       154
       -
             Kernels can be declared in any language that supports and has the required

     

       155
       155
       -
             dependencies to communicate with a jupyter server.

     

       156
       156
       -
             In python's case, it means that ipykernel package must always be included in

     

       157
       157
       -
             the list of packages of the targeted environment.

     

       158
       158
       -
             ";

     

       155
       155
       +
               Kernels can be declared in any language that supports and has the required

     

       156
       156
       +
               dependencies to communicate with a jupyter server.

     

       157
       157
       +
               In python's case, it means that ipykernel package must always be included in

     

       158
       158
       +
               the list of packages of the targeted environment.

     

       159
       159
       +
             '';

     

       159
       160
        
           };

     

       160
       161
        
         };

     

       161
       162

+36 -36

nixos/modules/services/mail/postfix.nix

···

       355
       355
        
             setgidGroup = mkOption {

     

       356
       356
        
               type = types.str;

     

       357
       357
        
               default = "postdrop";

     

       358
       358
       -
               description = "

     

       358
       358
       +
               description = ''

     

       359
       359
        
                 How to call postfix setgid group (for postdrop). Should

     

       360
       360
        
                 be uniquely used group.

     

       361
       361
       -
               ";

     

       361
       361
       +
               '';

     

       362
       362
        
             };

     

       363
       363
        
       

     

       364
       364
        
             networks = mkOption {

     

       365
       365
        
               type = types.nullOr (types.listOf types.str);

     

       366
       366
        
               default = null;

     

       367
       367
        
               example = ["192.168.0.1/24"];

     

       368
       368
       -
               description = "

     

       368
       368
       +
               description = ''

     

       369
       369
        
                 Net masks for trusted - allowed to relay mail to third parties -

     

       370
       370
        
                 hosts. Leave empty to use mynetworks_style configuration or use

     

       371
       371
        
                 default (localhost-only).

     

       372
       372
       -
               ";

     

       372
       372
       +
               '';

     

       373
       373
        
             };

     

       374
       374
        
       

     

       375
       375
        
             networksStyle = mkOption {

     

       376
       376
        
               type = types.str;

     

       377
       377
        
               default = "";

     

       378
       378
       -
               description = "

     

       378
       378
       +
               description = ''

     

       379
       379
        
                 Name of standard way of trusted network specification to use,

     

       380
       380
        
                 leave blank if you specify it explicitly or if you want to use

     

       381
       381
        
                 default (localhost-only).

     

       382
       382
       -
               ";

     

       382
       382
       +
               '';

     

       383
       383
        
             };

     

       384
       384
        
       

     

       385
       385
        
             hostname = mkOption {

     

       386
       386
        
               type = types.str;

     

       387
       387
        
               default = "";

     

       388
       388
       -
               description ="

     

       388
       388
       +
               description = ''

     

       389
       389
        
                 Hostname to use. Leave blank to use just the hostname of machine.

     

       390
       390
        
                 It should be FQDN.

     

       391
       391
       -
               ";

     

       391
       391
       +
               '';

     

       392
       392
        
             };

     

       393
       393
        
       

     

       394
       394
        
             domain = mkOption {

     

       395
       395
        
               type = types.str;

     

       396
       396
        
               default = "";

     

       397
       397
       -
               description ="

     

       397
       397
       +
               description = ''

     

       398
       398
        
                 Domain to use. Leave blank to use hostname minus first component.

     

       399
       399
       -
               ";

     

       399
       399
       +
               '';

     

       400
       400
        
             };

     

       401
       401
        
       

     

       402
       402
        
             origin = mkOption {

     

       403
       403
        
               type = types.str;

     

       404
       404
        
               default = "";

     

       405
       405
       -
               description ="

     

       405
       405
       +
               description = ''

     

       406
       406
        
                 Origin to use in outgoing e-mail. Leave blank to use hostname.

     

       407
       407
       -
               ";

     

       407
       407
       +
               '';

     

       408
       408
        
             };

     

       409
       409
        
       

     

       410
       410
        
             destination = mkOption {

     

       411
       411
        
               type = types.nullOr (types.listOf types.str);

     

       412
       412
        
               default = null;

     

       413
       413
        
               example = ["localhost"];

     

       414
       414
       -
               description = "

     

       414
       414
       +
               description = ''

     

       415
       415
        
                 Full (!) list of domains we deliver locally. Leave blank for

     

       416
       416
        
                 acceptable Postfix default.

     

       417
       417
       -
               ";

     

       417
       417
       +
               '';

     

       418
       418
        
             };

     

       419
       419
        
       

     

       420
       420
        
             relayDomains = mkOption {

     

       421
       421
        
               type = types.nullOr (types.listOf types.str);

     

       422
       422
        
               default = null;

     

       423
       423
        
               example = ["localdomain"];

     

       424
       424
       -
               description = "

     

       424
       424
       +
               description = ''

     

       425
       425
        
                 List of domains we agree to relay to. Default is empty.

     

       426
       426
       -
               ";

     

       426
       426
       +
               '';

     

       427
       427
        
             };

     

       428
       428
        
       

     

       429
       429
        
             relayHost = mkOption {

     

       430
       430
        
               type = types.str;

     

       431
       431
        
               default = "";

     

       432
       432
       -
               description = "

     

       432
       432
       +
               description = ''

     

       433
       433
        
                 Mail relay for outbound mail.

     

       434
       434
       -
               ";

     

       434
       434
       +
               '';

     

       435
       435
        
             };

     

       436
       436
        
       

     

       437
       437
        
             relayPort = mkOption {

     

       438
       438
        
               type = types.int;

     

       439
       439
        
               default = 25;

     

       440
       440
       -
               description = "

     

       440
       440
       +
               description = ''

     

       441
       441
        
                 SMTP port for relay mail relay.

     

       442
       442
       -
               ";

     

       442
       442
       +
               '';

     

       443
       443
        
             };

     

       444
       444
        
       

     

       445
       445
        
             lookupMX = mkOption {

     

       446
       446
        
               type = types.bool;

     

       447
       447
        
               default = false;

     

       448
       448
       -
               description = "

     

       448
       448
       +
               description = ''

     

       449
       449
        
                 Whether relay specified is just domain whose MX must be used.

     

       450
       450
       -
               ";

     

       450
       450
       +
               '';

     

       451
       451
        
             };

     

       452
       452
        
       

     

       453
       453
        
             postmasterAlias = mkOption {

     

       454
       454
        
               type = types.str;

     

       455
       455
        
               default = "root";

     

       456
       456
       -
               description = "

     

       456
       456
       +
               description = ''

     

       457
       457
        
                 Who should receive postmaster e-mail. Multiple values can be added by

     

       458
       458
        
                 separating values with comma.

     

       459
       459
       -
               ";

     

       459
       459
       +
               '';

     

       460
       460
        
             };

     

       461
       461
        
       

     

       462
       462
        
             rootAlias = mkOption {

     

       463
       463
        
               type = types.str;

     

       464
       464
        
               default = "";

     

       465
       465
       -
               description = "

     

       465
       465
       +
               description = ''

     

       466
       466
        
                 Who should receive root e-mail. Blank for no redirection.

     

       467
       467
        
                 Multiple values can be added by separating values with comma.

     

       468
       468
       -
               ";

     

       468
       468
       +
               '';

     

       469
       469
        
             };

     

       470
       470
        
       

     

       471
       471
        
             extraAliases = mkOption {

     

       472
       472
        
               type = types.lines;

     

       473
       473
        
               default = "";

     

       474
       474
       -
               description = "

     

       474
       474
       +
               description = ''

     

       475
       475
        
                 Additional entries to put verbatim into aliases file, cf. man-page aliases(8).

     

       476
       476
       -
               ";

     

       476
       476
       +
               '';

     

       477
       477
        
             };

     

       478
       478
        
       

     

       479
       479
        
             aliasMapType = mkOption {

     
···

       497
       497
        
             extraConfig = mkOption {

     

       498
       498
        
               type = types.lines;

     

       499
       499
        
               default = "";

     

       500
       500
       -
               description = "

     

       500
       500
       +
               description = ''

     

       501
       501
        
                 Extra lines to be added verbatim to the main.cf configuration file.

     

       502
       502
       -
               ";

     

       502
       502
       +
               '';

     

       503
       503
        
             };

     

       504
       504
        
       

     

       505
       505
        
             tlsTrustedAuthorities = mkOption {

     
···

       527
       527
        
               type = types.str;

     

       528
       528
        
               default = "";

     

       529
       529
        
               example = "+";

     

       530
       530
       -
               description = "

     

       530
       530
       +
               description = ''

     

       531
       531
        
                 Delimiter for address extension: so mail to user+test can be handled by ~user/.forward+test

     

       532
       532
       -
               ";

     

       532
       532
       +
               '';

     

       533
       533
        
             };

     

       534
       534
        
       

     

       535
       535
        
             canonical = mkOption {

     
···

       543
       543
        
             virtual = mkOption {

     

       544
       544
        
               type = types.lines;

     

       545
       545
        
               default = "";

     

       546
       546
       -
               description = "

     

       546
       546
       +
               description = ''

     

       547
       547
        
                 Entries for the virtual alias map, cf. man-page virtual(5).

     

       548
       548
       -
               ";

     

       548
       548
       +
               '';

     

       549
       549
        
             };

     

       550
       550
        
       

     

       551
       551
        
             virtualMapType = mkOption {

     
···

       572
       572
        
             transport = mkOption {

     

       573
       573
        
               default = "";

     

       574
       574
        
               type = types.lines;

     

       575
       575
       -
               description = "

     

       575
       575
       +
               description = ''

     

       576
       576
        
                 Entries for the transport map, cf. man-page transport(8).

     

       577
       577
       -
               ";

     

       577
       577
       +
               '';

     

       578
       578
        
             };

     

       579
       579
        
       

     

       580
       580
        
             dnsBlacklists = mkOption {

+2 -2

nixos/modules/services/misc/exhibitor.nix

···

       71
       71
        
             enable = mkOption {

     

       72
       72
        
               type = types.bool;

     

       73
       73
        
               default = false;

     

       74
       74
       -
               description = "

     

       74
       74
       +
               description = ''

     

       75
       75
        
                 Whether to enable the exhibitor server.

     

       76
       76
       -
               ";

     

       76
       76
       +
               '';

     

       77
       77
        
             };

     

       78
       78
        
             # See https://github.com/soabase/exhibitor/wiki/Running-Exhibitor for what these mean

     

       79
       79
        
             # General options for any type of config

+10 -10

nixos/modules/services/monitoring/nagios.nix

···

       91
       91
        
             enable = mkEnableOption ''<link xlink:href="http://www.nagios.org/">Nagios</link> to monitor your system or network.'';

     

       92
       92
        
       

     

       93
       93
        
             objectDefs = mkOption {

     

       94
       94
       -
               description = "

     

       94
       94
       +
               description = ''

     

       95
       95
        
                 A list of Nagios object configuration files that must define

     

       96
       96
        
                 the hosts, host groups, services and contacts for the

     

       97
       97
        
                 network that you want Nagios to monitor.

     

       98
       98
       -
               ";

     

       98
       98
       +
               '';

     

       99
       99
        
               type = types.listOf types.path;

     

       100
       100
        
               example = literalExpression "[ ./objects.cfg ]";

     

       101
       101
        
             };

     
···

       104
       104
        
               type = types.listOf types.package;

     

       105
       105
        
               default = with pkgs; [ monitoring-plugins msmtp mailutils ];

     

       106
       106
        
               defaultText = literalExpression "[pkgs.monitoring-plugins pkgs.msmtp pkgs.mailutils]";

     

       107
       107
       -
               description = "

     

       107
       107
       +
               description = ''

     

       108
       108
        
                 Packages to be added to the Nagios <envar>PATH</envar>.

     

       109
       109
        
                 Typically used to add plugins, but can be anything.

     

       110
       110
       -
               ";

     

       110
       110
       +
               '';

     

       111
       111
        
             };

     

       112
       112
        
       

     

       113
       113
        
             mainConfigFile = mkOption {

     

       114
       114
        
               type = types.nullOr types.package;

     

       115
       115
        
               default = null;

     

       116
       116
       -
               description = "

     

       116
       116
       +
               description = ''

     

       117
       117
        
                 If non-null, overrides the main configuration file of Nagios.

     

       118
       118
       -
               ";

     

       118
       118
       +
               '';

     

       119
       119
        
             };

     

       120
       120
        
       

     

       121
       121
        
             extraConfig = mkOption {

     
···

       139
       139
        
               type = types.package;

     

       140
       140
        
               default = nagiosCGICfgFile;

     

       141
       141
        
               defaultText = literalExpression "nagiosCGICfgFile";

     

       142
       142
       -
               description = "

     

       142
       142
       +
               description = ''

     

       143
       143
        
                 Derivation for the configuration file of Nagios CGI scripts

     

       144
       144
        
                 that can be used in web servers for running the Nagios web interface.

     

       145
       145
       -
               ";

     

       145
       145
       +
               '';

     

       146
       146
        
             };

     

       147
       147
        
       

     

       148
       148
        
             enableWebInterface = mkOption {

     

       149
       149
        
               type = types.bool;

     

       150
       150
        
               default = false;

     

       151
       151
       -
               description = "

     

       151
       151
       +
               description = ''

     

       152
       152
        
                 Whether to enable the Nagios web interface.  You should also

     

       153
       153
        
                 enable Apache (<option>services.httpd.enable</option>).

     

       154
       154
       -
               ";

     

       154
       154
       +
               '';

     

       155
       155
        
             };

     

       156
       156
        
       

     

       157
       157
        
             virtualHost = mkOption {

+2 -2

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

···

       23
       23
        
             enable = mkOption {

     

       24
       24
        
               type = types.bool;

     

       25
       25
        
               default = false;

     

       26
       26
       -
               description = "

     

       26
       26
       +
               description = ''

     

       27
       27
        
                 Whether to enable Yandex-disk client. See https://disk.yandex.ru/

     

       28
       28
       -
               ";

     

       28
       28
       +
               '';

     

       29
       29
        
             };

     

       30
       30
        
       

     

       31
       31
        
             username = mkOption {

+20 -20

nixos/modules/services/networking/bind.nix

···

       117
       117
        
             cacheNetworks = mkOption {

     

       118
       118
        
               default = [ "127.0.0.0/24" ];

     

       119
       119
        
               type = types.listOf types.str;

     

       120
       120
       -
               description = "

     

       120
       120
       +
               description = ''

     

       121
       121
        
                 What networks are allowed to use us as a resolver.  Note

     

       122
       122
        
                 that this is for recursive queries -- all networks are

     

       123
       123
        
                 allowed to query zones configured with the `zones` option.

     

       124
       124
        
                 It is recommended that you limit cacheNetworks to avoid your

     

       125
       125
        
                 server being used for DNS amplification attacks.

     

       126
       126
       -
               ";

     

       126
       126
       +
               '';

     

       127
       127
        
             };

     

       128
       128
        
       

     

       129
       129
        
             blockedNetworks = mkOption {

     

       130
       130
        
               default = [ ];

     

       131
       131
        
               type = types.listOf types.str;

     

       132
       132
       -
               description = "

     

       132
       132
       +
               description = ''

     

       133
       133
        
                 What networks are just blocked.

     

       134
       134
       -
               ";

     

       134
       134
       +
               '';

     

       135
       135
        
             };

     

       136
       136
        
       

     

       137
       137
        
             ipv4Only = mkOption {

     

       138
       138
        
               default = false;

     

       139
       139
        
               type = types.bool;

     

       140
       140
       -
               description = "

     

       140
       140
       +
               description = ''

     

       141
       141
        
                 Only use ipv4, even if the host supports ipv6.

     

       142
       142
       -
               ";

     

       142
       142
       +
               '';

     

       143
       143
        
             };

     

       144
       144
        
       

     

       145
       145
        
             forwarders = mkOption {

     

       146
       146
        
               default = config.networking.nameservers;

     

       147
       147
        
               defaultText = literalExpression "config.networking.nameservers";

     

       148
       148
        
               type = types.listOf types.str;

     

       149
       149
       -
               description = "

     

       149
       149
       +
               description = ''

     

       150
       150
        
                 List of servers we should forward requests to.

     

       151
       151
       -
               ";

     

       151
       151
       +
               '';

     

       152
       152
        
             };

     

       153
       153
        
       

     

       154
       154
        
             forward = mkOption {

     

       155
       155
        
               default = "first";

     

       156
       156
        
               type = types.enum ["first" "only"];

     

       157
       157
       -
               description = "

     

       157
       157
       +
               description = ''

     

       158
       158
        
                 Whether to forward 'first' (try forwarding but lookup directly if forwarding fails) or 'only'.

     

       159
       159
       -
               ";

     

       159
       159
       +
               '';

     

       160
       160
        
             };

     

       161
       161
        
       

     

       162
       162
        
             listenOn = mkOption {

     

       163
       163
        
               default = [ "any" ];

     

       164
       164
        
               type = types.listOf types.str;

     

       165
       165
       -
               description = "

     

       165
       165
       +
               description = ''

     

       166
       166
        
                 Interfaces to listen on.

     

       167
       167
       -
               ";

     

       167
       167
       +
               '';

     

       168
       168
        
             };

     

       169
       169
        
       

     

       170
       170
        
             listenOnIpv6 = mkOption {

     

       171
       171
        
               default = [ "any" ];

     

       172
       172
        
               type = types.listOf types.str;

     

       173
       173
       -
               description = "

     

       173
       173
       +
               description = ''

     

       174
       174
        
                 Ipv6 interfaces to listen on.

     

       175
       175
       -
               ";

     

       175
       175
       +
               '';

     

       176
       176
        
             };

     

       177
       177
        
       

     

       178
       178
        
             directory = mkOption {

     
···

       184
       184
        
             zones = mkOption {

     

       185
       185
        
               default = [ ];

     

       186
       186
        
               type = with types; coercedTo (listOf attrs) bindZoneCoerce (attrsOf (types.submodule bindZoneOptions));

     

       187
       187
       -
               description = "

     

       187
       187
       +
               description = ''

     

       188
       188
        
                 List of zones we claim authority over.

     

       189
       189
       -
               ";

     

       189
       189
       +
               '';

     

       190
       190
        
               example = {

     

       191
       191
        
                 "example.com" = {

     

       192
       192
        
                   master = false;

     
···

       201
       201
        
             extraConfig = mkOption {

     

       202
       202
        
               type = types.lines;

     

       203
       203
        
               default = "";

     

       204
       204
       -
               description = "

     

       204
       204
       +
               description = ''

     

       205
       205
        
                 Extra lines to be added verbatim to the generated named configuration file.

     

       206
       206
       -
               ";

     

       206
       206
       +
               '';

     

       207
       207
        
             };

     

       208
       208
        
       

     

       209
       209
        
             extraOptions = mkOption {

     
···

       219
       219
        
               type = types.path;

     

       220
       220
        
               default = confFile;

     

       221
       221
        
               defaultText = literalExpression "confFile";

     

       222
       222
       -
               description = "

     

       222
       222
       +
               description = ''

     

       223
       223
        
                 Overridable config file to use for named. By default, that

     

       224
       224
        
                 generated by nixos.

     

       225
       225
       -
               ";

     

       225
       225
       +
               '';

     

       226
       226
        
             };

     

       227
       227
        
       

     

       228
       228
        
           };

+16 -16

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

···

       41
       41
        
             serverName = mkOption {

     

       42
       42
        
               default = "hades.arpa";

     

       43
       43
        
               type = types.str;

     

       44
       44
       -
               description = "

     

       44
       44
       +
               description = ''

     

       45
       45
        
                 IRCD server name.

     

       46
       46
       -
               ";

     

       46
       46
       +
               '';

     

       47
       47
        
             };

     

       48
       48
        
       

     

       49
       49
        
             sid = mkOption {

     

       50
       50
        
               default = "0NL";

     

       51
       51
        
               type = types.str;

     

       52
       52
       -
               description = "

     

       52
       52
       +
               description = ''

     

       53
       53
        
                 IRCD server unique ID in a net of servers.

     

       54
       54
       -
               ";

     

       54
       54
       +
               '';

     

       55
       55
        
             };

     

       56
       56
        
       

     

       57
       57
        
             description = mkOption {

     

       58
       58
        
               default = "Hybrid-7 IRC server.";

     

       59
       59
        
               type = types.str;

     

       60
       60
       -
               description = "

     

       60
       60
       +
               description = ''

     

       61
       61
        
                 IRCD server description.

     

       62
       62
       -
               ";

     

       62
       62
       +
               '';

     

       63
       63
        
             };

     

       64
       64
        
       

     

       65
       65
        
             rsaKey = mkOption {

     

       66
       66
        
               default = null;

     

       67
       67
        
               example = literalExpression "/root/certificates/irc.key";

     

       68
       68
        
               type = types.nullOr types.path;

     

       69
       69
       -
               description = "

     

       69
       69
       +
               description = ''

     

       70
       70
        
                 IRCD server RSA key.

     

       71
       71
       -
               ";

     

       71
       71
       +
               '';

     

       72
       72
        
             };

     

       73
       73
        
       

     

       74
       74
        
             certificate = mkOption {

     

       75
       75
        
               default = null;

     

       76
       76
        
               example = literalExpression "/root/certificates/irc.pem";

     

       77
       77
        
               type = types.nullOr types.path;

     

       78
       78
       -
               description = "

     

       78
       78
       +
               description = ''

     

       79
       79
        
                 IRCD server SSL certificate. There are some limitations - read manual.

     

       80
       80
       -
               ";

     

       80
       80
       +
               '';

     

       81
       81
        
             };

     

       82
       82
        
       

     

       83
       83
        
             adminEmail = mkOption {

     

       84
       84
        
               default = "<bit-bucket@example.com>";

     

       85
       85
        
               type = types.str;

     

       86
       86
        
               example = "<name@domain.tld>";

     

       87
       87
       -
               description = "

     

       87
       87
       +
               description = ''

     

       88
       88
        
                 IRCD server administrator e-mail.

     

       89
       89
       -
               ";

     

       89
       89
       +
               '';

     

       90
       90
        
             };

     

       91
       91
        
       

     

       92
       92
        
             extraIPs = mkOption {

     

       93
       93
        
               default = [];

     

       94
       94
        
               example = ["127.0.0.1"];

     

       95
       95
        
               type = types.listOf types.str;

     

       96
       96
       -
               description = "

     

       96
       96
       +
               description = ''

     

       97
       97
        
                 Extra IP's to bind.

     

       98
       98
       -
               ";

     

       98
       98
       +
               '';

     

       99
       99
        
             };

     

       100
       100
        
       

     

       101
       101
        
             extraPort = mkOption {

     

       102
       102
        
               default = "7117";

     

       103
       103
        
               type = types.str;

     

       104
       104
       -
               description = "

     

       104
       104
       +
               description = ''

     

       105
       105
        
                 Extra port to avoid filtering.

     

       106
       106
       -
               ";

     

       106
       106
       +
               '';

     

       107
       107
        
             };

     

       108
       108
        
       

     

       109
       109
        
           };

+2 -2

nixos/modules/services/networking/kresd.nix

···

       59
       59
        
           };

     

       60
       60
        
           package = mkOption {

     

       61
       61
        
             type = types.package;

     

       62
       62
       -
             description = "

     

       62
       62
       +
             description = ''

     

       63
       63
        
               knot-resolver package to use.

     

       64
       64
       -
             ";

     

       64
       64
       +
             '';

     

       65
       65
        
             default = pkgs.knot-resolver;

     

       66
       66
        
             defaultText = literalExpression "pkgs.knot-resolver";

     

       67
       67
        
             example = literalExpression "pkgs.knot-resolver.override { extraFeatures = true; }";

+2 -2

nixos/modules/services/security/haka.nix

···

       61
       61
        
               default = pkgs.haka;

     

       62
       62
        
               defaultText = literalExpression "pkgs.haka";

     

       63
       63
        
               type = types.package;

     

       64
       64
       -
               description = "

     

       64
       64
       +
               description = ''

     

       65
       65
        
                 Which Haka derivation to use.

     

       66
       66
       -
               ";

     

       66
       66
       +
               '';

     

       67
       67
        
             };

     

       68
       68
        
       

     

       69
       69
        
             configFile = mkOption {

+8 -8

nixos/modules/services/web-apps/pgpkeyserver-lite.nix

···

       24
       24
        
               default = pkgs.pgpkeyserver-lite;

     

       25
       25
        
               defaultText = literalExpression "pkgs.pgpkeyserver-lite";

     

       26
       26
        
               type = types.package;

     

       27
       27
       -
               description = "

     

       27
       27
       +
               description = ''

     

       28
       28
        
                 Which webgui derivation to use.

     

       29
       29
       -
               ";

     

       29
       29
       +
               '';

     

       30
       30
        
             };

     

       31
       31
        
       

     

       32
       32
        
             hostname = mkOption {

     

       33
       33
        
               type = types.str;

     

       34
       34
       -
               description = "

     

       34
       34
       +
               description = ''

     

       35
       35
        
                 Which hostname to set the vHost to that is proxying to sks.

     

       36
       36
       -
               ";

     

       36
       36
       +
               '';

     

       37
       37
        
             };

     

       38
       38
        
       

     

       39
       39
        
             hkpAddress = mkOption {

     

       40
       40
        
               default = builtins.head sksCfg.hkpAddress;

     

       41
       41
        
               defaultText = literalExpression "head config.${sksOpt.hkpAddress}";

     

       42
       42
        
               type = types.str;

     

       43
       43
       -
               description = "

     

       43
       43
       +
               description = ''

     

       44
       44
        
                 Wich ip address the sks-keyserver is listening on.

     

       45
       45
       -
               ";

     

       45
       45
       +
               '';

     

       46
       46
        
             };

     

       47
       47
        
       

     

       48
       48
        
             hkpPort = mkOption {

     

       49
       49
        
               default = sksCfg.hkpPort;

     

       50
       50
        
               defaultText = literalExpression "config.${sksOpt.hkpPort}";

     

       51
       51
        
               type = types.int;

     

       52
       52
       -
               description = "

     

       52
       52
       +
               description = ''

     

       53
       53
        
                 Which port the sks-keyserver is listening on.

     

       54
       54
       -
               ";

     

       54
       54
       +
               '';

     

       55
       55
        
             };

     

       56
       56
        
           };

     

       57
       57
        
         };

+26 -26

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

···

       390
       390
        
             statusPage = mkOption {

     

       391
       391
        
               default = false;

     

       392
       392
        
               type = types.bool;

     

       393
       393
       -
               description = "

     

       393
       393
       +
               description = ''

     

       394
       394
        
                 Enable status page reachable from localhost on http://127.0.0.1/nginx_status.

     

       395
       395
       -
               ";

     

       395
       395
       +
               '';

     

       396
       396
        
             };

     

       397
       397
        
       

     

       398
       398
        
             recommendedTlsSettings = mkOption {

     

       399
       399
        
               default = false;

     

       400
       400
        
               type = types.bool;

     

       401
       401
       -
               description = "

     

       401
       401
       +
               description = ''

     

       402
       402
        
                 Enable recommended TLS settings.

     

       403
       403
       -
               ";

     

       403
       403
       +
               '';

     

       404
       404
        
             };

     

       405
       405
        
       

     

       406
       406
        
             recommendedOptimisation = mkOption {

     

       407
       407
        
               default = false;

     

       408
       408
        
               type = types.bool;

     

       409
       409
       -
               description = "

     

       409
       409
       +
               description = ''

     

       410
       410
        
                 Enable recommended optimisation settings.

     

       411
       411
       -
               ";

     

       411
       411
       +
               '';

     

       412
       412
        
             };

     

       413
       413
        
       

     

       414
       414
        
             recommendedGzipSettings = mkOption {

     

       415
       415
        
               default = false;

     

       416
       416
        
               type = types.bool;

     

       417
       417
       -
               description = "

     

       417
       417
       +
               description = ''

     

       418
       418
        
                 Enable recommended gzip settings.

     

       419
       419
       -
               ";

     

       419
       419
       +
               '';

     

       420
       420
        
             };

     

       421
       421
        
       

     

       422
       422
        
             recommendedProxySettings = mkOption {

     

       423
       423
        
               default = false;

     

       424
       424
        
               type = types.bool;

     

       425
       425
       -
               description = "

     

       425
       425
       +
               description = ''

     

       426
       426
        
                 Whether to enable recommended proxy settings if a vhost does not specify the option manually.

     

       427
       427
       -
               ";

     

       427
       427
       +
               '';

     

       428
       428
        
             };

     

       429
       429
        
       

     

       430
       430
        
             proxyTimeout = mkOption {

     

       431
       431
        
               type = types.str;

     

       432
       432
        
               default = "60s";

     

       433
       433
        
               example = "20s";

     

       434
       434
       -
               description = "

     

       434
       434
       +
               description = ''

     

       435
       435
        
                 Change the proxy related timeouts in recommendedProxySettings.

     

       436
       436
       -
               ";

     

       436
       436
       +
               '';

     

       437
       437
        
             };

     

       438
       438
        
       

     

       439
       439
        
             defaultListenAddresses = mkOption {

     
···

       441
       441
        
               default = [ "0.0.0.0" ] ++ optional enableIPv6 "[::0]";

     

       442
       442
        
               defaultText = literalExpression ''[ "0.0.0.0" ] ++ lib.optional config.networking.enableIPv6 "[::0]"'';

     

       443
       443
        
               example = literalExpression ''[ "10.0.0.12" "[2002:a00:1::]" ]'';

     

       444
       444
       -
               description = "

     

       444
       444
       +
               description = ''

     

       445
       445
        
                 If vhosts do not specify listenAddresses, use these addresses by default.

     

       446
       446
       -
               ";

     

       446
       446
       +
               '';

     

       447
       447
        
             };

     

       448
       448
        
       

     

       449
       449
        
             package = mkOption {

     
···

       453
       453
        
               apply = p: p.override {

     

       454
       454
        
                 modules = p.modules ++ cfg.additionalModules;

     

       455
       455
        
               };

     

       456
       456
       -
               description = "

     

       456
       456
       +
               description = ''

     

       457
       457
        
                 Nginx package to use. This defaults to the stable version. Note

     

       458
       458
        
                 that the nginx team recommends to use the mainline version which

     

       459
       459
        
                 available in nixpkgs as <literal>nginxMainline</literal>.

     

       460
       460
       -
               ";

     

       460
       460
       +
               '';

     

       461
       461
        
             };

     

       462
       462
        
       

     

       463
       463
        
             additionalModules = mkOption {

     
···

       474
       474
        
             logError = mkOption {

     

       475
       475
        
               default = "stderr";

     

       476
       476
        
               type = types.str;

     

       477
       477
       -
               description = "

     

       477
       477
       +
               description = ''

     

       478
       478
        
                 Configures logging.

     

       479
       479
        
                 The first parameter defines a file that will store the log. The

     

       480
       480
        
                 special value stderr selects the standard error file. Logging to

     
···

       485
       485
        
                 increasing severity. Setting a certain log level will cause all

     

       486
       486
        
                 messages of the specified and more severe log levels to be logged.

     

       487
       487
        
                 If this parameter is omitted then error is used.

     

       488
       488
       -
               ";

     

       488
       488
       +
               '';

     

       489
       489
        
             };

     

       490
       490
        
       

     

       491
       491
        
             preStart =  mkOption {

     

       492
       492
        
               type = types.lines;

     

       493
       493
        
               default = "";

     

       494
       494
       -
               description = "

     

       494
       494
       +
               description = ''

     

       495
       495
        
                 Shell commands executed before the service's nginx is started.

     

       496
       496
       -
               ";

     

       496
       496
       +
               '';

     

       497
       497
        
             };

     

       498
       498
        
       

     

       499
       499
        
             config = mkOption {

     
···

       551
       551
        
             httpConfig = mkOption {

     

       552
       552
        
               type = types.lines;

     

       553
       553
        
               default = "";

     

       554
       554
       -
               description = "

     

       554
       554
       +
               description = ''

     

       555
       555
        
                 Configuration lines to be set inside the http block.

     

       556
       556
        
                 This is mutually exclusive with the structured configuration

     

       557
       557
        
                 via virtualHosts and the recommendedXyzSettings configuration

     

       558
       558
        
                 options. See appendHttpConfig for appending to the generated http block.

     

       559
       559
       -
               ";

     

       559
       559
       +
               '';

     

       560
       560
        
             };

     

       561
       561
        
       

     

       562
       562
        
             streamConfig = mkOption {

     
···

       569
       569
        
                   proxy_pass 192.168.0.1:53535;

     

       570
       570
        
                 }

     

       571
       571
        
               '';

     

       572
       572
       -
               description = "

     

       572
       572
       +
               description = ''

     

       573
       573
        
                 Configuration lines to be set inside the stream block.

     

       574
       574
       -
               ";

     

       574
       574
       +
               '';

     

       575
       575
        
             };

     

       576
       576
        
       

     

       577
       577
        
             eventsConfig = mkOption {

     
···

       585
       585
        
             appendHttpConfig = mkOption {

     

       586
       586
        
               type = types.lines;

     

       587
       587
        
               default = "";

     

       588
       588
       -
               description = "

     

       588
       588
       +
               description = ''

     

       589
       589
        
                 Configuration lines to be appended to the generated http block.

     

       590
       590
        
                 This is mutually exclusive with using config and httpConfig for

     

       591
       591
        
                 specifying the whole http block verbatim.

     

       592
       592
       -
               ";

     

       592
       592
       +
               '';

     

       593
       593
        
             };

     

       594
       594
        
       

     

       595
       595
        
             enableReload = mkOption {

+2 -2

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

···

       112
       112
        
             serverXml = mkOption {

     

       113
       113
        
               type = types.lines;

     

       114
       114
        
               default = "";

     

       115
       115
       -
               description = "

     

       115
       115
       +
               description = ''

     

       116
       116
        
                 Verbatim server.xml configuration.

     

       117
       117
        
                 This is mutually exclusive with the virtualHosts options.

     

       118
       118
       -
               ";

     

       118
       118
       +
               '';

     

       119
       119
        
             };

     

       120
       120
        
       

     

       121
       121
        
             commonLibs = mkOption {

+10 -10

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

···

       27
       27
        
             http_address = mkOption {

     

       28
       28
        
               type = types.str;

     

       29
       29
        
               default = "*:6081";

     

       30
       30
       -
               description = "

     

       30
       30
       +
               description = ''

     

       31
       31
        
                 HTTP listen address and port.

     

       32
       32
       -
               ";

     

       32
       32
       +
               '';

     

       33
       33
        
             };

     

       34
       34
        
       

     

       35
       35
        
             config = mkOption {

     

       36
       36
        
               type = types.lines;

     

       37
       37
       -
               description = "

     

       37
       37
       +
               description = ''

     

       38
       38
        
                 Verbatim default.vcl configuration.

     

       39
       39
       -
               ";

     

       39
       39
       +
               '';

     

       40
       40
        
             };

     

       41
       41
        
       

     

       42
       42
        
             stateDir = mkOption {

     

       43
       43
        
               type = types.path;

     

       44
       44
        
               default = "/var/spool/varnish/${config.networking.hostName}";

     

       45
       45
        
               defaultText = literalExpression ''"/var/spool/varnish/''${config.networking.hostName}"'';

     

       46
       46
       -
               description = "

     

       46
       46
       +
               description = ''

     

       47
       47
        
                 Directory holding all state for Varnish to run.

     

       48
       48
       -
               ";

     

       48
       48
       +
               '';

     

       49
       49
        
             };

     

       50
       50
        
       

     

       51
       51
        
             extraModules = mkOption {

     

       52
       52
        
               type = types.listOf types.package;

     

       53
       53
        
               default = [];

     

       54
       54
        
               example = literalExpression "[ pkgs.varnishPackages.geoip ]";

     

       55
       55
       -
               description = "

     

       55
       55
       +
               description = ''

     

       56
       56
        
                 Varnish modules (except 'std').

     

       57
       57
       -
               ";

     

       57
       57
       +
               '';

     

       58
       58
        
             };

     

       59
       59
        
       

     

       60
       60
        
             extraCommandLine = mkOption {

     

       61
       61
        
               type = types.str;

     

       62
       62
        
               default = "";

     

       63
       63
        
               example = "-s malloc,256M";

     

       64
       64
       -
               description = "

     

       64
       64
       +
               description = ''

     

       65
       65
        
                 Command line switches for varnishd (run 'varnishd -?' to get list of options)

     

       66
       66
       -
               ";

     

       66
       66
       +
               '';

     

       67
       67
        
             };

     

       68
       68
        
           };

     

       69
       69