Builder: a build takes over an older unreleased reservation; builder_reserve_done reserves for a done build
A trunk build reserving while its series is reserved by an older build never released drops the older reservation's bound and finding and says so in the journal. builder_reserve_done (a hand act, reasks mode reserve-done) reserves the series' next version for a done trunk build that reserved none, with the done key's digests, and queues its publish as builder_publish_again does. Builds: design 47 G A-455, §369, §588
This commit is contained in:
@@ -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
|
||||
}},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)}
|
||||
|
||||
@@ -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")
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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.<module>.<fingerprint>` (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"
|
||||
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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
|
||||
)
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -29,6 +29,7 @@
|
||||
"builder_reserved",
|
||||
"builder_release",
|
||||
"builder_reserved_drop",
|
||||
"builder_reserve_done",
|
||||
"builder_seat_queue",
|
||||
"builder_stuck",
|
||||
"builder_toolchains",
|
||||
|
||||
Reference in New Issue
Block a user