A-385 kept-accounts-are-a-union: an account kept beyond a pass is the union of the list in force and what the pass composes for it, a held runner composed from its running build's manifest

Builds: design 47 G A-385 (G-22-lead-answers-2.md)

Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
This commit is contained in:
2026-11-14 01:09:07 +01:00
parent c3fd353abe
commit 66ae3cd918
4 changed files with 112 additions and 2 deletions
+67
View File
@@ -5402,3 +5402,70 @@ func TestAKeptAccountGainsTheRightEveryAccountCarries(t *testing.T) {
}
}
}
// Design 47 G A-385: an account kept beyond a pass, a tool runner's included, is the union of the list in force and what the pass composes
// for it (here from the manifest the held runner's running build was judged on), never the list in force alone: before the catalog half is
// read, a held runner carrying a module with a state gains that state's rights (a bound ledger's state is the same kind) and loses nothing.
func TestAHeldRunnerIsWrittenAsTheUnionOfTheListInForceAndWhatIsComposed(t *testing.T) {
const runner = `{"module":"node-tools","version":"1","tool-runner":true,"own-secrets":{"broker":"/var/lib/nt/broker"}}`
const carried = `{"module":"mod-c","version":"1","tools":["t"],"state":["kept"]}`
b := fixture()
b.manifestOf("node-tools", runner)
b.manifestOf("mod-c", carried)
b.assign("a", "node-tools")
b.assign("a", "mod-c")
busKey, err := seal.GenerateKeyPair()
if err != nil {
t.Fatal(err)
}
b.put(grants.ReadHave, "a.nats", nodeengine.HaveByNodeModuleValue{V: keys.Version, Phase: nodeengineclient.PhaseRunning, Health: nodeengineclient.HealthOK,
UserList: &nodeengine.UserListWritten{Source: grantsstate.GrantsUserListSource, Revision: 8, Wanted: "sha256:aa", Digest: "sha256:aa", Users: 5,
Key: busKey.PublicKey, Follows: grantsstate.FollowGrants}})
for _, u := range shadowOf(t, b) {
b.put(grants.ReadAccounts, u.User, map[string]any{"user": u.User, "hash": "$2a$10$x", "generation": 1, "fingerprint": "sha256:1"})
}
p := partOn(b)
p.Bus = grants.BusAddress{URL: "nats://a.mesh:4222", Fingerprint: "ab"}
p.Objects = &fakeObjects{}
p.Compose()
first, _, _ := p.Sealed()
key := grants.SealedUserKey(first.Digest, "a.node-tools")
var was grants.User
if err := json.Unmarshal(b.own[grants.StateUserList][key], &was); err != nil {
t.Fatal(err)
}
isLedger := func(s string) bool { return strings.Contains(s, "mod-c_kept") }
if !slices.ContainsFunc(was.Publish, isLedger) {
t.Fatalf("the runner of a composes no right on the state of its carried module mod-c: %v", was.Publish)
}
// The list in force holds the runner without the ledger (written before the carried module had one), the runner's manifest is held,
// its running build's manifest is what its have names, and the catalog half is unread.
was.Publish = slices.DeleteFunc(slices.Clone(was.Publish), isLedger)
b.own[grants.StateUserList][key], _ = json.Marshal(was)
digest := meshcatalogclient.ManifestDigest([]byte(runner))
fp := "src2:" + strings.Repeat("cd", 32)
b.put(grants.ReadHave, "a.node-tools", nodeengine.HaveByNodeModuleValue{V: keys.Version, Phase: nodeengineclient.PhaseRunning, Health: nodeengineclient.HealthOK, Fp: fp})
b.entry(fp, digest)
b.refuse("node-tools", runner, "held for the test")
b.mu.Lock()
b.catalogWaited = []string{"the catalog half of the branch main"}
b.mu.Unlock()
b.assign("b", "mod-x") // the list changes
p.Compose()
next, _, _ := p.Sealed()
if next.Digest == first.Digest {
t.Fatal("the list did not change: the pass kept the list in force")
}
var got grants.User
if err := json.Unmarshal(b.own[grants.StateUserList][grants.SealedUserKey(next.Digest, "a.node-tools")], &got); err != nil {
t.Fatal(err)
}
if !slices.ContainsFunc(got.Publish, isLedger) {
t.Errorf("the held runner lacks its carried module's state rights: %v", got.Publish)
}
for _, s := range was.Publish {
if !slices.Contains(got.Publish, s) {
t.Errorf("the held runner lost %s", s)
}
}
}
+6 -1
View File
@@ -369,11 +369,16 @@ func (p *Part) Compose() Result {
candidates = append(candidates, user)
}
heldUsers := heldModuleUsers(in, candidates)
for user, why := range runnerUsersKept(listRecs, inForce) {
runnersKept := runnerUsersKept(listRecs, inForce)
for user, why := range runnersKept {
heldUsers[user] = why
}
allRefused := mergedRefusals(refused, heldUsers)
kept, _ := p.keptOf(allRefused)
// An account kept beyond the pass is the union of the list in force and what the pass composes for it, never the list in force
// alone (design 47 G A-385); a runner kept for what it runs, whose manifest does not say it is one, is never composed as a plain module
// (ADR 0601 §4).
kept = unionComposed(kept, users, runnersKept)
for _, user := range sortedKeys(refused) {
res.PrincipalsRefused = append(res.PrincipalsRefused, user+": "+refused[user])
}
@@ -83,7 +83,12 @@ func records(in Inputs, union bool) (buscompose.Records, []Gap) {
if m, ok := in.Running[node+"."+module]; ok {
return m, true
}
m, ok := in.Manifests[module]
if m, ok := in.Manifests[module]; ok {
return m, true
}
// The manifest the module's running build was judged on, while its trunk manifest is held: the runner it is, the modules it
// carries and their grants are composed from it, never from the list in force alone (design 47 G A-385).
m, ok := in.Held[module]
return m, ok
}
var here []catalogue.Manifest
@@ -178,3 +178,36 @@ func withMissing(list, rights []string) []string {
}
return out
}
// unionComposed is kept with each kept user that the pass also composed (composed, and not one in apart) holding the union of
// the grants of the list in force and of the composed account; the composed copy stays out of users, as a kept one's place is its own
// (withKept). It only adds.
func unionComposed(kept map[string]User, composed []User, apart map[string]string) map[string]User {
if len(kept) == 0 {
return kept
}
out := make(map[string]User, len(kept))
for name, u := range kept {
out[name] = u
}
for _, c := range composed {
u, ok := out[c.User]
if !ok {
continue
}
if _, no := apart[c.User]; no {
continue
}
u.Publish = set(append(slices.Clone(u.Publish), c.Publish...))
u.Subscribe = set(append(slices.Clone(u.Subscribe), c.Subscribe...))
u.AllowResponses = u.AllowResponses || c.AllowResponses
if u.PublishDeny != nil || c.PublishDeny != nil {
u.PublishDeny = set(append(slices.Clone(u.PublishDeny), c.PublishDeny...))
}
if u.SubscribeDeny != nil || c.SubscribeDeny != nil {
u.SubscribeDeny = set(append(slices.Clone(u.SubscribeDeny), c.SubscribeDeny...))
}
out[c.User] = u
}
return out
}