diff --git a/node-tools/internal/firstview/firstview.go b/node-tools/internal/firstview/firstview.go index 604c93c..5fa5ef7 100644 --- a/node-tools/internal/firstview/firstview.go +++ b/node-tools/internal/firstview/firstview.go @@ -58,18 +58,19 @@ func (s Spec) Name() string { return AssignerSeat + "." + s.State } // Views is the first views: the assigner's two, and the catalog half's per watched branch. type Views struct { - logf func(string, ...any) - mu sync.Mutex - followers map[string]*views.Follower // by `.` - byState map[string]*views.Follower // by the state an event names, the owners' views families - adopted map[string]*adoption // by `.`, the views the branch follower adopted - hearers map[string][]*adoption // event key `.` -> the adopted views that hear it - branches *meshcatalogclient.Branches - holder *holding // the module that claims the assigner seat, once the catalog half names it - ctx context.Context - cancel context.CancelFunc - wg sync.WaitGroup - deps Deps + logf func(string, ...any) + mu sync.Mutex + followers map[string]*views.Follower // by `.` + byState map[string]*views.Follower // by the state an event names, the owners' views families + adopted map[string]*adoption // by `.`, the views the branch follower adopted + unheardKeys map[string]bool // event keys said as heard by no view + hearers map[string][]*adoption // event key `.` -> the adopted views that hear it + branches *meshcatalogclient.Branches + holder *holding // the module that claims the assigner seat, once the catalog half names it + ctx context.Context + cancel context.CancelFunc + wg sync.WaitGroup + deps Deps // heard is closed and made again at every event heard, so a wait for the picture wakes on events, never on a timer. heard chan struct{} // onKey are the hearers of one key of an owner's state, by ` ` (OnSeatHolder). @@ -207,7 +208,7 @@ func StartWith(parent context.Context, d Deps, logf func(string, ...any)) (*View func (v *Views) hear(env bus.Envelope) error { defer v.heardOne() v.mu.Lock() - hs := append([]*adoption(nil), v.hearers[env.Key]...) + hs := v.hearersOf(env.Key) v.mu.Unlock() if len(hs) > 0 { // an event of the catalog half or the gate's source, heard by the views the branch follower adopted for _, a := range hs { @@ -219,6 +220,7 @@ func (v *Views) hear(env bus.Envelope) error { } ev, err := views.DecodeEvent(env.Body) if err != nil { + v.unheard(env.Key) return nil // not a views event: nothing to hold, nothing to retry } v.mu.Lock() @@ -235,6 +237,37 @@ func (v *Views) hear(env bus.Envelope) error { return nil } +// hearersOf are the adopted views that hear the event key `.` or, as its subject carries further tokens +// (`.`, the mesh-catalog seat's catalog-revision), the key's shorter prefixes: the way mesh-sdk's views reader +// finds its adopted hears. The caller holds v.mu. +func (v *Views) hearersOf(key string) []*adoption { + for k := key; k != ""; { + if hs := v.hearers[k]; len(hs) > 0 { + return append([]*adoption(nil), hs...) + } + i := strings.LastIndex(k, ".") + if i <= 0 { + break + } + k = k[:i] + } + return nil +} + +// unheard says once per key an event no adopted view and no owner's state hears, never dropping it silently. +func (v *Views) unheard(key string) { + v.mu.Lock() + if v.unheardKeys == nil { + v.unheardKeys = map[string]bool{} + } + seen := v.unheardKeys[key] + v.unheardKeys[key] = true + v.mu.Unlock() + if !seen { + v.logf("[mesh-tools] an event %s is heard by no view of this tool runner: it is dropped (said once per key)", key) + } +} + // finding writes or clears the runner's finding of a first view unanswered past its bound, through its writer (design 47 G A-28). func (v *Views) finding(f condseat.Finding, tool string, raised bool) { if v.deps.Findings == nil { diff --git a/node-tools/internal/firstview/firstview_test.go b/node-tools/internal/firstview/firstview_test.go index 5221d6e..74c2837 100644 --- a/node-tools/internal/firstview/firstview_test.go +++ b/node-tools/internal/firstview/firstview_test.go @@ -156,10 +156,14 @@ func TestTheRunnerHoldsTheFourStatesFromTheOwnersFirstViewsAndTheirEvents(t *tes o.catalog, o.modules = 4, []string{"web", "db", fixtureHolder} o.mu.Unlock() ev, _ := json.Marshal(catalogseat.CatalogRevisionEvent{V: 1, Branch: "main", Kind: meshcatalogclient.KindTrunk, Revision: 4}) - if err := o.deliver(bus.Envelope{Key: catalogseat.Seat + "." + catalogseat.EventCatalogRevision, Body: ev}); err != nil { + if err := o.deliver(bus.Envelope{Key: catalogseat.Seat + "." + catalogseat.EventCatalogRevision + ".main", Body: ev}); err != nil { t.Fatal(err) } eventually(t, "the catalog-revision was not taken", func() bool { m, err := v.Modules(); return err == nil && len(m) == 3 }) + // An event no view hears is said once per key, not dropped silently. + for i := 0; i < 2; i++ { + _ = o.deliver(bus.Envelope{Key: "some-seat.unknown-event.x", Body: json.RawMessage(`"x"`)}) + } // And the halves by branch, with their revision, which mesh_wait names checking an emitter (design 34 every-event ยง14). if h, err := v.Halves(); err != nil || h["main"].Revision.Revision != 4 || len(h["main"].Entries) != 3 { t.Errorf("the halves: %+v, %v", h, err) @@ -207,6 +211,9 @@ func TestTheRunnerHoldsTheFourStatesFromTheOwnersFirstViewsAndTheirEvents(t *tes } lmu.Lock() defer lmu.Unlock() + if n := strings.Count(strings.Join(logs, "\n"), "heard by no view"); n != 1 { + t.Errorf("an unheard event was said %d times, want once: %v", n, logs) + } if !strings.Contains(strings.Join(logs, "\n"), "a gap in") { t.Errorf("the gap was not said in the log: %v", logs) }