Qyriad/dynix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: Qyriad:6e6948c666e0b8e9ce5ea39d69884c80a597d4ce
Branches Tags
Qyriad:main
..
compare: Qyriad:d76474c5240450bd9c4ceae9993941b900d3d23d
Branches Tags
Qyriad:main

No commits in common. "6e6948c666e0b8e9ce5ea39d69884c80a597d4ce" and "d76474c5240450bd9c4ceae9993941b900d3d23d" have entirely different histories.
6e6948c666 ... d76474c524

21 changed files with 438 additions and 364 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.editorconfig
View file

@ -1,3 +1,5 @@
root = true
[*] [*]
end_of_line = lf end_of_line = lf
insert_final_newline = true insert_final_newline = true

119
README.md
View file

@ -1,119 +0,0 @@
# Dynix — WIP modular dynamicism for NixOS systems
Dynix is a prototype for modifying an append-only NixOS configuration, and dynamically
## Running the tests
There are currently 3 implemented dynamicism modules: `gotosocial`, `harmonia`, and `distccd`.
Each test uses the [NixOS test infrastructure](https://nixos.org/manual/nixos/unstable/#sec-nixos-tests) to:
1. Setup a virtual machine running NixOS
2. Configure the VM's NixOS to run a given service, with certain settings
3. Verify that the running service is using those settings
4. Use Dynix to change a setting for that service
5. Verify that the running service is now using the new setting
The tests themselves can be run with Nix.
To run the test for, e.g., Gotosocial, you can run:
```bash
$ nix --experimental-features "nix-command flakes pipe-operator pipe-operators" build .#default.tests.gotosocial
```
The experimental [piping operator](https://github.com/NixOS/rfcs/pull/148) is currently used in Dynix, so you must enable the experimental feature `pipe-operator` for Lix or `pipe-operators` for CppNix (you can add both to cover both Nix implementations); flakes are used for locked inputs.
To run a test with fewer experimental features, and without locked inputs, you can use the old CLI:
```bash
$ nix-build --experimental-features "pipe-operator pipe-operators" -A tests.gotosocial
```
All the tests at once can be run with:
```bash
$ nix build --experimental-features "nix-command flakes pipe-operator pipe-operators" .#default.allTests
```
## Gotosocial
This example, implemented in [./modules/dynamicism/gotosocial.nix](./modules/dynamicism/gotosocial.nix), is tested in [./tests/gotosocial](./tests/gotosocial).
The test sets up a VM using NixOS's `services.gotosocial` module with the following *static* [configuration](./tests/gotosocial/configuration.nix):
```nix
{
services.gotosocial = {
enable = true;
setupPostgresqlDB = true;
settings = {
application-name = "gotosocial-for-machine";
host = "gotosocial-machine.local";
};
};
}
```
The automated [test script](./tests/gotosocial/test-script.py):
1. Asserts that that the above *static* configuration is in effect (by extracting the configuration from the running Gotosocial process)
2. Runs `dynix append "services.gotosocial.settings.application-name" "yay!"`, which modifies the append-only configuration file `/etc/nixos/dynamic.nix` in the VM filesystem
3. Runs the dynamic activation script built by `(import <nixpkgs/nixos>).config.dynamicism.applyDynamicConfiguration { }`, which *applies* the dynamic configuration
4. Asserts that the dynamically configured `application-name` is in effect
5. Runs `nixos-rebuild switch` to re-apply the *static* configuration
6. Asserts that the dynamic configuration is *no longer* in effect, and we are back to the static configuration
## Harmonia
This example, implemented in [./modules/dynamicism/harmonia.nix](./modules/dynamicism/harmonia.nix), is tested in [./tests/harmonia](./tests/harmonia).
The test sets up a VM using NixOS's `services.harmonia` module with the following *static* [configuration](./tests/harmonia/configuration.nix)
```nix
{
services.harmonia = {
enable = true;
settings = {
workers = 4;
max_connection_rate = 256;
};
};
}
```
The VM [test script](./tests/harmonia/test-script.py):
1. Asserts that the above *static* configuration is in effect (by extracting the configuration from the running Harmonia process)
2. Runs `dynix append "services.harmonia.settings.workers" 20`, to modify the append-only configuration file `/etc/nixos/dynamic.nix` in the VM filesystem
3. Runs the dynamic activation script built by `(import <nixpkgs/nixos>).config.dynamicism.applyDynamicConfiguration { }`, to *apply* the dynamic configuration
4. Asserts that the dynamically configured `workers` is in effect
5. Runs `dynix append "services.harmonia.settings.max_connection_rate" 100`
6. Runs the dynamic activation script
7. Asserts that *both* `max_connection_rate` and `workers` dynamic values are in effect
8. Runs `nixos-rebuild switch` to re-apply the *static* configuration
9. Asserts that the dynamic configuration is *no longer* in effect, and we are back to the static configuration
## Distccd
This example, implemented in [./modules/dynamicism/distccd.nix](./modules/dynamicism/distccd.nix), is tested in [./tests/distccd](./tests/distccd).
The test sets up a VM using NixOS's `services.distccd` module with the following *static* [configuration](./tests/distccd/configuration.nix):
```nix
{
services.distccd = {
jobTimeout = 900;
maxJobs = 12;
logLevel = "warning";
};
}
```
The VM [test script](./tests/distccd/test-script.py):
1. Asserts that the above *static* configuration is in effect (by extracting the configuration from the running Distccd process)
2. Runs `dynix append "services.distccd.maxJobs" 4`, to modify the append-only configuration file `/etc/nixos/dynamic.nix` in the VM filesystem
3. Runs the dynamic activation script built by `(import <nixpkgs/nixos>).config.dynamicism.applyDynamicConfiguration { }`, to *apply* the dynamic configuration
4. Asserts that the dynamically configured `maxJobs` is in effect
5. Runs `dynix append "services.distccd.logLevel" "error"`
6. Runs the dynamic activation script
7. Asserts that *both* `maxJobs` and `logLevel` dynamic values are in effect
8. Runs `nixos-rebuild switch` to re-apply the *static* configuration
9. Asserts that the dynamic configuration is *no longer* in effect, and we are back to the static configuration.

28
default.nix
View file

@ -1,18 +1,18 @@
{ {
pkgs ? import <nixpkgs> { }, pkgs ? import <nixpkgs> { },
qpkgs ? let qpkgs ? let
src = fetchTarball "https://github.com/Qyriad/nur-packages/archive/main.tar.gz"; src = fetchTree (builtins.parseFlakeRef "github:Qyriad/nur-packages");
in import src { inherit pkgs; }, in import src { inherit pkgs; },
}: let }: let
inherit (qpkgs) lib; inherit (qpkgs) lib;
dynix = qpkgs.callPackage ./package.nix { } dynix = qpkgs.callPackage ./package.nix { }
|> qpkgs.stdlib.mkStdenvPretty; |> qpkgs.stdlib.mkStdenvPretty;
byStdenv = lib.mapAttrs (stdenvName: stdenv: let byStdenv = lib.mapAttrs (stdenvName: stdenv: let
withStdenv = dynix.override { clangStdenv = stdenv; }; withStdenv = dynix.override { inherit stdenv; };
dynix' = withStdenv.overrideAttrs (prev: { dynix' = withStdenv.overrideAttrs (prev: {
pname = "${prev.pname}-${stdenvName}"; pname = "${prev.pname}-${stdenvName}";
}); });
in dynix') qpkgs.validStdenvs; in dynix') qpkgs.validStdenvs;
in dynix.overrideAttrs (prev: lib.recursiveUpdate prev { in dynix.overrideAttrs (prev: lib.recursiveUpdate prev {
passthru = { inherit byStdenv; }; passthru = { inherit byStdenv; };
}) })

94
flake.nix
View file

@ -1,55 +1,51 @@
{ {
inputs = { inputs = {
nixpkgs = { nixpkgs = {
url = "github:NixOS/nixpkgs/nixpkgs-unstable"; url = "github:NixOS/nixpkgs/nixpkgs-unstable";
flake = false; flake = false;
}; };
flake-utils.url = "github:numtide/flake-utils"; flake-utils.url = "github:numtide/flake-utils";
fenix = { fenix = {
url = "github:nix-community/fenix"; url = "github:nix-community/fenix";
flake = false; flake = false;
}; };
qyriad-nur = { qyriad-nur = {
url = "github:Qyriad/nur-packages"; url = "github:Qyriad/nur-packages";
flake = false; flake = false;
}; };
}; };
outputs = { outputs = {
self, self,
nixpkgs, nixpkgs,
flake-utils, flake-utils,
fenix, fenix,
qyriad-nur, qyriad-nur,
}: flake-utils.lib.eachDefaultSystem (system: let }: flake-utils.lib.eachDefaultSystem (system: let
pkgs = import nixpkgs { inherit system; }; pkgs = import nixpkgs { inherit system; };
qpkgs = import qyriad-nur { inherit pkgs; }; qpkgs = import qyriad-nur { inherit pkgs; };
inherit (qpkgs) lib; inherit (qpkgs) lib;
fenixLib = import fenix { inherit pkgs; }; fenixLib = import fenix { inherit pkgs; };
dynix = import ./default.nix { inherit pkgs qpkgs; }; dynix = import ./default.nix { inherit pkgs qpkgs; };
extraVersions = lib.mapAttrs' (stdenvName: value: { extraVersions = lib.mapAttrs' (stdenvName: value: {
name = "${stdenvName}-dynix"; name = "${stdenvName}-dynix";
inherit value; inherit value;
}) dynix.byStdenv; }) dynix.byStdenv;
devShell = import ./shell.nix { inherit pkgs qpkgs dynix fenixLib; }; devShell = import ./shell.nix { inherit pkgs qpkgs dynix fenixLib; };
extraDevShells = lib.mapAttrs' (stdenvName: value: { extraDevShells = lib.mapAttrs' (stdenvName: value: {
name = "${stdenvName}-dynix"; name = "${stdenvName}-dynix";
inherit value; inherit value;
}) dynix.byStdenv; }) dynix.byStdenv;
in { in {
packages = extraVersions // { packages = extraVersions // {
default = dynix; default = dynix;
inherit dynix; inherit dynix;
}; };
devShells = extraDevShells // { devShells = extraDevShells // {
default = devShell; default = devShell;
}; };
});
checks = self.packages.${system}.default.tests // {
default = self.packages.${system}.default.allTests;
};
});
} }

