selfcompose: ask a trunk build the catalog gave none of again on a backoff or a catalog-revision, not at every pass

A trunk build answered none waits laterAgain's step for its module (5 s growing to 5 min); the seat mesh-catalog's
event catalog-revision, heard through Env.Hear, ends the wait of every module at once; an answer starts the steps
again. A pass is woken at the step's end.

Builds: design 47 G-22 A-487a, A-461e, G-12 line 317
This commit is contained in:
2026-11-19 00:57:21 +01:00
parent 6e89a5defd
commit 6ac8952541
4 changed files with 161 additions and 4 deletions
+39 -2
View File
@@ -589,6 +589,9 @@ func (c *Composer) askTrunkBuilds() (wait func()) {
sayLines = append(sayLines, a.Said)
}
if a.NeedTrunk {
if r, backing := c.trunkRetry[module]; backing && c.now().Before(r.next) {
continue // the catalog gave none and its backoff runs: asked again at its end or at a catalog-revision (A-487a)
}
if had, asked := c.trunkBuilds[module]; !asked || had.running != a.RunFP {
asks = append(asks, ask{node, module, a.RunFP})
if c.trunkAsking == nil {
@@ -614,6 +617,7 @@ func (c *Composer) askTrunkBuilds() (wait func()) {
for a := range work {
t, why := c.trunkOf(a.module)
fp := t.fp
var wait time.Duration
c.mu.Lock()
delete(c.trunkAsking, a.module)
if fp != "" {
@@ -623,16 +627,20 @@ func (c *Composer) askTrunkBuilds() (wait func()) {
t.running = a.running
c.trunkBuilds[a.module] = t
delete(c.trunkWhy, a.module)
delete(c.trunkRetry, a.module)
} else {
if c.trunkWhy == nil {
c.trunkWhy = map[string]string{}
}
c.trunkWhy[a.module] = why
wait = c.trunkBackoffLocked(a.module)
}
c.mu.Unlock()
if fp == "" {
// Said with its reason, and asked again on the next pass: nothing is kept of an answer that was none (A-461e).
c.env.Say(fmt.Sprintf("the trunk build of %s, placed on %s, could not be had, and is asked again: %s", a.module, a.node, why))
// Said with its reason, and asked again at a catalog-revision or after its backoff, whichever comes first, never
// at every pass (A-461e, A-487a); the backoff wakes a pass at its end.
c.env.Say(fmt.Sprintf("the trunk build of %s, placed on %s, could not be had, and is asked again in %s or when the catalog says a revision: %s", a.module, a.node, wait, why))
time.AfterFunc(wait, c.askRehand)
continue
}
c.askRehand()
@@ -648,6 +656,35 @@ func (c *Composer) askTrunkBuilds() (wait func()) {
return all.Wait
}
// trunkBackoff is the asks of a module's trunk build that gave none, in a row, and the time before which it is not asked again.
type trunkBackoff struct {
tries int
next time.Time
}
// trunkBackoffLocked notes one more ask of the module's trunk build that gave none and returns the wait before it is asked again:
// laterAgain's, 5 s growing to 5 minutes (A-487a). Under mu.
func (c *Composer) trunkBackoffLocked(module string) time.Duration {
if c.trunkRetry == nil {
c.trunkRetry = map[string]trunkBackoff{}
}
r := c.trunkRetry[module]
wait := LaterWait(r.tries)
c.trunkRetry[module] = trunkBackoff{tries: r.tries + 1, next: c.now().Add(wait)}
return wait
}
// trunkRetryCleared ends the wait of every module whose trunk build the catalog gave none of, on the catalog's word that it holds a
// new revision: the next pass asks them again (A-487a). The asks in a row are kept, so one that fails again waits longer.
func (c *Composer) trunkRetryCleared() {
c.mu.Lock()
defer c.mu.Unlock()
for m, r := range c.trunkRetry {
r.next = time.Time{}
c.trunkRetry[m] = r
}
}
// entryManifest is an entry's manifest as a reader takes it, with its digest: the one the indexer set at take-in, or, where it set
// none, the digest of the manifest's bytes.
func entryManifest(e meshcatalog.CatalogEntry) (digest string, raw []byte, err error) {
+87
View File
@@ -666,3 +666,90 @@ func TestOnlyWhatTheNodeNeedsOfAnotherNodesPlacementIsAsked(t *testing.T) {
t.Errorf("the trunk builds asked are %v, want the store's holder and the bound provider alone", asked)
}
}
// A-487a (A-461e): a trunk build the catalog gave none of is not asked again at every pass: it waits laterAgain's step for the module
// (5 s, then 15 s), and the seat's event catalog-revision ends the wait at once; an answer starts the steps again from 5 s. The
// event is heard through Env.Hear on the seat's subject, whatever its branch.
func TestTrunkAskBackoffAndCatalogRevision(t *testing.T) {
old := meshcatalogclient.SourcePrefix2 + strings.Repeat("1", 64)
now := time.Date(2026, 11, 19, 10, 0, 0, 0, time.UTC)
var asks int
answers := false
env := newFakeBus().env()
env.Node = "n1"
env.Now = func() time.Time { return now }
env.Entry = EntryCall(func(_ context.Context, _, verb string, _ any) (json.RawMessage, error) {
if verb != meshcatalog.VerbModule {
return nil, errors.New("not held")
}
asks++
if !answers {
return nil, errors.New("the catalog is busy")
}
return json.Marshal(meshcatalog.ModuleAnswer{Module: meshcatalog.ModuleAnswerModule{Fp: old, Manifest: map[string]any{"module": "postgres"}}})
})
c := New(env)
c.mu.Lock()
c.wants["postgres"] = meshwants.WantsByWantNodeModuleValue{Fp: old}
c.assignments["n1"] = meshmoduleassigner.Assignments{Node: "n1", Modules: []meshmoduleassigner.PlacedModule{{Module: "postgres"}}}
c.heard = map[string]map[string]heardRun{"n1": {"postgres": {fingerprint: old}}}
c.mu.Unlock()
pass := func(want int, what string) {
t.Helper()
c.askTrunkBuilds()()
if asks != want {
t.Fatalf("%s: the catalog was asked %d times, want %d", what, asks, want)
}
}
pass(1, "first pass")
pass(1, "a second pass at once")
now = now.Add(4 * time.Second)
pass(1, "within the 5 s step")
now = now.Add(2 * time.Second)
pass(2, "after the 5 s step")
now = now.Add(14 * time.Second)
pass(2, "within the 15 s step")
c.trunkRetryCleared() // what hearing catalog-revision does
pass(3, "after catalog-revision")
pass(3, "the revision's ask gave none again: a step waits again")
answers = true
now = now.Add(time.Minute)
pass(4, "after the longer step")
if _, backing := c.trunkRetry["postgres"]; backing {
t.Errorf("an answer came and the backoff of the module stands: %+v", c.trunkRetry)
}
// The wiring: the composer hears the seat's event on its subject and clears the waits.
heard := make(chan []byte, 1)
env.Hear = func(subject string) (<-chan []byte, func(), error) {
if subject == CatalogRevisionEvents {
return heard, func() {}, nil
}
return make(chan []byte), func() {}, nil
}
answers = false
c = New(env)
c.mu.Lock()
c.trunkRetry = map[string]trunkBackoff{"postgres": {tries: 1, next: now.Add(time.Hour)}}
c.mu.Unlock()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if _, err := c.Watch(ctx, "n1.>"); err != nil {
t.Fatal(err)
}
heard <- []byte(`{}`)
deadline := time.After(5 * time.Second)
for {
c.mu.Lock()
next := c.trunkRetry["postgres"].next
c.mu.Unlock()
if next.IsZero() {
break
}
select {
case <-deadline:
t.Fatal("catalog-revision was heard and the wait of the module stands")
case <-time.After(5 * time.Millisecond):
}
}
}
+32 -2
View File
@@ -161,6 +161,10 @@ type SeatGate interface {
// VaultSecretChanged is the vault's event that a secret changed: a name and its generation, never a value.
const VaultSecretChanged = "mesh.mod.mesh-vault.event.secret-changed"
// CatalogRevisionEvents is the seat mesh-catalog's event catalog-revision, whatever branch its subject names: a node-engine asks
// again the trunk builds the catalog gave none of at once, not at the end of their backoff (A-487a, design 47 G-12 line 317).
const CatalogRevisionEvents = "mesh.seat.mesh-catalog.event.catalog-revision.>"
// Composer composes the node and is the agent's watcher of its compositions (agent.Env.Composed).
type Composer struct {
// OnEngine is told the node-engine's own module each time a composing finds it (design 47 G §527, §634); set before the
@@ -220,8 +224,11 @@ type Composer struct {
// trunkAsking is, by module, a trunk build being asked beside the pass (askTrunkBuilds), under mu.
trunkAsking map[string]bool
// trunkWhy is, by module, why the last ask of its trunk build gave none, for the words of the one place (A-484).
trunkWhy map[string]string
heardRead bool
trunkWhy map[string]string
// trunkRetry is, by module, the backoff of asking its trunk build again after an answer that was none: the asks made in a row
// without an answer and the time before which it is not asked (A-487a), under mu.
trunkRetry map[string]trunkBackoff
heardRead bool
// ends is, by module, the last build end naming no branch the builder said of it (NoteBuildEnded), its newest build that
// ended, under mu; endsRead is whether the first read of the builder's stream ended (BuildEndsRead) (design 47 G A-293).
ends map[string]builds.BuildEnded
@@ -540,6 +547,29 @@ func (c *Composer) Watch(ctx context.Context, _ string) (<-chan agent.Update, er
}(i, ch)
}
if c.env.Hear != nil {
revisions, stopRevisions, err := c.env.Hear(CatalogRevisionEvents)
if err != nil {
return nil, fmt.Errorf("the node asks the trunk builds again when the catalog says a revision, and cannot hear it: %w", err)
}
go func() {
defer stopRevisions()
for {
select {
case <-ctx.Done():
return
case _, ok := <-revisions:
if !ok {
return
}
c.trunkRetryCleared()
select {
case merged <- tagged{in: -1, ok: true}:
case <-ctx.Done():
return
}
}
}
}()
heard, stop, err := c.env.Hear(VaultSecretChanged)
if err != nil {
return nil, fmt.Errorf("the node composes again when a secret changes, and cannot hear the vault say so: %w", err)
+3
View File
@@ -249,6 +249,9 @@ func TestTheNodeComposesItsWantsFromTheBus(t *testing.T) {
}
secretChanged := make(chan []byte, 1)
env.Hear = func(subject string) (<-chan []byte, func(), error) {
if subject == CatalogRevisionEvents {
return make(chan []byte), func() {}, nil
}
if subject != VaultSecretChanged {
t.Errorf("heard %s", subject)
}