Read the seat mesh-placement's state through the sdk's PlacementKeys in mesh-conditions, mesh-config, mesh-provisioner, mesh-vault and mesh-self-check, so they read its keys per module and node and the form before alike while it is delivered (issue 774, research 072 row 37)

2026-10-31 09:27:15 +01:00
parent 21fddffc6e
commit 85c336f260
23 changed files with 235 additions and 150 deletions
@@ -25,7 +25,8 @@ type PlacementReader struct {
 	Read func(key string) ([]byte, error)
 }

-// placements is every node's placement, by node; none when the vault reads no placement.
+// placements is every node's placement, by node, from the state's keys in either form (delivery.PlacementsOf; research
+// 072 row 37); none when the vault reads no placement. A node whose keys do not read whole is read as they stand.
 func (v *Vault) placements() (map[string]delivery.Placement, error) {
 	out := map[string]delivery.Placement{}
 	if v.Placement.Keys == nil || v.Placement.Read == nil {
@@ -35,52 +36,73 @@ func (v *Vault) placements() (map[string]delivery.Placement, error) {
 	if err != nil {
 		return nil, fmt.Errorf("the placement's keys could not be read: %w", err)
 	}
+	values := map[string][]byte{}
 	for _, k := range keys {
-		node, err := delivery.ParsePlacementKey(k)
-		if err != nil {
+		if _, _, _, err := delivery.ParsePlacementKey(k); err != nil {
 			continue
 		}
 		raw, err := v.Placement.Read(k)
 		if err != nil {
-			return nil, fmt.Errorf("the placement of %s could not be read: %w", node, err)
+			return nil, fmt.Errorf("the placement's key %s could not be read: %w", k, err)
 		}
-		if raw == nil {
-			continue
+		if raw != nil {
+			values[k] = raw
 		}
-		p, err := delivery.DecodePlacement(raw)
-		if err != nil || p.Node != node {
-			continue
-		}
-		out[node] = p
 	}
+	out, _ = delivery.PlacementsOf(values)
 	return out, nil
 }

+// nodePlaced is what node's own key of the placement says: the modules placed there and what a person decided of it,
+// read from its node key `<node>.node` alone (which names every module placed, research 072 row 37), or, for a node not
+// converted yet, from its key in the form before, `placement.<node>`. found is false when it has neither.
+func (v *Vault) nodePlaced(node string) (modules []string, decided delivery.NodeDecided, found bool, err error) {
+	key, err := delivery.PlacementNodeKey(node)
+	if err != nil {
+		return nil, decided, false, err
+	}
+	raw, err := v.Placement.Read(key)
+	if err != nil {
+		return nil, decided, false, err
+	}
+	if raw != nil {
+		n, err := delivery.DecodePlacementNode(raw)
+		if err != nil {
+			return nil, decided, false, fmt.Errorf("the placement of %s is not readable: %w", node, err)
+		}
+		for _, r := range n.Modules {
+			modules = append(modules, r.Module)
+		}
+		return modules, n.Decided, true, nil
+	}
+	legacy, err := delivery.LegacyPlacementKey(node)
+	if err != nil {
+		return nil, decided, false, err
+	}
+	if raw, err = v.Placement.Read(legacy); err != nil || raw == nil {
+		return nil, decided, false, err
+	}
+	p, err := delivery.DecodePlacement(raw)
+	if err != nil {
+		return nil, decided, false, fmt.Errorf("the placement of %s is not readable: %w", node, err)
+	}
+	return p.Assigned(), p.Decided, true, nil
+}
+
 // placedOn says module is placed on node by the catalogue.
 func (v *Vault) placedOn(node, module string) (bool, error) {
 	placed, err := v.placedModules(node)
 	return slices.Contains(placed, module), err
 }

-// placedModules is every module the catalogue places on node, read from the node's one key of the placement; none when
-// the vault reads no placement or the node has no key.
+// placedModules is every module the catalogue places on node, read from the node's own key of the placement
+// (nodePlaced); none when the vault reads no placement or the node has no key.
 func (v *Vault) placedModules(node string) ([]string, error) {
 	if v.Placement.Read == nil {
 		return nil, nil
 	}
-	key, err := delivery.PlacementKey(node)
-	if err != nil {
-		return nil, err
-	}
-	raw, err := v.Placement.Read(key)
-	if err != nil || raw == nil {
-		return nil, err
-	}
-	p, err := delivery.DecodePlacement(raw)
-	if err != nil {
-		return nil, fmt.Errorf("the placement of %s is not readable: %w", node, err)
-	}
-	return p.Assigned(), nil
+	modules, _, _, err := v.nodePlaced(node)
+	return modules, err
 }

 // standsOn says module stands on node: placed there, or assigned there while the assignments stand. A read that fails is
@@ -16,12 +16,14 @@ func placementsOf(t *testing.T, nodes map[string][]string) PlacementReader {
 		for _, m := range modules {
 			p.Modules = append(p.Modules, delivery.PlacedModule{Module: m})
 		}
-		raw, err := delivery.EncodePlacement(p)
+		// Research 072 row 37: the node key and a key per module.
+		kv, err := delivery.PlacementValues(p)
 		if err != nil {
 			t.Fatal(err)
 		}
-		key, _ := delivery.PlacementKey(node)
-		values[key] = raw
+		for k, raw := range kv {
+			values[k] = raw
+		}
 	}
 	return PlacementReader{
 		Keys: func() ([]string, error) {
@@ -303,22 +303,14 @@ func (v *Vault) internalName(node string) (string, error) {
 	if v.Placement.Read == nil {
 		return "", errors.New("the vault reads no placement, so it cannot tell a node's internal name")
 	}
-	key, err := delivery.PlacementKey(node)
-	if err != nil {
-		return "", err
-	}
-	raw, err := v.Placement.Read(key)
+	_, decided, found, err := v.nodePlaced(node)
 	if err != nil {
 		return "", fmt.Errorf(notYetPrefix+"the placement of %s could not be read: %w", node, err)
 	}
-	if raw == nil {
+	if !found {
 		return "", fmt.Errorf("%s has no placement of the seat mesh-placement, so it has no name inside the mesh", node)
 	}
-	p, err := delivery.DecodePlacement(raw)
-	if err != nil {
-		return "", fmt.Errorf("the placement of %s is not readable: %w", node, err)
-	}
-	if p.Decided.Address == "" {
+	if decided.Address == "" {
 		return "", fmt.Errorf("%s is not on the private network (its placement names no address), so it has no name inside the mesh to be certified for", node)
 	}
 	return overlay.InternalName(node), nil
@@ -40,16 +40,21 @@ func TestTheVaultSigns(t *testing.T) {
 		"g14":   {Node: "g14", Decided: delivery.NodeDecided{Address: "10.77.0.4"}},
 		"plain": {Node: "plain"},
 	}
+	// Research 072 row 37: ace and plain in their keys per module and node, g14 still in the form before.
 	v.Placement = PlacementReader{Read: func(key string) ([]byte, error) {
-		node, err := delivery.ParsePlacementKey(key)
+		node, _, kind, err := delivery.ParsePlacementKey(key)
 		if err != nil {
 			return nil, err
 		}
 		p, ok := placements[node]
-		if !ok {
+		if !ok || (node == "g14") != (kind == delivery.PlacementLegacyKind) {
 			return nil, nil
 		}
-		return delivery.EncodePlacement(p)
+		if kind == delivery.PlacementLegacyKind {
+			return delivery.EncodePlacement(p)
+		}
+		values, err := delivery.PlacementValues(p)
+		return values[key], err
 	}}
 	records := map[string]string{"ace": base64.StdEncoding.EncodeToString(servingPub), "plain": base64.StdEncoding.EncodeToString(servingPub)}
 	v.Haves = func(key string) ([]byte, error) {