nixos/release.nix

   1 with import ../lib;
   2
   3 { nixpkgs ? { outPath = cleanSource ./..; revCount = 708350; shortRev = "1d95cb5"; }
   4 , stableBranch ? false
   5 , supportedSystems ? [ "x86_64-linux" "aarch64-linux" ]
   6 , configuration ? {}
   7 }:
   8
   9 with import ../pkgs/top-level/release-lib.nix { inherit supportedSystems; };
  10
  11 let
  12
  13   version = fileContents ../.version;
  14   versionSuffix =
  15     (if stableBranch then "." else "beta") + "${toString nixpkgs.revCount}.${nixpkgs.shortRev}";
  16
  17   # Run the tests for each platform.  You can run a test by doing
  18   # e.g. ‘nix-build release.nix -A tests.login.x86_64-linux’,
  19   # or equivalently, ‘nix-build tests/login.nix’.
  20   # See also nixosTests in pkgs/top-level/all-packages.nix
  21   allTestsForSystem = system:
  22     import ./tests/all-tests.nix {
  23       inherit system;
  24       pkgs = import ./.. { inherit system; };
  25       callTest = config: {
  26         ${system} = hydraJob config.test;
  27       };
  28     } // {
  29       # for typechecking of the scripts and evaluation of
  30       # the nodes, without running VMs.
  31       allDrivers =
  32         import ./tests/all-tests.nix {
  33         inherit system;
  34         pkgs = import ./.. { inherit system; };
  35         callTest = config: {
  36           ${system} = hydraJob config.driver;
  37         };
  38       };
  39     };
  40
  41   allTests =
  42     foldAttrs recursiveUpdate {} (map allTestsForSystem supportedSystems);
  43
  44   pkgs = import ./.. { system = "x86_64-linux"; };
  45
  46
  47   versionModule = { config, ... }: {
  48     system.nixos.versionSuffix = versionSuffix;
  49     system.nixos.revision = nixpkgs.rev or nixpkgs.shortRev;
  50
  51     # At creation time we do not have state yet, so just default to latest.
  52     system.stateVersion = config.system.nixos.release;
  53   };
  54
  55   makeModules = module: rest: [ configuration versionModule module rest ];
  56
  57   makeIso =
  58     { module, type, system, ... }:
  59
  60     with import ./.. { inherit system; };
  61
  62     hydraJob ((import lib/eval-config.nix {
  63       inherit system;
  64       modules = makeModules module {
  65         isoImage.isoBaseName = "nixos-${type}";
  66       };
  67     }).config.system.build.isoImage);
  68
  69
  70   makeSdImage =
  71     { module, system, ... }:
  72
  73     with import ./.. { inherit system; };
  74
  75     hydraJob ((import lib/eval-config.nix {
  76       inherit system;
  77       modules = makeModules module {};
  78     }).config.system.build.sdImage);
  79
  80
  81   makeSystemTarball =
  82     { module, maintainers ? ["viric"], system }:
  83
  84     with import ./.. { inherit system; };
  85
  86     let
  87
  88       config = (import lib/eval-config.nix {
  89         inherit system;
  90         modules = makeModules module {};
  91       }).config;
  92
  93       tarball = config.system.build.tarball;
  94
  95     in
  96       tarball //
  97         { meta = {
  98             description = "NixOS system tarball for ${system} - ${stdenv.hostPlatform.linux-kernel.name}";
  99             maintainers = map (x: lib.maintainers.${x}) maintainers;
 100           };
 101           inherit config;
 102         };
 103
 104
 105   makeClosure = module: buildFromConfig module (config: config.system.build.toplevel);
 106
 107
 108   buildFromConfig = module: sel: forAllSystems (system: hydraJob (sel (import ./lib/eval-config.nix {
 109     inherit system;
 110     modules = makeModules module
 111       ({ ... }:
 112       { fileSystems."/".device  = mkDefault "/dev/sda1";
 113         boot.loader.grub.device = mkDefault "/dev/sda";
 114       });
 115   }).config));
 116
 117   makeNetboot = { module, system, ... }:
 118     let
 119       configEvaled = import lib/eval-config.nix {
 120         inherit system;
 121         modules = makeModules module {};
 122       };
 123       build = configEvaled.config.system.build;
 124       kernelTarget = configEvaled.pkgs.stdenv.hostPlatform.linux-kernel.target;
 125     in
 126       configEvaled.pkgs.symlinkJoin {
 127         name = "netboot";
 128         paths = [
 129           build.netbootRamdisk
 130           build.kernel
 131           build.netbootIpxeScript
 132         ];
 133         postBuild = ''
 134           mkdir -p $out/nix-support
 135           echo "file ${kernelTarget} ${build.kernel}/${kernelTarget}" >> $out/nix-support/hydra-build-products
 136           echo "file initrd ${build.netbootRamdisk}/initrd" >> $out/nix-support/hydra-build-products
 137           echo "file ipxe ${build.netbootIpxeScript}/netboot.ipxe" >> $out/nix-support/hydra-build-products
 138         '';
 139         preferLocalBuild = true;
 140       };
 141
 142 in rec {
 143
 144   channel = import lib/make-channel.nix { inherit pkgs nixpkgs version versionSuffix; };
 145
 146   manualHTML = buildFromConfig ({ ... }: { }) (config: config.system.build.manual.manualHTML);
 147   manual = manualHTML; # TODO(@oxij): remove eventually
 148   manualEpub = (buildFromConfig ({ ... }: { }) (config: config.system.build.manual.manualEpub));
 149   nixos-configuration-reference-manpage = buildFromConfig ({ ... }: { }) (config: config.system.build.manual.nixos-configuration-reference-manpage);
 150   options = (buildFromConfig ({ ... }: { }) (config: config.system.build.manual.optionsJSON)).x86_64-linux;
 151
 152
 153   # Build the initial ramdisk so Hydra can keep track of its size over time.
 154   initialRamdisk = buildFromConfig ({ ... }: { }) (config: config.system.build.initialRamdisk);
 155
 156   kexec = forMatchingSystems supportedSystems (system: (import lib/eval-config.nix {
 157     inherit system;
 158     modules = [
 159       ./modules/installer/netboot/netboot-minimal.nix
 160     ];
 161   }).config.system.build.kexecTree);
 162
 163   netboot = forMatchingSystems supportedSystems (system: makeNetboot {
 164     module = ./modules/installer/netboot/netboot-minimal.nix;
 165     inherit system;
 166   });
 167
 168   iso_minimal = forAllSystems (system: makeIso {
 169     module = ./modules/installer/cd-dvd/installation-cd-minimal.nix;
 170     type = "minimal";
 171     inherit system;
 172   });
 173
 174   iso_plasma5 = forMatchingSystems supportedSystems (system: makeIso {
 175     module = ./modules/installer/cd-dvd/installation-cd-graphical-calamares-plasma5.nix;
 176     type = "plasma5";
 177     inherit system;
 178   });
 179
 180   iso_plasma6 = forMatchingSystems supportedSystems (system: makeIso {
 181     module = ./modules/installer/cd-dvd/installation-cd-graphical-calamares-plasma6.nix;
 182     type = "plasma6";
 183     inherit system;
 184   });
 185
 186   iso_gnome = forMatchingSystems supportedSystems (system: makeIso {
 187     module = ./modules/installer/cd-dvd/installation-cd-graphical-calamares-gnome.nix;
 188     type = "gnome";
 189     inherit system;
 190   });
 191
 192   # A variant with a more recent (but possibly less stable) kernel that might support more hardware.
 193   # This variant keeps zfs support enabled, hoping it will build and work.
 194   iso_minimal_new_kernel = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system: makeIso {
 195     module = ./modules/installer/cd-dvd/installation-cd-minimal-new-kernel.nix;
 196     type = "minimal-new-kernel";
 197     inherit system;
 198   });
 199
 200   # A variant with a more recent (but possibly less stable) kernel that might support more hardware.
 201   # ZFS support disabled since it is unlikely to support the latest kernel.
 202   iso_minimal_new_kernel_no_zfs = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system: makeIso {
 203     module = ./modules/installer/cd-dvd/installation-cd-minimal-new-kernel-no-zfs.nix;
 204     type = "minimal-new-kernel-no-zfs";
 205     inherit system;
 206   });
 207
 208   sd_image = forMatchingSystems [ "armv6l-linux" "armv7l-linux" "aarch64-linux" ] (system: makeSdImage {
 209     module = {
 210         armv6l-linux = ./modules/installer/sd-card/sd-image-raspberrypi-installer.nix;
 211         armv7l-linux = ./modules/installer/sd-card/sd-image-armv7l-multiplatform-installer.nix;
 212         aarch64-linux = ./modules/installer/sd-card/sd-image-aarch64-installer.nix;
 213       }.${system};
 214     inherit system;
 215   });
 216
 217   sd_image_new_kernel = forMatchingSystems [ "aarch64-linux" ] (system: makeSdImage {
 218     module = {
 219         aarch64-linux = ./modules/installer/sd-card/sd-image-aarch64-new-kernel-installer.nix;
 220       }.${system};
 221     type = "minimal-new-kernel";
 222     inherit system;
 223   });
 224
 225   sd_image_new_kernel_no_zfs = forMatchingSystems [ "aarch64-linux" ] (system: makeSdImage {
 226     module = {
 227         aarch64-linux = ./modules/installer/sd-card/sd-image-aarch64-new-kernel-no-zfs-installer.nix;
 228       }.${system};
 229     type = "minimal-new-kernel-no-zfs";
 230     inherit system;
 231   });
 232
 233   # KVM image for proxmox in VMA format
 234   proxmoxImage = forMatchingSystems [ "x86_64-linux" ] (system:
 235     with import ./.. { inherit system; };
 236
 237     hydraJob ((import lib/eval-config.nix {
 238       inherit system;
 239       modules = [
 240         ./modules/virtualisation/proxmox-image.nix
 241       ];
 242     }).config.system.build.VMA)
 243   );
 244
 245   # LXC tarball for proxmox
 246   proxmoxLXC = forMatchingSystems [ "x86_64-linux" ] (system:
 247     with import ./.. { inherit system; };
 248
 249     hydraJob ((import lib/eval-config.nix {
 250       inherit system;
 251       modules = [
 252         ./modules/virtualisation/proxmox-lxc.nix
 253       ];
 254     }).config.system.build.tarball)
 255   );
 256
 257   # A disk image that can be imported to Amazon EC2 and registered as an AMI
 258   amazonImage = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 259
 260     with import ./.. { inherit system; };
 261
 262     hydraJob ((import lib/eval-config.nix {
 263       inherit system;
 264       modules =
 265         [ configuration
 266           versionModule
 267           ./maintainers/scripts/ec2/amazon-image.nix
 268         ];
 269     }).config.system.build.amazonImage)
 270
 271   );
 272   amazonImageZfs = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 273
 274     with import ./.. { inherit system; };
 275
 276     hydraJob ((import lib/eval-config.nix {
 277       inherit system;
 278       modules =
 279         [ configuration
 280           versionModule
 281           ./maintainers/scripts/ec2/amazon-image-zfs.nix
 282         ];
 283     }).config.system.build.amazonImage)
 284
 285   );
 286
 287
 288   # Test job for https://github.com/NixOS/nixpkgs/issues/121354 to test
 289   # automatic sizing without blocking the channel.
 290   amazonImageAutomaticSize = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 291
 292     with import ./.. { inherit system; };
 293
 294     hydraJob ((import lib/eval-config.nix {
 295       inherit system;
 296       modules =
 297         [ configuration
 298           versionModule
 299           ./maintainers/scripts/ec2/amazon-image.nix
 300           ({ ... }: { virtualisation.diskSize = "auto"; })
 301         ];
 302     }).config.system.build.amazonImage)
 303
 304   );
 305
 306   # An image that can be imported into incus and used for container creation
 307   incusContainerImage =
 308     forMatchingSystems
 309       [
 310         "x86_64-linux"
 311         "aarch64-linux"
 312       ]
 313       (
 314         system:
 315         with import ./.. { inherit system; };
 316
 317         hydraJob (
 318           (import lib/eval-config.nix {
 319             inherit system;
 320             modules = [
 321               configuration
 322               versionModule
 323               ./maintainers/scripts/incus/incus-container-image.nix
 324             ];
 325           }).config.system.build.squashfs
 326         )
 327       );
 328
 329   # Metadata for the incus image
 330   incusContainerMeta =
 331     forMatchingSystems
 332       [
 333         "x86_64-linux"
 334         "aarch64-linux"
 335       ]
 336       (
 337         system:
 338
 339         with import ./.. { inherit system; };
 340
 341         hydraJob (
 342           (import lib/eval-config.nix {
 343             inherit system;
 344             modules = [
 345               configuration
 346               versionModule
 347               ./maintainers/scripts/incus/incus-container-image.nix
 348             ];
 349           }).config.system.build.metadata
 350         )
 351       );
 352
 353   # An image that can be imported into incus and used for container creation
 354   incusVirtualMachineImage =
 355     forMatchingSystems
 356       [
 357         "x86_64-linux"
 358         "aarch64-linux"
 359       ]
 360       (
 361         system:
 362
 363         with import ./.. { inherit system; };
 364
 365         hydraJob (
 366           (import lib/eval-config.nix {
 367             inherit system;
 368             modules = [
 369               configuration
 370               versionModule
 371               ./maintainers/scripts/incus/incus-virtual-machine-image.nix
 372             ];
 373           }).config.system.build.qemuImage
 374         )
 375       );
 376
 377   # Metadata for the incus image
 378   incusVirtualMachineImageMeta =
 379     forMatchingSystems
 380       [
 381         "x86_64-linux"
 382         "aarch64-linux"
 383       ]
 384       (
 385         system:
 386
 387         with import ./.. { inherit system; };
 388
 389         hydraJob (
 390           (import lib/eval-config.nix {
 391             inherit system;
 392             modules = [
 393               configuration
 394               versionModule
 395               ./maintainers/scripts/incus/incus-virtual-machine-image.nix
 396             ];
 397           }).config.system.build.metadata
 398         )
 399       );
 400
 401   # An image that can be imported into lxd and used for container creation
 402   lxdContainerImage = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 403
 404     with import ./.. { inherit system; };
 405
 406     hydraJob ((import lib/eval-config.nix {
 407       inherit system;
 408       modules =
 409         [ configuration
 410           versionModule
 411           ./maintainers/scripts/lxd/lxd-container-image.nix
 412         ];
 413     }).config.system.build.tarball)
 414
 415   );
 416
 417   lxdContainerImageSquashfs = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 418
 419     with import ./.. { inherit system; };
 420
 421     hydraJob ((import lib/eval-config.nix {
 422       inherit system;
 423       modules =
 424         [ configuration
 425           versionModule
 426           ./maintainers/scripts/lxd/lxd-container-image.nix
 427         ];
 428     }).config.system.build.squashfs)
 429
 430   );
 431
 432   # Metadata for the lxd image
 433   lxdContainerMeta = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 434
 435     with import ./.. { inherit system; };
 436
 437     hydraJob ((import lib/eval-config.nix {
 438       inherit system;
 439       modules =
 440         [ configuration
 441           versionModule
 442           ./maintainers/scripts/lxd/lxd-container-image.nix
 443         ];
 444     }).config.system.build.metadata)
 445
 446   );
 447
 448   # An image that can be imported into lxd and used for container creation
 449   lxdVirtualMachineImage = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 450
 451     with import ./.. { inherit system; };
 452
 453     hydraJob ((import lib/eval-config.nix {
 454       inherit system;
 455       modules =
 456         [ configuration
 457           versionModule
 458           ./maintainers/scripts/lxd/lxd-virtual-machine-image.nix
 459         ];
 460     }).config.system.build.qemuImage)
 461
 462   );
 463
 464   # Metadata for the lxd image
 465   lxdVirtualMachineImageMeta = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 466
 467     with import ./.. { inherit system; };
 468
 469     hydraJob ((import lib/eval-config.nix {
 470       inherit system;
 471       modules =
 472         [ configuration
 473           versionModule
 474           ./maintainers/scripts/lxd/lxd-virtual-machine-image.nix
 475         ];
 476     }).config.system.build.metadata)
 477
 478   );
 479
 480   # Ensure that all packages used by the minimal NixOS config end up in the channel.
 481   dummy = forAllSystems (system: pkgs.runCommand "dummy"
 482     { toplevel = (import lib/eval-config.nix {
 483         inherit system;
 484         modules = singleton ({ ... }:
 485           { fileSystems."/".device  = mkDefault "/dev/sda1";
 486             boot.loader.grub.device = mkDefault "/dev/sda";
 487             system.stateVersion = mkDefault lib.trivial.release;
 488           });
 489       }).config.system.build.toplevel;
 490       preferLocalBuild = true;
 491     }
 492     "mkdir $out; ln -s $toplevel $out/dummy");
 493
 494
 495   # Provide container tarball for lxc, libvirt-lxc, docker-lxc, ...
 496   containerTarball = forAllSystems (system: makeSystemTarball {
 497     module = ./modules/virtualisation/lxc-container.nix;
 498     inherit system;
 499   });
 500
 501   tests = allTests;
 502
 503   /* Build a bunch of typical closures so that Hydra can keep track of
 504      the evolution of closure sizes. */
 505
 506   closures = {
 507
 508     smallContainer = makeClosure ({ ... }:
 509       { boot.isContainer = true;
 510         services.openssh.enable = true;
 511       });
 512
 513     tinyContainer = makeClosure ({ ... }:
 514       { boot.isContainer = true;
 515         imports = [ modules/profiles/minimal.nix ];
 516       });
 517
 518     ec2 = makeClosure ({ ... }:
 519       { imports = [ modules/virtualisation/amazon-image.nix ];
 520       });
 521
 522     kde = makeClosure ({ ... }:
 523       { services.xserver.enable = true;
 524         services.displayManager.sddm.enable = true;
 525         services.xserver.desktopManager.plasma5.enable = true;
 526       });
 527
 528     xfce = makeClosure ({ ... }:
 529       { services.xserver.enable = true;
 530         services.xserver.desktopManager.xfce.enable = true;
 531       });
 532
 533     gnome = makeClosure ({ ... }:
 534       { services.xserver.enable = true;
 535         services.xserver.displayManager.gdm.enable = true;
 536         services.xserver.desktopManager.gnome.enable = true;
 537       });
 538
 539     pantheon = makeClosure ({ ... }:
 540       { services.xserver.enable = true;
 541         services.xserver.desktopManager.pantheon.enable = true;
 542       });
 543
 544     deepin = makeClosure ({ ... }:
 545       { services.xserver.enable = true;
 546         services.xserver.displayManager.lightdm.enable = true;
 547         services.xserver.desktopManager.deepin.enable = true;
 548       });
 549
 550     # Linux/Apache/PostgreSQL/PHP stack.
 551     lapp = makeClosure ({ pkgs, ... }:
 552       { services.httpd.enable = true;
 553         services.httpd.adminAddr = "foo@example.org";
 554         services.httpd.enablePHP = true;
 555         services.postgresql.enable = true;
 556         services.postgresql.package = pkgs.postgresql;
 557       });
 558   };
 559 }