diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/waits_test.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/waits_test.go index e782acf2..a65a854f 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/waits_test.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/waits_test.go @@ -2,6 +2,7 @@ package main import ( "encoding/json" + "errors" "strings" "testing" "time" @@ -44,3 +45,56 @@ func TestWaitsToolsListTheWaitsAndReleaseAfterTheHandAct(t *testing.T) { t.Fatalf("release: %v, %d recorded, asked %+v", err, recorded, asked) } } + +// Design 47 G A-455: builder_reserve_done records the hand act first and only then asks the builder through reasks; the builder's +// answer (the version and its queued publish) is the tool's answer, its refusal the tool's error, and an act that was not +// recorded asks nothing. +func TestReserveDoneRecordsTheHandActFirstAndAnswersTheBuilders(t *testing.T) { + var order []string + var asked []build.ReAsk + reply := func(refuse bool) func(string, []byte) (json.RawMessage, error) { + return func(key string, value []byte) (json.RawMessage, error) { + order = append(order, "asked") + a, _ := build.DecodeReAsk(value) + asked = append(asked, a) + a.Answered, a.Answer, a.Refused = time.Now(), "reserved 0.1.13 for node-tools and queued 1 versions to publish: node-tools@0.1.13", refuse + if refuse { + a.Answer = "the build key is not done" + } + return json.Marshal(a) + } + } + record := func(fail bool) meshhandactsclient.Recorder { + return meshhandactsclient.Recorder{Ask: func(string, any) (json.RawMessage, error) { + order = append(order, "recorded") + if fail { + return nil, errors.New("no responders") + } + return json.RawMessage(`{}`), nil + }} + } + run := func(ask func(string, []byte) (json.RawMessage, error), acts meshhandactsclient.Recorder, args map[string]any) (any, error) { + for _, tl := range reservedTools(versions.Reader{}, ask, time.Now, acts) { + if tl.Name == versions.ReserveDoneTool { + return tl.Run(args) + } + } + t.Fatal("the bundle serves no builder_reserve_done") + return nil, nil + } + args := map[string]any{"module": "node-tools", "fp": "src2:7df8", "why": "its build ended done with no version"} + out, err := run(reply(false), record(false), args) + if err != nil || len(order) != 2 || order[0] != "recorded" || order[1] != "asked" || asked[0].Mode != build.ModeReserveDone || asked[0].Name != "node-tools" || asked[0].FP != "src2:7df8" { + t.Fatalf("answer %v, %v; order %v, asked %+v", out, err, order, asked) + } + if ans := out.(map[string]any)["answer"].(string); !strings.Contains(ans, "reserved 0.1.13") || !strings.Contains(ans, "queued 1 versions") { + t.Errorf("the answer %q names no version and queued publish", ans) + } + if _, err := run(reply(true), record(false), args); err == nil || !strings.Contains(err.Error(), "not done") { + t.Errorf("the builder's refusal is not the tool's error: %v", err) + } + order = nil + if _, err := run(reply(false), record(true), args); err == nil || len(order) != 1 || order[0] != "recorded" { + t.Errorf("an unrecorded act was asked of the builder: %v, %v", err, order) + } +} diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go index bbdd9392..de6cd2a2 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go @@ -247,18 +247,7 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro acts.Republish = republish.Republish reserved.publishAtEnd = republish.Ended // builder_reserve_done: a done trunk build that reserved none is given a version, and its publish queued as publish again does. - acts.ReserveDone = func(ctx context.Context, module, fp, by, why string, at time.Time) (string, error) { - res, err := b.ReserveDone(ctx, module, fp) - if err != nil { - return "", err - } - logger.Printf("%s at %s: version %s is reserved by hand (%s, %s) for the done build", module, fp, res.Version, by, why) - queued, err := republish.Republish(ctx, module, res.Version) - if err != nil { - return "", fmt.Errorf("%s is reserved for %s at %s, but its publish is not queued (builder_publish_again queues it): %w", res.Version, module, fp, err) - } - return fmt.Sprintf("reserved %s for %s at %s and queued %d versions to publish: %s; builder_publish_queue shows them", res.Version, module, fp, len(queued), strings.Join(queued, ", ")), nil - } + acts.ReserveDone = reserveDoneAct(b.ReserveDone, republish.Republish, logger.Printf) again := &republishing{rp: republish} // The operator is asked once a key's event builds are spent (design 47 G §568): the builder's asker on the seat operator-channel. decided := &decisions{subject: oc.SubjectDecided(cred.Module)} diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve.go index 0296509b..05af9ef5 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve.go @@ -341,3 +341,22 @@ func (rv *reservations) noMark(ctx context.Context, o versions.Outcome) string { } return strings.Join(out, "; ") } + +// reserveDoneAct is builder_reserve_done's act (design 47 G A-455): the next version of the series is reserved for a done trunk build +// that reserved none, and its publish is queued as builder_publish_again queues it. Its answer says the version and the queued +// publishes; a reservation whose publish could not be queued is said so, with the tool that queues it. +func reserveDoneAct(reserve func(ctx context.Context, module, fp string) (versions.ReservedVersion, error), + republish func(ctx context.Context, module, version string) ([]string, error), logf func(string, ...any)) func(ctx context.Context, module, fp, by, why string, at time.Time) (string, error) { + return func(ctx context.Context, module, fp, by, why string, at time.Time) (string, error) { + res, err := reserve(ctx, module, fp) + if err != nil { + return "", err + } + logf("%s at %s: version %s is reserved by hand (%s, %s) for the done build", module, fp, res.Version, by, why) + queued, err := republish(ctx, module, res.Version) + if err != nil { + return "", fmt.Errorf("%s is reserved for %s at %s, but its publish is not queued (builder_publish_again queues it): %w", res.Version, module, fp, err) + } + return fmt.Sprintf("reserved %s for %s at %s and queued %d versions to publish: %s; builder_publish_queue shows them", res.Version, module, fp, len(queued), strings.Join(queued, ", ")), nil + } +} diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve_test.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve_test.go index 1c94a32a..16772f57 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve_test.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve_test.go @@ -17,6 +17,7 @@ import ( "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshbuilds" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" + "mesh-delivery-builder/internal/build" "mesh-delivery-builder/internal/versions" ) @@ -293,3 +294,81 @@ func TestABuildTakingOverAnOlderReservationDropsItsBoundAndSaysSo(t *testing.T) t.Errorf("reserved for fp-new: %+v %v", got, ok) } } + +// ansKV records the value versionActed writes back to a reasks key. +type ansKV struct { + jetstream.KeyValue + wrote chan []byte +} + +func (a *ansKV) Update(_ context.Context, _ string, v []byte, _ uint64) (uint64, error) { + a.wrote <- v + return 2, nil +} + +type ansEntry struct { + jetstream.KeyValueEntry + key string + value []byte +} + +func (e ansEntry) Key() string { return e.key } +func (e ansEntry) Revision() uint64 { return 1 } +func (e ansEntry) Value() []byte { return e.value } +func (e ansEntry) Operation() jetstream.KeyValueOp { return jetstream.KeyValuePut } + +// TestAReserveDoneIsAnsweredWithTheVersionAndItsQueuedPublish: design 47 G A-455 — the reasks value of builder_reserve_done reaches +// the act, which reserves for the done build and queues the publish as publish again does, and its answer names both; a +// refusal of the reserving queues nothing and is the answer; a publish that cannot be queued says the version is reserved. +func TestAReserveDoneIsAnsweredWithTheVersionAndItsQueuedPublish(t *testing.T) { + ctx := context.Background() + var queued []string + var logged []string + logf := func(f string, a ...any) { logged = append(logged, fmt.Sprintf(f, a...)) } + reserve := func(_ context.Context, module, fp string) (versions.ReservedVersion, error) { + if fp == "refused" { + return versions.ReservedVersion{}, fmt.Errorf("the build key of %s at %s is not done", module, fp) + } + return versions.ReservedVersion{Module: module, Version: "0.1.13", Fingerprint: fp}, nil + } + republish := func(_ context.Context, module, version string) ([]string, error) { + if module == "nope" { + return nil, fmt.Errorf("the queue is full") + } + queued = append(queued, module+"@"+version) + return []string{module + "@" + version}, nil + } + acts := versions.Acts{ReserveDone: reserveDoneAct(reserve, republish, logf)} + for _, c := range []struct { + module, fp, want string + refused bool + }{ + {"node-tools", "src2:7df8", "reserved 0.1.13 for node-tools at src2:7df8 and queued 1 versions to publish: node-tools@0.1.13", false}, + {"node-tools", "refused", "not done", true}, + {"nope", "src2:1", "0.1.13 is reserved for nope at src2:1, but its publish is not queued", true}, + } { + value, err := json.Marshal(build.ReAsk{V: 1, Why: "w", By: "me", Mode: build.ModeReserveDone, Name: c.module, FP: c.fp}) + if err != nil { + t.Fatal(err) + } + kv := &ansKV{wrote: make(chan []byte, 1)} + // reAsked sends a reserve-done to the version acts (b is not asked), and the answer is written back to the key. + reAsked(ctx, nil, acts, kv, ansEntry{key: "reserve-done." + c.module, value: value}, logf) + var wrote []byte + select { + case wrote = <-kv.wrote: + case <-time.After(10 * time.Second): + t.Fatalf("%s at %s: no answer was written to the key", c.module, c.fp) + } + var got build.ReAsk + if err := json.Unmarshal(wrote, &got); err != nil || got.Refused != c.refused || !strings.Contains(got.Answer, c.want) || got.Answered.IsZero() { + t.Errorf("%s at %s: written %s (%v), want refused=%v containing %q", c.module, c.fp, wrote, err, c.refused, c.want) + } + } + if !slices.Equal(queued, []string{"node-tools@0.1.13"}) { + t.Errorf("queued %v, want only node-tools@0.1.13", queued) + } + if !slices.ContainsFunc(logged, func(l string) bool { return strings.Contains(l, "0.1.13 is reserved by hand") }) { + t.Errorf("the reserving by hand is not said in the log: %q", logged) + } +}