commit 0699530f08290f34c532beedd66046825d9756fa · pyrox.dev/nixpkgs

+2 -2

lib/default.nix

···

       123
       123
        
           inherit (self.options) isOption mkEnableOption mkSinkUndeclaredOptions

     

       124
       124
        
             mergeDefaultOption mergeOneOption mergeEqualOption getValues

     

       125
       125
        
             getFiles optionAttrSetToDocList optionAttrSetToDocList'

     

       126
       126
       -
             scrubOptionValue literalExample showOption showFiles

     

       127
       127
       -
             unknownModule mkOption;

     

       126
       126
       +
             scrubOptionValue literalExpression literalExample literalDocBook

     

       127
       127
       +
             showOption showFiles unknownModule mkOption;

     

       128
       128
        
           inherit (self.types) isType setType defaultTypeMerge defaultFunctor

     

       129
       129
        
             isOptionType mkOptionType;

     

       130
       130
        
           inherit (self.asserts)

+19 -5

lib/options.nix

···

       54
       54
        
       

     

       55
       55
        
            Example:

     

       56
       56
        
              mkOption { }  // => { _type = "option"; }

     

       57
       57
       -
              mkOption { defaultText = "foo"; } // => { _type = "option"; defaultText = "foo"; }

     

       57
       57
       +
              mkOption { default = "foo"; } // => { _type = "option"; default = "foo"; }

     

       58
       58
        
         */

     

       59
       59
        
         mkOption =

     

       60
       60
        
           {

     
···

       212
       212
        
           else x;

     

       213
       213
        
       

     

       214
       214
        
       

     

       215
       215
       -
         /* For use in the `example` option attribute. It causes the given

     

       216
       216
       -
            text to be included verbatim in documentation. This is necessary

     

       217
       217
       -
            for example values that are not simple values, e.g., functions.

     

       215
       215
       +
         /* For use in the `defaultText` and `example` option attributes. Causes the

     

       216
       216
       +
            given string to be rendered verbatim in the documentation as Nix code. This

     

       217
       217
       +
            is necessary for complex values, e.g. functions, or values that depend on

     

       218
       218
       +
            other values or packages.

     

       218
       219
        
         */

     

       219
       219
       -
         literalExample = text: { _type = "literalExample"; inherit text; };

     

       220
       220
       +
         literalExpression = text:

     

       221
       221
       +
           if ! isString text then throw "literalExpression expects a string."

     

       222
       222
       +
           else { _type = "literalExpression"; inherit text; };

     

       223
       223
       +
       

     

       224
       224
       +
         literalExample = lib.warn "literalExample is deprecated, use literalExpression instead, or use literalDocBook for a non-Nix description." literalExpression;

     

       225
       225
       +
       

     

       226
       226
       +
       

     

       227
       227
       +
         /* For use in the `defaultText` and `example` option attributes. Causes the

     

       228
       228
       +
            given DocBook text to be inserted verbatim in the documentation, for when

     

       229
       229
       +
            a `literalExpression` would be too hard to read.

     

       230
       230
       +
         */

     

       231
       231
       +
         literalDocBook = text:

     

       232
       232
       +
           if ! isString text then throw "literalDocBook expects a string."

     

       233
       233
       +
           else { _type = "literalDocBook"; inherit text; };

     

       220
       234
        
       

     

       221
       235
        
         # Helper functions.

     

       222
       236

+10

nixos/doc/manual/development/option-declarations.section.md

···

       38
       38
        
           of the module will have to define the value of the option, otherwise

     

       39
       39
        
           an error will be thrown.

     

       40
       40
        
       

     

       41
       41
       +
       `defaultText`

     

       42
       42
       +
       

     

       43
       43
       +
       :   A textual representation of the default value to be rendered verbatim in

     

       44
       44
       +
           the manual. Useful if the default value is a complex expression or depends

     

       45
       45
       +
           on other values or packages.

     

       46
       46
       +
           Use `lib.literalExpression` for a Nix expression, `lib.literalDocBook` for

     

       47
       47
       +
           a plain English description in DocBook format.

     

       48
       48
       +
       

     

       41
       49
        
       `example`

     

       42
       50
        
       

     

       43
       51
        
       :   An example value that will be shown in the NixOS manual.

     

       52
       52
       +
           You can use `lib.literalExpression` and `lib.literalDocBook` in the same way

     

       53
       53
       +
           as in `defaultText`.

     

       44
       54
        
       

     

       45
       55
        
       `description`

     

       46
       56

+19 -1

nixos/doc/manual/from_md/development/option-declarations.section.xml

···

       59
       59
        
           </varlistentry>

     

       60
       60
        
           <varlistentry>

     

       61
       61
        
             <term>

     

       62
       62
       +
               <literal>defaultText</literal>

     

       63
       63
       +
             </term>

     

       64
       64
       +
             <listitem>

     

       65
       65
       +
               <para>

     

       66
       66
       +
                 A textual representation of the default value to be rendered

     

       67
       67
       +
                 verbatim in the manual. Useful if the default value is a

     

       68
       68
       +
                 complex expression or depends on other values or packages. Use

     

       69
       69
       +
                 <literal>lib.literalExpression</literal> for a Nix expression,

     

       70
       70
       +
                 <literal>lib.literalDocBook</literal> for a plain English

     

       71
       71
       +
                 description in DocBook format.

     

       72
       72
       +
               </para>

     

       73
       73
       +
             </listitem>

     

       74
       74
       +
           </varlistentry>

     

       75
       75
       +
           <varlistentry>

     

       76
       76
       +
             <term>

     

       62
       77
        
               <literal>example</literal>

     

       63
       78
        
             </term>

     

       64
       79
        
             <listitem>

     

       65
       80
        
               <para>

     

       66
       66
       -
                 An example value that will be shown in the NixOS manual.

     

       81
       81
       +
                 An example value that will be shown in the NixOS manual. You

     

       82
       82
       +
                 can use <literal>lib.literalExpression</literal> and

     

       83
       83
       +
                 <literal>lib.literalDocBook</literal> in the same way as in

     

       84
       84
       +
                 <literal>defaultText</literal>.

     

       67
       85
        
               </para>

     

       68
       86
        
             </listitem>

     

       69
       87
        
           </varlistentry>

+28 -18

nixos/lib/make-options-doc/options-to-docbook.xsl

···

       54
       54
        
                       <para>

     

       55
       55
        
                         <emphasis>Default:</emphasis>

     

       56
       56
        
                         <xsl:text> </xsl:text>

     

       57
       57
       -
                         <xsl:apply-templates select="attr[@name = 'default']" mode="top" />

     

       57
       57
       +
                         <xsl:apply-templates select="attr[@name = 'default']/*" mode="top" />

     

       58
       58
        
                       </para>

     

       59
       59
        
                     </xsl:if>

     

       60
       60
        
       

     
···

       62
       62
        
                       <para>

     

       63
       63
        
                         <emphasis>Example:</emphasis>

     

       64
       64
        
                         <xsl:text> </xsl:text>

     

       65
       65
       -
                         <xsl:choose>

     

       66
       66
       -
                           <xsl:when test="attr[@name = 'example']/attrs[attr[@name = '_type' and string[@value = 'literalExample']]]">

     

       67
       67
       -
                             <programlisting><xsl:value-of select="attr[@name = 'example']/attrs/attr[@name = 'text']/string/@value" /></programlisting>

     

       68
       68
       -
                           </xsl:when>

     

       69
       69
       -
                           <xsl:otherwise>

     

       70
       70
       -
                             <xsl:apply-templates select="attr[@name = 'example']" mode="top" />

     

       71
       71
       -
                           </xsl:otherwise>

     

       72
       72
       -
                         </xsl:choose>

     

       65
       65
       +
                         <xsl:apply-templates select="attr[@name = 'example']/*" mode="top" />

     

       73
       66
        
                       </para>

     

       74
       67
        
                     </xsl:if>

     

       75
       68
        
       

     
···

       107
       100
        
         </xsl:template>

     

       108
       101
        
       

     

       109
       102
        
       

     

       110
       110
       -
         <xsl:template match="*" mode="top">

     

       103
       103
       +
         <xsl:template match="attrs[attr[@name = '_type' and string[@value = 'literalExpression']]]" mode = "top">

     

       111
       104
        
           <xsl:choose>

     

       112
       112
       -
             <xsl:when test="string[contains(@value, '&#010;')]">

     

       113
       113
       -
       <programlisting>

     

       114
       114
       -
       <xsl:text>''

     

       115
       115
       -
       </xsl:text><xsl:value-of select='str:replace(string/@value, "${", "&apos;&apos;${")' /><xsl:text>''</xsl:text></programlisting>

     

       105
       105
       +
             <xsl:when test="contains(attr[@name = 'text']/string/@value, '&#010;')">

     

       106
       106
       +
               <programlisting><xsl:value-of select="attr[@name = 'text']/string/@value" /></programlisting>

     

       116
       107
        
             </xsl:when>

     

       117
       108
        
             <xsl:otherwise>

     

       118
       118
       -
               <literal><xsl:apply-templates /></literal>

     

       109
       109
       +
               <literal><xsl:value-of select="attr[@name = 'text']/string/@value" /></literal>

     

       119
       110
        
             </xsl:otherwise>

     

       120
       111
        
           </xsl:choose>

     

       121
       112
        
         </xsl:template>

     

       122
       113
        
       

     

       123
       114
        
       

     

       115
       115
       +
         <xsl:template match="attrs[attr[@name = '_type' and string[@value = 'literalDocBook']]]" mode = "top">

     

       116
       116
       +
           <xsl:value-of disable-output-escaping="yes" select="attr[@name = 'text']/string/@value" />

     

       117
       117
       +
         </xsl:template>

     

       118
       118
       +
       

     

       119
       119
       +
       

     

       120
       120
       +
         <xsl:template match="string[contains(@value, '&#010;')]" mode="top">

     

       121
       121
       +
           <programlisting>

     

       122
       122
       +
             <xsl:text>''&#010;</xsl:text>

     

       123
       123
       +
             <xsl:value-of select='str:replace(str:replace(@value, "&apos;&apos;", "&apos;&apos;&apos;"), "${", "&apos;&apos;${")' />

     

       124
       124
       +
             <xsl:text>''</xsl:text>

     

       125
       125
       +
           </programlisting>

     

       126
       126
       +
         </xsl:template>

     

       127
       127
       +
       

     

       128
       128
       +
       

     

       129
       129
       +
         <xsl:template match="*" mode="top">

     

       130
       130
       +
           <literal><xsl:apply-templates select="." /></literal>

     

       131
       131
       +
         </xsl:template>

     

       132
       132
       +
       

     

       133
       133
       +
       

     

       124
       134
        
         <xsl:template match="null">

     

       125
       135
        
           <xsl:text>null</xsl:text>

     

       126
       136
        
         </xsl:template>

     
···

       129
       139
        
         <xsl:template match="string">

     

       130
       140
        
           <xsl:choose>

     

       131
       141
        
             <xsl:when test="(contains(@value, '&quot;') or contains(@value, '\')) and not(contains(@value, '&#010;'))">

     

       132
       132
       -
               <xsl:text>''</xsl:text><xsl:value-of select='str:replace(@value, "${", "&apos;&apos;${")' /><xsl:text>''</xsl:text>

     

       142
       142
       +
               <xsl:text>''</xsl:text><xsl:value-of select='str:replace(str:replace(@value, "&apos;&apos;", "&apos;&apos;&apos;"), "${", "&apos;&apos;${")' /><xsl:text>''</xsl:text>

     

       133
       143
        
             </xsl:when>

     

       134
       144
        
             <xsl:otherwise>

     

       135
       135
       -
               <xsl:text>"</xsl:text><xsl:value-of select="str:replace(str:replace(str:replace(str:replace(@value, '\', '\\'), '&quot;', '\&quot;'), '&#010;', '\n'), '$', '\$')" /><xsl:text>"</xsl:text>

     

       145
       145
       +
               <xsl:text>"</xsl:text><xsl:value-of select="str:replace(str:replace(str:replace(str:replace(@value, '\', '\\'), '&quot;', '\&quot;'), '&#010;', '\n'), '${', '\${')" /><xsl:text>"</xsl:text>

     

       136
       146
        
             </xsl:otherwise>

     

       137
       147
        
           </xsl:choose>

     

       138
       148
        
         </xsl:template>

     
···

       163
       173
        
         </xsl:template>

     

       164
       174
        
       

     

       165
       175
        
       

     

       166
       166
       -
         <xsl:template match="attrs[attr[@name = '_type' and string[@value = 'literalExample']]]">

     

       176
       176
       +
         <xsl:template match="attrs[attr[@name = '_type' and string[@value = 'literalExpression']]]">

     

       167
       177
        
           <xsl:value-of select="attr[@name = 'text']/string/@value" />

     

       168
       178
        
         </xsl:template>

     

       169
       179

+1 -1

nixos/maintainers/scripts/ec2/amazon-image.nix

···

       27
       27
        
           };

     

       28
       28
        
       

     

       29
       29
        
           contents = mkOption {

     

       30
       30
       -
             example = literalExample ''

     

       30
       30
       +
             example = literalExpression ''

     

       31
       31
        
               [ { source = pkgs.memtest86 + "/memtest.bin";

     

       32
       32
        
                   target = "boot/memtest.bin";

     

       33
       33
        
                 }

+1 -1

nixos/modules/config/fonts/fonts.nix

···

       61
       61
        
             fonts = mkOption {

     

       62
       62
        
               type = types.listOf types.path;

     

       63
       63
        
               default = [];

     

       64
       64
       -
               example = literalExample "[ pkgs.dejavu_fonts ]";

     

       64
       64
       +
               example = literalExpression "[ pkgs.dejavu_fonts ]";

     

       65
       65
        
               description = "List of primary font paths.";

     

       66
       66
        
             };

     

       67
       67

+1 -1

nixos/modules/config/i18n.nix

···

       14
       14
        
                 allLocales = any (x: x == "all") config.i18n.supportedLocales;

     

       15
       15
        
                 locales = config.i18n.supportedLocales;

     

       16
       16
        
               };

     

       17
       17
       -
               example = literalExample "pkgs.glibcLocales";

     

       17
       17
       +
               example = literalExpression "pkgs.glibcLocales";

     

       18
       18
        
               description = ''

     

       19
       19
        
                 Customized pkg.glibcLocales package.

     

       20
       20

+8 -8

nixos/modules/config/krb5/default.nix

···

       83
       83
        
             kerberos = mkOption {

     

       84
       84
        
               type = types.package;

     

       85
       85
        
               default = pkgs.krb5Full;

     

       86
       86
       -
               defaultText = "pkgs.krb5Full";

     

       87
       87
       -
               example = literalExample "pkgs.heimdal";

     

       86
       86
       +
               defaultText = literalExpression "pkgs.krb5Full";

     

       87
       87
       +
               example = literalExpression "pkgs.heimdal";

     

       88
       88
        
               description = ''

     

       89
       89
        
                 The Kerberos implementation that will be present in

     

       90
       90
        
                 <literal>environment.systemPackages</literal> after enabling this

     
···

       96
       96
        
               type = with types; either attrs lines;

     

       97
       97
        
               default = {};

     

       98
       98
        
               apply = attrs: filterEmbeddedMetadata attrs;

     

       99
       99
       -
               example = literalExample ''

     

       99
       99
       +
               example = literalExpression ''

     

       100
       100
        
                 {

     

       101
       101
        
                   default_realm = "ATHENA.MIT.EDU";

     

       102
       102
        
                 };

     
···

       109
       109
        
             realms = mkOption {

     

       110
       110
        
               type = with types; either attrs lines;

     

       111
       111
        
               default = {};

     

       112
       112
       -
               example = literalExample ''

     

       112
       112
       +
               example = literalExpression ''

     

       113
       113
        
                 {

     

       114
       114
        
                   "ATHENA.MIT.EDU" = {

     

       115
       115
        
                     admin_server = "athena.mit.edu";

     
···

       127
       127
        
             domain_realm = mkOption {

     

       128
       128
        
               type = with types; either attrs lines;

     

       129
       129
        
               default = {};

     

       130
       130
       -
               example = literalExample ''

     

       130
       130
       +
               example = literalExpression ''

     

       131
       131
        
                 {

     

       132
       132
        
                   "example.com" = "EXAMPLE.COM";

     

       133
       133
        
                   ".example.com" = "EXAMPLE.COM";

     
···

       142
       142
        
             capaths = mkOption {

     

       143
       143
        
               type = with types; either attrs lines;

     

       144
       144
        
               default = {};

     

       145
       145
       -
               example = literalExample ''

     

       145
       145
       +
               example = literalExpression ''

     

       146
       146
        
                 {

     

       147
       147
        
                   "ATHENA.MIT.EDU" = {

     

       148
       148
        
                     "EXAMPLE.COM" = ".";

     
···

       161
       161
        
             appdefaults = mkOption {

     

       162
       162
        
               type = with types; either attrs lines;

     

       163
       163
        
               default = {};

     

       164
       164
       -
               example = literalExample ''

     

       164
       164
       +
               example = literalExpression ''

     

       165
       165
        
                 {

     

       166
       166
        
                   pam = {

     

       167
       167
        
                     debug = false;

     
···

       182
       182
        
             plugins = mkOption {

     

       183
       183
        
               type = with types; either attrs lines;

     

       184
       184
        
               default = {};

     

       185
       185
       -
               example = literalExample ''

     

       185
       185
       +
               example = literalExpression ''

     

       186
       186
        
                 {

     

       187
       187
        
                   ccselect = {

     

       188
       188
        
                     disable = "k5identity";

+3 -3

nixos/modules/config/networking.nix

···

       21
       21
        
       

     

       22
       22
        
           networking.hosts = lib.mkOption {

     

       23
       23
        
             type = types.attrsOf (types.listOf types.str);

     

       24
       24
       -
             example = literalExample ''

     

       24
       24
       +
             example = literalExpression ''

     

       25
       25
        
               {

     

       26
       26
        
                 "127.0.0.1" = [ "foo.bar.baz" ];

     

       27
       27
        
                 "192.168.0.2" = [ "fileserver.local" "nameserver.local" ];

     
···

       34
       34
        
       

     

       35
       35
        
           networking.hostFiles = lib.mkOption {

     

       36
       36
        
             type = types.listOf types.path;

     

       37
       37
       -
             defaultText = lib.literalExample "Hosts from `networking.hosts` and `networking.extraHosts`";

     

       38
       38
       -
             example = lib.literalExample ''[ "''${pkgs.my-blocklist-package}/share/my-blocklist/hosts" ]'';

     

       37
       37
       +
             defaultText = literalDocBook "Hosts from <option>networking.hosts</option> and <option>networking.extraHosts</option>";

     

       38
       38
       +
             example = literalExpression ''[ "''${pkgs.my-blocklist-package}/share/my-blocklist/hosts" ]'';

     

       39
       39
        
             description = ''

     

       40
       40
        
               Files that should be concatenated together to form <filename>/etc/hosts</filename>.

     

       41
       41
        
             '';

+2 -2

nixos/modules/config/power-management.nix

···

       35
       35
        
             powerUpCommands = mkOption {

     

       36
       36
        
               type = types.lines;

     

       37
       37
        
               default = "";

     

       38
       38
       -
               example = literalExample ''

     

       38
       38
       +
               example = literalExpression ''

     

       39
       39
        
                 "''${pkgs.hdparm}/sbin/hdparm -B 255 /dev/sda"

     

       40
       40
        
               '';

     

       41
       41
        
               description =

     
···

       49
       49
        
             powerDownCommands = mkOption {

     

       50
       50
        
               type = types.lines;

     

       51
       51
        
               default = "";

     

       52
       52
       -
               example = literalExample ''

     

       52
       52
       +
               example = literalExpression ''

     

       53
       53
        
                 "''${pkgs.hdparm}/sbin/hdparm -B 255 /dev/sda"

     

       54
       54
        
               '';

     

       55
       55
        
               description =

+5 -5

nixos/modules/config/pulseaudio.nix

···

       149
       149
        
               default = if config.services.jack.jackd.enable

     

       150
       150
        
                         then pkgs.pulseaudioFull

     

       151
       151
        
                         else pkgs.pulseaudio;

     

       152
       152
       -
               defaultText = "pkgs.pulseaudio";

     

       153
       153
       -
               example = literalExample "pkgs.pulseaudioFull";

     

       152
       152
       +
               defaultText = literalExpression "pkgs.pulseaudio";

     

       153
       153
       +
               example = literalExpression "pkgs.pulseaudioFull";

     

       154
       154
        
               description = ''

     

       155
       155
        
                 The PulseAudio derivation to use.  This can be used to enable

     

       156
       156
        
                 features (such as JACK support, Bluetooth) via the

     
···

       161
       161
        
             extraModules = mkOption {

     

       162
       162
        
               type = types.listOf types.package;

     

       163
       163
        
               default = [];

     

       164
       164
       -
               example = literalExample "[ pkgs.pulseaudio-modules-bt ]";

     

       164
       164
       +
               example = literalExpression "[ pkgs.pulseaudio-modules-bt ]";

     

       165
       165
        
               description = ''

     

       166
       166
        
                 Extra pulseaudio modules to use. This is intended for out-of-tree

     

       167
       167
        
                 pulseaudio modules like extra bluetooth codecs.

     
···

       184
       184
        
                 type = types.attrsOf types.unspecified;

     

       185
       185
        
                 default = {};

     

       186
       186
        
                 description = "Config of the pulse daemon. See <literal>man pulse-daemon.conf</literal>.";

     

       187
       187
       -
                 example = literalExample ''{ realtime-scheduling = "yes"; }'';

     

       187
       187
       +
                 example = literalExpression ''{ realtime-scheduling = "yes"; }'';

     

       188
       188
        
               };

     

       189
       189
        
             };

     

       190
       190
        
       

     
···

       204
       204
        
                 allowedIpRanges = mkOption {

     

       205
       205
        
                   type = types.listOf types.str;

     

       206
       206
        
                   default = [];

     

       207
       207
       -
                   example = literalExample ''[ "127.0.0.1" "192.168.1.0/24" ]'';

     

       207
       207
       +
                   example = literalExpression ''[ "127.0.0.1" "192.168.1.0/24" ]'';

     

       208
       208
        
                   description = ''

     

       209
       209
        
                     A list of IP subnets that are allowed to stream to the server.

     

       210
       210
        
                   '';

+3 -5

nixos/modules/config/shells-environment.nix

···

       136
       136
        
       

     

       137
       137
        
           environment.binsh = mkOption {

     

       138
       138
        
             default = "${config.system.build.binsh}/bin/sh";

     

       139
       139
       -
             defaultText = "\${config.system.build.binsh}/bin/sh";

     

       140
       140
       -
             example = literalExample ''

     

       141
       141
       -
               "''${pkgs.dash}/bin/dash"

     

       142
       142
       -
             '';

     

       139
       139
       +
             defaultText = literalExpression ''"''${config.system.build.binsh}/bin/sh"'';

     

       140
       140
       +
             example = literalExpression ''"''${pkgs.dash}/bin/dash"'';

     

       143
       141
        
             type = types.path;

     

       144
       142
        
             visible = false;

     

       145
       143
        
             description = ''

     
···

       152
       150
        
       

     

       153
       151
        
           environment.shells = mkOption {

     

       154
       152
        
             default = [];

     

       155
       155
       -
             example = literalExample "[ pkgs.bashInteractive pkgs.zsh ]";

     

       153
       153
       +
             example = literalExpression "[ pkgs.bashInteractive pkgs.zsh ]";

     

       156
       154
        
             description = ''

     

       157
       155
        
               A list of permissible login shells for user accounts.

     

       158
       156
        
               No need to mention <literal>/bin/sh</literal>

+1 -1

nixos/modules/config/sysctl.nix

···

       22
       22
        
       

     

       23
       23
        
           boot.kernel.sysctl = mkOption {

     

       24
       24
        
             default = {};

     

       25
       25
       -
             example = literalExample ''

     

       25
       25
       +
             example = literalExpression ''

     

       26
       26
        
               { "net.ipv4.tcp_syncookies" = false; "vm.swappiness" = 60; }

     

       27
       27
        
             '';

     

       28
       28
        
             type = types.attrsOf sysctlOption;

+3 -3

nixos/modules/config/system-path.nix

···

       58
       58
        
             systemPackages = mkOption {

     

       59
       59
        
               type = types.listOf types.package;

     

       60
       60
        
               default = [];

     

       61
       61
       -
               example = literalExample "[ pkgs.firefox pkgs.thunderbird ]";

     

       61
       61
       +
               example = literalExpression "[ pkgs.firefox pkgs.thunderbird ]";

     

       62
       62
        
               description = ''

     

       63
       63
        
                 The set of packages that appear in

     

       64
       64
        
                 /run/current-system/sw.  These packages are

     
···

       73
       73
        
             defaultPackages = mkOption {

     

       74
       74
        
               type = types.listOf types.package;

     

       75
       75
        
               default = defaultPackages;

     

       76
       76
       -
               example = literalExample "[]";

     

       76
       76
       +
               example = [];

     

       77
       77
        
               description = ''

     

       78
       78
       -
                 Set of default packages that aren't strictly neccessary

     

       78
       78
       +
                 Set of default packages that aren't strictly necessary

     

       79
       79
        
                 for a running system, entries can be removed for a more

     

       80
       80
        
                 minimal NixOS installation.

     

       81
       81

+1 -1

nixos/modules/config/unix-odbc-drivers.nix

···

       19
       19
        
           environment.unixODBCDrivers = mkOption {

     

       20
       20
        
             type = types.listOf types.package;

     

       21
       21
        
             default = [];

     

       22
       22
       -
             example = literalExample "with pkgs.unixODBCDrivers; [ sqlite psql ]";

     

       22
       22
       +
             example = literalExpression "with pkgs.unixODBCDrivers; [ sqlite psql ]";

     

       23
       23
        
             description = ''

     

       24
       24
        
               Specifies Unix ODBC drivers to be registered in

     

       25
       25
        
               <filename>/etc/odbcinst.ini</filename>.  You may also want to

+3 -3

nixos/modules/config/users-groups.nix

···

       165
       165
        
             shell = mkOption {

     

       166
       166
        
               type = types.nullOr (types.either types.shellPackage (passwdEntry types.path));

     

       167
       167
        
               default = pkgs.shadow;

     

       168
       168
       -
               defaultText = "pkgs.shadow";

     

       169
       169
       -
               example = literalExample "pkgs.bashInteractive";

     

       168
       168
       +
               defaultText = literalExpression "pkgs.shadow";

     

       169
       169
       +
               example = literalExpression "pkgs.bashInteractive";

     

       170
       170
        
               description = ''

     

       171
       171
        
                 The path to the user's shell. Can use shell derivations,

     

       172
       172
        
                 like <literal>pkgs.bashInteractive</literal>. Don’t

     
···

       291
       291
        
             packages = mkOption {

     

       292
       292
        
               type = types.listOf types.package;

     

       293
       293
        
               default = [];

     

       294
       294
       -
               example = literalExample "[ pkgs.firefox pkgs.thunderbird ]";

     

       294
       294
       +
               example = literalExpression "[ pkgs.firefox pkgs.thunderbird ]";

     

       295
       295
        
               description = ''

     

       296
       296
        
                 The set of packages that should be made available to the user.

     

       297
       297
        
                 This is in contrast to <option>environment.systemPackages</option>,

+1 -1

nixos/modules/config/xdg/portals/wlr.nix

···

       37
       37
        
             default = { };

     

       38
       38
        
       

     

       39
       39
        
             # Example taken from the manpage

     

       40
       40
       -
             example = literalExample ''

     

       40
       40
       +
             example = literalExpression ''

     

       41
       41
        
               {

     

       42
       42
        
                 screencast = {

     

       43
       43
        
                   output_name = "HDMI-A-1";

+1 -1

nixos/modules/hardware/ckb-next.nix

···

       27
       27
        
             package = mkOption {

     

       28
       28
        
               type = types.package;

     

       29
       29
        
               default = pkgs.ckb-next;

     

       30
       30
       -
               defaultText = "pkgs.ckb-next";

     

       30
       30
       +
               defaultText = literalExpression "pkgs.ckb-next";

     

       31
       31
        
               description = ''

     

       32
       32
        
                 The package implementing the Corsair keyboard/mouse driver.

     

       33
       33
        
               '';

+5 -5

nixos/modules/hardware/device-tree.nix

···

       21
       21
        
                 each .dtb file matching "compatible" of the overlay.

     

       22
       22
        
               '';

     

       23
       23
        
               default = null;

     

       24
       24
       -
               example = literalExample "./dts/overlays.dts";

     

       24
       24
       +
               example = literalExpression "./dts/overlays.dts";

     

       25
       25
        
             };

     

       26
       26
        
       

     

       27
       27
        
             dtsText = mkOption {

     
···

       31
       31
        
                 Literal DTS contents, overlay is applied to

     

       32
       32
        
                 each .dtb file matching "compatible" of the overlay.

     

       33
       33
        
               '';

     

       34
       34
       -
               example = literalExample ''

     

       34
       34
       +
               example = ''

     

       35
       35
        
                 /dts-v1/;

     

       36
       36
        
                 /plugin/;

     

       37
       37
        
                 / {

     
···

       125
       125
        
       

     

       126
       126
        
               kernelPackage = mkOption {

     

       127
       127
        
                 default = config.boot.kernelPackages.kernel;

     

       128
       128
       -
                 defaultText = "config.boot.kernelPackages.kernel";

     

       129
       129
       -
                 example = literalExample "pkgs.linux_latest";

     

       128
       128
       +
                 defaultText = literalExpression "config.boot.kernelPackages.kernel";

     

       129
       129
       +
                 example = literalExpression "pkgs.linux_latest";

     

       130
       130
        
                 type = types.path;

     

       131
       131
        
                 description = ''

     

       132
       132
        
                   Kernel package containing the base device-tree (.dtb) to boot. Uses

     
···

       156
       156
        
       

     

       157
       157
        
               overlays = mkOption {

     

       158
       158
        
                 default = [];

     

       159
       159
       -
                 example = literalExample ''

     

       159
       159
       +
                 example = literalExpression ''

     

       160
       160
        
                   [

     

       161
       161
        
                     { name = "pps"; dtsFile = ./dts/pps.dts; }

     

       162
       162
        
                     { name = "spi";

+1 -1

nixos/modules/hardware/digitalbitbox.nix

···

       19
       19
        
           package = mkOption {

     

       20
       20
        
             type = types.package;

     

       21
       21
        
             default = pkgs.digitalbitbox;

     

       22
       22
       -
             defaultText = "pkgs.digitalbitbox";

     

       22
       22
       +
             defaultText = literalExpression "pkgs.digitalbitbox";

     

       23
       23
        
             description = "The Digital Bitbox package to use. This can be used to install a package with udev rules that differ from the defaults.";

     

       24
       24
        
           };

     

       25
       25
        
         };

+2 -2

nixos/modules/hardware/opengl.nix

···

       89
       89
        
             extraPackages = mkOption {

     

       90
       90
        
               type = types.listOf types.package;

     

       91
       91
        
               default = [];

     

       92
       92
       -
               example = literalExample "with pkgs; [ vaapiIntel libvdpau-va-gl vaapiVdpau intel-ocl ]";

     

       92
       92
       +
               example = literalExpression "with pkgs; [ vaapiIntel libvdpau-va-gl vaapiVdpau intel-ocl ]";

     

       93
       93
        
               description = ''

     

       94
       94
        
                 Additional packages to add to OpenGL drivers. This can be used

     

       95
       95
        
                 to add OpenCL drivers, VA-API/VDPAU drivers etc.

     
···

       99
       99
        
             extraPackages32 = mkOption {

     

       100
       100
        
               type = types.listOf types.package;

     

       101
       101
        
               default = [];

     

       102
       102
       -
               example = literalExample "with pkgs.pkgsi686Linux; [ vaapiIntel libvdpau-va-gl vaapiVdpau ]";

     

       102
       102
       +
               example = literalExpression "with pkgs.pkgsi686Linux; [ vaapiIntel libvdpau-va-gl vaapiVdpau ]";

     

       103
       103
        
               description = ''

     

       104
       104
        
                 Additional packages to add to 32-bit OpenGL drivers on

     

       105
       105
        
                 64-bit systems. Used when <option>driSupport32Bit</option> is

+1 -1

nixos/modules/hardware/opentabletdriver.nix

···

       29
       29
        
             package = mkOption {

     

       30
       30
        
               type = types.package;

     

       31
       31
        
               default = pkgs.opentabletdriver;

     

       32
       32
       -
               defaultText = "pkgs.opentabletdriver";

     

       32
       32
       +
               defaultText = literalExpression "pkgs.opentabletdriver";

     

       33
       33
        
               description = ''

     

       34
       34
        
                 OpenTabletDriver derivation to use.

     

       35
       35
        
               '';

+4 -4

nixos/modules/hardware/printers.nix

···

       72
       72
        
                   };

     

       73
       73
        
                   deviceUri = mkOption {

     

       74
       74
        
                     type = types.str;

     

       75
       75
       -
                     example = [

     

       75
       75
       +
                     example = literalExpression ''

     

       76
       76
        
                       "ipp://printserver.local/printers/BrotherHL_Workroom"

     

       77
       77
        
                       "usb://HP/DESKJET%20940C?serial=CN16E6C364BH"

     

       78
       78
       -
                     ];

     

       78
       78
       +
                     '';

     

       79
       79
        
                     description = ''

     

       80
       80
        
                       How to reach the printer.

     

       81
       81
        
                       <command>lpinfo -v</command> shows a list of supported device URIs and schemes.

     
···

       83
       83
        
                   };

     

       84
       84
        
                   model = mkOption {

     

       85
       85
        
                     type = types.str;

     

       86
       86
       -
                     example = literalExample ''

     

       87
       87
       -
                       gutenprint.''${lib.versions.majorMinor (lib.getVersion pkgs.gutenprint)}://brother-hl-5140/expert

     

       86
       86
       +
                     example = literalExpression ''

     

       87
       87
       +
                       "gutenprint.''${lib.versions.majorMinor (lib.getVersion pkgs.gutenprint)}://brother-hl-5140/expert"

     

       88
       88
        
                     '';

     

       89
       89
        
                     description = ''

     

       90
       90
        
                       Location of the ppd driver file for the printer.

+1 -1

nixos/modules/hardware/sata.nix

···

       39
       39
        
           enable = mkEnableOption "SATA drive timeouts";

     

       40
       40
        
       

     

       41
       41
        
           deciSeconds = mkOption {

     

       42
       42
       -
             example = "70";

     

       42
       42
       +
             example = 70;

     

       43
       43
        
             type = types.int;

     

       44
       44
        
             description = ''

     

       45
       45
        
               Set SCT Error Recovery Control timeout in deciseconds for use in RAID configurations.

+2 -2

nixos/modules/hardware/video/nvidia.nix

···

       165
       165
        
           hardware.nvidia.package = lib.mkOption {

     

       166
       166
        
             type = lib.types.package;

     

       167
       167
        
             default = config.boot.kernelPackages.nvidiaPackages.stable;

     

       168
       168
       -
             defaultText = "config.boot.kernelPackages.nvidiaPackages.stable";

     

       168
       168
       +
             defaultText = literalExpression "config.boot.kernelPackages.nvidiaPackages.stable";

     

       169
       169
        
             description = ''

     

       170
       170
        
               The NVIDIA X11 derivation to use.

     

       171
       171
        
             '';

     

       172
       172
       -
             example = "config.boot.kernelPackages.nvidiaPackages.legacy_340";

     

       172
       172
       +
             example = literalExpression "config.boot.kernelPackages.nvidiaPackages.legacy_340";

     

       173
       173
        
           };

     

       174
       174
        
         };

     

       175
       175

+1 -1

nixos/modules/hardware/video/uvcvideo/default.nix

···

       33
       33
        
       

     

       34
       34
        
             packages = mkOption {

     

       35
       35
        
               type = types.listOf types.path;

     

       36
       36
       -
               example = literalExample "[ pkgs.tiscamera ]";

     

       36
       36
       +
               example = literalExpression "[ pkgs.tiscamera ]";

     

       37
       37
        
               description = ''

     

       38
       38
        
                 List of packages containing <command>uvcvideo</command> dynamic controls

     

       39
       39
        
                 rules. All files found in

+1 -1

nixos/modules/i18n/input-method/fcitx.nix

···

       17
       17
        
             engines = mkOption {

     

       18
       18
        
               type    = with types; listOf fcitxEngine;

     

       19
       19
        
               default = [];

     

       20
       20
       -
               example = literalExample "with pkgs.fcitx-engines; [ mozc hangul ]";

     

       20
       20
       +
               example = literalExpression "with pkgs.fcitx-engines; [ mozc hangul ]";

     

       21
       21
        
               description =

     

       22
       22
        
                 let

     

       23
       23
        
                   enginesDrv = filterAttrs (const isDerivation) pkgs.fcitx-engines;

+1 -1

nixos/modules/i18n/input-method/fcitx5.nix

···

       12
       12
        
             addons = mkOption {

     

       13
       13
        
               type = with types; listOf package;

     

       14
       14
        
               default = [];

     

       15
       15
       -
               example = with pkgs; [ fcitx5-rime ];

     

       15
       15
       +
               example = literalExpression "with pkgs; [ fcitx5-rime ]";

     

       16
       16
        
               description = ''

     

       17
       17
        
                 Enabled Fcitx5 addons.

     

       18
       18
        
               '';

+2 -2

nixos/modules/i18n/input-method/ibus.nix

···

       36
       36
        
             engines = mkOption {

     

       37
       37
        
               type    = with types; listOf ibusEngine;

     

       38
       38
        
               default = [];

     

       39
       39
       -
               example = literalExample "with pkgs.ibus-engines; [ mozc hangul ]";

     

       39
       39
       +
               example = literalExpression "with pkgs.ibus-engines; [ mozc hangul ]";

     

       40
       40
        
               description =

     

       41
       41
        
                 let

     

       42
       42
        
                   enginesDrv = filterAttrs (const isDerivation) pkgs.ibus-engines;

     
···

       48
       48
        
             panel = mkOption {

     

       49
       49
        
               type = with types; nullOr path;

     

       50
       50
        
               default = null;

     

       51
       51
       -
               example = literalExample "''${pkgs.plasma5Packages.plasma-desktop}/lib/libexec/kimpanel-ibus-panel";

     

       51
       51
       +
               example = literalExpression ''"''${pkgs.plasma5Packages.plasma-desktop}/lib/libexec/kimpanel-ibus-panel"'';

     

       52
       52
        
               description = "Replace the IBus panel with another panel.";

     

       53
       53
        
             };

     

       54
       54
        
           };

+1 -1

nixos/modules/i18n/input-method/kime.nix

···

       10
       10
        
             config = mkOption {

     

       11
       11
        
               type = yamlFormat.type;

     

       12
       12
        
               default = { };

     

       13
       13
       -
               example = literalExample ''

     

       13
       13
       +
               example = literalExpression ''

     

       14
       14
        
                 {

     

       15
       15
        
                   daemon = {

     

       16
       16
        
                     modules = ["Xim" "Indicator"];

+2 -2

nixos/modules/installer/cd-dvd/iso-image.nix

···

       528
       528
        
           };

     

       529
       529
        
       

     

       530
       530
        
           isoImage.contents = mkOption {

     

       531
       531
       -
             example = literalExample ''

     

       531
       531
       +
             example = literalExpression ''

     

       532
       532
        
               [ { source = pkgs.memtest86 + "/memtest.bin";

     

       533
       533
        
                   target = "boot/memtest.bin";

     

       534
       534
        
                 }

     
···

       541
       541
        
           };

     

       542
       542
        
       

     

       543
       543
        
           isoImage.storeContents = mkOption {

     

       544
       544
       -
             example = literalExample "[ pkgs.stdenv ]";

     

       544
       544
       +
             example = literalExpression "[ pkgs.stdenv ]";

     

       545
       545
        
             description = ''

     

       546
       546
        
               This option lists additional derivations to be included in the

     

       547
       547
        
               Nix store in the generated ISO image.

+2 -2

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

···

       15
       15
        
       {

     

       16
       16
        
         options = {

     

       17
       17
        
           tarball.contents = mkOption {

     

       18
       18
       -
             example = literalExample ''

     

       18
       18
       +
             example = literalExpression ''

     

       19
       19
        
               [ { source = pkgs.memtest86 + "/memtest.bin";

     

       20
       20
        
                   target = "boot/memtest.bin";

     

       21
       21
        
                 }

     
···

       28
       28
        
           };

     

       29
       29
        
       

     

       30
       30
        
           tarball.storeContents = mkOption {

     

       31
       31
       -
             example = literalExample "[ pkgs.stdenv ]";

     

       31
       31
       +
             example = literalExpression "[ pkgs.stdenv ]";

     

       32
       32
        
             description = ''

     

       33
       33
        
               This option lists additional derivations to be included in the

     

       34
       34
        
               Nix store in the generated ISO image.

+1 -1

nixos/modules/installer/netboot/netboot.nix

···

       9
       9
        
         options = {

     

       10
       10
        
       

     

       11
       11
        
           netboot.storeContents = mkOption {

     

       12
       12
       -
             example = literalExample "[ pkgs.stdenv ]";

     

       12
       12
       +
             example = literalExpression "[ pkgs.stdenv ]";

     

       13
       13
        
             description = ''

     

       14
       14
        
               This option lists additional derivations to be included in the

     

       15
       15
        
               Nix store in the generated netboot image.

+4 -4

nixos/modules/installer/sd-card/sd-image.nix

···

       49
       49
        
       

     

       50
       50
        
           storePaths = mkOption {

     

       51
       51
        
             type = with types; listOf package;

     

       52
       52
       -
             example = literalExample "[ pkgs.stdenv ]";

     

       52
       52
       +
             example = literalExpression "[ pkgs.stdenv ]";

     

       53
       53
        
             description = ''

     

       54
       54
        
               Derivations to be included in the Nix store in the generated SD image.

     

       55
       55
        
             '';

     
···

       107
       107
        
           };

     

       108
       108
        
       

     

       109
       109
        
           populateFirmwareCommands = mkOption {

     

       110
       110
       -
             example = literalExample "'' cp \${pkgs.myBootLoader}/u-boot.bin firmware/ ''";

     

       110
       110
       +
             example = literalExpression "'' cp \${pkgs.myBootLoader}/u-boot.bin firmware/ ''";

     

       111
       111
        
             description = ''

     

       112
       112
        
               Shell commands to populate the ./firmware directory.

     

       113
       113
        
               All files in that directory are copied to the

     
···

       116
       116
        
           };

     

       117
       117
        
       

     

       118
       118
        
           populateRootCommands = mkOption {

     

       119
       119
       -
             example = literalExample "''\${config.boot.loader.generic-extlinux-compatible.populateCmd} -c \${config.system.build.toplevel} -d ./files/boot''";

     

       119
       119
       +
             example = literalExpression "''\${config.boot.loader.generic-extlinux-compatible.populateCmd} -c \${config.system.build.toplevel} -d ./files/boot''";

     

       120
       120
        
             description = ''

     

       121
       121
        
               Shell commands to populate the ./files directory.

     

       122
       122
        
               All files in that directory are copied to the

     
···

       126
       126
        
           };

     

       127
       127
        
       

     

       128
       128
        
           postBuildCommands = mkOption {

     

       129
       129
       -
             example = literalExample "'' dd if=\${pkgs.myBootLoader}/SPL of=$img bs=1024 seek=1 conv=notrunc ''";

     

       129
       129
       +
             example = literalExpression "'' dd if=\${pkgs.myBootLoader}/SPL of=$img bs=1024 seek=1 conv=notrunc ''";

     

       130
       130
        
             default = "";

     

       131
       131
        
             description = ''

     

       132
       132
        
               Shell commands to run after the image is built.

+2 -2

nixos/modules/misc/documentation.nix

···

       133
       133
        
                 extraOutputsToInstall = ["man"];

     

       134
       134
        
                 ignoreCollisions = true;

     

       135
       135
        
               };

     

       136
       136
       -
               defaultText = "all man pages in config.environment.systemPackages";

     

       136
       136
       +
               defaultText = literalDocBook "all man pages in <option>config.environment.systemPackages</option>";

     

       137
       137
        
               description = ''

     

       138
       138
        
                 The manual pages to generate caches for if <option>generateCaches</option>

     

       139
       139
        
                 is enabled. Must be a path to a directory with man pages under

     
···

       211
       211
        
                 Which extra NixOS module paths the generated NixOS's documentation should strip

     

       212
       212
        
                 from options.

     

       213
       213
        
               '';

     

       214
       214
       -
               example = literalExample ''

     

       214
       214
       +
               example = literalExpression ''

     

       215
       215
        
                 # e.g. with options from modules in ''${pkgs.customModules}/nix:

     

       216
       216
        
                 [ pkgs.customModules ]

     

       217
       217
        
               '';

+2 -2

nixos/modules/misc/locate.nix

···

       25
       25
        
           locate = mkOption {

     

       26
       26
        
             type = package;

     

       27
       27
        
             default = pkgs.findutils;

     

       28
       28
       -
             defaultText = "pkgs.findutils";

     

       29
       29
       -
             example = "pkgs.mlocate";

     

       28
       28
       +
             defaultText = literalExpression "pkgs.findutils";

     

       29
       29
       +
             example = literalExpression "pkgs.mlocate";

     

       30
       30
        
             description = ''

     

       31
       31
        
               The locate implementation to use

     

       32
       32
        
             '';

+9 -9

nixos/modules/misc/nixpkgs.nix

···

       67
       67
        
         options.nixpkgs = {

     

       68
       68
        
       

     

       69
       69
        
           pkgs = mkOption {

     

       70
       70
       -
             defaultText = literalExample

     

       71
       71
       -
               ''import "''${nixos}/.." {

     

       72
       72
       -
                   inherit (cfg) config overlays localSystem crossSystem;

     

       73
       73
       -
                 }

     

       74
       74
       -
               '';

     

       70
       70
       +
             defaultText = literalExpression ''

     

       71
       71
       +
               import "''${nixos}/.." {

     

       72
       72
       +
                 inherit (cfg) config overlays localSystem crossSystem;

     

       73
       73
       +
               }

     

       74
       74
       +
             '';

     

       75
       75
        
             type = pkgsType;

     

       76
       76
       -
             example = literalExample "import <nixpkgs> {}";

     

       76
       76
       +
             example = literalExpression "import <nixpkgs> {}";

     

       77
       77
        
             description = ''

     

       78
       78
        
               If set, the pkgs argument to all NixOS modules is the value of

     

       79
       79
        
               this option, extended with <code>nixpkgs.overlays</code>, if

     
···

       109
       109
        
       

     

       110
       110
        
           config = mkOption {

     

       111
       111
        
             default = {};

     

       112
       112
       -
             example = literalExample

     

       112
       112
       +
             example = literalExpression

     

       113
       113
        
               ''

     

       114
       114
        
                 { allowBroken = true; allowUnfree = true; }

     

       115
       115
        
               '';

     
···

       125
       125
        
       

     

       126
       126
        
           overlays = mkOption {

     

       127
       127
        
             default = [];

     

       128
       128
       -
             example = literalExample

     

       128
       128
       +
             example = literalExpression

     

       129
       129
        
               ''

     

       130
       130
        
                 [

     

       131
       131
        
                   (self: super: {

     
···

       158
       158
        
             # Make sure that the final value has all fields for sake of other modules

     

       159
       159
        
             # referring to this. TODO make `lib.systems` itself use the module system.

     

       160
       160
        
             apply = lib.systems.elaborate;

     

       161
       161
       -
             defaultText = literalExample

     

       161
       161
       +
             defaultText = literalExpression

     

       162
       162
        
               ''(import "''${nixos}/../lib").lib.systems.examples.aarch64-multiplatform'';

     

       163
       163
        
             description = ''

     

       164
       164
        
               Specifies the platform on which NixOS should be built. When

+2 -2

nixos/modules/programs/atop.nix

···

       19
       19
        
             package = mkOption {

     

       20
       20
        
               type = types.package;

     

       21
       21
        
               default = pkgs.atop;

     

       22
       22
       -
               defaultText = "pkgs.atop";

     

       22
       22
       +
               defaultText = literalExpression "pkgs.atop";

     

       23
       23
        
               description = ''

     

       24
       24
        
                 Which package to use for Atop.

     

       25
       25
        
               '';

     
···

       37
       37
        
               package = mkOption {

     

       38
       38
        
                 type = types.package;

     

       39
       39
        
                 default = config.boot.kernelPackages.netatop;

     

       40
       40
       -
                 defaultText = "config.boot.kernelPackages.netatop";

     

       40
       40
       +
                 defaultText = literalExpression "config.boot.kernelPackages.netatop";

     

       41
       41
        
                 description = ''

     

       42
       42
        
                   Which package to use for netatop.

     

       43
       43
        
                 '';

+1 -1

nixos/modules/programs/captive-browser.nix

···

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

     

       16
       16
        
               default = pkgs.captive-browser;

     

       17
       17
       -
               defaultText = "pkgs.captive-browser";

     

       17
       17
       +
               defaultText = literalExpression "pkgs.captive-browser";

     

       18
       18
        
               description = "Which package to use for captive-browser";

     

       19
       19
        
             };

     

       20
       20

+2 -2

nixos/modules/programs/chromium.nix

···

       33
       33
        
                 for additional details.

     

       34
       34
        
               '';

     

       35
       35
        
               default = [];

     

       36
       36
       -
               example = literalExample ''

     

       36
       36
       +
               example = literalExpression ''

     

       37
       37
        
                 [

     

       38
       38
        
                   "chlffgpmiacpedhhbkiomidkjlcfhogd" # pushbullet

     

       39
       39
        
                   "mbniclmhobmnbdlbpiphghaielnnpgdp" # lightshot

     
···

       75
       75
        
                 Make sure the selected policy is supported on Linux and your browser version.

     

       76
       76
        
               '';

     

       77
       77
        
               default = {};

     

       78
       78
       -
               example = literalExample ''

     

       78
       78
       +
               example = literalExpression ''

     

       79
       79
        
                 {

     

       80
       80
        
                   "BrowserSignin" = 0;

     

       81
       81
        
                   "SyncDisabled" = true;

+1 -1

nixos/modules/programs/digitalbitbox/default.nix

···

       19
       19
        
           package = mkOption {

     

       20
       20
        
             type = types.package;

     

       21
       21
        
             default = pkgs.digitalbitbox;

     

       22
       22
       -
             defaultText = "pkgs.digitalbitbox";

     

       22
       22
       +
             defaultText = literalExpression "pkgs.digitalbitbox";

     

       23
       23
        
             description = "The Digital Bitbox package to use. This can be used to install a package with udev rules that differ from the defaults.";

     

       24
       24
        
           };

     

       25
       25
        
         };

+1 -1

nixos/modules/programs/dmrconfig.nix

···

       24
       24
        
             package = mkOption {

     

       25
       25
        
               default = pkgs.dmrconfig;

     

       26
       26
        
               type = types.package;

     

       27
       27
       -
               defaultText = "pkgs.dmrconfig";

     

       27
       27
       +
               defaultText = literalExpression "pkgs.dmrconfig";

     

       28
       28
        
               description = "dmrconfig derivation to use";

     

       29
       29
        
             };

     

       30
       30
        
           };

+1

nixos/modules/programs/feedbackd.nix

···

       18
       18
        
               '';

     

       19
       19
        
               type = types.package;

     

       20
       20
        
               default = pkgs.feedbackd;

     

       21
       21
       +
               defaultText = literalExpression "pkgs.feedbackd";

     

       21
       22
        
             };

     

       22
       23
        
           };

     

       23
       24
        
         };

+3 -3

nixos/modules/programs/firejail.nix

···

       40
       40
        
                 executable = mkOption {

     

       41
       41
        
                   type = types.path;

     

       42
       42
        
                   description = "Executable to run sandboxed";

     

       43
       43
       -
                   example = literalExample "''${lib.getBin pkgs.firefox}/bin/firefox";

     

       43
       43
       +
                   example = literalExpression ''"''${lib.getBin pkgs.firefox}/bin/firefox"'';

     

       44
       44
        
                 };

     

       45
       45
        
                 profile = mkOption {

     

       46
       46
        
                   type = types.nullOr types.path;

     

       47
       47
        
                   default = null;

     

       48
       48
        
                   description = "Profile to use";

     

       49
       49
       -
                   example = literalExample "''${pkgs.firejail}/etc/firejail/firefox.profile";

     

       49
       49
       +
                   example = literalExpression ''"''${pkgs.firejail}/etc/firejail/firefox.profile"'';

     

       50
       50
        
                 };

     

       51
       51
        
                 extraArgs = mkOption {

     

       52
       52
        
                   type = types.listOf types.str;

     
···

       57
       57
        
               };

     

       58
       58
        
             }));

     

       59
       59
        
             default = {};

     

       60
       60
       -
             example = literalExample ''

     

       60
       60
       +
             example = literalExpression ''

     

       61
       61
        
               {

     

       62
       62
        
                 firefox = {

     

       63
       63
        
                   executable = "''${lib.getBin pkgs.firefox}/bin/firefox";

+1 -1

nixos/modules/programs/flexoptix-app.nix

···

       13
       13
        
               description = "FLEXOPTIX app package to use";

     

       14
       14
        
               type = types.package;

     

       15
       15
        
               default = pkgs.flexoptix-app;

     

       16
       16
       -
               defaultText = "\${pkgs.flexoptix-app}";

     

       16
       16
       +
               defaultText = literalExpression "pkgs.flexoptix-app";

     

       17
       17
        
             };

     

       18
       18
        
           };

     

       19
       19
        
         };

+1 -1

nixos/modules/programs/freetds.nix

···

       17
       17
        
           environment.freetds = mkOption {

     

       18
       18
        
             type = types.attrsOf types.str;

     

       19
       19
        
             default = {};

     

       20
       20
       -
             example = literalExample ''

     

       20
       20
       +
             example = literalExpression ''

     

       21
       21
        
               { MYDATABASE = '''

     

       22
       22
        
                   host = 10.0.2.100

     

       23
       23
        
                   port = 1433

+1 -1

nixos/modules/programs/gamemode.nix

···

       23
       23
        
                 System-wide configuration for GameMode (/etc/gamemode.ini).

     

       24
       24
        
                 See gamemoded(8) man page for available settings.

     

       25
       25
        
               '';

     

       26
       26
       -
               example = literalExample ''

     

       26
       26
       +
               example = literalExpression ''

     

       27
       27
        
                 {

     

       28
       28
        
                   general = {

     

       29
       29
        
                     renice = 10;

+2 -2

nixos/modules/programs/git.nix

···

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

     

       16
       16
        
               default = pkgs.git;

     

       17
       17
       -
               defaultText = "pkgs.git";

     

       18
       18
       -
               example = literalExample "pkgs.gitFull";

     

       17
       17
       +
               defaultText = literalExpression "pkgs.git";

     

       18
       18
       +
               example = literalExpression "pkgs.gitFull";

     

       19
       19
        
               description = "The git package to use";

     

       20
       20
        
             };

     

       21
       21

+1 -1

nixos/modules/programs/gnupg.nix

···

       27
       27
        
           package = mkOption {

     

       28
       28
        
             type = types.package;

     

       29
       29
        
             default = pkgs.gnupg;

     

       30
       30
       -
             defaultText = "pkgs.gnupg";

     

       30
       30
       +
             defaultText = literalExpression "pkgs.gnupg";

     

       31
       31
        
             description = ''

     

       32
       32
        
               The gpg package that should be used.

     

       33
       33
        
             '';

+1 -1

nixos/modules/programs/java.nix

···

       34
       34
        
       

     

       35
       35
        
             package = mkOption {

     

       36
       36
        
               default = pkgs.jdk;

     

       37
       37
       -
               defaultText = "pkgs.jdk";

     

       37
       37
       +
               defaultText = literalExpression "pkgs.jdk";

     

       38
       38
        
               description = ''

     

       39
       39
        
                 Java package to install. Typical values are pkgs.jdk or pkgs.jre.

     

       40
       40
        
               '';

+2 -2

nixos/modules/programs/kdeconnect.nix

···

       13
       13
        
           '';

     

       14
       14
        
           package = mkOption {

     

       15
       15
        
             default = pkgs.kdeconnect;

     

       16
       16
       -
             defaultText = "pkgs.kdeconnect";

     

       16
       16
       +
             defaultText = literalExpression "pkgs.kdeconnect";

     

       17
       17
        
             type = types.package;

     

       18
       18
       -
             example = literalExample "pkgs.gnomeExtensions.gsconnect";

     

       18
       18
       +
             example = literalExpression "pkgs.gnomeExtensions.gsconnect";

     

       19
       19
        
             description = ''

     

       20
       20
        
               The package providing the implementation for kdeconnect.

     

       21
       21
        
             '';

+2 -1

nixos/modules/programs/less.nix

···

       40
       40
        
             configFile = mkOption {

     

       41
       41
        
               type = types.nullOr types.path;

     

       42
       42
        
               default = null;

     

       43
       43
       -
               example = literalExample "\${pkgs.my-configs}/lesskey";

     

       43
       43
       +
               example = literalExpression ''"''${pkgs.my-configs}/lesskey"'';

     

       44
       44
        
               description = ''

     

       45
       45
        
                 Path to lesskey configuration file.

     

       46
       46
        
       

     
···

       91
       91
        
             lessopen = mkOption {

     

       92
       92
        
               type = types.nullOr types.str;

     

       93
       93
        
               default = "|${pkgs.lesspipe}/bin/lesspipe.sh %s";

     

       94
       94
       +
               defaultText = literalExpression ''"|''${pkgs.lesspipe}/bin/lesspipe.sh %s"'';

     

       94
       95
        
               description = ''

     

       95
       96
        
                 Before less opens a file, it first gives your input preprocessor a chance to modify the way the contents of the file are displayed.

     

       96
       97
        
               '';

+1

nixos/modules/programs/mtr.nix

···

       20
       20
        
             package = mkOption {

     

       21
       21
        
               type = types.package;

     

       22
       22
        
               default = pkgs.mtr;

     

       23
       23
       +
               defaultText = literalExpression "pkgs.mtr";

     

       23
       24
        
               description = ''

     

       24
       25
        
                 The package to use.

     

       25
       26
        
               '';

+13 -13

nixos/modules/programs/neovim.nix

···

       47
       47
        
           configure = mkOption {

     

       48
       48
        
             type = types.attrs;

     

       49
       49
        
             default = {};

     

       50
       50
       -
             example = literalExample ''

     

       51
       51
       -
               configure = {

     

       52
       52
       -
                   customRC = $''''

     

       50
       50
       +
             example = literalExpression ''

     

       51
       51
       +
               {

     

       52
       52
       +
                 customRC = '''

     

       53
       53
        
                   " here your custom configuration goes!

     

       54
       54
       -
                   $'''';

     

       55
       55
       -
                   packages.myVimPackage = with pkgs.vimPlugins; {

     

       56
       56
       -
                     # loaded on launch

     

       57
       57
       -
                     start = [ fugitive ];

     

       58
       58
       -
                     # manually loadable by calling `:packadd $plugin-name`

     

       59
       59
       -
                     opt = [ ];

     

       60
       60
       -
                   };

     

       54
       54
       +
                 ''';

     

       55
       55
       +
                 packages.myVimPackage = with pkgs.vimPlugins; {

     

       56
       56
       +
                   # loaded on launch

     

       57
       57
       +
                   start = [ fugitive ];

     

       58
       58
       +
                   # manually loadable by calling `:packadd $plugin-name`

     

       59
       59
       +
                   opt = [ ];

     

       61
       60
        
                 };

     

       61
       61
       +
               }

     

       62
       62
        
             '';

     

       63
       63
        
             description = ''

     

       64
       64
        
               Generate your init file from your list of plugins and custom commands.

     
···

       69
       69
        
           package = mkOption {

     

       70
       70
        
             type = types.package;

     

       71
       71
        
             default = pkgs.neovim-unwrapped;

     

       72
       72
       -
             defaultText = literalExample "pkgs.neovim-unwrapped";

     

       72
       72
       +
             defaultText = literalExpression "pkgs.neovim-unwrapped";

     

       73
       73
        
             description = "The package to use for the neovim binary.";

     

       74
       74
        
           };

     

       75
       75
        
       

     
···

       82
       82
        
       

     

       83
       83
        
           runtime = mkOption {

     

       84
       84
        
             default = {};

     

       85
       85
       -
             example = literalExample ''

     

       86
       86
       -
               runtime."ftplugin/c.vim".text = "setlocal omnifunc=v:lua.vim.lsp.omnifunc";

     

       85
       85
       +
             example = literalExpression ''

     

       86
       86
       +
               { "ftplugin/c.vim".text = "setlocal omnifunc=v:lua.vim.lsp.omnifunc"; }

     

       87
       87
        
             '';

     

       88
       88
        
             description = ''

     

       89
       89
        
               Set of files that have to be linked in <filename>runtime</filename>.

+1

nixos/modules/programs/noisetorch.nix

···

       10
       10
        
           package = mkOption {

     

       11
       11
        
             type = types.package;

     

       12
       12
        
             default = pkgs.noisetorch;

     

       13
       13
       +
             defaultText = literalExpression "pkgs.noisetorch";

     

       13
       14
        
             description = ''

     

       14
       15
        
               The noisetorch package to use.

     

       15
       16
        
             '';

+3 -2

nixos/modules/programs/npm.nix

···

       14
       14
        
             enable = mkEnableOption "<command>npm</command> global config";

     

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
       -
               type = types.path;

     

       17
       17
       +
               type = types.package;

     

       18
       18
        
               description = "The npm package version / flavor to use";

     

       19
       19
        
               default = pkgs.nodePackages.npm;

     

       20
       20
       -
               example = literalExample "pkgs.nodePackages_13_x.npm";

     

       20
       20
       +
               defaultText = literalExpression "pkgs.nodePackages.npm";

     

       21
       21
       +
               example = literalExpression "pkgs.nodePackages_13_x.npm";

     

       21
       22
        
             };

     

       22
       23
        
       

     

       23
       24
        
             npmrc = mkOption {

+1 -1

nixos/modules/programs/proxychains.nix

···

       120
       120
        
                 Proxies to be used by proxychains.

     

       121
       121
        
               '';

     

       122
       122
        
       

     

       123
       123
       -
               example = literalExample ''

     

       123
       123
       +
               example = literalExpression ''

     

       124
       124
        
                 { myproxy =

     

       125
       125
        
                   { type = "socks4";

     

       126
       126
        
                     host = "127.0.0.1";

+1 -1

nixos/modules/programs/shadow.nix

···

       66
       66
        
               This must not be a store path, since the path is

     

       67
       67
        
               used outside the store (in particular in /etc/passwd).

     

       68
       68
        
             '';

     

       69
       69
       -
             example = literalExample "pkgs.zsh";

     

       69
       69
       +
             example = literalExpression "pkgs.zsh";

     

       70
       70
        
             type = types.either types.path types.shellPackage;

     

       71
       71
        
           };

     

       72
       72

+7 -5

nixos/modules/programs/spacefm.nix

···

       29
       29
        
                 terminal_su = "${pkgs.sudo}/bin/sudo";

     

       30
       30
        
                 graphical_su = "${pkgs.gksu}/bin/gksu";

     

       31
       31
        
               };

     

       32
       32
       -
               example = literalExample ''{

     

       33
       33
       -
                 tmp_dir = "/tmp";

     

       34
       34
       -
                 terminal_su = "''${pkgs.sudo}/bin/sudo";

     

       35
       35
       -
                 graphical_su = "''${pkgs.gksu}/bin/gksu";

     

       36
       36
       -
               }'';

     

       32
       32
       +
               defaultText = literalExpression ''

     

       33
       33
       +
                 {

     

       34
       34
       +
                   tmp_dir = "/tmp";

     

       35
       35
       +
                   terminal_su = "''${pkgs.sudo}/bin/sudo";

     

       36
       36
       +
                   graphical_su = "''${pkgs.gksu}/bin/gksu";

     

       37
       37
       +
                 }

     

       38
       38
       +
               '';

     

       37
       39
        
               description = ''

     

       38
       40
        
                 The system-wide spacefm configuration.

     

       39
       41
        
                 Parameters to be written to <filename>/etc/spacefm/spacefm.conf</filename>.

+4 -3

nixos/modules/programs/ssh.nix

···

       36
       36
        
             askPassword = mkOption {

     

       37
       37
        
               type = types.str;

     

       38
       38
        
               default = "${pkgs.x11_ssh_askpass}/libexec/x11-ssh-askpass";

     

       39
       39
       +
               defaultText = literalExpression ''"''${pkgs.x11_ssh_askpass}/libexec/x11-ssh-askpass"'';

     

       39
       40
        
               description = "Program used by SSH to ask for passwords.";

     

       40
       41
        
             };

     

       41
       42
        
       

     
···

       113
       114
        
             agentPKCS11Whitelist = mkOption {

     

       114
       115
        
               type = types.nullOr types.str;

     

       115
       116
        
               default = null;

     

       116
       116
       -
               example = "\${pkgs.opensc}/lib/opensc-pkcs11.so";

     

       117
       117
       +
               example = literalExpression ''"''${pkgs.opensc}/lib/opensc-pkcs11.so"'';

     

       117
       118
        
               description = ''

     

       118
       119
        
                 A pattern-list of acceptable paths for PKCS#11 shared libraries

     

       119
       120
        
                 that may be used with the -s option to ssh-add.

     
···

       123
       124
        
             package = mkOption {

     

       124
       125
        
               type = types.package;

     

       125
       126
        
               default = pkgs.openssh;

     

       126
       126
       -
               defaultText = "pkgs.openssh";

     

       127
       127
       +
               defaultText = literalExpression "pkgs.openssh";

     

       127
       128
        
               description = ''

     

       128
       129
        
                 The package used for the openssh client and daemon.

     

       129
       130
        
               '';

     
···

       180
       181
        
               description = ''

     

       181
       182
        
                 The set of system-wide known SSH hosts.

     

       182
       183
        
               '';

     

       183
       183
       -
               example = literalExample ''

     

       184
       184
       +
               example = literalExpression ''

     

       184
       185
        
                 {

     

       185
       186
        
                   myhost = {

     

       186
       187
        
                     hostNames = [ "myhost" "myhost.mydomain.com" "10.10.1.4" ];

+1 -1

nixos/modules/programs/ssmtp.nix

···

       54
       54
        
                 <citerefentry><refentrytitle>ssmtp</refentrytitle><manvolnum>5</manvolnum></citerefentry> configuration. Refer

     

       55
       55
        
                 to <link xlink:href="https://linux.die.net/man/5/ssmtp.conf"/> for details on supported values.

     

       56
       56
        
               '';

     

       57
       57
       -
               example = literalExample ''

     

       57
       57
       +
               example = literalExpression ''

     

       58
       58
        
                 {

     

       59
       59
        
                   Debug = true;

     

       60
       60
        
                   FromLineOverride = false;

+2 -2

nixos/modules/programs/sway.nix

···

       92
       92
        
             default = with pkgs; [

     

       93
       93
        
               swaylock swayidle alacritty dmenu

     

       94
       94
        
             ];

     

       95
       95
       -
             defaultText = literalExample ''

     

       95
       95
       +
             defaultText = literalExpression ''

     

       96
       96
        
               with pkgs; [ swaylock swayidle alacritty dmenu ];

     

       97
       97
        
             '';

     

       98
       98
       -
             example = literalExample ''

     

       98
       98
       +
             example = literalExpression ''

     

       99
       99
        
               with pkgs; [

     

       100
       100
        
                 i3status i3status-rust

     

       101
       101
        
                 termite rofi light

+4 -4

nixos/modules/programs/tsm-client.nix

···

       5
       5
        
         inherit (builtins) length map;

     

       6
       6
        
         inherit (lib.attrsets) attrNames filterAttrs hasAttr mapAttrs mapAttrsToList optionalAttrs;

     

       7
       7
        
         inherit (lib.modules) mkDefault mkIf;

     

       8
       8
       -
         inherit (lib.options) literalExample mkEnableOption mkOption;

     

       8
       8
       +
         inherit (lib.options) literalExpression mkEnableOption mkOption;

     

       9
       9
        
         inherit (lib.strings) concatStringsSep optionalString toLower;

     

       10
       10
        
         inherit (lib.types) addCheck attrsOf lines nullOr package path port str strMatching submodule;

     

       11
       11
        
       

     
···

       123
       123
        
           };

     

       124
       124
        
           options.text = mkOption {

     

       125
       125
        
             type = lines;

     

       126
       126
       -
             example = literalExample

     

       126
       126
       +
             example = literalExpression

     

       127
       127
        
               ''lib.modules.mkAfter "compression no"'';

     

       128
       128
        
             description = ''

     

       129
       129
        
               Additional text lines for the server stanza.

     
···

       218
       218
        
           package = mkOption {

     

       219
       219
        
             type = package;

     

       220
       220
        
             default = pkgs.tsm-client;

     

       221
       221
       -
             defaultText = "pkgs.tsm-client";

     

       222
       222
       -
             example = literalExample "pkgs.tsm-client-withGui";

     

       221
       221
       +
             defaultText = literalExpression "pkgs.tsm-client";

     

       222
       222
       +
             example = literalExpression "pkgs.tsm-client-withGui";

     

       223
       223
        
             description = ''

     

       224
       224
        
               The TSM client derivation to be

     

       225
       225
        
               added to the system environment.

+2 -2

nixos/modules/programs/vim.nix

···

       18
       18
        
           package = mkOption {

     

       19
       19
        
             type = types.package;

     

       20
       20
        
             default = pkgs.vim;

     

       21
       21
       -
             defaultText = "pkgs.vim";

     

       22
       22
       -
             example = "pkgs.vimHugeX";

     

       21
       21
       +
             defaultText = literalExpression "pkgs.vim";

     

       22
       22
       +
             example = literalExpression "pkgs.vimHugeX";

     

       23
       23
        
             description = ''

     

       24
       24
        
               vim package to use.

     

       25
       25
        
             '';

+1 -1

nixos/modules/programs/wireshark.nix

···

       19
       19
        
             package = mkOption {

     

       20
       20
        
               type = types.package;

     

       21
       21
        
               default = pkgs.wireshark-cli;

     

       22
       22
       -
               defaultText = "pkgs.wireshark-cli";

     

       22
       22
       +
               defaultText = literalExpression "pkgs.wireshark-cli";

     

       23
       23
        
               description = ''

     

       24
       24
        
                 Which Wireshark package to install in the global environment.

     

       25
       25
        
               '';

+2 -1

nixos/modules/programs/xonsh.nix

···

       27
       27
        
             package = mkOption {

     

       28
       28
        
               type = types.package;

     

       29
       29
        
               default = pkgs.xonsh;

     

       30
       30
       -
               example = literalExample "pkgs.xonsh.override { configFile = \"/path/to/xonshrc\"; }";

     

       30
       30
       +
               defaultText = literalExpression "pkgs.xonsh";

     

       31
       31
       +
               example = literalExpression "pkgs.xonsh.override { configFile = \"/path/to/xonshrc\"; }";

     

       31
       32
        
               description = ''

     

       32
       33
        
                 xonsh package to use.

     

       33
       34
        
               '';

+2 -1

nixos/modules/programs/xss-lock.nix

···

       11
       11
        
       

     

       12
       12
        
           lockerCommand = mkOption {

     

       13
       13
        
             default = "${pkgs.i3lock}/bin/i3lock";

     

       14
       14
       -
             example = literalExample "\${pkgs.i3lock-fancy}/bin/i3lock-fancy";

     

       14
       14
       +
             defaultText = literalExpression ''"''${pkgs.i3lock}/bin/i3lock"'';

     

       15
       15
       +
             example = literalExpression ''"''${pkgs.i3lock-fancy}/bin/i3lock-fancy"'';

     

       15
       16
        
             type = types.separatedString " ";

     

       16
       17
        
             description = "Locker to be used with xsslock";

     

       17
       18
        
           };

+4 -5

nixos/modules/programs/xwayland.nix

···

       16
       16
        
             type = types.str;

     

       17
       17
        
             default = optionalString config.fonts.fontDir.enable

     

       18
       18
        
               "/run/current-system/sw/share/X11/fonts";

     

       19
       19
       -
             defaultText = literalExample ''

     

       20
       20
       -
               optionalString config.fonts.fontDir.enable

     

       21
       21
       -
                 "/run/current-system/sw/share/X11/fonts";

     

       19
       19
       +
             defaultText = literalExpression ''

     

       20
       20
       +
               optionalString config.fonts.fontDir.enable "/run/current-system/sw/share/X11/fonts"

     

       22
       21
        
             '';

     

       23
       22
        
             description = ''

     

       24
       23
        
               Default font path. Setting this option causes Xwayland to be rebuilt.

     
···

       30
       29
        
             default = pkgs.xwayland.override (oldArgs: {

     

       31
       30
        
               inherit (cfg) defaultFontPath;

     

       32
       31
        
             });

     

       33
       33
       -
             defaultText = literalExample ''

     

       32
       32
       +
             defaultText = literalExpression ''

     

       34
       33
        
               pkgs.xwayland.override (oldArgs: {

     

       35
       34
        
                 inherit (config.programs.xwayland) defaultFontPath;

     

       36
       36
       -
               });

     

       35
       35
       +
               })

     

       37
       36
        
             '';

     

       38
       37
        
             description = "The Xwayland package to use.";

     

       39
       38
        
           };

+2 -1

nixos/modules/programs/yabar.nix

···

       45
       45
        
       

     

       46
       46
        
             package = mkOption {

     

       47
       47
        
               default = pkgs.yabar-unstable;

     

       48
       48
       -
               example = literalExample "pkgs.yabar";

     

       48
       48
       +
               defaultText = literalExpression "pkgs.yabar-unstable";

     

       49
       49
       +
               example = literalExpression "pkgs.yabar";

     

       49
       50
        
               type = types.package;

     

       50
       51
        
       

     

       51
       52
        
               # `yabar-stable` segfaults under certain conditions.

+1 -1

nixos/modules/programs/zsh/oh-my-zsh.nix

···

       48
       48
        
       

     

       49
       49
        
               package = mkOption {

     

       50
       50
        
                 default = pkgs.oh-my-zsh;

     

       51
       51
       -
                 defaultText = "pkgs.oh-my-zsh";

     

       51
       51
       +
                 defaultText = literalExpression "pkgs.oh-my-zsh";

     

       52
       52
        
                 description = ''

     

       53
       53
        
                   Package to install for `oh-my-zsh` usage.

     

       54
       54
        
                 '';

+1 -1

nixos/modules/programs/zsh/zsh-autoenv.nix

···

       10
       10
        
             enable = mkEnableOption "zsh-autoenv";

     

       11
       11
        
             package = mkOption {

     

       12
       12
        
               default = pkgs.zsh-autoenv;

     

       13
       13
       -
               defaultText = "pkgs.zsh-autoenv";

     

       13
       13
       +
               defaultText = literalExpression "pkgs.zsh-autoenv";

     

       14
       14
        
               description = ''

     

       15
       15
        
                 Package to install for `zsh-autoenv` usage.

     

       16
       16
        
               '';

+1 -1

nixos/modules/programs/zsh/zsh-autosuggestions.nix

···

       40
       40
        
             type = with types; attrsOf str;

     

       41
       41
        
             default = {};

     

       42
       42
        
             description = "Attribute set with additional configuration values";

     

       43
       43
       -
             example = literalExample ''

     

       43
       43
       +
             example = literalExpression ''

     

       44
       44
        
               {

     

       45
       45
        
                 "ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE" = "20";

     

       46
       46
        
               }

+2 -2

nixos/modules/programs/zsh/zsh-syntax-highlighting.nix

···

       42
       42
        
               default = {};

     

       43
       43
        
               type = types.attrsOf types.str;

     

       44
       44
        
       

     

       45
       45
       -
               example = literalExample ''

     

       45
       45
       +
               example = literalExpression ''

     

       46
       46
        
                 {

     

       47
       47
        
                   "rm -rf *" = "fg=white,bold,bg=red";

     

       48
       48
        
                 }

     
···

       59
       59
        
               default = {};

     

       60
       60
        
               type = types.attrsOf types.str;

     

       61
       61
        
       

     

       62
       62
       -
               example = literalExample ''

     

       62
       62
       +
               example = literalExpression ''

     

       63
       63
        
                 {

     

       64
       64
        
                   "alias" = "fg=magenta,bold";

     

       65
       65
        
                 }

+2 -2

nixos/modules/security/acme.nix

···

       486
       486
        
             extraDomainNames = mkOption {

     

       487
       487
        
               type = types.listOf types.str;

     

       488
       488
        
               default = [];

     

       489
       489
       -
               example = literalExample ''

     

       489
       489
       +
               example = literalExpression ''

     

       490
       490
        
                 [

     

       491
       491
        
                   "example.org"

     

       492
       492
        
                   "mydomain.org"

     
···

       656
       656
        
                 to those units if they rely on the certificates being present,

     

       657
       657
        
                 or trigger restarts of the service if certificates get renewed.

     

       658
       658
        
               '';

     

       659
       659
       -
               example = literalExample ''

     

       659
       659
       +
               example = literalExpression ''

     

       660
       660
        
                 {

     

       661
       661
        
                   "example.com" = {

     

       662
       662
        
                     webroot = "/var/lib/acme/acme-challenge/";

+2 -2

nixos/modules/security/ca.nix

···

       24
       24
        
           security.pki.certificateFiles = mkOption {

     

       25
       25
        
             type = types.listOf types.path;

     

       26
       26
        
             default = [];

     

       27
       27
       -
             example = literalExample "[ \"\${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt\" ]";

     

       27
       27
       +
             example = literalExpression ''[ "''${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt" ]'';

     

       28
       28
        
             description = ''

     

       29
       29
        
               A list of files containing trusted root certificates in PEM

     

       30
       30
        
               format. These are concatenated to form

     
···

       37
       37
        
           security.pki.certificates = mkOption {

     

       38
       38
        
             type = types.listOf types.str;

     

       39
       39
        
             default = [];

     

       40
       40
       -
             example = literalExample ''

     

       40
       40
       +
             example = literalExpression ''

     

       41
       41
        
               [ '''

     

       42
       42
        
                   NixOS.org

     

       43
       43
        
                   =========

+1 -1

nixos/modules/security/dhparams.nix

···

       53
       53
        
                 coerce = bits: { inherit bits; };

     

       54
       54
        
               in attrsOf (coercedTo int coerce (submodule paramsSubmodule));

     

       55
       55
        
               default = {};

     

       56
       56
       -
               example = lib.literalExample "{ nginx.bits = 3072; }";

     

       56
       56
       +
               example = lib.literalExpression "{ nginx.bits = 3072; }";

     

       57
       57
        
               description = ''

     

       58
       58
        
                 Diffie-Hellman parameters to generate.

     

       59
       59

+1 -1

nixos/modules/security/doas.nix

···

       77
       77
        
               You can use <code>mkBefore</code> and/or <code>mkAfter</code> to ensure

     

       78
       78
        
               this is the case when configuration options are merged.

     

       79
       79
        
             '';

     

       80
       80
       -
             example = literalExample ''

     

       80
       80
       +
             example = literalExpression ''

     

       81
       81
        
               [

     

       82
       82
        
                 # Allow execution of any command by any user in group doas, requiring

     

       83
       83
        
                 # a password and keeping any previously-defined environment variables.

+1 -1

nixos/modules/security/pam.nix

···

       586
       586
        
           };

     

       587
       587
        
       

     

       588
       588
        
           security.pam.services = mkOption {

     

       589
       589
       -
             default = [];

     

       589
       589
       +
             default = {};

     

       590
       590
        
             type = with types; attrsOf (submodule pamOpts);

     

       591
       591
        
             description =

     

       592
       592
        
               ''

+2 -2

nixos/modules/security/pam_mount.nix

···

       33
       33
        
             additionalSearchPaths = mkOption {

     

       34
       34
        
               type = types.listOf types.package;

     

       35
       35
        
               default = [];

     

       36
       36
       -
               example = literalExample "[ pkgs.bindfs ]";

     

       36
       36
       +
               example = literalExpression "[ pkgs.bindfs ]";

     

       37
       37
        
               description = ''

     

       38
       38
        
                 Additional programs to include in the search path of pam_mount.

     

       39
       39
        
                 Useful for example if you want to use some FUSE filesystems like bindfs.

     
···

       43
       43
        
             fuseMountOptions = mkOption {

     

       44
       44
        
               type = types.listOf types.str;

     

       45
       45
        
               default = [];

     

       46
       46
       -
               example = literalExample ''

     

       46
       46
       +
               example = literalExpression ''

     

       47
       47
        
                 [ "nodev" "nosuid" "force-user=%(USER)" "gid=%(USERGID)" "perms=0700" "chmod-deny" "chown-deny" "chgrp-deny" ]

     

       48
       48
        
               '';

     

       49
       49
        
               description = ''

+2 -2

nixos/modules/security/sudo.nix

···

       45
       45
        
           security.sudo.package = mkOption {

     

       46
       46
        
             type = types.package;

     

       47
       47
        
             default = pkgs.sudo;

     

       48
       48
       -
             defaultText = "pkgs.sudo";

     

       48
       48
       +
             defaultText = literalExpression "pkgs.sudo";

     

       49
       49
        
             description = ''

     

       50
       50
        
               Which package to use for `sudo`.

     

       51
       51
        
             '';

     
···

       91
       91
        
               this is the case when configuration options are merged.

     

       92
       92
        
             '';

     

       93
       93
        
             default = [];

     

       94
       94
       -
             example = literalExample ''

     

       94
       94
       +
             example = literalExpression ''

     

       95
       95
        
               [

     

       96
       96
        
                 # Allow execution of any command by all users in group sudo,

     

       97
       97
        
                 # requiring a password.

+2 -2

nixos/modules/security/systemd-confinement.nix

···

       62
       62
        
             options.confinement.binSh = lib.mkOption {

     

       63
       63
        
               type = types.nullOr types.path;

     

       64
       64
        
               default = toplevelConfig.environment.binsh;

     

       65
       65
       -
               defaultText = "config.environment.binsh";

     

       66
       66
       -
               example = lib.literalExample "\${pkgs.dash}/bin/dash";

     

       65
       65
       +
               defaultText = lib.literalExpression "config.environment.binsh";

     

       66
       66
       +
               example = lib.literalExpression ''"''${pkgs.dash}/bin/dash"'';

     

       67
       67
        
               description = ''

     

       68
       68
        
                 The program to make available as <filename>/bin/sh</filename> inside

     

       69
       69
        
                 the chroot. If this is set to <literal>null</literal>, no

+3 -4

nixos/modules/security/tpm2.nix

···

       26
       26
        
             '';

     

       27
       27
        
             type = lib.types.nullOr lib.types.str;

     

       28
       28
        
             default = if cfg.abrmd.enable then "tss" else "root";

     

       29
       29
       -
             defaultText = ''"tss" when using the userspace resource manager,'' +

     

       30
       30
       -
                           ''"root" otherwise'';

     

       29
       29
       +
             defaultText = lib.literalExpression ''if config.security.tpm2.abrmd.enable then "tss" else "root"'';

     

       31
       30
        
           };

     

       32
       31
        
       

     

       33
       32
        
           tssGroup = lib.mkOption {

     
···

       57
       56
        
               description = "tpm2-abrmd package to use";

     

       58
       57
        
               type = lib.types.package;

     

       59
       58
        
               default = pkgs.tpm2-abrmd;

     

       60
       60
       -
               defaultText = "pkgs.tpm2-abrmd";

     

       59
       59
       +
               defaultText = lib.literalExpression "pkgs.tpm2-abrmd";

     

       61
       60
        
             };

     

       62
       61
        
           };

     

       63
       62
        
       

     
···

       71
       70
        
               description = "tpm2-pkcs11 package to use";

     

       72
       71
        
               type = lib.types.package;

     

       73
       72
        
               default = pkgs.tpm2-pkcs11;

     

       74
       74
       -
               defaultText = "pkgs.tpm2-pkcs11";

     

       73
       73
       +
               defaultText = lib.literalExpression "pkgs.tpm2-pkcs11";

     

       75
       74
        
             };

     

       76
       75
        
           };

     

       77
       76

+1 -1

nixos/modules/security/wrappers/default.nix

···

       152
       152
        
           security.wrappers = lib.mkOption {

     

       153
       153
        
             type = lib.types.attrsOf wrapperType;

     

       154
       154
        
             default = {};

     

       155
       155
       -
             example = lib.literalExample

     

       155
       155
       +
             example = lib.literalExpression

     

       156
       156
        
               ''

     

       157
       157
        
                 {

     

       158
       158
        
                   # a setuid root program

+1 -1

nixos/modules/services/admin/meshcentral.nix

···

       10
       10
        
             description = "MeshCentral package to use. Replacing this may be necessary to add dependencies for extra functionality.";

     

       11
       11
        
             type = types.package;

     

       12
       12
        
             default = pkgs.meshcentral;

     

       13
       13
       -
             defaultText = "pkgs.meshcentral";

     

       13
       13
       +
             defaultText = literalExpression "pkgs.meshcentral";

     

       14
       14
        
           };

     

       15
       15
        
           settings = mkOption {

     

       16
       16
        
             description = ''

+2 -2

nixos/modules/services/admin/oxidized.nix

···

       33
       33
        
       

     

       34
       34
        
           configFile = mkOption {

     

       35
       35
        
             type = types.path;

     

       36
       36
       -
             example = literalExample ''

     

       36
       36
       +
             example = literalExpression ''

     

       37
       37
        
               pkgs.writeText "oxidized-config.yml" '''

     

       38
       38
        
                 ---

     

       39
       39
        
                 debug: true

     
···

       69
       69
        
       

     

       70
       70
        
           routerDB = mkOption {

     

       71
       71
        
             type = types.path;

     

       72
       72
       -
             example = literalExample ''

     

       72
       72
       +
             example = literalExpression ''

     

       73
       73
        
               pkgs.writeText "oxidized-router.db" '''

     

       74
       74
        
                 hostname-sw1:powerconnect:username1:password2

     

       75
       75
        
                 hostname-sw2:procurve:username2:password2

+2 -1

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

···

       33
       33
        
             };

     

       34
       34
        
             configurationDir = mkOption {

     

       35
       35
        
               default = "${activemq}/conf";

     

       36
       36
       +
               defaultText = literalExpression ''"''${pkgs.activemq}/conf"'';

     

       36
       37
        
               type = types.str;

     

       37
       38
        
               description = ''

     

       38
       39
        
                 The base directory for ActiveMQ's configuration.

     
···

       64
       65
        
             javaProperties = mkOption {

     

       65
       66
        
               type = types.attrs;

     

       66
       67
        
               default = { };

     

       67
       67
       -
               example = literalExample ''

     

       68
       68
       +
               example = literalExpression ''

     

       68
       69
        
                 {

     

       69
       70
        
                   "java.net.preferIPv4Stack" = "true";

     

       70
       71
        
                 }

+2 -2

nixos/modules/services/amqp/rabbitmq.nix

···

       29
       29
        
             package = mkOption {

     

       30
       30
        
               default = pkgs.rabbitmq-server;

     

       31
       31
        
               type = types.package;

     

       32
       32
       -
               defaultText = "pkgs.rabbitmq-server";

     

       32
       32
       +
               defaultText = literalExpression "pkgs.rabbitmq-server";

     

       33
       33
        
               description = ''

     

       34
       34
        
                 Which rabbitmq package to use.

     

       35
       35
        
               '';

     
···

       82
       82
        
             configItems = mkOption {

     

       83
       83
        
               default = { };

     

       84
       84
        
               type = types.attrsOf types.str;

     

       85
       85
       -
               example = literalExample ''

     

       85
       85
       +
               example = literalExpression ''

     

       86
       86
        
                 {

     

       87
       87
        
                   "auth_backends.1.authn" = "rabbit_auth_backend_ldap";

     

       88
       88
        
                   "auth_backends.1.authz" = "rabbit_auth_backend_internal";

+1

nixos/modules/services/audio/botamusique.nix

···

       17
       17
        
           package = mkOption {

     

       18
       18
        
             type = types.package;

     

       19
       19
        
             default = pkgs.botamusique;

     

       20
       20
       +
             defaultText = literalExpression "pkgs.botamusique";

     

       20
       21
        
             description = "The botamusique package to use.";

     

       21
       22
        
           };

     

       22
       23

+3 -3

nixos/modules/services/audio/jack.nix

···

       25
       25
        
                 internal = true;

     

       26
       26
        
                 type = types.package;

     

       27
       27
        
                 default = pkgs.jack2;

     

       28
       28
       -
                 defaultText = "pkgs.jack2";

     

       29
       29
       -
                 example = literalExample "pkgs.jack1";

     

       28
       28
       +
                 defaultText = literalExpression "pkgs.jack2";

     

       29
       29
       +
                 example = literalExpression "pkgs.jack1";

     

       30
       30
        
                 description = ''

     

       31
       31
        
                   The JACK package to use.

     

       32
       32
        
                 '';

     
···

       37
       37
        
                 default = [

     

       38
       38
        
                   "-dalsa"

     

       39
       39
        
                 ];

     

       40
       40
       -
                 example = literalExample ''

     

       40
       40
       +
                 example = literalExpression ''

     

       41
       41
        
                   [ "-dalsa" "--device" "hw:1" ];

     

       42
       42
        
                 '';

     

       43
       43
        
                 description = ''

+3 -3

nixos/modules/services/audio/liquidsoap.nix

···

       39
       39
        
             default = {};

     

       40
       40
        
       

     

       41
       41
        
             example = {

     

       42
       42
       -
               myStream1 = literalExample "\"/etc/liquidsoap/myStream1.liq\"";

     

       43
       43
       -
               myStream2 = literalExample "./myStream2.liq";

     

       44
       44
       -
               myStream3 = literalExample "\"out(playlist(\\\"/srv/music/\\\"))\"";

     

       42
       42
       +
               myStream1 = "/etc/liquidsoap/myStream1.liq";

     

       43
       43
       +
               myStream2 = literalExpression "./myStream2.liq";

     

       44
       44
       +
               myStream3 = "out(playlist(\"/srv/music/\"))";

     

       45
       45
        
             };

     

       46
       46
        
       

     

       47
       47
        
             type = types.attrsOf (types.either types.path types.str);

+1 -1

nixos/modules/services/audio/mopidy.nix

···

       39
       39
        
             extensionPackages = mkOption {

     

       40
       40
        
               default = [];

     

       41
       41
        
               type = types.listOf types.package;

     

       42
       42
       -
               example = literalExample "[ pkgs.mopidy-spotify ]";

     

       42
       42
       +
               example = literalExpression "[ pkgs.mopidy-spotify ]";

     

       43
       43
        
               description = ''

     

       44
       44
        
                 Mopidy extensions that should be loaded by the service.

     

       45
       45
        
               '';

+3 -3

nixos/modules/services/audio/mpd.nix

···

       74
       74
        
             musicDirectory = mkOption {

     

       75
       75
        
               type = with types; either path (strMatching "(http|https|nfs|smb)://.+");

     

       76
       76
        
               default = "${cfg.dataDir}/music";

     

       77
       77
       -
               defaultText = "\${dataDir}/music";

     

       77
       77
       +
               defaultText = literalExpression ''"''${dataDir}/music"'';

     

       78
       78
        
               description = ''

     

       79
       79
        
                 The directory or NFS/SMB network share where MPD reads music from. If left

     

       80
       80
        
                 as the default value this directory will automatically be created before

     
···

       86
       86
        
             playlistDirectory = mkOption {

     

       87
       87
        
               type = types.path;

     

       88
       88
        
               default = "${cfg.dataDir}/playlists";

     

       89
       89
       -
               defaultText = "\${dataDir}/playlists";

     

       89
       89
       +
               defaultText = literalExpression ''"''${dataDir}/playlists"'';

     

       90
       90
        
               description = ''

     

       91
       91
        
                 The directory where MPD stores playlists. If left as the default value

     

       92
       92
        
                 this directory will automatically be created before the MPD server starts,

     
···

       155
       155
        
             dbFile = mkOption {

     

       156
       156
        
               type = types.nullOr types.str;

     

       157
       157
        
               default = "${cfg.dataDir}/tag_cache";

     

       158
       158
       -
               defaultText = "\${dataDir}/tag_cache";

     

       158
       158
       +
               defaultText = literalExpression ''"''${dataDir}/tag_cache"'';

     

       159
       159
        
               description = ''

     

       160
       160
        
                 The path to MPD's database. If set to <literal>null</literal> the

     

       161
       161
        
                 parameter is omitted from the configuration.

+1 -1

nixos/modules/services/audio/slimserver.nix

···

       22
       22
        
             package = mkOption {

     

       23
       23
        
               type = types.package;

     

       24
       24
        
               default = pkgs.slimserver;

     

       25
       25
       -
               defaultText = "pkgs.slimserver";

     

       25
       25
       +
               defaultText = literalExpression "pkgs.slimserver";

     

       26
       26
        
               description = "Slimserver package to use.";

     

       27
       27
        
             };

     

       28
       28

+3 -3

nixos/modules/services/audio/snapserver.nix

···

       206
       206
        
                       For type <literal>meta</literal>, a list of stream names in the form <literal>/one/two/...</literal>. Don't forget the leading slash.

     

       207
       207
        
                       For type <literal>alsa</literal>, use an empty string.

     

       208
       208
        
                     '';

     

       209
       209
       -
                     example = literalExample ''

     

       209
       209
       +
                     example = literalExpression ''

     

       210
       210
        
                       "/path/to/pipe"

     

       211
       211
        
                       "/path/to/librespot"

     

       212
       212
        
                       "192.168.1.2:4444"

     
···

       226
       226
        
                     description = ''

     

       227
       227
        
                       Key-value pairs that convey additional parameters about a stream.

     

       228
       228
        
                     '';

     

       229
       229
       -
                     example = literalExample ''

     

       229
       229
       +
                     example = literalExpression ''

     

       230
       230
        
                       # for type == "pipe":

     

       231
       231
        
                       {

     

       232
       232
        
                         mode = "create";

     
···

       254
       254
        
               description = ''

     

       255
       255
        
                 The definition for an input source.

     

       256
       256
        
               '';

     

       257
       257
       -
               example = literalExample ''

     

       257
       257
       +
               example = literalExpression ''

     

       258
       258
        
                 {

     

       259
       259
        
                   mpd = {

     

       260
       260
        
                     type = "pipe";

-1

nixos/modules/services/audio/ympd.nix

···

       26
       26
        
                 type = types.str;

     

       27
       27
        
                 default = "localhost";

     

       28
       28
        
                 description = "The host where MPD is listening.";

     

       29
       29
       -
                 example = "localhost";

     

       30
       29
        
               };

     

       31
       30
        
       

     

       32
       31
        
               port = mkOption {

+2 -2

nixos/modules/services/backup/automysqlbackup.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
       

     

       5
       5
       -
         inherit (lib) concatMapStringsSep concatStringsSep isInt isList literalExample;

     

       5
       5
       +
         inherit (lib) concatMapStringsSep concatStringsSep isInt isList literalExpression;

     

       6
       6
        
         inherit (lib) mapAttrs mapAttrsToList mkDefault mkEnableOption mkIf mkOption optional types;

     

       7
       7
        
       

     

       8
       8
        
         cfg = config.services.automysqlbackup;

     
···

       48
       48
        
                 <filename>''${pkgs.automysqlbackup}/etc/automysqlbackup.conf</filename>

     

       49
       49
        
                 for details on supported values.

     

       50
       50
        
               '';

     

       51
       51
       -
               example = literalExample ''

     

       51
       51
       +
               example = literalExpression ''

     

       52
       52
        
                 {

     

       53
       53
        
                   db_names = [ "nextcloud" "matomo" ];

     

       54
       54
        
                   table_exclude = [ "nextcloud.oc_users" "nextcloud.oc_whats_new" ];

+5 -8

nixos/modules/services/backup/borgbackup.nix

···

       203
       203
        
             See also the chapter about BorgBackup in the NixOS manual.

     

       204
       204
        
           '';

     

       205
       205
        
           default = { };

     

       206
       206
       -
           example = literalExample ''

     

       206
       206
       +
           example = literalExpression ''

     

       207
       207
        
             { # for a local backup

     

       208
       208
        
               rootBackup = {

     

       209
       209
        
                 paths = "/";

     
···

       260
       260
        
                 archiveBaseName = mkOption {

     

       261
       261
        
                   type = types.strMatching "[^/{}]+";

     

       262
       262
        
                   default = "${globalConfig.networking.hostName}-${name}";

     

       263
       263
       -
                   defaultText = "\${config.networking.hostName}-<name>";

     

       263
       263
       +
                   defaultText = literalExpression ''"''${config.networking.hostName}-<name>"'';

     

       264
       264
        
                   description = ''

     

       265
       265
        
                     How to name the created archives. A timestamp, whose format is

     

       266
       266
        
                     determined by <option>dateFormat</option>, will be appended. The full

     
···

       326
       326
        
                     you to specify a <option>passCommand</option>

     

       327
       327
        
                     or a <option>passphrase</option>.

     

       328
       328
        
                   '';

     

       329
       329
       -
                   example = ''

     

       330
       330
       -
                     encryption.mode = "repokey-blake2" ;

     

       331
       331
       -
                     encryption.passphrase = "mySecretPassphrase" ;

     

       332
       332
       -
                   '';

     

       329
       329
       +
                   example = "repokey-blake2";

     

       333
       330
        
                 };

     

       334
       331
        
       

     

       335
       332
        
                 encryption.passCommand = mkOption {

     
···

       437
       434
        
                     for the available options.

     

       438
       435
        
                   '';

     

       439
       436
        
                   default = { };

     

       440
       440
       -
                   example = literalExample ''

     

       437
       437
       +
                   example = literalExpression ''

     

       441
       438
        
                     {

     

       442
       439
        
                       within = "1d"; # Keep all archives from the last day

     

       443
       440
        
                       daily = 7;

     
···

       455
       452
        
                     Use <literal>""</literal> to consider all archives.

     

       456
       453
        
                   '';

     

       457
       454
        
                   default = config.archiveBaseName;

     

       458
       458
       -
                   defaultText = "\${archiveBaseName}";

     

       455
       455
       +
                   defaultText = literalExpression "archiveBaseName";

     

       459
       456
        
                 };

     

       460
       457
        
       

     

       461
       458
        
                 environment = mkOption {

+1 -1

nixos/modules/services/backup/btrbk.nix

···

       57
       57
        
               description = "Extra packages for btrbk, like compression utilities for <literal>stream_compress</literal>";

     

       58
       58
        
               type = lib.types.listOf lib.types.package;

     

       59
       59
        
               default = [ ];

     

       60
       60
       -
               example = lib.literalExample "[ pkgs.xz ]";

     

       60
       60
       +
               example = lib.literalExpression "[ pkgs.xz ]";

     

       61
       61
        
             };

     

       62
       62
        
             niceness = lib.mkOption {

     

       63
       63
        
               description = "Niceness for local instances of btrbk. Also applies to remote ones connecting via ssh when positive.";

+1 -1

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

···

       85
       85
        
       

     

       86
       86
        
             backupAll = mkOption {

     

       87
       87
        
               default = cfg.databases == [];

     

       88
       88
       -
               defaultText = "services.postgresqlBackup.databases == []";

     

       88
       88
       +
               defaultText = literalExpression "services.postgresqlBackup.databases == []";

     

       89
       89
        
               type = lib.types.bool;

     

       90
       90
        
               description = ''

     

       91
       91
        
                 Backup all databases using pg_dumpall.

+5 -5

nixos/modules/services/backup/postgresql-wal-receiver.nix

···

       7
       7
        
           options = {

     

       8
       8
        
             postgresqlPackage = mkOption {

     

       9
       9
        
               type = types.package;

     

       10
       10
       -
               example = literalExample "pkgs.postgresql_11";

     

       10
       10
       +
               example = literalExpression "pkgs.postgresql_11";

     

       11
       11
        
               description = ''

     

       12
       12
        
                 PostgreSQL package to use.

     

       13
       13
        
               '';

     
···

       15
       15
        
       

     

       16
       16
        
             directory = mkOption {

     

       17
       17
        
               type = types.path;

     

       18
       18
       -
               example = literalExample "/mnt/pg_wal/main/";

     

       18
       18
       +
               example = literalExpression "/mnt/pg_wal/main/";

     

       19
       19
        
               description = ''

     

       20
       20
        
                 Directory to write the output to.

     

       21
       21
        
               '';

     
···

       88
       88
        
             extraArgs = mkOption {

     

       89
       89
        
               type = with types; listOf str;

     

       90
       90
        
               default = [ ];

     

       91
       91
       -
               example = literalExample ''

     

       91
       91
       +
               example = literalExpression ''

     

       92
       92
        
                 [

     

       93
       93
        
                   "--no-sync"

     

       94
       94
        
                 ]

     
···

       101
       101
        
             environment = mkOption {

     

       102
       102
        
               type = with types; attrsOf str;

     

       103
       103
        
               default = { };

     

       104
       104
       -
               example = literalExample ''

     

       104
       104
       +
               example = literalExpression ''

     

       105
       105
        
                 {

     

       106
       106
        
                   PGPASSFILE = "/private/passfile";

     

       107
       107
        
                   PGSSLMODE = "require";

     
···

       121
       121
        
             receivers = mkOption {

     

       122
       122
        
               type = with types; attrsOf (submodule receiverSubmodule);

     

       123
       123
        
               default = { };

     

       124
       124
       -
               example = literalExample ''

     

       124
       124
       +
               example = literalExpression ''

     

       125
       125
        
                 {

     

       126
       126
        
                   main = {

     

       127
       127
        
                     postgresqlPackage = pkgs.postgresql_11;

+1 -1

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

···

       59
       59
        
       

     

       60
       60
        
           package = mkOption {

     

       61
       61
        
             default = pkgs.restic-rest-server;

     

       62
       62
       -
             defaultText = "pkgs.restic-rest-server";

     

       62
       62
       +
             defaultText = literalExpression "pkgs.restic-rest-server";

     

       63
       63
        
             type = types.package;

     

       64
       64
        
             description = "Restic REST server package to use.";

     

       65
       65
        
           };

+1 -1

nixos/modules/services/backup/syncoid.nix

···

       286
       286
        
               };

     

       287
       287
        
             }));

     

       288
       288
        
             default = { };

     

       289
       289
       -
             example = literalExample ''

     

       289
       289
       +
             example = literalExpression ''

     

       290
       290
        
               {

     

       291
       291
        
                 "pool/test".target = "root@target:pool/test";

     

       292
       292
        
               }

+3 -3

nixos/modules/services/backup/tarsnap.nix

···

       214
       214
        
                     maxbwRateUp = mkOption {

     

       215
       215
        
                       type = types.nullOr types.int;

     

       216
       216
        
                       default = null;

     

       217
       217
       -
                       example = literalExample "25 * 1000";

     

       217
       217
       +
                       example = literalExpression "25 * 1000";

     

       218
       218
        
                       description = ''

     

       219
       219
        
                         Upload bandwidth rate limit in bytes.

     

       220
       220
        
                       '';

     
···

       223
       223
        
                     maxbwRateDown = mkOption {

     

       224
       224
        
                       type = types.nullOr types.int;

     

       225
       225
        
                       default = null;

     

       226
       226
       -
                       example = literalExample "50 * 1000";

     

       226
       226
       +
                       example = literalExpression "50 * 1000";

     

       227
       227
        
                       description = ''

     

       228
       228
        
                         Download bandwidth rate limit in bytes.

     

       229
       229
        
                       '';

     
···

       256
       256
        
       

     

       257
       257
        
               default = {};

     

       258
       258
        
       

     

       259
       259
       -
               example = literalExample ''

     

       259
       259
       +
               example = literalExpression ''

     

       260
       260
        
                 {

     

       261
       261
        
                   nixos =

     

       262
       262
        
                     { directories = [ "/home" "/root/ssl" ];

+6 -6

nixos/modules/services/backup/znapzend.nix

···

       166
       166
        
                 <option>postsnap</option>.

     

       167
       167
        
               '';

     

       168
       168
        
               default = null;

     

       169
       169
       -
               example = literalExample ''

     

       170
       170
       -
                 ''${pkgs.mariadb}/bin/mysql -e "set autocommit=0;flush tables with read lock;\\! ''${pkgs.coreutils}/bin/sleep 600" &  ''${pkgs.coreutils}/bin/echo $! > /tmp/mariadblock.pid ; sleep 10

     

       169
       169
       +
               example = literalExpression ''

     

       170
       170
       +
                 '''''${pkgs.mariadb}/bin/mysql -e "set autocommit=0;flush tables with read lock;\\! ''${pkgs.coreutils}/bin/sleep 600" &  ''${pkgs.coreutils}/bin/echo $! > /tmp/mariadblock.pid ; sleep 10'''

     

       171
       171
        
               '';

     

       172
       172
        
             };

     

       173
       173
        
       

     
···

       178
       178
        
                 e.g. for database unlocking. See also <option>presnap</option>.

     

       179
       179
        
               '';

     

       180
       180
        
               default = null;

     

       181
       181
       -
               example = literalExample ''

     

       182
       182
       -
                 ''${pkgs.coreutils}/bin/kill `''${pkgs.coreutils}/bin/cat /tmp/mariadblock.pid`;''${pkgs.coreutils}/bin/rm /tmp/mariadblock.pid

     

       181
       181
       +
               example = literalExpression ''

     

       182
       182
       +
                 "''${pkgs.coreutils}/bin/kill `''${pkgs.coreutils}/bin/cat /tmp/mariadblock.pid`;''${pkgs.coreutils}/bin/rm /tmp/mariadblock.pid"

     

       183
       183
        
               '';

     

       184
       184
        
             };

     

       185
       185
        
       

     
···

       223
       223
        
               type = attrsOf (destType config);

     

       224
       224
        
               description = "Additional destinations.";

     

       225
       225
        
               default = {};

     

       226
       226
       -
               example = literalExample ''

     

       226
       226
       +
               example = literalExpression ''

     

       227
       227
        
                 {

     

       228
       228
        
                   local = {

     

       229
       229
        
                     dataset = "btank/backup";

     
···

       331
       331
        
               type = attrsOf srcType;

     

       332
       332
        
               description = "Znapzend configuration.";

     

       333
       333
        
               default = {};

     

       334
       334
       -
               example = literalExample ''

     

       334
       334
       +
               example = literalExpression ''

     

       335
       335
        
                 {

     

       336
       336
        
                   "tank/home" = {

     

       337
       337
        
                     # Make snapshots of tank/home every hour, keep those for 1 day,

+1

nixos/modules/services/blockchain/ethereum/geth.nix

···

       108
       108
        
       

     

       109
       109
        
             package = mkOption {

     

       110
       110
        
               default = pkgs.go-ethereum.geth;

     

       111
       111
       +
               defaultText = literalExpression "pkgs.go-ethereum.geth";

     

       111
       112
        
               type = types.package;

     

       112
       113
        
               description = "Package to use as Go Ethereum node.";

     

       113
       114
        
             };

+5 -6

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

···

       8
       8
        
           coreSite = mkOption {

     

       9
       9
        
             default = {};

     

       10
       10
        
             type = types.attrsOf types.anything;

     

       11
       11
       -
             example = literalExample ''

     

       11
       11
       +
             example = literalExpression ''

     

       12
       12
        
               {

     

       13
       13
        
                 "fs.defaultFS" = "hdfs://localhost";

     

       14
       14
        
               }

     
···

       19
       19
        
           hdfsSite = mkOption {

     

       20
       20
        
             default = {};

     

       21
       21
        
             type = types.attrsOf types.anything;

     

       22
       22
       -
             example = literalExample ''

     

       22
       22
       +
             example = literalExpression ''

     

       23
       23
        
               {

     

       24
       24
        
                 "dfs.nameservices" = "namenode1";

     

       25
       25
        
               }

     
···

       30
       30
        
           mapredSite = mkOption {

     

       31
       31
        
             default = {};

     

       32
       32
        
             type = types.attrsOf types.anything;

     

       33
       33
       -
             example = literalExample ''

     

       33
       33
       +
             example = literalExpression ''

     

       34
       34
        
               {

     

       35
       35
        
                 "mapreduce.map.cpu.vcores" = "1";

     

       36
       36
        
               }

     
···

       41
       41
        
           yarnSite = mkOption {

     

       42
       42
        
             default = {};

     

       43
       43
        
             type = types.attrsOf types.anything;

     

       44
       44
       -
             example = literalExample ''

     

       44
       44
       +
             example = literalExpression ''

     

       45
       45
        
               {

     

       46
       46
        
                 "yarn.resourcemanager.ha.id" = "resourcemanager1";

     

       47
       47
        
               }

     
···

       52
       52
        
           package = mkOption {

     

       53
       53
        
             type = types.package;

     

       54
       54
        
             default = pkgs.hadoop;

     

       55
       55
       -
             defaultText = "pkgs.hadoop";

     

       56
       56
       -
             example = literalExample "pkgs.hadoop";

     

       55
       55
       +
             defaultText = literalExpression "pkgs.hadoop";

     

       57
       56
        
             description = "";

     

       58
       57
        
           };

     

       59
       58
        
         };

+1 -2

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

···

       12
       12
        
           package = mkOption {

     

       13
       13
        
             type = types.package;

     

       14
       14
        
             default = pkgs.k3s;

     

       15
       15
       -
             defaultText = "pkgs.k3s";

     

       16
       16
       -
             example = literalExample "pkgs.k3s";

     

       15
       15
       +
             defaultText = literalExpression "pkgs.k3s";

     

       17
       16
        
             description = "Package that should be used for k3s";

     

       18
       17
        
           };

     

       19
       18

+2 -2

nixos/modules/services/cluster/kubernetes/addon-manager.nix

···

       27
       27
        
             '';

     

       28
       28
        
             default = { };

     

       29
       29
        
             type = attrsOf attrs;

     

       30
       30
       -
             example = literalExample ''

     

       30
       30
       +
             example = literalExpression ''

     

       31
       31
        
               {

     

       32
       32
        
                 "my-service" = {

     

       33
       33
        
                   "apiVersion" = "v1";

     
···

       46
       46
        
             description = "Kubernetes addons (any kind of Kubernetes resource can be an addon).";

     

       47
       47
        
             default = { };

     

       48
       48
        
             type = attrsOf (either attrs (listOf attrs));

     

       49
       49
       -
             example = literalExample ''

     

       49
       49
       +
             example = literalExpression ''

     

       50
       50
        
               {

     

       51
       51
        
                 "my-service" = {

     

       52
       52
        
                   "apiVersion" = "v1";

+17 -14

nixos/modules/services/cluster/kubernetes/addons/dns.nix

···

       83
       83
        
                 reload

     

       84
       84
        
                 loadbalance

     

       85
       85
        
               }'';

     

       86
       86
       -
             defaultText = ''

     

       87
       87
       -
               .:${toString ports.dns} {

     

       88
       88
       -
                 errors

     

       89
       89
       -
                 health :${toString ports.health}

     

       90
       90
       -
                 kubernetes ''${config.services.kubernetes.addons.dns.clusterDomain} in-addr.arpa ip6.arpa {

     

       91
       91
       -
                   pods insecure

     

       92
       92
       -
                   fallthrough in-addr.arpa ip6.arpa

     

       86
       86
       +
             defaultText = literalExpression ''

     

       87
       87
       +
               '''

     

       88
       88
       +
                 .:${toString ports.dns} {

     

       89
       89
       +
                   errors

     

       90
       90
       +
                   health :${toString ports.health}

     

       91
       91
       +
                   kubernetes ''${config.services.kubernetes.addons.dns.clusterDomain} in-addr.arpa ip6.arpa {

     

       92
       92
       +
                     pods insecure

     

       93
       93
       +
                     fallthrough in-addr.arpa ip6.arpa

     

       94
       94
       +
                   }

     

       95
       95
       +
                   prometheus :${toString ports.metrics}

     

       96
       96
       +
                   forward . /etc/resolv.conf

     

       97
       97
       +
                   cache 30

     

       98
       98
       +
                   loop

     

       99
       99
       +
                   reload

     

       100
       100
       +
                   loadbalance

     

       93
       101
        
                 }

     

       94
       94
       -
                 prometheus :${toString ports.metrics}

     

       95
       95
       -
                 forward . /etc/resolv.conf

     

       96
       96
       -
                 cache 30

     

       97
       97
       -
                 loop

     

       98
       98
       -
                 reload

     

       99
       99
       -
                 loadbalance

     

       100
       100
       -
               }'';

     

       102
       102
       +
               '''

     

       103
       103
       +
             '';

     

       101
       104
        
           };

     

       102
       105
        
         };

     

       103
       106

+1 -1

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

···

       126
       126
        
             description = "Kubernetes package to use.";

     

       127
       127
        
             type = types.package;

     

       128
       128
        
             default = pkgs.kubernetes;

     

       129
       129
       -
             defaultText = "pkgs.kubernetes";

     

       129
       129
       +
             defaultText = literalExpression "pkgs.kubernetes";

     

       130
       130
        
           };

     

       131
       131
        
       

     

       132
       132
        
           kubeconfig = mkKubeConfigOptions "Default kubeconfig";

+1 -1

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

···

       96
       96
        
               description = "Kubernetes CNI configuration.";

     

       97
       97
        
               type = listOf attrs;

     

       98
       98
        
               default = [];

     

       99
       99
       -
               example = literalExample ''

     

       99
       99
       +
               example = literalExpression ''

     

       100
       100
        
                 [{

     

       101
       101
        
                   "cniVersion": "0.3.1",

     

       102
       102
        
                   "name": "mynet",

+3 -3

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

···

       70
       70
        
               type = types.path;

     

       71
       71
        
               description = "Spark configuration directory. Spark will use the configuration files (spark-defaults.conf, spark-env.sh, log4j.properties, etc) from this directory.";

     

       72
       72
        
               default = "${cfg.package}/lib/${cfg.package.untarDir}/conf";

     

       73
       73
       -
               defaultText = literalExample "\${cfg.package}/lib/\${cfg.package.untarDir}/conf";

     

       73
       73
       +
               defaultText = literalExpression ''"''${package}/lib/''${package.untarDir}/conf"'';

     

       74
       74
        
             };

     

       75
       75
        
             logDir = mkOption {

     

       76
       76
        
               type = types.path;

     
···

       81
       81
        
               type = types.package;

     

       82
       82
        
               description = "Spark package.";

     

       83
       83
        
               default = pkgs.spark;

     

       84
       84
       -
               defaultText = "pkgs.spark";

     

       85
       85
       -
               example = literalExample ''pkgs.spark.overrideAttrs (super: rec {

     

       84
       84
       +
               defaultText = literalExpression "pkgs.spark";

     

       85
       85
       +
               example = literalExpression ''pkgs.spark.overrideAttrs (super: rec {

     

       86
       86
        
                 pname = "spark";

     

       87
       87
        
                 version = "2.4.4";

     

       88
       88

+2 -2

nixos/modules/services/computing/boinc/client.nix

···

       30
       30
        
             package = mkOption {

     

       31
       31
        
               type = types.package;

     

       32
       32
        
               default = pkgs.boinc;

     

       33
       33
       -
               defaultText = "pkgs.boinc";

     

       33
       33
       +
               defaultText = literalExpression "pkgs.boinc";

     

       34
       34
        
               description = ''

     

       35
       35
        
                 Which BOINC package to use.

     

       36
       36
        
               '';

     
···

       60
       60
        
             extraEnvPackages = mkOption {

     

       61
       61
        
               type = types.listOf types.package;

     

       62
       62
        
               default = [];

     

       63
       63
       -
               example = "[ pkgs.virtualbox ]";

     

       63
       63
       +
               example = literalExpression "[ pkgs.virtualbox ]";

     

       64
       64
        
               description = ''

     

       65
       65
        
                 Additional packages to make available in the environment in which

     

       66
       66
        
                 BOINC will run. Common choices are:

+1 -1

nixos/modules/services/computing/foldingathome/client.nix

···

       23
       23
        
           package = mkOption {

     

       24
       24
        
             type = types.package;

     

       25
       25
        
             default = pkgs.fahclient;

     

       26
       26
       -
             defaultText = "pkgs.fahclient";

     

       26
       26
       +
             defaultText = literalExpression "pkgs.fahclient";

     

       27
       27
        
             description = ''

     

       28
       28
        
               Which Folding@home client to use.

     

       29
       29
        
             '';

+4 -4

nixos/modules/services/computing/slurm/slurm.nix

···

       132
       132
        
             package = mkOption {

     

       133
       133
        
               type = types.package;

     

       134
       134
        
               default = pkgs.slurm.override { enableX11 = ! cfg.enableSrunX11; };

     

       135
       135
       -
               defaultText = "pkgs.slurm";

     

       136
       136
       -
               example = literalExample "pkgs.slurm-full";

     

       135
       135
       +
               defaultText = literalExpression "pkgs.slurm";

     

       136
       136
       +
               example = literalExpression "pkgs.slurm-full";

     

       137
       137
        
               description = ''

     

       138
       138
        
                 The package to use for slurm binaries.

     

       139
       139
        
               '';

     
···

       172
       172
        
             nodeName = mkOption {

     

       173
       173
        
               type = types.listOf types.str;

     

       174
       174
        
               default = [];

     

       175
       175
       -
               example = literalExample ''[ "linux[1-32] CPUs=1 State=UNKNOWN" ];'';

     

       175
       175
       +
               example = literalExpression ''[ "linux[1-32] CPUs=1 State=UNKNOWN" ];'';

     

       176
       176
        
               description = ''

     

       177
       177
        
                 Name that SLURM uses to refer to a node (or base partition for BlueGene

     

       178
       178
        
                 systems). Typically this would be the string that "/bin/hostname -s"

     
···

       183
       183
        
             partitionName = mkOption {

     

       184
       184
        
               type = types.listOf types.str;

     

       185
       185
        
               default = [];

     

       186
       186
       -
               example = literalExample ''[ "debug Nodes=linux[1-32] Default=YES MaxTime=INFINITE State=UP" ];'';

     

       186
       186
       +
               example = literalExpression ''[ "debug Nodes=linux[1-32] Default=YES MaxTime=INFINITE State=UP" ];'';

     

       187
       187
        
               description = ''

     

       188
       188
        
                 Name by which the partition may be referenced. Note that now you have

     

       189
       189
        
                 to write the partition's parameters after the name.

+6 -5

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

···

       93
       93
        
               type = types.path;

     

       94
       94
        
               description = "Optionally pass master.cfg path. Other options in this configuration will be ignored.";

     

       95
       95
        
               default = defaultMasterCfg;

     

       96
       96
       +
               defaultText = literalDocBook ''generated configuration file'';

     

       96
       97
        
               example = "/etc/nixos/buildbot/master.cfg";

     

       97
       98
        
             };

     

       98
       99
        
       

     
···

       210
       211
        
             package = mkOption {

     

       211
       212
        
               type = types.package;

     

       212
       213
        
               default = pkgs.python3Packages.buildbot-full;

     

       213
       213
       -
               defaultText = "pkgs.python3Packages.buildbot-full";

     

       214
       214
       +
               defaultText = literalExpression "pkgs.python3Packages.buildbot-full";

     

       214
       215
        
               description = "Package to use for buildbot.";

     

       215
       215
       -
               example = literalExample "pkgs.python3Packages.buildbot";

     

       216
       216
       +
               example = literalExpression "pkgs.python3Packages.buildbot";

     

       216
       217
        
             };

     

       217
       218
        
       

     

       218
       219
        
             packages = mkOption {

     

       219
       220
        
               default = [ pkgs.git ];

     

       220
       220
       -
               example = literalExample "[ pkgs.git ]";

     

       221
       221
       +
               defaultText = literalExpression "[ pkgs.git ]";

     

       221
       222
        
               type = types.listOf types.package;

     

       222
       223
        
               description = "Packages to add to PATH for the buildbot process.";

     

       223
       224
        
             };

     
···

       225
       226
        
             pythonPackages = mkOption {

     

       226
       227
        
               type = types.functionTo (types.listOf types.package);

     

       227
       228
        
               default = pythonPackages: with pythonPackages; [ ];

     

       228
       228
       -
               defaultText = "pythonPackages: with pythonPackages; [ ]";

     

       229
       229
       +
               defaultText = literalExpression "pythonPackages: with pythonPackages; [ ]";

     

       229
       230
        
               description = "Packages to add the to the PYTHONPATH of the buildbot process.";

     

       230
       230
       -
               example = literalExample "pythonPackages: with pythonPackages; [ requests ]";

     

       231
       231
       +
               example = literalExpression "pythonPackages: with pythonPackages; [ requests ]";

     

       231
       232
        
             };

     

       232
       233
        
           };

     

       233
       234
        
         };

+3 -3

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

···

       128
       128
        
             package = mkOption {

     

       129
       129
        
               type = types.package;

     

       130
       130
        
               default = pkgs.python3Packages.buildbot-worker;

     

       131
       131
       -
               defaultText = "pkgs.python3Packages.buildbot-worker";

     

       131
       131
       +
               defaultText = literalExpression "pkgs.python3Packages.buildbot-worker";

     

       132
       132
        
               description = "Package to use for buildbot worker.";

     

       133
       133
       -
               example = literalExample "pkgs.python2Packages.buildbot-worker";

     

       133
       133
       +
               example = literalExpression "pkgs.python2Packages.buildbot-worker";

     

       134
       134
        
             };

     

       135
       135
        
       

     

       136
       136
        
             packages = mkOption {

     

       137
       137
        
               default = with pkgs; [ git ];

     

       138
       138
       -
               example = literalExample "[ pkgs.git ]";

     

       138
       138
       +
               defaultText = literalExpression "[ pkgs.git ]";

     

       139
       139
        
               type = types.listOf types.package;

     

       140
       140
        
               description = "Packages to add to PATH for the buildbot process.";

     

       141
       141
        
             };

+4 -3

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

···

       39
       39
        
       

     

       40
       40
        
             package = mkOption {

     

       41
       41
        
               default = pkgs.buildkite-agent;

     

       42
       42
       -
               defaultText = "pkgs.buildkite-agent";

     

       42
       42
       +
               defaultText = literalExpression "pkgs.buildkite-agent";

     

       43
       43
        
               description = "Which buildkite-agent derivation to use";

     

       44
       44
        
               type = types.package;

     

       45
       45
        
             };

     
···

       52
       52
        
       

     

       53
       53
        
             runtimePackages = mkOption {

     

       54
       54
        
               default = [ pkgs.bash pkgs.gnutar pkgs.gzip pkgs.git pkgs.nix ];

     

       55
       55
       -
               defaultText = "[ pkgs.bash pkgs.gnutar pkgs.gzip pkgs.git pkgs.nix ]";

     

       55
       55
       +
               defaultText = literalExpression "[ pkgs.bash pkgs.gnutar pkgs.gzip pkgs.git pkgs.nix ]";

     

       56
       56
        
               description = "Add programs to the buildkite-agent environment";

     

       57
       57
        
               type = types.listOf types.package;

     

       58
       58
        
             };

     
···

       168
       168
        
             hooksPath = mkOption {

     

       169
       169
        
               type = types.path;

     

       170
       170
        
               default = hooksDir config;

     

       171
       171
       -
               defaultText = "generated from services.buildkite-agents.<name>.hooks";

     

       171
       171
       +
               defaultText = literalDocBook "generated from <option>services.buildkite-agents.&lt;name&gt;.hooks</option>";

     

       172
       172
        
               description = ''

     

       173
       173
        
                 Path to the directory storing the hooks.

     

       174
       174
        
                 Consider using <option>services.buildkite-agents.&lt;name&gt;.hooks.&lt;name&gt;</option>

     
···

       179
       179
        
             shell = mkOption {

     

       180
       180
        
               type = types.str;

     

       181
       181
        
               default = "${pkgs.bash}/bin/bash -e -c";

     

       182
       182
       +
               defaultText = literalExpression ''"''${pkgs.bash}/bin/bash -e -c"'';

     

       182
       183
        
               description = ''

     

       183
       184
        
                 Command that buildkite-agent 3 will execute when it spawns a shell.

     

       184
       185
        
               '';

+2 -1

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

···

       77
       77
        
       

     

       78
       78
        
               Changing this option triggers a new runner registration.

     

       79
       79
        
             '';

     

       80
       80
       -
             example = literalExample ''[ "nixos" ]'';

     

       80
       80
       +
             example = literalExpression ''[ "nixos" ]'';

     

       81
       81
        
             default = [ ];

     

       82
       82
        
           };

     

       83
       83
        
       

     
···

       105
       105
        
               Which github-runner derivation to use.

     

       106
       106
        
             '';

     

       107
       107
        
             default = pkgs.github-runner;

     

       108
       108
       +
             defaultText = literalExpression "pkgs.github-runner";

     

       108
       109
        
           };

     

       109
       110
        
         };

     

       110
       111

+6 -6

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

···

       136
       136
        
           checkInterval = mkOption {

     

       137
       137
        
             type = types.int;

     

       138
       138
        
             default = 0;

     

       139
       139
       -
             example = literalExample "with lib; (length (attrNames config.services.gitlab-runner.services)) * 3";

     

       139
       139
       +
             example = literalExpression "with lib; (length (attrNames config.services.gitlab-runner.services)) * 3";

     

       140
       140
        
             description = ''

     

       141
       141
        
               Defines the interval length, in seconds, between new jobs check.

     

       142
       142
        
               The default value is 3;

     
···

       147
       147
        
           concurrent = mkOption {

     

       148
       148
        
             type = types.int;

     

       149
       149
        
             default = 1;

     

       150
       150
       -
             example = literalExample "config.nix.maxJobs";

     

       150
       150
       +
             example = literalExpression "config.nix.maxJobs";

     

       151
       151
        
             description = ''

     

       152
       152
        
               Limits how many jobs globally can be run concurrently.

     

       153
       153
        
               The most upper limit of jobs using all defined runners.

     
···

       203
       203
        
               };

     

       204
       204
        
             };

     

       205
       205
        
             default = { };

     

       206
       206
       -
             example = literalExample ''

     

       206
       206
       +
             example = literalExpression ''

     

       207
       207
        
               {

     

       208
       208
        
                 listenAddress = "0.0.0.0:8093";

     

       209
       209
        
               }

     
···

       234
       234
        
           package = mkOption {

     

       235
       235
        
             type = types.package;

     

       236
       236
        
             default = pkgs.gitlab-runner;

     

       237
       237
       -
             defaultText = "pkgs.gitlab-runner";

     

       238
       238
       -
             example = literalExample "pkgs.gitlab-runner_1_11";

     

       237
       237
       +
             defaultText = literalExpression "pkgs.gitlab-runner";

     

       238
       238
       +
             example = literalExpression "pkgs.gitlab-runner_1_11";

     

       239
       239
        
             description = "Gitlab Runner package to use.";

     

       240
       240
        
           };

     

       241
       241
        
           extraPackages = mkOption {

     
···

       248
       248
        
           services = mkOption {

     

       249
       249
        
             description = "GitLab Runner services.";

     

       250
       250
        
             default = { };

     

       251
       251
       -
             example = literalExample ''

     

       251
       251
       +
             example = literalExpression ''

     

       252
       252
        
               {

     

       253
       253
        
                 # runner for building in docker via host's nix-daemon

     

       254
       254
        
                 # nix store will be readable in runner, might be insecure

+1 -1

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

···

       37
       37
        
       

     

       38
       38
        
             packages = mkOption {

     

       39
       39
        
               default = [ pkgs.stdenv pkgs.jre pkgs.git config.programs.ssh.package pkgs.nix ];

     

       40
       40
       -
               defaultText = "[ pkgs.stdenv pkgs.jre pkgs.git config.programs.ssh.package pkgs.nix ]";

     

       40
       40
       +
               defaultText = literalExpression "[ pkgs.stdenv pkgs.jre pkgs.git config.programs.ssh.package pkgs.nix ]";

     

       41
       41
        
               type = types.listOf types.package;

     

       42
       42
        
               description = ''

     

       43
       43
        
                 Packages to add to PATH for the Go.CD agent process.

+1 -1

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

···

       69
       69
        
       

     

       70
       70
        
             packages = mkOption {

     

       71
       71
        
               default = [ pkgs.stdenv pkgs.jre pkgs.git config.programs.ssh.package pkgs.nix ];

     

       72
       72
       -
               defaultText = "[ pkgs.stdenv pkgs.jre pkgs.git config.programs.ssh.package pkgs.nix ]";

     

       72
       72
       +
               defaultText = literalExpression "[ pkgs.stdenv pkgs.jre pkgs.git config.programs.ssh.package pkgs.nix ]";

     

       73
       73
        
               type = types.listOf types.package;

     

       74
       74
        
               description = ''

     

       75
       75
        
                 Packages to add to PATH for the Go.CD server's process.

+1 -1

nixos/modules/services/continuous-integration/hail.nix

···

       35
       35
        
           package = mkOption {

     

       36
       36
        
             type = types.package;

     

       37
       37
        
             default = pkgs.haskellPackages.hail;

     

       38
       38
       -
             defaultText = "pkgs.haskellPackages.hail";

     

       38
       38
       +
             defaultText = literalExpression "pkgs.haskellPackages.hail";

     

       39
       39
        
             description = "Hail package to use.";

     

       40
       40
        
           };

     

       41
       41
        
         };

+8 -7

nixos/modules/services/continuous-integration/hercules-ci-agent/common.nix

···

       10
       10
        
       let

     

       11
       11
        
         inherit (lib)

     

       12
       12
        
           filterAttrs

     

       13
       13
       -
           literalExample

     

       13
       13
       +
           literalDocBook

     

       14
       14
       +
           literalExpression

     

       14
       15
        
           mkIf

     

       15
       16
        
           mkOption

     

       16
       17
        
           mkRemovedOptionModule

     
···

       60
       61
        
               '';

     

       61
       62
        
               type = types.path;

     

       62
       63
        
               default = config.baseDirectory + "/work";

     

       63
       63
       -
               defaultText = literalExample ''baseDirectory + "/work"'';

     

       64
       64
       +
               defaultText = literalExpression ''baseDirectory + "/work"'';

     

       64
       65
        
             };

     

       65
       66
        
             staticSecretsDirectory = mkOption {

     

       66
       67
        
               description = ''

     
···

       68
       69
        
               '';

     

       69
       70
        
               type = types.path;

     

       70
       71
        
               default = config.baseDirectory + "/secrets";

     

       71
       71
       -
               defaultText = literalExample ''baseDirectory + "/secrets"'';

     

       72
       72
       +
               defaultText = literalExpression ''baseDirectory + "/secrets"'';

     

       72
       73
        
             };

     

       73
       74
        
             clusterJoinTokenPath = mkOption {

     

       74
       75
        
               description = ''

     
···

       76
       77
        
               '';

     

       77
       78
        
               type = types.path;

     

       78
       79
        
               default = config.staticSecretsDirectory + "/cluster-join-token.key";

     

       79
       79
       -
               defaultText = literalExample ''staticSecretsDirectory + "/cluster-join-token.key"'';

     

       80
       80
       +
               defaultText = literalExpression ''staticSecretsDirectory + "/cluster-join-token.key"'';

     

       80
       81
        
               # internal: It's a bit too detailed to show by default in the docs,

     

       81
       82
        
               # but useful to define explicitly to allow reuse by other modules.

     

       82
       83
        
               internal = true;

     
···

       87
       88
        
               '';

     

       88
       89
        
               type = types.path;

     

       89
       90
        
               default = config.staticSecretsDirectory + "/binary-caches.json";

     

       90
       90
       -
               defaultText = literalExample ''staticSecretsDirectory + "/binary-caches.json"'';

     

       91
       91
       +
               defaultText = literalExpression ''staticSecretsDirectory + "/binary-caches.json"'';

     

       91
       92
        
               # internal: It's a bit too detailed to show by default in the docs,

     

       92
       93
        
               # but useful to define explicitly to allow reuse by other modules.

     

       93
       94
        
               internal = true;

     
···

       158
       159
        
             '';

     

       159
       160
        
             type = types.package;

     

       160
       161
        
             default = pkgs.hercules-ci-agent;

     

       161
       161
       -
             defaultText = literalExample "pkgs.hercules-ci-agent";

     

       162
       162
       +
             defaultText = literalExpression "pkgs.hercules-ci-agent";

     

       162
       163
        
           };

     

       163
       164
        
           settings = mkOption {

     

       164
       165
        
             description = ''

     
···

       180
       181
        
           tomlFile = mkOption {

     

       181
       182
        
             type = types.path;

     

       182
       183
        
             internal = true;

     

       183
       183
       -
             defaultText = "generated hercules-ci-agent.toml";

     

       184
       184
       +
             defaultText = literalDocBook "generated <literal>hercules-ci-agent.toml</literal>";

     

       184
       185
        
             description = ''

     

       185
       186
        
               The fully assembled config file.

     

       186
       187
        
             '';

+2 -2

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

···

       100
       100
        
             package = mkOption {

     

       101
       101
        
               type = types.package;

     

       102
       102
        
               default = pkgs.hydra-unstable;

     

       103
       103
       -
               defaultText = "pkgs.hydra-unstable";

     

       103
       103
       +
               defaultText = literalExpression "pkgs.hydra-unstable";

     

       104
       104
        
               description = "The Hydra package.";

     

       105
       105
        
             };

     

       106
       106
        
       

     
···

       155
       155
        
             smtpHost = mkOption {

     

       156
       156
        
               type = types.nullOr types.str;

     

       157
       157
        
               default = null;

     

       158
       158
       -
               example = ["localhost"];

     

       158
       158
       +
               example = "localhost";

     

       159
       159
        
               description = ''

     

       160
       160
        
                 Hostname of the SMTP server to use to send email.

     

       161
       161
        
               '';

+3 -3

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

···

       81
       81
        
       

     

       82
       82
        
             package = mkOption {

     

       83
       83
        
               default = pkgs.jenkins;

     

       84
       84
       -
               defaultText = "pkgs.jenkins";

     

       84
       84
       +
               defaultText = literalExpression "pkgs.jenkins";

     

       85
       85
        
               type = types.package;

     

       86
       86
        
               description = "Jenkins package to use.";

     

       87
       87
        
             };

     

       88
       88
        
       

     

       89
       89
        
             packages = mkOption {

     

       90
       90
        
               default = [ pkgs.stdenv pkgs.git pkgs.jdk11 config.programs.ssh.package pkgs.nix ];

     

       91
       91
       -
               defaultText = "[ pkgs.stdenv pkgs.git pkgs.jdk11 config.programs.ssh.package pkgs.nix ]";

     

       91
       91
       +
               defaultText = literalExpression "[ pkgs.stdenv pkgs.git pkgs.jdk11 config.programs.ssh.package pkgs.nix ]";

     

       92
       92
        
               type = types.listOf types.package;

     

       93
       93
        
               description = ''

     

       94
       94
        
                 Packages to add to PATH for the jenkins process.

     
···

       120
       120
        
                 <literal>null</literal>. You can generate this set with a

     

       121
       121
        
                 tool such as <literal>jenkinsPlugins2nix</literal>.

     

       122
       122
        
               '';

     

       123
       123
       -
               example = literalExample ''

     

       123
       123
       +
               example = literalExpression ''

     

       124
       124
        
                 import path/to/jenkinsPlugins2nix-generated-plugins.nix { inherit (pkgs) fetchurl stdenv; }

     

       125
       125
        
               '';

     

       126
       126
        
             };

+2 -2

nixos/modules/services/continuous-integration/jenkins/job-builder.nix

···

       74
       74
        
             jsonJobs = mkOption {

     

       75
       75
        
               default = [ ];

     

       76
       76
        
               type = types.listOf types.str;

     

       77
       77
       -
               example = literalExample ''

     

       77
       77
       +
               example = literalExpression ''

     

       78
       78
        
                 [

     

       79
       79
        
                   '''

     

       80
       80
        
                     [ { "job":

     
···

       94
       94
        
             nixJobs = mkOption {

     

       95
       95
        
               default = [ ];

     

       96
       96
        
               type = types.listOf types.attrs;

     

       97
       97
       -
               example = literalExample ''

     

       97
       97
       +
               example = literalExpression ''

     

       98
       98
        
                 [ { job =

     

       99
       99
        
                     { name = "jenkins-job-test-3";

     

       100
       100
        
                       builders = [

+1 -1

nixos/modules/services/databases/aerospike.nix

···

       43
       43
        
       

     

       44
       44
        
             package = mkOption {

     

       45
       45
        
               default = pkgs.aerospike;

     

       46
       46
       -
               defaultText = "pkgs.aerospike";

     

       46
       46
       +
               defaultText = literalExpression "pkgs.aerospike";

     

       47
       47
        
               type = types.package;

     

       48
       48
        
               description = "Which Aerospike derivation to use";

     

       49
       49
        
             };

+6 -4

nixos/modules/services/databases/cassandra.nix

···

       4
       4
        
         inherit (lib)

     

       5
       5
        
           concatStringsSep

     

       6
       6
        
           flip

     

       7
       7
       -
           literalExample

     

       7
       7
       +
           literalDocBook

     

       8
       8
       +
           literalExpression

     

       8
       9
        
           optionalAttrs

     

       9
       10
        
           optionals

     

       10
       11
        
           recursiveUpdate

     
···

       136
       137
        
           package = mkOption {

     

       137
       138
        
             type = types.package;

     

       138
       139
        
             default = pkgs.cassandra;

     

       139
       139
       -
             defaultText = "pkgs.cassandra";

     

       140
       140
       -
             example = literalExample "pkgs.cassandra_3_11";

     

       140
       140
       +
             defaultText = literalExpression "pkgs.cassandra";

     

       141
       141
       +
             example = literalExpression "pkgs.cassandra_3_11";

     

       141
       142
        
             description = ''

     

       142
       143
        
               The Apache Cassandra package to use.

     

       143
       144
        
             '';

     
···

       276
       277
        
           extraEnvSh = mkOption {

     

       277
       278
        
             type = types.lines;

     

       278
       279
        
             default = "";

     

       279
       279
       -
             example = "CLASSPATH=$CLASSPATH:\${extraJar}";

     

       280
       280
       +
             example = literalExpression ''"CLASSPATH=$CLASSPATH:''${extraJar}"'';

     

       280
       281
        
             description = ''

     

       281
       282
        
               Extra shell lines to be appended onto cassandra-env.sh.

     

       282
       283
        
             '';

     
···

       436
       437
        
               if versionAtLeast cfg.package.version "3.11"

     

       437
       438
        
               then pkgs.writeText "jmx-roles-file" defaultJmxRolesFile

     

       438
       439
        
               else null;

     

       440
       440
       +
             defaultText = literalDocBook ''generated configuration file if version is at least 3.11, otherwise <literal>null</literal>'';

     

       439
       441
        
             example = "/var/lib/cassandra/jmx.password";

     

       440
       442
        
             description = ''

     

       441
       443
        
               Specify your own jmx roles file.

+1 -1

nixos/modules/services/databases/cockroachdb.nix

···

       150
       150
        
             package = mkOption {

     

       151
       151
        
               type = types.package;

     

       152
       152
        
               default = pkgs.cockroachdb;

     

       153
       153
       -
               defaultText = "pkgs.cockroachdb";

     

       153
       153
       +
               defaultText = literalExpression "pkgs.cockroachdb";

     

       154
       154
        
               description = ''

     

       155
       155
        
                 The CockroachDB derivation to use for running the service.

     

       156
       156

+1 -2

nixos/modules/services/databases/couchdb.nix

···

       44
       44
        
             package = mkOption {

     

       45
       45
        
               type = types.package;

     

       46
       46
        
               default = pkgs.couchdb;

     

       47
       47
       -
               defaultText = "pkgs.couchdb";

     

       48
       48
       -
               example = literalExample "pkgs.couchdb";

     

       47
       47
       +
               defaultText = literalExpression "pkgs.couchdb";

     

       49
       48
        
               description = ''

     

       50
       49
        
                 CouchDB package to use.

     

       51
       50
        
               '';

+3 -5

nixos/modules/services/databases/firebird.nix

···

       44
       44
        
       

     

       45
       45
        
             package = mkOption {

     

       46
       46
        
               default = pkgs.firebird;

     

       47
       47
       -
               defaultText = "pkgs.firebird";

     

       47
       47
       +
               defaultText = literalExpression "pkgs.firebird";

     

       48
       48
        
               type = types.package;

     

       49
       49
       -
               example = ''

     

       50
       50
       -
                 <code>package = pkgs.firebird_3;</code>

     

       51
       51
       -
               '';

     

       49
       49
       +
               example = literalExpression "pkgs.firebird_3";

     

       52
       50
        
               description = ''

     

       53
       51
        
                 Which Firebird package to be installed: <code>pkgs.firebird_3</code>

     

       54
       52
        
                 For SuperServer use override: <code>pkgs.firebird_3.override { superServer = true; };</code>

     
···

       56
       54
        
             };

     

       57
       55
        
       

     

       58
       56
        
             port = mkOption {

     

       59
       59
       -
               default = "3050";

     

       57
       57
       +
               default = 3050;

     

       60
       58
        
               type = types.port;

     

       61
       59
        
               description = ''

     

       62
       60
        
                 Port Firebird uses.

+1 -2

nixos/modules/services/databases/hbase.nix

···

       44
       44
        
             package = mkOption {

     

       45
       45
        
               type = types.package;

     

       46
       46
        
               default = pkgs.hbase;

     

       47
       47
       -
               defaultText = "pkgs.hbase";

     

       48
       48
       -
               example = literalExample "pkgs.hbase";

     

       47
       47
       +
               defaultText = literalExpression "pkgs.hbase";

     

       49
       48
        
               description = ''

     

       50
       49
        
                 HBase package to use.

     

       51
       50
        
               '';

+1 -1

nixos/modules/services/databases/influxdb.nix

···

       121
       121
        
       

     

       122
       122
        
             package = mkOption {

     

       123
       123
        
               default = pkgs.influxdb;

     

       124
       124
       -
               defaultText = "pkgs.influxdb";

     

       124
       124
       +
               defaultText = literalExpression "pkgs.influxdb";

     

       125
       125
        
               description = "Which influxdb derivation to use";

     

       126
       126
        
               type = types.package;

     

       127
       127
        
             };

+1 -1

nixos/modules/services/databases/influxdb2.nix

···

       11
       11
        
             enable = mkEnableOption "the influxdb2 server";

     

       12
       12
        
             package = mkOption {

     

       13
       13
        
               default = pkgs.influxdb2;

     

       14
       14
       -
               defaultText = "pkgs.influxdb2";

     

       14
       14
       +
               defaultText = literalExpression "pkgs.influxdb2";

     

       15
       15
        
               description = "influxdb2 derivation to use.";

     

       16
       16
        
               type = types.package;

     

       17
       17
        
             };

+1 -1

nixos/modules/services/databases/monetdb.nix

···

       17
       17
        
             package = mkOption {

     

       18
       18
        
               type = types.package;

     

       19
       19
        
               default = pkgs.monetdb;

     

       20
       20
       -
               defaultText = "pkgs.monetdb";

     

       20
       20
       +
               defaultText = literalExpression "pkgs.monetdb";

     

       21
       21
        
               description = "MonetDB package to use.";

     

       22
       22
        
             };

     

       23
       23

+1 -1

nixos/modules/services/databases/mongodb.nix

···

       33
       33
        
       

     

       34
       34
        
             package = mkOption {

     

       35
       35
        
               default = pkgs.mongodb;

     

       36
       36
       -
               defaultText = "pkgs.mongodb";

     

       36
       36
       +
               defaultText = literalExpression "pkgs.mongodb";

     

       37
       37
        
               type = types.package;

     

       38
       38
        
               description = "

     

       39
       39
        
                 Which MongoDB derivation to use.

+8 -8

nixos/modules/services/databases/mysql.nix

···

       34
       34
        
       

     

       35
       35
        
             package = mkOption {

     

       36
       36
        
               type = types.package;

     

       37
       37
       -
               example = literalExample "pkgs.mariadb";

     

       37
       37
       +
               example = literalExpression "pkgs.mariadb";

     

       38
       38
        
               description = "

     

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

     

       40
       40
        
               ";

     
···

       43
       43
        
             bind = mkOption {

     

       44
       44
        
               type = types.nullOr types.str;

     

       45
       45
        
               default = null;

     

       46
       46
       -
               example = literalExample "0.0.0.0";

     

       46
       46
       +
               example = "0.0.0.0";

     

       47
       47
        
               description = "Address to bind to. The default is to bind to all addresses.";

     

       48
       48
        
             };

     

       49
       49
        
       

     
···

       74
       74
        
             configFile = mkOption {

     

       75
       75
        
               type = types.path;

     

       76
       76
        
               default = settingsFile;

     

       77
       77
       -
               defaultText = "settingsFile";

     

       77
       77
       +
               defaultText = literalExpression "settingsFile";

     

       78
       78
        
               description = ''

     

       79
       79
        
                 Override the configuration file used by MySQL. By default,

     

       80
       80
        
                 NixOS generates one automatically from <option>services.mysql.settings</option>.

     

       81
       81
        
               '';

     

       82
       82
       -
               example = literalExample ''

     

       82
       82
       +
               example = literalExpression ''

     

       83
       83
        
                 pkgs.writeText "my.cnf" '''

     

       84
       84
        
                   [mysqld]

     

       85
       85
        
                   datadir = /var/lib/mysql

     
···

       109
       109
        
                   </para>

     

       110
       110
        
                 </note>

     

       111
       111
        
               '';

     

       112
       112
       -
               example = literalExample ''

     

       112
       112
       +
               example = literalExpression ''

     

       113
       113
        
                 {

     

       114
       114
        
                   mysqld = {

     

       115
       115
        
                     key_buffer_size = "6G";

     
···

       167
       167
        
                 of MySQL. The schema attribute is optional: If not specified, an empty database is created.

     

       168
       168
        
               '';

     

       169
       169
        
               example = [

     

       170
       170
       -
                 { name = "foodatabase"; schema = literalExample "./foodatabase.sql"; }

     

       170
       170
       +
                 { name = "foodatabase"; schema = literalExpression "./foodatabase.sql"; }

     

       171
       171
        
                 { name = "bardatabase"; }

     

       172
       172
        
               ];

     

       173
       173
        
             };

     
···

       217
       217
        
                       <link xlink:href="https://mariadb.com/kb/en/library/grant/">GRANT syntax</link>.

     

       218
       218
        
                       The attributes are used as <code>GRANT ''${attrName} ON ''${attrValue}</code>.

     

       219
       219
        
                     '';

     

       220
       220
       -
                     example = literalExample ''

     

       220
       220
       +
                     example = literalExpression ''

     

       221
       221
        
                       {

     

       222
       222
        
                         "database.*" = "ALL PRIVILEGES";

     

       223
       223
        
                         "*.*" = "SELECT, LOCK TABLES";

     
···

       235
       235
        
                 option is changed. This means that users created and permissions assigned once through this option or

     

       236
       236
        
                 otherwise have to be removed manually.

     

       237
       237
        
               '';

     

       238
       238
       -
               example = literalExample ''

     

       238
       238
       +
               example = literalExpression ''

     

       239
       239
        
                 [

     

       240
       240
        
                   {

     

       241
       241
        
                     name = "nextcloud";

+1 -1

nixos/modules/services/databases/neo4j.nix

···

       179
       179
        
           package = mkOption {

     

       180
       180
        
             type = types.package;

     

       181
       181
        
             default = pkgs.neo4j;

     

       182
       182
       -
             defaultText = "pkgs.neo4j";

     

       182
       182
       +
             defaultText = literalExpression "pkgs.neo4j";

     

       183
       183
        
             description = ''

     

       184
       184
        
               Neo4j package to use.

     

       185
       185
        
             '';

+7 -6

nixos/modules/services/databases/openldap.nix

···

       34
       34
        
                 in types.attrsOf (types.submodule { options = hiddenOptions; });

     

       35
       35
        
                 default = {};

     

       36
       36
        
                 description = "Child entries of the current entry, with recursively the same structure.";

     

       37
       37
       -
                 example = lib.literalExample ''

     

       37
       37
       +
                 example = lib.literalExpression ''

     

       38
       38
        
                   {

     

       39
       39
        
                       "cn=schema" = {

     

       40
       40
        
                       # The attribute used in the DN must be defined

     
···

       127
       127
        
             package = mkOption {

     

       128
       128
        
               type = types.package;

     

       129
       129
        
               default = pkgs.openldap;

     

       130
       130
       +
               defaultText = literalExpression "pkgs.openldap";

     

       130
       131
        
               description = ''

     

       131
       132
        
                 OpenLDAP package to use.

     

       132
       133
        
       

     
···

       158
       159
        
             settings = mkOption {

     

       159
       160
        
               type = ldapAttrsType;

     

       160
       161
        
               description = "Configuration for OpenLDAP, in OLC format";

     

       161
       161
       -
               example = lib.literalExample ''

     

       162
       162
       +
               example = lib.literalExpression ''

     

       162
       163
        
                 {

     

       163
       164
        
                   attrs.olcLogLevel = [ "stats" ];

     

       164
       165
        
                   children = {

     

       165
       166
        
                     "cn=schema".includes = [

     

       166
       166
       -
                        "\${pkgs.openldap}/etc/schema/core.ldif"

     

       167
       167
       -
                        "\${pkgs.openldap}/etc/schema/cosine.ldif"

     

       168
       168
       -
                        "\${pkgs.openldap}/etc/schema/inetorgperson.ldif"

     

       167
       167
       +
                        "''${pkgs.openldap}/etc/schema/core.ldif"

     

       168
       168
       +
                        "''${pkgs.openldap}/etc/schema/cosine.ldif"

     

       169
       169
       +
                        "''${pkgs.openldap}/etc/schema/inetorgperson.ldif"

     

       169
       170
        
                     ];

     

       170
       171
        
                     "olcDatabase={-1}frontend" = {

     

       171
       172
        
                       attrs = {

     
···

       225
       226
        
                 rebuilt on each server startup, so this will slow down server startup,

     

       226
       227
        
                 especially with large databases.

     

       227
       228
        
               '';

     

       228
       228
       -
               example = lib.literalExample ''

     

       229
       229
       +
               example = lib.literalExpression ''

     

       229
       230
        
                 {

     

       230
       231
        
                   "dc=example,dc=org" = '''

     

       231
       232
        
                     dn= dn: dc=example,dc=org

+1 -2

nixos/modules/services/databases/opentsdb.nix

···

       26
       26
        
             package = mkOption {

     

       27
       27
        
               type = types.package;

     

       28
       28
        
               default = pkgs.opentsdb;

     

       29
       29
       -
               defaultText = "pkgs.opentsdb";

     

       30
       30
       -
               example = literalExample "pkgs.opentsdb";

     

       29
       29
       +
               defaultText = literalExpression "pkgs.opentsdb";

     

       31
       30
        
               description = ''

     

       32
       31
        
                 OpenTSDB package to use.

     

       33
       32
        
               '';

+1 -1

nixos/modules/services/databases/pgmanage.nix

···

       49
       49
        
           package = mkOption {

     

       50
       50
        
             type = types.package;

     

       51
       51
        
             default = pkgs.pgmanage;

     

       52
       52
       -
             defaultText = "pkgs.pgmanage";

     

       52
       52
       +
             defaultText = literalExpression "pkgs.pgmanage";

     

       53
       53
        
             description = ''

     

       54
       54
        
               The pgmanage package to use.

     

       55
       55
        
             '';

+6 -6

nixos/modules/services/databases/postgresql.nix

···

       44
       44
        
       

     

       45
       45
        
             package = mkOption {

     

       46
       46
        
               type = types.package;

     

       47
       47
       -
               example = literalExample "pkgs.postgresql_11";

     

       47
       47
       +
               example = literalExpression "pkgs.postgresql_11";

     

       48
       48
        
               description = ''

     

       49
       49
        
                 PostgreSQL package to use.

     

       50
       50
        
               '';

     
···

       66
       66
        
       

     

       67
       67
        
             dataDir = mkOption {

     

       68
       68
        
               type = types.path;

     

       69
       69
       -
               defaultText = "/var/lib/postgresql/\${config.services.postgresql.package.psqlSchema}";

     

       69
       69
       +
               defaultText = literalExpression ''"/var/lib/postgresql/''${config.services.postgresql.package.psqlSchema}"'';

     

       70
       70
        
               example = "/var/lib/postgresql/11";

     

       71
       71
        
               description = ''

     

       72
       72
        
                 The data directory for PostgreSQL. If left as the default value

     
···

       161
       161
        
                       <link xlink:href="https://www.postgresql.org/docs/current/sql-grant.html">GRANT syntax</link>.

     

       162
       162
        
                       The attributes are used as <code>GRANT ''${attrValue} ON ''${attrName}</code>.

     

       163
       163
        
                     '';

     

       164
       164
       -
                     example = literalExample ''

     

       164
       164
       +
                     example = literalExpression ''

     

       165
       165
        
                       {

     

       166
       166
        
                         "DATABASE \"nextcloud\"" = "ALL PRIVILEGES";

     

       167
       167
        
                         "ALL TABLES IN SCHEMA public" = "ALL PRIVILEGES";

     
···

       179
       179
        
                 option is changed. This means that users created and permissions assigned once through this option or

     

       180
       180
        
                 otherwise have to be removed manually.

     

       181
       181
        
               '';

     

       182
       182
       -
               example = literalExample ''

     

       182
       182
       +
               example = literalExpression ''

     

       183
       183
        
                 [

     

       184
       184
        
                   {

     

       185
       185
        
                     name = "nextcloud";

     
···

       221
       221
        
             extraPlugins = mkOption {

     

       222
       222
        
               type = types.listOf types.path;

     

       223
       223
        
               default = [];

     

       224
       224
       -
               example = literalExample "with pkgs.postgresql_11.pkgs; [ postgis pg_repack ]";

     

       224
       224
       +
               example = literalExpression "with pkgs.postgresql_11.pkgs; [ postgis pg_repack ]";

     

       225
       225
        
               description = ''

     

       226
       226
        
                 List of PostgreSQL plugins. PostgreSQL version for each plugin should

     

       227
       227
        
                 match version for <literal>services.postgresql.package</literal> value.

     
···

       241
       241
        
                   escaped with two single quotes as described by the upstream documentation linked above.

     

       242
       242
        
                 </para></note>

     

       243
       243
        
               '';

     

       244
       244
       -
               example = literalExample ''

     

       244
       244
       +
               example = literalExpression ''

     

       245
       245
        
                 {

     

       246
       246
        
                   log_connections = true;

     

       247
       247
        
                   log_statement = "all";

+2 -3

nixos/modules/services/databases/redis.nix

···

       47
       47
        
             package = mkOption {

     

       48
       48
        
               type = types.package;

     

       49
       49
        
               default = pkgs.redis;

     

       50
       50
       -
               defaultText = "pkgs.redis";

     

       50
       50
       +
               defaultText = literalExpression "pkgs.redis";

     

       51
       51
        
               description = "Which Redis derivation to use.";

     

       52
       52
        
             };

     

       53
       53
        
       

     
···

       133
       133
        
               type = with types; listOf (listOf int);

     

       134
       134
        
               default = [ [900 1] [300 10] [60 10000] ];

     

       135
       135
        
               description = "The schedule in which data is persisted to disk, represented as a list of lists where the first element represent the amount of seconds and the second the number of changes.";

     

       136
       136
       -
               example = [ [900 1] [300 10] [60 10000] ];

     

       137
       136
        
             };

     

       138
       137
        
       

     

       139
       138
        
             slaveOf = mkOption {

     
···

       217
       216
        
                 <link xlink:href="https://redis.io/topics/config"/>

     

       218
       217
        
                 for details on supported values.

     

       219
       218
        
               '';

     

       220
       220
       -
               example = literalExample ''

     

       219
       219
       +
               example = literalExpression ''

     

       221
       220
        
                 {

     

       222
       221
        
                   loadmodule = [ "/path/to/my_module.so" "/path/to/other_module.so" ];

     

       223
       222
        
                 }

+1 -2

nixos/modules/services/databases/riak.nix

···

       21
       21
        
             package = mkOption {

     

       22
       22
        
               type = types.package;

     

       23
       23
        
               default = pkgs.riak;

     

       24
       24
       -
               defaultText = "pkgs.riak";

     

       25
       25
       -
               example = literalExample "pkgs.riak";

     

       24
       24
       +
               defaultText = literalExpression "pkgs.riak";

     

       26
       25
        
               description = ''

     

       27
       26
        
                 Riak package to use.

     

       28
       27
        
               '';

+1 -1

nixos/modules/services/databases/victoriametrics.nix

···

       6
       6
        
           package = mkOption {

     

       7
       7
        
             type = types.package;

     

       8
       8
        
             default = pkgs.victoriametrics;

     

       9
       9
       -
             defaultText = "pkgs.victoriametrics";

     

       9
       9
       +
             defaultText = literalExpression "pkgs.victoriametrics";

     

       10
       10
        
             description = ''

     

       11
       11
        
               The VictoriaMetrics distribution to use.

     

       12
       12
        
             '';

+1 -3

nixos/modules/services/desktops/geoclue2.nix

···

       21
       21
        
       

     

       22
       22
        
             isAllowed = mkOption {

     

       23
       23
        
               type = types.bool;

     

       24
       24
       -
               default = null;

     

       25
       24
        
               description = ''

     

       26
       25
        
                 Whether the application will be allowed access to location information.

     

       27
       26
        
               '';

     
···

       29
       28
        
       

     

       30
       29
        
             isSystem = mkOption {

     

       31
       30
        
               type = types.bool;

     

       32
       32
       -
               default = null;

     

       33
       31
        
               description = ''

     

       34
       32
        
                 Whether the application is a system component or not.

     

       35
       33
        
               '';

     
···

       162
       160
        
             appConfig = mkOption {

     

       163
       161
        
               type = types.attrsOf appConfigModule;

     

       164
       162
        
               default = {};

     

       165
       165
       -
               example = literalExample ''

     

       163
       163
       +
               example = literalExpression ''

     

       166
       164
        
                 "com.github.app" = {

     

       167
       165
        
                   isAllowed = true;

     

       168
       166
        
                   isSystem = true;

+1 -1

nixos/modules/services/desktops/gnome/evolution-data-server.nix

···

       39
       39
        
             plugins = mkOption {

     

       40
       40
        
               type = types.listOf types.package;

     

       41
       41
        
               default = [ ];

     

       42
       42
       -
               example = literalExample "[ pkgs.evolution-ews ]";

     

       42
       42
       +
               example = literalExpression "[ pkgs.evolution-ews ]";

     

       43
       43
        
               description = "Plugins for Evolution.";

     

       44
       44
        
             };

     

       45
       45

+1

nixos/modules/services/desktops/gvfs.nix

···

       35
       35
        
             package = mkOption {

     

       36
       36
        
               type = types.package;

     

       37
       37
        
               default = pkgs.gnome.gvfs;

     

       38
       38
       +
               defaultText = literalExpression "pkgs.gnome.gvfs";

     

       38
       39
        
               description = "Which GVfs package to use.";

     

       39
       40
        
             };

     

       40
       41

+2 -2

nixos/modules/services/desktops/pipewire/pipewire-media-session.nix

···

       37
       37
        
             enable = mkOption {

     

       38
       38
        
               type = types.bool;

     

       39
       39
        
               default = config.services.pipewire.enable;

     

       40
       40
       -
               defaultText = "config.services.pipewire.enable";

     

       40
       40
       +
               defaultText = literalExpression "config.services.pipewire.enable";

     

       41
       41
        
               description = "Example pipewire session manager";

     

       42
       42
        
             };

     

       43
       43
        
       

     

       44
       44
        
             package = mkOption {

     

       45
       45
        
               type = types.package;

     

       46
       46
        
               default = pkgs.pipewire.mediaSession;

     

       47
       47
       -
               example = literalExample "pkgs.pipewire.mediaSession";

     

       47
       47
       +
               defaultText = literalExpression "pkgs.pipewire.mediaSession";

     

       48
       48
        
               description = ''

     

       49
       49
        
                 The pipewire-media-session derivation to use.

     

       50
       50
        
               '';

+1 -2

nixos/modules/services/desktops/pipewire/pipewire.nix

···

       51
       51
        
             package = mkOption {

     

       52
       52
        
               type = types.package;

     

       53
       53
        
               default = pkgs.pipewire;

     

       54
       54
       -
               defaultText = "pkgs.pipewire";

     

       55
       55
       -
               example = literalExample "pkgs.pipewire";

     

       54
       54
       +
               defaultText = literalExpression "pkgs.pipewire";

     

       56
       55
        
               description = ''

     

       57
       56
        
                 The pipewire derivation to use.

     

       58
       57
        
               '';

+1 -1

nixos/modules/services/development/distccd.nix

···

       69
       69
        
             package = mkOption {

     

       70
       70
        
               type = types.package;

     

       71
       71
        
               default = pkgs.distcc;

     

       72
       72
       -
               example = "pkgs.distcc";

     

       72
       72
       +
               defaultText = literalExpression "pkgs.distcc";

     

       73
       73
        
               description = ''

     

       74
       74
        
                 The distcc package to use.

     

       75
       75
        
               '';

+3 -3

nixos/modules/services/development/hoogle.nix

···

       27
       27
        
           packages = mkOption {

     

       28
       28
        
             type = types.functionTo (types.listOf types.package);

     

       29
       29
        
             default = hp: [];

     

       30
       30
       -
             defaultText = "hp: []";

     

       31
       31
       -
             example = "hp: with hp; [ text lens ]";

     

       30
       30
       +
             defaultText = literalExpression "hp: []";

     

       31
       31
       +
             example = literalExpression "hp: with hp; [ text lens ]";

     

       32
       32
        
             description = ''

     

       33
       33
        
               The Haskell packages to generate documentation for.

     

       34
       34
        
       

     
···

       41
       41
        
           haskellPackages = mkOption {

     

       42
       42
        
             description = "Which haskell package set to use.";

     

       43
       43
        
             default = pkgs.haskellPackages;

     

       44
       44
       -
             defaultText = "pkgs.haskellPackages";

     

       44
       44
       +
             defaultText = literalExpression "pkgs.haskellPackages";

     

       45
       45
        
           };

     

       46
       46
        
       

     

       47
       47
        
           home = mkOption {

+3 -5

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

···

       40
       40
        
             # want to pass in JUPYTER_PATH but use .environment instead,

     

       41
       41
        
             # saving a rebuild.

     

       42
       42
        
             default = pkgs.python3.pkgs.notebook;

     

       43
       43
       +
             defaultText = literalExpression "pkgs.python3.pkgs.notebook";

     

       43
       44
        
             description = ''

     

       44
       45
        
               Jupyter package to use.

     

       45
       46
        
             '';

     
···

       105
       106
        
                 "open('/path/secret_file', 'r', encoding='utf8').read().strip()"

     

       106
       107
        
               It will be interpreted at the end of the notebookConfig.

     

       107
       108
        
             '';

     

       108
       108
       -
             example = [

     

       109
       109
       -
               "'sha1:1b961dc713fb:88483270a63e57d18d43cf337e629539de1436ba'"

     

       110
       110
       -
               "open('/path/secret_file', 'r', encoding='utf8').read().strip()"

     

       111
       111
       -
             ];

     

       109
       109
       +
             example = "'sha1:1b961dc713fb:88483270a63e57d18d43cf337e629539de1436ba'";

     

       112
       110
        
           };

     

       113
       111
        
       

     

       114
       112
        
           notebookConfig = mkOption {

     
···

       125
       123
        
             })));

     

       126
       124
        
       

     

       127
       125
        
             default = null;

     

       128
       128
       -
             example = literalExample ''

     

       126
       126
       +
             example = literalExpression ''

     

       129
       127
        
               {

     

       130
       128
        
                 python3 = let

     

       131
       129
        
                   env = (pkgs.python3.withPackages (pythonPackages: with pythonPackages; [

+4 -4

nixos/modules/services/development/jupyter/kernel-options.nix

···

       9
       9
        
           displayName = mkOption {

     

       10
       10
        
             type = types.str;

     

       11
       11
        
             default = "";

     

       12
       12
       -
             example = [

     

       12
       12
       +
             example = literalExpression ''

     

       13
       13
        
               "Python 3"

     

       14
       14
        
               "Python 3 for Data Science"

     

       15
       15
       -
             ];

     

       15
       15
       +
             '';

     

       16
       16
        
             description = ''

     

       17
       17
        
               Name that will be shown to the user.

     

       18
       18
        
             '';

     
···

       43
       43
        
           logo32 = mkOption {

     

       44
       44
        
             type = types.nullOr types.path;

     

       45
       45
        
             default = null;

     

       46
       46
       -
             example = "{env.sitePackages}/ipykernel/resources/logo-32x32.png";

     

       46
       46
       +
             example = literalExpression ''"''${env.sitePackages}/ipykernel/resources/logo-32x32.png"'';

     

       47
       47
        
             description = ''

     

       48
       48
        
               Path to 32x32 logo png.

     

       49
       49
        
             '';

     
···

       51
       51
        
           logo64 = mkOption {

     

       52
       52
        
             type = types.nullOr types.path;

     

       53
       53
        
             default = null;

     

       54
       54
       -
             example = "{env.sitePackages}/ipykernel/resources/logo-64x64.png";

     

       54
       54
       +
             example = literalExpression ''"''${env.sitePackages}/ipykernel/resources/logo-64x64.png"'';

     

       55
       55
        
             description = ''

     

       56
       56
        
               Path to 64x64 logo png.

     

       57
       57
        
             '';

+20 -8

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

···

       66
       66
        
               defaults for configuration but you can override anything since

     

       67
       67
        
               this is a python file.

     

       68
       68
        
             '';

     

       69
       69
       -
             example = literalExample ''

     

       70
       70
       -
                c.SystemdSpawner.mem_limit = '8G'

     

       71
       71
       -
                c.SystemdSpawner.cpu_limit = 2.0

     

       69
       69
       +
             example = ''

     

       70
       70
       +
               c.SystemdSpawner.mem_limit = '8G'

     

       71
       71
       +
               c.SystemdSpawner.cpu_limit = 2.0

     

       72
       72
        
             '';

     

       73
       73
        
           };

     

       74
       74
        
       

     

       75
       75
        
           jupyterhubEnv = mkOption {

     

       76
       76
        
             type = types.package;

     

       77
       77
       -
             default = (pkgs.python3.withPackages (p: with p; [

     

       77
       77
       +
             default = pkgs.python3.withPackages (p: with p; [

     

       78
       78
        
               jupyterhub

     

       79
       79
        
               jupyterhub-systemdspawner

     

       80
       80
       -
             ]));

     

       80
       80
       +
             ]);

     

       81
       81
       +
             defaultText = literalExpression ''

     

       82
       82
       +
               pkgs.python3.withPackages (p: with p; [

     

       83
       83
       +
                 jupyterhub

     

       84
       84
       +
                 jupyterhub-systemdspawner

     

       85
       85
       +
               ])

     

       86
       86
       +
             '';

     

       81
       87
        
             description = ''

     

       82
       88
        
               Python environment to run jupyterhub

     

       83
       89
        
       

     
···

       90
       96
        
       

     

       91
       97
        
           jupyterlabEnv = mkOption {

     

       92
       98
        
             type = types.package;

     

       93
       93
       -
             default = (pkgs.python3.withPackages (p: with p; [

     

       99
       99
       +
             default = pkgs.python3.withPackages (p: with p; [

     

       94
       100
        
               jupyterhub

     

       95
       101
        
               jupyterlab

     

       96
       96
       -
             ]));

     

       102
       102
       +
             ]);

     

       103
       103
       +
             defaultText = literalExpression ''

     

       104
       104
       +
               pkgs.python3.withPackages (p: with p; [

     

       105
       105
       +
                 jupyterhub

     

       106
       106
       +
                 jupyterlab

     

       107
       107
       +
               ])

     

       108
       108
       +
             '';

     

       97
       109
        
             description = ''

     

       98
       110
        
               Python environment to run jupyterlab

     

       99
       111
        
       

     
···

       111
       123
        
             })));

     

       112
       124
        
       

     

       113
       125
        
             default = null;

     

       114
       114
       -
             example = literalExample ''

     

       126
       126
       +
             example = literalExpression ''

     

       115
       127
        
               {

     

       116
       128
        
                 python3 = let

     

       117
       129
        
                   env = (pkgs.python3.withPackages (pythonPackages: with pythonPackages; [

+1 -2

nixos/modules/services/development/lorri.nix

···

       21
       21
        
               description = ''

     

       22
       22
        
                 The lorri package to use.

     

       23
       23
        
               '';

     

       24
       24
       -
               defaultText = lib.literalExample "pkgs.lorri";

     

       25
       25
       -
               example = lib.literalExample "pkgs.lorri";

     

       24
       24
       +
               defaultText = lib.literalExpression "pkgs.lorri";

     

       26
       25
        
             };

     

       27
       26
        
           };

     

       28
       27
        
         };

+3 -3

nixos/modules/services/display-managers/greetd.nix

···

       13
       13
        
           package = mkOption {

     

       14
       14
        
             type = types.package;

     

       15
       15
        
             default = pkgs.greetd.greetd;

     

       16
       16
       -
             defaultText = "pkgs.greetd.greetd";

     

       16
       16
       +
             defaultText = literalExpression "pkgs.greetd.greetd";

     

       17
       17
        
             description = "The greetd package that should be used.";

     

       18
       18
        
           };

     

       19
       19
        
       

     

       20
       20
        
           settings = mkOption {

     

       21
       21
        
             type = settingsFormat.type;

     

       22
       22
       -
             example = literalExample ''

     

       22
       22
       +
             example = literalExpression ''

     

       23
       23
        
               {

     

       24
       24
        
                 default_session = {

     

       25
       25
        
                   command = "''${pkgs.greetd.greetd}/bin/agreety --cmd sway";

     
···

       43
       43
        
           restart = mkOption {

     

       44
       44
        
             type = types.bool;

     

       45
       45
        
             default = !(cfg.settings ? initial_session);

     

       46
       46
       -
             defaultText = "!(config.services.greetd.settings ? initial_session)";

     

       46
       46
       +
             defaultText = literalExpression "!(config.services.greetd.settings ? initial_session)";

     

       47
       47
        
             description = ''

     

       48
       48
        
               Wether to restart greetd when it terminates (e.g. on failure).

     

       49
       49
        
               This is usually desirable so a user can always log in, but should be disabled when using 'settings.initial_session' (autologin),

+1 -1

nixos/modules/services/editors/emacs.nix

···

       66
       66
        
           package = mkOption {

     

       67
       67
        
             type = types.package;

     

       68
       68
        
             default = pkgs.emacs;

     

       69
       69
       -
             defaultText = "pkgs.emacs";

     

       69
       69
       +
             defaultText = literalExpression "pkgs.emacs";

     

       70
       70
        
             description = ''

     

       71
       71
        
               emacs derivation to use.

     

       72
       72
        
             '';

+1 -1

nixos/modules/services/editors/infinoted.nix

···

       11
       11
        
           package = mkOption {

     

       12
       12
        
             type = types.package;

     

       13
       13
        
             default = pkgs.libinfinity;

     

       14
       14
       -
             defaultText = "pkgs.libinfinity";

     

       14
       14
       +
             defaultText = literalExpression "pkgs.libinfinity";

     

       15
       15
        
             description = ''

     

       16
       16
        
               Package providing infinoted

     

       17
       17
        
             '';

+28 -26

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

···

       18
       18
        
           package = mkOption {

     

       19
       19
        
             type = types.package;

     

       20
       20
        
             default = pkgs.crossfire-server;

     

       21
       21
       -
             defaultText = "pkgs.crossfire-server";

     

       21
       21
       +
             defaultText = literalExpression "pkgs.crossfire-server";

     

       22
       22
        
             description = ''

     

       23
       23
        
               The package to use for the Crossfire server (and map/arch data, if you

     

       24
       24
        
               don't change dataDir).

     
···

       28
       28
        
           dataDir = mkOption {

     

       29
       29
        
             type = types.str;

     

       30
       30
        
             default = "${cfg.package}/share/crossfire";

     

       31
       31
       -
             defaultText = "\${config.services.crossfire.package}/share/crossfire";

     

       31
       31
       +
             defaultText = literalExpression ''"''${config.services.crossfire.package}/share/crossfire"'';

     

       32
       32
        
             description = ''

     

       33
       33
        
               Where to load readonly data from -- maps, archetypes, treasure tables,

     

       34
       34
        
               and the like. If you plan to edit the data on the live server (rather

     
···

       72
       72
        
               overwrite the example files that come with the server, rather than being

     

       73
       73
        
               appended to them as the other configuration files are.

     

       74
       74
        
             '';

     

       75
       75
       -
             example = literalExample ''

     

       76
       76
       -
               dm_file = '''

     

       77
       77
       -
                 admin:secret_password:localhost

     

       78
       78
       -
                 jane:xyzzy:*

     

       79
       79
       -
               ''';

     

       80
       80
       -
               ban_file = '''

     

       81
       81
       -
                 # Bob is a jerk

     

       82
       82
       -
                 bob@*

     

       83
       83
       -
                 # So is everyone on 192.168.86.255/24

     

       84
       84
       -
                 *@192.168.86.

     

       85
       85
       -
               ''';

     

       86
       86
       -
               metaserver2 = '''

     

       87
       87
       -
                 metaserver2_notification on

     

       88
       88
       -
                 localhostname crossfire.example.net

     

       89
       89
       -
               ''';

     

       90
       90
       -
               motd = "Welcome to CrossFire!";

     

       91
       91
       -
               news = "No news yet.";

     

       92
       92
       -
               rules = "Don't be a jerk.";

     

       93
       93
       -
               settings = '''

     

       94
       94
       -
                 # be nicer to newbies and harsher to experienced players

     

       95
       95
       -
                 balanced_stat_loss true

     

       96
       96
       -
                 # don't let players pick up and use admin-created items

     

       97
       97
       -
                 real_wiz false

     

       98
       98
       -
               ''';

     

       75
       75
       +
             example = literalExpression ''

     

       76
       76
       +
               {

     

       77
       77
       +
                 dm_file = '''

     

       78
       78
       +
                   admin:secret_password:localhost

     

       79
       79
       +
                   jane:xyzzy:*

     

       80
       80
       +
                 ''';

     

       81
       81
       +
                 ban_file = '''

     

       82
       82
       +
                   # Bob is a jerk

     

       83
       83
       +
                   bob@*

     

       84
       84
       +
                   # So is everyone on 192.168.86.255/24

     

       85
       85
       +
                   *@192.168.86.

     

       86
       86
       +
                 ''';

     

       87
       87
       +
                 metaserver2 = '''

     

       88
       88
       +
                   metaserver2_notification on

     

       89
       89
       +
                   localhostname crossfire.example.net

     

       90
       90
       +
                 ''';

     

       91
       91
       +
                 motd = "Welcome to CrossFire!";

     

       92
       92
       +
                 news = "No news yet.";

     

       93
       93
       +
                 rules = "Don't be a jerk.";

     

       94
       94
       +
                 settings = '''

     

       95
       95
       +
                   # be nicer to newbies and harsher to experienced players

     

       96
       96
       +
                   balanced_stat_loss true

     

       97
       97
       +
                   # don't let players pick up and use admin-created items

     

       98
       98
       +
                   real_wiz false

     

       99
       99
       +
                 ''';

     

       100
       100
       +
               }

     

       99
       101
        
             '';

     

       100
       102
        
             default = {};

     

       101
       103
        
           };

+20 -18

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

···

       18
       18
        
           package = mkOption {

     

       19
       19
        
             type = types.package;

     

       20
       20
        
             default = pkgs.deliantra-server;

     

       21
       21
       -
             defaultText = "pkgs.deliantra-server";

     

       21
       21
       +
             defaultText = literalExpression "pkgs.deliantra-server";

     

       22
       22
        
             description = ''

     

       23
       23
        
               The package to use for the Deliantra server (and map/arch data, if you

     

       24
       24
        
               don't change dataDir).

     
···

       28
       28
        
           dataDir = mkOption {

     

       29
       29
        
             type = types.str;

     

       30
       30
        
             default = "${pkgs.deliantra-data}";

     

       31
       31
       -
             defaultText = "\${pkgs.deliantra-data}";

     

       31
       31
       +
             defaultText = literalExpression ''"''${pkgs.deliantra-data}"'';

     

       32
       32
        
             description = ''

     

       33
       33
        
               Where to store readonly data (maps, archetypes, sprites, etc).

     

       34
       34
        
               Note that if you plan to use the live map editor (rather than editing

     
···

       69
       69
        
               The example here is not comprehensive. See the files in

     

       70
       70
        
               /etc/deliantra-server after enabling this module for full documentation.

     

       71
       71
        
             '';

     

       72
       72
       -
             example = literalExample ''

     

       73
       73
       -
               dm_file = '''

     

       74
       74
       -
                 admin:secret_password:localhost

     

       75
       75
       -
                 jane:xyzzy:*

     

       76
       76
       -
               ''';

     

       77
       77
       -
               motd = "Welcome to Deliantra!";

     

       78
       78
       -
               settings = '''

     

       79
       79
       -
                 # Settings for game mechanics.

     

       80
       80
       -
                 stat_loss_on_death true

     

       81
       81
       -
                 armor_max_enchant 7

     

       82
       82
       -
               ''';

     

       83
       83
       -
               config = '''

     

       84
       84
       -
                 # Settings for the server daemon.

     

       85
       85
       -
                 hiscore_url https://deliantra.example.net/scores/

     

       86
       86
       -
                 max_map_reset 86400

     

       87
       87
       -
               ''';

     

       72
       72
       +
             example = literalExpression ''

     

       73
       73
       +
               {

     

       74
       74
       +
                 dm_file = '''

     

       75
       75
       +
                   admin:secret_password:localhost

     

       76
       76
       +
                   jane:xyzzy:*

     

       77
       77
       +
                 ''';

     

       78
       78
       +
                 motd = "Welcome to Deliantra!";

     

       79
       79
       +
                 settings = '''

     

       80
       80
       +
                   # Settings for game mechanics.

     

       81
       81
       +
                   stat_loss_on_death true

     

       82
       82
       +
                   armor_max_enchant 7

     

       83
       83
       +
                 ''';

     

       84
       84
       +
                 config = '''

     

       85
       85
       +
                   # Settings for the server daemon.

     

       86
       86
       +
                   hiscore_url https://deliantra.example.net/scores/

     

       87
       87
       +
                   max_map_reset 86400

     

       88
       88
       +
                 ''';

     

       89
       89
       +
               }

     

       88
       90
        
             '';

     

       89
       91
        
             default = {

     

       90
       92
        
               motd = "";

+3 -3

nixos/modules/services/games/factorio.nix

···

       86
       86
        
             configFile = mkOption {

     

       87
       87
        
               type = types.path;

     

       88
       88
        
               default = configFile;

     

       89
       89
       -
               defaultText = "configFile";

     

       89
       89
       +
               defaultText = literalExpression "configFile";

     

       90
       90
        
               description = ''

     

       91
       91
        
                 The server's configuration file.

     

       92
       92
        
       

     
···

       162
       162
        
             package = mkOption {

     

       163
       163
        
               type = types.package;

     

       164
       164
        
               default = pkgs.factorio-headless;

     

       165
       165
       -
               defaultText = "pkgs.factorio-headless";

     

       166
       166
       -
               example = "pkgs.factorio-headless-experimental";

     

       165
       165
       +
               defaultText = literalExpression "pkgs.factorio-headless";

     

       166
       166
       +
               example = literalExpression "pkgs.factorio-headless-experimental";

     

       167
       167
        
               description = ''

     

       168
       168
        
                 Factorio version to use. This defaults to the stable channel.

     

       169
       169
        
               '';

+4 -4

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

···

       109
       109
        
                 You can use <link xlink:href="https://mcuuid.net/"/> to get a

     

       110
       110
        
                 Minecraft UUID for a username.

     

       111
       111
        
               '';

     

       112
       112
       -
               example = literalExample ''

     

       112
       112
       +
               example = literalExpression ''

     

       113
       113
        
                 {

     

       114
       114
        
                   username1 = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";

     

       115
       115
        
                   username2 = "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy";

     
···

       120
       120
        
             serverProperties = mkOption {

     

       121
       121
        
               type = with types; attrsOf (oneOf [ bool int str ]);

     

       122
       122
        
               default = {};

     

       123
       123
       -
               example = literalExample ''

     

       123
       123
       +
               example = literalExpression ''

     

       124
       124
        
                 {

     

       125
       125
        
                   server-port = 43000;

     

       126
       126
        
                   difficulty = 3;

     
···

       144
       144
        
             package = mkOption {

     

       145
       145
        
               type = types.package;

     

       146
       146
        
               default = pkgs.minecraft-server;

     

       147
       147
       -
               defaultText = "pkgs.minecraft-server";

     

       148
       148
       -
               example = literalExample "pkgs.minecraft-server_1_12_2";

     

       147
       147
       +
               defaultText = literalExpression "pkgs.minecraft-server";

     

       148
       148
       +
               example = literalExpression "pkgs.minecraft-server_1_12_2";

     

       149
       149
        
               description = "Version of minecraft-server to run.";

     

       150
       150
        
             };

     

       151
       151

+1 -1

nixos/modules/services/hardware/acpid.nix

···

       61
       61
        
                 options = {

     

       62
       62
        
                   event = mkOption {

     

       63
       63
        
                     type = types.str;

     

       64
       64
       -
                     example = [ "button/power.*" "button/lid.*" "ac_adapter.*" "button/mute.*" "button/volumedown.*" "cd/play.*" "cd/next.*" ];

     

       64
       64
       +
                     example = literalExpression ''"button/power.*" "button/lid.*" "ac_adapter.*" "button/mute.*" "button/volumedown.*" "cd/play.*" "cd/next.*"'';

     

       65
       65
        
                     description = "Event type.";

     

       66
       66
        
                   };

     

       67
       67

+1 -1

nixos/modules/services/hardware/actkbd.nix

···

       74
       74
        
             bindings = mkOption {

     

       75
       75
        
               type = types.listOf (types.submodule bindingCfg);

     

       76
       76
        
               default = [];

     

       77
       77
       -
               example = lib.literalExample ''

     

       77
       77
       +
               example = lib.literalExpression ''

     

       78
       78
        
                 [ { keys = [ 113 ]; events = [ "key" ]; command = "''${pkgs.alsa-utils}/bin/amixer -q set Master toggle"; }

     

       79
       79
        
                 ]

     

       80
       80
        
               '';

+3 -3

nixos/modules/services/hardware/bluetooth.nix

···

       6
       6
        
         inherit (lib)

     

       7
       7
        
           mkDefault mkEnableOption mkIf mkOption

     

       8
       8
        
           mkRenamedOptionModule mkRemovedOptionModule

     

       9
       9
       -
           concatStringsSep escapeShellArgs

     

       9
       9
       +
           concatStringsSep escapeShellArgs literalExpression

     

       10
       10
        
           optional optionals optionalAttrs recursiveUpdate types;

     

       11
       11
        
       

     

       12
       12
        
         cfgFmt = pkgs.formats.ini { };

     
···

       53
       53
        
             package = mkOption {

     

       54
       54
        
               type = types.package;

     

       55
       55
        
               default = pkgs.bluez;

     

       56
       56
       -
               defaultText = "pkgs.bluez";

     

       57
       57
       -
               example = "pkgs.bluezFull";

     

       56
       56
       +
               defaultText = literalExpression "pkgs.bluez";

     

       57
       57
       +
               example = literalExpression "pkgs.bluezFull";

     

       58
       58
        
               description = ''

     

       59
       59
        
                 Which BlueZ package to use.

     

       60
       60

+1 -1

nixos/modules/services/hardware/freefall.nix

···

       21
       21
        
           package = mkOption {

     

       22
       22
        
             type = types.package;

     

       23
       23
        
             default = pkgs.freefall;

     

       24
       24
       -
             defaultText = "pkgs.freefall";

     

       24
       24
       +
             defaultText = literalExpression "pkgs.freefall";

     

       25
       25
        
             description = ''

     

       26
       26
        
               freefall derivation to use.

     

       27
       27
        
             '';

+2 -1

nixos/modules/services/hardware/fwupd.nix

···

       80
       80
        
             extraTrustedKeys = mkOption {

     

       81
       81
        
               type = types.listOf types.path;

     

       82
       82
        
               default = [];

     

       83
       83
       -
               example = literalExample "[ /etc/nixos/fwupd/myfirmware.pem ]";

     

       83
       83
       +
               example = literalExpression "[ /etc/nixos/fwupd/myfirmware.pem ]";

     

       84
       84
        
               description = ''

     

       85
       85
        
                 Installing a public key allows firmware signed with a matching private key to be recognized as trusted, which may require less authentication to install than for untrusted files. By default trusted firmware can be upgraded (but not downgraded) without the user or administrator password. Only very few keys are installed by default.

     

       86
       86
        
               '';

     
···

       98
       98
        
             package = mkOption {

     

       99
       99
        
               type = types.package;

     

       100
       100
        
               default = pkgs.fwupd;

     

       101
       101
       +
               defaultText = literalExpression "pkgs.fwupd";

     

       101
       102
        
               description = ''

     

       102
       103
        
                 Which fwupd package to use.

     

       103
       104
        
               '';

+1

nixos/modules/services/hardware/interception-tools.nix

···

       15
       15
        
           plugins = mkOption {

     

       16
       16
        
             type = types.listOf types.package;

     

       17
       17
        
             default = [ pkgs.interception-tools-plugins.caps2esc ];

     

       18
       18
       +
             defaultText = literalExpression "[ pkgs.interception-tools-plugins.caps2esc ]";

     

       18
       19
        
             description = ''

     

       19
       20
        
               A list of interception tools plugins that will be made available to use

     

       20
       21
        
               inside the udevmon configuration.

+2 -2

nixos/modules/services/hardware/pcscd.nix

···

       21
       21
        
           plugins = mkOption {

     

       22
       22
        
             type = types.listOf types.package;

     

       23
       23
        
             default = [ pkgs.ccid ];

     

       24
       24
       -
             defaultText = "[ pkgs.ccid ]";

     

       25
       25
       -
             example = literalExample "[ pkgs.pcsc-cyberjack ]";

     

       24
       24
       +
             defaultText = literalExpression "[ pkgs.ccid ]";

     

       25
       25
       +
             example = literalExpression "[ pkgs.pcsc-cyberjack ]";

     

       26
       26
        
             description = "Plugin packages to be used for PCSC-Lite.";

     

       27
       27
        
           };

     

       28
       28

+2 -1

nixos/modules/services/hardware/sane.nix

···

       73
       73
        
                 The example contains the package for HP scanners.

     

       74
       74
        
               </para></note>

     

       75
       75
        
             '';

     

       76
       76
       -
             example = literalExample "[ pkgs.hplipWithPlugin ]";

     

       76
       76
       +
             example = literalExpression "[ pkgs.hplipWithPlugin ]";

     

       77
       77
        
           };

     

       78
       78
        
       

     

       79
       79
        
           hardware.sane.disabledDefaultBackends = mkOption {

     
···

       115
       115
        
           hardware.sane.drivers.scanSnap.package = mkOption {

     

       116
       116
        
             type = types.package;

     

       117
       117
        
             default = pkgs.sane-drivers.epjitsu;

     

       118
       118
       +
             defaultText = literalExpression "pkgs.sane-drivers.epjitsu";

     

       118
       119
        
             description = ''

     

       119
       120
        
               Epjitsu driver package to use. Useful if you want to extract the driver files yourself.

     

       120
       121

+4 -4

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

···

       20
       20
        
                 the name of attribute will be used.

     

       21
       21
        
               '';

     

       22
       22
        
       

     

       23
       23
       -
               example = literalExample "office1";

     

       23
       23
       +
               example = "office1";

     

       24
       24
        
             };

     

       25
       25
        
       

     

       26
       26
        
             model = mkOption {

     
···

       29
       29
        
                 The model of the network device.

     

       30
       30
        
               '';

     

       31
       31
        
       

     

       32
       32
       -
               example = literalExample "MFC-7860DW";

     

       32
       32
       +
               example = "MFC-7860DW";

     

       33
       33
        
             };

     

       34
       34
        
       

     

       35
       35
        
             ip = mkOption {

     
···

       40
       40
        
                 provide a nodename.

     

       41
       41
        
               '';

     

       42
       42
        
       

     

       43
       43
       -
               example = literalExample "192.168.1.2";

     

       43
       43
       +
               example = "192.168.1.2";

     

       44
       44
        
             };

     

       45
       45
        
       

     

       46
       46
        
             nodename = mkOption {

     
···

       51
       51
        
                 provide an ip.

     

       52
       52
        
               '';

     

       53
       53
        
       

     

       54
       54
       -
               example = literalExample "BRW0080927AFBCE";

     

       54
       54
       +
               example = "BRW0080927AFBCE";

     

       55
       55
        
             };

     

       56
       56
        
       

     

       57
       57
        
           };

+4 -4

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

···

       20
       20
        
                 the name of attribute will be used.

     

       21
       21
        
               '';

     

       22
       22
        
       

     

       23
       23
       -
               example = literalExample "office1";

     

       23
       23
       +
               example = "office1";

     

       24
       24
        
             };

     

       25
       25
        
       

     

       26
       26
        
             model = mkOption {

     
···

       29
       29
        
                 The model of the network device.

     

       30
       30
        
               '';

     

       31
       31
        
       

     

       32
       32
       -
               example = literalExample "ADS-1200";

     

       32
       32
       +
               example = "ADS-1200";

     

       33
       33
        
             };

     

       34
       34
        
       

     

       35
       35
        
             ip = mkOption {

     
···

       40
       40
        
                 provide a nodename.

     

       41
       41
        
               '';

     

       42
       42
        
       

     

       43
       43
       -
               example = literalExample "192.168.1.2";

     

       43
       43
       +
               example = "192.168.1.2";

     

       44
       44
        
             };

     

       45
       45
        
       

     

       46
       46
        
             nodename = mkOption {

     
···

       51
       51
        
                 provide an ip.

     

       52
       52
        
               '';

     

       53
       53
        
       

     

       54
       54
       -
               example = literalExample "BRW0080927AFBCE";

     

       54
       54
       +
               example = "BRW0080927AFBCE";

     

       55
       55
        
             };

     

       56
       56
        
       

     

       57
       57
        
           };

+1 -1

nixos/modules/services/hardware/thermald.nix

···

       27
       27
        
             package = mkOption {

     

       28
       28
        
               type = types.package;

     

       29
       29
        
               default = pkgs.thermald;

     

       30
       30
       -
               defaultText = "pkgs.thermald";

     

       30
       30
       +
               defaultText = literalExpression "pkgs.thermald";

     

       31
       31
        
               description = "Which thermald package to use.";

     

       32
       32
        
             };

     

       33
       33
        
           };

+1 -1

nixos/modules/services/hardware/triggerhappy.nix

···

       69
       69
        
             bindings = mkOption {

     

       70
       70
        
               type = types.listOf (types.submodule bindingCfg);

     

       71
       71
        
               default = [];

     

       72
       72
       -
               example = lib.literalExample ''

     

       72
       72
       +
               example = lib.literalExpression ''

     

       73
       73
        
                 [ { keys = ["PLAYPAUSE"];  cmd = "''${pkgs.mpc_cli}/bin/mpc -q toggle"; } ]

     

       74
       74
        
               '';

     

       75
       75
        
               description = ''

+1 -1

nixos/modules/services/hardware/undervolt.nix

···

       50
       50
        
           package = mkOption {

     

       51
       51
        
             type = types.package;

     

       52
       52
        
             default = pkgs.undervolt;

     

       53
       53
       -
             defaultText = "pkgs.undervolt";

     

       53
       53
       +
             defaultText = literalExpression "pkgs.undervolt";

     

       54
       54
        
             description = ''

     

       55
       55
        
               undervolt derivation to use.

     

       56
       56
        
             '';

+1 -2

nixos/modules/services/hardware/upower.nix

···

       30
       30
        
             package = mkOption {

     

       31
       31
        
               type = types.package;

     

       32
       32
        
               default = pkgs.upower;

     

       33
       33
       -
               defaultText = "pkgs.upower";

     

       34
       34
       -
               example = lib.literalExample "pkgs.upower";

     

       33
       33
       +
               defaultText = literalExpression "pkgs.upower";

     

       35
       34
        
               description = ''

     

       36
       35
        
                 Which upower package to use.

     

       37
       36
        
               '';

+2 -2

nixos/modules/services/hardware/vdr.nix

···

       17
       17
        
             package = mkOption {

     

       18
       18
        
               type = types.package;

     

       19
       19
        
               default = pkgs.vdr;

     

       20
       20
       -
               defaultText = "pkgs.vdr";

     

       21
       21
       -
               example = literalExample "pkgs.wrapVdr.override { plugins = with pkgs.vdrPlugins; [ hello ]; }";

     

       20
       20
       +
               defaultText = literalExpression "pkgs.vdr";

     

       21
       21
       +
               example = literalExpression "pkgs.wrapVdr.override { plugins = with pkgs.vdrPlugins; [ hello ]; }";

     

       22
       22
        
               description = "Package to use.";

     

       23
       23
        
             };

     

       24
       24

+1

nixos/modules/services/logging/SystemdJournal2Gelf.nix

···

       36
       36
        
             package = mkOption {

     

       37
       37
        
               type = types.package;

     

       38
       38
        
               default = pkgs.systemd-journal2gelf;

     

       39
       39
       +
               defaultText = literalExpression "pkgs.systemd-journal2gelf";

     

       39
       40
        
               description = ''

     

       40
       41
        
                 SystemdJournal2Gelf package to use.

     

       41
       42
        
               '';

+4 -4

nixos/modules/services/logging/awstats.nix

···

       51
       51
        
             hostAliases = mkOption {

     

       52
       52
        
               type = types.listOf types.str;

     

       53
       53
        
               default = [];

     

       54
       54
       -
               example = "[ \"www.example.org\" ]";

     

       54
       54
       +
               example = [ "www.example.org" ];

     

       55
       55
        
               description = ''

     

       56
       56
        
                 List of aliases the site has.

     

       57
       57
        
               '';

     
···

       60
       60
        
             extraConfig = mkOption {

     

       61
       61
        
               type = types.attrsOf types.str;

     

       62
       62
        
               default = {};

     

       63
       63
       -
               example = literalExample ''

     

       63
       63
       +
               example = literalExpression ''

     

       64
       64
        
                 {

     

       65
       65
        
                   "ValidHTTPCodes" = "404";

     

       66
       66
        
                 }

     

       67
       67
        
               '';

     

       68
       68
       -
               description = "Extra configuration to be appendend to awstats.\${name}.conf.";

     

       68
       68
       +
               description = "Extra configuration to be appended to awstats.\${name}.conf.";

     

       69
       69
        
             };

     

       70
       70
        
       

     

       71
       71
        
             webService = {

     
···

       106
       106
        
           configs = mkOption {

     

       107
       107
        
             type = types.attrsOf (types.submodule configOpts);

     

       108
       108
        
             default = {};

     

       109
       109
       -
             example = literalExample ''

     

       109
       109
       +
             example = literalExpression ''

     

       110
       110
        
               {

     

       111
       111
        
                 "mysite" = {

     

       112
       112
        
                   domain = "example.com";

+1 -1

nixos/modules/services/logging/fluentd.nix

···

       27
       27
        
             package = mkOption {

     

       28
       28
        
               type = types.path;

     

       29
       29
        
               default = pkgs.fluentd;

     

       30
       30
       -
               defaultText = "pkgs.fluentd";

     

       30
       30
       +
               defaultText = literalExpression "pkgs.fluentd";

     

       31
       31
        
               description = "The fluentd package to use.";

     

       32
       32
        
             };

     

       33
       33

+2 -3

nixos/modules/services/logging/graylog.nix

···

       38
       38
        
             package = mkOption {

     

       39
       39
        
               type = types.package;

     

       40
       40
        
               default = pkgs.graylog;

     

       41
       41
       -
               defaultText = "pkgs.graylog";

     

       41
       41
       +
               defaultText = literalExpression "pkgs.graylog";

     

       42
       42
        
               description = "Graylog package to use.";

     

       43
       43
        
             };

     

       44
       44
        
       

     

       45
       45
        
             user = mkOption {

     

       46
       46
        
               type = types.str;

     

       47
       47
        
               default = "graylog";

     

       48
       48
       -
               example = literalExample "graylog";

     

       49
       48
        
               description = "User account under which graylog runs";

     

       50
       49
        
             };

     

       51
       50
        
       

     
···

       90
       89
        
       

     

       91
       90
        
             elasticsearchHosts = mkOption {

     

       92
       91
        
               type = types.listOf types.str;

     

       93
       93
       -
               example = literalExample ''[ "http://node1:9200" "http://user:password@node2:19200" ]'';

     

       92
       92
       +
               example = literalExpression ''[ "http://node1:9200" "http://user:password@node2:19200" ]'';

     

       94
       93
        
               description = "List of valid URIs of the http ports of your elastic nodes. If one or more of your elasticsearch hosts require authentication, include the credentials in each node URI that requires authentication";

     

       95
       94
        
             };

     

       96
       95

+2 -2

nixos/modules/services/logging/journalbeat.nix

···

       27
       27
        
             package = mkOption {

     

       28
       28
        
               type = types.package;

     

       29
       29
        
               default = pkgs.journalbeat;

     

       30
       30
       -
               defaultText = "pkgs.journalbeat";

     

       31
       31
       -
               example = literalExample "pkgs.journalbeat7";

     

       30
       30
       +
               defaultText = literalExpression "pkgs.journalbeat";

     

       31
       31
       +
               example = literalExpression "pkgs.journalbeat7";

     

       32
       32
        
               description = ''

     

       33
       33
        
                 The journalbeat package to use

     

       34
       34
        
               '';

+1 -1

nixos/modules/services/logging/logcheck.nix

···

       172
       172
        
       

     

       173
       173
        
             extraRulesDirs = mkOption {

     

       174
       174
        
               default = [];

     

       175
       175
       -
               example = "/etc/logcheck";

     

       175
       175
       +
               example = [ "/etc/logcheck" ];

     

       176
       176
        
               type = types.listOf types.path;

     

       177
       177
        
               description = ''

     

       178
       178
        
                 Directories with extra rules.

+1 -1

nixos/modules/services/logging/logrotate.nix

···

       111
       111
        
                 can be controlled by the <link linkend="opt-services.logrotate.paths._name_.priority">priority</link> option

     

       112
       112
        
                 using the same semantics as `lib.mkOrder`. Smaller values have a greater priority.

     

       113
       113
        
               '';

     

       114
       114
       -
               example = literalExample ''

     

       114
       114
       +
               example = literalExpression ''

     

       115
       115
        
                 {

     

       116
       116
        
                   httpd = {

     

       117
       117
        
                     path = "/var/log/httpd/*.log";

+10 -9

nixos/modules/services/logging/logstash.nix

···

       53
       53
        
             package = mkOption {

     

       54
       54
        
               type = types.package;

     

       55
       55
        
               default = pkgs.logstash;

     

       56
       56
       -
               defaultText = "pkgs.logstash";

     

       57
       57
       -
               example = literalExample "pkgs.logstash";

     

       56
       56
       +
               defaultText = literalExpression "pkgs.logstash";

     

       58
       57
        
               description = "Logstash package to use.";

     

       59
       58
        
             };

     

       60
       59
        
       

     

       61
       60
        
             plugins = mkOption {

     

       62
       61
        
               type = types.listOf types.path;

     

       63
       62
        
               default = [ ];

     

       64
       64
       -
               example = literalExample "[ pkgs.logstash-contrib ]";

     

       63
       63
       +
               example = literalExpression "[ pkgs.logstash-contrib ]";

     

       65
       64
        
               description = "The paths to find other logstash plugins in.";

     

       66
       65
        
             };

     

       67
       66
        
       

     
···

       102
       101
        
               type = types.lines;

     

       103
       102
        
               default = "generator { }";

     

       104
       103
        
               description = "Logstash input configuration.";

     

       105
       105
       -
               example = ''

     

       106
       106
       -
                 # Read from journal

     

       107
       107
       -
                 pipe {

     

       108
       108
       -
                   command => "''${pkgs.systemd}/bin/journalctl -f -o json"

     

       109
       109
       -
                   type => "syslog" codec => json {}

     

       110
       110
       -
                 }

     

       104
       104
       +
               example = literalExpression ''

     

       105
       105
       +
                 '''

     

       106
       106
       +
                   # Read from journal

     

       107
       107
       +
                   pipe {

     

       108
       108
       +
                     command => "''${pkgs.systemd}/bin/journalctl -f -o json"

     

       109
       109
       +
                     type => "syslog" codec => json {}

     

       110
       110
       +
                   }

     

       111
       111
       +
                 '''

     

       111
       112
        
               '';

     

       112
       113
        
             };

     

       113
       114

+2 -2

nixos/modules/services/logging/syslog-ng.nix

···

       43
       43
        
             package = mkOption {

     

       44
       44
        
               type = types.package;

     

       45
       45
        
               default = pkgs.syslogng;

     

       46
       46
       -
               defaultText = "pkgs.syslogng";

     

       46
       46
       +
               defaultText = literalExpression "pkgs.syslogng";

     

       47
       47
        
               description = ''

     

       48
       48
        
                 The package providing syslog-ng binaries.

     

       49
       49
        
               '';

     
···

       51
       51
        
             extraModulePaths = mkOption {

     

       52
       52
        
               type = types.listOf types.str;

     

       53
       53
        
               default = [];

     

       54
       54
       -
               example = literalExample ''

     

       54
       54
       +
               example = literalExpression ''

     

       55
       55
        
                 [ "''${pkgs.syslogng_incubator}/lib/syslog-ng" ]

     

       56
       56
        
               '';

     

       57
       57
        
               description = ''

+1 -1

nixos/modules/services/mail/davmail.nix

···

       42
       42
        
                 and <link xlink:href="http://davmail.sourceforge.net/advanced.html"/>

     

       43
       43
        
                 for details on supported values.

     

       44
       44
        
               '';

     

       45
       45
       -
               example = literalExample ''

     

       45
       45
       +
               example = literalExpression ''

     

       46
       46
        
                 {

     

       47
       47
        
                   davmail.allowRemote = true;

     

       48
       48
        
                   davmail.imapPort = 55555;

+2 -2

nixos/modules/services/mail/dovecot.nix

···

       289
       289
        
           modules = mkOption {

     

       290
       290
        
             type = types.listOf types.package;

     

       291
       291
        
             default = [];

     

       292
       292
       -
             example = literalExample "[ pkgs.dovecot_pigeonhole ]";

     

       292
       292
       +
             example = literalExpression "[ pkgs.dovecot_pigeonhole ]";

     

       293
       293
        
             description = ''

     

       294
       294
        
               Symlinks the contents of lib/dovecot of every given package into

     

       295
       295
        
               /etc/dovecot/modules. This will make the given modules available

     
···

       339
       339
        
               (list: listToAttrs (map (entry: { name = entry.name; value = removeAttrs entry ["name"]; }) list))

     

       340
       340
        
               (attrsOf (submodule mailboxes));

     

       341
       341
        
             default = {};

     

       342
       342
       -
             example = literalExample ''

     

       342
       342
       +
             example = literalExpression ''

     

       343
       343
        
               {

     

       344
       344
        
                 Spam = { specialUse = "Junk"; auto = "create"; };

     

       345
       345
        
               }

+2 -2

nixos/modules/services/mail/exim.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         inherit (lib) mkIf mkOption singleton types;

     

       4
       4
       +
         inherit (lib) literalExpression mkIf mkOption singleton types;

     

       5
       5
        
         inherit (pkgs) coreutils;

     

       6
       6
        
         cfg = config.services.exim;

     

       7
       7
        
       in

     
···

       60
       60
        
             package = mkOption {

     

       61
       61
        
               type = types.package;

     

       62
       62
        
               default = pkgs.exim;

     

       63
       63
       -
               defaultText = "pkgs.exim";

     

       63
       63
       +
               defaultText = literalExpression "pkgs.exim";

     

       64
       64
        
               description = ''

     

       65
       65
        
                 The Exim derivation to use.

     

       66
       66
        
                 This can be used to enable features such as LDAP or PAM support.

+2 -2

nixos/modules/services/mail/mailman.nix

···

       87
       87
        
             package = mkOption {

     

       88
       88
        
               type = types.package;

     

       89
       89
        
               default = pkgs.mailman;

     

       90
       90
       -
               defaultText = "pkgs.mailman";

     

       91
       91
       -
               example = literalExample "pkgs.mailman.override { archivers = []; }";

     

       90
       90
       +
               defaultText = literalExpression "pkgs.mailman";

     

       91
       91
       +
               example = literalExpression "pkgs.mailman.override { archivers = []; }";

     

       92
       92
        
               description = "Mailman package to use";

     

       93
       93
        
             };

     

       94
       94

+2 -2

nixos/modules/services/mail/offlineimap.nix

···

       25
       25
        
           package = mkOption {

     

       26
       26
        
             type = types.package;

     

       27
       27
        
             default = pkgs.offlineimap;

     

       28
       28
       -
             defaultText = "pkgs.offlineimap";

     

       28
       28
       +
             defaultText = literalExpression "pkgs.offlineimap";

     

       29
       29
        
             description = "Offlineimap derivation to use.";

     

       30
       30
        
           };

     

       31
       31
        
       

     

       32
       32
        
           path = mkOption {

     

       33
       33
        
             type = types.listOf types.path;

     

       34
       34
        
             default = [];

     

       35
       35
       -
             example = literalExample "[ pkgs.pass pkgs.bash pkgs.notmuch ]";

     

       35
       35
       +
             example = literalExpression "[ pkgs.pass pkgs.bash pkgs.notmuch ]";

     

       36
       36
        
             description = "List of derivations to put in Offlineimap's path.";

     

       37
       37
        
           };

     

       38
       38

+1 -1

nixos/modules/services/mail/opensmtpd.nix

···

       34
       34
        
             package = mkOption {

     

       35
       35
        
               type = types.package;

     

       36
       36
        
               default = pkgs.opensmtpd;

     

       37
       37
       -
               defaultText = "pkgs.opensmtpd";

     

       37
       37
       +
               defaultText = literalExpression "pkgs.opensmtpd";

     

       38
       38
        
               description = "The OpenSMTPD package to use.";

     

       39
       39
        
             };

     

       40
       40

+1

nixos/modules/services/mail/postfix.nix

···

       505
       505
        
             tlsTrustedAuthorities = mkOption {

     

       506
       506
        
               type = types.str;

     

       507
       507
        
               default = "${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt";

     

       508
       508
       +
               defaultText = literalExpression ''"''${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt"'';

     

       508
       509
        
               description = ''

     

       509
       510
        
                 File containing trusted certification authorities (CA) to verify certificates of mailservers contacted for mail delivery. This basically sets smtp_tls_CAfile and enables opportunistic tls. Defaults to NixOS trusted certification authorities.

     

       510
       511
        
               '';

+3 -2

nixos/modules/services/mail/roundcube.nix

···

       32
       32
        
           package = mkOption {

     

       33
       33
        
             type = types.package;

     

       34
       34
        
             default = pkgs.roundcube;

     

       35
       35
       +
             defaultText = literalExpression "pkgs.roundcube";

     

       35
       36
        
       

     

       36
       36
       -
             example = literalExample ''

     

       37
       37
       +
             example = literalExpression ''

     

       37
       38
        
               roundcube.withPlugins (plugins: [ plugins.persistent_login ])

     

       38
       39
        
             '';

     

       39
       40
        
       

     
···

       89
       90
        
           dicts = mkOption {

     

       90
       91
        
             type = types.listOf types.package;

     

       91
       92
        
             default = [];

     

       92
       92
       -
             example = literalExample "with pkgs.aspellDicts; [ en fr de ]";

     

       93
       93
       +
             example = literalExpression "with pkgs.aspellDicts; [ en fr de ]";

     

       93
       94
        
             description = ''

     

       94
       95
        
               List of aspell dictionnaries for spell checking. If empty, spell checking is disabled.

     

       95
       96
        
             '';

+3 -7

nixos/modules/services/mail/rspamd.nix

···

       240
       240
        
               description = ''

     

       241
       241
        
                 Local configuration files, written into <filename>/etc/rspamd/local.d/{name}</filename>.

     

       242
       242
        
               '';

     

       243
       243
       -
               example = literalExample ''

     

       243
       243
       +
               example = literalExpression ''

     

       244
       244
        
                 { "redis.conf".source = "/nix/store/.../etc/dir/redis.conf";

     

       245
       245
        
                   "arc.conf".text = "allow_envfrom_empty = true;";

     

       246
       246
        
                 }

     
···

       253
       253
        
               description = ''

     

       254
       254
        
                 Overridden configuration files, written into <filename>/etc/rspamd/override.d/{name}</filename>.

     

       255
       255
        
               '';

     

       256
       256
       -
               example = literalExample ''

     

       256
       256
       +
               example = literalExpression ''

     

       257
       257
        
                 { "redis.conf".source = "/nix/store/.../etc/dir/redis.conf";

     

       258
       258
        
                   "arc.conf".text = "allow_envfrom_empty = true;";

     

       259
       259
        
                 }

     
···

       278
       278
        
                 normal = {};

     

       279
       279
        
                 controller = {};

     

       280
       280
        
               };

     

       281
       281
       -
               example = literalExample ''

     

       281
       281
       +
               example = literalExpression ''

     

       282
       282
        
                 {

     

       283
       283
        
                   normal = {

     

       284
       284
        
                     includes = [ "$CONFDIR/worker-normal.inc" ];

     
···

       335
       335
        
                   Addon to postfix configuration

     

       336
       336
        
                 '';

     

       337
       337
        
                 default = {

     

       338
       338
       -
                   smtpd_milters = ["unix:/run/rspamd/rspamd-milter.sock"];

     

       339
       339
       -
                   non_smtpd_milters = ["unix:/run/rspamd/rspamd-milter.sock"];

     

       340
       340
       -
                 };

     

       341
       341
       -
                 example = {

     

       342
       338
        
                   smtpd_milters = ["unix:/run/rspamd/rspamd-milter.sock"];

     

       343
       339
        
                   non_smtpd_milters = ["unix:/run/rspamd/rspamd-milter.sock"];

     

       344
       340
        
                 };

+4 -4

nixos/modules/services/mail/sympa.nix

···

       153
       153
        
               Email domains handled by this instance. There have

     

       154
       154
        
               to be MX records for keys of this attribute set.

     

       155
       155
        
             '';

     

       156
       156
       -
             example = literalExample ''

     

       156
       156
       +
             example = literalExpression ''

     

       157
       157
        
               {

     

       158
       158
        
                 "lists.example.org" = {

     

       159
       159
        
                   webHost = "lists.example.org";

     
···

       200
       200
        
             name = mkOption {

     

       201
       201
        
               type = str;

     

       202
       202
        
               default = if cfg.database.type == "SQLite" then "${dataDir}/sympa.sqlite" else "sympa";

     

       203
       203
       -
               defaultText = ''if database.type == "SQLite" then "${dataDir}/sympa.sqlite" else "sympa"'';

     

       203
       203
       +
               defaultText = literalExpression ''if database.type == "SQLite" then "${dataDir}/sympa.sqlite" else "sympa"'';

     

       204
       204
        
               description = ''

     

       205
       205
        
                 Database name. When using SQLite this must be an absolute

     

       206
       206
        
                 path to the database file.

     
···

       279
       279
        
           settings = mkOption {

     

       280
       280
        
             type = attrsOf (oneOf [ str int bool ]);

     

       281
       281
        
             default = {};

     

       282
       282
       -
             example = literalExample ''

     

       282
       282
       +
             example = literalExpression ''

     

       283
       283
        
               {

     

       284
       284
        
                 default_home = "lists";

     

       285
       285
        
                 viewlogs_page_size = 50;

     
···

       314
       314
        
               config.source = mkIf (config.text != null) (mkDefault (pkgs.writeText "sympa-${baseNameOf name}" config.text));

     

       315
       315
        
             }));

     

       316
       316
        
             default = {};

     

       317
       317
       -
             example = literalExample ''

     

       317
       317
       +
             example = literalExpression ''

     

       318
       318
        
               {

     

       319
       319
        
                 "list_data/lists.example.org/help" = {

     

       320
       320
        
                   text = "subject This list provides help to users";

+3 -3

nixos/modules/services/misc/airsonic.nix

···

       74
       74
        
             transcoders = mkOption {

     

       75
       75
        
               type = types.listOf types.path;

     

       76
       76
        
               default = [ "${pkgs.ffmpeg.bin}/bin/ffmpeg" ];

     

       77
       77
       -
               defaultText= [ "\${pkgs.ffmpeg.bin}/bin/ffmpeg" ];

     

       77
       77
       +
               defaultText = literalExpression ''[ "''${pkgs.ffmpeg.bin}/bin/ffmpeg" ]'';

     

       78
       78
        
               description = ''

     

       79
       79
        
                 List of paths to transcoder executables that should be accessible

     

       80
       80
        
                 from Airsonic. Symlinks will be created to each executable inside

     
···

       85
       85
        
             jre = mkOption {

     

       86
       86
        
               type = types.package;

     

       87
       87
        
               default = pkgs.jre8;

     

       88
       88
       -
               defaultText = literalExample "pkgs.jre8";

     

       88
       88
       +
               defaultText = literalExpression "pkgs.jre8";

     

       89
       89
        
               description = ''

     

       90
       90
        
                 JRE package to use.

     

       91
       91
        
       

     
···

       97
       97
        
             war = mkOption {

     

       98
       98
        
               type = types.path;

     

       99
       99
        
               default = "${pkgs.airsonic}/webapps/airsonic.war";

     

       100
       100
       -
               defaultText = "\${pkgs.airsonic}/webapps/airsonic.war";

     

       100
       100
       +
               defaultText = literalExpression ''"''${pkgs.airsonic}/webapps/airsonic.war"'';

     

       101
       101
        
               description = "Airsonic war file to use.";

     

       102
       102
        
             };

     

       103
       103

+1 -1

nixos/modules/services/misc/ankisyncd.nix

···

       33
       33
        
             package = mkOption {

     

       34
       34
        
               type = types.package;

     

       35
       35
        
               default = pkgs.ankisyncd;

     

       36
       36
       -
               defaultText = literalExample "pkgs.ankisyncd";

     

       36
       36
       +
               defaultText = literalExpression "pkgs.ankisyncd";

     

       37
       37
        
               description = "The package to use for the ankisyncd command.";

     

       38
       38
        
             };

     

       39
       39

+2 -2

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

···

       102
       102
        
           package = mkOption {

     

       103
       103
        
             description = "The kafka package to use";

     

       104
       104
        
             default = pkgs.apacheKafka;

     

       105
       105
       -
             defaultText = "pkgs.apacheKafka";

     

       105
       105
       +
             defaultText = literalExpression "pkgs.apacheKafka";

     

       106
       106
        
             type = types.package;

     

       107
       107
        
           };

     

       108
       108
        
       

     

       109
       109
        
           jre = mkOption {

     

       110
       110
        
             description = "The JRE with which to run Kafka";

     

       111
       111
        
             default = cfg.package.passthru.jre;

     

       112
       112
       -
             defaultText = "pkgs.apacheKafka.passthru.jre";

     

       112
       112
       +
             defaultText = literalExpression "pkgs.apacheKafka.passthru.jre";

     

       113
       113
        
             type = types.package;

     

       114
       114
        
           };

     

       115
       115

+1 -1

nixos/modules/services/misc/autofs.nix

···

       29
       29
        
       

     

       30
       30
        
             autoMaster = mkOption {

     

       31
       31
        
               type = types.str;

     

       32
       32
       -
               example = literalExample ''

     

       32
       32
       +
               example = literalExpression ''

     

       33
       33
        
                 let

     

       34
       34
        
                   mapConf = pkgs.writeText "auto" '''

     

       35
       35
        
                    kernel    -ro,soft,intr       ftp.kernel.org:/pub/linux

+2 -2

nixos/modules/services/misc/bees.nix

···

       61
       61
        
             description = ''

     

       62
       62
        
               Extra command-line options passed to the daemon. See upstream bees documentation.

     

       63
       63
        
             '';

     

       64
       64
       -
             example = literalExample ''

     

       64
       64
       +
             example = literalExpression ''

     

       65
       65
        
               [ "--thread-count" "4" ]

     

       66
       66
        
             '';

     

       67
       67
        
           };

     
···

       75
       75
        
             type = with types; attrsOf (submodule fsOptions);

     

       76
       76
        
             description = "BTRFS filesystems to run block-level deduplication on.";

     

       77
       77
        
             default = { };

     

       78
       78
       -
             example = literalExample ''

     

       78
       78
       +
             example = literalExpression ''

     

       79
       79
        
               {

     

       80
       80
        
                 root = {

     

       81
       81
        
                   spec = "LABEL=root";

+1 -1

nixos/modules/services/misc/cgminer.nix

···

       35
       35
        
       

     

       36
       36
        
             package = mkOption {

     

       37
       37
        
               default = pkgs.cgminer;

     

       38
       38
       -
               defaultText = "pkgs.cgminer";

     

       38
       38
       +
               defaultText = literalExpression "pkgs.cgminer";

     

       39
       39
        
               description = "Which cgminer derivation to use.";

     

       40
       40
        
               type = types.package;

     

       41
       41
        
             };

+1 -1

nixos/modules/services/misc/clipcat.nix

···

       12
       12
        
           package = mkOption {

     

       13
       13
        
             type = types.package;

     

       14
       14
        
             default = pkgs.clipcat;

     

       15
       15
       -
             defaultText = "pkgs.clipcat";

     

       15
       15
       +
             defaultText = literalExpression "pkgs.clipcat";

     

       16
       16
        
             description = "clipcat derivation to use.";

     

       17
       17
        
           };

     

       18
       18
        
         };

+1 -1

nixos/modules/services/misc/clipmenu.nix

···

       12
       12
        
           package = mkOption {

     

       13
       13
        
             type = types.package;

     

       14
       14
        
             default = pkgs.clipmenu;

     

       15
       15
       -
             defaultText = "pkgs.clipmenu";

     

       15
       15
       +
             defaultText = literalExpression "pkgs.clipmenu";

     

       16
       16
        
             description = "clipmenu derivation to use.";

     

       17
       17
        
           };

     

       18
       18
        
         };

+1 -1

nixos/modules/services/misc/confd.nix

···

       64
       64
        
           package = mkOption {

     

       65
       65
        
             description = "Confd package to use.";

     

       66
       66
        
             default = pkgs.confd;

     

       67
       67
       -
             defaultText = "pkgs.confd";

     

       67
       67
       +
             defaultText = literalExpression "pkgs.confd";

     

       68
       68
        
             type = types.package;

     

       69
       69
        
           };

     

       70
       70
        
         };

+2 -2

nixos/modules/services/misc/dictd.nix

···

       25
       25
        
             DBs = mkOption {

     

       26
       26
        
               type = types.listOf types.package;

     

       27
       27
        
               default = with pkgs.dictdDBs; [ wiktionary wordnet ];

     

       28
       28
       -
               defaultText = "with pkgs.dictdDBs; [ wiktionary wordnet ]";

     

       29
       29
       -
               example = literalExample "[ pkgs.dictdDBs.nld2eng ]";

     

       28
       28
       +
               defaultText = literalExpression "with pkgs.dictdDBs; [ wiktionary wordnet ]";

     

       29
       29
       +
               example = literalExpression "[ pkgs.dictdDBs.nld2eng ]";

     

       30
       30
        
               description = "List of databases to make available.";

     

       31
       31
        
             };

     

       32
       32

+1 -2

nixos/modules/services/misc/disnix.nix

···

       31
       31
        
               type = types.path;

     

       32
       32
        
               description = "The Disnix package";

     

       33
       33
        
               default = pkgs.disnix;

     

       34
       34
       -
               defaultText = "pkgs.disnix";

     

       34
       34
       +
               defaultText = literalExpression "pkgs.disnix";

     

       35
       35
        
             };

     

       36
       36
        
       

     

       37
       37
        
             enableProfilePath = mkEnableOption "exposing the Disnix profiles in the system's PATH";

     
···

       39
       39
        
             profiles = mkOption {

     

       40
       40
        
               type = types.listOf types.str;

     

       41
       41
        
               default = [ "default" ];

     

       42
       42
       -
               example = [ "default" ];

     

       43
       42
        
               description = "Names of the Disnix profiles to expose in the system's PATH";

     

       44
       43
        
             };

     

       45
       44
        
           };

+2 -2

nixos/modules/services/misc/dwm-status.nix

···

       27
       27
        
             package = mkOption {

     

       28
       28
        
               type = types.package;

     

       29
       29
        
               default = pkgs.dwm-status;

     

       30
       30
       -
               defaultText = "pkgs.dwm-status";

     

       31
       31
       -
               example = "pkgs.dwm-status.override { enableAlsaUtils = false; }";

     

       30
       30
       +
               defaultText = literalExpression "pkgs.dwm-status";

     

       31
       31
       +
               example = literalExpression "pkgs.dwm-status.override { enableAlsaUtils = false; }";

     

       32
       32
        
               description = ''

     

       33
       33
        
                 Which dwm-status package to use.

     

       34
       34
        
               '';

+1 -1

nixos/modules/services/misc/etcd.nix

···

       123
       123
        
             '';

     

       124
       124
        
             type = types.attrsOf types.str;

     

       125
       125
        
             default = {};

     

       126
       126
       -
             example = literalExample ''

     

       126
       126
       +
             example = literalExpression ''

     

       127
       127
        
               {

     

       128
       128
        
                 "CORS" = "*";

     

       129
       129
        
                 "NAME" = "default-name";

+3 -3

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

···

       97
       97
        
                     static_root = mkOption {

     

       98
       98
        
                       type = types.str;

     

       99
       99
        
                       default = "${cfg.dataDir}/static";

     

       100
       100
       -
                       defaultText = "\${config.services.etebase-server.dataDir}/static";

     

       100
       100
       +
                       defaultText = literalExpression ''"''${config.services.etebase-server.dataDir}/static"'';

     

       101
       101
        
                       description = "The directory for static files.";

     

       102
       102
        
                     };

     

       103
       103
        
                     media_root = mkOption {

     

       104
       104
        
                       type = types.str;

     

       105
       105
        
                       default = "${cfg.dataDir}/media";

     

       106
       106
       -
                       defaultText = "\${config.services.etebase-server.dataDir}/media";

     

       106
       106
       +
                       defaultText = literalExpression ''"''${config.services.etebase-server.dataDir}/media"'';

     

       107
       107
        
                       description = "The media directory.";

     

       108
       108
        
                     };

     

       109
       109
        
                   };

     
···

       126
       126
        
                     name = mkOption {

     

       127
       127
        
                       type = types.str;

     

       128
       128
        
                       default = "${cfg.dataDir}/db.sqlite3";

     

       129
       129
       -
                       defaultText = "\${config.services.etebase-server.dataDir}/db.sqlite3";

     

       129
       129
       +
                       defaultText = literalExpression ''"''${config.services.etebase-server.dataDir}/db.sqlite3"'';

     

       130
       130
        
                       description = "The database name.";

     

       131
       131
        
                     };

     

       132
       132
        
                   };

+1 -1

nixos/modules/services/misc/felix.nix

···

       22
       22
        
             bundles = mkOption {

     

       23
       23
        
               type = types.listOf types.package;

     

       24
       24
        
               default = [ pkgs.felix_remoteshell ];

     

       25
       25
       -
               defaultText = "[ pkgs.felix_remoteshell ]";

     

       25
       25
       +
               defaultText = literalExpression "[ pkgs.felix_remoteshell ]";

     

       26
       26
        
               description = "List of bundles that should be activated on startup";

     

       27
       27
        
             };

     

       28
       28

+4 -5

nixos/modules/services/misc/freeswitch.nix

···

       32
       32
        
             configTemplate = mkOption {

     

       33
       33
        
               type = types.path;

     

       34
       34
        
               default = "${config.services.freeswitch.package}/share/freeswitch/conf/vanilla";

     

       35
       35
       -
               defaultText = literalExample "\${config.services.freeswitch.package}/share/freeswitch/conf/vanilla";

     

       36
       36
       -
               example = literalExample "\${config.services.freeswitch.package}/share/freeswitch/conf/minimal";

     

       35
       35
       +
               defaultText = literalExpression ''"''${config.services.freeswitch.package}/share/freeswitch/conf/vanilla"'';

     

       36
       36
       +
               example = literalExpression ''"''${config.services.freeswitch.package}/share/freeswitch/conf/minimal"'';

     

       37
       37
        
               description = ''

     

       38
       38
        
                 Configuration template to use.

     

       39
       39
        
                 See available templates in <link xlink:href="https://github.com/signalwire/freeswitch/tree/master/conf">FreeSWITCH repository</link>.

     
···

       43
       43
        
             configDir = mkOption {

     

       44
       44
        
               type = with types; attrsOf path;

     

       45
       45
        
               default = { };

     

       46
       46
       -
               example = literalExample ''

     

       46
       46
       +
               example = literalExpression ''

     

       47
       47
        
                 {

     

       48
       48
        
                   "freeswitch.xml" = ./freeswitch.xml;

     

       49
       49
        
                   "dialplan/default.xml" = pkgs.writeText "dialplan-default.xml" '''

     
···

       61
       61
        
             package = mkOption {

     

       62
       62
        
               type = types.package;

     

       63
       63
        
               default = pkgs.freeswitch;

     

       64
       64
       -
               defaultText = literalExample "pkgs.freeswitch";

     

       65
       65
       -
               example = literalExample "pkgs.freeswitch";

     

       64
       64
       +
               defaultText = literalExpression "pkgs.freeswitch";

     

       66
       65
        
               description = ''

     

       67
       66
        
                 FreeSWITCH package.

     

       68
       67
        
               '';

+6 -5

nixos/modules/services/misc/gitea.nix

···

       32
       32
        
             package = mkOption {

     

       33
       33
        
               default = pkgs.gitea;

     

       34
       34
        
               type = types.package;

     

       35
       35
       -
               defaultText = "pkgs.gitea";

     

       35
       35
       +
               defaultText = literalExpression "pkgs.gitea";

     

       36
       36
        
               description = "gitea derivation to use";

     

       37
       37
        
             };

     

       38
       38
        
       

     
···

       122
       122
        
               socket = mkOption {

     

       123
       123
        
                 type = types.nullOr types.path;

     

       124
       124
        
                 default = if (cfg.database.createDatabase && usePostgresql) then "/run/postgresql" else if (cfg.database.createDatabase && useMysql) then "/run/mysqld/mysqld.sock" else null;

     

       125
       125
       -
                 defaultText = "null";

     

       125
       125
       +
                 defaultText = literalExpression "null";

     

       126
       126
        
                 example = "/run/mysqld/mysqld.sock";

     

       127
       127
        
                 description = "Path to the unix socket file to use for authentication.";

     

       128
       128
        
               };

     
···

       255
       255
        
             };

     

       256
       256
        
       

     

       257
       257
        
             staticRootPath = mkOption {

     

       258
       258
       -
               type = types.str;

     

       259
       259
       -
               default = "${gitea.data}";

     

       258
       258
       +
               type = types.either types.str types.path;

     

       259
       259
       +
               default = gitea.data;

     

       260
       260
       +
               defaultText = literalExpression "package.data";

     

       260
       261
        
               example = "/var/lib/gitea/data";

     

       261
       262
        
               description = "Upper level of template and static files path.";

     

       262
       263
        
             };

     
···

       287
       288
        
                 Gitea configuration. Refer to <link xlink:href="https://docs.gitea.io/en-us/config-cheat-sheet/"/>

     

       288
       289
        
                 for details on supported values.

     

       289
       290
        
               '';

     

       290
       290
       -
               example = literalExample ''

     

       291
       291
       +
               example = literalExpression ''

     

       291
       292
        
                 {

     

       292
       293
        
                   "cron.sync_external_users" = {

     

       293
       294
        
                     RUN_AT_START = true;

+26 -26

nixos/modules/services/misc/gitit.nix

···

       36
       36
        
       

     

       37
       37
        
             haskellPackages = mkOption {

     

       38
       38
        
               default = pkgs.haskellPackages;

     

       39
       39
       -
               defaultText = "pkgs.haskellPackages";

     

       40
       40
       -
               example = literalExample "pkgs.haskell.packages.ghc784";

     

       39
       39
       +
               defaultText = literalExpression "pkgs.haskellPackages";

     

       40
       40
       +
               example = literalExpression "pkgs.haskell.packages.ghc784";

     

       41
       41
        
               description = "haskellPackages used to build gitit and plugins.";

     

       42
       42
        
             };

     

       43
       43
        
       

     

       44
       44
        
             extraPackages = mkOption {

     

       45
       45
        
               type = types.functionTo (types.listOf types.package);

     

       46
       46
        
               default = self: [];

     

       47
       47
       -
               example = literalExample ''

     

       47
       47
       +
               example = literalExpression ''

     

       48
       48
        
                 haskellPackages: [

     

       49
       49
        
                   haskellPackages.wreq

     

       50
       50
        
                 ]

     
···

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

     

       666
       666
        
             path = with pkgs; [ curl ]

     

       667
       667
        
                    ++ optional cfg.pdfExport texlive.combined.scheme-basic

     

       668
       668
       -
       	     ++ optional (cfg.repositoryType == "darcs") darcs

     

       669
       669
       -
       	     ++ optional (cfg.repositoryType == "mercurial") mercurial

     

       670
       670
       -
       	     ++ optional (cfg.repositoryType == "git") git;

     

       668
       668
       +
                    ++ optional (cfg.repositoryType == "darcs") darcs

     

       669
       669
       +
                    ++ optional (cfg.repositoryType == "mercurial") mercurial

     

       670
       670
       +
                    ++ optional (cfg.repositoryType == "git") git;

     

       671
       671
        
       

     

       672
       672
        
             preStart = let

     

       673
       673
        
               gm = "gitit@${config.networking.hostName}";

     
···

       684
       684
        
                 fi

     

       685
       685
        
               done

     

       686
       686
        
               cd ${repositoryPath}

     

       687
       687
       -
       	${

     

       688
       688
       -
       	  if repositoryType == "darcs" then

     

       689
       689
       -
       	  ''

     

       690
       690
       -
       	  if [ ! -d _darcs ]

     

       691
       691
       -
       	  then

     

       692
       692
       -
       	    ${pkgs.darcs}/bin/darcs initialize

     

       693
       693
       -
       	    echo "${gm}" > _darcs/prefs/email

     

       694
       694
       -
       	  ''

     

       695
       695
       -
       	  else if repositoryType == "mercurial" then

     

       696
       696
       -
       	  ''

     

       697
       697
       -
       	  if [ ! -d .hg ]

     

       698
       698
       -
       	  then

     

       699
       699
       -
       	    ${pkgs.mercurial}/bin/hg init

     

       700
       700
       -
       	    cat >> .hg/hgrc <<NAMED

     

       687
       687
       +
               ${

     

       688
       688
       +
                 if repositoryType == "darcs" then

     

       689
       689
       +
                 ''

     

       690
       690
       +
                 if [ ! -d _darcs ]

     

       691
       691
       +
                 then

     

       692
       692
       +
                   ${pkgs.darcs}/bin/darcs initialize

     

       693
       693
       +
                   echo "${gm}" > _darcs/prefs/email

     

       694
       694
       +
                 ''

     

       695
       695
       +
                 else if repositoryType == "mercurial" then

     

       696
       696
       +
                 ''

     

       697
       697
       +
                 if [ ! -d .hg ]

     

       698
       698
       +
                 then

     

       699
       699
       +
                   ${pkgs.mercurial}/bin/hg init

     

       700
       700
       +
                   cat >> .hg/hgrc <<NAMED

     

       701
       701
        
       [ui]

     

       702
       702
        
       username = gitit ${gm}

     

       703
       703
        
       NAMED

     

       704
       704
       -
       	  ''

     

       705
       705
       -
       	  else

     

       706
       706
       -
       	  ''

     

       707
       707
       -
       	  if [ ! -d  .git ]

     

       704
       704
       +
                 ''

     

       705
       705
       +
                 else

     

       706
       706
       +
                 ''

     

       707
       707
       +
                 if [ ! -d  .git ]

     

       708
       708
        
                 then

     

       709
       709
        
                   ${pkgs.git}/bin/git init

     

       710
       710
        
                   ${pkgs.git}/bin/git config user.email "${gm}"

     

       711
       711
        
                   ${pkgs.git}/bin/git config user.name "gitit"

     

       712
       712
       -
       	  ''}

     

       712
       712
       +
                 ''}

     

       713
       713
        
                 chown ${uid}:${gid} -R ${repositoryPath}

     

       714
       714
        
                 fi

     

       715
       715
       -
       	cd -

     

       715
       715
       +
               cd -

     

       716
       716
        
             '';

     

       717
       717
        
       

     

       718
       718
        
             serviceConfig = {

+8 -10

nixos/modules/services/misc/gitlab.nix

···

       239
       239
        
             packages.gitlab = mkOption {

     

       240
       240
        
               type = types.package;

     

       241
       241
        
               default = pkgs.gitlab;

     

       242
       242
       -
               defaultText = "pkgs.gitlab";

     

       242
       242
       +
               defaultText = literalExpression "pkgs.gitlab";

     

       243
       243
        
               description = "Reference to the gitlab package";

     

       244
       244
       -
               example = "pkgs.gitlab-ee";

     

       244
       244
       +
               example = literalExpression "pkgs.gitlab-ee";

     

       245
       245
        
             };

     

       246
       246
        
       

     

       247
       247
        
             packages.gitlab-shell = mkOption {

     

       248
       248
        
               type = types.package;

     

       249
       249
        
               default = pkgs.gitlab-shell;

     

       250
       250
       -
               defaultText = "pkgs.gitlab-shell";

     

       250
       250
       +
               defaultText = literalExpression "pkgs.gitlab-shell";

     

       251
       251
        
               description = "Reference to the gitlab-shell package";

     

       252
       252
        
             };

     

       253
       253
        
       

     

       254
       254
        
             packages.gitlab-workhorse = mkOption {

     

       255
       255
        
               type = types.package;

     

       256
       256
        
               default = pkgs.gitlab-workhorse;

     

       257
       257
       -
               defaultText = "pkgs.gitlab-workhorse";

     

       257
       257
       +
               defaultText = literalExpression "pkgs.gitlab-workhorse";

     

       258
       258
        
               description = "Reference to the gitlab-workhorse package";

     

       259
       259
        
             };

     

       260
       260
        
       

     

       261
       261
        
             packages.gitaly = mkOption {

     

       262
       262
        
               type = types.package;

     

       263
       263
        
               default = pkgs.gitaly;

     

       264
       264
       -
               defaultText = "pkgs.gitaly";

     

       264
       264
       +
               defaultText = literalExpression "pkgs.gitaly";

     

       265
       265
        
               description = "Reference to the gitaly package";

     

       266
       266
        
             };

     

       267
       267
        
       

     

       268
       268
        
             packages.pages = mkOption {

     

       269
       269
        
               type = types.package;

     

       270
       270
        
               default = pkgs.gitlab-pages;

     

       271
       271
       -
               defaultText = "pkgs.gitlab-pages";

     

       271
       271
       +
               defaultText = literalExpression "pkgs.gitlab-pages";

     

       272
       272
        
               description = "Reference to the gitlab-pages package";

     

       273
       273
        
             };

     

       274
       274
        
       

     
···

       356
       356
        
             backup.uploadOptions = mkOption {

     

       357
       357
        
               type = types.attrs;

     

       358
       358
        
               default = {};

     

       359
       359
       -
               example = literalExample ''

     

       359
       359
       +
               example = literalExpression ''

     

       360
       360
        
                 {

     

       361
       361
        
                   # Fog storage connection settings, see http://fog.io/storage/

     

       362
       362
        
                   connection = {

     
···

       543
       543
        
               };

     

       544
       544
        
               certFile = mkOption {

     

       545
       545
        
                 type = types.path;

     

       546
       546
       -
                 default = null;

     

       547
       546
        
                 description = "Path to GitLab container registry certificate.";

     

       548
       547
        
               };

     

       549
       548
        
               keyFile = mkOption {

     

       550
       549
        
                 type = types.path;

     

       551
       551
       -
                 default = null;

     

       552
       550
        
                 description = "Path to GitLab container registry certificate-key.";

     

       553
       551
        
               };

     

       554
       552
        
               defaultForProjects = mkOption {

     
···

       858
       856
        
             extraConfig = mkOption {

     

       859
       857
        
               type = types.attrs;

     

       860
       858
        
               default = {};

     

       861
       861
       -
               example = literalExample ''

     

       859
       859
       +
               example = literalExpression ''

     

       862
       860
        
                 {

     

       863
       861
        
                   gitlab = {

     

       864
       862
        
                     default_projects_features = {

+7 -5

nixos/modules/services/misc/gitolite.nix

···

       64
       64
        
             extraGitoliteRc = mkOption {

     

       65
       65
        
               type = types.lines;

     

       66
       66
        
               default = "";

     

       67
       67
       -
               example = literalExample ''

     

       68
       68
       -
                 $RC{UMASK} = 0027;

     

       69
       69
       -
                 $RC{SITE_INFO} = 'This is our private repository host';

     

       70
       70
       -
                 push( @{$RC{ENABLE}}, 'Kindergarten' ); # enable the command/feature

     

       71
       71
       -
                 @{$RC{ENABLE}} = grep { $_ ne 'desc' } @{$RC{ENABLE}}; # disable the command/feature

     

       67
       67
       +
               example = literalExpression ''

     

       68
       68
       +
                 '''

     

       69
       69
       +
                   $RC{UMASK} = 0027;

     

       70
       70
       +
                   $RC{SITE_INFO} = 'This is our private repository host';

     

       71
       71
       +
                   push( @{$RC{ENABLE}}, 'Kindergarten' ); # enable the command/feature

     

       72
       72
       +
                   @{$RC{ENABLE}} = grep { $_ ne 'desc' } @{$RC{ENABLE}}; # disable the command/feature

     

       73
       73
       +
                 '''

     

       72
       74
        
               '';

     

       73
       75
        
               description = ''

     

       74
       76
        
                 Extra configuration to append to the default <literal>~/.gitolite.rc</literal>.

+1 -1

nixos/modules/services/misc/greenclip.nix

···

       12
       12
        
           package = mkOption {

     

       13
       13
        
             type = types.package;

     

       14
       14
        
             default = pkgs.haskellPackages.greenclip;

     

       15
       15
       -
             defaultText = "pkgs.haskellPackages.greenclip";

     

       15
       15
       +
             defaultText = literalExpression "pkgs.haskellPackages.greenclip";

     

       16
       16
        
             description = "greenclip derivation to use.";

     

       17
       17
        
           };

     

       18
       18
        
         };

+4 -4

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

···

       112
       112
        
                   emptyValue.value = {};

     

       113
       113
        
                 };

     

       114
       114
        
               in valueType;

     

       115
       115
       -
             example = literalExample ''

     

       115
       115
       +
             example = literalExpression ''

     

       116
       116
        
               {

     

       117
       117
        
                 homeassistant = {

     

       118
       118
        
                   name = "Home";

     
···

       152
       152
        
             default = null;

     

       153
       153
        
             type = with types; nullOr attrs;

     

       154
       154
        
             # from https://www.home-assistant.io/lovelace/yaml-mode/

     

       155
       155
       -
             example = literalExample ''

     

       155
       155
       +
             example = literalExpression ''

     

       156
       156
        
               {

     

       157
       157
        
                 title = "My Awesome Home";

     

       158
       158
        
                 views = [ {

     
···

       188
       188
        
             default = pkgs.home-assistant.overrideAttrs (oldAttrs: {

     

       189
       189
        
               doInstallCheck = false;

     

       190
       190
        
             });

     

       191
       191
       -
             defaultText = literalExample ''

     

       191
       191
       +
             defaultText = literalExpression ''

     

       192
       192
        
               pkgs.home-assistant.overrideAttrs (oldAttrs: {

     

       193
       193
        
                 doInstallCheck = false;

     

       194
       194
        
               })

     

       195
       195
        
             '';

     

       196
       196
        
             type = types.package;

     

       197
       197
       -
             example = literalExample ''

     

       197
       197
       +
             example = literalExpression ''

     

       198
       198
        
               pkgs.home-assistant.override {

     

       199
       199
        
                 extraPackages = ps: with ps; [ colorlog ];

     

       200
       200
        
               }

+4 -3

nixos/modules/services/misc/ihaskell.nix

···

       6
       6
        
       

     

       7
       7
        
         cfg = config.services.ihaskell;

     

       8
       8
        
         ihaskell = pkgs.ihaskell.override {

     

       9
       9
       -
           packages = self: cfg.extraPackages self;

     

       9
       9
       +
           packages = cfg.extraPackages;

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
       in

     
···

       22
       22
        
       

     

       23
       23
        
             extraPackages = mkOption {

     

       24
       24
        
               type = types.functionTo (types.listOf types.package);

     

       25
       25
       -
               default = self: [];

     

       26
       26
       -
               example = literalExample ''

     

       25
       25
       +
               default = haskellPackages: [];

     

       26
       26
       +
               defaultText = literalExpression "haskellPackages: []";

     

       27
       27
       +
               example = literalExpression ''

     

       27
       28
        
                 haskellPackages: [

     

       28
       29
        
                   haskellPackages.wreq

     

       29
       30
        
                   haskellPackages.lens

+1 -1

nixos/modules/services/misc/jackett.nix

···

       38
       38
        
             package = mkOption {

     

       39
       39
        
               type = types.package;

     

       40
       40
        
               default = pkgs.jackett;

     

       41
       41
       -
               defaultText = "pkgs.jackett";

     

       41
       41
       +
               defaultText = literalExpression "pkgs.jackett";

     

       42
       42
        
               description = "Jackett package to use.";

     

       43
       43
        
             };

     

       44
       44
        
           };

+1 -1

nixos/modules/services/misc/jellyfin.nix

···

       19
       19
        
             package = mkOption {

     

       20
       20
        
               type = types.package;

     

       21
       21
        
               default = pkgs.jellyfin;

     

       22
       22
       -
               example = literalExample "pkgs.jellyfin";

     

       22
       22
       +
               defaultText = literalExpression "pkgs.jellyfin";

     

       23
       23
        
               description = ''

     

       24
       24
        
                 Jellyfin package to use.

     

       25
       25
        
               '';

+1

nixos/modules/services/misc/klipper.nix

···

       19
       19
        
             package = mkOption {

     

       20
       20
        
               type = types.package;

     

       21
       21
        
               default = pkgs.klipper;

     

       22
       22
       +
               defaultText = literalExpression "pkgs.klipper";

     

       22
       23
        
               description = "The Klipper package.";

     

       23
       24
        
             };

     

       24
       25

+1 -1

nixos/modules/services/misc/lidarr.nix

···

       19
       19
        
             package = mkOption {

     

       20
       20
        
               type = types.package;

     

       21
       21
        
               default = pkgs.lidarr;

     

       22
       22
       -
               defaultText = "pkgs.lidarr";

     

       22
       22
       +
               defaultText = literalExpression "pkgs.lidarr";

     

       23
       23
        
               description = "The Lidarr package to use";

     

       24
       24
        
             };

     

       25
       25

+1 -1

nixos/modules/services/misc/matrix-appservice-discord.nix

···

       31
       31
        
                   botToken = "";

     

       32
       32
        
                 };

     

       33
       33
        
               };

     

       34
       34
       -
               example = literalExample ''

     

       34
       34
       +
               example = literalExpression ''

     

       35
       35
        
                 {

     

       36
       36
        
                   bridge = {

     

       37
       37
        
                     domain = "public-domain.tld";

+2 -2

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

···

       125
       125
        
             package = mkOption {

     

       126
       126
        
               type = types.package;

     

       127
       127
        
               default = pkgs.matrix-synapse;

     

       128
       128
       -
               defaultText = "pkgs.matrix-synapse";

     

       128
       128
       +
               defaultText = literalExpression "pkgs.matrix-synapse";

     

       129
       129
        
               description = ''

     

       130
       130
        
                 Overridable attribute of the matrix synapse server package to use.

     

       131
       131
        
               '';

     
···

       133
       133
        
             plugins = mkOption {

     

       134
       134
        
               type = types.listOf types.package;

     

       135
       135
        
               default = [ ];

     

       136
       136
       -
               example = literalExample ''

     

       136
       136
       +
               example = literalExpression ''

     

       137
       137
        
                 with config.services.matrix-synapse.package.plugins; [

     

       138
       138
        
                   matrix-synapse-ldap3

     

       139
       139
        
                   matrix-synapse-pam

+1 -1

nixos/modules/services/misc/mautrix-telegram.nix

···

       60
       60
        
                   };

     

       61
       61
        
                 };

     

       62
       62
        
               };

     

       63
       63
       -
               example = literalExample ''

     

       63
       63
       +
               example = literalExpression ''

     

       64
       64
        
                 {

     

       65
       65
        
                   homeserver = {

     

       66
       66
        
                     address = "http://localhost:8008";

+1 -1

nixos/modules/services/misc/mbpfan.nix

···

       13
       13
        
           package = mkOption {

     

       14
       14
        
             type = types.package;

     

       15
       15
        
             default = pkgs.mbpfan;

     

       16
       16
       -
             defaultText = "pkgs.mbpfan";

     

       16
       16
       +
             defaultText = literalExpression "pkgs.mbpfan";

     

       17
       17
        
             description = ''

     

       18
       18
        
               The package used for the mbpfan daemon.

     

       19
       19
        
             '';

+4 -3

nixos/modules/services/misc/mediatomb.nix

···

       216
       216
        
       

     

       217
       217
        
             package = mkOption {

     

       218
       218
        
               type = types.package;

     

       219
       219
       -
               example = literalExample "pkgs.mediatomb";

     

       219
       219
       +
               example = literalExpression "pkgs.mediatomb";

     

       220
       220
        
               default = pkgs.gerbera;

     

       221
       221
       +
               defaultText = literalExpression "pkgs.gerbera";

     

       221
       222
        
               description = ''

     

       222
       222
       -
                 Underlying package to be used with the module (default: pkgs.gerbera).

     

       223
       223
       +
                 Underlying package to be used with the module.

     

       223
       224
        
               '';

     

       224
       225
        
             };

     

       225
       226
        
       

     
···

       325
       326
        
       

     

       326
       327
        
             mediaDirectories = mkOption {

     

       327
       328
        
               type = with types; listOf (submodule mediaDirectory);

     

       328
       328
       -
               default = {};

     

       329
       329
       +
               default = [];

     

       329
       330
        
               description = ''

     

       330
       331
        
                 Declare media directories to index.

     

       331
       332
        
               '';

+1 -1

nixos/modules/services/misc/mx-puppet-discord.nix

···

       45
       45
        
                   lineDateFormat = "MMM-D HH:mm:ss.SSS";

     

       46
       46
        
                 };

     

       47
       47
        
               };

     

       48
       48
       -
               example = literalExample ''

     

       48
       48
       +
               example = literalExpression ''

     

       49
       49
        
                 {

     

       50
       50
        
                   bridge = {

     

       51
       51
        
                     bindAddress = "localhost";

+1 -1

nixos/modules/services/misc/nitter.nix

···

       79
       79
        
               staticDir = mkOption {

     

       80
       80
        
                 type = types.path;

     

       81
       81
        
                 default = "${pkgs.nitter}/share/nitter/public";

     

       82
       82
       -
                 defaultText = "\${pkgs.nitter}/share/nitter/public";

     

       82
       82
       +
                 defaultText = literalExpression ''"''${pkgs.nitter}/share/nitter/public"'';

     

       83
       83
        
                 description = "Path to the static files directory.";

     

       84
       84
        
               };

     

       85
       85

+2 -2

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

···

       85
       85
        
             package = mkOption {

     

       86
       86
        
               type = types.package;

     

       87
       87
        
               default = pkgs.nix;

     

       88
       88
       -
               defaultText = "pkgs.nix";

     

       88
       88
       +
               defaultText = literalExpression "pkgs.nix";

     

       89
       89
        
               description = ''

     

       90
       90
        
                 This option specifies the Nix package instance to use throughout the system.

     

       91
       91
        
               '';

     
···

       460
       460
        
                     flake = mkOption {

     

       461
       461
        
                       type = types.nullOr types.attrs;

     

       462
       462
        
                       default = null;

     

       463
       463
       -
                       example = literalExample "nixpkgs";

     

       463
       463
       +
                       example = literalExpression "nixpkgs";

     

       464
       464
        
                       description = ''

     

       465
       465
        
                         The flake input to which <option>from></option> is to be rewritten.

     

       466
       466
        
                       '';

+1 -1

nixos/modules/services/misc/nzbhydra2.nix

···

       25
       25
        
             package = mkOption {

     

       26
       26
        
               type = types.package;

     

       27
       27
        
               default = pkgs.nzbhydra2;

     

       28
       28
       -
               defaultText = "pkgs.nzbhydra2";

     

       28
       28
       +
               defaultText = literalExpression "pkgs.nzbhydra2";

     

       29
       29
        
               description = "NZBHydra2 package to use.";

     

       30
       30
        
             };

     

       31
       31
        
           };

+2 -2

nixos/modules/services/misc/octoprint.nix

···

       68
       68
        
             plugins = mkOption {

     

       69
       69
        
               type = types.functionTo (types.listOf types.package);

     

       70
       70
        
               default = plugins: [];

     

       71
       71
       -
               defaultText = "plugins: []";

     

       72
       72
       -
               example = literalExample "plugins: with plugins; [ themeify stlviewer ]";

     

       71
       71
       +
               defaultText = literalExpression "plugins: []";

     

       72
       72
       +
               example = literalExpression "plugins: with plugins; [ themeify stlviewer ]";

     

       73
       73
        
               description = "Additional plugins to be used. Available plugins are passed through the plugins input.";

     

       74
       74
        
             };

     

       75
       75

+4 -4

nixos/modules/services/misc/paperless-ng.nix

···

       107
       107
        
           mediaDir = mkOption {

     

       108
       108
        
             type = types.str;

     

       109
       109
        
             default = "${cfg.dataDir}/media";

     

       110
       110
       -
             defaultText = "\${dataDir}/consume";

     

       110
       110
       +
             defaultText = literalExpression ''"''${dataDir}/media"'';

     

       111
       111
        
             description = "Directory to store the Paperless documents.";

     

       112
       112
        
           };

     

       113
       113
        
       

     

       114
       114
        
           consumptionDir = mkOption {

     

       115
       115
        
             type = types.str;

     

       116
       116
        
             default = "${cfg.dataDir}/consume";

     

       117
       117
       -
             defaultText = "\${dataDir}/consume";

     

       117
       117
       +
             defaultText = literalExpression ''"''${dataDir}/consume"'';

     

       118
       118
        
             description = "Directory from which new documents are imported.";

     

       119
       119
        
           };

     

       120
       120
        
       

     
···

       167
       167
        
               See <link xlink:href="https://paperless-ng.readthedocs.io/en/latest/configuration.html">the documentation</link>

     

       168
       168
        
               for available options.

     

       169
       169
        
             '';

     

       170
       170
       -
             example = literalExample ''

     

       170
       170
       +
             example = literalExpression ''

     

       171
       171
        
               {

     

       172
       172
        
                 PAPERLESS_OCR_LANGUAGE = "deu+eng";

     

       173
       173
        
               }

     
···

       183
       183
        
           package = mkOption {

     

       184
       184
        
             type = types.package;

     

       185
       185
        
             default = pkgs.paperless-ng;

     

       186
       186
       -
             defaultText = "pkgs.paperless-ng";

     

       186
       186
       +
             defaultText = literalExpression "pkgs.paperless-ng";

     

       187
       187
        
             description = "The Paperless package to use.";

     

       188
       188
        
           };

     

       189
       189
        
         };

+1 -1

nixos/modules/services/misc/plex.nix

···

       68
       68
        
             package = mkOption {

     

       69
       69
        
               type = types.package;

     

       70
       70
        
               default = pkgs.plex;

     

       71
       71
       -
               defaultText = "pkgs.plex";

     

       71
       71
       +
               defaultText = literalExpression "pkgs.plex";

     

       72
       72
        
               description = ''

     

       73
       73
        
                 The Plex package to use. Plex subscribers may wish to use their own

     

       74
       74
        
                 package here, pointing to subscriber-only server versions.

+9 -8

nixos/modules/services/misc/redmine.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         inherit (lib) mkBefore mkDefault mkEnableOption mkIf mkOption mkRemovedOptionModule types;

     

       5
       5
       -
         inherit (lib) concatStringsSep literalExample mapAttrsToList;

     

       5
       5
       +
         inherit (lib) concatStringsSep literalExpression mapAttrsToList;

     

       6
       6
        
         inherit (lib) optional optionalAttrs optionalString;

     

       7
       7
        
       

     

       8
       8
        
         cfg = config.services.redmine;

     
···

       54
       54
        
             package = mkOption {

     

       55
       55
        
               type = types.package;

     

       56
       56
        
               default = pkgs.redmine;

     

       57
       57
       +
               defaultText = literalExpression "pkgs.redmine";

     

       57
       58
        
               description = "Which Redmine package to use.";

     

       58
       58
       -
               example = "pkgs.redmine.override { ruby = pkgs.ruby_2_7; }";

     

       59
       59
       +
               example = literalExpression "pkgs.redmine.override { ruby = pkgs.ruby_2_7; }";

     

       59
       60
        
             };

     

       60
       61
        
       

     

       61
       62
        
             user = mkOption {

     
···

       90
       91
        
                 <link xlink:href="https://guides.rubyonrails.org/action_mailer_basics.html#action-mailer-configuration"/>

     

       91
       92
        
                 for details.

     

       92
       93
        
               '';

     

       93
       93
       -
               example = literalExample ''

     

       94
       94
       +
               example = literalExpression ''

     

       94
       95
        
                 {

     

       95
       96
        
                   email_delivery = {

     

       96
       97
        
                     delivery_method = "smtp";

     
···

       112
       113
        
                 See <link xlink:href="https://svn.redmine.org/redmine/trunk/config/additional_environment.rb.example"/>

     

       113
       114
        
                 for details.

     

       114
       115
        
               '';

     

       115
       115
       -
               example = literalExample ''

     

       116
       116
       +
               example = ''

     

       116
       117
        
                 config.logger.level = Logger::DEBUG

     

       117
       118
        
               '';

     

       118
       119
        
             };

     
···

       121
       122
        
               type = types.attrsOf types.path;

     

       122
       123
        
               default = {};

     

       123
       124
        
               description = "Set of themes.";

     

       124
       124
       -
               example = literalExample ''

     

       125
       125
       +
               example = literalExpression ''

     

       125
       126
        
                 {

     

       126
       127
        
                   dkuk-redmine_alex_skin = builtins.fetchurl {

     

       127
       128
        
                     url = "https://bitbucket.org/dkuk/redmine_alex_skin/get/1842ef675ef3.zip";

     
···

       135
       136
        
               type = types.attrsOf types.path;

     

       136
       137
        
               default = {};

     

       137
       138
        
               description = "Set of plugins.";

     

       138
       138
       -
               example = literalExample ''

     

       139
       139
       +
               example = literalExpression ''

     

       139
       140
        
                 {

     

       140
       141
        
                   redmine_env_auth = builtins.fetchurl {

     

       141
       142
        
                     url = "https://github.com/Intera/redmine_env_auth/archive/0.6.zip";

     
···

       162
       163
        
               port = mkOption {

     

       163
       164
        
                 type = types.int;

     

       164
       165
        
                 default = if cfg.database.type == "postgresql" then 5432 else 3306;

     

       165
       165
       -
                 defaultText = "3306";

     

       166
       166
       +
                 defaultText = literalExpression "3306";

     

       166
       167
        
                 description = "Database host port.";

     

       167
       168
        
               };

     

       168
       169
        
       

     
···

       194
       195
        
                   if mysqlLocal then "/run/mysqld/mysqld.sock"

     

       195
       196
        
                   else if pgsqlLocal then "/run/postgresql"

     

       196
       197
        
                   else null;

     

       197
       197
       -
                 defaultText = "/run/mysqld/mysqld.sock";

     

       198
       198
       +
                 defaultText = literalExpression "/run/mysqld/mysqld.sock";

     

       198
       199
        
                 example = "/run/mysqld/mysqld.sock";

     

       199
       200
        
                 description = "Path to the unix socket file to use for authentication.";

     

       200
       201
        
               };

+1 -1

nixos/modules/services/misc/rippled.nix

···

       210
       210
        
               description = "Which rippled package to use.";

     

       211
       211
        
               type = types.package;

     

       212
       212
        
               default = pkgs.rippled;

     

       213
       213
       -
               defaultText = "pkgs.rippled";

     

       213
       213
       +
               defaultText = literalExpression "pkgs.rippled";

     

       214
       214
        
             };

     

       215
       215
        
       

     

       216
       216
        
             ports = mkOption {

+2 -1

nixos/modules/services/misc/sickbeard.nix

···

       24
       24
        
             package = mkOption {

     

       25
       25
        
               type = types.package;

     

       26
       26
        
               default = pkgs.sickbeard;

     

       27
       27
       -
               example = literalExample "pkgs.sickrage";

     

       27
       27
       +
               defaultText = literalExpression "pkgs.sickbeard";

     

       28
       28
       +
               example = literalExpression "pkgs.sickrage";

     

       28
       29
        
               description =''

     

       29
       30
        
                 Enable <literal>pkgs.sickrage</literal> or <literal>pkgs.sickgear</literal>

     

       30
       31
        
                 as an alternative to SickBeard

+12 -10

nixos/modules/services/misc/snapper.nix

···

       51
       51
        
       

     

       52
       52
        
           configs = mkOption {

     

       53
       53
        
             default = { };

     

       54
       54
       -
             example = literalExample {

     

       55
       55
       -
               home = {

     

       56
       56
       -
                 subvolume = "/home";

     

       57
       57
       -
                 extraConfig = ''

     

       58
       58
       -
                   ALLOW_USERS="alice"

     

       59
       59
       -
                   TIMELINE_CREATE=yes

     

       60
       60
       -
                   TIMELINE_CLEANUP=yes

     

       61
       61
       -
                 '';

     

       62
       62
       -
               };

     

       63
       63
       -
             };

     

       54
       54
       +
             example = literalExpression ''

     

       55
       55
       +
               {

     

       56
       56
       +
                 home = {

     

       57
       57
       +
                   subvolume = "/home";

     

       58
       58
       +
                   extraConfig = '''

     

       59
       59
       +
                     ALLOW_USERS="alice"

     

       60
       60
       +
                     TIMELINE_CREATE=yes

     

       61
       61
       +
                     TIMELINE_CLEANUP=yes

     

       62
       62
       +
                   ''';

     

       63
       63
       +
                 };

     

       64
       64
       +
               }

     

       65
       65
       +
             '';

     

       64
       66
        
       

     

       65
       67
        
             description = ''

     

       66
       68
        
               Subvolume configuration

+1 -1

nixos/modules/services/misc/sourcehut/builds.nix

···

       54
       54
        
           images = mkOption {

     

       55
       55
        
             type = types.attrsOf (types.attrsOf (types.attrsOf types.package));

     

       56
       56
        
             default = { };

     

       57
       57
       -
             example = lib.literalExample ''(let

     

       57
       57
       +
             example = lib.literalExpression ''(let

     

       58
       58
        
                 # Pinning unstable to allow usage with flakes and limit rebuilds.

     

       59
       59
        
                 pkgs_unstable = builtins.fetchGit {

     

       60
       60
        
                     url = "https://github.com/NixOS/nixpkgs";

+2 -1

nixos/modules/services/misc/sourcehut/git.nix

···

       49
       49
        
           package = mkOption {

     

       50
       50
        
             type = types.package;

     

       51
       51
        
             default = pkgs.git;

     

       52
       52
       -
             example = literalExample "pkgs.gitFull";

     

       52
       52
       +
             defaultText = literalExpression "pkgs.git";

     

       53
       53
       +
             example = literalExpression "pkgs.gitFull";

     

       53
       54
        
             description = ''

     

       54
       55
        
               Git package for git.sr.ht. This can help silence collisions.

     

       55
       56
        
             '';

+1 -1

nixos/modules/services/misc/ssm-agent.nix

···

       23
       23
        
             type = types.path;

     

       24
       24
        
             description = "The SSM agent package to use";

     

       25
       25
        
             default = pkgs.ssm-agent.override { overrideEtc = false; };

     

       26
       26
       -
             defaultText = "pkgs.ssm-agent.override { overrideEtc = false; }";

     

       26
       26
       +
             defaultText = literalExpression "pkgs.ssm-agent.override { overrideEtc = false; }";

     

       27
       27
        
           };

     

       28
       28
        
         };

     

       29
       29

+1

nixos/modules/services/misc/subsonic.nix

···

       93
       93
        
             transcoders = mkOption {

     

       94
       94
        
               type = types.listOf types.path;

     

       95
       95
        
               default = [ "${pkgs.ffmpeg.bin}/bin/ffmpeg" ];

     

       96
       96
       +
               defaultText = literalExpression ''[ "''${pkgs.ffmpeg.bin}/bin/ffmpeg" ]'';

     

       96
       97
        
               description = ''

     

       97
       98
        
                 List of paths to transcoder executables that should be accessible

     

       98
       99
        
                 from Subsonic. Symlinks will be created to each executable inside

+1 -1

nixos/modules/services/misc/tautulli.nix

···

       47
       47
        
             package = mkOption {

     

       48
       48
        
               type = types.package;

     

       49
       49
        
               default = pkgs.tautulli;

     

       50
       50
       -
               defaultText = "pkgs.tautulli";

     

       50
       50
       +
               defaultText = literalExpression "pkgs.tautulli";

     

       51
       51
        
               description = ''

     

       52
       52
        
                 The Tautulli package to use.

     

       53
       53
        
               '';

+1 -1

nixos/modules/services/misc/tp-auto-kbbl.nix

···

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

     

       16
       16
        
               default = pkgs.tp-auto-kbbl;

     

       17
       17
       -
               defaultText = literalExample "pkgs.tp-auto-kbbl";

     

       17
       17
       +
               defaultText = literalExpression "pkgs.tp-auto-kbbl";

     

       18
       18
        
               description = "Package providing <command>tp-auto-kbbl</command>.";

     

       19
       19
        
             };

     

       20
       20

+1 -1

nixos/modules/services/misc/uhub.nix

···

       50
       50
        
                       options = {

     

       51
       51
        
                         plugin = mkOption {

     

       52
       52
        
                           type = path;

     

       53
       53
       -
                           example = literalExample

     

       53
       53
       +
                           example = literalExpression

     

       54
       54
        
                             "$${pkgs.uhub}/plugins/mod_auth_sqlite.so";

     

       55
       55
        
                           description = "Path to plugin file.";

     

       56
       56
        
                         };

+3 -4

nixos/modules/services/misc/weechat.nix

···

       21
       21
        
           };

     

       22
       22
        
           binary = mkOption {

     

       23
       23
        
             type = types.path;

     

       24
       24
       -
             description = "Binary to execute (by default \${weechat}/bin/weechat).";

     

       25
       25
       -
             example = literalExample ''

     

       26
       26
       -
               ''${pkgs.weechat}/bin/weechat-headless

     

       27
       27
       -
             '';

     

       24
       24
       +
             description = "Binary to execute.";

     

       28
       25
        
             default = "${pkgs.weechat}/bin/weechat";

     

       26
       26
       +
             defaultText = literalExpression ''"''${pkgs.weechat}/bin/weechat"'';

     

       27
       27
       +
             example = literalExpression ''"''${pkgs.weechat}/bin/weechat-headless"'';

     

       29
       28
        
           };

     

       30
       29
        
         };

     

       31
       30

+1 -1

nixos/modules/services/misc/xmr-stak.nix

···

       29
       29
        
             configFiles = mkOption {

     

       30
       30
        
               type = types.attrsOf types.str;

     

       31
       31
        
               default = {};

     

       32
       32
       -
               example = literalExample ''

     

       32
       32
       +
               example = literalExpression ''

     

       33
       33
        
                 {

     

       34
       34
        
                   "config.txt" = '''

     

       35
       35
        
                     "verbose_level" : 4,

+2 -2

nixos/modules/services/misc/zigbee2mqtt.nix

···

       25
       25
        
             default = pkgs.zigbee2mqtt.override {

     

       26
       26
        
               dataDir = cfg.dataDir;

     

       27
       27
        
             };

     

       28
       28
       -
             defaultText = literalExample ''

     

       28
       28
       +
             defaultText = literalExpression ''

     

       29
       29
        
               pkgs.zigbee2mqtt {

     

       30
       30
        
                 dataDir = services.zigbee2mqtt.dataDir

     

       31
       31
        
               }

     
···

       42
       42
        
           settings = mkOption {

     

       43
       43
        
             type = format.type;

     

       44
       44
        
             default = {};

     

       45
       45
       -
             example = literalExample ''

     

       45
       45
       +
             example = literalExpression ''

     

       46
       46
        
               {

     

       47
       47
        
                 homeassistant = config.services.home-assistant.enable;

     

       48
       48
        
                 permit_join = true;

+1 -1

nixos/modules/services/misc/zookeeper.nix

···

       110
       110
        
           package = mkOption {

     

       111
       111
        
             description = "The zookeeper package to use";

     

       112
       112
        
             default = pkgs.zookeeper;

     

       113
       113
       -
             defaultText = "pkgs.zookeeper";

     

       113
       113
       +
             defaultText = literalExpression "pkgs.zookeeper";

     

       114
       114
        
             type = types.package;

     

       115
       115
        
           };

     

       116
       116

-4

nixos/modules/services/monitoring/alerta.nix

···

       32
       32
        
           bind = mkOption {

     

       33
       33
        
             type = types.str;

     

       34
       34
        
             default = "0.0.0.0";

     

       35
       35
       -
             example = literalExample "0.0.0.0";

     

       36
       35
        
             description = "Address to bind to. The default is to bind to all addresses";

     

       37
       36
        
           };

     

       38
       37
        
       

     
···

       46
       45
        
             type = types.str;

     

       47
       46
        
             description = "URL of the MongoDB or PostgreSQL database to connect to";

     

       48
       47
        
             default = "mongodb://localhost";

     

       49
       49
       -
             example = "mongodb://localhost";

     

       50
       48
        
           };

     

       51
       49
        
       

     

       52
       50
        
           databaseName = mkOption {

     

       53
       51
        
             type = types.str;

     

       54
       52
        
             description = "Name of the database instance to connect to";

     

       55
       53
        
             default = "monitoring";

     

       56
       56
       -
             example = "monitoring";

     

       57
       54
        
           };

     

       58
       55
        
       

     

       59
       56
        
           corsOrigins = mkOption {

     

       60
       57
        
             type = types.listOf types.str;

     

       61
       58
        
             description = "List of URLs that can access the API for Cross-Origin Resource Sharing (CORS)";

     

       62
       59
        
             example = [ "http://localhost" "http://localhost:5000" ];

     

       63
       63
       -
             default = [ "http://localhost" "http://localhost:5000" ];

     

       64
       60
        
           };

     

       65
       61
        
       

     

       66
       62
        
           authenticationRequired = mkOption {

+1 -2

nixos/modules/services/monitoring/arbtt.nix

···

       18
       18
        
             package = mkOption {

     

       19
       19
        
               type = types.package;

     

       20
       20
        
               default = pkgs.haskellPackages.arbtt;

     

       21
       21
       -
               defaultText = "pkgs.haskellPackages.arbtt";

     

       22
       22
       -
               example = literalExample "pkgs.haskellPackages.arbtt";

     

       21
       21
       +
               defaultText = literalExpression "pkgs.haskellPackages.arbtt";

     

       23
       22
        
               description = ''

     

       24
       23
        
                 The package to use for the arbtt binaries.

     

       25
       24
        
               '';

+1 -2

nixos/modules/services/monitoring/bosun.nix

···

       33
       33
        
             package = mkOption {

     

       34
       34
        
               type = types.package;

     

       35
       35
        
               default = pkgs.bosun;

     

       36
       36
       -
               defaultText = "pkgs.bosun";

     

       37
       37
       -
               example = literalExample "pkgs.bosun";

     

       36
       36
       +
               defaultText = literalExpression "pkgs.bosun";

     

       38
       37
        
               description = ''

     

       39
       38
        
                 bosun binary to use.

     

       40
       39
        
               '';

+1 -1

nixos/modules/services/monitoring/collectd.nix

···

       45
       45
        
       

     

       46
       46
        
           package = mkOption {

     

       47
       47
        
             default = pkgs.collectd;

     

       48
       48
       -
             defaultText = "pkgs.collectd";

     

       48
       48
       +
             defaultText = literalExpression "pkgs.collectd";

     

       49
       49
        
             description = ''

     

       50
       50
        
               Which collectd package to use.

     

       51
       51
        
             '';

+6 -4

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

···

       59
       59
        
       

     

       60
       60
        
           package = mkOption {

     

       61
       61
        
             default = pkgs.datadog-agent;

     

       62
       62
       -
             defaultText = "pkgs.datadog-agent";

     

       62
       62
       +
             defaultText = literalExpression "pkgs.datadog-agent";

     

       63
       63
        
             description = ''

     

       64
       64
        
               Which DataDog v7 agent package to use. Note that the provided

     

       65
       65
        
               package is expected to have an overridable `pythonPackages`-attribute

     
···

       135
       135
        
               package set must be provided.

     

       136
       136
        
             '';

     

       137
       137
        
       

     

       138
       138
       -
             example = {

     

       139
       139
       -
               ntp = (pythonPackages: [ pythonPackages.ntplib ]);

     

       140
       140
       -
             };

     

       138
       138
       +
             example = literalExpression ''

     

       139
       139
       +
               {

     

       140
       140
       +
                 ntp = pythonPackages: [ pythonPackages.ntplib ];

     

       141
       141
       +
               }

     

       142
       142
       +
             '';

     

       141
       143
        
           };

     

       142
       144
        
       

     

       143
       145
        
           extraConfig = mkOption {

+3 -2

nixos/modules/services/monitoring/grafana-reporter.nix

···

       41
       41
        
       

     

       42
       42
        
           templateDir = mkOption {

     

       43
       43
        
             description = "Optional template directory to use custom tex templates";

     

       44
       44
       -
             default = "${pkgs.grafana_reporter}";

     

       45
       45
       -
             type = types.str;

     

       44
       44
       +
             default = pkgs.grafana_reporter;

     

       45
       45
       +
             defaultText = literalExpression "pkgs.grafana_reporter";

     

       46
       46
       +
             type = types.either types.str types.path;

     

       46
       47
        
           };

     

       47
       48
        
         };

     

       48
       49

+3 -2

nixos/modules/services/monitoring/grafana.nix

···

       330
       330
        
           staticRootPath = mkOption {

     

       331
       331
        
             description = "Root path for static assets.";

     

       332
       332
        
             default = "${cfg.package}/share/grafana/public";

     

       333
       333
       +
             defaultText = literalExpression ''"''${package}/share/grafana/public"'';

     

       333
       334
        
             type = types.str;

     

       334
       335
        
           };

     

       335
       336
        
       

     

       336
       337
        
           package = mkOption {

     

       337
       338
        
             description = "Package to use.";

     

       338
       339
        
             default = pkgs.grafana;

     

       339
       339
       -
             defaultText = "pkgs.grafana";

     

       340
       340
       +
             defaultText = literalExpression "pkgs.grafana";

     

       340
       341
        
             type = types.package;

     

       341
       342
        
           };

     

       342
       343
        
       

     
···

       344
       345
        
             type = with types; nullOr (listOf path);

     

       345
       346
        
             default = null;

     

       346
       347
        
             description = "If non-null, then a list of packages containing Grafana plugins to install. If set, plugins cannot be manually installed.";

     

       347
       347
       -
             example = literalExample "with pkgs.grafanaPlugins; [ grafana-piechart-panel ]";

     

       348
       348
       +
             example = literalExpression "with pkgs.grafanaPlugins; [ grafana-piechart-panel ]";

     

       348
       349
        
             # Make sure each plugin is added only once; otherwise building

     

       349
       350
        
             # the link farm fails, since the same path is added multiple

     

       350
       351
        
             # times.

+3 -3

nixos/modules/services/monitoring/graphite.nix

···

       132
       132
        
             finders = mkOption {

     

       133
       133
        
               description = "List of finder plugins to load.";

     

       134
       134
        
               default = [];

     

       135
       135
       -
               example = literalExample "[ pkgs.python3Packages.influxgraph ]";

     

       135
       135
       +
               example = literalExpression "[ pkgs.python3Packages.influxgraph ]";

     

       136
       136
        
               type = types.listOf types.package;

     

       137
       137
        
             };

     

       138
       138
        
       

     
···

       160
       160
        
             package = mkOption {

     

       161
       161
        
               description = "Package to use for graphite api.";

     

       162
       162
        
               default = pkgs.python3Packages.graphite_api;

     

       163
       163
       -
               defaultText = "pkgs.python3Packages.graphite_api";

     

       163
       163
       +
               defaultText = literalExpression "pkgs.python3Packages.graphite_api";

     

       164
       164
        
               type = types.package;

     

       165
       165
        
             };

     

       166
       166
        
       

     
···

       335
       335
        
                 <link xlink:href='https://github.com/scobal/seyren#config' />

     

       336
       336
        
               '';

     

       337
       337
        
               type = types.attrsOf types.str;

     

       338
       338
       -
               example = literalExample ''

     

       338
       338
       +
               example = literalExpression ''

     

       339
       339
        
                 {

     

       340
       340
        
                   GRAPHITE_USERNAME = "user";

     

       341
       341
        
                   GRAPHITE_PASSWORD = "pass";

+1 -1

nixos/modules/services/monitoring/heapster.nix

···

       33
       33
        
           package = mkOption {

     

       34
       34
        
             description = "Package to use by heapster";

     

       35
       35
        
             default = pkgs.heapster;

     

       36
       36
       -
             defaultText = "pkgs.heapster";

     

       36
       36
       +
             defaultText = literalExpression "pkgs.heapster";

     

       37
       37
        
             type = types.package;

     

       38
       38
        
           };

     

       39
       39
        
         };

+1 -1

nixos/modules/services/monitoring/incron.nix

···

       56
       56
        
             extraPackages = mkOption {

     

       57
       57
        
               type = types.listOf types.package;

     

       58
       58
        
               default = [];

     

       59
       59
       -
               example = literalExample "[ pkgs.rsync ]";

     

       59
       59
       +
               example = literalExpression "[ pkgs.rsync ]";

     

       60
       60
        
               description = "Extra packages available to the system incrontab.";

     

       61
       61
        
             };

     

       62
       62

+1 -4

nixos/modules/services/monitoring/kapacitor.nix

···

       62
       62
        
           dataDir = mkOption {

     

       63
       63
        
             type = types.path;

     

       64
       64
        
             example = "/var/lib/kapacitor";

     

       65
       65
       -
             default = "/var/lib/kapacitor";

     

       66
       65
        
             description = "Location where Kapacitor stores its state";

     

       67
       66
        
           };

     

       68
       67
        
       

     
···

       75
       74
        
           bind = mkOption {

     

       76
       75
        
             type = types.str;

     

       77
       76
        
             default = "";

     

       78
       78
       -
             example = literalExample "0.0.0.0";

     

       77
       77
       +
             example = "0.0.0.0";

     

       79
       78
        
             description = "Address to bind to. The default is to bind to all addresses";

     

       80
       79
        
           };

     

       81
       80
        
       

     
···

       101
       100
        
             type = types.str;

     

       102
       101
        
             description = "Specifies how often to snapshot the task state  (in InfluxDB time units)";

     

       103
       102
        
             default = "1m0s";

     

       104
       104
       -
             example = "1m0s";

     

       105
       103
        
           };

     

       106
       104
        
       

     

       107
       105
        
           loadDirectory = mkOption {

     
···

       136
       134
        
             url = mkOption {

     

       137
       135
        
               description = "The URL to the Alerta REST API";

     

       138
       136
        
               default = "http://localhost:5000";

     

       139
       139
       -
               example = "http://localhost:5000";

     

       140
       137
        
               type = types.str;

     

       141
       138
        
             };

     

       142
       139

+2 -2

nixos/modules/services/monitoring/loki.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         inherit (lib) escapeShellArgs literalExample mkEnableOption mkIf mkOption types;

     

       4
       4
       +
         inherit (lib) escapeShellArgs mkEnableOption mkIf mkOption types;

     

       5
       5
        
       

     

       6
       6
        
         cfg = config.services.loki;

     

       7
       7
        
       

     
···

       57
       57
        
           extraFlags = mkOption {

     

       58
       58
        
             type = types.listOf types.str;

     

       59
       59
        
             default = [];

     

       60
       60
       -
             example = literalExample [ "--server.http-listen-port=3101" ];

     

       60
       60
       +
             example = [ "--server.http-listen-port=3101" ];

     

       61
       61
        
             description = ''

     

       62
       62
        
               Specify a list of additional command line flags,

     

       63
       63
        
               which get escaped and are then passed to Loki.

-1

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

···

       19
       19
        
       

     

       20
       20
        
           apiKeyFile = mkOption {

     

       21
       21
        
             type = types.path;

     

       22
       22
       -
             default = "";

     

       23
       22
        
             example = "/run/keys/mackerel-api-key";

     

       24
       23
        
             description = ''

     

       25
       24
        
               Path to file containing the Mackerel API key. The file should contain a

+3 -4

nixos/modules/services/monitoring/metricbeat.nix

···

       3
       3
        
       let

     

       4
       4
        
         inherit (lib)

     

       5
       5
        
           attrValues

     

       6
       6
       -
           literalExample

     

       6
       6
       +
           literalExpression

     

       7
       7
        
           mkEnableOption

     

       8
       8
        
           mkIf

     

       9
       9
        
           mkOption

     
···

       24
       24
        
             package = mkOption {

     

       25
       25
        
               type = types.package;

     

       26
       26
        
               default = pkgs.metricbeat;

     

       27
       27
       -
               defaultText = literalExample "pkgs.metricbeat";

     

       28
       28
       -
               example = literalExample "pkgs.metricbeat7";

     

       27
       27
       +
               defaultText = literalExpression "pkgs.metricbeat";

     

       28
       28
       +
               example = literalExpression "pkgs.metricbeat7";

     

       29
       29
        
               description = ''

     

       30
       30
        
                 The metricbeat package to use

     

       31
       31
        
               '';

     
···

       51
       51
        
                   module = mkOption {

     

       52
       52
        
                     type = types.str;

     

       53
       53
        
                     default = name;

     

       54
       54
       -
                     defaultText = literalExample ''<name>'';

     

       55
       54
        
                     description = ''

     

       56
       55
        
                       The name of the module.

     

       57
       56

+7 -5

nixos/modules/services/monitoring/munin.nix

···

       189
       189
        
                 <literal>/bin</literal>, <literal>/usr/bin</literal>,

     

       190
       190
        
                 <literal>/sbin</literal>, and <literal>/usr/sbin</literal>.

     

       191
       191
        
               '';

     

       192
       192
       -
               example = literalExample ''

     

       192
       192
       +
               example = literalExpression ''

     

       193
       193
        
                 {

     

       194
       194
        
                   zfs_usage_bigpool = /src/munin-contrib/plugins/zfs/zfs_usage_;

     

       195
       195
        
                   zfs_usage_smallpool = /src/munin-contrib/plugins/zfs/zfs_usage_;

     
···

       220
       220
        
                 <literal>/bin</literal>, <literal>/usr/bin</literal>,

     

       221
       221
        
                 <literal>/sbin</literal>, and <literal>/usr/sbin</literal>.

     

       222
       222
        
               '';

     

       223
       223
       -
               example = literalExample ''

     

       223
       223
       +
               example = literalExpression ''

     

       224
       224
        
                 [

     

       225
       225
        
                   /src/munin-contrib/plugins/zfs

     

       226
       226
        
                   /src/munin-contrib/plugins/ssh

     
···

       285
       285
        
                 host for cron to succeed. See

     

       286
       286
        
                 <link xlink:href='http://guide.munin-monitoring.org/en/latest/reference/munin.conf.html' />

     

       287
       287
        
               '';

     

       288
       288
       -
               example = ''

     

       289
       289
       -
                 [''${config.networking.hostName}]

     

       290
       290
       -
                 address localhost

     

       288
       288
       +
               example = literalExpression ''

     

       289
       289
       +
                 '''

     

       290
       290
       +
                   [''${config.networking.hostName}]

     

       291
       291
       +
                   address localhost

     

       292
       292
       +
                 '''

     

       291
       293
        
               '';

     

       292
       294
        
             };

     

       293
       295

+4 -4

nixos/modules/services/monitoring/nagios.nix

···

       97
       97
        
                 network that you want Nagios to monitor.

     

       98
       98
        
               ";

     

       99
       99
        
               type = types.listOf types.path;

     

       100
       100
       -
               example = literalExample "[ ./objects.cfg ]";

     

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

     

       101
       101
        
             };

     

       102
       102
        
       

     

       103
       103
        
             plugins = mkOption {

     

       104
       104
        
               type = types.listOf types.package;

     

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

     

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

     

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

     

       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.

     
···

       137
       137
        
             cgiConfigFile = mkOption {

     

       138
       138
        
               type = types.package;

     

       139
       139
        
               default = nagiosCGICfgFile;

     

       140
       140
       -
               defaultText = "nagiosCGICfgFile";

     

       140
       140
       +
               defaultText = literalExpression "nagiosCGICfgFile";

     

       141
       141
        
               description = "

     

       142
       142
        
                 Derivation for the configuration file of Nagios CGI scripts

     

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

     
···

       155
       155
        
       

     

       156
       156
        
             virtualHost = mkOption {

     

       157
       157
        
               type = types.submodule (import ../web-servers/apache-httpd/vhost-options.nix);

     

       158
       158
       -
               example = literalExample ''

     

       158
       158
       +
               example = literalExpression ''

     

       159
       159
        
                 { hostName = "example.org";

     

       160
       160
        
                   adminAddr = "webmaster@example.org";

     

       161
       161
        
                   enableSSL = true;

+5 -5

nixos/modules/services/monitoring/netdata.nix

···

       45
       45
        
             package = mkOption {

     

       46
       46
        
               type = types.package;

     

       47
       47
        
               default = pkgs.netdata;

     

       48
       48
       -
               defaultText = "pkgs.netdata";

     

       48
       48
       +
               defaultText = literalExpression "pkgs.netdata";

     

       49
       49
        
               description = "Netdata package to use.";

     

       50
       50
        
             };

     

       51
       51
        
       

     
···

       84
       84
        
               extraPackages = mkOption {

     

       85
       85
        
                 type = types.functionTo (types.listOf types.package);

     

       86
       86
        
                 default = ps: [];

     

       87
       87
       -
                 defaultText = "ps: []";

     

       88
       88
       -
                 example = literalExample ''

     

       87
       87
       +
                 defaultText = literalExpression "ps: []";

     

       88
       88
       +
                 example = literalExpression ''

     

       89
       89
        
                   ps: [

     

       90
       90
        
                     ps.psycopg2

     

       91
       91
        
                     ps.docker

     
···

       102
       102
        
             extraPluginPaths = mkOption {

     

       103
       103
        
               type = types.listOf types.path;

     

       104
       104
        
               default = [ ];

     

       105
       105
       -
               example = literalExample ''

     

       105
       105
       +
               example = literalExpression ''

     

       106
       106
        
                 [ "/path/to/plugins.d" ]

     

       107
       107
        
               '';

     

       108
       108
        
               description = ''

     
···

       121
       121
        
               type = types.attrsOf types.attrs;

     

       122
       122
        
               default = {};

     

       123
       123
        
               description = "netdata.conf configuration as nix attributes. cannot be combined with configText.";

     

       124
       124
       -
               example = literalExample ''

     

       124
       124
       +
               example = literalExpression ''

     

       125
       125
        
                 global = {

     

       126
       126
        
                   "debug log" = "syslog";

     

       127
       127
        
                   "access log" = "syslog";

+1 -1

nixos/modules/services/monitoring/parsedmarc.nix

···

       39
       39
        
               hostname = lib.mkOption {

     

       40
       40
        
                 type = lib.types.str;

     

       41
       41
        
                 default = config.networking.fqdn;

     

       42
       42
       -
                 defaultText = "config.networking.fqdn";

     

       42
       42
       +
                 defaultText = lib.literalExpression "config.networking.fqdn";

     

       43
       43
        
                 example = "monitoring.example.com";

     

       44
       44
        
                 description = ''

     

       45
       45
        
                   The hostname to use when configuring Postfix.

+1 -1

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

···

       45
       45
        
             package = mkOption {

     

       46
       46
        
               type = types.package;

     

       47
       47
        
               default = pkgs.prometheus-alertmanager;

     

       48
       48
       -
               defaultText = "pkgs.alertmanager";

     

       48
       48
       +
               defaultText = literalExpression "pkgs.alertmanager";

     

       49
       49
        
               description = ''

     

       50
       50
        
                 Package that should be used for alertmanager.

     

       51
       51
        
               '';

+2 -2

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

···

       692
       692
        
           package = mkOption {

     

       693
       693
        
             type = types.package;

     

       694
       694
        
             default = pkgs.prometheus;

     

       695
       695
       -
             defaultText = "pkgs.prometheus";

     

       695
       695
       +
             defaultText = literalExpression "pkgs.prometheus";

     

       696
       696
        
             description = ''

     

       697
       697
        
               The prometheus package that should be used.

     

       698
       698
        
             '';

     
···

       833
       833
        
       

     

       834
       834
        
           alertmanagers = mkOption {

     

       835
       835
        
             type = types.listOf types.attrs;

     

       836
       836
       -
             example = literalExample ''

     

       836
       836
       +
             example = literalExpression ''

     

       837
       837
        
               [ {

     

       838
       838
        
                 scheme = "https";

     

       839
       839
        
                 path_prefix = "/alertmanager";

+3 -3

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

···

       1
       1
        
       { config, pkgs, lib, options, ... }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         inherit (lib) concatStrings foldl foldl' genAttrs literalExample maintainers

     

       4
       4
       +
         inherit (lib) concatStrings foldl foldl' genAttrs literalExpression maintainers

     

       5
       5
        
                       mapAttrsToList mkDefault mkEnableOption mkIf mkMerge mkOption

     

       6
       6
        
                       optional types mkOptionDefault flip attrNames;

     

       7
       7
        
       

     
···

       109
       109
        
           firewallFilter = mkOption {

     

       110
       110
        
             type = types.nullOr types.str;

     

       111
       111
        
             default = null;

     

       112
       112
       -
             example = literalExample ''

     

       112
       112
       +
             example = literalExpression ''

     

       113
       113
        
               "-i eth0 -p tcp -m tcp --dport ${toString port}"

     

       114
       114
        
             '';

     

       115
       115
        
             description = ''

     
···

       204
       204
        
           };

     

       205
       205
        
           description = "Prometheus exporter configuration";

     

       206
       206
        
           default = {};

     

       207
       207
       -
           example = literalExample ''

     

       207
       207
       +
           example = literalExpression ''

     

       208
       208
        
             {

     

       209
       209
        
               node = {

     

       210
       210
        
                 enable = true;

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/buildkite-agent.nix

···

       36
       36
        
           queues = mkOption {

     

       37
       37
        
             type = with types; nullOr (listOf str);

     

       38
       38
        
             default = null;

     

       39
       39
       -
             example = literalExample ''[ "my-queue1" "my-queue2" ]'';

     

       39
       39
       +
             example = literalExpression ''[ "my-queue1" "my-queue2" ]'';

     

       40
       40
        
             description = ''

     

       41
       41
        
               Which specific queues to process.

     

       42
       42
        
             '';

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/flow.nix

···

       9
       9
        
         extraOpts = {

     

       10
       10
        
           brokers = mkOption {

     

       11
       11
        
             type = types.listOf types.str;

     

       12
       12
       -
             example = literalExample ''[ "kafka.example.org:19092" ]'';

     

       12
       12
       +
             example = literalExpression ''[ "kafka.example.org:19092" ]'';

     

       13
       13
        
             description = "List of Kafka brokers to connect to.";

     

       14
       14
        
           };

     

       15
       15

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/kea.nix

···

       13
       13
        
         extraOpts = {

     

       14
       14
        
           controlSocketPaths = mkOption {

     

       15
       15
        
             type = types.listOf types.str;

     

       16
       16
       -
             example = literalExample ''

     

       16
       16
       +
             example = literalExpression ''

     

       17
       17
        
               [

     

       18
       18
        
                 "/run/kea/kea-dhcp4.socket"

     

       19
       19
        
                 "/run/kea/kea-dhcp6.socket"

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/knot.nix

···

       10
       10
        
           knotLibraryPath = mkOption {

     

       11
       11
        
             type = types.str;

     

       12
       12
        
             default = "${pkgs.knot-dns.out}/lib/libknot.so";

     

       13
       13
       -
             defaultText = "\${pkgs.knot-dns}/lib/libknot.so";

     

       13
       13
       +
             defaultText = literalExpression ''"''${pkgs.knot-dns.out}/lib/libknot.so"'';

     

       14
       14
        
             description = ''

     

       15
       15
        
               Path to the library of <package>knot-dns</package>.

     

       16
       16
        
             '';

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/mail.nix

···

       100
       100
        
           servers = mkOption {

     

       101
       101
        
             type = types.listOf (types.submodule serverOptions);

     

       102
       102
        
             default = [];

     

       103
       103
       -
             example = literalExample ''

     

       103
       103
       +
             example = literalExpression ''

     

       104
       104
        
               [ {

     

       105
       105
        
                 name = "testserver";

     

       106
       106
        
                 server = "smtp.domain.tld";

+2 -2

nixos/modules/services/monitoring/prometheus/exporters/mikrotik.nix

···

       15
       15
        
               Path to a mikrotik exporter configuration file. Mutually exclusive with

     

       16
       16
        
               <option>configuration</option> option.

     

       17
       17
        
             '';

     

       18
       18
       -
             example = literalExample "./mikrotik.yml";

     

       18
       18
       +
             example = literalExpression "./mikrotik.yml";

     

       19
       19
        
           };

     

       20
       20
        
       

     

       21
       21
        
           configuration = mkOption {

     
···

       28
       28
        
               See <link xlink:href="https://github.com/nshttpd/mikrotik-exporter/blob/master/README.md"/>

     

       29
       29
        
               for the description of the configuration file format.

     

       30
       30
        
             '';

     

       31
       31
       -
             example = literalExample ''

     

       31
       31
       +
             example = literalExpression ''

     

       32
       32
        
               {

     

       33
       33
        
                 devices = [

     

       34
       34
        
                   {

+2 -2

nixos/modules/services/monitoring/prometheus/exporters/node.nix

···

       11
       11
        
           enabledCollectors = mkOption {

     

       12
       12
        
             type = types.listOf types.str;

     

       13
       13
        
             default = [];

     

       14
       14
       -
             example = ''[ "systemd" ]'';

     

       14
       14
       +
             example = [ "systemd" ];

     

       15
       15
        
             description = ''

     

       16
       16
        
               Collectors to enable. The collectors listed here are enabled in addition to the default ones.

     

       17
       17
        
             '';

     
···

       19
       19
        
           disabledCollectors = mkOption {

     

       20
       20
        
             type = types.listOf types.str;

     

       21
       21
        
             default = [];

     

       22
       22
       -
             example = ''[ "timex" ]'';

     

       22
       22
       +
             example = [ "timex" ];

     

       23
       23
        
             description = ''

     

       24
       24
        
               Collectors to disable which are enabled by default.

     

       25
       25
        
             '';

+2 -2

nixos/modules/services/monitoring/prometheus/exporters/pihole.nix

···

       42
       42
        
           };

     

       43
       43
        
           piholePort = mkOption {

     

       44
       44
        
             type = types.port;

     

       45
       45
       -
             default = "80";

     

       46
       46
       -
             example = "443";

     

       45
       45
       +
             default = 80;

     

       46
       46
       +
             example = 443;

     

       47
       47
        
             description = ''

     

       48
       48
        
               The port pihole webinterface is reachable on

     

       49
       49
        
             '';

+6 -8

nixos/modules/services/monitoring/prometheus/exporters/process.nix

···

       11
       11
        
         extraOpts = {

     

       12
       12
        
           settings.process_names = mkOption {

     

       13
       13
        
             type = types.listOf types.anything;

     

       14
       14
       -
             default = {};

     

       15
       15
       -
             example = literalExample ''

     

       16
       16
       -
               {

     

       17
       17
       -
                 process_names = [

     

       18
       18
       -
                   # Remove nix store path from process name

     

       19
       19
       -
                   { name = "{{.Matches.Wrapped}} {{ .Matches.Args }}"; cmdline = [ "^/nix/store[^ ]*/(?P<Wrapped>[^ /]*) (?P<Args>.*)" ]; }

     

       20
       20
       -
                 ];

     

       21
       21
       -
               }

     

       14
       14
       +
             default = [];

     

       15
       15
       +
             example = literalExpression ''

     

       16
       16
       +
               [

     

       17
       17
       +
                 # Remove nix store path from process name

     

       18
       18
       +
                 { name = "{{.Matches.Wrapped}} {{ .Matches.Args }}"; cmdline = [ "^/nix/store[^ ]*/(?P<Wrapped>[^ /]*) (?P<Args>.*)" ]; }

     

       19
       19
       +
               ]

     

       22
       20
        
             '';

     

       23
       21
        
             description = ''

     

       24
       22
        
               All settings expressed as an Nix attrset.

+2 -2

nixos/modules/services/monitoring/prometheus/exporters/rspamd.nix

···

       62
       62
        
             default = {

     

       63
       63
        
               host = config.networking.hostName;

     

       64
       64
        
             };

     

       65
       65
       -
             defaultText = "{ host = config.networking.hostName; }";

     

       66
       66
       -
             example = literalExample ''

     

       65
       65
       +
             defaultText = literalExpression "{ host = config.networking.hostName; }";

     

       66
       66
       +
             example = literalExpression ''

     

       67
       67
        
               {

     

       68
       68
        
                 host = config.networking.hostName;

     

       69
       69
        
                 custom_label = "some_value";

+1 -1

nixos/modules/services/monitoring/prometheus/exporters/script.nix

···

       30
       30
        
                 };

     

       31
       31
        
               };

     

       32
       32
        
             });

     

       33
       33
       -
             example = literalExample ''

     

       33
       33
       +
             example = literalExpression ''

     

       34
       34
        
               {

     

       35
       35
        
                 scripts = [

     

       36
       36
        
                   { name = "sleep"; script = "sleep 5"; }

+7 -9

nixos/modules/services/monitoring/prometheus/exporters/snmp.nix

···

       14
       14
        
             description = ''

     

       15
       15
        
               Path to a snmp exporter configuration file. Mutually exclusive with 'configuration' option.

     

       16
       16
        
             '';

     

       17
       17
       -
             example = "./snmp.yml";

     

       17
       17
       +
             example = literalExpression "./snmp.yml";

     

       18
       18
        
           };

     

       19
       19
        
       

     

       20
       20
        
           configuration = mkOption {

     
···

       23
       23
        
             description = ''

     

       24
       24
        
               Snmp exporter configuration as nix attribute set. Mutually exclusive with 'configurationPath' option.

     

       25
       25
        
             '';

     

       26
       26
       -
             example = ''

     

       27
       27
       -
               {

     

       28
       28
       -
                 "default" = {

     

       29
       29
       -
                   "version" = 2;

     

       30
       30
       -
                   "auth" = {

     

       31
       31
       -
                     "community" = "public";

     

       32
       32
       -
                   };

     

       26
       26
       +
             example = {

     

       27
       27
       +
               "default" = {

     

       28
       28
       +
                 "version" = 2;

     

       29
       29
       +
                 "auth" = {

     

       30
       30
       +
                   "community" = "public";

     

       33
       31
        
                 };

     

       34
       32
        
               };

     

       35
       35
       -
             '';

     

       33
       33
       +
             };

     

       36
       34
        
           };

     

       37
       35
        
       

     

       38
       36
        
           logFormat = mkOption {

+1 -1

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

···

       26
       26
        
             package = mkOption {

     

       27
       27
        
               type = types.package;

     

       28
       28
        
               default = pkgs.prometheus-pushgateway;

     

       29
       29
       -
               defaultText = "pkgs.prometheus-pushgateway";

     

       29
       29
       +
               defaultText = literalExpression "pkgs.prometheus-pushgateway";

     

       30
       30
        
               description = ''

     

       31
       31
        
                 Package that should be used for the prometheus pushgateway.

     

       32
       32
        
               '';

+2 -3

nixos/modules/services/monitoring/scollector.nix

···

       43
       43
        
             package = mkOption {

     

       44
       44
        
               type = types.package;

     

       45
       45
        
               default = pkgs.scollector;

     

       46
       46
       -
               defaultText = "pkgs.scollector";

     

       47
       47
       -
               example = literalExample "pkgs.scollector";

     

       46
       46
       +
               defaultText = literalExpression "pkgs.scollector";

     

       48
       47
        
               description = ''

     

       49
       48
        
                 scollector binary to use.

     

       50
       49
        
               '';

     
···

       78
       77
        
             collectors = mkOption {

     

       79
       78
        
               type = with types; attrsOf (listOf path);

     

       80
       79
        
               default = {};

     

       81
       81
       -
               example = literalExample "{ \"0\" = [ \"\${postgresStats}/bin/collect-stats\" ]; }";

     

       80
       80
       +
               example = literalExpression ''{ "0" = [ "''${postgresStats}/bin/collect-stats" ]; }'';

     

       82
       81
        
               description = ''

     

       83
       82
        
                 An attribute set mapping the frequency of collection to a list of

     

       84
       83
        
                 binaries that should be executed at that frequency. You can use "0"

+2 -2

nixos/modules/services/monitoring/telegraf.nix

···

       15
       15
        
       

     

       16
       16
        
             package = mkOption {

     

       17
       17
        
               default = pkgs.telegraf;

     

       18
       18
       -
               defaultText = "pkgs.telegraf";

     

       18
       18
       +
               defaultText = literalExpression "pkgs.telegraf";

     

       19
       19
        
               description = "Which telegraf derivation to use";

     

       20
       20
        
               type = types.package;

     

       21
       21
        
             };

     
···

       23
       23
        
             environmentFiles = mkOption {

     

       24
       24
        
               type = types.listOf types.path;

     

       25
       25
        
               default = [];

     

       26
       26
       -
               example = "/run/keys/telegraf.env";

     

       26
       26
       +
               example = [ "/run/keys/telegraf.env" ];

     

       27
       27
        
               description = ''

     

       28
       28
        
                 File to load as environment file. Environment variables from this file

     

       29
       29
        
                 will be interpolated into the config file using envsubst with this

+4 -4

nixos/modules/services/monitoring/thanos.nix

···

       120
       120
        
                 type = with types; nullOr str;

     

       121
       121
        
                 default = if cfg.tracing.config == null then null

     

       122
       122
        
                           else toString (toYAML "tracing.yaml" cfg.tracing.config);

     

       123
       123
       -
                 defaultText = ''

     

       123
       123
       +
                 defaultText = literalExpression ''

     

       124
       124
        
                   if config.services.thanos.<cmd>.tracing.config == null then null

     

       125
       125
        
                   else toString (toYAML "tracing.yaml" config.services.thanos.<cmd>.tracing.config);

     

       126
       126
        
                 '';

     
···

       185
       185
        
                 type = with types; nullOr str;

     

       186
       186
        
                 default = if cfg.objstore.config == null then null

     

       187
       187
        
                           else toString (toYAML "objstore.yaml" cfg.objstore.config);

     

       188
       188
       -
                 defaultText = ''

     

       188
       188
       +
                 defaultText = literalExpression ''

     

       189
       189
        
                   if config.services.thanos.<cmd>.objstore.config == null then null

     

       190
       190
        
                   else toString (toYAML "objstore.yaml" config.services.thanos.<cmd>.objstore.config);

     

       191
       191
        
                 '';

     
···

       227
       227
        
               option = mkOption {

     

       228
       228
        
                 type = types.str;

     

       229
       229
        
                 default = "/var/lib/${config.services.prometheus.stateDir}/data";

     

       230
       230
       -
                 defaultText = "/var/lib/\${config.services.prometheus.stateDir}/data";

     

       230
       230
       +
                 defaultText = literalExpression ''"/var/lib/''${config.services.prometheus.stateDir}/data"'';

     

       231
       231
        
                 description = ''

     

       232
       232
        
                   Data directory of TSDB.

     

       233
       233
        
                 '';

     
···

       656
       656
        
           package = mkOption {

     

       657
       657
        
             type = types.package;

     

       658
       658
        
             default = pkgs.thanos;

     

       659
       659
       -
             defaultText = "pkgs.thanos";

     

       659
       659
       +
             defaultText = literalExpression "pkgs.thanos";

     

       660
       660
        
             description = ''

     

       661
       661
        
               The thanos package that should be used.

     

       662
       662
        
             '';

+2 -2

nixos/modules/services/monitoring/unifi-poller.nix

···

       87
       87
        
             pass = mkOption {

     

       88
       88
        
               type = types.path;

     

       89
       89
        
               default = pkgs.writeText "unifi-poller-influxdb-default.password" "unifipoller";

     

       90
       90
       -
               defaultText = "unifi-poller-influxdb-default.password";

     

       90
       90
       +
               defaultText = literalExpression "unifi-poller-influxdb-default.password";

     

       91
       91
        
               description = ''

     

       92
       92
        
                 Path of a file containing the password for influxdb.

     

       93
       93
        
                 This file needs to be readable by the unifi-poller user.

     
···

       130
       130
        
               pass = mkOption {

     

       131
       131
        
                 type = types.path;

     

       132
       132
        
                 default = pkgs.writeText "unifi-poller-unifi-default.password" "unifi";

     

       133
       133
       -
                 defaultText = "unifi-poller-unifi-default.password";

     

       133
       133
       +
                 defaultText = literalExpression "unifi-poller-unifi-default.password";

     

       134
       134
        
                 description = ''

     

       135
       135
        
                   Path of a file containing the password for the unifi service user.

     

       136
       136
        
                   This file needs to be readable by the unifi-poller user.

+5 -5

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

···

       4
       4
        
         cfg = config.services.zabbixAgent;

     

       5
       5
        
       

     

       6
       6
        
         inherit (lib) mkDefault mkEnableOption mkIf mkMerge mkOption;

     

       7
       7
       -
         inherit (lib) attrValues concatMapStringsSep literalExample optionalString types;

     

       7
       7
       +
         inherit (lib) attrValues concatMapStringsSep literalExpression optionalString types;

     

       8
       8
        
         inherit (lib.generators) toKeyValue;

     

       9
       9
        
       

     

       10
       10
        
         user = "zabbix-agent";

     
···

       34
       34
        
             package = mkOption {

     

       35
       35
        
               type = types.package;

     

       36
       36
        
               default = pkgs.zabbix.agent;

     

       37
       37
       -
               defaultText = "pkgs.zabbix.agent";

     

       37
       37
       +
               defaultText = literalExpression "pkgs.zabbix.agent";

     

       38
       38
        
               description = "The Zabbix package to use.";

     

       39
       39
        
             };

     

       40
       40
        
       

     

       41
       41
        
             extraPackages = mkOption {

     

       42
       42
        
               type = types.listOf types.package;

     

       43
       43
        
               default = with pkgs; [ nettools ];

     

       44
       44
       -
               defaultText = "[ nettools ]";

     

       45
       45
       -
               example = "[ nettools mysql ]";

     

       44
       44
       +
               defaultText = literalExpression "with pkgs; [ nettools ]";

     

       45
       45
       +
               example = literalExpression "with pkgs; [ nettools mysql ]";

     

       46
       46
        
               description = ''

     

       47
       47
        
                 Packages to be added to the Zabbix <envar>PATH</envar>.

     

       48
       48
        
                 Typically used to add executables for scripts, but can be anything.

     
···

       53
       53
        
               type = types.attrsOf types.package;

     

       54
       54
        
               description = "A set of modules to load.";

     

       55
       55
        
               default = {};

     

       56
       56
       -
               example = literalExample ''

     

       56
       56
       +
               example = literalExpression ''

     

       57
       57
        
                 {

     

       58
       58
        
                   "dummy.so" = pkgs.stdenv.mkDerivation {

     

       59
       59
        
                     name = "zabbix-dummy-module-''${cfg.package.version}";

+5 -5

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

···

       6
       6
        
         mysql = config.services.mysql;

     

       7
       7
        
       

     

       8
       8
        
         inherit (lib) mkAfter mkDefault mkEnableOption mkIf mkMerge mkOption;

     

       9
       9
       -
         inherit (lib) attrValues concatMapStringsSep getName literalExample optional optionalAttrs optionalString types;

     

       9
       9
       +
         inherit (lib) attrValues concatMapStringsSep getName literalExpression optional optionalAttrs optionalString types;

     

       10
       10
        
         inherit (lib.generators) toKeyValue;

     

       11
       11
        
       

     

       12
       12
        
         user = "zabbix";

     
···

       52
       52
        
                 if cfg.database.type == "mysql" then pkgs.zabbix.proxy-mysql

     

       53
       53
        
                 else if cfg.database.type == "pgsql" then pkgs.zabbix.proxy-pgsql

     

       54
       54
        
                 else pkgs.zabbix.proxy-sqlite;

     

       55
       55
       -
               defaultText = "pkgs.zabbix.proxy-pgsql";

     

       55
       55
       +
               defaultText = literalExpression "pkgs.zabbix.proxy-pgsql";

     

       56
       56
        
               description = "The Zabbix package to use.";

     

       57
       57
        
             };

     

       58
       58
        
       

     

       59
       59
        
             extraPackages = mkOption {

     

       60
       60
        
               type = types.listOf types.package;

     

       61
       61
        
               default = with pkgs; [ nettools nmap traceroute ];

     

       62
       62
       -
               defaultText = "[ nettools nmap traceroute ]";

     

       62
       62
       +
               defaultText = literalExpression "[ nettools nmap traceroute ]";

     

       63
       63
        
               description = ''

     

       64
       64
        
                 Packages to be added to the Zabbix <envar>PATH</envar>.

     

       65
       65
        
                 Typically used to add executables for scripts, but can be anything.

     
···

       70
       70
        
               type = types.attrsOf types.package;

     

       71
       71
        
               description = "A set of modules to load.";

     

       72
       72
        
               default = {};

     

       73
       73
       -
               example = literalExample ''

     

       73
       73
       +
               example = literalExpression ''

     

       74
       74
        
                 {

     

       75
       75
        
                   "dummy.so" = pkgs.stdenv.mkDerivation {

     

       76
       76
        
                     name = "zabbix-dummy-module-''${cfg.package.version}";

     
···

       109
       109
        
               name = mkOption {

     

       110
       110
        
                 type = types.str;

     

       111
       111
        
                 default = if cfg.database.type == "sqlite" then "${stateDir}/zabbix.db" else "zabbix";

     

       112
       112
       -
                 defaultText = "zabbix";

     

       112
       112
       +
                 defaultText = literalExpression "zabbix";

     

       113
       113
        
                 description = "Database name.";

     

       114
       114
        
               };

     

       115
       115

+4 -4

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

···

       6
       6
        
         mysql = config.services.mysql;

     

       7
       7
        
       

     

       8
       8
        
         inherit (lib) mkAfter mkDefault mkEnableOption mkIf mkMerge mkOption;

     

       9
       9
       -
         inherit (lib) attrValues concatMapStringsSep getName literalExample optional optionalAttrs optionalString types;

     

       9
       9
       +
         inherit (lib) attrValues concatMapStringsSep getName literalExpression optional optionalAttrs optionalString types;

     

       10
       10
        
         inherit (lib.generators) toKeyValue;

     

       11
       11
        
       

     

       12
       12
        
         user = "zabbix";

     
···

       44
       44
        
             package = mkOption {

     

       45
       45
        
               type = types.package;

     

       46
       46
        
               default = if cfg.database.type == "mysql" then pkgs.zabbix.server-mysql else pkgs.zabbix.server-pgsql;

     

       47
       47
       -
               defaultText = "pkgs.zabbix.server-pgsql";

     

       47
       47
       +
               defaultText = literalExpression "pkgs.zabbix.server-pgsql";

     

       48
       48
        
               description = "The Zabbix package to use.";

     

       49
       49
        
             };

     

       50
       50
        
       

     

       51
       51
        
             extraPackages = mkOption {

     

       52
       52
        
               type = types.listOf types.package;

     

       53
       53
        
               default = with pkgs; [ nettools nmap traceroute ];

     

       54
       54
       -
               defaultText = "[ nettools nmap traceroute ]";

     

       54
       54
       +
               defaultText = literalExpression "[ nettools nmap traceroute ]";

     

       55
       55
        
               description = ''

     

       56
       56
        
                 Packages to be added to the Zabbix <envar>PATH</envar>.

     

       57
       57
        
                 Typically used to add executables for scripts, but can be anything.

     
···

       62
       62
        
               type = types.attrsOf types.package;

     

       63
       63
        
               description = "A set of modules to load.";

     

       64
       64
        
               default = {};

     

       65
       65
       -
               example = literalExample ''

     

       65
       65
       +
               example = literalExpression ''

     

       66
       66
        
                 {

     

       67
       67
        
                   "dummy.so" = pkgs.stdenv.mkDerivation {

     

       68
       68
        
                     name = "zabbix-dummy-module-''${cfg.package.version}";

+11 -21

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

···

       97
       97
        
             mgrModulePath = mkOption {

     

       98
       98
        
               type = types.path;

     

       99
       99
        
               default = "${pkgs.ceph.lib}/lib/ceph/mgr";

     

       100
       100
       +
               defaultText = literalExpression ''"''${pkgs.ceph.lib}/lib/ceph/mgr"'';

     

       100
       101
        
               description = ''

     

       101
       102
        
                 Path at which to find ceph-mgr modules.

     

       102
       103
        
               '';

     
···

       181
       182
        
             rgwMimeTypesFile = mkOption {

     

       182
       183
        
               type = with types; nullOr path;

     

       183
       184
        
               default = "${pkgs.mime-types}/etc/mime.types";

     

       185
       185
       +
               defaultText = literalExpression ''"''${pkgs.mime-types}/etc/mime.types"'';

     

       184
       186
        
               description = ''

     

       185
       187
        
                 Path to mime types used by radosgw.

     

       186
       188
        
               '';

     
···

       190
       192
        
           extraConfig = mkOption {

     

       191
       193
        
             type = with types; attrsOf str;

     

       192
       194
        
             default = {};

     

       193
       193
       -
             example = ''

     

       194
       194
       -
               {

     

       195
       195
       -
                 "ms bind ipv6" = "true";

     

       196
       196
       -
               };

     

       197
       197
       -
             '';

     

       195
       195
       +
             example = {

     

       196
       196
       +
               "ms bind ipv6" = "true";

     

       197
       197
       +
             };

     

       198
       198
        
             description = ''

     

       199
       199
        
               Extra configuration to add to the global section. Use for setting values that are common for all daemons in the cluster.

     

       200
       200
        
             '';

     
···

       205
       205
        
             daemons = mkOption {

     

       206
       206
        
               type = with types; listOf str;

     

       207
       207
        
               default = [];

     

       208
       208
       -
               example = ''

     

       209
       209
       -
                 [ "name1" "name2" ];

     

       210
       210
       -
               '';

     

       208
       208
       +
               example = [ "name1" "name2" ];

     

       211
       209
        
               description = ''

     

       212
       210
        
                 A list of names for manager daemons that should have a service created. The names correspond

     

       213
       211
        
                 to the id part in ceph i.e. [ "name1" ] would result in mgr.name1

     
···

       227
       225
        
             daemons = mkOption {

     

       228
       226
        
               type = with types; listOf str;

     

       229
       227
        
               default = [];

     

       230
       230
       -
               example = ''

     

       231
       231
       -
                 [ "name1" "name2" ];

     

       232
       232
       -
               '';

     

       228
       228
       +
               example = [ "name1" "name2" ];

     

       233
       229
        
               description = ''

     

       234
       230
        
                 A list of monitor daemons that should have a service created. The names correspond

     

       235
       231
        
                 to the id part in ceph i.e. [ "name1" ] would result in mon.name1

     
···

       249
       245
        
             daemons = mkOption {

     

       250
       246
        
               type = with types; listOf str;

     

       251
       247
        
               default = [];

     

       252
       252
       -
               example = ''

     

       253
       253
       -
                 [ "name1" "name2" ];

     

       254
       254
       -
               '';

     

       248
       248
       +
               example = [ "name1" "name2" ];

     

       255
       249
        
               description = ''

     

       256
       250
        
                 A list of OSD daemons that should have a service created. The names correspond

     

       257
       251
        
                 to the id part in ceph i.e. [ "name1" ] would result in osd.name1

     
···

       279
       273
        
             daemons = mkOption {

     

       280
       274
        
               type = with types; listOf str;

     

       281
       275
        
               default = [];

     

       282
       282
       -
               example = ''

     

       283
       283
       -
                 [ "name1" "name2" ];

     

       284
       284
       -
               '';

     

       276
       276
       +
               example = [ "name1" "name2" ];

     

       285
       277
        
               description = ''

     

       286
       278
        
                 A list of metadata service daemons that should have a service created. The names correspond

     

       287
       279
        
                 to the id part in ceph i.e. [ "name1" ] would result in mds.name1

     
···

       301
       293
        
             daemons = mkOption {

     

       302
       294
        
               type = with types; listOf str;

     

       303
       295
        
               default = [];

     

       304
       304
       -
               example = ''

     

       305
       305
       -
                 [ "name1" "name2" ];

     

       306
       306
       -
               '';

     

       296
       296
       +
               example = [ "name1" "name2" ];

     

       307
       297
        
               description = ''

     

       308
       298
        
                 A list of rados gateway daemons that should have a service created. The names correspond

     

       309
       299
        
                 to the id part in ceph i.e. [ "name1" ] would result in client.name1, radosgw daemons

     
···

       318
       308
        
             extraConfig = mkOption {

     

       319
       309
        
               type = with types; attrsOf (attrsOf str);

     

       320
       310
        
               default = {};

     

       321
       321
       -
               example = ''

     

       311
       311
       +
               example = literalExpression ''

     

       322
       312
        
                 {

     

       323
       313
        
                   # This would create a section for a radosgw daemon named node0 and related

     

       324
       314
        
                   # configuration for it

-3

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

···

       113
       113
        
               type = types.nullOr (types.submodule {

     

       114
       114
        
                 options = {

     

       115
       115
        
                   tlsKeyPath = mkOption {

     

       116
       116
       -
                     default = null;

     

       117
       116
        
                     type = types.str;

     

       118
       117
        
                     description = "Path to the private key used for TLS.";

     

       119
       118
        
                   };

     

       120
       119
        
       

     

       121
       120
        
                   tlsPem = mkOption {

     

       122
       122
       -
                     default = null;

     

       123
       121
        
                     type = types.path;

     

       124
       122
        
                     description = "Path to the certificate used for TLS.";

     

       125
       123
        
                   };

     

       126
       124
        
       

     

       127
       125
        
                   caCert = mkOption {

     

       128
       128
       -
                     default = null;

     

       129
       126
        
                     type = types.path;

     

       130
       127
        
                     description = "Path certificate authority used to sign the cluster certificates.";

     

       131
       128
        
                   };

+1 -1

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

···

       57
       57
        
             package = mkOption {

     

       58
       58
        
               type = types.package;

     

       59
       59
        
               default = pkgs.ipfs;

     

       60
       60
       -
               defaultText = "pkgs.ipfs";

     

       60
       60
       +
               defaultText = literalExpression "pkgs.ipfs";

     

       61
       61
        
               description = "Which IPFS package to use.";

     

       62
       62
        
             };

     

       63
       63

+1 -1

nixos/modules/services/network-filesystems/litestream/default.nix

···

       13
       13
        
           package = mkOption {

     

       14
       14
        
             description = "Package to use.";

     

       15
       15
        
             default = pkgs.litestream;

     

       16
       16
       -
             defaultText = "pkgs.litestream";

     

       16
       16
       +
             defaultText = literalExpression "pkgs.litestream";

     

       17
       17
        
             type = types.package;

     

       18
       18
        
           };

     

       19
       19

+7 -8

nixos/modules/services/network-filesystems/openafs/client.nix

···

       4
       4
        
       with import ./lib.nix { inherit config lib pkgs; };

     

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
       -
         inherit (lib) getBin mkOption mkIf optionalString singleton types;

     

       7
       7
       +
         inherit (lib) getBin literalExpression mkOption mkIf optionalString singleton types;

     

       8
       8
        
       

     

       9
       9
        
         cfg = config.services.openafsClient;

     

       10
       10
        
       

     
···

       57
       57
        
                 CellServDB. See CellServDB(5) man page for syntax. Ignored when

     

       58
       58
        
                 <literal>afsdb</literal> is set to <literal>true</literal>.

     

       59
       59
        
               '';

     

       60
       60
       -
               example = ''

     

       61
       61
       -
                 [ { ip = "1.2.3.4"; dnsname = "first.afsdb.server.dns.fqdn.org"; }

     

       62
       62
       -
                   { ip = "2.3.4.5"; dnsname = "second.afsdb.server.dns.fqdn.org"; }

     

       63
       63
       -
                 ]

     

       64
       64
       -
               '';

     

       60
       60
       +
               example = [

     

       61
       61
       +
                 { ip = "1.2.3.4"; dnsname = "first.afsdb.server.dns.fqdn.org"; }

     

       62
       62
       +
                 { ip = "2.3.4.5"; dnsname = "second.afsdb.server.dns.fqdn.org"; }

     

       63
       63
       +
               ];

     

       65
       64
        
             };

     

       66
       65
        
       

     

       67
       66
        
             cache = {

     
···

       149
       148
        
             packages = {

     

       150
       149
        
               module = mkOption {

     

       151
       150
        
                 default = config.boot.kernelPackages.openafs;

     

       152
       152
       -
                 defaultText = "config.boot.kernelPackages.openafs";

     

       151
       151
       +
                 defaultText = literalExpression "config.boot.kernelPackages.openafs";

     

       153
       152
        
                 type = types.package;

     

       154
       153
        
                 description = "OpenAFS kernel module package. MUST match the userland package!";

     

       155
       154
        
               };

     

       156
       155
        
               programs = mkOption {

     

       157
       156
        
                 default = getBin pkgs.openafs;

     

       158
       158
       -
                 defaultText = "getBin pkgs.openafs";

     

       157
       157
       +
                 defaultText = literalExpression "getBin pkgs.openafs";

     

       159
       158
        
                 type = types.package;

     

       160
       159
        
                 description = "OpenAFS programs package. MUST match the kernel module package!";

     

       161
       160
        
               };

+2 -2

nixos/modules/services/network-filesystems/openafs/server.nix

···

       4
       4
        
       with import ./lib.nix { inherit config lib pkgs; };

     

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
       -
         inherit (lib) concatStringsSep mkIf mkOption optionalString types;

     

       7
       7
       +
         inherit (lib) concatStringsSep literalExpression mkIf mkOption optionalString types;

     

       8
       8
        
       

     

       9
       9
        
         bosConfig = pkgs.writeText "BosConfig" (''

     

       10
       10
        
           restrictmode 1

     
···

       81
       81
        
       

     

       82
       82
        
             package = mkOption {

     

       83
       83
        
               default = pkgs.openafs.server or pkgs.openafs;

     

       84
       84
       -
               defaultText = "pkgs.openafs.server or pkgs.openafs";

     

       84
       84
       +
               defaultText = literalExpression "pkgs.openafs.server or pkgs.openafs";

     

       85
       85
        
               type = types.package;

     

       86
       86
        
               description = "OpenAFS package for the server binaries";

     

       87
       87
        
             };

-1

nixos/modules/services/network-filesystems/orangefs/client.nix

···

       47
       47
        
       

     

       48
       48
        
                   target = mkOption {

     

       49
       49
        
                     type = types.str;

     

       50
       50
       -
                     default = null;

     

       51
       50
        
                     example = "tcp://server:3334/orangefs";

     

       52
       51
        
                     description = "Target URL";

     

       53
       52
        
                   };

+5 -8

nixos/modules/services/network-filesystems/orangefs/server.nix

···

       118
       118
        
             servers = mkOption {

     

       119
       119
        
               type = with types; attrsOf types.str;

     

       120
       120
        
               default = {};

     

       121
       121
       -
               example = ''

     

       122
       122
       -
                 {

     

       123
       123
       -
                   node1="tcp://node1:3334";

     

       124
       124
       -
                   node2="tcp://node2:3334";

     

       125
       125
       -
                 }

     

       126
       126
       -
               '';

     

       121
       121
       +
               example = {

     

       122
       122
       +
                 node1 = "tcp://node1:3334";

     

       123
       123
       +
                 node2 = "tcp://node2:3334";

     

       124
       124
       +
               };

     

       127
       125
        
               description = "URLs for storage server including port. The attribute names define the server alias.";

     

       128
       126
        
             };

     

       129
       127
        
       

     
···

       132
       130
        
                 These options will create the <literal>&lt;FileSystem&gt;</literal> sections of config file.

     

       133
       131
        
               '';

     

       134
       132
        
               default = { orangefs = {}; };

     

       135
       135
       -
               defaultText = literalExample "{ orangefs = {}; }";

     

       136
       136
       -
               example = literalExample ''

     

       133
       133
       +
               example = literalExpression ''

     

       137
       134
        
                 {

     

       138
       135
        
                   fs1 = {

     

       139
       136
        
                     id = 101;

+3 -3

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

···

       117
       117
        
             package = mkOption {

     

       118
       118
        
               type = types.package;

     

       119
       119
        
               default = pkgs.samba;

     

       120
       120
       -
               defaultText = "pkgs.samba";

     

       121
       121
       -
               example = literalExample "pkgs.samba4Full";

     

       120
       120
       +
               defaultText = literalExpression "pkgs.samba";

     

       121
       121
       +
               example = literalExpression "pkgs.samba4Full";

     

       122
       122
        
               description = ''

     

       123
       123
        
                 Defines which package should be used for the samba server.

     

       124
       124
        
               '';

     
···

       176
       176
        
                 See <command>man smb.conf</command> for options.

     

       177
       177
        
               '';

     

       178
       178
        
               type = types.attrsOf (types.attrsOf types.unspecified);

     

       179
       179
       -
               example = literalExample ''

     

       179
       179
       +
               example = literalExpression ''

     

       180
       180
        
                 { public =

     

       181
       181
        
                   { path = "/srv/public";

     

       182
       182
        
                     "read only" = true;

+2 -4

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

···

       34
       34
        
                   };

     

       35
       35
        
                   package = mkOption {

     

       36
       36
        
                     default = pkgs.tahoelafs;

     

       37
       37
       -
                     defaultText = "pkgs.tahoelafs";

     

       37
       37
       +
                     defaultText = literalExpression "pkgs.tahoelafs";

     

       38
       38
        
                     type = types.package;

     

       39
       39
       -
                     example = literalExample "pkgs.tahoelafs";

     

       40
       39
        
                     description = ''

     

       41
       40
        
                       The package to use for the Tahoe LAFS daemon.

     

       42
       41
        
                     '';

     
···

       179
       178
        
                   };

     

       180
       179
        
                   package = mkOption {

     

       181
       180
        
                     default = pkgs.tahoelafs;

     

       182
       182
       -
                     defaultText = "pkgs.tahoelafs";

     

       181
       181
       +
                     defaultText = literalExpression "pkgs.tahoelafs";

     

       183
       182
        
                     type = types.package;

     

       184
       184
       -
                     example = literalExample "pkgs.tahoelafs";

     

       185
       183
        
                     description = ''

     

       186
       184
        
                       The package to use for the Tahoe LAFS daemon.

     

       187
       185
        
                     '';

+2 -2

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

···

       142
       142
        
                 '';

     

       143
       143
        
               };

     

       144
       144
        
               syncMode = mkOption {

     

       145
       145
       -
                 type = types.enum [ "ASYNC" "SYNC_WRITE_METADATA" "SYNC_WRITE" "FDATASYNC" "ASYNC" ];

     

       145
       145
       +
                 type = types.enum [ "ASYNC" "SYNC_WRITE_METADATA" "SYNC_WRITE" "FDATASYNC" "FSYNC" ];

     

       146
       146
        
                 default = "FSYNC";

     

       147
       147
        
                 example = "FDATASYNC";

     

       148
       148
        
                 description = ''

     
···

       268
       268
        
               };

     

       269
       269
        
               syncMode = mkOption {

     

       270
       270
        
                 default = "FSYNC";

     

       271
       271
       -
                 type = types.enum [ "ASYNC" "SYNC_WRITE_METADATA" "SYNC_WRITE" "FDATASYNC" "ASYNC" ];

     

       271
       271
       +
                 type = types.enum [ "ASYNC" "SYNC_WRITE_METADATA" "SYNC_WRITE" "FDATASYNC" "FSYNC" ];

     

       272
       272
        
                 example = "FDATASYNC";

     

       273
       273
        
                 description = ''

     

       274
       274
        
                   The sync mode influences how operations are committed to the disk

+3 -16

nixos/modules/services/networking/3proxy.nix

···

       205
       205
        
                     };

     

       206
       206
        
                   });

     

       207
       207
        
                   default = [ ];

     

       208
       208
       -
                   example = literalExample ''

     

       208
       208
       +
                   example = literalExpression ''

     

       209
       209
        
                     [

     

       210
       210
        
                       {

     

       211
       211
        
                         rule = "allow";

     
···

       244
       244
        
               };

     

       245
       245
        
             });

     

       246
       246
        
             default = [ ];

     

       247
       247
       -
             example = literalExample ''

     

       247
       247
       +
             example = literalExpression ''

     

       248
       248
        
               [

     

       249
       249
        
                 {

     

       250
       250
        
                   type = "proxy";

     
···

       290
       290
        
               "::1"

     

       291
       291
        
               "fc00::/7"

     

       292
       292
        
             ];

     

       293
       293
       -
             example = [

     

       294
       294
       -
               "0.0.0.0/8"

     

       295
       295
       -
               "127.0.0.0/8"

     

       296
       296
       -
               "10.0.0.0/8"

     

       297
       297
       -
               "100.64.0.0/10"

     

       298
       298
       -
               "172.16.0.0/12"

     

       299
       299
       -
               "192.168.0.0/16"

     

       300
       300
       -
               "::"

     

       301
       301
       -
               "::1"

     

       302
       302
       -
               "fc00::/7"

     

       303
       303
       -
             ];

     

       304
       293
        
             description = ''

     

       305
       294
        
               What IP ranges to deny access when denyPrivate is set tu true.

     

       306
       295
        
             '';

     
···

       322
       311
        
                 nscache = mkOption {

     

       323
       312
        
                   type = types.int;

     

       324
       313
        
                   default = 65535;

     

       325
       325
       -
                   example = 65535;

     

       326
       314
        
                   description = "Set name cache size for IPv4.";

     

       327
       315
        
                 };

     

       328
       316
        
                 nscache6 = mkOption {

     

       329
       317
        
                   type = types.int;

     

       330
       318
        
                   default = 65535;

     

       331
       331
       -
                   example = 65535;

     

       332
       319
        
                   description = "Set name cache size for IPv6.";

     

       333
       320
        
                 };

     

       334
       321
        
                 nsrecord = mkOption {

     

       335
       322
        
                   type = types.attrsOf types.str;

     

       336
       323
        
                   default = { };

     

       337
       337
       -
                   example = literalExample ''

     

       324
       324
       +
                   example = literalExpression ''

     

       338
       325
        
                     {

     

       339
       326
        
                       "files.local" = "192.168.1.12";

     

       340
       327
        
                       "site.local" = "192.168.1.43";

+2 -2

nixos/modules/services/networking/asterisk.nix

···

       115
       115
        
             confFiles = mkOption {

     

       116
       116
        
               default = {};

     

       117
       117
        
               type = types.attrsOf types.str;

     

       118
       118
       -
               example = literalExample

     

       118
       118
       +
               example = literalExpression

     

       119
       119
        
                 ''

     

       120
       120
        
                   {

     

       121
       121
        
                     "extensions.conf" = '''

     
···

       200
       200
        
             package = mkOption {

     

       201
       201
        
               type = types.package;

     

       202
       202
        
               default = pkgs.asterisk;

     

       203
       203
       -
               defaultText = "pkgs.asterisk";

     

       203
       203
       +
               defaultText = literalExpression "pkgs.asterisk";

     

       204
       204
        
               description = "The Asterisk package to use.";

     

       205
       205
        
             };

     

       206
       206
        
           };

+1 -1

nixos/modules/services/networking/atftpd.nix

···

       28
       28
        
             extraOptions = mkOption {

     

       29
       29
        
               default = [];

     

       30
       30
        
               type = types.listOf types.str;

     

       31
       31
       -
               example = literalExample ''

     

       31
       31
       +
               example = literalExpression ''

     

       32
       32
        
                 [ "--bind-address 192.168.9.1"

     

       33
       33
        
                   "--verbose=7"

     

       34
       34
        
                 ]

+3 -3

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

···

       54
       54
        
           hostName = mkOption {

     

       55
       55
        
             type = types.str;

     

       56
       56
        
             default = config.networking.hostName;

     

       57
       57
       -
             defaultText = literalExample "config.networking.hostName";

     

       57
       57
       +
             defaultText = literalExpression "config.networking.hostName";

     

       58
       58
        
             description = ''

     

       59
       59
        
               Host name advertised on the LAN. If not set, avahi will use the value

     

       60
       60
        
               of <option>config.networking.hostName</option>.

     
···

       87
       87
        
           ipv6 = mkOption {

     

       88
       88
        
             type = types.bool;

     

       89
       89
        
             default = config.networking.enableIPv6;

     

       90
       90
       -
             defaultText = "config.networking.enableIPv6";

     

       90
       90
       +
             defaultText = literalExpression "config.networking.enableIPv6";

     

       91
       91
        
             description = "Whether to use IPv6.";

     

       92
       92
        
           };

     

       93
       93
        
       

     
···

       134
       134
        
           extraServiceFiles = mkOption {

     

       135
       135
        
             type = with types; attrsOf (either str path);

     

       136
       136
        
             default = {};

     

       137
       137
       -
             example = literalExample ''

     

       137
       137
       +
             example = literalExpression ''

     

       138
       138
        
               {

     

       139
       139
        
                 ssh = "''${pkgs.avahi}/etc/avahi/services/ssh.service";

     

       140
       140
        
                 smb = '''

+2 -2

nixos/modules/services/networking/bee.nix

···

       20
       20
        
             package = mkOption {

     

       21
       21
        
               type = types.package;

     

       22
       22
        
               default = pkgs.bee;

     

       23
       23
       -
               defaultText = "pkgs.bee";

     

       24
       24
       -
               example = "pkgs.bee-unstable";

     

       23
       23
       +
               defaultText = literalExpression "pkgs.bee";

     

       24
       24
       +
               example = literalExpression "pkgs.bee-unstable";

     

       25
       25
        
               description = "The package providing the bee binary for the service.";

     

       26
       26
        
             };

     

       27
       27

+1

nixos/modules/services/networking/biboumi.nix

···

       107
       107
        
                 options.policy_directory = mkOption {

     

       108
       108
        
                   type = types.path;

     

       109
       109
        
                   default = "${pkgs.biboumi}/etc/biboumi";

     

       110
       110
       +
                   defaultText = literalExpression ''"''${pkgs.biboumi}/etc/biboumi"'';

     

       110
       111
        
                   description = ''

     

       111
       112
        
                     A directory that should contain the policy files,

     

       112
       113
        
                     used to customize Botan’s behaviour

+2 -2

nixos/modules/services/networking/bind.nix

···

       110
       110
        
             package = mkOption {

     

       111
       111
        
               type = types.package;

     

       112
       112
        
               default = pkgs.bind;

     

       113
       113
       -
               defaultText = "pkgs.bind";

     

       113
       113
       +
               defaultText = literalExpression "pkgs.bind";

     

       114
       114
        
               description = "The BIND package to use.";

     

       115
       115
        
             };

     

       116
       116
        
       

     
···

       209
       209
        
             configFile = mkOption {

     

       210
       210
        
               type = types.path;

     

       211
       211
        
               default = confFile;

     

       212
       212
       -
               defaultText = "confFile";

     

       212
       212
       +
               defaultText = literalExpression "confFile";

     

       213
       213
        
               description = "

     

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

     

       215
       215
        
                 generated by nixos.

+2 -2

nixos/modules/services/networking/bitcoind.nix

···

       40
       40
        
             package = mkOption {

     

       41
       41
        
               type = types.package;

     

       42
       42
        
               default = pkgs.bitcoind;

     

       43
       43
       -
               defaultText = "pkgs.bitcoind";

     

       43
       43
       +
               defaultText = literalExpression "pkgs.bitcoind";

     

       44
       44
        
               description = "The package providing bitcoin binaries.";

     

       45
       45
        
             };

     

       46
       46
        
       

     
···

       88
       88
        
               };

     

       89
       89
        
               users = mkOption {

     

       90
       90
        
                 default = {};

     

       91
       91
       -
                 example = literalExample ''

     

       91
       91
       +
                 example = literalExpression ''

     

       92
       92
        
                   {

     

       93
       93
        
                     alice.passwordHMAC = "f7efda5c189b999524f151318c0c86$d5b51b3beffbc02b724e5d095828e0bc8b2456e9ac8757ae3211a5d9b16a22ae";

     

       94
       94
        
                     bob.passwordHMAC = "b2dd077cb54591a2f3139e69a897ac$4e71f08d48b4347cf8eff3815c0e25ae2e9a4340474079f55705f40574f4ec99";

+2 -2

nixos/modules/services/networking/bitlbee.nix

···

       109
       109
        
             plugins = mkOption {

     

       110
       110
        
               type = types.listOf types.package;

     

       111
       111
        
               default = [];

     

       112
       112
       -
               example = literalExample "[ pkgs.bitlbee-facebook ]";

     

       112
       112
       +
               example = literalExpression "[ pkgs.bitlbee-facebook ]";

     

       113
       113
        
               description = ''

     

       114
       114
        
                 The list of bitlbee plugins to install.

     

       115
       115
        
               '';

     
···

       118
       118
        
             libpurple_plugins = mkOption {

     

       119
       119
        
               type = types.listOf types.package;

     

       120
       120
        
               default = [];

     

       121
       121
       -
               example = literalExample "[ pkgs.purple-matrix ]";

     

       121
       121
       +
               example = literalExpression "[ pkgs.purple-matrix ]";

     

       122
       122
        
               description = ''

     

       123
       123
        
                 The list of libpurple plugins to install.

     

       124
       124
        
               '';

+6 -9

nixos/modules/services/networking/blockbook-frontend.nix

···

       15
       15
        
             package = mkOption {

     

       16
       16
        
               type = types.package;

     

       17
       17
        
               default = pkgs.blockbook;

     

       18
       18
       +
               defaultText = literalExpression "pkgs.blockbook";

     

       18
       19
        
               description = "Which blockbook package to use.";

     

       19
       20
        
             };

     

       20
       21
        
       

     
···

       50
       51
        
             coinName = mkOption {

     

       51
       52
        
               type = types.str;

     

       52
       53
        
               default = "Bitcoin";

     

       53
       53
       -
               example = "Bitcoin";

     

       54
       54
        
               description = ''

     

       55
       55
        
                 See <link xlink:href="https://github.com/trezor/blockbook/blob/master/bchain/coins/blockchain.go#L61"/>

     

       56
       56
        
                 for current of coins supported in master (Note: may differ from release).

     
···

       60
       60
        
             cssDir = mkOption {

     

       61
       61
        
               type = types.path;

     

       62
       62
        
               default = "${config.package}/share/css/";

     

       63
       63
       -
               example = "${config.dataDir}/static/css/";

     

       63
       63
       +
               defaultText = literalExpression ''"''${package}/share/css/"'';

     

       64
       64
       +
               example = literalExpression ''"''${dataDir}/static/css/"'';

     

       64
       65
        
               description = ''

     

       65
       66
        
                 Location of the dir with <filename>main.css</filename> CSS file.

     

       66
       67
        
                 By default, the one shipped with the package is used.

     
···

       82
       83
        
             internal = mkOption {

     

       83
       84
        
               type = types.nullOr types.str;

     

       84
       85
        
               default = ":9030";

     

       85
       85
       -
               example = ":9030";

     

       86
       86
        
               description = "Internal http server binding <literal>[address]:port</literal>.";

     

       87
       87
        
             };

     

       88
       88
        
       

     

       89
       89
        
             messageQueueBinding = mkOption {

     

       90
       90
        
               type = types.str;

     

       91
       91
        
               default = "tcp://127.0.0.1:38330";

     

       92
       92
       -
               example = "tcp://127.0.0.1:38330";

     

       93
       92
        
               description = "Message Queue Binding <literal>address:port</literal>.";

     

       94
       93
        
             };

     

       95
       94
        
       

     

       96
       95
        
             public = mkOption {

     

       97
       96
        
               type = types.nullOr types.str;

     

       98
       97
        
               default = ":9130";

     

       99
       99
       -
               example = ":9130";

     

       100
       98
        
               description = "Public http server binding <literal>[address]:port</literal>.";

     

       101
       99
        
             };

     

       102
       100
        
       

     
···

       116
       114
        
               user = mkOption {

     

       117
       115
        
                 type = types.str;

     

       118
       116
        
                 default = "rpc";

     

       119
       119
       -
                 example = "rpc";

     

       120
       117
        
                 description = "Username for JSON-RPC connections.";

     

       121
       118
        
               };

     

       122
       119
        
       

     

       123
       120
        
               password = mkOption {

     

       124
       121
        
                 type = types.str;

     

       125
       122
        
                 default = "rpc";

     

       126
       126
       -
                 example = "rpc";

     

       127
       123
        
                 description = ''

     

       128
       124
        
                   RPC password for JSON-RPC connections.

     

       129
       125
        
                   Warning: this is stored in cleartext in the Nix store!!!

     
···

       150
       146
        
             templateDir = mkOption {

     

       151
       147
        
               type = types.path;

     

       152
       148
        
               default = "${config.package}/share/templates/";

     

       153
       153
       -
               example = "${config.dataDir}/templates/static/";

     

       149
       149
       +
               defaultText = literalExpression ''"''${package}/share/templates/"'';

     

       150
       150
       +
               example = literalExpression ''"''${dataDir}/templates/static/"'';

     

       154
       151
        
               description = "Location of the HTML templates. By default, ones shipped with the package are used.";

     

       155
       152
        
             };

     

       156
       153
        
       

     

       157
       154
        
             extraConfig = mkOption {

     

       158
       155
        
               type = types.attrs;

     

       159
       156
        
               default = {};

     

       160
       160
       -
               example = literalExample '' {

     

       157
       157
       +
               example = literalExpression '' {

     

       161
       158
        
                 "alternative_estimate_fee" = "whatthefee-disabled";

     

       162
       159
        
                 "alternative_estimate_fee_params" = "{\"url\": \"https://whatthefee.io/data.json\", \"periodSeconds\": 60}";

     

       163
       160
        
                 "fiat_rates" = "coingecko";

+2 -2

nixos/modules/services/networking/cjdns.nix

···

       150
       150
        
               connectTo = mkOption {

     

       151
       151
        
                 type = types.attrsOf ( types.submodule ( connectToSubmodule ) );

     

       152
       152
        
                 default = { };

     

       153
       153
       -
                 example = literalExample ''

     

       153
       153
       +
                 example = literalExpression ''

     

       154
       154
        
                   {

     

       155
       155
        
                     "192.168.1.1:27313" = {

     

       156
       156
        
                       hostname = "homer.hype";

     
···

       197
       197
        
               connectTo = mkOption {

     

       198
       198
        
                 type = types.attrsOf ( types.submodule ( connectToSubmodule ) );

     

       199
       199
        
                 default = { };

     

       200
       200
       -
                 example = literalExample ''

     

       200
       200
       +
                 example = literalExpression ''

     

       201
       201
        
                   {

     

       202
       202
        
                     "01:02:03:04:05:06" = {

     

       203
       203
        
                       hostname = "homer.hype";

+3 -2

nixos/modules/services/networking/connman.nix

···

       77
       77
        
             };

     

       78
       78
        
       

     

       79
       79
        
             package = mkOption {

     

       80
       80
       -
               type = types.path;

     

       80
       80
       +
               type = types.package;

     

       81
       81
        
               description = "The connman package / build flavor";

     

       82
       82
        
               default = connman;

     

       83
       83
       -
               example = literalExample "pkgs.connmanFull";

     

       83
       83
       +
               defaultText = literalExpression "pkgs.connman";

     

       84
       84
       +
               example = literalExpression "pkgs.connmanFull";

     

       84
       85
        
             };

     

       85
       86
        
       

     

       86
       87
        
           };

+2 -2

nixos/modules/services/networking/consul.nix

···

       34
       34
        
             package = mkOption {

     

       35
       35
        
               type = types.package;

     

       36
       36
        
               default = pkgs.consul;

     

       37
       37
       -
               defaultText = "pkgs.consul";

     

       37
       37
       +
               defaultText = literalExpression "pkgs.consul";

     

       38
       38
        
               description = ''

     

       39
       39
        
                 The package used for the Consul agent and CLI.

     

       40
       40
        
               '';

     
···

       121
       121
        
               package = mkOption {

     

       122
       122
        
                 description = "Package to use for consul-alerts.";

     

       123
       123
        
                 default = pkgs.consul-alerts;

     

       124
       124
       -
                 defaultText = "pkgs.consul-alerts";

     

       124
       124
       +
                 defaultText = literalExpression "pkgs.consul-alerts";

     

       125
       125
        
                 type = types.package;

     

       126
       126
        
               };

     

       127
       127

+1 -1

nixos/modules/services/networking/coredns.nix

···

       22
       22
        
       

     

       23
       23
        
           package = mkOption {

     

       24
       24
        
             default = pkgs.coredns;

     

       25
       25
       -
             defaultText = "pkgs.coredns";

     

       25
       25
       +
             defaultText = literalExpression "pkgs.coredns";

     

       26
       26
        
             type = types.package;

     

       27
       27
        
             description = "Coredns package to use.";

     

       28
       28
        
           };

+3 -3

nixos/modules/services/networking/corerad.nix

···

       14
       14
        
       

     

       15
       15
        
           settings = mkOption {

     

       16
       16
        
             type = settingsFormat.type;

     

       17
       17
       -
             example = literalExample ''

     

       17
       17
       +
             example = literalExpression ''

     

       18
       18
        
               {

     

       19
       19
        
                 interfaces = [

     

       20
       20
        
                   # eth0 is an upstream interface monitoring for IPv6 router advertisements.

     
···

       44
       44
        
       

     

       45
       45
        
           configFile = mkOption {

     

       46
       46
        
             type = types.path;

     

       47
       47
       -
             example = literalExample "\"\${pkgs.corerad}/etc/corerad/corerad.toml\"";

     

       47
       47
       +
             example = literalExpression ''"''${pkgs.corerad}/etc/corerad/corerad.toml"'';

     

       48
       48
        
             description = "Path to CoreRAD TOML configuration file.";

     

       49
       49
        
           };

     

       50
       50
        
       

     

       51
       51
        
           package = mkOption {

     

       52
       52
        
             default = pkgs.corerad;

     

       53
       53
       -
             defaultText = literalExample "pkgs.corerad";

     

       53
       53
       +
             defaultText = literalExpression "pkgs.corerad";

     

       54
       54
        
             type = types.package;

     

       55
       55
        
             description = "CoreRAD package to use.";

     

       56
       56
        
           };

+2 -2

nixos/modules/services/networking/coturn.nix

···

       68
       68
        
             alt-listening-port = mkOption {

     

       69
       69
        
               type = types.int;

     

       70
       70
        
               default = cfg.listening-port + 1;

     

       71
       71
       -
               defaultText = "listening-port + 1";

     

       71
       71
       +
               defaultText = literalExpression "listening-port + 1";

     

       72
       72
        
               description = ''

     

       73
       73
        
                 Alternative listening port for UDP and TCP listeners;

     

       74
       74
        
                 default (or zero) value means "listening port plus one".

     
···

       83
       83
        
             alt-tls-listening-port = mkOption {

     

       84
       84
        
               type = types.int;

     

       85
       85
        
               default = cfg.tls-listening-port + 1;

     

       86
       86
       -
               defaultText = "tls-listening-port + 1";

     

       86
       86
       +
               defaultText = literalExpression "tls-listening-port + 1";

     

       87
       87
        
               description = ''

     

       88
       88
        
                 Alternative listening port for TLS and DTLS protocols.

     

       89
       89
        
               '';

+1 -1

nixos/modules/services/networking/dnscache.nix

···

       61
       61
        
                 Table of {hostname: server} pairs to use as authoritative servers for hosts (and subhosts).

     

       62
       62
        
                 If entry for @ is not specified predefined list of root servers is used.

     

       63
       63
        
               '';

     

       64
       64
       -
               example = literalExample ''

     

       64
       64
       +
               example = literalExpression ''

     

       65
       65
        
                 {

     

       66
       66
        
                   "@" = ["8.8.8.8" "8.8.4.4"];

     

       67
       67
        
                   "example.com" = ["192.168.100.100"];

+3 -3

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

···

       13
       13
        
               Attrset that is converted and passed as TOML config file.

     

       14
       14
        
               For available params, see: <link xlink:href="https://github.com/DNSCrypt/dnscrypt-proxy/blob/${pkgs.dnscrypt-proxy2.version}/dnscrypt-proxy/example-dnscrypt-proxy.toml"/>

     

       15
       15
        
             '';

     

       16
       16
       -
             example = literalExample ''

     

       16
       16
       +
             example = literalExpression ''

     

       17
       17
        
               {

     

       18
       18
        
                 sources.public-resolvers = {

     

       19
       19
        
                   urls = [ "https://download.dnscrypt.info/resolvers-list/v2/public-resolvers.md" ];

     
···

       29
       29
        
       

     

       30
       30
        
           upstreamDefaults = mkOption {

     

       31
       31
        
             description = ''

     

       32
       32
       -
               Whether to base the config declared in <literal>services.dnscrypt-proxy2.settings</literal> on the upstream example config (<link xlink:href="https://github.com/DNSCrypt/dnscrypt-proxy/blob/master/dnscrypt-proxy/example-dnscrypt-proxy.toml"/>)

     

       32
       32
       +
               Whether to base the config declared in <option>services.dnscrypt-proxy2.settings</option> on the upstream example config (<link xlink:href="https://github.com/DNSCrypt/dnscrypt-proxy/blob/master/dnscrypt-proxy/example-dnscrypt-proxy.toml"/>)

     

       33
       33
        
       

     

       34
       34
        
               Disable this if you want to declare your dnscrypt config from scratch.

     

       35
       35
        
             '';

     
···

       56
       56
        
               ''}

     

       57
       57
        
               ${pkgs.remarshal}/bin/json2toml < config.json > $out

     

       58
       58
        
             '';

     

       59
       59
       -
             defaultText = literalExample "TOML file generated from services.dnscrypt-proxy2.settings";

     

       59
       59
       +
             defaultText = literalDocBook "TOML file generated from <option>services.dnscrypt-proxy2.settings</option>";

     

       60
       60
        
           };

     

       61
       61
        
         };

     

       62
       62

+1 -1

nixos/modules/services/networking/doh-proxy-rust.nix

···

       15
       15
        
           flags = mkOption {

     

       16
       16
        
             type = types.listOf types.str;

     

       17
       17
        
             default = [];

     

       18
       18
       -
             example = literalExample [ "--server-address=9.9.9.9:53" ];

     

       18
       18
       +
             example = [ "--server-address=9.9.9.9:53" ];

     

       19
       19
        
             description = ''

     

       20
       20
        
               A list of command-line flags to pass to doh-proxy. For details on the

     

       21
       21
        
               available options, see <link xlink:href="https://github.com/jedisct1/doh-server#usage"/>.

+2 -2

nixos/modules/services/networking/ejabberd.nix

···

       32
       32
        
             package = mkOption {

     

       33
       33
        
               type = types.package;

     

       34
       34
        
               default = pkgs.ejabberd;

     

       35
       35
       -
               defaultText = "pkgs.ejabberd";

     

       35
       35
       +
               defaultText = literalExpression "pkgs.ejabberd";

     

       36
       36
        
               description = "ejabberd server package to use";

     

       37
       37
        
             };

     

       38
       38
        
       

     
···

       76
       76
        
               type = types.listOf types.path;

     

       77
       77
        
               default = [];

     

       78
       78
        
               description = "Configuration dumps that should be loaded on the first startup";

     

       79
       79
       -
               example = literalExample "[ ./myejabberd.dump ]";

     

       79
       79
       +
               example = literalExpression "[ ./myejabberd.dump ]";

     

       80
       80
        
             };

     

       81
       81
        
       

     

       82
       82
        
             imagemagick = mkOption {

+1

nixos/modules/services/networking/epmd.nix

···

       20
       20
        
           package = mkOption {

     

       21
       21
        
             type = types.package;

     

       22
       22
        
             default = pkgs.erlang;

     

       23
       23
       +
             defaultText = literalExpression "pkgs.erlang";

     

       23
       24
        
             description = ''

     

       24
       25
        
               The Erlang package to use to get epmd binary. That way you can re-use

     

       25
       26
        
               an Erlang runtime that is already installed for other purposes.

+2 -2

nixos/modules/services/networking/ferm.nix

···

       30
       30
        
             config = mkOption {

     

       31
       31
        
               description = "Verbatim ferm.conf configuration.";

     

       32
       32
        
               default = "";

     

       33
       33
       -
               defaultText = "empty firewall, allows any traffic";

     

       33
       33
       +
               defaultText = literalDocBook "empty firewall, allows any traffic";

     

       34
       34
        
               type = types.lines;

     

       35
       35
        
             };

     

       36
       36
        
             package = mkOption {

     

       37
       37
        
               description = "The ferm package.";

     

       38
       38
        
               type = types.package;

     

       39
       39
        
               default = pkgs.ferm;

     

       40
       40
       -
               defaultText = "pkgs.ferm";

     

       40
       40
       +
               defaultText = literalExpression "pkgs.ferm";

     

       41
       41
        
             };

     

       42
       42
        
           };

     

       43
       43
        
         };

+3 -3

nixos/modules/services/networking/firewall.nix

···

       325
       325
        
             package = mkOption {

     

       326
       326
        
               type = types.package;

     

       327
       327
        
               default = pkgs.iptables;

     

       328
       328
       -
               defaultText = "pkgs.iptables";

     

       329
       329
       -
               example = literalExample "pkgs.iptables-nftables-compat";

     

       328
       328
       +
               defaultText = literalExpression "pkgs.iptables";

     

       329
       329
       +
               example = literalExpression "pkgs.iptables-nftables-compat";

     

       330
       330
        
               description =

     

       331
       331
        
                 ''

     

       332
       332
        
                   The iptables package to use for running the firewall service."

     
···

       500
       500
        
             extraPackages = mkOption {

     

       501
       501
        
               type = types.listOf types.package;

     

       502
       502
        
               default = [ ];

     

       503
       503
       -
               example = literalExample "[ pkgs.ipset ]";

     

       503
       503
       +
               example = literalExpression "[ pkgs.ipset ]";

     

       504
       504
        
               description =

     

       505
       505
        
                 ''

     

       506
       506
        
                   Additional packages to be included in the environment of the system

+1 -1

nixos/modules/services/networking/flannel.nix

···

       20
       20
        
             description = "Package to use for flannel";

     

       21
       21
        
             type = types.package;

     

       22
       22
        
             default = pkgs.flannel;

     

       23
       23
       -
             defaultText = "pkgs.flannel";

     

       23
       23
       +
             defaultText = literalExpression "pkgs.flannel";

     

       24
       24
        
           };

     

       25
       25
        
       

     

       26
       26
        
           publicIp = mkOption {

+2 -2

nixos/modules/services/networking/ghostunnel.nix

···

       5
       5
        
           concatMap

     

       6
       6
        
           concatStringsSep

     

       7
       7
        
           escapeShellArg

     

       8
       8
       -
           literalExample

     

       8
       8
       +
           literalExpression

     

       9
       9
        
           mapAttrs'

     

       10
       10
        
           mkDefault

     

       11
       11
        
           mkEnableOption

     
···

       219
       219
        
             description = "The ghostunnel package to use.";

     

       220
       220
        
             type = types.package;

     

       221
       221
        
             default = pkgs.ghostunnel;

     

       222
       222
       -
             defaultText = literalExample ''pkgs.ghostunnel'';

     

       222
       222
       +
             defaultText = literalExpression "pkgs.ghostunnel";

     

       223
       223
        
           };

     

       224
       224
        
       

     

       225
       225
        
           services.ghostunnel.servers = mkOption {

+1 -1

nixos/modules/services/networking/globalprotect-vpn.nix

···

       21
       21
        
               as described at <link xlink:href="https://www.infradead.org/openconnect/hip.html" />

     

       22
       22
        
             '';

     

       23
       23
        
             default = null;

     

       24
       24
       -
             example = literalExample "\${pkgs.openconnect}/libexec/openconnect/hipreport.sh";

     

       24
       24
       +
             example = literalExpression ''"''${pkgs.openconnect}/libexec/openconnect/hipreport.sh"'';

     

       25
       25
        
             type = types.nullOr types.path;

     

       26
       26
        
           };

     

       27
       27
        
         };

+2 -2

nixos/modules/services/networking/gnunet.nix

···

       115
       115
        
             package = mkOption {

     

       116
       116
        
               type = types.package;

     

       117
       117
        
               default = pkgs.gnunet;

     

       118
       118
       -
               defaultText = "pkgs.gnunet";

     

       118
       118
       +
               defaultText = literalExpression "pkgs.gnunet";

     

       119
       119
        
               description = "Overridable attribute of the gnunet package to use.";

     

       120
       120
       -
               example = literalExample "pkgs.gnunet_git";

     

       120
       120
       +
               example = literalExpression "pkgs.gnunet_git";

     

       121
       121
        
             };

     

       122
       122
        
       

     

       123
       123
        
             extraOptions = mkOption {

+1 -1

nixos/modules/services/networking/gobgpd.nix

···

       18
       18
        
               <link xlink:href="https://github.com/osrg/gobgp#documentation"/>

     

       19
       19
        
               for details on supported values.

     

       20
       20
        
             '';

     

       21
       21
       -
             example = literalExample ''

     

       21
       21
       +
             example = literalExpression ''

     

       22
       22
        
               {

     

       23
       23
        
                 global = {

     

       24
       24
        
                   config = {

+1 -1

nixos/modules/services/networking/hans.nix

···

       27
       27
        
                 where <replaceable>name</replaceable> is the name of the

     

       28
       28
        
                 corresponding attribute name.

     

       29
       29
        
               '';

     

       30
       30
       -
               example = literalExample ''

     

       30
       30
       +
               example = literalExpression ''

     

       31
       31
        
               {

     

       32
       32
        
                 foo = {

     

       33
       33
        
                   server = "192.0.2.1";

+4 -4

nixos/modules/services/networking/hylafax/options.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
       

     

       5
       5
       -
         inherit (lib.options) literalExample mkEnableOption mkOption;

     

       5
       5
       +
         inherit (lib.options) literalExpression mkEnableOption mkOption;

     

       6
       6
        
         inherit (lib.types) bool enum ints lines attrsOf nullOr path str submodule;

     

       7
       7
        
         inherit (lib.modules) mkDefault mkIf mkMerge;

     

       8
       8
        
       

     
···

       197
       197
        
       

     

       198
       198
        
           sendmailPath = mkOption {

     

       199
       199
        
             type = path;

     

       200
       200
       -
             example = literalExample "''${pkgs.postfix}/bin/sendmail";

     

       200
       200
       +
             example = literalExpression ''"''${pkgs.postfix}/bin/sendmail"'';

     

       201
       201
        
             # '' ;  # fix vim

     

       202
       202
        
             description = ''

     

       203
       203
        
               Path to <filename>sendmail</filename> program.

     
···

       344
       344
        
           faxqclean.doneqMinutes = mkOption {

     

       345
       345
        
             type = ints.positive;

     

       346
       346
        
             default = 15;

     

       347
       347
       -
             example = literalExample "24*60";

     

       347
       347
       +
             example = literalExpression "24*60";

     

       348
       348
        
             description = ''

     

       349
       349
        
               Set the job

     

       350
       350
        
               age threshold (in minutes) that controls how long

     
···

       354
       354
        
           faxqclean.docqMinutes = mkOption {

     

       355
       355
        
             type = ints.positive;

     

       356
       356
        
             default = 60;

     

       357
       357
       -
             example = literalExample "24*60";

     

       357
       357
       +
             example = literalExpression "24*60";

     

       358
       358
        
             description = ''

     

       359
       359
        
               Set the document

     

       360
       360
        
               age threshold (in minutes) that controls how long

+1 -1

nixos/modules/services/networking/i2pd.nix

···

       481
       481
        
             exploratory.inbound = i2cpOpts "exploratory";

     

       482
       482
        
             exploratory.outbound = i2cpOpts "exploratory";

     

       483
       483
        
       

     

       484
       484
       -
             ntcp2.enable = mkEnableTrueOption "NTCP2.";

     

       484
       484
       +
             ntcp2.enable = mkEnableTrueOption "NTCP2";

     

       485
       485
        
             ntcp2.published = mkEnableOption "NTCP2 publication";

     

       486
       486
        
             ntcp2.port = mkOption {

     

       487
       487
        
               type = types.int;

+1 -1

nixos/modules/services/networking/icecream/daemon.nix

···

       101
       101
        
       

     

       102
       102
        
             package = mkOption {

     

       103
       103
        
               default = pkgs.icecream;

     

       104
       104
       -
               defaultText = "pkgs.icecream";

     

       104
       104
       +
               defaultText = literalExpression "pkgs.icecream";

     

       105
       105
        
               type = types.package;

     

       106
       106
        
               description = "Icecream package to use.";

     

       107
       107
        
             };

+1 -1

nixos/modules/services/networking/icecream/scheduler.nix

···

       56
       56
        
       

     

       57
       57
        
             package = mkOption {

     

       58
       58
        
               default = pkgs.icecream;

     

       59
       59
       -
               defaultText = "pkgs.icecream";

     

       59
       59
       +
               defaultText = literalExpression "pkgs.icecream";

     

       60
       60
        
               type = types.package;

     

       61
       61
        
               description = "Icecream package to use.";

     

       62
       62
        
             };

+2 -2

nixos/modules/services/networking/inspircd.nix

···

       17
       17
        
             package = lib.mkOption {

     

       18
       18
        
               type = lib.types.package;

     

       19
       19
        
               default = pkgs.inspircd;

     

       20
       20
       -
               defaultText = lib.literalExample "pkgs.inspircd";

     

       21
       21
       -
               example = lib.literalExample "pkgs.inspircdMinimal";

     

       20
       20
       +
               defaultText = lib.literalExpression "pkgs.inspircd";

     

       21
       21
       +
               example = lib.literalExpression "pkgs.inspircdMinimal";

     

       22
       22
        
               description = ''

     

       23
       23
        
                 The InspIRCd package to use. This is mainly useful

     

       24
       24
        
                 to specify an overridden version of the

+1 -1

nixos/modules/services/networking/iodine.nix

···

       36
       36
        
                 where <replaceable>name</replaceable> is the name of the

     

       37
       37
        
                 corresponding attribute name.

     

       38
       38
        
               '';

     

       39
       39
       -
               example = literalExample ''

     

       39
       39
       +
               example = literalExpression ''

     

       40
       40
        
                 {

     

       41
       41
        
                   foo = {

     

       42
       42
        
                     server = "tunnel.mdomain.com";

+2 -2

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

···

       64
       64
        
       

     

       65
       65
        
             rsaKey = mkOption {

     

       66
       66
        
               default = null;

     

       67
       67
       -
               example = literalExample "/root/certificates/irc.key";

     

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

     

       68
       68
        
               type = types.nullOr types.path;

     

       69
       69
        
               description = "

     

       70
       70
        
                 IRCD server RSA key.

     
···

       73
       73
        
       

     

       74
       74
        
             certificate = mkOption {

     

       75
       75
        
               default = null;

     

       76
       76
       -
               example = literalExample "/root/certificates/irc.pem";

     

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

     

       77
       77
        
               type = types.nullOr types.path;

     

       78
       78
        
               description = "

     

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

+1 -1

nixos/modules/services/networking/iscsi/initiator.nix

···

       23
       23
        
             type = package;

     

       24
       24
        
             description = "openiscsi package to use";

     

       25
       25
        
             default = pkgs.openiscsi;

     

       26
       26
       -
             defaultText = "pkgs.openiscsi";

     

       26
       26
       +
             defaultText = literalExpression "pkgs.openiscsi";

     

       27
       27
        
           };

     

       28
       28
        
       

     

       29
       29
        
           extraConfig = mkOption {

+1 -1

nixos/modules/services/networking/jicofo.nix

···

       70
       70
        
           config = mkOption {

     

       71
       71
        
             type = attrsOf str;

     

       72
       72
        
             default = { };

     

       73
       73
       -
             example = literalExample ''

     

       73
       73
       +
             example = literalExpression ''

     

       74
       74
        
               {

     

       75
       75
        
                 "org.jitsi.jicofo.auth.URL" = "XMPP:jitsi-meet.example.com";

     

       76
       76
        
               }

+3 -3

nixos/modules/services/networking/jitsi-videobridge.nix

···

       56
       56
        
           config = mkOption {

     

       57
       57
        
             type = attrs;

     

       58
       58
        
             default = { };

     

       59
       59
       -
             example = literalExample ''

     

       59
       59
       +
             example = literalExpression ''

     

       60
       60
        
               {

     

       61
       61
        
                 videobridge = {

     

       62
       62
        
                   ice.udp.port = 5000;

     
···

       82
       82
        
               See <link xlink:href="https://github.com/jitsi/jitsi-videobridge/blob/master/doc/muc.md" /> for more information.

     

       83
       83
        
             '';

     

       84
       84
        
             default = { };

     

       85
       85
       -
             example = literalExample ''

     

       85
       85
       +
             example = literalExpression ''

     

       86
       86
        
               {

     

       87
       87
        
                 "localhost" = {

     

       88
       88
        
                   hostName = "localhost";

     
···

       199
       199
        
               Needed for monitoring jitsi.

     

       200
       200
        
             '';

     

       201
       201
        
             default = [];

     

       202
       202
       -
             example = literalExample "[ \"colibri\" \"rest\" ]";

     

       202
       202
       +
             example = literalExpression "[ \"colibri\" \"rest\" ]";

     

       203
       203
        
           };

     

       204
       204
        
         };

     

       205
       205

+1 -3

nixos/modules/services/networking/keepalived/vrrp-instance-options.nix

···

       102
       102
        
               inherit lib;

     

       103
       103
        
             }));

     

       104
       104
        
             default = [];

     

       105
       105
       -
             example = literalExample ''

     

       106
       106
       -
               TODO: Example

     

       107
       107
       -
             '';

     

       105
       105
       +
             # TODO: example

     

       108
       106
        
             description = "Declarative vhost config";

     

       109
       107
        
           };

     

       110
       108

+1 -1

nixos/modules/services/networking/keepalived/vrrp-script-options.nix

···

       7
       7
        
       

     

       8
       8
        
           script = mkOption {

     

       9
       9
        
             type = str;

     

       10
       10
       -
             example = "\${pkgs.curl} -f http://localhost:80";

     

       10
       10
       +
             example = literalExpression ''"''${pkgs.curl} -f http://localhost:80"'';

     

       11
       11
        
             description = "(Path of) Script command to execute followed by args, i.e. cmd [args]...";

     

       12
       12
        
           };

     

       13
       13

+1 -1

nixos/modules/services/networking/knot.nix

···

       71
       71
        
             package = mkOption {

     

       72
       72
        
               type = types.package;

     

       73
       73
        
               default = pkgs.knot-dns;

     

       74
       74
       -
               defaultText = "pkgs.knot-dns";

     

       74
       74
       +
               defaultText = literalExpression "pkgs.knot-dns";

     

       75
       75
        
               description = ''

     

       76
       76
        
                 Which Knot DNS package to use

     

       77
       77
        
               '';

+2 -2

nixos/modules/services/networking/kresd.nix

···

       62
       62
        
               knot-resolver package to use.

     

       63
       63
        
             ";

     

       64
       64
        
             default = pkgs.knot-resolver;

     

       65
       65
       -
             defaultText = "pkgs.knot-resolver";

     

       66
       66
       -
             example = literalExample "pkgs.knot-resolver.override { extraFeatures = true; }";

     

       65
       65
       +
             defaultText = literalExpression "pkgs.knot-resolver";

     

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

     

       67
       67
        
           };

     

       68
       68
        
           extraConfig = mkOption {

     

       69
       69
        
             type = types.lines;

+1 -1

nixos/modules/services/networking/lambdabot.nix

···

       27
       27
        
             package = mkOption {

     

       28
       28
        
               type = types.package;

     

       29
       29
        
               default = pkgs.lambdabot;

     

       30
       30
       -
               defaultText = "pkgs.lambdabot";

     

       30
       30
       +
               defaultText = literalExpression "pkgs.lambdabot";

     

       31
       31
        
               description = "Used lambdabot package";

     

       32
       32
        
             };

     

       33
       33

+2 -2

nixos/modules/services/networking/libreswan.nix

···

       66
       66
        
             connections = mkOption {

     

       67
       67
        
               type = types.attrsOf types.lines;

     

       68
       68
        
               default = {};

     

       69
       69
       -
               example = literalExample ''

     

       69
       69
       +
               example = literalExpression ''

     

       70
       70
        
                 { myconnection = '''

     

       71
       71
        
                     auto=add

     

       72
       72
        
                     left=%defaultroute

     
···

       85
       85
        
             policies = mkOption {

     

       86
       86
        
               type = types.attrsOf types.lines;

     

       87
       87
        
               default = {};

     

       88
       88
       -
               example = literalExample ''

     

       88
       88
       +
               example = literalExpression ''

     

       89
       89
        
                 { private-or-clear = '''

     

       90
       90
        
                     # Attempt opportunistic IPsec for the entire Internet

     

       91
       91
        
                     0.0.0.0/0

+1 -1

nixos/modules/services/networking/minidlna.nix

···

       39
       39
        
           services.minidlna.friendlyName = mkOption {

     

       40
       40
        
             type = types.str;

     

       41
       41
        
             default = "${config.networking.hostName} MiniDLNA";

     

       42
       42
       -
             defaultText = "$HOSTNAME MiniDLNA";

     

       42
       42
       +
             defaultText = literalExpression ''"''${config.networking.hostName} MiniDLNA"'';

     

       43
       43
        
             example = "rpi3";

     

       44
       44
        
             description =

     

       45
       45
        
               ''

+1 -1

nixos/modules/services/networking/miredo.nix

···

       25
       25
        
             package = mkOption {

     

       26
       26
        
               type = types.package;

     

       27
       27
        
               default = pkgs.miredo;

     

       28
       28
       -
               defaultText = "pkgs.miredo";

     

       28
       28
       +
               defaultText = literalExpression "pkgs.miredo";

     

       29
       29
        
               description = ''

     

       30
       30
        
                 The package to use for the miredo daemon's binary.

     

       31
       31
        
               '';

+2 -5

nixos/modules/services/networking/morty.nix

···

       23
       23
        
               type = types.bool;

     

       24
       24
        
               default = true;

     

       25
       25
        
               description = "Allow IPv6 HTTP requests?";

     

       26
       26
       -
               defaultText = "Allow IPv6 HTTP requests.";

     

       27
       26
        
             };

     

       28
       27
        
       

     

       29
       28
        
             key = mkOption {

     
···

       33
       32
        
                 HMAC url validation key (hexadecimal encoded).

     

       34
       33
        
                 Leave blank to disable. Without validation key, anyone can

     

       35
       34
        
                 submit proxy requests. Leave blank to disable.

     

       35
       35
       +
                 Generate with <literal>printf %s somevalue | openssl dgst -sha1 -hmac somekey</literal>

     

       36
       36
        
               '';

     

       37
       37
       -
               defaultText = "No HMAC url validation. Generate with echo -n somevalue | openssl dgst -sha1 -hmac somekey";

     

       38
       37
        
             };

     

       39
       38
        
       

     

       40
       39
        
             timeout = mkOption {

     

       41
       40
        
               type = types.int;

     

       42
       41
        
               default = 2;

     

       43
       42
        
               description = "Request timeout in seconds.";

     

       44
       44
       -
               defaultText = "A resource now gets 2 seconds to respond.";

     

       45
       43
        
             };

     

       46
       44
        
       

     

       47
       45
        
             package = mkOption {

     

       48
       46
        
               type = types.package;

     

       49
       47
        
               default = pkgs.morty;

     

       50
       50
       -
               defaultText = "pkgs.morty";

     

       48
       48
       +
               defaultText = literalExpression "pkgs.morty";

     

       51
       49
        
               description = "morty package to use.";

     

       52
       50
        
             };

     

       53
       51
        
       

     
···

       61
       59
        
               type = types.str;

     

       62
       60
        
               default = "127.0.0.1";

     

       63
       61
        
               description = "The address on which the service listens";

     

       64
       64
       -
               defaultText = "127.0.0.1 (localhost)";

     

       65
       62
        
             };

     

       66
       63
        
       

     

       67
       64
        
           };

-2

nixos/modules/services/networking/mosquitto.nix

···

       56
       56
        
       

     

       57
       57
        
             port = mkOption {

     

       58
       58
        
               default = 1883;

     

       59
       59
       -
               example = 1883;

     

       60
       59
        
               type = types.int;

     

       61
       60
        
               description = ''

     

       62
       61
        
                 Port on which to listen without SSL.

     
···

       95
       94
        
       

     

       96
       95
        
               port = mkOption {

     

       97
       96
        
                 default = 8883;

     

       98
       98
       -
                 example = 8883;

     

       99
       97
        
                 type = types.int;

     

       100
       98
        
                 description = ''

     

       101
       99
        
                   Port on which to listen with SSL.

+1 -1

nixos/modules/services/networking/murmur.nix

···

       112
       112
        
             package = mkOption {

     

       113
       113
        
               type = types.package;

     

       114
       114
        
               default = pkgs.murmur;

     

       115
       115
       -
               defaultText = "pkgs.murmur";

     

       115
       115
       +
               defaultText = literalExpression "pkgs.murmur";

     

       116
       116
        
               description = "Overridable attribute of the murmur package to use.";

     

       117
       117
        
             };

     

       118
       118

+1 -1

nixos/modules/services/networking/mxisd.nix

···

       42
       42
        
             package = mkOption {

     

       43
       43
        
               type = types.package;

     

       44
       44
        
               default = pkgs.ma1sd;

     

       45
       45
       -
               defaultText = "pkgs.ma1sd";

     

       45
       45
       +
               defaultText = literalExpression "pkgs.ma1sd";

     

       46
       46
        
               description = "The mxisd/ma1sd package to use";

     

       47
       47
        
             };

     

       48
       48

+1 -1

nixos/modules/services/networking/nat.nix

···

       247
       247
        
                 loopbackIPs = mkOption {

     

       248
       248
        
                   type = types.listOf types.str;

     

       249
       249
        
                   default = [];

     

       250
       250
       -
                   example = literalExample ''[ "55.1.2.3" ]'';

     

       250
       250
       +
                   example = literalExpression ''[ "55.1.2.3" ]'';

     

       251
       251
        
                   description = "Public IPs for NAT reflection; for connections to `loopbackip:sourcePort' from the host itself and from other hosts behind NAT";

     

       252
       252
        
                 };

     

       253
       253
        
               };

+1 -2

nixos/modules/services/networking/nats.nix

···

       43
       43
        
       

     

       44
       44
        
             port = mkOption {

     

       45
       45
        
               default = 4222;

     

       46
       46
       -
               example = 4222;

     

       47
       46
        
               type = types.port;

     

       48
       47
        
               description = ''

     

       49
       48
        
                 Port on which to listen.

     
···

       67
       66
        
             settings = mkOption {

     

       68
       67
        
               default = { };

     

       69
       68
        
               type = format.type;

     

       70
       70
       -
               example = literalExample ''

     

       69
       69
       +
               example = literalExpression ''

     

       71
       70
        
                 {

     

       72
       71
        
                   jetstream = {

     

       73
       72
        
                     max_mem = "1G";

+1 -1

nixos/modules/services/networking/ncdns.nix

···

       164
       164
        
             settings = mkOption {

     

       165
       165
        
               type = configType;

     

       166
       166
        
               default = { };

     

       167
       167
       -
               example = literalExample ''

     

       167
       167
       +
               example = literalExpression ''

     

       168
       168
        
                 { # enable webserver

     

       169
       169
        
                   ncdns.httplistenaddr = ":8202";

     

       170
       170

+1 -1

nixos/modules/services/networking/ndppd.nix

···

       142
       142
        
               messages, and respond to them according to a set of rules.

     

       143
       143
        
             '';

     

       144
       144
        
             default = {};

     

       145
       145
       -
             example = literalExample ''

     

       145
       145
       +
             example = literalExpression ''

     

       146
       146
        
               {

     

       147
       147
        
                 eth0.rules."1111::/64" = {};

     

       148
       148
        
               }

+6 -8

nixos/modules/services/networking/nebula.nix

···

       30
       30
        
                   package = mkOption {

     

       31
       31
        
                     type = types.package;

     

       32
       32
        
                     default = pkgs.nebula;

     

       33
       33
       -
                     defaultText = "pkgs.nebula";

     

       33
       33
       +
                     defaultText = literalExpression "pkgs.nebula";

     

       34
       34
        
                     description = "Nebula derivation to use.";

     

       35
       35
        
                   };

     

       36
       36
        
       

     
···

       59
       59
        
                       The static host map defines a set of hosts with fixed IP addresses on the internet (or any network).

     

       60
       60
        
                       A host can have multiple fixed IP addresses defined here, and nebula will try each when establishing a tunnel.

     

       61
       61
        
                     '';

     

       62
       62
       -
                     example = literalExample ''

     

       63
       63
       -
                       { "192.168.100.1" = [ "100.64.22.11:4242" ]; }

     

       64
       64
       -
                     '';

     

       62
       62
       +
                     example = { "192.168.100.1" = [ "100.64.22.11:4242" ]; };

     

       65
       63
        
                   };

     

       66
       64
        
       

     

       67
       65
        
                   isLighthouse = mkOption {

     
···

       77
       75
        
                       List of IPs of lighthouse hosts this node should report to and query from. This should be empty on lighthouse

     

       78
       76
        
                       nodes. The IPs should be the lighthouse's Nebula IPs, not their external IPs.

     

       79
       77
        
                     '';

     

       80
       80
       -
                     example = ''[ "192.168.100.1" ]'';

     

       78
       78
       +
                     example = [ "192.168.100.1" ];

     

       81
       79
        
                   };

     

       82
       80
        
       

     

       83
       81
        
                   listen.host = mkOption {

     
···

       110
       108
        
                     type = types.listOf types.attrs;

     

       111
       109
        
                     default = [];

     

       112
       110
        
                     description = "Firewall rules for outbound traffic.";

     

       113
       113
       -
                     example = ''[ { port = "any"; proto = "any"; host = "any"; } ]'';

     

       111
       111
       +
                     example = [ { port = "any"; proto = "any"; host = "any"; } ];

     

       114
       112
        
                   };

     

       115
       113
        
       

     

       116
       114
        
                   firewall.inbound = mkOption {

     

       117
       115
        
                     type = types.listOf types.attrs;

     

       118
       116
        
                     default = [];

     

       119
       117
        
                     description = "Firewall rules for inbound traffic.";

     

       120
       120
       -
                     example = ''[ { port = "any"; proto = "any"; host = "any"; } ]'';

     

       118
       118
       +
                     example = [ { port = "any"; proto = "any"; host = "any"; } ];

     

       121
       119
        
                   };

     

       122
       120
        
       

     

       123
       121
        
                   settings = mkOption {

     
···

       128
       126
        
                       <link xlink:href="https://github.com/slackhq/nebula/blob/master/examples/config.yml"/>

     

       129
       127
        
                       for details on supported values.

     

       130
       128
        
                     '';

     

       131
       131
       -
                     example = literalExample ''

     

       129
       129
       +
                     example = literalExpression ''

     

       132
       130
        
                       {

     

       133
       131
        
                         lighthouse.dns = {

     

       134
       132
        
                           host = "0.0.0.0";

+1 -1

nixos/modules/services/networking/networkmanager.nix

···

       353
       353
        
                 };

     

       354
       354
        
               });

     

       355
       355
        
               default = [];

     

       356
       356
       -
               example = literalExample ''

     

       356
       356
       +
               example = literalExpression ''

     

       357
       357
        
               [ {

     

       358
       358
        
                     source = pkgs.writeText "upHook" '''

     

       359
       359

+2

nixos/modules/services/networking/nftables.nix

···

       32
       32
        
           };

     

       33
       33
        
           networking.nftables.ruleset = mkOption {

     

       34
       34
        
             type = types.lines;

     

       35
       35
       +
             default = "";

     

       35
       36
        
             example = ''

     

       36
       37
        
               # Check out https://wiki.nftables.org/ for better documentation.

     

       37
       38
        
               # Table for both IPv4 and IPv6.

     
···

       86
       87
        
               name = "nftables-rules";

     

       87
       88
        
               text = cfg.ruleset;

     

       88
       89
        
             };

     

       90
       90
       +
             defaultText = literalDocBook ''a file with the contents of <option>networking.nftables.ruleset</option>'';

     

       89
       91
        
             description =

     

       90
       92
        
               ''

     

       91
       93
        
                 The ruleset file to be used with nftables.  Should be in a format that

+1 -1

nixos/modules/services/networking/ngircd.nix

···

       34
       34
        
               type = types.package;

     

       35
       35
        
       

     

       36
       36
        
               default = pkgs.ngircd;

     

       37
       37
       -
               defaultText = "pkgs.ngircd";

     

       37
       37
       +
               defaultText = literalExpression "pkgs.ngircd";

     

       38
       38
        
             };

     

       39
       39
        
           };

     

       40
       40
        
         };

-1

nixos/modules/services/networking/nixops-dns.nix

···

       34
       34
        
       

     

       35
       35
        
                 For example "ops" will resolve "vm.ops".

     

       36
       36
        
               '';

     

       37
       37
       -
               example = "ops";

     

       38
       37
        
               default = "ops";

     

       39
       38
        
             };

     

       40
       39

+11 -11

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

···

       159
       159
        
                 options = {

     

       160
       160
        
                   username = mkOption {

     

       161
       161
        
                     type = types.str;

     

       162
       162
       -
                     default = null;

     

       163
       162
        
                     description = ''

     

       164
       163
        
                       Username

     

       165
       164
        
                     '';

     
···

       167
       166
        
       

     

       168
       167
        
                   passwordHash = mkOption {

     

       169
       168
        
                     type = types.str;

     

       170
       170
       -
                     default = null;

     

       171
       169
        
                     example = "$6$GtzE7FrpE$wwuVgFYU.TZH4Rz.Snjxk9XGua89IeVwPQ/fEUD8eujr40q5Y021yhn0aNcsQ2Ifw.BLclyzvzgegopgKcneL0";

     

       172
       170
        
                     description = ''

     

       173
       171
        
                       SHA-512 password hash (can be generated by

     
···

       189
       187
        
               '';

     

       190
       188
        
       

     

       191
       189
        
               default = {};

     

       192
       192
       -
               example = literalExample ''

     

       193
       193
       -
                 "user1" = {

     

       194
       194
       -
                   passwordHash = "$6$1l0t5Kn2Dk$appzivc./9l/kjq57eg5UCsBKlcfyCr0zNWYNerKoPsI1d7eAwiT0SVsOVx/CTgaBNT/u4fi2vN.iGlPfv1ek0";

     

       195
       195
       -
                   maxConnections = 5;

     

       196
       196
       -
                 };

     

       197
       197
       -
                 "anotheruser" = {

     

       198
       198
       -
                   passwordHash = "$6$6lwEsWB.TmsS$W7m1riUx4QrA8pKJz8hvff0dnF1NwtZXgdjmGqA1Dx2MDPj07tI9GNcb0SWlMglE.2/hBgynDdAd/XqqtRqVQ0";

     

       199
       199
       -
                   maxConnections = 7;

     

       200
       200
       -
                 };

     

       190
       190
       +
               example = literalExpression ''

     

       191
       191
       +
                 {

     

       192
       192
       +
                   "user1" = {

     

       193
       193
       +
                     passwordHash = "$6$1l0t5Kn2Dk$appzivc./9l/kjq57eg5UCsBKlcfyCr0zNWYNerKoPsI1d7eAwiT0SVsOVx/CTgaBNT/u4fi2vN.iGlPfv1ek0";

     

       194
       194
       +
                     maxConnections = 5;

     

       195
       195
       +
                   };

     

       196
       196
       +
                   "anotheruser" = {

     

       197
       197
       +
                     passwordHash = "$6$6lwEsWB.TmsS$W7m1riUx4QrA8pKJz8hvff0dnF1NwtZXgdjmGqA1Dx2MDPj07tI9GNcb0SWlMglE.2/hBgynDdAd/XqqtRqVQ0";

     

       198
       198
       +
                     maxConnections = 7;

     

       199
       199
       +
                   };

     

       200
       200
       +
                 }

     

       201
       201
        
               '';

     

       202
       202
        
             };

     

       203
       203
        
           };

+4 -4

nixos/modules/services/networking/nomad.nix

···

       13
       13
        
             package = mkOption {

     

       14
       14
        
               type = types.package;

     

       15
       15
        
               default = pkgs.nomad;

     

       16
       16
       -
               defaultText = "pkgs.nomad";

     

       16
       16
       +
               defaultText = literalExpression "pkgs.nomad";

     

       17
       17
        
               description = ''

     

       18
       18
        
                 The package used for the Nomad agent and CLI.

     

       19
       19
        
               '';

     
···

       25
       25
        
               description = ''

     

       26
       26
        
                 Extra packages to add to <envar>PATH</envar> for the Nomad agent process.

     

       27
       27
        
               '';

     

       28
       28
       -
               example = literalExample ''

     

       28
       28
       +
               example = literalExpression ''

     

       29
       29
        
                 with pkgs; [ cni-plugins ]

     

       30
       30
        
               '';

     

       31
       31
        
             };

     
···

       55
       55
        
               description = ''

     

       56
       56
        
                 Additional settings paths used to configure nomad. These can be files or directories.

     

       57
       57
        
               '';

     

       58
       58
       -
               example = literalExample ''

     

       58
       58
       +
               example = literalExpression ''

     

       59
       59
        
                 [ "/etc/nomad-mutable.json" "/run/keys/nomad-with-secrets.json" "/etc/nomad/config.d" ]

     

       60
       60
        
               '';

     

       61
       61
        
             };

     
···

       81
       81
        
                 the <literal>DynamicUser</literal> feature of systemd which directly

     

       82
       82
        
                 manages and operates on <literal>StateDirectory</literal>.

     

       83
       83
        
               '';

     

       84
       84
       -
               example = literalExample ''

     

       84
       84
       +
               example = literalExpression ''

     

       85
       85
        
                 {

     

       86
       86
        
                   # A minimal config example:

     

       87
       87
        
                   server = {

+2 -4

nixos/modules/services/networking/nsd.nix

···

       260
       260
        
             data = mkOption {

     

       261
       261
        
               type = types.lines;

     

       262
       262
        
               default = "";

     

       263
       263
       -
               example = "";

     

       264
       263
        
               description = ''

     

       265
       264
        
                 The actual zone data. This is the content of your zone file.

     

       266
       265
        
                 Use imports or pkgs.lib.readFile if you don't want this data in your config file.

     
···

       397
       396
        
             requestXFR = mkOption {

     

       398
       397
        
               type = types.listOf types.str;

     

       399
       398
        
               default = [];

     

       400
       400
       -
               example = [];

     

       401
       399
        
               description = ''

     

       402
       400
        
                 Format: <code>[AXFR|UDP] &lt;ip-address&gt; &lt;key-name | NOKEY&gt;</code>

     

       403
       401
        
               '';

     
···

       726
       724
        
               };

     

       727
       725
        
             });

     

       728
       726
        
             default = {};

     

       729
       729
       -
             example = literalExample ''

     

       727
       727
       +
             example = literalExpression ''

     

       730
       728
        
               { "tsig.example.org" = {

     

       731
       729
        
                   algorithm = "hmac-md5";

     

       732
       730
        
                   keyFile = "/path/to/my/key";

     
···

       861
       859
        
           zones = mkOption {

     

       862
       860
        
             type = types.attrsOf zoneOptions;

     

       863
       861
        
             default = {};

     

       864
       864
       -
             example = literalExample ''

     

       862
       862
       +
             example = literalExpression ''

     

       865
       863
        
               { "serverGroup1" = {

     

       866
       864
        
                   provideXFR = [ "10.1.2.3 NOKEY" ];

     

       867
       865
        
                   children = {

+1 -1

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

···

       44
       44
        
             package = mkOption {

     

       45
       45
        
               type = types.package;

     

       46
       46
        
               default = pkgs.chrony;

     

       47
       47
       -
               defaultText = "pkgs.chrony";

     

       47
       47
       +
               defaultText = literalExpression "pkgs.chrony";

     

       48
       48
        
               description = ''

     

       49
       49
        
                 Which chrony package to use.

     

       50
       50
        
               '';

+1 -1

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

···

       97
       97
        
             extraFlags = mkOption {

     

       98
       98
        
               type = types.listOf types.str;

     

       99
       99
        
               description = "Extra flags passed to the ntpd command.";

     

       100
       100
       -
               example = literalExample ''[ "--interface=eth0" ]'';

     

       100
       100
       +
               example = literalExpression ''[ "--interface=eth0" ]'';

     

       101
       101
        
               default = [];

     

       102
       102
        
             };

     

       103
       103

+1 -1

nixos/modules/services/networking/ofono.nix

···

       24
       24
        
             plugins = mkOption {

     

       25
       25
        
               type = types.listOf types.package;

     

       26
       26
        
               default = [];

     

       27
       27
       -
               example = literalExample "[ pkgs.modem-manager-gui ]";

     

       27
       27
       +
               example = literalExpression "[ pkgs.modem-manager-gui ]";

     

       28
       28
        
               description = ''

     

       29
       29
        
                 The list of plugins to install.

     

       30
       30
        
               '';

+1 -2

nixos/modules/services/networking/onedrive.nix

···

       35
       35
        
            package = lib.mkOption {

     

       36
       36
        
              type = lib.types.package;

     

       37
       37
        
              default = pkgs.onedrive;

     

       38
       38
       -
              defaultText = "pkgs.onedrive";

     

       39
       39
       -
              example = lib.literalExample "pkgs.onedrive";

     

       38
       38
       +
              defaultText = lib.literalExpression "pkgs.onedrive";

     

       40
       39
        
              description = ''

     

       41
       40
        
                OneDrive package to use.

     

       42
       41
        
              '';

+1 -1

nixos/modules/services/networking/openvpn.nix

···

       84
       84
        
           services.openvpn.servers = mkOption {

     

       85
       85
        
             default = {};

     

       86
       86
        
       

     

       87
       87
       -
             example = literalExample ''

     

       87
       87
       +
             example = literalExpression ''

     

       88
       88
        
               {

     

       89
       89
        
                 server = {

     

       90
       90
        
                   config = '''

+2 -2

nixos/modules/services/networking/ostinato.nix

···

       65
       65
        
               include = mkOption {

     

       66
       66
        
                 type = types.listOf types.str;

     

       67
       67
        
                 default = [];

     

       68
       68
       -
                 example = ''[ "eth*" "lo*" ]'';

     

       68
       68
       +
                 example = [ "eth*" "lo*" ];

     

       69
       69
        
                 description = ''

     

       70
       70
        
                   For a port to pass the filter and appear on the port list managed

     

       71
       71
        
                   by drone, it be allowed by this include list.

     
···

       74
       74
        
               exclude = mkOption {

     

       75
       75
        
                 type = types.listOf types.str;

     

       76
       76
        
                 default = [];

     

       77
       77
       -
                 example = ''[ "usbmon*" "eth0" ]'';

     

       77
       77
       +
                 example = [ "usbmon*" "eth0" ];

     

       78
       78
        
                 description = ''

     

       79
       79
        
                   A list of ports does not appear on the port list managed by drone.

     

       80
       80
        
                 '';

+1 -1

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

···

       127
       127
        
           settings = mkOption {

     

       128
       128
        
             type = configType;

     

       129
       129
        
             default = { };

     

       130
       130
       -
             example = literalExample ''

     

       130
       130
       +
             example = literalExpression ''

     

       131
       131
        
               {

     

       132
       132
        
                 loglevel = 8;

     

       133
       133
        
                 log-common-errors = true;

+1

nixos/modules/services/networking/pleroma.nix

···

       9
       9
        
             package = mkOption {

     

       10
       10
        
               type = types.package;

     

       11
       11
        
               default = pkgs.pleroma;

     

       12
       12
       +
               defaultText = literalExpression "pkgs.pleroma";

     

       12
       13
        
               description = "Pleroma package to use.";

     

       13
       14
        
             };

     

       14
       15

+1 -1

nixos/modules/services/networking/pppd.nix

···

       16
       16
        
       

     

       17
       17
        
             package = mkOption {

     

       18
       18
        
               default = pkgs.ppp;

     

       19
       19
       -
               defaultText = "pkgs.ppp";

     

       19
       19
       +
               defaultText = literalExpression "pkgs.ppp";

     

       20
       20
        
               type = types.package;

     

       21
       21
        
               description = "pppd package to use.";

     

       22
       22
        
             };

+1 -1

nixos/modules/services/networking/privoxy.nix

···

       164
       164
        
               };

     

       165
       165
        
             };

     

       166
       166
        
             default = {};

     

       167
       167
       -
             example = literalExample ''

     

       167
       167
       +
             example = literalExpression ''

     

       168
       168
        
               { # Listen on IPv6 only

     

       169
       169
        
                 listen-address = "[::]:8118";

     

       170
       170

+2 -2

nixos/modules/services/networking/prosody.nix

···

       500
       500
        
               type = types.package;

     

       501
       501
        
               description = "Prosody package to use";

     

       502
       502
        
               default = pkgs.prosody;

     

       503
       503
       -
               defaultText = "pkgs.prosody";

     

       504
       504
       -
               example = literalExample ''

     

       503
       503
       +
               defaultText = literalExpression "pkgs.prosody";

     

       504
       504
       +
               example = literalExpression ''

     

       505
       505
        
                 pkgs.prosody.override {

     

       506
       506
        
                   withExtraLibs = [ pkgs.luaPackages.lpty ];

     

       507
       507
        
                   withCommunityModules = [ "auth_external" ];

+1 -2

nixos/modules/services/networking/quassel.nix

···

       37
       37
        
             package = mkOption {

     

       38
       38
        
               type = types.package;

     

       39
       39
        
               default = pkgs.quasselDaemon;

     

       40
       40
       -
               defaultText = "pkgs.quasselDaemon";

     

       40
       40
       +
               defaultText = literalExpression "pkgs.quasselDaemon";

     

       41
       41
        
               description = ''

     

       42
       42
        
                 The package of the quassel daemon.

     

       43
       43
        
               '';

     

       44
       44
       -
               example = literalExample "pkgs.quasselDaemon";

     

       45
       44
        
             };

     

       46
       45
        
       

     

       47
       46
        
             interfaces = mkOption {

+2 -2

nixos/modules/services/networking/quorum.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       let

     

       3
       3
        
       

     

       4
       4
       -
         inherit (lib) mkEnableOption mkIf mkOption literalExample types optionalString;

     

       4
       4
       +
         inherit (lib) mkEnableOption mkIf mkOption literalExpression types optionalString;

     

       5
       5
        
       

     

       6
       6
        
         cfg = config.services.quorum;

     

       7
       7
        
         dataDir = "/var/lib/quorum";

     
···

       130
       130
        
             genesis = mkOption {

     

       131
       131
        
               type = types.nullOr types.attrs;

     

       132
       132
        
               default = null;

     

       133
       133
       -
               example = literalExample '' {

     

       133
       133
       +
               example = literalExpression '' {

     

       134
       134
        
                 alloc = {

     

       135
       135
        
                   a47385db68718bdcbddc2d2bb7c54018066ec111 = {

     

       136
       136
        
                     balance = "1000000000000000000000000000";

+3 -3

nixos/modules/services/networking/radicale.nix

···

       33
       33
        
             # warnings about incompatible configuration and storage formats.

     

       34
       34
        
             type = with types; nullOr package // { inherit (package) description; };

     

       35
       35
        
             default = null;

     

       36
       36
       -
             defaultText = "pkgs.radicale";

     

       36
       36
       +
             defaultText = literalExpression "pkgs.radicale";

     

       37
       37
        
           };

     

       38
       38
        
       

     

       39
       39
        
           config = mkOption {

     
···

       55
       55
        
               <link xlink:href="https://radicale.org/3.0.html#documentation/configuration" />.

     

       56
       56
        
               This option is mutually exclusive with <option>config</option>.

     

       57
       57
        
             '';

     

       58
       58
       -
             example = literalExample ''

     

       58
       58
       +
             example = literalExpression ''

     

       59
       59
        
               server = {

     

       60
       60
        
                 hosts = [ "0.0.0.0:5232" "[::]:5232" ];

     

       61
       61
        
               };

     
···

       80
       80
        
               <option>settings.rights.file</option> to approriate values.

     

       81
       81
        
             '';

     

       82
       82
        
             default = { };

     

       83
       83
       -
             example = literalExample ''

     

       83
       83
       +
             example = literalExpression ''

     

       84
       84
        
               root = {

     

       85
       85
        
                 user = ".+";

     

       86
       86
        
                 collection = "";

+3 -3

nixos/modules/services/networking/searx.nix

···

       68
       68
        
             settings = mkOption {

     

       69
       69
        
               type = types.attrsOf settingType;

     

       70
       70
        
               default = { };

     

       71
       71
       -
               example = literalExample ''

     

       71
       71
       +
               example = literalExpression ''

     

       72
       72
        
                 { server.port = 8080;

     

       73
       73
        
                   server.bind_address = "0.0.0.0";

     

       74
       74
        
                   server.secret_key = "@SEARX_SECRET_KEY@";

     
···

       116
       116
        
             package = mkOption {

     

       117
       117
        
               type = types.package;

     

       118
       118
        
               default = pkgs.searx;

     

       119
       119
       -
               defaultText = "pkgs.searx";

     

       119
       119
       +
               defaultText = literalExpression "pkgs.searx";

     

       120
       120
        
               description = "searx package to use.";

     

       121
       121
        
             };

     

       122
       122
        
       

     
···

       138
       138
        
             uwsgiConfig = mkOption {

     

       139
       139
        
               type = options.services.uwsgi.instance.type;

     

       140
       140
        
               default = { http = ":8080"; };

     

       141
       141
       -
               example = literalExample ''

     

       141
       141
       +
               example = literalExpression ''

     

       142
       142
        
                 {

     

       143
       143
        
                   disable-logging = true;

     

       144
       144
        
                   http = ":8080";                   # serve via HTTP...

+4 -6

nixos/modules/services/networking/shadowsocks.nix

···

       98
       98
        
             plugin = mkOption {

     

       99
       99
        
               type = types.nullOr types.str;

     

       100
       100
        
               default = null;

     

       101
       101
       -
               example = "\${pkgs.shadowsocks-v2ray-plugin}/bin/v2ray-plugin";

     

       101
       101
       +
               example = literalExpression ''"''${pkgs.shadowsocks-v2ray-plugin}/bin/v2ray-plugin"'';

     

       102
       102
        
               description = ''

     

       103
       103
        
                 SIP003 plugin for shadowsocks

     

       104
       104
        
               '';

     
···

       116
       116
        
             extraConfig = mkOption {

     

       117
       117
        
               type = types.attrs;

     

       118
       118
        
               default = {};

     

       119
       119
       -
               example = ''

     

       120
       120
       -
                 {

     

       121
       121
       -
                   nameserver = "8.8.8.8";

     

       122
       122
       -
                 }

     

       123
       123
       -
               '';

     

       119
       119
       +
               example = {

     

       120
       120
       +
                 nameserver = "8.8.8.8";

     

       121
       121
       +
               };

     

       124
       122
        
               description = ''

     

       125
       123
        
                 Additional configuration for shadowsocks that is not covered by the

     

       126
       124
        
                 provided options. The provided attrset will be serialized to JSON and

+1 -1

nixos/modules/services/networking/shellhub-agent.nix

···

       23
       23
        
             package = mkOption {

     

       24
       24
        
               type = types.package;

     

       25
       25
        
               default = pkgs.shellhub-agent;

     

       26
       26
       -
               defaultText = "pkgs.shellhub-agent";

     

       26
       26
       +
               defaultText = literalExpression "pkgs.shellhub-agent";

     

       27
       27
        
               description = ''

     

       28
       28
        
                 Which ShellHub Agent package to use.

     

       29
       29
        
               '';

+1 -1

nixos/modules/services/networking/shorewall.nix

···

       22
       22
        
             package = lib.mkOption {

     

       23
       23
        
               type        = types.package;

     

       24
       24
        
               default     = pkgs.shorewall;

     

       25
       25
       -
               defaultText = "pkgs.shorewall";

     

       25
       25
       +
               defaultText = lib.literalExpression "pkgs.shorewall";

     

       26
       26
        
               description = "The shorewall package to use.";

     

       27
       27
        
             };

     

       28
       28
        
             configs = lib.mkOption {

+1 -1

nixos/modules/services/networking/shorewall6.nix

···

       22
       22
        
             package = lib.mkOption {

     

       23
       23
        
               type        = types.package;

     

       24
       24
        
               default     = pkgs.shorewall;

     

       25
       25
       -
               defaultText = "pkgs.shorewall";

     

       25
       25
       +
               defaultText = lib.literalExpression "pkgs.shorewall";

     

       26
       26
        
               description = "The shorewall package to use.";

     

       27
       27
        
             };

     

       28
       28
        
             configs = lib.mkOption {

+1 -1

nixos/modules/services/networking/skydns.nix

···

       56
       56
        
       

     

       57
       57
        
           package = mkOption {

     

       58
       58
        
             default = pkgs.skydns;

     

       59
       59
       -
             defaultText = "pkgs.skydns";

     

       59
       59
       +
             defaultText = literalExpression "pkgs.skydns";

     

       60
       60
        
             type = types.package;

     

       61
       61
        
             description = "Skydns package to use.";

     

       62
       62
        
           };

+1 -1

nixos/modules/services/networking/smartdns.nix

···

       32
       32
        
             type =

     

       33
       33
        
             let atom = oneOf [ str int bool ];

     

       34
       34
        
             in attrsOf (coercedTo atom toList (listOf atom));

     

       35
       35
       -
             example = literalExample ''

     

       35
       35
       +
             example = literalExpression ''

     

       36
       36
        
               {

     

       37
       37
        
                 bind = ":5353 -no-rule -group example";

     

       38
       38
        
                 cache-size = 4096;

+9 -8

nixos/modules/services/networking/smokeping.nix

···

       60
       60
        
                 to = root@localhost

     

       61
       61
        
                 from = smokeping@localhost

     

       62
       62
        
               '';

     

       63
       63
       -
               example = literalExample ''

     

       63
       63
       +
               example = ''

     

       64
       64
        
                 to = alertee@address.somewhere

     

       65
       65
        
                 from = smokealert@company.xy

     

       66
       66
        
       

     
···

       75
       75
        
             cgiUrl = mkOption {

     

       76
       76
        
               type = types.str;

     

       77
       77
        
               default = "http://${cfg.hostName}:${toString cfg.port}/smokeping.cgi";

     

       78
       78
       -
               defaultText = "http://\${hostName}:\${toString port}/smokeping.cgi";

     

       78
       78
       +
               defaultText = literalExpression ''"http://''${hostName}:''${toString port}/smokeping.cgi"'';

     

       79
       79
        
               example = "https://somewhere.example.com/smokeping.cgi";

     

       80
       80
        
               description = "URL to the smokeping cgi.";

     

       81
       81
        
             };

     
···

       100
       100
        
                     MIN  0.5 144   720

     

       101
       101
        
       

     

       102
       102
        
               '';

     

       103
       103
       -
               example = literalExample ''

     

       103
       103
       +
               example = ''

     

       104
       104
        
                 # near constant pings.

     

       105
       105
        
                 step     = 30

     

       106
       106
        
                 pings    = 20

     
···

       125
       125
        
             hostName = mkOption {

     

       126
       126
        
               type = types.str;

     

       127
       127
        
               default = config.networking.fqdn;

     

       128
       128
       -
               defaultText = "\${config.networking.fqdn}";

     

       128
       128
       +
               defaultText = literalExpression "config.networking.fqdn";

     

       129
       129
        
               example = "somewhere.example.com";

     

       130
       130
        
               description = "DNS name for the urls generated in the cgi.";

     

       131
       131
        
             };

     

       132
       132
        
             imgUrl = mkOption {

     

       133
       133
        
               type = types.str;

     

       134
       134
        
               default = "http://${cfg.hostName}:${toString cfg.port}/cache";

     

       135
       135
       -
               defaultText = "http://\${hostName}:\${toString port}/cache";

     

       135
       135
       +
               defaultText = literalExpression ''"http://''${hostName}:''${toString port}/cache"'';

     

       136
       136
        
               example = "https://somewhere.example.com/cache";

     

       137
       137
        
               description = "Base url for images generated in the cgi.";

     

       138
       138
        
             };

     
···

       157
       157
        
             ownerEmail = mkOption {

     

       158
       158
        
               type = types.str;

     

       159
       159
        
               default = "no-reply@${cfg.hostName}";

     

       160
       160
       -
               defaultText = "no-reply@\${hostName}";

     

       160
       160
       +
               defaultText = literalExpression ''"no-reply@''${hostName}"'';

     

       161
       161
        
               example = "no-reply@yourdomain.com";

     

       162
       162
        
               description = "Email contact for owner";

     

       163
       163
        
             };

     

       164
       164
        
             package = mkOption {

     

       165
       165
        
               type = types.package;

     

       166
       166
        
               default = pkgs.smokeping;

     

       167
       167
       -
               defaultText = "pkgs.smokeping";

     

       167
       167
       +
               defaultText = literalExpression "pkgs.smokeping";

     

       168
       168
        
               description = "Specify a custom smokeping package";

     

       169
       169
        
             };

     

       170
       170
        
             port = mkOption {

     

       171
       171
        
               type = types.int;

     

       172
       172
        
               default = 8081;

     

       173
       173
       -
               example = 8081;

     

       174
       173
        
               description = "TCP port to use for the web server.";

     

       175
       174
        
             };

     

       176
       175
        
             presentationConfig = mkOption {

     
···

       217
       216
        
             presentationTemplate = mkOption {

     

       218
       217
        
               type = types.str;

     

       219
       218
        
               default = "${pkgs.smokeping}/etc/basepage.html.dist";

     

       219
       219
       +
               defaultText = literalExpression ''"''${pkgs.smokeping}/etc/basepage.html.dist"'';

     

       220
       220
        
               description = "Default page layout for the web UI.";

     

       221
       221
        
             };

     

       222
       222
        
             probeConfig = mkOption {

     
···

       236
       236
        
             smokeMailTemplate = mkOption {

     

       237
       237
        
               type = types.str;

     

       238
       238
        
               default = "${cfg.package}/etc/smokemail.dist";

     

       239
       239
       +
               defaultText = literalExpression ''"''${package}/etc/smokemail.dist"'';

     

       239
       240
        
               description = "Specify the smokemail template for alerts.";

     

       240
       241
        
             };

     

       241
       242
        
             targetConfig = mkOption {

+2 -2

nixos/modules/services/networking/sniproxy.nix

···

       34
       34
        
               type = types.lines;

     

       35
       35
        
               default = "";

     

       36
       36
        
               description = "sniproxy.conf configuration excluding the daemon username and pid file.";

     

       37
       37
       -
               example = literalExample ''

     

       37
       37
       +
               example = ''

     

       38
       38
        
                 error_log {

     

       39
       39
        
                   filename /var/log/sniproxy/error.log

     

       40
       40
        
                 }

     
···

       47
       47
        
                 table {

     

       48
       48
        
                   example.com 192.0.2.10

     

       49
       49
        
                   example.net 192.0.2.20

     

       50
       50
       -
               }

     

       50
       50
       +
                 }

     

       51
       51
        
               '';

     

       52
       52
        
             };

     

       53
       53

+1 -1

nixos/modules/services/networking/softether.nix

···

       21
       21
        
             package = mkOption {

     

       22
       22
        
               type = types.package;

     

       23
       23
        
               default = pkgs.softether;

     

       24
       24
       -
               defaultText = "pkgs.softether";

     

       24
       24
       +
               defaultText = literalExpression "pkgs.softether";

     

       25
       25
        
               description = ''

     

       26
       26
        
                 softether derivation to use.

     

       27
       27
        
               '';

+2 -2

nixos/modules/services/networking/spacecookie.nix

···

       30
       30
        
             package = mkOption {

     

       31
       31
        
               type = types.package;

     

       32
       32
        
               default = pkgs.spacecookie;

     

       33
       33
       -
               defaultText = literalExample "pkgs.spacecookie";

     

       34
       34
       -
               example = literalExample "pkgs.haskellPackages.spacecookie";

     

       33
       33
       +
               defaultText = literalExpression "pkgs.spacecookie";

     

       34
       34
       +
               example = literalExpression "pkgs.haskellPackages.spacecookie";

     

       35
       35
        
               description = ''

     

       36
       36
        
                 The spacecookie derivation to use. This can be used to

     

       37
       37
        
                 override the used package or to use another version.

+1 -1

nixos/modules/services/networking/spiped.nix

···

       138
       138
        
       

     

       139
       139
        
               default = {};

     

       140
       140
        
       

     

       141
       141
       -
               example = literalExample ''

     

       141
       141
       +
               example = literalExpression ''

     

       142
       142
        
                 {

     

       143
       143
        
                   pipe1 =

     

       144
       144
        
                     { keyfile = "/var/lib/spiped/pipe1.key";

+1 -1

nixos/modules/services/networking/strongswan-swanctl/module.nix

···

       13
       13
        
           package = mkOption {

     

       14
       14
        
             type = types.package;

     

       15
       15
        
             default = pkgs.strongswan;

     

       16
       16
       -
             defaultText = "pkgs.strongswan";

     

       16
       16
       +
             defaultText = literalExpression "pkgs.strongswan";

     

       17
       17
        
             description = ''

     

       18
       18
        
               The strongswan derivation to use.

     

       19
       19
        
             '';

+2 -2

nixos/modules/services/networking/strongswan.nix

···

       4
       4
        
       

     

       5
       5
        
         inherit (builtins) toFile;

     

       6
       6
        
         inherit (lib) concatMapStringsSep concatStringsSep mapAttrsToList

     

       7
       7
       -
                       mkIf mkEnableOption mkOption types literalExample;

     

       7
       7
       +
                       mkIf mkEnableOption mkOption types literalExpression;

     

       8
       8
        
       

     

       9
       9
        
         cfg = config.services.strongswan;

     

       10
       10
        
       

     
···

       79
       79
        
           connections = mkOption {

     

       80
       80
        
             type = types.attrsOf (types.attrsOf types.str);

     

       81
       81
        
             default = {};

     

       82
       82
       -
             example = literalExample ''

     

       82
       82
       +
             example = literalExpression ''

     

       83
       83
        
               {

     

       84
       84
        
                 "%default" = {

     

       85
       85
        
                   keyexchange = "ikev2";

+1

nixos/modules/services/networking/stunnel.nix

···

       69
       69
        
             CAFile = mkOption {

     

       70
       70
        
               type = types.nullOr types.path;

     

       71
       71
        
               default = "${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt";

     

       72
       72
       +
               defaultText = literalExpression ''"''${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt"'';

     

       72
       73
        
               description = "Path to a file containing certificates to validate against.";

     

       73
       74
        
             };

     

       74
       75

+2 -2

nixos/modules/services/networking/supplicant.nix

···

       73
       73
        
                   path = mkOption {

     

       74
       74
        
                     type = types.nullOr types.path;

     

       75
       75
        
                     default = null;

     

       76
       76
       -
                     example = literalExample "/etc/wpa_supplicant.conf";

     

       76
       76
       +
                     example = literalExpression "/etc/wpa_supplicant.conf";

     

       77
       77
        
                     description = ''

     

       78
       78
        
                       External <literal>wpa_supplicant.conf</literal> configuration file.

     

       79
       79
        
                       The configuration options defined declaratively within <literal>networking.supplicant</literal> have

     
···

       170
       170
        
       

     

       171
       171
        
             default = { };

     

       172
       172
        
       

     

       173
       173
       -
             example = literalExample ''

     

       173
       173
       +
             example = literalExpression ''

     

       174
       174
        
               { "wlan0 wlan1" = {

     

       175
       175
        
                   configFile.path = "/etc/wpa_supplicant.conf";

     

       176
       176
        
                   userControlled.group = "network";

+4 -3

nixos/modules/services/networking/supybot.nix

···

       24
       24
        
               default = if versionAtLeast config.system.stateVersion "20.09"

     

       25
       25
        
                 then "/var/lib/supybot"

     

       26
       26
        
                 else "/home/supybot";

     

       27
       27
       -
               defaultText = "/var/lib/supybot";

     

       27
       27
       +
               defaultText = literalExpression "/var/lib/supybot";

     

       28
       28
        
               description = "The root directory, logs and plugins are stored here";

     

       29
       29
        
             };

     

       30
       30
        
       

     
···

       49
       49
        
                 Please note that you still need to add the plugins to the config

     

       50
       50
        
                 file (or with <literal>!load</literal>) using their attribute name.

     

       51
       51
        
               '';

     

       52
       52
       -
               example = literalExample ''

     

       52
       52
       +
               example = literalExpression ''

     

       53
       53
        
                 let

     

       54
       54
        
                   plugins = pkgs.fetchzip {

     

       55
       55
        
                     url = "https://github.com/ProgVal/Supybot-plugins/archive/57c2450c.zip";

     
···

       66
       66
        
             extraPackages = mkOption {

     

       67
       67
        
               type = types.functionTo (types.listOf types.package);

     

       68
       68
        
               default = p: [];

     

       69
       69
       +
               defaultText = literalExpression "p: []";

     

       69
       70
        
               description = ''

     

       70
       71
        
                 Extra Python packages available to supybot plugins. The

     

       71
       72
        
                 value must be a function which receives the attrset defined

     

       72
       73
        
                 in <varname>python3Packages</varname> as the sole argument.

     

       73
       74
        
               '';

     

       74
       74
       -
               example = literalExample "p: [ p.lxml p.requests ]";

     

       75
       75
       +
               example = literalExpression "p: [ p.lxml p.requests ]";

     

       75
       76
        
             };

     

       76
       77
        
       

     

       77
       78
        
           };

+5 -5

nixos/modules/services/networking/syncthing.nix

···

       182
       182
        
                 will be reverted on restart if <link linkend="opt-services.syncthing.overrideDevices">overrideDevices</link>

     

       183
       183
        
                 is enabled.

     

       184
       184
        
               '';

     

       185
       185
       -
               example = literalExample ''

     

       185
       185
       +
               example = literalExpression ''

     

       186
       186
        
                 {

     

       187
       187
        
                   "/home/user/sync" = {

     

       188
       188
        
                     id = "syncme";

     
···

       243
       243
        
                       There are 4 different types of versioning with different parameters.

     

       244
       244
        
                       See <link xlink:href="https://docs.syncthing.net/users/versioning.html"/>.

     

       245
       245
        
                     '';

     

       246
       246
       -
                     example = literalExample ''

     

       246
       246
       +
                     example = literalExpression ''

     

       247
       247
        
                       [

     

       248
       248
        
                         {

     

       249
       249
        
                           versioning = {

     
···

       430
       430
        
               description = ''

     

       431
       431
        
                 The path where the settings and keys will exist.

     

       432
       432
        
               '';

     

       433
       433
       -
               default = cfg.dataDir + (optionalString cond "/.config/syncthing");

     

       434
       434
       -
               defaultText = literalExample "dataDir${optionalString cond " + \"/.config/syncthing\""}";

     

       433
       433
       +
               default = cfg.dataDir + optionalString cond "/.config/syncthing";

     

       434
       434
       +
               defaultText = literalExpression "dataDir${optionalString cond " + \"/.config/syncthing\""}";

     

       435
       435
        
             };

     

       436
       436
        
       

     

       437
       437
        
             extraFlags = mkOption {

     
···

       461
       461
        
             package = mkOption {

     

       462
       462
        
               type = types.package;

     

       463
       463
        
               default = pkgs.syncthing;

     

       464
       464
       -
               defaultText = literalExample "pkgs.syncthing";

     

       464
       464
       +
               defaultText = literalExpression "pkgs.syncthing";

     

       465
       465
        
               description = ''

     

       466
       466
        
                 The Syncthing package to use.

     

       467
       467
        
               '';

+1 -1

nixos/modules/services/networking/tailscale.nix

···

       24
       24
        
           package = mkOption {

     

       25
       25
        
             type = types.package;

     

       26
       26
        
             default = pkgs.tailscale;

     

       27
       27
       -
             defaultText = "pkgs.tailscale";

     

       27
       27
       +
             defaultText = literalExpression "pkgs.tailscale";

     

       28
       28
        
             description = "The package to use for tailscale";

     

       29
       29
        
           };

     

       30
       30
        
         };

+1 -1

nixos/modules/services/networking/tedicross.nix

···

       18
       18
        
             config = mkOption {

     

       19
       19
        
               type = types.attrs;

     

       20
       20
        
               # from https://github.com/TediCross/TediCross/blob/master/example.settings.yaml

     

       21
       21
       -
               example = literalExample ''

     

       21
       21
       +
               example = literalExpression ''

     

       22
       22
        
                 {

     

       23
       23
        
                   telegram = {

     

       24
       24
        
                     useFirstNameInsteadOfUsername = false;

+1 -1

nixos/modules/services/networking/thelounge.nix

···

       32
       32
        
           extraConfig = mkOption {

     

       33
       33
        
             default = {};

     

       34
       34
        
             type = types.attrs;

     

       35
       35
       -
             example = literalExample ''{

     

       35
       35
       +
             example = literalExpression ''{

     

       36
       36
        
               reverseProxy = true;

     

       37
       37
        
               defaults = {

     

       38
       38
        
                 name = "Your Network";

+3 -3

nixos/modules/services/networking/tinc.nix

···

       226
       226
        
       

     

       227
       227
        
                   hostSettings = mkOption {

     

       228
       228
        
                     default = { };

     

       229
       229
       -
                     example = literalExample ''

     

       229
       229
       +
                     example = literalExpression ''

     

       230
       230
        
                       {

     

       231
       231
        
                         host1 = {

     

       232
       232
        
                           addresses = [

     
···

       282
       282
        
                   package = mkOption {

     

       283
       283
        
                     type = types.package;

     

       284
       284
        
                     default = pkgs.tinc_pre;

     

       285
       285
       -
                     defaultText = "pkgs.tinc_pre";

     

       285
       285
       +
                     defaultText = literalExpression "pkgs.tinc_pre";

     

       286
       286
        
                     description = ''

     

       287
       287
        
                       The package to use for the tinc daemon's binary.

     

       288
       288
        
                     '';

     
···

       302
       302
        
                   settings = mkOption {

     

       303
       303
        
                     default = { };

     

       304
       304
        
                     type = types.submodule { freeformType = tincConfType; };

     

       305
       305
       -
                     example = literalExample ''

     

       305
       305
       +
                     example = literalExpression ''

     

       306
       306
        
                       {

     

       307
       307
        
                         Interface = "custom.interface";

     

       308
       308
        
                         DirectOnly = true;

+1 -1

nixos/modules/services/networking/toxvpn.nix

···

       22
       22
        
             auto_add_peers = mkOption {

     

       23
       23
        
               type        = types.listOf types.str;

     

       24
       24
        
               default     = [];

     

       25
       25
       -
               example     = ''[ "toxid1" "toxid2" ]'';

     

       25
       25
       +
               example     = [ "toxid1" "toxid2" ];

     

       26
       26
        
               description = "peers to automatically connect to on startup";

     

       27
       27
        
             };

     

       28
       28
        
           };

+1 -1

nixos/modules/services/networking/trickster.nix

···

       20
       20
        
             package = mkOption {

     

       21
       21
        
               type = types.package;

     

       22
       22
        
               default = pkgs.trickster;

     

       23
       23
       -
               defaultText = "pkgs.trickster";

     

       23
       23
       +
               defaultText = literalExpression "pkgs.trickster";

     

       24
       24
        
               description = ''

     

       25
       25
        
                 Package that should be used for trickster.

     

       26
       26
        
               '';

+5 -5

nixos/modules/services/networking/ucarp.nix

···

       91
       91
        
               Command to run after become master, the interface name, virtual address

     

       92
       92
        
               and optional extra parameters are passed as arguments.

     

       93
       93
        
             '';

     

       94
       94
       -
             example = ''

     

       94
       94
       +
             example = literalExpression ''

     

       95
       95
        
               pkgs.writeScript "upscript" '''

     

       96
       96
        
                 #!/bin/sh

     

       97
       97
       -
                 $\{pkgs.iproute2\}/bin/ip addr add "$2"/24 dev "$1"

     

       97
       97
       +
                 ''${pkgs.iproute2}/bin/ip addr add "$2"/24 dev "$1"

     

       98
       98
        
               ''';

     

       99
       99
        
             '';

     

       100
       100
        
           };

     
···

       105
       105
        
               Command to run after become backup, the interface name, virtual address

     

       106
       106
        
               and optional extra parameters are passed as arguments.

     

       107
       107
        
             '';

     

       108
       108
       -
             example = ''

     

       108
       108
       +
             example = literalExpression ''

     

       109
       109
        
               pkgs.writeScript "downscript" '''

     

       110
       110
        
                 #!/bin/sh

     

       111
       111
       -
                 $\{pkgs.iproute2\}/bin/ip addr del "$2"/24 dev "$1"

     

       111
       111
       +
                 ''${pkgs.iproute2}/bin/ip addr del "$2"/24 dev "$1"

     

       112
       112
        
               ''';

     

       113
       113
        
             '';

     

       114
       114
        
           };

     
···

       152
       152
        
               upstream updates for a long time and can be considered as unmaintained.

     

       153
       153
        
             '';

     

       154
       154
        
             default = pkgs.ucarp;

     

       155
       155
       -
             defaultText = "pkgs.ucarp";

     

       155
       155
       +
             defaultText = literalExpression "pkgs.ucarp";

     

       156
       156
        
           };

     

       157
       157
        
         };

     

       158
       158

+2 -2

nixos/modules/services/networking/unbound.nix

···

       45
       45
        
             package = mkOption {

     

       46
       46
        
               type = types.package;

     

       47
       47
        
               default = pkgs.unbound-with-systemd;

     

       48
       48
       -
               defaultText = "pkgs.unbound-with-systemd";

     

       48
       48
       +
               defaultText = literalExpression "pkgs.unbound-with-systemd";

     

       49
       49
        
               description = "The unbound package to use";

     

       50
       50
        
             };

     

       51
       51
        
       

     
···

       128
       128
        
                   };

     

       129
       129
        
                 };

     

       130
       130
        
               };

     

       131
       131
       -
               example = literalExample ''

     

       131
       131
       +
               example = literalExpression ''

     

       132
       132
        
                 {

     

       133
       133
        
                   server = {

     

       134
       134
        
                     interface = [ "127.0.0.1" ];

+3 -3

nixos/modules/services/networking/unifi.nix

···

       44
       44
        
           services.unifi.jrePackage = mkOption {

     

       45
       45
        
             type = types.package;

     

       46
       46
        
             default = pkgs.jre8;

     

       47
       47
       -
             defaultText = "pkgs.jre8";

     

       47
       47
       +
             defaultText = literalExpression "pkgs.jre8";

     

       48
       48
        
             description = ''

     

       49
       49
        
               The JRE package to use. Check the release notes to ensure it is supported.

     

       50
       50
        
             '';

     
···

       53
       53
        
           services.unifi.unifiPackage = mkOption {

     

       54
       54
        
             type = types.package;

     

       55
       55
        
             default = pkgs.unifiLTS;

     

       56
       56
       -
             defaultText = "pkgs.unifiLTS";

     

       56
       56
       +
             defaultText = literalExpression "pkgs.unifiLTS";

     

       57
       57
        
             description = ''

     

       58
       58
        
               The unifi package to use.

     

       59
       59
        
             '';

     
···

       62
       62
        
           services.unifi.mongodbPackage = mkOption {

     

       63
       63
        
             type = types.package;

     

       64
       64
        
             default = pkgs.mongodb;

     

       65
       65
       -
             defaultText = "pkgs.mongodb";

     

       65
       65
       +
             defaultText = literalExpression "pkgs.mongodb";

     

       66
       66
        
             description = ''

     

       67
       67
        
               The mongodb package to use.

     

       68
       68
        
             '';

+1 -1

nixos/modules/services/networking/vsftpd.nix

···

       159
       159
        
             userlistFile = mkOption {

     

       160
       160
        
               type = types.path;

     

       161
       161
        
               default = pkgs.writeText "userlist" (concatMapStrings (x: "${x}\n") cfg.userlist);

     

       162
       162
       -
               defaultText = "pkgs.writeText \"userlist\" (concatMapStrings (x: \"\${x}\n\") cfg.userlist)";

     

       162
       162
       +
               defaultText = literalExpression ''pkgs.writeText "userlist" (concatMapStrings (x: "''${x}\n") cfg.userlist)'';

     

       163
       163
        
               description = ''

     

       164
       164
        
                 Newline separated list of names to be allowed/denied if <option>userlistEnable</option>

     

       165
       165
        
                 is <literal>true</literal>. Meaning see <option>userlistDeny</option>.

+1 -1

nixos/modules/services/networking/websockify.nix

···

       21
       21
        
             sslKey = mkOption {

     

       22
       22
        
               description = "Path to the SSL key.";

     

       23
       23
        
               default = cfg.sslCert;

     

       24
       24
       -
               defaultText = "config.services.networking.websockify.sslCert";

     

       24
       24
       +
               defaultText = literalExpression "config.services.networking.websockify.sslCert";

     

       25
       25
        
               type = types.path;

     

       26
       26
        
             };

     

       27
       27

+4 -12

nixos/modules/services/networking/wg-quick.nix

···

       56
       56
        
             };

     

       57
       57
        
       

     

       58
       58
        
             preUp = mkOption {

     

       59
       59
       -
               example = literalExample ''

     

       60
       60
       -
                 ${pkgs.iproute2}/bin/ip netns add foo

     

       61
       61
       -
               '';

     

       59
       59
       +
               example = literalExpression ''"''${pkgs.iproute2}/bin/ip netns add foo"'';

     

       62
       60
        
               default = "";

     

       63
       61
        
               type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;

     

       64
       62
        
               description = ''

     
···

       67
       65
        
             };

     

       68
       66
        
       

     

       69
       67
        
             preDown = mkOption {

     

       70
       70
       -
               example = literalExample ''

     

       71
       71
       -
                 ${pkgs.iproute2}/bin/ip netns del foo

     

       72
       72
       -
               '';

     

       68
       68
       +
               example = literalExpression ''"''${pkgs.iproute2}/bin/ip netns del foo"'';

     

       73
       69
        
               default = "";

     

       74
       70
        
               type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;

     

       75
       71
        
               description = ''

     
···

       78
       74
        
             };

     

       79
       75
        
       

     

       80
       76
        
             postUp = mkOption {

     

       81
       81
       -
               example = literalExample ''

     

       82
       82
       -
                 ${pkgs.iproute2}/bin/ip netns add foo

     

       83
       83
       -
               '';

     

       77
       77
       +
               example = literalExpression ''"''${pkgs.iproute2}/bin/ip netns add foo"'';

     

       84
       78
        
               default = "";

     

       85
       79
        
               type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;

     

       86
       80
        
               description = ''

     
···

       89
       83
        
             };

     

       90
       84
        
       

     

       91
       85
        
             postDown = mkOption {

     

       92
       92
       -
               example = literalExample ''

     

       93
       93
       -
                 ${pkgs.iproute2}/bin/ip netns del foo

     

       94
       94
       -
               '';

     

       86
       86
       +
               example = literalExpression ''"''${pkgs.iproute2}/bin/ip netns del foo"'';

     

       95
       87
        
               default = "";

     

       96
       88
        
               type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;

     

       97
       89
        
               description = ''

+4 -6

nixos/modules/services/networking/wireguard.nix

···

       62
       62
        
             };

     

       63
       63
        
       

     

       64
       64
        
             preSetup = mkOption {

     

       65
       65
       -
               example = literalExample ''

     

       66
       66
       -
                 ${pkgs.iproute2}/bin/ip netns add foo

     

       67
       67
       -
               '';

     

       65
       65
       +
               example = literalExpression ''"''${pkgs.iproute2}/bin/ip netns add foo"'';

     

       68
       66
        
               default = "";

     

       69
       67
        
               type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;

     

       70
       68
        
               description = ''

     
···

       73
       71
        
             };

     

       74
       72
        
       

     

       75
       73
        
             postSetup = mkOption {

     

       76
       76
       -
               example = literalExample ''

     

       77
       77
       -
                 printf "nameserver 10.200.100.1" | ${pkgs.openresolv}/bin/resolvconf -a wg0 -m 0

     

       74
       74
       +
               example = literalExpression ''

     

       75
       75
       +
                 '''printf "nameserver 10.200.100.1" | ''${pkgs.openresolv}/bin/resolvconf -a wg0 -m 0'''

     

       78
       76
        
               '';

     

       79
       77
        
               default = "";

     

       80
       78
        
               type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;

     
···

       82
       80
        
             };

     

       83
       81
        
       

     

       84
       82
        
             postShutdown = mkOption {

     

       85
       85
       -
               example = literalExample "${pkgs.openresolv}/bin/resolvconf -d wg0";

     

       83
       83
       +
               example = literalExpression ''"''${pkgs.openresolv}/bin/resolvconf -d wg0"'';

     

       86
       84
        
               default = "";

     

       87
       85
        
               type = with types; coercedTo (listOf str) (concatStringsSep "\n") lines;

     

       88
       86
        
               description = "Commands called after shutting down the interface.";

+2 -2

nixos/modules/services/networking/wpa_supplicant.nix

···

       328
       328
        
                     description = ''

     

       329
       329
        
                       Set this to <literal>true</literal> if the SSID of the network is hidden.

     

       330
       330
        
                     '';

     

       331
       331
       -
                     example = literalExample ''

     

       331
       331
       +
                     example = literalExpression ''

     

       332
       332
        
                       { echelon = {

     

       333
       333
        
                           hidden = true;

     

       334
       334
        
                           psk = "abcdefgh";

     
···

       377
       377
        
                 /etc/wpa_supplicant.conf as the configuration file.

     

       378
       378
        
               '';

     

       379
       379
        
               default = {};

     

       380
       380
       -
               example = literalExample ''

     

       380
       380
       +
               example = literalExpression ''

     

       381
       381
        
                 { echelon = {                   # SSID with no spaces or special characters

     

       382
       382
        
                     psk = "abcdefgh";           # (password will be written to /nix/store!)

     

       383
       383
        
                   };

+8 -7

nixos/modules/services/networking/x2goserver.nix

···

       42
       42
        
           nxagentDefaultOptions = mkOption {

     

       43
       43
        
             type = types.listOf types.str;

     

       44
       44
        
             default = [ "-extension GLX" "-nolisten tcp" ];

     

       45
       45
       -
             example = [ "-extension GLX" "-nolisten tcp" ];

     

       46
       45
        
             description = ''

     

       47
       46
        
               List of default nx agent options.

     

       48
       47
        
             '';

     
···

       55
       54
        
               x2goserver.conf ini configuration as nix attributes. See

     

       56
       55
        
               `x2goserver.conf(5)` for details

     

       57
       56
        
             '';

     

       58
       58
       -
             example = literalExample ''

     

       59
       59
       -
               superenicer = {

     

       60
       60
       -
                 "enable" = "yes";

     

       61
       61
       -
                 "idle-nice-level" = 19;

     

       62
       62
       -
               };

     

       63
       63
       -
               telekinesis = { "enable" = "no"; };

     

       57
       57
       +
             example = literalExpression ''

     

       58
       58
       +
               {

     

       59
       59
       +
                 superenicer = {

     

       60
       60
       +
                   "enable" = "yes";

     

       61
       61
       +
                   "idle-nice-level" = 19;

     

       62
       62
       +
                 };

     

       63
       63
       +
                 telekinesis = { "enable" = "no"; };

     

       64
       64
       +
               }

     

       64
       65
        
             '';

     

       65
       66
        
           };

     

       66
       67
        
         };

+2 -2

nixos/modules/services/networking/xandikos.nix

···

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

     

       16
       16
        
               default = pkgs.xandikos;

     

       17
       17
       -
               defaultText = "pkgs.xandikos";

     

       17
       17
       +
               defaultText = literalExpression "pkgs.xandikos";

     

       18
       18
        
               description = "The Xandikos package to use.";

     

       19
       19
        
             };

     

       20
       20
        
       

     
···

       45
       45
        
             extraOptions = mkOption {

     

       46
       46
        
               default = [];

     

       47
       47
        
               type = types.listOf types.str;

     

       48
       48
       -
               example = literalExample ''

     

       48
       48
       +
               example = literalExpression ''

     

       49
       49
        
                 [ "--autocreate"

     

       50
       50
        
                   "--defaults"

     

       51
       51
        
                   "--current-user-principal user"

+1 -1

nixos/modules/services/networking/xrdp.nix

···

       47
       47
        
             package = mkOption {

     

       48
       48
        
               type = types.package;

     

       49
       49
        
               default = pkgs.xrdp;

     

       50
       50
       -
               defaultText = "pkgs.xrdp";

     

       50
       50
       +
               defaultText = literalExpression "pkgs.xrdp";

     

       51
       51
        
               description = ''

     

       52
       52
        
                 The package to use for the xrdp daemon's binary.

     

       53
       53
        
               '';

+1 -1

nixos/modules/services/networking/yggdrasil.nix

···

       99
       99
        
             package = mkOption {

     

       100
       100
        
               type = package;

     

       101
       101
        
               default = pkgs.yggdrasil;

     

       102
       102
       -
               defaultText = "pkgs.yggdrasil";

     

       102
       102
       +
               defaultText = literalExpression "pkgs.yggdrasil";

     

       103
       103
        
               description = "Yggdrasil package to use.";

     

       104
       104
        
             };

     

       105
       105

+2 -4

nixos/modules/services/networking/zeronet.nix

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         inherit (lib) generators literalExample mkEnableOption mkIf mkOption recursiveUpdate types;

     

       4
       4
       +
         inherit (lib) generators literalExpression mkEnableOption mkIf mkOption recursiveUpdate types;

     

       5
       5
        
         cfg = config.services.zeronet;

     

       6
       6
        
         dataDir = "/var/lib/zeronet";

     

       7
       7
        
         configFile = pkgs.writeText "zeronet.conf" (generators.toINI {} (recursiveUpdate defaultSettings cfg.settings));

     
···

       22
       22
        
           settings = mkOption {

     

       23
       23
        
             type = with types; attrsOf (oneOf [ str int bool (listOf str) ]);

     

       24
       24
        
             default = {};

     

       25
       25
       -
             example = literalExample "global.tor = enable;";

     

       25
       25
       +
             example = literalExpression "{ global.tor = enable; }";

     

       26
       26
        
       

     

       27
       27
        
             description = ''

     

       28
       28
        
               <filename>zeronet.conf</filename> configuration. Refer to

     
···

       34
       34
        
           port = mkOption {

     

       35
       35
        
             type = types.port;

     

       36
       36
        
             default = 43110;

     

       37
       37
       -
             example = 43110;

     

       38
       37
        
             description = "Optional zeronet web UI port.";

     

       39
       38
        
           };

     

       40
       39
        
       

     
···

       43
       42
        
             # read-only config file and crashes

     

       44
       43
        
             type = types.port;

     

       45
       44
        
             default = 12261;

     

       46
       46
       -
             example = 12261;

     

       47
       45
        
             description = "Zeronet fileserver port.";

     

       48
       46
        
           };

     

       49
       47

+1 -2

nixos/modules/services/networking/zerotierone.nix

···

       19
       19
        
       

     

       20
       20
        
         options.services.zerotierone.port = mkOption {

     

       21
       21
        
           default = 9993;

     

       22
       22
       -
           example = 9993;

     

       23
       22
        
           type = types.int;

     

       24
       23
        
           description = ''

     

       25
       24
        
             Network port used by ZeroTier.

     
···

       28
       27
        
       

     

       29
       28
        
         options.services.zerotierone.package = mkOption {

     

       30
       29
        
           default = pkgs.zerotierone;

     

       31
       31
       -
           defaultText = "pkgs.zerotierone";

     

       30
       30
       +
           defaultText = literalExpression "pkgs.zerotierone";

     

       32
       31
        
           type = types.package;

     

       33
       32
        
           description = ''

     

       34
       33
        
             ZeroTier One package to use.

+3 -3

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

···

       125
       125
        
             config = mkOption {

     

       126
       126
        
               type = semanticTypes.zncConf;

     

       127
       127
        
               default = {};

     

       128
       128
       -
               example = literalExample ''

     

       128
       128
       +
               example = literalExpression ''

     

       129
       129
        
                 {

     

       130
       130
        
                   LoadModule = [ "webadmin" "adminlog" ];

     

       131
       131
        
                   User.paul = {

     
···

       180
       180
        
       

     

       181
       181
        
             configFile = mkOption {

     

       182
       182
        
               type = types.path;

     

       183
       183
       -
               example = "~/.znc/configs/znc.conf";

     

       183
       183
       +
               example = literalExpression "~/.znc/configs/znc.conf";

     

       184
       184
        
               description = ''

     

       185
       185
        
                 Configuration file for ZNC. It is recommended to use the

     

       186
       186
        
                 <option>config</option> option instead.

     
···

       195
       195
        
             modulePackages = mkOption {

     

       196
       196
        
               type = types.listOf types.package;

     

       197
       197
        
               default = [ ];

     

       198
       198
       -
               example = literalExample "[ pkgs.zncModules.fish pkgs.zncModules.push ]";

     

       198
       198
       +
               example = literalExpression "[ pkgs.zncModules.fish pkgs.zncModules.push ]";

     

       199
       199
        
               description = ''

     

       200
       200
        
                 A list of global znc module packages to add to znc.

     

       201
       201
        
               '';

+3 -3

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

···

       44
       44
        
             modules = mkOption {

     

       45
       45
        
               type = types.listOf types.str;

     

       46
       46
        
               default = [ "simple_away" ];

     

       47
       47
       -
               example = literalExample ''[ "simple_away" "sasl" ]'';

     

       47
       47
       +
               example = literalExpression ''[ "simple_away" "sasl" ]'';

     

       48
       48
        
               description = ''

     

       49
       49
        
                 ZNC network modules to load.

     

       50
       50
        
               '';

     
···

       148
       148
        
                 description = ''

     

       149
       149
        
                   IRC networks to connect the user to.

     

       150
       150
        
                 '';

     

       151
       151
       -
                 example = literalExample ''

     

       151
       151
       +
                 example = literalExpression ''

     

       152
       152
        
                   {

     

       153
       153
        
                     "libera" = {

     

       154
       154
        
                       server = "irc.libera.chat";

     
···

       170
       170
        
               };

     

       171
       171
        
       

     

       172
       172
        
               passBlock = mkOption {

     

       173
       173
       -
                 example = literalExample ''

     

       173
       173
       +
                 example = ''

     

       174
       174
        
                   &lt;Pass password&gt;

     

       175
       175
        
                      Method = sha256

     

       176
       176
        
                      Hash = e2ce303c7ea75c571d80d8540a8699b46535be6a085be3414947d638e48d9e93

+1 -1

nixos/modules/services/printing/cupsd.nix

···

       270
       270
        
             drivers = mkOption {

     

       271
       271
        
               type = types.listOf types.path;

     

       272
       272
        
               default = [];

     

       273
       273
       -
               example = literalExample "with pkgs; [ gutenprint hplip splix ]";

     

       273
       273
       +
               example = literalExpression "with pkgs; [ gutenprint hplip splix ]";

     

       274
       274
        
               description = ''

     

       275
       275
        
                 CUPS drivers to use. Drivers provided by CUPS, cups-filters,

     

       276
       276
        
                 Ghostscript and Samba are added unconditionally. If this list contains

+1 -1

nixos/modules/services/scheduling/cron.nix

···

       52
       52
        
             systemCronJobs = mkOption {

     

       53
       53
        
               type = types.listOf types.str;

     

       54
       54
        
               default = [];

     

       55
       55
       -
               example = literalExample ''

     

       55
       55
       +
               example = literalExpression ''

     

       56
       56
        
                 [ "* * * * *  test   ls -l / > /tmp/cronout 2>&1"

     

       57
       57
        
                   "* * * * *  eelco  echo Hello World > /home/eelco/cronout"

     

       58
       58
        
                 ]

+2 -2

nixos/modules/services/search/elasticsearch.nix

···

       53
       53
        
           package = mkOption {

     

       54
       54
        
             description = "Elasticsearch package to use.";

     

       55
       55
        
             default = pkgs.elasticsearch;

     

       56
       56
       -
             defaultText = "pkgs.elasticsearch";

     

       56
       56
       +
             defaultText = literalExpression "pkgs.elasticsearch";

     

       57
       57
        
             type = types.package;

     

       58
       58
        
           };

     

       59
       59
        
       

     
···

       140
       140
        
             description = "Extra elasticsearch plugins";

     

       141
       141
        
             default = [ ];

     

       142
       142
        
             type = types.listOf types.package;

     

       143
       143
       -
             example = lib.literalExample "[ pkgs.elasticsearchPlugins.discovery-ec2 ]";

     

       143
       143
       +
             example = lib.literalExpression "[ pkgs.elasticsearchPlugins.discovery-ec2 ]";

     

       144
       144
        
           };

     

       145
       145
        
       

     

       146
       146
        
         };

+13 -11

nixos/modules/services/search/hound.nix

···

       50
       50
        
       

     

       51
       51
        
             package = mkOption {

     

       52
       52
        
               default = pkgs.hound;

     

       53
       53
       -
               defaultText = "pkgs.hound";

     

       53
       53
       +
               defaultText = literalExpression "pkgs.hound";

     

       54
       54
        
               type = types.package;

     

       55
       55
        
               description = ''

     

       56
       56
        
                 Package for running hound.

     
···

       63
       63
        
                 The full configuration of the Hound daemon. Note the dbpath

     

       64
       64
        
                 should be an absolute path to a writable location on disk.

     

       65
       65
        
               '';

     

       66
       66
       -
               example = ''

     

       67
       67
       -
                 {

     

       68
       68
       -
                    "max-concurrent-indexers" : 2,

     

       69
       69
       -
                    "dbpath" : "''${services.hound.home}/data",

     

       70
       70
       -
                    "repos" : {

     

       71
       71
       -
                       "nixpkgs": {

     

       72
       72
       -
                          "url" : "https://www.github.com/NixOS/nixpkgs.git"

     

       73
       73
       -
                       }

     

       74
       74
       -
                    }

     

       75
       75
       -
                 }

     

       66
       66
       +
               example = literalExpression ''

     

       67
       67
       +
                 '''

     

       68
       68
       +
                   {

     

       69
       69
       +
                     "max-concurrent-indexers" : 2,

     

       70
       70
       +
                     "dbpath" : "''${services.hound.home}/data",

     

       71
       71
       +
                     "repos" : {

     

       72
       72
       +
                         "nixpkgs": {

     

       73
       73
       +
                           "url" : "https://www.github.com/NixOS/nixpkgs.git"

     

       74
       74
       +
                         }

     

       75
       75
       +
                     }

     

       76
       76
       +
                   }

     

       77
       77
       +
                 '''

     

       76
       78
        
               '';

     

       77
       79
        
             };

     

       78
       80

+1 -2

nixos/modules/services/search/kibana.nix

···

       149
       149
        
           package = mkOption {

     

       150
       150
        
             description = "Kibana package to use";

     

       151
       151
        
             default = pkgs.kibana;

     

       152
       152
       -
             defaultText = "pkgs.kibana";

     

       153
       153
       -
             example = "pkgs.kibana";

     

       152
       152
       +
             defaultText = literalExpression "pkgs.kibana";

     

       154
       153
        
             type = types.package;

     

       155
       154
        
           };

     

       156
       155

+1 -1

nixos/modules/services/search/solr.nix

···

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

     

       18
       18
        
               default = pkgs.solr;

     

       19
       19
       -
               defaultText = "pkgs.solr";

     

       19
       19
       +
               defaultText = literalExpression "pkgs.solr";

     

       20
       20
        
               description = "Which Solr package to use.";

     

       21
       21
        
             };

     

       22
       22

+2 -2

nixos/modules/services/security/certmgr.nix

···

       40
       40
        
           package = mkOption {

     

       41
       41
        
             type = types.package;

     

       42
       42
        
             default = pkgs.certmgr;

     

       43
       43
       -
             defaultText = "pkgs.certmgr";

     

       43
       43
       +
             defaultText = literalExpression "pkgs.certmgr";

     

       44
       44
        
             description = "Which certmgr package to use in the service.";

     

       45
       45
        
           };

     

       46
       46
        
       

     
···

       76
       76
        
       

     

       77
       77
        
           specs = mkOption {

     

       78
       78
        
             default = {};

     

       79
       79
       -
             example = literalExample ''

     

       79
       79
       +
             example = literalExpression ''

     

       80
       80
        
             {

     

       81
       81
        
               exampleCert =

     

       82
       82
        
               let

+2 -2

nixos/modules/services/security/cfssl.nix

···

       27
       27
        
           };

     

       28
       28
        
       

     

       29
       29
        
           ca = mkOption {

     

       30
       30
       -
             defaultText = "\${cfg.dataDir}/ca.pem";

     

       30
       30
       +
             defaultText = literalExpression ''"''${cfg.dataDir}/ca.pem"'';

     

       31
       31
        
             type = types.str;

     

       32
       32
        
             description = "CA used to sign the new certificate -- accepts '[file:]fname' or 'env:varname'.";

     

       33
       33
        
           };

     

       34
       34
        
       

     

       35
       35
        
           caKey = mkOption {

     

       36
       36
       -
             defaultText = "file:\${cfg.dataDir}/ca-key.pem";

     

       36
       36
       +
             defaultText = literalExpression ''"file:''${cfg.dataDir}/ca-key.pem"'';

     

       37
       37
        
             type = types.str;

     

       38
       38
        
             description = "CA private key -- accepts '[file:]fname' or 'env:varname'.";

     

       39
       39
        
           };

+6 -4

nixos/modules/services/security/fail2ban.nix

···

       55
       55
        
       

     

       56
       56
        
             package = mkOption {

     

       57
       57
        
               default = pkgs.fail2ban;

     

       58
       58
       +
               defaultText = literalExpression "pkgs.fail2ban";

     

       58
       59
        
               type = types.package;

     

       59
       59
       -
               example = "pkgs.fail2ban_0_11";

     

       60
       60
       +
               example = literalExpression "pkgs.fail2ban_0_11";

     

       60
       61
        
               description = "The fail2ban package to use for running the fail2ban service.";

     

       61
       62
        
             };

     

       62
       63
        
       

     

       63
       64
        
             packageFirewall = mkOption {

     

       64
       65
        
               default = pkgs.iptables;

     

       66
       66
       +
               defaultText = literalExpression "pkgs.iptables";

     

       65
       67
        
               type = types.package;

     

       66
       66
       -
               example = "pkgs.nftables";

     

       68
       68
       +
               example = literalExpression "pkgs.nftables";

     

       67
       69
        
               description = "The firewall package used by fail2ban service.";

     

       68
       70
        
             };

     

       69
       71
        
       

     

       70
       72
        
             extraPackages = mkOption {

     

       71
       73
        
               default = [];

     

       72
       74
        
               type = types.listOf types.package;

     

       73
       73
       -
               example = lib.literalExample "[ pkgs.ipset ]";

     

       75
       75
       +
               example = lib.literalExpression "[ pkgs.ipset ]";

     

       74
       76
        
               description = ''

     

       75
       77
        
                 Extra packages to be made available to the fail2ban service. The example contains

     

       76
       78
        
                 the packages needed by the `iptables-ipset-proto6` action.

     
···

       202
       204
        
       

     

       203
       205
        
             jails = mkOption {

     

       204
       206
        
               default = { };

     

       205
       205
       -
               example = literalExample ''

     

       207
       207
       +
               example = literalExpression ''

     

       206
       208
        
                 { apache-nohome-iptables = '''

     

       207
       209
        
                     # Block an IP address if it accesses a non-existent

     

       208
       210
        
                     # home directory more than 5 times in 10 minutes,

+2 -2

nixos/modules/services/security/fprintd.nix

···

       23
       23
        
             package = mkOption {

     

       24
       24
        
               type = types.package;

     

       25
       25
        
               default = fprintdPkg;

     

       26
       26
       -
               defaultText = "if cfg.tod.enable then pkgs.fprintd-tod else pkgs.fprintd";

     

       26
       26
       +
               defaultText = literalExpression "if config.services.fprintd.tod.enable then pkgs.fprintd-tod else pkgs.fprintd";

     

       27
       27
        
               description = ''

     

       28
       28
        
                 fprintd package to use.

     

       29
       29
        
               '';

     
···

       35
       35
        
       

     

       36
       36
        
               driver = mkOption {

     

       37
       37
        
                 type = types.package;

     

       38
       38
       -
                 example = literalExample "pkgs.libfprint-2-tod1-goodix";

     

       38
       38
       +
                 example = literalExpression "pkgs.libfprint-2-tod1-goodix";

     

       39
       39
        
                 description = ''

     

       40
       40
        
                   Touch OEM Drivers (TOD) package to use.

     

       41
       41
        
                 '';

+1 -1

nixos/modules/services/security/haka.nix

···

       59
       59
        
       

     

       60
       60
        
             package = mkOption {

     

       61
       61
        
               default = pkgs.haka;

     

       62
       62
       -
               defaultText = "pkgs.haka";

     

       62
       62
       +
               defaultText = literalExpression "pkgs.haka";

     

       63
       63
        
               type = types.package;

     

       64
       64
        
               description = "

     

       65
       65
        
                 Which Haka derivation to use.

+1 -1

nixos/modules/services/security/hockeypuck.nix

···

       18
       18
        
           settings = lib.mkOption {

     

       19
       19
        
             type = settingsFormat.type;

     

       20
       20
        
             default = { };

     

       21
       21
       -
             example = lib.literalExample ''

     

       21
       21
       +
             example = lib.literalExpression ''

     

       22
       22
        
               {

     

       23
       23
        
                 hockeypuck = {

     

       24
       24
        
                   loglevel = "INFO";

+2 -2

nixos/modules/services/security/nginx-sso.nix

···

       13
       13
        
           package = mkOption {

     

       14
       14
        
             type = types.package;

     

       15
       15
        
             default = pkgs.nginx-sso;

     

       16
       16
       -
             defaultText = "pkgs.nginx-sso";

     

       16
       16
       +
             defaultText = literalExpression "pkgs.nginx-sso";

     

       17
       17
        
             description = ''

     

       18
       18
        
               The nginx-sso package that should be used.

     

       19
       19
        
             '';

     
···

       22
       22
        
           configuration = mkOption {

     

       23
       23
        
             type = types.attrsOf types.unspecified;

     

       24
       24
        
             default = {};

     

       25
       25
       -
             example = literalExample ''

     

       25
       25
       +
             example = literalExpression ''

     

       26
       26
        
               {

     

       27
       27
        
                 listen = { addr = "127.0.0.1"; port = 8080; };

     

       28
       28

+1 -1

nixos/modules/services/security/oauth2_proxy.nix

···

       91
       91
        
           package = mkOption {

     

       92
       92
        
             type = types.package;

     

       93
       93
        
             default = pkgs.oauth2-proxy;

     

       94
       94
       -
             defaultText = "pkgs.oauth2-proxy";

     

       94
       94
       +
             defaultText = literalExpression "pkgs.oauth2-proxy";

     

       95
       95
        
             description = ''

     

       96
       96
        
               The package that provides oauth2-proxy.

     

       97
       97
        
             '';

-1

nixos/modules/services/security/privacyidea.nix

···

       169
       169
        
       

     

       170
       170
        
               configFile = mkOption {

     

       171
       171
        
                 type = types.path;

     

       172
       172
       -
                 default = "";

     

       173
       172
        
                 description = ''

     

       174
       173
        
                   Path to PrivacyIDEA LDAP Proxy configuration (proxy.ini).

     

       175
       174
        
                 '';

+1 -1

nixos/modules/services/security/shibboleth-sp.nix

···

       14
       14
        
       

     

       15
       15
        
             configFile = mkOption {

     

       16
       16
        
               type = types.path;

     

       17
       17
       -
               example = "${pkgs.shibboleth-sp}/etc/shibboleth/shibboleth2.xml";

     

       17
       17
       +
               example = literalExpression ''"''${pkgs.shibboleth-sp}/etc/shibboleth/shibboleth2.xml"'';

     

       18
       18
        
               description = "Path to shibboleth config file";

     

       19
       19
        
             };

     

       20
       20

+2 -2

nixos/modules/services/security/sks.nix

···

       23
       23
        
       

     

       24
       24
        
             package = mkOption {

     

       25
       25
        
               default = pkgs.sks;

     

       26
       26
       -
               defaultText = "pkgs.sks";

     

       26
       26
       +
               defaultText = literalExpression "pkgs.sks";

     

       27
       27
        
               type = types.package;

     

       28
       28
        
               description = "Which SKS derivation to use.";

     

       29
       29
        
             };

     
···

       74
       74
        
             webroot = mkOption {

     

       75
       75
        
               type = types.nullOr types.path;

     

       76
       76
        
               default = "${sksPkg.webSamples}/OpenPKG";

     

       77
       77
       -
               defaultText = "\${pkgs.sks.webSamples}/OpenPKG";

     

       77
       77
       +
               defaultText = literalExpression ''"''${package.webSamples}/OpenPKG"'';

     

       78
       78
        
               description = ''

     

       79
       79
        
                 Source directory (will be symlinked, if not null) for the files the

     

       80
       80
        
                 built-in webserver should serve. SKS (''${pkgs.sks.webSamples})

+1

nixos/modules/services/security/step-ca.nix

···

       13
       13
        
             package = lib.mkOption {

     

       14
       14
        
               type = lib.types.package;

     

       15
       15
        
               default = pkgs.step-ca;

     

       16
       16
       +
               defaultText = lib.literalExpression "pkgs.step-ca";

     

       16
       17
        
               description = "Which step-ca package to use.";

     

       17
       18
        
             };

     

       18
       19
        
             address = lib.mkOption {

+1 -2

nixos/modules/services/security/tor.nix

···

       232
       232
        
             package = mkOption {

     

       233
       233
        
               type = types.package;

     

       234
       234
        
               default = pkgs.tor;

     

       235
       235
       -
               defaultText = "pkgs.tor";

     

       236
       236
       -
               example = literalExample "pkgs.tor";

     

       235
       235
       +
               defaultText = literalExpression "pkgs.tor";

     

       237
       236
        
               description = "Tor package to use.";

     

       238
       237
        
             };

     

       239
       238

+1 -1

nixos/modules/services/security/usbguard.nix

···

       44
       44
        
             package = mkOption {

     

       45
       45
        
               type = types.package;

     

       46
       46
        
               default = pkgs.usbguard;

     

       47
       47
       -
               defaultText = "pkgs.usbguard";

     

       47
       47
       +
               defaultText = literalExpression "pkgs.usbguard";

     

       48
       48
        
               description = ''

     

       49
       49
        
                 The usbguard package to use. If you do not need the Qt GUI, use

     

       50
       50
        
                 <literal>pkgs.usbguard-nox</literal> to save disk space.

+1 -1

nixos/modules/services/security/vault.nix

···

       42
       42
        
             package = mkOption {

     

       43
       43
        
               type = types.package;

     

       44
       44
        
               default = pkgs.vault;

     

       45
       45
       -
               defaultText = "pkgs.vault";

     

       45
       45
       +
               defaultText = literalExpression "pkgs.vault";

     

       46
       46
        
               description = "This option specifies the vault package to use.";

     

       47
       47
        
             };

     

       48
       48

+3 -3

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

···

       60
       60
        
           config = mkOption {

     

       61
       61
        
             type = attrsOf (nullOr (oneOf [ bool int str ]));

     

       62
       62
        
             default = {};

     

       63
       63
       -
             example = literalExample ''

     

       63
       63
       +
             example = literalExpression ''

     

       64
       64
        
               {

     

       65
       65
        
                 domain = "https://bw.domain.tld:8443";

     

       66
       66
        
                 signupsAllowed = true;

     
···

       106
       106
        
           package = mkOption {

     

       107
       107
        
             type = package;

     

       108
       108
        
             default = pkgs.vaultwarden;

     

       109
       109
       -
             defaultText = "pkgs.vaultwarden";

     

       109
       109
       +
             defaultText = literalExpression "pkgs.vaultwarden";

     

       110
       110
        
             description = "Vaultwarden package to use.";

     

       111
       111
        
           };

     

       112
       112
        
       

     

       113
       113
        
           webVaultPackage = mkOption {

     

       114
       114
        
             type = package;

     

       115
       115
        
             default = pkgs.vaultwarden-vault;

     

       116
       116
       -
             defaultText = "pkgs.vaultwarden-vault";

     

       116
       116
       +
             defaultText = literalExpression "pkgs.vaultwarden-vault";

     

       117
       117
        
             description = "Web vault package to use.";

     

       118
       118
        
           };

     

       119
       119
        
         };

+1 -1

nixos/modules/services/security/yubikey-agent.nix

···

       33
       33
        
             package = mkOption {

     

       34
       34
        
               type = types.package;

     

       35
       35
        
               default = pkgs.yubikey-agent;

     

       36
       36
       -
               defaultText = "pkgs.yubikey-agent";

     

       36
       36
       +
               defaultText = literalExpression "pkgs.yubikey-agent";

     

       37
       37
        
               description = ''

     

       38
       38
        
                 The package used for the yubikey-agent daemon.

     

       39
       39
        
               '';

+1 -1

nixos/modules/services/system/saslauthd.nix

···

       20
       20
        
       

     

       21
       21
        
             package = mkOption {

     

       22
       22
        
               default = pkgs.cyrus_sasl.bin;

     

       23
       23
       -
               defaultText = "pkgs.cyrus_sasl.bin";

     

       23
       23
       +
               defaultText = literalExpression "pkgs.cyrus_sasl.bin";

     

       24
       24
        
               type = types.package;

     

       25
       25
        
               description = "Cyrus SASL package to use.";

     

       26
       26
        
             };

+2 -2

nixos/modules/services/torrent/deluge.nix

···

       50
       50
        
               config = mkOption {

     

       51
       51
        
                 type = types.attrs;

     

       52
       52
        
                 default = {};

     

       53
       53
       -
                 example = literalExample ''

     

       53
       53
       +
                 example = literalExpression ''

     

       54
       54
        
                   {

     

       55
       55
        
                     download_location = "/srv/torrents/";

     

       56
       56
        
                     max_upload_speed = "1000.0";

     
···

       149
       149
        
       

     

       150
       150
        
               package = mkOption {

     

       151
       151
        
                 type = types.package;

     

       152
       152
       -
                 example = literalExample "pkgs.deluge-2_x";

     

       152
       152
       +
                 example = literalExpression "pkgs.deluge-2_x";

     

       153
       153
        
                 description = ''

     

       154
       154
        
                   Deluge package to use.

     

       155
       155
        
                 '';

+1 -1

nixos/modules/services/torrent/flexget.nix

···

       39
       39
        
       

     

       40
       40
        
             systemScheduler = mkOption {

     

       41
       41
        
               default = true;

     

       42
       42
       -
               example = "false";

     

       42
       42
       +
               example = false;

     

       43
       43
        
               type = types.bool;

     

       44
       44
        
               description = "When true, execute the runs via the flexget-runner.timer. If false, you have to specify the settings yourself in the YML file.";

     

       45
       45
        
             };

+1 -1

nixos/modules/services/torrent/magnetico.nix

···

       111
       111
        
           web.credentials = mkOption {

     

       112
       112
        
             type = types.attrsOf types.str;

     

       113
       113
        
             default = {};

     

       114
       114
       -
             example = lib.literalExample ''

     

       114
       114
       +
             example = lib.literalExpression ''

     

       115
       115
        
               {

     

       116
       116
        
                 myuser = "$2y$12$YE01LZ8jrbQbx6c0s2hdZO71dSjn2p/O9XsYJpz.5968yCysUgiaG";

     

       117
       117
        
               }

+1 -1

nixos/modules/services/torrent/opentracker.nix

···

       13
       13
        
               opentracker package to use

     

       14
       14
        
             '';

     

       15
       15
        
             default = pkgs.opentracker;

     

       16
       16
       -
             defaultText = "pkgs.opentracker";

     

       16
       16
       +
             defaultText = literalExpression "pkgs.opentracker";

     

       17
       17
        
           };

     

       18
       18
        
       

     

       19
       19
        
           extraOptions = mkOption {

+1 -1

nixos/modules/services/torrent/rtorrent.nix

···

       45
       45
        
           package = mkOption {

     

       46
       46
        
             type = types.package;

     

       47
       47
        
             default = pkgs.rtorrent;

     

       48
       48
       -
             defaultText = "pkgs.rtorrent";

     

       48
       48
       +
             defaultText = literalExpression "pkgs.rtorrent";

     

       49
       49
        
             description = ''

     

       50
       50
        
               The rtorrent package to use.

     

       51
       51
        
             '';

+1

nixos/modules/services/ttys/getty.nix

···

       42
       42
        
             loginProgram = mkOption {

     

       43
       43
        
               type = types.path;

     

       44
       44
        
               default = "${pkgs.shadow}/bin/login";

     

       45
       45
       +
               defaultText = literalExpression ''"''${pkgs.shadow}/bin/login"'';

     

       45
       46
        
               description = ''

     

       46
       47
        
                 Path to the login binary executed by agetty.

     

       47
       48
        
               '';

+25 -4

nixos/modules/services/video/epgstation/default.nix

···

       126
       126
        
             passwordFile = mkOption {

     

       127
       127
        
               type = types.path;

     

       128
       128
        
               default = pkgs.writeText "epgstation-password" defaultPassword;

     

       129
       129
       +
               defaultText = literalDocBook ''a file containing <literal>${defaultPassword}</literal>'';

     

       129
       130
        
               example = "/run/keys/epgstation-password";

     

       130
       131
        
               description = ''

     

       131
       132
        
                 A file containing the password for <option>basicAuth.user</option>.

     
···

       145
       146
        
             passwordFile = mkOption {

     

       146
       147
        
               type = types.path;

     

       147
       148
        
               default = pkgs.writeText "epgstation-db-password" defaultPassword;

     

       149
       149
       +
               defaultText = literalDocBook ''a file containing <literal>${defaultPassword}</literal>'';

     

       148
       150
        
               example = "/run/keys/epgstation-db-password";

     

       149
       151
        
               description = ''

     

       150
       152
        
                 A file containing the password for the database named

     
···

       189
       191
        
                 type = with types; listOf attrs;

     

       190
       192
        
                 description = "Encoding presets for recorded videos.";

     

       191
       193
        
                 default = [

     

       192
       192
       -
                   { name = "H264";

     

       194
       194
       +
                   {

     

       195
       195
       +
                     name = "H264";

     

       193
       196
        
                     cmd = "${pkgs.epgstation}/libexec/enc.sh main";

     

       194
       197
        
                     suffix = ".mp4";

     

       195
       195
       -
                     default = true; }

     

       196
       196
       -
                   { name = "H264-sub";

     

       198
       198
       +
                     default = true;

     

       199
       199
       +
                   }

     

       200
       200
       +
                   {

     

       201
       201
       +
                     name = "H264-sub";

     

       197
       202
        
                     cmd = "${pkgs.epgstation}/libexec/enc.sh sub";

     

       198
       198
       -
                     suffix = "-sub.mp4"; }

     

       203
       203
       +
                     suffix = "-sub.mp4";

     

       204
       204
       +
                   }

     

       199
       205
        
                 ];

     

       206
       206
       +
                 defaultText = literalExpression ''

     

       207
       207
       +
                   [

     

       208
       208
       +
                     {

     

       209
       209
       +
                       name = "H264";

     

       210
       210
       +
                       cmd = "''${pkgs.epgstation}/libexec/enc.sh main";

     

       211
       211
       +
                       suffix = ".mp4";

     

       212
       212
       +
                       default = true;

     

       213
       213
       +
                     }

     

       214
       214
       +
                     {

     

       215
       215
       +
                       name = "H264-sub";

     

       216
       216
       +
                       cmd = "''${pkgs.epgstation}/libexec/enc.sh sub";

     

       217
       217
       +
                       suffix = "-sub.mp4";

     

       218
       218
       +
                     }

     

       219
       219
       +
                   ]

     

       220
       220
       +
                 '';

     

       200
       221
        
               };

     

       201
       222
        
             };

     

       202
       223
        
           };

+3 -3

nixos/modules/services/video/mirakurun.nix

···

       72
       72
        
               serverSettings = mkOption {

     

       73
       73
        
                 type = settingsFmt.type;

     

       74
       74
        
                 default = {};

     

       75
       75
       -
                 example = literalExample ''

     

       75
       75
       +
                 example = literalExpression ''

     

       76
       76
        
                   {

     

       77
       77
        
                     highWaterMark = 25165824;

     

       78
       78
        
                     overflowTimeLimit = 30000;

     
···

       89
       89
        
               tunerSettings = mkOption {

     

       90
       90
        
                 type = with types; nullOr settingsFmt.type;

     

       91
       91
        
                 default = null;

     

       92
       92
       -
                 example = literalExample ''

     

       92
       92
       +
                 example = literalExpression ''

     

       93
       93
        
                   [

     

       94
       94
        
                     {

     

       95
       95
        
                       name = "tuner-name";

     
···

       110
       110
        
               channelSettings = mkOption {

     

       111
       111
        
                 type = with types; nullOr settingsFmt.type;

     

       112
       112
        
                 default = null;

     

       113
       113
       -
                 example = literalExample ''

     

       113
       113
       +
                 example = literalExpression ''

     

       114
       114
        
                   [

     

       115
       115
        
                     {

     

       116
       116
        
                       name = "channel";

+1 -1

nixos/modules/services/video/replay-sorcery.nix

···

       26
       26
        
               type = attrsOf (oneOf [ str int ]);

     

       27
       27
        
               default = {};

     

       28
       28
        
               description = "System-wide configuration for ReplaySorcery (/etc/replay-sorcery.conf).";

     

       29
       29
       -
               example = literalExample ''

     

       29
       29
       +
               example = literalExpression ''

     

       30
       30
        
                 {

     

       31
       31
        
                   videoInput = "hwaccel"; # requires `services.replay-sorcery.enableSysAdminCapability = true`

     

       32
       32
        
                   videoFramerate = 60;

+3 -3

nixos/modules/services/video/unifi-video.nix

···

       104
       104
        
             jrePackage = mkOption {

     

       105
       105
        
               type = types.package;

     

       106
       106
        
               default = pkgs.jre8;

     

       107
       107
       -
               defaultText = "pkgs.jre8";

     

       107
       107
       +
               defaultText = literalExpression "pkgs.jre8";

     

       108
       108
        
               description = ''

     

       109
       109
        
                 The JRE package to use. Check the release notes to ensure it is supported.

     

       110
       110
        
               '';

     
···

       113
       113
        
             unifiVideoPackage = mkOption {

     

       114
       114
        
               type = types.package;

     

       115
       115
        
               default = pkgs.unifi-video;

     

       116
       116
       -
               defaultText = "pkgs.unifi-video";

     

       116
       116
       +
               defaultText = literalExpression "pkgs.unifi-video";

     

       117
       117
        
               description = ''

     

       118
       118
        
                 The unifi-video package to use.

     

       119
       119
        
               '';

     
···

       122
       122
        
             mongodbPackage = mkOption {

     

       123
       123
        
               type = types.package;

     

       124
       124
        
               default = pkgs.mongodb-4_0;

     

       125
       125
       -
               defaultText = "pkgs.mongodb";

     

       125
       125
       +
               defaultText = literalExpression "pkgs.mongodb";

     

       126
       126
        
               description = ''

     

       127
       127
        
                 The mongodb package to use.

     

       128
       128
        
               '';

+2 -1

nixos/modules/services/wayland/cage.nix

···

       18
       18
        
         options.services.cage.extraArguments = mkOption {

     

       19
       19
        
           type = types.listOf types.str;

     

       20
       20
        
           default = [];

     

       21
       21
       -
           defaultText = "[]";

     

       21
       21
       +
           defaultText = literalExpression "[]";

     

       22
       22
        
           description = "Additional command line arguments to pass to Cage.";

     

       23
       23
        
           example = ["-d"];

     

       24
       24
        
         };

     
···

       26
       26
        
         options.services.cage.program = mkOption {

     

       27
       27
        
           type = types.path;

     

       28
       28
        
           default = "${pkgs.xterm}/bin/xterm";

     

       29
       29
       +
           defaultText = literalExpression ''"''${pkgs.xterm}/bin/xterm"'';

     

       29
       30
        
           description = ''

     

       30
       31
        
             Program to run in cage.

     

       31
       32
        
           '';

+2 -2

nixos/modules/services/web-apps/atlassian/confluence.nix

···

       128
       128
        
             package = mkOption {

     

       129
       129
        
               type = types.package;

     

       130
       130
        
               default = pkgs.atlassian-confluence;

     

       131
       131
       -
               defaultText = "pkgs.atlassian-confluence";

     

       131
       131
       +
               defaultText = literalExpression "pkgs.atlassian-confluence";

     

       132
       132
        
               description = "Atlassian Confluence package to use.";

     

       133
       133
        
             };

     

       134
       134
        
       

     

       135
       135
        
             jrePackage = mkOption {

     

       136
       136
        
               type = types.package;

     

       137
       137
        
               default = pkgs.oraclejre8;

     

       138
       138
       -
               defaultText = "pkgs.oraclejre8";

     

       138
       138
       +
               defaultText = literalExpression "pkgs.oraclejre8";

     

       139
       139
        
               description = "Note that Atlassian only support the Oracle JRE (JRASERVER-46152).";

     

       140
       140
        
             };

     

       141
       141
        
           };

+2 -2

nixos/modules/services/web-apps/atlassian/crowd.nix

···

       96
       96
        
             package = mkOption {

     

       97
       97
        
               type = types.package;

     

       98
       98
        
               default = pkgs.atlassian-crowd;

     

       99
       99
       -
               defaultText = "pkgs.atlassian-crowd";

     

       99
       99
       +
               defaultText = literalExpression "pkgs.atlassian-crowd";

     

       100
       100
        
               description = "Atlassian Crowd package to use.";

     

       101
       101
        
             };

     

       102
       102
        
       

     

       103
       103
        
             jrePackage = mkOption {

     

       104
       104
        
               type = types.package;

     

       105
       105
        
               default = pkgs.oraclejre8;

     

       106
       106
       -
               defaultText = "pkgs.oraclejre8";

     

       106
       106
       +
               defaultText = literalExpression "pkgs.oraclejre8";

     

       107
       107
        
               description = "Note that Atlassian only support the Oracle JRE (JRASERVER-46152).";

     

       108
       108
        
             };

     

       109
       109
        
           };

+2 -2

nixos/modules/services/web-apps/atlassian/jira.nix

···

       134
       134
        
             package = mkOption {

     

       135
       135
        
               type = types.package;

     

       136
       136
        
               default = pkgs.atlassian-jira;

     

       137
       137
       -
               defaultText = "pkgs.atlassian-jira";

     

       137
       137
       +
               defaultText = literalExpression "pkgs.atlassian-jira";

     

       138
       138
        
               description = "Atlassian JIRA package to use.";

     

       139
       139
        
             };

     

       140
       140
        
       

     

       141
       141
        
             jrePackage = mkOption {

     

       142
       142
        
               type = types.package;

     

       143
       143
        
               default = pkgs.oraclejre8;

     

       144
       144
       -
               defaultText = "pkgs.oraclejre8";

     

       144
       144
       +
               defaultText = literalExpression "pkgs.oraclejre8";

     

       145
       145
        
               description = "Note that Atlassian only support the Oracle JRE (JRASERVER-46152).";

     

       146
       146
        
             };

     

       147
       147
        
           };

+11 -9

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

···

       91
       91
        
             user = mkOption {

     

       92
       92
        
               type = types.str;

     

       93
       93
        
               default = user;

     

       94
       94
       -
               defaultText = "\${user}";

     

       94
       94
       +
               defaultText = literalExpression "user";

     

       95
       95
        
               description = "Database username.";

     

       96
       96
        
             };

     

       97
       97
        
             passwordFile = mkOption {

     
···

       187
       187
        
                 (import ../web-servers/nginx/vhost-options.nix { inherit config lib; }) {}

     

       188
       188
        
             );

     

       189
       189
        
             default = {};

     

       190
       190
       -
             example = {

     

       191
       191
       -
               serverAliases = [

     

       192
       192
       -
                 "bookstack.\${config.networking.domain}"

     

       193
       193
       -
               ];

     

       194
       194
       -
               # To enable encryption and let let's encrypt take care of certificate

     

       195
       195
       -
               forceSSL = true;

     

       196
       196
       -
               enableACME = true;

     

       197
       197
       -
             };

     

       190
       190
       +
             example = literalExpression ''

     

       191
       191
       +
               {

     

       192
       192
       +
                 serverAliases = [

     

       193
       193
       +
                   "bookstack.''${config.networking.domain}"

     

       194
       194
       +
                 ];

     

       195
       195
       +
                 # To enable encryption and let let's encrypt take care of certificate

     

       196
       196
       +
                 forceSSL = true;

     

       197
       197
       +
                 enableACME = true;

     

       198
       198
       +
               }

     

       199
       199
       +
             '';

     

       198
       200
        
             description = ''

     

       199
       201
        
               With this option, you can customize the nginx virtualHost settings.

     

       200
       202
        
             '';

+2 -2

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

···

       11
       11
        
       

     

       12
       12
        
           package = mkOption {

     

       13
       13
        
             default = pkgs.cryptpad;

     

       14
       14
       -
             defaultText = "pkgs.cryptpad";

     

       14
       14
       +
             defaultText = literalExpression "pkgs.cryptpad";

     

       15
       15
        
             type = types.package;

     

       16
       16
        
             description = "

     

       17
       17
        
               Cryptpad package to use.

     
···

       21
       21
        
           configFile = mkOption {

     

       22
       22
        
             type = types.path;

     

       23
       23
        
             default = "${cfg.package}/lib/node_modules/cryptpad/config/config.example.js";

     

       24
       24
       -
             defaultText = "\${cfg.package}/lib/node_modules/cryptpad/config/config.example.js";

     

       24
       24
       +
             defaultText = literalExpression ''"''${package}/lib/node_modules/cryptpad/config/config.example.js"'';

     

       25
       25
        
             description = ''

     

       26
       26
        
               Path to the JavaScript configuration file.

     

       27
       27

+1 -1

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

···

       23
       23
        
           settings = mkOption {

     

       24
       24
        
             type = settingsFormat.type;

     

       25
       25
        
             default = {};

     

       26
       26
       -
             example = literalExample ''

     

       26
       26
       +
             example = literalExpression ''

     

       27
       27
        
               {

     

       28
       28
        
                 # External url

     

       29
       29
        
                 issuer = "http://127.0.0.1:5556/dex";

+13 -12

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

···

       33
       33
        
               apply = p: p.override {

     

       34
       34
        
                 plugins = lib.unique (p.enabledPlugins ++ cfg.plugins);

     

       35
       35
        
               };

     

       36
       36
       -
               defaultText = "pkgs.discourse";

     

       36
       36
       +
               defaultText = lib.literalExpression "pkgs.discourse";

     

       37
       37
        
               description = ''

     

       38
       38
        
                 The discourse package to use.

     

       39
       39
        
               '';

     
···

       45
       45
        
                           config.networking.fqdn

     

       46
       46
        
                         else

     

       47
       47
        
                           config.networking.hostName;

     

       48
       48
       -
               defaultText = "config.networking.fqdn";

     

       48
       48
       +
               defaultText = lib.literalExpression "config.networking.fqdn";

     

       49
       49
        
               example = "discourse.example.com";

     

       50
       50
        
               description = ''

     

       51
       51
        
                 The hostname to serve Discourse on.

     
···

       99
       99
        
             enableACME = lib.mkOption {

     

       100
       100
        
               type = lib.types.bool;

     

       101
       101
        
               default = cfg.sslCertificate == null && cfg.sslCertificateKey == null;

     

       102
       102
       -
               defaultText = "true, unless services.discourse.sslCertificate and services.discourse.sslCertificateKey are set.";

     

       102
       102
       +
               defaultText = lib.literalDocBook ''

     

       103
       103
       +
                 <literal>true</literal>, unless <option>services.discourse.sslCertificate</option>

     

       104
       104
       +
                 and <option>services.discourse.sslCertificateKey</option> are set.

     

       105
       105
       +
               '';

     

       103
       106
        
               description = ''

     

       104
       107
        
                 Whether an ACME certificate should be used to secure

     

       105
       108
        
                 connections to the server.

     
···

       109
       112
        
             backendSettings = lib.mkOption {

     

       110
       113
        
               type = with lib.types; attrsOf (nullOr (oneOf [ str int bool float ]));

     

       111
       114
        
               default = {};

     

       112
       112
       -
               example = lib.literalExample ''

     

       115
       115
       +
               example = lib.literalExpression ''

     

       113
       116
        
                 {

     

       114
       117
        
                   max_reqs_per_ip_per_minute = 300;

     

       115
       118
        
                   max_reqs_per_ip_per_10_seconds = 60;

     
···

       134
       137
        
             siteSettings = lib.mkOption {

     

       135
       138
        
               type = json.type;

     

       136
       139
        
               default = {};

     

       137
       137
       -
               example = lib.literalExample ''

     

       140
       140
       +
               example = lib.literalExpression ''

     

       138
       141
        
                 {

     

       139
       142
        
                   required = {

     

       140
       143
        
                     title = "My Cats";

     
···

       334
       337
        
               notificationEmailAddress = lib.mkOption {

     

       335
       338
        
                 type = lib.types.str;

     

       336
       339
        
                 default = "${if cfg.mail.incoming.enable then "notifications" else "noreply"}@${cfg.hostname}";

     

       337
       337
       -
                 defaultText = ''

     

       338
       338
       -
                   "notifications@`config.services.discourse.hostname`" if

     

       339
       339
       -
                   config.services.discourse.mail.incoming.enable is "true",

     

       340
       340
       -
                   otherwise "noreply`config.services.discourse.hostname`"

     

       340
       340
       +
                 defaultText = lib.literalExpression ''

     

       341
       341
       +
                   "''${if config.services.discourse.mail.incoming.enable then "notifications" else "noreply"}@''${config.services.discourse.hostname}"

     

       341
       342
        
                 '';

     

       342
       343
        
                 description = ''

     

       343
       344
        
                   The <literal>from:</literal> email address used when

     
···

       448
       449
        
                 replyEmailAddress = lib.mkOption {

     

       449
       450
        
                   type = lib.types.str;

     

       450
       451
        
                   default = "%{reply_key}@${cfg.hostname}";

     

       451
       451
       -
                   defaultText = "%{reply_key}@`config.services.discourse.hostname`";

     

       452
       452
       +
                   defaultText = lib.literalExpression ''"%{reply_key}@''${config.services.discourse.hostname}"'';

     

       452
       453
        
                   description = ''

     

       453
       454
        
                     Template for reply by email incoming email address, for

     

       454
       455
        
                     example: %{reply_key}@reply.example.com or

     
···

       459
       460
        
                 mailReceiverPackage = lib.mkOption {

     

       460
       461
        
                   type = lib.types.package;

     

       461
       462
        
                   default = pkgs.discourse-mail-receiver;

     

       462
       462
       -
                   defaultText = "pkgs.discourse-mail-receiver";

     

       463
       463
       +
                   defaultText = lib.literalExpression "pkgs.discourse-mail-receiver";

     

       463
       464
        
                   description = ''

     

       464
       465
        
                     The discourse-mail-receiver package to use.

     

       465
       466
        
                   '';

     
···

       484
       485
        
             plugins = lib.mkOption {

     

       485
       486
        
               type = lib.types.listOf lib.types.package;

     

       486
       487
        
               default = [];

     

       487
       487
       -
               example = lib.literalExample ''

     

       488
       488
       +
               example = lib.literalExpression ''

     

       488
       489
        
                 with config.services.discourse.package.plugins; [

     

       489
       490
        
                   discourse-canned-replies

     

       490
       491
        
                   discourse-github

+1

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

···

       26
       26
        
           package = mkOption {

     

       27
       27
        
             type = types.package;

     

       28
       28
        
             default = pkgs.documize-community;

     

       29
       29
       +
             defaultText = literalExpression "pkgs.documize-community";

     

       29
       30
        
             description = ''

     

       30
       31
        
               Which package to use for documize.

     

       31
       32
        
             '';

+33 -32

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

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         inherit (lib) mkDefault mkEnableOption mkForce mkIf mkMerge mkOption types maintainers recursiveUpdate;

     

       5
       5
       -
         inherit (lib) any attrValues concatMapStrings concatMapStringsSep flatten literalExample;

     

       5
       5
       +
         inherit (lib) any attrValues concatMapStrings concatMapStringsSep flatten literalExpression;

     

       6
       6
        
         inherit (lib) filterAttrs mapAttrs mapAttrs' mapAttrsToList nameValuePair optional optionalAttrs optionalString;

     

       7
       7
        
       

     

       8
       8
        
         cfg = migrateOldAttrs config.services.dokuwiki;

     
···

       69
       69
        
               package = mkOption {

     

       70
       70
        
                 type = types.package;

     

       71
       71
        
                 default = pkgs.dokuwiki;

     

       72
       72
       +
                 defaultText = literalExpression "pkgs.dokuwiki";

     

       72
       73
        
                 description = "Which DokuWiki package to use.";

     

       73
       74
        
               };

     

       74
       75
        
       

     
···

       167
       168
        
                       List of path(s) to respective plugin(s) which are copied from the 'plugin' directory.

     

       168
       169
        
                       <note><para>These plugins need to be packaged before use, see example.</para></note>

     

       169
       170
        
                 '';

     

       170
       170
       -
                 example = ''

     

       171
       171
       -
                       # Let's package the icalevents plugin

     

       172
       172
       -
                       plugin-icalevents = pkgs.stdenv.mkDerivation {

     

       173
       173
       -
                         name = "icalevents";

     

       174
       174
       -
                         # Download the plugin from the dokuwiki site

     

       175
       175
       -
                         src = pkgs.fetchurl {

     

       176
       176
       -
                           url = "https://github.com/real-or-random/dokuwiki-plugin-icalevents/releases/download/2017-06-16/dokuwiki-plugin-icalevents-2017-06-16.zip";

     

       177
       177
       -
                           sha256 = "e40ed7dd6bbe7fe3363bbbecb4de481d5e42385b5a0f62f6a6ce6bf3a1f9dfa8";

     

       171
       171
       +
                 example = literalExpression ''

     

       172
       172
       +
                       let

     

       173
       173
       +
                         # Let's package the icalevents plugin

     

       174
       174
       +
                         plugin-icalevents = pkgs.stdenv.mkDerivation {

     

       175
       175
       +
                           name = "icalevents";

     

       176
       176
       +
                           # Download the plugin from the dokuwiki site

     

       177
       177
       +
                           src = pkgs.fetchurl {

     

       178
       178
       +
                             url = "https://github.com/real-or-random/dokuwiki-plugin-icalevents/releases/download/2017-06-16/dokuwiki-plugin-icalevents-2017-06-16.zip";

     

       179
       179
       +
                             sha256 = "e40ed7dd6bbe7fe3363bbbecb4de481d5e42385b5a0f62f6a6ce6bf3a1f9dfa8";

     

       180
       180
       +
                           };

     

       181
       181
       +
                           sourceRoot = ".";

     

       182
       182
       +
                           # We need unzip to build this package

     

       183
       183
       +
                           buildInputs = [ pkgs.unzip ];

     

       184
       184
       +
                           # Installing simply means copying all files to the output directory

     

       185
       185
       +
                           installPhase = "mkdir -p $out; cp -R * $out/";

     

       178
       186
        
                         };

     

       179
       179
       -
                         sourceRoot = ".";

     

       180
       180
       -
                         # We need unzip to build this package

     

       181
       181
       -
                         buildInputs = [ pkgs.unzip ];

     

       182
       182
       -
                         # Installing simply means copying all files to the output directory

     

       183
       183
       -
                         installPhase = "mkdir -p $out; cp -R * $out/";

     

       184
       184
       -
                       };

     

       185
       185
       -
       

     

       186
       187
        
                       # And then pass this theme to the plugin list like this:

     

       187
       187
       -
                       plugins = [ plugin-icalevents ];

     

       188
       188
       +
                       in [ plugin-icalevents ]

     

       188
       189
        
                 '';

     

       189
       190
        
               };

     

       190
       191
        
       

     
···

       195
       196
        
                       List of path(s) to respective template(s) which are copied from the 'tpl' directory.

     

       196
       197
        
                       <note><para>These templates need to be packaged before use, see example.</para></note>

     

       197
       198
        
                 '';

     

       198
       198
       -
                 example = ''

     

       199
       199
       -
                       # Let's package the bootstrap3 theme

     

       200
       200
       -
                       template-bootstrap3 = pkgs.stdenv.mkDerivation {

     

       201
       201
       -
                         name = "bootstrap3";

     

       202
       202
       -
                         # Download the theme from the dokuwiki site

     

       203
       203
       -
                         src = pkgs.fetchurl {

     

       204
       204
       -
                           url = "https://github.com/giterlizzi/dokuwiki-template-bootstrap3/archive/v2019-05-22.zip";

     

       205
       205
       -
                           sha256 = "4de5ff31d54dd61bbccaf092c9e74c1af3a4c53e07aa59f60457a8f00cfb23a6";

     

       199
       199
       +
                 example = literalExpression ''

     

       200
       200
       +
                       let

     

       201
       201
       +
                         # Let's package the bootstrap3 theme

     

       202
       202
       +
                         template-bootstrap3 = pkgs.stdenv.mkDerivation {

     

       203
       203
       +
                           name = "bootstrap3";

     

       204
       204
       +
                           # Download the theme from the dokuwiki site

     

       205
       205
       +
                           src = pkgs.fetchurl {

     

       206
       206
       +
                             url = "https://github.com/giterlizzi/dokuwiki-template-bootstrap3/archive/v2019-05-22.zip";

     

       207
       207
       +
                             sha256 = "4de5ff31d54dd61bbccaf092c9e74c1af3a4c53e07aa59f60457a8f00cfb23a6";

     

       208
       208
       +
                           };

     

       209
       209
       +
                           # We need unzip to build this package

     

       210
       210
       +
                           buildInputs = [ pkgs.unzip ];

     

       211
       211
       +
                           # Installing simply means copying all files to the output directory

     

       212
       212
       +
                           installPhase = "mkdir -p $out; cp -R * $out/";

     

       206
       213
        
                         };

     

       207
       207
       -
                         # We need unzip to build this package

     

       208
       208
       -
                         buildInputs = [ pkgs.unzip ];

     

       209
       209
       -
                         # Installing simply means copying all files to the output directory

     

       210
       210
       -
                         installPhase = "mkdir -p $out; cp -R * $out/";

     

       211
       211
       -
                       };

     

       212
       212
       -
       

     

       213
       214
        
                       # And then pass this theme to the template list like this:

     

       214
       214
       -
                       templates = [ template-bootstrap3 ];

     

       215
       215
       +
                       in [ template-bootstrap3 ]

     

       215
       216
        
                 '';

     

       216
       217
        
               };

     

       217
       218

+2 -2

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

···

       1
       1
        
       { config, lib, pkgs, utils, ... }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         inherit (lib) mkDefault mkEnableOption mkIf mkOption types literalExample;

     

       4
       4
       +
         inherit (lib) mkDefault mkEnableOption mkIf mkOption types literalExpression;

     

       5
       5
        
         cfg = config.services.engelsystem;

     

       6
       6
        
       in {

     

       7
       7
        
         options = {

     
···

       24
       24
        
       

     

       25
       25
        
             package = mkOption {

     

       26
       26
        
               type = types.package;

     

       27
       27
       -
               example = literalExample "pkgs.engelsystem";

     

       28
       27
        
               description = "Engelsystem package used for the service.";

     

       29
       28
        
               default = pkgs.engelsystem;

     

       29
       29
       +
               defaultText = literalExpression "pkgs.engelsystem";

     

       30
       30
        
             };

     

       31
       31
        
       

     

       32
       32
        
             createDatabase = mkOption {

+6 -4

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

···

       12
       12
        
             type = types.package;

     

       13
       13
        
             description = "Fluidd package to be used in the module";

     

       14
       14
        
             default = pkgs.fluidd;

     

       15
       15
       -
             defaultText = "pkgs.fluidd";

     

       15
       15
       +
             defaultText = literalExpression "pkgs.fluidd";

     

       16
       16
        
           };

     

       17
       17
        
       

     

       18
       18
        
           hostName = mkOption {

     
···

       25
       25
        
             type = types.submodule

     

       26
       26
        
               (import ../web-servers/nginx/vhost-options.nix { inherit config lib; });

     

       27
       27
        
             default = { };

     

       28
       28
       -
             example = {

     

       29
       29
       -
               serverAliases = [ "fluidd.\${config.networking.domain}" ];

     

       30
       30
       -
             };

     

       28
       28
       +
             example = literalExpression ''

     

       29
       29
       +
               {

     

       30
       30
       +
                 serverAliases = [ "fluidd.''${config.networking.domain}" ];

     

       31
       31
       +
               }

     

       32
       32
       +
             '';

     

       31
       33
        
             description = "Extra configuration for the nginx virtual host of fluidd.";

     

       32
       34
        
           };

     

       33
       35
        
         };

+2 -1

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

···

       80
       80
        
             staticDir = mkOption {

     

       81
       81
        
               type = types.str;

     

       82
       82
        
               default = "${cfg.package.static}/static";

     

       83
       83
       +
               defaultText = literalExpression ''"''${package.static}/static"'';

     

       83
       84
        
               example = "/var/lib/galene/static";

     

       84
       85
        
               description = "Web server directory.";

     

       85
       86
        
             };

     
···

       107
       108
        
       

     

       108
       109
        
             package = mkOption {

     

       109
       110
        
               default = pkgs.galene;

     

       110
       110
       -
               defaultText = "pkgs.galene";

     

       111
       111
       +
               defaultText = literalExpression "pkgs.galene";

     

       111
       112
        
               type = types.package;

     

       112
       113
        
               description = ''

     

       113
       114
        
                 Package for running Galene.

+2 -1

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

···

       64
       64
        
             package = mkOption {

     

       65
       65
        
               type = types.package;

     

       66
       66
        
               default = pkgs.gerrit;

     

       67
       67
       +
               defaultText = literalExpression "pkgs.gerrit";

     

       67
       68
        
               description = "Gerrit package to use";

     

       68
       69
        
             };

     

       69
       70
        
       

     

       70
       71
        
             jvmPackage = mkOption {

     

       71
       72
        
               type = types.package;

     

       72
       73
        
               default = pkgs.jre_headless;

     

       73
       73
       -
               defaultText = "pkgs.jre_headless";

     

       74
       74
       +
               defaultText = literalExpression "pkgs.jre_headless";

     

       74
       75
        
               description = "Java Runtime Environment package to use";

     

       75
       76
        
             };

     

       76
       77

+8 -7

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

···

       73
       73
        
             port = mkOption {

     

       74
       74
        
               type = types.int;

     

       75
       75
        
               default = 3000;

     

       76
       76
       -
               example = "80";

     

       76
       76
       +
               example = 80;

     

       77
       77
        
               description = ''

     

       78
       78
        
                 Port to listen on.

     

       79
       79
        
               '';

     
···

       135
       135
        
             csp = mkOption {

     

       136
       136
        
               type = types.nullOr types.attrs;

     

       137
       137
        
               default = null;

     

       138
       138
       -
               example = literalExample ''

     

       138
       138
       +
               example = literalExpression ''

     

       139
       139
        
                 {

     

       140
       140
        
                   enable = true;

     

       141
       141
        
                   directives = {

     
···

       222
       222
        
             db = mkOption {

     

       223
       223
        
               type = types.attrs;

     

       224
       224
        
               default = {};

     

       225
       225
       -
               example = literalExample ''

     

       225
       225
       +
               example = literalExpression ''

     

       226
       226
        
                 {

     

       227
       227
        
                   dialect = "sqlite";

     

       228
       228
        
                   storage = "/var/lib/${name}/db.${name}.sqlite";

     
···

       313
       313
        
             errorPath = mkOption {

     

       314
       314
        
               type = types.nullOr types.str;

     

       315
       315
        
               default = null;

     

       316
       316
       -
               defaultText = "./public/views/error.ejs";

     

       316
       316
       +
               defaultText = literalExpression "./public/views/error.ejs";

     

       317
       317
        
               description = ''

     

       318
       318
        
                 Path to the error template file.

     

       319
       319
        
                 (Non-canonical paths are relative to HedgeDoc's base directory)

     
···

       322
       322
        
             prettyPath = mkOption {

     

       323
       323
        
               type = types.nullOr types.str;

     

       324
       324
        
               default = null;

     

       325
       325
       -
               defaultText = "./public/views/pretty.ejs";

     

       325
       325
       +
               defaultText = literalExpression "./public/views/pretty.ejs";

     

       326
       326
        
               description = ''

     

       327
       327
        
                 Path to the pretty template file.

     

       328
       328
        
                 (Non-canonical paths are relative to HedgeDoc's base directory)

     
···

       331
       331
        
             slidePath = mkOption {

     

       332
       332
        
               type = types.nullOr types.str;

     

       333
       333
        
               default = null;

     

       334
       334
       -
               defaultText = "./public/views/slide.hbs";

     

       334
       334
       +
               defaultText = literalExpression "./public/views/slide.hbs";

     

       335
       335
        
               description = ''

     

       336
       336
        
                 Path to the slide template file.

     

       337
       337
        
                 (Non-canonical paths are relative to HedgeDoc's base directory)

     
···

       340
       340
        
             uploadsPath = mkOption {

     

       341
       341
        
               type = types.str;

     

       342
       342
        
               default = "${cfg.workDir}/uploads";

     

       343
       343
       -
               defaultText = "/var/lib/${name}/uploads";

     

       343
       343
       +
               defaultText = literalExpression "/var/lib/${name}/uploads";

     

       344
       344
        
               description = ''

     

       345
       345
        
                 Path under which uploaded files are saved.

     

       346
       346
        
               '';

     
···

       925
       925
        
           package = mkOption {

     

       926
       926
        
             type = types.package;

     

       927
       927
        
             default = pkgs.hedgedoc;

     

       928
       928
       +
             defaultText = literalExpression "pkgs.hedgedoc";

     

       928
       929
        
             description = ''

     

       929
       930
        
               Package that provides HedgeDoc.

     

       930
       931
        
             '';

+1 -1

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

···

       20
       20
        
           port = mkOption {

     

       21
       21
        
             type = types.port;

     

       22
       22
        
             default = 5000;

     

       23
       23
       -
             example = "80";

     

       23
       23
       +
             example = 80;

     

       24
       24
        
             description = ''

     

       25
       25
        
               Port to listen on.

     

       26
       26
        
             '';

+1 -1

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

···

       59
       59
        
           modulePackages = mkOption {

     

       60
       60
        
             type = attrsOf package;

     

       61
       61
        
             default = {};

     

       62
       62
       -
             example = literalExample ''

     

       62
       62
       +
             example = literalExpression ''

     

       63
       63
        
               {

     

       64
       64
        
                 "snow" = icingaweb2Modules.theme-snow;

     

       65
       65
        
               }

+2 -2

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

···

       1
       1
        
       { config, lib, pkgs, ... }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         inherit (lib) mkEnableOption mkIf mkOption types literalExample;

     

       4
       4
       +
         inherit (lib) mkEnableOption mkIf mkOption types literalExpression;

     

       5
       5
        
       

     

       6
       6
        
         cfg = config.services.isso;

     

       7
       7
        
       

     
···

       31
       31
        
                 freeformType = settingsFormat.type;

     

       32
       32
        
               };

     

       33
       33
        
       

     

       34
       34
       -
               example = literalExample ''

     

       34
       34
       +
               example = literalExpression ''

     

       35
       35
        
                 {

     

       36
       36
        
                   general = {

     

       37
       37
        
                     host = "http://localhost";

+6 -5

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

···

       84
       84
        
             type = types.submodule

     

       85
       85
        
               (import ../web-servers/nginx/vhost-options.nix { inherit config lib; });

     

       86
       86
        
             default = {};

     

       87
       87
       -
             example = {

     

       88
       88
       -
               serverAliases = [ "wiki.\${config.networking.domain}" ];

     

       89
       89
       -
             };

     

       87
       87
       +
             example = literalExpression ''

     

       88
       88
       +
               {

     

       89
       89
       +
                 serverAliases = [ "wiki.''${config.networking.domain}" ];

     

       90
       90
       +
               }

     

       91
       91
       +
             '';

     

       90
       92
        
             description = "Extra configuration for the nginx virtual host of Jirafeau.";

     

       91
       93
        
           };

     

       92
       94
        
       

     

       93
       95
        
           package = mkOption {

     

       94
       96
        
             type = types.package;

     

       95
       97
        
             default = pkgs.jirafeau;

     

       96
       96
       -
             defaultText = "pkgs.jirafeau";

     

       98
       98
       +
             defaultText = literalExpression "pkgs.jirafeau";

     

       97
       99
        
             description = "Jirafeau package to use";

     

       98
       98
       -
             example = "pkgs.jirafeau";

     

       99
       100
        
           };

     

       100
       101
        
       

     

       101
       102
        
           poolConfig = mkOption {

+2 -2

nixos/modules/services/web-apps/jitsi-meet.nix

···

       54
       54
        
           config = mkOption {

     

       55
       55
        
             type = attrs;

     

       56
       56
        
             default = { };

     

       57
       57
       -
             example = literalExample ''

     

       57
       57
       +
             example = literalExpression ''

     

       58
       58
        
               {

     

       59
       59
        
                 enableWelcomePage = false;

     

       60
       60
        
                 defaultLang = "fi";

     
···

       81
       81
        
           interfaceConfig = mkOption {

     

       82
       82
        
             type = attrs;

     

       83
       83
        
             default = { };

     

       84
       84
       -
             example = literalExample ''

     

       84
       84
       +
             example = literalExpression ''

     

       85
       85
        
               {

     

       86
       86
        
                 SHOW_JITSI_WATERMARK = false;

     

       87
       87
        
                 SHOW_WATERMARK_FOR_GUESTS = false;

+2 -1

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

···

       210
       210
        
           package = lib.mkOption {

     

       211
       211
        
             type = lib.types.package;

     

       212
       212
        
             default = pkgs.keycloak;

     

       213
       213
       +
             defaultText = lib.literalExpression "pkgs.keycloak";

     

       213
       214
        
             description = ''

     

       214
       215
        
               Keycloak package to use.

     

       215
       216
        
             '';

     
···

       228
       229
        
           extraConfig = lib.mkOption {

     

       229
       230
        
             type = lib.types.attrs;

     

       230
       231
        
             default = { };

     

       231
       231
       -
             example = lib.literalExample ''

     

       232
       232
       +
             example = lib.literalExpression ''

     

       232
       233
        
               {

     

       233
       234
        
                 "subsystem=keycloak-server" = {

     

       234
       235
        
                   "spi=hostname" = {

+5 -5

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

···

       3
       3
        
       let

     

       4
       4
        
       

     

       5
       5
        
         inherit (lib) mkDefault mkEnableOption mkForce mkIf mkMerge mkOption;

     

       6
       6
       -
         inherit (lib) literalExample mapAttrs optional optionalString types;

     

       6
       6
       +
         inherit (lib) literalExpression mapAttrs optional optionalString types;

     

       7
       7
        
       

     

       8
       8
        
         cfg = config.services.limesurvey;

     

       9
       9
        
         fpm = config.services.phpfpm.pools.limesurvey;

     
···

       51
       51
        
             port = mkOption {

     

       52
       52
        
               type = types.int;

     

       53
       53
        
               default = if cfg.database.type == "pgsql" then 5442 else 3306;

     

       54
       54
       -
               defaultText = "3306";

     

       54
       54
       +
               defaultText = literalExpression "3306";

     

       55
       55
        
               description = "Database host port.";

     

       56
       56
        
             };

     

       57
       57
        
       

     
···

       84
       84
        
                 else if pgsqlLocal then "/run/postgresql"

     

       85
       85
        
                 else null

     

       86
       86
        
               ;

     

       87
       87
       -
               defaultText = "/run/mysqld/mysqld.sock";

     

       87
       87
       +
               defaultText = literalExpression "/run/mysqld/mysqld.sock";

     

       88
       88
        
               description = "Path to the unix socket file to use for authentication.";

     

       89
       89
        
             };

     

       90
       90
        
       

     

       91
       91
        
             createLocally = mkOption {

     

       92
       92
        
               type = types.bool;

     

       93
       93
        
               default = cfg.database.type == "mysql";

     

       94
       94
       -
               defaultText = "true";

     

       94
       94
       +
               defaultText = literalExpression "true";

     

       95
       95
        
               description = ''

     

       96
       96
        
                 Create the database and database user locally.

     

       97
       97
        
                 This currently only applies if database type "mysql" is selected.

     
···

       101
       101
        
       

     

       102
       102
        
           virtualHost = mkOption {

     

       103
       103
        
             type = types.submodule (import ../web-servers/apache-httpd/vhost-options.nix);

     

       104
       104
       -
             example = literalExample ''

     

       104
       104
       +
             example = literalExpression ''

     

       105
       105
        
               {

     

       106
       106
        
                 hostName = "survey.example.org";

     

       107
       107
        
                 adminAddr = "webmaster@example.org";

+1 -1

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

···

       399
       399
        
             package = lib.mkOption {

     

       400
       400
        
               type = lib.types.package;

     

       401
       401
        
               default = pkgs.mastodon;

     

       402
       402
       -
               defaultText = "pkgs.mastodon";

     

       402
       402
       +
               defaultText = lib.literalExpression "pkgs.mastodon";

     

       403
       403
        
               description = "Mastodon package to use.";

     

       404
       404
        
             };

     

       405
       405

+10 -8

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

···

       48
       48
        
                 as they don't get backported if they are not security-relevant.

     

       49
       49
        
               '';

     

       50
       50
        
               default = pkgs.matomo;

     

       51
       51
       -
               defaultText = "pkgs.matomo";

     

       51
       51
       +
               defaultText = literalExpression "pkgs.matomo";

     

       52
       52
        
             };

     

       53
       53
        
       

     

       54
       54
        
             webServerUser = mkOption {

     
···

       100
       100
        
               )

     

       101
       101
        
               );

     

       102
       102
        
               default = null;

     

       103
       103
       -
               example = {

     

       104
       104
       -
                 serverAliases = [

     

       105
       105
       -
                   "matomo.\${config.networking.domain}"

     

       106
       106
       -
                   "stats.\${config.networking.domain}"

     

       107
       107
       -
                 ];

     

       108
       108
       -
                 enableACME = false;

     

       109
       109
       -
               };

     

       103
       103
       +
               example = literalExpression ''

     

       104
       104
       +
                 {

     

       105
       105
       +
                   serverAliases = [

     

       106
       106
       +
                     "matomo.''${config.networking.domain}"

     

       107
       107
       +
                     "stats.''${config.networking.domain}"

     

       108
       108
       +
                   ];

     

       109
       109
       +
                   enableACME = false;

     

       110
       110
       +
                 }

     

       111
       111
       +
               '';

     

       110
       112
        
               description = ''

     

       111
       113
        
                   With this option, you can customize an nginx virtualHost which already has sensible defaults for Matomo.

     

       112
       114
        
                   Either this option or the webServerUser option is mandatory.

+6 -5

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

···

       3
       3
        
       let

     

       4
       4
        
       

     

       5
       5
        
         inherit (lib) mkDefault mkEnableOption mkForce mkIf mkMerge mkOption;

     

       6
       6
       -
         inherit (lib) concatStringsSep literalExample mapAttrsToList optional optionals optionalString types;

     

       6
       6
       +
         inherit (lib) concatStringsSep literalExpression mapAttrsToList optional optionals optionalString types;

     

       7
       7
        
       

     

       8
       8
        
         cfg = config.services.mediawiki;

     

       9
       9
        
         fpm = config.services.phpfpm.pools.mediawiki;

     
···

       176
       176
        
             package = mkOption {

     

       177
       177
        
               type = types.package;

     

       178
       178
        
               default = pkgs.mediawiki;

     

       179
       179
       +
               defaultText = literalExpression "pkgs.mediawiki";

     

       179
       180
        
               description = "Which MediaWiki package to use.";

     

       180
       181
        
             };

     

       181
       182
        
       

     
···

       219
       220
        
       

     

       220
       221
        
                 Use <literal>null</literal> instead of path to enable extensions that are part of MediaWiki.

     

       221
       222
        
               '';

     

       222
       222
       -
               example = literalExample ''

     

       223
       223
       +
               example = literalExpression ''

     

       223
       224
        
                 {

     

       224
       225
        
                   Matomo = pkgs.fetchzip {

     

       225
       226
        
                     url = "https://github.com/DaSchTour/matomo-mediawiki-extension/archive/v4.0.1.tar.gz";

     
···

       286
       287
        
               socket = mkOption {

     

       287
       288
        
                 type = types.nullOr types.path;

     

       288
       289
        
                 default = if cfg.database.createLocally then "/run/mysqld/mysqld.sock" else null;

     

       289
       289
       -
                 defaultText = "/run/mysqld/mysqld.sock";

     

       290
       290
       +
                 defaultText = literalExpression "/run/mysqld/mysqld.sock";

     

       290
       291
        
                 description = "Path to the unix socket file to use for authentication.";

     

       291
       292
        
               };

     

       292
       293
        
       

     

       293
       294
        
               createLocally = mkOption {

     

       294
       295
        
                 type = types.bool;

     

       295
       296
        
                 default = cfg.database.type == "mysql";

     

       296
       296
       -
                 defaultText = "true";

     

       297
       297
       +
                 defaultText = literalExpression "true";

     

       297
       298
        
                 description = ''

     

       298
       299
        
                   Create the database and database user locally.

     

       299
       300
        
                   This currently only applies if database type "mysql" is selected.

     
···

       303
       304
        
       

     

       304
       305
        
             virtualHost = mkOption {

     

       305
       306
        
               type = types.submodule (import ../web-servers/apache-httpd/vhost-options.nix);

     

       306
       306
       -
               example = literalExample ''

     

       307
       307
       +
               example = literalExpression ''

     

       307
       308
        
                 {

     

       308
       309
        
                   hostName = "mediawiki.example.org";

     

       309
       310
        
                   adminAddr = "webmaster@example.org";

+1 -1

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

···

       35
       35
        
       

     

       36
       36
        
             config = mkOption {

     

       37
       37
        
               type = types.attrsOf types.str;

     

       38
       38
       -
               example = literalExample ''

     

       38
       38
       +
               example = literalExpression ''

     

       39
       39
        
                 {

     

       40
       40
        
                   CLEANUP_FREQUENCY = "48";

     

       41
       41
        
                   LISTEN_ADDR = "localhost:8080";

+1 -1

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

···

       151
       151
        
                 webHost = mkDefault name;

     

       152
       152
        
               };

     

       153
       153
        
             }));

     

       154
       154
       -
             example = literalExample ''

     

       154
       154
       +
             example = literalExpression ''

     

       155
       155
        
               {

     

       156
       156
        
                 "mywiki" = {

     

       157
       157
        
                   siteName = "Example Wiki";

+5 -5

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

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         inherit (lib) mkDefault mkEnableOption mkForce mkIf mkMerge mkOption types;

     

       5
       5
       -
         inherit (lib) concatStringsSep literalExample mapAttrsToList optional optionalString;

     

       5
       5
       +
         inherit (lib) concatStringsSep literalExpression mapAttrsToList optional optionalString;

     

       6
       6
        
       

     

       7
       7
        
         cfg = config.services.moodle;

     

       8
       8
        
         fpm = config.services.phpfpm.pools.moodle;

     
···

       67
       67
        
           package = mkOption {

     

       68
       68
        
             type = types.package;

     

       69
       69
        
             default = pkgs.moodle;

     

       70
       70
       -
             defaultText = "pkgs.moodle";

     

       70
       70
       +
             defaultText = literalExpression "pkgs.moodle";

     

       71
       71
        
             description = "The Moodle package to use.";

     

       72
       72
        
           };

     

       73
       73
        
       

     
···

       100
       100
        
                 mysql = 3306;

     

       101
       101
        
                 pgsql = 5432;

     

       102
       102
        
               }.${cfg.database.type};

     

       103
       103
       -
               defaultText = "3306";

     

       103
       103
       +
               defaultText = literalExpression "3306";

     

       104
       104
        
             };

     

       105
       105
        
       

     

       106
       106
        
             name = mkOption {

     
···

       131
       131
        
                 if mysqlLocal then "/run/mysqld/mysqld.sock"

     

       132
       132
        
                 else if pgsqlLocal then "/run/postgresql"

     

       133
       133
        
                 else null;

     

       134
       134
       -
               defaultText = "/run/mysqld/mysqld.sock";

     

       134
       134
       +
               defaultText = literalExpression "/run/mysqld/mysqld.sock";

     

       135
       135
        
               description = "Path to the unix socket file to use for authentication.";

     

       136
       136
        
             };

     

       137
       137
        
       

     
···

       144
       144
        
       

     

       145
       145
        
           virtualHost = mkOption {

     

       146
       146
        
             type = types.submodule (import ../web-servers/apache-httpd/vhost-options.nix);

     

       147
       147
       -
             example = literalExample ''

     

       147
       147
       +
             example = literalExpression ''

     

       148
       148
        
               {

     

       149
       149
        
                 hostName = "moodle.example.org";

     

       150
       150
        
                 adminAddr = "webmaster@example.org";

+2 -2

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

···

       134
       134
        
           phpExtraExtensions = mkOption {

     

       135
       135
        
             type = with types; functionTo (listOf package);

     

       136
       136
        
             default = all: [];

     

       137
       137
       -
             defaultText = "all: []";

     

       137
       137
       +
             defaultText = literalExpression "all: []";

     

       138
       138
        
             description = ''

     

       139
       139
        
               Additional PHP extensions to use for nextcloud.

     

       140
       140
        
               By default, only extensions necessary for a vanilla nextcloud installation are enabled,

     

       141
       141
        
               but you may choose from the list of available extensions and add further ones.

     

       142
       142
        
               This is sometimes necessary to be able to install a certain nextcloud app that has additional requirements.

     

       143
       143
        
             '';

     

       144
       144
       -
             example = literalExample ''

     

       144
       144
       +
             example = literalExpression ''

     

       145
       145
        
               all: [ all.pdlib all.bz2 ]

     

       146
       146
        
             '';

     

       147
       147
        
           };

+22

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

···

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

     

       18
       18
        
               default = pkgs.nexus;

     

       19
       19
       +
               defaultText = literalExpression "pkgs.nexus";

     

       19
       20
        
               description = "Package which runs Nexus3";

     

       20
       21
        
             };

     

       21
       22
        
       

     
···

       69
       70
        
                 -Djava.io.tmpdir=${cfg.home}/nexus3/tmp

     

       70
       71
        
                 -Dkaraf.startLocalConsole=false

     

       71
       72
        
                 -Djava.endorsed.dirs=${cfg.package}/lib/endorsed

     

       73
       73
       +
               '';

     

       74
       74
       +
               defaultText = literalExpression ''

     

       75
       75
       +
                 '''

     

       76
       76
       +
                   -Xms1200M

     

       77
       77
       +
                   -Xmx1200M

     

       78
       78
       +
                   -XX:MaxDirectMemorySize=2G

     

       79
       79
       +
                   -XX:+UnlockDiagnosticVMOptions

     

       80
       80
       +
                   -XX:+UnsyncloadClass

     

       81
       81
       +
                   -XX:+LogVMOutput

     

       82
       82
       +
                   -XX:LogFile=''${home}/nexus3/log/jvm.log

     

       83
       83
       +
                   -XX:-OmitStackTraceInFastThrow

     

       84
       84
       +
                   -Djava.net.preferIPv4Stack=true

     

       85
       85
       +
                   -Dkaraf.home=''${package}

     

       86
       86
       +
                   -Dkaraf.base=''${package}

     

       87
       87
       +
                   -Dkaraf.etc=''${package}/etc/karaf

     

       88
       88
       +
                   -Djava.util.logging.config.file=''${package}/etc/karaf/java.util.logging.properties

     

       89
       89
       +
                   -Dkaraf.data=''${home}/nexus3

     

       90
       90
       +
                   -Djava.io.tmpdir=''${home}/nexus3/tmp

     

       91
       91
       +
                   -Dkaraf.startLocalConsole=false

     

       92
       92
       +
                   -Djava.endorsed.dirs=''${package}/lib/endorsed

     

       93
       93
       +
                 '''

     

       72
       94
        
               '';

     

       73
       95
        
       

     

       74
       96
        
               description = ''

+3 -3

nixos/modules/services/web-apps/node-red.nix

···

       21
       21
        
       

     

       22
       22
        
           package = mkOption {

     

       23
       23
        
             default = pkgs.nodePackages.node-red;

     

       24
       24
       -
             defaultText = "pkgs.nodePackages.node-red";

     

       24
       24
       +
             defaultText = literalExpression "pkgs.nodePackages.node-red";

     

       25
       25
        
             type = types.package;

     

       26
       26
        
             description = "Node-RED package to use.";

     

       27
       27
        
           };

     
···

       46
       46
        
           configFile = mkOption {

     

       47
       47
        
             type = types.path;

     

       48
       48
        
             default = "${cfg.package}/lib/node_modules/node-red/settings.js";

     

       49
       49
       -
             defaultText = "\${cfg.package}/lib/node_modules/node-red/settings.js";

     

       49
       49
       +
             defaultText = literalExpression ''"''${package}/lib/node_modules/node-red/settings.js"'';

     

       50
       50
        
             description = ''

     

       51
       51
        
               Path to the JavaScript configuration file.

     

       52
       52
        
               See <link

     
···

       102
       102
        
             type = types.attrs;

     

       103
       103
        
             default = {};

     

       104
       104
        
             description = "List of settings.js overrides to pass via -D to Node-RED.";

     

       105
       105
       -
             example = literalExample ''

     

       105
       105
       +
             example = literalExpression ''

     

       106
       106
        
               {

     

       107
       107
        
                 "logging.console.level" = "trace";

     

       108
       108
        
               }

+1 -1

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

···

       21
       21
        
       

     

       22
       22
        
             package = mkOption {

     

       23
       23
        
               default = pkgs.pgpkeyserver-lite;

     

       24
       24
       -
               defaultText = "pkgs.pgpkeyserver-lite";

     

       24
       24
       +
               defaultText = literalExpression "pkgs.pgpkeyserver-lite";

     

       25
       25
        
               type = types.package;

     

       26
       26
        
               description = "

     

       27
       27
        
                 Which webgui derivation to use.

+2

nixos/modules/services/web-apps/plantuml-server.nix

···

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

     

       18
       18
        
               default = pkgs.plantuml-server;

     

       19
       19
       +
               defaultText = literalExpression "pkgs.plantuml-server";

     

       19
       20
        
               description = "PlantUML server package to use";

     

       20
       21
        
             };

     

       21
       22
        
       

     
···

       58
       59
        
             graphvizPackage = mkOption {

     

       59
       60
        
               type = types.package;

     

       60
       61
        
               default = pkgs.graphviz_2_32;

     

       62
       62
       +
               defaultText = literalExpression "pkgs.graphviz_2_32";

     

       61
       63
        
               description = "Package containing the dot executable.";

     

       62
       64
        
             };

     

       63
       65

-3

nixos/modules/services/web-apps/restya-board.nix

···

       30
       30
        
             dataDir = mkOption {

     

       31
       31
        
               type = types.path;

     

       32
       32
        
               default = "/var/lib/restya-board";

     

       33
       33
       -
               example = "/var/lib/restya-board";

     

       34
       33
        
               description = ''

     

       35
       34
        
                 Data of the application.

     

       36
       35
        
               '';

     
···

       39
       38
        
             user = mkOption {

     

       40
       39
        
               type = types.str;

     

       41
       40
        
               default = "restya-board";

     

       42
       42
       -
               example = "restya-board";

     

       43
       41
        
               description = ''

     

       44
       42
        
                 User account under which the web-application runs.

     

       45
       43
        
               '';

     
···

       48
       46
        
             group = mkOption {

     

       49
       47
        
               type = types.str;

     

       50
       48
        
               default = "nginx";

     

       51
       51
       -
               example = "nginx";

     

       52
       49
        
               description = ''

     

       53
       50
        
                 Group account under which the web-application runs.

     

       54
       51
        
               '';

+1 -3

nixos/modules/services/web-apps/rss-bridge.nix

···

       16
       16
        
             user = mkOption {

     

       17
       17
        
               type = types.str;

     

       18
       18
        
               default = "nginx";

     

       19
       19
       -
               example = "nginx";

     

       20
       19
        
               description = ''

     

       21
       20
        
                 User account under which both the service and the web-application run.

     

       22
       21
        
               '';

     
···

       25
       24
        
             group = mkOption {

     

       26
       25
        
               type = types.str;

     

       27
       26
        
               default = "nginx";

     

       28
       28
       -
               example = "nginx";

     

       29
       27
        
               description = ''

     

       30
       28
        
                 Group under which the web-application run.

     

       31
       29
        
               '';

     
···

       61
       59
        
             whitelist = mkOption {

     

       62
       60
        
               type = types.listOf types.str;

     

       63
       61
        
               default = [];

     

       64
       64
       -
               example = options.literalExample ''

     

       62
       62
       +
               example = options.literalExpression ''

     

       65
       63
        
                 [

     

       66
       64
        
                   "Facebook"

     

       67
       65
        
                   "Instagram"

-1

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

···

       35
       35
        
               user = mkOption {

     

       36
       36
        
                 type = types.str;

     

       37
       37
        
                 default = "nginx";

     

       38
       38
       -
                 example = "nginx";

     

       39
       38
        
                 description = ''

     

       40
       39
        
                   User account under which both the service and the web-application run.

     

       41
       40
        
                 '';

+1 -1

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

···

       11
       11
        
             package = mkOption {

     

       12
       12
        
               type = types.package;

     

       13
       13
        
               default = pkgs.shiori;

     

       14
       14
       -
               defaultText = "pkgs.shiori";

     

       14
       14
       +
               defaultText = literalExpression "pkgs.shiori";

     

       15
       15
        
               description = "The Shiori package to use.";

     

       16
       16
        
             };

     

       17
       17

-2

nixos/modules/services/web-apps/tt-rss.nix

···

       126
       126
        
             root = mkOption {

     

       127
       127
        
               type = types.path;

     

       128
       128
        
               default = "/var/lib/tt-rss";

     

       129
       129
       -
               example = "/var/lib/tt-rss";

     

       130
       129
        
               description = ''

     

       131
       130
        
                 Root of the application.

     

       132
       131
        
               '';

     
···

       135
       134
        
             user = mkOption {

     

       136
       135
        
               type = types.str;

     

       137
       136
        
               default = "tt_rss";

     

       138
       138
       -
               example = "tt_rss";

     

       139
       137
        
               description = ''

     

       140
       138
        
                 User account under which both the update daemon and the web-application run.

     

       141
       139
        
               '';

+3 -3

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

···

       14
       14
        
           package-api = mkOption {

     

       15
       15
        
             default = pkgs.vikunja-api;

     

       16
       16
        
             type = types.package;

     

       17
       17
       -
             defaultText = "pkgs.vikunja-api";

     

       17
       17
       +
             defaultText = literalExpression "pkgs.vikunja-api";

     

       18
       18
        
             description = "vikunja-api derivation to use.";

     

       19
       19
        
           };

     

       20
       20
        
           package-frontend = mkOption {

     

       21
       21
        
             default = pkgs.vikunja-frontend;

     

       22
       22
        
             type = types.package;

     

       23
       23
       -
             defaultText = "pkgs.vikunja-frontend";

     

       23
       23
       +
             defaultText = literalExpression "pkgs.vikunja-frontend";

     

       24
       24
        
             description = "vikunja-frontend derivation to use.";

     

       25
       25
        
           };

     

       26
       26
        
           environmentFiles = mkOption {

     
···

       34
       34
        
           setupNginx = mkOption {

     

       35
       35
        
             type = types.bool;

     

       36
       36
        
             default = config.services.nginx.enable;

     

       37
       37
       -
             defaultText = "config.services.nginx.enable";

     

       37
       37
       +
             defaultText = literalExpression "config.services.nginx.enable";

     

       38
       38
        
             description = ''

     

       39
       39
        
               Whether to setup NGINX.

     

       40
       40
        
               Further nginx configuration can be done by changing

+1 -1

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

···

       11
       11
        
       

     

       12
       12
        
             package = mkOption {

     

       13
       13
        
               default = pkgs.whitebophir;

     

       14
       14
       -
               defaultText = "pkgs.whitebophir";

     

       14
       14
       +
               defaultText = literalExpression "pkgs.whitebophir";

     

       15
       15
        
               type = types.package;

     

       16
       16
        
               description = "Whitebophir package to use.";

     

       17
       17
        
             };

+36 -35

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

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         inherit (lib) mkDefault mkEnableOption mkForce mkIf mkMerge mkOption types;

     

       5
       5
       -
         inherit (lib) any attrValues concatMapStringsSep flatten literalExample;

     

       5
       5
       +
         inherit (lib) any attrValues concatMapStringsSep flatten literalExpression;

     

       6
       6
        
         inherit (lib) filterAttrs mapAttrs mapAttrs' mapAttrsToList nameValuePair optional optionalAttrs optionalString;

     

       7
       7
        
       

     

       8
       8
        
         cfg = migrateOldAttrs config.services.wordpress;

     
···

       87
       87
        
               package = mkOption {

     

       88
       88
        
                 type = types.package;

     

       89
       89
        
                 default = pkgs.wordpress;

     

       90
       90
       +
                 defaultText = literalExpression "pkgs.wordpress";

     

       90
       91
        
                 description = "Which WordPress package to use.";

     

       91
       92
        
               };

     

       92
       93
        
       

     
···

       106
       107
        
                   List of path(s) to respective plugin(s) which are copied from the 'plugins' directory.

     

       107
       108
        
                   <note><para>These plugins need to be packaged before use, see example.</para></note>

     

       108
       109
        
                 '';

     

       109
       109
       -
                 example = ''

     

       110
       110
       -
                   # Wordpress plugin 'embed-pdf-viewer' installation example

     

       111
       111
       -
                   embedPdfViewerPlugin = pkgs.stdenv.mkDerivation {

     

       112
       112
       -
                     name = "embed-pdf-viewer-plugin";

     

       113
       113
       -
                     # Download the theme from the wordpress site

     

       114
       114
       -
                     src = pkgs.fetchurl {

     

       115
       115
       -
                       url = "https://downloads.wordpress.org/plugin/embed-pdf-viewer.2.0.3.zip";

     

       116
       116
       -
                       sha256 = "1rhba5h5fjlhy8p05zf0p14c9iagfh96y91r36ni0rmk6y891lyd";

     

       110
       110
       +
                 example = literalExpression ''

     

       111
       111
       +
                   let

     

       112
       112
       +
                     # Wordpress plugin 'embed-pdf-viewer' installation example

     

       113
       113
       +
                     embedPdfViewerPlugin = pkgs.stdenv.mkDerivation {

     

       114
       114
       +
                       name = "embed-pdf-viewer-plugin";

     

       115
       115
       +
                       # Download the theme from the wordpress site

     

       116
       116
       +
                       src = pkgs.fetchurl {

     

       117
       117
       +
                         url = "https://downloads.wordpress.org/plugin/embed-pdf-viewer.2.0.3.zip";

     

       118
       118
       +
                         sha256 = "1rhba5h5fjlhy8p05zf0p14c9iagfh96y91r36ni0rmk6y891lyd";

     

       119
       119
       +
                       };

     

       120
       120
       +
                       # We need unzip to build this package

     

       121
       121
       +
                       nativeBuildInputs = [ pkgs.unzip ];

     

       122
       122
       +
                       # Installing simply means copying all files to the output directory

     

       123
       123
       +
                       installPhase = "mkdir -p $out; cp -R * $out/";

     

       117
       124
        
                     };

     

       118
       118
       -
                     # We need unzip to build this package

     

       119
       119
       -
                     nativeBuildInputs = [ pkgs.unzip ];

     

       120
       120
       -
                     # Installing simply means copying all files to the output directory

     

       121
       121
       -
                     installPhase = "mkdir -p $out; cp -R * $out/";

     

       122
       122
       -
                   };

     

       123
       123
       -
       

     

       124
       124
       -
                   And then pass this theme to the themes list like this:

     

       125
       125
       -
                     plugins = [ embedPdfViewerPlugin ];

     

       125
       125
       +
                   # And then pass this theme to the themes list like this:

     

       126
       126
       +
                   in [ embedPdfViewerPlugin ]

     

       126
       127
        
                 '';

     

       127
       128
        
               };

     

       128
       129
        
       

     
···

       133
       134
        
                   List of path(s) to respective theme(s) which are copied from the 'theme' directory.

     

       134
       135
        
                   <note><para>These themes need to be packaged before use, see example.</para></note>

     

       135
       136
        
                 '';

     

       136
       136
       -
                 example = ''

     

       137
       137
       -
                   # Let's package the responsive theme

     

       138
       138
       -
                   responsiveTheme = pkgs.stdenv.mkDerivation {

     

       139
       139
       -
                     name = "responsive-theme";

     

       140
       140
       -
                     # Download the theme from the wordpress site

     

       141
       141
       -
                     src = pkgs.fetchurl {

     

       142
       142
       -
                       url = "https://downloads.wordpress.org/theme/responsive.3.14.zip";

     

       143
       143
       -
                       sha256 = "0rjwm811f4aa4q43r77zxlpklyb85q08f9c8ns2akcarrvj5ydx3";

     

       137
       137
       +
                 example = literalExpression ''

     

       138
       138
       +
                   let

     

       139
       139
       +
                     # Let's package the responsive theme

     

       140
       140
       +
                     responsiveTheme = pkgs.stdenv.mkDerivation {

     

       141
       141
       +
                       name = "responsive-theme";

     

       142
       142
       +
                       # Download the theme from the wordpress site

     

       143
       143
       +
                       src = pkgs.fetchurl {

     

       144
       144
       +
                         url = "https://downloads.wordpress.org/theme/responsive.3.14.zip";

     

       145
       145
       +
                         sha256 = "0rjwm811f4aa4q43r77zxlpklyb85q08f9c8ns2akcarrvj5ydx3";

     

       146
       146
       +
                       };

     

       147
       147
       +
                       # We need unzip to build this package

     

       148
       148
       +
                       nativeBuildInputs = [ pkgs.unzip ];

     

       149
       149
       +
                       # Installing simply means copying all files to the output directory

     

       150
       150
       +
                       installPhase = "mkdir -p $out; cp -R * $out/";

     

       144
       151
        
                     };

     

       145
       145
       -
                     # We need unzip to build this package

     

       146
       146
       -
                     nativeBuildInputs = [ pkgs.unzip ];

     

       147
       147
       -
                     # Installing simply means copying all files to the output directory

     

       148
       148
       -
                     installPhase = "mkdir -p $out; cp -R * $out/";

     

       149
       149
       -
                   };

     

       150
       150
       -
       

     

       151
       151
       -
                   And then pass this theme to the themes list like this:

     

       152
       152
       -
                     themes = [ responsiveTheme ];

     

       152
       152
       +
                   # And then pass this theme to the themes list like this:

     

       153
       153
       +
                   in [ responsiveTheme ]

     

       153
       154
        
                 '';

     

       154
       155
        
               };

     

       155
       156
        
       

     
···

       204
       205
        
                 socket = mkOption {

     

       205
       206
        
                   type = types.nullOr types.path;

     

       206
       207
        
                   default = null;

     

       207
       207
       -
                   defaultText = "/run/mysqld/mysqld.sock";

     

       208
       208
       +
                   defaultText = literalExpression "/run/mysqld/mysqld.sock";

     

       208
       209
        
                   description = "Path to the unix socket file to use for authentication.";

     

       209
       210
        
                 };

     

       210
       211
        
       

     
···

       217
       218
        
       

     

       218
       219
        
               virtualHost = mkOption {

     

       219
       220
        
                 type = types.submodule (import ../web-servers/apache-httpd/vhost-options.nix);

     

       220
       220
       -
                 example = literalExample ''

     

       221
       221
       +
                 example = literalExpression ''

     

       221
       222
        
                   {

     

       222
       223
        
                     adminAddr = "webmaster@example.org";

     

       223
       224
        
                     forceSSL = true;

+2 -2

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

···

       46
       46
        
               https://www.jetbrains.com/help/youtrack/standalone/YouTrack-Java-Start-Parameters.html

     

       47
       47
        
               for more information.

     

       48
       48
        
             '';

     

       49
       49
       -
             example = literalExample ''

     

       49
       49
       +
             example = literalExpression ''

     

       50
       50
        
               {

     

       51
       51
        
                 "jetbrains.youtrack.overrideRootPassword" = "tortuga";

     

       52
       52
        
               }

     
···

       60
       60
        
             '';

     

       61
       61
        
             type = types.package;

     

       62
       62
        
             default = pkgs.youtrack;

     

       63
       63
       -
             defaultText = "pkgs.youtrack";

     

       63
       63
       +
             defaultText = literalExpression "pkgs.youtrack";

     

       64
       64
        
           };

     

       65
       65
        
       

     

       66
       66
        
           port = mkOption {

+3 -3

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

···

       3
       3
        
       let

     

       4
       4
        
       

     

       5
       5
        
         inherit (lib) mkDefault mkEnableOption mkForce mkIf mkMerge mkOption types;

     

       6
       6
       -
         inherit (lib) literalExample mapAttrs optionalString versionAtLeast;

     

       6
       6
       +
         inherit (lib) literalExpression mapAttrs optionalString versionAtLeast;

     

       7
       7
        
       

     

       8
       8
        
         cfg = config.services.zabbixWeb;

     

       9
       9
        
         fpm = config.services.phpfpm.pools.zabbix;

     
···

       43
       43
        
             package = mkOption {

     

       44
       44
        
               type = types.package;

     

       45
       45
        
               default = pkgs.zabbix.web;

     

       46
       46
       -
               defaultText = "zabbix.web";

     

       46
       46
       +
               defaultText = literalExpression "zabbix.web";

     

       47
       47
        
               description = "Which Zabbix package to use.";

     

       48
       48
        
             };

     

       49
       49
        
       

     
···

       116
       116
        
       

     

       117
       117
        
             virtualHost = mkOption {

     

       118
       118
        
               type = types.submodule (import ../web-servers/apache-httpd/vhost-options.nix);

     

       119
       119
       -
               example = literalExample ''

     

       119
       119
       +
               example = literalExpression ''

     

       120
       120
        
                 {

     

       121
       121
        
                   hostName = "zabbix.example.org";

     

       122
       122
        
                   adminAddr = "webmaster@example.org";

+13 -6

nixos/modules/services/web-servers/apache-httpd/default.nix

···

       407
       407
        
             package = mkOption {

     

       408
       408
        
               type = types.package;

     

       409
       409
        
               default = pkgs.apacheHttpd;

     

       410
       410
       -
               defaultText = "pkgs.apacheHttpd";

     

       410
       410
       +
               defaultText = literalExpression "pkgs.apacheHttpd";

     

       411
       411
        
               description = ''

     

       412
       412
        
                 Overridable attribute of the Apache HTTP Server package to use.

     

       413
       413
        
               '';

     
···

       416
       416
        
             configFile = mkOption {

     

       417
       417
        
               type = types.path;

     

       418
       418
        
               default = confFile;

     

       419
       419
       -
               defaultText = "confFile";

     

       420
       420
       -
               example = literalExample ''pkgs.writeText "httpd.conf" "# my custom config file ..."'';

     

       419
       419
       +
               defaultText = literalExpression "confFile";

     

       420
       420
       +
               example = literalExpression ''pkgs.writeText "httpd.conf" "# my custom config file ..."'';

     

       421
       421
        
               description = ''

     

       422
       422
        
                 Override the configuration file used by Apache. By default,

     

       423
       423
        
                 NixOS generates one automatically.

     
···

       437
       437
        
             extraModules = mkOption {

     

       438
       438
        
               type = types.listOf types.unspecified;

     

       439
       439
        
               default = [];

     

       440
       440
       -
               example = literalExample ''

     

       440
       440
       +
               example = literalExpression ''

     

       441
       441
        
                 [

     

       442
       442
        
                   "proxy_connect"

     

       443
       443
        
                   { name = "jk"; path = "''${pkgs.tomcat_connectors}/modules/mod_jk.so"; }

     
···

       516
       516
        
                   documentRoot = "${pkg}/htdocs";

     

       517
       517
        
                 };

     

       518
       518
        
               };

     

       519
       519
       -
               example = literalExample ''

     

       519
       519
       +
               defaultText = literalExpression ''

     

       520
       520
       +
                 {

     

       521
       521
       +
                   localhost = {

     

       522
       522
       +
                     documentRoot = "''${package.out}/htdocs";

     

       523
       523
       +
                   };

     

       524
       524
       +
                 }

     

       525
       525
       +
               '';

     

       526
       526
       +
               example = literalExpression ''

     

       520
       527
        
                 {

     

       521
       528
        
                   "foo.example.com" = {

     

       522
       529
        
                     forceSSL = true;

     
···

       550
       557
        
             phpPackage = mkOption {

     

       551
       558
        
               type = types.package;

     

       552
       559
        
               default = pkgs.php;

     

       553
       553
       -
               defaultText = "pkgs.php";

     

       560
       560
       +
               defaultText = literalExpression "pkgs.php";

     

       554
       561
        
               description = ''

     

       555
       562
        
                 Overridable attribute of the PHP package to use.

     

       556
       563
        
               '';

+2 -2

nixos/modules/services/web-servers/apache-httpd/vhost-options.nix

···

       1
       1
        
       { config, lib, name, ... }:

     

       2
       2
        
       let

     

       3
       3
       -
         inherit (lib) literalExample mkOption nameValuePair types;

     

       3
       3
       +
         inherit (lib) literalExpression mkOption nameValuePair types;

     

       4
       4
        
       in

     

       5
       5
        
       {

     

       6
       6
        
         options = {

     
···

       266
       266
        
           locations = mkOption {

     

       267
       267
        
             type = with types; attrsOf (submodule (import ./location-options.nix));

     

       268
       268
        
             default = {};

     

       269
       269
       -
             example = literalExample ''

     

       269
       269
       +
             example = literalExpression ''

     

       270
       270
        
               {

     

       271
       271
        
                 "/" = {

     

       272
       272
        
                   proxyPass = "http://localhost:3000";

+2 -3

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

···

       83
       83
        
               inherit config lib;

     

       84
       84
        
             }));

     

       85
       85
        
             default = { };

     

       86
       86
       -
             example = literalExample ''

     

       86
       86
       +
             example = literalExpression ''

     

       87
       87
        
               {

     

       88
       88
        
                 "hydra.example.com" = {

     

       89
       89
        
                   serverAliases = [ "www.hydra.example.com" ];

     
···

       162
       162
        
       

     

       163
       163
        
           package = mkOption {

     

       164
       164
        
             default = pkgs.caddy;

     

       165
       165
       -
             defaultText = "pkgs.caddy";

     

       166
       166
       -
             example = "pkgs.caddy";

     

       165
       165
       +
             defaultText = literalExpression "pkgs.caddy";

     

       167
       166
        
             type = types.package;

     

       168
       167
        
             description = ''

     

       169
       168
        
               Caddy package to use.

+7 -5

nixos/modules/services/web-servers/lighttpd/cgit.nix

···

       41
       41
        
       

     

       42
       42
        
           configText = mkOption {

     

       43
       43
        
             default = "";

     

       44
       44
       -
             example = ''

     

       45
       45
       -
               source-filter=''${pkgs.cgit}/lib/cgit/filters/syntax-highlighting.py

     

       46
       46
       -
               about-filter=''${pkgs.cgit}/lib/cgit/filters/about-formatting.sh

     

       47
       47
       -
               cache-size=1000

     

       48
       48
       -
               scan-path=/srv/git

     

       44
       44
       +
             example = literalExpression ''

     

       45
       45
       +
               '''

     

       46
       46
       +
                 source-filter=''${pkgs.cgit}/lib/cgit/filters/syntax-highlighting.py

     

       47
       47
       +
                 about-filter=''${pkgs.cgit}/lib/cgit/filters/about-formatting.sh

     

       48
       48
       +
                 cache-size=1000

     

       49
       49
       +
                 scan-path=/srv/git

     

       50
       50
       +
               '''

     

       49
       51
        
             '';

     

       50
       52
        
             type = types.lines;

     

       51
       53
        
             description = ''

+1 -1

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

···

       87
       87
        
       

     

       88
       88
        
           package = mkOption {

     

       89
       89
        
             default = pkgs.minio;

     

       90
       90
       -
             defaultText = "pkgs.minio";

     

       90
       90
       +
             defaultText = literalExpression "pkgs.minio";

     

       91
       91
        
             type = types.package;

     

       92
       92
        
             description = "Minio package to use.";

     

       93
       93
        
           };

+1 -1

nixos/modules/services/web-servers/molly-brown.nix

···

       22
       22
        
       

     

       23
       23
        
           hostName = mkOption {

     

       24
       24
        
             type = types.str;

     

       25
       25
       -
             example = literalExample "config.networking.hostName";

     

       26
       25
        
             default = config.networking.hostName;

     

       26
       26
       +
             defaultText = literalExpression "config.networking.hostName";

     

       27
       27
        
             description = ''

     

       28
       28
        
               The hostname to respond to requests for. Requests for URLs with

     

       29
       29
        
               other hosts will result in a status 53 (PROXY REQUEST REFUSED)

+5 -5

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

···

       425
       425
        
       

     

       426
       426
        
             package = mkOption {

     

       427
       427
        
               default = pkgs.nginxStable;

     

       428
       428
       -
               defaultText = "pkgs.nginxStable";

     

       428
       428
       +
               defaultText = literalExpression "pkgs.nginxStable";

     

       429
       429
        
               type = types.package;

     

       430
       430
        
               apply = p: p.override {

     

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

     
···

       440
       440
        
             additionalModules = mkOption {

     

       441
       441
        
               default = [];

     

       442
       442
        
               type = types.listOf (types.attrsOf types.anything);

     

       443
       443
       -
               example = literalExample "[ pkgs.nginxModules.brotli ]";

     

       443
       443
       +
               example = literalExpression "[ pkgs.nginxModules.brotli ]";

     

       444
       444
        
               description = ''

     

       445
       445
        
                 Additional <link xlink:href="https://www.nginx.com/resources/wiki/modules/">third-party nginx modules</link>

     

       446
       446
        
                 to install. Packaged modules are available in

     
···

       674
       674
        
                   addresses = mkOption {

     

       675
       675
        
                     type = types.listOf types.str;

     

       676
       676
        
                     default = [];

     

       677
       677
       -
                     example = literalExample ''[ "[::1]" "127.0.0.1:5353" ]'';

     

       677
       677
       +
                     example = literalExpression ''[ "[::1]" "127.0.0.1:5353" ]'';

     

       678
       678
        
                     description = "List of resolvers to use";

     

       679
       679
        
                   };

     

       680
       680
        
                   valid = mkOption {

     
···

       738
       738
        
                 Defines a group of servers to use as proxy target.

     

       739
       739
        
               '';

     

       740
       740
        
               default = {};

     

       741
       741
       -
               example = literalExample ''

     

       741
       741
       +
               example = literalExpression ''

     

       742
       742
        
                 "backend_server" = {

     

       743
       743
        
                   servers = { "127.0.0.1:8000" = {}; };

     

       744
       744
        
                   extraConfig = ''''

     
···

       755
       755
        
               default = {

     

       756
       756
        
                 localhost = {};

     

       757
       757
        
               };

     

       758
       758
       -
               example = literalExample ''

     

       758
       758
       +
               example = literalExpression ''

     

       759
       759
        
                 {

     

       760
       760
        
                   "hydra.example.com" = {

     

       761
       761
        
                     forceSSL = true;

+1 -1

nixos/modules/services/web-servers/nginx/location-options.nix

···

       12
       12
        
           basicAuth = mkOption {

     

       13
       13
        
             type = types.attrsOf types.str;

     

       14
       14
        
             default = {};

     

       15
       15
       -
             example = literalExample ''

     

       15
       15
       +
             example = literalExpression ''

     

       16
       16
        
               {

     

       17
       17
        
                 user = "password";

     

       18
       18
        
               };

+3 -3

nixos/modules/services/web-servers/nginx/vhost-options.nix

···

       162
       162
        
           sslTrustedCertificate = mkOption {

     

       163
       163
        
             type = types.nullOr types.path;

     

       164
       164
        
             default = null;

     

       165
       165
       -
             example = "\${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt";

     

       165
       165
       +
             example = literalExpression ''"''${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt"'';

     

       166
       166
        
             description = "Path to root SSL certificate for stapling and client certificates.";

     

       167
       167
        
           };

     

       168
       168
        
       

     
···

       231
       231
        
           basicAuth = mkOption {

     

       232
       232
        
             type = types.attrsOf types.str;

     

       233
       233
        
             default = {};

     

       234
       234
       -
             example = literalExample ''

     

       234
       234
       +
             example = literalExpression ''

     

       235
       235
        
               {

     

       236
       236
        
                 user = "password";

     

       237
       237
        
               };

     
···

       261
       261
        
               inherit lib;

     

       262
       262
        
             }));

     

       263
       263
        
             default = {};

     

       264
       264
       -
             example = literalExample ''

     

       264
       264
       +
             example = literalExpression ''

     

       265
       265
        
               {

     

       266
       266
        
                 "/" = {

     

       267
       267
        
                   proxyPass = "http://localhost:3000";

+5 -5

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

···

       59
       59
        
               phpPackage = mkOption {

     

       60
       60
        
                 type = types.package;

     

       61
       61
        
                 default = cfg.phpPackage;

     

       62
       62
       -
                 defaultText = "config.services.phpfpm.phpPackage";

     

       62
       62
       +
                 defaultText = literalExpression "config.services.phpfpm.phpPackage";

     

       63
       63
        
                 description = ''

     

       64
       64
        
                   The PHP package to use for running this PHP-FPM pool.

     

       65
       65
        
                 '';

     
···

       78
       78
        
                 description = ''

     

       79
       79
        
                   Environment variables used for this PHP-FPM pool.

     

       80
       80
        
                 '';

     

       81
       81
       -
                 example = literalExample ''

     

       81
       81
       +
                 example = literalExpression ''

     

       82
       82
        
                   {

     

       83
       83
        
                     HOSTNAME = "$HOSTNAME";

     

       84
       84
        
                     TMP = "/tmp";

     
···

       107
       107
        
                   for details. Note that settings names must be enclosed in quotes (e.g.

     

       108
       108
        
                   <literal>"pm.max_children"</literal> instead of <literal>pm.max_children</literal>).

     

       109
       109
        
                 '';

     

       110
       110
       -
                 example = literalExample ''

     

       110
       110
       +
                 example = literalExpression ''

     

       111
       111
        
                   {

     

       112
       112
        
                     "pm" = "dynamic";

     

       113
       113
        
                     "pm.max_children" = 75;

     
···

       179
       179
        
             phpPackage = mkOption {

     

       180
       180
        
               type = types.package;

     

       181
       181
        
               default = pkgs.php;

     

       182
       182
       -
               defaultText = "pkgs.php";

     

       182
       182
       +
               defaultText = literalExpression "pkgs.php";

     

       183
       183
        
               description = ''

     

       184
       184
        
                 The PHP package to use for running the PHP-FPM service.

     

       185
       185
        
               '';

     
···

       200
       200
        
             pools = mkOption {

     

       201
       201
        
               type = types.attrsOf (types.submodule poolOpts);

     

       202
       202
        
               default = {};

     

       203
       203
       -
               example = literalExample ''

     

       203
       203
       +
               example = literalExpression ''

     

       204
       204
        
                {

     

       205
       205
        
                  mypool = {

     

       206
       206
        
                    user = "php";

+4 -4

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

···

       24
       24
        
             package = mkOption {

     

       25
       25
        
               type = types.package;

     

       26
       26
        
               default = pkgs.tomcat85;

     

       27
       27
       -
               defaultText = "pkgs.tomcat85";

     

       28
       28
       -
               example = lib.literalExample "pkgs.tomcat9";

     

       27
       27
       +
               defaultText = literalExpression "pkgs.tomcat85";

     

       28
       28
       +
               example = lib.literalExpression "pkgs.tomcat9";

     

       29
       29
        
               description = ''

     

       30
       30
        
                 Which tomcat package to use.

     

       31
       31
        
               '';

     
···

       127
       127
        
             webapps = mkOption {

     

       128
       128
        
               type = types.listOf types.path;

     

       129
       129
        
               default = [ tomcat.webapps ];

     

       130
       130
       -
               defaultText = "[ pkgs.tomcat85.webapps ]";

     

       130
       130
       +
               defaultText = literalExpression "[ pkgs.tomcat85.webapps ]";

     

       131
       131
        
               description = "List containing WAR files or directories with WAR files which are web applications to be deployed on Tomcat";

     

       132
       132
        
             };

     

       133
       133
        
       

     
···

       166
       166
        
             jdk = mkOption {

     

       167
       167
        
               type = types.package;

     

       168
       168
        
               default = pkgs.jdk;

     

       169
       169
       -
               defaultText = "pkgs.jdk";

     

       169
       169
       +
               defaultText = literalExpression "pkgs.jdk";

     

       170
       170
        
               description = "Which JDK to use.";

     

       171
       171
        
             };

     

       172
       172

+3 -3

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

···

       54
       54
        
       

     

       55
       55
        
           staticConfigFile = mkOption {

     

       56
       56
        
             default = null;

     

       57
       57
       -
             example = literalExample "/path/to/static_config.toml";

     

       57
       57
       +
             example = literalExpression "/path/to/static_config.toml";

     

       58
       58
        
             type = types.nullOr types.path;

     

       59
       59
        
             description = ''

     

       60
       60
        
               Path to traefik's static configuration to use.

     
···

       78
       78
        
       

     

       79
       79
        
           dynamicConfigFile = mkOption {

     

       80
       80
        
             default = null;

     

       81
       81
       -
             example = literalExample "/path/to/dynamic_config.toml";

     

       81
       81
       +
             example = literalExpression "/path/to/dynamic_config.toml";

     

       82
       82
        
             type = types.nullOr types.path;

     

       83
       83
        
             description = ''

     

       84
       84
        
               Path to traefik's dynamic configuration to use.

     
···

       123
       123
        
       

     

       124
       124
        
           package = mkOption {

     

       125
       125
        
             default = pkgs.traefik;

     

       126
       126
       -
             defaultText = "pkgs.traefik";

     

       126
       126
       +
             defaultText = literalExpression "pkgs.traefik";

     

       127
       127
        
             type = types.package;

     

       128
       128
        
             description = "Traefik package to use.";

     

       129
       129
        
           };

+22 -18

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

···

       62
       62
        
           ipAllow = mkOption {

     

       63
       63
        
             type = types.nullOr yaml.type;

     

       64
       64
        
             default = builtins.fromJSON (builtins.readFile ./ip_allow.json);

     

       65
       65
       -
             defaultText = "upstream defaults";

     

       66
       66
       -
             example = literalExample {

     

       67
       67
       -
               ip_allow = [{

     

       68
       68
       -
                 apply = "in";

     

       69
       69
       -
                 ip_addrs = "127.0.0.1";

     

       70
       70
       -
                 action = "allow";

     

       71
       71
       -
                 methods = "ALL";

     

       72
       72
       -
               }];

     

       73
       73
       -
             };

     

       65
       65
       +
             defaultText = literalDocBook "upstream defaults";

     

       66
       66
       +
             example = literalExpression ''

     

       67
       67
       +
               {

     

       68
       68
       +
                 ip_allow = [{

     

       69
       69
       +
                   apply = "in";

     

       70
       70
       +
                   ip_addrs = "127.0.0.1";

     

       71
       71
       +
                   action = "allow";

     

       72
       72
       +
                   methods = "ALL";

     

       73
       73
       +
                 }];

     

       74
       74
       +
               }

     

       75
       75
       +
             '';

     

       74
       76
        
             description = ''

     

       75
       77
        
               Control client access to Traffic Server and Traffic Server connections

     

       76
       78
        
               to upstream servers.

     
···

       83
       85
        
           logging = mkOption {

     

       84
       86
        
             type = types.nullOr yaml.type;

     

       85
       87
        
             default = builtins.fromJSON (builtins.readFile ./logging.json);

     

       86
       86
       -
             defaultText = "upstream defaults";

     

       87
       87
       -
             example = literalExample { };

     

       88
       88
       +
             defaultText = literalDocBook "upstream defaults";

     

       89
       89
       +
             example = { };

     

       88
       90
        
             description = ''

     

       89
       91
        
               Configure logs.

     

       90
       92
        
       

     
···

       145
       147
        
               in

     

       146
       148
        
               valueType;

     

       147
       149
        
             default = { };

     

       148
       148
       -
             example = literalExample { proxy.config.proxy_name = "my_server"; };

     

       150
       150
       +
             example = { proxy.config.proxy_name = "my_server"; };

     

       149
       151
        
             description = ''

     

       150
       152
        
               List of configurable variables used by Traffic Server.

     

       151
       153
        
       

     
···

       197
       199
        
           sni = mkOption {

     

       198
       200
        
             type = types.nullOr yaml.type;

     

       199
       201
        
             default = null;

     

       200
       200
       -
             example = literalExample {

     

       201
       201
       -
               sni = [{

     

       202
       202
       -
                 fqdn = "no-http2.example.com";

     

       203
       203
       -
                 https = "off";

     

       204
       204
       -
               }];

     

       205
       205
       -
             };

     

       202
       202
       +
             example = literalExpression ''

     

       203
       203
       +
               {

     

       204
       204
       +
                 sni = [{

     

       205
       205
       +
                   fqdn = "no-http2.example.com";

     

       206
       206
       +
                   https = "off";

     

       207
       207
       +
                 }];

     

       208
       208
       +
               }

     

       209
       209
       +
             '';

     

       206
       210
        
             description = ''

     

       207
       211
        
               Configure aspects of TLS connection handling for both inbound and

     

       208
       212
        
               outbound connections.

+1 -1

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

···

       78
       78
        
             clientOptions = mkOption {

     

       79
       79
        
               type = types.attrsOf types.str;

     

       80
       80
        
               default = {};

     

       81
       81
       -
               example = literalExample ''{

     

       81
       81
       +
               example = literalExpression ''{

     

       82
       82
        
                 fontSize = "16";

     

       83
       83
        
                 fontFamily = "Fira Code";

     

       84
       84

+2 -2

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

···

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

     

       16
       16
        
               default = pkgs.unit;

     

       17
       17
       -
               defaultText = "pkgs.unit";

     

       17
       17
       +
               defaultText = literalExpression "pkgs.unit";

     

       18
       18
        
               description = "Unit package to use.";

     

       19
       19
        
             };

     

       20
       20
        
             user = mkOption {

     
···

       45
       45
        
                   "applications": {}

     

       46
       46
        
                 }

     

       47
       47
        
               '';

     

       48
       48
       -
               example = literalExample ''

     

       48
       48
       +
               example = ''

     

       49
       49
        
                 {

     

       50
       50
        
                   "listeners": {

     

       51
       51
        
                     "*:8300": {

+2 -2

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

···

       114
       114
        
               default = {

     

       115
       115
        
                 type = "normal";

     

       116
       116
        
               };

     

       117
       117
       -
               example = literalExample ''

     

       117
       117
       +
               example = literalExpression ''

     

       118
       118
        
                 {

     

       119
       119
        
                   type = "emperor";

     

       120
       120
        
                   vassals = {

     
···

       163
       163
        
               type = types.listOf types.str;

     

       164
       164
        
               apply = caps: caps ++ optionals isEmperor imperialPowers;

     

       165
       165
        
               default = [ ];

     

       166
       166
       -
               example = literalExample ''

     

       166
       166
       +
               example = literalExpression ''

     

       167
       167
        
                 [

     

       168
       168
        
                   "CAP_NET_BIND_SERVICE" # bind on ports <1024

     

       169
       169
        
                   "CAP_NET_RAW"          # open raw sockets

+2 -2

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

···

       16
       16
        
             package = mkOption {

     

       17
       17
        
               type = types.package;

     

       18
       18
        
               default = pkgs.varnish;

     

       19
       19
       -
               defaultText = "pkgs.varnish";

     

       19
       19
       +
               defaultText = literalExpression "pkgs.varnish";

     

       20
       20
        
               description = ''

     

       21
       21
        
                 The package to use

     

       22
       22
        
               '';

     
···

       48
       48
        
             extraModules = mkOption {

     

       49
       49
        
               type = types.listOf types.package;

     

       50
       50
        
               default = [];

     

       51
       51
       -
               example = literalExample "[ pkgs.varnishPackages.geoip ]";

     

       51
       51
       +
               example = literalExpression "[ pkgs.varnishPackages.geoip ]";

     

       52
       52
        
               description = "

     

       53
       53
        
                 Varnish modules (except 'std').

     

       54
       54
        
               ";

+1 -1

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

···

       75
       75
        
           services.zope2.instances = mkOption {

     

       76
       76
        
             default = {};

     

       77
       77
        
             type = with types; attrsOf (submodule zope2Opts);

     

       78
       78
       -
             example = literalExample ''

     

       78
       78
       +
             example = literalExpression ''

     

       79
       79
        
               {

     

       80
       80
        
                 plone01 = {

     

       81
       81
        
                   http_address = "127.0.0.1:8080";

+1 -1

nixos/modules/services/x11/desktop-managers/cde.nix

···

       14
       14
        
             default = with pkgs.xorg; [

     

       15
       15
        
               xclock bitmap xlsfonts xfd xrefresh xload xwininfo xdpyinfo xwd xwud

     

       16
       16
        
             ];

     

       17
       17
       -
             example = literalExample ''

     

       17
       17
       +
             defaultText = literalExpression ''

     

       18
       18
        
               with pkgs.xorg; [

     

       19
       19
        
                 xclock bitmap xlsfonts xfd xrefresh xload xwininfo xdpyinfo xwd xwud

     

       20
       20
        
               ]

+2 -2

nixos/modules/services/x11/desktop-managers/cinnamon.nix

···

       26
       26
        
             sessionPath = mkOption {

     

       27
       27
        
               default = [];

     

       28
       28
        
               type = types.listOf types.package;

     

       29
       29
       -
               example = literalExample "[ pkgs.gnome.gpaste ]";

     

       29
       29
       +
               example = literalExpression "[ pkgs.gnome.gpaste ]";

     

       30
       30
        
               description = ''

     

       31
       31
        
                 Additional list of packages to be added to the session search path.

     

       32
       32
        
                 Useful for GSettings-conditional autostart.

     
···

       50
       50
        
       

     

       51
       51
        
           environment.cinnamon.excludePackages = mkOption {

     

       52
       52
        
             default = [];

     

       53
       53
       -
             example = literalExample "[ pkgs.cinnamon.blueberry ]";

     

       53
       53
       +
             example = literalExpression "[ pkgs.cinnamon.blueberry ]";

     

       54
       54
        
             type = types.listOf types.package;

     

       55
       55
        
             description = "Which packages cinnamon should exclude from the default environment";

     

       56
       56
        
           };

+10 -8

nixos/modules/services/x11/desktop-managers/gnome.nix

···

       186
       186
        
             sessionPath = mkOption {

     

       187
       187
        
               default = [];

     

       188
       188
        
               type = types.listOf types.package;

     

       189
       189
       -
               example = literalExample "[ pkgs.gnome.gpaste ]";

     

       189
       189
       +
               example = literalExpression "[ pkgs.gnome.gpaste ]";

     

       190
       190
        
               description = ''

     

       191
       191
        
                 Additional list of packages to be added to the session search path.

     

       192
       192
        
                 Useful for GNOME Shell extensions or GSettings-conditional autostart.

     
···

       200
       200
        
               internal = true; # this is messy

     

       201
       201
        
               default = defaultFavoriteAppsOverride;

     

       202
       202
        
               type = types.lines;

     

       203
       203
       -
               example = literalExample ''

     

       204
       204
       -
                 [org.gnome.shell]

     

       205
       205
       -
                 favorite-apps=[ 'firefox.desktop', 'org.gnome.Calendar.desktop' ]

     

       203
       203
       +
               example = literalExpression ''

     

       204
       204
       +
                 '''

     

       205
       205
       +
                   [org.gnome.shell]

     

       206
       206
       +
                   favorite-apps=[ 'firefox.desktop', 'org.gnome.Calendar.desktop' ]

     

       207
       207
       +
                 '''

     

       206
       208
        
               '';

     

       207
       209
        
               description = "List of desktop files to put as favorite apps into gnome-shell. These need to be installed somehow globally.";

     

       208
       210
        
             };

     
···

       242
       244
        
                     wmCommand = mkOption {

     

       243
       245
        
                       type = types.str;

     

       244
       246
        
                       description = "The executable of the window manager to use.";

     

       245
       245
       -
                       example = "\${pkgs.haskellPackages.xmonad}/bin/xmonad";

     

       247
       247
       +
                       example = literalExpression ''"''${pkgs.haskellPackages.xmonad}/bin/xmonad"'';

     

       246
       248
        
                     };

     

       247
       249
        
       

     

       248
       250
        
                     enableGnomePanel = mkOption {

     

       249
       251
        
                       type = types.bool;

     

       250
       252
        
                       default = true;

     

       251
       251
       -
                       example = "false";

     

       253
       253
       +
                       example = false;

     

       252
       254
        
                       description = "Whether to enable the GNOME panel in this session.";

     

       253
       255
        
                     };

     

       254
       256
        
                   };

     
···

       259
       261
        
       

     

       260
       262
        
               panelModulePackages = mkOption {

     

       261
       263
        
                 default = [ pkgs.gnome.gnome-applets ];

     

       264
       264
       +
                 defaultText = literalExpression "[ pkgs.gnome.gnome-applets ]";

     

       262
       265
        
                 type = types.listOf types.path;

     

       263
       266
        
                 description = ''

     

       264
       267
        
                   Packages containing modules that should be made available to <literal>gnome-panel</literal> (usually for applets).

     

       265
       268
        
       

     

       266
       269
        
                   If you're packaging something to use here, please install the modules in <literal>$out/lib/gnome-panel/modules</literal>.

     

       267
       270
        
                 '';

     

       268
       268
       -
                 example = literalExample "[ pkgs.gnome.gnome-applets ]";

     

       269
       271
        
               };

     

       270
       272
        
             };

     

       271
       273
        
           };

     

       272
       274
        
       

     

       273
       275
        
           environment.gnome.excludePackages = mkOption {

     

       274
       276
        
             default = [];

     

       275
       275
       -
             example = literalExample "[ pkgs.gnome.totem ]";

     

       277
       277
       +
             example = literalExpression "[ pkgs.gnome.totem ]";

     

       276
       278
        
             type = types.listOf types.package;

     

       277
       279
        
             description = "Which packages gnome should exclude from the default environment";

     

       278
       280
        
           };

+2 -2

nixos/modules/services/x11/desktop-managers/kodi.nix

···

       18
       18
        
             package = mkOption {

     

       19
       19
        
               type = types.package;

     

       20
       20
        
               default = pkgs.kodi;

     

       21
       21
       -
               defaultText = "pkgs.kodi";

     

       22
       22
       -
               example = "pkgs.kodi.withPackages (p: with p; [ jellyfin pvr-iptvsimple vfs-sftp ])";

     

       21
       21
       +
               defaultText = literalExpression "pkgs.kodi";

     

       22
       22
       +
               example = literalExpression "pkgs.kodi.withPackages (p: with p; [ jellyfin pvr-iptvsimple vfs-sftp ])";

     

       23
       23
        
               description = ''

     

       24
       24
        
                 Package that should be used for Kodi.

     

       25
       25
        
               '';

+1 -1

nixos/modules/services/x11/desktop-managers/lxqt.nix

···

       19
       19
        
       

     

       20
       20
        
           environment.lxqt.excludePackages = mkOption {

     

       21
       21
        
             default = [];

     

       22
       22
       -
             example = literalExample "[ pkgs.lxqt.qterminal ]";

     

       22
       22
       +
             example = literalExpression "[ pkgs.lxqt.qterminal ]";

     

       23
       23
        
             type = types.listOf types.package;

     

       24
       24
        
             description = "Which LXQt packages to exclude from the default environment";

     

       25
       25
        
           };

+1 -1

nixos/modules/services/x11/desktop-managers/mate.nix

···

       35
       35
        
       

     

       36
       36
        
           environment.mate.excludePackages = mkOption {

     

       37
       37
        
             default = [];

     

       38
       38
       -
             example = literalExample "[ pkgs.mate.mate-terminal pkgs.mate.pluma ]";

     

       38
       38
       +
             example = literalExpression "[ pkgs.mate.mate-terminal pkgs.mate.pluma ]";

     

       39
       39
        
             type = types.listOf types.package;

     

       40
       40
        
             description = "Which MATE packages to exclude from the default environment";

     

       41
       41
        
           };

+2 -2

nixos/modules/services/x11/desktop-managers/pantheon.nix

···

       43
       43
        
             sessionPath = mkOption {

     

       44
       44
        
               default = [];

     

       45
       45
        
               type = types.listOf types.package;

     

       46
       46
       -
               example = literalExample "[ pkgs.gnome.gpaste ]";

     

       46
       46
       +
               example = literalExpression "[ pkgs.gnome.gpaste ]";

     

       47
       47
        
               description = ''

     

       48
       48
        
                 Additional list of packages to be added to the session search path.

     

       49
       49
        
                 Useful for GSettings-conditional autostart.

     
···

       86
       86
        
       

     

       87
       87
        
           environment.pantheon.excludePackages = mkOption {

     

       88
       88
        
             default = [];

     

       89
       89
       -
             example = literalExample "[ pkgs.pantheon.elementary-camera ]";

     

       89
       89
       +
             example = literalExpression "[ pkgs.pantheon.elementary-camera ]";

     

       90
       90
        
             type = types.listOf types.package;

     

       91
       91
        
             description = "Which packages pantheon should exclude from the default environment";

     

       92
       92
        
           };

+2 -1

nixos/modules/services/x11/desktop-managers/surf-display.nix

···

       50
       50
        
             defaultWwwUri = mkOption {

     

       51
       51
        
               type = types.str;

     

       52
       52
        
               default = "${pkgs.surf-display}/share/surf-display/empty-page.html";

     

       53
       53
       +
               defaultText = literalExpression ''"''${pkgs.surf-display}/share/surf-display/empty-page.html"'';

     

       53
       54
        
               example = "https://www.example.com/";

     

       54
       55
        
               description = "Default URI to display.";

     

       55
       56
        
             };

     
···

       57
       58
        
             inactivityInterval = mkOption {

     

       58
       59
        
               type = types.int;

     

       59
       60
        
               default = 300;

     

       60
       60
       -
               example = "0";

     

       61
       61
       +
               example = 0;

     

       61
       62
        
               description = ''

     

       62
       63
        
                 Setting for internal inactivity timer to restart surf-display if the

     

       63
       64
        
                 user goes inactive/idle to get a fresh session for the next user of

+1 -1

nixos/modules/services/x11/desktop-managers/xfce.nix

···

       49
       49
        
             thunarPlugins = mkOption {

     

       50
       50
        
               default = [];

     

       51
       51
        
               type = types.listOf types.package;

     

       52
       52
       -
               example = literalExample "[ pkgs.xfce.thunar-archive-plugin ]";

     

       52
       52
       +
               example = literalExpression "[ pkgs.xfce.thunar-archive-plugin ]";

     

       53
       53
        
               description = ''

     

       54
       54
        
                 A list of plugin that should be installed with Thunar.

     

       55
       55
        
               '';

+2 -2

nixos/modules/services/x11/desktop-managers/xterm.nix

···

       14
       14
        
       

     

       15
       15
        
           services.xserver.desktopManager.xterm.enable = mkOption {

     

       16
       16
        
             type = types.bool;

     

       17
       17
       -
             default = (versionOlder config.system.stateVersion "19.09") && xSessionEnabled;

     

       18
       18
       -
             defaultText = if versionOlder config.system.stateVersion "19.09" then "config.services.xserver.enable" else "false";

     

       17
       17
       +
             default = versionOlder config.system.stateVersion "19.09" && xSessionEnabled;

     

       18
       18
       +
             defaultText = literalExpression ''versionOlder config.system.stateVersion "19.09" && config.services.xserver.enable;'';

     

       19
       19
        
             description = "Enable a xterm terminal as a desktop manager.";

     

       20
       20
        
           };

     

       21
       21

+2 -4

nixos/modules/services/x11/display-managers/default.nix

···

       217
       217
        
       

     

       218
       218
        
             session = mkOption {

     

       219
       219
        
               default = [];

     

       220
       220
       -
               example = literalExample

     

       220
       220
       +
               example = literalExpression

     

       221
       221
        
                 ''

     

       222
       222
        
                   [ { manage = "desktop";

     

       223
       223
        
                       name = "xterm";

     
···

       305
       305
        
       

     

       306
       306
        
               execCmd = mkOption {

     

       307
       307
        
                 type = types.str;

     

       308
       308
       -
                 example = literalExample ''

     

       309
       309
       -
                   "''${pkgs.lightdm}/bin/lightdm"

     

       310
       310
       -
                 '';

     

       308
       308
       +
                 example = literalExpression ''"''${pkgs.lightdm}/bin/lightdm"'';

     

       311
       309
        
                 description = "Command to start the display manager.";

     

       312
       310
        
               };

     

       313
       311

+3 -3

nixos/modules/services/x11/display-managers/lightdm-greeters/enso-os.nix

···

       35
       35
        
               package = mkOption {

     

       36
       36
        
                 type = types.package;

     

       37
       37
        
                 default = pkgs.gnome.gnome-themes-extra;

     

       38
       38
       -
                 defaultText = "pkgs.gnome.gnome-themes-extra";

     

       38
       38
       +
                 defaultText = literalExpression "pkgs.gnome.gnome-themes-extra";

     

       39
       39
        
                 description = ''

     

       40
       40
        
                   The package path that contains the theme given in the name option.

     

       41
       41
        
                 '';

     
···

       54
       54
        
               package = mkOption {

     

       55
       55
        
                 type = types.package;

     

       56
       56
        
                 default = pkgs.papirus-icon-theme;

     

       57
       57
       -
                 defaultText = "pkgs.papirus-icon-theme";

     

       57
       57
       +
                 defaultText = literalExpression "pkgs.papirus-icon-theme";

     

       58
       58
        
                 description = ''

     

       59
       59
        
                   The package path that contains the icon theme given in the name option.

     

       60
       60
        
                 '';

     
···

       73
       73
        
               package = mkOption {

     

       74
       74
        
                 type = types.package;

     

       75
       75
        
                 default = pkgs.capitaine-cursors;

     

       76
       76
       -
                 defaultText = "pkgs.capitaine-cursors";

     

       76
       76
       +
                 defaultText = literalExpression "pkgs.capitaine-cursors";

     

       77
       77
        
                 description = ''

     

       78
       78
        
                   The package path that contains the cursor theme given in the name option.

     

       79
       79
        
                 '';

+3 -3

nixos/modules/services/x11/display-managers/lightdm-greeters/gtk.nix

···

       48
       48
        
               package = mkOption {

     

       49
       49
        
                 type = types.package;

     

       50
       50
        
                 default = pkgs.gnome.gnome-themes-extra;

     

       51
       51
       -
                 defaultText = "pkgs.gnome.gnome-themes-extra";

     

       51
       51
       +
                 defaultText = literalExpression "pkgs.gnome.gnome-themes-extra";

     

       52
       52
        
                 description = ''

     

       53
       53
        
                   The package path that contains the theme given in the name option.

     

       54
       54
        
                 '';

     
···

       69
       69
        
               package = mkOption {

     

       70
       70
        
                 type = types.package;

     

       71
       71
        
                 default = pkgs.gnome.adwaita-icon-theme;

     

       72
       72
       -
                 defaultText = "pkgs.gnome.adwaita-icon-theme";

     

       72
       72
       +
                 defaultText = literalExpression "pkgs.gnome.adwaita-icon-theme";

     

       73
       73
        
                 description = ''

     

       74
       74
        
                   The package path that contains the icon theme given in the name option.

     

       75
       75
        
                 '';

     
···

       90
       90
        
               package = mkOption {

     

       91
       91
        
                 type = types.package;

     

       92
       92
        
                 default = pkgs.gnome.adwaita-icon-theme;

     

       93
       93
       -
                 defaultText = "pkgs.gnome.adwaita-icon-theme";

     

       93
       93
       +
                 defaultText = literalExpression "pkgs.gnome.adwaita-icon-theme";

     

       94
       94
        
                 description = ''

     

       95
       95
        
                   The package path that contains the cursor theme given in the name option.

     

       96
       96
        
                 '';

+1 -1

nixos/modules/services/x11/display-managers/lightdm.nix

···

       148
       148
        
             background = mkOption {

     

       149
       149
        
               type = types.path;

     

       150
       150
        
               # Manual cannot depend on packages, we are actually setting the default in config below.

     

       151
       151
       -
               defaultText = "pkgs.nixos-artwork.wallpapers.simple-dark-gray-bottom.gnomeFilePath";

     

       151
       151
       +
               defaultText = literalExpression "pkgs.nixos-artwork.wallpapers.simple-dark-gray-bottom.gnomeFilePath";

     

       152
       152
        
               description = ''

     

       153
       153
        
                 The background image or color to use.

     

       154
       154
        
               '';

+6 -8

nixos/modules/services/x11/display-managers/sddm.nix

···

       113
       113
        
             settings = mkOption {

     

       114
       114
        
               type = iniFmt.type;

     

       115
       115
        
               default = { };

     

       116
       116
       -
               example = ''

     

       117
       117
       -
                 {

     

       118
       118
       -
                   Autologin = {

     

       119
       119
       -
                     User = "john";

     

       120
       120
       -
                     Session = "plasma.desktop";

     

       121
       121
       -
                   };

     

       122
       122
       -
                 }

     

       123
       123
       -
               '';

     

       116
       116
       +
               example = {

     

       117
       117
       +
                 Autologin = {

     

       118
       118
       +
                   User = "john";

     

       119
       119
       +
                   Session = "plasma.desktop";

     

       120
       120
       +
                 };

     

       121
       121
       +
               };

     

       124
       122
        
               description = ''

     

       125
       123
        
                 Extra settings merged in and overwritting defaults in sddm.conf.

     

       126
       124
        
               '';

+1 -1

nixos/modules/services/x11/extra-layouts.nix

···

       93
       93
        
           extraLayouts = mkOption {

     

       94
       94
        
             type = types.attrsOf (types.submodule layoutOpts);

     

       95
       95
        
             default = {};

     

       96
       96
       -
             example = literalExample

     

       96
       96
       +
             example = literalExpression

     

       97
       97
        
             ''

     

       98
       98
        
               {

     

       99
       99
        
                 mine = {

+11 -9

nixos/modules/services/x11/imwheel.nix

···

       21
       21
        
               rules = mkOption {

     

       22
       22
        
                 type = types.attrsOf types.str;

     

       23
       23
        
                 default = {};

     

       24
       24
       -
                 example = literalExample ''

     

       25
       25
       -
                   ".*" = '''

     

       26
       26
       -
                     None,      Up,   Button4, 8

     

       27
       27
       -
                     None,      Down, Button5, 8

     

       28
       28
       -
                     Shift_L,   Up,   Shift_L|Button4, 4

     

       29
       29
       -
                     Shift_L,   Down, Shift_L|Button5, 4

     

       30
       30
       -
                     Control_L, Up,   Control_L|Button4

     

       31
       31
       -
                     Control_L, Down, Control_L|Button5

     

       32
       32
       -
                   ''';

     

       24
       24
       +
                 example = literalExpression ''

     

       25
       25
       +
                   {

     

       26
       26
       +
                     ".*" = '''

     

       27
       27
       +
                       None,      Up,   Button4, 8

     

       28
       28
       +
                       None,      Down, Button5, 8

     

       29
       29
       +
                       Shift_L,   Up,   Shift_L|Button4, 4

     

       30
       30
       +
                       Shift_L,   Down, Shift_L|Button5, 4

     

       31
       31
       +
                       Control_L, Up,   Control_L|Button4

     

       32
       32
       +
                       Control_L, Down, Control_L|Button5

     

       33
       33
       +
                     ''';

     

       34
       34
       +
                   }

     

       33
       35
        
                 '';

     

       34
       36
        
                 description = ''

     

       35
       37
        
                   Window class translation rules.

+1 -1

nixos/modules/services/x11/picom.nix

···

       254
       254
        
           in mkOption {

     

       255
       255
        
             type = topLevel;

     

       256
       256
        
             default = { };

     

       257
       257
       -
             example = literalExample ''

     

       257
       257
       +
             example = literalExpression ''

     

       258
       258
        
               blur =

     

       259
       259
        
                 { method = "gaussian";

     

       260
       260
        
                   size = 10;

+1 -1

nixos/modules/services/x11/redshift.nix

···

       76
       76
        
           package = mkOption {

     

       77
       77
        
             type = types.package;

     

       78
       78
        
             default = pkgs.redshift;

     

       79
       79
       -
             defaultText = "pkgs.redshift";

     

       79
       79
       +
             defaultText = literalExpression "pkgs.redshift";

     

       80
       80
        
             description = ''

     

       81
       81
        
               redshift derivation to use.

     

       82
       82
        
             '';

+1 -1

nixos/modules/services/x11/touchegg.nix

···

       16
       16
        
           package = mkOption {

     

       17
       17
        
             type = types.package;

     

       18
       18
        
             default = pkgs.touchegg;

     

       19
       19
       -
             defaultText = "pkgs.touchegg";

     

       19
       19
       +
             defaultText = literalExpression "pkgs.touchegg";

     

       20
       20
        
             description = "touchegg derivation to use.";

     

       21
       21
        
           };

     

       22
       22
        
         };

+1 -1

nixos/modules/services/x11/unclutter-xfixes.nix

···

       17
       17
        
             description = "unclutter-xfixes derivation to use.";

     

       18
       18
        
             type = types.package;

     

       19
       19
        
             default = pkgs.unclutter-xfixes;

     

       20
       20
       -
             defaultText = "pkgs.unclutter-xfixes";

     

       20
       20
       +
             defaultText = literalExpression "pkgs.unclutter-xfixes";

     

       21
       21
        
           };

     

       22
       22
        
       

     

       23
       23
        
           timeout = mkOption {

+1 -1

nixos/modules/services/x11/unclutter.nix

···

       16
       16
        
           package = mkOption {

     

       17
       17
        
             type = types.package;

     

       18
       18
        
             default = pkgs.unclutter;

     

       19
       19
       -
             defaultText = "pkgs.unclutter";

     

       19
       19
       +
             defaultText = literalExpression "pkgs.unclutter";

     

       20
       20
        
             description = "unclutter derivation to use.";

     

       21
       21
        
           };

     

       22
       22

+1 -1

nixos/modules/services/x11/urxvtd.nix

···

       19
       19
        
       

     

       20
       20
        
           package = mkOption {

     

       21
       21
        
             default = pkgs.rxvt-unicode;

     

       22
       22
       -
             defaultText = "pkgs.rxvt-unicode";

     

       22
       22
       +
             defaultText = literalExpression "pkgs.rxvt-unicode";

     

       23
       23
        
             description = ''

     

       24
       24
        
               Package to install. Usually pkgs.rxvt-unicode.

     

       25
       25
        
             '';

+1 -1

nixos/modules/services/x11/window-managers/awesome.nix

···

       27
       27
        
               default = [];

     

       28
       28
        
               type = types.listOf types.package;

     

       29
       29
        
               description = "List of lua packages available for being used in the Awesome configuration.";

     

       30
       30
       -
               example = literalExample "[ pkgs.luaPackages.vicious ]";

     

       30
       30
       +
               example = literalExpression "[ pkgs.luaPackages.vicious ]";

     

       31
       31
        
             };

     

       32
       32
        
       

     

       33
       33
        
             package = mkOption {

+6 -6

nixos/modules/services/x11/window-managers/bspwm.nix

···

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type        = types.package;

     

       16
       16
        
               default     = pkgs.bspwm;

     

       17
       17
       -
               defaultText = "pkgs.bspwm";

     

       18
       18
       -
               example     = "pkgs.bspwm-unstable";

     

       17
       17
       +
               defaultText = literalExpression "pkgs.bspwm";

     

       18
       18
       +
               example     = literalExpression "pkgs.bspwm-unstable";

     

       19
       19
        
               description = ''

     

       20
       20
        
                 bspwm package to use.

     

       21
       21
        
               '';

     

       22
       22
        
             };

     

       23
       23
        
             configFile = mkOption {

     

       24
       24
        
               type        = with types; nullOr path;

     

       25
       25
       -
               example     = "${pkgs.bspwm}/share/doc/bspwm/examples/bspwmrc";

     

       25
       25
       +
               example     = literalExpression ''"''${pkgs.bspwm}/share/doc/bspwm/examples/bspwmrc"'';

     

       26
       26
        
               default     = null;

     

       27
       27
        
               description = ''

     

       28
       28
        
                 Path to the bspwm configuration file.

     
···

       34
       34
        
               package = mkOption {

     

       35
       35
        
                 type        = types.package;

     

       36
       36
        
                 default     = pkgs.sxhkd;

     

       37
       37
       -
                 defaultText = "pkgs.sxhkd";

     

       38
       38
       -
                 example     = "pkgs.sxhkd-unstable";

     

       37
       37
       +
                 defaultText = literalExpression "pkgs.sxhkd";

     

       38
       38
       +
                 example     = literalExpression "pkgs.sxhkd-unstable";

     

       39
       39
        
                 description = ''

     

       40
       40
        
                   sxhkd package to use.

     

       41
       41
        
                 '';

     

       42
       42
        
               };

     

       43
       43
        
               configFile = mkOption {

     

       44
       44
        
                 type        = with types; nullOr path;

     

       45
       45
       -
                 example     = "${pkgs.bspwm}/share/doc/bspwm/examples/sxhkdrc";

     

       45
       45
       +
                 example     = literalExpression ''"''${pkgs.bspwm}/share/doc/bspwm/examples/sxhkdrc"'';

     

       46
       46
        
                 default     = null;

     

       47
       47
        
                 description = ''

     

       48
       48
        
                   Path to the sxhkd configuration file.

+1 -1

nixos/modules/services/x11/window-managers/clfswm.nix

···

       13
       13
        
             package = mkOption {

     

       14
       14
        
               type        = types.package;

     

       15
       15
        
               default     = pkgs.lispPackages.clfswm;

     

       16
       16
       -
               defaultText = "pkgs.lispPackages.clfswm";

     

       16
       16
       +
               defaultText = literalExpression "pkgs.lispPackages.clfswm";

     

       17
       17
        
               description = ''

     

       18
       18
        
                 clfswm package to use.

     

       19
       19
        
               '';

+4 -3

nixos/modules/services/x11/window-managers/exwm.nix

···

       22
       22
        
             loadScript = mkOption {

     

       23
       23
        
               default = "(require 'exwm)";

     

       24
       24
        
               type = types.lines;

     

       25
       25
       -
               example = literalExample ''

     

       25
       25
       +
               example = ''

     

       26
       26
        
                 (require 'exwm)

     

       27
       27
        
                 (exwm-enable)

     

       28
       28
        
               '';

     
···

       39
       39
        
             };

     

       40
       40
        
             extraPackages = mkOption {

     

       41
       41
        
               type = types.functionTo (types.listOf types.package);

     

       42
       42
       -
               default = self: [];

     

       43
       43
       -
               example = literalExample ''

     

       42
       42
       +
               default = epkgs: [];

     

       43
       43
       +
               defaultText = literalExpression "epkgs: []";

     

       44
       44
       +
               example = literalExpression ''

     

       44
       45
        
                 epkgs: [

     

       45
       46
        
                   epkgs.emms

     

       46
       47
        
                   epkgs.magit

+1 -1

nixos/modules/services/x11/window-managers/herbstluftwm.nix

···

       14
       14
        
             package = mkOption {

     

       15
       15
        
               type = types.package;

     

       16
       16
        
               default = pkgs.herbstluftwm;

     

       17
       17
       -
               defaultText = "pkgs.herbstluftwm";

     

       17
       17
       +
               defaultText = literalExpression "pkgs.herbstluftwm";

     

       18
       18
        
               description = ''

     

       19
       19
        
                 Herbstluftwm package to use.

     

       20
       20
        
               '';

+3 -3

nixos/modules/services/x11/window-managers/i3.nix

···

       30
       30
        
           package = mkOption {

     

       31
       31
        
             type        = types.package;

     

       32
       32
        
             default     = pkgs.i3;

     

       33
       33
       -
             defaultText = "pkgs.i3";

     

       34
       34
       -
             example     = "pkgs.i3-gaps";

     

       33
       33
       +
             defaultText = literalExpression "pkgs.i3";

     

       34
       34
       +
             example     = literalExpression "pkgs.i3-gaps";

     

       35
       35
        
             description = ''

     

       36
       36
        
               i3 package to use.

     

       37
       37
        
             '';

     
···

       40
       40
        
           extraPackages = mkOption {

     

       41
       41
        
             type = with types; listOf package;

     

       42
       42
        
             default = with pkgs; [ dmenu i3status i3lock ];

     

       43
       43
       -
             example = literalExample ''

     

       43
       43
       +
             defaultText = literalExpression ''

     

       44
       44
        
               with pkgs; [

     

       45
       45
        
                 dmenu

     

       46
       46
        
                 i3status

+1 -1

nixos/modules/services/x11/window-managers/wmderland.nix

···

       28
       28
        
               feh

     

       29
       29
        
               rxvt-unicode

     

       30
       30
        
             ];

     

       31
       31
       -
             example = literalExample ''

     

       31
       31
       +
             defaultText = literalExpression ''

     

       32
       32
        
               with pkgs; [

     

       33
       33
        
                 rofi

     

       34
       34
        
                 dunst

+5 -5

nixos/modules/services/x11/window-managers/xmonad.nix

···

       2
       2
        
       

     

       3
       3
        
       with lib;

     

       4
       4
        
       let

     

       5
       5
       -
         inherit (lib) mkOption mkIf optionals literalExample;

     

       5
       5
       +
         inherit (lib) mkOption mkIf optionals literalExpression;

     

       6
       6
        
         cfg = config.services.xserver.windowManager.xmonad;

     

       7
       7
        
       

     

       8
       8
        
         ghcWithPackages = cfg.haskellPackages.ghcWithPackages;

     
···

       42
       42
        
             enable = mkEnableOption "xmonad";

     

       43
       43
        
             haskellPackages = mkOption {

     

       44
       44
        
               default = pkgs.haskellPackages;

     

       45
       45
       -
               defaultText = "pkgs.haskellPackages";

     

       46
       46
       -
               example = literalExample "pkgs.haskell.packages.ghc784";

     

       45
       45
       +
               defaultText = literalExpression "pkgs.haskellPackages";

     

       46
       46
       +
               example = literalExpression "pkgs.haskell.packages.ghc784";

     

       47
       47
        
               description = ''

     

       48
       48
        
                 haskellPackages used to build Xmonad and other packages.

     

       49
       49
        
                 This can be used to change the GHC version used to build

     
···

       55
       55
        
             extraPackages = mkOption {

     

       56
       56
        
               type = types.functionTo (types.listOf types.package);

     

       57
       57
        
               default = self: [];

     

       58
       58
       -
               defaultText = "self: []";

     

       59
       59
       -
               example = literalExample ''

     

       58
       58
       +
               defaultText = literalExpression "self: []";

     

       59
       59
       +
               example = literalExpression ''

     

       60
       60
        
                 haskellPackages: [

     

       61
       61
        
                   haskellPackages.xmonad-contrib

     

       62
       62
        
                   haskellPackages.monad-logger

+4 -3

nixos/modules/services/x11/xautolock.nix

···

       27
       27
        
       

     

       28
       28
        
               locker = mkOption {

     

       29
       29
        
                 default = "${pkgs.xlockmore}/bin/xlock"; # default according to `man xautolock`

     

       30
       30
       -
                 example = "${pkgs.i3lock}/bin/i3lock -i /path/to/img";

     

       30
       30
       +
                 defaultText = literalExpression ''"''${pkgs.xlockmore}/bin/xlock"'';

     

       31
       31
       +
                 example = literalExpression ''"''${pkgs.i3lock}/bin/i3lock -i /path/to/img"'';

     

       31
       32
        
                 type = types.str;

     

       32
       33
        
       

     

       33
       34
        
                 description = ''

     
···

       37
       38
        
       

     

       38
       39
        
               nowlocker = mkOption {

     

       39
       40
        
                 default = null;

     

       40
       40
       -
                 example = "${pkgs.i3lock}/bin/i3lock -i /path/to/img";

     

       41
       41
       +
                 example = literalExpression ''"''${pkgs.i3lock}/bin/i3lock -i /path/to/img"'';

     

       41
       42
        
                 type = types.nullOr types.str;

     

       42
       43
        
       

     

       43
       44
        
                 description = ''

     
···

       56
       57
        
       

     

       57
       58
        
               notifier = mkOption {

     

       58
       59
        
                 default = null;

     

       59
       59
       -
                 example = "${pkgs.libnotify}/bin/notify-send \"Locking in 10 seconds\"";

     

       60
       60
       +
                 example = literalExpression ''"''${pkgs.libnotify}/bin/notify-send 'Locking in 10 seconds'"'';

     

       60
       61
        
                 type = types.nullOr types.str;

     

       61
       62
        
       

     

       62
       63
        
                 description = ''

+3 -2

nixos/modules/services/x11/xserver.nix

···

       217
       217
        
             inputClassSections = mkOption {

     

       218
       218
        
               type = types.listOf types.lines;

     

       219
       219
        
               default = [];

     

       220
       220
       -
               example = literalExample ''

     

       220
       220
       +
               example = literalExpression ''

     

       221
       221
        
                 [ '''

     

       222
       222
        
                     Identifier      "Trackpoint Wheel Emulation"

     

       223
       223
        
                     MatchProduct    "ThinkPad USB Keyboard with TrackPoint"

     
···

       233
       233
        
             modules = mkOption {

     

       234
       234
        
               type = types.listOf types.path;

     

       235
       235
        
               default = [];

     

       236
       236
       -
               example = literalExample "[ pkgs.xf86_input_wacom ]";

     

       236
       236
       +
               example = literalExpression "[ pkgs.xf86_input_wacom ]";

     

       237
       237
        
               description = "Packages to be added to the module search path of the X server.";

     

       238
       238
        
             };

     

       239
       239
        
       

     
···

       351
       351
        
             xkbDir = mkOption {

     

       352
       352
        
               type = types.path;

     

       353
       353
        
               default = "${pkgs.xkeyboard_config}/etc/X11/xkb";

     

       354
       354
       +
               defaultText = literalExpression ''"''${pkgs.xkeyboard_config}/etc/X11/xkb"'';

     

       354
       355
        
               description = ''

     

       355
       356
        
                 Path used for -xkbdir xserver parameter.

     

       356
       357
        
               '';

+4 -5

nixos/modules/system/activation/activation-script.nix

···

       110
       110
        
           system.activationScripts = mkOption {

     

       111
       111
        
             default = {};

     

       112
       112
        
       

     

       113
       113
       -
             example = literalExample ''

     

       113
       113
       +
             example = literalExpression ''

     

       114
       114
        
               { stdio.text =

     

       115
       115
        
                 '''

     

       116
       116
        
                   # Needed by some programs.

     
···

       147
       147
        
           system.userActivationScripts = mkOption {

     

       148
       148
        
             default = {};

     

       149
       149
        
       

     

       150
       150
       -
             example = literalExample ''

     

       150
       150
       +
             example = literalExpression ''

     

       151
       151
        
               { plasmaSetup = {

     

       152
       152
        
                   text = '''

     

       153
       153
        
                     ${pkgs.libsForQt5.kservice}/bin/kbuildsycoca5"

     
···

       193
       193
        
       

     

       194
       194
        
           environment.usrbinenv = mkOption {

     

       195
       195
        
             default = "${pkgs.coreutils}/bin/env";

     

       196
       196
       -
             example = literalExample ''

     

       197
       197
       -
               "''${pkgs.busybox}/bin/env"

     

       198
       198
       -
             '';

     

       196
       196
       +
             defaultText = literalExpression ''"''${pkgs.coreutils}/bin/env"'';

     

       197
       197
       +
             example = literalExpression ''"''${pkgs.busybox}/bin/env"'';

     

       199
       198
        
             type = types.nullOr types.path;

     

       200
       199
        
             visible = false;

     

       201
       200
        
             description = ''

+7 -3

nixos/modules/system/activation/top-level.nix

···

       155
       155
        
       

     

       156
       156
        
           specialisation = mkOption {

     

       157
       157
        
             default = {};

     

       158
       158
       -
             example = lib.literalExample "{ fewJobsManyCores.configuration = { nix.buildCores = 0; nix.maxJobs = 1; }; }";

     

       158
       158
       +
             example = lib.literalExpression "{ fewJobsManyCores.configuration = { nix.buildCores = 0; nix.maxJobs = 1; }; }";

     

       159
       159
        
             description = ''

     

       160
       160
        
               Additional configurations to build. If

     

       161
       161
        
               <literal>inheritParentConfig</literal> is true, the system

     
···

       243
       243
        
       

     

       244
       244
        
           system.replaceRuntimeDependencies = mkOption {

     

       245
       245
        
             default = [];

     

       246
       246
       -
             example = lib.literalExample "[ ({ original = pkgs.openssl; replacement = pkgs.callPackage /path/to/openssl { }; }) ]";

     

       246
       246
       +
             example = lib.literalExpression "[ ({ original = pkgs.openssl; replacement = pkgs.callPackage /path/to/openssl { }; }) ]";

     

       247
       247
        
             type = types.listOf (types.submodule (

     

       248
       248
        
               { ... }: {

     

       249
       249
        
                 options.original = mkOption {

     
···

       274
       274
        
               if config.networking.hostName == ""

     

       275
       275
        
               then "unnamed"

     

       276
       276
        
               else config.networking.hostName;

     

       277
       277
       -
             defaultText = '''networking.hostName' if non empty else "unnamed"'';

     

       277
       277
       +
             defaultText = literalExpression ''

     

       278
       278
       +
               if config.networking.hostName == ""

     

       279
       279
       +
               then "unnamed"

     

       280
       280
       +
               else config.networking.hostName;

     

       281
       281
       +
             '';

     

       278
       282
        
             description = ''

     

       279
       283
        
               The name of the system used in the <option>system.build.toplevel</option> derivation.

     

       280
       284
        
               </para><para>

+1 -1

nixos/modules/system/boot/initrd-openvpn.nix

···

       35
       35
        
                 </para>

     

       36
       36
        
               </warning>

     

       37
       37
        
             '';

     

       38
       38
       -
             example = "./configuration.ovpn";

     

       38
       38
       +
             example = literalExpression "./configuration.ovpn";

     

       39
       39
        
           };

     

       40
       40
        
       

     

       41
       41
        
         };

+1 -1

nixos/modules/system/boot/initrd-ssh.nix

···

       78
       78
        
           authorizedKeys = mkOption {

     

       79
       79
        
             type = types.listOf types.str;

     

       80
       80
        
             default = config.users.users.root.openssh.authorizedKeys.keys;

     

       81
       81
       -
             defaultText = "config.users.users.root.openssh.authorizedKeys.keys";

     

       81
       81
       +
             defaultText = literalExpression "config.users.users.root.openssh.authorizedKeys.keys";

     

       82
       82
        
             description = ''

     

       83
       83
        
               Authorized keys for the root user on initrd.

     

       84
       84
        
             '';

+6 -6

nixos/modules/system/boot/kernel.nix

···

       23
       23
        
       

     

       24
       24
        
           boot.kernel.features = mkOption {

     

       25
       25
        
             default = {};

     

       26
       26
       -
             example = literalExample "{ debug = true; }";

     

       26
       26
       +
             example = literalExpression "{ debug = true; }";

     

       27
       27
        
             internal = true;

     

       28
       28
        
             description = ''

     

       29
       29
        
               This option allows to enable or disable certain kernel features.

     
···

       46
       46
        
             });

     

       47
       47
        
             # We don't want to evaluate all of linuxPackages for the manual

     

       48
       48
        
             # - some of it might not even evaluate correctly.

     

       49
       49
       -
             defaultText = "pkgs.linuxPackages";

     

       50
       50
       -
             example = literalExample "pkgs.linuxKernel.packages.linux_5_10";

     

       49
       49
       +
             defaultText = literalExpression "pkgs.linuxPackages";

     

       50
       50
       +
             example = literalExpression "pkgs.linuxKernel.packages.linux_5_10";

     

       51
       51
        
             description = ''

     

       52
       52
        
               This option allows you to override the Linux kernel used by

     

       53
       53
        
               NixOS.  Since things like external kernel module packages are

     
···

       65
       65
        
           boot.kernelPatches = mkOption {

     

       66
       66
        
             type = types.listOf types.attrs;

     

       67
       67
        
             default = [];

     

       68
       68
       -
             example = literalExample "[ pkgs.kernelPatches.ubuntu_fan_4_4 ]";

     

       68
       68
       +
             example = literalExpression "[ pkgs.kernelPatches.ubuntu_fan_4_4 ]";

     

       69
       69
        
             description = "A list of additional patches to apply to the kernel.";

     

       70
       70
        
           };

     

       71
       71
        
       

     
···

       113
       113
        
           boot.extraModulePackages = mkOption {

     

       114
       114
        
             type = types.listOf types.package;

     

       115
       115
        
             default = [];

     

       116
       116
       -
             example = literalExample "[ config.boot.kernelPackages.nvidia_x11 ]";

     

       116
       116
       +
             example = literalExpression "[ config.boot.kernelPackages.nvidia_x11 ]";

     

       117
       117
        
             description = "A list of additional packages supplying kernel modules.";

     

       118
       118
        
           };

     

       119
       119
        
       

     
···

       181
       181
        
       

     

       182
       182
        
           system.requiredKernelConfig = mkOption {

     

       183
       183
        
             default = [];

     

       184
       184
       -
             example = literalExample ''

     

       184
       184
       +
             example = literalExpression ''

     

       185
       185
        
               with config.lib.kernelConfig; [

     

       186
       186
        
                 (isYes "MODULES")

     

       187
       187
        
                 (isEnabled "FB_CON_DECOR")

+1 -1

nixos/modules/system/boot/kernel_config.nix

···

       100
       100
        
       

     

       101
       101
        
           settings = mkOption {

     

       102
       102
        
             type = types.attrsOf kernelItem;

     

       103
       103
       -
             example = literalExample '' with lib.kernel; {

     

       103
       103
       +
             example = literalExpression '' with lib.kernel; {

     

       104
       104
        
               "9P_NET" = yes;

     

       105
       105
        
               USB = option yes;

     

       106
       106
        
               MMC_BLOCK_MINORS = freeform "32";

+6 -6

nixos/modules/system/boot/loader/grub/grub.nix

···

       329
       329
        
       

     

       330
       330
        
             extraInstallCommands = mkOption {

     

       331
       331
        
               default = "";

     

       332
       332
       -
               example = literalExample ''

     

       332
       332
       +
               example = ''

     

       333
       333
        
                 # the example below generates detached signatures that GRUB can verify

     

       334
       334
        
                 # https://www.gnu.org/software/grub/manual/grub/grub.html#Using-digital-signatures

     

       335
       335
        
                 ''${pkgs.findutils}/bin/find /boot -not -path "/boot/efi/*" -type f -name '*.sig' -delete

     
···

       392
       392
        
             extraFiles = mkOption {

     

       393
       393
        
               type = types.attrsOf types.path;

     

       394
       394
        
               default = {};

     

       395
       395
       -
               example = literalExample ''

     

       395
       395
       +
               example = literalExpression ''

     

       396
       396
        
                 { "memtest.bin" = "''${pkgs.memtest86plus}/memtest.bin"; }

     

       397
       397
        
               '';

     

       398
       398
        
               description = ''

     
···

       413
       413
        
       

     

       414
       414
        
             splashImage = mkOption {

     

       415
       415
        
               type = types.nullOr types.path;

     

       416
       416
       -
               example = literalExample "./my-background.png";

     

       416
       416
       +
               example = literalExpression "./my-background.png";

     

       417
       417
        
               description = ''

     

       418
       418
        
                 Background image used for GRUB.

     

       419
       419
        
                 Set to <literal>null</literal> to run GRUB in text mode.

     
···

       449
       449
        
       

     

       450
       450
        
             theme = mkOption {

     

       451
       451
        
               type = types.nullOr types.path;

     

       452
       452
       -
               example = literalExample "pkgs.nixos-grub2-theme";

     

       452
       452
       +
               example = literalExpression "pkgs.nixos-grub2-theme";

     

       453
       453
        
               default = null;

     

       454
       454
        
               description = ''

     

       455
       455
        
                 Grub theme to be used.

     
···

       475
       475
        
             font = mkOption {

     

       476
       476
        
               type = types.nullOr types.path;

     

       477
       477
        
               default = "${realGrub}/share/grub/unicode.pf2";

     

       478
       478
       -
               defaultText = ''"''${pkgs.grub2}/share/grub/unicode.pf2"'';

     

       478
       478
       +
               defaultText = literalExpression ''"''${pkgs.grub2}/share/grub/unicode.pf2"'';

     

       479
       479
        
               description = ''

     

       480
       480
        
                 Path to a TrueType, OpenType, or pf2 font to be used by Grub.

     

       481
       481
        
               '';

     
···

       483
       483
        
       

     

       484
       484
        
             fontSize = mkOption {

     

       485
       485
        
               type = types.nullOr types.int;

     

       486
       486
       -
               example = literalExample 16;

     

       486
       486
       +
               example = 16;

     

       487
       487
        
               default = null;

     

       488
       488
        
               description = ''

     

       489
       489
        
                 Font size for the grub menu. Ignored unless <literal>font</literal>

+1 -1

nixos/modules/system/boot/loader/grub/ipxe.nix

···

       33
       33
        
                   booting from the GRUB boot menu.

     

       34
       34
        
                 '';

     

       35
       35
        
               default = { };

     

       36
       36
       -
               example = literalExample ''

     

       36
       36
       +
               example = literalExpression ''

     

       37
       37
        
                 { demo = '''

     

       38
       38
        
                     #!ipxe

     

       39
       39
        
                     dhcp

-2

nixos/modules/system/boot/luksroot.nix

···

       663
       663
        
                       };

     

       664
       664
        
       

     

       665
       665
        
                       encryptedPass = mkOption {

     

       666
       666
       -
                         default = "";

     

       667
       666
        
                         type = types.path;

     

       668
       667
        
                         description = "Path to the GPG encrypted passphrase.";

     

       669
       668
        
                       };

     

       670
       669
        
       

     

       671
       670
        
                       publicKey = mkOption {

     

       672
       672
       -
                         default = "";

     

       673
       671
        
                         type = types.path;

     

       674
       672
        
                         description = "Path to the Public Key.";

     

       675
       673
        
                       };

+4 -8

nixos/modules/system/boot/networkd.nix

···

       844
       844
        
           options = {

     

       845
       845
        
             wireguardPeerConfig = mkOption {

     

       846
       846
        
               default = {};

     

       847
       847
       -
               example = { };

     

       848
       847
        
               type = types.addCheck (types.attrsOf unitOption) check.netdev.sectionWireGuardPeer;

     

       849
       848
        
               description = ''

     

       850
       849
        
                 Each attribute in this set specifies an option in the

     
···

       859
       858
        
         netdevOptions = commonNetworkOptions // {

     

       860
       859
        
       

     

       861
       860
        
           netdevConfig = mkOption {

     

       862
       862
       -
             default = {};

     

       863
       861
        
             example = { Name = "mybridge"; Kind = "bridge"; };

     

       864
       862
        
             type = types.addCheck (types.attrsOf unitOption) check.netdev.sectionNetdev;

     

       865
       863
        
             description = ''

     
···

       896
       894
        
       

     

       897
       895
        
           vxlanConfig = mkOption {

     

       898
       896
        
             default = {};

     

       899
       899
       -
             example = { Id = "4"; };

     

       900
       897
        
             type = types.addCheck (types.attrsOf unitOption) check.netdev.sectionVXLAN;

     

       901
       898
        
             description = ''

     

       902
       899
        
               Each attribute in this set specifies an option in the

     
···

       959
       956
        
             example = {

     

       960
       957
        
               PrivateKeyFile = "/etc/wireguard/secret.key";

     

       961
       958
        
               ListenPort = 51820;

     

       962
       962
       -
               FwMark = 42;

     

       959
       959
       +
               FirewallMark = 42;

     

       963
       960
        
             };

     

       964
       961
        
             type = types.addCheck (types.attrsOf unitOption) check.netdev.sectionWireGuard;

     

       965
       962
        
             description = ''

     
···

       1038
       1035
        
         addressOptions = {

     

       1039
       1036
        
           options = {

     

       1040
       1037
        
             addressConfig = mkOption {

     

       1041
       1041
       -
               default = {};

     

       1042
       1038
        
               example = { Address = "192.168.0.100/24"; };

     

       1043
       1039
        
               type = types.addCheck (types.attrsOf unitOption) check.network.sectionAddress;

     

       1044
       1040
        
               description = ''

     
···

       1055
       1051
        
           options = {

     

       1056
       1052
        
             routingPolicyRuleConfig = mkOption {

     

       1057
       1053
        
               default = { };

     

       1058
       1058
       -
               example = { routingPolicyRuleConfig = { Table = 10; IncomingInterface = "eth1"; Family = "both"; } ;};

     

       1054
       1054
       +
               example = { Table = 10; IncomingInterface = "eth1"; Family = "both"; };

     

       1059
       1055
        
               type = types.addCheck (types.attrsOf unitOption) check.network.sectionRoutingPolicyRule;

     

       1060
       1056
        
               description = ''

     

       1061
       1057
        
                 Each attribute in this set specifies an option in the

     
···

       1146
       1142
        
       

     

       1147
       1143
        
           dhcpV6Config = mkOption {

     

       1148
       1144
        
             default = {};

     

       1149
       1149
       -
             example = { UseDNS = true; UseRoutes = true; };

     

       1145
       1145
       +
             example = { UseDNS = true; };

     

       1150
       1146
        
             type = types.addCheck (types.attrsOf unitOption) check.network.sectionDHCPv6;

     

       1151
       1147
        
             description = ''

     

       1152
       1148
        
               Each attribute in this set specifies an option in the

     
···

       1213
       1209
        
       

     

       1214
       1210
        
           ipv6Prefixes = mkOption {

     

       1215
       1211
        
             default = [];

     

       1216
       1216
       -
             example = { AddressAutoconfiguration = true; OnLink = true; };

     

       1212
       1212
       +
             example = [ { AddressAutoconfiguration = true; OnLink = true; } ];

     

       1217
       1213
        
             type = with types; listOf (submodule ipv6PrefixOptions);

     

       1218
       1214
        
             description = ''

     

       1219
       1215
        
               A list of ipv6Prefix sections to be added to the unit.  See

+2 -1

nixos/modules/system/boot/plymouth.nix

···

       62
       62
        
       

     

       63
       63
        
             font = mkOption {

     

       64
       64
        
               default = "${pkgs.dejavu_fonts.minimal}/share/fonts/truetype/DejaVuSans.ttf";

     

       65
       65
       +
               defaultText = literalExpression ''"''${pkgs.dejavu_fonts.minimal}/share/fonts/truetype/DejaVuSans.ttf"'';

     

       65
       66
        
               type = types.path;

     

       66
       67
        
               description = ''

     

       67
       68
        
                 Font file made available for displaying text on the splash screen.

     
···

       88
       89
        
               type = types.path;

     

       89
       90
        
               # Dimensions are 48x48 to match GDM logo

     

       90
       91
        
               default = "${nixos-icons}/share/icons/hicolor/48x48/apps/nix-snowflake-white.png";

     

       91
       91
       -
               defaultText = ''pkgs.fetchurl {

     

       92
       92
       +
               defaultText = literalExpression ''pkgs.fetchurl {

     

       92
       93
        
                 url = "https://nixos.org/logo/nixos-hires.png";

     

       93
       94
        
                 sha256 = "1ivzgd7iz0i06y36p8m5w48fd8pjqwxhdaavc0pxs7w1g7mcy5si";

     

       94
       95
        
               }'';

+3 -3

nixos/modules/system/boot/stage-1.nix

···

       411
       411
        
           boot.initrd.enable = mkOption {

     

       412
       412
        
             type = types.bool;

     

       413
       413
        
             default = !config.boot.isContainer;

     

       414
       414
       -
             defaultText = "!config.boot.isContainer";

     

       414
       414
       +
             defaultText = literalExpression "!config.boot.isContainer";

     

       415
       415
        
             description = ''

     

       416
       416
        
               Whether to enable the NixOS initial RAM disk (initrd). This may be

     

       417
       417
        
               needed to perform some initialisation tasks (like mounting

     
···

       527
       527
        
               then "zstd"

     

       528
       528
        
               else "gzip"

     

       529
       529
        
             );

     

       530
       530
       -
             defaultText = "zstd if the kernel supports it (5.9+), gzip if not.";

     

       530
       530
       +
             defaultText = literalDocBook "<literal>zstd</literal> if the kernel supports it (5.9+), <literal>gzip</literal> if not";

     

       531
       531
        
             type = types.unspecified; # We don't have a function type...

     

       532
       532
        
             description = ''

     

       533
       533
        
               The compressor to use on the initrd image. May be any of:

     
···

       559
       559
        
                   is the path it should be copied from (or null for the same

     

       560
       560
        
                   path inside and out).

     

       561
       561
        
                 '';

     

       562
       562
       -
               example = literalExample

     

       562
       562
       +
               example = literalExpression

     

       563
       563
        
                 ''

     

       564
       564
        
                   { "/etc/dropbear/dropbear_rsa_host_key" =

     

       565
       565
        
                       ./secret-dropbear-key;

+5 -5

nixos/modules/system/boot/systemd.nix

···

       426
       426
        
       

     

       427
       427
        
           systemd.package = mkOption {

     

       428
       428
        
             default = pkgs.systemd;

     

       429
       429
       -
             defaultText = "pkgs.systemd";

     

       429
       429
       +
             defaultText = literalExpression "pkgs.systemd";

     

       430
       430
        
             type = types.package;

     

       431
       431
        
             description = "The systemd package.";

     

       432
       432
        
           };

     
···

       446
       446
        
           systemd.packages = mkOption {

     

       447
       447
        
             default = [];

     

       448
       448
        
             type = types.listOf types.package;

     

       449
       449
       -
             example = literalExample "[ pkgs.systemd-cryptsetup-generator ]";

     

       449
       449
       +
             example = literalExpression "[ pkgs.systemd-cryptsetup-generator ]";

     

       450
       450
        
             description = "Packages providing systemd units and hooks.";

     

       451
       451
        
           };

     

       452
       452
        
       

     
···

       663
       663
        
       

     

       664
       664
        
           services.journald.forwardToSyslog = mkOption {

     

       665
       665
        
             default = config.services.rsyslogd.enable || config.services.syslog-ng.enable;

     

       666
       666
       -
             defaultText = "services.rsyslogd.enable || services.syslog-ng.enable";

     

       666
       666
       +
             defaultText = literalExpression "services.rsyslogd.enable || services.syslog-ng.enable";

     

       667
       667
        
             type = types.bool;

     

       668
       668
        
             description = ''

     

       669
       669
        
               Whether to forward log messages to syslog.

     
···

       722
       722
        
       

     

       723
       723
        
           services.logind.lidSwitchExternalPower = mkOption {

     

       724
       724
        
             default = config.services.logind.lidSwitch;

     

       725
       725
       -
             defaultText = "services.logind.lidSwitch";

     

       725
       725
       +
             defaultText = literalExpression "services.logind.lidSwitch";

     

       726
       726
        
             example = "ignore";

     

       727
       727
        
             type = logindHandlerType;

     

       728
       728
        
       

     
···

       768
       768
        
           systemd.tmpfiles.packages = mkOption {

     

       769
       769
        
             type = types.listOf types.package;

     

       770
       770
        
             default = [];

     

       771
       771
       -
             example = literalExample "[ pkgs.lvm2 ]";

     

       771
       771
       +
             example = literalExpression "[ pkgs.lvm2 ]";

     

       772
       772
        
             apply = map getLib;

     

       773
       773
        
             description = ''

     

       774
       774
        
               List of packages containing <command>systemd-tmpfiles</command> rules.

+1 -1

nixos/modules/system/etc/etc.nix

···

       72
       72
        
       

     

       73
       73
        
           environment.etc = mkOption {

     

       74
       74
        
             default = {};

     

       75
       75
       -
             example = literalExample ''

     

       75
       75
       +
             example = literalExpression ''

     

       76
       76
        
               { example-configuration-file =

     

       77
       77
        
                   { source = "/nix/store/.../etc/dir/file.conf.example";

     

       78
       78
        
                     mode = "0440";

+1 -1

nixos/modules/tasks/filesystems.nix

···

       163
       163
        
       

     

       164
       164
        
           fileSystems = mkOption {

     

       165
       165
        
             default = {};

     

       166
       166
       -
             example = literalExample ''

     

       166
       166
       +
             example = literalExpression ''

     

       167
       167
        
               {

     

       168
       168
        
                 "/".device = "/dev/hda1";

     

       169
       169
        
                 "/data" = {

+1 -1

nixos/modules/tasks/filesystems/nfs.nix

···

       35
       35
        
                 <link xlink:href="https://linux.die.net/man/5/idmapd.conf"/>

     

       36
       36
        
                 for details.

     

       37
       37
        
               '';

     

       38
       38
       -
               example = literalExample ''

     

       38
       38
       +
               example = literalExpression ''

     

       39
       39
        
                 {

     

       40
       40
        
                   Translation = {

     

       41
       41
        
                     GSS-Methods = "static,nsswitch";

+2 -3

nixos/modules/tasks/filesystems/zfs.nix

···

       104
       104
        
               readOnly = true;

     

       105
       105
        
               type = types.package;

     

       106
       106
        
               default = if config.boot.zfs.enableUnstable then pkgs.zfsUnstable else pkgs.zfs;

     

       107
       107
       -
               defaultText = "if config.boot.zfs.enableUnstable then pkgs.zfsUnstable else pkgs.zfs";

     

       107
       107
       +
               defaultText = literalExpression "if config.boot.zfs.enableUnstable then pkgs.zfsUnstable else pkgs.zfs";

     

       108
       108
        
               description = "Configured ZFS userland tools package.";

     

       109
       109
        
             };

     

       110
       110
        
       

     
···

       150
       150
        
             devNodes = mkOption {

     

       151
       151
        
               type = types.path;

     

       152
       152
        
               default = "/dev/disk/by-id";

     

       153
       153
       -
               example = "/dev/disk/by-id";

     

       154
       153
        
               description = ''

     

       155
       154
        
                 Name of directory from which to import ZFS devices.

     

       156
       155
        
       

     
···

       351
       350
        
       

     

       352
       351
        
             settings = mkOption {

     

       353
       352
        
               type = with types; attrsOf (oneOf [ str int bool (listOf str) ]);

     

       354
       354
       -
               example = literalExample ''

     

       353
       353
       +
               example = literalExpression ''

     

       355
       354
        
                 {

     

       356
       355
        
                   ZED_DEBUG_LOG = "/tmp/zed.debug.log";

     

       357
       356

+1 -1

nixos/modules/tasks/lvm.nix

···

       9
       9
        
             type = types.package;

     

       10
       10
        
             default = if cfg.dmeventd.enable then pkgs.lvm2_dmeventd else pkgs.lvm2;

     

       11
       11
        
             internal = true;

     

       12
       12
       -
             defaultText = "pkgs.lvm2";

     

       12
       12
       +
             defaultText = literalExpression "pkgs.lvm2";

     

       13
       13
        
             description = ''

     

       14
       14
        
               This option allows you to override the LVM package that's used on the system

     

       15
       15
        
               (udev rules, tmpfiles, systemd services).

+9 -10

nixos/modules/tasks/network-interfaces.nix

···

       146
       146
        
             tempAddress = mkOption {

     

       147
       147
        
               type = types.enum (lib.attrNames tempaddrValues);

     

       148
       148
        
               default = cfg.tempAddresses;

     

       149
       149
       -
               defaultText = literalExample ''config.networking.tempAddresses'';

     

       149
       149
       +
               defaultText = literalExpression ''config.networking.tempAddresses'';

     

       150
       150
        
               description = ''

     

       151
       151
        
                 When IPv6 is enabled with SLAAC, this option controls the use of

     

       152
       152
        
                 temporary address (aka privacy extensions) on this

     
···

       257
       257
        
       

     

       258
       258
        
             virtualType = mkOption {

     

       259
       259
        
               default = if hasPrefix "tun" name then "tun" else "tap";

     

       260
       260
       -
               defaultText = literalExample ''if hasPrefix "tun" name then "tun" else "tap"'';

     

       260
       260
       +
               defaultText = literalExpression ''if hasPrefix "tun" name then "tun" else "tap"'';

     

       261
       261
        
               type = with types; enum [ "tun" "tap" ];

     

       262
       262
        
               description = ''

     

       263
       263
        
                 The type of interface to create.

     
···

       420
       420
        
                 The FQDN is required but cannot be determined. Please make sure that

     

       421
       421
        
                 both networking.hostName and networking.domain are set properly.

     

       422
       422
        
               '';

     

       423
       423
       -
             defaultText = literalExample ''''${networking.hostName}.''${networking.domain}'';

     

       423
       423
       +
             defaultText = literalExpression ''"''${networking.hostName}.''${networking.domain}"'';

     

       424
       424
        
             description = ''

     

       425
       425
        
               The fully qualified domain name (FQDN) of this host. It is the result

     

       426
       426
        
               of combining networking.hostName and networking.domain. Using this

     
···

       578
       578
        
               options = {

     

       579
       579
        
       

     

       580
       580
        
                 interfaces = mkOption {

     

       581
       581
       -
                   example = [ "eth0" "eth1" ];

     

       582
       581
        
                   description = "The physical network interfaces connected by the vSwitch.";

     

       583
       582
        
                   type = with types; attrsOf (submodule vswitchInterfaceOpts);

     

       584
       583
        
                 };

     
···

       691
       690
        
               '';

     

       692
       691
        
             in mkOption {

     

       693
       692
        
               default = { };

     

       694
       694
       -
               example = literalExample ''

     

       693
       693
       +
               example = literalExpression ''

     

       695
       694
        
                 {

     

       696
       695
        
                   bond0 = {

     

       697
       696
        
                     interfaces = [ "eth0" "wlan0" ];

     
···

       720
       719
        
                   driverOptions = mkOption {

     

       721
       720
        
                     type = types.attrsOf types.str;

     

       722
       721
        
                     default = {};

     

       723
       723
       -
                     example = literalExample driverOptionsExample;

     

       722
       722
       +
                     example = literalExpression driverOptionsExample;

     

       724
       723
        
                     description = ''

     

       725
       724
        
                       Options for the bonding driver.

     

       726
       725
        
                       Documentation can be found in

     
···

       784
       783
        
       

     

       785
       784
        
           networking.macvlans = mkOption {

     

       786
       785
        
             default = { };

     

       787
       787
       -
             example = literalExample ''

     

       786
       786
       +
             example = literalExpression ''

     

       788
       787
        
               {

     

       789
       788
        
                 wan = {

     

       790
       789
        
                   interface = "enp2s0";

     
···

       819
       818
        
       

     

       820
       819
        
           networking.sits = mkOption {

     

       821
       820
        
             default = { };

     

       822
       822
       -
             example = literalExample ''

     

       821
       821
       +
             example = literalExpression ''

     

       823
       822
        
               {

     

       824
       823
        
                 hurricane = {

     

       825
       824
        
                   remote = "10.0.0.1";

     
···

       883
       882
        
       

     

       884
       883
        
           networking.vlans = mkOption {

     

       885
       884
        
             default = { };

     

       886
       886
       -
             example = literalExample ''

     

       885
       885
       +
             example = literalExpression ''

     

       887
       886
        
               {

     

       888
       887
        
                 vlan0 = {

     

       889
       888
        
                   id = 3;

     
···

       927
       926
        
       

     

       928
       927
        
           networking.wlanInterfaces = mkOption {

     

       929
       928
        
             default = { };

     

       930
       930
       -
             example = literalExample ''

     

       929
       929
       +
             example = literalExpression ''

     

       931
       930
        
               {

     

       932
       931
        
                 wlan-station0 = {

     

       933
       932
        
                     device = "wlp6s0";

+1 -1

nixos/modules/virtualisation/anbox.nix

···

       35
       35
        
       

     

       36
       36
        
           image = mkOption {

     

       37
       37
        
             default = pkgs.anbox.image;

     

       38
       38
       -
             example = literalExample "pkgs.anbox.image";

     

       38
       38
       +
             defaultText = literalExpression "pkgs.anbox.image";

     

       39
       39
        
             type = types.package;

     

       40
       40
        
             description = ''

     

       41
       41
        
               Base android image for Anbox.

+4 -4

nixos/modules/virtualisation/containers.nix

···

       2
       2
        
       let

     

       3
       3
        
         cfg = config.virtualisation.containers;

     

       4
       4
        
       

     

       5
       5
       -
         inherit (lib) mkOption types;

     

       5
       5
       +
         inherit (lib) literalExpression mkOption types;

     

       6
       6
        
       

     

       7
       7
        
         toml = pkgs.formats.toml { };

     

       8
       8
        
       in

     
···

       50
       50
        
       

     

       51
       51
        
           containersConf.cniPlugins = mkOption {

     

       52
       52
        
             type = types.listOf types.package;

     

       53
       53
       -
             defaultText = ''

     

       53
       53
       +
             defaultText = literalExpression ''

     

       54
       54
        
               [

     

       55
       55
        
                 pkgs.cni-plugins

     

       56
       56
        
               ]

     

       57
       57
        
             '';

     

       58
       58
       -
             example = lib.literalExample ''

     

       58
       58
       +
             example = literalExpression ''

     

       59
       59
        
               [

     

       60
       60
        
                 pkgs.cniPlugins.dnsname

     

       61
       61
        
               ]

     
···

       106
       106
        
           policy = mkOption {

     

       107
       107
        
             default = {};

     

       108
       108
        
             type = types.attrs;

     

       109
       109
       -
             example = lib.literalExample ''

     

       109
       109
       +
             example = literalExpression ''

     

       110
       110
        
               {

     

       111
       111
        
                 default = [ { type = "insecureAcceptAnything"; } ];

     

       112
       112
        
                 transports = {

+4 -4

nixos/modules/virtualisation/cri-o.nix

···

       38
       38
        
             type = types.nullOr types.str;

     

       39
       39
        
             default = null;

     

       40
       40
        
             description = "Override the default pause image for pod sandboxes";

     

       41
       41
       -
             example = [ "k8s.gcr.io/pause:3.2" ];

     

       41
       41
       +
             example = "k8s.gcr.io/pause:3.2";

     

       42
       42
        
           };

     

       43
       43
        
       

     

       44
       44
        
           pauseCommand = mkOption {

     

       45
       45
        
             type = types.nullOr types.str;

     

       46
       46
        
             default = null;

     

       47
       47
        
             description = "Override the default pause command";

     

       48
       48
       -
             example = [ "/pause" ];

     

       48
       48
       +
             example = "/pause";

     

       49
       49
        
           };

     

       50
       50
        
       

     

       51
       51
        
           runtime = mkOption {

     

       52
       52
        
             type = types.nullOr types.str;

     

       53
       53
        
             default = null;

     

       54
       54
        
             description = "Override the default runtime";

     

       55
       55
       -
             example = [ "crun" ];

     

       55
       55
       +
             example = "crun";

     

       56
       56
        
           };

     

       57
       57
        
       

     

       58
       58
        
           extraPackages = mkOption {

     

       59
       59
        
             type = with types; listOf package;

     

       60
       60
        
             default = [ ];

     

       61
       61
       -
             example = literalExample ''

     

       61
       61
       +
             example = literalExpression ''

     

       62
       62
        
               [

     

       63
       63
        
                 pkgs.gvisor

     

       64
       64
        
               ]

+1 -1

nixos/modules/virtualisation/digital-ocean-init.nix

···

       20
       20
        
         options.virtualisation.digitalOcean.defaultConfigFile = mkOption {

     

       21
       21
        
           type = types.path;

     

       22
       22
        
           default = defaultConfigFile;

     

       23
       23
       -
           defaultText = ''

     

       23
       23
       +
           defaultText = literalDocBook ''

     

       24
       24
        
             The default configuration imports user-data if applicable and

     

       25
       25
        
             <literal>(modulesPath + "/virtualisation/digital-ocean-config.nix")</literal>.

     

       26
       26
        
           '';

+2 -1

nixos/modules/virtualisation/docker.nix

···

       138
       138
        
       

     

       139
       139
        
           package = mkOption {

     

       140
       140
        
             default = pkgs.docker;

     

       141
       141
       +
             defaultText = literalExpression "pkgs.docker";

     

       141
       142
        
             type = types.package;

     

       142
       142
       -
             example = pkgs.docker-edge;

     

       143
       143
       +
             example = literalExpression "pkgs.docker-edge";

     

       143
       144
        
             description = ''

     

       144
       145
        
               Docker package to be used in the module.

     

       145
       146
        
             '';

+1 -1

nixos/modules/virtualisation/ecs-agent.nix

···

       12
       12
        
             type = types.path;

     

       13
       13
        
             description = "The ECS agent package to use";

     

       14
       14
        
             default = pkgs.ecs-agent;

     

       15
       15
       -
             defaultText = "pkgs.ecs-agent";

     

       15
       15
       +
             defaultText = literalExpression "pkgs.ecs-agent";

     

       16
       16
        
           };

     

       17
       17
        
       

     

       18
       18
        
           extra-environment = mkOption {

+2 -1

nixos/modules/virtualisation/libvirtd.nix

···

       50
       50
        
           package = mkOption {

     

       51
       51
        
             type = types.package;

     

       52
       52
        
             default = pkgs.libvirt;

     

       53
       53
       -
             defaultText = "pkgs.libvirt";

     

       53
       53
       +
             defaultText = literalExpression "pkgs.libvirt";

     

       54
       54
        
             description = ''

     

       55
       55
        
               libvirt package to use.

     

       56
       56
        
             '';

     
···

       59
       59
        
           qemuPackage = mkOption {

     

       60
       60
        
             type = types.package;

     

       61
       61
        
             default = pkgs.qemu;

     

       62
       62
       +
             defaultText = literalExpression "pkgs.qemu";

     

       62
       63
        
             description = ''

     

       63
       64
        
               Qemu package to use with libvirt.

     

       64
       65
        
               `pkgs.qemu` can emulate alien architectures (e.g. aarch64 on x86)

+3 -3

nixos/modules/virtualisation/lxd.nix

···

       35
       35
        
             package = mkOption {

     

       36
       36
        
               type = types.package;

     

       37
       37
        
               default = pkgs.lxd.override { nftablesSupport = config.networking.nftables.enable; };

     

       38
       38
       -
               defaultText = "pkgs.lxd";

     

       38
       38
       +
               defaultText = literalExpression "pkgs.lxd";

     

       39
       39
        
               description = ''

     

       40
       40
        
                 The LXD package to use.

     

       41
       41
        
               '';

     
···

       44
       44
        
             lxcPackage = mkOption {

     

       45
       45
        
               type = types.package;

     

       46
       46
        
               default = pkgs.lxc;

     

       47
       47
       -
               defaultText = "pkgs.lxc";

     

       47
       47
       +
               defaultText = literalExpression "pkgs.lxc";

     

       48
       48
        
               description = ''

     

       49
       49
        
                 The LXC package to use with LXD (required for AppArmor profiles).

     

       50
       50
        
               '';

     
···

       53
       53
        
             zfsSupport = mkOption {

     

       54
       54
        
               type = types.bool;

     

       55
       55
        
               default = config.boot.zfs.enabled;

     

       56
       56
       -
               defaultText = "config.boot.zfs.enabled";

     

       56
       56
       +
               defaultText = literalExpression "config.boot.zfs.enabled";

     

       57
       57
        
               description = ''

     

       58
       58
        
                 Enables lxd to use zfs as a storage for containers.

     

       59
       59

+3 -3

nixos/modules/virtualisation/nixos-containers.nix

···

       530
       530
        
                   nixpkgs = mkOption {

     

       531
       531
        
                     type = types.path;

     

       532
       532
        
                     default = pkgs.path;

     

       533
       533
       -
                     defaultText = "pkgs.path";

     

       533
       533
       +
                     defaultText = literalExpression "pkgs.path";

     

       534
       534
        
                     description = ''

     

       535
       535
        
                       A path to the nixpkgs that provide the modules, pkgs and lib for evaluating the container.

     

       536
       536
        
       

     
···

       636
       636
        
                   bindMounts = mkOption {

     

       637
       637
        
                     type = with types; attrsOf (submodule bindMountOpts);

     

       638
       638
        
                     default = {};

     

       639
       639
       -
                     example = literalExample ''

     

       639
       639
       +
                     example = literalExpression ''

     

       640
       640
        
                       { "/home" = { hostPath = "/home/alice";

     

       641
       641
        
                                     isReadOnly = false; };

     

       642
       642
        
                       }

     
···

       707
       707
        
               }));

     

       708
       708
        
       

     

       709
       709
        
             default = {};

     

       710
       710
       -
             example = literalExample

     

       710
       710
       +
             example = literalExpression

     

       711
       711
        
               ''

     

       712
       712
        
                 { webserver =

     

       713
       713
        
                     { path = "/nix/var/nix/profiles/webserver";

+8 -8

nixos/modules/virtualisation/oci-containers.nix

···

       28
       28
        
                   You still need to set the <literal>image</literal> attribute, as it

     

       29
       29
        
                   will be used as the image name for docker to start a container.

     

       30
       30
        
                 '';

     

       31
       31
       -
                 example = literalExample "pkgs.dockerTools.buildDockerImage {...};";

     

       31
       31
       +
                 example = literalExpression "pkgs.dockerTools.buildDockerImage {...};";

     

       32
       32
        
               };

     

       33
       33
        
       

     

       34
       34
        
               login = {

     
···

       59
       59
        
                 type =  with types; listOf str;

     

       60
       60
        
                 default = [];

     

       61
       61
        
                 description = "Commandline arguments to pass to the image's entrypoint.";

     

       62
       62
       -
                 example = literalExample ''

     

       62
       62
       +
                 example = literalExpression ''

     

       63
       63
        
                   ["--port=9000"]

     

       64
       64
        
                 '';

     

       65
       65
        
               };

     
···

       75
       75
        
                 type = with types; attrsOf str;

     

       76
       76
        
                 default = {};

     

       77
       77
        
                 description = "Environment variables to set for this container.";

     

       78
       78
       -
                 example = literalExample ''

     

       78
       78
       +
                 example = literalExpression ''

     

       79
       79
        
                   {

     

       80
       80
        
                     DATABASE_HOST = "db.example.com";

     

       81
       81
        
                     DATABASE_PORT = "3306";

     
···

       87
       87
        
                 type = with types; listOf path;

     

       88
       88
        
                 default = [];

     

       89
       89
        
                 description = "Environment files for this container.";

     

       90
       90
       -
                 example = literalExample ''

     

       90
       90
       +
                 example = literalExpression ''

     

       91
       91
        
                   [

     

       92
       92
        
                     /path/to/.env

     

       93
       93
        
                     /path/to/.env.secret

     
···

       160
       160
        
                   <link xlink:href="https://docs.docker.com/engine/reference/run/#expose-incoming-ports">

     

       161
       161
        
                   Docker engine documentation</link> for full details.

     

       162
       162
        
                 '';

     

       163
       163
       -
                 example = literalExample ''

     

       163
       163
       +
                 example = literalExpression ''

     

       164
       164
        
                   [

     

       165
       165
        
                     "8080:9000"

     

       166
       166
        
                   ]

     
···

       191
       191
        
                   <link xlink:href="https://docs.docker.com/engine/reference/run/#volume-shared-filesystems">

     

       192
       192
        
                   docker engine documentation</link> for details.

     

       193
       193
        
                 '';

     

       194
       194
       -
                 example = literalExample ''

     

       194
       194
       +
                 example = literalExpression ''

     

       195
       195
        
                   [

     

       196
       196
        
                     "volume_name:/path/inside/container"

     

       197
       197
        
                     "/path/on/host:/path/inside/container"

     
···

       214
       214
        
       

     

       215
       215
        
                   Use the same name as the attribute under <literal>virtualisation.oci-containers.containers</literal>.

     

       216
       216
        
                 '';

     

       217
       217
       -
                 example = literalExample ''

     

       217
       217
       +
                 example = literalExpression ''

     

       218
       218
        
                   virtualisation.oci-containers.containers = {

     

       219
       219
        
                     node1 = {};

     

       220
       220
        
                     node2 = {

     
···

       228
       228
        
                 type = with types; listOf str;

     

       229
       229
        
                 default = [];

     

       230
       230
        
                 description = "Extra options for <command>${defaultBackend} run</command>.";

     

       231
       231
       -
                 example = literalExample ''

     

       231
       231
       +
                 example = literalExpression ''

     

       232
       232
        
                   ["--network=host"]

     

       233
       233
        
                 '';

     

       234
       234
        
               };

+1 -1

nixos/modules/virtualisation/openvswitch.nix

···

       31
       31
        
           package = mkOption {

     

       32
       32
        
             type = types.package;

     

       33
       33
        
             default = pkgs.openvswitch;

     

       34
       34
       -
             defaultText = "pkgs.openvswitch";

     

       34
       34
       +
             defaultText = literalExpression "pkgs.openvswitch";

     

       35
       35
        
             description = ''

     

       36
       36
        
               Open vSwitch package to use.

     

       37
       37
        
             '';

+1 -2

nixos/modules/virtualisation/parallels-guest.nix

···

       34
       34
        
             package = mkOption {

     

       35
       35
        
               type = types.nullOr types.package;

     

       36
       36
        
               default = config.boot.kernelPackages.prl-tools;

     

       37
       37
       -
               defaultText = "config.boot.kernelPackages.prl-tools";

     

       38
       38
       -
               example = literalExample "config.boot.kernelPackages.prl-tools";

     

       37
       37
       +
               defaultText = literalExpression "config.boot.kernelPackages.prl-tools";

     

       39
       38
        
               description = ''

     

       40
       39
        
                 Defines which package to use for prl-tools. Override to change the version.

     

       41
       40
        
               '';

+1 -1

nixos/modules/virtualisation/podman.nix

···

       95
       95
        
           extraPackages = mkOption {

     

       96
       96
        
             type = with types; listOf package;

     

       97
       97
        
             default = [ ];

     

       98
       98
       -
             example = lib.literalExample ''

     

       98
       98
       +
             example = lib.literalExpression ''

     

       99
       99
        
               [

     

       100
       100
        
                 pkgs.gvisor

     

       101
       101
        
               ]

+1

nixos/modules/virtualisation/qemu-guest-agent.nix

···

       15
       15
        
             package = mkOption {

     

       16
       16
        
               type = types.package;

     

       17
       17
        
               default = pkgs.qemu.ga;

     

       18
       18
       +
               defaultText = literalExpression "pkgs.qemu.ga";

     

       18
       19
        
               description = "The QEMU guest agent package.";

     

       19
       20
        
             };

     

       20
       21
        
         };

+1 -1

nixos/modules/virtualisation/qemu-vm.nix

···

       455
       455
        
                 };

     

       456
       456
        
               });

     

       457
       457
        
             default = [];

     

       458
       458
       -
             example = lib.literalExample

     

       458
       458
       +
             example = lib.literalExpression

     

       459
       459
        
               ''

     

       460
       460
        
               [ # forward local port 2222 -> 22, to ssh into the VM

     

       461
       461
        
                 { from = "host"; host.port = 2222; guest.port = 22; }

+3 -4

nixos/modules/virtualisation/railcar.nix

···

       41
       41
        
               description = "Source for the in-container mount";

     

       42
       42
        
             };

     

       43
       43
        
             options = mkOption {

     

       44
       44
       -
               type = attrsOf (str);

     

       44
       44
       +
               type = listOf str;

     

       45
       45
        
               default = [ "bind" ];

     

       46
       46
        
               description = ''

     

       47
       47
        
                 Mount options of the filesystem to be used.

     
···

       77
       77
        
                     The defaults have been chosen for simple bindmounts, meaning

     

       78
       78
        
                     that you only need to provide the "source" parameter.

     

       79
       79
        
                   '';

     

       80
       80
       -
                   example = ''

     

       81
       81
       -
                     { "/data" = { source = "/var/lib/data"; }; }

     

       82
       82
       -
                   '';

     

       80
       80
       +
                   example = { "/data" = { source = "/var/lib/data"; }; };

     

       83
       81
        
                 };

     

       84
       82
        
       

     

       85
       83
        
                 runType = mkOption {

     
···

       112
       110
        
           package = mkOption {

     

       113
       111
        
             type = types.package;

     

       114
       112
        
             default = pkgs.railcar;

     

       113
       113
       +
             defaultText = literalExpression "pkgs.railcar";

     

       115
       114
        
             description = "Railcar package to use";

     

       116
       115
        
           };

     

       117
       116
        
         };

+1 -1

nixos/modules/virtualisation/virtualbox-host.nix

···

       43
       43
        
           package = mkOption {

     

       44
       44
        
             type = types.package;

     

       45
       45
        
             default = pkgs.virtualbox;

     

       46
       46
       -
             defaultText = "pkgs.virtualbox";

     

       46
       46
       +
             defaultText = literalExpression "pkgs.virtualbox";

     

       47
       47
        
             description = ''

     

       48
       48
        
               Which VirtualBox package to use.

     

       49
       49
        
             '';

+4 -4

nixos/modules/virtualisation/xen-dom0.nix

···

       35
       35
        
       

     

       36
       36
        
           virtualisation.xen.package = mkOption {

     

       37
       37
        
             type = types.package;

     

       38
       38
       -
             defaultText = "pkgs.xen";

     

       39
       39
       -
             example = literalExample "pkgs.xen-light";

     

       38
       38
       +
             defaultText = literalExpression "pkgs.xen";

     

       39
       39
       +
             example = literalExpression "pkgs.xen-light";

     

       40
       40
        
             description = ''

     

       41
       41
        
               The package used for Xen binary.

     

       42
       42
        
             '';

     
···

       45
       45
        
       

     

       46
       46
        
           virtualisation.xen.package-qemu = mkOption {

     

       47
       47
        
             type = types.package;

     

       48
       48
       -
             defaultText = "pkgs.xen";

     

       49
       49
       -
             example = literalExample "pkgs.qemu_xen-light";

     

       48
       48
       +
             defaultText = literalExpression "pkgs.xen";

     

       49
       49
       +
             example = literalExpression "pkgs.qemu_xen-light";

     

       50
       50
        
             description = ''

     

       51
       51
        
               The package with qemu binaries for dom0 qemu and xendomains.

     

       52
       52
        
             '';