1
modules/dynamicism/dynamicism.nix
View file

@ -11,6 +11,7 @@ let
inherit (import ./lib.nix { inherit lib; }) inherit (import ./lib.nix { inherit lib; })
typeCheck typeCheck
convenientAttrPath
executablePathInStore executablePathInStore
concatFoldl concatFoldl
recUpdateFoldl recUpdateFoldl

252
package.nix
View file

@ -1,160 +1,160 @@
{ {
lib, lib,
clangStdenv, clangStdenv,
callPackage, callPackage,
linkFarm, linkFarm,
rustHooks, rustHooks,
rustPackages, rustPackages,
versionCheckHook, versionCheckHook,
}: lib.callWith' rustPackages ({ }: lib.callWith' rustPackages ({
rustPlatform, rustPlatform,
cargo, cargo,
}: let }: let
stdenv = clangStdenv; stdenv = clangStdenv;
cargoToml = lib.importTOML ./Cargo.toml; cargoToml = lib.importTOML ./Cargo.toml;
cargoPackage = cargoToml.package; cargoPackage = cargoToml.package;
in stdenv.mkDerivation (finalAttrs: let in stdenv.mkDerivation (finalAttrs: let
self = finalAttrs.finalPackage; self = finalAttrs.finalPackage;
in { in {
pname = cargoPackage.name; pname = cargoPackage.name;
version = cargoPackage.version; version = cargoPackage.version;
strictDeps = true; strictDeps = true;
__structuredAttrs = true; __structuredAttrs = true;
outputs = [ "out" "modules" ]; outputs = [ "out" "modules" ];
doCheck = true; doCheck = true;
doInstallCheck = true; doInstallCheck = true;
phases = [ "unpackPhase" "patchPhase" "installPhase" ]; phases = [ "unpackPhase" "patchPhase" "installPhase" ];
src = linkFarm "dynix-source" { src = linkFarm "dynix-source" {
inherit (self) dynixCommand dynixModules; inherit (self) dynixCommand dynixModules;
}; };
installPhase = '' installPhase = lib.dedent ''
runHook preInstall runHook preInstall
mkdir -p "$out" mkdir -p "$out"
cp -r --reflink=auto "$dynixCommand/"* "$out/" cp -r --reflink=auto "$dynixCommand/"* "$out/"
mkdir -p "$modules" mkdir -p "$modules"
cp -r --reflink=auto "$dynixModules/"* "$modules/" cp -r --reflink=auto "$dynixModules/"* "$modules/"
runHook postInstall runHook postInstall
''; '';
# #
# SUB-DERIVATONS # SUB-DERIVATONS
# #
dynixCommand = stdenv.mkDerivation (finalAttrs: let dynixCommand = stdenv.mkDerivation (finalAttrs: let
commandSelf = finalAttrs.finalPackage; commandSelf = finalAttrs.finalPackage;
in { in {
pname = "${self.pname}-command"; pname = "${self.pname}-command";
inherit (self) version; inherit (self) version;
inherit (self) strictDeps __structuredAttrs; inherit (self) strictDeps __structuredAttrs;
inherit (self) doCheck doInstallCheck; inherit (self) doCheck doInstallCheck;
src = lib.fileset.toSource { src = lib.fileset.toSource {
root = ./.; root = ./.;
fileset = lib.fileset.unions [ fileset = lib.fileset.unions [
./Cargo.toml ./Cargo.toml
./Cargo.lock ./Cargo.lock
./src ./src
]; ];
}; };
cargoDeps = rustPlatform.importCargoLock { cargoDeps = rustPlatform.importCargoLock {
lockFile = ./Cargo.lock; lockFile = ./Cargo.lock;
}; };
nativeBuildInputs = rustHooks.asList ++ [ nativeBuildInputs = rustHooks.asList ++ [
cargo cargo
]; ];
nativeInstallCheckInputs = [ nativeInstallCheckInputs = [
versionCheckHook versionCheckHook
]; ];
meta = { meta = {
mainProgram = "dynix"; mainProgram = "dynix";
}; };
}); });
dynixModules = stdenv.mkDerivation (finalAttrs: let dynixModules = stdenv.mkDerivation (finalAttrs: let
modulesSelf = finalAttrs.finalPackage; modulesSelf = finalAttrs.finalPackage;
in { in {
pname = "${self.pname}-modules"; pname = "${self.pname}-modules";
inherit (self) version; inherit (self) version;
inherit (self) strictDeps __structuredAttrs; inherit (self) strictDeps __structuredAttrs;
inherit (self) doCheck doInstallCheck; inherit (self) doCheck doInstallCheck;
src = lib.fileset.toSource { src = lib.fileset.toSource {
root = ./modules/dynamicism; root = ./modules/dynamicism;
fileset = lib.fileset.unions [ fileset = lib.fileset.unions [
./modules/dynamicism ./modules/dynamicism
]; ];
}; };
phases = [ "unpackPhase" "patchPhase" "installPhase" ]; phases = [ "unpackPhase" "patchPhase" "installPhase" ];
modulesOut = "${placeholder "out"}/share/nixos/modules/dynix"; modulesOut = "${placeholder "out"}/share/nixos/modules/dynix";
installPhase = lib.dedent '' installPhase = lib.dedent ''
runHook preInstall runHook preInstall
mkdir -p "$modulesOut" mkdir -p "$modulesOut"
cp -r "$src/"* "$modulesOut/" cp -r "$src/"* "$modulesOut/"
runHook postInstall runHook postInstall
''; '';
}); });
# #
# ---------------------------------------------------------------------------- # ----------------------------------------------------------------------------
# #
passthru.mkDevShell = { passthru.mkDevShell = {
path, path,
mkShell, mkShell,
python3Packages, python3Packages,
fenixToolchain, fenixToolchain,
}: let }: let
mkShell' = mkShell.override { inherit stdenv; }; mkShell' = mkShell.override { inherit stdenv; };
pyEnv = python3Packages.python.withPackages (p: [ p.beartype ]); pyEnv = python3Packages.python.withPackages (p: [ p.beartype ]);
in mkShell' { in mkShell' {
name = "devshell-for-${self.name}"; name = "devshell-for-${self.name}";
inputsFrom = [ self ]; inputsFrom = [ self ];
packages = [ packages = [
pyEnv pyEnv
stdenv.cc stdenv.cc
fenixToolchain fenixToolchain
]; ];
env.PYTHONPATH = [ env.PYTHONPATH = [
"${pyEnv}/${pyEnv.sitePackages}" "${pyEnv}/${pyEnv.sitePackages}"
# Cursed. # Cursed.
"${path}/nixos/lib/test-driver/src" "${path}/nixos/lib/test-driver/src"
] |> lib.concatStringsSep ":"; ] |> lib.concatStringsSep ":";
}; };
passthru.modulesPath = self.modules + "/share/nixos/modules"; passthru.modulesPath = self.modules + "/share/nixos/modules";
passthru.dynix = self.modulesPath + "/dynix"; passthru.dynix = self.modulesPath + "/dynix";
passthru.tests = lib.fix (callPackage ./tests { passthru.tests = lib.fix (callPackage ./tests {
dynix = self; dynix = self;
}).packages; }).packages;
passthru.allTests = linkFarm "dynix-all-tests" self.tests; passthru.allTests = linkFarm "dynix-all-tests" self.tests;
meta = { meta = {
longDescription = lib.dedent '' longDescription = lib.dedent ''
Default output contains the Rust binary. Default output contains the Rust binary.
The `modules` output contains the modules prefixed under `/share/nixos/modules/dynix`. The `modules` output contains the modules prefixed under `/share/nixos/modules/dynix`.
The `dynix` passthru attr is a shortcut for the modules output *with* the modules prefix, The `dynix` passthru attr is a shortcut for the modules output *with* the modules prefix,
and thus `dynix.dynix` can be passed directly to `imports = [`. and thus `dynix.dynix` can be passed directly to `imports = [`.
''; '';
mainProgram = "dynix"; mainProgram = "dynix";
outputsToInstall = [ "out" "modules" ]; outputsToInstall = [ "out" "modules" ];
}; };
})) }))

