commit 871526be1fb3d371437a8382901c8a9a25deb197 · pyrox.dev/nixpkgs

+68

lib/asserts.nix

···

       1
       1
        
       { lib }:

     

       2
       2
        
       

     

       3
       3
       +
       let

     

       4
       4
       +
         inherit (lib.strings)

     

       5
       5
       +
           concatStringsSep

     

       6
       6
       +
           ;

     

       7
       7
       +
         inherit (lib.lists)

     

       8
       8
       +
           filter

     

       9
       9
       +
           ;

     

       10
       10
       +
         inherit (lib.trivial)

     

       11
       11
       +
           showWarnings

     

       12
       12
       +
           ;

     

       13
       13
       +
       in

     

       3
       14
        
       rec {

     

       4
       15
        
       

     

       5
       16
        
         /**

     
···

       131
       142
        
             "each element in ${name} must be one of ${lib.generators.toPretty { } xs}, but is: ${

     

       132
       143
        
               lib.generators.toPretty { } vals

     

       133
       144
        
             }";

     

       145
       145
       +
       

     

       146
       146
       +
         /**

     

       147
       147
       +
           Wrap a value with logic that throws an error when assertions

     

       148
       148
       +
           fail and emits any warnings.

     

       149
       149
       +
       

     

       150
       150
       +
           # Inputs

     

       151
       151
       +
       

     

       152
       152
       +
           `assertions`

     

       153
       153
       +
       

     

       154
       154
       +
           : A list of assertions. If any of their `assertion` attrs is `false`, their `message` attrs will be emitted in a `throw`.

     

       155
       155
       +
       

     

       156
       156
       +
           `warnings`

     

       157
       157
       +
       

     

       158
       158
       +
           : A list of strings to emit as warnings. This function does no filtering on this list.

     

       159
       159
       +
       

     

       160
       160
       +
           `val`

     

       161
       161
       +
       

     

       162
       162
       +
           : A value to return, wrapped in `warn`, if a `throw` is not necessary.

     

       163
       163
       +
       

     

       164
       164
       +
           # Type

     

       165
       165
       +
       

     

       166
       166
       +
           ```

     

       167
       167
       +
           checkAssertWarn :: [ { assertion :: Bool; message :: String } ] -> [ String ] -> Any -> Any

     

       168
       168
       +
           ```

     

       169
       169
       +
       

     

       170
       170
       +
           # Examples

     

       171
       171
       +
           :::{.example}

     

       172
       172
       +
           ## `lib.asserts.checkAssertWarn` usage example

     

       173
       173
       +
           ```nix

     

       174
       174
       +
           checkAssertWarn

     

       175
       175
       +
             [ { assertion = false; message = "Will fail"; } ]

     

       176
       176
       +
             [ ]

     

       177
       177
       +
             null

     

       178
       178
       +
           stderr>        error:

     

       179
       179
       +
           stderr>        Failed assertions:

     

       180
       180
       +
           stderr>        - Will fail

     

       181
       181
       +
       

     

       182
       182
       +
           checkAssertWarn

     

       183
       183
       +
             [ { assertion = true; message = "Will not fail"; } ]

     

       184
       184
       +
             [ "Will warn" ]

     

       185
       185
       +
             null

     

       186
       186
       +
           stderr> evaluation warning: Will warn

     

       187
       187
       +
           null

     

       188
       188
       +
           ```

     

       189
       189
       +
       

     

       190
       190
       +
           :::

     

       191
       191
       +
         */

     

       192
       192
       +
         checkAssertWarn =

     

       193
       193
       +
           assertions: warnings: val:

     

       194
       194
       +
           let

     

       195
       195
       +
             failedAssertions = map (x: x.message) (filter (x: !x.assertion) assertions);

     

       196
       196
       +
           in

     

       197
       197
       +
           if failedAssertions != [ ] then

     

       198
       198
       +
             throw "\nFailed assertions:\n${concatStringsSep "\n" (map (x: "- ${x}") failedAssertions)}"

     

       199
       199
       +
           else

     

       200
       200
       +
             showWarnings warnings val;

     

       201
       201
       +
       

     

       134
       202
        
       }

+77 -55

nixos/modules/image/repart.nix

