surma
c926f3bc72
128 fast activate/revert cycles are not a realistic load. restarts_service covers the restart of a service after an upgrade. nix flake check runs the normal tests only.
202 lines
8.7 KiB
Nix
202 lines
8.7 KiB
Nix
{
|
|
description = "Sausage: grow a system of WASI plugins by talking to it";
|
|
|
|
inputs = {
|
|
nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
|
|
flake-utils.url = "github:numtide/flake-utils";
|
|
rust-overlay.url = "github:oxalica/rust-overlay";
|
|
rust-overlay.inputs.nixpkgs.follows = "nixpkgs";
|
|
crane.url = "github:ipetkov/crane";
|
|
};
|
|
|
|
outputs = { nixpkgs, flake-utils, rust-overlay, crane, ... }:
|
|
flake-utils.lib.eachSystem flake-utils.lib.allSystems (system:
|
|
let
|
|
pkgs = import nixpkgs {
|
|
inherit system;
|
|
overlays = [ rust-overlay.overlays.default ];
|
|
};
|
|
# The toolchain that builds the host and, at runtime, the plugins.
|
|
rust = pkgs.rust-bin.stable.latest.default.override {
|
|
targets = [ "wasm32-wasip2" ];
|
|
extensions = [ "rust-src" ];
|
|
};
|
|
# The native cargo plugin needs Cargo, rustc (with wasm32-wasip2), and
|
|
# the native linker, even when the host itself is started with a bare
|
|
# PATH. Keep this same runtime path in the packaged host and exercise
|
|
# the installed binary below with PATH deliberately empty.
|
|
runtimePath = pkgs.lib.makeBinPath [ rust pkgs.stdenv.cc ];
|
|
# A WASI clang with wasi-libc, so that build scripts (the `cc` crate)
|
|
# can compile C for wasm32-wasip2. Its headers are WASI 0.1: C code
|
|
# that needs sockets does not build.
|
|
wasiCc = pkgs.pkgsCross.wasi32.stdenv.cc;
|
|
wasiCcEnv = {
|
|
CC_wasm32_wasip2 = "${wasiCc}/bin/${wasiCc.targetPrefix}cc";
|
|
AR_wasm32_wasip2 = "${wasiCc}/bin/${wasiCc.targetPrefix}ar";
|
|
};
|
|
craneLib = (crane.mkLib pkgs).overrideToolchain rust;
|
|
common = {
|
|
pname = "sausage";
|
|
version = "0.1.0";
|
|
src = ./.;
|
|
};
|
|
# The test packages for `checks.tests`.
|
|
testPackages = "--workspace";
|
|
cargoArtifacts = craneLib.buildDepsOnly (common // {
|
|
doCheck = false;
|
|
# The dependencies of the host binary and of the tests.
|
|
buildPhaseCargoCommand = ''
|
|
cargoWithProfile build --locked -p sausage
|
|
cargoWithProfile test --locked --no-run ${testPackages}
|
|
'';
|
|
});
|
|
sausage = craneLib.buildPackage (common // {
|
|
inherit cargoArtifacts;
|
|
doNotRemoveReferencesToRustToolchain = true;
|
|
cargoExtraArgs = "--locked -p sausage";
|
|
doCheck = false;
|
|
nativeBuildInputs = [ pkgs.makeWrapper ];
|
|
# The native `cargo` plugin runs cargo at runtime. Build scripts need a C linker,
|
|
# and C code for WASI needs the WASI clang.
|
|
postInstall = ''
|
|
wrapProgram $out/bin/sausage --prefix PATH : ${runtimePath} \
|
|
--set-default CC_wasm32_wasip2 ${wasiCcEnv.CC_wasm32_wasip2} \
|
|
--set-default AR_wasm32_wasip2 ${wasiCcEnv.AR_wasm32_wasip2}
|
|
'';
|
|
meta.mainProgram = "sausage";
|
|
});
|
|
# `nix run .#loop -- <world>` runs the newest `sausage run <world>`
|
|
# (without a folder: bare `sausage`, i.e. ./world, created if needed)
|
|
# from the public repo, again and again: after a crash or a call of
|
|
# `core.exit` it refreshes the flake and starts the host again, so
|
|
# the world updates itself. `quit` (exit code 0) ends the loop.
|
|
# SAUSAGE_FLAKE overrides where it fetches from (any flake URL,
|
|
# e.g. a fork or a local checkout).
|
|
repoUrl = "git+https://gitea.surma.technology/surma/sausage";
|
|
loop = pkgs.writeShellScriptBin "sausage-loop" ''
|
|
url="''${SAUSAGE_FLAKE:-${repoUrl}}"
|
|
# No folder: bare `sausage` (creates ./world first if needed).
|
|
if [ $# -gt 0 ]; then set -- run "$@"; fi
|
|
while true; do
|
|
nix run --refresh "$url#default" -- "$@"
|
|
code=$?
|
|
if [ "$code" -eq 0 ]; then exit 0; fi
|
|
echo "sausage-loop: sausage exited with $code, starting the newest version in 2 s …" >&2
|
|
sleep 2
|
|
done
|
|
'';
|
|
in
|
|
{
|
|
packages.default = sausage;
|
|
|
|
# `nix flake check` runs every test of the workspace. The tests build
|
|
# WASM plugins with cargo, offline, from the vendored crates of
|
|
# Cargo.lock.
|
|
# The binary the host loop runs (`nix run`), built from the same
|
|
# cached dependencies as the tests.
|
|
checks.package = sausage;
|
|
checks.tests = craneLib.cargoTest (common // wasiCcEnv // {
|
|
inherit cargoArtifacts;
|
|
cargoExtraArgs = "--locked ${testPackages}";
|
|
# Nothing builds on the test run's target folder: don't store it.
|
|
doInstallCargoArtifacts = false;
|
|
# The SDK tests run sample plugins with the wasmtime CLI.
|
|
nativeBuildInputs = [ pkgs.wasmtime ];
|
|
});
|
|
# Exercise the installed host exactly as the loop launches it: the
|
|
# caller has no Cargo on PATH, so only the packaged runtime toolchain
|
|
# can run `cargo.build`: the tests under WASI and the wasm32-wasip2
|
|
# build, with C code from the packaged WASI clang.
|
|
checks.runtime-toolchain = pkgs.runCommand "sausage-runtime-toolchain" { } ''
|
|
set -eu
|
|
root="$TMPDIR/runtime-toolchain"
|
|
world="$root/world"
|
|
emptyPath="$root/empty-bin"
|
|
mkdir -p "$emptyPath" "$root/home" "$root/cargo-home"
|
|
mkdir -p "$world/plugins" "$world/state" "$world/config"
|
|
echo "[]" > "$world/config/boot.json"
|
|
source="$world/plugins/probe/source"
|
|
mkdir -p "$source/src" "$source/tests"
|
|
cat > "$source/Cargo.toml" <<'TOML'
|
|
[package]
|
|
name = "runtime-probe"
|
|
version = "0.1.0"
|
|
edition = "2024"
|
|
TOML
|
|
# C code for WASI, compiled with the packaged WASI clang.
|
|
printf 'int probe_add(int a, int b) { return a + b; }\n' > "$source/src/add.c"
|
|
cat > "$source/build.rs" <<'RUST'
|
|
use std::process::Command;
|
|
fn main() {
|
|
if std::env::var("TARGET").unwrap() != "wasm32-wasip2" {
|
|
return;
|
|
}
|
|
let out = std::env::var("OUT_DIR").unwrap();
|
|
let cc = std::env::var("CC_wasm32_wasip2").expect("CC_wasm32_wasip2");
|
|
let ar = std::env::var("AR_wasm32_wasip2").expect("AR_wasm32_wasip2");
|
|
let object = format!("{out}/add.o");
|
|
assert!(Command::new(cc).args(["-c", "src/add.c", "-o", &object]).status().unwrap().success());
|
|
assert!(Command::new(ar).args(["crs", &format!("{out}/libadd.a"), &object]).status().unwrap().success());
|
|
println!("cargo:rustc-link-search=native={out}");
|
|
println!("cargo:rustc-link-lib=static=add");
|
|
}
|
|
RUST
|
|
cat > "$source/src/main.rs" <<'RUST'
|
|
#[cfg(target_os = "wasi")]
|
|
unsafe extern "C" {
|
|
fn probe_add(a: i32, b: i32) -> i32;
|
|
}
|
|
fn main() {
|
|
#[cfg(target_os = "wasi")]
|
|
assert_eq!(unsafe { probe_add(2, 3) }, 5);
|
|
}
|
|
RUST
|
|
cat > "$source/tests/probe.rs" <<'RUST'
|
|
#[test]
|
|
fn test_runs_under_wasi() {
|
|
assert_eq!(2 + 2, 4);
|
|
}
|
|
RUST
|
|
echo "runtime-check: run packaged host with an empty PATH"
|
|
coproc host {
|
|
${pkgs.coreutils}/bin/env -i PATH="$emptyPath" HOME="$root/home" TMPDIR="$root" \
|
|
CARGO_HOME="$root/cargo-home" ${sausage}/bin/sausage run "$world"
|
|
}
|
|
hostInput=''${host[1]}
|
|
hostOutput=''${host[0]}
|
|
hostPid=$host_PID
|
|
trap 'kill "$hostPid" 2>/dev/null || true' EXIT
|
|
printf '%s\n' 'cargo.build {"plugin":"probe"}' >&"$hostInput"
|
|
built=0
|
|
while IFS= read -r -t 600 line <&"$hostOutput"; do
|
|
echo "$line"
|
|
case "$line" in
|
|
*'error:'*)
|
|
echo "packaged cargo.build failed with an empty caller PATH" >&2
|
|
exit 1
|
|
;;
|
|
*'"passed": 1'*) built=1; break ;;
|
|
esac
|
|
done
|
|
if [ "$built" -ne 1 ]; then
|
|
echo "packaged host did not build the probe, or its test did not pass" >&2
|
|
exit 1
|
|
fi
|
|
printf '%s\n' 'quit' >&"$hostInput"
|
|
wait "$hostPid"
|
|
mkdir -p "$out"
|
|
touch "$out/passed"
|
|
'';
|
|
|
|
apps.default = { type = "app"; program = "${sausage}/bin/sausage"; };
|
|
apps.loop = { type = "app"; program = "${loop}/bin/sausage-loop"; };
|
|
|
|
devShells.default = pkgs.mkShell (wasiCcEnv // {
|
|
packages = [ rust pkgs.wasmtime pkgs.wasm-tools ];
|
|
shellHook = ''
|
|
export CARGO_HOME="$PWD/.cargo-home"
|
|
'';
|
|
});
|
|
});
|
|
}
|