daemon tests for gotosocial

default.nix

@@ -9,18 +9,28 @@
   in import src { inherit pkgs; },
 }: let
   inherit (qpkgs) lib;
-  dynix = (qpkgs.callPackage ./package.nix { })
+
+  # Use LLD for faster link times.
+  defaultStdenv = pkgs.clangStdenv.override {
+    cc = pkgs.clangStdenv.cc.override {
+      bintools = pkgs.wrapBintoolsWith { inherit (pkgs.llvmPackages) bintools; };
+    };
+  };
+
+  dynix = (qpkgs.callPackage ./package.nix { clangStdenv = defaultStdenv; })
     .overrideAttrs (final: prev: {
       dynixCommand = qpkgs.stdlib.mkStdenvPretty prev.dynixCommand;
       dynixModules = qpkgs.stdlib.mkStdenvPretty prev.dynixModules;
     })
   |> qpkgs.stdlib.mkStdenvPretty;
+
   byStdenv = lib.mapAttrs (stdenvName: stdenv: let
     withStdenv = dynix.override { clangStdenv = stdenv; };
     dynix' = withStdenv.overrideAttrs (prev: {
       pname = "${prev.pname}-${stdenvName}";
     });
   in dynix') qpkgs.validStdenvs;
+
 in dynix.overrideAttrs (prev: lib.recursiveUpdate prev {
   passthru = { inherit byStdenv; };
 })

package.nix

@@ -7,23 +7,15 @@
   clangStdenv,
   callPackage,
   linkFarm,
-  llvmPackages,
   rustHooks,
   rustPackages,
   versionCheckHook,
-  wrapBintoolsWith,
+  writeScript,
 }: lib.callWith' rustPackages ({
   rustPlatform,
   cargo,
 }: let
