From 0ee747cf1b9e6d05da5c49cc0d0f331b1aedb3c7 Mon Sep 17 00:00:00 2001 From: jochen Date: Mon, 16 Nov 2026 14:39:30 +0100 Subject: [PATCH] assigner: the composition step takes a node's input through the chunked seat call, with a call token (A-237b) Builds: design 47 G (G-22 lead answers 2) A-237b; A-237, A-249 --- .../compositioninputs.go | 48 +++++++++++++++---- .../compositioninputs_test.go | 41 ++++++++++++++-- .../compositionrun_test.go | 5 +- .../cmd/mesh-delivery-assigner/main.go | 2 +- 4 files changed, 79 insertions(+), 17 deletions(-) diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositioninputs.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositioninputs.go index ae741722..117d8f2d 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositioninputs.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositioninputs.go @@ -3,6 +3,9 @@ package main import ( "bytes" "context" + "crypto/rand" + "encoding/base64" + "encoding/hex" "encoding/json" "errors" "fmt" @@ -70,9 +73,11 @@ type nodeInput struct { // compositionInputs asks the machines of a step for their inputs. type compositionInputs struct { machines func(module, branch string) []string - // call asks one node's seat verb (process.Conn.CallKeptOn). - call func(node, key string, body any) (json.RawMessage, error) - bound time.Duration + // callFile asks a seat verb marked chunks, addressed to one node as `seat:.@`, and answers the verb's answer with + // the whole file received added as its member `file`, base64 (process.Conn.CallFile; design 47 G A-237b, A-249). The call + // token is the body's `call`. + callFile func(key string, body any) (json.RawMessage, error) + bound time.Duration } // gather asks each machine of the step's module and branch for its input with the step's candidate key, and answers every machine in @@ -119,7 +124,13 @@ func (c *compositionInputs) one(ctx context.Context, bound time.Duration, node, } got := make(chan reply, 1) go func() { - raw, err := c.call(node, composeCandidateKey, ne.ComposeCandidateInput{Candidate: key, Input: true}) + // The input is any size, so the verb sends it in chunks on the call token chosen here, and the file is the input (A-237b). + var bits [16]byte + if _, err := rand.Read(bits[:]); err != nil { + got <- reply{nil, err} + return + } + raw, err := c.callFile(composeCandidateKey+"@"+node, ne.ComposeCandidateInput{Candidate: key, Input: true, Call: hex.EncodeToString(bits[:])}) got <- reply{raw, err} }() var raw json.RawMessage @@ -146,17 +157,36 @@ func (c *compositionInputs) one(ctx context.Context, bound time.Duration, node, case a.Verdict == nec.Unready: in.Why = "unready: " + a.Refused return in - case len(a.Input) == 0: + case a.Chunks == 0 && len(a.Input) == 0: in.Why = "the engine answered no composition input" if a.Refused != "" { in.Why += ": " + a.Refused } return in } - body, err := json.Marshal(a.Input) - if err != nil { - in.Why = "its composition input cannot be encoded again: " + err.Error() - return in + var body []byte + if a.Chunks > 0 { + // The composition input is the file the chunks carried, the engine's own bytes (numbers as written). + var whole struct { + File string `json:"file"` + } + if err := json.Unmarshal(raw, &whole); err != nil { + in.Why = "its answer is not a compose-candidate answer: " + err.Error() + return in + } + file, err := base64.StdEncoding.DecodeString(whole.File) + if err != nil || len(file) == 0 { + in.Why = fmt.Sprintf("the engine named %d chunks of composition input and the file received is empty or not base64: %v", a.Chunks, err) + return in + } + body = file + } else { + // An answer with the input inline (an engine before A-237b): the object, as it was. + var err error + if body, err = json.Marshal(a.Input); err != nil { + in.Why = "its composition input cannot be encoded again: " + err.Error() + return in + } } in.Body = body return in diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositioninputs_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositioninputs_test.go index 1499a32b..78fe48e1 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositioninputs_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositioninputs_test.go @@ -2,8 +2,10 @@ package main import ( "context" + "encoding/base64" "encoding/json" "errors" + "regexp" "strings" "sync" "testing" @@ -69,8 +71,9 @@ func TestAStepsInputsAreAskedOfEachMachine(t *testing.T) { // gather asks the machines side by side, so the record of what each was asked is guarded. var mu sync.Mutex asked := map[string]string{} - call := func(node, key string, body any) (json.RawMessage, error) { + call := func(key string, body any) (json.RawMessage, error) { raw, _ := json.Marshal(body) + key, node, _ := strings.Cut(key, "@") // addressed to one node (A-237b) mu.Lock() asked[node] = key + " " + string(raw) mu.Unlock() @@ -82,13 +85,15 @@ func TestAStepsInputsAreAskedOfEachMachine(t *testing.T) { } return json.RawMessage(`{"candidate":"run-r1","node":"` + node + `","verdict":"composed","input":{"n":12345678901234567890,"node":"` + node + `"},"modules":[],"own":{},"took":1,"v":1}`), nil } - c := &compositionInputs{machines: func(module, branch string) []string { return []string{"ace", "g14", "novox", "shanks"} }, call: call, bound: time.Second} + c := &compositionInputs{machines: func(module, branch string) []string { return []string{"ace", "g14", "novox", "shanks"} }, callFile: call, bound: time.Second} got, err := c.gather(context.Background(), meshwants.StepRun{Module: "m", Branch: "main", Run: "r1"}, func(node string) bool { return node == "shanks" }) if err != nil || len(got) != 4 { t.Fatalf("%+v %v", got, err) } - if want := `seat:node-engine.compose-candidate {"candidate":"run-r1","input":true}`; asked["ace"] != want { - t.Errorf("asked %q, want %q", asked["ace"], want) + // With a call token of 128 random bits (32 hex digits), the verb being marked chunks. + if k, body, _ := strings.Cut(asked["ace"], " "); k != "seat:node-engine.compose-candidate" || + !regexp.MustCompile(`^\{"call":"[0-9a-f]{32}","candidate":"run-r1","input":true\}$`).MatchString(body) { + t.Errorf("asked %q", asked["ace"]) } if got[0].Node != "ace" || got[0].Why != "" || !strings.Contains(string(got[0].Body), "12345678901234567890") { t.Errorf("ace: %+v", got[0]) @@ -99,8 +104,34 @@ func TestAStepsInputsAreAskedOfEachMachine(t *testing.T) { if _, was := asked["shanks"]; was || !got[3].Away { t.Errorf("the machine away is asked or not said away: %+v", got[3]) } - none := &compositionInputs{machines: func(string, string) []string { return nil }, call: call} + none := &compositionInputs{machines: func(string, string) []string { return nil }, callFile: call} if _, err := none.gather(context.Background(), meshwants.StepRun{Module: "m", Run: "r1"}, nil); err == nil { t.Error("a step with no machine is gathered") } } + +// A-237b: the composition input is any size, so a node names the chunks it sent and the assigner reads the file the chunked call +// received as the input, its numbers as written; a node that names chunks and sends no file is said so. +func TestAStepsInputIsTheFileOfTheNodesChunks(t *testing.T) { + input := `{"n":12345678901234567890,"big":"` + strings.Repeat("x", 1<<20) + `"}` + file := base64.StdEncoding.EncodeToString([]byte(input)) + call := func(key string, body any) (json.RawMessage, error) { + _, node, _ := strings.Cut(key, "@") + answer := `{"candidate":"run-r1","node":"` + node + `","verdict":"composed","modules":[],"own":{},"took":1,"v":1,"chunks":3` + if node == "g14" { + return json.RawMessage(answer + `}`), nil // names chunks, none received + } + return json.RawMessage(answer + `,"file":"` + file + `"}`), nil + } + c := &compositionInputs{machines: func(module, branch string) []string { return []string{"ace", "g14"} }, callFile: call, bound: time.Second} + got, err := c.gather(context.Background(), meshwants.StepRun{Module: "m", Branch: "main", Run: "r1"}, func(string) bool { return false }) + if err != nil || len(got) != 2 { + t.Fatalf("%+v %v", got, err) + } + if got[0].Why != "" || string(got[0].Body) != input { + t.Errorf("ace: why %q, %d bytes, want the file received (%d bytes) as the input", got[0].Why, len(got[0].Body), len(input)) + } + if !strings.Contains(got[1].Why, "chunks") || got[1].Body != nil { + t.Errorf("g14: %+v", got[1]) + } +} diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionrun_test.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionrun_test.go index fa0ca057..341e5796 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionrun_test.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/compositionrun_test.go @@ -71,7 +71,8 @@ func newRunStand(t *testing.T, revisionEngine, trunkEngine, seatDigest string) * } return nil, errors.New("no such verb " + key) } - engines := func(node, _ string, _ any) (json.RawMessage, error) { + engines := func(key string, _ any) (json.RawMessage, error) { + _, node, _ := strings.Cut(key, "@") // addressed to one node (A-237b) return json.RawMessage(`{"candidate":"main.7","node":"` + node + `","verdict":"composed","input":{"node":"` + node + `"},"modules":[],"own":{},"took":1,"v":1}`), nil } running := map[string]string{"ace": "src2:e1", "g14": "src2:e2"} @@ -80,7 +81,7 @@ func newRunStand(t *testing.T, revisionEngine, trunkEngine, seatDigest string) * keeper := testKeeper(&objectsMem{objs: map[string][]byte{}}, time.Now) ends := &runEnds{} s.r = &compositionRun{ - inputs: &compositionInputs{machines: func(string, string) []string { return []string{"ace", "g14", "shanks"} }, call: engines, bound: time.Second}, + inputs: &compositionInputs{machines: func(string, string) []string { return []string{"ace", "g14", "shanks"} }, callFile: engines, bound: time.Second}, keeper: keeper, call: call, ends: ends, away: away, now: time.Now, logf: t.Logf, trunk: func() (mcc.Half, bool) { return mcc.Half{Entries: map[string]meshcatalog.CatalogEntry{"engine": engine(trunkEngine, commitE1)}}, true diff --git a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go index 94c57402..4d3da00a 100644 --- a/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go +++ b/modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/main.go @@ -675,7 +675,7 @@ func follow(ctx context.Context, js jetstream.JetStream, nc process.Subscriber, } // The composition step (design 47 G §22, §354): the seat mesh-wants' accepted kind step, run by one run ask per machine. if bus != nil && js != nil && inputs != nil && p.publishWants != nil { - run := &compositionRun{inputs: &compositionInputs{machines: w.machinesOf, call: bus.CallKeptOn}, keeper: inputs, call: bus.CallKept, + run := &compositionRun{inputs: &compositionInputs{machines: w.machinesOf, callFile: bus.CallFile}, keeper: inputs, call: bus.CallKept, trunk: trunkOf(iv, w.trunkName), running: w.runningOf, away: away, put: runAskPublisher(js), ends: ends, ask: bus.CallFile, now: time.Now, logf: logger.Printf} steps := &compositionSteps{node: thisNode, say: p.publishWants, run: run.run, now: time.Now, logf: logger.Printf, asker: stepAskerOf(seatlist.Definition(gate.Reader, meshwants.Seat))}