38
shell.nix
View file

@ -1,26 +1,26 @@
{ {
pkgs ? import <nixpkgs> { pkgs ? import <nixpkgs> {
config = { config = {
checkMeta = true; checkMeta = true;
allowAliases = false; allowAliases = false;
}; };
}, },
qpkgs ? let qpkgs ? let
src = fetchTarball "https://github.com/Qyriad/nur-packages/archive/main.tar.gz"; src = fetchTarball "https://github.com/Qyriad/nur-packages/archive/main.tar.gz";
in import src { inherit pkgs; }, in import src { inherit pkgs; },
dynix ? import ./default.nix { inherit pkgs qpkgs; }, dynix ? import ./default.nix { inherit pkgs qpkgs; },
fenixLib ? let fenixLib ? let
src = fetchTarball "https://github.com/nix-community/fenix/archive/main.tar.gz"; src = fetchTarball "https://github.com/nix-community/fenix/archive/main.tar.gz";
in import src { inherit pkgs; }, in import src { inherit pkgs; },
fenixToolchain ? fenixLib.latest.toolchain, fenixToolchain ? fenixLib.latest.toolchain,
}: let }: let
inherit (pkgs) lib; inherit (pkgs) lib;
mkDevShell = dynix: qpkgs.callPackage dynix.mkDevShell { inherit fenixToolchain; }; mkDevShell = dynix: qpkgs.callPackage dynix.mkDevShell { inherit fenixToolchain; };
devShell = mkDevShell dynix; devShell = mkDevShell dynix;
byStdenv = lib.mapAttrs (lib.const mkDevShell) dynix.byStdenv; byStdenv = lib.mapAttrs (lib.const mkDevShell) dynix.byStdenv;
in devShell.overrideAttrs (prev: { in devShell.overrideAttrs (prev: {
passthru = { inherit byStdenv; }; passthru = { inherit byStdenv; };
}) })

