Fix flake update (#11)

Co-authored-by: flowey <floweydev@gmail.com>
Co-authored-by: gitea-actions[bot] <gitea-actions@noreply.local>
Reviewed-on: #11

.github/workflows/diff-pr.yml

@@ -17,10 +17,18 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with:
+          ref: ${{ github.event.pull_request.head.sha }}
           fetch-depth: 0
 
+      - name: merge base branch
+        run: |
+          git config user.email "ci@localhost"
+          git config user.name "CI"
+          git fetch origin ${{ github.event.pull_request.base.ref }}
+          git merge --no-edit origin/${{ github.event.pull_request.base.ref }}
+
       - name: worktree base for diff
-        run: git worktree add "$RUNNER_TEMP/base" "${{ github.event.pull_request.base.sha }}"
+        run: git worktree add "$RUNNER_TEMP/base" "origin/${{ github.event.pull_request.base.ref }}"
 
       - name: build closures and render diff
         run: |

.github/workflows/flake-update.yml

@@ -5,21 +5,19 @@ on:
     - cron: "17 4 * * *"
   workflow_dispatch:
 
-permissions:
-  contents: write
-  pull-requests: write
-
 jobs:
   update:
     runs-on: nix
     steps:
       - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
 
       - run: nix flake update -L
 
       - name: open/update PR
         env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_TOKEN: ${{ secrets.BOT_TOKEN }}
           API: ${{ github.api_url }}
           REPO: ${{ github.repository }}
         run: |

ci.py

@@ -8,6 +8,7 @@ import re
 import subprocess
 import subprocess_tee
 import sys
+import urllib.error
 import urllib.request
 from collections import Counter
 from pathlib import Path
@@ -26,6 +27,10 @@ def git(*args, check=True):
     return run("git", *args, check=check, capture_output=True)
 
 
+class GiteaError(Exception):
+    pass
+
+
 def gitea(method, path, body=None):
     url = f'{os.environ["API"]}/repos/{os.environ["REPO"]}{path}'
     data = json.dumps(body).encode() if body is not None else None
@@ -37,7 +42,11 @@ def gitea(method, path, body=None):
         with urllib.request.urlopen(req) as resp:
             raw = resp.read()
     except urllib.error.HTTPError as e:
-        sys.exit(f"gitea {method} {path}: {e.code} {e.reason}\n{e.read().decode()}")
+        try:
+            detail = json.loads(e.read()).get("message", e.reason)
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            detail = e.reason
+        raise GiteaError(f"{method} {path}: {e.code} {detail}") from None
     return json.loads(raw) if raw else None
 
 
@@ -466,16 +475,24 @@ def open_pr(args):
 
     host = os.environ["API"].removesuffix("/api/v1")
     auth = base64.b64encode(f'token:{os.environ["GH_TOKEN"]}'.encode()).decode()
-    git("-c", f"http.extraHeader=Authorization: Basic {auth}",
+    push = git("-c", f"http.extraHeader=Authorization: Basic {auth}",
-        "push", "-f", f'{host}/{os.environ["REPO"]}.git', f"HEAD:{args.branch}")
+               "push", "-f", f'{host}/{os.environ["REPO"]}.git', f"HEAD:{args.branch}",
+               check=False)
+    if push.returncode != 0:
+        raise RuntimeError(f"git push failed:\n{push.stderr}")
 
-    owner = os.environ["REPO"].split("/")[0]
+    pulls = gitea("GET", f"/pulls?state=open&base_branch={args.base}")
-    if gitea("GET", f"/pulls?state=open&head={owner}:{args.branch}"):
+    existing = next((pr for pr in pulls if pr["head"]["ref"] == args.branch), None)
+    if existing:
+        print(f"PR #{existing['number']} already open, pushed update")
         return
     labels = [label_id(args.label)] if args.label else []
-    gitea("POST", "/pulls",
+    pr = gitea("POST", "/pulls",
-          {"title": args.title, "head": args.branch, "base": args.base,
+               {"title": args.title, "head": args.branch, "base": args.base,
-           "body": Path(args.body_file).read_text(), "labels": labels})
+                "body": Path(args.body_file).read_text(), "labels": labels})
+    if not pr or "number" not in pr:
+        raise GiteaError(f"POST /pulls: unexpected response: {json.dumps(pr)}")
+    print(f"opened PR #{pr['number']}")
 
 
 def main():

configuration.nix

@@ -5,6 +5,7 @@
   hostInfo,
   customPkgs,
   flakeRev,
+  deployLabel,
   ...
 }:
 let
@@ -62,14 +63,7 @@ in
 
   time.timeZone = "UTC";
   system.stateVersion = "26.05";
-  system.nixos.label =
+  system.nixos.label = if deployLabel != null then deployLabel else flakeRev;
-    let
-      labelFile = ./.nixos-label;
-    in
-    if builtins.pathExists labelFile then
-      lib.removeSuffix "\n" (builtins.readFile labelFile)
-    else
-      flakeRev;
 
   nix = {
     settings = {

containers/server-n0/devenv.nix

@@ -1,54 +0,0 @@
-{
-  name,
-  hostInfo,
-  dsl,
-  ...
-}:
-let
-  inherit (dsl) mkContainer mkService;
-  inherit (hostInfo.paths) data secrets;
-in
-mkContainer {
-  inherit name;
-  net.access = [ { to = "@internet"; } ];
-  svc.autoStart = true;
-  resources.fs = {
-    "/config" = {
-      hostPath = "${data}/web/devenv/config";
-      isReadOnly = false;
-    };
-    "/workspace" = {
-      hostPath = "${data}/web/devenv/workspace";
-      isReadOnly = false;
-    };
-    "/run/secrets/code-server-env" = {
-      hostPath = "${secrets}/code-server-env";
-      isReadOnly = true;
-    };
-  };
-  users = [
-    {
-      name = "coder";
-      uid = 1000;
-      home = "/config";
-    }
-  ];
-  service =
-    { pkgs, lib, ... }:
-    mkService {
-      description = "code-server";
-      execStart = "${lib.getExe' pkgs.code-server "code-server"} --bind-addr 0.0.0.0:8080 --user-data-dir /config/data --extensions-dir /config/extensions --auth password /workspace";
-      networkOnline = true;
-      serviceConfig = {
-        EnvironmentFile = "/run/secrets/code-server-env";
-        User = "coder";
-        ReadWritePaths = [
-          "/config"
-          "/workspace"
-        ];
-      };
-    };
-  net.expose.tcp = [ 8080 ];
-  resources.mem = "4G";
-  resources.cpu = 2;
-}

containers/server-n0/git.nix

@@ -53,6 +53,10 @@ in
       systemd.services.gitea.serviceConfig.FailureAction = "exit-force";
     };
     net.expose.tcp = [ 3000 ];
+    miscProperties.nginx = {
+      domain = "git.floweytf.com";
+      port = 3000;
+    };
   };
 
   ci-runner =

