Hold what mounts a missing disk, and say entries the mesh could not take out (hq ADR 0325 re-review)

A container was still created over an unmounted mount point, so its writes landed on
the filesystem below; a folder moved to another disk was kept on the old warrant; and
entries left by a drop or a move that could not run lived only in a log line. Every
container mounting an access whose disk is away now waits, the warrant holds only for
the filesystem it was carried out on (the wait names the new one, path-free), entries
left on a filesystem are recorded per mount and taken out when it is back, and every
leftover is said as unhealthy until it is. A hung stat is shared per path, and a
widened mask takes from other entries only the bits it adds.

cmd/mesh-host/kept.go

@@ -32,6 +32,8 @@ type judgedAccess struct {
 	module, id, name, path string
 	taken                  bool
 	users                  []store.KeptUser
+	// leftover is the mesh's entries nobody wants, not an access (link.KindKeptEntries).
+	leftover bool
 }
 
 // accessJudge reads every access on every look. Safe for the apply and the looking loop at once.
@@ -152,9 +154,10 @@ func judgeAccess(a judgedAccess) verdict {
 	v := apply.AccessVerdict(context.Background(), a.path, a.taken, len(a.users) > 0)
 	switch v.Kind {
 	case apply.VerdictWaitKeep:
-		return verdict{state: link.StateWaiting, reason: "it holds data the mesh has not taken, and waits for the " +
-			"operator's word (novox/hq ADR 0325 §7)", waits: []link.AccessWait{{Kind: link.WaitKindAccess,
-			Access: a.name, Part: a.module, What: apply.KeepWords(a.name)}}}
+		return verdict{state: link.StateWaiting, reason: "it holds data the mesh has not taken on the filesystem " +
+			"it is on now, and waits for the operator's word (novox/hq ADR 0325 §7, §8)",
+			waits: []link.AccessWait{{Kind: link.WaitKindAccess, Access: a.name, Part: a.module,
+				What: apply.KeepWords(a.name), Placed: v.Placed}}}
 	case apply.VerdictWaitDisk:
 		return verdict{state: link.StateWaiting, reason: "the disk that holds it is not there (novox/hq ADR 0325 §9)",
 			waits: []link.AccessWait{{Kind: link.WaitKindAccess, Access: a.name, Part: a.module,
@@ -264,13 +267,25 @@ func (j *accessJudge) look(now time.Time) ([]link.ResourceHealth, bool) {
 		read[i] = v
 	}
 
+	// And the entries nobody wants that could not be taken out yet, each under the access that last named its
+	// folder, until its drop walk has run (ADR 0325 §8).
+	for _, l := range apply.Leftovers() {
+		as = append(as, judgedAccess{module: l.Module, id: l.Access + "~entries", name: l.Name, path: l.Path,
+			leftover: true})
+		read = append(read, verdict{state: link.StateUnhealthy, reason: l.Why})
+	}
+
 	j.mu.Lock()
 	defer j.mu.Unlock()
 	changed := false
 	out := make([]link.ResourceHealth, 0, len(as))
 	for i, a := range as {
 		r := read[i]
-		v := link.ResourceHealth{Module: a.module, Resource: a.id, Kind: link.KindAccess, Target: a.path,
+		kind := link.KindAccess
+		if a.leftover {
+			kind = link.KindKeptEntries
+		}
+		v := link.ResourceHealth{Module: a.module, Resource: a.id, Kind: kind, Target: a.path,
 			State: r.state, Reason: r.reason, Since: now.UTC(), AccessWaits: r.waits, Act: r.act, Entries: r.entries}
 		if was, had := j.was[a.id]; had && was.State == r.state && was.Reason == r.reason {
 			v.Since = was.Since

cmd/mesh-host/kept_test.go

@@ -38,7 +38,9 @@ func TestAnAccessTheMeshMayNotKeepYetIsSaidAsAWaitOfItsOwnKind(t *testing.T) {
 		t.Fatalf("not waiting with one wait: %+v", v)
 	}
 	raw, _ := json.Marshal(v.waits[0])
-	if string(raw) != `{"kind":"access","access":"movies","part":"radarr","what":"let the mesh keep the shared folder movies"}` {
+	want := `{"kind":"access","access":"movies","part":"radarr","what":"let the mesh keep the shared folder movies",` +
+		`"placed":"` + v.waits[0].Placed + `"}`
+	if string(raw) != want || !strings.HasPrefix(v.waits[0].Placed, "fs-") {
 		t.Fatalf("the wait reads %s", raw)
 	}
 	if strings.Contains(v.reason, dir) {