mirror of
https://github.com/NixOS/mobile-nixos.git
synced 2024-07-14 15:20:28 +03:00
322 lines
11 KiB
Nix
322 lines
11 KiB
Nix
# What's release.nix?
|
|
# ===================
|
|
#
|
|
# This is mainly intended to be run by the build farm at the foundation's Hydra
|
|
# instance. Though you can use it to run your builds, it is not as ergonomic as
|
|
# using `nix-build` on `./default.nix`.
|
|
#
|
|
# Also note that *by design* it still relies on NIX_PATH being used for the
|
|
# input Nixpkgs.
|
|
#
|
|
# Note:
|
|
# Verify that .ci/instantiate-all.nix lists the expected paths when adding to this file.
|
|
let
|
|
# An ambiant arbitrary Nixpkgs package set.
|
|
# This is assumed to be used for e.g. Hydra evals where <nixpkgs> is an input.
|
|
# This pkgs' is used as an input to release-tools, *and* to get a `lib`.
|
|
# Named pkgs' to reduce confusion with fully evaluated `pkgs`.
|
|
pkgs' = import <nixpkgs> {};
|
|
|
|
mobileReleaseTools = (import ./lib/release-tools.nix {
|
|
pkgs = pkgs';
|
|
});
|
|
inherit (mobileReleaseTools) all-devices;
|
|
in
|
|
{ mobile-nixos ? builtins.fetchGit ./.
|
|
# By default, builds all devices.
|
|
, devices ? all-devices
|
|
# By default, assume we eval only for currentSystem
|
|
, systems ? [ builtins.currentSystem ]
|
|
# nixpkgs is also an input, used as `<nixpkgs>` in the system configuration.
|
|
|
|
# Some additional configuration will be made with this.
|
|
# Mainly to work with some limitations (output size).
|
|
, inNixOSHydra ? false
|
|
}:
|
|
|
|
let
|
|
# We require some `lib` stuff in here.
|
|
# Pick a lib from the arbitrary package set.
|
|
inherit (pkgs') lib releaseTools;
|
|
inherit (mobileReleaseTools.withPkgs pkgs')
|
|
evalFor
|
|
evalWithConfiguration
|
|
knownSystems
|
|
specialConfig
|
|
;
|
|
|
|
# Systems we should eval for, per host system.
|
|
# Non-native will be assumed cross.
|
|
shouldEvalOn = {
|
|
x86_64-linux = [
|
|
"armv7l-linux"
|
|
"aarch64-linux"
|
|
"x86_64-linux"
|
|
];
|
|
aarch64-linux = [
|
|
"aarch64-linux"
|
|
];
|
|
armv7l-linux = [
|
|
"armv7l-linux"
|
|
];
|
|
};
|
|
|
|
onlyDerivations = lib.filterAttrs (k: v: lib.isDerivation v);
|
|
onlyDerivationsAndAttrsets = lib.filterAttrs (k: v: lib.isDerivation v || (lib.isAttrs v && !lib.isFunction v));
|
|
|
|
# Given an evaluated "device", filters `pkgs` down to only our packages
|
|
# unique to the overaly.
|
|
# Also removes some non-packages from the overlay.
|
|
overlayForEval =
|
|
let
|
|
# Trick the overlay in giving us its attributes.
|
|
# Using the values is likely to fail. Thank lazyness!
|
|
overlayAttrNames = builtins.attrNames (import ./overlay/overlay.nix {} {});
|
|
in
|
|
eval: let overlay = (lib.genAttrs overlayAttrNames (name: eval.pkgs.${name})); in
|
|
overlay // {
|
|
# We only "monkey patch" over top of the main nixos one.
|
|
xorg = {
|
|
xf86videofbdev = eval.pkgs.xorg.xf86videofbdev;
|
|
};
|
|
|
|
# lib-like attributes...
|
|
# How should we handle these?
|
|
image-builder = null;
|
|
mobile-nixos = (onlyDerivationsAndAttrsets overlay.mobile-nixos) // {
|
|
# The cross canaries attrsets will be used as constituents.
|
|
# Filter out `override` and `overrideAttrs` early.
|
|
cross-canary-test = onlyDerivations overlay.mobile-nixos.cross-canary-test;
|
|
cross-canary-test-static = onlyDerivations overlay.mobile-nixos.cross-canary-test-static;
|
|
};
|
|
|
|
# Also lib-like, but a "global" like attribute :/
|
|
defaultKernelPatches = null;
|
|
}
|
|
;
|
|
|
|
# Given a system builds run on, this will return a set of further systems
|
|
# this builds in, either native or cross.
|
|
# The values are `overlayForEval` applied for the pair local/cross systems.
|
|
evalForSystem = system: builtins.listToAttrs
|
|
(builtins.map (
|
|
buildingForSystem:
|
|
let
|
|
# "device" name for the eval *and* key used for the set.
|
|
name = if system == buildingForSystem then buildingForSystem else "${buildingForSystem}-cross";
|
|
# "device" eval for our dummy device.
|
|
eval = evalFor (specialConfig {inherit name buildingForSystem system;});
|
|
overlay = overlayForEval eval;
|
|
in {
|
|
inherit name;
|
|
value = overlay;
|
|
}) shouldEvalOn.${system}
|
|
)
|
|
;
|
|
|
|
# `device` here is indexed by the system it's being built on first.
|
|
# FIXME: can we better filter this?
|
|
device = lib.genAttrs devices (device:
|
|
lib.genAttrs systems (system:
|
|
(evalWithConfiguration {
|
|
nixpkgs.localSystem = knownSystems.${system};
|
|
} device).config.mobile.outputs.default
|
|
)
|
|
);
|
|
|
|
# `kernel` here is indexed by the system it's being built on first.
|
|
# FIXME: can we better filter this?
|
|
kernel = lib.genAttrs devices (device:
|
|
lib.genAttrs systems (system:
|
|
(evalWithConfiguration {
|
|
nixpkgs.localSystem = knownSystems.${system};
|
|
} device).config.mobile.boot.stage-1.kernel.package
|
|
)
|
|
);
|
|
|
|
evalExample =
|
|
{ example
|
|
, system
|
|
, targetSystem ? system
|
|
}:
|
|
import example {
|
|
device = specialConfig {
|
|
name =
|
|
if system == targetSystem
|
|
then system
|
|
else "${targetSystem}-built-on-${system}"
|
|
;
|
|
inherit system;
|
|
buildingForSystem = targetSystem;
|
|
config = {
|
|
# Ensures outputs are digestible by Hydra
|
|
mobile._internal.compressLargeArtifacts = inNixOSHydra;
|
|
# Build a generic rootfs
|
|
mobile.rootfs.shared.enabled = true;
|
|
};
|
|
};
|
|
}
|
|
;
|
|
|
|
evalInstaller =
|
|
{ device
|
|
, localSystem
|
|
}:
|
|
let
|
|
eval = evalWithConfiguration {
|
|
imports = [
|
|
./examples/installer/configuration.nix
|
|
];
|
|
nixpkgs.localSystem = knownSystems.${localSystem};
|
|
} device;
|
|
in
|
|
eval // { inherit (eval.config.mobile) outputs; }
|
|
;
|
|
|
|
doc = import ./doc {
|
|
pkgs = pkgs';
|
|
};
|
|
in
|
|
rec {
|
|
inherit device;
|
|
inherit kernel;
|
|
inherit doc;
|
|
|
|
# Some example systems to build.
|
|
# They track breaking changes, and ensures dependencies are built.
|
|
# They may or may not work as-they-are on devices. YMMV.
|
|
examples = {
|
|
hello = {
|
|
x86_64-linux.toplevel = (evalExample { example = ./examples/hello; system = "x86_64-linux"; }).outputs.toplevel;
|
|
aarch64-linux.toplevel = (evalExample { example = ./examples/hello; system = "aarch64-linux"; }).outputs.toplevel;
|
|
cross-x86-aarch64.toplevel = (evalExample { example = ./examples/hello; system = "x86_64-linux"; targetSystem = "aarch64-linux"; }).outputs.toplevel;
|
|
cross-x86-armv7l.toplevel = (evalExample { example = ./examples/hello; system = "x86_64-linux"; targetSystem = "armv7l-linux"; }).outputs.toplevel;
|
|
};
|
|
phosh = {
|
|
x86_64-linux.toplevel = (evalExample { example = ./examples/phosh; system = "x86_64-linux"; }).outputs.toplevel;
|
|
aarch64-linux.toplevel = (evalExample { example = ./examples/phosh; system = "aarch64-linux"; }).outputs.toplevel;
|
|
cross-x86-aarch64.toplevel = (evalExample { example = ./examples/phosh; system = "x86_64-linux"; targetSystem = "aarch64-linux"; }).outputs.toplevel;
|
|
};
|
|
plasma-mobile = {
|
|
x86_64-linux.toplevel = (evalExample { example = ./examples/plasma-mobile; system = "x86_64-linux"; }).outputs.toplevel;
|
|
aarch64-linux.toplevel = (evalExample { example = ./examples/plasma-mobile; system = "aarch64-linux"; }).outputs.toplevel;
|
|
cross-x86-aarch64.toplevel = (evalExample { example = ./examples/plasma-mobile; system = "x86_64-linux"; targetSystem = "aarch64-linux"; }).outputs.toplevel;
|
|
};
|
|
};
|
|
|
|
installer = {
|
|
lenovo-krane = (evalInstaller { device = "lenovo-krane"; localSystem = "aarch64-linux"; }).outputs.default;
|
|
lenovo-wormdingler = (evalInstaller { device = "lenovo-wormdingler"; localSystem = "aarch64-linux"; }).outputs.default;
|
|
pine64-pinephone = (evalInstaller { device = "pine64-pinephone"; localSystem = "aarch64-linux"; }).outputs.default;
|
|
pine64-pinephonepro = (evalInstaller { device = "pine64-pinephonepro"; localSystem = "aarch64-linux"; }).outputs.default;
|
|
};
|
|
|
|
# Overlays build native, and cross, according to shouldEvalOn
|
|
overlay = lib.genAttrs systems (system:
|
|
(evalForSystem system)
|
|
);
|
|
|
|
cross-canaries = lib.genAttrs ["aarch64-linux" "armv7l-linux"] (system:
|
|
releaseTools.aggregate {
|
|
name = "cross-canaries-${system}";
|
|
constituents =
|
|
let
|
|
overlay' = overlay.x86_64-linux."${system}-cross";
|
|
in
|
|
(builtins.attrValues overlay'.mobile-nixos.cross-canary-test)
|
|
++ (builtins.attrValues overlay'.mobile-nixos.cross-canary-test-static)
|
|
;
|
|
meta = {
|
|
description = "Useful checks for cross-compilation.";
|
|
};
|
|
}
|
|
);
|
|
|
|
cross-compiled = {
|
|
installer = {
|
|
lenovo-krane = (evalInstaller { device = "lenovo-krane"; localSystem = "x86_64-linux"; }).outputs.default;
|
|
lenovo-wormdingler = (evalInstaller { device = "lenovo-wormdingler"; localSystem = "x86_64-linux"; }).outputs.default;
|
|
pine64-pinephone = (evalInstaller { device = "pine64-pinephone"; localSystem = "x86_64-linux"; }).outputs.default;
|
|
pine64-pinephonepro = (evalInstaller { device = "pine64-pinephonepro"; localSystem = "aarch64-linux"; }).outputs.default;
|
|
};
|
|
};
|
|
|
|
tested = let
|
|
hasSystem = name: lib.lists.any (el: el == name) systems;
|
|
|
|
constituents =
|
|
cross-canaries.aarch64-linux.constituents
|
|
++ lib.optionals (hasSystem "x86_64-linux") [
|
|
device.uefi-x86_64.x86_64-linux # UEFI system
|
|
|
|
# Cross builds
|
|
device.motorola-potter.x86_64-linux # Android
|
|
device.asus-dumo.x86_64-linux # Depthcharge
|
|
|
|
# Example systems
|
|
examples.hello.x86_64-linux.toplevel
|
|
examples.hello.cross-x86-aarch64.toplevel
|
|
examples.phosh.x86_64-linux.toplevel
|
|
examples.plasma-mobile.x86_64-linux.toplevel
|
|
|
|
# Flashable zip binaries are universal for a platform.
|
|
overlay.x86_64-linux.aarch64-linux-cross.mobile-nixos.android-flashable-zip-binaries
|
|
]
|
|
++ lib.optionals (hasSystem "aarch64-linux") [
|
|
device.motorola-potter.aarch64-linux # Android
|
|
device.asus-dumo.aarch64-linux # Depthcharge
|
|
|
|
# Example systems
|
|
examples.hello.aarch64-linux.toplevel
|
|
examples.phosh.aarch64-linux.toplevel
|
|
examples.plasma-mobile.aarch64-linux.toplevel
|
|
|
|
installer.pine64-pinephone
|
|
|
|
# Flashable zip binaries are universal for a platform.
|
|
overlay.aarch64-linux.aarch64-linux.mobile-nixos.android-flashable-zip-binaries
|
|
];
|
|
in
|
|
releaseTools.aggregate {
|
|
name = "mobile-nixos-tested";
|
|
inherit constituents;
|
|
meta = {
|
|
description = "Representative subset of devices that have to succeed.";
|
|
};
|
|
};
|
|
|
|
# Uses the constituents of tested
|
|
testedPlus = let
|
|
hasSystem = name: lib.lists.any (el: el == name) systems;
|
|
|
|
constituents = tested.constituents
|
|
++ cross-canaries.armv7l-linux.constituents
|
|
++ lib.optionals (hasSystem "x86_64-linux") [
|
|
# FIXME: add an armv7l system once one is available again
|
|
# device.asus-flo.x86_64-linux
|
|
overlay.x86_64-linux.armv7l-linux-cross.mobile-nixos.android-flashable-zip-binaries
|
|
examples.hello.cross-x86-armv7l.toplevel
|
|
]
|
|
++ lib.optionals (hasSystem "aarch64-linux") [
|
|
]
|
|
++ lib.optionals (hasSystem "armv7l-linux") [
|
|
# FIXME: add an armv7l system once one is available again
|
|
# device.asus-flo.armv7l-linux
|
|
overlay.armv7l-linux.armv7l-linux.mobile-nixos.android-flashable-zip-binaries
|
|
]
|
|
;
|
|
in
|
|
releaseTools.aggregate {
|
|
name = "mobile-nixos-tested-plus";
|
|
inherit constituents;
|
|
meta = {
|
|
description = ''
|
|
Other targets that may be failing more often than `tested`.
|
|
This contains more esoteric and less tested platforms.
|
|
|
|
For a future release, `testedPlus` shoud also pass.
|
|
'';
|
|
};
|
|
};
|
|
}
|