Builder: a released build counts as reserved for the build step (A-456a)
Builds: design 47 G A-456a, A-456
This commit is contained in:
@@ -244,6 +244,7 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
|
||||
Acted: awaitedReserved{awaitedVersions{b: actedKV, bucket: own.acted}}, Entry: entryVia(calls.Call), Send: sendVia(calls.Call),
|
||||
Unreleased: reserved.unreleasedWords, Max: republishMax, Logf: logger.Printf,
|
||||
Holders: holders} // a registry seat's holder from the seat-holders view, from the start (design 47 G A-416, A-416a)
|
||||
reserved.r.Releases = awaitedReserved{awaitedVersions{b: actedKV, bucket: own.acted}} // the record of the releases it saw (design 47 G A-456a)
|
||||
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.
|
||||
|
||||
@@ -360,3 +360,8 @@ func reserveDoneAct(reserve func(ctx context.Context, module, fp string) (versio
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
// ReleasedFor says whether a version was released for the build of fingerprint (design 47 G A-456a).
|
||||
func (rv *reservations) ReleasedFor(ctx context.Context, module, fingerprint string) (bool, error) {
|
||||
return rv.r.ReleasedFor(ctx, module, fingerprint)
|
||||
}
|
||||
|
||||
@@ -142,6 +142,8 @@ type Reservations interface {
|
||||
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)
|
||||
// ReleasedFor says whether a version was released for the build of fingerprint, read from the builder's own record (A-456a).
|
||||
ReleasedFor(ctx context.Context, module, fingerprint string) (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
|
||||
|
||||
@@ -22,6 +22,7 @@ import (
|
||||
// fakeReservations answers a fill and keeps what the builder reserved and recorded.
|
||||
type fakeReservations struct {
|
||||
filled bool
|
||||
released map[string]bool
|
||||
reserved [][]string
|
||||
series []string
|
||||
built map[string]string
|
||||
@@ -29,6 +30,10 @@ type fakeReservations struct {
|
||||
deps map[string][]meshbuilds.Dependency
|
||||
}
|
||||
|
||||
func (f *fakeReservations) ReleasedFor(_ context.Context, _, fp string) (bool, error) {
|
||||
return f.released[fp], nil
|
||||
}
|
||||
|
||||
func (f *fakeReservations) Filled() bool { return f.filled }
|
||||
|
||||
func (f *fakeReservations) ReservedFor(_ context.Context, _, fp string) (versions.ReservedVersion, bool, error) {
|
||||
|
||||
@@ -112,6 +112,11 @@ func (b *Builder) passedWithItsVersion(ctx context.Context, entry meshcatalog.Ca
|
||||
case err != nil:
|
||||
return meshbuilds.StepEndedOutcomeCouldNotRun, fmt.Sprintf("%s at %s: the reservations cannot be read: %v", entry.Module, entry.Fp, err)
|
||||
case !held:
|
||||
if released, err := b.Reserved.ReleasedFor(ctx, entry.Module, entry.Fp); err != nil {
|
||||
return meshbuilds.StepEndedOutcomeCouldNotRun, fmt.Sprintf("%s at %s: the releases cannot be read: %v", entry.Module, entry.Fp, err)
|
||||
} else if released {
|
||||
return meshbuilds.StepEndedOutcomePassed, "" // a released build counts as reserved (A-456a)
|
||||
}
|
||||
return meshbuilds.StepEndedOutcomeFailed, fmt.Sprintf("%s: built at %s, but no version is reserved for it; builder_reserve_done reserves one for the done build", entry.Module, entry.Fp)
|
||||
}
|
||||
return meshbuilds.StepEndedOutcomePassed, ""
|
||||
|
||||
@@ -82,18 +82,19 @@ func TestAStepAskIsWokenByItsBuildsEnd(t *testing.T) {
|
||||
// that reserves none (a manifest of before G, version "1") passes as it did.
|
||||
func TestABuildStepPassesAReservingBuildOnlyWithItsReservedVersion(t *testing.T) {
|
||||
for _, c := range []struct {
|
||||
name, version string
|
||||
reserve bool
|
||||
want, said string
|
||||
name, version string
|
||||
reserve, released bool
|
||||
want, said string
|
||||
}{
|
||||
{"no version reserved", "0.1", false, meshbuilds.StepEndedOutcomeFailed, "built at " + fp1 + ", but no version is reserved for it"},
|
||||
{"a version reserved", "0.1", true, meshbuilds.StepEndedOutcomePassed, ""},
|
||||
{"a series of before G", "1", false, meshbuilds.StepEndedOutcomePassed, ""},
|
||||
{"no version reserved", "0.1", false, false, meshbuilds.StepEndedOutcomeFailed, "built at " + fp1 + ", but no version is reserved for it"},
|
||||
{"a version reserved", "0.1", true, false, meshbuilds.StepEndedOutcomePassed, ""},
|
||||
{"a released build whose reservation is gone", "0.1", false, true, meshbuilds.StepEndedOutcomePassed, ""},
|
||||
{"a series of before G", "1", false, false, meshbuilds.StepEndedOutcomePassed, ""},
|
||||
} {
|
||||
t.Run(c.name, func(t *testing.T) {
|
||||
r := newRig(t, goBundle)
|
||||
r.mf.byDigest[mdigest('a')] = catalogue.Manifest{Module: "m", Version: c.version, Build: &catalogue.Build{Artifacts: []catalogue.Artifact{goBundle}}}
|
||||
res := &fakeReservations{filled: true}
|
||||
res := &fakeReservations{filled: true, released: map[string]bool{fp1: c.released}}
|
||||
if v := r.consider(t, "modules/m"); v.State != builds.BuildDone { // built while the builder reserved nothing, as the live key was
|
||||
t.Fatalf("build = %+v, want done", v)
|
||||
}
|
||||
|
||||
@@ -115,7 +115,10 @@ type Reserver struct {
|
||||
// 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
|
||||
// Releases is the builder's own record of the versions it saw released, by module and fingerprint (design 47 G A-456a): the
|
||||
// reservation is deleted at release, so a rerun of a released build's step reads it here, never from the catalog. Nil keeps none.
|
||||
Releases ReserveStore
|
||||
Now func() time.Time
|
||||
}
|
||||
|
||||
func (r *Reserver) now() time.Time {
|
||||
@@ -248,6 +251,20 @@ func allSet(m map[string]string) bool {
|
||||
return true
|
||||
}
|
||||
|
||||
// ReleasedKey is the key of the record that the build of fingerprint was released (design 47 G A-456a), in the state acted.
|
||||
func ReleasedKey(module, fingerprint string) string {
|
||||
return "released." + EscapeToken(module) + "." + EscapeToken(fingerprint)
|
||||
}
|
||||
|
||||
// ReleasedFor says whether the builder saw a version released for the build of fingerprint.
|
||||
func (r *Reserver) ReleasedFor(ctx context.Context, module, fingerprint string) (bool, error) {
|
||||
if r.Releases == nil {
|
||||
return false, nil
|
||||
}
|
||||
_, _, found, err := r.Releases.Get(ctx, ReleasedKey(module, fingerprint))
|
||||
return found, err
|
||||
}
|
||||
|
||||
// Released takes the catalog's version-released in: the key of that version is deleted, and every key of module's other
|
||||
// series (the manifest moved on). A key holding a newer reserved version of the same series stays. It answers the keys
|
||||
// deleted.
|
||||
@@ -269,6 +286,11 @@ func (r *Reserver) Released(ctx context.Context, module, version string) ([]stri
|
||||
if !found || (cur.Series == series && cur.Version != version) {
|
||||
continue
|
||||
}
|
||||
if cur.Version == version && cur.Fingerprint != "" && r.Releases != nil {
|
||||
if _, err := r.Releases.Create(ctx, ReleasedKey(module, cur.Fingerprint), []byte(`{"version":"`+version+`"}`)); err != nil && !errors.Is(err, ErrConflict) {
|
||||
return gone, fmt.Errorf("the release of %s %s cannot be recorded: %w", module, version, err)
|
||||
}
|
||||
}
|
||||
if err := r.Store.Delete(ctx, k); err != nil {
|
||||
return gone, fmt.Errorf("%s cannot be deleted: %w", k, err)
|
||||
}
|
||||
|
||||
@@ -173,3 +173,31 @@ func TestReservationIsReadAndMarkedPublished(t *testing.T) {
|
||||
t.Errorf("the bound key does not name the reservation back: %q %v", key, ok)
|
||||
}
|
||||
}
|
||||
|
||||
// TestAReleaseIsRecordedByFingerprintBeforeItsReservationGoes: design 47 G A-456a — the version-released of a version records
|
||||
// that the build of its fingerprint was released, so a rerun of its step finds it after the reservation is deleted.
|
||||
func TestAReleaseIsRecordedByFingerprintBeforeItsReservationGoes(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
rel := &reserveMem{mem: newMem()}
|
||||
r := &Reserver{Store: &reserveMem{mem: newMem()}, Releases: rel, Filled: func() bool { return true },
|
||||
ReleasedOf: func(context.Context, string) ([]string, error) { return nil, nil }}
|
||||
v, err := r.Reserve(ctx, "m", "0.1", []string{"m:a"}, Source{Fingerprint: "src2:aa"})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ok, _ := r.ReleasedFor(ctx, "m", "src2:aa"); ok {
|
||||
t.Fatal("a build not released is said released")
|
||||
}
|
||||
if _, err := r.Released(ctx, "m", v.Version); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ok, err := r.ReleasedFor(ctx, "m", "src2:aa"); !ok || err != nil {
|
||||
t.Errorf("released for the fingerprint: %v (%v), want true", ok, err)
|
||||
}
|
||||
if ok, _ := r.ReleasedFor(ctx, "m", "src2:bb"); ok {
|
||||
t.Error("another fingerprint is said released")
|
||||
}
|
||||
if all, _ := r.All(ctx); len(all) != 0 {
|
||||
t.Errorf("reservations left: %v", all)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user