nixos/release.nix

   1 with import ../lib;
   2
   3 { nixpkgs ? { outPath = cleanSource ./..; revCount = 130979; shortRev = "gfedcba"; }
   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 "pre") + "${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.version;
  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   # A bootable VirtualBox virtual appliance as an OVA file (i.e. packaged OVF).
 234   ova = forMatchingSystems [ "x86_64-linux" ] (system:
 235
 236     with import ./.. { inherit system; };
 237
 238     hydraJob ((import lib/eval-config.nix {
 239       inherit system;
 240       modules =
 241         [ versionModule
 242           ./modules/installer/virtualbox-demo.nix
 243         ];
 244     }).config.system.build.virtualBoxOVA)
 245
 246   );
 247
 248   # KVM image for proxmox in VMA format
 249   proxmoxImage = forMatchingSystems [ "x86_64-linux" ] (system:
 250     with import ./.. { inherit system; };
 251
 252     hydraJob ((import lib/eval-config.nix {
 253       inherit system;
 254       modules = [
 255         ./modules/virtualisation/proxmox-image.nix
 256       ];
 257     }).config.system.build.VMA)
 258   );
 259
 260   # LXC tarball for proxmox
 261   proxmoxLXC = forMatchingSystems [ "x86_64-linux" ] (system:
 262     with import ./.. { inherit system; };
 263
 264     hydraJob ((import lib/eval-config.nix {
 265       inherit system;
 266       modules = [
 267         ./modules/virtualisation/proxmox-lxc.nix
 268       ];
 269     }).config.system.build.tarball)
 270   );
 271
 272   # A disk image that can be imported to Amazon EC2 and registered as an AMI
 273   amazonImage = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 274
 275     with import ./.. { inherit system; };
 276
 277     hydraJob ((import lib/eval-config.nix {
 278       inherit system;
 279       modules =
 280         [ configuration
 281           versionModule
 282           ./maintainers/scripts/ec2/amazon-image.nix
 283         ];
 284     }).config.system.build.amazonImage)
 285
 286   );
 287   amazonImageZfs = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 288
 289     with import ./.. { inherit system; };
 290
 291     hydraJob ((import lib/eval-config.nix {
 292       inherit system;
 293       modules =
 294         [ configuration
 295           versionModule
 296           ./maintainers/scripts/ec2/amazon-image-zfs.nix
 297         ];
 298     }).config.system.build.amazonImage)
 299
 300   );
 301
 302
 303   # Test job for https://github.com/NixOS/nixpkgs/issues/121354 to test
 304   # automatic sizing without blocking the channel.
 305   amazonImageAutomaticSize = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 306
 307     with import ./.. { inherit system; };
 308
 309     hydraJob ((import lib/eval-config.nix {
 310       inherit system;
 311       modules =
 312         [ configuration
 313           versionModule
 314           ./maintainers/scripts/ec2/amazon-image.nix
 315           ({ ... }: { amazonImage.sizeMB = "auto"; })
 316         ];
 317     }).config.system.build.amazonImage)
 318
 319   );
 320
 321   # An image that can be imported into incus and used for container creation
 322   incusContainerImage =
 323     forMatchingSystems
 324       [
 325         "x86_64-linux"
 326         "aarch64-linux"
 327       ]
 328       (
 329         system:
 330         with import ./.. { inherit system; };
 331
 332         hydraJob (
 333           (import lib/eval-config.nix {
 334             inherit system;
 335             modules = [
 336               configuration
 337               versionModule
 338               ./maintainers/scripts/incus/incus-container-image.nix
 339             ];
 340           }).config.system.build.squashfs
 341         )
 342       );
 343
 344   # Metadata for the incus image
 345   incusContainerMeta =
 346     forMatchingSystems
 347       [
 348         "x86_64-linux"
 349         "aarch64-linux"
 350       ]
 351       (
 352         system:
 353
 354         with import ./.. { inherit system; };
 355
 356         hydraJob (
 357           (import lib/eval-config.nix {
 358             inherit system;
 359             modules = [
 360               configuration
 361               versionModule
 362               ./maintainers/scripts/incus/incus-container-image.nix
 363             ];
 364           }).config.system.build.metadata
 365         )
 366       );
 367
 368   # An image that can be imported into incus and used for container creation
 369   incusVirtualMachineImage =
 370     forMatchingSystems
 371       [
 372         "x86_64-linux"
 373         "aarch64-linux"
 374       ]
 375       (
 376         system:
 377
 378         with import ./.. { inherit system; };
 379
 380         hydraJob (
 381           (import lib/eval-config.nix {
 382             inherit system;
 383             modules = [
 384               configuration
 385               versionModule
 386               ./maintainers/scripts/incus/incus-virtual-machine-image.nix
 387             ];
 388           }).config.system.build.qemuImage
 389         )
 390       );
 391
 392   # Metadata for the incus image
 393   incusVirtualMachineImageMeta =
 394     forMatchingSystems
 395       [
 396         "x86_64-linux"
 397         "aarch64-linux"
 398       ]
 399       (
 400         system:
 401
 402         with import ./.. { inherit system; };
 403
 404         hydraJob (
 405           (import lib/eval-config.nix {
 406             inherit system;
 407             modules = [
 408               configuration
 409               versionModule
 410               ./maintainers/scripts/incus/incus-virtual-machine-image.nix
 411             ];
 412           }).config.system.build.metadata
 413         )
 414       );
 415
 416   # An image that can be imported into lxd and used for container creation
 417   lxdContainerImage = 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.tarball)
 429
 430   );
 431
 432   lxdContainerImageSquashfs = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 433
 434     with import ./.. { inherit system; };
 435
 436     hydraJob ((import lib/eval-config.nix {
 437       inherit system;
 438       modules =
 439         [ configuration
 440           versionModule
 441           ./maintainers/scripts/lxd/lxd-container-image.nix
 442         ];
 443     }).config.system.build.squashfs)
 444
 445   );
 446
 447   # Metadata for the lxd image
 448   lxdContainerMeta = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 449
 450     with import ./.. { inherit system; };
 451
 452     hydraJob ((import lib/eval-config.nix {
 453       inherit system;
 454       modules =
 455         [ configuration
 456           versionModule
 457           ./maintainers/scripts/lxd/lxd-container-image.nix
 458         ];
 459     }).config.system.build.metadata)
 460
 461   );
 462
 463   # An image that can be imported into lxd and used for container creation
 464   lxdVirtualMachineImage = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 465
 466     with import ./.. { inherit system; };
 467
 468     hydraJob ((import lib/eval-config.nix {
 469       inherit system;
 470       modules =
 471         [ configuration
 472           versionModule
 473           ./maintainers/scripts/lxd/lxd-virtual-machine-image.nix
 474         ];
 475     }).config.system.build.qemuImage)
 476
 477   );
 478
 479   # Metadata for the lxd image
 480   lxdVirtualMachineImageMeta = forMatchingSystems [ "x86_64-linux" "aarch64-linux" ] (system:
 481
 482     with import ./.. { inherit system; };
 483
 484     hydraJob ((import lib/eval-config.nix {
 485       inherit system;
 486       modules =
 487         [ configuration
 488           versionModule
 489           ./maintainers/scripts/lxd/lxd-virtual-machine-image.nix
 490         ];
 491     }).config.system.build.metadata)
 492
 493   );
 494
 495   # Ensure that all packages used by the minimal NixOS config end up in the channel.
 496   dummy = forAllSystems (system: pkgs.runCommand "dummy"
 497     { toplevel = (import lib/eval-config.nix {
 498         inherit system;
 499         modules = singleton ({ ... }:
 500           { fileSystems."/".device  = mkDefault "/dev/sda1";
 501             boot.loader.grub.device = mkDefault "/dev/sda";
 502             system.stateVersion = mkDefault lib.trivial.release;
 503           });
 504       }).config.system.build.toplevel;
 505       preferLocalBuild = true;
 506     }
 507     "mkdir $out; ln -s $toplevel $out/dummy");
 508
 509
 510   # Provide container tarball for lxc, libvirt-lxc, docker-lxc, ...
 511   containerTarball = forAllSystems (system: makeSystemTarball {
 512     module = ./modules/virtualisation/lxc-container.nix;
 513     inherit system;
 514   });
 515
 516   tests = allTests;
 517
 518   /* Build a bunch of typical closures so that Hydra can keep track of
 519      the evolution of closure sizes. */
 520
 521   closures = {
 522
 523     smallContainer = makeClosure ({ ... }:
 524       { boot.isContainer = true;
 525         services.openssh.enable = true;
 526       });
 527
 528     tinyContainer = makeClosure ({ ... }:
 529       { boot.isContainer = true;
 530         imports = [ modules/profiles/minimal.nix ];
 531       });
 532
 533     ec2 = makeClosure ({ ... }:
 534       { imports = [ modules/virtualisation/amazon-image.nix ];
 535       });
 536
 537     kde = makeClosure ({ ... }:
 538       { services.xserver.enable = true;
 539         services.displayManager.sddm.enable = true;
 540         services.xserver.desktopManager.plasma5.enable = true;
 541       });
 542
 543     xfce = makeClosure ({ ... }:
 544       { services.xserver.enable = true;
 545         services.xserver.desktopManager.xfce.enable = true;
 546       });
 547
 548     gnome = makeClosure ({ ... }:
 549       { services.xserver.enable = true;
 550         services.xserver.displayManager.gdm.enable = true;
 551         services.xserver.desktopManager.gnome.enable = true;
 552       });
 553
 554     pantheon = makeClosure ({ ... }:
 555       { services.xserver.enable = true;
 556         services.xserver.desktopManager.pantheon.enable = true;
 557       });
 558
 559     deepin = makeClosure ({ ... }:
 560       { services.xserver.enable = true;
 561         services.xserver.displayManager.lightdm.enable = true;
 562         services.xserver.desktopManager.deepin.enable = true;
 563       });
 564
 565     # Linux/Apache/PostgreSQL/PHP stack.
 566     lapp = makeClosure ({ pkgs, ... }:
 567       { services.httpd.enable = true;
 568         services.httpd.adminAddr = "foo@example.org";
 569         services.httpd.enablePHP = true;
 570         services.postgresql.enable = true;
 571         services.postgresql.package = pkgs.postgresql;
 572       });
 573   };
 574 }