mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-22 00:21:43 +01:00
build(nix): one root flake for Windows, KDE Plasma and macOS
One flake.nix and one flake.lock replace the root flake that re-exported two nested flakes.
The inputs are one nixpkgs (the revision the KDE flake was locked to, f05535a0: the VM suites
run against its Plasma and KWin 6.8.2), one crane, rust-overlay (19ecdd08, rustc 1.99.1),
flake-parts, treefmt-nix and git-hooks-nix, all the KDE flake revisions, plus asc. A second
nixpkgs, nixpkgs-x86_64-darwin (16c7794d, the macOS flake pin), serves the x86_64-darwin
outputs only: evaluating that system with the unified pin throws (nixpkgs 26.11 dropped it).
Layout: nix/common.nix (systems, pkgs, treefmt, pre-commit, dev shells default and native,
default overlay), nix/lib.nix, nix/workspace-src.nix (one source per platform from the one Cargo
workspace: the platform members, its files of the shared crates told apart by name, the data
files, and stubs for the other members, which cargo needs), nix/{windows,linux,macos}/
{build,flake-module}.nix. The dependency derivations use a manifests-only dummy source, a plain
path, so crane reads nothing built at evaluation and the Darwin outputs evaluate on Linux.
Names: unprefixed outputs are the native build (Linux: KDE; Darwin: macOS); Windows cross
outputs are windows-*; checks are windows-*, linux-*, macos-* and vm-NAME; table in docs/dev/flake.md
(next revision). One deny.toml, one format-all and one version (workspace) are used by all.
PLACEHOLDER for the agent that owns the check sets: the checks that evaluate a NixOS system
or a VM (vm-*, linux-nixos-module-eval, linux-plasma-guests-eval, linux-run-kde*) are
legacyPackages.<system>.heavyChecks.<name>, not checks, because evaluating them needs more
memory than nix flake check --all-systems can use. The Plasma guests got a stub root file system
and boot loader (mkDefault, replaced by their vmVariant) so that nix flake check can evaluate
their toplevel.
Verified: nix flake check --no-build --all-systems passes (42 s, rc 0); nix flake check
--no-build passes. Not verified: any build (next revisions record them).
This commit is contained in:
1 parent
05698a34ba
commit
ae9ee327f9
11 files changed
+1821
-1084
No files matched your search
@@ -0,0 +1,115 @@
|
||||
# The crane derivations of the Linux (KDE Plasma) packages, from the Linux members of the one Cargo
|
||||
# workspace (nix/workspace-src.nix).
|
||||
{ inputs, self }:
|
||||
let
|
||||
lib' = import ../lib.nix { inherit inputs; };
|
||||
inherit (lib') version;
|
||||
inherit (inputs) crane;
|
||||
in
|
||||
{
|
||||
mkKomorebiPackages =
|
||||
{ pkgs }:
|
||||
let
|
||||
toolchain = pkgs.rust-bin.fromRustupToolchainFile ../../rust-toolchain.toml;
|
||||
craneLib = (crane.mkLib pkgs).overrideToolchain toolchain;
|
||||
|
||||
inherit
|
||||
(import ../workspace-src.nix {
|
||||
inherit pkgs craneLib;
|
||||
repoRoot = ../..;
|
||||
platform = "linux";
|
||||
})
|
||||
real
|
||||
src
|
||||
stubbedPackages
|
||||
;
|
||||
|
||||
lockFile = lib'.repoFile "Cargo.lock";
|
||||
tomlFile = lib'.repoFile "Cargo.toml";
|
||||
packages = "-p komorebi -p komorebi-linux -p komorebic -p komorebi-client -p komorebi-hotkeys";
|
||||
workspaceArgs = {
|
||||
pname = "komorebi-workspace-linux";
|
||||
inherit version;
|
||||
# the lock and the root manifest as files of their own: a path inside the filtered source
|
||||
# would put all of it into the context of every derivation, and an edit of any file
|
||||
# would then change the dependencies
|
||||
cargoLock = lockFile;
|
||||
cargoToml = tomlFile;
|
||||
cargoVendorDir = craneLib.vendorCargoDeps { cargoLock = lockFile; };
|
||||
};
|
||||
|
||||
commonArgs = workspaceArgs // {
|
||||
cargoExtraArgs = "--locked ${packages}";
|
||||
inherit src;
|
||||
strictDeps = true;
|
||||
# The version crate wants a commit at compile time. It is a constant here, so that the
|
||||
# dependencies and every check are the same derivations for every commit; only the final
|
||||
# build below knows the real one.
|
||||
COMMIT_HASH = "nix-check";
|
||||
};
|
||||
|
||||
# the dummy source is of the manifests alone (nix/lib.nix): the dependencies are the same
|
||||
# derivations for every source file and every stub, and nothing is built at evaluation
|
||||
cargoArtifacts = craneLib.buildDepsOnly (
|
||||
builtins.removeAttrs commonArgs [ "src" ]
|
||||
// {
|
||||
dummySrc = craneLib.mkDummySrc {
|
||||
src = lib'.manifestSource pkgs.lib;
|
||||
cargoLock = lockFile;
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
individualCrateArgs = commonArgs // {
|
||||
inherit cargoArtifacts;
|
||||
doCheck = false;
|
||||
doDoc = false;
|
||||
};
|
||||
|
||||
fullBuild = craneLib.buildPackage (
|
||||
individualCrateArgs
|
||||
// {
|
||||
COMMIT_HASH = self.rev or (pkgs.lib.removeSuffix "-dirty" (self.dirtyRev or "unknown"));
|
||||
}
|
||||
);
|
||||
|
||||
# the same build with the constant commit of the checks: the VM tests install this one, so
|
||||
# that a new commit does not build the daemon again
|
||||
vmBuild = craneLib.buildPackage individualCrateArgs;
|
||||
|
||||
extractBinaryOf =
|
||||
package: binaryName:
|
||||
pkgs.runCommand "komorebi-${binaryName}" { meta = package.meta // { }; } ''
|
||||
mkdir -p $out/bin
|
||||
cp ${package}/bin/${binaryName} $out/bin/
|
||||
'';
|
||||
extractBinary = extractBinaryOf fullBuild;
|
||||
in
|
||||
{
|
||||
inherit
|
||||
craneLib
|
||||
src
|
||||
real
|
||||
workspaceArgs
|
||||
stubbedPackages
|
||||
packages
|
||||
commonArgs
|
||||
individualCrateArgs
|
||||
fullBuild
|
||||
vmBuild
|
||||
;
|
||||
komorebi = extractBinary "komorebi";
|
||||
komorebic = extractBinary "komorebic";
|
||||
komorebiForVm = extractBinaryOf vmBuild "komorebi";
|
||||
komorebicForVm = extractBinaryOf vmBuild "komorebic";
|
||||
# komorebic with the constant commit of the checks, whose output the schemas are
|
||||
# checked against: it is the same for every commit
|
||||
komorebicForChecks = craneLib.buildPackage (
|
||||
individualCrateArgs
|
||||
// {
|
||||
pname = "komorebic-for-checks";
|
||||
cargoExtraArgs = "--package komorebic --bin komorebic";
|
||||
}
|
||||
);
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,526 @@
|
||||
# komorebi for Linux (KDE Plasma): the native packages, the `linux-*` checks, the VM tests (`vm-*`),
|
||||
# the NixOS module and the Plasma guests. The Rust packages are built on Linux; Apple silicon gets
|
||||
# the checks and the VM guests' definitions, which run the same tests against the fake desktop.
|
||||
{
|
||||
inputs,
|
||||
self,
|
||||
lib,
|
||||
...
|
||||
}:
|
||||
let
|
||||
lib' = import ../lib.nix { inherit inputs; };
|
||||
inherit (inputs) nixpkgs;
|
||||
linux = import ./build.nix { inherit inputs self; };
|
||||
inherit (lib') mkPkgs;
|
||||
in
|
||||
{
|
||||
perSystem =
|
||||
{
|
||||
config,
|
||||
pkgs,
|
||||
system,
|
||||
...
|
||||
}:
|
||||
let
|
||||
build = linux.mkKomorebiPackages { inherit pkgs; };
|
||||
isLinux = pkgs.stdenv.hostPlatform.isLinux;
|
||||
# the guests install komorebi through the module, as a NixOS user does
|
||||
komorebiModule = self.nixosModules.forVmTests;
|
||||
# a Mac runs the guests under HVF, which is slower than KVM. A Linux host is no faster
|
||||
# than a Mac to the suites that time the daemon: on a 24-core WSL2 machine, under nested
|
||||
# KVM and with nothing else running, `latency` measured a p95 of 129 ms against its
|
||||
# 100 ms times `scale`, where x86-1 had passed it at 1
|
||||
vm = import ./tests/vm {
|
||||
hostPkgs = pkgs;
|
||||
inherit komorebiModule;
|
||||
scale = 1.5;
|
||||
};
|
||||
# the probe of a NixOS-WSL2 machine (docs/linux/dev/wsl2-probe.md); the checks use a constant
|
||||
# revision, so that they are the same derivations for every commit
|
||||
wsl2Probe = import ./dev/wsl2-probe.nix {
|
||||
inherit pkgs;
|
||||
rev = self.rev or self.dirtyRev or "unknown";
|
||||
};
|
||||
wsl2ProbeForChecks = import ./dev/wsl2-probe.nix {
|
||||
inherit pkgs;
|
||||
rev = "nix-check";
|
||||
};
|
||||
# `run-kde` starts the demo guest of the host's architecture (docs/linux/trying-it.md). The guest's
|
||||
# runner is named in the program, not depended on: the command works out what is missing
|
||||
# and builds it, with its progress shown, instead of `nix run` fetching 4 GB first.
|
||||
runKde =
|
||||
let
|
||||
arch = if system == "x86_64-linux" then "x86_64" else "aarch64";
|
||||
guest = self.nixosConfigurations."run-kde-${arch}";
|
||||
runner = builtins.unsafeDiscardStringContext "${guest.config.system.build.vm}";
|
||||
in
|
||||
pkgs.writeShellApplication {
|
||||
name = "run-kde";
|
||||
runtimeInputs = with pkgs; [
|
||||
coreutils
|
||||
e2fsprogs
|
||||
gawk
|
||||
git
|
||||
gnugrep
|
||||
gnused
|
||||
mesa-demos
|
||||
openssh
|
||||
qemu-utils
|
||||
virtiofsd
|
||||
];
|
||||
text = ''
|
||||
: "''${RUN_KDE_GUEST:=run-kde-${arch}}"
|
||||
: "''${RUN_KDE_RUNNER_BIN:=${runner}/bin/run-${guest.config.networking.hostName}-vm}"
|
||||
''
|
||||
+ builtins.readFile ../../scripts/linux/run-kde;
|
||||
};
|
||||
# rustfmt.toml uses options only a nightly rustfmt knows
|
||||
nightlyRustfmt = pkgs.rust-bin.nightly.latest.rustfmt;
|
||||
checkSystem = builtins.elem system lib'.linuxCheckSystems;
|
||||
|
||||
# PLACEHOLDER until the structure of the check sets is decided (agent flake-checks): the checks that
|
||||
# evaluate a NixOS system or a VM (vm-*, the Plasma guests, the module option tests, run-kde) take
|
||||
# minutes and many GB to evaluate, so `nix flake check --no-build --all-systems` cannot hold them. They
|
||||
# are `legacyPackages.<system>.heavyChecks.<name>` (same names as before), not `checks.<system>`.
|
||||
isHeavy =
|
||||
name:
|
||||
lib.hasPrefix "vm-" name
|
||||
|| builtins.elem name [
|
||||
"linux-nixos-module-eval"
|
||||
"linux-plasma-guests-eval"
|
||||
"linux-run-kde"
|
||||
"linux-run-kde-doctor"
|
||||
"linux-run-kde-dry-run"
|
||||
];
|
||||
split =
|
||||
r:
|
||||
if r ? allChecks then
|
||||
removeAttrs r [ "allChecks" ]
|
||||
// {
|
||||
checks = lib.filterAttrs (n: _: !isHeavy n) r.allChecks;
|
||||
legacyPackages = r.legacyPackages // {
|
||||
heavyChecks = lib.filterAttrs (n: _: isHeavy n) r.allChecks;
|
||||
};
|
||||
}
|
||||
else
|
||||
r;
|
||||
in
|
||||
split (
|
||||
lib.optionalAttrs checkSystem {
|
||||
allChecks = {
|
||||
# tools/format-all: the nightly rustfmt over the files of the Linux source, file by file. `cargo fmt`
|
||||
# followed `mod windows;` of the shared entry files into files this source does not have.
|
||||
linux-fmt =
|
||||
pkgs.runCommand "komorebi-linux-fmt"
|
||||
{
|
||||
nativeBuildInputs = [ nightlyRustfmt ];
|
||||
}
|
||||
''
|
||||
RUSTFMT=rustfmt bash ${lib'.repoFile "tools/format-all"} --check --root ${build.real}
|
||||
touch $out
|
||||
'';
|
||||
|
||||
linux-clippy = build.craneLib.cargoClippy (
|
||||
build.individualCrateArgs
|
||||
// {
|
||||
cargoClippyExtraArgs = "--all-targets -- -D warnings";
|
||||
}
|
||||
);
|
||||
|
||||
linux-doc = build.craneLib.cargoDoc (
|
||||
build.individualCrateArgs
|
||||
// {
|
||||
cargoDocExtraArgs = "--no-deps";
|
||||
env.RUSTDOCFLAGS = "-D warnings";
|
||||
}
|
||||
);
|
||||
|
||||
linux-toml-fmt = build.craneLib.taploFmt (
|
||||
build.workspaceArgs
|
||||
// {
|
||||
src = lib.sources.sourceFilesBySuffices build.real [ ".toml" ];
|
||||
}
|
||||
);
|
||||
|
||||
# cargo deny sees every member of the workspace: leave out the other platforms' packages (stubs
|
||||
# here); the policy is the one deny.toml of the repository
|
||||
linux-deny = build.craneLib.cargoDeny (
|
||||
build.workspaceArgs
|
||||
// {
|
||||
inherit (build) src;
|
||||
cargoDenyExtraArgs =
|
||||
"--workspace " + lib.concatMapStringsSep " " (p: "--exclude ${p}") build.stubbedPackages;
|
||||
cargoDenyChecks = "bans licenses sources";
|
||||
}
|
||||
);
|
||||
|
||||
linux-nextest = build.craneLib.cargoNextest (build.individualCrateArgs // { doCheck = true; });
|
||||
|
||||
# The bridge is not Rust: tsc checks its types from its JSDoc comments, and node runs
|
||||
# its tests against a fake KWin. No package.json and no build step.
|
||||
linux-bridge-js =
|
||||
pkgs.runCommand "komorebi-bridge-js"
|
||||
{
|
||||
nativeBuildInputs = [
|
||||
pkgs.nodejs
|
||||
pkgs.typescript
|
||||
];
|
||||
src = lib.fileset.toSource {
|
||||
root = ../../komorebi-linux/src/kwin;
|
||||
fileset = lib.fileset.fileFilter (file: !file.hasExt "rs") ../../komorebi-linux/src/kwin;
|
||||
};
|
||||
}
|
||||
''
|
||||
cd $src
|
||||
tsc -p tsconfig.json
|
||||
node --test bridge.test.js
|
||||
touch $out
|
||||
'';
|
||||
|
||||
vm-lib = vm.lib;
|
||||
|
||||
# The schemas, the options made from one of them and the example are what the Rust types
|
||||
# say: `just jsonschema` and `just nixgen-linux` write them
|
||||
linux-schema-fresh =
|
||||
pkgs.runCommand "komorebi-schema-fresh"
|
||||
{
|
||||
nativeBuildInputs = [
|
||||
build.komorebicForChecks
|
||||
pkgs.diffutils
|
||||
];
|
||||
}
|
||||
''
|
||||
komorebic static-config-schema | diff -u ${lib'.repoFile "schemas/linux/schema.json"} - \
|
||||
|| { echo "schemas/linux/schema.json is stale: run just jsonschema"; exit 1; }
|
||||
komorebic application-specific-configuration-schema | diff -u ${lib'.repoFile "schemas/linux/schema.asc.json"} - \
|
||||
|| { echo "schemas/linux/schema.asc.json is stale: run just jsonschema"; exit 1; }
|
||||
expected=$(sha256sum ${lib'.repoFile "schemas/linux/schema.json"} | cut -d' ' -f1)
|
||||
head -n 1 ${./komorebi-options.nix} | grep -qx "# schema-sha256: $expected" \
|
||||
|| { echo "nix/linux/komorebi-options.nix is stale: run just nixgen-linux"; exit 1; }
|
||||
touch $out
|
||||
'';
|
||||
|
||||
# the options the module is typed with, evaluated against the example configuration
|
||||
linux-nix-options-validation = import ./tests/default.nix { inherit pkgs; };
|
||||
|
||||
# every file of the key binding corpus through `komorebic hotkeys compile`, as the
|
||||
# module runs it
|
||||
linux-keybindings-fixtures = import ./tests/keybindings.nix {
|
||||
inherit pkgs;
|
||||
komorebic = build.fullBuild;
|
||||
};
|
||||
|
||||
# The NixOS module in real NixOS systems, evaluated and never built, so a Mac checks it
|
||||
# too. A VM suite, `vm-module`, runs it.
|
||||
linux-nixos-module-eval = import ./tests/nixos-module.nix {
|
||||
inherit pkgs;
|
||||
inherit (nixpkgs.lib) nixosSystem;
|
||||
module = self.nixosModules.default;
|
||||
komorebiFor = guestSystem: self.packages.${guestSystem}.komorebi-full;
|
||||
borderEffectFor = guestSystem: self.packages.${guestSystem}.kde-rounded-corners-komorebi;
|
||||
animationEffectFor = guestSystem: self.packages.${guestSystem}.kwin-effect-geometry-change-komorebi;
|
||||
};
|
||||
|
||||
# The Plasma guests to develop against, evaluated and never built, so that every system
|
||||
# sees an option that nixpkgs renamed or an assertion that fails. The QEMU guests are
|
||||
# systems in a VM (`vmVariant`), with a runner for the machine that runs QEMU; UTM's is
|
||||
# a system of its own. Each guest is for one kind of machine, which is also checked: the
|
||||
# architecture of the guest, the machine that runs its QEMU, and that a guest of a Linux
|
||||
# machine has KVM and one display device only.
|
||||
linux-plasma-guests-eval =
|
||||
let
|
||||
guests = self.nixosConfigurations;
|
||||
machines =
|
||||
let
|
||||
mac = {
|
||||
guest = "aarch64-linux";
|
||||
host = "aarch64-darwin";
|
||||
};
|
||||
linux = system: {
|
||||
guest = system;
|
||||
host = system;
|
||||
};
|
||||
# the runner of the demo is given its display device, its ports and whether to
|
||||
# insist on KVM when it starts, by `run-kde`
|
||||
demo = machine: machine // { demo = true; };
|
||||
in
|
||||
{
|
||||
plasma-vm = mac;
|
||||
plasma-vm-session = mac;
|
||||
plasma-vm-x86_64 = linux "x86_64-linux";
|
||||
plasma-vm-session-x86_64 = linux "x86_64-linux";
|
||||
plasma-vm-aarch64 = linux "aarch64-linux";
|
||||
plasma-vm-session-aarch64 = linux "aarch64-linux";
|
||||
run-kde-x86_64 = demo (linux "x86_64-linux");
|
||||
run-kde-aarch64 = demo (linux "aarch64-linux");
|
||||
};
|
||||
isDisplay =
|
||||
option: lib.hasPrefix "-device virtio-vga" option || lib.hasPrefix "-device virtio-gpu" option;
|
||||
qemuGuest =
|
||||
name:
|
||||
let
|
||||
machine = machines.${name};
|
||||
demo = machine.demo or false;
|
||||
vm = guests.${name}.config.virtualisation.vmVariant.virtualisation;
|
||||
in
|
||||
assert lib.assertMsg (
|
||||
guests.${name}.pkgs.stdenv.hostPlatform.system == machine.guest
|
||||
) "${name} is not a ${machine.guest} guest";
|
||||
assert lib.assertMsg (
|
||||
vm.host.pkgs.stdenv.hostPlatform.system == machine.host
|
||||
) "${name} does not run on a ${machine.host} host";
|
||||
assert lib.assertMsg (
|
||||
vm.qemu.forceAccel != demo
|
||||
) "${name} would run without KVM or HVF, which is too slow to use";
|
||||
assert lib.assertMsg (
|
||||
builtins.length (builtins.filter isDisplay vm.qemu.options) == (if demo then 0 else 1)
|
||||
) "${name} does not have the display devices it should have";
|
||||
assert lib.assertMsg
|
||||
# an x86_64 machine has a VGA of its own, which would be a second display
|
||||
((machine.guest == "x86_64-linux" && !demo) == builtins.elem "-vga none" vm.qemu.options)
|
||||
"${name} has `-vga none` if and only if it is an x86_64 guest with a display device";
|
||||
assert lib.assertMsg (
|
||||
demo -> (vm.forwardPorts == [ ] && vm.sharedDirectories.run-kde.target == "/run/run-kde")
|
||||
) "${name} does not leave its ports and its shared directory to the runner's environment";
|
||||
{
|
||||
${name} = guests.${name}.config.virtualisation.vmVariant.system.build.toplevel;
|
||||
"${name}, its runner" = guests.${name}.config.system.build.vm;
|
||||
};
|
||||
builds = lib.foldl' (builds: name: builds // qemuGuest name) { } (lib.attrNames machines) // {
|
||||
plasma-utm = guests.plasma-utm.config.system.build.toplevel;
|
||||
};
|
||||
lines = lib.mapAttrsToList (
|
||||
name: drv: "${name}: ${builtins.unsafeDiscardStringContext drv.drvPath}"
|
||||
) builds;
|
||||
in
|
||||
pkgs.runCommand "plasma-guests-eval" { } ''
|
||||
${lib.concatMapStringsSep "\n" (line: "echo ${lib.escapeShellArg line}") lines}
|
||||
touch $out
|
||||
'';
|
||||
}
|
||||
# The probe builds (shellcheck runs over the script and over the guest's init as it
|
||||
# does) and its dry run works without a machine to probe, so that it cannot rot between
|
||||
# the times somebody runs it.
|
||||
// lib.optionalAttrs isLinux {
|
||||
linux-wsl2-probe = wsl2ProbeForChecks.probe;
|
||||
linux-wsl2-probe-dry-run =
|
||||
pkgs.runCommand "wsl2-probe-dry-run" { nativeBuildInputs = [ wsl2ProbeForChecks.probe ]; }
|
||||
''
|
||||
wsl2-probe --dry-run --no-prompt --report report.txt > out.txt
|
||||
cat out.txt
|
||||
for probe in P0 P1 P2 P3 P4 P5 P6; do
|
||||
grep -q "^$probe " out.txt || { echo "no verdict line for $probe"; exit 1; }
|
||||
done
|
||||
grep -q "PASTE THIS" out.txt
|
||||
grep -q "would run" out.txt
|
||||
# the report file has what the screen has
|
||||
grep -q "PASTE THIS" report.txt
|
||||
# a mistake in the options is refused
|
||||
if wsl2-probe --nonsense 2> err.txt; then exit 1; fi
|
||||
grep -q "unknown option" err.txt
|
||||
touch $out
|
||||
'';
|
||||
}
|
||||
# `run-kde` is shellchecked when it is built, and its output is what a test says it is
|
||||
// lib.optionalAttrs isLinux (
|
||||
lib.mapAttrs' (name: lib.nameValuePair "linux-${name}") (
|
||||
{
|
||||
run-kde = config.packages.run-kde;
|
||||
}
|
||||
// import ./tests/run-kde.nix {
|
||||
inherit pkgs;
|
||||
runKde = config.packages.run-kde;
|
||||
}
|
||||
)
|
||||
)
|
||||
# The VM tests need QEMU with KVM, so only Linux checks them. A Mac runs the same tests
|
||||
# through legacyPackages.<system>.vm, see docs/linux/dev/vm-tests.md.
|
||||
// lib.optionalAttrs isLinux (
|
||||
lib.mapAttrs' (name: test: lib.nameValuePair "vm-${name}" test) vm.suites
|
||||
)
|
||||
# the KWin effects komorebi drives, installed and inspected without a session
|
||||
// lib.optionalAttrs isLinux (
|
||||
lib.mapAttrs' (name: lib.nameValuePair "linux-${name}") (
|
||||
import ./tests/effects.nix {
|
||||
inherit pkgs;
|
||||
inherit (config) packages;
|
||||
}
|
||||
)
|
||||
);
|
||||
|
||||
legacyPackages = lib.optionalAttrs checkSystem (
|
||||
{
|
||||
# every suite, as a test with a `driver`, on every system
|
||||
vm = vm.suites;
|
||||
# the suites of each tier, for the CI matrix
|
||||
vmTiers = vm.tiers;
|
||||
# the guests of every suite, to build on a Linux builder when the host is a Mac
|
||||
vmGuests = vm.guests;
|
||||
}
|
||||
// lib.optionalAttrs isLinux {
|
||||
# the same suites on a machine with no KVM, which is slow but works anywhere
|
||||
vmTcg =
|
||||
(import ./tests/vm {
|
||||
hostPkgs = pkgs;
|
||||
inherit komorebiModule;
|
||||
scale = 8;
|
||||
}).suites;
|
||||
}
|
||||
);
|
||||
}
|
||||
)
|
||||
// lib.optionalAttrs (builtins.elem system lib'.linuxSystems) {
|
||||
packages = {
|
||||
inherit (build) komorebi komorebic;
|
||||
komorebi-full = build.fullBuild;
|
||||
default = build.fullBuild;
|
||||
kde-rounded-corners-komorebi = pkgs.callPackage ../linux/kde-rounded-corners.nix { };
|
||||
kwin-effect-geometry-change-komorebi =
|
||||
pkgs.callPackage ../linux/kwin-effect-geometry-change.nix
|
||||
{ };
|
||||
wsl2-probe = wsl2Probe.probe;
|
||||
wsl2-probe-guest = wsl2Probe.guest;
|
||||
run-kde = runKde;
|
||||
};
|
||||
|
||||
apps = {
|
||||
komorebi = {
|
||||
type = "app";
|
||||
program = "${build.komorebi}/bin/komorebi";
|
||||
meta.description = "The komorebi daemon";
|
||||
};
|
||||
komorebic = {
|
||||
type = "app";
|
||||
program = "${build.komorebic}/bin/komorebic";
|
||||
meta.description = "The command line interface of komorebi";
|
||||
};
|
||||
wsl2-probe = {
|
||||
type = "app";
|
||||
program = lib.getExe wsl2Probe.probe;
|
||||
meta.description = "Probes a NixOS-WSL2 machine for KVM, WSLg, a GPU and RDP";
|
||||
};
|
||||
run-kde = {
|
||||
type = "app";
|
||||
program = lib.getExe config.packages.run-kde;
|
||||
meta.description = "Start the komorebi demo in a virtual machine";
|
||||
};
|
||||
default = config.apps.komorebi;
|
||||
};
|
||||
};
|
||||
|
||||
flake = {
|
||||
overlays.linux =
|
||||
final: _:
|
||||
let
|
||||
build = linux.mkKomorebiPackages { pkgs = mkPkgs final.stdenv.hostPlatform.system; };
|
||||
in
|
||||
{
|
||||
inherit (build) komorebi komorebic;
|
||||
komorebi-full = build.fullBuild;
|
||||
# with the consumer's KWin, so that the plugin links the libkwin it is loaded into
|
||||
kde-rounded-corners-komorebi = final.callPackage ./kde-rounded-corners.nix { };
|
||||
kwin-effect-geometry-change-komorebi = final.callPackage ./kwin-effect-geometry-change.nix { };
|
||||
};
|
||||
# the same packages built with the constant commit of the checks, for the VM tests
|
||||
overlays.forVmTests =
|
||||
final: prev:
|
||||
let
|
||||
build = linux.mkKomorebiPackages { pkgs = mkPkgs final.stdenv.hostPlatform.system; };
|
||||
in
|
||||
(self.overlays.linux final prev)
|
||||
// {
|
||||
komorebi = build.komorebiForVm;
|
||||
komorebic = build.komorebicForVm;
|
||||
komorebi-full = build.vmBuild;
|
||||
};
|
||||
|
||||
# `services.komorebi`, with the overlay that provides its package, so that a NixOS
|
||||
# configuration needs this flake as an input and one module line (docs/linux/installation.md)
|
||||
nixosModules.default = {
|
||||
imports = [ ./nixos-module.nix ];
|
||||
nixpkgs.overlays = [ self.overlays.linux ];
|
||||
};
|
||||
nixosModules.komorebi = self.nixosModules.default;
|
||||
# the names of the root flake before the nested flakes were merged into it
|
||||
nixosModules.komorebi-for-kde = self.nixosModules.default;
|
||||
overlays.komorebi-for-kde = self.overlays.linux;
|
||||
# `services.komorebi` with the packages the VM tests install
|
||||
nixosModules.forVmTests = {
|
||||
imports = [ ./nixos-module.nix ];
|
||||
nixpkgs.overlays = [ self.overlays.forVmTests ];
|
||||
};
|
||||
|
||||
# Plasma guests to develop against (docs/linux/dev/utm.md). For an Apple silicon Mac, QEMU runs
|
||||
# the first two under HVF, and UTM boots the third from a disk image. For a Linux machine
|
||||
# with KVM, QEMU runs the other four: the same two guests for an x86_64 host and for an
|
||||
# aarch64 one, each of which runs the guest of its own architecture. The last two are the
|
||||
# demo that `run-kde` starts.
|
||||
nixosConfigurations =
|
||||
let
|
||||
# `guest` is the system of the guest, and `host` the pkgs of the machine that runs QEMU
|
||||
mkPlasmaGuest =
|
||||
{ guest, host }:
|
||||
modules:
|
||||
nixpkgs.lib.nixosSystem {
|
||||
specialArgs.hostPkgs = host;
|
||||
modules = [
|
||||
self.nixosModules.default
|
||||
{ nixpkgs.hostPlatform = guest; }
|
||||
# `nix flake check` evaluates the toplevel of every configuration, which needs a root file
|
||||
# system and a boot loader; the guests run as VMs (vmVariant), which replace both
|
||||
(
|
||||
{ lib, ... }:
|
||||
{
|
||||
fileSystems."/" = lib.mkDefault {
|
||||
device = "/dev/disk/by-label/nixos";
|
||||
fsType = "ext4";
|
||||
};
|
||||
boot.loader.grub.devices = lib.mkDefault [ "nodev" ];
|
||||
}
|
||||
)
|
||||
]
|
||||
++ modules;
|
||||
};
|
||||
onMac = mkPlasmaGuest {
|
||||
guest = "aarch64-linux";
|
||||
host = nixpkgs.legacyPackages.aarch64-darwin;
|
||||
};
|
||||
onLinux =
|
||||
system:
|
||||
mkPlasmaGuest {
|
||||
guest = system;
|
||||
host = nixpkgs.legacyPackages.${system};
|
||||
};
|
||||
session = [
|
||||
./dev/plasma-vm.nix
|
||||
{ komorebi.plasmaVm.session = true; }
|
||||
];
|
||||
# the session guest with the demo of `run-kde` (nix/linux/dev/run-kde.nix) and no display
|
||||
# device, which the command gives it when it starts the guest
|
||||
demo = [
|
||||
./dev/plasma-vm.nix
|
||||
{
|
||||
komorebi.plasmaVm = {
|
||||
session = true;
|
||||
display = false;
|
||||
};
|
||||
}
|
||||
./dev/run-kde.nix
|
||||
({ lib, ... }: { networking.hostName = lib.mkOverride 40 "komorebi-demo"; })
|
||||
];
|
||||
in
|
||||
{
|
||||
plasma-vm = onMac [ ./dev/plasma-vm.nix ];
|
||||
plasma-vm-session = onMac session;
|
||||
plasma-utm = onMac [ ./dev/plasma-utm.nix ];
|
||||
|
||||
plasma-vm-x86_64 = onLinux "x86_64-linux" [ ./dev/plasma-vm.nix ];
|
||||
plasma-vm-session-x86_64 = onLinux "x86_64-linux" session;
|
||||
plasma-vm-aarch64 = onLinux "aarch64-linux" [ ./dev/plasma-vm.nix ];
|
||||
plasma-vm-session-aarch64 = onLinux "aarch64-linux" session;
|
||||
|
||||
run-kde-x86_64 = onLinux "x86_64-linux" demo;
|
||||
run-kde-aarch64 = onLinux "aarch64-linux" demo;
|
||||
};
|
||||
};
|
||||
}
|
||||
Reference in new issue
Block a user