diff --git a/node-tools/internal/bus/state.go b/node-tools/internal/bus/state.go index ed6c196..1e482f9 100644 --- a/node-tools/internal/bus/state.go +++ b/node-tools/internal/bus/state.go @@ -5,7 +5,9 @@ import ( "encoding/json" "errors" "fmt" + "maps" "regexp" + "slices" "sort" "strings" "sync" @@ -174,64 +176,50 @@ func (c *Conn) StatePage(module, name, after string, maxBytes int, budget time.D each := func() (context.Context, context.CancelFunc) { return context.WithTimeout(context.Background(), StateTimeout) } - var keys []string - var get func(key string) (*StateEntry, error) + // Every current value is read in one stream per bucket (currentOf), never one bus request per key: a page of the + // assignments (about 330 keys) read key by key took 13 s from a node far from the bus (2026-11-14). + current := map[string]*StateEntry{} if s.PerNode { fam := c.family(s) - if keys, err = fam.Keys(ctx); err != nil { + keys, err := fam.Keys(ctx) + if err != nil { return StatePage{}, err } - buckets := map[string]jetstream.KeyValue{} // each node's bucket bound once - get = func(key string) (*StateEntry, error) { - node, err := pernode.NodeOf(key) - if err != nil { - return nil, err + nodes := map[string]bool{} + for _, k := range keys { + if node, err := pernode.NodeOf(k); err == nil { + nodes[node] = true } - kv, bound := buckets[node] - if !bound { - octx, ocancel := each() // the open is a bus request in the loop: its own deadline, never ctx's - kv, err = fam.Open(octx, node) - ocancel() - if err != nil { - return nil, err - } - buckets[node] = kv + } + for node := range nodes { + octx, ocancel := each() // each node's bucket is a bus request of its own: its own deadline + kv, err := fam.Open(octx, node) + ocancel() + if err != nil { + return StatePage{}, err } if kv == nil { - return nil, nil - } - gctx, gcancel := each() - defer gcancel() - e, err := kv.Get(gctx, key) - if errors.Is(err, jetstream.ErrKeyNotFound) { - return nil, nil + continue } + wctx, wcancel := each() + got, err := currentOf(wctx, kv) + wcancel() if err != nil { - return nil, err + return StatePage{}, err } - return &StateEntry{Key: e.Key(), Value: valueOf(e.Value()), Revision: e.Revision(), At: e.Created().UTC()}, nil + maps.Copy(current, got) } } else { kv, err := c.bucket(ctx, s) if err != nil { return StatePage{}, err } - if keys, err = keysOf(ctx, kv); err != nil { + if current, err = currentOf(ctx, kv); err != nil { return StatePage{}, err } - get = func(key string) (*StateEntry, error) { - gctx, gcancel := each() - defer gcancel() - e, err := kv.Get(gctx, key) - if errors.Is(err, jetstream.ErrKeyNotFound) { - return nil, nil - } - if err != nil { - return nil, err - } - return &StateEntry{Key: e.Key(), Value: valueOf(e.Value()), Revision: e.Revision(), At: e.Created().UTC()}, nil - } } + keys := slices.Collect(maps.Keys(current)) + get := func(key string) (*StateEntry, error) { return current[key], nil } sort.Strings(keys) page := StatePage{Entries: []StateEntry{}} started := PageClock() @@ -719,3 +707,28 @@ func providerReference(v any) bool { // referenceName is a node's or a module's name as mesh-sdk names them: lower case, digits and dashes. var referenceName = regexp.MustCompile(`^[a-z0-9][a-z0-9-]*$`) + +// currentOf is every current value of a bucket, read in one stream (a watch of every key, deletes left out, ended at its +// first nil): the values a page answers, without a bus request per key. +func currentOf(ctx context.Context, kv jetstream.KeyValue) (map[string]*StateEntry, error) { + w, err := kv.WatchAll(ctx, jetstream.IgnoreDeletes()) + if err != nil { + return nil, err + } + defer func() { _ = w.Stop() }() + out := map[string]*StateEntry{} + for { + select { + case <-ctx.Done(): + return nil, fmt.Errorf("the values of %s are not all read: %w", kv.Bucket(), ctx.Err()) + case e, ok := <-w.Updates(): + if !ok { + return out, nil + } + if e == nil { + return out, nil + } + out[e.Key()] = &StateEntry{Key: e.Key(), Value: valueOf(e.Value()), Revision: e.Revision(), At: e.Created().UTC()} + } + } +}