commit 97bfcc4bcd6b39850ef3ede321463d78f9c58431 · pyrox.dev/nixpkgs

+1 -1

nixos/modules/services/databases/postgresql.nix

···

       439
       439
        
                   ]);

     

       440
       440
        
                   options = {

     

       441
       441
        
                     shared_preload_libraries = mkOption {

     

       442
       442
       -
                       type = nullOr (coercedTo (listOf str) (concatStringsSep ", ") str);

     

       442
       442
       +
                       type = nullOr (coercedTo (listOf str) (concatStringsSep ",") commas);

     

       443
       443
        
                       default = null;

     

       444
       444
        
                       example = literalExpression ''[ "auto_explain" "anon" ]'';

     

       445
       445
        
                       description = ''

+9 -1

nixos/modules/virtualisation/oci-containers.nix

···

       381
       381
        
                 '';

     

       382
       382
        
               };

     

       383
       383
        
       

     

       384
       384
       +
               autoRemoveOnStop = mkOption {

     

       385
       385
       +
                 type = types.bool;

     

       386
       386
       +
                 default = true;

     

       387
       387
       +
                 description = ''

     

       388
       388
       +
                   Automatically remove the container when it is stopped or killed

     

       389
       389
       +
                 '';

     

       390
       390
       +
               };

     

       391
       391
       +
       

     

       384
       392
        
               networks = mkOption {

     

       385
       393
        
                 type = with types; listOf str;

     

       386
       394
        
                 default = [ ];

     
···

       468
       476
        
               ++ map escapeShellArg container.preRunExtraOptions

     

       469
       477
        
               ++ [

     

       470
       478
        
                 "run"

     

       471
       471
       -
                 "--rm"

     

       472
       479
        
                 "--name=${escapedName}"

     

       473
       480
        
                 "--log-driver=${container.log-driver}"

     

       474
       481
        
               ]

     
···

       489
       496
        
               ++ (mapAttrsToList (k: v: "-l ${escapeShellArg k}=${escapeShellArg v}") container.labels)

     

       490
       497
        
               ++ optional (container.workdir != null) "-w ${escapeShellArg container.workdir}"

     

       491
       498
        
               ++ optional (container.privileged) "--privileged"

     

       499
       499
       +
               ++ optional (container.autoRemoveOnStop) "--rm"

     

       492
       500
        
               ++ mapAttrsToList (k: _: "--cap-add=${escapeShellArg k}") (

     

       493
       501
        
                 filterAttrs (_: v: v == true) container.capabilities

     

       494
       502
        
               )

+28 -12

nixos/tests/all-tests.nix

···

       190
       190
        
         avahi = handleTest ./avahi.nix {};

     

       191
       191
        
         avahi-with-resolved = handleTest ./avahi.nix { networkd = true; };

     

       192
       192
        
         ayatana-indicators = runTest ./ayatana-indicators.nix;

     

       193
       193
       -
         babeld = handleTest ./babeld.nix {};

     

       193
       193
       +
         babeld = runTest ./babeld.nix;

     

       194
       194
        
         bazarr = handleTest ./bazarr.nix {};

     

       195
       195
        
         bcachefs = handleTestOn ["x86_64-linux" "aarch64-linux"] ./bcachefs.nix {};

     

       196
       196
        
         beanstalkd = handleTest ./beanstalkd.nix {};

     
···

       212
       212
        
         boot-stage2 = handleTest ./boot-stage2.nix {};

     

       213
       213
        
         borgbackup = handleTest ./borgbackup.nix {};

     

       214
       214
        
         borgmatic = handleTest ./borgmatic.nix {};

     

       215
       215
       -
         botamusique = handleTest ./botamusique.nix {};

     

       215
       215
       +
         botamusique = runTest ./botamusique.nix;

     

       216
       216
        
         bpf = handleTestOn ["x86_64-linux" "aarch64-linux"] ./bpf.nix {};

     

       217
       217
        
         bpftune = handleTest ./bpftune.nix {};

     

       218
       218
        
         breitbandmessung = handleTest ./breitbandmessung.nix {};

     
···

       387
       387
        
         filesystems-overlayfs = runTest ./filesystems-overlayfs.nix;

     

       388
       388
        
         firefly-iii = handleTest ./firefly-iii.nix {};

     

       389
       389
        
         firefly-iii-data-importer = handleTest ./firefly-iii-data-importer.nix {};

     

       390
       390
       -
         firefox = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox; };

     

       391
       391
       -
         firefox-beta = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-beta; };

     

       392
       392
       -
         firefox-devedition = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-devedition; };

     

       393
       393
       -
         firefox-esr    = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr; }; # used in `tested` job

     

       394
       394
       -
         firefox-esr-128 = handleTest ./firefox.nix { firefoxPackage = pkgs.firefox-esr-128; };

     

       390
       390
       +
         firefox = runTest {

     

       391
       391
       +
           imports = [./firefox.nix ];

     

       392
       392
       +
           _module.args.firefoxPackage = pkgs.firefox;

     

       393
       393
       +
         };

     

       394
       394
       +
         firefox-beta = runTest {

     

       395
       395
       +
           imports = [ ./firefox.nix ] ;

     

       396
       396
       +
           _module.args.firefoxPackage = pkgs.firefox-beta;

     

       397
       397
       +
         };

     

       398
       398
       +
         firefox-devedition = runTest {

     

       399
       399
       +
           imports = [ ./firefox.nix ];

     

       400
       400
       +
           _module.args.firefoxPackage = pkgs.firefox-devedition;

     

       401
       401
       +
         };

     

       402
       402
       +
         firefox-esr = runTest {

     

       403
       403
       +
            # used in `tested` job

     

       404
       404
       +
           imports = [ ./firefox.nix ] ;

     

       405
       405
       +
           _module.args.firefoxPackage = pkgs.firefox-esr;

     

       406
       406
       +
         };

     

       407
       407
       +
         firefox-esr-128 = runTest {

     

       408
       408
       +
           imports = [ ./firefox.nix ] ;

     

       409
       409
       +
           _module.args.firefoxPackage = pkgs.firefox-esr-128;

     

       410
       410
       +
         };

     

       395
       411
        
         firefoxpwa = handleTest ./firefoxpwa.nix {};

     

       396
       412
        
         firejail = handleTest ./firejail.nix {};

     

       397
       413
        
         firewall = handleTest ./firewall.nix { nftables = false; };

     
···

       444
       460
        
         gnupg = handleTest ./gnupg.nix {};

     

       445
       461
        
         goatcounter = handleTest ./goatcounter.nix {};

     

       446
       462
        
         go-camo = handleTest ./go-camo.nix { };

     

       447
       447
       -
         go-neb = handleTest ./go-neb.nix {};

     

       463
       463
       +
         go-neb = runTest ./go-neb.nix;

     

       448
       464
        
         gobgpd = handleTest ./gobgpd.nix {};

     

       449
       465
        
         gocd-agent = handleTest ./gocd-agent.nix {};

     

       450
       466
        
         gocd-server = handleTest ./gocd-server.nix {};

     
···

       559
       575
        
         kavita = handleTest ./kavita.nix {};

     

       560
       576
        
         kbd-setfont-decompress = handleTest ./kbd-setfont-decompress.nix {};

     

       561
       577
        
         kbd-update-search-paths-patch = handleTest ./kbd-update-search-paths-patch.nix {};

     

       562
       562
       -
         kea = handleTest ./kea.nix {};

     

       578
       578
       +
         kea = runTest ./kea.nix;

     

       563
       579
        
         keepalived = handleTest ./keepalived.nix {};

     

       564
       580
        
         keepassxc = handleTest ./keepassxc.nix {};

     

       565
       581
        
         kerberos = handleTest ./kerberos/default.nix {};

     
···

       573
       589
        
         keymap = handleTest ./keymap.nix {};

     

       574
       590
        
         kimai = handleTest ./kimai.nix {};

     

       575
       591
        
         kmonad = runTest ./kmonad.nix;

     

       576
       576
       -
         knot = handleTest ./knot.nix {};

     

       592
       592
       +
         knot = runTest ./knot.nix;

     

       577
       593
        
         komga = handleTest ./komga.nix {};

     

       578
       594
        
         krb5 = discoverTests (import ./krb5);

     

       579
       595
        
         ksm = handleTest ./ksm.nix {};

     
···

       887
       903
        
         phylactery = handleTest ./web-apps/phylactery.nix {};

     

       888
       904
        
         pict-rs = handleTest ./pict-rs.nix {};

     

       889
       905
        
         pingvin-share = handleTest ./pingvin-share.nix {} ;

     

       890
       890
       -
         pinnwand = handleTest ./pinnwand.nix {};

     

       906
       906
       +
         pinnwand = runTest ./pinnwand.nix;

     

       891
       907
        
         plantuml-server = handleTest ./plantuml-server.nix {};

     

       892
       908
        
         plasma-bigscreen = handleTest ./plasma-bigscreen.nix {};

     

       893
       909
        
         plasma5 = handleTest ./plasma5.nix {};

     
···

       1020
       1036
        
         slurm = handleTest ./slurm.nix {};

     

       1021
       1037
        
         snmpd = handleTest ./snmpd.nix {};

     

       1022
       1038
        
         smokeping = handleTest ./smokeping.nix {};

     

       1023
       1023
       -
         snapcast = handleTest ./snapcast.nix {};

     

       1039
       1039
       +
         snapcast = runTest ./snapcast.nix;

     

       1024
       1040
        
         snapper = handleTest ./snapper.nix {};

     

       1025
       1041
        
         snipe-it = runTest ./web-apps/snipe-it.nix;

     

       1026
       1042
        
         soapui = handleTest ./soapui.nix {};

+178 -177

nixos/tests/babeld.nix