containers/server-n0/mail.nix

@@ -150,6 +150,9 @@ mkContainer {
 
   net.access = [ { to = "@internet"; } ];
   svc.autoStart = true;
+  miscProperties.nginx = {
+    domain = "mail.floweytf.com";
+  };
   net.forward.tcp = [
     25
     993

containers/server-n0/maven.nix

@@ -38,4 +38,8 @@ mkContainer {
       environment.JAVA_OPTS = "-Xmx128M";
     };
   net.expose.tcp = [ 8080 ];
+  miscProperties.nginx = {
+    domain = "maven.floweytf.com";
+    port = 8080;
+  };
 }

containers/server-n0/nginx.nix

@@ -7,7 +7,7 @@
   ...
 }:
 let
-  inherit (dsl) mkContainer;
+  inherit (dsl) mkContainer collectContainers;
   inherit (hostInfo.paths) data;
 
   mkNginxConfig =
@@ -40,9 +40,6 @@ let
           defaultLoc = lib.optionalAttrs (upstream != null) {
             "/" = {
               proxyWebsockets = websockets;
-              # avoid startup error when containers aren't registered yet
-              # proxyPass is left unset for that reason, so recommendedProxySettings
-              # won't auto-include its headers here - set them manually to match
               extraConfig = ''
                 set $backend "${upstream.container.name}:${toString upstream.port}";
                 proxy_pass http://$backend;
@@ -157,49 +154,46 @@ let
 
   up = container: port: { inherit container port; };
 
-  nginxSetup =
+  discovered = collectContainers "nginx" containers;
-    hostAddr:
+
-    mkNginxConfig {
+  discoveredVhosts = map (
-      email = "floweydev@gmail.com";
+    { container, data }:
-      resolver = hostAddr;
+    {
-      vhosts = [
+      inherit (data) domain;
-        {
+    }
-          domain = "devenv.floweytf.com";
+    // lib.optionalAttrs (data ? port) { upstream = up container data.port; }
-          upstream = up containers.devenv 8080;
+    // lib.optionalAttrs (data ? websockets) { inherit (data) websockets; }
-        }
+    // lib.optionalAttrs (data ? redirect) { inherit (data) redirect; }
-        {
+    // lib.optionalAttrs (data ? listenHttp) { inherit (data) listenHttp; }
-          domain = "maven.floweytf.com";
+    // lib.optionalAttrs (data ? extraLocations) { inherit (data) extraLocations; }
-          upstream = up containers.maven 8080;
+  ) discovered;
-        }
+
-        {
+  extraVhosts = [
-          domain = "git.floweytf.com";
+    {
-          upstream = up containers.git 3000;
+      domain = "utils.floweytf.com";
-        }
+      redirect = false;
-        {
+      listenHttp = true;
-          domain = "utils.floweytf.com";
+      extraLocations = {
-          redirect = false;
+        "/static/" = {
-          listenHttp = true;
+          alias = "/usr/share/nginx/static/";
-          extraLocations = {
+          extraConfig = "autoindex on;";
-            "/static/" = {
+        };
-              alias = "/usr/share/nginx/static/";
+      };
-              extraConfig = "autoindex on;";
+    }
-            };
+  ];
-          };
+
-        }
+  upstreamContainers = map (e: e.container) (lib.filter ({ data, ... }: data ? port) discovered);
-        {
+
-          # no upstream, vhost only exists for certs
+  setup = mkNginxConfig {
-          domain = "mail.floweytf.com";
+    email = "floweydev@gmail.com";
-        }
+    resolver = hostAddr;
-      ];
+    vhosts = discoveredVhosts ++ extraVhosts;
-    };
+  };
-in
-let
-  setup = nginxSetup hostAddr;
   c = mkContainer {
     inherit name;
     net.access = setup.access ++ [ { to = "@internet"; } ];
     svc.autoStart = true;
-    svc.depends = lib.attrVals [ "devenv" "maven" "git" ] containers;
+    svc.depends = upstreamContainers;
     net.forward.tcp = [
       80
       443
@@ -208,6 +202,7 @@ let
       hostPath = "${data}/core/nginx/acme";
       isReadOnly = false;
     };
+    miscProperties.acmeDomains = map (v: v.domain) (discoveredVhosts ++ extraVhosts);
     inherit (setup) containerConfig;
   };
   inherit (c) hostAddr;

dsl.nix

@@ -1223,6 +1223,43 @@ rec {
         ) (lib.attrValues autoStartTestContainers)
       );
 
+      exposedTcp = lib.mapAttrs (_: c: c.ports or [ ]) autoStartTestContainers;
+
+      hostAccessTcp = lib.filterAttrs (_: v: v != [ ]) (
+        lib.mapAttrs (
+          _: c: lib.concatMap (a: if a.to == "@host" then a.tcp or [ ] else [ ]) c.access
+        ) autoStartTestContainers
+      );
+
+      pyForwardTcp = lib.concatStringsSep ", " (
+        lib.concatMap (
+          c:
+          map (
+            p:
+            let
+              np = normalizePort p;
+            in
+            "(${toString np.host}, \"${c.name}\", ${toString np.container})"
+          ) c.hostPorts
+        ) (lib.attrValues autoStartTestContainers)
+      );
+
+      nginxBackendPorts = lib.mapAttrs (_: c: c.miscProperties.nginx.port) (
+        lib.filterAttrs (
+          _: c: c.miscProperties ? nginx && c.miscProperties.nginx ? port
+        ) autoStartTestContainers
+      );
+
+      nginxDomainMap = lib.listToAttrs (
+        lib.concatMap (
+          c:
+          lib.optional (c.miscProperties ? nginx && c.miscProperties.nginx ? domain) {
+            name = c.miscProperties.nginx.domain;
+            value = c.name;
+          }
+        ) (lib.attrValues autoStartTestContainers)
+      );
+
       bin = lib.getExe';
 
       testTools = [
@@ -1330,6 +1367,12 @@ rec {
         # (src, to, tcp ports, udp ports); `to` may be "@host" or "@internet"
         EDGES = [${pyEdges}]
 
+        EXPOSED_TCP = ${pyDict pyInts exposedTcp}
+        HOST_ACCESS_TCP = ${pyDict pyInts hostAccessTcp}
+        FORWARD_TCP = [${pyForwardTcp}]
+        NGINX_BACKENDS = ${pyDict toString nginxBackendPorts}
+        NGINX_DOMAINS = ${pyDict pyStr nginxDomainMap}
+
         NSENTER = "${bin pkgs.util-linux "nsenter"}"
         CURL = "${bin pkgs.curl "curl"}"
         IP = "${bin pkgs.iproute2 "ip"}"

flake.lock

@@ -1,5 +1,17 @@
 {
   "nodes": {
+    "deploy-label": {
+      "flake": false,
+      "locked": {
+        "path": "./misc/deploy-label",
+        "type": "path"
+      },
+      "original": {
+        "path": "./misc/deploy-label",
+        "type": "path"
+      },
+      "parent": []
+    },
     "flake-utils": {
       "inputs": {
         "systems": "systems"
@@ -47,11 +59,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1782711974,
+        "lastModified": 1790093442,
-        "narHash": "sha256-ju0/qU6ZGqRxc5yDhuljrprG0BSPgguc8Kz3txktSjI=",
+        "narHash": "sha256-n0t8bN5x0NU9Ugwa/Vr0bcnA4YKA3YmyVg+Vp7t70HU=",
         "owner": "Floweynt",
         "repo": "monumenta-charm-eval",
-        "rev": "1aa8b532975679787f7c5bed180fd7fc0da6b905",
+        "rev": "0aaac697ff4d65e7af2fc9bebaf4f479d7c763b6",
         "type": "github"
       },
       "original": {
@@ -63,11 +75,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1789546076,
+        "lastModified": 1790046670,
-        "narHash": "sha256-zVxLZiSnmaaPLwnhj7pwmqe3axBg/C6nG5JZsJMh2g4=",
+        "narHash": "sha256-MYiI+CzL0tuWgRPjGsKCDHqYs2T3OzMlMQWOYWG0qso=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "b1b875982b17dabde9b4a37f3e229e74913e6db3",
+        "rev": "6774f7bc253789b113a4f39285dc0fa100abeacc",
         "type": "github"
       },
       "original": {
@@ -79,6 +91,7 @@
     },
     "root": {
       "inputs": {
+        "deploy-label": "deploy-label",
         "microvm": "microvm",
         "mtce": "mtce",
         "nixpkgs": "nixpkgs"

flake.nix

@@ -7,6 +7,8 @@
     mtce.inputs.nixpkgs.follows = "nixpkgs";
     microvm.url = "github:microvm-nix/microvm.nix";
     microvm.inputs.nixpkgs.follows = "nixpkgs";
+    deploy-label.url = "path:./misc/deploy-label";
+    deploy-label.flake = false;
   };
 
   outputs =
@@ -15,6 +17,7 @@
       nixpkgs,
       mtce,
       microvm,
+      deploy-label,
       ...
     }:
     let
@@ -23,6 +26,12 @@
       pkgs = import nixpkgs { inherit system; };
 
       flakeRev = self.shortRev or self.dirtyShortRev or "unknown";
+      deployLabel =
+        let
+          labelFile = "${deploy-label}/label";
+          raw = lib.removeSuffix "\n" (builtins.readFile labelFile);
+        in
+        if raw != "" then raw else null;
 
       customPkgs = {
         hopper-rs = pkgs.callPackage ./packages/hopper-rs.nix { };
@@ -56,7 +65,12 @@
 
       specialArgsFor = hostName: {
         hostInfo = hostInfoFor hostName;
-        inherit inputs customPkgs flakeRev;
+        inherit
+          inputs
+          customPkgs
+          flakeRev
+          deployLabel
+          ;
       };
 
       hostDefFor =

modules/autodeploy.nix

@@ -38,7 +38,7 @@ in
       type = lib.types.listOf lib.types.str;
       default = [ ];
     };
-    
+
     repoOwner = lib.mkOption {
       type = lib.types.str;
       description = "User that owns the configuration checkout";

scripts/server-autodeploy.sh

@@ -48,13 +48,17 @@ runas git tag -v "$latest" || {
 sha=$(runas git rev-list -1 "$latest")
 report_status "pending" "deploying $latest" "$sha"
 
+label_dir=$(mktemp -d)
+echo "$latest" > "$label_dir/label"
 flake_url="git+${GITEA_URL}/${GITEA_REPO}?ref=refs/tags/${latest}&rev=${sha}#$HOSTNAME"
 
-if nixos-rebuild switch --flake "$flake_url"; then
+if nixos-rebuild switch --flake "$flake_url" --override-input deploy-label "path:$label_dir"; then
+  rm -rf "$label_dir"
   echo "$latest" > "$STATE_DIR/tag"
   report_status "success" "deployed $latest" "$sha"
   echo "deployed $latest"
 else
+  rm -rf "$label_dir"
   report_status "failure" "nixos-rebuild failed" "$sha"
   exit 1
 fi

tests/server-n0/integration.nix

@@ -14,13 +14,11 @@ let
 
   it = dsl.mkIntegrationTest { inherit host testContainers pkgs; };
 
-  nginxAcmeDomains = [
+  nginxAcmeDomains =
-    "devenv.floweytf.com"
+    if testContainers ? nginx && testContainers.nginx.miscProperties ? acmeDomains then
-    "maven.floweytf.com"
+      testContainers.nginx.miscProperties.acmeDomains
-    "git.floweytf.com"
+    else
-    "utils.floweytf.com"
+      [ ];
-    "mail.floweytf.com"
-  ];
 
   nginxAcmeDir = domain: "${serverDataDir}/core/nginx/acme/${domain}";
 
@@ -67,9 +65,44 @@ let
       '';
   sshpiperTestUser = "admin";
 
-  hostExporterPort = 9100;
-  hostCadvisorPort = 9200;
   hostSshdPort = 5952;
+
+  # derive data directories from container bind mounts
+  allDataDirs = lib.unique (
+    lib.concatMap (c: lib.filter (p: lib.hasPrefix serverDataDir p) c.bindMountHostPaths) (
+      lib.attrValues testContainers
+    )
+  );
+
+  mkdirAllDataDirs = lib.concatMapStrings (p: ''mkdir -p "${p}"'' + "\n") allDataDirs;
+
+  # writable data dirs need ownership set to 1000:1000 (the standard
+  # container user uid). services that run as a different user (loki,
+  # prometheus, grafana) fix ownership via StateDirectory on startup.
+  writableDataDirs = lib.unique (
+    lib.concatMap (
+      c:
+      if c.kind == "nspawn" then
+        lib.filter (p: lib.hasPrefix serverDataDir p) (
+          map (bm: bm.hostPath) (lib.attrValues (lib.filterAttrs (_: bm: !bm.isReadOnly) c.bindMounts))
+        )
+      else
+        [ ]
+    ) (lib.attrValues testContainers)
+  );
+
+  chownWritableDataDirs = lib.concatMapStrings (
+    p: ''chown -R 1000:1000 "${p}"'' + "\n"
+  ) writableDataDirs;
+
+  # secret paths needed by test containers
+  secretPaths = lib.unique (
+    lib.concatMap (c: lib.filter (p: lib.hasPrefix serverSecretsDir p) c.bindMountHostPaths) (
+      lib.attrValues testContainers
+    )
+  );
+
+  mkdirSecretParents = lib.concatMapStrings (p: ''mkdir -p "$(dirname '${p}')"'' + "\n") secretPaths;
 in
 {
   name = "integration-${host.hostName}";
@@ -90,63 +123,33 @@ in
           it.serverModule
         ];
 
-        containers.nginx.config = {
-          systemd.services = lib.genAttrs (map (d: "acme-order-renew-${d}") nginxAcmeDomains) (_: {
-            enable = lib.mkForce false;
-          });
-        };
-
         system.activationScripts.test-secrets =
           # bash
           ''
-            mkdir -p /nix/var/nix/db /nix/var/nix/daemon-socket
+              mkdir -p /nix/var/nix/db /nix/var/nix/daemon-socket
-
+              mkdir -p /var/log/journal
-            mkdir -p /var/log/journal
+              mkdir -p "${serverSecretsDir}"
 
+            ${mkdirAllDataDirs}
             ${mkdirAcmeDirs}
-            mkdir -p "${serverSecretsDir}" \
+            ${mkdirSecretParents}
-              "${serverDataDir}/core/sshpiper" \
+            ${chownWritableDataDirs}
-              "${serverDataDir}/core/mail" \
-              "${serverDataDir}/overseer/loki/data" \
-              "${serverDataDir}/overseer/prometheus/data" \
-              "${serverDataDir}/overseer/grafana" \
-              "${serverDataDir}/web/git" \
-              "${serverDataDir}/web/git-ci-runner/nix-rw-store" \
-              "${serverDataDir}/web/git-ci-runner/docker" \
-              "${serverDataDir}/web/git-ci-runner/runner-state" \
-              "${serverSecretsDir}/ci-runner" \
-              "${serverDataDir}/web/reposilite" \
-              "${serverDataDir}/web/devenv/config" \
-              "${serverDataDir}/web/devenv/workspace" \
-              "${serverDataDir}/ssh/generic" \
-              "${serverDataDir}/ssh/nyaa" \
-              "${serverDataDir}/mc/botm" \
-              "${serverDataDir}/mc/rogule-dev" \
-              "${serverDataDir}/mc/rogule-build" \
-              "${serverDataDir}/mc/starwalker" \
-              "${serverDataDir}/mc/tl"
 
-            chown -R 1000:1000 \
+              for keytype in ed25519 rsa ecdsa; do
-              "${serverDataDir}/web/git" \
+                keyfile="${serverSecretsDir}/ssh_host_''${keytype}_key"
-              "${serverDataDir}/web/reposilite" \
+                if [[ ! -f "$keyfile" ]]; then
-              "${serverDataDir}/web/devenv/config" \
+                  ${lib.getExe' pkgs.openssh "ssh-keygen"} -q -t "$keytype" -f "$keyfile" -N ""
-              "${serverDataDir}/web/devenv/workspace" \
+                fi
-              "${serverDataDir}/core/mail" \
+              done
-              "${serverDataDir}/ssh/generic" \
-              "${serverDataDir}/mc/botm" \
-              "${serverDataDir}/mc/rogule-dev" \
-              "${serverDataDir}/mc/rogule-build" \
-              "${serverDataDir}/mc/starwalker" \
-              "${serverDataDir}/mc/tl"
 
-            for keytype in ed25519 rsa ecdsa; do
+            ${installFakeCerts}
-              keyfile="${serverSecretsDir}/ssh_host_''${keytype}_key"
+          ''
-              if [[ ! -f "$keyfile" ]]; then
+          + lib.optionalString (testContainers ? sshpiper) ''
-                ${lib.getExe' pkgs.openssh "ssh-keygen"} -q -t "$keytype" -f "$keyfile" -N ""
+            mkdir -p "${serverDataDir}/core/sshpiper/user_${sshpiperTestUser}"
-              fi
+            install -m 644 ${testSshKey}/key.pub \
-            done
+              "${serverDataDir}/core/sshpiper/user_${sshpiperTestUser}/authorized_keys"
-
+          ''
-            # stalwart rejects weak/dictionary passwords
+          + lib.optionalString (testContainers ? mail) ''
             for f in mail-admin-password mail-account-password; do
               target="${serverSecretsDir}/$f"
               if [[ ! -f "$target" ]]; then
@@ -154,22 +157,14 @@ in
                 chmod 600 "$target"
               fi
             done
-
-            if [[ ! -f "${serverSecretsDir}/ci-runner/token" ]]; then
-              echo "TOKEN=test-registration-token" > "${serverSecretsDir}/ci-runner/token"
-              chmod 600 "${serverSecretsDir}/ci-runner/token"
-            fi
-
-            if [[ ! -f "${serverSecretsDir}/code-server-env" ]]; then
-              echo "test-secret" > "${serverSecretsDir}/code-server-env"
-              chmod 600 "${serverSecretsDir}/code-server-env"
-            fi
-
-            ${installFakeCerts}
-            mkdir -p "${serverDataDir}/core/sshpiper/user_${sshpiperTestUser}"
-            install -m 644 ${testSshKey}/key.pub \
-              "${serverDataDir}/core/sshpiper/user_${sshpiperTestUser}/authorized_keys"
           '';
+      }
+      // lib.optionalAttrs (testContainers ? nginx && nginxAcmeDomains != [ ]) {
+        containers.nginx.config = {
+          systemd.services = lib.genAttrs (map (d: "acme-order-renew-${d}") nginxAcmeDomains) (_: {
+            enable = lib.mkForce false;
+          });
+        };
       };
   };
 
@@ -182,8 +177,6 @@ in
       TEST_SSH_KEY_STORE = "${testSshKey}/key"
 
       SSHPIPER_TEST_USER = "${sshpiperTestUser}"
-      HOST_EXPORTER_PORT = ${toString hostExporterPort}
-      HOST_CADVISOR_PORT = ${toString hostCadvisorPort}
       HOST_SSHD_PORT = ${toString hostSshdPort}
     ''
     + builtins.readFile ./integration.py;

tests/server-n0/integration.py

@@ -29,12 +29,15 @@ if TYPE_CHECKING:
     KIND: dict[str, str] = {}
     DEVICES: dict[str, list[str]] = {}
     EDGES: list[tuple[str, str, list[int], list[int]]] = []
+    EXPOSED_TCP: dict[str, list[int]] = {}
+    HOST_ACCESS_TCP: dict[str, list[int]] = {}
+    FORWARD_TCP: list[tuple[int, str, int]] = []
+    NGINX_BACKENDS: dict[str, int] = {}
+    NGINX_DOMAINS: dict[str, str] = {}
     SSH_KEY: str = ""
     SSH_OPTS: str = ""
     TEST_SSH_KEY_STORE: str = ""
     SSHPIPER_TEST_USER: str = ""
-    HOST_EXPORTER_PORT: int = 0
-    HOST_CADVISOR_PORT: int = 0
     HOST_SSHD_PORT: int = 0
 
 SW = "/run/current-system/sw/bin"
@@ -42,6 +45,12 @@ SH = f"{SW}/sh"
 
 PEER_EDGES = {(src, to) for src, to, _, _ in EDGES if to not in ("@host", "@internet")}
 
+# pre-compute the set of all host-access ports (union across containers)
+ALL_HOST_ACCESS_PORTS = {p for ps in HOST_ACCESS_TCP.values() for p in ps}
+
+# published host ports
+FWD_HOST_PORTS = {hp for hp, _, _ in FORWARD_TCP}
+
 
 def failed_units(node_arg=""):
     out = server.succeed(f"systemctl {node_arg} list-units --state=failed --no-legend --plain || true")
@@ -144,49 +153,38 @@ with subtest("(isolation): internet egress follows the access list"):
         server.fail(net_cmd(name, f"{IP} route show default | grep -q ."))
 
 with subtest("(functional): container DNS still resolves"):
+    src = enterable[0]
+    dst = next(c for c in included if c != src)
     resolved = server.succeed(
-        net_cmd("git", f"{DIG} +short +time=3 @{HOST_ADDR['git']} nginx.containers")
+        net_cmd(src, f"{DIG} +short +time=3 @{HOST_ADDR[src]} {dst}.containers")
     ).strip()
-    assert resolved == ADDR["nginx"], f"nginx.containers resolved to {resolved!r}, expected {ADDR['nginx']}"
+    assert resolved == ADDR[dst], f"{dst}.containers resolved to {resolved!r}, expected {ADDR[dst]}"
 
 with subtest("(functional): web services respond"):
-    for name, port in [("devenv", 8080), ("maven", 8080), ("git", 3000)]:
+    for name, port in NGINX_BACKENDS.items():
-        server.succeed(net_cmd(name, f"{CURL} -sf --max-time 5 -o /dev/null http://{ADDR[name]}:{port}/ >&2"))
+        if name in enterable:
-
+            server.succeed(net_cmd(name, f"{CURL} -sf --max-time 5 -o /dev/null http://{ADDR[name]}:{port}/ >&2"))
-# TODO: re-enable mail
-"""
-with subtest("(functional): mail accepts connections"):
-    smtp_probe = net_cmd("mail", f"{SH} -c 'exec 3<>/dev/tcp/{ADDR['mail']}/25 && head -1 <&3'")
-    server.wait_until_succeeds(f"{smtp_probe} | grep -q '^220'", timeout=60)
-
-    imap_probe = net_cmd(
-        "mail",
-        f"{TIMEOUT} 3 {OPENSSL} s_client -connect {ADDR['mail']}:993 -quiet -verify_quiet 2>/dev/null",
-    )
-
-    def imap_ready(_):
-        greeting = server.execute(f"echo | {imap_probe} | head -1")[1]
-        return greeting.strip().startswith("* OK")
-
-    retry(imap_ready, timeout_seconds=60)
-"""
 
 with subtest("(functional): nginx proxies to backend containers"):
-    server.succeed(
+    if "nginx" in enterable:
-        net_cmd(
+        for domain, backend in NGINX_DOMAINS.items():
-            "nginx",
+            if backend in included:
-            f"{CURL} -sfk --max-time 5 --resolve git.floweytf.com:443:{ADDR['nginx']} "
+                server.succeed(
-            "https://git.floweytf.com/ >&2",
+                    net_cmd(
-        )
+                        "nginx",
-    )
+                        f"{CURL} -sfk --max-time 5 --resolve {domain}:443:{ADDR['nginx']} "
+                        f"https://{domain}/ >&2",
+                    )
+                )
 
 with subtest("(functional): sshpiper authenticates/routes properly"):
-    whoami = server.succeed(f"{SSH} {SSH_OPTS} -p 2222 {SSHPIPER_TEST_USER}@{ADDR['sshpiper']} whoami").strip()
+    if "sshpiper" in included:
-    assert whoami == "runner", f"expected to land as runner, got {whoami}"
+        whoami = server.succeed(f"{SSH} {SSH_OPTS} -p 2222 {SSHPIPER_TEST_USER}@{ADDR['sshpiper']} whoami").strip()
-    hostname = server.succeed(
+        assert whoami == "runner", f"expected to land as runner, got {whoami}"
-        f"{SSH} {SSH_OPTS} -p 2222 {SSHPIPER_TEST_USER}@{ADDR['sshpiper']} hostname"
+        hostname = server.succeed(
-    ).strip()
+            f"{SSH} {SSH_OPTS} -p 2222 {SSHPIPER_TEST_USER}@{ADDR['sshpiper']} hostname"
-    assert hostname == "ssh-admin", f"expected to land on ssh-admin, got {hostname}"
+        ).strip()
+        assert hostname == "ssh-admin", f"expected to land on ssh-admin, got {hostname}"
 
 with subtest("(isolation): every declared container edge connects"):
     for src, to, tcp_ports, _ in EDGES:
@@ -196,89 +194,136 @@ with subtest("(isolation): every declared container edge connects"):
             server.succeed(ct_connect(src, ADDR[to], port))
 
 with subtest("(isolation): undeclared container edges are refused"):
-    for src, dst, port in [
+    tested = 0
-        ("devenv", "git", 3000),
+    for src in enterable:
-        ("git", "devenv", 8080),
+        for dst in enterable:
-        ("maven", "git", 3000),
+            if src == dst or (src, dst) in PEER_EDGES:
-        # ("nginx", "mail", 25),
+                continue
-        ("ssh-botm", "ssh-admin", 22),
+            ports = EXPOSED_TCP.get(dst, [])
-        ("overseer", "git", 3000),
+            if not ports:
-    ]:
+                continue
-        assert (src, dst) not in PEER_EDGES, f"{src} -> {dst} is a declared edge, not a negative case"
+            server.fail(ct_connect(src, ADDR[dst], ports[0], timeout=2))
-        server.fail(ct_connect(src, ADDR[dst], port, timeout=2))
+            tested += 1
+    assert tested > 0, "no negative edge cases to test"
 
 with subtest("(isolation): edges are one-way"):
-    assert ("nginx", "git") in PEER_EDGES
+    tested = 0
-    assert ("git", "nginx") not in PEER_EDGES
+    for src, dst, tcp_ports, _ in EDGES:
-    server.succeed(ct_connect("nginx", ADDR["git"], 3000))
+        if dst in ("@host", "@internet") or src not in enterable or dst not in enterable:
-    server.fail(ct_connect("git", ADDR["nginx"], 443, timeout=2))
+            continue
+        if (dst, src) in PEER_EDGES or not tcp_ports:
+            continue
+        server.succeed(ct_connect(src, ADDR[dst], tcp_ports[0]))
+        tested += 1
+        rev_ports = EXPOSED_TCP.get(src, [])
+        if rev_ports:
+            server.fail(ct_connect(dst, ADDR[src], rev_ports[0], timeout=2))
+    assert tested > 0, "no one-way edge cases to test"
 
 with subtest("(isolation): host access allowlist"):
-    server.succeed(ct_connect("overseer", HOST_ADDR["overseer"], HOST_EXPORTER_PORT))
+    for name, ports in HOST_ACCESS_TCP.items():
-    for port in (HOST_EXPORTER_PORT, HOST_CADVISOR_PORT):
+        if name in enterable:
-        server.fail(ct_connect("git", HOST_ADDR["git"], port, timeout=2))
+            for port in ports:
-        server.fail(ct_connect("git", HOST_ADDR["overseer"], port, timeout=2))
+                server.succeed(ct_connect(name, HOST_ADDR[name], port))
+    no_access = [c for c in enterable if c not in HOST_ACCESS_TCP]
+    if no_access and ALL_HOST_ACCESS_PORTS:
+        ct = no_access[0]
+        for port in ALL_HOST_ACCESS_PORTS:
+            server.fail(ct_connect(ct, HOST_ADDR[ct], port, timeout=2))
+            # reaching the port through a different container's host addr is also blocked
+            for other in HOST_ACCESS_TCP:
+                if other in included:
+                    server.fail(ct_connect(ct, HOST_ADDR[other], port, timeout=2))
 
 with subtest("(isolation): host services outside the access list"):
     internet.succeed(connect(server_ip, HOST_SSHD_PORT))
-    for name in ("git", "overseer"):
+    for name in enterable:
-        server.fail(ct_connect(name, HOST_ADDR[name], HOST_SSHD_PORT, timeout=2))
+        if HOST_SSHD_PORT not in HOST_ACCESS_TCP.get(name, []):
-        server.fail(ct_connect(name, server_ip, HOST_SSHD_PORT, timeout=2))
+            server.fail(ct_connect(name, HOST_ADDR[name], HOST_SSHD_PORT, timeout=2))
+            server.fail(ct_connect(name, server_ip, HOST_SSHD_PORT, timeout=2))
 
 with subtest("(isolation): source address spoofing is dropped"):
+    src = enterable[0]
+    other = enterable[1]
+
     before = spoof_counter()
-    server.succeed(net_cmd("git", f"{PING} -c 1 -W 2 {HOST_ADDR['git']} >&2"))
+    server.succeed(net_cmd(src, f"{PING} -c 1 -W 2 {HOST_ADDR[src]} >&2"))
     assert spoof_counter() == before, "an unspoofed packet hit the source guard"
 
-    iface = IFACE["git"]
+    iface = IFACE[src]
-    server.succeed(net_cmd("git", f"{IP} addr add {ADDR['nginx']}/32 dev {iface}"))
+    server.succeed(net_cmd(src, f"{IP} addr add {ADDR[other]}/32 dev {iface}"))
     try:
         server.execute(
-            net_cmd("git", f"{PING} -c 2 -W 2 -I {ADDR['nginx']} {HOST_ADDR['git']}")
+            net_cmd(src, f"{PING} -c 2 -W 2 -I {ADDR[other]} {HOST_ADDR[src]}")
         )
         assert spoof_counter() > before, "a forged source address was not dropped"
     finally:
-        server.succeed(net_cmd("git", f"{IP} addr del {ADDR['nginx']}/32 dev {iface}"))
+        server.succeed(net_cmd(src, f"{IP} addr del {ADDR[other]}/32 dev {iface}"))
 
 with subtest("(isolation): renaming the interface changes nothing"):
-    iface, host_addr = IFACE["nginx"], HOST_ADDR["nginx"]
+    # find a container with a declared peer edge
+    rename_src = rename_dst = rename_port = None
+    for src, dst, tcp_ports, _ in EDGES:
+        if dst in ("@host", "@internet") or src not in enterable or dst not in included:
+            continue
+        if tcp_ports:
+            rename_src, rename_dst, rename_port = src, dst, tcp_ports[0]
+            break
+
+    assert rename_src is not None and rename_dst is not None and rename_port is not None, \
+        "no peer edge to test interface rename"
+
+    iface, host_addr = IFACE[rename_src], HOST_ADDR[rename_src]
 
     def rename(frm, to):
-        server.succeed(net_cmd("nginx", f"{IP} link set dev {frm} down"))
+        server.succeed(net_cmd(rename_src, f"{IP} link set dev {frm} down"))
-        server.succeed(net_cmd("nginx", f"{IP} link set dev {frm} name {to}"))
+        server.succeed(net_cmd(rename_src, f"{IP} link set dev {frm} name {to}"))
-        server.succeed(net_cmd("nginx", f"{IP} link set dev {to} up"))
+        server.succeed(net_cmd(rename_src, f"{IP} link set dev {to} up"))
         for route in (host_addr, f"10.0.0.0/8 via {host_addr}", f"default via {host_addr}"):
-            server.succeed(net_cmd("nginx", f"{IP} route replace {route} dev {to}"))
+            server.succeed(net_cmd(rename_src, f"{IP} route replace {route} dev {to}"))
 
     rename(iface, "evil0")
     try:
-        server.succeed(ct_connect("nginx", ADDR["git"], 3000))
+        server.succeed(ct_connect(rename_src, ADDR[rename_dst], rename_port))
-        # server.fail(ct_connect("nginx", ADDR["mail"], 25, timeout=2))
     finally:
         rename("evil0", iface)
 
 with subtest("(isolation): the veth cannot be moved out of the namespace"):
-    server.fail(net_cmd("git", f"{IP} link set dev {IFACE['git']} netns 1"))
+    ct = enterable[0]
+    server.fail(net_cmd(ct, f"{IP} link set dev {IFACE[ct]} netns 1"))
 
 with subtest("(isolation): route bypass"):
-    iface = IFACE["hopper"]
+    bypass_ct = next((c for c in enterable if c in no_gateway), None)
+    if bypass_ct is None:
+        bypass_ct = next((c for c in enterable if c not in allow_internet), None)
+    assert bypass_ct is not None, "no container without internet to test route bypass"
+
+    iface = IFACE[bypass_ct]
     server.succeed(
-        net_cmd("hopper", f"{IP} route replace default via {HOST_ADDR['hopper']} dev {iface} onlink")
+        net_cmd(bypass_ct, f"{IP} route replace default via {HOST_ADDR[bypass_ct]} dev {iface} onlink")
     )
-    server.fail(net_cmd("hopper", f"{CURL} -sf --max-time 5 http://{internet_ip}/ >&2"))
+    server.fail(net_cmd(bypass_ct, f"{CURL} -sf --max-time 5 http://{internet_ip}/ >&2"))
-    server.fail(ct_connect("hopper", ADDR["git"], 3000, timeout=2))
+    unreachable = next(
+        (c for c in included if c != bypass_ct and (bypass_ct, c) not in PEER_EDGES and EXPOSED_TCP.get(c, [])),
+        None,
+    )
+    if unreachable:
+        server.fail(ct_connect(bypass_ct, ADDR[unreachable], EXPOSED_TCP[unreachable][0], timeout=2))
 
 with subtest("(isolation): no IPv6 link-local addresses"):
-    for name in ["git", "overseer"]:
+    for name in enterable:
         assert not has_ipv6_link_local(name), f"{name} still has an IPv6 link-local address"
 
 with subtest("(isolation): published ports grant no reach between containers"):
-    for port in (80, 443, 25565, 22, 25):
+    if FWD_HOST_PORTS:
-        server.fail(ct_connect("overseer", HOST_ADDR["overseer"], port, timeout=2))
+        ct = next((c for c in enterable if c not in HOST_ACCESS_TCP), enterable[0])
-        server.fail(ct_connect("git", server_ip, port, timeout=2))
+        for port in FWD_HOST_PORTS:
+            server.fail(ct_connect(ct, HOST_ADDR[ct], port, timeout=2))
+        server.fail(ct_connect(ct, server_ip, next(iter(FWD_HOST_PORTS)), timeout=2))
 
 with subtest("(isolation): privilege escalation / container escape"):
-    leader = container_pid("git")
+    ct = enterable[0]
+    leader = container_pid(ct)
 
     host_uid = server.succeed(f"awk '/^Uid:/{{print $2}}' /proc/{leader}/status").strip()
     assert host_uid != "0", "container's PID 1 is not idmapped away from host uid 0"
@@ -287,28 +332,16 @@ with subtest("(isolation): privilege escalation / container escape"):
     container_pidns = server.succeed(f"readlink /proc/{leader}/ns/pid").strip()
     assert host_pidns != container_pidns, "container shares the host's PID namespace"
 
-    server.succeed(
+    server.fail(ct_cmd(ct, "touch /nix/store/canary"))
-        f"{NSENTER} --mount=/proc/{leader}/ns/mnt --root=/proc/{leader}/root -- "
-        f"{SH} -c 'echo x >> /var/lib/gitea/canary' >&2"
-    )
-
-    sshpiper_pid = container_pid("sshpiper")
-    server.fail(
-        f"{NSENTER} --mount=/proc/{sshpiper_pid}/ns/mnt --root=/proc/{sshpiper_pid}/root -- "
-        f"{SH} -c 'echo x >> /etc/ssh/ssh_host_ed25519_key' >&2"
-    )
-    server.fail(
-        f"{NSENTER} --mount=/proc/{leader}/ns/mnt --root=/proc/{leader}/root -- "
-        f"{SH} -c 'touch /nix/store/canary' >&2"
-    )
     server.fail(
         f"{NSENTER} --mount=/proc/{leader}/ns/mnt --root=/proc/{leader}/root -- "
         "/run/current-system/sw/bin/test -d /persist >&2"
     )
 
 with subtest("(functional): external clients reach published ports"):
-    for port in (80, 25565, 22):
+    for hp, _, _ in FORWARD_TCP:
-        internet.succeed(ext_connect(port))
+        internet.succeed(ext_connect(hp))
+    # a non-published port should be unreachable
     internet.fail(ext_connect(8080))
 
 with subtest("(functional): no failing-reason restarts"):
@@ -317,21 +350,27 @@ with subtest("(functional): no failing-reason restarts"):
         assert (
             failed_units(f"-M {name}") == []
         ), f"{name} has failed units: {failed_units(f'-M {name}')}"
-        restarts = server.succeed(f"systemctl show container@{name}.service -p NRestarts --value").strip()
+        unit = "container" if KIND[name] == "nspawn" else "microvm"
-        assert restarts == "0", f"container@{name}.service restarted {restarts} times"
+        restarts = server.succeed(f"systemctl show {unit}@{name}.service -p NRestarts --value").strip()
+        assert restarts == "0", f"{unit}@{name}.service restarted {restarts} times"
 
 with subtest("(functional): port forwards survive an nftables reload"):
-    server.succeed("systemctl reload nftables.service")
+    if FORWARD_TCP:
-    elements = server.succeed("nft list map ip container-portforward tcp-fwd")
+        hp, ct_name, _ = FORWARD_TCP[0]
-    assert re.search(r"\b80\s*:", elements), f"nftables reload emptied the map: {elements!r}"
+        server.succeed("systemctl reload nftables.service")
-    internet.wait_until_succeeds(ext_connect(80), timeout=30)
+        elements = server.succeed("nft list map ip container-portforward tcp-fwd")
+        assert re.search(rf"\b{hp}\s*:", elements), f"nftables reload emptied the map: {elements!r}"
+        internet.wait_until_succeeds(ext_connect(hp), timeout=30)
 
 with subtest("(functional): published ports follow the container's lifetime"):
-    server.succeed("systemctl stop container@nginx")
+    if FORWARD_TCP:
-    internet.fail(ext_connect(80))
+        hp, ct_name, _ = FORWARD_TCP[0]
-    server.succeed("systemctl start container@nginx")
+        unit = "container" if KIND[ct_name] == "nspawn" else "microvm"
-    server.wait_for_unit("container@nginx.service")
+        server.succeed(f"systemctl stop {unit}@{ct_name}")
-    internet.wait_until_succeeds(ext_connect(80), timeout=30)
+        internet.fail(ext_connect(hp))
+        server.succeed(f"systemctl start {unit}@{ct_name}")
+        server.wait_for_unit(f"{unit}@{ct_name}.service")
+        internet.wait_until_succeeds(ext_connect(hp), timeout=30)
 
 with subtest("(functional): declared devices are usable in-container"):
     for name, devices in DEVICES.items():