Names N2b: every seat list part's callers name seats, resolved from the seat-holders view

The builder, its tools bundle, the assigner (process and bundle) and the view's tools bundle answered
their seat list's again tool to the modules node-tools and mesh-healers. Their lists are now the
operator, seat:node-tool-runner and seat:mesh-healers, resolved by a holder function:
- meshcatalogclient's Branches.Claimant (moved from the builder's versions.HolderOf, which now asks it)
  names the claimant of mesh-module-assigner from the trunk's half, and Branches.SeatHolders follows
  that claimant's seat-holders view through the part's wiring. It drops the view and follows the new
  claimant's on a catalog change, asks nothing on a timer, and answers seatlist.HoldersIn.
- the assigner answers HoldersIn from its own seat-holders picture (its world in the process, the
  watched copy in the bundle).
The builder's and the view's manifests consume seat:mesh-module-assigner.views.seat-holders. The
assigner's seat-holders first-view tool answers both, by module as A-131 has it.

Builds: design 47 G A-298, A-295, A-296, A-210, A-131, §717, §616, §614

Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
This commit is contained in:
2026-11-12 19:05:51 +01:00
parent 5943cd87a1
commit 4938fb2d73
20 changed files with 304 additions and 67 deletions
@@ -599,7 +599,7 @@ func TestWantsAreWrittenAndNoDifferenceIs(t *testing.T) {
// its mark, and refuses every other account, the assigner's own included.
firstViewsBeforeAnyNewFormState(t, b, map[string][]string{
"assignments": {"n1.mesh-grants", "n1.node-tools", "n1.mesh-delivery-indexer", "n1.mesh-delivery-builder", "n1.mesh-delivery-checker"},
"seat-holders": {"n1.node-tools"},
"seat-holders": {"n1.node-tools", "n1.mesh-delivery-builder", "n1.mesh-delivery-view"}, // A-298: the parts following it
"wants": {"n1.mesh-grants"},
})
// The reader raises the finding of the first view through the module's finding writer (A-26), its id escaped as a key's name.
@@ -384,6 +384,8 @@ var watched = []string{
// each change; changes that come during a pass make one more. It returns when ctx ends or a watch ends.
func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, kvs kvSet, say func(oc.Condition) error, findings assign.Findings, bus caller, iv *catalogViews, inputs *inputKeeper, gate *seatlist.Part, logger *log.Logger, getenv func(string) string) error {
w := newWorld()
// The callers' seat entries are resolved from the assigner's own seat-holders as it last read them (A-298).
gate.Holders(seatlist.HoldersIn(func() (map[string][]byte, error) { return w.read(plc.SeatHoldersBucket), nil }))
dirty := make(chan struct{}, 1)
wake := func() {
select {
@@ -271,10 +271,14 @@ func TestTheSeatsVerbs(t *testing.T) {
}
s.seatList = nil
t.Run("1966: the seat list's again tool answers an operator's session through the mesh MCP server", func(t *testing.T) {
// Such a session is proved as its machine's tool runner (issue 627); the healers too, no other module.
for caller, refused := range map[string]bool{"person.jochen": false, "shanks.node-tools": false, "ace.mesh-healers": false,
"ace.messenger": true} {
if err := seatlist.Refusal("assigner_seat_list_again", seatListAgainCallers, caller); (err != nil) != refused {
// Such a session is proved as its machine's tool runner (issue 627); the healers too, no other module. The list names
// the seats, resolved from the assigner's own seat-holders (A-295, A-298): a module holding neither is refused.
held := map[string][]byte{"node-tool-runner.shanks": []byte(`{"holders":[{"module":"node-tools","node":"shanks"}]}`),
"mesh-healers": []byte(`{"holders":[{"module":"mesh-delivery-watchman","node":"ace"}]}`)}
holders := seatlist.HoldersIn(func() (map[string][]byte, error) { return held, nil })
for caller, refused := range map[string]bool{"person.jochen": false, "shanks.node-tools": false, "ace.mesh-delivery-watchman": false,
"ace.mesh-healers": true, "ace.messenger": true} {
if err := seatlist.RefusalWith("assigner_seat_list_again", seatListAgainCallers, caller, holders); (err != nil) != refused {
t.Errorf("%s: refused=%v, err %v", caller, refused, err)
}
}
@@ -10,6 +10,7 @@ import (
// seat-holders state read; until the list is read, a mesh seat the bootstrapped definitions do not name is never judged held once
// (plc.CheckAssignments), and seat-holders is not written.
// A call through the mesh MCP server is proved only as its machine's tool runner (<node>.node-tools, issue 627), so
// node-tools stands for an operator's session until a session is proved (issue 1966).
var seatListAgainCallers = []string{stdio.AnyPerson, "node-tools", "mesh-healers"}
// A call through the mesh MCP server is proved only as its machine's tool runner (issue 627), so the holders of the seat
// node-tool-runner stand for an operator's session until a session is proved (issue 1966). The list names seats, never a
// module, resolved from the assigner's own seat-holders (design 47 G A-210, A-295, A-298).
var seatListAgainCallers = []string{stdio.AnyPerson, stdio.CallerSeatPrefix + "node-tool-runner", stdio.CallerSeatPrefix + "mesh-healers"}
@@ -1,6 +1,8 @@
package main
import (
mma "git.novox.be/novox/mesh-contracts/go/seats/meshmoduleassigner"
"encoding/json"
"errors"
"fmt"
@@ -413,6 +415,8 @@ func serveTools() error {
return stdio.SeatPublish(wantsEventSubject(e), b, id)
})
wants.watched = stdio.NewWatchedStates() // the large states read whole from one watched copy (ADR 0580 clause 3)
// The callers' seat entries are resolved from the assigner's own seat-holders, its watched copy (A-298).
gate.Holders(seatlist.HoldersIn(func() (map[string][]byte, error) { return wants.watched.Values(mma.StateSeatHolders) }))
wants.revisions = runtimeObjects{busstate.ObjectsOf(assigngraph.RevisionsObjects)}
tools = append(tools, wants.tools()...)
tools = append(tools, inputsRead(&inputKeeper{vals: stateobjects.ForState(buckets.InputsState), now: time.Now, logf: func(string, ...any) {}}))
@@ -112,7 +112,7 @@ func TestManifest(t *testing.T) {
t.Errorf("runs-as = %q: the bundle runs on the assigner's own account (ADR 0621 §1)", m.RunsAs)
}
// ADR 0621 §2: each first-view tool answers exactly its readers, never the assigner.
callers := map[string]string{"assignments": "mesh-grants,node-tools,mesh-delivery-indexer,mesh-delivery-builder,mesh-delivery-checker", "seat-holders": "node-tools", "wants": "mesh-grants"}
callers := map[string]string{"assignments": "mesh-grants,node-tools,mesh-delivery-indexer,mesh-delivery-builder,mesh-delivery-checker", "seat-holders": "node-tools,mesh-delivery-builder,mesh-delivery-view", "wants": "mesh-grants"}
env := m.Build.Artifacts[0].Env
for tool, list := range callers {
if env[views.CallersEnv(tool)] != list || views.ParseCallers(env[views.CallersEnv(tool)]).Allows("n1."+m.Module) {
+1 -1
View File
@@ -248,7 +248,7 @@
],
"env": {
"MESH_VIEW_CALLERS_ASSIGNMENTS": "mesh-grants,node-tools,mesh-delivery-indexer,mesh-delivery-builder,mesh-delivery-checker",
"MESH_VIEW_CALLERS_SEAT_HOLDERS": "node-tools",
"MESH_VIEW_CALLERS_SEAT_HOLDERS": "node-tools,mesh-delivery-builder,mesh-delivery-view",
"MESH_VIEW_CALLERS_WANTS": "mesh-grants"
}
}
@@ -408,7 +408,9 @@ func main() {
pk.Start(context.Background())
// The build modules are no names (design 47 G A-82): the build seats on the seat list, each held by the module the catalog
// half's manifests say; the seat list and its two tools wired once by mesh-sdk (§204).
gate := seatlist.NewPart("builder", []string{stdio.AnyPerson, "node-tools", "mesh-healers"})
// Its callers name seats, never a module, resolved from the seat-holders view the catalog half's claimant serves (A-295, A-298).
gate := seatlist.NewPart("builder", []string{stdio.AnyPerson, stdio.CallerSeatPrefix + "node-tool-runner", stdio.CallerSeatPrefix + "mesh-healers"})
gate.Holders(branches.SeatHolders(context.Background()))
go func() {
<-stdio.Served()
gate.Follow(seatlist.StdioBus(), nil, func(f string, a ...any) { fmt.Fprintf(os.Stderr, "[mesh-delivery-builder-tools] "+f+"\n", a...) })
@@ -161,6 +161,17 @@ func (w sweepWiring) Adopt(f *views.Follower, seatName, event string, hear func(
return nil
}
// Follow follows a plain view through the wrapped wiring (meshcatalogclient's SeatHolders, A-298).
func (w sweepWiring) Follow(owner, state, tool string) (func() map[string]json.RawMessage, error) {
f, ok := w.Wiring.(interface {
Follow(owner, state, tool string) (func() map[string]json.RawMessage, error)
})
if !ok {
return nil, fmt.Errorf("the builder's reader follows no plain view of %s.%s", owner, state)
}
return f.Follow(owner, state, tool)
}
func (w sweepWiring) Drop(owner, state string) error {
err := w.Wiring.Drop(owner, state)
w.half.dropped(state)
@@ -119,6 +119,7 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
// The build modules are no names (design 47 G A-82): the holders of the build seats, the seat list's definitions and the
// catalog half's claims, found at each use.
seatGate := newSeatGate()
seatGate.Holders(branches.SeatHolders(ctx))
seats := buildrun.NewBuildSeats(seatGate.definitions, versions.HolderOf(branches))
bound := defaultStepBound
if v := strings.TrimSpace(getenv("MESH_BUILDER_STEP_BOUND")); v != "" {
@@ -9,8 +9,9 @@ import (
// The builder reads the seat list as every part does, through mesh-sdk's one wiring (go/seatlist.Part; design 47 G §204): its
// definitions name the build seats (the seats whose acting rule is the step build), its tools `builder_seat_list` and
// `builder_seat_list_again`. A call through the mesh MCP server is proved only as its machine's tool runner (issue 627).
var seatListAgainCallers = []string{stdio.AnyPerson, "node-tools", "mesh-healers"}
// `builder_seat_list_again`. A call through the mesh MCP server is proved only as its machine's tool runner (issue 627). The
// list names seats, never a module, resolved by the holder function meshcatalogclient's SeatHolders answers (A-295, A-298).
var seatListAgainCallers = []string{stdio.AnyPerson, stdio.CallerSeatPrefix + "node-tool-runner", stdio.CallerSeatPrefix + "mesh-healers"}
// seatGate is the builder's wiring of the seat list.
type seatGate struct{ *seatlist.Part }
@@ -2,15 +2,11 @@ package versions
import (
"context"
"encoding/json"
"slices"
"sort"
"strings"
"sync"
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient"
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
"git.novox.be/novox/mesh-sdk/go/catalogue"
)
// Entries are the catalog graph entries of the halves the builder follows, one per module and watched branch (design 47 G §348,
@@ -85,55 +81,10 @@ func EntriesOf(branches *meshcatalogclient.Branches) Entries {
}
}
// HolderOf finds the module that holds a seat: the one whose entry in the first followed branch's half (the trunk's) has a
// manifest that claims it (design 47 G A-82; the seat list answers seat definitions alone, §527). More than one claimant, or
// none, is no holder.
// HolderOf finds the module that holds a seat: its claimant in the trunk's half, as meshcatalogclient's Branches.Claimant
// answers it (design 47 G A-82, A-298).
func HolderOf(branches *meshcatalogclient.Branches) func(seat string) (string, bool) {
var mu sync.Mutex
claims := map[string][]string{} // manifest digest -> the seats it claims
claimed := func(e meshcatalog.CatalogEntry) []string {
mu.Lock()
defer mu.Unlock()
if seats, ok := claims[e.ManifestDigest]; ok && e.ManifestDigest != "" {
return seats
}
var seats []string
if raw, err := json.Marshal(e.Manifest); err == nil {
if mf, err := catalogue.Decode(raw); err == nil {
for _, c := range mf.Claims {
seats = append(seats, c.Name)
}
}
}
if e.ManifestDigest != "" {
claims[e.ManifestDigest] = seats
}
return seats
}
return func(seat string) (string, bool) {
followed := branches.Followed()
if len(followed) == 0 {
return "", false
}
cat, ok := branches.Catalog(followed[0])
if !ok {
return "", false
}
half, ok := cat.View()
if !ok {
return "", false
}
var holders []string
for _, e := range half.Entries {
if slices.Contains(claimed(e), seat) {
holders = append(holders, e.Module)
}
}
if len(holders) != 1 {
return "", false
}
return holders[0], true
}
return branches.Claimant
}
// RequirementsFrom answers the versions of a package the entries of every followed half require, each once, in order: what a
@@ -161,6 +161,7 @@ func TestManifestDeclarations(t *testing.T) { // 1607/AC1
"go-package-registry.kept", "go-package-registry.published", "go-package-registry.refused", "go-package-registry.removed",
"mesh-artifact-sweep.artifacts-gone", "mesh-catalog.manifest-accepted", "mesh-catalog.seat-definition-changed", "mesh-catalog.seat-definition-removed", "mesh-catalog.version-released", "mesh-catalog.versions-filled",
"mesh-conditions.condition-cleared", "mesh-conditions.findings-asked", "seat:mesh-module-assigner.views.assignments",
"seat:mesh-module-assigner.views.seat-holders", // A-298: the claimant's seat-holders view resolves the callers' seat entries
"mesh-catalog.catalog-revision", "mesh-catalog.registration-changed", "mesh-delivery.source-moved", "node-build-go.toolchain-reported", "node-build-node.toolchain-reported", "node-engine.manifest-reads-changed", "node-engine.running",
"npm-package-registry.kept", "npm-package-registry.published", "npm-package-registry.refused", "npm-package-registry.removed",
"oci-artifact-registry.kept", "oci-artifact-registry.published", "oci-artifact-registry.refused", "oci-artifact-registry.removed", "operator-channel.decided"}; !reflect.DeepEqual(sorted(m.Consumes), sorted(want)) {
@@ -73,6 +73,7 @@
"oci-artifact-registry.refused",
"oci-artifact-registry.removed",
"seat:mesh-module-assigner.views.assignments",
"seat:mesh-module-assigner.views.seat-holders",
"mesh-catalog.catalog-revision",
"mesh-catalog.registration-changed",
"mesh-delivery.source-moved"
@@ -7,6 +7,7 @@ import (
"fmt"
"slices"
"sync"
"sync/atomic"
"time"
seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
@@ -67,6 +68,10 @@ type Branches struct {
Registrations *Registrations
// Entries is the cache of the entries read by fingerprint.
Entries *Entries
// claims are the seats each manifest digest claims (Claimant), holders the part's follow of the seat-holders view (SeatHolders).
claimsMu sync.Mutex
claims map[string][]string
holders atomic.Pointer[seatHolders]
// Changed, when not nil, is told of each change to a branch's view (module, its entry, deleted), set before Wire.
Changed func(branch, module string, entry json.RawMessage, deleted bool, at time.Time)
// Adopted, when not nil, is told on a goroutine of its own of each branch whose view was adopted, with that view (a part that waits for
@@ -243,6 +248,7 @@ func (b *Branches) reconcile() {
}
branch := want[e]
c.Follower.Changed = func(module string, entry json.RawMessage, deleted bool, at time.Time) {
b.holders.Load().changed()
if b.Changed != nil {
b.Changed(branch, module, entry, deleted, at)
}
@@ -23,6 +23,26 @@ type fakeWiring struct {
adopted map[string]*views.Follower
hears map[string]func(context.Context, []byte) error
dropped []string
// follows are the plain views followed (SeatHolders), values what each answers.
follows []string
values map[string]map[string]json.RawMessage
followed chan string
}
func (w *fakeWiring) Follow(owner, state, tool string) (func() map[string]json.RawMessage, error) {
w.mu.Lock()
defer w.mu.Unlock()
name := owner + "." + state
w.adopted[name] = &views.Follower{Owner: owner, State: state, Tool: tool}
w.follows = append(w.follows, tool)
if w.followed != nil {
w.followed <- owner
}
return func() map[string]json.RawMessage {
w.mu.Lock()
defer w.mu.Unlock()
return w.values[owner]
}, nil
}
func (w *fakeWiring) Adopt(f *views.Follower, _, _ string, hear func(context.Context, []byte) error) error {
@@ -74,6 +94,8 @@ type fakeSeats struct {
version int64
entries map[string]seat.CatalogEntry
entryAsk int
// trunk, when set, is the revision answered for every branch.
trunk *seat.RevisionAnswer
}
func (f *fakeSeats) call(key string, body any) (json.RawMessage, error) {
@@ -89,6 +111,9 @@ func (f *fakeSeats) call(key string, body any) (json.RawMessage, error) {
}
return json.Marshal(a)
case RevisionVerb:
if f.trunk != nil {
return json.Marshal(f.trunk)
}
return json.Marshal(seat.RevisionAnswer{NoneYet: true})
case EntryVerb:
f.entryAsk++
@@ -272,3 +297,64 @@ func TestEntriesAreAskedOnceAnsweredOrNotFound(t *testing.T) {
t.Fatalf("a call that reached no holder: rows %+v", rows)
}
}
// A-298 (§717, A-295): the part's holder function follows the seat-holders view of the module the trunk's half names as the
// claimant of mesh-module-assigner, asked of its tool seat-holders; a revision naming another claimant drops it and follows the
// new one's; nothing is followed while no claimant is named.
func TestSeatHoldersFollowsTheClaimantOfTheAssignerSeat(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
claims := func(rev int64, assigner string) *seat.RevisionAnswer {
return &seat.RevisionAnswer{Revision: &seat.CatalogRevision{Kind: KindTrunk, Branch: "main", Revision: rev}, Entries: []seat.CatalogEntry{
{Module: assigner, ManifestDigest: assigner, Manifest: map[string]any{"module": assigner, "claims": []any{map[string]any{"name": "mesh-module-assigner", "scope": "mesh"}}}},
{Module: "app", ManifestDigest: "app", Manifest: map[string]any{"module": "app"}}}}
}
seats := &fakeSeats{source: []string{"main"}, regs: map[string][]string{}, version: 1}
w := &fakeWiring{adopted: map[string]*views.Follower{}, hears: map[string]func(context.Context, []byte) error{},
values: map[string]map[string]json.RawMessage{
"asg-a": {"node-tool-runner.ace": json.RawMessage(`{"holders":[{"module":"node-tools","node":"ace"}]}`)},
"asg-b": {"node-tool-runner.ace": json.RawMessage(`{"holders":[{"module":"tool-runner-2","node":"ace"}]}`)}},
followed: make(chan string, 4)}
b, err := NewBranches(w, seats.call)
if err != nil {
t.Fatal(err)
}
holders := b.SeatHolders(ctx)
src, _ := w.get("mesh-delivery.source")
if err := src.Start(ctx); err != nil {
t.Fatal(err)
}
if got := holders("node-tool-runner"); len(got) != 0 {
t.Fatalf("holders before any claimant = %v", got)
}
// The follow runs on its own goroutine: each Follow is told, and the holder function answers once that follow is held.
answered := func(owner, want string) {
t.Helper()
if got := <-w.followed; got != owner {
t.Fatalf("followed %s, want %s", got, owner)
}
if got := holders("node-tool-runner"); !slices.Equal(got, []string{want}) {
t.Fatalf("holders = %v, want %s", got, want)
}
}
main, _ := w.get("mesh-catalog.catalog-revisions.main")
seats.mu.Lock()
seats.trunk = claims(1, "asg-a")
seats.mu.Unlock()
if err := main.Start(ctx); err != nil {
t.Fatal(err)
}
answered("asg-a", "node-tools")
seats.mu.Lock()
seats.trunk = claims(2, "asg-b")
seats.mu.Unlock()
if err := main.Again(ctx, "a revision naming another claimant"); err != nil {
t.Fatal(err)
}
answered("asg-b", "tool-runner-2")
w.mu.Lock()
defer w.mu.Unlock()
if !slices.Equal(w.follows, []string{"asg-a.seat-holders", "asg-b.seat-holders"}) || !slices.Equal(w.dropped, []string{"asg-a.seat-holders"}) {
t.Errorf("followed %v and dropped %v, want asg-a's then asg-b's, asg-a's dropped", w.follows, w.dropped)
}
}
@@ -0,0 +1,163 @@
package meshcatalogclient
import (
"context"
"encoding/json"
"slices"
"sync"
seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
"git.novox.be/novox/mesh-sdk/go/catalogue"
"git.novox.be/novox/mesh-sdk/go/seatlist"
)
// seatHoldersState is the state of the seat that places modules (seatlist.HolderSeat) its definition offers as a view: who holds
// which seat, keyed `<seat>` and `<seat>.<node>` (§616, §699).
const seatHoldersState = "seat-holders"
// Claimant is the module that claims seat: the one whose entry in the first followed branch's half (the trunk's) has a manifest
// that claims it (design 47 G A-82, §614, A-298). More than one claimant, or none, is none.
func (b *Branches) Claimant(seatName string) (string, bool) {
followed := b.Followed()
if len(followed) == 0 {
return "", false
}
cat, ok := b.Catalog(followed[0])
if !ok {
return "", false
}
half, ok := cat.View()
if !ok {
return "", false
}
var holders []string
for _, e := range half.Entries {
if slices.Contains(b.claimed(e), seatName) {
holders = append(holders, e.Module)
}
}
if len(holders) != 1 {
return "", false
}
return holders[0], true
}
// claimed is the seats an entry's manifest claims, decoded once per manifest digest.
func (b *Branches) claimed(e seat.CatalogEntry) []string {
b.claimsMu.Lock()
defer b.claimsMu.Unlock()
if seats, ok := b.claims[e.ManifestDigest]; ok && e.ManifestDigest != "" {
return seats
}
var seats []string
if raw, err := json.Marshal(e.Manifest); err == nil {
if mf, err := catalogue.Decode(raw); err == nil {
for _, c := range mf.Claims {
seats = append(seats, c.Name)
}
}
}
if e.ManifestDigest != "" {
if b.claims == nil {
b.claims = map[string][]string{}
}
b.claims[e.ManifestDigest] = seats
}
return seats
}
// viewFollowing is a Wiring that also follows an owner's state as a plain view (Reader.Follow, ProcessReader.Follow), and answers
// the keys it last heard.
type viewFollowing interface {
Follow(owner, state, tool string) (func() map[string]json.RawMessage, error)
}
func (w readerWiring) Follow(owner, state, tool string) (func() map[string]json.RawMessage, error) {
f := w.r.Follow(owner, state, tool)
return f.Values, nil
}
func (w processWiring) Follow(owner, state, tool string) (func() map[string]json.RawMessage, error) {
p, err := w.r.Follow(owner, state, tool)
if err != nil {
return nil, err
}
return p.Follower().Values, nil
}
// seatHolders is the part's follow of the claimant's seat-holders view: the claimant followed and what it answers.
type seatHolders struct {
mu sync.Mutex
owner string
values func() map[string]json.RawMessage
kick chan struct{}
}
// SeatHolders is the part's holder function (seatlist.Part.Holders, design 47 G A-295, A-298, §717): it follows the view
// `seat-holders` of the module the catalog half names as the claimant of the seat that places modules (seatlist.HolderSeat), its
// first view asked of the claimant's tool `seat-holders`, and at each catalog change naming another claimant drops that view and
// follows the new one's (§532); with no claimant it keeps what it has. Nothing is asked on a timer. The part's manifest consumes
// `seat:mesh-module-assigner.views.seat-holders`. A Wiring that follows no plain view answers no holders, said in the log.
func (b *Branches) SeatHolders(ctx context.Context) func(seat string) []string {
sh := &seatHolders{kick: make(chan struct{}, 1)}
b.holders.Store(sh)
fw, ok := b.w.(viewFollowing)
if !ok {
b.logf("meshcatalogclient: this part's reader follows no plain view, so no seat's holders are known")
} else {
go func() {
for {
select {
case <-ctx.Done():
return
case <-sh.kick:
}
b.refollow(sh, fw)
}
}()
sh.changed()
}
return seatlist.HoldersIn(func() (map[string]json.RawMessage, error) {
sh.mu.Lock()
values := sh.values
sh.mu.Unlock()
if values == nil {
return nil, nil
}
return values(), nil
})
}
// changed asks the follow to read the claimant again, without blocking the caller (a view's change is told under its lock).
func (sh *seatHolders) changed() {
if sh == nil {
return
}
select {
case sh.kick <- struct{}{}:
default:
}
}
// refollow follows the claimant's seat-holders view when the claimant is another than the one followed.
func (b *Branches) refollow(sh *seatHolders, fw viewFollowing) {
claimant, ok := b.Claimant(seatlist.HolderSeat)
sh.mu.Lock()
defer sh.mu.Unlock()
if !ok || claimant == sh.owner {
return
}
if sh.owner != "" {
if err := b.w.Drop(sh.owner, seatHoldersState); err != nil {
b.logf("meshcatalogclient: the seat-holders view of %s is not dropped: %v", sh.owner, err)
}
sh.owner, sh.values = "", nil
}
values, err := fw.Follow(claimant, seatHoldersState, claimant+"."+seatHoldersState)
if err != nil {
b.logf("meshcatalogclient: the seat-holders view of %s is not followed: %v", claimant, err)
return
}
sh.owner, sh.values = claimant, values
b.logf("meshcatalogclient: the seat-holders view of %s, the claimant of %s, is followed", claimant, seatlist.HolderSeat)
}
@@ -445,7 +445,9 @@ func main() {
r.Pending = pendingOf
// The build modules are no names (design 47 G A-82): the build seats on the seat list, each held by the module the seat
// list names for it; the seat list and its two tools are wired once by mesh-sdk (§204).
gate := seatlist.NewPart("view", []string{stdio.AnyPerson, "node-tools", "mesh-healers"})
// Its callers name seats, never a module, resolved from the seat-holders view the catalog half's claimant serves (A-295, A-298).
gate := seatlist.NewPart("view", []string{stdio.AnyPerson, stdio.CallerSeatPrefix + "node-tool-runner", stdio.CallerSeatPrefix + "mesh-healers"})
gate.Holders(branches.SeatHolders(context.Background()))
go func() {
<-stdio.Served()
gate.Follow(seatlist.StdioBus(), nil, func(f string, a ...any) { fmt.Fprintf(os.Stderr, "[mesh-delivery-view-tools] "+f+"\n", a...) })
+1 -1
View File
@@ -173,7 +173,7 @@ func TestManifestIsTakenAndReadsOnly(t *testing.T) { // 1134/AC7
if m.Version != "0.1" {
t.Errorf("version = %q, want 0.1", m.Version)
}
if want := []string{"mesh-conditions.findings-asked", "mesh-delivery-assigner.views.asks", "mesh-delivery-assigner.views.assignments", "mesh-delivery-assigner.views.wants",
if want := []string{"mesh-conditions.findings-asked", "mesh-delivery-assigner.views.asks", "mesh-delivery-assigner.views.assignments", "seat:mesh-module-assigner.views.seat-holders", "mesh-delivery-assigner.views.wants",
"mesh-catalog.catalog-revision", "mesh-catalog.registration-changed", "mesh-delivery.source-moved", "mesh-catalog.seat-definition-changed", "mesh-catalog.seat-definition-removed", "mesh-delivery-indexer.views.candidates", "mesh-delivery-indexer.views.taken", "mesh-delivery-teller.views.answers",
"mesh-wants.wait-held", "mesh-wants.wait-ended", "node-engine.wait-held", "node-engine.wait-ended", "mesh-pipeline-runner.wait-held", "mesh-pipeline-runner.wait-ended",
"mesh-grants.wait-held", "mesh-grants.wait-ended", "mesh-delivery-builder.wait-held", "mesh-delivery-builder.wait-ended",
+1
View File
@@ -66,6 +66,7 @@
"mesh-conditions.findings-asked",
"mesh-delivery-assigner.views.asks",
"mesh-delivery-assigner.views.assignments",
"seat:mesh-module-assigner.views.seat-holders",
"mesh-delivery-assigner.views.wants",
"mesh-catalog.catalog-revision",
"mesh-catalog.registration-changed",