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 de6cd2a2..adef3885 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go @@ -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. 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 05af9ef5..f6a9bd54 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve.go @@ -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) +} diff --git a/modules/mesh-delivery-builder/internal/build/numbers.go b/modules/mesh-delivery-builder/internal/build/numbers.go index c409187c..928d283c 100644 --- a/modules/mesh-delivery-builder/internal/build/numbers.go +++ b/modules/mesh-delivery-builder/internal/build/numbers.go @@ -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 diff --git a/modules/mesh-delivery-builder/internal/build/reserve_test.go b/modules/mesh-delivery-builder/internal/build/reserve_test.go index 81189adb..bc566a4f 100644 --- a/modules/mesh-delivery-builder/internal/build/reserve_test.go +++ b/modules/mesh-delivery-builder/internal/build/reserve_test.go @@ -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) { diff --git a/modules/mesh-delivery-builder/internal/build/step.go b/modules/mesh-delivery-builder/internal/build/step.go index df689857..093fe210 100644 --- a/modules/mesh-delivery-builder/internal/build/step.go +++ b/modules/mesh-delivery-builder/internal/build/step.go @@ -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, "" diff --git a/modules/mesh-delivery-builder/internal/build/step_test.go b/modules/mesh-delivery-builder/internal/build/step_test.go index 0be7cf09..36a93fec 100644 --- a/modules/mesh-delivery-builder/internal/build/step_test.go +++ b/modules/mesh-delivery-builder/internal/build/step_test.go @@ -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) } diff --git a/modules/mesh-delivery-builder/internal/versions/reserve.go b/modules/mesh-delivery-builder/internal/versions/reserve.go index f1cb1011..3eb292d0 100644 --- a/modules/mesh-delivery-builder/internal/versions/reserve.go +++ b/modules/mesh-delivery-builder/internal/versions/reserve.go @@ -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) } diff --git a/modules/mesh-delivery-builder/internal/versions/reserve_test.go b/modules/mesh-delivery-builder/internal/versions/reserve_test.go index 7c880271..43b5190f 100644 --- a/modules/mesh-delivery-builder/internal/versions/reserve_test.go +++ b/modules/mesh-delivery-builder/internal/versions/reserve_test.go @@ -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) + } +}