2
tests/default.nix
View file

@ -1,7 +1,7 @@
{ {
pkgs ? import <nixpkgs> { }, pkgs ? import <nixpkgs> { },
qpkgs ? let qpkgs ? let
src = fetchTarball "https://github.com/Qyriad/nur-packages/archive/main.tar.gz"; src = fetchTree (builtins.parseFlakeRef "github:Qyriad/nur-packages");
in import src { inherit pkgs; }, in import src { inherit pkgs; },
callPackage ? qpkgs.callPackage, callPackage ? qpkgs.callPackage,
lib ? qpkgs.lib, lib ? qpkgs.lib,

2
tests/distccd/configuration.nix
View file

@ -1,11 +1,9 @@
{ ... }: { ... }:
{ {
services.distccd = { services.distccd = {
enable = true; enable = true;
jobTimeout = 900; jobTimeout = 900;
maxJobs = 12; maxJobs = 12;
logLevel = "warning";
nice = -10; nice = -10;
}; };

39
tests/distccd/test-script.py
View file

@ -1,5 +1,7 @@
import argparse import argparse
import functools import functools
#from pathlib import Path
#from pprint import pformat
import shlex import shlex
import textwrap import textwrap
from typing import Any, cast, TYPE_CHECKING from typing import Any, cast, TYPE_CHECKING
@ -62,6 +64,7 @@ def get_cli_args() -> argparse.Namespace:
machine.log(f"{cmdline_args=}") machine.log(f"{cmdline_args=}")
print(f"{cmdline_args=}") print(f"{cmdline_args=}")
#return shlex.join(cmdline_args[1:])
args, rest = parser.parse_known_args(cmdline_args) args, rest = parser.parse_known_args(cmdline_args)
return args return args
@ -74,7 +77,12 @@ def dynix_append(option: str, value: Any):
@beartype @beartype
def do_apply(): def do_apply():
expr = textwrap.dedent(""" expr = textwrap.dedent("""
(import <nixpkgs/nixos> { }).config.dynamicism.applyDynamicConfiguration { } let
nixos = import <nixpkgs/nixos> { };
in nixos.config.dynamicism.applyDynamicConfiguration {
baseConfiguration = /etc/nixos/configuration.nix;
newConfiguration = /etc/nixos/dynamic.nix;
}
""").strip() """).strip()
machine.succeed(rf""" machine.succeed(rf"""
@ -82,13 +90,12 @@ def do_apply():
""".strip()) """.strip())
machine.wait_for_unit("default.target") machine.wait_for_unit("default.target")
machine.wait_for_unit("install-dynix.service") assert "lix" in machine.succeed("nix --version").lower()
machine.log("INIT")
dynix_out = machine.succeed("dynix --version")
assert "dynix" in dynix_out, f"dynix not in {dynix_out=}"
# Config should have our initial values. # Config should have our initial values.
args = get_cli_args() args = get_cli_args()
#assert '--jobs 12' in args, f'--jobs 12 not in {args=}'
assert args.jobs == 12, f'{args.jobs=} != 12' assert args.jobs == 12, f'{args.jobs=} != 12'
assert args.job_lifetime == 900, f'{args.job_lifetime} != 900' assert args.job_lifetime == 900, f'{args.job_lifetime} != 900'
assert args.log_level == 'warning', f'{args.log_level=} != warning' assert args.log_level == 'warning', f'{args.log_level=} != warning'
@ -98,16 +105,17 @@ with machine.nested("must succeed: initial nixos-rebuild switch"):
# Config should not have changed. # Config should not have changed.
args = get_cli_args() args = get_cli_args()
assert args.jobs == 12, f'{args.jobs=} != 12' #machine.log(f"config.toml after first rebuild: {indent(pformat(args))}")
assert args.job_lifetime == 900, f'{args.job_lifetime} != 900' #assert int(args['workers']) == 4, f"{args['workers']=} != 4"
assert args.log_level == 'warning', f'{args.log_level=} != warning' #assert int(args['max_connection_rate']) == 256, f"{args['max_connection_rate']=} != 256"
#
new_jobs = 4 new_jobs = 4
dynix_append("services.distccd.maxJobs", new_jobs) dynix_append("services.distccd.maxJobs", new_jobs)
do_apply() do_apply()
# Only jobs should have changed. The others should still be default.
args = get_cli_args() args = get_cli_args()
# Only jobs should have changed. The others should still be default.
assert args.jobs == new_jobs, f'{args.jobs=} != {new_jobs=}' assert args.jobs == new_jobs, f'{args.jobs=} != {new_jobs=}'
assert args.job_lifetime == 900, f'{args.job_lifetime} != 900' assert args.job_lifetime == 900, f'{args.job_lifetime} != 900'
assert args.log_level == 'warning', f'{args.log_level=} != warning' assert args.log_level == 'warning', f'{args.log_level=} != warning'
@ -117,13 +125,6 @@ dynix_append("services.distccd.logLevel", f'"{new_log_level}"')
do_apply() do_apply()
args = get_cli_args() args = get_cli_args()
assert args.jobs == new_jobs, f'{args.jobs=} != {new_jobs=}' #assert args.jobs == new_jobs, f'{args.jobs=} != {new_jobs=}'
assert args.job_lifetime == 900, f'{args.job_lifetime} != 900' #assert args.job_lifetime == 900, f'{args.job_lifetime} != 900'
assert args.log_level == new_log_level, f'{args.log_level=} != {new_log_level=}' assert args.log_level == new_log_level, f'{args.log_level=} != {new_log_level=}'
# And this should set everything back.
machine.succeed("env PAGER= nixos-rebuild switch --log-format raw-with-logs --fallback")
args = get_cli_args()
assert args.jobs == 12, f'{args.jobs=} != 12'
assert args.job_lifetime == 900, f'{args.job_lifetime} != 900'
assert args.log_level == 'warning', f'{args.log_level=} != warning'

7
tests/gotosocial/configuration-package.nix Normal file
View file

@ -0,0 +1,7 @@
{
runCommand,
}: runCommand "tests-gotosocial-configuration-dot-nix" {
} ''
set -euo pipefail
install -Dm a=r ${./configuration.nix} "$out/share/nixos/configuration.nix"
''

7
tests/gotosocial/default.nix Normal file
View file

@ -0,0 +1,7 @@
/**
* Convenience shortcut for running this test from the command-line.
* Normally this test is initialized from /tests/default.nix.
*/
{
pkgs ? import <nixpkgs> { },
}: pkgs.testers.runNixOSTest ./test.nix

7
tests/gotosocial/hardware-configuration.nix Normal file
View file

@ -0,0 +1,7 @@
/** Dummy hardware configuration.
* Will be replaced with the real one in the test VM.
*/
{ ... }:
{
}

14
tests/gotosocial/test-script.py
View file

@ -61,7 +61,12 @@ def dynix_append(option: str, value: str):
@beartype @beartype
def do_apply(): def do_apply():
expr = textwrap.dedent(""" expr = textwrap.dedent("""
(import <nixpkgs/nixos> { }).config.dynamicism.applyDynamicConfiguration { } let
nixos = import <nixpkgs/nixos> { };
in nixos.config.dynamicism.applyDynamicConfiguration {
baseConfiguration = /etc/nixos/configuration.nix;
newConfiguration = /etc/nixos/dynamic.nix;
}
""").strip() """).strip()
machine.succeed(rf""" machine.succeed(rf"""
@ -70,6 +75,7 @@ def do_apply():
machine.wait_for_unit("default.target") machine.wait_for_unit("default.target")
assert "lix" in machine.succeed("nix --version").lower()
machine.wait_for_unit("install-dynix.service") machine.wait_for_unit("install-dynix.service")
dynix_out = machine.succeed("dynix --version") dynix_out = machine.succeed("dynix --version")
@ -88,12 +94,6 @@ except StopIteration:
raise AssertionError(f"no 'application-name:' found in config file: {textwrap.indent(config_text, " ")}") raise AssertionError(f"no 'application-name:' found in config file: {textwrap.indent(config_text, " ")}")
assert "gotosocial-for-machine" in application_name, f"'gotosocial-for-machine' should be in {application_name=}" assert "gotosocial-for-machine" in application_name, f"'gotosocial-for-machine' should be in {application_name=}"
try:
host = next(line for line in lines if line.startswith("host:"))
except StopIteration:
raise AssertionError(f"no 'host:' found in config file: {textwrap.indent(config_text, " ")}")
assert "gotosocial-machine" in host, f"'gotosocial-machine' should be in {host=}"
new_app_name = "yay!" new_app_name = "yay!"
dynix_append("services.gotosocial.settings.application-name", f'"{new_app_name}"') dynix_append("services.gotosocial.settings.application-name", f'"{new_app_name}"')
do_apply() do_apply()

16
tests/harmonia/configuration.nix
View file

@ -1,6 +1,20 @@
{ ... }: { lib, modulesPath, ... }:
let
moduleList = import "${modulesPath}/module-list.nix";
dynixFromSearchPath = let
res = builtins.tryEval <dynix>;
in lib.optional res.success res.value;
in
{ {
imports = [
#"${modulesPath}/testing/test-instrumentation.nix"
#./hardware-configuration.nix
] ++ lib.concatLists [
#dynixFromSearchPath
moduleList
];
dynamicism.for.harmonia.enable = true; dynamicism.for.harmonia.enable = true;
services.harmonia = { services.harmonia = {
enable = true; enable = true;

4
tests/harmonia/hardware-configuration.nix Normal file
View file

@ -0,0 +1,4 @@
{ ... }:
{
}

23
tests/harmonia/test-script.py
View file

@ -1,5 +1,6 @@
import functools import functools
from pathlib import Path from pathlib import Path
from pprint import pformat
import shlex import shlex
import textwrap import textwrap
import tomllib import tomllib
@ -63,7 +64,12 @@ def dynix_append(option: str, value: Any):
@beartype @beartype
def do_apply(): def do_apply():
expr = textwrap.dedent(""" expr = textwrap.dedent("""
(import <nixpkgs/nixos> { }).config.dynamicism.applyDynamicConfiguration { } let
nixos = import <nixpkgs/nixos> { };
in nixos.config.dynamicism.applyDynamicConfiguration {
baseConfiguration = /etc/nixos/configuration.nix;
newConfiguration = /etc/nixos/dynamic.nix;
}
""").strip() """).strip()
machine.succeed(rf""" machine.succeed(rf"""
@ -71,13 +77,12 @@ def do_apply():
""".strip()) """.strip())
machine.wait_for_unit("default.target") machine.wait_for_unit("default.target")
machine.wait_for_unit("install-dynix.service") assert "lix" in machine.succeed("nix --version").lower()
machine.log("INIT")
dynix_out = machine.succeed("dynix --version")
assert "dynix" in dynix_out, f"dynix not in {dynix_out=}"
# Config should have our initial values. # Config should have our initial values.
config_toml = get_config_file() config_toml = get_config_file()
machine.log(f"config.toml BEFORE first rebuild (initial): {indent(pformat(config_toml))}")
assert int(config_toml['workers']) == 4, f"{config_toml['workers']=} != 4" assert int(config_toml['workers']) == 4, f"{config_toml['workers']=} != 4"
assert int(config_toml['max_connection_rate']) == 256, f"{config_toml['max_connection_rate']=} != 256" assert int(config_toml['max_connection_rate']) == 256, f"{config_toml['max_connection_rate']=} != 256"
@ -86,6 +91,7 @@ with machine.nested("must succeed: initial nixos-rebuild switch"):
# Config should not have changed. # Config should not have changed.
config_toml = get_config_file() config_toml = get_config_file()
machine.log(f"config.toml after first rebuild: {indent(pformat(config_toml))}")
assert int(config_toml['workers']) == 4, f"{config_toml['workers']=} != 4" assert int(config_toml['workers']) == 4, f"{config_toml['workers']=} != 4"
assert int(config_toml['max_connection_rate']) == 256, f"{config_toml['max_connection_rate']=} != 256" assert int(config_toml['max_connection_rate']) == 256, f"{config_toml['max_connection_rate']=} != 256"
@ -95,6 +101,7 @@ do_apply()
# Workers, but not max connection rate, should have changed. # Workers, but not max connection rate, should have changed.
config_toml = get_config_file() config_toml = get_config_file()
machine.log(f"config.toml after DYNAMIC ACTIVATION: {indent(pformat(config_toml))}")
assert int(config_toml['workers']) == new_workers, f"{config_toml['workers']=} != {new_workers}" assert int(config_toml['workers']) == new_workers, f"{config_toml['workers']=} != {new_workers}"
assert int(config_toml['max_connection_rate']) == 256, f"{config_toml['max_connection_rate']=} != 256" assert int(config_toml['max_connection_rate']) == 256, f"{config_toml['max_connection_rate']=} != 256"
@ -102,14 +109,16 @@ new_max_connection_rate = 100
dynix_append("services.harmonia.settings.max_connection_rate", new_max_connection_rate) dynix_append("services.harmonia.settings.max_connection_rate", new_max_connection_rate)
do_apply() do_apply()
# Max connection rate should have changed, and workers should be the same as before. # Max connection rate should have changed, but workers should have reverted.
config_toml = get_config_file() config_toml = get_config_file()
machine.log(f"config_toml after SECOND dynamic activation: {indent(pformat(config_toml))}")
assert int(config_toml['max_connection_rate']) == new_max_connection_rate, f"{config_toml['max_connection_rate']=} != {new_max_connection_rate}" assert int(config_toml['max_connection_rate']) == new_max_connection_rate, f"{config_toml['max_connection_rate']=} != {new_max_connection_rate}"
assert int(config_toml['workers']) == new_workers, f"{config_toml['workers']=} != {new_workers}"
# And this should set everything back. # And this should set everything back.
machine.succeed("env PAGER= nixos-rebuild switch --log-format raw-with-logs --fallback") machine.succeed("env PAGER= nixos-rebuild switch --log-format raw-with-logs --fallback")
machine.systemctl("restart harmonia.service")
machine.wait_for_unit("harmonia.service") machine.wait_for_unit("harmonia.service")
config_toml = get_config_file() config_toml = get_config_file()
machine.log(f"config_toml after NORMAL activation: {indent(pformat(config_toml))}")
assert int(config_toml['max_connection_rate']) == 256, f'{config_toml["max_connection_rate"]=} != 256' assert int(config_toml['max_connection_rate']) == 256, f'{config_toml["max_connection_rate"]=} != 256'
assert int(config_toml['workers']) == 4, f'{config_toml["workers"]=} != 4' assert int(config_toml['workers']) == 4, f'{config_toml["workers"]=} != 4'

67
tests/tzupdate/configuration.nix Normal file
View file

@ -0,0 +1,67 @@
{ pkgs, lib, config, modulesPath, ... }:
let
name = config.networking.hostName;
moduleList = import "${modulesPath}/module-list.nix";
dynixFromSearchPath = let
res = builtins.tryEval <dynix>;
in lib.optional res.success res.value;
in
{
imports = [
"${modulesPath}/testing/test-instrumentation.nix"
./hardware-configuration.nix
] ++ lib.concatLists [
moduleList
dynixFromSearchPath
];
dynamicism.for.tzupdate.enable = true;
services.tzupdate = {
enable = true;
};
system.switch.enable = true;
documentation.enable = false;
networking.hostName = "tzupdate-machine";
boot.loader.grub = {
enable = true;
device = "/dev/vda";
forceInstall = true;
};
nix = {
package = pkgs.lixPackageSets.latest.lix;
nixPath = [
"nixpkgs=${pkgs.path}"
"/nix/var/nix/profiles/per-user/root/profile/share/nixos/modules"
];
settings = {
experimental-features = [ "nix-command" "pipe-operator" ];
substituters = lib.mkForce [ ];
hashed-mirrors = null;
connect-timeout = 1;
# For my debugging purposes.
show-trace = true;
};
};
environment.pathsToLink = [ "/share" ];
environment.extraOutputsToInstall = [ "modules" ];
environment.variables = {
"NIXOS_CONFIG" = "/etc/nixos/configuration.nix";
};
environment.shellAliases = {
ls = "eza --long --header --group --group-directories-first --classify --binary";
};
environment.systemPackages = with pkgs; [
eza
fd
ripgrep
];
}

4
tests/tzupdate/hardware-configuration.nix Normal file
View file

@ -0,0 +1,4 @@
{ ... }:
{
}

52
tests/tzupdate/test-script.py Normal file
View file

@ -0,0 +1,52 @@
#from pathlib import Path
#import shlex
#import textwrap
from typing import cast, TYPE_CHECKING
from beartype import beartype
from test_driver.machine import Machine
from test_driver.errors import RequestedAssertionFailed
if TYPE_CHECKING:
global machine
machine = cast(Machine, ...)
assert machine.shell is not None
ls = "eza -lah --color=always --group-directories-first"
@beartype
def run_log(machine: Machine, *commands: str, timeout: int | None = 60) -> str:
output = ""
for command in commands:
with machine.nested(f"must succeed: {command}"):
(status, out) = machine.execute(f"{command} | tee /dev/stderr", timeout=timeout)
if status != 0:
machine.log(f"output: {out}")
raise RequestedAssertionFailed(
f"command `{command}` failed (exit code {status})",
)
output += out
return output
machine.wait_for_unit("default.target")
assert "lix" in machine.succeed("nix --version").lower()
machine.log("INIT")
machine.succeed("nixos-generate-config")
machine.succeed("mkdir -vp /etc/nixos")
# Dereference is required since that configuration.nix is probably a symlink to the store.
machine.succeed("cp -rv --dereference /run/current-system/sw/share/nixos/configuration.nix /etc/nixos/")
machine.succeed("env PAGER= nixos-rebuild switch --log-format raw-with-logs --fallback")
@beartype
def get_interval() -> str:
prop = machine.get_unit_property("tzupdate.timer", "OnCalendar")
print(f"{prop=}")
return prop
get_interval()

24
tests/tzupdate/test.nix Normal file
View file

@ -0,0 +1,24 @@
{ ... }:
{
name = "nixos-test-dynamicism-tzupdate";
extraPythonPackages = p: [
p.beartype
];
nodes.machine = { name, pkgs, ... }: {
imports = [ ./configuration.nix ];
environment.systemPackages = let
configFileTree = pkgs.runCommand "${name}-configuration-dot-nix" { } ''
set -euo pipefail
install -Dm a=r ${./configuration.nix} "$out/share/nixos/configuration.nix"
'';
in [
configFileTree
];
};
testScript = builtins.readFile ./test-script.py;
}