···

       1
       1
       -
       import ./make-test-python.nix (

     

       2
       2
       -
         { pkgs, lib, ... }:

     

       3
       3
       -
         {

     

       4
       4
       -
           name = "babeld";

     

       5
       5
       -
           meta = with pkgs.lib.maintainers; {

     

       6
       6
       -
             maintainers = [ hexa ];

     

       7
       7
       -
           };

     

       1
       1
       +
       {

     

       2
       2
       +
         pkgs,

     

       3
       3
       +
         ...

     

       4
       4
       +
       }:

     

       5
       5
       +
       {

     

       6
       6
       +
         name = "babeld";

     

       7
       7
       +
         meta = with pkgs.lib.maintainers; {

     

       8
       8
       +
           maintainers = [ hexa ];

     

       9
       9
       +
         };

     

       8
       10
        
       

     

       9
       9
       -
           nodes = {

     

       10
       10
       -
             client =

     

       11
       11
       -
               { pkgs, lib, ... }:

     

       12
       12
       -
               {

     

       13
       13
       -
                 virtualisation.vlans = [ 10 ];

     

       11
       11
       +
         nodes = {

     

       12
       12
       +
           client =

     

       13
       13
       +
             { lib, ... }:

     

       14
       14
       +
             {

     

       15
       15
       +
               virtualisation.vlans = [ 10 ];

     

       14
       16
        
       

     

       15
       15
       -
                 networking = {

     

       16
       16
       -
                   useDHCP = false;

     

       17
       17
       -
                   interfaces."eth1" = {

     

       18
       18
       -
                     ipv4.addresses = lib.mkForce [

     

       19
       19
       -
                       {

     

       20
       20
       -
                         address = "192.168.10.2";

     

       21
       21
       -
                         prefixLength = 24;

     

       22
       22
       -
                       }

     

       23
       23
       -
                     ];

     

       24
       24
       -
                     ipv4.routes = lib.mkForce [

     

       25
       25
       -
                       {

     

       26
       26
       -
                         address = "0.0.0.0";

     

       27
       27
       -
                         prefixLength = 0;

     

       28
       28
       -
                         via = "192.168.10.1";

     

       29
       29
       -
                       }

     

       30
       30
       -
                     ];

     

       31
       31
       -
                     ipv6.addresses = lib.mkForce [

     

       32
       32
       -
                       {

     

       33
       33
       -
                         address = "2001:db8:10::2";

     

       34
       34
       -
                         prefixLength = 64;

     

       35
       35
       -
                       }

     

       36
       36
       -
                     ];

     

       37
       37
       -
                     ipv6.routes = lib.mkForce [

     

       38
       38
       -
                       {

     

       39
       39
       -
                         address = "::";

     

       40
       40
       -
                         prefixLength = 0;

     

       41
       41
       -
                         via = "2001:db8:10::1";

     

       42
       42
       -
                       }

     

       43
       43
       -
                     ];

     

       44
       44
       -
                   };

     

       17
       17
       +
               networking = {

     

       18
       18
       +
                 useDHCP = false;

     

       19
       19
       +
                 interfaces."eth1" = {

     

       20
       20
       +
                   ipv4.addresses = lib.mkForce [

     

       21
       21
       +
                     {

     

       22
       22
       +
                       address = "192.168.10.2";

     

       23
       23
       +
                       prefixLength = 24;

     

       24
       24
       +
                     }

     

       25
       25
       +
                   ];

     

       26
       26
       +
                   ipv4.routes = lib.mkForce [

     

       27
       27
       +
                     {

     

       28
       28
       +
                       address = "0.0.0.0";

     

       29
       29
       +
                       prefixLength = 0;

     

       30
       30
       +
                       via = "192.168.10.1";

     

       31
       31
       +
                     }

     

       32
       32
       +
                   ];

     

       33
       33
       +
                   ipv6.addresses = lib.mkForce [

     

       34
       34
       +
                     {

     

       35
       35
       +
                       address = "2001:db8:10::2";

     

       36
       36
       +
                       prefixLength = 64;

     

       37
       37
       +
                     }

     

       38
       38
       +
                   ];

     

       39
       39
       +
                   ipv6.routes = lib.mkForce [

     

       40
       40
       +
                     {

     

       41
       41
       +
                       address = "::";

     

       42
       42
       +
                       prefixLength = 0;

     

       43
       43
       +
                       via = "2001:db8:10::1";

     

       44
       44
       +
                     }

     

       45
       45
       +
                   ];

     

       45
       46
        
                 };

     

       46
       47
        
               };

     

       48
       48
       +
             };

     

       47
       49
        
       

     

       48
       48
       -
             local_router =

     

       49
       49
       -
               { pkgs, lib, ... }:

     

       50
       50
       -
               {

     

       51
       51
       -
                 virtualisation.vlans = [

     

       52
       52
       -
                   10

     

       53
       53
       -
                   20

     

       54
       54
       -
                 ];

     

       50
       50
       +
           local_router =

     

       51
       51
       +
             { lib, ... }:

     

       52
       52
       +
             {

     

       53
       53
       +
               virtualisation.vlans = [

     

       54
       54
       +
                 10

     

       55
       55
       +
                 20

     

       56
       56
       +
               ];

     

       55
       57
        
       

     

       56
       56
       -
                 networking = {

     

       57
       57
       -
                   useDHCP = false;

     

       58
       58
       -
                   firewall.enable = false;

     

       58
       58
       +
               networking = {

     

       59
       59
       +
                 useDHCP = false;

     

       60
       60
       +
                 firewall.enable = false;

     

       59
       61
        
       

     

       60
       60
       -
                   interfaces."eth1" = {

     

       61
       61
       -
                     ipv4.addresses = lib.mkForce [

     

       62
       62
       -
                       {

     

       63
       63
       -
                         address = "192.168.10.1";

     

       64
       64
       -
                         prefixLength = 24;

     

       65
       65
       -
                       }

     

       66
       66
       -
                     ];

     

       67
       67
       -
                     ipv6.addresses = lib.mkForce [

     

       68
       68
       -
                       {

     

       69
       69
       -
                         address = "2001:db8:10::1";

     

       70
       70
       -
                         prefixLength = 64;

     

       71
       71
       -
                       }

     

       72
       72
       -
                     ];

     

       73
       73
       -
                   };

     

       62
       62
       +
                 interfaces."eth1" = {

     

       63
       63
       +
                   ipv4.addresses = lib.mkForce [

     

       64
       64
       +
                     {

     

       65
       65
       +
                       address = "192.168.10.1";

     

       66
       66
       +
                       prefixLength = 24;

     

       67
       67
       +
                     }

     

       68
       68
       +
                   ];

     

       69
       69
       +
                   ipv6.addresses = lib.mkForce [

     

       70
       70
       +
                     {

     

       71
       71
       +
                       address = "2001:db8:10::1";

     

       72
       72
       +
                       prefixLength = 64;

     

       73
       73
       +
                     }

     

       74
       74
       +
                   ];

     

       75
       75
       +
                 };

     

       74
       76
        
       

     

       75
       75
       -
                   interfaces."eth2" = {

     

       76
       76
       -
                     ipv4.addresses = lib.mkForce [

     

       77
       77
       -
                       {

     

       78
       78
       -
                         address = "192.168.20.1";

     

       79
       79
       -
                         prefixLength = 24;

     

       80
       80
       -
                       }

     

       81
       81
       -
                     ];

     

       82
       82
       -
                     ipv6.addresses = lib.mkForce [

     

       83
       83
       -
                       {

     

       84
       84
       -
                         address = "2001:db8:20::1";

     

       85
       85
       -
                         prefixLength = 64;

     

       86
       86
       -
                       }

     

       87
       87
       -
                     ];

     

       88
       88
       -
                   };

     

       77
       77
       +
                 interfaces."eth2" = {

     

       78
       78
       +
                   ipv4.addresses = lib.mkForce [

     

       79
       79
       +
                     {

     

       80
       80
       +
                       address = "192.168.20.1";

     

       81
       81
       +
                       prefixLength = 24;

     

       82
       82
       +
                     }

     

       83
       83
       +
                   ];

     

       84
       84
       +
                   ipv6.addresses = lib.mkForce [

     

       85
       85
       +
                     {

     

       86
       86
       +
                       address = "2001:db8:20::1";

     

       87
       87
       +
                       prefixLength = 64;

     

       88
       88
       +
                     }

     

       89
       89
       +
                   ];

     

       89
       90
        
                 };

     

       91
       91
       +
               };

     

       90
       92
        
       

     

       91
       91
       -
                 services.babeld = {

     

       92
       92
       -
                   enable = true;

     

       93
       93
       -
                   interfaces.eth2 = {

     

       94
       94
       -
                     hello-interval = 1;

     

       95
       95
       -
                     type = "wired";

     

       96
       96
       -
                   };

     

       97
       97
       -
                   extraConfig = ''

     

       98
       98
       -
                     local-port-readwrite 33123

     

       93
       93
       +
               services.babeld = {

     

       94
       94
       +
                 enable = true;

     

       95
       95
       +
                 interfaces.eth2 = {

     

       96
       96
       +
                   hello-interval = 1;

     

       97
       97
       +
                   type = "wired";

     

       98
       98
       +
                 };

     

       99
       99
       +
                 extraConfig = ''

     

       100
       100
       +
                   local-port-readwrite 33123

     

       99
       101
        
       

     

       100
       100
       -
                     import-table 254 # main

     

       101
       101
       -
                     export-table 254 # main

     

       102
       102
       +
                   import-table 254 # main

     

       103
       103
       +
                   export-table 254 # main

     

       102
       104
        
       

     

       103
       103
       -
                     in ip 192.168.10.0/24 deny

     

       104
       104
       -
                     in ip 192.168.20.0/24 deny

     

       105
       105
       -
                     in ip 2001:db8:10::/64 deny

     

       106
       106
       -
                     in ip 2001:db8:20::/64 deny

     

       105
       105
       +
                   in ip 192.168.10.0/24 deny

     

       106
       106
       +
                   in ip 192.168.20.0/24 deny

     

       107
       107
       +
                   in ip 2001:db8:10::/64 deny

     

       108
       108
       +
                   in ip 2001:db8:20::/64 deny

     

       107
       109
        
       

     

       108
       108
       -
                     in ip 192.168.30.0/24 allow

     

       109
       109
       -
                     in ip 2001:db8:30::/64 allow

     

       110
       110
       +
                   in ip 192.168.30.0/24 allow

     

       111
       111
       +
                   in ip 2001:db8:30::/64 allow

     

       110
       112
        
       

     

       111
       111
       -
                     in deny

     

       113
       113
       +
                   in deny

     

       112
       114
        
       

     

       113
       113
       -
                     redistribute local proto 2

     

       114
       114
       -
                     redistribute local deny

     

       115
       115
       -
                   '';

     

       116
       116
       -
                 };

     

       115
       115
       +
                   redistribute local proto 2

     

       116
       116
       +
                   redistribute local deny

     

       117
       117
       +
                 '';

     

       117
       118
        
               };

     

       118
       118
       -
             remote_router =

     

       119
       119
       -
               { pkgs, lib, ... }:

     

       120
       120
       -
               {

     

       121
       121
       -
                 virtualisation.vlans = [

     

       122
       122
       -
                   20

     

       123
       123
       -
                   30

     

       124
       124
       -
                 ];

     

       119
       119
       +
             };

     

       120
       120
       +
           remote_router =

     

       121
       121
       +
             { lib, ... }:

     

       122
       122
       +
             {

     

       123
       123
       +
               virtualisation.vlans = [

     

       124
       124
       +
                 20

     

       125
       125
       +
                 30

     

       126
       126
       +
               ];

     

       125
       127
        
       

     

       126
       126
       -
                 networking = {

     

       127
       127
       -
                   useDHCP = false;

     

       128
       128
       -
                   firewall.enable = false;

     

       128
       128
       +
               networking = {

     

       129
       129
       +
                 useDHCP = false;

     

       130
       130
       +
                 firewall.enable = false;

     

       129
       131
        
       

     

       130
       130
       -
                   interfaces."eth1" = {

     

       131
       131
       -
                     ipv4.addresses = lib.mkForce [

     

       132
       132
       -
                       {

     

       133
       133
       -
                         address = "192.168.20.2";

     

       134
       134
       -
                         prefixLength = 24;

     

       135
       135
       -
                       }

     

       136
       136
       -
                     ];

     

       137
       137
       -
                     ipv6.addresses = lib.mkForce [

     

       138
       138
       -
                       {

     

       139
       139
       -
                         address = "2001:db8:20::2";

     

       140
       140
       -
                         prefixLength = 64;

     

       141
       141
       -
                       }

     

       142
       142
       -
                     ];

     

       143
       143
       -
                   };

     

       132
       132
       +
                 interfaces."eth1" = {

     

       133
       133
       +
                   ipv4.addresses = lib.mkForce [

     

       134
       134
       +
                     {

     

       135
       135
       +
                       address = "192.168.20.2";

     

       136
       136
       +
                       prefixLength = 24;

     

       137
       137
       +
                     }

     

       138
       138
       +
                   ];

     

       139
       139
       +
                   ipv6.addresses = lib.mkForce [

     

       140
       140
       +
                     {

     

       141
       141
       +
                       address = "2001:db8:20::2";

     

       142
       142
       +
                       prefixLength = 64;

     

       143
       143
       +
                     }

     

       144
       144
       +
                   ];

     

       145
       145
       +
                 };

     

       144
       146
        
       

     

       145
       145
       -
                   interfaces."eth2" = {

     

       146
       146
       -
                     ipv4.addresses = lib.mkForce [

     

       147
       147
       -
                       {

     

       148
       148
       -
                         address = "192.168.30.1";

     

       149
       149
       -
                         prefixLength = 24;

     

       150
       150
       -
                       }

     

       151
       151
       -
                     ];

     

       152
       152
       -
                     ipv6.addresses = lib.mkForce [

     

       153
       153
       -
                       {

     

       154
       154
       -
                         address = "2001:db8:30::1";

     

       155
       155
       -
                         prefixLength = 64;

     

       156
       156
       -
                       }

     

       157
       157
       -
                     ];

     

       158
       158
       -
                   };

     

       147
       147
       +
                 interfaces."eth2" = {

     

       148
       148
       +
                   ipv4.addresses = lib.mkForce [

     

       149
       149
       +
                     {

     

       150
       150
       +
                       address = "192.168.30.1";

     

       151
       151
       +
                       prefixLength = 24;

     

       152
       152
       +
                     }

     

       153
       153
       +
                   ];

     

       154
       154
       +
                   ipv6.addresses = lib.mkForce [

     

       155
       155
       +
                     {

     

       156
       156
       +
                       address = "2001:db8:30::1";

     

       157
       157
       +
                       prefixLength = 64;

     

       158
       158
       +
                     }

     

       159
       159
       +
                   ];

     

       159
       160
        
                 };

     

       160
       160
       -
       

     

       161
       161
       -
                 services.babeld = {

     

       162
       162
       -
                   enable = true;

     

       163
       163
       -
                   interfaces.eth1 = {

     

       164
       164
       -
                     hello-interval = 1;

     

       165
       165
       -
                     type = "wired";

     

       166
       166
       -
                   };

     

       167
       167
       -
                   extraConfig = ''

     

       168
       168
       -
                     local-port-readwrite 33123

     

       161
       161
       +
               };

     

       169
       162
        
       

     

       170
       170
       -
                     import-table 254 # main

     

       171
       171
       -
                     export-table 254 # main

     

       163
       163
       +
               services.babeld = {

     

       164
       164
       +
                 enable = true;

     

       165
       165
       +
                 interfaces.eth1 = {

     

       166
       166
       +
                   hello-interval = 1;

     

       167
       167
       +
                   type = "wired";

     

       168
       168
       +
                 };

     

       169
       169
       +
                 extraConfig = ''

     

       170
       170
       +
                   local-port-readwrite 33123

     

       172
       171
        
       

     

       173
       173
       -
                     in ip 192.168.20.0/24 deny

     

       174
       174
       -
                     in ip 192.168.30.0/24 deny

     

       175
       175
       -
                     in ip 2001:db8:20::/64 deny

     

       176
       176
       -
                     in ip 2001:db8:30::/64 deny

     

       172
       172
       +
                   import-table 254 # main

     

       173
       173
       +
                   export-table 254 # main

     

       177
       174
        
       

     

       178
       178
       -
                     in ip 192.168.10.0/24 allow

     

       179
       179
       -
                     in ip 2001:db8:10::/64 allow

     

       175
       175
       +
                   in ip 192.168.20.0/24 deny

     

       176
       176
       +
                   in ip 192.168.30.0/24 deny

     

       177
       177
       +
                   in ip 2001:db8:20::/64 deny

     

       178
       178
       +
                   in ip 2001:db8:30::/64 deny

     

       180
       179
        
       

     

       181
       181
       -
                     in deny

     

       180
       180
       +
                   in ip 192.168.10.0/24 allow

     

       181
       181
       +
                   in ip 2001:db8:10::/64 allow

     

       182
       182
        
       

     

       183
       183
       -
                     redistribute local proto 2

     

       184
       184
       -
                     redistribute local deny

     

       185
       185
       -
                   '';

     

       186
       186
       -
                 };

     

       183
       183
       +
                   in deny

     

       187
       184
        
       

     

       185
       185
       +
                   redistribute local proto 2

     

       186
       186
       +
                   redistribute local deny

     

       187
       187
       +
                 '';

     

       188
       188
        
               };

     

       189
       189
       -
           };

     

       190
       189
        
       

     

       191
       191
       -
           testScript = ''

     

       192
       192
       -
             start_all()

     

       190
       190
       +
             };

     

       191
       191
       +
         };

     

       193
       192
        
       

     

       194
       194
       -
             local_router.wait_for_unit("babeld.service")

     

       195
       195
       -
             remote_router.wait_for_unit("babeld.service")

     

       193
       193
       +
         testScript = ''

     

       194
       194
       +
           start_all()

     

       196
       195
        
       

     

       197
       197
       -
             local_router.wait_until_succeeds("ip route get 192.168.30.1")

     

       198
       198
       -
             local_router.wait_until_succeeds("ip route get 2001:db8:30::1")

     

       196
       196
       +
           local_router.wait_for_unit("babeld.service")

     

       197
       197
       +
           remote_router.wait_for_unit("babeld.service")

     

       199
       198
        
       

     

       200
       200
       -
             remote_router.wait_until_succeeds("ip route get 192.168.10.1")

     

       201
       201
       -
             remote_router.wait_until_succeeds("ip route get 2001:db8:10::1")

     

       199
       199
       +
           local_router.wait_until_succeeds("ip route get 192.168.30.1")

     

       200
       200
       +
           local_router.wait_until_succeeds("ip route get 2001:db8:30::1")

     

       202
       201
        
       

     

       203
       203
       -
             client.succeed("ping -c1 192.168.30.1")

     

       204
       204
       -
             client.succeed("ping -c1 2001:db8:30::1")

     

       202
       202
       +
           remote_router.wait_until_succeeds("ip route get 192.168.10.1")

     

       203
       203
       +
           remote_router.wait_until_succeeds("ip route get 2001:db8:10::1")

     

       205
       204
        
       

     

       206
       206
       -
             remote_router.succeed("ping -c1 192.168.10.2")

     

       207
       207
       -
             remote_router.succeed("ping -c1 2001:db8:10::2")

     

       208
       208
       -
           '';

     

       209
       209
       -
         }

     

       210
       210
       -
       )

     

       205
       205
       +
           client.succeed("ping -c1 192.168.30.1")

     

       206
       206
       +
           client.succeed("ping -c1 2001:db8:30::1")

     

       207
       207
       +
       

     

       208
       208
       +
           remote_router.succeed("ping -c1 192.168.10.2")

     

       209
       209
       +
           remote_router.succeed("ping -c1 2001:db8:10::2")

     

       210
       210
       +
         '';

     

       211
       211
       +
       }

+45 -43

nixos/tests/botamusique.nix

···

       1
       1
       -
       import ./make-test-python.nix (

     

       2
       2
       -
         { pkgs, lib, ... }:

     

       1
       1
       +
       {

     

       2
       2
       +
         pkgs,

     

       3
       3
       +
         lib,

     

       4
       4
       +
         ...

     

       5
       5
       +
       }:

     

       3
       6
        
       

     

       4
       4
       -
         {

     

       5
       5
       -
           name = "botamusique";

     

       6
       6
       -
           meta.maintainers = with lib.maintainers; [ hexa ];

     

       7
       7
       +
       {

     

       8
       8
       +
         name = "botamusique";

     

       9
       9
       +
         meta.maintainers = with lib.maintainers; [ hexa ];

     

       7
       10
        
       

     

       8
       8
       -
           nodes = {

     

       9
       9
       -
             machine =

     

       10
       10
       -
               { config, ... }:

     

       11
       11
       -
               {

     

       12
       12
       -
                 networking.extraHosts = ''

     

       13
       13
       -
                   127.0.0.1 all.api.radio-browser.info

     

       14
       14
       -
                 '';

     

       11
       11
       +
         nodes = {

     

       12
       12
       +
           machine =

     

       13
       13
       +
             { config, ... }:

     

       14
       14
       +
             {

     

       15
       15
       +
               networking.extraHosts = ''

     

       16
       16
       +
                 127.0.0.1 all.api.radio-browser.info

     

       17
       17
       +
               '';

     

       15
       18
        
       

     

       16
       16
       -
                 services.murmur = {

     

       17
       17
       -
                   enable = true;

     

       18
       18
       -
                   registerName = "NixOS tests";

     

       19
       19
       -
                 };

     

       19
       19
       +
               services.murmur = {

     

       20
       20
       +
                 enable = true;

     

       21
       21
       +
                 registerName = "NixOS tests";

     

       22
       22
       +
               };

     

       20
       23
        
       

     

       21
       21
       -
                 services.botamusique = {

     

       22
       22
       -
                   enable = true;

     

       23
       23
       -
                   settings = {

     

       24
       24
       -
                     server = {

     

       25
       25
       -
                       channel = "NixOS tests";

     

       26
       26
       -
                     };

     

       27
       27
       -
                     bot = {

     

       28
       28
       -
                       version = false;

     

       29
       29
       -
                       auto_check_update = false;

     

       30
       30
       -
                     };

     

       24
       24
       +
               services.botamusique = {

     

       25
       25
       +
                 enable = true;

     

       26
       26
       +
                 settings = {

     

       27
       27
       +
                   server = {

     

       28
       28
       +
                     channel = "NixOS tests";

     

       29
       29
       +
                   };

     

       30
       30
       +
                   bot = {

     

       31
       31
       +
                     version = false;

     

       32
       32
       +
                     auto_check_update = false;

     

       31
       33
        
                   };

     

       32
       34
        
                 };

     

       33
       35
        
               };

     

       34
       34
       -
           };

     

       36
       36
       +
             };

     

       37
       37
       +
         };

     

       35
       38
        
       

     

       36
       36
       -
           testScript = ''

     

       37
       37
       -
             start_all()

     

       39
       39
       +
         testScript = ''

     

       40
       40
       +
           start_all()

     

       38
       41
        
       

     

       39
       39
       -
             machine.wait_for_unit("murmur.service")

     

       40
       40
       -
             machine.wait_for_unit("botamusique.service")

     

       42
       42
       +
           machine.wait_for_unit("murmur.service")

     

       43
       43
       +
           machine.wait_for_unit("botamusique.service")

     

       41
       44
        
       

     

       42
       42
       -
             machine.sleep(10)

     

       45
       45
       +
           machine.sleep(10)

     

       43
       46
        
       

     

       44
       44
       -
             machine.wait_until_succeeds(

     

       45
       45
       -
                 "journalctl -u murmur.service -e | grep -q '<1:botamusique(-1)> Authenticated'"

     

       46
       46
       -
             )

     

       47
       47
       +
           machine.wait_until_succeeds(

     

       48
       48
       +
               "journalctl -u murmur.service -e | grep -q '<1:botamusique(-1)> Authenticated'"

     

       49
       49
       +
           )

     

       47
       50
        
       

     

       48
       48
       -
             with subtest("Check systemd hardening"):

     

       49
       49
       -
                 output = machine.execute("systemctl show botamusique.service")[1]

     

       50
       50
       -
                 machine.log(output)

     

       51
       51
       -
                 output = machine.execute("systemd-analyze security botamusique.service")[1]

     

       52
       52
       -
                 machine.log(output)

     

       53
       53
       -
           '';

     

       54
       54
       -
         }

     

       55
       55
       -
       )

     

       51
       51
       +
           with subtest("Check systemd hardening"):

     

       52
       52
       +
               output = machine.execute("systemctl show botamusique.service")[1]

     

       53
       53
       +
               machine.log(output)

     

       54
       54
       +
               output = machine.execute("systemd-analyze security botamusique.service")[1]

     

       55
       55
       +
               machine.log(output)

     

       56
       56
       +
         '';

     

       57
       57
       +
       }

+14 -6

nixos/tests/firefox.nix

···

       1
       1
       -
       import ./make-test-python.nix ({ lib, pkgs, firefoxPackage, ... }:

     

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         pkgs,

     

       4
       4
       +
         firefoxPackage,

     

       5
       5
       +
         ...

     

       6
       6
       +
       }:

     

       2
       7
        
       {

     

       3
       8
        
         name = firefoxPackage.pname;

     

       4
       9
        
       

     
···

       9
       14
        
         nodes.machine =

     

       10
       15
        
           { pkgs, ... }:

     

       11
       16
        
       

     

       12
       12
       -
           { imports = [ ./common/x11.nix ];

     

       17
       17
       +
           {

     

       18
       18
       +
             imports = [ ./common/x11.nix ];

     

       13
       19
        
             environment.systemPackages = [ pkgs.xdotool ];

     

       14
       20
        
       

     

       15
       21
        
             programs.firefox = {

     
···

       31
       37
        
       

     

       32
       38
        
           };

     

       33
       39
        
       

     

       34
       34
       -
         testScript = let

     

       35
       35
       -
           exe = lib.getExe firefoxPackage;

     

       36
       36
       -
         in ''

     

       40
       40
       +
         testScript =

     

       41
       41
       +
           let

     

       42
       42
       +
             exe = lib.getExe firefoxPackage;

     

       43
       43
       +
           in

     

       44
       44
       +
           ''

     

       37
       45
        
             from contextlib import contextmanager

     

       38
       46
        
       

     

       39
       47
        
       

     
···

       97
       105
        
                 machine.screenshot("screen")

     

       98
       106
        
           '';

     

       99
       107
        
       

     

       100
       100
       -
       })

     

       108
       108
       +
       }

+48 -47

nixos/tests/go-neb.nix

···

       1
       1
       -
       import ./make-test-python.nix (

     

       2
       2
       -
         { pkgs, ... }:

     

       3
       3
       -
         {

     

       4
       4
       -
           name = "go-neb";

     

       5
       5
       -
           meta = with pkgs.lib.maintainers; {

     

       6
       6
       -
             maintainers = [

     

       7
       7
       -
               hexa

     

       8
       8
       -
               maralorn

     

       9
       9
       -
             ];

     

       10
       10
       -
           };

     

       1
       1
       +
       {

     

       2
       2
       +
         pkgs,

     

       3
       3
       +
         ...

     

       4
       4
       +
       }:

     

       5
       5
       +
       {

     

       6
       6
       +
         name = "go-neb";

     

       7
       7
       +
         meta = with pkgs.lib.maintainers; {

     

       8
       8
       +
           maintainers = [

     

       9
       9
       +
             hexa

     

       10
       10
       +
             maralorn

     

       11
       11
       +
           ];

     

       12
       12
       +
         };

     

       11
       13
        
       

     

       12
       12
       -
           nodes = {

     

       13
       13
       -
             server = {

     

       14
       14
       -
               services.go-neb = {

     

       15
       15
       -
                 enable = true;

     

       16
       16
       -
                 baseUrl = "http://localhost";

     

       17
       17
       -
                 secretFile = pkgs.writeText "secrets" "ACCESS_TOKEN=changeme";

     

       18
       18
       -
                 config = {

     

       19
       19
       -
                   clients = [

     

       20
       20
       -
                     {

     

       21
       21
       -
                       UserId = "@test:localhost";

     

       22
       22
       -
                       AccessToken = "$ACCESS_TOKEN";

     

       23
       23
       -
                       HomeServerUrl = "http://localhost";

     

       24
       24
       -
                       Sync = false;

     

       25
       25
       -
                       AutoJoinRooms = false;

     

       26
       26
       -
                       DisplayName = "neverbeseen";

     

       27
       27
       -
                     }

     

       28
       28
       -
                   ];

     

       29
       29
       -
                   services = [

     

       30
       30
       -
                     {

     

       31
       31
       -
                       ID = "wikipedia_service";

     

       32
       32
       -
                       Type = "wikipedia";

     

       33
       33
       -
                       UserID = "@test:localhost";

     

       34
       34
       -
                       Config = { };

     

       35
       35
       -
                     }

     

       36
       36
       -
                   ];

     

       37
       37
       -
                 };

     

       14
       14
       +
         nodes = {

     

       15
       15
       +
           server = {

     

       16
       16
       +
             services.go-neb = {

     

       17
       17
       +
               enable = true;

     

       18
       18
       +
               baseUrl = "http://localhost";

     

       19
       19
       +
               secretFile = pkgs.writeText "secrets" "ACCESS_TOKEN=changeme";

     

       20
       20
       +
               config = {

     

       21
       21
       +
                 clients = [

     

       22
       22
       +
                   {

     

       23
       23
       +
                     UserId = "@test:localhost";

     

       24
       24
       +
                     AccessToken = "$ACCESS_TOKEN";

     

       25
       25
       +
                     HomeServerUrl = "http://localhost";

     

       26
       26
       +
                     Sync = false;

     

       27
       27
       +
                     AutoJoinRooms = false;

     

       28
       28
       +
                     DisplayName = "neverbeseen";

     

       29
       29
       +
                   }

     

       30
       30
       +
                 ];

     

       31
       31
       +
                 services = [

     

       32
       32
       +
                   {

     

       33
       33
       +
                     ID = "wikipedia_service";

     

       34
       34
       +
                     Type = "wikipedia";

     

       35
       35
       +
                     UserID = "@test:localhost";

     

       36
       36
       +
                     Config = { };

     

       37
       37
       +
                   }

     

       38
       38
       +
                 ];

     

       38
       39
        
               };

     

       39
       40
        
             };

     

       40
       41
        
           };

     

       42
       42
       +
         };

     

       41
       43
        
       

     

       42
       42
       -
           testScript = ''

     

       43
       43
       -
             start_all()

     

       44
       44
       -
             server.wait_for_unit("go-neb.service")

     

       45
       45
       -
             server.wait_until_succeeds("curl -fL http://localhost:4050/services/hooks/d2lraXBlZGlhX3NlcnZpY2U")

     

       46
       46
       -
             server.succeed(

     

       47
       47
       -
                 "journalctl -eu go-neb -o cat | grep -q service_id=wikipedia_service",

     

       48
       48
       -
                 "grep -q changeme /var/run/go-neb/config.yaml",

     

       49
       49
       -
             )

     

       50
       50
       -
           '';

     

       44
       44
       +
         testScript = ''

     

       45
       45
       +
           start_all()

     

       46
       46
       +
           server.wait_for_unit("go-neb.service")

     

       47
       47
       +
           server.wait_until_succeeds("curl -fL http://localhost:4050/services/hooks/d2lraXBlZGlhX3NlcnZpY2U")

     

       48
       48
       +
           server.succeed(

     

       49
       49
       +
               "journalctl -eu go-neb -o cat | grep -q service_id=wikipedia_service",

     

       50
       50
       +
               "grep -q changeme /var/run/go-neb/config.yaml",

     

       51
       51
       +
           )

     

       52
       52
       +
         '';

     

       51
       53
        
       

     

       52
       52
       -
         }

     

       53
       53
       -
       )

     

       54
       54
       +
       }

+186 -184

nixos/tests/kea.nix

···

       5
       5
        
       # that the nameserver can resolve the clients fqdn to the correct IP

     

       6
       6
        
       # address.

     

       7
       7
        
       

     

       8
       8
       -
       import ./make-test-python.nix (

     

       9
       9
       -
         { pkgs, lib, ... }:

     

       10
       10
       -
         {

     

       11
       11
       -
           meta.maintainers = with lib.maintainers; [ hexa ];

     

       8
       8
       +
       {

     

       9
       9
       +
         pkgs,

     

       10
       10
       +
         lib,

     

       11
       11
       +
         ...

     

       12
       12
       +
       }:

     

       13
       13
       +
       {

     

       14
       14
       +
         meta.maintainers = with lib.maintainers; [ hexa ];

     

       12
       15
        
       

     

       13
       13
       -
           name = "kea";

     

       16
       16
       +
         name = "kea";

     

       14
       17
        
       

     

       15
       15
       -
           nodes = {

     

       16
       16
       -
             router =

     

       17
       17
       -
               { config, pkgs, ... }:

     

       18
       18
       -
               {

     

       19
       19
       -
                 virtualisation.vlans = [ 1 ];

     

       18
       18
       +
         nodes = {

     

       19
       19
       +
           router =

     

       20
       20
       +
             { config, pkgs, ... }:

     

       21
       21
       +
             {

     

       22
       22
       +
               virtualisation.vlans = [ 1 ];

     

       20
       23
        
       

     

       21
       21
       -
                 networking = {

     

       22
       22
       -
                   useDHCP = false;

     

       23
       23
       -
                   firewall.allowedUDPPorts = [ 67 ];

     

       24
       24
       -
                 };

     

       24
       24
       +
               networking = {

     

       25
       25
       +
                 useDHCP = false;

     

       26
       26
       +
                 firewall.allowedUDPPorts = [ 67 ];

     

       27
       27
       +
               };

     

       25
       28
        
       

     

       26
       26
       -
                 systemd.network = {

     

       27
       27
       -
                   enable = true;

     

       28
       28
       -
                   networks = {

     

       29
       29
       -
                     "01-eth1" = {

     

       30
       30
       -
                       name = "eth1";

     

       31
       31
       -
                       networkConfig = {

     

       32
       32
       -
                         Address = "10.0.0.1/29";

     

       33
       33
       -
                       };

     

       29
       29
       +
               systemd.network = {

     

       30
       30
       +
                 enable = true;

     

       31
       31
       +
                 networks = {

     

       32
       32
       +
                   "01-eth1" = {

     

       33
       33
       +
                     name = "eth1";

     

       34
       34
       +
                     networkConfig = {

     

       35
       35
       +
                       Address = "10.0.0.1/29";

     

       34
       36
        
                     };

     

       35
       37
        
                   };

     

       36
       38
        
                 };

     

       39
       39
       +
               };

     

       37
       40
        
       

     

       38
       38
       -
                 services.kea.dhcp4 = {

     

       39
       39
       -
                   enable = true;

     

       40
       40
       -
                   settings = {

     

       41
       41
       -
                     valid-lifetime = 3600;

     

       42
       42
       -
                     renew-timer = 900;

     

       43
       43
       -
                     rebind-timer = 1800;

     

       41
       41
       +
               services.kea.dhcp4 = {

     

       42
       42
       +
                 enable = true;

     

       43
       43
       +
                 settings = {

     

       44
       44
       +
                   valid-lifetime = 3600;

     

       45
       45
       +
                   renew-timer = 900;

     

       46
       46
       +
                   rebind-timer = 1800;

     

       44
       47
        
       

     

       45
       45
       -
                     lease-database = {

     

       46
       46
       -
                       type = "memfile";

     

       47
       47
       -
                       persist = true;

     

       48
       48
       -
                       name = "/var/lib/kea/dhcp4.leases";

     

       49
       49
       -
                     };

     

       48
       48
       +
                   lease-database = {

     

       49
       49
       +
                     type = "memfile";

     

       50
       50
       +
                     persist = true;

     

       51
       51
       +
                     name = "/var/lib/kea/dhcp4.leases";

     

       52
       52
       +
                   };

     

       50
       53
        
       

     

       51
       51
       -
                     control-socket = {

     

       52
       52
       -
                       socket-type = "unix";

     

       53
       53
       -
                       socket-name = "/run/kea/dhcp4.sock";

     

       54
       54
       -
                     };

     

       54
       54
       +
                   control-socket = {

     

       55
       55
       +
                     socket-type = "unix";

     

       56
       56
       +
                     socket-name = "/run/kea/dhcp4.sock";

     

       57
       57
       +
                   };

     

       58
       58
       +
       

     

       59
       59
       +
                   interfaces-config = {

     

       60
       60
       +
                     dhcp-socket-type = "raw";

     

       61
       61
       +
                     interfaces = [

     

       62
       62
       +
                       "eth1"

     

       63
       63
       +
                     ];

     

       64
       64
       +
                   };

     

       55
       65
        
       

     

       56
       56
       -
                     interfaces-config = {

     

       57
       57
       -
                       dhcp-socket-type = "raw";

     

       58
       58
       -
                       interfaces = [

     

       59
       59
       -
                         "eth1"

     

       66
       66
       +
                   subnet4 = [

     

       67
       67
       +
                     {

     

       68
       68
       +
                       id = 1;

     

       69
       69
       +
                       subnet = "10.0.0.0/29";

     

       70
       70
       +
                       pools = [

     

       71
       71
       +
                         {

     

       72
       72
       +
                           pool = "10.0.0.3 - 10.0.0.3";

     

       73
       73
       +
                         }

     

       60
       74
        
                       ];

     

       61
       61
       -
                     };

     

       75
       75
       +
                     }

     

       76
       76
       +
                   ];

     

       77
       77
       +
       

     

       78
       78
       +
                   # Enable communication between dhcp4 and a local dhcp-ddns

     

       79
       79
       +
                   # instance.

     

       80
       80
       +
                   # https://kea.readthedocs.io/en/kea-2.2.0/arm/dhcp4-srv.html#ddns-for-dhcpv4

     

       81
       81
       +
                   dhcp-ddns = {

     

       82
       82
       +
                     enable-updates = true;

     

       83
       83
       +
                   };

     

       84
       84
       +
       

     

       85
       85
       +
                   ddns-send-updates = true;

     

       86
       86
       +
                   ddns-qualifying-suffix = "lan.nixos.test.";

     

       87
       87
       +
                 };

     

       88
       88
       +
               };

     

       62
       89
        
       

     

       63
       63
       -
                     subnet4 = [

     

       90
       90
       +
               services.kea.dhcp-ddns = {

     

       91
       91
       +
                 enable = true;

     

       92
       92
       +
                 settings = {

     

       93
       93
       +
                   forward-ddns = {

     

       94
       94
       +
                     # Configure updates of a forward zone named `lan.nixos.test`

     

       95
       95
       +
                     # hosted at the nameserver at 10.0.0.2

     

       96
       96
       +
                     # https://kea.readthedocs.io/en/kea-2.2.0/arm/ddns.html#adding-forward-dns-servers

     

       97
       97
       +
                     ddns-domains = [

     

       64
       98
        
                       {

     

       65
       65
       -
                         id = 1;

     

       66
       66
       -
                         subnet = "10.0.0.0/29";

     

       67
       67
       -
                         pools = [

     

       99
       99
       +
                         name = "lan.nixos.test.";

     

       100
       100
       +
                         # Use a TSIG key in production!

     

       101
       101
       +
                         key-name = "";

     

       102
       102
       +
                         dns-servers = [

     

       68
       103
        
                           {

     

       69
       69
       -
                             pool = "10.0.0.3 - 10.0.0.3";

     

       104
       104
       +
                             ip-address = "10.0.0.2";

     

       105
       105
       +
                             port = 53;

     

       70
       106
        
                           }

     

       71
       107
        
                         ];

     

       72
       108
        
                       }

     

       73
       109
        
                     ];

     

       74
       74
       -
       

     

       75
       75
       -
                     # Enable communication between dhcp4 and a local dhcp-ddns

     

       76
       76
       -
                     # instance.

     

       77
       77
       -
                     # https://kea.readthedocs.io/en/kea-2.2.0/arm/dhcp4-srv.html#ddns-for-dhcpv4

     

       78
       78
       -
                     dhcp-ddns = {

     

       79
       79
       -
                       enable-updates = true;

     

       80
       80
       -
                     };

     

       81
       81
       -
       

     

       82
       82
       -
                     ddns-send-updates = true;

     

       83
       83
       -
                     ddns-qualifying-suffix = "lan.nixos.test.";

     

       84
       110
        
                   };

     

       85
       111
        
                 };

     

       86
       86
       -
       

     

       87
       87
       -
                 services.kea.dhcp-ddns = {

     

       88
       88
       -
                   enable = true;

     

       89
       89
       -
                   settings = {

     

       90
       90
       -
                     forward-ddns = {

     

       91
       91
       -
                       # Configure updates of a forward zone named `lan.nixos.test`

     

       92
       92
       -
                       # hosted at the nameserver at 10.0.0.2

     

       93
       93
       -
                       # https://kea.readthedocs.io/en/kea-2.2.0/arm/ddns.html#adding-forward-dns-servers

     

       94
       94
       -
                       ddns-domains = [

     

       95
       95
       -
                         {

     

       96
       96
       -
                           name = "lan.nixos.test.";

     

       97
       97
       -
                           # Use a TSIG key in production!

     

       98
       98
       -
                           key-name = "";

     

       99
       99
       -
                           dns-servers = [

     

       100
       100
       -
                             {

     

       101
       101
       -
                               ip-address = "10.0.0.2";

     

       102
       102
       -
                               port = 53;

     

       103
       103
       -
                             }

     

       104
       104
       -
                           ];

     

       105
       105
       -
                         }

     

       106
       106
       -
                       ];

     

       107
       107
       -
                     };

     

       108
       108
       -
                   };

     

       109
       109
       -
                 };

     

       112
       112
       +
               };

     

       110
       113
        
       

     

       111
       111
       -
                 services.kea.ctrl-agent = {

     

       112
       112
       -
                   enable = true;

     

       113
       113
       -
                   settings = {

     

       114
       114
       -
                     http-host = "127.0.0.1";

     

       115
       115
       -
                     http-port = 8000;

     

       116
       116
       -
                     control-sockets.dhcp4 = {

     

       117
       117
       -
                       socket-type = "unix";

     

       118
       118
       -
                       socket-name = "/run/kea/dhcp4.sock";

     

       119
       119
       -
                     };

     

       114
       114
       +
               services.kea.ctrl-agent = {

     

       115
       115
       +
                 enable = true;

     

       116
       116
       +
                 settings = {

     

       117
       117
       +
                   http-host = "127.0.0.1";

     

       118
       118
       +
                   http-port = 8000;

     

       119
       119
       +
                   control-sockets.dhcp4 = {

     

       120
       120
       +
                     socket-type = "unix";

     

       121
       121
       +
                     socket-name = "/run/kea/dhcp4.sock";

     

       120
       122
        
                   };

     

       121
       123
        
                 };

     

       124
       124
       +
               };

     

       122
       125
        
       

     

       123
       123
       -
                 services.prometheus.exporters.kea = {

     

       124
       124
       -
                   enable = true;

     

       125
       125
       -
                   controlSocketPaths = [

     

       126
       126
       -
                     "http://127.0.0.1:8000"

     

       127
       127
       -
                   ];

     

       128
       128
       -
                 };

     

       126
       126
       +
               services.prometheus.exporters.kea = {

     

       127
       127
       +
                 enable = true;

     

       128
       128
       +
                 controlSocketPaths = [

     

       129
       129
       +
                   "http://127.0.0.1:8000"

     

       130
       130
       +
                 ];

     

       129
       131
        
               };

     

       132
       132
       +
             };

     

       130
       133
        
       

     

       131
       131
       -
             nameserver =

     

       132
       132
       -
               { config, pkgs, ... }:

     

       133
       133
       -
               {

     

       134
       134
       -
                 virtualisation.vlans = [ 1 ];

     

       134
       134
       +
           nameserver =

     

       135
       135
       +
             { config, pkgs, ... }:

     

       136
       136
       +
             {

     

       137
       137
       +
               virtualisation.vlans = [ 1 ];

     

       135
       138
        
       

     

       136
       136
       -
                 networking = {

     

       137
       137
       -
                   useDHCP = false;

     

       138
       138
       -
                   firewall.allowedUDPPorts = [ 53 ];

     

       139
       139
       -
                 };

     

       139
       139
       +
               networking = {

     

       140
       140
       +
                 useDHCP = false;

     

       141
       141
       +
                 firewall.allowedUDPPorts = [ 53 ];

     

       142
       142
       +
               };

     

       140
       143
        
       

     

       141
       141
       -
                 systemd.network = {

     

       142
       142
       -
                   enable = true;

     

       143
       143
       -
                   networks = {

     

       144
       144
       -
                     "01-eth1" = {

     

       145
       145
       -
                       name = "eth1";

     

       146
       146
       -
                       networkConfig = {

     

       147
       147
       -
                         Address = "10.0.0.2/29";

     

       148
       148
       -
                       };

     

       144
       144
       +
               systemd.network = {

     

       145
       145
       +
                 enable = true;

     

       146
       146
       +
                 networks = {

     

       147
       147
       +
                   "01-eth1" = {

     

       148
       148
       +
                     name = "eth1";

     

       149
       149
       +
                     networkConfig = {

     

       150
       150
       +
                       Address = "10.0.0.2/29";

     

       149
       151
        
                     };

     

       150
       152
        
                   };

     

       151
       153
        
                 };

     

       154
       154
       +
               };

     

       152
       155
        
       

     

       153
       153
       -
                 services.resolved.enable = false;

     

       156
       156
       +
               services.resolved.enable = false;

     

       154
       157
        
       

     

       155
       155
       -
                 # Set up an authoritative nameserver, serving the `lan.nixos.test`

     

       156
       156
       -
                 # zone and configure an ACL that allows dynamic updates from

     

       157
       157
       -
                 # the router's ip address.

     

       158
       158
       -
                 # This ACL is likely insufficient for production usage. Please

     

       159
       159
       -
                 # use TSIG keys.

     

       160
       160
       -
                 services.knot =

     

       161
       161
       -
                   let

     

       162
       162
       -
                     zone = pkgs.writeTextDir "lan.nixos.test.zone" ''

     

       163
       163
       -
                       @ SOA ns.nixos.test nox.nixos.test 0 86400 7200 3600000 172800

     

       164
       164
       -
                       @ NS nameserver

     

       165
       165
       -
                       nameserver A 10.0.0.3

     

       166
       166
       -
                       router A 10.0.0.1

     

       167
       167
       -
                     '';

     

       168
       168
       -
                     zonesDir = pkgs.buildEnv {

     

       169
       169
       -
                       name = "knot-zones";

     

       170
       170
       -
                       paths = [ zone ];

     

       171
       171
       -
                     };

     

       172
       172
       -
                   in

     

       173
       173
       -
                   {

     

       174
       174
       -
                     enable = true;

     

       175
       175
       -
                     extraArgs = [

     

       176
       176
       -
                       "-v"

     

       158
       158
       +
               # Set up an authoritative nameserver, serving the `lan.nixos.test`

     

       159
       159
       +
               # zone and configure an ACL that allows dynamic updates from

     

       160
       160
       +
               # the router's ip address.

     

       161
       161
       +
               # This ACL is likely insufficient for production usage. Please

     

       162
       162
       +
               # use TSIG keys.

     

       163
       163
       +
               services.knot =

     

       164
       164
       +
                 let

     

       165
       165
       +
                   zone = pkgs.writeTextDir "lan.nixos.test.zone" ''

     

       166
       166
       +
                     @ SOA ns.nixos.test nox.nixos.test 0 86400 7200 3600000 172800

     

       167
       167
       +
                     @ NS nameserver

     

       168
       168
       +
                     nameserver A 10.0.0.3

     

       169
       169
       +
                     router A 10.0.0.1

     

       170
       170
       +
                   '';

     

       171
       171
       +
                   zonesDir = pkgs.buildEnv {

     

       172
       172
       +
                     name = "knot-zones";

     

       173
       173
       +
                     paths = [ zone ];

     

       174
       174
       +
                   };

     

       175
       175
       +
                 in

     

       176
       176
       +
                 {

     

       177
       177
       +
                   enable = true;

     

       178
       178
       +
                   extraArgs = [

     

       179
       179
       +
                     "-v"

     

       180
       180
       +
                   ];

     

       181
       181
       +
                   settings = {

     

       182
       182
       +
                     server.listen = [

     

       183
       183
       +
                       "0.0.0.0@53"

     

       177
       184
        
                     ];

     

       178
       178
       -
                     settings = {

     

       179
       179
       -
                       server.listen = [

     

       180
       180
       -
                         "0.0.0.0@53"

     

       181
       181
       -
                       ];

     

       182
       185
        
       

     

       183
       183
       -
                       log.syslog.any = "info";

     

       186
       186
       +
                     log.syslog.any = "info";

     

       184
       187
        
       

     

       185
       185
       -
                       acl.dhcp_ddns = {

     

       186
       186
       -
                         address = "10.0.0.1";

     

       187
       187
       -
                         action = "update";

     

       188
       188
       -
                       };

     

       188
       188
       +
                     acl.dhcp_ddns = {

     

       189
       189
       +
                       address = "10.0.0.1";

     

       190
       190
       +
                       action = "update";

     

       191
       191
       +
                     };

     

       189
       192
        
       

     

       190
       190
       -
                       template.default = {

     

       191
       191
       -
                         storage = zonesDir;

     

       192
       192
       -
                         zonefile-sync = "-1";

     

       193
       193
       -
                         zonefile-load = "difference-no-serial";

     

       194
       194
       -
                         journal-content = "all";

     

       195
       195
       -
                       };

     

       193
       193
       +
                     template.default = {

     

       194
       194
       +
                       storage = zonesDir;

     

       195
       195
       +
                       zonefile-sync = "-1";

     

       196
       196
       +
                       zonefile-load = "difference-no-serial";

     

       197
       197
       +
                       journal-content = "all";

     

       198
       198
       +
                     };

     

       196
       199
        
       

     

       197
       197
       -
                       zone."lan.nixos.test" = {

     

       198
       198
       -
                         file = "lan.nixos.test.zone";

     

       199
       199
       -
                         acl = [

     

       200
       200
       -
                           "dhcp_ddns"

     

       201
       201
       -
                         ];

     

       202
       202
       -
                       };

     

       200
       200
       +
                     zone."lan.nixos.test" = {

     

       201
       201
       +
                       file = "lan.nixos.test.zone";

     

       202
       202
       +
                       acl = [

     

       203
       203
       +
                         "dhcp_ddns"

     

       204
       204
       +
                       ];

     

       203
       205
        
                     };

     

       204
       206
        
                   };

     

       207
       207
       +
                 };

     

       205
       208
        
       

     

       206
       206
       -
               };

     

       209
       209
       +
             };

     

       207
       210
        
       

     

       208
       208
       -
             client =

     

       209
       209
       -
               { config, pkgs, ... }:

     

       210
       210
       -
               {

     

       211
       211
       -
                 virtualisation.vlans = [ 1 ];

     

       212
       212
       -
                 systemd.services.systemd-networkd.environment.SYSTEMD_LOG_LEVEL = "debug";

     

       213
       213
       -
                 networking = {

     

       214
       214
       -
                   useNetworkd = true;

     

       215
       215
       -
                   useDHCP = false;

     

       216
       216
       -
                   firewall.enable = false;

     

       217
       217
       -
                   interfaces.eth1.useDHCP = true;

     

       218
       218
       -
                 };

     

       211
       211
       +
           client =

     

       212
       212
       +
             { config, pkgs, ... }:

     

       213
       213
       +
             {

     

       214
       214
       +
               virtualisation.vlans = [ 1 ];

     

       215
       215
       +
               systemd.services.systemd-networkd.environment.SYSTEMD_LOG_LEVEL = "debug";

     

       216
       216
       +
               networking = {

     

       217
       217
       +
                 useNetworkd = true;

     

       218
       218
       +
                 useDHCP = false;

     

       219
       219
       +
                 firewall.enable = false;

     

       220
       220
       +
                 interfaces.eth1.useDHCP = true;

     

       219
       221
        
               };

     

       220
       220
       -
           };

     

       221
       221
       -
           testScript =

     

       222
       222
       -
             { ... }:

     

       223
       223
       -
             ''

     

       224
       224
       -
               start_all()

     

       225
       225
       -
               router.wait_for_unit("kea-dhcp4-server.service")

     

       226
       226
       -
               client.systemctl("start systemd-networkd-wait-online.service")

     

       227
       227
       -
               client.wait_for_unit("systemd-networkd-wait-online.service")

     

       228
       228
       -
               client.wait_until_succeeds("ping -c 5 10.0.0.1")

     

       229
       229
       -
               router.wait_until_succeeds("ping -c 5 10.0.0.3")

     

       230
       230
       -
               nameserver.wait_until_succeeds("kdig +short client.lan.nixos.test @10.0.0.2 | grep -q 10.0.0.3")

     

       231
       231
       -
               router.log(router.execute("curl 127.0.0.1:9547")[1])

     

       232
       232
       -
               router.succeed("curl --no-buffer 127.0.0.1:9547 | grep -qE '^kea_dhcp4_addresses_assigned_total.*1.0$'")

     

       233
       233
       -
             '';

     

       234
       234
       -
         }

     

       235
       235
       -
       )

     

       222
       222
       +
             };

     

       223
       223
       +
         };

     

       224
       224
       +
         testScript =

     

       225
       225
       +
           { ... }:

     

       226
       226
       +
           ''

     

       227
       227
       +
             start_all()

     

       228
       228
       +
             router.wait_for_unit("kea-dhcp4-server.service")

     

       229
       229
       +
             client.systemctl("start systemd-networkd-wait-online.service")

     

       230
       230
       +
             client.wait_for_unit("systemd-networkd-wait-online.service")

     

       231
       231
       +
             client.wait_until_succeeds("ping -c 5 10.0.0.1")

     

       232
       232
       +
             router.wait_until_succeeds("ping -c 5 10.0.0.3")

     

       233
       233
       +
             nameserver.wait_until_succeeds("kdig +short client.lan.nixos.test @10.0.0.2 | grep -q 10.0.0.3")

     

       234
       234
       +
             router.log(router.execute("curl 127.0.0.1:9547")[1])

     

       235
       235
       +
             router.succeed("curl --no-buffer 127.0.0.1:9547 | grep -qE '^kea_dhcp4_addresses_assigned_total.*1.0$'")

     

       236
       236
       +
           '';

     

       237
       237
       +
       }

+219 -217

nixos/tests/knot.nix

···

       1
       1
       -
       import ./make-test-python.nix (

     

       2
       2
       -
         { pkgs, lib, ... }:

     

       3
       3
       -
         let

     

       4
       4
       -
           common = {

     

       5
       5
       -
             networking.firewall.enable = false;

     

       6
       6
       -
             networking.useDHCP = false;

     

       7
       7
       -
           };

     

       8
       8
       -
           exampleZone = pkgs.writeTextDir "example.com.zone" ''

     

       9
       9
       -
             @ SOA ns.example.com. noc.example.com. 2019031301 86400 7200 3600000 172800

     

       10
       10
       -
             @       NS      ns1

     

       11
       11
       -
             @       NS      ns2

     

       12
       12
       -
             ns1     A       192.168.0.1

     

       13
       13
       -
             ns1     AAAA    fd00::1

     

       14
       14
       -
             ns2     A       192.168.0.2

     

       15
       15
       -
             ns2     AAAA    fd00::2

     

       16
       16
       -
             www     A       192.0.2.1

     

       17
       17
       -
             www     AAAA    2001:DB8::1

     

       18
       18
       -
             sub     NS      ns.example.com.

     

       19
       19
       -
           '';

     

       20
       20
       -
           delegatedZone = pkgs.writeTextDir "sub.example.com.zone" ''

     

       21
       21
       -
             @ SOA ns.example.com. noc.example.com. 2019031301 86400 7200 3600000 172800

     

       22
       22
       -
             @       NS      ns1.example.com.

     

       23
       23
       -
             @       NS      ns2.example.com.

     

       24
       24
       -
             @       A       192.0.2.2

     

       25
       25
       -
             @       AAAA    2001:DB8::2

     

       26
       26
       -
           '';

     

       1
       1
       +
       {

     

       2
       2
       +
         pkgs,

     

       3
       3
       +
         lib,

     

       4
       4
       +
         ...

     

       5
       5
       +
       }:

     

       6
       6
       +
       let

     

       7
       7
       +
         common = {

     

       8
       8
       +
           networking.firewall.enable = false;

     

       9
       9
       +
           networking.useDHCP = false;

     

       10
       10
       +
         };

     

       11
       11
       +
         exampleZone = pkgs.writeTextDir "example.com.zone" ''

     

       12
       12
       +
           @ SOA ns.example.com. noc.example.com. 2019031301 86400 7200 3600000 172800

     

       13
       13
       +
           @       NS      ns1

     

       14
       14
       +
           @       NS      ns2

     

       15
       15
       +
           ns1     A       192.168.0.1

     

       16
       16
       +
           ns1     AAAA    fd00::1

     

       17
       17
       +
           ns2     A       192.168.0.2

     

       18
       18
       +
           ns2     AAAA    fd00::2

     

       19
       19
       +
           www     A       192.0.2.1

     

       20
       20
       +
           www     AAAA    2001:DB8::1

     

       21
       21
       +
           sub     NS      ns.example.com.

     

       22
       22
       +
         '';

     

       23
       23
       +
         delegatedZone = pkgs.writeTextDir "sub.example.com.zone" ''

     

       24
       24
       +
           @ SOA ns.example.com. noc.example.com. 2019031301 86400 7200 3600000 172800

     

       25
       25
       +
           @       NS      ns1.example.com.

     

       26
       26
       +
           @       NS      ns2.example.com.

     

       27
       27
       +
           @       A       192.0.2.2

     

       28
       28
       +
           @       AAAA    2001:DB8::2

     

       29
       29
       +
         '';

     

       27
       30
        
       

     

       28
       28
       -
           knotZonesEnv = pkgs.buildEnv {

     

       29
       29
       -
             name = "knot-zones";

     

       30
       30
       -
             paths = [

     

       31
       31
       -
               exampleZone

     

       32
       32
       -
               delegatedZone

     

       33
       33
       -
             ];

     

       34
       34
       -
           };

     

       35
       35
       -
           # DO NOT USE pkgs.writeText IN PRODUCTION. This put secrets in the nix store!

     

       36
       36
       -
           tsigFile = pkgs.writeText "tsig.conf" ''

     

       37
       37
       -
             key:

     

       38
       38
       -
               - id: xfr_key

     

       39
       39
       -
                 algorithm: hmac-sha256

     

       40
       40
       -
                 secret: zOYgOgnzx3TGe5J5I/0kxd7gTcxXhLYMEq3Ek3fY37s=

     

       41
       41
       -
           '';

     

       42
       42
       -
         in

     

       43
       43
       -
         {

     

       44
       44
       -
           name = "knot";

     

       45
       45
       -
           meta = with pkgs.lib.maintainers; {

     

       46
       46
       -
             maintainers = [ hexa ];

     

       47
       47
       -
           };

     

       31
       31
       +
         knotZonesEnv = pkgs.buildEnv {

     

       32
       32
       +
           name = "knot-zones";

     

       33
       33
       +
           paths = [

     

       34
       34
       +
             exampleZone

     

       35
       35
       +
             delegatedZone

     

       36
       36
       +
           ];

     

       37
       37
       +
         };

     

       38
       38
       +
         # DO NOT USE pkgs.writeText IN PRODUCTION. This put secrets in the nix store!

     

       39
       39
       +
         tsigFile = pkgs.writeText "tsig.conf" ''

     

       40
       40
       +
           key:

     

       41
       41
       +
             - id: xfr_key

     

       42
       42
       +
               algorithm: hmac-sha256

     

       43
       43
       +
               secret: zOYgOgnzx3TGe5J5I/0kxd7gTcxXhLYMEq3Ek3fY37s=

     

       44
       44
       +
         '';

     

       45
       45
       +
       in

     

       46
       46
       +
       {

     

       47
       47
       +
         name = "knot";

     

       48
       48
       +
         meta = with pkgs.lib.maintainers; {

     

       49
       49
       +
           maintainers = [ hexa ];

     

       50
       50
       +
         };

     

       48
       51
        
       

     

       49
       49
       -
           nodes = {

     

       50
       50
       -
             primary =

     

       51
       51
       -
               { lib, ... }:

     

       52
       52
       -
               {

     

       53
       53
       -
                 imports = [ common ];

     

       52
       52
       +
         nodes = {

     

       53
       53
       +
           primary =

     

       54
       54
       +
             { lib, ... }:

     

       55
       55
       +
             {

     

       56
       56
       +
               imports = [ common ];

     

       54
       57
        
       

     

       55
       55
       -
                 # trigger sched_setaffinity syscall

     

       56
       56
       -
                 virtualisation.cores = 2;

     

       58
       58
       +
               # trigger sched_setaffinity syscall

     

       59
       59
       +
               virtualisation.cores = 2;

     

       57
       60
        
       

     

       58
       58
       -
                 networking.interfaces.eth1 = {

     

       59
       59
       -
                   ipv4.addresses = lib.mkForce [

     

       60
       60
       -
                     {

     

       61
       61
       -
                       address = "192.168.0.1";

     

       62
       62
       -
                       prefixLength = 24;

     

       63
       63
       -
                     }

     

       61
       61
       +
               networking.interfaces.eth1 = {

     

       62
       62
       +
                 ipv4.addresses = lib.mkForce [

     

       63
       63
       +
                   {

     

       64
       64
       +
                     address = "192.168.0.1";

     

       65
       65
       +
                     prefixLength = 24;

     

       66
       66
       +
                   }

     

       67
       67
       +
                 ];

     

       68
       68
       +
                 ipv6.addresses = lib.mkForce [

     

       69
       69
       +
                   {

     

       70
       70
       +
                     address = "fd00::1";

     

       71
       71
       +
                     prefixLength = 64;

     

       72
       72
       +
                   }

     

       73
       73
       +
                 ];

     

       74
       74
       +
               };

     

       75
       75
       +
               services.knot.enable = true;

     

       76
       76
       +
               services.knot.extraArgs = [ "-v" ];

     

       77
       77
       +
               services.knot.keyFiles = [ tsigFile ];

     

       78
       78
       +
               services.knot.settings = {

     

       79
       79
       +
                 server = {

     

       80
       80
       +
                   listen = [

     

       81
       81
       +
                     "0.0.0.0@53"

     

       82
       82
       +
                     "::@53"

     

       64
       83
        
                   ];

     

       65
       65
       -
                   ipv6.addresses = lib.mkForce [

     

       66
       66
       -
                     {

     

       67
       67
       -
                       address = "fd00::1";

     

       68
       68
       -
                       prefixLength = 64;

     

       69
       69
       -
                     }

     

       84
       84
       +
                   listen-quic = [

     

       85
       85
       +
                     "0.0.0.0@853"

     

       86
       86
       +
                     "::@853"

     

       70
       87
        
                   ];

     

       88
       88
       +
                   automatic-acl = true;

     

       71
       89
        
                 };

     

       72
       72
       -
                 services.knot.enable = true;

     

       73
       73
       -
                 services.knot.extraArgs = [ "-v" ];

     

       74
       74
       -
                 services.knot.keyFiles = [ tsigFile ];

     

       75
       75
       -
                 services.knot.settings = {

     

       76
       76
       -
                   server = {

     

       77
       77
       -
                     listen = [

     

       78
       78
       -
                       "0.0.0.0@53"

     

       79
       79
       -
                       "::@53"

     

       80
       80
       -
                     ];

     

       81
       81
       -
                     listen-quic = [

     

       82
       82
       -
                       "0.0.0.0@853"

     

       83
       83
       -
                       "::@853"

     

       84
       84
       -
                     ];

     

       85
       85
       -
                     automatic-acl = true;

     

       86
       86
       -
                   };

     

       87
       90
        
       

     

       88
       88
       -
                   acl.secondary_acl = {

     

       89
       89
       -
                     address = "192.168.0.2";

     

       90
       90
       -
                     key = "xfr_key";

     

       91
       91
       -
                     action = "transfer";

     

       92
       92
       -
                   };

     

       91
       91
       +
                 acl.secondary_acl = {

     

       92
       92
       +
                   address = "192.168.0.2";

     

       93
       93
       +
                   key = "xfr_key";

     

       94
       94
       +
                   action = "transfer";

     

       95
       95
       +
                 };

     

       93
       96
        
       

     

       94
       94
       -
                   remote.secondary.address = "192.168.0.2@53";

     

       97
       97
       +
                 remote.secondary.address = "192.168.0.2@53";

     

       95
       98
        
       

     

       96
       96
       -
                   template.default = {

     

       97
       97
       -
                     storage = knotZonesEnv;

     

       98
       98
       -
                     notify = [ "secondary" ];

     

       99
       99
       -
                     acl = [ "secondary_acl" ];

     

       100
       100
       -
                     dnssec-signing = true;

     

       101
       101
       -
                     # Input-only zone files

     

       102
       102
       -
                     # https://www.knot-dns.cz/docs/2.8/html/operation.html#example-3

     

       103
       103
       -
                     # prevents modification of the zonefiles, since the zonefiles are immutable

     

       104
       104
       -
                     zonefile-sync = -1;

     

       105
       105
       -
                     zonefile-load = "difference";

     

       106
       106
       -
                     journal-content = "changes";

     

       107
       107
       -
                   };

     

       108
       108
       -
       

     

       109
       109
       -
                   zone = {

     

       110
       110
       -
                     "example.com".file = "example.com.zone";

     

       111
       111
       -
                     "sub.example.com".file = "sub.example.com.zone";

     

       112
       112
       -
                   };

     

       99
       99
       +
                 template.default = {

     

       100
       100
       +
                   storage = knotZonesEnv;

     

       101
       101
       +
                   notify = [ "secondary" ];

     

       102
       102
       +
                   acl = [ "secondary_acl" ];

     

       103
       103
       +
                   dnssec-signing = true;

     

       104
       104
       +
                   # Input-only zone files

     

       105
       105
       +
                   # https://www.knot-dns.cz/docs/2.8/html/operation.html#example-3

     

       106
       106
       +
                   # prevents modification of the zonefiles, since the zonefiles are immutable

     

       107
       107
       +
                   zonefile-sync = -1;

     

       108
       108
       +
                   zonefile-load = "difference";

     

       109
       109
       +
                   journal-content = "changes";

     

       110
       110
       +
                 };

     

       113
       111
        
       

     

       114
       114
       -
                   log.syslog.any = "info";

     

       112
       112
       +
                 zone = {

     

       113
       113
       +
                   "example.com".file = "example.com.zone";

     

       114
       114
       +
                   "sub.example.com".file = "sub.example.com.zone";

     

       115
       115
        
                 };

     

       116
       116
       +
       

     

       117
       117
       +
                 log.syslog.any = "info";

     

       116
       118
        
               };

     

       119
       119
       +
             };

     

       117
       120
        
       

     

       118
       118
       -
             secondary =

     

       119
       119
       -
               { lib, ... }:

     

       120
       120
       -
               {

     

       121
       121
       -
                 imports = [ common ];

     

       122
       122
       -
                 networking.interfaces.eth1 = {

     

       123
       123
       -
                   ipv4.addresses = lib.mkForce [

     

       124
       124
       -
                     {

     

       125
       125
       -
                       address = "192.168.0.2";

     

       126
       126
       -
                       prefixLength = 24;

     

       127
       127
       -
                     }

     

       128
       128
       -
                   ];

     

       129
       129
       -
                   ipv6.addresses = lib.mkForce [

     

       130
       130
       -
                     {

     

       131
       131
       -
                       address = "fd00::2";

     

       132
       132
       -
                       prefixLength = 64;

     

       133
       133
       -
                     }

     

       121
       121
       +
           secondary =

     

       122
       122
       +
             { lib, ... }:

     

       123
       123
       +
             {

     

       124
       124
       +
               imports = [ common ];

     

       125
       125
       +
               networking.interfaces.eth1 = {

     

       126
       126
       +
                 ipv4.addresses = lib.mkForce [

     

       127
       127
       +
                   {

     

       128
       128
       +
                     address = "192.168.0.2";

     

       129
       129
       +
                     prefixLength = 24;

     

       130
       130
       +
                   }

     

       131
       131
       +
                 ];

     

       132
       132
       +
                 ipv6.addresses = lib.mkForce [

     

       133
       133
       +
                   {

     

       134
       134
       +
                     address = "fd00::2";

     

       135
       135
       +
                     prefixLength = 64;

     

       136
       136
       +
                   }

     

       137
       137
       +
                 ];

     

       138
       138
       +
               };

     

       139
       139
       +
               services.knot.enable = true;

     

       140
       140
       +
               services.knot.keyFiles = [ tsigFile ];

     

       141
       141
       +
               services.knot.extraArgs = [ "-v" ];

     

       142
       142
       +
               services.knot.settings = {

     

       143
       143
       +
                 server = {

     

       144
       144
       +
                   automatic-acl = true;

     

       145
       145
       +
                 };

     

       146
       146
       +
       

     

       147
       147
       +
                 xdp = {

     

       148
       148
       +
                   listen = [

     

       149
       149
       +
                     "eth1"

     

       134
       150
        
                   ];

     

       151
       151
       +
                   tcp = true;

     

       135
       152
        
                 };

     

       136
       136
       -
                 services.knot.enable = true;

     

       137
       137
       -
                 services.knot.keyFiles = [ tsigFile ];

     

       138
       138
       -
                 services.knot.extraArgs = [ "-v" ];

     

       139
       139
       -
                 services.knot.settings = {

     

       140
       140
       -
                   server = {

     

       141
       141
       -
                     automatic-acl = true;

     

       142
       142
       -
                   };

     

       143
       153
        
       

     

       144
       144
       -
                   xdp = {

     

       145
       145
       -
                     listen = [

     

       146
       146
       -
                       "eth1"

     

       147
       147
       -
                     ];

     

       148
       148
       -
                     tcp = true;

     

       149
       149
       -
                   };

     

       154
       154
       +
                 remote.primary = {

     

       155
       155
       +
                   address = "192.168.0.1@53";

     

       156
       156
       +
                   key = "xfr_key";

     

       157
       157
       +
                 };

     

       150
       158
        
       

     

       151
       151
       -
                   remote.primary = {

     

       152
       152
       -
                     address = "192.168.0.1@53";

     

       153
       153
       -
                     key = "xfr_key";

     

       154
       154
       -
                   };

     

       159
       159
       +
                 remote.primary-quic = {

     

       160
       160
       +
                   address = "192.168.0.1@853";

     

       161
       161
       +
                   key = "xfr_key";

     

       162
       162
       +
                   quic = true;

     

       163
       163
       +
                 };

     

       155
       164
        
       

     

       156
       156
       -
                   remote.primary-quic = {

     

       157
       157
       -
                     address = "192.168.0.1@853";

     

       158
       158
       -
                     key = "xfr_key";

     

       159
       159
       -
                     quic = true;

     

       160
       160
       -
                   };

     

       165
       165
       +
                 template.default = {

     

       166
       166
       +
                   # zonefileless setup

     

       167
       167
       +
                   # https://www.knot-dns.cz/docs/2.8/html/operation.html#example-2

     

       168
       168
       +
                   zonefile-sync = "-1";

     

       169
       169
       +
                   zonefile-load = "none";

     

       170
       170
       +
                   journal-content = "all";

     

       171
       171
       +
                 };

     

       161
       172
        
       

     

       162
       162
       -
                   template.default = {

     

       163
       163
       -
                     # zonefileless setup

     

       164
       164
       -
                     # https://www.knot-dns.cz/docs/2.8/html/operation.html#example-2

     

       165
       165
       -
                     zonefile-sync = "-1";

     

       166
       166
       -
                     zonefile-load = "none";

     

       167
       167
       -
                     journal-content = "all";

     

       173
       173
       +
                 zone = {

     

       174
       174
       +
                   "example.com" = {

     

       175
       175
       +
                     master = "primary";

     

       176
       176
       +
                     file = "example.com.zone";

     

       168
       177
        
                   };

     

       169
       169
       -
       

     

       170
       170
       -
                   zone = {

     

       171
       171
       -
                     "example.com" = {

     

       172
       172
       -
                       master = "primary";

     

       173
       173
       -
                       file = "example.com.zone";

     

       174
       174
       -
                     };

     

       175
       175
       -
                     "sub.example.com" = {

     

       176
       176
       -
                       master = "primary-quic";

     

       177
       177
       -
                       file = "sub.example.com.zone";

     

       178
       178
       -
                     };

     

       178
       178
       +
                   "sub.example.com" = {

     

       179
       179
       +
                     master = "primary-quic";

     

       180
       180
       +
                     file = "sub.example.com.zone";

     

       179
       181
        
                   };

     

       182
       182
       +
                 };

     

       180
       183
        
       

     

       181
       181
       -
                   log.syslog.any = "debug";

     

       182
       182
       -
                 };

     

       184
       184
       +
                 log.syslog.any = "debug";

     

       183
       185
        
               };

     

       184
       184
       -
             client =

     

       185
       185
       -
               { lib, nodes, ... }:

     

       186
       186
       -
               {

     

       187
       187
       -
                 imports = [ common ];

     

       188
       188
       -
                 networking.interfaces.eth1 = {

     

       189
       189
       -
                   ipv4.addresses = [

     

       190
       190
       -
                     {

     

       191
       191
       -
                       address = "192.168.0.3";

     

       192
       192
       -
                       prefixLength = 24;

     

       193
       193
       -
                     }

     

       194
       194
       -
                   ];

     

       195
       195
       -
                   ipv6.addresses = [

     

       196
       196
       -
                     {

     

       197
       197
       -
                       address = "fd00::3";

     

       198
       198
       -
                       prefixLength = 64;

     

       199
       199
       -
                     }

     

       200
       200
       -
                   ];

     

       201
       201
       -
                 };

     

       202
       202
       -
                 environment.systemPackages = [ pkgs.knot-dns ];

     

       186
       186
       +
             };

     

       187
       187
       +
           client =

     

       188
       188
       +
             { lib, nodes, ... }:

     

       189
       189
       +
             {

     

       190
       190
       +
               imports = [ common ];

     

       191
       191
       +
               networking.interfaces.eth1 = {

     

       192
       192
       +
                 ipv4.addresses = [

     

       193
       193
       +
                   {

     

       194
       194
       +
                     address = "192.168.0.3";

     

       195
       195
       +
                     prefixLength = 24;

     

       196
       196
       +
                   }

     

       197
       197
       +
                 ];

     

       198
       198
       +
                 ipv6.addresses = [

     

       199
       199
       +
                   {

     

       200
       200
       +
                     address = "fd00::3";

     

       201
       201
       +
                     prefixLength = 64;

     

       202
       202
       +
                   }

     

       203
       203
       +
                 ];

     

       203
       204
        
               };

     

       204
       204
       -
           };

     

       205
       205
       +
               environment.systemPackages = [ pkgs.knot-dns ];

     

       206
       206
       +
             };

     

       207
       207
       +
         };

     

       205
       208
        
       

     

       206
       206
       -
           testScript =

     

       207
       207
       -
             { nodes, ... }:

     

       208
       208
       -
             let

     

       209
       209
       -
               primary4 = (lib.head nodes.primary.config.networking.interfaces.eth1.ipv4.addresses).address;

     

       210
       210
       -
               primary6 = (lib.head nodes.primary.config.networking.interfaces.eth1.ipv6.addresses).address;

     

       209
       209
       +
         testScript =

     

       210
       210
       +
           { nodes, ... }:

     

       211
       211
       +
           let

     

       212
       212
       +
             primary4 = (lib.head nodes.primary.config.networking.interfaces.eth1.ipv4.addresses).address;

     

       213
       213
       +
             primary6 = (lib.head nodes.primary.config.networking.interfaces.eth1.ipv6.addresses).address;

     

       211
       214
        
       

     

       212
       212
       -
               secondary4 = (lib.head nodes.secondary.config.networking.interfaces.eth1.ipv4.addresses).address;

     

       213
       213
       -
               secondary6 = (lib.head nodes.secondary.config.networking.interfaces.eth1.ipv6.addresses).address;

     

       214
       214
       -
             in

     

       215
       215
       -
             ''

     

       216
       216
       -
               import re

     

       215
       215
       +
             secondary4 = (lib.head nodes.secondary.config.networking.interfaces.eth1.ipv4.addresses).address;

     

       216
       216
       +
             secondary6 = (lib.head nodes.secondary.config.networking.interfaces.eth1.ipv6.addresses).address;

     

       217
       217
       +
           in

     

       218
       218
       +
           ''

     

       219
       219
       +
             import re

     

       217
       220
        
       

     

       218
       218
       -
               start_all()

     

       221
       221
       +
             start_all()

     

       219
       222
        
       

     

       220
       220
       -
               client.wait_for_unit("network.target")

     

       221
       221
       -
               primary.wait_for_unit("knot.service")

     

       222
       222
       -
               secondary.wait_for_unit("knot.service")

     

       223
       223
       +
             client.wait_for_unit("network.target")

     

       224
       224
       +
             primary.wait_for_unit("knot.service")

     

       225
       225
       +
             secondary.wait_for_unit("knot.service")

     

       223
       226
        
       

     

       224
       224
       -
               for zone in ("example.com.", "sub.example.com."):

     

       225
       225
       -
                   secondary.wait_until_succeeds(

     

       226
       226
       -
                     f"knotc zone-status {zone} | grep -q 'serial: 2019031302'"

     

       227
       227
       -
                   )

     

       227
       227
       +
             for zone in ("example.com.", "sub.example.com."):

     

       228
       228
       +
                 secondary.wait_until_succeeds(

     

       229
       229
       +
                   f"knotc zone-status {zone} | grep -q 'serial: 2019031302'"

     

       230
       230
       +
                 )

     

       228
       231
        
       

     

       229
       229
       -
               def test(host, query_type, query, pattern):

     

       230
       230
       -
                   out = client.succeed(f"khost -t {query_type} {query} {host}").strip()

     

       231
       231
       -
                   client.log(f"{host} replied with: {out}")

     

       232
       232
       -
                   assert re.search(pattern, out), f'Did not match "{pattern}"'

     

       232
       232
       +
             def test(host, query_type, query, pattern):

     

       233
       233
       +
                 out = client.succeed(f"khost -t {query_type} {query} {host}").strip()

     

       234
       234
       +
                 client.log(f"{host} replied with: {out}")

     

       235
       235
       +
                 assert re.search(pattern, out), f'Did not match "{pattern}"'

     

       233
       236
        
       

     

       234
       237
        
       

     

       235
       235
       -
               for host in ("${primary4}", "${primary6}", "${secondary4}", "${secondary6}"):

     

       236
       236
       -
                   with subtest(f"Interrogate {host}"):

     

       237
       237
       -
                       test(host, "SOA", "example.com", r"start of authority.*noc\.example\.com\.")

     

       238
       238
       -
                       test(host, "A", "example.com", r"has no [^ ]+ record")

     

       239
       239
       -
                       test(host, "AAAA", "example.com", r"has no [^ ]+ record")

     

       238
       238
       +
             for host in ("${primary4}", "${primary6}", "${secondary4}", "${secondary6}"):

     

       239
       239
       +
                 with subtest(f"Interrogate {host}"):

     

       240
       240
       +
                     test(host, "SOA", "example.com", r"start of authority.*noc\.example\.com\.")

     

       241
       241
       +
                     test(host, "A", "example.com", r"has no [^ ]+ record")

     

       242
       242
       +
                     test(host, "AAAA", "example.com", r"has no [^ ]+ record")

     

       240
       243
        
       

     

       241
       241
       -
                       test(host, "A", "www.example.com", r"address 192.0.2.1$")

     

       242
       242
       -
                       test(host, "AAAA", "www.example.com", r"address 2001:db8::1$")

     

       244
       244
       +
                     test(host, "A", "www.example.com", r"address 192.0.2.1$")

     

       245
       245
       +
                     test(host, "AAAA", "www.example.com", r"address 2001:db8::1$")

     

       243
       246
        
       

     

       244
       244
       -
                       test(host, "NS", "sub.example.com", r"nameserver is ns\d\.example\.com.$")

     

       245
       245
       -
                       test(host, "A", "sub.example.com", r"address 192.0.2.2$")

     

       246
       246
       -
                       test(host, "AAAA", "sub.example.com", r"address 2001:db8::2$")

     

       247
       247
       +
                     test(host, "NS", "sub.example.com", r"nameserver is ns\d\.example\.com.$")

     

       248
       248
       +
                     test(host, "A", "sub.example.com", r"address 192.0.2.2$")

     

       249
       249
       +
                     test(host, "AAAA", "sub.example.com", r"address 2001:db8::2$")

     

       247
       250
        
       

     

       248
       248
       -
                       test(host, "RRSIG", "www.example.com", r"RR set signature is")

     

       249
       249
       -
                       test(host, "DNSKEY", "example.com", r"DNSSEC key is")

     

       251
       251
       +
                     test(host, "RRSIG", "www.example.com", r"RR set signature is")

     

       252
       252
       +
                     test(host, "DNSKEY", "example.com", r"DNSSEC key is")

     

       250
       253
        
       

     

       251
       251
       -
               primary.log(primary.succeed("systemd-analyze security knot.service | grep -v '✓'"))

     

       252
       252
       -
             '';

     

       253
       253
       -
         }

     

       254
       254
       -
       )

     

       254
       254
       +
             primary.log(primary.succeed("systemd-analyze security knot.service | grep -v '✓'"))

     

       255
       255
       +
           '';

     

       256
       256
       +
       }

+86 -85

nixos/tests/pinnwand.nix

···

       1
       1
       -
       import ./make-test-python.nix (

     

       2
       2
       -
         { pkgs, ... }:

     

       3
       3
       -
         let

     

       4
       4
       -
           port = 8000;

     

       5
       5
       -
           baseUrl = "http://server:${toString port}";

     

       6
       6
       -
         in

     

       7
       7
       -
         {

     

       8
       8
       -
           name = "pinnwand";

     

       9
       9
       -
           meta = with pkgs.lib.maintainers; {

     

       10
       10
       -
             maintainers = [ hexa ];

     

       11
       11
       -
           };

     

       1
       1
       +
       {

     

       2
       2
       +
         pkgs,

     

       3
       3
       +
         ...

     

       4
       4
       +
       }:

     

       5
       5
       +
       let

     

       6
       6
       +
         port = 8000;

     

       7
       7
       +
         baseUrl = "http://server:${toString port}";

     

       8
       8
       +
       in

     

       9
       9
       +
       {

     

       10
       10
       +
         name = "pinnwand";

     

       11
       11
       +
         meta = with pkgs.lib.maintainers; {

     

       12
       12
       +
           maintainers = [ hexa ];

     

       13
       13
       +
         };

     

       12
       14
        
       

     

       13
       13
       -
           nodes = {

     

       14
       14
       -
             server =

     

       15
       15
       -
               { config, ... }:

     

       16
       16
       -
               {

     

       17
       17
       -
                 networking.firewall.allowedTCPPorts = [

     

       18
       18
       -
                   port

     

       19
       19
       -
                 ];

     

       15
       15
       +
         nodes = {

     

       16
       16
       +
           server =

     

       17
       17
       +
             { config, ... }:

     

       18
       18
       +
             {

     

       19
       19
       +
               networking.firewall.allowedTCPPorts = [

     

       20
       20
       +
                 port

     

       21
       21
       +
               ];

     

       20
       22
        
       

     

       21
       21
       -
                 services.pinnwand = {

     

       22
       22
       -
                   enable = true;

     

       23
       23
       -
                   port = port;

     

       24
       24
       -
                 };

     

       23
       23
       +
               services.pinnwand = {

     

       24
       24
       +
                 enable = true;

     

       25
       25
       +
                 port = port;

     

       25
       26
        
               };

     

       27
       27
       +
             };

     

       26
       28
        
       

     

       27
       27
       -
             client =

     

       28
       28
       -
               { pkgs, ... }:

     

       29
       29
       -
               {

     

       30
       30
       -
                 environment.systemPackages = [

     

       31
       31
       -
                   pkgs.steck

     

       29
       29
       +
           client =

     

       30
       30
       +
             { pkgs, ... }:

     

       31
       31
       +
             {

     

       32
       32
       +
               environment.systemPackages = [

     

       33
       33
       +
                 pkgs.steck

     

       34
       34
       +
       

     

       35
       35
       +
                 (pkgs.writers.writePython3Bin "setup-steck.py"

     

       36
       36
       +
                   {

     

       37
       37
       +
                     libraries = with pkgs.python3.pkgs; [

     

       38
       38
       +
                       appdirs

     

       39
       39
       +
                       toml

     

       40
       40
       +
                     ];

     

       41
       41
       +
                     flakeIgnore = [

     

       42
       42
       +
                       "E501"

     

       43
       43
       +
                     ];

     

       44
       44
       +
                   }

     

       45
       45
       +
                   ''

     

       46
       46
       +
                     import appdirs

     

       47
       47
       +
                     import toml

     

       48
       48
       +
                     import os

     

       32
       49
        
       

     

       33
       33
       -
                   (pkgs.writers.writePython3Bin "setup-steck.py"

     

       34
       34
       -
                     {

     

       35
       35
       -
                       libraries = with pkgs.python3.pkgs; [

     

       36
       36
       -
                         appdirs

     

       37
       37
       -
                         toml

     

       38
       38
       -
                       ];

     

       39
       39
       -
                       flakeIgnore = [

     

       40
       40
       -
                         "E501"

     

       41
       41
       -
                       ];

     

       50
       50
       +
                     CONFIG = {

     

       51
       51
       +
                         "base": "${baseUrl}/",

     

       52
       52
       +
                         "confirm": False,

     

       53
       53
       +
                         "magic": True,

     

       54
       54
       +
                         "ignore": True

     

       42
       55
        
                     }

     

       43
       43
       -
                     ''

     

       44
       44
       -
                       import appdirs

     

       45
       45
       -
                       import toml

     

       46
       46
       -
                       import os

     

       47
       56
        
       

     

       48
       48
       -
                       CONFIG = {

     

       49
       49
       -
                           "base": "${baseUrl}/",

     

       50
       50
       -
                           "confirm": False,

     

       51
       51
       -
                           "magic": True,

     

       52
       52
       -
                           "ignore": True

     

       53
       53
       -
                       }

     

       57
       57
       +
                     os.makedirs(appdirs.user_config_dir('steck'))

     

       58
       58
       +
                     with open(os.path.join(appdirs.user_config_dir('steck'), 'steck.toml'), "w") as fd:

     

       59
       59
       +
                         toml.dump(CONFIG, fd)

     

       60
       60
       +
                   ''

     

       61
       61
       +
                 )

     

       62
       62
       +
               ];

     

       63
       63
       +
             };

     

       64
       64
       +
         };

     

       54
       65
        
       

     

       55
       55
       -
                       os.makedirs(appdirs.user_config_dir('steck'))

     

       56
       56
       -
                       with open(os.path.join(appdirs.user_config_dir('steck'), 'steck.toml'), "w") as fd:

     

       57
       57
       -
                           toml.dump(CONFIG, fd)

     

       58
       58
       -
                     ''

     

       59
       59
       -
                   )

     

       60
       60
       -
                 ];

     

       61
       61
       -
               };

     

       62
       62
       -
           };

     

       66
       66
       +
         testScript = ''

     

       67
       67
       +
           start_all()

     

       63
       68
        
       

     

       64
       64
       -
           testScript = ''

     

       65
       65
       -
             start_all()

     

       69
       69
       +
           server.wait_for_unit("pinnwand.service")

     

       70
       70
       +
           client.wait_for_unit("network.target")

     

       66
       71
        
       

     

       67
       67
       -
             server.wait_for_unit("pinnwand.service")

     

       68
       68
       -
             client.wait_for_unit("network.target")

     

       72
       72
       +
           # create steck.toml config file

     

       73
       73
       +
           client.succeed("setup-steck.py")

     

       69
       74
        
       

     

       70
       70
       -
             # create steck.toml config file

     

       71
       71
       -
             client.succeed("setup-steck.py")

     

       75
       75
       +
           # wait until the server running pinnwand is reachable

     

       76
       76
       +
           client.wait_until_succeeds("ping -c1 server")

     

       72
       77
        
       

     

       73
       73
       -
             # wait until the server running pinnwand is reachable

     

       74
       74
       -
             client.wait_until_succeeds("ping -c1 server")

     

       78
       78
       +
           # make sure pinnwand is listening

     

       79
       79
       +
           server.wait_for_open_port(${toString port})

     

       75
       80
        
       

     

       76
       76
       -
             # make sure pinnwand is listening

     

       77
       77
       -
             server.wait_for_open_port(${toString port})

     

       81
       81
       +
           # send the contents of /etc/machine-id

     

       82
       82
       +
           response = client.succeed("steck paste /etc/machine-id")

     

       78
       83
        
       

     

       79
       79
       -
             # send the contents of /etc/machine-id

     

       80
       80
       -
             response = client.succeed("steck paste /etc/machine-id")

     

       81
       81
       -
       

     

       82
       82
       -
             # parse the steck response

     

       83
       83
       -
             raw_url = None

     

       84
       84
       -
             removal_link = None

     

       85
       85
       -
             for line in response.split("\n"):

     

       86
       86
       -
                 if line.startswith("View link:"):

     

       87
       87
       -
                     raw_url = f"${baseUrl}/raw/{line.split('/')[-1]}"

     

       88
       88
       -
                 if line.startswith("Removal link:"):

     

       89
       89
       -
                     removal_link = line.split(":", 1)[1]

     

       84
       84
       +
           # parse the steck response

     

       85
       85
       +
           raw_url = None

     

       86
       86
       +
           removal_link = None

     

       87
       87
       +
           for line in response.split("\n"):

     

       88
       88
       +
               if line.startswith("View link:"):

     

       89
       89
       +
                   raw_url = f"${baseUrl}/raw/{line.split('/')[-1]}"

     

       90
       90
       +
               if line.startswith("Removal link:"):

     

       91
       91
       +
                   removal_link = line.split(":", 1)[1]

     

       90
       92
        
       

     

       91
       91
       -
             # check whether paste matches what we sent

     

       92
       92
       -
             client.succeed(f"curl {raw_url} > /tmp/machine-id")

     

       93
       93
       -
             client.succeed("diff /tmp/machine-id /etc/machine-id")

     

       93
       93
       +
           # check whether paste matches what we sent

     

       94
       94
       +
           client.succeed(f"curl {raw_url} > /tmp/machine-id")

     

       95
       95
       +
           client.succeed("diff /tmp/machine-id /etc/machine-id")

     

       94
       96
        
       

     

       95
       95
       -
             # remove paste and check that it's not available any more

     

       96
       96
       -
             client.succeed(f"curl {removal_link}")

     

       97
       97
       -
             client.fail(f"curl --fail {raw_url}")

     

       97
       97
       +
           # remove paste and check that it's not available any more

     

       98
       98
       +
           client.succeed(f"curl {removal_link}")

     

       99
       99
       +
           client.fail(f"curl --fail {raw_url}")

     

       98
       100
        
       

     

       99
       99
       -
             server.log(server.execute("systemd-analyze security pinnwand | grep '✗'")[1])

     

       100
       100
       -
           '';

     

       101
       101
       -
         }

     

       102
       102
       -
       )

     

       101
       101
       +
           server.log(server.execute("systemd-analyze security pinnwand | grep '✗'")[1])

     

       102
       102
       +
         '';

     

       103
       103
       +
       }

+79 -78

nixos/tests/snapcast.nix

···

       1
       1
       -
       import ./make-test-python.nix (

     

       2
       2
       -
         { pkgs, ... }:

     

       1
       1
       +
       {

     

       2
       2
       +
         pkgs,

     

       3
       3
       +
         ...

     

       4
       4
       +
       }:

     

       3
       5
        
       

     

       4
       4
       -
         let

     

       5
       5
       -
           port = 10004;

     

       6
       6
       -
           tcpPort = 10005;

     

       7
       7
       -
           httpPort = 10080;

     

       8
       8
       -
           tcpStreamPort = 10006;

     

       9
       9
       -
           bufferSize = 742;

     

       10
       10
       -
         in

     

       11
       11
       -
         {

     

       12
       12
       -
           name = "snapcast";

     

       13
       13
       -
           meta = with pkgs.lib.maintainers; {

     

       14
       14
       -
             maintainers = [ hexa ];

     

       15
       15
       -
           };

     

       6
       6
       +
       let

     

       7
       7
       +
         port = 10004;

     

       8
       8
       +
         tcpPort = 10005;

     

       9
       9
       +
         httpPort = 10080;

     

       10
       10
       +
         tcpStreamPort = 10006;

     

       11
       11
       +
         bufferSize = 742;

     

       12
       12
       +
       in

     

       13
       13
       +
       {

     

       14
       14
       +
         name = "snapcast";

     

       15
       15
       +
         meta = with pkgs.lib.maintainers; {

     

       16
       16
       +
           maintainers = [ hexa ];

     

       17
       17
       +
         };

     

       16
       18
        
       

     

       17
       17
       -
           nodes = {

     

       18
       18
       -
             server = {

     

       19
       19
       -
               services.snapserver = {

     

       20
       20
       -
                 enable = true;

     

       21
       21
       -
                 port = port;

     

       22
       22
       -
                 tcp.port = tcpPort;

     

       23
       23
       -
                 http.port = httpPort;

     

       24
       24
       -
                 openFirewall = true;

     

       25
       25
       -
                 buffer = bufferSize;

     

       26
       26
       -
                 streams = {

     

       27
       27
       -
                   mpd = {

     

       28
       28
       -
                     type = "pipe";

     

       29
       29
       -
                     location = "/run/snapserver/mpd";

     

       30
       30
       -
                     query.mode = "create";

     

       31
       31
       -
                   };

     

       32
       32
       -
                   bluetooth = {

     

       33
       33
       -
                     type = "pipe";

     

       34
       34
       -
                     location = "/run/snapserver/bluetooth";

     

       35
       35
       -
                   };

     

       36
       36
       -
                   tcp = {

     

       37
       37
       -
                     type = "tcp";

     

       38
       38
       -
                     location = "127.0.0.1:${toString tcpStreamPort}";

     

       39
       39
       -
                   };

     

       40
       40
       -
                   meta = {

     

       41
       41
       -
                     type = "meta";

     

       42
       42
       -
                     location = "/mpd/bluetooth/tcp";

     

       43
       43
       -
                   };

     

       19
       19
       +
         nodes = {

     

       20
       20
       +
           server = {

     

       21
       21
       +
             services.snapserver = {

     

       22
       22
       +
               enable = true;

     

       23
       23
       +
               port = port;

     

       24
       24
       +
               tcp.port = tcpPort;

     

       25
       25
       +
               http.port = httpPort;

     

       26
       26
       +
               openFirewall = true;

     

       27
       27
       +
               buffer = bufferSize;

     

       28
       28
       +
               streams = {

     

       29
       29
       +
                 mpd = {

     

       30
       30
       +
                   type = "pipe";

     

       31
       31
       +
                   location = "/run/snapserver/mpd";

     

       32
       32
       +
                   query.mode = "create";

     

       33
       33
       +
                 };

     

       34
       34
       +
                 bluetooth = {

     

       35
       35
       +
                   type = "pipe";

     

       36
       36
       +
                   location = "/run/snapserver/bluetooth";

     

       37
       37
       +
                 };

     

       38
       38
       +
                 tcp = {

     

       39
       39
       +
                   type = "tcp";

     

       40
       40
       +
                   location = "127.0.0.1:${toString tcpStreamPort}";

     

       41
       41
       +
                 };

     

       42
       42
       +
                 meta = {

     

       43
       43
       +
                   type = "meta";

     

       44
       44
       +
                   location = "/mpd/bluetooth/tcp";

     

       44
       45
        
                 };

     

       45
       46
        
               };

     

       46
       46
       -
               environment.systemPackages = [ pkgs.snapcast ];

     

       47
       47
        
             };

     

       48
       48
       -
             client = {

     

       49
       49
       -
               environment.systemPackages = [ pkgs.snapcast ];

     

       50
       50
       -
             };

     

       48
       48
       +
             environment.systemPackages = [ pkgs.snapcast ];

     

       51
       49
        
           };

     

       50
       50
       +
           client = {

     

       51
       51
       +
             environment.systemPackages = [ pkgs.snapcast ];

     

       52
       52
       +
           };

     

       53
       53
       +
         };

     

       52
       54
        
       

     

       53
       53
       -
           testScript = ''

     

       54
       54
       -
             import json

     

       55
       55
       +
         testScript = ''

     

       56
       56
       +
           import json

     

       55
       57
        
       

     

       56
       56
       -
             get_rpc_version = {"id": "1", "jsonrpc": "2.0", "method": "Server.GetRPCVersion"}

     

       58
       58
       +
           get_rpc_version = {"id": "1", "jsonrpc": "2.0", "method": "Server.GetRPCVersion"}

     

       57
       59
        
       

     

       58
       58
       -
             start_all()

     

       60
       60
       +
           start_all()

     

       59
       61
        
       

     

       60
       60
       -
             server.wait_for_unit("snapserver.service")

     

       61
       61
       -
             server.wait_until_succeeds("ss -ntl | grep -q ${toString port}")

     

       62
       62
       -
             server.wait_until_succeeds("ss -ntl | grep -q ${toString tcpPort}")

     

       63
       63
       -
             server.wait_until_succeeds("ss -ntl | grep -q ${toString httpPort}")

     

       64
       64
       -
             server.wait_until_succeeds("ss -ntl | grep -q ${toString tcpStreamPort}")

     

       62
       62
       +
           server.wait_for_unit("snapserver.service")

     

       63
       63
       +
           server.wait_until_succeeds("ss -ntl | grep -q ${toString port}")

     

       64
       64
       +
           server.wait_until_succeeds("ss -ntl | grep -q ${toString tcpPort}")

     

       65
       65
       +
           server.wait_until_succeeds("ss -ntl | grep -q ${toString httpPort}")

     

       66
       66
       +
           server.wait_until_succeeds("ss -ntl | grep -q ${toString tcpStreamPort}")

     

       65
       67
        
       

     

       66
       66
       -
             with subtest("check that pipes are created"):

     

       67
       67
       -
                 server.succeed("test -p /run/snapserver/mpd")

     

       68
       68
       -
                 server.succeed("test -p /run/snapserver/bluetooth")

     

       68
       68
       +
           with subtest("check that pipes are created"):

     

       69
       69
       +
               server.succeed("test -p /run/snapserver/mpd")

     

       70
       70
       +
               server.succeed("test -p /run/snapserver/bluetooth")

     

       69
       71
        
       

     

       70
       70
       -
             with subtest("test tcp json-rpc"):

     

       71
       71
       -
                 server.succeed(f"echo '{json.dumps(get_rpc_version)}' | nc -w 1 localhost ${toString tcpPort}")

     

       72
       72
       +
           with subtest("test tcp json-rpc"):

     

       73
       73
       +
               server.succeed(f"echo '{json.dumps(get_rpc_version)}' | nc -w 1 localhost ${toString tcpPort}")

     

       72
       74
        
       

     

       73
       73
       -
             with subtest("test http json-rpc"):

     

       74
       74
       -
                 server.succeed(

     

       75
       75
       -
                     "curl --fail http://localhost:${toString httpPort}/jsonrpc -d '{json.dumps(get_rpc_version)}'"

     

       76
       76
       -
                 )

     

       75
       75
       +
           with subtest("test http json-rpc"):

     

       76
       76
       +
               server.succeed(

     

       77
       77
       +
                   "curl --fail http://localhost:${toString httpPort}/jsonrpc -d '{json.dumps(get_rpc_version)}'"

     

       78
       78
       +
               )

     

       77
       79
        
       

     

       78
       78
       -
             with subtest("test a ipv6 connection"):

     

       79
       79
       -
                 server.execute("systemd-run --unit=snapcast-local-client snapclient -h ::1 -p ${toString port}")

     

       80
       80
       -
                 server.wait_until_succeeds(

     

       81
       81
       -
                     "journalctl -o cat -u snapserver.service | grep -q 'Hello from'"

     

       82
       82
       -
                 )

     

       83
       83
       -
                 server.wait_until_succeeds("journalctl -o cat -u snapcast-local-client | grep -q 'buffer: ${toString bufferSize}'")

     

       80
       80
       +
           with subtest("test a ipv6 connection"):

     

       81
       81
       +
               server.execute("systemd-run --unit=snapcast-local-client snapclient -h ::1 -p ${toString port}")

     

       82
       82
       +
               server.wait_until_succeeds(

     

       83
       83
       +
                   "journalctl -o cat -u snapserver.service | grep -q 'Hello from'"

     

       84
       84
       +
               )

     

       85
       85
       +
               server.wait_until_succeeds("journalctl -o cat -u snapcast-local-client | grep -q 'buffer: ${toString bufferSize}'")

     

       84
       86
        
       

     

       85
       85
       -
             with subtest("test a connection"):

     

       86
       86
       -
                 client.execute("systemd-run --unit=snapcast-client snapclient -h server -p ${toString port}")

     

       87
       87
       -
                 server.wait_until_succeeds(

     

       88
       88
       -
                     "journalctl -o cat -u snapserver.service | grep -q 'Hello from'"

     

       89
       89
       -
                 )

     

       90
       90
       -
                 client.wait_until_succeeds("journalctl -o cat -u snapcast-client | grep -q 'buffer: ${toString bufferSize}'")

     

       91
       91
       -
           '';

     

       92
       92
       -
         }

     

       93
       93
       -
       )

     

       87
       87
       +
           with subtest("test a connection"):

     

       88
       88
       +
               client.execute("systemd-run --unit=snapcast-client snapclient -h server -p ${toString port}")

     

       89
       89
       +
               server.wait_until_succeeds(

     

       90
       90
       +
                   "journalctl -o cat -u snapserver.service | grep -q 'Hello from'"

     

       91
       91
       +
               )

     

       92
       92
       +
               client.wait_until_succeeds("journalctl -o cat -u snapcast-client | grep -q 'buffer: ${toString bufferSize}'")

     

       93
       93
       +
         '';

     

       94
       94
       +
       }

+2 -3

pkgs/applications/editors/vim/plugins/non-generated/sniprun/default.nix

···

       14
       14
        
       

     

       15
       15
        
         # sniprun

     

       16
       16
        
         vimUtils,

     

       17
       17
       -
         substituteAll,

     

       17
       17
       +
         replaceVars,

     

       18
       18
        
         nix-update-script,

     

       19
       19
        
       }:

     

       20
       20
        
       let

     
···

       58
       58
        
         inherit version src;

     

       59
       59
        
       

     

       60
       60
        
         patches = [

     

       61
       61
       -
           (substituteAll {

     

       62
       62
       -
             src = ./fix-paths.patch;

     

       61
       61
       +
           (replaceVars ./fix-paths.patch {

     

       63
       62
        
             sniprun = lib.getExe sniprun-bin;

     

       64
       63
        
           })

     

       65
       64
        
         ];

+2 -2

pkgs/applications/editors/vscode/extensions/default.nix

···

       4301
       4301
        
               mktplcRef = {

     

       4302
       4302
        
                 name = "sas-lsp";

     

       4303
       4303
        
                 publisher = "SAS";

     

       4304
       4304
       -
                 version = "1.13.0";

     

       4305
       4305
       -
                 hash = "sha256-bcj9p/hvzZ1z03D1dXxiyPmGndh3pD7seI5VYHWsvzU=";

     

       4304
       4304
       +
                 version = "1.13.1";

     

       4305
       4305
       +
                 hash = "sha256-Ol79+z/W4RzAQ0jjDMkxPrg8eOWanOqtIF7ZxNrskOk=";

     

       4306
       4306
        
               };

     

       4307
       4307
        
               meta = {

     

       4308
       4308
        
                 changelog = "https://marketplace.visualstudio.com/items/SAS.sas-lsp/changelog";

+2 -2

pkgs/applications/emulators/dolphin-emu/default.nix

···

       55
       55
        
       

     

       56
       56
        
       stdenv.mkDerivation (finalAttrs: {

     

       57
       57
        
         pname = "dolphin-emu";

     

       58
       58
       -
         version = "2412";

     

       58
       58
       +
         version = "2503";

     

       59
       59
        
       

     

       60
       60
        
         src = fetchFromGitHub {

     

       61
       61
        
           owner = "dolphin-emu";

     

       62
       62
        
           repo = "dolphin";

     

       63
       63
        
           tag = finalAttrs.version;

     

       64
       64
       -
           hash = "sha256-5Eir8EQPGVSg2QXzzuHH9lf7CrV76KwmRsHiDqs6tD4=";

     

       64
       64
       +
           hash = "sha256-oqJKXFcsFgoYjUqdk3Z/CIFhOa8w0drcF4JwtHRI1Hs=";

     

       65
       65
        
           fetchSubmodules = true;

     

       66
       66
        
         };

     

       67
       67

+3 -3

pkgs/applications/graphics/ImageMagick/default.nix

···

       84
       84
        
       

     

       85
       85
        
       stdenv.mkDerivation (finalAttrs: {

     

       86
       86
        
         pname = "imagemagick";

     

       87
       87
       -
         version = "7.1.1-44";

     

       87
       87
       +
         version = "7.1.1-45";

     

       88
       88
        
       

     

       89
       89
        
         src = fetchFromGitHub {

     

       90
       90
        
           owner = "ImageMagick";

     

       91
       91
        
           repo = "ImageMagick";

     

       92
       92
       -
           rev = finalAttrs.version;

     

       93
       93
       -
           hash = "sha256-DsJRTLMyjU2mMEGq/2qEJvjdYa698TEZZqkxuWtd/A4=";

     

       92
       92
       +
           tag = finalAttrs.version;

     

       93
       93
       +
           hash = "sha256-7oE+fkozhTqTagcwpzttKLZoq4gT1nSib4JssRmz3YI=";

     

       94
       94
        
         };

     

       95
       95
        
       

     

       96
       96
        
         outputs = [

-1179

pkgs/applications/misc/anup/Cargo.lock

···

       1
       1
       -
       # This file is automatically @generated by Cargo.

     

       2
       2
       -
       # It is not intended for manual editing.

     

       3
       3
       -
       [[package]]

     

       4
       4
       -
       name = "anime"

     

       5
       5
       -
       version = "0.1.0"

     

       6
       6
       -
       dependencies = [

     

       7
       7
       -
        "attohttpc",

     

       8
       8
       -
        "base64 0.13.0",

     

       9
       9
       -
        "chrono",

     

       10
       10
       -
        "diesel",

     

       11
       11
       -
        "enum_dispatch",

     

       12
       12
       -
        "nom",

     

       13
       13
       -
        "serde",

     

       14
       14
       -
        "serde_derive",

     

       15
       15
       -
        "serde_json",

     

       16
       16
       -
        "smallvec",

     

       17
       17
       -
        "strsim",

     

       18
       18
       -
        "thiserror",

     

       19
       19
       -
       ]

     

       20
       20
       -
       

     

       21
       21
       -
       [[package]]

     

       22
       22
       -
       name = "anup"

     

       23
       23
       -
       version = "0.4.0"

     

       24
       24
       -
       dependencies = [

     

       25
       25
       -
        "anime",

     

       26
       26
       -
        "anyhow",

     

       27
       27
       -
        "argh",

     

       28
       28
       -
        "bincode",

     

       29
       29
       -
        "bitflags",

     

       30
       30
       -
        "chrono",

     

       31
       31
       -
        "crossterm 0.19.0",

     

       32
       32
       -
        "diesel",

     

       33
       33
       -
        "dirs-next",

     

       34
       34
       -
        "futures",

     

       35
       35
       -
        "once_cell",

     

       36
       36
       -
        "parking_lot",

     

       37
       37
       -
        "pico-args",

     

       38
       38
       -
        "ron",

     

       39
       39
       -
        "serde",

     

       40
       40
       -
        "serde_derive",

     

       41
       41
       -
        "smallvec",

     

       42
       42
       -
        "strsim",

     

       43
       43
       -
        "thiserror",

     

       44
       44
       -
        "tokio",

     

       45
       45
       -
        "tui",

     

       46
       46
       -
        "tui-utils",

     

       47
       47
       -
        "unicode-segmentation",

     

       48
       48
       -
        "unicode-width",

     

       49
       49
       -
       ]

     

       50
       50
       -
       

     

       51
       51
       -
       [[package]]

     

       52
       52
       -
       name = "anyhow"

     

       53
       53
       -
       version = "1.0.39"

     

       54
       54
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       55
       55
       -
       checksum = "81cddc5f91628367664cc7c69714ff08deee8a3efc54623011c772544d7b2767"

     

       56
       56
       -
       

     

       57
       57
       -
       [[package]]

     

       58
       58
       -
       name = "argh"

     

       59
       59
       -
       version = "0.1.4"

     

       60
       60
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       61
       61
       -
       checksum = "91792f088f87cdc7a2cfb1d617fa5ea18d7f1dc22ef0e1b5f82f3157cdc522be"

     

       62
       62
       -
       dependencies = [

     

       63
       63
       -
        "argh_derive",

     

       64
       64
       -
        "argh_shared",

     

       65
       65
       -
       ]

     

       66
       66
       -
       

     

       67
       67
       -
       [[package]]

     

       68
       68
       -
       name = "argh_derive"

     

       69
       69
       -
       version = "0.1.4"

     

       70
       70
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       71
       71
       -
       checksum = "c4eb0c0c120ad477412dc95a4ce31e38f2113e46bd13511253f79196ca68b067"

     

       72
       72
       -
       dependencies = [

     

       73
       73
       -
        "argh_shared",

     

       74
       74
       -
        "heck",

     

       75
       75
       -
        "proc-macro2",

     

       76
       76
       -
        "quote",

     

       77
       77
       -
        "syn",

     

       78
       78
       -
       ]

     

       79
       79
       -
       

     

       80
       80
       -
       [[package]]

     

       81
       81
       -
       name = "argh_shared"

     

       82
       82
       -
       version = "0.1.4"

     

       83
       83
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       84
       84
       -
       checksum = "781f336cc9826dbaddb9754cb5db61e64cab4f69668bd19dcc4a0394a86f4cb1"

     

       85
       85
       -
       

     

       86
       86
       -
       [[package]]

     

       87
       87
       -
       name = "arrayvec"

     

       88
       88
       -
       version = "0.5.2"

     

       89
       89
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       90
       90
       -
       checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"

     

       91
       91
       -
       

     

       92
       92
       -
       [[package]]

     

       93
       93
       -
       name = "attohttpc"

     

       94
       94
       -
       version = "0.16.3"

     

       95
       95
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       96
       96
       -
       checksum = "fdb8867f378f33f78a811a8eb9bf108ad99430d7aad43315dd9319c827ef6247"

     

       97
       97
       -
       dependencies = [

     

       98
       98
       -
        "http",

     

       99
       99
       -
        "log",

     

       100
       100
       -
        "rustls",

     

       101
       101
       -
        "serde",

     

       102
       102
       -
        "serde_json",

     

       103
       103
       -
        "url",

     

       104
       104
       -
        "webpki",

     

       105
       105
       -
        "webpki-roots",

     

       106
       106
       -
        "wildmatch",

     

       107
       107
       -
       ]

     

       108
       108
       -
       

     

       109
       109
       -
       [[package]]

     

       110
       110
       -
       name = "autocfg"

     

       111
       111
       -
       version = "1.0.1"

     

       112
       112
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       113
       113
       -
       checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"

     

       114
       114
       -
       

     

       115
       115
       -
       [[package]]

     

       116
       116
       -
       name = "base64"

     

       117
       117
       -
       version = "0.12.3"

     

       118
       118
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       119
       119
       -
       checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"

     

       120
       120
       -
       

     

       121
       121
       -
       [[package]]

     

       122
       122
       -
       name = "base64"

     

       123
       123
       -
       version = "0.13.0"

     

       124
       124
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       125
       125
       -
       checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"

     

       126
       126
       -
       

     

       127
       127
       -
       [[package]]

     

       128
       128
       -
       name = "bincode"

     

       129
       129
       -
       version = "1.3.2"

     

       130
       130
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       131
       131
       -
       checksum = "d175dfa69e619905c4c3cdb7c3c203fa3bdd5d51184e3afdb2742c0280493772"

     

       132
       132
       -
       dependencies = [

     

       133
       133
       -
        "byteorder",

     

       134
       134
       -
        "serde",

     

       135
       135
       -
       ]

     

       136
       136
       -
       

     

       137
       137
       -
       [[package]]

     

       138
       138
       -
       name = "bitflags"

     

       139
       139
       -
       version = "1.2.1"

     

       140
       140
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       141
       141
       -
       checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"

     

       142
       142
       -
       

     

       143
       143
       -
       [[package]]

     

       144
       144
       -
       name = "bitvec"

     

       145
       145
       -
       version = "0.19.5"

     

       146
       146
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       147
       147
       -
       checksum = "8942c8d352ae1838c9dda0b0ca2ab657696ef2232a20147cf1b30ae1a9cb4321"

     

       148
       148
       -
       dependencies = [

     

       149
       149
       -
        "funty",

     

       150
       150
       -
        "radium",

     

       151
       151
       -
        "tap",

     

       152
       152
       -
        "wyz",

     

       153
       153
       -
       ]

     

       154
       154
       -
       

     

       155
       155
       -
       [[package]]

     

       156
       156
       -
       name = "bumpalo"

     

       157
       157
       -
       version = "3.6.1"

     

       158
       158
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       159
       159
       -
       checksum = "63396b8a4b9de3f4fdfb320ab6080762242f66a8ef174c49d8e19b674db4cdbe"

     

       160
       160
       -
       

     

       161
       161
       -
       [[package]]

     

       162
       162
       -
       name = "byteorder"

     

       163
       163
       -
       version = "1.3.4"

     

       164
       164
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       165
       165
       -
       checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"

     

       166
       166
       -
       

     

       167
       167
       -
       [[package]]

     

       168
       168
       -
       name = "bytes"

     

       169
       169
       -
       version = "1.0.1"

     

       170
       170
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       171
       171
       -
       checksum = "b700ce4376041dcd0a327fd0097c41095743c4c8af8887265942faf1100bd040"

     

       172
       172
       -
       

     

       173
       173
       -
       [[package]]

     

       174
       174
       -
       name = "cassowary"

     

       175
       175
       -
       version = "0.3.0"

     

       176
       176
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       177
       177
       -
       checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53"

     

       178
       178
       -
       

     

       179
       179
       -
       [[package]]

     

       180
       180
       -
       name = "cc"

     

       181
       181
       -
       version = "1.0.67"

     

       182
       182
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       183
       183
       -
       checksum = "e3c69b077ad434294d3ce9f1f6143a2a4b89a8a2d54ef813d85003a4fd1137fd"

     

       184
       184
       -
       

     

       185
       185
       -
       [[package]]

     

       186
       186
       -
       name = "cfg-if"

     

       187
       187
       -
       version = "1.0.0"

     

       188
       188
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       189
       189
       -
       checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

     

       190
       190
       -
       

     

       191
       191
       -
       [[package]]

     

       192
       192
       -
       name = "chrono"

     

       193
       193
       -
       version = "0.4.19"

     

       194
       194
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       195
       195
       -
       checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"

     

       196
       196
       -
       dependencies = [

     

       197
       197
       -
        "libc",

     

       198
       198
       -
        "num-integer",

     

       199
       199
       -
        "num-traits",

     

       200
       200
       -
        "time",

     

       201
       201
       -
        "winapi",

     

       202
       202
       -
       ]

     

       203
       203
       -
       

     

       204
       204
       -
       [[package]]

     

       205
       205
       -
       name = "crossterm"

     

       206
       206
       -
       version = "0.18.2"

     

       207
       207
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       208
       208
       -
       checksum = "4e86d73f2a0b407b5768d10a8c720cf5d2df49a9efc10ca09176d201ead4b7fb"

     

       209
       209
       -
       dependencies = [

     

       210
       210
       -
        "bitflags",

     

       211
       211
       -
        "crossterm_winapi 0.6.2",

     

       212
       212
       -
        "lazy_static",

     

       213
       213
       -
        "libc",

     

       214
       214
       -
        "mio",

     

       215
       215
       -
        "parking_lot",

     

       216
       216
       -
        "signal-hook",

     

       217
       217
       -
        "winapi",

     

       218
       218
       -
       ]

     

       219
       219
       -
       

     

       220
       220
       -
       [[package]]

     

       221
       221
       -
       name = "crossterm"

     

       222
       222
       -
       version = "0.19.0"

     

       223
       223
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       224
       224
       -
       checksum = "7c36c10130df424b2f3552fcc2ddcd9b28a27b1e54b358b45874f88d1ca6888c"

     

       225
       225
       -
       dependencies = [

     

       226
       226
       -
        "bitflags",

     

       227
       227
       -
        "crossterm_winapi 0.7.0",

     

       228
       228
       -
        "futures-core",

     

       229
       229
       -
        "lazy_static",

     

       230
       230
       -
        "libc",

     

       231
       231
       -
        "mio",

     

       232
       232
       -
        "parking_lot",

     

       233
       233
       -
        "serde",

     

       234
       234
       -
        "signal-hook",

     

       235
       235
       -
        "winapi",

     

       236
       236
       -
       ]

     

       237
       237
       -
       

     

       238
       238
       -
       [[package]]

     

       239
       239
       -
       name = "crossterm_winapi"

     

       240
       240
       -
       version = "0.6.2"

     

       241
       241
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       242
       242
       -
       checksum = "c2265c3f8e080075d9b6417aa72293fc71662f34b4af2612d8d1b074d29510db"

     

       243
       243
       -
       dependencies = [

     

       244
       244
       -
        "winapi",

     

       245
       245
       -
       ]

     

       246
       246
       -
       

     

       247
       247
       -
       [[package]]

     

       248
       248
       -
       name = "crossterm_winapi"

     

       249
       249
       -
       version = "0.7.0"

     

       250
       250
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       251
       251
       -
       checksum = "0da8964ace4d3e4a044fd027919b2237000b24315a37c916f61809f1ff2140b9"

     

       252
       252
       -
       dependencies = [

     

       253
       253
       -
        "winapi",

     

       254
       254
       -
       ]

     

       255
       255
       -
       

     

       256
       256
       -
       [[package]]

     

       257
       257
       -
       name = "diesel"

     

       258
       258
       -
       version = "1.4.6"

     

       259
       259
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       260
       260
       -
       checksum = "047bfc4d5c3bd2ef6ca6f981941046113524b9a9f9a7cbdfdd7ff40f58e6f542"

     

       261
       261
       -
       dependencies = [

     

       262
       262
       -
        "byteorder",

     

       263
       263
       -
        "diesel_derives",

     

       264
       264
       -
        "libsqlite3-sys",

     

       265
       265
       -
       ]

     

       266
       266
       -
       

     

       267
       267
       -
       [[package]]

     

       268
       268
       -
       name = "diesel_derives"

     

       269
       269
       -
       version = "1.4.1"

     

       270
       270
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       271
       271
       -
       checksum = "45f5098f628d02a7a0f68ddba586fb61e80edec3bdc1be3b921f4ceec60858d3"

     

       272
       272
       -
       dependencies = [

     

       273
       273
       -
        "proc-macro2",

     

       274
       274
       -
        "quote",

     

       275
       275
       -
        "syn",

     

       276
       276
       -
       ]

     

       277
       277
       -
       

     

       278
       278
       -
       [[package]]

     

       279
       279
       -
       name = "dirs-next"

     

       280
       280
       -
       version = "2.0.0"

     

       281
       281
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       282
       282
       -
       checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"

     

       283
       283
       -
       dependencies = [

     

       284
       284
       -
        "cfg-if",

     

       285
       285
       -
        "dirs-sys-next",

     

       286
       286
       -
       ]

     

       287
       287
       -
       

     

       288
       288
       -
       [[package]]

     

       289
       289
       -
       name = "dirs-sys-next"

     

       290
       290
       -
       version = "0.1.2"

     

       291
       291
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       292
       292
       -
       checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"

     

       293
       293
       -
       dependencies = [

     

       294
       294
       -
        "libc",

     

       295
       295
       -
        "redox_users",

     

       296
       296
       -
        "winapi",

     

       297
       297
       -
       ]

     

       298
       298
       -
       

     

       299
       299
       -
       [[package]]

     

       300
       300
       -
       name = "enum_dispatch"

     

       301
       301
       -
       version = "0.3.5"

     

       302
       302
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       303
       303
       -
       checksum = "8946e241a7774d5327d92749c50806f275f57d031d2229ecbfd65469a8ad338e"

     

       304
       304
       -
       dependencies = [

     

       305
       305
       -
        "once_cell",

     

       306
       306
       -
        "proc-macro2",

     

       307
       307
       -
        "quote",

     

       308
       308
       -
        "syn",

     

       309
       309
       -
       ]

     

       310
       310
       -
       

     

       311
       311
       -
       [[package]]

     

       312
       312
       -
       name = "fnv"

     

       313
       313
       -
       version = "1.0.7"

     

       314
       314
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       315
       315
       -
       checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

     

       316
       316
       -
       

     

       317
       317
       -
       [[package]]

     

       318
       318
       -
       name = "form_urlencoded"

     

       319
       319
       -
       version = "1.0.1"

     

       320
       320
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       321
       321
       -
       checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"

     

       322
       322
       -
       dependencies = [

     

       323
       323
       -
        "matches",

     

       324
       324
       -
        "percent-encoding",

     

       325
       325
       -
       ]

     

       326
       326
       -
       

     

       327
       327
       -
       [[package]]

     

       328
       328
       -
       name = "funty"

     

       329
       329
       -
       version = "1.1.0"

     

       330
       330
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       331
       331
       -
       checksum = "fed34cd105917e91daa4da6b3728c47b068749d6a62c59811f06ed2ac71d9da7"

     

       332
       332
       -
       

     

       333
       333
       -
       [[package]]

     

       334
       334
       -
       name = "futures"

     

       335
       335
       -
       version = "0.3.13"

     

       336
       336
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       337
       337
       -
       checksum = "7f55667319111d593ba876406af7c409c0ebb44dc4be6132a783ccf163ea14c1"

     

       338
       338
       -
       dependencies = [

     

       339
       339
       -
        "futures-channel",

     

       340
       340
       -
        "futures-core",

     

       341
       341
       -
        "futures-executor",

     

       342
       342
       -
        "futures-io",

     

       343
       343
       -
        "futures-sink",

     

       344
       344
       -
        "futures-task",

     

       345
       345
       -
        "futures-util",

     

       346
       346
       -
       ]

     

       347
       347
       -
       

     

       348
       348
       -
       [[package]]

     

       349
       349
       -
       name = "futures-channel"

     

       350
       350
       -
       version = "0.3.13"

     

       351
       351
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       352
       352
       -
       checksum = "8c2dd2df839b57db9ab69c2c9d8f3e8c81984781937fe2807dc6dcf3b2ad2939"

     

       353
       353
       -
       dependencies = [

     

       354
       354
       -
        "futures-core",

     

       355
       355
       -
        "futures-sink",

     

       356
       356
       -
       ]

     

       357
       357
       -
       

     

       358
       358
       -
       [[package]]

     

       359
       359
       -
       name = "futures-core"

     

       360
       360
       -
       version = "0.3.13"

     

       361
       361
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       362
       362
       -
       checksum = "15496a72fabf0e62bdc3df11a59a3787429221dd0710ba8ef163d6f7a9112c94"

     

       363
       363
       -
       

     

       364
       364
       -
       [[package]]

     

       365
       365
       -
       name = "futures-executor"

     

       366
       366
       -
       version = "0.3.13"

     

       367
       367
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       368
       368
       -
       checksum = "891a4b7b96d84d5940084b2a37632dd65deeae662c114ceaa2c879629c9c0ad1"

     

       369
       369
       -
       dependencies = [

     

       370
       370
       -
        "futures-core",

     

       371
       371
       -
        "futures-task",

     

       372
       372
       -
        "futures-util",

     

       373
       373
       -
       ]

     

       374
       374
       -
       

     

       375
       375
       -
       [[package]]

     

       376
       376
       -
       name = "futures-io"

     

       377
       377
       -
       version = "0.3.13"

     

       378
       378
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       379
       379
       -
       checksum = "d71c2c65c57704c32f5241c1223167c2c3294fd34ac020c807ddbe6db287ba59"

     

       380
       380
       -
       

     

       381
       381
       -
       [[package]]

     

       382
       382
       -
       name = "futures-macro"

     

       383
       383
       -
       version = "0.3.13"

     

       384
       384
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       385
       385
       -
       checksum = "ea405816a5139fb39af82c2beb921d52143f556038378d6db21183a5c37fbfb7"

     

       386
       386
       -
       dependencies = [

     

       387
       387
       -
        "proc-macro-hack",

     

       388
       388
       -
        "proc-macro2",

     

       389
       389
       -
        "quote",

     

       390
       390
       -
        "syn",

     

       391
       391
       -
       ]

     

       392
       392
       -
       

     

       393
       393
       -
       [[package]]

     

       394
       394
       -
       name = "futures-sink"

     

       395
       395
       -
       version = "0.3.13"

     

       396
       396
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       397
       397
       -
       checksum = "85754d98985841b7d4f5e8e6fbfa4a4ac847916893ec511a2917ccd8525b8bb3"

     

       398
       398
       -
       

     

       399
       399
       -
       [[package]]

     

       400
       400
       -
       name = "futures-task"

     

       401
       401
       -
       version = "0.3.13"

     

       402
       402
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       403
       403
       -
       checksum = "fa189ef211c15ee602667a6fcfe1c1fd9e07d42250d2156382820fba33c9df80"

     

       404
       404
       -
       

     

       405
       405
       -
       [[package]]

     

       406
       406
       -
       name = "futures-util"

     

       407
       407
       -
       version = "0.3.13"

     

       408
       408
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       409
       409
       -
       checksum = "1812c7ab8aedf8d6f2701a43e1243acdbcc2b36ab26e2ad421eb99ac963d96d1"

     

       410
       410
       -
       dependencies = [

     

       411
       411
       -
        "futures-channel",

     

       412
       412
       -
        "futures-core",

     

       413
       413
       -
        "futures-io",

     

       414
       414
       -
        "futures-macro",

     

       415
       415
       -
        "futures-sink",

     

       416
       416
       -
        "futures-task",

     

       417
       417
       -
        "memchr",

     

       418
       418
       -
        "pin-project-lite",

     

       419
       419
       -
        "pin-utils",

     

       420
       420
       -
        "proc-macro-hack",

     

       421
       421
       -
        "proc-macro-nested",

     

       422
       422
       -
        "slab",

     

       423
       423
       -
       ]

     

       424
       424
       -
       

     

       425
       425
       -
       [[package]]

     

       426
       426
       -
       name = "getrandom"

     

       427
       427
       -
       version = "0.2.2"

     

       428
       428
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       429
       429
       -
       checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8"

     

       430
       430
       -
       dependencies = [

     

       431
       431
       -
        "cfg-if",

     

       432
       432
       -
        "libc",

     

       433
       433
       -
        "wasi",

     

       434
       434
       -
       ]

     

       435
       435
       -
       

     

       436
       436
       -
       [[package]]

     

       437
       437
       -
       name = "heck"

     

       438
       438
       -
       version = "0.3.2"

     

       439
       439
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       440
       440
       -
       checksum = "87cbf45460356b7deeb5e3415b5563308c0a9b057c85e12b06ad551f98d0a6ac"

     

       441
       441
       -
       dependencies = [

     

       442
       442
       -
        "unicode-segmentation",

     

       443
       443
       -
       ]

     

       444
       444
       -
       

     

       445
       445
       -
       [[package]]

     

       446
       446
       -
       name = "http"

     

       447
       447
       -
       version = "0.2.3"

     

       448
       448
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       449
       449
       -
       checksum = "7245cd7449cc792608c3c8a9eaf69bd4eabbabf802713748fd739c98b82f0747"

     

       450
       450
       -
       dependencies = [

     

       451
       451
       -
        "bytes",

     

       452
       452
       -
        "fnv",

     

       453
       453
       -
        "itoa",

     

       454
       454
       -
       ]

     

       455
       455
       -
       

     

       456
       456
       -
       [[package]]

     

       457
       457
       -
       name = "idna"

     

       458
       458
       -
       version = "0.2.2"

     

       459
       459
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       460
       460
       -
       checksum = "89829a5d69c23d348314a7ac337fe39173b61149a9864deabd260983aed48c21"

     

       461
       461
       -
       dependencies = [

     

       462
       462
       -
        "matches",

     

       463
       463
       -
        "unicode-bidi",

     

       464
       464
       -
        "unicode-normalization",

     

       465
       465
       -
       ]

     

       466
       466
       -
       

     

       467
       467
       -
       [[package]]

     

       468
       468
       -
       name = "instant"

     

       469
       469
       -
       version = "0.1.9"

     

       470
       470
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       471
       471
       -
       checksum = "61124eeebbd69b8190558df225adf7e4caafce0d743919e5d6b19652314ec5ec"

     

       472
       472
       -
       dependencies = [

     

       473
       473
       -
        "cfg-if",

     

       474
       474
       -
       ]

     

       475
       475
       -
       

     

       476
       476
       -
       [[package]]

     

       477
       477
       -
       name = "itoa"

     

       478
       478
       -
       version = "0.4.7"

     

       479
       479
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       480
       480
       -
       checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"

     

       481
       481
       -
       

     

       482
       482
       -
       [[package]]

     

       483
       483
       -
       name = "js-sys"

     

       484
       484
       -
       version = "0.3.49"

     

       485
       485
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       486
       486
       -
       checksum = "dc15e39392125075f60c95ba416f5381ff6c3a948ff02ab12464715adf56c821"

     

       487
       487
       -
       dependencies = [

     

       488
       488
       -
        "wasm-bindgen",

     

       489
       489
       -
       ]

     

       490
       490
       -
       

     

       491
       491
       -
       [[package]]

     

       492
       492
       -
       name = "lazy_static"

     

       493
       493
       -
       version = "1.4.0"

     

       494
       494
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       495
       495
       -
       checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

     

       496
       496
       -
       

     

       497
       497
       -
       [[package]]

     

       498
       498
       -
       name = "lexical-core"

     

       499
       499
       -
       version = "0.7.5"

     

       500
       500
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       501
       501
       -
       checksum = "21f866863575d0e1d654fbeeabdc927292fdf862873dc3c96c6f753357e13374"

     

       502
       502
       -
       dependencies = [

     

       503
       503
       -
        "arrayvec",

     

       504
       504
       -
        "bitflags",

     

       505
       505
       -
        "cfg-if",

     

       506
       506
       -
        "ryu",

     

       507
       507
       -
        "static_assertions",

     

       508
       508
       -
       ]

     

       509
       509
       -
       

     

       510
       510
       -
       [[package]]

     

       511
       511
       -
       name = "libc"

     

       512
       512
       -
       version = "0.2.90"

     

       513
       513
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       514
       514
       -
       checksum = "ba4aede83fc3617411dc6993bc8c70919750c1c257c6ca6a502aed6e0e2394ae"

     

       515
       515
       -
       

     

       516
       516
       -
       [[package]]

     

       517
       517
       -
       name = "libsqlite3-sys"

     

       518
       518
       -
       version = "0.20.1"

     

       519
       519
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       520
       520
       -
       checksum = "64d31059f22935e6c31830db5249ba2b7ecd54fd73a9909286f0a67aa55c2fbd"

     

       521
       521
       -
       dependencies = [

     

       522
       522
       -
        "pkg-config",

     

       523
       523
       -
        "vcpkg",

     

       524
       524
       -
       ]

     

       525
       525
       -
       

     

       526
       526
       -
       [[package]]

     

       527
       527
       -
       name = "lock_api"

     

       528
       528
       -
       version = "0.4.2"

     

       529
       529
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       530
       530
       -
       checksum = "dd96ffd135b2fd7b973ac026d28085defbe8983df057ced3eb4f2130b0831312"

     

       531
       531
       -
       dependencies = [

     

       532
       532
       -
        "scopeguard",

     

       533
       533
       -
       ]

     

       534
       534
       -
       

     

       535
       535
       -
       [[package]]

     

       536
       536
       -
       name = "log"

     

       537
       537
       -
       version = "0.4.14"

     

       538
       538
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       539
       539
       -
       checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"

     

       540
       540
       -
       dependencies = [

     

       541
       541
       -
        "cfg-if",

     

       542
       542
       -
       ]

     

       543
       543
       -
       

     

       544
       544
       -
       [[package]]

     

       545
       545
       -
       name = "matches"

     

       546
       546
       -
       version = "0.1.8"

     

       547
       547
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       548
       548
       -
       checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"

     

       549
       549
       -
       

     

       550
       550
       -
       [[package]]

     

       551
       551
       -
       name = "memchr"

     

       552
       552
       -
       version = "2.3.4"

     

       553
       553
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       554
       554
       -
       checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"

     

       555
       555
       -
       

     

       556
       556
       -
       [[package]]

     

       557
       557
       -
       name = "mio"

     

       558
       558
       -
       version = "0.7.10"

     

       559
       559
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       560
       560
       -
       checksum = "2182a122f3b7f3f5329cb1972cee089ba2459a0a80a56935e6e674f096f8d839"

     

       561
       561
       -
       dependencies = [

     

       562
       562
       -
        "libc",

     

       563
       563
       -
        "log",

     

       564
       564
       -
        "miow",

     

       565
       565
       -
        "ntapi",

     

       566
       566
       -
        "winapi",

     

       567
       567
       -
       ]

     

       568
       568
       -
       

     

       569
       569
       -
       [[package]]

     

       570
       570
       -
       name = "miow"

     

       571
       571
       -
       version = "0.3.6"

     

       572
       572
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       573
       573
       -
       checksum = "5a33c1b55807fbed163481b5ba66db4b2fa6cde694a5027be10fb724206c5897"

     

       574
       574
       -
       dependencies = [

     

       575
       575
       -
        "socket2",

     

       576
       576
       -
        "winapi",

     

       577
       577
       -
       ]

     

       578
       578
       -
       

     

       579
       579
       -
       [[package]]

     

       580
       580
       -
       name = "nom"

     

       581
       581
       -
       version = "6.1.2"

     

       582
       582
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       583
       583
       -
       checksum = "e7413f999671bd4745a7b624bd370a569fb6bc574b23c83a3c5ed2e453f3d5e2"

     

       584
       584
       -
       dependencies = [

     

       585
       585
       -
        "bitvec",

     

       586
       586
       -
        "funty",

     

       587
       587
       -
        "lexical-core",

     

       588
       588
       -
        "memchr",

     

       589
       589
       -
        "version_check",

     

       590
       590
       -
       ]

     

       591
       591
       -
       

     

       592
       592
       -
       [[package]]

     

       593
       593
       -
       name = "ntapi"

     

       594
       594
       -
       version = "0.3.6"

     

       595
       595
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       596
       596
       -
       checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44"

     

       597
       597
       -
       dependencies = [

     

       598
       598
       -
        "winapi",

     

       599
       599
       -
       ]

     

       600
       600
       -
       

     

       601
       601
       -
       [[package]]

     

       602
       602
       -
       name = "num-integer"

     

       603
       603
       -
       version = "0.1.44"

     

       604
       604
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       605
       605
       -
       checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"

     

       606
       606
       -
       dependencies = [

     

       607
       607
       -
        "autocfg",

     

       608
       608
       -
        "num-traits",

     

       609
       609
       -
       ]

     

       610
       610
       -
       

     

       611
       611
       -
       [[package]]

     

       612
       612
       -
       name = "num-traits"

     

       613
       613
       -
       version = "0.2.14"

     

       614
       614
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       615
       615
       -
       checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"

     

       616
       616
       -
       dependencies = [

     

       617
       617
       -
        "autocfg",

     

       618
       618
       -
       ]

     

       619
       619
       -
       

     

       620
       620
       -
       [[package]]

     

       621
       621
       -
       name = "once_cell"

     

       622
       622
       -
       version = "1.7.2"

     

       623
       623
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       624
       624
       -
       checksum = "af8b08b04175473088b46763e51ee54da5f9a164bc162f615b91bc179dbf15a3"

     

       625
       625
       -
       

     

       626
       626
       -
       [[package]]

     

       627
       627
       -
       name = "parking_lot"

     

       628
       628
       -
       version = "0.11.1"

     

       629
       629
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       630
       630
       -
       checksum = "6d7744ac029df22dca6284efe4e898991d28e3085c706c972bcd7da4a27a15eb"

     

       631
       631
       -
       dependencies = [

     

       632
       632
       -
        "instant",

     

       633
       633
       -
        "lock_api",

     

       634
       634
       -
        "parking_lot_core",

     

       635
       635
       -
       ]

     

       636
       636
       -
       

     

       637
       637
       -
       [[package]]

     

       638
       638
       -
       name = "parking_lot_core"

     

       639
       639
       -
       version = "0.8.3"

     

       640
       640
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       641
       641
       -
       checksum = "fa7a782938e745763fe6907fc6ba86946d72f49fe7e21de074e08128a99fb018"

     

       642
       642
       -
       dependencies = [

     

       643
       643
       -
        "cfg-if",

     

       644
       644
       -
        "instant",

     

       645
       645
       -
        "libc",

     

       646
       646
       -
        "redox_syscall",

     

       647
       647
       -
        "smallvec",

     

       648
       648
       -
        "winapi",

     

       649
       649
       -
       ]

     

       650
       650
       -
       

     

       651
       651
       -
       [[package]]

     

       652
       652
       -
       name = "percent-encoding"

     

       653
       653
       -
       version = "2.1.0"

     

       654
       654
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       655
       655
       -
       checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"

     

       656
       656
       -
       

     

       657
       657
       -
       [[package]]

     

       658
       658
       -
       name = "pico-args"

     

       659
       659
       -
       version = "0.4.0"

     

       660
       660
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       661
       661
       -
       checksum = "d70072c20945e1ab871c472a285fc772aefd4f5407723c206242f2c6f94595d6"

     

       662
       662
       -
       

     

       663
       663
       -
       [[package]]

     

       664
       664
       -
       name = "pin-project-lite"

     

       665
       665
       -
       version = "0.2.6"

     

       666
       666
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       667
       667
       -
       checksum = "dc0e1f259c92177c30a4c9d177246edd0a3568b25756a977d0632cf8fa37e905"

     

       668
       668
       -
       

     

       669
       669
       -
       [[package]]

     

       670
       670
       -
       name = "pin-utils"

     

       671
       671
       -
       version = "0.1.0"

     

       672
       672
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       673
       673
       -
       checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"

     

       674
       674
       -
       

     

       675
       675
       -
       [[package]]

     

       676
       676
       -
       name = "pkg-config"

     

       677
       677
       -
       version = "0.3.19"

     

       678
       678
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       679
       679
       -
       checksum = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c"

     

       680
       680
       -
       

     

       681
       681
       -
       [[package]]

     

       682
       682
       -
       name = "proc-macro-hack"

     

       683
       683
       -
       version = "0.5.19"

     

       684
       684
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       685
       685
       -
       checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"

     

       686
       686
       -
       

     

       687
       687
       -
       [[package]]

     

       688
       688
       -
       name = "proc-macro-nested"

     

       689
       689
       -
       version = "0.1.7"

     

       690
       690
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       691
       691
       -
       checksum = "bc881b2c22681370c6a780e47af9840ef841837bc98118431d4e1868bd0c1086"

     

       692
       692
       -
       

     

       693
       693
       -
       [[package]]

     

       694
       694
       -
       name = "proc-macro2"

     

       695
       695
       -
       version = "1.0.24"

     

       696
       696
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       697
       697
       -
       checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71"

     

       698
       698
       -
       dependencies = [

     

       699
       699
       -
        "unicode-xid",

     

       700
       700
       -
       ]

     

       701
       701
       -
       

     

       702
       702
       -
       [[package]]

     

       703
       703
       -
       name = "quote"

     

       704
       704
       -
       version = "1.0.9"

     

       705
       705
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       706
       706
       -
       checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"

     

       707
       707
       -
       dependencies = [

     

       708
       708
       -
        "proc-macro2",

     

       709
       709
       -
       ]

     

       710
       710
       -
       

     

       711
       711
       -
       [[package]]

     

       712
       712
       -
       name = "radium"

     

       713
       713
       -
       version = "0.5.3"

     

       714
       714
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       715
       715
       -
       checksum = "941ba9d78d8e2f7ce474c015eea4d9c6d25b6a3327f9832ee29a4de27f91bbb8"

     

       716
       716
       -
       

     

       717
       717
       -
       [[package]]

     

       718
       718
       -
       name = "redox_syscall"

     

       719
       719
       -
       version = "0.2.5"

     

       720
       720
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       721
       721
       -
       checksum = "94341e4e44e24f6b591b59e47a8a027df12e008d73fd5672dbea9cc22f4507d9"

     

       722
       722
       -
       dependencies = [

     

       723
       723
       -
        "bitflags",

     

       724
       724
       -
       ]

     

       725
       725
       -
       

     

       726
       726
       -
       [[package]]

     

       727
       727
       -
       name = "redox_users"

     

       728
       728
       -
       version = "0.4.0"

     

       729
       729
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       730
       730
       -
       checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64"

     

       731
       731
       -
       dependencies = [

     

       732
       732
       -
        "getrandom",

     

       733
       733
       -
        "redox_syscall",

     

       734
       734
       -
       ]

     

       735
       735
       -
       

     

       736
       736
       -
       [[package]]

     

       737
       737
       -
       name = "ring"

     

       738
       738
       -
       version = "0.16.20"

     

       739
       739
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       740
       740
       -
       checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"

     

       741
       741
       -
       dependencies = [

     

       742
       742
       -
        "cc",

     

       743
       743
       -
        "libc",

     

       744
       744
       -
        "once_cell",

     

       745
       745
       -
        "spin",

     

       746
       746
       -
        "untrusted",

     

       747
       747
       -
        "web-sys",

     

       748
       748
       -
        "winapi",

     

       749
       749
       -
       ]

     

       750
       750
       -
       

     

       751
       751
       -
       [[package]]

     

       752
       752
       -
       name = "ron"

     

       753
       753
       -
       version = "0.6.4"

     

       754
       754
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       755
       755
       -
       checksum = "064ea8613fb712a19faf920022ec8ddf134984f100090764a4e1d768f3827f1f"

     

       756
       756
       -
       dependencies = [

     

       757
       757
       -
        "base64 0.13.0",

     

       758
       758
       -
        "bitflags",

     

       759
       759
       -
        "serde",

     

       760
       760
       -
       ]

     

       761
       761
       -
       

     

       762
       762
       -
       [[package]]

     

       763
       763
       -
       name = "rustls"

     

       764
       764
       -
       version = "0.18.1"

     

       765
       765
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       766
       766
       -
       checksum = "5d1126dcf58e93cee7d098dbda643b5f92ed724f1f6a63007c1116eed6700c81"

     

       767
       767
       -
       dependencies = [

     

       768
       768
       -
        "base64 0.12.3",

     

       769
       769
       -
        "log",

     

       770
       770
       -
        "ring",

     

       771
       771
       -
        "sct",

     

       772
       772
       -
        "webpki",

     

       773
       773
       -
       ]

     

       774
       774
       -
       

     

       775
       775
       -
       [[package]]

     

       776
       776
       -
       name = "ryu"

     

       777
       777
       -
       version = "1.0.5"

     

       778
       778
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       779
       779
       -
       checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"

     

       780
       780
       -
       

     

       781
       781
       -
       [[package]]

     

       782
       782
       -
       name = "scopeguard"

     

       783
       783
       -
       version = "1.1.0"

     

       784
       784
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       785
       785
       -
       checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"

     

       786
       786
       -
       

     

       787
       787
       -
       [[package]]

     

       788
       788
       -
       name = "sct"

     

       789
       789
       -
       version = "0.6.0"

     

       790
       790
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       791
       791
       -
       checksum = "e3042af939fca8c3453b7af0f1c66e533a15a86169e39de2657310ade8f98d3c"

     

       792
       792
       -
       dependencies = [

     

       793
       793
       -
        "ring",

     

       794
       794
       -
        "untrusted",

     

       795
       795
       -
       ]

     

       796
       796
       -
       

     

       797
       797
       -
       [[package]]

     

       798
       798
       -
       name = "serde"

     

       799
       799
       -
       version = "1.0.124"

     

       800
       800
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       801
       801
       -
       checksum = "bd761ff957cb2a45fbb9ab3da6512de9de55872866160b23c25f1a841e99d29f"

     

       802
       802
       -
       dependencies = [

     

       803
       803
       -
        "serde_derive",

     

       804
       804
       -
       ]

     

       805
       805
       -
       

     

       806
       806
       -
       [[package]]

     

       807
       807
       -
       name = "serde_derive"

     

       808
       808
       -
       version = "1.0.124"

     

       809
       809
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       810
       810
       -
       checksum = "1800f7693e94e186f5e25a28291ae1570da908aff7d97a095dec1e56ff99069b"

     

       811
       811
       -
       dependencies = [

     

       812
       812
       -
        "proc-macro2",

     

       813
       813
       -
        "quote",

     

       814
       814
       -
        "syn",

     

       815
       815
       -
       ]

     

       816
       816
       -
       

     

       817
       817
       -
       [[package]]

     

       818
       818
       -
       name = "serde_json"

     

       819
       819
       -
       version = "1.0.64"

     

       820
       820
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       821
       821
       -
       checksum = "799e97dc9fdae36a5c8b8f2cae9ce2ee9fdce2058c57a93e6099d919fd982f79"

     

       822
       822
       -
       dependencies = [

     

       823
       823
       -
        "itoa",

     

       824
       824
       -
        "ryu",

     

       825
       825
       -
        "serde",

     

       826
       826
       -
       ]

     

       827
       827
       -
       

     

       828
       828
       -
       [[package]]

     

       829
       829
       -
       name = "signal-hook"

     

       830
       830
       -
       version = "0.1.17"

     

       831
       831
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       832
       832
       -
       checksum = "7e31d442c16f047a671b5a71e2161d6e68814012b7f5379d269ebd915fac2729"

     

       833
       833
       -
       dependencies = [

     

       834
       834
       -
        "libc",

     

       835
       835
       -
        "mio",

     

       836
       836
       -
        "signal-hook-registry",

     

       837
       837
       -
       ]

     

       838
       838
       -
       

     

       839
       839
       -
       [[package]]

     

       840
       840
       -
       name = "signal-hook-registry"

     

       841
       841
       -
       version = "1.3.0"

     

       842
       842
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       843
       843
       -
       checksum = "16f1d0fef1604ba8f7a073c7e701f213e056707210e9020af4528e0101ce11a6"

     

       844
       844
       -
       dependencies = [

     

       845
       845
       -
        "libc",

     

       846
       846
       -
       ]

     

       847
       847
       -
       

     

       848
       848
       -
       [[package]]

     

       849
       849
       -
       name = "slab"

     

       850
       850
       -
       version = "0.4.2"

     

       851
       851
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       852
       852
       -
       checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"

     

       853
       853
       -
       

     

       854
       854
       -
       [[package]]

     

       855
       855
       -
       name = "smallvec"

     

       856
       856
       -
       version = "1.6.1"

     

       857
       857
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       858
       858
       -
       checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"

     

       859
       859
       -
       

     

       860
       860
       -
       [[package]]

     

       861
       861
       -
       name = "socket2"

     

       862
       862
       -
       version = "0.3.19"

     

       863
       863
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       864
       864
       -
       checksum = "122e570113d28d773067fab24266b66753f6ea915758651696b6e35e49f88d6e"

     

       865
       865
       -
       dependencies = [

     

       866
       866
       -
        "cfg-if",

     

       867
       867
       -
        "libc",

     

       868
       868
       -
        "winapi",

     

       869
       869
       -
       ]

     

       870
       870
       -
       

     

       871
       871
       -
       [[package]]

     

       872
       872
       -
       name = "spin"

     

       873
       873
       -
       version = "0.5.2"

     

       874
       874
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       875
       875
       -
       checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"

     

       876
       876
       -
       

     

       877
       877
       -
       [[package]]

     

       878
       878
       -
       name = "static_assertions"

     

       879
       879
       -
       version = "1.1.0"

     

       880
       880
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       881
       881
       -
       checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"

     

       882
       882
       -
       

     

       883
       883
       -
       [[package]]

     

       884
       884
       -
       name = "strsim"

     

       885
       885
       -
       version = "0.10.0"

     

       886
       886
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       887
       887
       -
       checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"

     

       888
       888
       -
       

     

       889
       889
       -
       [[package]]

     

       890
       890
       -
       name = "syn"

     

       891
       891
       -
       version = "1.0.64"

     

       892
       892
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       893
       893
       -
       checksum = "3fd9d1e9976102a03c542daa2eff1b43f9d72306342f3f8b3ed5fb8908195d6f"

     

       894
       894
       -
       dependencies = [

     

       895
       895
       -
        "proc-macro2",

     

       896
       896
       -
        "quote",

     

       897
       897
       -
        "unicode-xid",

     

       898
       898
       -
       ]

     

       899
       899
       -
       

     

       900
       900
       -
       [[package]]

     

       901
       901
       -
       name = "tap"

     

       902
       902
       -
       version = "1.0.1"

     

       903
       903
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       904
       904
       -
       checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"

     

       905
       905
       -
       

     

       906
       906
       -
       [[package]]

     

       907
       907
       -
       name = "thiserror"

     

       908
       908
       -
       version = "1.0.24"

     

       909
       909
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       910
       910
       -
       checksum = "e0f4a65597094d4483ddaed134f409b2cb7c1beccf25201a9f73c719254fa98e"

     

       911
       911
       -
       dependencies = [

     

       912
       912
       -
        "thiserror-impl",

     

       913
       913
       -
       ]

     

       914
       914
       -
       

     

       915
       915
       -
       [[package]]

     

       916
       916
       -
       name = "thiserror-impl"

     

       917
       917
       -
       version = "1.0.24"

     

       918
       918
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       919
       919
       -
       checksum = "7765189610d8241a44529806d6fd1f2e0a08734313a35d5b3a556f92b381f3c0"

     

       920
       920
       -
       dependencies = [

     

       921
       921
       -
        "proc-macro2",

     

       922
       922
       -
        "quote",

     

       923
       923
       -
        "syn",

     

       924
       924
       -
       ]

     

       925
       925
       -
       

     

       926
       926
       -
       [[package]]

     

       927
       927
       -
       name = "time"

     

       928
       928
       -
       version = "0.1.43"

     

       929
       929
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       930
       930
       -
       checksum = "ca8a50ef2360fbd1eeb0ecd46795a87a19024eb4b53c5dc916ca1fd95fe62438"

     

       931
       931
       -
       dependencies = [

     

       932
       932
       -
        "libc",

     

       933
       933
       -
        "winapi",

     

       934
       934
       -
       ]

     

       935
       935
       -
       

     

       936
       936
       -
       [[package]]

     

       937
       937
       -
       name = "tinyvec"

     

       938
       938
       -
       version = "1.1.1"

     

       939
       939
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       940
       940
       -
       checksum = "317cca572a0e89c3ce0ca1f1bdc9369547fe318a683418e42ac8f59d14701023"

     

       941
       941
       -
       dependencies = [

     

       942
       942
       -
        "tinyvec_macros",

     

       943
       943
       -
       ]

     

       944
       944
       -
       

     

       945
       945
       -
       [[package]]

     

       946
       946
       -
       name = "tinyvec_macros"

     

       947
       947
       -
       version = "0.1.0"

     

       948
       948
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       949
       949
       -
       checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"

     

       950
       950
       -
       

     

       951
       951
       -
       [[package]]

     

       952
       952
       -
       name = "tokio"

     

       953
       953
       -
       version = "1.4.0"

     

       954
       954
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       955
       955
       -
       checksum = "134af885d758d645f0f0505c9a8b3f9bf8a348fd822e112ab5248138348f1722"

     

       956
       956
       -
       dependencies = [

     

       957
       957
       -
        "autocfg",

     

       958
       958
       -
        "bytes",

     

       959
       959
       -
        "libc",

     

       960
       960
       -
        "mio",

     

       961
       961
       -
        "once_cell",

     

       962
       962
       -
        "parking_lot",

     

       963
       963
       -
        "pin-project-lite",

     

       964
       964
       -
        "signal-hook-registry",

     

       965
       965
       -
        "winapi",

     

       966
       966
       -
       ]

     

       967
       967
       -
       

     

       968
       968
       -
       [[package]]

     

       969
       969
       -
       name = "tui"

     

       970
       970
       -
       version = "0.14.0"

     

       971
       971
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       972
       972
       -
       checksum = "9ced152a8e9295a5b168adc254074525c17ac4a83c90b2716274cc38118bddc9"

     

       973
       973
       -
       dependencies = [

     

       974
       974
       -
        "bitflags",

     

       975
       975
       -
        "cassowary",

     

       976
       976
       -
        "crossterm 0.18.2",

     

       977
       977
       -
        "unicode-segmentation",

     

       978
       978
       -
        "unicode-width",

     

       979
       979
       -
       ]

     

       980
       980
       -
       

     

       981
       981
       -
       [[package]]

     

       982
       982
       -
       name = "tui-utils"

     

       983
       983
       -
       version = "0.10.0"

     

       984
       984
       -
       source = "git+https://github.com/Acizza/tui-utils?rev=0.10.0#109a7f264b0c160799552d209fffaee0c3f1c703"

     

       985
       985
       -
       dependencies = [

     

       986
       986
       -
        "smallvec",

     

       987
       987
       -
        "tui",

     

       988
       988
       -
        "unicode-segmentation",

     

       989
       989
       -
        "unicode-width",

     

       990
       990
       -
       ]

     

       991
       991
       -
       

     

       992
       992
       -
       [[package]]

     

       993
       993
       -
       name = "unicode-bidi"

     

       994
       994
       -
       version = "0.3.4"

     

       995
       995
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       996
       996
       -
       checksum = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"

     

       997
       997
       -
       dependencies = [

     

       998
       998
       -
        "matches",

     

       999
       999
       -
       ]

     

       1000
       1000
       -
       

     

       1001
       1001
       -
       [[package]]

     

       1002
       1002
       -
       name = "unicode-normalization"

     

       1003
       1003
       -
       version = "0.1.17"

     

       1004
       1004
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1005
       1005
       -
       checksum = "07fbfce1c8a97d547e8b5334978438d9d6ec8c20e38f56d4a4374d181493eaef"

     

       1006
       1006
       -
       dependencies = [

     

       1007
       1007
       -
        "tinyvec",

     

       1008
       1008
       -
       ]

     

       1009
       1009
       -
       

     

       1010
       1010
       -
       [[package]]

     

       1011
       1011
       -
       name = "unicode-segmentation"

     

       1012
       1012
       -
       version = "1.7.1"

     

       1013
       1013
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1014
       1014
       -
       checksum = "bb0d2e7be6ae3a5fa87eed5fb451aff96f2573d2694942e40543ae0bbe19c796"

     

       1015
       1015
       -
       

     

       1016
       1016
       -
       [[package]]

     

       1017
       1017
       -
       name = "unicode-width"

     

       1018
       1018
       -
       version = "0.1.8"

     

       1019
       1019
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1020
       1020
       -
       checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"

     

       1021
       1021
       -
       

     

       1022
       1022
       -
       [[package]]

     

       1023
       1023
       -
       name = "unicode-xid"

     

       1024
       1024
       -
       version = "0.2.1"

     

       1025
       1025
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1026
       1026
       -
       checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"

     

       1027
       1027
       -
       

     

       1028
       1028
       -
       [[package]]

     

       1029
       1029
       -
       name = "untrusted"

     

       1030
       1030
       -
       version = "0.7.1"

     

       1031
       1031
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1032
       1032
       -
       checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"

     

       1033
       1033
       -
       

     

       1034
       1034
       -
       [[package]]

     

       1035
       1035
       -
       name = "url"

     

       1036
       1036
       -
       version = "2.2.1"

     

       1037
       1037
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1038
       1038
       -
       checksum = "9ccd964113622c8e9322cfac19eb1004a07e636c545f325da085d5cdde6f1f8b"

     

       1039
       1039
       -
       dependencies = [

     

       1040
       1040
       -
        "form_urlencoded",

     

       1041
       1041
       -
        "idna",

     

       1042
       1042
       -
        "matches",

     

       1043
       1043
       -
        "percent-encoding",

     

       1044
       1044
       -
       ]

     

       1045
       1045
       -
       

     

       1046
       1046
       -
       [[package]]

     

       1047
       1047
       -
       name = "vcpkg"

     

       1048
       1048
       -
       version = "0.2.11"

     

       1049
       1049
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1050
       1050
       -
       checksum = "b00bca6106a5e23f3eee943593759b7fcddb00554332e856d990c893966879fb"

     

       1051
       1051
       -
       

     

       1052
       1052
       -
       [[package]]

     

       1053
       1053
       -
       name = "version_check"

     

       1054
       1054
       -
       version = "0.9.3"

     

       1055
       1055
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1056
       1056
       -
       checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"

     

       1057
       1057
       -
       

     

       1058
       1058
       -
       [[package]]

     

       1059
       1059
       -
       name = "wasi"

     

       1060
       1060
       -
       version = "0.10.2+wasi-snapshot-preview1"

     

       1061
       1061
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1062
       1062
       -
       checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"

     

       1063
       1063
       -
       

     

       1064
       1064
       -
       [[package]]

     

       1065
       1065
       -
       name = "wasm-bindgen"

     

       1066
       1066
       -
       version = "0.2.72"

     

       1067
       1067
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1068
       1068
       -
       checksum = "8fe8f61dba8e5d645a4d8132dc7a0a66861ed5e1045d2c0ed940fab33bac0fbe"

     

       1069
       1069
       -
       dependencies = [

     

       1070
       1070
       -
        "cfg-if",

     

       1071
       1071
       -
        "wasm-bindgen-macro",

     

       1072
       1072
       -
       ]

     

       1073
       1073
       -
       

     

       1074
       1074
       -
       [[package]]

     

       1075
       1075
       -
       name = "wasm-bindgen-backend"

     

       1076
       1076
       -
       version = "0.2.72"

     

       1077
       1077
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1078
       1078
       -
       checksum = "046ceba58ff062da072c7cb4ba5b22a37f00a302483f7e2a6cdc18fedbdc1fd3"

     

       1079
       1079
       -
       dependencies = [

     

       1080
       1080
       -
        "bumpalo",

     

       1081
       1081
       -
        "lazy_static",

     

       1082
       1082
       -
        "log",

     

       1083
       1083
       -
        "proc-macro2",

     

       1084
       1084
       -
        "quote",

     

       1085
       1085
       -
        "syn",

     

       1086
       1086
       -
        "wasm-bindgen-shared",

     

       1087
       1087
       -
       ]

     

       1088
       1088
       -
       

     

       1089
       1089
       -
       [[package]]

     

       1090
       1090
       -
       name = "wasm-bindgen-macro"

     

       1091
       1091
       -
       version = "0.2.72"

     

       1092
       1092
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1093
       1093
       -
       checksum = "0ef9aa01d36cda046f797c57959ff5f3c615c9cc63997a8d545831ec7976819b"

     

       1094
       1094
       -
       dependencies = [

     

       1095
       1095
       -
        "quote",

     

       1096
       1096
       -
        "wasm-bindgen-macro-support",

     

       1097
       1097
       -
       ]

     

       1098
       1098
       -
       

     

       1099
       1099
       -
       [[package]]

     

       1100
       1100
       -
       name = "wasm-bindgen-macro-support"

     

       1101
       1101
       -
       version = "0.2.72"

     

       1102
       1102
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1103
       1103
       -
       checksum = "96eb45c1b2ee33545a813a92dbb53856418bf7eb54ab34f7f7ff1448a5b3735d"

     

       1104
       1104
       -
       dependencies = [

     

       1105
       1105
       -
        "proc-macro2",

     

       1106
       1106
       -
        "quote",

     

       1107
       1107
       -
        "syn",

     

       1108
       1108
       -
        "wasm-bindgen-backend",

     

       1109
       1109
       -
        "wasm-bindgen-shared",

     

       1110
       1110
       -
       ]

     

       1111
       1111
       -
       

     

       1112
       1112
       -
       [[package]]

     

       1113
       1113
       -
       name = "wasm-bindgen-shared"

     

       1114
       1114
       -
       version = "0.2.72"

     

       1115
       1115
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1116
       1116
       -
       checksum = "b7148f4696fb4960a346eaa60bbfb42a1ac4ebba21f750f75fc1375b098d5ffa"

     

       1117
       1117
       -
       

     

       1118
       1118
       -
       [[package]]

     

       1119
       1119
       -
       name = "web-sys"

     

       1120
       1120
       -
       version = "0.3.49"

     

       1121
       1121
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1122
       1122
       -
       checksum = "59fe19d70f5dacc03f6e46777213facae5ac3801575d56ca6cbd4c93dcd12310"

     

       1123
       1123
       -
       dependencies = [

     

       1124
       1124
       -
        "js-sys",

     

       1125
       1125
       -
        "wasm-bindgen",

     

       1126
       1126
       -
       ]

     

       1127
       1127
       -
       

     

       1128
       1128
       -
       [[package]]

     

       1129
       1129
       -
       name = "webpki"

     

       1130
       1130
       -
       version = "0.21.4"

     

       1131
       1131
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1132
       1132
       -
       checksum = "b8e38c0608262c46d4a56202ebabdeb094cef7e560ca7a226c6bf055188aa4ea"

     

       1133
       1133
       -
       dependencies = [

     

       1134
       1134
       -
        "ring",

     

       1135
       1135
       -
        "untrusted",

     

       1136
       1136
       -
       ]

     

       1137
       1137
       -
       

     

       1138
       1138
       -
       [[package]]

     

       1139
       1139
       -
       name = "webpki-roots"

     

       1140
       1140
       -
       version = "0.19.0"

     

       1141
       1141
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1142
       1142
       -
       checksum = "f8eff4b7516a57307f9349c64bf34caa34b940b66fed4b2fb3136cb7386e5739"

     

       1143
       1143
       -
       dependencies = [

     

       1144
       1144
       -
        "webpki",

     

       1145
       1145
       -
       ]

     

       1146
       1146
       -
       

     

       1147
       1147
       -
       [[package]]

     

       1148
       1148
       -
       name = "wildmatch"

     

       1149
       1149
       -
       version = "1.1.0"

     

       1150
       1150
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1151
       1151
       -
       checksum = "7f44b95f62d34113cf558c93511ac93027e03e9c29a60dd0fd70e6e025c7270a"

     

       1152
       1152
       -
       

     

       1153
       1153
       -
       [[package]]

     

       1154
       1154
       -
       name = "winapi"

     

       1155
       1155
       -
       version = "0.3.9"

     

       1156
       1156
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1157
       1157
       -
       checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"

     

       1158
       1158
       -
       dependencies = [

     

       1159
       1159
       -
        "winapi-i686-pc-windows-gnu",

     

       1160
       1160
       -
        "winapi-x86_64-pc-windows-gnu",

     

       1161
       1161
       -
       ]

     

       1162
       1162
       -
       

     

       1163
       1163
       -
       [[package]]

     

       1164
       1164
       -
       name = "winapi-i686-pc-windows-gnu"

     

       1165
       1165
       -
       version = "0.4.0"

     

       1166
       1166
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1167
       1167
       -
       checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

     

       1168
       1168
       -
       

     

       1169
       1169
       -
       [[package]]

     

       1170
       1170
       -
       name = "winapi-x86_64-pc-windows-gnu"

     

       1171
       1171
       -
       version = "0.4.0"

     

       1172
       1172
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1173
       1173
       -
       checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

     

       1174
       1174
       -
       

     

       1175
       1175
       -
       [[package]]

     

       1176
       1176
       -
       name = "wyz"

     

       1177
       1177
       -
       version = "0.2.0"

     

       1178
       1178
       -
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1179
       1179
       -
       checksum = "85e60b0d1b5f99db2556934e21937020776a5d31520bf169e851ac44e6420214"

+3 -3

pkgs/applications/networking/cluster/roxctl/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "roxctl";

     

       5
       5
       -
         version = "4.6.2";

     

       5
       5
       +
         version = "4.6.3";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "stackrox";

     

       9
       9
        
           repo = "stackrox";

     

       10
       10
        
           rev = version;

     

       11
       11
       -
           sha256 = "sha256-UgwWNacoPSMtZBLnGh/e7tIgXksBgBcCyZJ3XpKUapQ=";

     

       11
       11
       +
           sha256 = "sha256-QrQLIqP70IUDY9lOZ0cTBIRYY8mVVW4sRt8522y/q80=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorHash = "sha256-NqPon1S0GzdyIDMNejIXmlkppR8DnXWNdXuyuiA2Vxo=";

     

       14
       14
       +
         vendorHash = "sha256-Zuln5na8MrL+IVOk+NOBrrYJIQ3RincJRYgpAd1WiS8=";

     

       15
       15
        
       

     

       16
       16
        
         nativeBuildInputs = [ installShellFiles ];

     

       17
       17

+59 -2

pkgs/applications/science/math/weka/default.nix

···

       5
       5
        
         jre,

     

       6
       6
        
         unzip,

     

       7
       7
        
         makeWrapper,

     

       8
       8
       +
         makeDesktopItem,

     

       9
       9
       +
         copyDesktopItems,

     

       10
       10
       +
         xdg-utils,

     

       11
       11
       +
         imagemagick,

     

       12
       12
       +
         maxMemoryAllocationPool ? "1000M",

     

       8
       13
        
       }:

     

       9
       14
        
       

     

       10
       15
        
       stdenv.mkDerivation rec {

     
···

       19
       24
        
         nativeBuildInputs = [

     

       20
       25
        
           makeWrapper

     

       21
       26
        
           unzip

     

       22
       22
       -
         ];

     

       27
       27
       +
           imagemagick

     

       28
       28
       +
         ] ++ lib.optionals stdenv.hostPlatform.isLinux [ copyDesktopItems ];

     

       23
       29
        
       

     

       24
       30
        
         # The -Xmx1000M comes suggested from their download page:

     

       25
       31
        
         # https://www.cs.waikato.ac.nz/ml/weka/downloading.html

     

       26
       32
        
         installPhase = ''

     

       33
       33
       +
           runHook preInstall

     

       34
       34
       +
       

     

       27
       35
        
           mkdir -pv $out/share/weka

     

       36
       36
       +
           mkdir -p $out/share/icons/hicolor

     

       28
       37
        
           cp -Rv * $out/share/weka

     

       29
       38
        
       

     

       30
       39
        
           makeWrapper ${jre}/bin/java $out/bin/weka \

     

       31
       31
       -
             --add-flags "-Xmx1000M -jar $out/share/weka/weka.jar"

     

       40
       40
       +
             --add-flags "-Xmx${maxMemoryAllocationPool} -jar $out/share/weka/weka.jar"

     

       41
       41
       +
       

     

       42
       42
       +
           makeWrapper ${jre}/bin/java $out/bin/weka-java \

     

       43
       43
       +
             --add-flags "-Xmx${maxMemoryAllocationPool} -cp $out/share/weka/weka.jar"

     

       44
       44
       +
       

     

       45
       45
       +
           ${lib.optionalString stdenv.hostPlatform.isLinux "

     

       46
       46
       +
               makeWrapper ${xdg-utils}/bin/xdg-open $out/bin/weka-doc --add-flags $out/share/weka/documentation.html

     

       47
       47
       +
           "}

     

       48
       48
       +
       

     

       49
       49
       +
           cat << EOF > $out/bin/weka-home

     

       50
       50
       +
           #!${stdenv.shell}

     

       51
       51
       +
           echo -n $out/share/weka

     

       52
       52
       +
           EOF

     

       53
       53
       +
       

     

       54
       54
       +
           chmod ugo+x $out/bin/weka-home

     

       55
       55
       +
       

     

       56
       56
       +
           for n in 16 24 32 48 64 96 128 256; do

     

       57
       57
       +
             size=$n"x"$n

     

       58
       58
       +
             mkdir -p $out/share/icons/hicolor/$size/apps

     

       59
       59
       +
             magick convert $out/share/weka/weka.gif -resize $size $out/share/icons/hicolor/$size/apps/weka.png

     

       60
       60
       +
           done;

     

       61
       61
       +
       

     

       62
       62
       +
           runHook postInstall

     

       32
       63
        
         '';

     

       64
       64
       +
       

     

       65
       65
       +
         desktopItems = [

     

       66
       66
       +
           (makeDesktopItem {

     

       67
       67
       +
             name = "weka";

     

       68
       68
       +
             exec = "weka";

     

       69
       69
       +
             icon = "weka";

     

       70
       70
       +
             desktopName = "WEKA";

     

       71
       71
       +
             categories = [

     

       72
       72
       +
               "Science"

     

       73
       73
       +
               "ArtificialIntelligence"

     

       74
       74
       +
               "ComputerScience"

     

       75
       75
       +
             ];

     

       76
       76
       +
           })

     

       77
       77
       +
       

     

       78
       78
       +
           (makeDesktopItem {

     

       79
       79
       +
             name = "weka-doc";

     

       80
       80
       +
             exec = "weka-doc";

     

       81
       81
       +
             icon = "weka";

     

       82
       82
       +
             desktopName = "View the WEKA documentation with a web browser";

     

       83
       83
       +
             categories = [

     

       84
       84
       +
               "Science"

     

       85
       85
       +
               "ArtificialIntelligence"

     

       86
       86
       +
               "ComputerScience"

     

       87
       87
       +
             ];

     

       88
       88
       +
           })

     

       89
       89
       +
         ];

     

       33
       90
        
       

     

       34
       91
        
         meta = with lib; {

     

       35
       92
        
           homepage = "https://www.cs.waikato.ac.nz/ml/weka/";

+3 -3

pkgs/by-name/ai/aiken/package.nix

···

       10
       10
        
       

     

       11
       11
        
       rustPlatform.buildRustPackage rec {

     

       12
       12
        
         pname = "aiken";

     

       13
       13
       -
         version = "1.1.12";

     

       13
       13
       +
         version = "1.1.13";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchFromGitHub {

     

       16
       16
        
           owner = "aiken-lang";

     

       17
       17
        
           repo = "aiken";

     

       18
       18
        
           rev = "v${version}";

     

       19
       19
       -
           hash = "sha256-QxIkqS+lqZjyuXUghSSd+4ud4Vrce7MgLrk2a5AQGmU=";

     

       19
       19
       +
           hash = "sha256-es1opcYGoryRLpEPJuuuusTSVDnNAoEoGLg+LB8VnM0=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         useFetchCargoVendor = true;

     

       23
       23
       -
         cargoHash = "sha256-vbwYoBDTdAHCpCOJEdVo9Ir8wd4284pgYjyQuy/STHc=";

     

       23
       23
       +
         cargoHash = "sha256-g4DHkHw6Nog+ZtquvVaRaZdfcuH/ReLYsLeARbnCqac=";

     

       24
       24
        
       

     

       25
       25
        
         buildInputs =

     

       26
       26
        
           [ openssl ]

+1 -1

pkgs/by-name/al/alacritty-theme/package.nix

···

       25
       25
        
         sourceRoot = "${self.src.name}/themes";

     

       26
       26
        
         installPhase = ''

     

       27
       27
        
           runHook preInstall

     

       28
       28
       -
           install -Dt $out *.toml

     

       28
       28
       +
           install -Dt $out/share/alacritty-theme *.toml

     

       29
       29
        
           runHook postInstall

     

       30
       30
        
         '';

     

       31
       31

+4 -4

pkgs/by-name/at/atproto-goat/package.nix

···

       7
       7
        
       

     

       8
       8
        
       buildGoModule rec {

     

       9
       9
        
         pname = "atproto-goat";

     

       10
       10
       -
         version = "0-unstable-2024-10-29";

     

       10
       10
       +
         version = "0-unstable-2025-02-01";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "bluesky-social";

     

       14
       14
        
           repo = "indigo";

     

       15
       15
       -
           rev = "983ce4a481a32a3eb2944c4c76e885d0f6006f83";

     

       16
       16
       -
           hash = "sha256-Jo3pI4uRyKh3yV03ijOcg+Uyu75Spmy/VS116MVgleU=";

     

       15
       15
       +
           rev = "fd270fbccf0ca858ed2eccdeff246a303c0be045";

     

       16
       16
       +
           hash = "sha256-1WK3tMz8WbuIGTHYwD0or+9D0KVezhnv3EDdK11KKp8=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         postPatch = ''

     
···

       22
       22
        
             --replace-fail '"github.com/carlmjohnson/versioninfo"' ""

     

       23
       23
        
         '';

     

       24
       24
        
       

     

       25
       25
       -
         vendorHash = "sha256-T+jtxubVKskrLGTUa4RI24o/WTSFCBk60HhyCFujPOI=";

     

       25
       25
       +
         vendorHash = "sha256-pGc29fgJFq8LP7n/pY1cv6ExZl88PAeFqIbFEhB3xXs=";

     

       26
       26
        
       

     

       27
       27
        
         subPackages = [ "cmd/goat" ];

     

       28
       28

+2 -2

pkgs/by-name/au/audacity/package.nix

···

       61
       61
        
       

     

       62
       62
        
       stdenv.mkDerivation (finalAttrs: {

     

       63
       63
        
         pname = "audacity";

     

       64
       64
       -
         version = "3.7.1";

     

       64
       64
       +
         version = "3.7.2";

     

       65
       65
        
       

     

       66
       66
        
         src = fetchFromGitHub {

     

       67
       67
        
           owner = "audacity";

     

       68
       68
        
           repo = "audacity";

     

       69
       69
        
           rev = "Audacity-${finalAttrs.version}";

     

       70
       70
       -
           hash = "sha256-QKydqpkqG7znBEdtVEayC2SyNGU8tQX6AfxdeJN8tDg=";

     

       70
       70
       +
           hash = "sha256-uRFLtjawMI5mHvlQNWkqSICPKbTiwp2bnBBsuj2JAP8=";

     

       71
       71
        
         };

     

       72
       72
        
       

     

       73
       73
        
         postPatch =

+3 -3

pkgs/by-name/ca/cargo-deb/package.nix

···

       8
       8
        
       

     

       9
       9
        
       rustPlatform.buildRustPackage rec {

     

       10
       10
        
         pname = "cargo-deb";

     

       11
       11
       -
         version = "2.11.2";

     

       11
       11
       +
         version = "2.11.3";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "kornelski";

     

       15
       15
        
           repo = pname;

     

       16
       16
        
           rev = "v${version}";

     

       17
       17
       -
           hash = "sha256-I8b14fB/m5fYPLIpXnhYGsLaKXs7F9NW2mjHxng6AHU=";

     

       17
       17
       +
           hash = "sha256-QDx7ZP/5z1YgD3RzLmwDE3KLY+5nMncYy97aveFH03w=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         useFetchCargoVendor = true;

     

       21
       21
       -
         cargoHash = "sha256-o9VN1D3OoqochtpNApE5N+g7xw/QOTbzwSKVPwzzDow=";

     

       21
       21
       +
         cargoHash = "sha256-ZN0TAQzt7LrHxoM4qAuMUm5Goaq1BuNBmd4kDGjiK4Q=";

     

       22
       22
        
       

     

       23
       23
        
         nativeBuildInputs = [

     

       24
       24
        
           makeWrapper

+3 -3

pkgs/by-name/ca/cargo-update/package.nix

···

       17
       17
        
       

     

       18
       18
        
       rustPlatform.buildRustPackage rec {

     

       19
       19
        
         pname = "cargo-update";

     

       20
       20
       -
         version = "16.1.0";

     

       20
       20
       +
         version = "16.2.0";

     

       21
       21
        
       

     

       22
       22
        
         src = fetchCrate {

     

       23
       23
        
           inherit pname version;

     

       24
       24
       -
           hash = "sha256-bdIFenNMW5iDQaKS2+lMYVVfc0zpbYNOHQqczpjBNC4=";

     

       24
       24
       +
           hash = "sha256-dO8A4XAFms31hWVpZelMnDmn0sPpCh4S4byEVRYjOTI=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         useFetchCargoVendor = true;

     

       28
       28
       -
         cargoHash = "sha256-KujJB9o5+yHu6mEQOvzGUcBS6/fh/jcnt7/FbUPLefg=";

     

       28
       28
       +
         cargoHash = "sha256-DxY03sqr/upJbNm8EkoIN96SOhZr1jm/6dgtKwyDFEU=";

     

       29
       29
        
       

     

       30
       30
        
         nativeBuildInputs =

     

       31
       31
        
           [

+2 -2

pkgs/by-name/cc/ccache/package.nix

···

       20
       20
        
       

     

       21
       21
        
       stdenv.mkDerivation (finalAttrs: {

     

       22
       22
        
         pname = "ccache";

     

       23
       23
       -
         version = "4.10.2";

     

       23
       23
       +
         version = "4.11";

     

       24
       24
        
       

     

       25
       25
        
         src = fetchFromGitHub {

     

       26
       26
        
           owner = "ccache";

     
···

       39
       39
        
               exit 1

     

       40
       40
        
             fi

     

       41
       41
        
           '';

     

       42
       42
       -
           hash = "sha256-j7Cjr5R/fN/1C6hR9400Y/hwgG++qjPvo9PYyetzrx0=";

     

       42
       42
       +
           hash = "sha256-hMQ+4/5kk+QRHtMEbIk4TIWaSyYXVdXrOMKCkglNe6g=";

     

       43
       43
        
         };

     

       44
       44
        
       

     

       45
       45
        
         outputs = [

+3 -3

pkgs/by-name/ch/chirp/package.nix

···

       11
       11
        
       

     

       12
       12
        
       python3Packages.buildPythonApplication {

     

       13
       13
        
         pname = "chirp";

     

       14
       14
       -
         version = "0.4.0-unstable-2025-03-05";

     

       14
       14
       +
         version = "0.4.0-unstable-2025-03-07";

     

       15
       15
        
         pyproject = true;

     

       16
       16
        
       

     

       17
       17
        
         src = fetchFromGitHub {

     

       18
       18
        
           owner = "kk7ds";

     

       19
       19
        
           repo = "chirp";

     

       20
       20
       -
           rev = "3e663d36f96aef03a58cab81d32122ca14a59343";

     

       21
       21
       -
           hash = "sha256-ODb+Q1Q+7XF/mX1GY2qItY4OOigguTFF+53vnaO5Ap0=";

     

       20
       20
       +
           rev = "7ba82c4faca496cf1370554a3485c1573b6a38a0";

     

       21
       21
       +
           hash = "sha256-UhQF6yfykraz5DblyW8cSP/XY+j/uxJtUVDpgdWlHZU=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         nativeBuildInputs = [

+2 -2

pkgs/by-name/co/copilot-language-server/package-lock.json

···

       1
       1
        
       {

     

       2
       2
        
           "name": "@github/copilot-language-server",

     

       3
       3
       -
           "version": "1.275.0",

     

       3
       3
       +
           "version": "1.280.0",

     

       4
       4
        
           "lockfileVersion": 3,

     

       5
       5
        
           "requires": true,

     

       6
       6
        
           "packages": {

     

       7
       7
        
               "": {

     

       8
       8
        
                   "name": "@github/copilot-language-server",

     

       9
       9
       -
                   "version": "1.275.0",

     

       9
       9
       +
                   "version": "1.280.0",

     

       10
       10
        
                   "license": "https://docs.github.com/en/site-policy/github-terms/github-terms-for-additional-products-and-features",

     

       11
       11
        
                   "dependencies": {

     

       12
       12
        
                       "vscode-languageserver-protocol": "^3.17.5"

+3 -3

pkgs/by-name/co/copilot-language-server/package.nix

···

       6
       6
        
       

     

       7
       7
        
       buildNpmPackage rec {

     

       8
       8
        
         pname = "copilot-language-server";

     

       9
       9
       -
         version = "1.275.0";

     

       9
       9
       +
         version = "1.280.0";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchurl {

     

       12
       12
        
           url = "https://registry.npmjs.org/@github/copilot-language-server/-/copilot-language-server-${version}.tgz";

     

       13
       13
       -
           hash = "sha256-OVqtwz9T5vSYAZc8nof0jXn7H40i1r7SAS6jK4xeSlo=";

     

       13
       13
       +
           hash = "sha256-6UniNoKUoATY+7amMoyWmo0DxEM82Iuu2Jf8P2raWx4=";

     

       14
       14
        
         };

     

       15
       15
        
       

     

       16
       16
       -
         npmDepsHash = "sha256-PLX/mN7xu8gMh2BkkyTncP3+rJ3nBmX+pHxl0ONXbe4=";

     

       16
       16
       +
         npmDepsHash = "sha256-BtErMpXdRC0t9DNa3hKU+tct6e9K+tMP+LcbmwSJrLI=";

     

       17
       17
        
       

     

       18
       18
        
         postPatch = ''

     

       19
       19
        
           ln -s ${./package-lock.json} package-lock.json

+56 -49

pkgs/by-name/co/cosmic-bg/package.nix

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
        
         stdenv,

     

       4
       4
       +
         stdenvAdapters,

     

       4
       5
        
         fetchFromGitHub,

     

       5
       6
        
         rustPlatform,

     

       7
       7
       +
         libcosmicAppHook,

     

       6
       8
        
         just,

     

       7
       7
       -
         pkg-config,

     

       8
       8
       -
         makeBinaryWrapper,

     

       9
       9
       -
         libxkbcommon,

     

       10
       10
       -
         wayland,

     

       9
       9
       +
         nasm,

     

       10
       10
       +
         nix-update-script,

     

       11
       11
       +
       

     

       12
       12
       +
         withMoldLinker ? stdenv.targetPlatform.isLinux,

     

       11
       13
        
       }:

     

       12
       14
        
       

     

       13
       13
       -
       rustPlatform.buildRustPackage rec {

     

       14
       14
       -
         pname = "cosmic-bg";

     

       15
       15
       -
         version = "1.0.0-alpha.6";

     

       15
       15
       +
       rustPlatform.buildRustPackage.override

     

       16
       16
       +
         { stdenv = if withMoldLinker then stdenvAdapters.useMoldLinker stdenv else stdenv; }

     

       17
       17
       +
         (finalAttrs: {

     

       18
       18
       +
           pname = "cosmic-bg";

     

       19
       19
       +
           version = "1.0.0-alpha.6";

     

       16
       20
        
       

     

       17
       17
       -
         src = fetchFromGitHub {

     

       18
       18
       -
           owner = "pop-os";

     

       19
       19
       -
           repo = pname;

     

       20
       20
       -
           rev = "epoch-${version}";

     

       21
       21
       -
           hash = "sha256-4b4laUXTnAbdngLVh8/dD144m9QrGReSEjRZoNR6Iks=";

     

       22
       22
       -
         };

     

       21
       21
       +
           src = fetchFromGitHub {

     

       22
       22
       +
             owner = "pop-os";

     

       23
       23
       +
             repo = "cosmic-bg";

     

       24
       24
       +
             tag = "epoch-${finalAttrs.version}";

     

       25
       25
       +
             hash = "sha256-4b4laUXTnAbdngLVh8/dD144m9QrGReSEjRZoNR6Iks=";

     

       26
       26
       +
           };

     

       23
       27
        
       

     

       24
       24
       -
         useFetchCargoVendor = true;

     

       25
       25
       -
         cargoHash = "sha256-GLXooTjcGq4MsBNnlpHBBUJGNs5UjKMQJGJuj9UO2wk=";

     

       28
       28
       +
           useFetchCargoVendor = true;

     

       29
       29
       +
           cargoHash = "sha256-GLXooTjcGq4MsBNnlpHBBUJGNs5UjKMQJGJuj9UO2wk=";

     

       26
       30
        
       

     

       27
       27
       -
         postPatch = ''

     

       28
       28
       -
           substituteInPlace justfile --replace-fail '#!/usr/bin/env' "#!$(command -v env)"

     

       29
       29
       -
         '';

     

       31
       31
       +
           nativeBuildInputs = [

     

       32
       32
       +
             just

     

       33
       33
       +
             libcosmicAppHook

     

       34
       34
       +
             nasm

     

       35
       35
       +
           ];

     

       30
       36
        
       

     

       31
       31
       -
         nativeBuildInputs = [

     

       32
       32
       -
           just

     

       33
       33
       -
           pkg-config

     

       34
       34
       -
           makeBinaryWrapper

     

       35
       35
       -
         ];

     

       36
       36
       -
         buildInputs = [

     

       37
       37
       -
           libxkbcommon

     

       38
       38
       -
           wayland

     

       39
       39
       -
         ];

     

       37
       37
       +
           dontUseJustBuild = true;

     

       38
       38
       +
           dontUseJustCheck = true;

     

       40
       39
        
       

     

       41
       41
       -
         dontUseJustBuild = true;

     

       40
       40
       +
           justFlags = [

     

       41
       41
       +
             "--set"

     

       42
       42
       +
             "prefix"

     

       43
       43
       +
             (placeholder "out")

     

       44
       44
       +
             "--set"

     

       45
       45
       +
             "bin-src"

     

       46
       46
       +
             "target/${stdenv.hostPlatform.rust.cargoShortTarget}/release/cosmic-bg"

     

       47
       47
       +
           ];

     

       42
       48
        
       

     

       43
       43
       -
         justFlags = [

     

       44
       44
       -
           "--set"

     

       45
       45
       -
           "prefix"

     

       46
       46
       -
           (placeholder "out")

     

       47
       47
       -
           "--set"

     

       48
       48
       -
           "bin-src"

     

       49
       49
       -
           "target/${stdenv.hostPlatform.rust.cargoShortTarget}/release/cosmic-bg"

     

       50
       50
       -
         ];

     

       49
       49
       +
           env."CARGO_TARGET_${stdenv.hostPlatform.rust.cargoEnvVarTarget}_RUSTFLAGS" =

     

       50
       50
       +
             lib.optionalString withMoldLinker "-C link-arg=-fuse-ld=mold";

     

       51
       51
        
       

     

       52
       52
       -
         postInstall = ''

     

       53
       53
       -
           wrapProgram $out/bin/cosmic-bg \

     

       54
       54
       -
             --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ wayland ]}"

     

       55
       55
       -
         '';

     

       52
       52
       +
           passthru.updateScript = nix-update-script {

     

       53
       53
       +
             extraArgs = [

     

       54
       54
       +
               "--version"

     

       55
       55
       +
               "unstable"

     

       56
       56
       +
               "--version-regex"

     

       57
       57
       +
               "epoch-(.*)"

     

       58
       58
       +
             ];

     

       59
       59
       +
           };

     

       56
       60
        
       

     

       57
       57
       -
         meta = with lib; {

     

       58
       58
       -
           homepage = "https://github.com/pop-os/cosmic-bg";

     

       59
       59
       -
           description = "Applies Background for the COSMIC Desktop Environment";

     

       60
       60
       -
           license = licenses.mpl20;

     

       61
       61
       -
           maintainers = with maintainers; [ nyabinary ];

     

       62
       62
       -
           platforms = platforms.linux;

     

       63
       63
       -
           mainProgram = "cosmic-bg";

     

       64
       64
       -
         };

     

       65
       65
       -
       }

     

       61
       61
       +
           meta = {

     

       62
       62
       +
             homepage = "https://github.com/pop-os/cosmic-bg";

     

       63
       63
       +
             description = "Applies Background for the COSMIC Desktop Environment";

     

       64
       64
       +
             license = lib.licenses.mpl20;

     

       65
       65
       +
             maintainers = with lib.maintainers; [

     

       66
       66
       +
               nyabinary

     

       67
       67
       +
               HeitorAugustoLN

     

       68
       68
       +
             ];

     

       69
       69
       +
             platforms = lib.platforms.linux;

     

       70
       70
       +
             mainProgram = "cosmic-bg";

     

       71
       71
       +
           };

     

       72
       72
       +
         })

+52 -50

pkgs/by-name/co/cosmic-launcher/package.nix

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
        
         stdenv,

     

       4
       4
       +
         stdenvAdapters,

     

       4
       5
        
         fetchFromGitHub,

     

       5
       6
        
         rustPlatform,

     

       6
       7
        
         just,

     

       7
       8
        
         libcosmicAppHook,

     

       8
       9
        
         nix-update-script,

     

       10
       10
       +
       

     

       11
       11
       +
         withMoldLinker ? stdenv.targetPlatform.isLinux,

     

       9
       12
        
       }:

     

       10
       13
        
       

     

       11
       11
       -
       rustPlatform.buildRustPackage rec {

     

       12
       12
       -
         pname = "cosmic-launcher";

     

       13
       13
       -
         version = "1.0.0-alpha.6";

     

       14
       14
       +
       rustPlatform.buildRustPackage.override

     

       15
       15
       +
         { stdenv = if withMoldLinker then stdenvAdapters.useMoldLinker stdenv else stdenv; }

     

       16
       16
       +
         (finalAttrs: {

     

       17
       17
       +
           pname = "cosmic-launcher";

     

       18
       18
       +
           version = "1.0.0-alpha.6";

     

       14
       19
        
       

     

       15
       15
       -
         src = fetchFromGitHub {

     

       16
       16
       -
           owner = "pop-os";

     

       17
       17
       -
           repo = "cosmic-launcher";

     

       18
       18
       -
           tag = "epoch-${version}";

     

       19
       19
       -
           hash = "sha256-BtYnL+qkM/aw+Air5yOKH098V+TQByM5mh1DX7v+v+s=";

     

       20
       20
       -
         };

     

       20
       20
       +
           src = fetchFromGitHub {

     

       21
       21
       +
             owner = "pop-os";

     

       22
       22
       +
             repo = "cosmic-launcher";

     

       23
       23
       +
             tag = "epoch-${finalAttrs.version}";

     

       24
       24
       +
             hash = "sha256-BtYnL+qkM/aw+Air5yOKH098V+TQByM5mh1DX7v+v+s=";

     

       25
       25
       +
           };

     

       21
       26
        
       

     

       22
       22
       -
         useFetchCargoVendor = true;

     

       23
       23
       -
         cargoHash = "sha256-g7Qr3C8jQg65KehXAhftdXCpEukag0w12ClvZFkxfqs=";

     

       27
       27
       +
           useFetchCargoVendor = true;

     

       28
       28
       +
           cargoHash = "sha256-g7Qr3C8jQg65KehXAhftdXCpEukag0w12ClvZFkxfqs=";

     

       24
       29
        
       

     

       25
       25
       -
         nativeBuildInputs = [

     

       26
       26
       -
           just

     

       27
       27
       -
           libcosmicAppHook

     

       28
       28
       -
         ];

     

       30
       30
       +
           nativeBuildInputs = [

     

       31
       31
       +
             just

     

       32
       32
       +
             libcosmicAppHook

     

       33
       33
       +
           ];

     

       29
       34
        
       

     

       30
       30
       -
         dontUseJustBuild = true;

     

       31
       31
       -
         dontUseJustCheck = true;

     

       35
       35
       +
           dontUseJustBuild = true;

     

       36
       36
       +
           dontUseJustCheck = true;

     

       32
       37
        
       

     

       33
       33
       -
         justFlags = [

     

       34
       34
       -
           "--set"

     

       35
       35
       -
           "prefix"

     

       36
       36
       -
           (placeholder "out")

     

       37
       37
       -
           "--set"

     

       38
       38
       -
           "bin-src"

     

       39
       39
       -
           "target/${stdenv.hostPlatform.rust.cargoShortTarget}/release/cosmic-launcher"

     

       40
       40
       -
         ];

     

       41
       41
       -
       

     

       42
       42
       -
         postPatch = ''

     

       43
       43
       -
           substituteInPlace justfile --replace-fail '#!/usr/bin/env' "#!$(command -v env)"

     

       44
       44
       -
         '';

     

       38
       38
       +
           justFlags = [

     

       39
       39
       +
             "--set"

     

       40
       40
       +
             "prefix"

     

       41
       41
       +
             (placeholder "out")

     

       42
       42
       +
             "--set"

     

       43
       43
       +
             "bin-src"

     

       44
       44
       +
             "target/${stdenv.hostPlatform.rust.cargoShortTarget}/release/cosmic-launcher"

     

       45
       45
       +
           ];

     

       45
       46
        
       

     

       46
       46
       -
         env."CARGO_TARGET_${stdenv.hostPlatform.rust.cargoEnvVarTarget}_RUSTFLAGS" = "--cfg tokio_unstable";

     

       47
       47
       +
           env."CARGO_TARGET_${stdenv.hostPlatform.rust.cargoEnvVarTarget}_RUSTFLAGS" =

     

       48
       48
       +
             "--cfg tokio_unstable${lib.optionalString withMoldLinker " -C link-arg=-fuse-ld=mold"}";

     

       47
       49
        
       

     

       48
       48
       -
         passthru.updateScript = nix-update-script {

     

       49
       49
       -
           extraArgs = [

     

       50
       50
       -
             "--version"

     

       51
       51
       -
             "unstable"

     

       52
       52
       -
             "--version-regex"

     

       53
       53
       -
             "epoch-(.*)"

     

       54
       54
       -
           ];

     

       55
       55
       -
         };

     

       50
       50
       +
           passthru.updateScript = nix-update-script {

     

       51
       51
       +
             extraArgs = [

     

       52
       52
       +
               "--version"

     

       53
       53
       +
               "unstable"

     

       54
       54
       +
               "--version-regex"

     

       55
       55
       +
               "epoch-(.*)"

     

       56
       56
       +
             ];

     

       57
       57
       +
           };

     

       56
       58
        
       

     

       57
       57
       -
         meta = {

     

       58
       58
       -
           homepage = "https://github.com/pop-os/cosmic-launcher";

     

       59
       59
       -
           description = "Launcher for the COSMIC Desktop Environment";

     

       60
       60
       -
           mainProgram = "cosmic-launcher";

     

       61
       61
       -
           license = lib.licenses.gpl3Only;

     

       62
       62
       -
           maintainers = with lib.maintainers; [

     

       63
       63
       -
             nyabinary

     

       64
       64
       -
             HeitorAugustoLN

     

       65
       65
       -
           ];

     

       66
       66
       -
           platforms = lib.platforms.linux;

     

       67
       67
       -
         };

     

       68
       68
       -
       }

     

       59
       59
       +
           meta = {

     

       60
       60
       +
             homepage = "https://github.com/pop-os/cosmic-launcher";

     

       61
       61
       +
             description = "Launcher for the COSMIC Desktop Environment";

     

       62
       62
       +
             mainProgram = "cosmic-launcher";

     

       63
       63
       +
             license = lib.licenses.gpl3Only;

     

       64
       64
       +
             maintainers = with lib.maintainers; [

     

       65
       65
       +
               nyabinary

     

       66
       66
       +
               HeitorAugustoLN

     

       67
       67
       +
             ];

     

       68
       68
       +
             platforms = lib.platforms.linux;

     

       69
       69
       +
           };

     

       70
       70
       +
         })

+54 -46

pkgs/by-name/co/cosmic-randr/package.nix

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
        
         stdenv,

     

       4
       4
       +
         stdenvAdapters,

     

       4
       5
        
         fetchFromGitHub,

     

       5
       6
        
         rustPlatform,

     

       6
       7
        
         just,

     

       7
       8
        
         pkg-config,

     

       8
       9
        
         wayland,

     

       9
       10
        
         nix-update-script,

     

       11
       11
       +
       

     

       12
       12
       +
         withMoldLinker ? stdenv.targetPlatform.isLinux,

     

       10
       13
        
       }:

     

       11
       14
        
       

     

       12
       12
       -
       rustPlatform.buildRustPackage rec {

     

       13
       13
       -
         pname = "cosmic-randr";

     

       14
       14
       -
         version = "1.0.0-alpha.6";

     

       15
       15
       +
       rustPlatform.buildRustPackage.override

     

       16
       16
       +
         { stdenv = if withMoldLinker then stdenvAdapters.useMoldLinker stdenv else stdenv; }

     

       17
       17
       +
         (finalAttrs: {

     

       18
       18
       +
           pname = "cosmic-randr";

     

       19
       19
       +
           version = "1.0.0-alpha.6";

     

       15
       20
        
       

     

       16
       16
       -
         src = fetchFromGitHub {

     

       17
       17
       -
           owner = "pop-os";

     

       18
       18
       -
           repo = "cosmic-randr";

     

       19
       19
       -
           tag = "epoch-${version}";

     

       20
       20
       -
           hash = "sha256-Sqxe+vKonsK9MmJGtbrZHE7frfrjkHXysm0WQt7WSU4=";

     

       21
       21
       -
         };

     

       22
       22
       -
       

     

       23
       23
       -
         useFetchCargoVendor = true;

     

       24
       24
       -
         cargoHash = "sha256-UQ/fhjUiniVeHRQYulYko4OxcWB6UhFuxH1dVAfAzIY=";

     

       21
       21
       +
           src = fetchFromGitHub {

     

       22
       22
       +
             owner = "pop-os";

     

       23
       23
       +
             repo = "cosmic-randr";

     

       24
       24
       +
             tag = "epoch-${finalAttrs.version}";

     

       25
       25
       +
             hash = "sha256-Sqxe+vKonsK9MmJGtbrZHE7frfrjkHXysm0WQt7WSU4=";

     

       26
       26
       +
           };

     

       25
       27
        
       

     

       26
       26
       -
         nativeBuildInputs = [

     

       27
       27
       -
           just

     

       28
       28
       -
           pkg-config

     

       29
       29
       -
         ];

     

       28
       28
       +
           useFetchCargoVendor = true;

     

       29
       29
       +
           cargoHash = "sha256-UQ/fhjUiniVeHRQYulYko4OxcWB6UhFuxH1dVAfAzIY=";

     

       30
       30
        
       

     

       31
       31
       -
         buildInputs = [ wayland ];

     

       31
       31
       +
           nativeBuildInputs = [

     

       32
       32
       +
             just

     

       33
       33
       +
             pkg-config

     

       34
       34
       +
           ];

     

       32
       35
        
       

     

       33
       33
       -
         dontUseJustBuild = true;

     

       34
       34
       -
         dontUseJustCheck = true;

     

       36
       36
       +
           buildInputs = [ wayland ];

     

       35
       37
        
       

     

       36
       36
       -
         justFlags = [

     

       37
       37
       -
           "--set"

     

       38
       38
       -
           "prefix"

     

       39
       39
       -
           (placeholder "out")

     

       40
       40
       -
           "--set"

     

       41
       41
       -
           "bin-src"

     

       42
       42
       -
           "target/${stdenv.hostPlatform.rust.cargoShortTarget}/release/cosmic-randr"

     

       43
       43
       -
         ];

     

       38
       38
       +
           dontUseJustBuild = true;

     

       39
       39
       +
           dontUseJustCheck = true;

     

       44
       40
        
       

     

       45
       45
       -
         passthru.updateScript = nix-update-script {

     

       46
       46
       -
           extraArgs = [

     

       47
       47
       -
             "--version"

     

       48
       48
       -
             "unstable"

     

       49
       49
       -
             "--version-regex"

     

       50
       50
       -
             "epoch-(.*)"

     

       41
       41
       +
           justFlags = [

     

       42
       42
       +
             "--set"

     

       43
       43
       +
             "prefix"

     

       44
       44
       +
             (placeholder "out")

     

       45
       45
       +
             "--set"

     

       46
       46
       +
             "bin-src"

     

       47
       47
       +
             "target/${stdenv.hostPlatform.rust.cargoShortTarget}/release/cosmic-randr"

     

       51
       48
        
           ];

     

       52
       52
       -
         };

     

       53
       49
        
       

     

       54
       54
       -
         meta = {

     

       55
       55
       -
           homepage = "https://github.com/pop-os/cosmic-randr";

     

       56
       56
       -
           description = "Library and utility for displaying and configuring Wayland outputs";

     

       57
       57
       -
           license = lib.licenses.mpl20;

     

       58
       58
       -
           maintainers = with lib.maintainers; [

     

       59
       59
       -
             nyabinary

     

       60
       60
       -
             HeitorAugustoLN

     

       61
       61
       -
           ];

     

       62
       62
       -
           platforms = lib.platforms.linux;

     

       63
       63
       -
           mainProgram = "cosmic-randr";

     

       64
       64
       -
         };

     

       65
       65
       -
       }

     

       50
       50
       +
           env."CARGO_TARGET_${stdenv.hostPlatform.rust.cargoEnvVarTarget}_RUSTFLAGS" =

     

       51
       51
       +
             lib.optionalString withMoldLinker "-C link-arg=-fuse-ld=mold";

     

       52
       52
       +
       

     

       53
       53
       +
           passthru.updateScript = nix-update-script {

     

       54
       54
       +
             extraArgs = [

     

       55
       55
       +
               "--version"

     

       56
       56
       +
               "unstable"

     

       57
       57
       +
               "--version-regex"

     

       58
       58
       +
               "epoch-(.*)"

     

       59
       59
       +
             ];

     

       60
       60
       +
           };

     

       61
       61
       +
       

     

       62
       62
       +
           meta = {

     

       63
       63
       +
             homepage = "https://github.com/pop-os/cosmic-randr";

     

       64
       64
       +
             description = "Library and utility for displaying and configuring Wayland outputs";

     

       65
       65
       +
             license = lib.licenses.mpl20;

     

       66
       66
       +
             maintainers = with lib.maintainers; [

     

       67
       67
       +
               nyabinary

     

       68
       68
       +
               HeitorAugustoLN

     

       69
       69
       +
             ];

     

       70
       70
       +
             platforms = lib.platforms.linux;

     

       71
       71
       +
             mainProgram = "cosmic-randr";

     

       72
       72
       +
           };

     

       73
       73
       +
         })

+28 -44

pkgs/by-name/co/cosmic-term/package.nix

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
       -
         cosmic-icons,

     

       3
       3
       +
         stdenv,

     

       4
       4
       +
         rustPlatform,

     

       4
       5
        
         fetchFromGitHub,

     

       6
       6
       +
         pkg-config,

     

       7
       7
       +
         just,

     

       8
       8
       +
         libcosmicAppHook,

     

       5
       9
        
         fontconfig,

     

       6
       10
        
         freetype,

     

       7
       7
       -
         just,

     

       8
       8
       -
         libglvnd,

     

       9
       11
        
         libinput,

     

       10
       10
       -
         libxkbcommon,

     

       11
       11
       -
         makeBinaryWrapper,

     

       12
       12
       -
         pkg-config,

     

       13
       13
       -
         rustPlatform,

     

       14
       14
       -
         stdenv,

     

       15
       15
       -
         vulkan-loader,

     

       16
       16
       -
         wayland,

     

       17
       17
       -
         xorg,

     

       12
       12
       +
         nix-update-script,

     

       18
       13
        
       }:

     

       19
       14
        
       

     

       20
       20
       -
       rustPlatform.buildRustPackage rec {

     

       15
       15
       +
       rustPlatform.buildRustPackage (finalAttrs: {

     

       21
       16
        
         pname = "cosmic-term";

     

       22
       17
        
         version = "1.0.0-alpha.6";

     

       23
       18
        
       

     

       24
       19
        
         src = fetchFromGitHub {

     

       25
       20
        
           owner = "pop-os";

     

       26
       21
        
           repo = "cosmic-term";

     

       27
       27
       -
           rev = "epoch-${version}";

     

       22
       22
       +
           tag = "epoch-${finalAttrs.version}";

     

       28
       23
        
           hash = "sha256-sdeRkT6UcyBKIFnJZn3aGf8LZQimqVPqtXo7RtwUs5M=";

     

       29
       24
        
         };

     

       30
       25
        
       

     
···

       33
       28
        
       

     

       34
       29
        
         # COSMIC applications now uses vergen for the About page

     

       35
       30
        
         # Update the COMMIT_DATE to match when the commit was made

     

       36
       36
       -
         env.VERGEN_GIT_COMMIT_DATE = "2025-02-21";

     

       37
       37
       -
         env.VERGEN_GIT_SHA = src.rev;

     

       38
       38
       -
       

     

       39
       39
       -
         postPatch = ''

     

       40
       40
       -
           substituteInPlace justfile --replace-fail '#!/usr/bin/env' "#!$(command -v env)"

     

       41
       41
       -
         '';

     

       31
       31
       +
         env = {

     

       32
       32
       +
           VERGEN_GIT_COMMIT_DATE = "2025-02-21";

     

       33
       33
       +
           VERGEN_GIT_SHA = finalAttrs.src.tag;

     

       34
       34
       +
         };

     

       42
       35
        
       

     

       43
       36
        
         nativeBuildInputs = [

     

       44
       37
        
           just

     

       45
       38
        
           pkg-config

     

       46
       46
       -
           makeBinaryWrapper

     

       39
       39
       +
           libcosmicAppHook

     

       47
       40
        
         ];

     

       48
       41
        
       

     

       49
       42
        
         buildInputs = [

     

       50
       43
        
           fontconfig

     

       51
       44
        
           freetype

     

       52
       52
       -
           libglvnd

     

       53
       45
        
           libinput

     

       54
       54
       -
           libxkbcommon

     

       55
       55
       -
           vulkan-loader

     

       56
       56
       -
           wayland

     

       57
       57
       -
           xorg.libX11

     

       58
       46
        
         ];

     

       59
       47
        
       

     

       60
       48
        
         dontUseJustBuild = true;

     

       49
       49
       +
         dontUseJustCheck = true;

     

       61
       50
        
       

     

       62
       51
        
         justFlags = [

     

       63
       52
        
           "--set"

     
···

       68
       57
        
           "target/${stdenv.hostPlatform.rust.cargoShortTarget}/release/cosmic-term"

     

       69
       58
        
         ];

     

       70
       59
        
       

     

       71
       71
       -
         # Force linking to libEGL, which is always dlopen()ed, and to

     

       72
       72
       -
         # libwayland-client, which is always dlopen()ed except by the

     

       73
       73
       -
         # obscure winit backend.

     

       74
       74
       -
         RUSTFLAGS = map (a: "-C link-arg=${a}") [

     

       75
       75
       -
           "-Wl,--push-state,--no-as-needed"

     

       76
       76
       -
           "-lEGL"

     

       77
       77
       -
           "-lwayland-client"

     

       78
       78
       -
           "-Wl,--pop-state"

     

       79
       79
       -
         ];

     

       80
       80
       -
       

     

       81
       81
       -
         postInstall = ''

     

       82
       82
       -
           wrapProgram "$out/bin/cosmic-term" \

     

       83
       83
       -
             --suffix XDG_DATA_DIRS : "${cosmic-icons}/share"

     

       84
       84
       -
         '';

     

       60
       60
       +
         passthru.updateScript = nix-update-script {

     

       61
       61
       +
           extraArgs = [

     

       62
       62
       +
             "--version"

     

       63
       63
       +
             "unstable"

     

       64
       64
       +
             "--version-regex"

     

       65
       65
       +
             "epoch-(.*)"

     

       66
       66
       +
           ];

     

       67
       67
       +
         };

     

       85
       68
        
       

     

       86
       86
       -
         meta = with lib; {

     

       69
       69
       +
         meta = {

     

       87
       70
        
           homepage = "https://github.com/pop-os/cosmic-term";

     

       88
       71
        
           description = "Terminal for the COSMIC Desktop Environment";

     

       89
       89
       -
           license = licenses.gpl3Only;

     

       90
       90
       -
           maintainers = with maintainers; [

     

       72
       72
       +
           license = lib.licenses.gpl3Only;

     

       73
       73
       +
           maintainers = with lib.maintainers; [

     

       91
       74
        
             ahoneybun

     

       92
       75
        
             nyabinary

     

       76
       76
       +
             HeitorAugustoLN

     

       93
       77
        
           ];

     

       94
       94
       -
           platforms = platforms.linux;

     

       78
       78
       +
           platforms = lib.platforms.linux;

     

       95
       79
        
           mainProgram = "cosmic-term";

     

       96
       80
        
         };

     

       97
       97
       -
       }

     

       81
       81
       +
       })

+2 -2

pkgs/by-name/dl/dlib/package.nix

···

       20
       20
        
       }@inputs:

     

       21
       21
        
       (if cudaSupport then cudaPackages.backendStdenv else inputs.stdenv).mkDerivation rec {

     

       22
       22
        
         pname = "dlib";

     

       23
       23
       -
         version = "19.24.6";

     

       23
       23
       +
         version = "19.24.8";

     

       24
       24
        
       

     

       25
       25
        
         src = fetchFromGitHub {

     

       26
       26
        
           owner = "davisking";

     

       27
       27
        
           repo = "dlib";

     

       28
       28
        
           tag = "v${version}";

     

       29
       29
       -
           sha256 = "sha256-BpE7ZrtiiaDqwy1G4IHOQBJMr6sAadFbRxsdObs1SIY=";

     

       29
       29
       +
           sha256 = "sha256-b8DFlfBnF4Fk7beJPxQJDVHaCR7s5/4uAPi3RV9cBZ4=";

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
         postPatch = ''

+2 -2

pkgs/by-name/do/doctl/package.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "doctl";

     

       5
       5
       -
         version = "1.122.0";

     

       5
       5
       +
         version = "1.123.0";

     

       6
       6
        
       

     

       7
       7
        
         vendorHash = null;

     

       8
       8
        
       

     
···

       31
       31
        
           owner = "digitalocean";

     

       32
       32
        
           repo = "doctl";

     

       33
       33
        
           rev = "v${version}";

     

       34
       34
       -
           sha256 = "sha256-l5UfvMTexoGhX2CWBZlO1ibM+cULdhRdZ7UeH0jgC7E=";

     

       34
       34
       +
           sha256 = "sha256-B7xUo59qyftjZj2ywJROaWYPkfelqPSkY3YqR2y+/jw=";

     

       35
       35
        
         };

     

       36
       36
        
       

     

       37
       37
        
         meta = with lib; {

+3 -3

pkgs/by-name/es/esp-generate/package.nix

···

       6
       6
        
       

     

       7
       7
        
       rustPlatform.buildRustPackage rec {

     

       8
       8
        
         pname = "esp-generate";

     

       9
       9
       -
         version = "0.3.0";

     

       9
       9
       +
         version = "0.3.1";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "esp-rs";

     

       13
       13
        
           repo = "esp-generate";

     

       14
       14
        
           rev = "v${version}";

     

       15
       15
       -
           hash = "sha256-Z+PsGx3Y2WZLO5QK5icI89YPOmY4p/RBMiYecEOfmwc=";

     

       15
       15
       +
           hash = "sha256-yk7iv5nq2b/1OY77818I7mXW96YxjwwJS3iiv1KXVHs=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         useFetchCargoVendor = true;

     

       19
       19
       -
         cargoHash = "sha256-uvHZyvIcPLB1GW7EkJshAeGRI3xJZtN9kPrLhHGoojs=";

     

       19
       19
       +
         cargoHash = "sha256-ncTX9cDSAf6ZGlz0utGYxkuXcx85vt3VHQzdmQhCNf0=";

     

       20
       20
        
       

     

       21
       21
        
         meta = {

     

       22
       22
        
           description = "Template generation tool to create no_std applications targeting Espressif's chips";

+2 -2

pkgs/by-name/ex/exodus/package.nix

···

       28
       28
        
       

     

       29
       29
        
       stdenv.mkDerivation (finalAttrs: {

     

       30
       30
        
         pname = "exodus";

     

       31
       31
       -
         version = "24.41.6";

     

       31
       31
       +
         version = "25.9.2";

     

       32
       32
        
       

     

       33
       33
        
         src = requireFile {

     

       34
       34
        
           name = "exodus-linux-x64-${finalAttrs.version}.zip";

     

       35
       35
        
           url = "https://downloads.exodus.com/releases/exodus-linux-x64-${finalAttrs.version}.zip";

     

       36
       36
       -
           hash = "sha256-lUL9n3EZVe2J7uCHUSJgI2g75Sp1Y/nfBTde7VId6sA=";

     

       36
       36
       +
           hash = "sha256-QEspr/n4TnwpCx9lBY874+dlcMvhXiYKhyqel7ebuzg=";

     

       37
       37
        
         };

     

       38
       38
        
       

     

       39
       39
        
         nativeBuildInputs = [ unzip ];

pkgs/by-name/fi/fishMinimal/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         fish,

     

       3
       3
       +
       }:

     

       4
       4
       +
       

     

       5
       5
       +
       fish.override {

     

       6
       6
       +
         usePython = false;

     

       7
       7
       +
       }

+3 -3

pkgs/by-name/fr/frink/package.nix

···

       9
       9
        
       }:

     

       10
       10
        
       stdenv.mkDerivation rec {

     

       11
       11
        
         pname = "frink";

     

       12
       12
       -
         version = "2024-05-09";

     

       12
       12
       +
         version = "2025-01-07";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
        
           # Upstream does not provide versioned download links

     

       16
       16
       -
           url = "https://web.archive.org/web/20240605193919/https://frinklang.org/frinkjar/frink-tng.jar";

     

       17
       17
       -
           sha256 = "sha256-ceV1p9wsXprcNLhol79evswVZ1SpH5IzfSbl8st4cmU=";

     

       16
       16
       +
           url = "https://web.archive.org/web/20250119105218/https://frinklang.org/frinkjar/frink-tng.jar";

     

       17
       17
       +
           sha256 = "sha256-qsbYUUBBVILUG6oZVR3t5UaVdNew6xRvjqQBJVr76L8=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         dontUnpack = true;

+2 -3

pkgs/by-name/gd/gdmd/package.nix

···

       2
       2
        
         lib,

     

       3
       3
        
         stdenvNoCC,

     

       4
       4
        
         fetchFromGitHub,

     

       5
       5
       -
         substituteAll,

     

       5
       5
       +
         replaceVars,

     

       6
       6
        
         gdc,

     

       7
       7
        
         perl,

     

       8
       8
        
       }:

     
···

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         patches = [

     

       21
       21
       -
           (substituteAll {

     

       22
       22
       -
             src = ./0001-gdc-store-path.diff;

     

       21
       21
       +
           (replaceVars ./0001-gdc-store-path.diff {

     

       23
       22
        
             gdc_dir = "${gdc}/bin";

     

       24
       23
        
           })

     

       25
       24
        
         ];

+1 -1

pkgs/by-name/go/google-chrome/update.sh

···

       1
       1
        
       #!/usr/bin/env nix-shell

     

       2
       2
       -
       #!nix-shell -I nixpkgs=./. -i bash -p curl jq gawk libossp_uuid libxml2 nix

     

       2
       2
       +
       #!nix-shell -I nixpkgs=./. -i bash -p curl jq gawk libossp_uuid libuuid libxml2 nix

     

       3
       3
        
       # shellcheck shell=bash

     

       4
       4
        
       

     

       5
       5
        
       set -euo pipefail

+3 -3

pkgs/by-name/in/inputplumber/package.nix

···

       10
       10
        
       

     

       11
       11
        
       rustPlatform.buildRustPackage rec {

     

       12
       12
        
         pname = "inputplumber";

     

       13
       13
       -
         version = "0.48.0";

     

       13
       13
       +
         version = "0.49.2";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchFromGitHub {

     

       16
       16
        
           owner = "ShadowBlip";

     

       17
       17
        
           repo = "InputPlumber";

     

       18
       18
        
           tag = "v${version}";

     

       19
       19
       -
           hash = "sha256-9/4+gNuG02uoXDflRh3q5T+hqAKu/j+1FQnXVJVTpiI=";

     

       19
       19
       +
           hash = "sha256-vWqmcVF/gi0ubIF/NDnz0op1ss0t7A7O8NrOzszx7Gw=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         useFetchCargoVendor = true;

     

       23
       23
       -
         cargoHash = "sha256-cRSY9a5qOvYrdvNSDoDjgrIo+SRlD24oAWriudbKS1E=";

     

       23
       23
       +
         cargoHash = "sha256-5yG8iUW5BVHI2QcOl+9dN1c1b/wmrFCO4mDs4ZflhUM=";

     

       24
       24
        
       

     

       25
       25
        
         nativeBuildInputs = [

     

       26
       26
        
           pkg-config

+18 -15

pkgs/by-name/ip/ipxe/package.nix

···

       112
       112
        
       

     

       113
       113
        
         buildFlags = lib.attrNames targets;

     

       114
       114
        
       

     

       115
       115
       -
         installPhase = ''

     

       116
       116
       -
           runHook preInstall

     

       115
       115
       +
         installPhase =

     

       116
       116
       +
           ''

     

       117
       117
       +
             runHook preInstall

     

       117
       118
        
       

     

       118
       118
       -
           mkdir -p $out

     

       119
       119
       -
           ${lib.concatStringsSep "\n" (

     

       120
       120
       -
             lib.mapAttrsToList (

     

       121
       121
       -
               from: to: if to == null then "cp -v ${from} $out" else "cp -v ${from} $out/${to}"

     

       122
       122
       -
             ) targets

     

       123
       123
       -
           )}

     

       124
       124
       -
       

     

       125
       125
       -
           # Some PXE constellations especially with dnsmasq are looking for the file with .0 ending

     

       126
       126
       -
           # let's provide it as a symlink to be compatible in this case.

     

       127
       127
       -
           ln -s undionly.kpxe $out/undionly.kpxe.0

     

       128
       128
       -
       

     

       129
       129
       -
           runHook postInstall

     

       130
       130
       -
         '';

     

       119
       119
       +
             mkdir -p $out

     

       120
       120
       +
             ${lib.concatStringsSep "\n" (

     

       121
       121
       +
               lib.mapAttrsToList (

     

       122
       122
       +
                 from: to: if to == null then "cp -v ${from} $out" else "cp -v ${from} $out/${to}"

     

       123
       123
       +
               ) targets

     

       124
       124
       +
             )}

     

       125
       125
       +
           ''

     

       126
       126
       +
           + lib.optionalString stdenv.hostPlatform.isx86 ''

     

       127
       127
       +
             # Some PXE constellations especially with dnsmasq are looking for the file with .0 ending

     

       128
       128
       +
             # let's provide it as a symlink to be compatible in this case.

     

       129
       129
       +
             ln -s undionly.kpxe $out/undionly.kpxe.0

     

       130
       130
       +
           ''

     

       131
       131
       +
           + ''

     

       132
       132
       +
             runHook postInstall

     

       133
       133
       +
           '';

     

       131
       134
        
       

     

       132
       135
        
         enableParallelBuilding = true;

     

       133
       136

+2 -2

pkgs/by-name/ka/kafkactl/package.nix

···

       6
       6
        
       

     

       7
       7
        
       buildGoModule rec {

     

       8
       8
        
         pname = "kafkactl";

     

       9
       9
       -
         version = "5.5.0";

     

       9
       9
       +
         version = "5.5.1";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "deviceinsight";

     

       13
       13
        
           repo = pname;

     

       14
       14
        
           tag = "v${version}";

     

       15
       15
       -
           hash = "sha256-9xo/lg3IhAdJnmmLAmiMcKNCTMXkKK2jnYaGHIk8Rq4=";

     

       15
       15
       +
           hash = "sha256-lsYdq3+hf+8EPLmLbgnzuVHfeZXrUlqYmHY4kJ6HzC4=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         vendorHash = "sha256-0Kc8Z32YdmwhKMTBMBAK0ZdnXnH8/Ze1HcMDafosLvw=";

+7 -7

pkgs/by-name/li/libdeltachat/package.nix

···

       20
       20
        
       

     

       21
       21
        
       stdenv.mkDerivation rec {

     

       22
       22
        
         pname = "libdeltachat";

     

       23
       23
       -
         version = "1.156.2";

     

       23
       23
       +
         version = "1.156.3";

     

       24
       24
        
       

     

       25
       25
        
         src = fetchFromGitHub {

     

       26
       26
       -
           owner = "deltachat";

     

       27
       27
       -
           repo = "deltachat-core-rust";

     

       26
       26
       +
           owner = "chatmail";

     

       27
       27
       +
           repo = "core";

     

       28
       28
        
           tag = "v${version}";

     

       29
       29
       -
           hash = "sha256-CpFnO8stLLTH/XOZZS3j9nVrf2FRekjkQ/R1pmw5o9A=";

     

       29
       29
       +
           hash = "sha256-FJTHG1NUdKcYTPrBkhu4ZiodSwpNgaGUHiHBSk/lUVA=";

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
         patches = [

     
···

       36
       36
        
         cargoDeps = rustPlatform.fetchCargoVendor {

     

       37
       37
        
           pname = "deltachat-core-rust";

     

       38
       38
        
           inherit version src;

     

       39
       39
       -
           hash = "sha256-jrsGMNgKglk+Rq/ZGiZgSZrT4uSA5RjbTYaDtW0Ijyg=";

     

       39
       39
       +
           hash = "sha256-Kh0TU6lJ7spZIOUyJabFd1icqN9jU+kG+BpADAi0nRo=";

     

       40
       40
        
         };

     

       41
       41
        
       

     

       42
       42
        
         nativeBuildInputs = [

     
···

       86
       86
        
       

     

       87
       87
        
         meta = with lib; {

     

       88
       88
        
           description = "Delta Chat Rust Core library";

     

       89
       89
       -
           homepage = "https://github.com/deltachat/deltachat-core-rust/";

     

       90
       90
       -
           changelog = "https://github.com/deltachat/deltachat-core-rust/blob/${src.tag}/CHANGELOG.md";

     

       89
       89
       +
           homepage = "https://github.com/chatmail/core";

     

       90
       90
       +
           changelog = "https://github.com/chatmail/core/blob/${src.tag}/CHANGELOG.md";

     

       91
       91
        
           license = licenses.mpl20;

     

       92
       92
        
           maintainers = with maintainers; [ dotlambda ];

     

       93
       93
        
           platforms = platforms.unix;

+28

pkgs/by-name/mn/mnamer/cached_session_error.patch

···

       1
       1
       +
       From 94ea94de526770e783d04d75b981dfa3ac90fd20 Mon Sep 17 00:00:00 2001

     

       2
       2
       +
       From: o7-machienhum <ryan.cjw@gmail.com>

     

       3
       3
       +
       Date: Tue, 30 Jan 2024 03:29:09 -0800

     

       4
       4
       +
       Subject: [PATCH] Fixes crash

     

       5
       5
       +
       

     

       6
       6
       +
       ---

     

       7
       7
       +
        mnamer/utils.py | 3 ---

     

       8
       8
       +
        1 file changed, 3 deletions(-)

     

       9
       9
       +
       

     

       10
       10
       +
       diff --git a/mnamer/utils.py b/mnamer/utils.py

     

       11
       11
       +
       index 84df7870..8eba68f8 100644

     

       12
       12
       +
       --- a/mnamer/utils.py

     

       13
       13
       +
       +++ b/mnamer/utils.py

     

       14
       14
       +
       @@ -256,7 +256,6 @@ def request_json(

     

       15
       15
       +
                "like Gecko) Chrome/79.0.3945.88 Safari/537.36"

     

       16
       16
       +
            )

     

       17
       17
       +
        

     

       18
       18
       +
       -    initial_cache_state = session._disabled  # yes, i'm a bad person

     

       19
       19
       +
            try:

     

       20
       20
       +
                session._disabled = not cache

     

       21
       21
       +
                response = session.request(

     

       22
       22
       +
       @@ -272,8 +271,6 @@ def request_json(

     

       23
       23
       +
            except:

     

       24
       24
       +
                content = None

     

       25
       25
       +
                status = 500

     

       26
       26
       +
       -    finally:

     

       27
       27
       +
       -        session._disabled = initial_cache_state

     

       28
       28
       +
            return status, (content or {})

+22 -13

pkgs/by-name/mn/mnamer/package.nix

···

       1
       1
       -
       { python3Packages, fetchFromGitHub, lib }:

     

       1
       1
       +
       {

     

       2
       2
       +
         python3Packages,

     

       3
       3
       +
         fetchFromGitHub,

     

       4
       4
       +
         lib,

     

       5
       5
       +
       }:

     

       2
       6
        
       

     

       3
       7
        
       python3Packages.buildPythonApplication rec {

     

       4
       8
        
         pname = "mnamer";

     

       5
       5
       -
         version = "2.5.4";

     

       9
       9
       +
         version = "2.5.5";

     

       10
       10
       +
         format = "pyproject";

     

       6
       11
        
       

     

       7
       12
        
         src = fetchFromGitHub {

     

       8
       13
        
           owner = "jkwill87";

     

       9
       14
        
           repo = "mnamer";

     

       10
       10
       -
           rev = version;

     

       11
       11
       -
           sha256 = "sha256-fONQq/RboWHFuEFU7HP1ThUpSjOIlkg54c2WlMUKwuk=";

     

       15
       15
       +
           tag = version;

     

       16
       16
       +
           sha256 = "sha256-qQu5V1GOsbrR00HOrot6TTAkc3KRasBPDEU7ZojUBio=";

     

       12
       17
        
         };

     

       13
       18
        
       

     

       14
       14
       -
         propagatedBuildInputs = with python3Packages; [

     

       19
       19
       +
         build-system = with python3Packages; [

     

       20
       20
       +
           setuptools

     

       21
       21
       +
           setuptools-scm

     

       22
       22
       +
         ];

     

       23
       23
       +
       

     

       24
       24
       +
         dependencies = with python3Packages; [

     

       25
       25
       +
           appdirs

     

       15
       26
        
           babelfish

     

       27
       27
       +
           guessit

     

       16
       28
        
           requests

     

       17
       17
       -
           appdirs

     

       29
       29
       +
           requests-cache

     

       18
       30
        
           teletype

     

       19
       19
       -
           requests-cache

     

       20
       20
       -
           guessit

     

       21
       31
        
         ];

     

       22
       32
        
       

     

       23
       23
       -
         patches = [

     

       24
       24
       -
           # requires specific old versions of dependencies which have been updated in nixpkgs

     

       25
       25
       -
           ./remove_requirements.patch

     

       33
       33
       +
         pythonRelaxDeps = true;

     

       26
       34
        
       

     

       27
       27
       -
           # author reads a private property that changed between versions

     

       28
       28
       -
           ./update_hack.patch

     

       35
       35
       +
         patches = [

     

       36
       36
       +
           # https://github.com/jkwill87/mnamer/pull/291

     

       37
       37
       +
           ./cached_session_error.patch

     

       29
       38
        
         ];

     

       30
       39
        
       

     

       31
       40
        
         nativeCheckInputs = [ python3Packages.pytestCheckHook ];

-21

pkgs/by-name/mn/mnamer/remove_requirements.patch

···

       1
       1
       -
       diff --git a/setup.py b/setup.py

     

       2
       2
       -
       index 245c1dd..fdc17ab 100755

     

       3
       3
       -
       --- a/setup.py

     

       4
       4
       -
       +++ b/setup.py

     

       5
       5
       -
       @@ -7,16 +7,12 @@ from mnamer.__version__ import VERSION

     

       6
       6
       -
        with open("readme.md", "r", encoding="utf8") as fp:

     

       7
       7
       -
            LONG_DESCRIPTION = fp.read()

     

       8
       8
       -
        

     

       9
       9
       -
       -with open("requirements.txt", "r", encoding="utf8") as fp:

     

       10
       10
       -
       -    REQUIREMENTS = fp.read().splitlines()

     

       11
       11
       -
       -

     

       12
       12
       -
        setup(

     

       13
       13
       -
            author="Jessy Williams",

     

       14
       14
       -
            author_email="jessy@jessywilliams.com",

     

       15
       15
       -
            description="A media file organiser",

     

       16
       16
       -
            entry_points={"console_scripts": ["mnamer=mnamer.__main__:main"]},

     

       17
       17
       -
            include_package_data=True,

     

       18
       18
       -
       -    install_requires=REQUIREMENTS,

     

       19
       19
       -
            license="MIT",

     

       20
       20
       -
            long_description=LONG_DESCRIPTION,

     

       21
       21
       -
            long_description_content_type="text/markdown",

-13

pkgs/by-name/mn/mnamer/update_hack.patch

···

       1
       1
       -
       diff --git a/mnamer/utils.py b/mnamer/utils.py

     

       2
       2
       -
       index 636b596..e52bd37 100644

     

       3
       3
       -
       --- a/mnamer/utils.py

     

       4
       4
       -
       +++ b/mnamer/utils.py

     

       5
       5
       -
       @@ -280,7 +280,7 @@ def request_json(

     

       6
       6
       -
                "like Gecko) Chrome/79.0.3945.88 Safari/537.36"

     

       7
       7
       -
            )

     

       8
       8
       -
        

     

       9
       9
       -
       -    initial_cache_state = session._is_cache_disabled  # yes, i'm a bad person

     

       10
       10
       -
       +    initial_cache_state = session._disabled  # yes, i'm a bad person

     

       11
       11
       -
            try:

     

       12
       12
       -
                session._is_cache_disabled = not cache

     

       13
       13
       -
                response = session.request(

+2 -2

pkgs/by-name/op/opshin/package.nix

···

       6
       6
        
       

     

       7
       7
        
       python3.pkgs.buildPythonApplication rec {

     

       8
       8
        
         pname = "opshin";

     

       9
       9
       -
         version = "0.24.0";

     

       9
       9
       +
         version = "0.24.1";

     

       10
       10
        
       

     

       11
       11
        
         format = "pyproject";

     

       12
       12
        
       

     
···

       14
       14
        
           owner = "OpShin";

     

       15
       15
        
           repo = "opshin";

     

       16
       16
        
           tag = version;

     

       17
       17
       -
           hash = "sha256-5IzPxzNvH9nlOYBCbc8kC7yzf8L8LPA5Wq9agqg9kng=";

     

       17
       17
       +
           hash = "sha256-+uuTEszA5p/qhvthM3Uje6yX3urbIUAKKfDZ4JXEYYQ=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         propagatedBuildInputs = with python3.pkgs; [

+3 -3

pkgs/by-name/or/orchard/package.nix

···

       7
       7
        
       

     

       8
       8
        
       buildGoModule rec {

     

       9
       9
        
         pname = "orchard";

     

       10
       10
       -
         version = "0.28.2";

     

       10
       10
       +
         version = "0.28.3";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "cirruslabs";

     

       14
       14
        
           repo = pname;

     

       15
       15
        
           rev = version;

     

       16
       16
       -
           hash = "sha256-QH/TkXBdqpgIiByLmutqk6M4GWwkm/BThTRN2DZXhc0=";

     

       16
       16
       +
           hash = "sha256-blXxINsM793iH7X38J+Mrqf/WKnSRoS48yP4r3Dllow=";

     

       17
       17
        
           # populate values that require us to use git. By doing this in postFetch we

     

       18
       18
        
           # can delete .git afterwards and maintain better reproducibility of the src.

     

       19
       19
        
           leaveDotGit = true;

     
···

       24
       24
        
           '';

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
       -
         vendorHash = "sha256-0bdsz5Oj351dztApJ1FnSbObuCKEPC38Fupe3NyRAAQ=";

     

       27
       27
       +
         vendorHash = "sha256-OimkH34coQLhJlJd3BGBFE9L/TQtU4tJbTl0zwmQh3w=";

     

       28
       28
        
       

     

       29
       29
        
         nativeBuildInputs = [ installShellFiles ];

     

       30
       30

+3 -3

pkgs/by-name/re/repomix/package.nix

···

       8
       8
        
       

     

       9
       9
        
       buildNpmPackage rec {

     

       10
       10
        
         pname = "repomix";

     

       11
       11
       -
         version = "0.2.29";

     

       11
       11
       +
         version = "0.2.36";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "yamadashy";

     

       15
       15
        
           repo = "repomix";

     

       16
       16
        
           tag = "v${version}";

     

       17
       17
       -
           hash = "sha256-AOqGmI5hnDA18/+uFGQwVKdLniOvGMEBKHTZJa5gE2w=";

     

       17
       17
       +
           hash = "sha256-utuCtkDp+3411FTqKxpXdE0XAMsVT0dwpcMAdJ2pAB0=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         npmDepsHash = "sha256-R/NTlU5ljwmoGHB/5wPADkGx8xjfF4d2bPWWkAr+VOk=";

     

       20
       20
       +
         npmDepsHash = "sha256-jKAHFxxRheMw8pcYfOurL7L5TFaNIQjoxpJsPysuKYI=";

     

       21
       21
        
       

     

       22
       22
        
         nativeInstallCheckInputs = [ versionCheckHook ];

     

       23
       23
        
         doInstallCheck = true;

+2 -3

pkgs/by-name/sa/sage/package.nix

···

       47
       47
        
             "{connection_file}"

     

       48
       48
        
           ];

     

       49
       49
        
           language = "sage";

     

       50
       50
       -
           # just one 16x16 logo is available

     

       51
       51
       -
           logo32 = "${sage-src}/src/doc/common/static/sageicon.png";

     

       52
       52
       -
           logo64 = "${sage-src}/src/doc/common/static/sageicon.png";

     

       50
       50
       +
           logo32 = "${sage-src}/src/sage/ext_data/notebook-ipython/logo-64x64.png";

     

       51
       51
       +
           logo64 = "${sage-src}/src/sage/ext_data/notebook-ipython/logo-64x64.png";

     

       53
       52
        
         };

     

       54
       53
        
       

     

       55
       54
        
         jupyter-kernel-specs = pkgs.jupyter-kernel.create {

+26

pkgs/by-name/sd/SDL_compat/find-headers.patch

···

       1
       1
       +
       diff --git a/sdl-config.in b/sdl-config.in

     

       2
       2
       +
       index ce332b3..359d574 100755

     

       3
       3
       +
       --- a/sdl-config.in

     

       4
       4
       +
       +++ b/sdl-config.in

     

       5
       5
       +
       @@ -50,14 +50,18 @@ while test $# -gt 0; do

     

       6
       6
       +
              echo @PROJECT_VERSION@

     

       7
       7
       +
              ;;

     

       8
       8
       +
            --cflags)

     

       9
       9
       +
       -      echo -I${includedir}/SDL @SDL_CFLAGS@

     

       10
       10
       +
       +      SDL_CFLAGS=""

     

       11
       11
       +
       +      for i in @includedir@/SDL $SDL_PATH; do

     

       12
       12
       +
       +        SDL_CFLAGS="$SDL_CFLAGS -I$i"

     

       13
       13
       +
       +      done

     

       14
       14
       +
       +      echo $SDL_CFLAGS @SDL_CFLAGS@

     

       15
       15
       +
              ;;

     

       16
       16
       +
        @ENABLE_SHARED_TRUE@    --libs)

     

       17
       17
       +
       -@ENABLE_SHARED_TRUE@      echo -L${libdir} @SDL_RLD_FLAGS@ @SDL_LIBS@

     

       18
       18
       +
       +@ENABLE_SHARED_TRUE@      echo -L${libdir} @SDL_RLD_FLAGS@ @SDL_LIBS@ $SDL_LIB_PATH

     

       19
       19
       +
        @ENABLE_SHARED_TRUE@      ;;

     

       20
       20
       +
        @ENABLE_STATIC_TRUE@@ENABLE_SHARED_TRUE@    --static-libs)

     

       21
       21
       +
        @ENABLE_STATIC_TRUE@@ENABLE_SHARED_FALSE@    --libs|--static-libs)

     

       22
       22
       +
       -@ENABLE_STATIC_TRUE@      echo -L${libdir} @SDL_LIBS@ @SDL_STATIC_LIBS@

     

       23
       23
       +
       +@ENABLE_STATIC_TRUE@      echo -L${libdir} @SDL_LIBS@ @SDL_STATIC_LIBS@ $SDL_LIB_PATH

     

       24
       24
       +
        @ENABLE_STATIC_TRUE@      ;;

     

       25
       25
       +
            *)

     

       26
       26
       +
              echo "${usage}" 1>&2

+6 -2

pkgs/by-name/sd/SDL_compat/package.nix

···

       48
       48
        
       

     

       49
       49
        
         enableParallelBuilding = true;

     

       50
       50
        
       

     

       51
       51
       -
         setupHook = ./setup-hook.sh;

     

       52
       52
       -
       

     

       53
       51
        
         postInstall = ''

     

       54
       52
        
           # allow as a drop in replacement for SDL

     

       55
       53
        
           # Can be removed after treewide switch from pkg-config to pkgconf

     

       56
       54
        
           ln -s $out/lib/pkgconfig/sdl12_compat.pc $out/lib/pkgconfig/sdl.pc

     

       57
       55
        
         '';

     

       56
       56
       +
       

     

       57
       57
       +
         # The setup hook scans paths of buildInputs to find SDL related packages and

     

       58
       58
       +
         # adds their include and library paths to environment variables. The sdl-config

     

       59
       59
       +
         # is patched to use these variables to produce correct flags for compiler.

     

       60
       60
       +
         patches = [ ./find-headers.patch ];

     

       61
       61
       +
         setupHook = ./setup-hook.sh;

     

       58
       62
        
       

     

       59
       63
        
         postFixup = ''

     

       60
       64
        
           for lib in $out/lib/*${stdenv.hostPlatform.extensions.sharedLibrary}* ; do

+2 -2

pkgs/by-name/sn/snowsql/package.nix

···

       11
       11
        
       

     

       12
       12
        
       stdenv.mkDerivation rec {

     

       13
       13
        
         pname = "snowsql";

     

       14
       14
       -
         version = "1.3.0";

     

       14
       14
       +
         version = "1.3.3";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchurl {

     

       17
       17
        
           url = "https://sfc-repo.snowflakecomputing.com/snowsql/bootstrap/${lib.versions.majorMinor version}/linux_x86_64/snowflake-snowsql-${version}-1.x86_64.rpm";

     

       18
       18
       -
           sha256 = "sha256-KKCCj+pIwWhuzOuxljQ8Y11mAwD/GONspbXuPAMBdhE=";

     

       18
       18
       +
           sha256 = "sha256-BedOcd3ZllzMSZ6hjs1BG0o9TEg3aJKtLzutOE3nI1s=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         nativeBuildInputs = [

+3 -3

pkgs/by-name/tt/ttdl/package.nix

···

       6
       6
        
       

     

       7
       7
        
       rustPlatform.buildRustPackage rec {

     

       8
       8
        
         pname = "ttdl";

     

       9
       9
       -
         version = "4.9.0";

     

       9
       9
       +
         version = "4.10.0";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "VladimirMarkelov";

     

       13
       13
        
           repo = "ttdl";

     

       14
       14
        
           rev = "v${version}";

     

       15
       15
       -
           sha256 = "sha256-qFOZj214iw/d1wvWz8wwIFB2kaDSPH80blDkohQxSro=";

     

       15
       15
       +
           sha256 = "sha256-cCz2wxYvYAoI+Hmyll+Fn56NUCuWlIiJycmYvGyhkR4=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         useFetchCargoVendor = true;

     

       19
       19
       -
         cargoHash = "sha256-gdFLT04pNedU30/Qw2OiXpdLL+6cC6ryUoeZLKu/myQ=";

     

       19
       19
       +
         cargoHash = "sha256-207Tmfs3LrZkwsAF/9qD5PN/zHwzCf0lq+87bFIP7y8=";

     

       20
       20
        
       

     

       21
       21
        
         meta = with lib; {

     

       22
       22
        
           description = "CLI tool to manage todo lists in todo.txt format";

+2 -2

pkgs/by-name/ty/tygo/package.nix

···

       6
       6
        
       

     

       7
       7
        
       buildGoModule rec {

     

       8
       8
        
         pname = "tygo";

     

       9
       9
       -
         version = "0.2.17";

     

       9
       9
       +
         version = "0.2.18";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "gzuidhof";

     

       13
       13
        
           repo = "tygo";

     

       14
       14
        
           rev = "v${version}";

     

       15
       15
       -
           hash = "sha256-yaXS+DS/xeIQXhn3L6x2lp/xu4OxrBqr5wKVbADhZkU=";

     

       15
       15
       +
           hash = "sha256-W2PgBcbkreP61QtAuOZ+VHUUZ4Mhe++1SK1p4Tg4Ack=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         vendorHash = "sha256-E73yqGhPzZA/1xTYGvTBy0/b4SE9hzx+gdhjX3ClE/Y=";

+4 -4

pkgs/by-name/un/unison-ucm/package.nix

···

       14
       14
        
       

     

       15
       15
        
       stdenv.mkDerivation (finalAttrs: {

     

       16
       16
        
         pname = "unison-code-manager";

     

       17
       17
       -
         version = "0.5.33";

     

       17
       17
       +
         version = "0.5.36";

     

       18
       18
        
       

     

       19
       19
        
         src =

     

       20
       20
        
           {

     

       21
       21
        
             aarch64-darwin = fetchurl {

     

       22
       22
        
               url = "https://github.com/unisonweb/unison/releases/download/release/${finalAttrs.version}/ucm-macos-arm64.tar.gz";

     

       23
       23
       -
               hash = "sha256-DXqQMv1pEEFSHDsY8BICFfKAD4zaishRIDo1hwCVj54=";

     

       23
       23
       +
               hash = "sha256-GH0qZtb29qDxL39nArYSzCQ50/ssPOiN9CXnAvb9uVQ=";

     

       24
       24
        
             };

     

       25
       25
        
             x86_64-darwin = fetchurl {

     

       26
       26
        
               url = "https://github.com/unisonweb/unison/releases/download/release/${finalAttrs.version}/ucm-macos-x64.tar.gz";

     

       27
       27
       -
               hash = "sha256-ffHbkujs3UMChPM2uL3tBcxInKEOHwRUMrIeh+k5ghY=";

     

       27
       27
       +
               hash = "sha256-seL8Ey20KYVsOLugGvfVXXIIVdv7q04PYXh3c6MoZDk=";

     

       28
       28
        
             };

     

       29
       29
        
             x86_64-linux = fetchurl {

     

       30
       30
        
               url = "https://github.com/unisonweb/unison/releases/download/release/${finalAttrs.version}/ucm-linux-x64.tar.gz";

     

       31
       31
       -
               hash = "sha256-+kBuQn73P8yxa8l6/R3NGj61LB6kKwa2lfNKZmhI5Dk=";

     

       31
       31
       +
               hash = "sha256-Zb91ixXd3ueQj6+YjC9Wgq3PnfcKBKZZdCJfS0nQOV4=";

     

       32
       32
        
             };

     

       33
       33
        
           }

     

       34
       34
        
           .${stdenv.hostPlatform.system} or (throw "Unsupported platform ${stdenv.hostPlatform.system}");

+1 -2

pkgs/by-name/va/varia/package.nix

···

       27
       27
        
       

     

       28
       28
        
         postPatch = ''

     

       29
       29
        
           substituteInPlace src/varia-py.in \

     

       30
       30
       -
             --replace-fail 'aria2cexec = sys.argv[1]' 'aria2cexec = "${lib.getExe aria2}"'

     

       31
       31
       -
           substituteInPlace src/varia-py.in \

     

       30
       30
       +
             --replace-fail 'aria2cexec = sys.argv[1]' 'aria2cexec = "${lib.getExe aria2}"' \

     

       32
       31
        
             --replace-fail 'ffmpegexec = sys.argv[2]' 'ffmpegexec = "${lib.getExe ffmpeg}"'

     

       33
       32
        
         '';

     

       34
       33

pkgs/by-name/vi/viennarna/package.nix

···

       2
       2
        
         lib,

     

       3
       3
        
         stdenv,

     

       4
       4
        
         fetchurl,

     

       5
       5
       +
         dlib,

     

       5
       6
        
         gsl,

     

       6
       7
        
         mpfr,

     

       7
       8
        
         perl,

     
···

       16
       17
        
           url = "https://www.tbi.univie.ac.at/RNA/download/sourcecode/2_7_x/ViennaRNA-${version}.tar.gz";

     

       17
       18
        
           hash = "sha256-mpn9aO04CJTe+01eaooocWKScAKM338W8KBdpujHFHM=";

     

       18
       19
        
         };

     

       20
       20
       +
       

     

       21
       21
       +
         # use nixpkgs dlib sources instead of bundled ones

     

       22
       22
       +
         # using dlib-19.24.8 fixes the build with modern compilers (such as clang-19)

     

       23
       23
       +
         postPatch = ''

     

       24
       24
       +
           rm -rf ./src/dlib-19.24

     

       25
       25
       +
           cp -a ${dlib.src} ./src/dlib-19.24

     

       26
       26
       +
           find ./src/dlib-19.24 -type d -exec chmod +w {} \;

     

       27
       27
       +
         '';

     

       19
       28
        
       

     

       20
       29
        
         buildInputs = [

     

       21
       30
        
           gsl

+2 -2

pkgs/by-name/wx/wxsqlite3/package.nix

···

       9
       9
        
       

     

       10
       10
        
       stdenv.mkDerivation rec {

     

       11
       11
        
         pname = "wxsqlite3";

     

       12
       12
       -
         version = "4.10.4";

     

       12
       12
       +
         version = "4.10.5";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = "utelle";

     

       16
       16
        
           repo = "wxsqlite3";

     

       17
       17
        
           rev = "v${version}";

     

       18
       18
       -
           hash = "sha256-IHlQxVAgCZ8Nwz2VbP8Wvf3on9XEaVBDEMInUWHw2XQ=";

     

       18
       18
       +
           hash = "sha256-aDEVT3R948P+N1fFC9Q7LNf8FpPuxlKs+dQurewtaFA=";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         nativeBuildInputs = [

+4 -5

pkgs/by-name/xf/xfig/package.nix

···

       16
       16
        
       

     

       17
       17
        
       stdenv.mkDerivation rec {

     

       18
       18
        
         pname = "xfig";

     

       19
       19
       -
         version = "3.2.9";

     

       19
       19
       +
         version = "3.2.9a";

     

       20
       20
        
       

     

       21
       21
        
         src = fetchurl {

     

       22
       22
        
           url = "mirror://sourceforge/mcj/xfig-${version}.tar.xz";

     

       23
       23
       -
           hash = "sha256-E+2dBNG7wt7AnafvSc7sJ4OC0pD2zZJkdMLy0Bb+wvc=";

     

       23
       23
       +
           hash = "sha256-vFcqGIHl4gmHrFkBWLBBq3gDhFqWkQNtO6XpgvZtnKM=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         nativeBuildInputs = [

     
···

       39
       39
        
         ];

     

       40
       40
        
       

     

       41
       41
        
         postPatch = ''

     

       42
       42
       -
           substituteInPlace src/main.c --replace '"fig2dev"' '"${fig2dev}/bin/fig2dev"'

     

       43
       43
       -
           substituteInPlace xfig.desktop --replace "/usr/bin/" "$out/bin/"

     

       42
       42
       +
           substituteInPlace src/main.c --replace-fail '"fig2dev"' '"${fig2dev}/bin/fig2dev"'

     

       44
       43
        
         '';

     

       45
       44
        
       

     

       46
       45
        
         postInstall = ''

     
···

       53
       52
        
           mkdir -p $out/share/icons/hicolor/{16x16,22x22,48x48,64x64}/apps

     

       54
       53
        
       

     

       55
       54
        
           for dimension in 16x16 22x22 48x48; do

     

       56
       56
       -
             convert doc/html/images/xfig-logo.png -geometry $dimension\

     

       55
       55
       +
             magick convert doc/html/images/xfig-logo.png -geometry $dimension\

     

       57
       56
        
               $out/share/icons/hicolor/16x16/apps/xfig.png

     

       58
       57
        
           done

     

       59
       58
        
           install doc/html/images/xfig-logo.png \

+2 -2

pkgs/by-name/ya/yandex-music/package.nix

···

       14
       14
        
       }:

     

       15
       15
        
       stdenvNoCC.mkDerivation rec {

     

       16
       16
        
         pname = "yandex-music";

     

       17
       17
       -
         version = "5.28.4";

     

       17
       17
       +
         version = "5.39.0";

     

       18
       18
        
       

     

       19
       19
        
         src = fetchFromGitHub {

     

       20
       20
        
           owner = "cucumber-sp";

     

       21
       21
        
           repo = "yandex-music-linux";

     

       22
       22
        
           rev = "v${version}";

     

       23
       23
       -
           hash = "sha256-0YUZKklwHkZ3bDI4OLmXyj0v2wzWzJbJpQ8QQa356fI=";

     

       23
       23
       +
           hash = "sha256-oEbbQRqvnK521N3Kerv18h1frVLbioFeHfb/FCkHC6Y=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         nativeBuildInputs = [

+4 -4

pkgs/by-name/ya/yandex-music/ym_info.json

···

       1
       1
        
       {

     

       2
       2
       -
         "version": "5.28.4",

     

       3
       3
       -
         "exe_name": "Yandex_Music_x64_5.28.4.exe",

     

       4
       4
       -
         "exe_link": "https://music-desktop-application.s3.yandex.net/stable/Yandex_Music_x64_5.28.4.exe",

     

       5
       5
       -
         "exe_hash": "sha256-fJlRtGgOJcHbAgUBxrv3AJro7uN5En9le2b+a5K2QMc="

     

       2
       2
       +
         "version": "5.39.0",

     

       3
       3
       +
         "exe_name": "Yandex_Music_x64_5.39.0.exe",

     

       4
       4
       +
         "exe_link": "https://music-desktop-application.s3.yandex.net/stable/Yandex_Music_x64_5.39.0.exe",

     

       5
       5
       +
         "exe_hash": "sha256-jOaxKDOkabsNQTXH5+UGwfdL+Srjm5gjQgHe/YuGiaQ="

     

       6
       6
        
       }

+3 -3

pkgs/by-name/ye/yew-fmt/package.nix

···

       8
       8
        
       

     

       9
       9
        
       rustPlatform.buildRustPackage rec {

     

       10
       10
        
         pname = "yew-fmt";

     

       11
       11
       -
         version = "0.5.3";

     

       11
       11
       +
         version = "0.5.5";

     

       12
       12
        
       

     

       13
       13
        
         src = fetchFromGitHub {

     

       14
       14
        
           owner = "its-the-shrimp";

     

       15
       15
        
           repo = "yew-fmt";

     

       16
       16
        
           tag = "v${version}";

     

       17
       17
       -
           hash = "sha256-Ck6WA6ROm8APTsgoxbVGUqoblc5awW+hmmzcy4ZFoBM=";

     

       17
       17
       +
           hash = "sha256-2sOw8wWfnEphYsruQyhZMW3KofcGkNHJB6Q1jhFP3oo=";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
       -
         cargoHash = "sha256-Fp8MT1LJ1EpqwEZ+SpOomqZ7we47w2S5ExkB966Z3r0=";

     

       20
       20
       +
         cargoHash = "sha256-o4oRVI3+Nz8fwdwlyVvXUuhCQr4Bbg5Kife/PJoJCJY=";

     

       21
       21
        
         nativeCheckInputs = [ rustfmt ];

     

       22
       22
        
         passthru.updateScript = nix-update-script { };

     

       23
       23
        
         useFetchCargoVendor = true;

+49

pkgs/by-name/zs/zsh-histdb/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         stdenvNoCC,

     

       4
       4
       +
         fetchFromGitHub,

     

       5
       5
       +
         makeWrapper,

     

       6
       6
       +
         zsh,

     

       7
       7
       +
         sqlite,

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       stdenvNoCC.mkDerivation {

     

       11
       11
       +
         pname = "zsh-histdb";

     

       12
       12
       +
         version = "0-unstable-2024-04-18";

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchFromGitHub {

     

       15
       15
       +
           owner = "larkery";

     

       16
       16
       +
           repo = "zsh-histdb";

     

       17
       17
       +
           rev = "90a6c104d0fcc0410d665e148fa7da28c49684eb";

     

       18
       18
       +
           hash = "sha256-vtG1poaRVbfb/wKPChk1WpPgDq+7udLqLfYfLqap4Vg=";

     

       19
       19
       +
         };

     

       20
       20
       +
       

     

       21
       21
       +
         postPatch = ''

     

       22
       22
       +
           substituteInPlace sqlite-history.zsh \

     

       23
       23
       +
             --replace-fail 'sqlite3' '"${lib.getExe sqlite}"'

     

       24
       24
       +
         '';

     

       25
       25
       +
       

     

       26
       26
       +
         buildInputs = [

     

       27
       27
       +
           zsh

     

       28
       28
       +
         ];

     

       29
       29
       +
       

     

       30
       30
       +
         installPhase = ''

     

       31
       31
       +
           runHook preInstall

     

       32
       32
       +
       

     

       33
       33
       +
           install -Dt $out/share/zsh-histdb/ \

     

       34
       34
       +
             sqlite-history.zsh histdb-interactive.zsh histdb-{merge,migrate}

     

       35
       35
       +
       

     

       36
       36
       +
           runHook postInstall

     

       37
       37
       +
         '';

     

       38
       38
       +
       

     

       39
       39
       +
         meta = {

     

       40
       40
       +
           description = "History database for Zsh, based on SQLite";

     

       41
       41
       +
           homepage = "https://github.com/larkery/zsh-histdb";

     

       42
       42
       +
           license = lib.licenses.mit;

     

       43
       43
       +
           maintainers = with lib.maintainers; [

     

       44
       44
       +
             fliegendewurst

     

       45
       45
       +
             luochen1990

     

       46
       46
       +
           ];

     

       47
       47
       +
           platforms = lib.platforms.unix;

     

       48
       48
       +
         };

     

       49
       49
       +
       }

+1 -1

pkgs/development/libraries/openal-soft/default.nix

···

       5
       5
        
         cmake,

     

       6
       6
        
         pkg-config,

     

       7
       7
        
         removeReferencesTo,

     

       8
       8
       -
         alsaSupport ? !stdenv.hostPlatform.isDarwin,

     

       8
       8
       +
         alsaSupport ? stdenv.hostPlatform.isLinux,

     

       9
       9
        
         alsa-lib,

     

       10
       10
        
         dbusSupport ? !stdenv.hostPlatform.isDarwin,

     

       11
       11
        
         dbus,

+12 -6

pkgs/development/python-modules/configshell/default.nix

···

       2
       2
        
         lib,

     

       3
       3
        
         fetchFromGitHub,

     

       4
       4
        
         buildPythonPackage,

     

       5
       5
       +
         pythonOlder,

     

       6
       6
       +
         hatchling,

     

       7
       7
       +
         hatch-vcs,

     

       5
       8
        
         pyparsing,

     

       6
       6
       -
         six,

     

       7
       7
       -
         urwid,

     

       8
       9
        
       }:

     

       9
       10
        
       

     

       10
       11
        
       buildPythonPackage rec {

     

       11
       12
        
         pname = "configshell";

     

       12
       13
        
         version = "2.0.0";

     

       13
       13
       -
         format = "setuptools";

     

       14
       14
       +
         pyproject = true;

     

       15
       15
       +
       

     

       16
       16
       +
         disabled = pythonOlder "3.9";

     

       14
       17
        
       

     

       15
       18
        
         src = fetchFromGitHub {

     

       16
       19
        
           owner = "open-iscsi";

     
···

       19
       22
        
           hash = "sha256-lP3WT9ASEj6WiCrurSU/e9FhIaeoQW/n9hi1XZMnV4Q=";

     

       20
       23
        
         };

     

       21
       24
        
       

     

       22
       22
       -
         propagatedBuildInputs = [

     

       25
       25
       +
         build-system = [

     

       26
       26
       +
           hatchling

     

       27
       27
       +
           hatch-vcs

     

       28
       28
       +
         ];

     

       29
       29
       +
       

     

       30
       30
       +
         dependencies = [

     

       23
       31
        
           pyparsing

     

       24
       24
       -
           six

     

       25
       25
       -
           urwid

     

       26
       32
        
         ];

     

       27
       33
        
       

     

       28
       34
        
         # Module has no tests

+6 -2

pkgs/development/python-modules/orbax-checkpoint/default.nix

···

       34
       34
        
       

     

       35
       35
        
       buildPythonPackage rec {

     

       36
       36
        
         pname = "orbax-checkpoint";

     

       37
       37
       -
         version = "0.11.6";

     

       37
       37
       +
         version = "0.11.8";

     

       38
       38
        
         pyproject = true;

     

       39
       39
        
       

     

       40
       40
        
         src = fetchFromGitHub {

     

       41
       41
        
           owner = "google";

     

       42
       42
        
           repo = "orbax";

     

       43
       43
        
           tag = "v${version}";

     

       44
       44
       -
           hash = "sha256-2bnm9D+ywhploTmtZ+frwf8VuTjczBVN+wqcfe3x77I=";

     

       44
       44
       +
           hash = "sha256-h7SXuOhytM9ev0Q53z0UoT9/ShPVlqgFofn7j8gnehM=";

     

       45
       45
        
         };

     

       46
       46
        
       

     

       47
       47
        
         sourceRoot = "${src.name}/checkpoint";

     

       48
       48
        
       

     

       49
       49
        
         build-system = [ flit-core ];

     

       50
       50
       +
       

     

       51
       51
       +
         pythonRelaxDeps = [

     

       52
       52
       +
           "jax"

     

       53
       53
       +
         ];

     

       50
       54
        
       

     

       51
       55
        
         dependencies = [

     

       52
       56
        
           absl-py

+6 -1

pkgs/development/python-modules/pdb2pqr/default.nix

···

       3
       3
        
         buildPythonPackage,

     

       4
       4
        
         fetchPypi,

     

       5
       5
        
         pythonOlder,

     

       6
       6
       +
         hatchling,

     

       6
       7
        
         mmcif-pdbx,

     

       7
       8
        
         numpy,

     

       8
       9
        
         propka,

     
···

       16
       17
        
       buildPythonPackage rec {

     

       17
       18
        
         pname = "pdb2pqr";

     

       18
       19
        
         version = "3.7.1";

     

       19
       19
       -
         format = "setuptools";

     

       20
       20
       +
         pyproject = true;

     

       20
       21
        
       

     

       21
       22
        
         disabled = pythonOlder "3.7";

     

       22
       23
        
       

     
···

       26
       27
        
         };

     

       27
       28
        
       

     

       28
       29
        
         pythonRelaxDeps = [ "docutils" ];

     

       30
       30
       +
       

     

       31
       31
       +
         build-system = [

     

       32
       32
       +
           hatchling

     

       33
       33
       +
         ];

     

       29
       34
        
       

     

       30
       35
        
         propagatedBuildInputs = [

     

       31
       36
        
           mmcif-pdbx

+2 -2

pkgs/development/python-modules/python-roborock/default.nix

···

       22
       22
        
       

     

       23
       23
        
       buildPythonPackage rec {

     

       24
       24
        
         pname = "python-roborock";

     

       25
       25
       -
         version = "2.12.0";

     

       25
       25
       +
         version = "2.12.1";

     

       26
       26
        
         pyproject = true;

     

       27
       27
        
       

     

       28
       28
        
         disabled = pythonOlder "3.10";

     
···

       31
       31
        
           owner = "humbertogontijo";

     

       32
       32
        
           repo = "python-roborock";

     

       33
       33
        
           tag = "v${version}";

     

       34
       34
       -
           hash = "sha256-hJzmAvIKb1rLwGo5uYiRWYspH4d3uTdoF7k+emlCAec=";

     

       34
       34
       +
           hash = "sha256-oUsnjvrPq4VcYwafZqzZkA2I9Hs75j03nOcIIO7abpk=";

     

       35
       35
        
         };

     

       36
       36
        
       

     

       37
       37
        
         postPatch = ''

+4 -4

pkgs/development/python-modules/torchrl/default.nix

···

       38
       38
        
         tensorboard,

     

       39
       39
        
         wandb,

     

       40
       40
        
       

     

       41
       41
       -
         # checks

     

       41
       41
       +
         # tests

     

       42
       42
        
         imageio,

     

       43
       43
        
         pytest-rerunfailures,

     

       44
       44
        
         pytestCheckHook,

     
···

       48
       48
        
       

     

       49
       49
        
       buildPythonPackage rec {

     

       50
       50
        
         pname = "torchrl";

     

       51
       51
       -
         version = "0.7.1";

     

       51
       51
       +
         version = "0.7.2";

     

       52
       52
        
         pyproject = true;

     

       53
       53
        
       

     

       54
       54
        
         src = fetchFromGitHub {

     

       55
       55
        
           owner = "pytorch";

     

       56
       56
        
           repo = "rl";

     

       57
       57
        
           tag = "v${version}";

     

       58
       58
       -
           hash = "sha256-+GE84GusipNZ18euV8ag0AbOtUrYfOxUAeXeCgF2OiI=";

     

       58
       58
       +
           hash = "sha256-hcCZSASAp9jbOhbFLJndridYn76R99K+LxRxQl3uaxM=";

     

       59
       59
        
         };

     

       60
       60
        
       

     

       61
       61
        
         build-system = [

     
···

       183
       183
        
         meta = {

     

       184
       184
        
           description = "Modular, primitive-first, python-first PyTorch library for Reinforcement Learning";

     

       185
       185
        
           homepage = "https://github.com/pytorch/rl";

     

       186
       186
       -
           changelog = "https://github.com/pytorch/rl/releases/tag/${src.tag}";

     

       186
       186
       +
           changelog = "https://github.com/pytorch/rl/releases/tag/v${version}";

     

       187
       187
        
           license = lib.licenses.mit;

     

       188
       188
        
           maintainers = with lib.maintainers; [ GaetanLepage ];

     

       189
       189
        
           # torhcrl is not compatible with our current version of gymnasium (>=1.0)

+3 -3

pkgs/development/python-modules/ultralytics/default.nix

···

       30
       30
        
       

     

       31
       31
        
       buildPythonPackage rec {

     

       32
       32
        
         pname = "ultralytics";

     

       33
       33
       -
         version = "8.3.85";

     

       33
       33
       +
         version = "8.3.86";

     

       34
       34
        
         pyproject = true;

     

       35
       35
        
       

     

       36
       36
        
         src = fetchFromGitHub {

     

       37
       37
        
           owner = "ultralytics";

     

       38
       38
        
           repo = "ultralytics";

     

       39
       39
        
           tag = "v${version}";

     

       40
       40
       -
           hash = "sha256-4EiTiy4SNinNwIUvqbckaA/5YRcv6io8ssTAhwDVgsM=";

     

       40
       40
       +
           hash = "sha256-9z6f/48jQVCR744ojNH+T22+JDg31+WEKWi48k5/GoY=";

     

       41
       41
        
         };

     

       42
       42
        
       

     

       43
       43
        
         postPatch = ''

     
···

       100
       100
        
       

     

       101
       101
        
         meta = {

     

       102
       102
        
           homepage = "https://github.com/ultralytics/ultralytics";

     

       103
       103
       -
           changelog = "https://github.com/ultralytics/ultralytics/releases/tag/v${version}";

     

       103
       103
       +
           changelog = "https://github.com/ultralytics/ultralytics/releases/tag/${src.tag}";

     

       104
       104
        
           description = "Train YOLO models for computer vision tasks";

     

       105
       105
        
           mainProgram = "yolo";

     

       106
       106
        
           license = lib.licenses.agpl3Only;

+2 -2

pkgs/development/python-modules/uproot/default.nix

···

       27
       27
        
       

     

       28
       28
        
       buildPythonPackage rec {

     

       29
       29
        
         pname = "uproot";

     

       30
       30
       -
         version = "5.5.2";

     

       30
       30
       +
         version = "5.6.0";

     

       31
       31
        
         pyproject = true;

     

       32
       32
        
       

     

       33
       33
        
         src = fetchFromGitHub {

     

       34
       34
        
           owner = "scikit-hep";

     

       35
       35
        
           repo = "uproot5";

     

       36
       36
        
           tag = "v${version}";

     

       37
       37
       -
           hash = "sha256-vMTZ3ajCEkKKerPXThSxk0vgGxK2Po9hVf8ofaGCO04=";

     

       37
       37
       +
           hash = "sha256-9DObKSMGx6fgU6DHafqynd7XC36zdjzp24iyaugobw8=";

     

       38
       38
        
         };

     

       39
       39
        
       

     

       40
       40
        
         build-system = [

+3 -3

pkgs/development/tools/apko/default.nix

···

       7
       7
        
       

     

       8
       8
        
       buildGoModule rec {

     

       9
       9
        
         pname = "apko";

     

       10
       10
       -
         version = "0.25.1";

     

       10
       10
       +
         version = "0.25.2";

     

       11
       11
        
       

     

       12
       12
        
         src = fetchFromGitHub {

     

       13
       13
        
           owner = "chainguard-dev";

     

       14
       14
        
           repo = pname;

     

       15
       15
        
           tag = "v${version}";

     

       16
       16
       -
           hash = "sha256-ElHRhEsXP3pzTkys9c8FaQODZJmFDMl4ubUIU4B1ACM=";

     

       16
       16
       +
           hash = "sha256-lvxdpc8rXGgebxjFEeQOlpDfLwwe8a0QAfqApCgWAHw=";

     

       17
       17
        
           # populate values that require us to use git. By doing this in postFetch we

     

       18
       18
        
           # can delete .git afterwards and maintain better reproducibility of the src.

     

       19
       19
        
           leaveDotGit = true;

     
···

       25
       25
        
             find "$out" -name .git -print0 | xargs -0 rm -rf

     

       26
       26
        
           '';

     

       27
       27
        
         };

     

       28
       28
       -
         vendorHash = "sha256-ddvdnnDxqwqO6xtLf5NoMT2WYNNMuvyHlo2+/A6rN0E=";

     

       28
       28
       +
         vendorHash = "sha256-EE59/VyP/dK9qZuTSQqqxAhcJUh/hfSopR7x6k5Eunc=";

     

       29
       29
        
       

     

       30
       30
        
         nativeBuildInputs = [ installShellFiles ];

     

       31
       31

+2 -2

pkgs/development/tools/esbuild/default.nix

···

       6
       6
        
       

     

       7
       7
        
       buildGoModule rec {

     

       8
       8
        
         pname = "esbuild";

     

       9
       9
       -
         version = "0.25.0";

     

       9
       9
       +
         version = "0.25.1";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "evanw";

     

       13
       13
        
           repo = "esbuild";

     

       14
       14
        
           rev = "v${version}";

     

       15
       15
       -
           hash = "sha256-L9jm94Epb22hYsU3hoq1lZXb5aFVD4FC4x2qNt0DljA=";

     

       15
       15
       +
           hash = "sha256-vrhtdrvrcC3dQoJM6hWq6wrGJLSiVww/CNPlL1N5kQ8=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         vendorHash = "sha256-+BfxCyg0KkDQpHt/wycy/8CTG6YBA/VJvJFhhzUnSiQ=";

-6

pkgs/games/rott/default.nix

···

       44
       44
        
           "SHAREWARE=${if buildShareware then "1" else "0"}"

     

       45
       45
        
         ];

     

       46
       46
        
       

     

       47
       47
       -
         # when using SDL_compat instead of SDL1, SDL_mixer isn't correctly detected,

     

       48
       48
       -
         # but there is no harm just specifying it

     

       49
       49
       -
         env.NIX_CFLAGS_COMPILE = toString [

     

       50
       50
       -
           "-I${lib.getDev SDL_mixer}/include/SDL"

     

       51
       51
       -
         ];

     

       52
       52
       -
       

     

       53
       47
        
         installPhase = ''

     

       54
       48
        
           runHook preInstall

     

       55
       49

+4 -3

pkgs/servers/http/nginx/modules.nix

···

       432
       432
        
           name = "modsecurity";

     

       433
       433
        
           src = fetchFromGitHub {

     

       434
       434
        
             name = "modsecurity-nginx";

     

       435
       435
       -
             owner = "SpiderLabs";

     

       435
       435
       +
             owner = "owasp-modsecurity";

     

       436
       436
        
             repo = "ModSecurity-nginx";

     

       437
       437
       -
             rev = "v1.0.3";

     

       438
       438
       -
             sha256 = "sha256-xp0/eqi5PJlzb9NaUbNnzEqNcxDPyjyNwZOwmlv1+ag=";

     

       437
       437
       +
             # unstable 2025-02-17

     

       438
       438
       +
             rev = "0b4f0cf38502f34a30c8543039f345cfc075670d";

     

       439
       439
       +
             hash = "sha256-P3IwKFR4NbaMXYY+O9OHfZWzka4M/wr8sJpX94LzQTU=";

     

       439
       440
        
           };

     

       440
       441
        
       

     

       441
       442
        
           inputs = [ curl geoip libmodsecurity libxml2 lmdb yajl ];

+3 -3

pkgs/servers/oxigraph/default.nix

···

       9
       9
        
       

     

       10
       10
        
       rustPlatform.buildRustPackage rec {

     

       11
       11
        
         pname = "oxigraph";

     

       12
       12
       -
         version = "0.4.8";

     

       12
       12
       +
         version = "0.4.9";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = pname;

     

       16
       16
        
           repo = pname;

     

       17
       17
        
           rev = "v${version}";

     

       18
       18
       -
           hash = "sha256-yMXNt7pGiwYDXjmHxKUQpqNrAmnFpg21Vc5R1DmwsHc=";

     

       18
       18
       +
           hash = "sha256-sv9LpAoPQ4oFrGI6j6NgVZwEwpM1wt93lHkUwnvmhIY=";

     

       19
       19
        
           fetchSubmodules = true;

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         useFetchCargoVendor = true;

     

       23
       23
       -
         cargoHash = "sha256-qOGpM3SOAOMO5W3wj4ruXlymp9bV4sqOU75gMVSEyfk=";

     

       23
       23
       +
         cargoHash = "sha256-nVlvmYOxZDMLvxP8JaKTyKMgW6+48B8B+UzlwgthJS0=";

     

       24
       24
        
       

     

       25
       25
        
         nativeBuildInputs = [

     

       26
       26
        
           rustPlatform.bindgenHook

+97 -97

pkgs/tools/admin/pulumi-bin/data.nix

···

       1
       1
        
       # DO NOT EDIT! This file is generated automatically by update.sh

     

       2
       2
        
       { }:

     

       3
       3
        
       {

     

       4
       4
       -
         version = "3.153.1";

     

       4
       4
       +
         version = "3.154.0";

     

       5
       5
        
         pulumiPkgs = {

     

       6
       6
        
           x86_64-linux = [

     

       7
       7
        
             {

     

       8
       8
       -
               url = "https://get.pulumi.com/releases/sdk/pulumi-v3.153.1-linux-x64.tar.gz";

     

       9
       9
       -
               sha256 = "01bppw8yik697x5mwh1pjd8wpi80qzkbbsdp4lyjrsi3514d6nji";

     

       8
       8
       +
               url = "https://get.pulumi.com/releases/sdk/pulumi-v3.154.0-linux-x64.tar.gz";

     

       9
       9
       +
               sha256 = "1vjz37qq7q2iyxz9c482rhcdljlsxl1y1mw8mqp50zlrc785n8rr";

     

       10
       10
        
             }

     

       11
       11
        
             {

     

       12
       12
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aiven-v6.35.0-linux-amd64.tar.gz";

     

       13
       13
        
               sha256 = "0m25l1iai6ja6n79jb1zzvmz1d087hy1ddhisb8r53nv8awdjz5b";

     

       14
       14
        
             }

     

       15
       15
        
             {

     

       16
       16
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-akamai-v7.6.1-linux-amd64.tar.gz";

     

       17
       17
       -
               sha256 = "0k5mg57257v9h8njlx943fgrxbvszcqi9bhk41kna8j2claqdzdb";

     

       16
       16
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-akamai-v8.0.0-linux-amd64.tar.gz";

     

       17
       17
       +
               sha256 = "1xbwvb15zgxf0vvrpdp5p0jk09kzz3f1hn15k0b3bqjal7dp51qz";

     

       18
       18
        
             }

     

       19
       19
        
             {

     

       20
       20
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-alicloud-v3.74.0-linux-amd64.tar.gz";

     

       21
       21
       -
               sha256 = "0jg062yhp0nx2lhixs3r7lvjzg0q5h3v1f8pvsp04y8hixq7jip8";

     

       20
       20
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-alicloud-v3.75.0-linux-amd64.tar.gz";

     

       21
       21
       +
               sha256 = "0mfr4yj59b2l8bch0dbbmznd3b2rwvsjvp2jyzlq6jpb1sfyj3cr";

     

       22
       22
        
             }

     

       23
       23
        
             {

     

       24
       24
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-artifactory-v8.7.3-linux-amd64.tar.gz";

     

       25
       25
       -
               sha256 = "1cn2ii8ryh46axdvnzksx5zlnd59y1bd9janid8g0pvdz9rxgvdq";

     

       24
       24
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-artifactory-v8.8.0-linux-amd64.tar.gz";

     

       25
       25
       +
               sha256 = "1kyljbg6lkc9mr6j493rjk5mnrh3ldgc8qjxmn8y3nzbc2xmcs65";

     

       26
       26
        
             }

     

       27
       27
        
             {

     

       28
       28
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-auth0-v3.14.0-linux-amd64.tar.gz";

     

       29
       29
        
               sha256 = "06kazf5r3r3cdr2cxk2afj1wjmjj0kda038j9vdpfirzpjyy47l3";

     

       30
       30
        
             }

     

       31
       31
        
             {

     

       32
       32
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v6.70.0-linux-amd64.tar.gz";

     

       33
       33
       -
               sha256 = "0cza17gkr0jd8y4rr17819n6g246jc7mlg675s0sz2dcqvkh5c6j";

     

       32
       32
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v6.71.0-linux-amd64.tar.gz";

     

       33
       33
       +
               sha256 = "0flwsaw3ack9sq99vbpg4k7dyh541ygvjgj0f7a9nm7j728sz9s2";

     

       34
       34
        
             }

     

       35
       35
        
             {

     

       36
       36
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuread-v6.2.0-linux-amd64.tar.gz";

     

       37
       37
        
               sha256 = "1fa45kzn755md2m98c8305hwqq7w414cvnbllvvdvqji2qmikh2d";

     

       38
       38
        
             }

     

       39
       39
        
             {

     

       40
       40
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuredevops-v3.6.0-linux-amd64.tar.gz";

     

       41
       41
       -
               sha256 = "0h3zym30gj8lyj294zj3dimdl2wdir2vmymvv6wr392f9i22m2yn";

     

       40
       40
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuredevops-v3.7.0-linux-amd64.tar.gz";

     

       41
       41
       +
               sha256 = "0c2rzijzfkb3kw4r4yi4hwaqmnxcz0smb0lxyqs05xzgijf74jgx";

     

       42
       42
        
             }

     

       43
       43
        
             {

     

       44
       44
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azure-v6.20.0-linux-amd64.tar.gz";

     

       45
       45
       -
               sha256 = "1dbgwhx1ba92wh9478b24lf3c0w3d2v1q6z7dniyccjimfgdwd29";

     

       44
       44
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azure-v6.21.0-linux-amd64.tar.gz";

     

       45
       45
       +
               sha256 = "18f8fap5zjrjqzmblxgpwffkqj82bhj3pl6vrmj7nlmj4q2r4i88";

     

       46
       46
        
             }

     

       47
       47
        
             {

     

       48
       48
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-cloudflare-v5.49.1-linux-amd64.tar.gz";

     
···

       73
       73
        
               sha256 = "191j823pngyicvgvkjfik9n0nsws2zsqqzykzsad74w59i9cr90c";

     

       74
       74
        
             }

     

       75
       75
        
             {

     

       76
       76
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v8.20.0-linux-amd64.tar.gz";

     

       77
       77
       -
               sha256 = "0lfa7kz3vc7hamsl270xijs7szhbdm09hmll6593q6x9wgmaadal";

     

       76
       76
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v8.21.0-linux-amd64.tar.gz";

     

       77
       77
       +
               sha256 = "1sql8napyydhf35vi4i36qf013g9ibmkr8qcd3c0vx1hslwi89hl";

     

       78
       78
        
             }

     

       79
       79
        
             {

     

       80
       80
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v6.7.0-linux-amd64.tar.gz";

     
···

       121
       121
        
               sha256 = "16scgz83rih511isyq7ycnm4gm94zvf6hgd86kic5s1q20lf86k9";

     

       122
       122
        
             }

     

       123
       123
        
             {

     

       124
       124
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v1.1.2-linux-amd64.tar.gz";

     

       125
       125
       -
               sha256 = "147dmg9gv8b3pifmqwjz9skvidryb8wkayvghdd6pziyqncbqwzb";

     

       124
       124
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v1.1.3-linux-amd64.tar.gz";

     

       125
       125
       +
               sha256 = "1ikw64y55dzhdc49mq3qy4gq2zfbvv3551295mygrz11zrjrmfzp";

     

       126
       126
        
             }

     

       127
       127
        
             {

     

       128
       128
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.111.0-linux-amd64.tar.gz";

     

       129
       129
       -
               sha256 = "0g4zbmn21ii3r75qb18xz4dhafyxzvfh1qmndx49p0mlqyrly950";

     

       128
       128
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.112.0-linux-amd64.tar.gz";

     

       129
       129
       +
               sha256 = "0l6s3pf2nqn4kh8px97c8qvycqm3bhgrnx0wzrsm7f1cfnpd0ss1";

     

       130
       130
        
             }

     

       131
       131
        
             {

     

       132
       132
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-sumologic-v1.0.4-linux-amd64.tar.gz";

     

       133
       133
       -
               sha256 = "0z0wggfg9s0x8wlvymsl030bby4id5rjhb3na0rmsjg3fjh71bsf";

     

       132
       132
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-sumologic-v1.0.5-linux-amd64.tar.gz";

     

       133
       133
       +
               sha256 = "02k9w2f9pvxhw6jsl4g7v7ppgcx4ixd855a2h1dgkallfc7ja63b";

     

       134
       134
        
             }

     

       135
       135
        
             {

     

       136
       136
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-tailscale-v0.18.0-linux-amd64.tar.gz";

     
···

       153
       153
        
               sha256 = "0h5pca5kgyjwdj9m8fd0wmygxhvjm6r5wss00wprad383mwp3s7v";

     

       154
       154
        
             }

     

       155
       155
        
             {

     

       156
       156
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-wavefront-v3.1.7-linux-amd64.tar.gz";

     

       157
       157
       -
               sha256 = "01y7h7k99wz1zh47qhmnzcn74b37lxngimff56rj6dhrd0ngir6k";

     

       156
       156
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-wavefront-v3.1.8-linux-amd64.tar.gz";

     

       157
       157
       +
               sha256 = "0bj4lc7g74vlsv4rqqj9ymbpbc3fdxn483wp1m6y838b3kd69hns";

     

       158
       158
        
             }

     

       159
       159
        
             {

     

       160
       160
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-yandex-v0.13.0-linux-amd64.tar.gz";

     
···

       163
       163
        
           ];

     

       164
       164
        
           x86_64-darwin = [

     

       165
       165
        
             {

     

       166
       166
       -
               url = "https://get.pulumi.com/releases/sdk/pulumi-v3.153.1-darwin-x64.tar.gz";

     

       167
       167
       -
               sha256 = "1nzapprv3c0p3xx4fa1lssxl3fcd0hmbnmn9pnrcll1y2nsvaahb";

     

       166
       166
       +
               url = "https://get.pulumi.com/releases/sdk/pulumi-v3.154.0-darwin-x64.tar.gz";

     

       167
       167
       +
               sha256 = "1l1n5w2b2n1vbrri2vj5wq9g97kka35qrwpz7h9bzb44gpiprjjx";

     

       168
       168
        
             }

     

       169
       169
        
             {

     

       170
       170
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aiven-v6.35.0-darwin-amd64.tar.gz";

     

       171
       171
        
               sha256 = "1rj4fn0m182c6laihgx3h92zyqw77qajxygv3k8md4f0b4wvnd7q";

     

       172
       172
        
             }

     

       173
       173
        
             {

     

       174
       174
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-akamai-v7.6.1-darwin-amd64.tar.gz";

     

       175
       175
       -
               sha256 = "0nczhgib7hcyh7midm0s5b8zbi76lkyfz76c3lmkqnr0kj5nzb5y";

     

       174
       174
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-akamai-v8.0.0-darwin-amd64.tar.gz";

     

       175
       175
       +
               sha256 = "1vrywndkhhr3k2ckpy7rxm910mq70ks1r36dnfa10pb53hhl1ngp";

     

       176
       176
        
             }

     

       177
       177
        
             {

     

       178
       178
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-alicloud-v3.74.0-darwin-amd64.tar.gz";

     

       179
       179
       -
               sha256 = "1mm51klxsqsgdz53m7zfbw3fh5vwwn1l1rxzwd1hjhm3giasqfv9";

     

       178
       178
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-alicloud-v3.75.0-darwin-amd64.tar.gz";

     

       179
       179
       +
               sha256 = "18y8vr13dcpwg9mdwfn2mh5bww782wx7j8wxvv8j0xnv6ikwgaxm";

     

       180
       180
        
             }

     

       181
       181
        
             {

     

       182
       182
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-artifactory-v8.7.3-darwin-amd64.tar.gz";

     

       183
       183
       -
               sha256 = "19a5sfg2j74ji73cszsqak4gdyk1x7l7p0rpss8j5xnwbyw1y0nf";

     

       182
       182
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-artifactory-v8.8.0-darwin-amd64.tar.gz";

     

       183
       183
       +
               sha256 = "10zkqc02lpf9k0brykyngsasi189w167f6v24cp8sl1agbdcqb9f";

     

       184
       184
        
             }

     

       185
       185
        
             {

     

       186
       186
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-auth0-v3.14.0-darwin-amd64.tar.gz";

     

       187
       187
        
               sha256 = "1yclkdpmm8y92wbyhb87h3vdhcibhcvfppv1nvwhqd3bbx3zk1rb";

     

       188
       188
        
             }

     

       189
       189
        
             {

     

       190
       190
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v6.70.0-darwin-amd64.tar.gz";

     

       191
       191
       -
               sha256 = "07r7a28qgn1m8g7sk6x66r01m9yvpccxwkqsic3x6rz7rar8aifq";

     

       190
       190
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v6.71.0-darwin-amd64.tar.gz";

     

       191
       191
       +
               sha256 = "09zrx8xxmp3nfj0vaznn4k2q24r6hjv5z1ip0vxa2jx2m2j3jd9c";

     

       192
       192
        
             }

     

       193
       193
        
             {

     

       194
       194
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuread-v6.2.0-darwin-amd64.tar.gz";

     

       195
       195
        
               sha256 = "0znbyyh84ygbscm7db10bbzhma23kxy8aqpcnf5hd0l1fvphyw4h";

     

       196
       196
        
             }

     

       197
       197
        
             {

     

       198
       198
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuredevops-v3.6.0-darwin-amd64.tar.gz";

     

       199
       199
       -
               sha256 = "1j952sjqhp42a1s8fxn5li8mjfvl9as3ydhwdpslx8pzc8ykr2zj";

     

       198
       198
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuredevops-v3.7.0-darwin-amd64.tar.gz";

     

       199
       199
       +
               sha256 = "05fabrw15x9rsyib1lxvwd78kcy241hfqdbqgpilf83isavf6s8y";

     

       200
       200
        
             }

     

       201
       201
        
             {

     

       202
       202
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azure-v6.20.0-darwin-amd64.tar.gz";

     

       203
       203
       -
               sha256 = "01ry0xj3hghqcp0jp5jfmxnkgk1cf9nz356glma21dsfv5c9h2gc";

     

       202
       202
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azure-v6.21.0-darwin-amd64.tar.gz";

     

       203
       203
       +
               sha256 = "1kzx16rv67ck7pnlyrmq7407bq41agfwxn7c70l0wsnp5y2l6zwj";

     

       204
       204
        
             }

     

       205
       205
        
             {

     

       206
       206
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-cloudflare-v5.49.1-darwin-amd64.tar.gz";

     
···

       231
       231
        
               sha256 = "0qqzfdibgwzgnv79as3l6k8hh4nviq2i0xsgzsvjkklzf2szyh8k";

     

       232
       232
        
             }

     

       233
       233
        
             {

     

       234
       234
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v8.20.0-darwin-amd64.tar.gz";

     

       235
       235
       -
               sha256 = "1vnv7njpcf7x2vmjhrrpqgjn82wkbq1rr32yankzbrfyzkpsmwck";

     

       234
       234
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v8.21.0-darwin-amd64.tar.gz";

     

       235
       235
       +
               sha256 = "00qmmnwc2i9n7r415bmjzb66wr9ragvkydgs8njjz7hsfz97girg";

     

       236
       236
        
             }

     

       237
       237
        
             {

     

       238
       238
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v6.7.0-darwin-amd64.tar.gz";

     
···

       279
       279
        
               sha256 = "0gkazxwkmb5317amaqb3h34ras7b2vxblaybz2llp47w4qnvq834";

     

       280
       280
        
             }

     

       281
       281
        
             {

     

       282
       282
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v1.1.2-darwin-amd64.tar.gz";

     

       283
       283
       -
               sha256 = "02mq6mnjbfkhwfm9fsgixw8imnxyrgl3zjh2v7z6la0qn888k9yi";

     

       282
       282
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v1.1.3-darwin-amd64.tar.gz";

     

       283
       283
       +
               sha256 = "1ahmp1za19qf6gg2nmgqxqr0xg24pavx9q8gf917gmmj4gx4b2ws";

     

       284
       284
        
             }

     

       285
       285
        
             {

     

       286
       286
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.111.0-darwin-amd64.tar.gz";

     

       287
       287
       -
               sha256 = "1q40y7d7mrr94afwbbyh8zi2liz37zz491ff82lxf31h2nbrcacv";

     

       286
       286
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.112.0-darwin-amd64.tar.gz";

     

       287
       287
       +
               sha256 = "1fxgshs66kqiyw50b347bzzx67mzhmmzr3qfn0nj3yfhsnb1bbky";

     

       288
       288
        
             }

     

       289
       289
        
             {

     

       290
       290
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-sumologic-v1.0.4-darwin-amd64.tar.gz";

     

       291
       291
       -
               sha256 = "1rc717psnir7hpl9az29z232zgkp2dnzfjsph6v3lm44qd0yw9dq";

     

       290
       290
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-sumologic-v1.0.5-darwin-amd64.tar.gz";

     

       291
       291
       +
               sha256 = "1ijy38aqk6mkzh5bkdd7d10ips77rqk10dic6sdx79hfay16i4g7";

     

       292
       292
        
             }

     

       293
       293
        
             {

     

       294
       294
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-tailscale-v0.18.0-darwin-amd64.tar.gz";

     
···

       311
       311
        
               sha256 = "1risgn050qs9yb0r7wx9z1xfw4ai50b5f6fzqchmaw4wpqj83j4h";

     

       312
       312
        
             }

     

       313
       313
        
             {

     

       314
       314
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-wavefront-v3.1.7-darwin-amd64.tar.gz";

     

       315
       315
       -
               sha256 = "1vpg87kw3i9zqk0x73l6xg0i6k9vyqilwsppz1kjg2jg91hm9aww";

     

       314
       314
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-wavefront-v3.1.8-darwin-amd64.tar.gz";

     

       315
       315
       +
               sha256 = "1hrkfl5nqazcf7k6aazi4n8p1d2965ffqfl9wgv6cmzpabwbmc01";

     

       316
       316
        
             }

     

       317
       317
        
             {

     

       318
       318
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-yandex-v0.13.0-darwin-amd64.tar.gz";

     
···

       321
       321
        
           ];

     

       322
       322
        
           aarch64-linux = [

     

       323
       323
        
             {

     

       324
       324
       -
               url = "https://get.pulumi.com/releases/sdk/pulumi-v3.153.1-linux-arm64.tar.gz";

     

       325
       325
       -
               sha256 = "18lq4gzc4hk8yxs5s4fxqixxh4dywak3rhri0pqpc9hidiqccwgs";

     

       324
       324
       +
               url = "https://get.pulumi.com/releases/sdk/pulumi-v3.154.0-linux-arm64.tar.gz";

     

       325
       325
       +
               sha256 = "16324963a5laa2lvv75gvh9pb0mpvg1y0m7rr4c6cppi7iachv3f";

     

       326
       326
        
             }

     

       327
       327
        
             {

     

       328
       328
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aiven-v6.35.0-linux-arm64.tar.gz";

     

       329
       329
        
               sha256 = "0jb91frd5y0bqbps1yqjqvdcdjs5xnyycs1iil5hrlr3c5gzmbhk";

     

       330
       330
        
             }

     

       331
       331
        
             {

     

       332
       332
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-akamai-v7.6.1-linux-arm64.tar.gz";

     

       333
       333
       -
               sha256 = "054pcilsi1qfnf2him7hb0nw9r1w7q47c60ska3cmw27q1xjvjsk";

     

       332
       332
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-akamai-v8.0.0-linux-arm64.tar.gz";

     

       333
       333
       +
               sha256 = "1166ih4sk9ya1m0sdvhvh8xhzmx8dpmzfg8l8jfn2i2af4w1iij2";

     

       334
       334
        
             }

     

       335
       335
        
             {

     

       336
       336
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-alicloud-v3.74.0-linux-arm64.tar.gz";

     

       337
       337
       -
               sha256 = "1ihf580aad9cz95211jxk7l4mvwnxhlvdmxlr70h4drjp377y59h";

     

       336
       336
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-alicloud-v3.75.0-linux-arm64.tar.gz";

     

       337
       337
       +
               sha256 = "17vzdi28awlplgmyv6zsb5ccya8yqii3j6wz742wd47w666lkbq9";

     

       338
       338
        
             }

     

       339
       339
        
             {

     

       340
       340
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-artifactory-v8.7.3-linux-arm64.tar.gz";

     

       341
       341
       -
               sha256 = "0n2kiqcqpkqiapzvh1a5cz1sv0431k4c0s62wczbynyj8f838ywk";

     

       340
       340
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-artifactory-v8.8.0-linux-arm64.tar.gz";

     

       341
       341
       +
               sha256 = "0a07fhkjivn8r2qfc4ads89a6s9fh3dm0n49iwj8j6zfnbwl2kdz";

     

       342
       342
        
             }

     

       343
       343
        
             {

     

       344
       344
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-auth0-v3.14.0-linux-arm64.tar.gz";

     

       345
       345
        
               sha256 = "0xpfjwdhapyfc1562pxbvgmcmljvvsxdiymrwvcfhn08sdgpmas2";

     

       346
       346
        
             }

     

       347
       347
        
             {

     

       348
       348
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v6.70.0-linux-arm64.tar.gz";

     

       349
       349
       -
               sha256 = "1vcin5gkwv79xq5zrixqgipzyca7rdvq5rlfv9iwxmyh8dwa2kyl";

     

       348
       348
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v6.71.0-linux-arm64.tar.gz";

     

       349
       349
       +
               sha256 = "1xxa6xxhrf4wvwv27v48mm5hw1i62m6r3chif8c8ql0cv32n2m4w";

     

       350
       350
        
             }

     

       351
       351
        
             {

     

       352
       352
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuread-v6.2.0-linux-arm64.tar.gz";

     

       353
       353
        
               sha256 = "0n53hh16ggv1cmj21hy0hqn92lvfnqdan57l0a7lqwx5r433mlrg";

     

       354
       354
        
             }

     

       355
       355
        
             {

     

       356
       356
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuredevops-v3.6.0-linux-arm64.tar.gz";

     

       357
       357
       -
               sha256 = "1d4a5xyx55mscqq4wqgvilfagk8mg49xnhwp5vx1i274kgdq7a7z";

     

       356
       356
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuredevops-v3.7.0-linux-arm64.tar.gz";

     

       357
       357
       +
               sha256 = "0fyhx0zvibb5msgiw0k8f8n9a957n6lbpkpg9kbp5ylhsjafi5ry";

     

       358
       358
        
             }

     

       359
       359
        
             {

     

       360
       360
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azure-v6.20.0-linux-arm64.tar.gz";

     

       361
       361
       -
               sha256 = "00mhcz8lyjlgxwan69br5bq1bvzglcnclwmpplcrzpwsqiwbgwss";

     

       360
       360
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azure-v6.21.0-linux-arm64.tar.gz";

     

       361
       361
       +
               sha256 = "1nipp4f4q61fwnr4wh99hc9an5qb572rfj0kbjw5pn9fhgy86nc4";

     

       362
       362
        
             }

     

       363
       363
        
             {

     

       364
       364
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-cloudflare-v5.49.1-linux-arm64.tar.gz";

     
···

       389
       389
        
               sha256 = "1dyg5k7giny2d26yw222kahdnbfwmhr8d1nkrn3i1ycqsb1g573j";

     

       390
       390
        
             }

     

       391
       391
        
             {

     

       392
       392
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v8.20.0-linux-arm64.tar.gz";

     

       393
       393
       -
               sha256 = "1vkdjyywikqkw1capz6ky3ggdqmiwaz9gxr0mx5g8sbd4vzssx0l";

     

       392
       392
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v8.21.0-linux-arm64.tar.gz";

     

       393
       393
       +
               sha256 = "1pzzlvh8bd4pillyb0mr6ba458fjqh3ab310wvih559gzg4fz85j";

     

       394
       394
        
             }

     

       395
       395
        
             {

     

       396
       396
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v6.7.0-linux-arm64.tar.gz";

     
···

       437
       437
        
               sha256 = "14y4jwzlxq0icjw7b3drfgv0kg2a9xl691r59388k9d193yh31n3";

     

       438
       438
        
             }

     

       439
       439
        
             {

     

       440
       440
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v1.1.2-linux-arm64.tar.gz";

     

       441
       441
       -
               sha256 = "1qghb1kj1flr36hcpk2r85ly833hm3z80lvwdw8rh2gz8ch6wi21";

     

       440
       440
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v1.1.3-linux-arm64.tar.gz";

     

       441
       441
       +
               sha256 = "1p7aahp9zfk5qhiw2h6wf11is4xnz6j7f1dcm69xli8x0wjib9kc";

     

       442
       442
        
             }

     

       443
       443
        
             {

     

       444
       444
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.111.0-linux-arm64.tar.gz";

     

       445
       445
       -
               sha256 = "0xc8bv6qj8g7cqhpi37gm4f2hcdzpr3j4pnrh4hxxvxhcsfy6ywc";

     

       444
       444
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.112.0-linux-arm64.tar.gz";

     

       445
       445
       +
               sha256 = "081pvgl2sshdjzn3rgal955crcf9pald3qn35bqw6xrzz7a3sv6r";

     

       446
       446
        
             }

     

       447
       447
        
             {

     

       448
       448
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-sumologic-v1.0.4-linux-arm64.tar.gz";

     

       449
       449
       -
               sha256 = "0f1zpcn0b0hd2kb1adigqp5zd2k7glxdav785yrg7zhq3gccmklw";

     

       448
       448
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-sumologic-v1.0.5-linux-arm64.tar.gz";

     

       449
       449
       +
               sha256 = "0i211g9bq48nhrglqmz8410qp5yby33b3mbkvasarywii6mic2q5";

     

       450
       450
        
             }

     

       451
       451
        
             {

     

       452
       452
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-tailscale-v0.18.0-linux-arm64.tar.gz";

     
···

       469
       469
        
               sha256 = "1wkcrvyw9r0j4vy3nmgsypzak8ld2750rc3cd88m0q9qi22vi6hm";

     

       470
       470
        
             }

     

       471
       471
        
             {

     

       472
       472
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-wavefront-v3.1.7-linux-arm64.tar.gz";

     

       473
       473
       -
               sha256 = "1haa6syws9744zjwgvh5p6lq15xpb1ha7zqga8giig13wligcxvv";

     

       472
       472
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-wavefront-v3.1.8-linux-arm64.tar.gz";

     

       473
       473
       +
               sha256 = "0pwxqlgsxn0fpq21p4rk7lsb2rlvig2paszwpvyzpfpzksn66mvm";

     

       474
       474
        
             }

     

       475
       475
        
             {

     

       476
       476
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-yandex-v0.13.0-linux-arm64.tar.gz";

     
···

       479
       479
        
           ];

     

       480
       480
        
           aarch64-darwin = [

     

       481
       481
        
             {

     

       482
       482
       -
               url = "https://get.pulumi.com/releases/sdk/pulumi-v3.153.1-darwin-arm64.tar.gz";

     

       483
       483
       -
               sha256 = "0bhwdkvqzsvl898ndhfs20affrnidkblcpibpzncsha1cycl3jnl";

     

       482
       482
       +
               url = "https://get.pulumi.com/releases/sdk/pulumi-v3.154.0-darwin-arm64.tar.gz";

     

       483
       483
       +
               sha256 = "07vpsiqr23sd9xiib35zwxnm3axadg2cvkdmkygvvhk0rzdb7zzl";

     

       484
       484
        
             }

     

       485
       485
        
             {

     

       486
       486
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aiven-v6.35.0-darwin-arm64.tar.gz";

     

       487
       487
        
               sha256 = "1lbv0bd6kz0d50306b9y27xllf2lmmwnj5fz15p36p1dawz029r1";

     

       488
       488
        
             }

     

       489
       489
        
             {

     

       490
       490
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-akamai-v7.6.1-darwin-arm64.tar.gz";

     

       491
       491
       -
               sha256 = "1x3jajip18dhs39bpi3yyj3mcwcyyxd4ijnsbq71a98cws55iipq";

     

       490
       490
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-akamai-v8.0.0-darwin-arm64.tar.gz";

     

       491
       491
       +
               sha256 = "0spsr6asi7vhml7fwplidzjphkr01zifmb61aj11hxwmpkldhwz8";

     

       492
       492
        
             }

     

       493
       493
        
             {

     

       494
       494
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-alicloud-v3.74.0-darwin-arm64.tar.gz";

     

       495
       495
       -
               sha256 = "1m71v28yr25ikj0sfd8h9dfnpd53g4jhs6lcxjzz9mb645vvsl0h";

     

       494
       494
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-alicloud-v3.75.0-darwin-arm64.tar.gz";

     

       495
       495
       +
               sha256 = "0c4krcnw4kh8wxrvrcfv0j2i276zmsbxiiiph19m3263ddi6i99x";

     

       496
       496
        
             }

     

       497
       497
        
             {

     

       498
       498
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-artifactory-v8.7.3-darwin-arm64.tar.gz";

     

       499
       499
       -
               sha256 = "1g3badq0zhjs69lyh6d9mpj0c77jqlgapbm03scbamgjzq0zzbdl";

     

       498
       498
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-artifactory-v8.8.0-darwin-arm64.tar.gz";

     

       499
       499
       +
               sha256 = "01glc6mn5k6qyk65qkzhbmkrhlwzlmdkvx8d8mkgm7fprdwaxfv0";

     

       500
       500
        
             }

     

       501
       501
        
             {

     

       502
       502
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-auth0-v3.14.0-darwin-arm64.tar.gz";

     

       503
       503
        
               sha256 = "09ss5j92ra4bs5vmsqq2sgs30nalsb1bs3s0njn72fsc1cd6n0qz";

     

       504
       504
        
             }

     

       505
       505
        
             {

     

       506
       506
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v6.70.0-darwin-arm64.tar.gz";

     

       507
       507
       -
               sha256 = "1v8yid6dd6i3nnf62m37mlgwqjy68dgd0k8zkw3q8qs1r9mf8wfq";

     

       506
       506
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-aws-v6.71.0-darwin-arm64.tar.gz";

     

       507
       507
       +
               sha256 = "06bah84cq2bhg4zxm0m70wrz1cr9mhixqz5n9q7q5l36hw6x1jmd";

     

       508
       508
        
             }

     

       509
       509
        
             {

     

       510
       510
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuread-v6.2.0-darwin-arm64.tar.gz";

     

       511
       511
        
               sha256 = "0zsvaz2shh35lw5c4sqvg39wrfsqk514z2nd9jzvjrnbwmwps6zd";

     

       512
       512
        
             }

     

       513
       513
        
             {

     

       514
       514
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuredevops-v3.6.0-darwin-arm64.tar.gz";

     

       515
       515
       -
               sha256 = "1x4ij8qv9jq39fbacirjvk96hc117da5ll3fzrmgpkvjc1mall01";

     

       514
       514
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azuredevops-v3.7.0-darwin-arm64.tar.gz";

     

       515
       515
       +
               sha256 = "0mmpf4ggzhimm6mhf2p0jydc78wm7wqbm180g6066dd84izi9dsi";

     

       516
       516
        
             }

     

       517
       517
        
             {

     

       518
       518
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azure-v6.20.0-darwin-arm64.tar.gz";

     

       519
       519
       -
               sha256 = "114njwjir2zk6fzfxiyjch97js6p0v2cr41v199zm2ff0h90727q";

     

       518
       518
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-azure-v6.21.0-darwin-arm64.tar.gz";

     

       519
       519
       +
               sha256 = "1f9vd95jw2s3yvssnv5xx5l4fzhklyb11rlhvl42cccfgndj7g6j";

     

       520
       520
        
             }

     

       521
       521
        
             {

     

       522
       522
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-cloudflare-v5.49.1-darwin-arm64.tar.gz";

     
···

       547
       547
        
               sha256 = "17cm719jsh6rc7lwd64kg7qdlxlclvwrky9598f85kbvnv6n0xa8";

     

       548
       548
        
             }

     

       549
       549
        
             {

     

       550
       550
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v8.20.0-darwin-arm64.tar.gz";

     

       551
       551
       -
               sha256 = "1l3jl4nwvhp58lybv4lll2qb8d400nx6kb504prh84i67my685ni";

     

       550
       550
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-gcp-v8.21.0-darwin-arm64.tar.gz";

     

       551
       551
       +
               sha256 = "1r3w1vw0d0qn2vnv4a0n81q3dpw4m7cs34gryvfvllp5f7m8zn31";

     

       552
       552
        
             }

     

       553
       553
        
             {

     

       554
       554
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-github-v6.7.0-darwin-arm64.tar.gz";

     
···

       595
       595
        
               sha256 = "1aqlwj0v0x2ipjvalzry8g4g5y28pm52q8mriirmimml0vavlib8";

     

       596
       596
        
             }

     

       597
       597
        
             {

     

       598
       598
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v1.1.2-darwin-arm64.tar.gz";

     

       599
       599
       -
               sha256 = "022x01wxl7zj65n25slijnb0is266xrg26sbb1z408bipv4svxgk";

     

       598
       598
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-snowflake-v1.1.3-darwin-arm64.tar.gz";

     

       599
       599
       +
               sha256 = "1sayvk6h8g2n5g9zb0drsqpibzlsm9k0zp4dvkcgf68iw32fpzxz";

     

       600
       600
        
             }

     

       601
       601
        
             {

     

       602
       602
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.111.0-darwin-arm64.tar.gz";

     

       603
       603
       -
               sha256 = "1jjqhkfciinwjp6i4qlfjs826m88wncz5v5ppg9mwa9wmnyagi3l";

     

       602
       602
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-spotinst-v3.112.0-darwin-arm64.tar.gz";

     

       603
       603
       +
               sha256 = "0cpi6q4rm2kfvycfva6h3qqj62x3469qlxv034rx4q4jahxnd4zn";

     

       604
       604
        
             }

     

       605
       605
        
             {

     

       606
       606
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-sumologic-v1.0.4-darwin-arm64.tar.gz";

     

       607
       607
       -
               sha256 = "18iw3nkmygsdb0mjdgx5h2ny834vlnd5g1f5nm9gkrs5594sqgf3";

     

       606
       606
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-sumologic-v1.0.5-darwin-arm64.tar.gz";

     

       607
       607
       +
               sha256 = "1j8r4ghifhxx1i3g9l0drbdgdigq59q1gkkr2j8y2626fypgddjh";

     

       608
       608
        
             }

     

       609
       609
        
             {

     

       610
       610
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-tailscale-v0.18.0-darwin-arm64.tar.gz";

     
···

       627
       627
        
               sha256 = "0xw51rfh9vv0dbdzkjz6yrhj86f691cdg40ax085zk0g31x2g1cm";

     

       628
       628
        
             }

     

       629
       629
        
             {

     

       630
       630
       -
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-wavefront-v3.1.7-darwin-arm64.tar.gz";

     

       631
       631
       -
               sha256 = "1c2h6yxgx395mf8z61n29xwcx85qq373fcvv5w620zj1y3l8ff57";

     

       630
       630
       +
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-wavefront-v3.1.8-darwin-arm64.tar.gz";

     

       631
       631
       +
               sha256 = "1mmnn6my6v0mj28fqgiymdwfjsmj3rcb1nf7aj92kp3m38a0gcjs";

     

       632
       632
        
             }

     

       633
       633
        
             {

     

       634
       634
        
               url = "https://api.pulumi.com/releases/plugins/pulumi-resource-yandex-v0.13.0-darwin-arm64.tar.gz";

+2 -2

pkgs/tools/security/libmodsecurity/default.nix

···

       21
       21
        
       

     

       22
       22
        
       stdenv.mkDerivation rec {

     

       23
       23
        
         pname = "libmodsecurity";

     

       24
       24
       -
         version = "3.0.13";

     

       24
       24
       +
         version = "3.0.14";

     

       25
       25
        
       

     

       26
       26
        
         src = fetchFromGitHub {

     

       27
       27
        
           owner = "owasp-modsecurity";

     

       28
       28
        
           repo = "ModSecurity";

     

       29
       29
        
           rev = "v${version}";

     

       30
       30
       -
           hash = "sha256-+z31t007NLCAFG/Lsj5j/AbBDPkI2wjbH5yM5vipH04=";

     

       30
       30
       +
           hash = "sha256-SaeBO3+WvPhHiJoiOmijB0G3/QYxjAdxgeCVqESS+4U=";

     

       31
       31
        
           fetchSubmodules = true;

     

       32
       32
        
         };

     

       33
       33