···

       3
       3
        
       

     

       4
       4
        
       {

     

       5
       5
        
         config,

     

       6
       6
       +
         options,

     

       6
       7
        
         pkgs,

     

       7
       8
        
         lib,

     

       8
       9
        
         utils,

     
···

       258
       259
        
             '';

     

       259
       260
        
           };

     

       260
       261
        
       

     

       262
       262
       +
           assertions = lib.mkOption {

     

       263
       263
       +
             type = options.assertions.type;

     

       264
       264
       +
             default = [ ];

     

       265
       265
       +
             internal = true;

     

       266
       266
       +
             visible = false;

     

       267
       267
       +
             description = ''

     

       268
       268
       +
               Assertions only evaluated by the repart image, not by the system toplevel.

     

       269
       269
       +
             '';

     

       270
       270
       +
           };

     

       271
       271
       +
       

     

       272
       272
       +
           warnings = lib.mkOption {

     

       273
       273
       +
             type = options.warnings.type;

     

       274
       274
       +
             default = [ ];

     

       275
       275
       +
             internal = true;

     

       276
       276
       +
             visible = false;

     

       277
       277
       +
             description = ''

     

       278
       278
       +
               Warnings only evaluated by the repart image, not by the system toplevel.

     

       279
       279
       +
             '';

     

       280
       280
       +
           };

     

       281
       281
       +
       

     

       261
       282
        
         };

     

       262
       283
        
       

     

       263
       284
        
         config = {

     

       264
       264
       -
           assertions = lib.mapAttrsToList (

     

       265
       265
       -
             fileName: partitionConfig:

     

       266
       266
       -
             let

     

       267
       267
       -
               inherit (partitionConfig) repartConfig;

     

       268
       268
       -
               labelLength = builtins.stringLength repartConfig.Label;

     

       269
       269
       -
             in

     

       270
       270
       -
             {

     

       271
       271
       -
               assertion = repartConfig ? Label -> GPTMaxLabelLength >= labelLength;

     

       272
       272
       -
               message = ''

     

       273
       273
       -
                 The partition label '${repartConfig.Label}'

     

       274
       274
       -
                 defined for '${fileName}' is ${toString labelLength} characters long,

     

       275
       275
       -
                 but the maximum label length supported by UEFI is ${toString GPTMaxLabelLength}.

     

       276
       276
       -
               '';

     

       277
       277
       -
             }

     

       278
       278
       -
           ) cfg.partitions;

     

       279
       279
       -
       

     

       280
       280
       -
           warnings = lib.filter (v: v != null) (

     

       281
       281
       -
             lib.mapAttrsToList (

     

       282
       282
       -
               fileName: partitionConfig:

     

       283
       283
       -
               let

     

       284
       284
       -
                 inherit (partitionConfig) repartConfig;

     

       285
       285
       -
                 suggestedMaxLabelLength = GPTMaxLabelLength - 2;

     

       286
       286
       -
                 labelLength = builtins.stringLength repartConfig.Label;

     

       287
       287
       -
               in

     

       288
       288
       -
               if (repartConfig ? Label && labelLength >= suggestedMaxLabelLength) then

     

       289
       289
       -
                 ''

     

       290
       290
       -
                   The partition label '${repartConfig.Label}'

     

       291
       291
       -
                   defined for '${fileName}' is ${toString labelLength} characters long.

     

       292
       292
       -
                   The suggested maximum label length is ${toString suggestedMaxLabelLength}.

     

       293
       293
       -
       

     

       294
       294
       -
                   If you use sytemd-sysupdate style A/B updates, this might

     

       295
       295
       -
                   not leave enough space to increment the version number included in

     

       296
       296
       -
                   the label in a future release. For example, if your label is

     

       297
       297
       -
                   ${toString GPTMaxLabelLength} characters long (the maximum enforced by UEFI) and

     

       298
       298
       -
                   you're at version 9, you cannot increment this to 10.

     

       299
       299
       -
                 ''

     

       300
       300
       -
               else

     

       301
       301
       -
                 null

     

       302
       302
       -
             ) cfg.partitions

     

       303
       303
       -
           );

     

       304
       304
       -
       

     

       305
       285
        
           image.baseName =

     

       306
       286
        
             let

     

       307
       287
        
               version = config.image.repart.version;

     
···

       352
       332
        
               };

     

       353
       333
        
       

     

       354
       334
        
               finalPartitions = lib.mapAttrs addClosure cfg.partitions;

     

       335
       335
       +
       

     

       336
       336
       +
               assertions = lib.mapAttrsToList (

     

       337
       337
       +
                 fileName: partitionConfig:

     

       338
       338
       +
                 let

     

       339
       339
       +
                   inherit (partitionConfig) repartConfig;

     

       340
       340
       +
                   labelLength = builtins.stringLength repartConfig.Label;

     

       341
       341
       +
                 in

     

       342
       342
       +
                 {

     

       343
       343
       +
                   assertion = repartConfig ? Label -> GPTMaxLabelLength >= labelLength;

     

       344
       344
       +
                   message = ''

     

       345
       345
       +
                     The partition label '${repartConfig.Label}'

     

       346
       346
       +
                     defined for '${fileName}' is ${toString labelLength} characters long,

     

       347
       347
       +
                     but the maximum label length supported by UEFI is ${toString GPTMaxLabelLength}.

     

       348
       348
       +
                   '';

     

       349
       349
       +
                 }

     

       350
       350
       +
               ) cfg.partitions;

     

       351
       351
       +
       

     

       352
       352
       +
               warnings = lib.filter (v: v != null) (

     

       353
       353
       +
                 lib.mapAttrsToList (

     

       354
       354
       +
                   fileName: partitionConfig:

     

       355
       355
       +
                   let

     

       356
       356
       +
                     inherit (partitionConfig) repartConfig;

     

       357
       357
       +
                     suggestedMaxLabelLength = GPTMaxLabelLength - 2;

     

       358
       358
       +
                     labelLength = builtins.stringLength repartConfig.Label;

     

       359
       359
       +
                   in

     

       360
       360
       +
                   if (repartConfig ? Label && labelLength >= suggestedMaxLabelLength) then

     

       361
       361
       +
                     ''

     

       362
       362
       +
                       The partition label '${repartConfig.Label}'

     

       363
       363
       +
                       defined for '${fileName}' is ${toString labelLength} characters long.

     

       364
       364
       +
                       The suggested maximum label length is ${toString suggestedMaxLabelLength}.

     

       365
       365
       +
       

     

       366
       366
       +
                       If you use sytemd-sysupdate style A/B updates, this might

     

       367
       367
       +
                       not leave enough space to increment the version number included in

     

       368
       368
       +
                       the label in a future release. For example, if your label is

     

       369
       369
       +
                       ${toString GPTMaxLabelLength} characters long (the maximum enforced by UEFI) and

     

       370
       370
       +
                       you're at version 9, you cannot increment this to 10.

     

       371
       371
       +
                     ''

     

       372
       372
       +
                   else

     

       373
       373
       +
                     null

     

       374
       374
       +
                 ) cfg.partitions

     

       375
       375
       +
               );

     

       355
       376
        
             };

     

       356
       377
        
       

     

       357
       378
        
           system.build.image =

     
