183 lines
7.5 KiB
Go
183 lines
7.5 KiB
Go
package selfcompose
|
|
|
|
import (
|
|
"context"
|
|
"git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient"
|
|
"git.novox.be/novox/mesh-contracts/go/seats/meshmoduleassigner"
|
|
"git.novox.be/novox/mesh-contracts/go/seats/nodeengine"
|
|
"git.novox.be/novox/mesh-delivery/contracts/go/clients/meshcatalogclient"
|
|
"git.novox.be/novox/mesh-delivery/contracts/go/seats/meshcatalog"
|
|
"git.novox.be/novox/mesh-delivery/contracts/go/seats/meshwants"
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds"
|
|
"github.com/novox/mesh-host/internal/buckets"
|
|
"github.com/novox/mesh-host/internal/buckets/bucketstest"
|
|
engcomp "github.com/novox/mesh-host/internal/compositions"
|
|
"slices"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/novox/mesh-host/internal/agent"
|
|
)
|
|
|
|
// fakeComposed is a node's composition state: its keys, and every write and deletion made.
|
|
type fakeComposed struct {
|
|
mu sync.Mutex
|
|
kv map[string]ComposedEntry
|
|
rev uint64
|
|
puts []string
|
|
deletes []string
|
|
}
|
|
|
|
func (f *fakeComposed) Entries(context.Context) (map[string]ComposedEntry, error) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
out := map[string]ComposedEntry{}
|
|
for k, v := range f.kv {
|
|
out[k] = v
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (f *fakeComposed) Put(_ context.Context, key string, value []byte) (uint64, error) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
f.rev++
|
|
f.kv[key] = ComposedEntry{Value: value, Revision: f.rev}
|
|
f.puts = append(f.puts, key)
|
|
return f.rev, nil
|
|
}
|
|
|
|
func (f *fakeComposed) Delete(_ context.Context, key string) error {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
delete(f.kv, key)
|
|
f.deletes = append(f.deletes, key)
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeComposed) written() []string {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
return slices.Clone(f.puts)
|
|
}
|
|
|
|
// novox/hq ADR 0593 §6: the node publishes each composition it makes in its composition state, a record never applied:
|
|
// the wanted module and the node's own at the first pass; nothing again for a pass that changes nothing; a done build
|
|
// of a module placed here that no want names, at its trunk's build, written once as its own key (before any want moves);
|
|
// the same build landing again writes nothing. And a module's keys are kept while among the five it wrote last or named
|
|
// by a want, and deleted otherwise.
|
|
func TestTheNodePublishesItsCompositions(t *testing.T) {
|
|
t.Run("the verb compose is answered while a pass runs", composeAnsweredWhileAPassRuns)
|
|
b := newFakeBus()
|
|
fp := meshcatalogclient.SourcePrefix2 + strings.Repeat("a", 64)
|
|
ofp := meshcatalogclient.SourcePrefix2 + strings.Repeat("c", 64)
|
|
digest := meshcatalogclient.ManifestDigest([]byte(lemurs))
|
|
oldie := `{"module":"oldie","version":"1","capabilities":["systemd"],"resources":[{"id":"service","type":"service","unit":"oldie.service","state":"running","boot":"enabled"}]}`
|
|
odigest := meshcatalogclient.ManifestDigest([]byte(oldie))
|
|
for d, json := range map[string]string{digest: lemurs, odigest: oldie} {
|
|
man, _ := meshcatalogclient.EncodeManifest(meshcatalog.ManifestsByDigestValue{Module: map[string]string{digest: "lemurs", odigest: "oldie"}[d], Manifest: json})
|
|
key, _ := meshcatalogclient.ManifestsKey(d)
|
|
b.kv[buckets.Manifests+"/"+key] = man
|
|
}
|
|
state := &fakeComposed{kv: map[string]ComposedEntry{}}
|
|
env := b.env()
|
|
env.ComposedState = state
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
c := New(env)
|
|
out, err := c.Watch(ctx, "n1.>")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
place := assignedValues(t, meshmoduleassigner.Assignments{Node: "n1", Decided: meshmoduleassigner.NodeDecided{Hub: true, Address: "10.77.0.1"},
|
|
Modules: []meshmoduleassigner.PlacedModule{{Module: "lemurs"}, {Module: "oldie"}}})
|
|
have, _ := nodeengineclient.EncodeHaveNode(nodeengine.HaveByNodeNodeValue{Record: &nodeengine.NodeRecord{Node: "n1", TunnelKey: "k", SealingKey: "sk", Capabilities: []string{"systemd"}}})
|
|
mod, _ := meshcatalogclient.EncodeModule(meshcatalog.ModulesByModuleValue{Fp2: fp, Manifest: digest, Repository: "novox/x", Commit: "c"})
|
|
omod, _ := meshcatalogclient.EncodeModule(meshcatalog.ModulesByModuleValue{Fp2: ofp, Manifest: odigest, Repository: "novox/o", Commit: "c"})
|
|
want, _ := bucketstest.Want(meshwants.WantsByWantNodeModuleValue{Fp: fp, Self: true})
|
|
nodeWant, _ := bucketstest.NodeWant(meshwants.WantsByWantNodeNodeValue{Self: true})
|
|
b.putAssigned(t, place)
|
|
b.put(t, buckets.Have, "n1.node", have)
|
|
b.put(t, buckets.Modules, "lemurs", mod)
|
|
b.put(t, buckets.Modules, "oldie", omod)
|
|
b.put(t, buckets.Wants, "want.n1.lemurs", want)
|
|
b.put(t, buckets.Wants, "want.n1.node", nodeWant)
|
|
for _, bucket := range []string{buckets.Wants, buckets.Assignments, buckets.Have, buckets.Modules, ResolvedBucket, builds.BuilderBuildsBucket} {
|
|
b.send(bucket, agent.Update{Caught: true})
|
|
}
|
|
for u := next(t, out); !u.Caught; u = next(t, out) {
|
|
}
|
|
lemursKey, _ := engcomp.Key("n1", "lemurs", fp)
|
|
oldieKey, _ := engcomp.Key("n1", "oldie", ofp)
|
|
waitFor := func(what string, ok func([]string) bool) []string {
|
|
t.Helper()
|
|
deadline := time.Now().Add(5 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
if got := state.written(); ok(got) {
|
|
return got
|
|
}
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
b.mu.Lock()
|
|
t.Logf("said: %q", b.said)
|
|
b.mu.Unlock()
|
|
t.Fatalf("%s: written %v", what, state.written())
|
|
return nil
|
|
}
|
|
first := waitFor("the first pass", func(got []string) bool { return len(got) >= 2 })
|
|
if !slices.Equal(first, []string{lemursKey, "n1.node"}) {
|
|
t.Errorf("the first pass wrote %v, want the wanted module's key and the node's own", first)
|
|
}
|
|
if raw := state.kv[lemursKey].Value; raw != nil {
|
|
comp, err := engcomp.Decode(raw)
|
|
if err != nil || comp.Module != "lemurs" || comp.FP != fp || len(comp.Resources) == 0 {
|
|
t.Errorf("the published composition of lemurs: %+v, %v", comp, err)
|
|
}
|
|
}
|
|
// A pass that changes nothing writes nothing.
|
|
setFor(t, &askedWithin, 0)
|
|
if _, err := c.ComposeNow(ctx); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
time.Sleep(50 * time.Millisecond)
|
|
if got := state.written(); len(got) != 2 {
|
|
t.Errorf("a pass that changed nothing wrote %v", got[2:])
|
|
}
|
|
// oldie's trunk build is done: its key at that build is written once, though no want names it.
|
|
build, _ := builds.EncodeBuilderBuild(builds.BuilderBuild{State: builds.BuildDone, Manifest: odigest})
|
|
bkey, _ := builds.BuilderBuildKey("oldie", ofp)
|
|
b.mu.Lock()
|
|
b.kv[builds.BuilderBuildsBucket+"/"+bkey] = build
|
|
b.mu.Unlock()
|
|
b.put(t, builds.BuilderBuildsBucket, bkey, build)
|
|
got := waitFor("oldie's done build", func(got []string) bool { return len(got) >= 3 })
|
|
if got[2] != oldieKey {
|
|
t.Errorf("the done build of oldie wrote %v, want %s", got[2:], oldieKey)
|
|
}
|
|
b.put(t, builds.BuilderBuildsBucket, bkey, build)
|
|
time.Sleep(100 * time.Millisecond)
|
|
if got := state.written(); len(got) != 3 {
|
|
t.Errorf("the same build landing again wrote %v", got[3:])
|
|
}
|
|
|
|
// What is kept: the five keys of a module written last, and one a want names; the rest is deleted.
|
|
keep := New(b.env())
|
|
keep.pubKept = map[string]ComposedEntry{}
|
|
var keys []string
|
|
for i, ch := range "123456" {
|
|
key, _ := engcomp.Key("n1", "lemurs", meshcatalogclient.SourcePrefix2+strings.Repeat(string(ch), 64))
|
|
keys = append(keys, key)
|
|
keep.pubKept[key] = ComposedEntry{Revision: uint64(10 + i)}
|
|
}
|
|
keep.pubKept["n1.node"] = ComposedEntry{Revision: 1}
|
|
if past := keep.pastKeeping(); !slices.Equal(past, []string{keys[0]}) {
|
|
t.Errorf("past keeping: %v, want the oldest of six, %s", past, keys[0])
|
|
}
|
|
keep.wants = map[string]meshwants.WantsByWantNodeModuleValue{"lemurs": {Fp: meshcatalogclient.SourcePrefix2 + strings.Repeat("1", 64)}}
|
|
if past := keep.pastKeeping(); len(past) != 0 {
|
|
t.Errorf("past keeping with a want naming the oldest: %v, want none", past)
|
|
}
|
|
}
|