commit 640c86c256e620be9f0120e461466d9d0eec985b · pyrox.dev/nixpkgs

+1 -1

nixos/tests/all-tests.nix

···

       395
        
         jibri = handleTest ./jibri.nix {};

     

       396
        
         jirafeau = handleTest ./jirafeau.nix {};

     

       397
        
         jitsi-meet = handleTest ./jitsi-meet.nix {};

     

       398
       -
         jool = handleTest ./jool.nix {};

     

       399
        
         k3s = handleTest ./k3s {};

     

       400
        
         kafka = handleTest ./kafka.nix {};

     

       401
        
         kanidm = handleTest ./kanidm.nix {};

···

       395
        
         jibri = handleTest ./jibri.nix {};

     

       396
        
         jirafeau = handleTest ./jirafeau.nix {};

     

       397
        
         jitsi-meet = handleTest ./jitsi-meet.nix {};

     

       398
       +
         jool = import ./jool.nix { inherit pkgs runTest; };

     

       399
        
         k3s = handleTest ./k3s {};

     

       400
        
         kafka = handleTest ./kafka.nix {};

     

       401
        
         kanidm = handleTest ./kanidm.nix {};

+38 -68

nixos/tests/jool.nix

···

       1
       -
       { system ? builtins.currentSystem,

     

       2
       -
         config ? {},

     

       3
       -
         pkgs ? import ../.. { inherit system config; }

     

       4
       -
       }:

     

       5
       -
       

     

       6
       -
       with import ../lib/testing-python.nix { inherit system pkgs; };

     

       7
        
       

     

       8
        
       let

     

       9
        
         inherit (pkgs) lib;

     
