jochen
4499e85476
mesh/merge-gate pass: builds build-agent, mesh-controller, route-proxy → ace, g14, novox, shanks; no bus step; every machine composes with the change as it…
mesh/repo-check pass: its merge-check.sh passed
mesh/delivery delivered
mesh/delivery-group group feat/no-change-takes-effect-unseen delivered: every member is delivered
Two incidents had one shape: a change took effect that nobody saw first (hq issues 241, 304). Three guards, each silent when nothing is at stake: - settings show [--history], and a set that answers each key it adds, changes and removes, and refuses a removal unless --replace; the replaced or cleared layer is kept in settings_history, in the same transaction as the write (migration 0078). - every send keeps a summary of what it sent (no file content), plan <node> --diff compares with it, and push with no machine is refused unless --all. - a push that would give a running container's mount another host directory holds that machine, naming the module, mount and both directories, until push <node> --move <module>; a named push's cascade is held the same way. Rebased onto main and fitted to it: the hold runs before the push says what it recreates, a whole push still says so first and leaves machines waiting for a gate, the verb's push with no machine is still --behind and a push still needs why. The verbs take plan diff, settings replace and history, and push move beside a machine, each refused where it cannot take effect.
46 lines
1.4 KiB
Go
46 lines
1.4 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// A cascade round gives its hold back on every way out: a declaration that cannot be marshalled
|
|
// and a send that fails leave nobody waiting for the node.
|
|
func TestASendRoundGivesItsHoldBackOnEveryWayOut(t *testing.T) {
|
|
open := aMesh(t)
|
|
ctx := t.Context()
|
|
unmarshallable := func(context.Context, string) (sendable, error) {
|
|
return sendable{Resources: []map[string]any{{"id": "x", "bad": make(chan int)}}}, nil
|
|
}
|
|
plain := func(context.Context, string) (sendable, error) {
|
|
return sendable{Resources: []map[string]any{{"id": "x"}}}, nil
|
|
}
|
|
failing := &recordingDelivery{declareErr: errors.New("the broker went away")}
|
|
fine := &recordingDelivery{}
|
|
|
|
for name, round := range map[string]func() error{
|
|
"a body that cannot be marshalled": func() error {
|
|
_, err := sendRound(ctx, open, []string{"anchor"}, unmarshallable, fine, "", nil)
|
|
return err
|
|
},
|
|
"a send that fails": func() error {
|
|
_, err := sendRound(ctx, open, []string{"anchor"}, plain, failing, "", nil)
|
|
return err
|
|
},
|
|
} {
|
|
if err := round(); err == nil {
|
|
t.Fatalf("%s was not an error", name)
|
|
}
|
|
waiting, cancel := context.WithTimeout(ctx, 2*time.Second)
|
|
release, err := open.inventory.HoldNodes(waiting, []string{"anchor"})
|
|
cancel()
|
|
if err != nil {
|
|
t.Fatalf("after %s the node is still held: %v", name, err)
|
|
}
|
|
release()
|
|
}
|
|
}
|