158 lines
9.3 KiB
Go
158 lines
9.3 KiB
Go
package assign
|
|
|
|
import (
|
|
"encoding/json"
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/asks"
|
|
"git.novox.be/novox/mesh-sdk/go/delivery"
|
|
)
|
|
|
|
// ADR 0567 §2, §5, §7, §8: what the seat's holder decides of a proposal: every refusal named at once, a valid one laid
|
|
// with the base revision of each key it changes, the writes at those revisions, the controller's calls that keep its
|
|
// assignments in step, the authorising ask bound to the changes, and the export read as the controller answers it.
|
|
func TestThePlacementSeatDecides(t *testing.T) {
|
|
anchor := delivery.Placement{V: delivery.Version, Node: "anchor", Decided: delivery.NodeDecided{Hub: true, Address: "10.0.0.1"},
|
|
Modules: []delivery.PlacedModule{{Module: "store", Ports: map[string]int{"5432": 5432}}, {Module: "web"}}}
|
|
laptop := delivery.Placement{V: delivery.Version, Node: "laptop", Decided: delivery.NodeDecided{Address: "10.0.0.2"}, Modules: []delivery.PlacedModule{{Module: "shell"}}}
|
|
in := func(changes ...delivery.PlacementProposalChange) ProposeIn {
|
|
return ProposeIn{ID: "p-one", By: "operator@laptop", Why: "move web", At: time.Unix(1, 0), Changes: changes,
|
|
Current: map[string]delivery.Placement{"anchor": anchor, "laptop": laptop}, Revisions: map[string]uint64{"anchor": 4, "laptop": 9},
|
|
Held: func(m string) bool { return m != "ghost" },
|
|
Recorded: func(n string) bool { return n == "anchor" || n == "laptop" }}
|
|
}
|
|
move := []delivery.PlacementProposalChange{{Op: delivery.OpTakeOff, Node: "anchor", Module: "web"}, {Op: delivery.OpPlace, Node: "laptop", Module: "web"}}
|
|
p, laid, findings := Propose(in(move...))
|
|
if len(findings) != 0 || p.State != delivery.ProposalAnswering || p.Base["anchor"] != 4 || p.Base["laptop"] != 9 ||
|
|
!slices.Equal(laid["laptop"].Assigned(), []string{"shell", "web"}) || !slices.Equal(laid["anchor"].Assigned(), []string{"store"}) {
|
|
t.Fatalf("a move: %+v, %+v, %v", p, laid, findings)
|
|
}
|
|
if _, err := delivery.EncodePlacementProposal(p); err != nil {
|
|
t.Fatalf("the proposal cannot be written: %v", err)
|
|
}
|
|
for name, c := range map[string]struct {
|
|
in ProposeIn
|
|
want string
|
|
}{
|
|
"a port before the lease": {in(delivery.PlacementProposalChange{Op: delivery.OpPlace, Node: "laptop", Module: "web", Ports: map[string]int{"80": 8080}}), "lease write"},
|
|
"a holding": {in(delivery.PlacementProposalChange{Op: delivery.OpHold, Node: "anchor", Module: "store", Claim: "mesh-store", Scope: "mesh"}), "lease write"},
|
|
"a binding": {in(delivery.PlacementProposalChange{Op: delivery.OpPlace, Node: "laptop", Module: "web", Bindings: map[string]delivery.Provider{"db": {Node: "anchor", Module: "store"}}}), "lease write"},
|
|
"a config place": {in(delivery.PlacementProposalChange{Op: delivery.OpConfig, Node: "anchor", Module: "web", Layer: map[string]any{"places": []any{}}}), "lease write"},
|
|
"a config access": {in(delivery.PlacementProposalChange{Op: delivery.OpConfig, Node: "anchor", Module: "web", MeshWide: map[string]any{"accesses": []any{}}}), "lease write"},
|
|
"a module not held": {in(delivery.PlacementProposalChange{Op: delivery.OpPlace, Node: "laptop", Module: "ghost"}), "the indexer holds no module ghost"},
|
|
"a node with no record": {in(delivery.PlacementProposalChange{Op: delivery.OpPlace, Node: "stranger", Module: "web"}), "stranger is a node with no record"},
|
|
"nothing changes": {in(delivery.PlacementProposalChange{Op: delivery.OpPlace, Node: "anchor", Module: "web"}), "leave every placement as it is"},
|
|
"no why": {func() ProposeIn { i := in(move...); i.Why = " "; return i }(), "says why"},
|
|
"no caller": {func() ProposeIn { i := in(move...); i.By = ""; return i }(), "names no caller"},
|
|
"a seed by hand": {in(delivery.PlacementProposalChange{Op: delivery.OpSeed, Node: "laptop", Whole: &laptop}), "adopt's alone"},
|
|
"a pin of nobody placed": {in(delivery.PlacementProposalChange{Op: delivery.OpPin, Node: "laptop", Provision: "db", Provider: &delivery.Provider{Node: "laptop", Module: "store"}}), "not placed there"},
|
|
} {
|
|
if _, _, f := Propose(c.in); !slices.ContainsFunc(f, func(s string) bool { return strings.Contains(s, c.want) }) {
|
|
t.Errorf("%s: findings %v, want one naming %q", name, f, c.want)
|
|
}
|
|
}
|
|
|
|
// A module's config values may be proposed before the lease write (§13); once the lease is written every change is
|
|
// the state's alone, and none waits.
|
|
if _, _, f := Propose(in(delivery.PlacementProposalChange{Op: delivery.OpConfig, Node: "anchor", Module: "web", Values: map[string]any{"puid": 1}})); len(f) != 0 {
|
|
t.Errorf("config values before the lease write: %v", f)
|
|
}
|
|
for _, c := range []delivery.PlacementProposalChange{
|
|
{Op: delivery.OpPlace, Node: "laptop", Module: "web", Ports: map[string]int{"80": 8080}, Bindings: map[string]delivery.Provider{"db": {Node: "anchor", Module: "store"}}},
|
|
{Op: delivery.OpConfig, Node: "anchor", Module: "web", Layer: map[string]any{"places": []any{}}},
|
|
{Op: delivery.OpDecide, Node: "laptop", Field: "site", Value: json.RawMessage(`"attic"`)},
|
|
{Op: delivery.OpHold, Node: "anchor", Module: "store", Claim: "node-shell", Scope: "node"},
|
|
} {
|
|
leased := in(c)
|
|
leased.Leased = true
|
|
if _, _, f := Propose(leased); len(f) != 0 {
|
|
t.Errorf("after the lease write %s is refused: %v", c.Op, f)
|
|
}
|
|
}
|
|
|
|
// A key moved while the warrant wrote: what is left to write is the other nodes' changes, to be laid and asked again.
|
|
if rest, ok := Rest(p, map[string]*delivery.Placement{"anchor": laid["anchor"]}); !ok || len(rest.Changes) != 1 || rest.Changes[0].Node != "laptop" ||
|
|
len(rest.Base) != 1 || rest.State != delivery.ProposalAnswering || rest.Must != nil {
|
|
t.Errorf("the rest = %+v, %v", rest, ok)
|
|
}
|
|
if _, ok := Rest(p, laid); ok {
|
|
t.Error("a proposal written whole leaves something to write")
|
|
}
|
|
|
|
// The seat says it waits while one of its states is not bound, naming it, and clears once all are.
|
|
for _, unbound := range [][]string{{delivery.PlacementPulsesBucket}, nil} {
|
|
c := SeatWaitsCondition(unbound)
|
|
if _, err := asks.EncodeCondition(c); err != nil || (len(unbound) > 0) != (c.State == asks.StateRaised) ||
|
|
(len(unbound) > 0 && !strings.Contains(c.Explanation, "the seat waits for its states: "+delivery.PlacementPulsesBucket)) {
|
|
t.Errorf("waiting for %v: %+v, %v", unbound, c, err)
|
|
}
|
|
}
|
|
|
|
// Issue 1126: the seed places the private network, which no repository holds; it is the mesh's own, and passes.
|
|
wired := laptop
|
|
wired.Modules = append(slices.Clone(laptop.Modules), delivery.PlacedModule{Module: "mesh-wireguard"})
|
|
seed := in(SeedChanges(map[string]delivery.Placement{"laptop": wired})...)
|
|
seed.Seed, seed.ExportDigest, seed.Current, seed.Revisions = true, "sha256:x", map[string]delivery.Placement{}, map[string]uint64{}
|
|
seed.Held = func(m string) bool { return m != "mesh-wireguard" } // the indexer holds every module but it
|
|
if _, _, f := Propose(seed); len(f) != 0 {
|
|
t.Errorf("a seed placing the private network is refused: %v", f)
|
|
}
|
|
|
|
writes, err := Writes(p, laid)
|
|
if err != nil || len(writes) != 2 || writes[0].Key != "placement.anchor" || writes[0].Base != 4 || writes[1].Base != 9 {
|
|
t.Fatalf("writes = %+v, %v", writes, err)
|
|
}
|
|
pinned := *laid["laptop"]
|
|
pinned.Pins = map[string]delivery.Provider{"db": {Node: "anchor", Module: "store"}}
|
|
calls := ControllerCalls(map[string]delivery.Placement{"anchor": anchor, "laptop": laptop},
|
|
map[string]*delivery.Placement{"anchor": laid["anchor"], "laptop": &pinned}, "p-one", "w1@t")
|
|
var said []string
|
|
for _, c := range calls {
|
|
said = append(said, c.Key())
|
|
if !strings.Contains(c.Args["why"].(string), "p-one") {
|
|
t.Errorf("%s does not name the proposal: %v", c.Key(), c.Args)
|
|
}
|
|
}
|
|
if !slices.Equal(said, []string{"mesh-controller.unassign anchor web", "mesh-controller.assign laptop web", "mesh-controller.pin laptop db"}) {
|
|
t.Errorf("the controller's calls = %v", said)
|
|
}
|
|
|
|
a, err := PlacementAsk("placement.p-one", p, "move web (proposed by operator@laptop)", 7, time.Unix(100, 0))
|
|
if err != nil || a.Ask.Check(time.Unix(100, 0)) != nil || a.Ask.Options[0].Level != asks.Approve || a.Ask.Options[0].Performs(PlacementAct(p)) != nil {
|
|
t.Fatalf("the ask = %+v, %v", a, err)
|
|
}
|
|
q := p
|
|
q.Changes = append(slices.Clone(p.Changes), delivery.PlacementProposalChange{Op: delivery.OpUnpin, Node: "laptop", Provision: "x"})
|
|
if a.Ask.Options[0].Performs(PlacementAct(q)) == nil {
|
|
t.Error("the ask's yes binds changes it was not asked about")
|
|
}
|
|
|
|
export, _ := json.Marshal(map[string]any{"anchor": anchor, "laptop": laptop})
|
|
for name, c := range map[string]struct {
|
|
raw string
|
|
want int
|
|
}{
|
|
"in output": {`{"ok":true,"output":` + quote(string(export)+"\n") + `}`, 2},
|
|
"as answer": {`{"ok":true,"output":"","answer":` + string(export) + `}`, 2},
|
|
"refused": {`{"ok":false,"output":"no store"}`, 0},
|
|
"no node": {`{"ok":true,"output":"{}"}`, 0},
|
|
"no version": {`{"ok":true,"output":"{\"anchor\":{\"node\":\"anchor\",\"modules\":[]}}"}`, 0},
|
|
} {
|
|
got, err := ExportOf([]byte(c.raw))
|
|
if len(got) != c.want || (c.want == 0) != (err != nil) {
|
|
t.Errorf("%s: %d nodes, %v", name, len(got), err)
|
|
}
|
|
}
|
|
if seed := SeedChanges(map[string]delivery.Placement{"laptop": laptop, "anchor": anchor}); len(seed) != 2 || seed[0].Node != "anchor" || seed[0].Op != delivery.OpSeed {
|
|
t.Errorf("the seed's changes = %+v", seed)
|
|
}
|
|
}
|
|
|
|
func quote(s string) string {
|
|
raw, _ := json.Marshal(s)
|
|
return string(raw)
|
|
}
|