diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/reserved.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/reserved.go index 983a54f4..a690371c 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/reserved.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder-tools/reserved.go @@ -13,7 +13,7 @@ import ( "mesh-delivery-builder/internal/versions" ) -// reservedTools are builder_reserved and builder_reserved_drop (design 47 G section 369), served as tools of the bundle. The drop is a hand act: it is recorded in the hand-act log first, then written to +// reservedTools are builder_reserved, builder_reserved_drop and builder_reserve_done (A-455) (design 47 G section 369), served as tools of the bundle. The drop is a hand act: it is recorded in the hand-act log first, then written to // reasks for the builder, which owns the reservations, to answer. // // The seat's verb reserved is the builder's process's (design 47 G A-115, A-127), not the bundle's. @@ -51,5 +51,32 @@ func reservedTools(rr versions.Reader, ask queueAsker, now func() time.Time, act } return map[string]any{"key": key, "answer": a.Answer}, nil }}, + {Name: versions.ReserveDoneTool, Description: versions.ReserveDoneDescription, + Input: map[string]any{"type": "object", "required": []string{"module", "fp", "why"}, "properties": map[string]any{ + "module": map[string]any{"type": "string", "description": "the module"}, + "fp": map[string]any{"type": "string", "description": "the fingerprint of its done trunk build"}, + "why": map[string]any{"type": "string", "description": "why, in plain words"}}}, + Run: func(args map[string]any) (any, error) { + key, value, err := build.NewReserveDone(str(args, "module"), str(args, "fp"), str(args, "why"), stdio.CallerOf(args), now()) + if err != nil { + return nil, err + } + if _, err := acts.Record(meshhandactsclient.Request{What: fmt.Sprintf("reserved a version for the done build of %s at %s by hand", str(args, "module"), str(args, "fp")), + Why: str(args, "why"), Cause: versions.ReserveDoneTool, Verb: "reserve-done"}); err != nil { + return nil, fmt.Errorf("the hand act was not recorded through mesh-hand-acts, so nothing was reserved: %w", err) + } + raw, err := ask(key, value) + if err != nil { + return nil, err + } + a, err := build.DecodeReAsk(raw) + if err != nil { + return nil, err + } + if a.Refused { + return nil, errors.New(a.Answer) + } + return map[string]any{"key": key, "answer": a.Answer}, nil + }}, } } 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 ff60d11f..bbdd9392 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go @@ -246,6 +246,19 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro Holders: holders} // a registry seat's holder from the seat-holders view, from the start (design 47 G A-416, A-416a) 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 + } 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/reasks.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reasks.go index c8d4f0b2..7fd7712f 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reasks.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reasks.go @@ -58,7 +58,7 @@ func reAsked(ctx context.Context, b askAgainer, acts versions.Acts, kv jetstream released(ctx, b, kv, e, r, logf) return } - if r.Mode == build.ModeRepublish || r.Mode == build.ModeFloorAgain || r.Mode == build.ModeOldFormDrop || r.Mode == build.ModeReservedDrop { + if r.Mode == build.ModeRepublish || r.Mode == build.ModeFloorAgain || r.Mode == build.ModeOldFormDrop || r.Mode == build.ModeReservedDrop || r.Mode == build.ModeReserveDone { // A version's hand act (design 51 *Tools of the builder*) may build again, so it is answered beside the watch. go versionActed(ctx, acts, kv, e, r, logf) return @@ -201,6 +201,12 @@ func versionActed(ctx context.Context, acts versions.Acts, kv jetstream.KeyValue r.Answer = "queued " + fmt.Sprint(len(r.Queued)) + " versions to publish again: " + strings.Join(r.Queued, ", ") + "; builder_publish_queue shows them" } } + } else if r.Mode == build.ModeReserveDone { + if acts.ReserveDone == nil { + err = errors.New("this builder keeps no reservations") + } else { + r.Answer, err = acts.ReserveDone(ctx, r.Name, r.FP, r.By, r.Why, r.At) + } } else if r.Mode == build.ModeReservedDrop { if acts.DropReserved == nil { err = errors.New("this builder keeps no reservations") 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 75ef30f4..0296509b 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve.go @@ -74,11 +74,34 @@ func newReservations(store versions.ReserveStore, call toolCaller, bounds func() } return out, nil }} + rv.r.Took = rv.took return rv } +// took is a build's takeover of the reservation of an older build never released (design 47 G A-455): the older version is +// dropped, its bound ended and its finding cleared (the newer build's reservation has its own), and the builder's log says so. +func (rv *reservations) took(ctx context.Context, older, newer versions.ReservedVersion) { + rv.logf("%s: the reservation of %s (build of %s, never released) is dropped: the build of %s takes the series over and reserves %s", newer.Module, older.Version, older.Fingerprint, newer.Fingerprint, newer.Version) + rv.dropBound(ctx, versions.ReservedKey(older.Module, older.Series)) + rv.found.clear(ctx, versions.VersionUnreleased, meshconditionsclient.ScopeModule, older.Module) +} + var _ build.Reservations = (*reservations)(nil) +// ReservedFor is the reservation made for the build of fingerprint. +func (rv *reservations) ReservedFor(ctx context.Context, module, fingerprint string) (versions.ReservedVersion, bool, error) { + all, err := rv.r.All(ctx) + if err != nil { + return versions.ReservedVersion{}, false, err + } + for _, v := range all { + if v.Module == module && v.Fingerprint == fingerprint { + return v, true, nil + } + } + return versions.ReservedVersion{}, false, nil +} + func (rv *reservations) Filled() bool { return rv.filled.Load() } func (rv *reservations) Reserve(ctx context.Context, module, series string, artifacts []string, src versions.Source) (versions.ReservedVersion, error) { 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 28218fad..1c94a32a 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 @@ -5,6 +5,7 @@ import ( "encoding/json" "fmt" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" + "slices" "strings" "testing" "time" @@ -250,3 +251,45 @@ func TestAPublishedHeardBeforeTheDigestsIsSaidWhenTheBuildRecordsThem(t *testing t.Fatalf("package-published said again: %+v", said) } } + +// TestABuildTakingOverAnOlderReservationDropsItsBoundAndSaysSo: design 47 G A-455 — a build that reserves while the series is +// reserved by an older build never released drops the older one's bound and finding and says so in the builder's journal. +func TestABuildTakingOverAnOlderReservationDropsItsBoundAndSaysSo(t *testing.T) { + ctx := context.Background() + st := &memFindings{vals: map[string][]byte{}} + found := &findings{module: builds.BuilderModule, w: st, logf: t.Logf, now: func() time.Time { return time.Unix(0, 0) }} + bounds := &boundsKV{keys: map[string]bool{}} + var journal []string + call := func(string, any) (json.RawMessage, error) { + return json.Marshal(meshcatalog.VersionsAnswer{Module: "m"}) + } + rv := newReservations(&memReserve{vals: map[string][]byte{}, revs: map[string]uint64{}}, call, func() jetstream.KeyValue { return bounds }, found, + nil, func(f string, a ...any) { journal = append(journal, fmt.Sprintf(f, a...)) }) + rv.filled.Store(true) + older, err := rv.Reserve(ctx, "m", "0.1", []string{"m:a"}, versions.Source{Fingerprint: "fp-old"}) + if err != nil { + t.Fatal(err) + } + if err := rv.Built(ctx, "m", older.Version, map[string]string{"m:a": "sha256:a"}, nil); err != nil { + t.Fatal(err) + } + rv.unreleased(ctx, older, "nothing within the bound") + if !bounds.keys[versions.ReservedBoundKey("m", "0.1")] || len(st.vals) != 1 { + t.Fatalf("the older reservation's bound %v or finding %v is not there", bounds.keys, st.vals) + } + newer, err := rv.Reserve(ctx, "m", "0.1", []string{"m:a"}, versions.Source{Fingerprint: "fp-new"}) + if err != nil || newer.Version != "0.1.1" { + t.Fatalf("reserved %q (%v), want 0.1.1", newer.Version, err) + } + if len(bounds.keys) != 0 || len(st.vals) != 0 { + t.Errorf("after the takeover: bounds %v, findings %v; want none", bounds.keys, st.vals) + } + if !slices.ContainsFunc(journal, func(l string) bool { + return strings.Contains(l, "0.1.0") && strings.Contains(l, "dropped") && strings.Contains(l, "0.1.1") + }) { + t.Errorf("journal %q does not say the reservation of 0.1.0 was dropped for 0.1.1", journal) + } + if got, ok, _ := rv.ReservedFor(ctx, "m", "fp-new"); !ok || got.Version != "0.1.1" { + t.Errorf("reserved for fp-new: %+v %v", got, ok) + } +} diff --git a/modules/mesh-delivery-builder/internal/build/numbers.go b/modules/mesh-delivery-builder/internal/build/numbers.go index 15b1f888..c409187c 100644 --- a/modules/mesh-delivery-builder/internal/build/numbers.go +++ b/modules/mesh-delivery-builder/internal/build/numbers.go @@ -2,6 +2,7 @@ package build import ( "context" + "errors" "fmt" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshbuilds" "git.novox.be/novox/mesh-sdk/go/catalogue" @@ -139,6 +140,8 @@ type Reservations interface { // Built records the digests of the artifacts built under the reserved version, by reference, and what each resolved and was // built with (design 47 G §466, §673). Built(ctx context.Context, module, version string, digests map[string]string, deps map[string][]meshbuilds.Dependency) error + // ReservedFor is the reservation made for the build of fingerprint, and whether there is one. + ReservedFor(ctx context.Context, module, fingerprint string) (versions.ReservedVersion, bool, error) } // reserves says whether a look at a trunk build is one that reserves: the build has a series of the form MAJOR.MINOR @@ -191,3 +194,70 @@ func (b *Builder) reserve(ctx context.Context, module string, m meshcatalog.Modu b.logf("%s: version %s is reserved for this build", module, res.Version) return res, true } + +// ReserveDone is builder_reserve_done (design 47 G A-455): a done trunk build of the first watched branch that reserved no +// version (its key is done, so a look never reserves for it, and a done key cannot be built again) reserves the next version of +// its series now, with the digests the done key holds, as a build that started would, and its build ends with every digest +// recorded. It answers the reserved version; the caller queues its publish (versions.Republisher). A fingerprint whose key is not +// done, whose entry no watched branch carries now, that is no first branch's, or that holds a reservation already is refused, saying which. +func (b *Builder) ReserveDone(ctx context.Context, module, fp string) (versions.ReservedVersion, error) { + b.init() + if b.Reserved == nil { + return versions.ReservedVersion{}, errors.New("this builder reserves no versions") + } + key, err := builds.BuilderBuildKey(module, fp) + if err != nil { + return versions.ReservedVersion{}, err + } + b.mu.Lock() + var m meshcatalog.ModulesByModuleValue + found := false + for hk, v := range b.heard { + if strings.HasSuffix(hk, "\x00"+module) && v.Fp2 == fp { + m, found = v, true + } + } + trunk, first := b.trunkFP[key], b.origin[key].First + b.mu.Unlock() + switch { + case !found: + return versions.ReservedVersion{}, fmt.Errorf("no watched branch carries an entry of %s at %s now, so there is nothing to reserve it from", module, fp) + case !trunk || !first: + return versions.ReservedVersion{}, fmt.Errorf("%s at %s is not the first watched branch's build: only that one reserves a version (§371)", module, fp) + } + digests := b.doneDigests(ctx, module, fp) + if digests == nil { + return versions.ReservedVersion{}, fmt.Errorf("the build key of %s at %s is not done", module, fp) + } + plan, planErr, _ := b.planOf(ctx, m.Manifest) + switch { + case planErr != nil: + return versions.ReservedVersion{}, fmt.Errorf("the plan of %s at %s cannot be read: %w", module, fp, planErr) + case len(plan.Tasks) == 0 || strings.Count(plan.Series, ".") != 1: + return versions.ReservedVersion{}, fmt.Errorf("%s at %s builds nothing or has no MAJOR.MINOR series (%q): it reserves no version", module, fp, plan.Series) + } + if cur, ok, err := b.Reserved.ReservedFor(ctx, module, fp); err != nil { + return versions.ReservedVersion{}, err + } else if ok { + return versions.ReservedVersion{}, fmt.Errorf("%s at %s holds the reservation of %s already", module, fp, cur.Version) + } + if !b.Reserved.Filled() { + return versions.ReservedVersion{}, versions.ErrNotFilled + } + res, ok := b.reserve(ctx, module, m, plan, b.originOf(key)) + if !ok { + return versions.ReservedVersion{}, fmt.Errorf("no version could be reserved for %s at %s (the builder's journal says why)", module, fp) + } + refs := map[string]string{} + for _, t := range plan.Tasks { + d, have := digests[t.Artifact] + if !have { + return res, fmt.Errorf("%s is reserved for %s at %s, but the done key holds no digest of %s", res.Version, module, fp, t.Artifact) + } + refs[module+":"+t.Artifact] = d + } + if err := b.Reserved.Built(ctx, module, res.Version, refs, nil); err != nil { + return res, fmt.Errorf("%s is reserved for %s at %s, but its digests are not recorded: %w", res.Version, module, fp, err) + } + return res, nil +} diff --git a/modules/mesh-delivery-builder/internal/build/reserve_test.go b/modules/mesh-delivery-builder/internal/build/reserve_test.go index d0979f55..81189adb 100644 --- a/modules/mesh-delivery-builder/internal/build/reserve_test.go +++ b/modules/mesh-delivery-builder/internal/build/reserve_test.go @@ -31,6 +31,15 @@ type fakeReservations struct { func (f *fakeReservations) Filled() bool { return f.filled } +func (f *fakeReservations) ReservedFor(_ context.Context, _, fp string) (versions.ReservedVersion, bool, error) { + for _, s := range f.sources { + if s.Fingerprint == fp { + return versions.ReservedVersion{Version: "held"}, true, nil + } + } + return versions.ReservedVersion{}, false, nil +} + func (f *fakeReservations) Reserve(_ context.Context, module, series string, artifacts []string, src versions.Source) (versions.ReservedVersion, error) { f.reserved, f.series, f.sources = append(f.reserved, artifacts), append(f.series, series), append(f.sources, src) return versions.ReservedVersion{Module: module, Series: series, Version: series + ".5"}, nil diff --git a/modules/mesh-delivery-builder/internal/build/reservedone_test.go b/modules/mesh-delivery-builder/internal/build/reservedone_test.go new file mode 100644 index 00000000..693b48cb --- /dev/null +++ b/modules/mesh-delivery-builder/internal/build/reservedone_test.go @@ -0,0 +1,56 @@ +package build + +import ( + "context" + "slices" + "strings" + "testing" + "time" + + "git.novox.be/novox/mesh-sdk/go/catalogue" + + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" +) + +// TestADoneTrunkBuildThatReservedNoneIsGivenAVersionByHand: design 47 G A-455 — builder_reserve_done reserves the series' next +// version for a done key that reserved none, with the digests the key holds; a key not done, a fingerprint no entry carries and +// a build that holds a reservation already are refused; the value it writes is a reasks value of its own key. +func TestADoneTrunkBuildThatReservedNoneIsGivenAVersionByHand(t *testing.T) { + ctx := context.Background() + r := newRig(t, goBundle) + r.mf.byDigest[mdigest('a')] = catalogue.Manifest{Module: "m", Version: "0.1", Build: &catalogue.Build{Artifacts: []catalogue.Artifact{goBundle}}} + res := &fakeReservations{filled: true} + r.b.Reserved = res + if _, err := r.b.ReserveDone(ctx, "m", fp1); err == nil { + t.Fatal("a version was reserved for a key that is not built") + } + // The build ran while the builder reserved nothing (as the live key did): done, with no reservation. + r.b.Reserved = nil + if v := r.consider(t, "modules/m"); v.State != builds.BuildDone { + t.Fatalf("build = %+v, want done", v) + } + r.b.Reserved = res + if _, err := r.b.ReserveDone(ctx, "m", "src2:"+strings.Repeat("9", 64)); err == nil || !strings.Contains(err.Error(), "no watched branch carries") { + t.Errorf("a fingerprint no entry carries: %v", err) + } + got, err := r.b.ReserveDone(ctx, "m", fp1) + if err != nil || got.Version != "0.1.5" || !slices.Equal(res.series, []string{"0.1"}) || !slices.Equal(res.reserved[0], []string{"m:tool"}) { + t.Fatalf("reserved %+v (%v) in %v for %v, want 0.1.5 of m:tool in 0.1", got, err, res.series, res.reserved) + } + if res.built["m:tool"] != digest || res.sources[0].Fingerprint != fp1 { + t.Errorf("recorded %v from %+v, want the done key's digest for the entry %s", res.built, res.sources, fp1) + } + if _, err := r.b.ReserveDone(ctx, "m", fp1); err == nil || !strings.Contains(err.Error(), "reservation") { + t.Errorf("a build that holds a reservation was given another: %v", err) + } + at := time.Unix(0, 0) + key, _, err := NewReserveDone("m", fp1, "why", "op", at) + if err != nil || !strings.HasPrefix(key, "reserve-done.") { + t.Errorf("key %q (%v)", key, err) + } + for _, args := range [][3]string{{"", fp1, "why"}, {"m", "", "why"}, {"m", fp1, " "}} { + if _, _, err := NewReserveDone(args[0], args[1], args[2], "op", at); err == nil { + t.Errorf("%q made a value", args) + } + } +} diff --git a/modules/mesh-delivery-builder/internal/build/stuck.go b/modules/mesh-delivery-builder/internal/build/stuck.go index 9f156410..c7ec4c46 100644 --- a/modules/mesh-delivery-builder/internal/build/stuck.go +++ b/modules/mesh-delivery-builder/internal/build/stuck.go @@ -137,6 +137,24 @@ func NewReservedDrop(module, series, why, by string, at time.Time) (string, []by return "reserved." + versions.ReservedKey(module, series), data, err } +// ModeReserveDone is the Mode of a reasks value of builder_reserve_done (design 47 G A-455): Name is the module and FP the +// fingerprint of a done trunk build that reserved no version. +const ModeReserveDone = "reserve-done" + +// NewReserveDone is the value builder_reserve_done writes: the key `reserve-done..` (never a build key) and +// the value. +func NewReserveDone(module, fp, why, by string, at time.Time) (string, []byte, error) { + module, fp = strings.TrimSpace(module), strings.TrimSpace(fp) + if module == "" || fp == "" { + return "", nil, errors.New("module and fp are required") + } + if strings.TrimSpace(why) == "" { + return "", nil, errors.New("say why a version is reserved for the done build (why)") + } + data, err := json.Marshal(ReAsk{V: 1, Why: strings.TrimSpace(why), By: by, At: at.UTC(), Mode: ModeReserveDone, Name: module, FP: fp}) + return "reserve-done." + versions.EscapeToken(module) + "." + versions.EscapeToken(fp), data, err +} + // ModeBuild is the Mode of a reasks value that asks the key to be built again, not its waiting asks to be asked again. const ModeBuild = "build" diff --git a/modules/mesh-delivery-builder/internal/versions/again.go b/modules/mesh-delivery-builder/internal/versions/again.go index 4bc81b89..5f9d2f61 100644 --- a/modules/mesh-delivery-builder/internal/versions/again.go +++ b/modules/mesh-delivery-builder/internal/versions/again.go @@ -24,6 +24,9 @@ type Acts struct { Republish func(ctx context.Context, module, version string) ([]string, error) // DropOldForm drops a retired node from the old form's count by hand (builder_old_form): its answer, or why not. DropOldForm func(ctx context.Context, node, by, why string, at time.Time) (string, error) + // ReserveDone reserves the next version for a done trunk build that reserved none and queues its publish (builder_reserve_done): + // its answer, or why not. + ReserveDone func(ctx context.Context, module, fp, by, why string, at time.Time) (string, error) // DropReserved drops a module's reservation of one MAJOR.MINOR by hand (builder_reserved_drop): its answer, or why not. DropReserved func(ctx context.Context, module, series, by, why string, at time.Time) (string, error) } diff --git a/modules/mesh-delivery-builder/internal/versions/reserve.go b/modules/mesh-delivery-builder/internal/versions/reserve.go index c6216f79..f1cb1011 100644 --- a/modules/mesh-delivery-builder/internal/versions/reserve.go +++ b/modules/mesh-delivery-builder/internal/versions/reserve.go @@ -28,6 +28,8 @@ const ( // ReservedTool is builder_reserved, ReservedDropTool builder_reserved_drop. ReservedTool = "builder_reserved" ReservedDropTool = "builder_reserved_drop" + // ReserveDoneTool is builder_reserve_done (design 47 G A-455). + ReserveDoneTool = "builder_reserve_done" // UnreleasedBound is the publish's bound: past it a built reservation with an artifact unpublished is the finding // version-unreleased (§369). UnreleasedBound = 10 * time.Minute @@ -110,7 +112,10 @@ type Reserver struct { ReleasedOf func(ctx context.Context, module string) ([]string, error) // Filled says the catalog said versions-filled. Filled func() bool - Now func() time.Time + // Took is told when a build took over the series' reservation of an older build never released (design 47 G A-455): the + // older reservation, which no want follows any more, is gone from the key, replaced by the newer's. Nil is told none. + Took func(ctx context.Context, older, newer ReservedVersion) + Now func() time.Time } func (r *Reserver) now() time.Time { @@ -182,6 +187,9 @@ func (r *Reserver) Reserve(ctx context.Context, module, series string, artifacts if err != nil { return ReservedVersion{}, fmt.Errorf("%s cannot be reserved: %w", key, err) } + if found && r.Took != nil { + r.Took(ctx, cur, out) + } return out, nil } } @@ -622,6 +630,10 @@ const ( "seat said published. With module, that module's only. A key goes when the catalog says version-released for it. Read-only." ReservedDropDescription = "Drop a module's reservation of one MAJOR.MINOR by hand (design 47 G section 369), when its version will never be " + "released; the next build takes the next after the highest released. A hand act: it is recorded in the hand-act log." + ReserveDoneDescription = "Reserve a version for a done trunk build that reserved none (design 47 G A-455): given module and fp, the next version " + + "of the series is reserved for that fingerprint with the digests of the build's artifacts, and its publish is queued as builder_publish_again " + + "queues it; builds nothing. For a done key that cannot be built again. Refused when the key is not done, is no first watched branch's, or " + + "holds a reservation already. A hand act: it is recorded in the hand-act log." // ReservedVerb is the seat mesh-builds' verb served as a tool of the same name. ReservedVerb = meshbuilds.VerbReserved ) diff --git a/modules/mesh-delivery-builder/internal/versions/reserve_test.go b/modules/mesh-delivery-builder/internal/versions/reserve_test.go index 2ba984d3..7c880271 100644 --- a/modules/mesh-delivery-builder/internal/versions/reserve_test.go +++ b/modules/mesh-delivery-builder/internal/versions/reserve_test.go @@ -58,7 +58,14 @@ func TestReservation(t *testing.T) { if err != nil || first.Version != "0.1.20" { t.Fatalf("first build reserves %q (%v), want 0.1.20 after the highest released 0.1.19", first.Version, err) } + var tookOlder, tookNewer []string + r.Took = func(_ context.Context, older, newer ReservedVersion) { + tookOlder, tookNewer = append(tookOlder, older.Version), append(tookNewer, newer.Version) + } second, err := r.Reserve(ctx, "m", "0.1", arts, Source{}) + if len(tookOlder) != 1 || tookOlder[0] != "0.1.20" || tookNewer[0] != "0.1.21" { + t.Fatalf("takeover of the older reservation told %v by %v, want 0.1.20 by 0.1.21 (design 47 G A-455)", tookOlder, tookNewer) + } if err != nil || second.Version != "0.1.21" { t.Fatalf("second build reserves %q (%v), want 0.1.21: never the first's", second.Version, err) } diff --git a/modules/mesh-delivery-builder/manifest_test.go b/modules/mesh-delivery-builder/manifest_test.go index 4d126c2d..c0b81e5b 100644 --- a/modules/mesh-delivery-builder/manifest_test.go +++ b/modules/mesh-delivery-builder/manifest_test.go @@ -175,7 +175,7 @@ func TestManifestDeclarations(t *testing.T) { // 1607/AC1 } // 1945: the builder's tools (builder_seat_queue: note 62), served by its tools bundle, and the event it says when it asks an ask again. if want := []string{"builder_announce_again", "builder_ask_again", "builder_bounds", "builder_build", "builder_build_again", "builder_builds_since", "builder_engine_reads", "builder_first_view_again", "builder_first_views", - "builder_floor_again", "builder_floor_waits", "builder_old_form", "builder_publish_again", "builder_publish_queue", "builder_release", "builder_reserved", "builder_reserved_drop", "builder_seat_list", "builder_seat_list_again", "builder_seat_queue", "builder_stuck", "builder_toolchains", "builder_toolchains_drop", "builder_versions", "builder_waits"}; !reflect.DeepEqual(sorted(m.Tools), want) { + "builder_floor_again", "builder_floor_waits", "builder_old_form", "builder_publish_again", "builder_publish_queue", "builder_release", "builder_reserve_done", "builder_reserved", "builder_reserved_drop", "builder_seat_list", "builder_seat_list_again", "builder_seat_queue", "builder_stuck", "builder_toolchains", "builder_toolchains_drop", "builder_versions", "builder_waits"}; !reflect.DeepEqual(sorted(m.Tools), want) { t.Errorf("tools = %v, want %v", m.Tools, want) } // Design 47 G §672: the toolchain waits' stream, kept 7 days within 16 MiB, and the bound's setting, 60 minutes. diff --git a/modules/mesh-delivery-builder/module.json b/modules/mesh-delivery-builder/module.json index aa8f9443..7feea927 100644 --- a/modules/mesh-delivery-builder/module.json +++ b/modules/mesh-delivery-builder/module.json @@ -29,6 +29,7 @@ "builder_reserved", "builder_release", "builder_reserved_drop", + "builder_reserve_done", "builder_seat_queue", "builder_stuck", "builder_toolchains",