Name the paths a seat's holder owns, and refuse a claim or a declaration without the seat (issue 412)

Which module owns /etc/hosts or /etc/resolv.conf on a machine was answered only by reading every
manifest, and a module not holding node-hostname could declare /etc/hosts where nobody held it.
hq ADR 0287 makes the paths part of the seat's definition: node-hostname names /etc/hosts and
/etc/hostname, node-uplink names /etc/resolv.conf stepping back for node-resolver, node-resolver
names /etc/resolv.conf.

CanHold refuses a holder that does not declare every path (registration and handover), registration
refuses a module declaring a seat's path while claiming none of the seats naming it, a module's own
seat names paths under the same rules (node only, literal, not named by another seat), composition
refuses a generated resource on a seat's path, the uplink's step-back is read from the seat instead
of a special case, and `seats` shows each seat's paths and who owns each on each machine.

cmd/mesh-controller/seats.go

@@ -34,8 +34,10 @@ type seatRow struct {
 	Delivers string `json:"delivers,omitempty"`
 	Decision string `json:"decision"`
 	// Replicated says the seat may be held on several machines at once (novox/hq ADR 0223).
-	Replicated bool         `json:"replicated,omitempty"`
-	Holders    []seatHolder `json:"holders"`
+	Replicated bool `json:"replicated,omitempty"`
+	// Paths are the paths on its machine the seat's holder owns (novox/hq ADR 0287).
+	Paths   []catalogue.SeatPath `json:"paths,omitempty"`
+	Holders []seatHolder         `json:"holders"`
 }
 
 // seatsHeld is every seat the mesh defines with its holders, and every claim held that names no
@@ -49,7 +51,7 @@ func seatsHeld(seats []catalogue.Seat, held []catalogue.Held) ([]seatRow, []cata
 	rows := make([]seatRow, 0, len(seats))
 	for _, s := range seats {
 		row := seatRow{Seat: s.Name, Scope: s.Scope, Delivers: s.Delivers, Decision: s.Decision,
-			Replicated: s.Replicated, Holders: []seatHolder{}}
+			Replicated: s.Replicated, Paths: s.Paths, Holders: []seatHolder{}}
 		seen := map[seatHolder]bool{}
 		for _, h := range held {
 			// Resolve the held claim to a seat rather than comparing names, so a record naming a
@@ -255,12 +257,16 @@ func seatsCommand(ctx context.Context, args []string) error {
 		return err
 	}
 	rows, outside := seatsHeld(catalogue.Seats(), world.Held)
+	// Which module owns each seat's path on each machine (novox/hq ADR 0287): the seat naming it, and
+	// that seat's holder there, with the stepping back applied.
+	owners := catalogue.PathOwners(catalogue.Seats(), world.Held)
 
 	if *asJSON {
 		out := struct {
-			Seats   []seatRow        `json:"seats"`
-			Outside []catalogue.Held `json:"outside,omitempty"`
-		}{rows, outside}
+			Seats   []seatRow             `json:"seats"`
+			Owners  []catalogue.PathOwner `json:"path-owners,omitempty"`
+			Outside []catalogue.Held      `json:"outside,omitempty"`
+		}{rows, owners, outside}
 		body, err := json.MarshalIndent(out, "", "  ")
 		if err != nil {
 			return err
@@ -270,7 +276,7 @@ func seatsCommand(ctx context.Context, args []string) error {
 	}
 
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
-	fmt.Fprintln(w, "SEAT\tSCOPE\tDELIVERS\tHELD BY")
+	fmt.Fprintln(w, "SEAT\tSCOPE\tDELIVERS\tPATHS\tHELD BY")
 	for _, r := range rows {
 		delivers := r.Delivers
 		if delivers == "" {
@@ -284,11 +290,22 @@ func seatsCommand(ctx context.Context, args []string) error {
 			}
 			holders = strings.Join(parts, ", ")
 		}
-		fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", r.Seat, r.Scope, delivers, holders)
+		fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n", r.Seat, r.Scope, delivers, seatPathsText(r.Paths), holders)
 	}
 	if err := w.Flush(); err != nil {
 		return err
 	}
+	if len(owners) > 0 {
+		fmt.Println("\nwho owns each seat's path, by machine (novox/hq ADR 0287):")
+		w = tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+		fmt.Fprintln(w, "PATH\tMACHINE\tSEAT\tMODULE")
+		for _, o := range owners {
+			fmt.Fprintf(w, "%s\t%s\t%s\t%s\n", o.Path, o.Node, o.Seat, o.Module)
+		}
+		if err := w.Flush(); err != nil {
+			return err
+		}
+	}
 	if len(outside) > 0 {
 		fmt.Println("\nheld, and not a seat this mesh defines (registered before the set closed — novox/hq ADR 0110):")
 		for _, h := range outside {
@@ -297,3 +314,19 @@ func seatsCommand(ctx context.Context, args []string) error {
 	}
 	return nil
 }
+
+// seatPathsText is a seat's paths in one column: each path, and the seat it steps back for, if any.
+func seatPathsText(paths []catalogue.SeatPath) string {
+	if len(paths) == 0 {
+		return "—"
+	}
+	parts := make([]string, 0, len(paths))
+	for _, p := range paths {
+		if p.StepsBackFor != "" {
+			parts = append(parts, p.Path+" (steps back for "+p.StepsBackFor+")")
+			continue
+		}
+		parts = append(parts, p.Path)
+	}
+	return strings.Join(parts, ", ")
+}

cmd/mesh-controller/seats_test.go

@@ -74,3 +74,22 @@ func TestAKindedBenchIsNotHandedOver(t *testing.T) {
 		}
 	}
 }
+
+// The listing shows each seat's paths, and the seat a path steps back for (novox/hq ADR 0287).
+func TestTheSeatsListingShowsEachSeatsPaths(t *testing.T) {
+	rows, _ := seatsHeld(catalogue.Seats(), nil)
+	got := map[string]string{}
+	for _, r := range rows {
+		got[r.Seat] = seatPathsText(r.Paths)
+	}
+	for seat, want := range map[string]string{
+		"node-hostname":      "/etc/hosts, /etc/hostname",
+		"node-uplink":        "/etc/resolv.conf (steps back for node-resolver)",
+		"node-resolver":      "/etc/resolv.conf",
+		"node-packet-filter": "—",
+	} {
+		if got[seat] != want {
+			t.Errorf("%s lists its paths as %q, not %q", seat, got[seat], want)
+		}
+	}
+}