···

       23
        
             description = "Mock webserver";

     

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

     

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

     

       26
       -
             serviceConfig.Restart = "always";

     

       27
        
             script = ''

     

       28
        
               while true; do

     

       29
        
               {

     
···

       40
        
       in

     

       41
        
       

     

       42
        
       {

     

       43
       -
         siit = makeTest {

     

       44
        
           # This test simulates the setup described in [1] with two IPv6 and

     

       45
        
           # IPv4-only devices on different subnets communicating through a border

     

       46
        
           # relay running Jool in SIIT mode.

     
···

       49
        
           meta.maintainers = with lib.maintainers; [ rnhmjoj ];

     

       50
        
       

     

       51
        
           # Border relay

     

       52
       -
           nodes.relay = { ... }: {

     

       53
       -
             imports = [ ../modules/profiles/minimal.nix ];

     

       54
        
             virtualisation.vlans = [ 1 2 ];

     

       55
        
       

     

       56
        
             # Enable packet routing

     
···

       65
        
               eth2.ipv4.addresses = [ { address = "192.0.2.1";  prefixLength = 24; } ];

     

       66
        
             };

     

       67
        
       

     

       68
       -
             networking.jool = {

     

       69
       -
               enable = true;

     

       70
       -
               siit.enable = true;

     

       71
       -
               siit.config.global.pool6 = "fd::/96";

     

       72
       -
             };

     

       73
        
           };

     

       74
        
       

     

       75
        
           # IPv6 only node

     

       76
       -
           nodes.alice = { ... }: {

     

       77
       -
             imports = [

     

       78
       -
               ../modules/profiles/minimal.nix

     

       79
       -
               ipv6Only

     

       80
       -
               (webserver 6 "Hello, Bob!")

     

       81
       -
             ];

     

       82
        
       

     

       83
        
             virtualisation.vlans = [ 1 ];

     

       84
        
             networking.interfaces.eth1.ipv6 = {

     
···

       89
        
           };

     

       90
        
       

     

       91
        
           # IPv4 only node

     

       92
       -
           nodes.bob = { ... }: {

     

       93
       -
             imports = [

     

       94
       -
               ../modules/profiles/minimal.nix

     

       95
       -
               ipv4Only

     

       96
       -
               (webserver 4 "Hello, Alice!")

     

       97
       -
             ];

     

       98
        
       

     

       99
        
             virtualisation.vlans = [ 2 ];

     

       100
        
             networking.interfaces.eth1.ipv4 = {

     
···

       107
        
           testScript = ''

     

       108
        
             start_all()

     

       109
        
       

     

       110
       -
             relay.wait_for_unit("jool-siit.service")

     

       111
        
             alice.wait_for_unit("network-addresses-eth1.service")

     

       112
        
             bob.wait_for_unit("network-addresses-eth1.service")

     

       113
        
       

     

       114
        
             with subtest("Alice and Bob can't ping each other"):

     

       115
       -
               relay.systemctl("stop jool-siit.service")

     

       116
        
               alice.fail("ping -c1 fd::192.0.2.16")

     

       117
        
               bob.fail("ping -c1 198.51.100.8")

     

       118
        
       

     

       119
        
             with subtest("Alice and Bob can ping using the relay"):

     

       120
       -
               relay.systemctl("start jool-siit.service")

     

       121
        
               alice.wait_until_succeeds("ping -c1 fd::192.0.2.16")

     

       122
        
               bob.wait_until_succeeds("ping -c1 198.51.100.8")

     

       123
        
       

     
···

       132
        
           '';

     

       133
        
         };

     

       134
        
       

     

       135
       -
         nat64 = makeTest {

     

       136
        
           # This test simulates the setup described in [1] with two IPv6-only nodes

     

       137
        
           # (a client and a homeserver) on the LAN subnet and an IPv4 node on the WAN.

     

       138
        
           # The router runs Jool in stateful NAT64 mode, masquarading the LAN and

     
···

       142
        
           meta.maintainers = with lib.maintainers; [ rnhmjoj ];

     

       143
        
       

     

       144
        
           # Router

     

       145
       -
           nodes.router = { ... }: {

     

       146
       -
             imports = [ ../modules/profiles/minimal.nix ];

     

       147
        
             virtualisation.vlans = [ 1 2 ];

     

       148
        
       

     

       149
        
             # Enable packet routing

     
···

       158
        
               eth2.ipv4.addresses = [ { address = "203.0.113.1"; prefixLength = 24; } ];

     

       159
        
             };

     

       160
        
       

     

       161
       -
             networking.jool = {

     

       162
       -
               enable = true;

     

       163
       -
               nat64.enable = true;

     

       164
       -
               nat64.config = {

     

       165
       -
                 bib = [

     

       166
       -
                   { # forward HTTP 203.0.113.1 (router) → 2001:db8::9 (homeserver)

     

       167
       -
                     "protocol"     = "TCP";

     

       168
       -
                     "ipv4 address" = "203.0.113.1#80";

     

       169
       -
                     "ipv6 address" = "2001:db8::9#80";

     

       170
       -
                   }

     

       171
       -
                 ];

     

       172
       -
                 pool4 = [

     

       173
       -
                   # Ports for dynamic translation

     

       174
       -
                   { protocol =  "TCP";  prefix = "203.0.113.1/32"; "port range" = "40001-65535"; }

     

       175
       -
                   { protocol =  "UDP";  prefix = "203.0.113.1/32"; "port range" = "40001-65535"; }

     

       176
       -
                   { protocol = "ICMP";  prefix = "203.0.113.1/32"; "port range" = "40001-65535"; }

     

       177
       -
                   # Ports for static BIB entries

     

       178
       -
                   { protocol =  "TCP";  prefix = "203.0.113.1/32"; "port range" = "80"; }

     

       179
       -
                 ];

     

       180
       -
               };

     

       181
        
             };

     

       182
        
           };

     

       183
        
       

     

       184
        
           # LAN client (IPv6 only)

     

       185
       -
           nodes.client = { ... }: {

     

       186
       -
             imports = [ ../modules/profiles/minimal.nix ipv6Only ];

     

       187
        
             virtualisation.vlans = [ 1 ];

     

       188
        
       

     

       189
        
             networking.interfaces.eth1.ipv6 = {

     
···

       194
        
           };

     

       195
        
       

     

       196
        
           # LAN server (IPv6 only)

     

       197
       -
           nodes.homeserver = { ... }: {

     

       198
       -
             imports = [

     

       199
       -
               ../modules/profiles/minimal.nix

     

       200
       -
               ipv6Only

     

       201
       -
               (webserver 6 "Hello from IPv6!")

     

       202
       -
             ];

     

       203
        
       

     

       204
        
             virtualisation.vlans = [ 1 ];

     

       205
        
             networking.interfaces.eth1.ipv6 = {

     
···

       210
        
           };

     

       211
        
       

     

       212
        
           # WAN server (IPv4 only)

     

       213
       -
           nodes.server = { ... }: {

     

       214
       -
             imports = [

     

       215
       -
               ../modules/profiles/minimal.nix

     

       216
       -
               ipv4Only

     

       217
       -
               (webserver 4 "Hello from IPv4!")

     

       218
       -
             ];

     

       219
        
       

     

       220
        
             virtualisation.vlans = [ 2 ];

     

       221
        
             networking.interfaces.eth1.ipv4.addresses =

     
···

       229
        
               node.wait_for_unit("network-addresses-eth1.service")

     

       230
        
       

     

       231
        
             with subtest("Client can ping the WAN server"):

     

       232
       -
               router.wait_for_unit("jool-nat64.service")

     

       233
        
               client.succeed("ping -c1 64:ff9b::203.0.113.16")

     

       234
        
       

     

       235
        
             with subtest("Client can connect to the WAN webserver"):

···

       1
       +
       { pkgs, runTest }:

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2
        
       

     

       3
        
       let

     

       4
        
         inherit (pkgs) lib;

     
···

       18
        
             description = "Mock webserver";

     

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

     

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

     

       0
        
       
     

       21
        
             script = ''

     

       22
        
               while true; do

     

       23
        
               {

     
···

       34
        
       in

     

       35
        
       

     

       36
        
       {

     

       37
       +
         siit = runTest {

     

       38
        
           # This test simulates the setup described in [1] with two IPv6 and

     

       39
        
           # IPv4-only devices on different subnets communicating through a border

     

       40
        
           # relay running Jool in SIIT mode.

     
···

       43
        
           meta.maintainers = with lib.maintainers; [ rnhmjoj ];

     

       44
        
       

     

       45
        
           # Border relay

     

       46
       +
           nodes.relay = {

     

       0
        
       
     

       47
        
             virtualisation.vlans = [ 1 2 ];

     

       48
        
       

     

       49
        
             # Enable packet routing

     
···

       58
        
               eth2.ipv4.addresses = [ { address = "192.0.2.1";  prefixLength = 24; } ];

     

       59
        
             };

     

       60
        
       

     

       61
       +
             networking.jool.enable = true;

     

       62
       +
             networking.jool.siit.default.global.pool6 = "fd::/96";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       63
        
           };

     

       64
        
       

     

       65
        
           # IPv6 only node

     

       66
       +
           nodes.alice = {

     

       67
       +
             imports = [ ipv6Only (webserver 6 "Hello, Bob!") ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       68
        
       

     

       69
        
             virtualisation.vlans = [ 1 ];

     

       70
        
             networking.interfaces.eth1.ipv6 = {

     
···

       75
        
           };

     

       76
        
       

     

       77
        
           # IPv4 only node

     

       78
       +
           nodes.bob = {

     

       79
       +
             imports = [ ipv4Only (webserver 4 "Hello, Alice!") ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       80
        
       

     

       81
        
             virtualisation.vlans = [ 2 ];

     

       82
        
             networking.interfaces.eth1.ipv4 = {

     
···

       89
        
           testScript = ''

     

       90
        
             start_all()

     

       91
        
       

     

       92
       +
             relay.wait_for_unit("jool-siit-default.service")

     

       93
        
             alice.wait_for_unit("network-addresses-eth1.service")

     

       94
        
             bob.wait_for_unit("network-addresses-eth1.service")

     

       95
        
       

     

       96
        
             with subtest("Alice and Bob can't ping each other"):

     

       97
       +
               relay.systemctl("stop jool-siit-default.service")

     

       98
        
               alice.fail("ping -c1 fd::192.0.2.16")

     

       99
        
               bob.fail("ping -c1 198.51.100.8")

     

       100
        
       

     

       101
        
             with subtest("Alice and Bob can ping using the relay"):

     

       102
       +
               relay.systemctl("start jool-siit-default.service")

     

       103
        
               alice.wait_until_succeeds("ping -c1 fd::192.0.2.16")

     

       104
        
               bob.wait_until_succeeds("ping -c1 198.51.100.8")

     

       105
        
       

     
···

       114
        
           '';

     

       115
        
         };

     

       116
        
       

     

       117
       +
         nat64 = runTest {

     

       118
        
           # This test simulates the setup described in [1] with two IPv6-only nodes

     

       119
        
           # (a client and a homeserver) on the LAN subnet and an IPv4 node on the WAN.

     

       120
        
           # The router runs Jool in stateful NAT64 mode, masquarading the LAN and

     
···

       124
        
           meta.maintainers = with lib.maintainers; [ rnhmjoj ];

     

       125
        
       

     

       126
        
           # Router

     

       127
       +
           nodes.router = {

     

       0
        
       
     

       128
        
             virtualisation.vlans = [ 1 2 ];

     

       129
        
       

     

       130
        
             # Enable packet routing

     
···

       139
        
               eth2.ipv4.addresses = [ { address = "203.0.113.1"; prefixLength = 24; } ];

     

       140
        
             };

     

       141
        
       

     

       142
       +
             networking.jool.enable = true;

     

       143
       +
             networking.jool.nat64.default = {

     

       144
       +
               bib = [

     

       145
       +
                 { # forward HTTP 203.0.113.1 (router) → 2001:db8::9 (homeserver)

     

       146
       +
                   "protocol"     = "TCP";

     

       147
       +
                   "ipv4 address" = "203.0.113.1#80";

     

       148
       +
                   "ipv6 address" = "2001:db8::9#80";

     

       149
       +
                 }

     

       150
       +
               ];

     

       151
       +
               pool4 = [

     

       152
       +
                 # Ports for dynamic translation

     

       153
       +
                 { protocol =  "TCP";  prefix = "203.0.113.1/32"; "port range" = "40001-65535"; }

     

       154
       +
                 { protocol =  "UDP";  prefix = "203.0.113.1/32"; "port range" = "40001-65535"; }

     

       155
       +
                 { protocol = "ICMP";  prefix = "203.0.113.1/32"; "port range" = "40001-65535"; }

     

       156
       +
                 # Ports for static BIB entries

     

       157
       +
                 { protocol =  "TCP";  prefix = "203.0.113.1/32"; "port range" = "80"; }

     

       158
       +
               ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       159
        
             };

     

       160
        
           };

     

       161
        
       

     

       162
        
           # LAN client (IPv6 only)

     

       163
       +
           nodes.client = {

     

       164
       +
             imports = [ ipv6Only ];

     

       165
        
             virtualisation.vlans = [ 1 ];

     

       166
        
       

     

       167
        
             networking.interfaces.eth1.ipv6 = {

     
···

       172
        
           };

     

       173
        
       

     

       174
        
           # LAN server (IPv6 only)

     

       175
       +
           nodes.homeserver = {

     

       176
       +
             imports = [ ipv6Only (webserver 6 "Hello from IPv6!") ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       177
        
       

     

       178
        
             virtualisation.vlans = [ 1 ];

     

       179
        
             networking.interfaces.eth1.ipv6 = {

     
···

       184
        
           };

     

       185
        
       

     

       186
        
           # WAN server (IPv4 only)

     

       187
       +
           nodes.server = {

     

       188
       +
             imports = [ ipv4Only (webserver 4 "Hello from IPv4!") ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       189
        
       

     

       190
        
             virtualisation.vlans = [ 2 ];

     

       191
        
             networking.interfaces.eth1.ipv4.addresses =

     
···

       199
        
               node.wait_for_unit("network-addresses-eth1.service")

     

       200
        
       

     

       201
        
             with subtest("Client can ping the WAN server"):

     

       202
       +
               router.wait_for_unit("jool-nat64-default.service")

     

       203
        
               client.succeed("ping -c1 64:ff9b::203.0.113.16")

     

       204
        
       

     

       205
        
             with subtest("Client can connect to the WAN webserver"):