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)

modules/mesh-config/cmd/mesh-config/config_test.go

@@ -134,34 +134,58 @@ func (m *memStore) unassign(t *testing.T, node, module string) {
 	m.place(t, node, module, false)
 }
 
+// place writes a node's placement as the seat writes it: its node key and module keys (research 072 row 37), and for
+// ace in the form before, `placement.ace`, which a reader still takes while the change is delivered.
 func (m *memStore) place(t *testing.T, node, module string, on bool) {
 	t.Helper()
-	type placed struct {
-		Module string `json:"module"`
+	keys := map[string][]byte{}
+	for _, k := range m.keysOf(PlacementRead) {
+		e, _ := m.Get(PlacementRead, k)
+		keys[k] = e.Value
 	}
-	p := struct {
-		V       int      `json:"v"`
-		Node    string   `json:"node"`
-		Modules []placed `json:"modules"`
-	}{V: 1, Node: node}
-	if e, _ := m.Get(PlacementRead, "placement."+node); e != nil {
-		if err := json.Unmarshal(e.Value, &p); err != nil {
-			t.Fatal(err)
-		}
+	all, err := delivery.PlacementsOf(keys)
+	if err != nil {
+		t.Fatal(err)
 	}
-	var kept []placed
+	p := all[node]
+	p.Node = node
+	var kept []delivery.PlacedModule
 	for _, x := range p.Modules {
 		if x.Module != module {
 			kept = append(kept, x)
 		}
 	}
 	if on {
-		kept = append(kept, placed{Module: module})
+		kept = append(kept, delivery.PlacedModule{Module: module})
 	}
 	p.Modules = kept
-	if err := m.Put(PlacementRead, "placement."+node, p); err != nil {
+	for _, k := range m.keysOf(PlacementRead) {
+		if n, _, _, err := delivery.ParsePlacementKey(k); err == nil && n == node {
+			_ = m.Delete(PlacementRead, k)
+		}
+	}
+	if node == "ace" {
+		raw, err := delivery.EncodePlacement(p)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_ = m.Put(PlacementRead, "placement.ace", json.RawMessage(raw))
+		return
+	}
+	values, err := delivery.PlacementValues(p)
+	if err != nil {
 		t.Fatal(err)
 	}
+	for k, raw := range values {
+		if err := m.Put(PlacementRead, k, json.RawMessage(raw)); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func (m *memStore) keysOf(state string) []string {
+	keys, _ := m.Keys(state)
+	return keys
 }
 
 // manifest keeps a manifest in the indexer's manifests by its digest, as the indexer writes it, and answers the digest.

modules/mesh-config/cmd/mesh-config/sources.go

@@ -70,32 +70,32 @@ func (c *Config) sourcesFrom(source string) (Sources, error) {
 	return s, nil
 }
 
-// readPlacement is every module the seat mesh-placement places on a node (ADR 0567 §1, §9): each node's key
-// `placement.<node>`.
+// readPlacement is every module the seat mesh-placement places on a node (ADR 0567 §1, §9), from the state's keys in
+// either form: a node key and its module keys, or the form before, `placement.<node>` (delivery.PlacementsOf;
+// research 072 row 37). By node in name order, each node's modules in the order its placement names them.
 func (c *Config) readPlacement(s *Sources) error {
-	placed := map[string]bool{}
-	return c.each(PlacementRead, func(key string, raw []byte) error {
-		node, err := delivery.ParsePlacementKey(key)
-		if err != nil {
-			return nil // a key of another kind
-		}
-		var p struct {
-			Node    string `json:"node"`
-			Modules []struct {
-				Module string `json:"module"`
-			} `json:"modules"`
-		}
-		if err := json.Unmarshal(raw, &p); err != nil || p.Node != node {
-			return fmt.Errorf("the placement %s is not one", key)
-		}
-		for _, m := range p.Modules {
-			if m.Module != "" && !placed[node+"."+m.Module] {
-				placed[node+"."+m.Module] = true
-				s.Assignments = append(s.Assignments, Assignment{Node: node, Module: m.Module})
-			}
-		}
+	keys := map[string][]byte{}
+	if err := c.each(PlacementRead, func(key string, raw []byte) error {
+		keys[key] = raw
 		return nil
-	})
+	}); err != nil {
+		return err
+	}
+	placements, err := delivery.PlacementsOf(keys)
+	if err != nil {
+		return fmt.Errorf("the placement is not read whole: %w", err)
+	}
+	nodes := make([]string, 0, len(placements))
+	for node := range placements {
+		nodes = append(nodes, node)
+	}
+	sort.Strings(nodes)
+	for _, node := range nodes {
+		for _, module := range placements[node].Assigned() {
+			s.Assignments = append(s.Assignments, Assignment{Node: node, Module: module})
+		}
+	}
+	return nil
 }
 
 // readDeclarations reads each placed module's declarations from its manifests as the delivery holds them: the trunk's