···

       367
       388
        
               );

     

       368
       389
        
       

     

       369
       390
        
               mkfsEnv = mkfsOptionsToEnv cfg.mkfsOptions;

     

       391
       391
       +
               val = pkgs.callPackage ./repart-image.nix {

     

       392
       392
       +
                 systemd = cfg.package;

     

       393
       393
       +
                 imageFileBasename = config.image.baseName;

     

       394
       394
       +
                 inherit (cfg)

     

       395
       395
       +
                   name

     

       396
       396
       +
                   version

     

       397
       397
       +
                   compression

     

       398
       398
       +
                   split

     

       399
       399
       +
                   seed

     

       400
       400
       +
                   sectorSize

     

       401
       401
       +
                   finalPartitions

     

       402
       402
       +
                   ;

     

       403
       403
       +
                 inherit fileSystems definitionsDirectory mkfsEnv;

     

       404
       404
       +
               };

     

       370
       405
        
             in

     

       371
       371
       -
             pkgs.callPackage ./repart-image.nix {

     

       372
       372
       -
               systemd = cfg.package;

     

       373
       373
       -
               imageFileBasename = config.image.baseName;

     

       374
       374
       -
               inherit (cfg)

     

       375
       375
       -
                 name

     

       376
       376
       -
                 version

     

       377
       377
       -
                 compression

     

       378
       378
       -
                 split

     

       379
       379
       -
                 seed

     

       380
       380
       -
                 sectorSize

     

       381
       381
       -
                 finalPartitions

     

       382
       382
       -
                 ;

     

       383
       383
       -
               inherit fileSystems definitionsDirectory mkfsEnv;

     

       384
       384
       -
             };

     

       406
       406
       +
             lib.asserts.checkAssertWarn cfg.assertions cfg.warnings val;

     

       385
       407
        
         };

     

       386
       408
        
       

     

       387
       409
        
         meta.maintainers = with lib.maintainers; [

+1 -8

nixos/modules/system/activation/top-level.nix

···

       77
       77
        
         );

     

       78
       78
        
       

     

       79
       79
        
         # Handle assertions and warnings

     

       80
       80
       -
       

     

       81
       81
       -
         failedAssertions = map (x: x.message) (filter (x: !x.assertion) config.assertions);

     

       82
       82
       -
       

     

       83
       83
       -
         baseSystemAssertWarn =

     

       84
       84
       -
           if failedAssertions != [ ] then

     

       85
       85
       -
             throw "\nFailed assertions:\n${concatStringsSep "\n" (map (x: "- ${x}") failedAssertions)}"

     

       86
       86
       -
           else

     

       87
       87
       -
             showWarnings config.warnings baseSystem;

     

       80
       80
       +
         baseSystemAssertWarn = lib.asserts.checkAssertWarn config.assertions config.warnings baseSystem;

     

       88
       81
        
       

     

       89
       82
        
         # Replace runtime dependencies

     

       90
       83
        
         system =