The steps of one candidate share a machine's run, so a revision of 24 pipelines composes each machine once: the step that starts a run asks the node's input, keeps one request, chooses and records the composer program, and puts one run ask; every other step reads the run's verdict from its key, its end written there from the build seat's step-ended. Builds: design 47 G §718, §719, §720 (within its candidate only, could not run is never read); A-468, A-468a
163 lines
6.9 KiB
Go
163 lines
6.9 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"errors"
|
|
"regexp"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
nec "git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient"
|
|
meshwants "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshwants"
|
|
)
|
|
|
|
// Design 47 G A-226: the candidate a step asks is `run-<id>` for a run on request, else `<branch>.<revision>`.
|
|
func TestTheCandidateKeyOfAStep(t *testing.T) {
|
|
for _, c := range []struct {
|
|
run meshwants.StepRun
|
|
want string
|
|
fail bool
|
|
}{
|
|
{run: meshwants.StepRun{Run: "r1", Branch: "main"}, want: "run-r1"},
|
|
{run: meshwants.StepRun{Branch: "feat/x", Revision: 42}, want: "feat/x.42"},
|
|
{run: meshwants.StepRun{Branch: "main", Revision: 362}, want: "main.362"},
|
|
{run: meshwants.StepRun{Branch: "main"}, fail: true},
|
|
{run: meshwants.StepRun{Branch: "main", Revision: 100000000000}, fail: true}, // a number the client's key would read as a heads hash
|
|
{run: meshwants.StepRun{Run: "a.b"}, fail: true}, // a run id the client refuses
|
|
} {
|
|
got, err := candidateKeyOf(c.run)
|
|
if (err != nil) != c.fail || got != c.want {
|
|
t.Errorf("%+v: %q, %v; want %q", c.run, got, err, c.want)
|
|
}
|
|
// A-226b: the node-engine reads every key the step names with the client's one parser.
|
|
if !c.fail {
|
|
if _, err := nec.ParseCandidateKey(got); err != nil {
|
|
t.Errorf("%+v: the key %q is refused by the seat's parser: %v", c.run, got, err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// A-252: the machines of a step are the nodes whose placement names its branch; none named is the trunk; an unwatched branch takes
|
|
// the trunk's nodes.
|
|
func TestTheMachinesOfAStep(t *testing.T) {
|
|
placed := map[string]map[string]string{"m": {"ace": "", "g14": "feat", "novox": "main", "shanks": "feat"}, "other": {"ace": ""}}
|
|
for _, c := range []struct {
|
|
branch string
|
|
watched bool
|
|
want string
|
|
}{
|
|
{"main", true, "ace novox"},
|
|
{"feat", true, "g14 shanks"},
|
|
{"gone", false, "ace novox"},
|
|
{"", true, "ace novox"},
|
|
} {
|
|
if got := strings.Join(machinesFor(placed, "m", c.branch, trunkBranch, c.watched), " "); got != c.want {
|
|
t.Errorf("branch %q watched %v: %q, want %q", c.branch, c.watched, got, c.want)
|
|
}
|
|
}
|
|
if got := machinesFor(placed, "none", "main", trunkBranch, true); len(got) != 0 {
|
|
t.Errorf("a module placed nowhere has machines %v", got)
|
|
}
|
|
}
|
|
|
|
// §354, A-243, A-252, §64: each machine is asked compose-candidate with the step's key and input true, its numbers as written; a
|
|
// silent or unready node says why, and a machine away is not asked.
|
|
func TestAStepsInputsAreAskedOfEachMachine(t *testing.T) {
|
|
// the machines are asked side by side, so the record of what each was asked is guarded.
|
|
var mu sync.Mutex
|
|
asked := map[string]string{}
|
|
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()
|
|
switch node {
|
|
case "g14":
|
|
return nil, errors.New("no responders")
|
|
case "novox":
|
|
return json.RawMessage(`{"candidate":"run-r1","node":"novox","verdict":"unready","refused":"starting","modules":[],"own":{},"took":1,"v":1}`), nil
|
|
}
|
|
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"} }, callFile: call, bound: time.Second}
|
|
got, err := gatherAll(c, 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)
|
|
}
|
|
// 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])
|
|
}
|
|
if !strings.Contains(got[1].Why, "no responders") || !strings.Contains(got[2].Why, "unready") || got[1].Body != nil || got[2].Body != nil {
|
|
t.Errorf("g14 and novox: %+v %+v", got[1], got[2])
|
|
}
|
|
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 }, callFile: call}
|
|
if _, err := gatherAll(none, 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 := gatherAll(c, 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])
|
|
}
|
|
}
|
|
|
|
// gatherAll asks each machine of a step for its input as each run's start does (compositionInputs.of), side by side; a machine away
|
|
// is not asked; no machine is an error.
|
|
func gatherAll(c *compositionInputs, run meshwants.StepRun, away func(string) bool) ([]nodeInput, error) {
|
|
key, err := candidateKeyOf(run)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
nodes := c.machines(run.Module, run.Branch)
|
|
if len(nodes) == 0 {
|
|
return nil, errors.New("no machine")
|
|
}
|
|
out := make([]nodeInput, len(nodes))
|
|
var wg sync.WaitGroup
|
|
for i, node := range nodes {
|
|
if away != nil && away(node) {
|
|
out[i] = nodeInput{Node: node, Away: true}
|
|
continue
|
|
}
|
|
wg.Add(1)
|
|
go func() { defer wg.Done(); out[i] = c.of(context.Background(), node, key) }()
|
|
}
|
|
wg.Wait()
|
|
return out, nil
|
|
}
|