sausage/flake.nix

{
  description = "Sausage: grow a system of WASI actors 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";
  };

  outputs = { nixpkgs, flake-utils, rust-overlay, ... }:
    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 actors.
        rust = pkgs.rust-bin.stable.latest.default.override {
          targets = [ "wasm32-wasip2" ];
          extensions = [ "rust-src" ];
        };
        rustPlatform = pkgs.makeRustPlatform { cargo = rust; rustc = rust; };
        sausage = rustPlatform.buildRustPackage {
          pname = "sausage";
          version = "0.1.0";
          src = ./.;
          cargoLock.lockFile = ./Cargo.lock;
          cargoBuildFlags = [ "-p" "sausage" ];
          doCheck = false;
          nativeBuildInputs = [ pkgs.makeWrapper ];
          # The `cargo` actor runs cargo at runtime. Build scripts need a C linker.
          postInstall = ''
            wrapProgram $out/bin/sausage --prefix PATH : ${pkgs.lib.makeBinPath [ rust pkgs.stdenv.cc ]}
          '';
          meta.mainProgram = "sausage";
        };
        # `nix run .#loop -- <world>` runs the newest `sausage run <world>`
        # from the Gitea repo, again and again: after a crash or a broker
        # `exit` request it refreshes the flake and starts the host again,
        # so the world updates itself. `/quit` (exit code 0) ends the loop.
        # `--internal` (or `.#loop-internal`) uses Gitea's SSH port on the LAN.
        publicUrl = "git+ssh://containeruser@gitea.surma.technology:2222/surma/sausage";
        internalUrl = "git+ssh://containeruser@10.0.0.2:2222/surma/sausage";
        loop = name: url: pkgs.writeShellScriptBin name ''
          url="${url}"
          if [ "''${1:-}" = "--internal" ]; then url="${internalUrl}"; shift; fi
          if [ $# -eq 0 ]; then set -- world; fi
          while true; do
            nix run --refresh "$url#default" -- run "$@"
            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 host, the SDK, and the
        # agent. The tests build WASM actors with cargo, offline, from the
        # vendored crates of Cargo.lock.
        checks.tests = sausage.overrideAttrs (old: {
          pname = "sausage-tests";
          doCheck = true;
          cargoTestFlags = [ "-p" "sausage" "-p" "sausage-actor" "-p" "agent" ];
          preCheck = ''
            # Its own lock file pins crates that the vendored set may lack.
            rm -f cli/tests/actors/toolbox/Cargo.lock
          '';
        });

        apps.default = { type = "app"; program = "${sausage}/bin/sausage"; };
        apps.loop = { type = "app"; program = "${loop "sausage-loop" publicUrl}/bin/sausage-loop"; };
        apps.loop-internal = { type = "app"; program = "${loop "sausage-loop-internal" internalUrl}/bin/sausage-loop-internal"; };

        devShells.default = pkgs.mkShell {
          packages = [ rust pkgs.wasmtime pkgs.wasm-tools ];
          shellHook = ''
            export CARGO_HOME="$PWD/.cargo-home"
          '';
        };
      });
}