-  # Use LLD for faster link times.
+  stdenv = clangStdenv;
-  stdenv = clangStdenv.override {
-    cc = clangStdenv.cc.override {
-      bintools = wrapBintoolsWith {
-        bintools = llvmPackages.bintools;
-      };
-    };
-  };
   cargoToml = lib.importTOML ./Cargo.toml;
   cargoPackage = cargoToml.package;
 in stdenv.mkDerivation (finalAttrs: let
@@ -46,12 +38,29 @@ in {
     cp -r --reflink=auto "$dynixCommand/"* "$out/"
     mkdir -p "$modules"
     cp -r --reflink=auto "$dynixModules/"* "$modules/"
+    install -Dm a=rx "$dynixTestingClient" "$out/libexec/dynix-testing-client.py"
   '';
 
   #
   # SUB-DERIVATONS
   #
 
+  dynixTestingClient = writeScript "dynix-testing-client.py" ''
+    #!/usr/bin/env python3
+    import socket, sys, os, json
+    try:
+        sockpath = sys.argv[1]
+    except IndexError:
+        sockpath = f"{os.environ['XDG_RUNTIME_DIR']}/dynix.sock"
+    sock = socket.socket(family=socket.AF_UNIX)
+    sock.connect(sockpath)
+    sock.sendall(sys.stdin.buffer.read())
+    sock.settimeout(20)
+    reply = json.loads(sock.recv(256).decode("utf-8"))
+    print(json.dumps(reply, indent=2))
+    sys.exit(reply["status"])
+  '';
+
   dynixCommand = stdenv.mkDerivation {
     pname = "${self.pname}-command";
     inherit (self) version;
@@ -73,6 +82,12 @@ in {
       lockFile = ./Cargo.lock;
     };
 
+    postInstall = ''
+      cargo doc --document-private-items
+      mkdir -p "$doc"
+      cp -r ./target/doc/* "$doc/"
+    '';
+
     nativeBuildInputs = rustHooks.asList ++ [
       cargo
     ];

src/daemon.rs

@@ -64,6 +64,14 @@ pub static NIXOS_REBUILD: LazyLock<&'static Path> = LazyLock::new(|| {
         .unwrap_or(Path::new("/run/current-system/sw/bin/nixos-rebuild"))
 });
 
+pub static NIX: LazyLock<&'static Path> = LazyLock::new(|| {
+    which::which("nix")
+        .inspect_err(|e| error!("couldn't find `nix` in PATH: {e}"))
+        .map(PathBuf::into_boxed_path)
+        .map(|boxed| &*Box::leak(boxed))
+        .unwrap_or(Path::new("/run/current-system/sw/bin/nix"))
+});
+
 const TIMEOUT_NEVER: Option<Duration> = None;
 
 static NEXT_TOKEN_NUMBER: AtomicUsize = AtomicUsize::new(1);
@@ -187,6 +195,7 @@ impl Daemon {
         token
     }
 
+    #[expect(dead_code)]
     fn register_with_name<S>(&mut self, fd: RawFd, kind: FdKind, name: Box<OsStr>) -> Token {
         let token = next_token();
 
@@ -360,31 +369,31 @@ const DAEMON: Token = Token(0);
 
 /// Private helpers.
 impl Daemon {
-    //fn proxy_stdio(&mut self, fd: &BorrowedFd) -> Result<(), IoError> {
+    fn proxy_stdio(&mut self, fd: &BorrowedFd) -> Result<(), IoError> {
-    //    let info = self.fd_info.get(&fd.as_raw_fd()).unwrap();
+        let info = self.fd_info.get(&fd.as_raw_fd()).unwrap();
-    //    let label = match info.kind {
+        let label = match info.kind {
-    //        FdKind::ChildStdout => "stdout",
+            FdKind::ChildStdout => "stdout",
-    //        FdKind::ChildStderr => "stderr",
+            FdKind::ChildStderr => "stderr",
-    //        other => unreachable!("child stdio cannot have kind {other:?}"),
+            other => unreachable!("child stdio cannot have kind {other:?}"),
-    //    };
+        };
-    //    // FIXME: don't use a new allocation every time.
+        // FIXME: don't use a new allocation every time.
-    //    let mut buffer: Vec<u8> = Vec::with_capacity(1024);
+        let mut buffer: Vec<u8> = Vec::with_capacity(1024);
-    //    // FIXME: handle line buffering correctly.
+        // FIXME: handle line buffering correctly.
-    //    loop {
+        loop {
-    //        let count = rustix::io::read(fd, spare_capacity(&mut buffer))
+            let count = rustix::io::read(fd, spare_capacity(&mut buffer))
-    //            .inspect_err(|e| error!("read() on child stdio fd {fd:?} failed: {e}"))?;
+                .inspect_err(|e| error!("read() on child stdio fd {fd:?} failed: {e}"))?;
-    //
+
-    //        if count == 0 {
+            if count == 0 {
-    //            break;
+                break;
-    //        }
+            }
-    //
+
-    //        for line in buffer.lines() {
+            for line in buffer.lines() {
-    //            debug!("[child {label}]: {}", line.as_bstr())
+                info!("[child {label}]: {}", line.as_bstr())
-    //        }
+            }
-    //    }
+        }
-    //
+
-    //    Ok(())
+        Ok(())
-    //}
+    }
 
     fn read_cmd(&mut self, fd: &BorrowedFd) -> Result<(), IoError> {
         // FIXME: don't use a new allocation every time.
@@ -433,25 +442,44 @@ impl Daemon {
         let new_pri = pri - 1;
         // Get next priority line.
         let opt_name = name.to_nix_decl();
-        let new_line = crate::get_next_prio_line(source_file.clone(), &opt_name, new_pri, &value)
+        let new_line = crate::get_next_prio_line(
+            source_file.clone(),
+            &opt_name,
+            new_pri,
+            &value.to_nix_source(),
+        )
         .unwrap_or_else(|e| panic!("someone is holding a reference to source.lines(): {e}"));
 
         crate::write_next_prio(source_file, new_line).unwrap_or_else(|e| todo!("{e}"));
 
         // Rebuild and switch.
         // FIXME: allow passing additional args.
-        let child = Command::new(*NIXOS_REBUILD)
+        //let child = Command::new(*NIXOS_REBUILD)
-            .arg("switch")
+        //    .arg("switch")
+        //    .arg("--log-format")
+        //    .arg("raw-with-logs")
+        //    .arg("--no-reexec")
+        //    .arg("-v")
+        //    .stdout(Stdio::piped())
+        //    .stderr(Stdio::piped())
+        //    .spawn()
+        //    .inspect_err(|e| {
+        //        error!("failed to spawn `nixos-rebuild` command: {e}");
+        //    })?;
+
+        let expr = "(import <nixpkgs/nixos> { }).config.dynamicism.applyDynamicConfiguration { }";
+        let child = Command::new(*NIX)
+            .arg("run")
+            .arg("--show-trace")
             .arg("--log-format")
             .arg("raw-with-logs")
-            .arg("--no-reexec")
+            .arg("--impure")
-            .arg("-v")
+            .arg("-E")
+            .arg(expr)
             .stdout(Stdio::piped())
             .stderr(Stdio::piped())
             .spawn()
-            .inspect_err(|e| {
+            .inspect_err(|e| error!("failed to spawn `nix run` command: {e}"))?;
-                error!("failed to spawn `nixos-rebuild` command: {e}");
-            })?;
 
         debug!("Spanwed child process {}", child.id());
 
@@ -622,10 +650,20 @@ impl Daemon {
                     panic!("Received an event on an unregistered fd {fd}; IO-safety violation?");
                 };
 
+                let either_available = event.is_readable() || event.is_writable();
+                if !either_available {
+                    info!(
+                        "File descriptor {} r:{}, w:{}",
+                        info.display(),
+                        event.is_readable(),
+                        event.is_writable(),
+                    );
+                    // FIXME: code duplication
                     if event.is_read_closed() {
                         self.deregister(fd);
                         return Ok(());
                     }
+                }
 
                 match info.kind {
                     FdKind::Pid(pid) => {
@@ -652,17 +690,34 @@ impl Daemon {
 
                         // Close the pidfd.
                         self.deregister(fd);
+
+                        let stream = self
+                            .fd_info
+                            .iter()
+                            .find_map(|info| (info.kind == FdKind::SockStream).then_some(info));
+                        if let Some(stream) = stream {
+                            // SAFETY: fixme.
+                            let stream_fd = unsafe { BorrowedFd::borrow_raw(stream.fd) };
+                            let payload = format!("{{ \"status\": {exit_code} }}\n");
+                            if let Err(e) = rustix::io::write(stream_fd, payload.as_bytes()) {
+                                error!("couldn't write reply to stream fd {stream_fd:?}: {e}");
+                            }
+                        }
+                    },
+                    FdKind::ChildStdout => {
+                        warn!("got stdout");
+                        // SAFETY: oh boy.
+                        let stdout = unsafe { BorrowedFd::borrow_raw(fd) };
+                        self.proxy_stdio(&stdout)
+                            .unwrap_or_else(|e| error!("failed to proxy child stdout: {e}"));
+                    },
+                    FdKind::ChildStderr => {
+                        warn!("got stderr");
+                        // SAFETY: oh boy.
+                        let stderr = unsafe { BorrowedFd::borrow_raw(fd) };
+                        self.proxy_stdio(&stderr)
+                            .unwrap_or_else(|e| error!("failed to proxy child stderr: {e}"));
                     },
-                    //FdKind::ChildStdout => {
-                    //    warn!("got stdout");
-                    //    todo!();
-                    //},
-                    //FdKind::ChildStderr => {
-                    //    warn!("got stderr");
-                    //    // SAFETY: oh boy.
-                    //    let stderr = unsafe { BorrowedFd::borrow_raw(fd) };
-                    //    self.proxy_stdio(&stderr).unwrap();
-                    //},
                     FdKind::SockStream => {
                         // SAFETY: oh boy.
                         let stream_fd = unsafe { BorrowedFd::borrow_raw(fd) };
@@ -670,6 +725,11 @@ impl Daemon {
                     },
                     kind => todo!("{kind:?}"),
                 };
+
+                if event.is_read_closed() {
+                    self.deregister(fd);
+                    return Ok(());
+                }
             },
         }
 

src/daemon/api.rs

@@ -47,6 +47,24 @@ impl ConvenientAttrPath {
     }
 }
 
+#[derive(Debug, Clone, PartialEq)]
+#[derive(Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum NixLiteral {
+    String(String),
+    Number(f64),
+    // FIXME: add the rest =P
+}
+
+impl NixLiteral {
+    pub fn to_nix_source(&self) -> String {
+        match self {
+            NixLiteral::String(s) => format!("\"{s}\""),
+            NixLiteral::Number(n) => n.to_string(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 #[derive(serde::Deserialize, serde::Serialize)]
 #[serde(tag = "action", content = "args", rename_all = "snake_case")]
@@ -54,6 +72,6 @@ impl ConvenientAttrPath {
 pub enum DaemonCmd {
     Append {
         name: ConvenientAttrPath,
-        value: Box<str>,
+        value: Box<NixLiteral>,
     },
 }

src/lib.rs

@@ -231,6 +231,7 @@ pub fn get_next_prio_line(
     let penultimate = penultimate.unwrap();
 
     let new_generation = 0 - new_prio;
+    info!("setting '{option_name}' to '{new_value}' for generation '{new_generation}'");
 
     let new_line = SourceLine {
         line: penultimate.line,
@@ -256,6 +257,8 @@ pub fn write_next_prio(mut source: SourceFile, new_line: SourceLine) -> Result<(
         text: Arc::from("    }"),
     };
 
+    debug!("writing new source line: {new_line}");
+
     source.insert_lines(&[new_mod_start, new_line, new_mod_end])?;
 
     Ok(())

tests/default.nix

@@ -50,16 +50,11 @@
         requiredBy = [ "multi-user.target" ];
         after = [ "default.target" ];
         script = ''
-          if [[ -e /etc/nixos/hardware-configuration.nix ]]; then
-            echo "install-dynix: configuration already copied; nothing to do"
-            exit 0
-          fi
-
           nix profile install -vv "${dynix.drvPath}^*" # "
 
           mkdir -vp /etc/nixos
           nixos-generate-config
-          cp -rv --dereference /run/current-system/sw/share/nixos/*.nix /etc/nixos/
+          cp -rvf --dereference /run/current-system/sw/share/nixos/*.nix /etc/nixos/
           if ! [[ -e /etc/nixos/dynix-vm-configuration.nix ]]; then
             echo "FAILURE"
             echo "FAILURE" >&2

tests/dynix-vm-configuration.nix

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: EUPL-1.1
 
-{ pkgs, lib, modulesPath, ... }:
+{ pkgs, lib, modulesPath, config, ... }:
 let
   moduleList = import (modulesPath + "/module-list.nix");
 
@@ -44,11 +44,40 @@ in
     };
   };
 
+  # Setup XDG base directories for me.
+  security.pam.services.login = {
+    rules.session.xdg = {
+      enable = true;
+      control = "optional";
+      modulePath = "${pkgs.pam_xdg}/lib/security/pam_xdg.so";
+      args = [ ];
+      order = 10500;
+    };
+  };
+
   environment.pathsToLink = [ "/share" ];
   environment.extraOutputsToInstall = [ "modules" ];
   environment.variables = {
     "NIXOS_CONFIG" = "/etc/nixos/configuration.nix";
   };
+  environment.sessionVariables = {
+    "NIXOS_CONFIG" = "/etc/nixos/configuration.nix";
+  };
+
+  systemd.services.dynix-daemon = {
+    enable = true;
+    path = [ config.nix.package ];
+    serviceConfig = {
+      Environment = [
+        "RUST_LOG=trace"
+      ];
+      ExecSearchPath = [ "/run/current-system/sw/bin" ];
+      SuccessExitStatus = [ "0" "2" ];
+      # `bash -l` so XDG_RUNTIME_DIR is set correctly. lol.
+      ExecStart = "bash -l -c 'exec /root/.nix-profile/bin/dynix daemon --color=always'";
+      SyslogIdentifier = "dynix-daemon";
+    };
+  };
 
   environment.shellAliases = {
     ls = "eza --long --header --group --group-directories-first --classify --binary";
@@ -58,5 +87,8 @@ in
     eza
     fd
     ripgrep
+    netcat.nc
+    socat
+    python3
   ];
 }

tests/gotosocial/test-script.py

@@ -5,7 +5,7 @@
 from pathlib import Path
 import shlex
 import textwrap
-from typing import cast, TYPE_CHECKING
+from typing import Any, cast, TYPE_CHECKING
 
 from beartype import beartype
 
@@ -18,6 +18,13 @@ if TYPE_CHECKING:
     assert machine.shell is not None
 
 ls = "eza -lah --color=always --group-directories-first"
+testing_client = "/root/.nix-profile/libexec/dynix-testing-client.py"
+
+ANSI_RESET = "\x1b[0m"
+ANSI_BOLD = "\x1b[1m"
+ANSI_NOBOLD = "\x1b[22m"
+ANSI_RED = "\x1b[31m"
+ANSI_GREEN = "\x1b[32m"
 
 @beartype
 def run_log(machine: Machine, *commands: str, timeout: int | None = 60) -> str:
@@ -54,71 +61,108 @@ def get_config_file() -> str:
 
     config_file_path.unlink()
 
+    machine.logger.info(f"{ANSI_GREEN}INFO{ANSI_RESET}: got config file:")
+    machine.logger.info(textwrap.indent(data, "  "))
+
     return data
 
 @beartype
-def dynix_append(option: str, value: str):
+def dynix_append_cli(option: str, value: Any):
+    value = f'"{value}"' if isinstance(value, str) else value
     machine.succeed(f'''
         dynix append {shlex.quote(option)} {shlex.quote(value)}
     '''.strip())
 
-@beartype
-def do_apply():
     expr = textwrap.dedent("""
         (import <nixpkgs/nixos> { }).config.dynamicism.applyDynamicConfiguration { }
     """).strip()
-
+    machine.succeed(textwrap.dedent(rf"""
-    machine.succeed(rf"""
         nix run --show-trace --log-format raw-with-logs --impure -E {shlex.quote(expr)}
-    """.strip())
+    """).strip())
 
 
+@beartype
+def dynix_append_daemon(option: str, value: Any):
+    import json
+    payload = json.dumps(dict(
+        action="append",
+        args=dict(
+            name=option,
+            value=value,
+        ),
+    ))
+
+    machine.succeed(f"echo '{payload}' | {testing_client} /run/user/0/dynix.sock")
+
+@beartype
+def run_all_tests(machine: Machine, *, use_daemon: bool):
+    dynix_append = dynix_append_daemon if use_daemon else dynix_append_cli
+
+    dynix_out = machine.succeed("dynix --version")
+    assert "dynix" in dynix_out, f"dynix not in {dynix_out=}"
+
+    machine.succeed("systemctl start user@0.service")
+    machine.wait_for_unit("user@0.service")
+    machine.succeed("systemctl start dynix-daemon.service")
+    machine.wait_for_unit("dynix-daemon.service")
+
+    machine.log("REBUILDING configuration inside VM")
+    machine.succeed("env PAGER= nixos-rebuild switch --log-format raw-with-logs --no-reexec --fallback")
+    machine.wait_for_unit("gotosocial.service")
+
+    # Make sure the config before any dynamic changes is what we expect.
+    config_text = get_config_file()
+    lines = config_text.splitlines()
+    try:
+        application_name = next(line for line in lines if line.startswith("application-name:"))
+    except StopIteration:
+        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=}"
+
+    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!"
+    dynix_append("services.gotosocial.settings.application-name", f'{new_app_name}')
+
+    config_text = get_config_file()
+    lines = config_text.splitlines()
+    try:
+        application_name = next(line for line in lines if line.startswith("application-name:"))
+    except StopIteration:
+        raise AssertionError(f"no 'application-name:' found in config file: {textwrap.indent(config_text, "  ")}")
+    assert new_app_name in application_name, f"'{new_app_name}' should be in {application_name=}"
+
+    machine.log("REBUILDING configuration inside VM")
+    machine.succeed("env PAGER= nixos-rebuild switch --log-format raw-with-logs --no-reexec --fallback")
+
+    machine.wait_for_unit("gotosocial.service")
+
+    config_text = get_config_file()
+    lines = config_text.splitlines()
+    try:
+        application_name = next(line for line in lines if line.startswith("application-name:"))
+    except StopIteration:
+        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=}"
+
+machine.start(allow_reboot=True)
 machine.wait_for_unit("default.target")
 machine.wait_for_unit("install-dynix.service")
-
-dynix_out = machine.succeed("dynix --version")
-assert "dynix" in dynix_out, f"dynix not in {dynix_out=}"
-
-machine.log("REBUILDING configuration inside VM")
-machine.succeed("env PAGER= nixos-rebuild switch --log-format raw-with-logs --no-reexec --fallback")
-machine.wait_for_unit("gotosocial.service")
-
-# Make sure the config before any dynamic changes is what we expect.
-config_text = get_config_file()
-lines = config_text.splitlines()
 try:
-    application_name = next(line for line in lines if line.startswith("application-name:"))
+    run_all_tests(machine, use_daemon=False)
-except StopIteration:
+except Exception as e:
-    raise AssertionError(f"no 'application-name:' found in config file: {textwrap.indent(config_text, "  ")}")
+    machine.logger.error(f"{ANSI_RED}ERROR{ANSI_RESET} during {ANSI_BOLD}CLI{ANSI_RESET} tests: {e}")
-assert "gotosocial-for-machine" in application_name, f"'gotosocial-for-machine' should be in {application_name=}"
+    raise
 
+machine.reboot()
+
+machine.wait_for_unit("install-dynix.service")
 try:
-    host = next(line for line in lines if line.startswith("host:"))
+    run_all_tests(machine, use_daemon=True)
-except StopIteration:
+except Exception as e:
-    raise AssertionError(f"no 'host:' found in config file: {textwrap.indent(config_text, "  ")}")
+    machine.logger.error(f"{ANSI_RED}ERROR{ANSI_RESET} during {ANSI_BOLD}daemon{ANSI_RESET} tests: {e}")
-assert "gotosocial-machine" in host, f"'gotosocial-machine' should be in {host=}"
+    raise
-
-new_app_name = "yay!"
-dynix_append("services.gotosocial.settings.application-name", f'"{new_app_name}"')
-do_apply()
-
-config_text = get_config_file()
-lines = config_text.splitlines()
-try:
-    application_name = next(line for line in lines if line.startswith("application-name:"))
-except StopIteration:
-    raise AssertionError(f"no 'application-name:' found in config file: {textwrap.indent(config_text, "  ")}")
-assert new_app_name in application_name, f"'{new_app_name}' should be in {application_name=}"
-
-machine.log("REBUILDING configuration inside VM")
-machine.succeed("env PAGER= nixos-rebuild switch --log-format raw-with-logs --no-reexec --fallback")
-
-machine.wait_for_unit("gotosocial.service")
-
-config_text = get_config_file()
-lines = config_text.splitlines()
-try:
-    application_name = next(line for line in lines if line.startswith("application-name:"))
-except StopIteration:
-    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=}"

tests/harmonia/test-script.py

@@ -4,6 +4,7 @@
 
 import functools
 from pathlib import Path
+import json
 import shlex
 import textwrap
 import tomllib
@@ -20,6 +21,7 @@ if TYPE_CHECKING:
     assert machine.shell is not None
 
 ls = "eza -lah --color=always --group-directories-first"
+testing_client = "/root/.nix-profile/libexec/dynix-testing-client.py"
 
 indent = functools.partial(textwrap.indent, prefix='  ')
 
@@ -55,66 +57,114 @@ def get_config_file() -> dict[str, Any]:
     with open(config_file_path, "rb") as f:
         config_data = tomllib.load(f)
 
+    try:
         config_file_path.unlink()
+    except Exception as e:
+        machine.log(f"Couldn't unlike path {config_file_path}: {e}")
+        raise
     return config_data
 
 @beartype
-def dynix_append(option: str, value: Any):
+def dynix_append_daemon(option: str, value: Any):
+    payload = json.dumps(dict(
+        action="append",
+        args=dict(
+            name=option,
+            value=value,
+        ),
+    ))
+
+    machine.succeed(f"echo '{payload}' | {testing_client} /run/user/0/dynix.sock")
+
+@beartype
+def dynix_append_cli(option: str, value: Any):
     machine.succeed(f'''
         dynix append {shlex.quote(option)} {shlex.quote(str(value))}
     '''.strip())
 
-@beartype
-def do_apply():
     expr = textwrap.dedent("""
         (import <nixpkgs/nixos> { }).config.dynamicism.applyDynamicConfiguration { }
     """).strip()
-
     machine.succeed(rf"""
         nix run --show-trace --log-format raw-with-logs --impure -E {shlex.quote(expr)}
     """.strip())
 
-machine.wait_for_unit("default.target")
+@beartype
-machine.wait_for_unit("install-dynix.service")
+def run_all_tests(machine: Machine, *, use_daemon: bool):
+    dynix_append = dynix_append_daemon if use_daemon else dynix_append_cli
 
-dynix_out = machine.succeed("dynix --version")
+    #
-assert "dynix" in dynix_out, f"dynix not in {dynix_out=}"
+    # Setup.
+    #
+    dynix_out = machine.succeed("dynix --version")
+    assert "dynix" in dynix_out, f"dynix not in {dynix_out=}"
 
+    machine.succeed("systemctl start user@0.service")
+    machine.wait_for_unit("user@0.service")
 
-# Config should have our initial values.
+    run_log(machine, "systemctl start dynix-daemon.service")
-config_toml = get_config_file()
+    machine.wait_for_unit("dynix-daemon.service")
-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"
 
-with machine.nested("must succeed: initial nixos-rebuild switch"):
+    machine.log("Checking initial harmonia.service conditions")
+
+    # Config should have our initial values.
+    config_toml = get_config_file()
+    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"
+
+    with machine.nested("must succeed: initial nixos-rebuild switch"):
         machine.succeed("env PAGER= nixos-rebuild switch --log-format raw-with-logs --no-reexec -v --fallback")
 
-# Config should not have changed.
+    # Config should not have changed.
-config_toml = get_config_file()
+    config_toml = get_config_file()
-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"
 
-new_workers = 20
+    machine.log("Testing dynamic workers=20")
-dynix_append("services.harmonia.settings.workers", new_workers)
+    new_workers = 20
-do_apply()
+    dynix_append("services.harmonia.settings.workers", new_workers)
 
-# Workers, but not max connection rate, should have changed.
+    machine.log("Testing that workers, but not max_connection_rate, changed")
-config_toml = get_config_file()
+    # Workers, but not max connection rate, should have changed.
-assert int(config_toml['workers']) == new_workers, f"{config_toml['workers']=} != {new_workers}"
+    config_toml = get_config_file()
-assert int(config_toml['max_connection_rate']) == 256, f"{config_toml['max_connection_rate']=} != 256"
+    from pprint import pformat
+    machine.log(pformat(config_toml))
+    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"
 
-new_max_connection_rate = 100
+    machine.log("Testing dynamic max_connection_rate=100")
-dynix_append("services.harmonia.settings.max_connection_rate", new_max_connection_rate)
+    new_max_connection_rate = 100
-do_apply()
+    dynix_append("services.harmonia.settings.max_connection_rate", new_max_connection_rate)
 
-# Max connection rate should have changed, and workers should be the same as before.
+    # Max connection rate should have changed, and workers should be the same as before.
-config_toml = get_config_file()
+    config_toml = get_config_file()
-assert int(config_toml['max_connection_rate']) == new_max_connection_rate, f"{config_toml['max_connection_rate']=} != {new_max_connection_rate}"
+    print(f"checking connection rate, {use_daemon=}")
-assert int(config_toml['workers']) == new_workers, f"{config_toml['workers']=} != {new_workers}"
+    assert int(config_toml['max_connection_rate']) == new_max_connection_rate, f"{config_toml['max_connection_rate']=} != {new_max_connection_rate}"
+    print(f"checking workers, {use_daemon=}")
+    assert int(config_toml['workers']) == new_workers, f"{config_toml['workers']=} != {new_workers}"
 
-# And this should set everything back.
+    machine.log("Done with tests; stopping dynix-daemon")
-machine.succeed("env PAGER= nixos-rebuild switch --log-format raw-with-logs --no-reexec -v --fallback")
+    machine.succeed("systemctl stop dynix-daemon.service")
-machine.wait_for_unit("harmonia.service")
+
-config_toml = get_config_file()
+    # And this should set everything back.
-assert int(config_toml['max_connection_rate']) == 256, f'{config_toml["max_connection_rate"]=} != 256'
+    machine.succeed("env PAGER= nixos-rebuild switch --log-format raw-with-logs --no-reexec -v --fallback")
-assert int(config_toml['workers']) == 4, f'{config_toml["workers"]=} != 4'
+    machine.wait_for_unit("harmonia.service")
+    config_toml = get_config_file()
+    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'
+
+machine.start(allow_reboot=True)
+machine.wait_for_unit("install-dynix.service")
+try:
+    run_all_tests(machine, use_daemon=False)
+except Exception as e:
+    machine.log(f"ERROR running CLI tests: {e}")
+
+machine.reboot()
+
+machine.wait_for_unit("install-dynix.service")
+try:
+    run_all_tests(machine, use_daemon=True)
+except Exception as e:
+    machine.log(f"ERROR running DAEMON tests: {e}")
+    raise