···

       
1
       
1
       
-
       
{ system

     

       
2
       
2
       
-
       
, # Use a minimal kernel?

     

       
3
       
3
       
-
       
  minimal ? false

     

       
4
       
4
       
-
       
, # Ignored

     

       
5
       
5
       
-
       
  config ? null

     

       
6
       
6
       
-
       
, # Nixpkgs, for qemu, lib and more

     

       
7
       
7
       
-
       
  pkgs, lib

     

       
8
       
8
       
-
       
, # !!! See comment about args in lib/modules.nix

     

       
9
       
9
       
-
       
  specialArgs ? {}

     

       
10
       
10
       
-
       
, # NixOS configuration to add to the VMs

     

       
11
       
11
       
-
       
  extraConfigurations ? []

     

       
12
       
12
       
-
       
}:

     

       
13
       
13
       
-
       


     

       
14
       
14
       
-
       
with lib;

     

       
15
       
15
       
-
       


     

       
16
       
16
       
-
       
rec {

     

       
17
       
17
       
-
       


     

       
18
       
18
       
-
       
  inherit pkgs;

     

       
19
       
19
       
-
       


     

       
20
       
20
       
-
       
  # Build a virtual network from an attribute set `{ machine1 =

     

       
21
       
21
       
-
       
  # config1; ... machineN = configN; }', where `machineX' is the

     

       
22
       
22
       
-
       
  # hostname and `configX' is a NixOS system configuration.  Each

     

       
23
       
23
       
-
       
  # machine is given an arbitrary IP address in the virtual network.

     

       
24
       
24
       
-
       
  buildVirtualNetwork =

     

       
25
       
25
       
-
       
    nodes: let nodesOut = mapAttrs (n: buildVM nodesOut) (assignIPAddresses nodes); in nodesOut;

     

       
26
       
26
       
-
       


     

       
27
       
27
       
-
       


     

       
28
       
28
       
-
       
  buildVM =

     

       
29
       
29
       
-
       
    nodes: configurations:

     

       
30
       
30
       
-
       


     

       
31
       
31
       
-
       
    import ./eval-config.nix {

     

       
32
       
32
       
-
       
      inherit system specialArgs;

     

       
33
       
33
       
-
       
      modules = configurations ++ extraConfigurations;

     

       
34
       
34
       
-
       
      baseModules =  (import ../modules/module-list.nix) ++

     

       
35
       
35
       
-
       
        [ ../modules/virtualisation/qemu-vm.nix

     

       
36
       
36
       
-
       
          ../modules/testing/test-instrumentation.nix # !!! should only get added for automated test runs

     

       
37
       
37
       
-
       
          { key = "no-manual"; documentation.nixos.enable = false; }

     

       
38
       
38
       
-
       
          { key = "no-revision";

     

       
39
       
39
       
-
       
            # Make the revision metadata constant, in order to avoid needless retesting.

     

       
40
       
40
       
-
       
            # The human version (e.g. 21.05-pre) is left as is, because it is useful

     

       
41
       
41
       
-
       
            # for external modules that test with e.g. testers.nixosTest and rely on that

     

       
42
       
42
       
-
       
            # version number.

     

       
43
       
43
       
-
       
            config.system.nixos.revision = mkForce "constant-nixos-revision";

     

       
44
       
44
       
-
       
          }

     

       
45
       
45
       
-
       
          { key = "nodes"; _module.args.nodes = nodes; }

     

       
46
       
46
       
-
       
        ] ++ optional minimal ../modules/testing/minimal-kernel.nix;

     

       
47
       
47
       
-
       
    };

     

       
48
       
48
       
-
       


     

       
49
       
49
       
-
       


     

       
50
       
50
       
-
       
  # Given an attribute set { machine1 = config1; ... machineN =

     

       
51
       
51
       
-
       
  # configN; }, sequentially assign IP addresses in the 192.168.1.0/24

     

       
52
       
52
       
-
       
  # range to each machine, and set the hostname to the attribute name.

     

       
53
       
53
       
-
       
  assignIPAddresses = nodes:

     

       
54
       
54
       
-
       


     

       
55
       
55
       
-
       
    let

     

       
56
       
56
       
-
       


     

       
57
       
57
       
-
       
      machines = attrNames nodes;

     

       
58
       
58
       
-
       


     

       
59
       
59
       
-
       
      machinesNumbered = zipLists machines (range 1 254);

     

       
60
       
60
       
-
       


     

       
61
       
61
       
-
       
      nodes_ = forEach machinesNumbered (m: nameValuePair m.fst

     

       
62
       
62
       
-
       
        [ ( { config, nodes, ... }:

     

       
63
       
63
       
-
       
            let

     

       
64
       
64
       
-
       
              interfacesNumbered = zipLists config.virtualisation.vlans (range 1 255);

     

       
65
       
65
       
-
       
              interfaces = forEach interfacesNumbered ({ fst, snd }:

     

       
66
       
66
       
-
       
                nameValuePair "eth${toString snd}" { ipv4.addresses =

     

       
67
       
67
       
-
       
                  [ { address = "192.168.${toString fst}.${toString m.snd}";

     

       
68
       
68
       
-
       
                      prefixLength = 24;

     

       
69
       
69
       
-
       
                  } ];

     

       
70
       
70
       
-
       
                });

     

       
71
       
71
       
-
       


     

       
72
       
72
       
-
       
              networkConfig =

     

       
73
       
73
       
-
       
                { networking.hostName = mkDefault m.fst;

     

       
74
       
74
       
-
       


     

       
75
       
75
       
-
       
                  networking.interfaces = listToAttrs interfaces;

     

       
76
       
76
       
-
       


     

       
77
       
77
       
-
       
                  networking.primaryIPAddress =

     

       
78
       
78
       
-
       
                    optionalString (interfaces != []) (head (head interfaces).value.ipv4.addresses).address;

     

       
79
       
79
       
-
       


     

       
80
       
80
       
-
       
                  # Put the IP addresses of all VMs in this machine's

     

       
81
       
81
       
-
       
                  # /etc/hosts file.  If a machine has multiple

     

       
82
       
82
       
-
       
                  # interfaces, use the IP address corresponding to

     

       
83
       
83
       
-
       
                  # the first interface (i.e. the first network in its

     

       
84
       
84
       
-
       
                  # virtualisation.vlans option).

     

       
85
       
85
       
-
       
                  networking.extraHosts = flip concatMapStrings machines

     

       
86
       
86
       
-
       
                    (m': let config = (getAttr m' nodes).config; in

     

       
87
       
87
       
-
       
                      optionalString (config.networking.primaryIPAddress != "")

     

       
88
       
88
       
-
       
                        ("${config.networking.primaryIPAddress} " +

     

       
89
       
89
       
-
       
                         optionalString (config.networking.domain != null)

     

       
90
       
90
       
-
       
                           "${config.networking.hostName}.${config.networking.domain} " +

     

       
91
       
91
       
-
       
                         "${config.networking.hostName}\n"));

     

       
92
       
92
       
-
       


     

       
93
       
93
       
-
       
                  virtualisation.qemu.options =

     

       
94
       
94
       
-
       
                    let qemu-common = import ../lib/qemu-common.nix { inherit lib pkgs; };

     

       
95
       
95
       
-
       
                    in flip concatMap interfacesNumbered

     

       
96
       
96
       
-
       
                      ({ fst, snd }: qemu-common.qemuNICFlags snd fst m.snd);

     

       
97
       
97
       
-
       
                };

     

       
98
       
98
       
-
       


     

       
99
       
99
       
-
       
              in

     

       
100
       
100
       
-
       
                { key = "ip-address";

     

       
101
       
101
       
-
       
                  config = networkConfig // {

     

       
102
       
102
       
-
       
                    # Expose the networkConfig items for tests like nixops

     

       
103
       
103
       
-
       
                    # that need to recreate the network config.

     

       
104
       
104
       
-
       
                    system.build.networkConfig = networkConfig;

     

       
105
       
105
       
-
       
                  };

     

       
106
       
106
       
-
       
                }

     

       
107
       
107
       
-
       
          )

     

       
108
       
108
       
-
       
          (getAttr m.fst nodes)

     

       
109
       
109
       
-
       
        ] );

     

       
110
       
110
       
-
       


     

       
111
       
111
       
-
       
    in listToAttrs nodes_;

     

       
112
       
112
       
-
       


     

       
113
       
113
       
-
       
}