From c8cc249a90824705b8929ed1981e43b03f997e60 Mon Sep 17 00:00:00 2001 From: jochen Date: Sun, 22 Nov 2026 01:54:49 +0100 Subject: [PATCH] B7: a tag names its commit; the builder reads a module's tags before it reserves MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A number whose tag stood at another commit was reserved again, and a Go package outside mesh-sdk's go directory was tagged go/v, which the Go toolchain never reads. The builder now reads the Go package's tags once per catalog revision, skips a number tagged at another commit with the finding version-tagged-elsewhere (cleared at the next release), and tags /v, the directory read from the package's module path. Builds: design 47 H2 §796 --- .../cmd/mesh-delivery-builder/main.go | 1 + .../cmd/mesh-delivery-builder/reserve.go | 16 +++ .../cmd/mesh-delivery-builder/reserve_test.go | 34 ++++- .../cmd/mesh-delivery-builder/versions.go | 53 ++++--- .../internal/build/numbers.go | 4 +- .../internal/build/reserve_test.go | 7 +- .../internal/versions/reserve.go | 135 ++++++++++++++++-- .../internal/versions/reserve_test.go | 58 +++++++- .../internal/versions/tag.go | 31 +++- 9 files changed, 292 insertions(+), 47 deletions(-) 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 6bdc9ff44..f50b44e91 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/main.go @@ -254,6 +254,7 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro } // A package's number reserved is said as the seat mesh-builds' version-reserved, so the indexer re-pins at the reservation (§805). reserved.names = versions.NamesFrom(versions.EntriesOf(branches)) + reserved.r.Names = reserved.names // a Go package's module path names its tag's directory (§796) reserved.sayReserved = func(ctx context.Context, ev meshbuilds.VersionReservedEvent) error { return emitSeatEvent(context.WithoutCancel(ctx), js, cred, meshbuilds.SubjectVersionReserved, "version-reserved-"+ev.Module+"-"+ev.Version+"-"+ev.Artifact, ev) } 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 ce6998d04..358e0679c 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/reserve.go @@ -122,6 +122,8 @@ func newReservations(store versions.ReserveStore, call toolCaller, bounds func() return out, nil }} rv.r.Took, rv.r.Logf, rv.r.Reserved = rv.took, logf, rv.reservedSaid + // A module's tags are read before it reserves, and a number tagged at another commit skipped (design 47 H2 §796). + rv.r.Tags, rv.r.TaggedElsewhere = tagsVia(call), rv.taggedElsewhere return rv } @@ -321,6 +323,7 @@ func (rv *reservations) heard(ctx context.Context, m jetstream.Msg) bool { } rv.found.clear(ctx, versions.VersionUnreleased, meshconditionsclient.ScopeModule, ev.Module) rv.found.clear(ctx, versions.VersionHeldElsewhere, meshconditionsclient.ScopeModule, ev.Module) + rv.found.clear(ctx, versions.VersionTaggedElsewhere, meshconditionsclient.ScopeModule, ev.Module) default: return false } @@ -478,6 +481,19 @@ func (rv *reservations) heldElsewhere(ctx context.Context, module, why string) { needs: "builder_reserved shows the reservation and its withdrawn numbers; the registry seat's versions shows what it holds."}) } +// taggedElsewhere raises version-tagged-elsewhere about module (design 47 H2 §796): numbers whose git tag stands at another +// commit were skipped at reserving; a tag is never moved. Cleared at the module's next version-released. +func (rv *reservations) taggedElsewhere(ctx context.Context, module string, skipped []string) { + why := "the tags of " + strings.Join(skipped, ", ") + " stand at another commit, so the reserve skipped them" + rv.logf("%s: %s", module, why) + rv.found.raise(ctx, finding{kind: versions.VersionTaggedElsewhere, scope: meshconditionsclient.ScopeModule, id: module, + summary: module + ": " + why, + headline: "A number whose tag stands at another commit is not used", + explanation: "The repository holds a tag of " + module + " at a commit other than the build's: " + why + ". A tag is never moved.", + resolved: "The catalog says version-released for " + module + ".", + needs: "builder_reserved shows the reservation; the seat git's tags shows each tag with its commit."}) +} + // movedElsewhere takes a done build whose number a registry holds at another digest off that number (design 47 H H-A-275, // H-A-279): every artifact carries its version from its build, so no digest survives a move. The number is withdrawn as a gap // (H-A-226), the finding raised naming both digests, and the build of the same fingerprint asked again (the build-again path of a 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 d5ec99035..3573a7b5b 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 @@ -163,17 +163,27 @@ func TestAReleasedVersionIsTaggedAtTheCommitItWasBuiltFrom(t *testing.T) { ctx := context.Background() var tags []git.TagInput refuse := "" + var standing []git.Tag // the tags the seat git's tags answers (design 47 H2 §796) call := func(addr string, body any) (json.RawMessage, error) { - if addr != "seat:git.tag" { + switch addr { + case "seat:git.tags": + return json.Marshal(map[string]any{"form": 2, "tags": standing, "a-field-of-a-later-form": true}) + case "seat:git.tag": + default: return json.Marshal(meshcatalog.VersionsAnswer{}) } tags = append(tags, body.(git.TagInput)) return json.Marshal(git.TagAnswer{Performed: refuse == "", Error: refuse}) } - found := &findings{module: builds.BuilderModule, w: &memFindings{vals: map[string][]byte{}}, logf: t.Logf, now: func() time.Time { return time.Unix(0, 0) }} + fw := &memFindings{vals: map[string][]byte{}} + found := &findings{module: builds.BuilderModule, w: fw, logf: t.Logf, now: func() time.Time { return time.Unix(0, 0) }} rv := newReservations(&memReserve{vals: map[string][]byte{}, revs: map[string]uint64{}}, call, func() jetstream.KeyValue { return &boundsKV{keys: map[string]bool{}} }, found, nil, t.Logf) rv.filled.Store(true) - goPkg := versions.Source{Repository: "o/r", Commit: "c0ffee", GoPackage: true} + // Design 47 H2 §796: the tag names the Go module's directory, read from its module path: mesh-sdk's `go` here. + rv.r.Names = func(_ context.Context, module, artifact string) (string, bool, error) { + return "git.example/o/r/go", artifact == "lib" || artifact == "pkg", nil + } + goPkg := versions.Source{Repository: "o/r", Commit: "c0ffee", GoPackage: true, GoArtifact: "lib"} if _, err := rv.Reserve(ctx, "pkg", "0.1", []string{"pkg:lib"}, goPkg); err != nil { t.Fatal(err) } @@ -204,7 +214,7 @@ func TestAReleasedVersionIsTaggedAtTheCommitItWasBuiltFrom(t *testing.T) { if _, err := rv.Reserve(ctx, "pkg", "0.1", []string{"pkg:lib"}, goPkg); err != nil { // build A: 0.1.0 (the stub catalog holds none released) t.Fatal(err) } - if v, err := rv.Reserve(ctx, "pkg", "0.1", []string{"pkg:lib"}, versions.Source{Repository: "o/r", Commit: "b0b", GoPackage: true}); err != nil || v.Version != "0.1.1" { // build B supersedes A + if v, err := rv.Reserve(ctx, "pkg", "0.1", []string{"pkg:lib"}, versions.Source{Repository: "o/r", Commit: "b0b", GoPackage: true, GoArtifact: "lib"}); err != nil || v.Version != "0.1.1" { // build B supersedes A t.Fatalf("second build reserved %q (%v)", v.Version, err) } release("pkg", "0.1.0") // A's version is never released in fact; were it said, it is no reservation of the key @@ -214,6 +224,20 @@ func TestAReleasedVersionIsTaggedAtTheCommitItWasBuiltFrom(t *testing.T) { if release("pkg", "0.1.1"); len(tags) != 1 || tags[0].Commit != "b0b" { t.Fatalf("the newer build's version: tags %+v; want go/v0.1.1 at b0b", tags) } + // Design 47 H2 §796: a tag standing at another commit makes the next number and the finding version-tagged-elsewhere, which + // clears at the module's next version-released. + standing = []git.Tag{{Tag: "go/v0.2.0", Commit: "elsewhere"}, {Tag: "go/v0.2.1", Commit: "elsewhere"}} + if v, err := rv.Reserve(ctx, "pkg", "0.2", []string{"pkg:lib"}, goPkg); err != nil || v.Version != "0.2.2" || v.Tag != "go/v0.2.2" { + t.Fatalf("reserved %+v (%v) with 0.2.0 and 0.2.1 tagged elsewhere, want 0.2.2 tagged go/v0.2.2", v, err) + } + key := meshconditionsclient.Key(meshconditionsclient.ScopeModule, "pkg", versions.VersionTaggedElsewhere) + if got, err := decodeFinding(fw.vals[key]); err != nil || !strings.Contains(got.Summary, "0.2.0") || !strings.Contains(got.Summary, "0.2.1") { + t.Fatalf("the finding %s = %+v (%v), want it naming 0.2.0 and 0.2.1", key, got, err) + } + if release("pkg", "0.2.2"); fw.vals[key] != nil { + t.Errorf("version-released of pkg left %s standing", key) + } + standing = nil // Design 47 H2 §805, H-A-420 (2): a package's number newly reserved is said as version-reserved, its path the package's name // and its revision the indexer's `.`; a reservation kept as it stood, an artifact that is no package and a // reservation naming no catalog revision say none. @@ -222,7 +246,7 @@ func TestAReleasedVersionIsTaggedAtTheCommitItWasBuiltFrom(t *testing.T) { return "git.example/o/r/" + artifact, module == "lib2" && artifact == "pkg", nil } rv.sayReserved = func(_ context.Context, ev meshbuilds.VersionReservedEvent) error { said = append(said, ev); return nil } - at := versions.Source{Repository: "o/r", Commit: "c1", Fingerprint: "src2:l2", GoPackage: true, Branch: "main", CatalogRevision: 158} + at := versions.Source{Repository: "o/r", Commit: "c1", Fingerprint: "src2:l2", GoPackage: true, GoArtifact: "pkg", Branch: "main", CatalogRevision: 158} for range 2 { if _, err := rv.Reserve(ctx, "lib2", "0.3", []string{"lib2:pkg", "lib2:bin"}, at); err != nil { t.Fatal(err) diff --git a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/versions.go b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/versions.go index cf254da22..6fc60acf6 100644 --- a/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/versions.go +++ b/modules/mesh-delivery-builder/cmd/mesh-delivery-builder/versions.go @@ -145,33 +145,44 @@ func floorVia(call toolCaller, requirements func(context.Context, string) ([]str } return out, nil }, - Tags: func(_ context.Context, repository, prefix string) ([]string, error) { - // The seat git's verb tags, whichever module holds the seat (design 47 G §7, A-82), page by page. - var out []string - for page := int64(1); ; page++ { - raw, err := call("seat:"+gitseat.Seat+"."+gitseat.VerbTags, gitseat.TagsInput{Repository: repository, Prefix: prefix, Page: page}) - if err != nil { - return nil, err - } - var a gitseat.TagsAnswer - if err := json.Unmarshal(raw, &a); err != nil { - return nil, fmt.Errorf("the seat git's tags answered what is no list of tags: %w", err) - } - if a.Error != "" { - return nil, fmt.Errorf("the seat git's tags: %s", a.Error) - } - for _, t := range a.Tags { - out = append(out, t.Tag) - } - if !a.More { - return out, nil - } + Tags: func(ctx context.Context, repository, prefix string) ([]string, error) { + tags, _, err := tagsVia(call)(ctx, repository, prefix) + out := make([]string, 0, len(tags)) + for _, t := range tags { + out = append(out, t.Tag) } + return out, err }, Requirements: requirements, } } +// tagsVia reads a repository's tags starting with prefix, each with the commit it names, through the seat git's verb tags, +// whichever module holds the seat (design 47 G §7, A-82), page by page; its answer is read tolerantly, form 2 naming each tag's +// commit (design 47 H2 §796, §780). away says the read met a transport fault or the error kind away (§776). +func tagsVia(call toolCaller) func(ctx context.Context, repository, prefix string) ([]gitseat.Tag, bool, error) { + return func(_ context.Context, repository, prefix string) ([]gitseat.Tag, bool, error) { + var out []gitseat.Tag + for page := int64(1); ; page++ { + raw, err := call("seat:"+gitseat.Seat+"."+gitseat.VerbTags, gitseat.TagsInput{Repository: repository, Prefix: prefix, Page: page}) + if err != nil { + return nil, true, err + } + a, _, err := gitseat.DecodeTagsAnswer(raw) + if err != nil { + return nil, false, fmt.Errorf("the seat git's tags answered what is no list of tags: %w", err) + } + if a.Error != "" { + return nil, a.ErrorKind == gitseat.ErrorKindAway, fmt.Errorf("the seat git's tags: %s (%s)", a.Error, a.ErrorKind) + } + out = append(out, a.Tags...) + if !a.More { + return out, false, nil + } + } + } +} + // emitEvent says one of the builder's events, mesh.mod..event., with the SDK's envelope headers and id as // the bus's dedup id. func emitEvent(ctx context.Context, js jetstream.JetStream, cred process.Account, event, id string, body any) error { diff --git a/modules/mesh-delivery-builder/internal/build/numbers.go b/modules/mesh-delivery-builder/internal/build/numbers.go index 450cbcf51..c34e611bc 100644 --- a/modules/mesh-delivery-builder/internal/build/numbers.go +++ b/modules/mesh-delivery-builder/internal/build/numbers.go @@ -199,7 +199,9 @@ func (b *Builder) reserve(ctx context.Context, module string, m meshcatalog.Modu } src := versions.Source{Repository: m.Repository, Commit: m.Commit, Fingerprint: m.Fp2, Branch: o.Branch, Revision: o.Source, CatalogRevision: o.Revision, Rebuild: rebuild} for _, t := range plan.Tasks { - src.GoPackage = src.GoPackage || (t.Kind == catalogue.ArtifactPackage && t.Language == "go") + if t.Kind == catalogue.ArtifactPackage && t.Language == "go" && !src.GoPackage { + src.GoPackage, src.GoArtifact = true, t.Artifact // its module path names its tag's directory (design 47 H2 §796) + } } res, err := b.Reserved.Reserve(ctx, module, plan.Series, refs, src) if err != nil { diff --git a/modules/mesh-delivery-builder/internal/build/reserve_test.go b/modules/mesh-delivery-builder/internal/build/reserve_test.go index 871eede06..37d11baa0 100644 --- a/modules/mesh-delivery-builder/internal/build/reserve_test.go +++ b/modules/mesh-delivery-builder/internal/build/reserve_test.go @@ -249,7 +249,8 @@ func TestAModuleWhoseOnlyArtifactIsAGoPackageIsBuiltUnderItsReservedVersion(t *t t.Run(c.name, func(t *testing.T) { r := newRig(t, goPackage) r.mf.byDigest[mdigest('a')] = catalogue.Manifest{Module: "m", Version: c.series, Build: &catalogue.Build{Artifacts: []catalogue.Artifact{goPackage}}} - r.b.Reserved = &fakeReservations{filled: true} + res := &fakeReservations{filled: true} + r.b.Reserved = res r.bm.packages["go-overlay"] = "git.novox.be/novox/mesh-networking/go@v0.1.5" // the Go build module's published reference var asked []buildstep.StepAsk r.asks.Answer = func(a buildstep.StepAsk) buildstep.Step { @@ -264,6 +265,10 @@ func TestAModuleWhoseOnlyArtifactIsAGoPackageIsBuiltUnderItsReservedVersion(t *t len(asked[0].Build.Artifacts) != 1 || asked[0].Build.Artifacts[0] != (buildstep.AskArtifact{Artifact: "go-overlay", Seat: c.seat}) { t.Fatalf("asks %+v, want one Go ask with version %q naming go-overlay on seat %q", asked, c.version, c.seat) } + // Design 47 H2 §796: the reservation names the Go package's artifact, whose module path names its tag's directory. + if c.version != "" && (len(res.sources) != 1 || !res.sources[0].GoPackage || res.sources[0].GoArtifact != "go-overlay") { + t.Errorf("reserved from %+v, want one source naming the Go package go-overlay", res.sources) + } }) } } diff --git a/modules/mesh-delivery-builder/internal/versions/reserve.go b/modules/mesh-delivery-builder/internal/versions/reserve.go index cbeab150b..b76a1534c 100644 --- a/modules/mesh-delivery-builder/internal/versions/reserve.go +++ b/modules/mesh-delivery-builder/internal/versions/reserve.go @@ -10,8 +10,10 @@ import ( "sort" "strconv" "strings" + "sync" "time" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git" "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" ) @@ -40,6 +42,9 @@ const ( // VersionHeldElsewhere is the finding of a number a registry seat already holds, skipped at reserving or moved from (design 47 // H H-A-275), scope module. VersionHeldElsewhere = "version-held-elsewhere" + // VersionTaggedElsewhere is the finding of a number whose git tag stands at another commit, skipped at reserving (design 47 + // H2 §796), scope module; cleared at the module's next version-released. + VersionTaggedElsewhere = "version-tagged-elsewhere" ) // ReservedVersion is the value of a reservation key. @@ -59,7 +64,7 @@ type ReservedVersion struct { PublishedAt map[string]time.Time `json:"published-at,omitempty"` At time.Time `json:"at"` // Repository and Commit are what the build was made from, and Tag the git tag its release is written as (a Go - // package's, GoTagOf): empty for a module with no Go package (design 47 G §370). + // package's, GoTagOf): empty for a module with no Go package (design 47 G §370), or whose Go package's directory is not known. Repository string `json:"repository,omitempty"` Commit string `json:"commit,omitempty"` Tag string `json:"tag,omitempty"` @@ -112,6 +117,9 @@ type Source struct { // Fingerprint is the fingerprint of the catalog entry the build is made from (design 47 G A-76). Fingerprint string GoPackage bool + // GoArtifact is the artifact that is the module's Go package, whose module path names the directory its tag is written in + // (design 47 H2 §796). + GoArtifact string // Branch is the watched branch of the catalog revision whose entry the build came from, and Revision the source revision of // that catalog revision (design 47 G §371, A-57), kept on the reservation for the publication. Branch string @@ -163,6 +171,92 @@ type Reserver struct { HeldNumbers func(ctx context.Context, module, fingerprint string, refs []string) ([]string, error) // HeldElsewhere is told the numbers of module a reserve skipped because a registry holds them (H-A-275); nil is told none. HeldElsewhere func(ctx context.Context, module string, skipped []string) + // Names answers a Go package's module path, which names the directory its tag is written in (design 47 H2 §796); nil, or a + // name not known, tags the version nowhere, said. + Names PackageNames + // Tags reads repository's tags starting with prefix, each with the commit it names, through the seat git's tags (design 47 + // H2 §796); away says the read met a transport fault or the error kind away, which lets the reservation go on, said. Nil + // reads none. + Tags func(ctx context.Context, repository, prefix string) (tags []git.Tag, away bool, err error) + // TaggedElsewhere is told the numbers of module a reserve skipped because their tag stands at another commit (§796); nil + // is told none. + TaggedElsewhere func(ctx context.Context, module string, skipped []string) + + tagsMu sync.Mutex + // tagsRead are the tags last read of each module, by series patch to the commit, with the catalog revision they were read + // under: a module's tags are read once per catalog revision it reserves under (§796). + tagsRead map[string]tagsAt +} + +// tagsAt are a module's tags of one series read under one catalog revision: patch to the commit its tag names. +type tagsAt struct { + revision, prefix string + commits map[int]string +} + +// goDirectory is the directory of module's Go package in its repository (§796), from its module path; ok is false, said, when +// no name or no directory of the repository is known. +func (r *Reserver) goDirectory(ctx context.Context, module string, src Source) (string, bool) { + if r.Names == nil { + return "", false + } + path, known, err := r.Names(ctx, module, src.GoArtifact) + switch { + case err != nil: + r.said(fmt.Errorf("%s: its Go package's name cannot be read, so its version is tagged nowhere: %w", module, err)) + return "", false + case !known: + r.said(fmt.Errorf("%s: no name of its Go package %s is known yet, so its version is tagged nowhere", module, src.GoArtifact)) + return "", false + } + dir, ok := GoDirectory(path, src.Repository) + if !ok { + r.said(fmt.Errorf("%s: its Go package %s is not a module path of the repository %s, so its version is tagged nowhere", module, path, src.Repository)) + } + return dir, ok +} + +// taggedAt are the patches of series whose tag `/v.` stands, each with its commit, read once per +// catalog revision the module reserves under (§796). A read that meets a transport fault or away answers none, said, and the +// reservation goes on; any other failure refuses the reservation, naming it. +func (r *Reserver) taggedAt(ctx context.Context, module, series, dir string, src Source) (map[int]string, error) { + if r.Tags == nil { + return nil, nil + } + prefix := TagPrefix(dir) + series + "." + revision := "" + if src.CatalogRevision > 0 { + revision = fmt.Sprintf("%s.%d", src.Branch, src.CatalogRevision) + r.tagsMu.Lock() + got, ok := r.tagsRead[module] + r.tagsMu.Unlock() + if ok && got.revision == revision && got.prefix == prefix { + return got.commits, nil + } + } + tags, away, err := r.Tags(ctx, src.Repository, prefix) + if err != nil && away { + r.said(fmt.Errorf("%s: its tags %s* cannot be read (%w), so the reservation goes on without them", module, prefix, err)) + return nil, nil + } + if err != nil { + return nil, fmt.Errorf("the tags %s* of %s cannot be read: %w", prefix, module, err) + } + commits := map[int]string{} + for _, t := range tags { + if s, p, err := SplitVersion(strings.TrimPrefix(t.Tag, TagPrefix(dir))); err == nil && s == series && strings.HasPrefix(t.Tag, prefix) { + commits[p] = t.Commit + } + } + if revision != "" { + r.tagsMu.Lock() + if r.tagsRead == nil { + r.tagsRead = map[string]tagsAt{} + } + r.tagsRead[module] = tagsAt{revision: revision, prefix: prefix, commits: commits} + r.tagsMu.Unlock() + } + return commits, nil } // heldNumbers are the patches of series a registry holds of module's artifacts (H-A-275); a read that fails is said, and none. @@ -183,15 +277,20 @@ func (r *Reserver) heldNumbers(ctx context.Context, module, series, fingerprint return out } -// nextFree is the first patch after after that no registry holds, and the held numbers it skipped (H-A-275). -func nextFree(series string, after int, held map[int]bool) (int, []string) { - var skipped []string - p := after + 1 - for held[p] { - skipped = append(skipped, fmt.Sprintf("%s.%d", series, p)) - p++ +// nextFree is the first patch after after that no registry holds and whose tag stands at no other commit than commit, with the +// held numbers it skipped (H-A-275) and those tagged elsewhere (design 47 H2 §796). +func nextFree(series string, after int, held map[int]bool, tagged map[int]string, commit string) (int, []string, []string) { + var skipped, elsewhere []string + for p := after + 1; ; p++ { + switch c, ok := tagged[p]; { + case held[p]: + skipped = append(skipped, fmt.Sprintf("%s.%d", series, p)) + case ok && c != commit: + elsewhere = append(elsewhere, fmt.Sprintf("%s.%d (tagged at %s)", series, p, c)) + default: + return p, skipped, elsewhere + } } - return p, skipped } // said is told the outcome of a reindex: a failure is said, the reservation's own write stands. @@ -243,6 +342,15 @@ func (r *Reserver) Reserve(ctx context.Context, module, series string, artifacts } key := ReservedKey(module, series) held := r.heldNumbers(ctx, module, series, src.Fingerprint, artifacts) + dir, tagged := "", false + var tags map[int]string + if src.GoPackage { + if dir, tagged = r.goDirectory(ctx, module, src); tagged { + if tags, err = r.taggedAt(ctx, module, series, dir, src); err != nil { + return ReservedVersion{}, err + } + } + } for { cur, rev, found, err := r.get(ctx, key) if err != nil { @@ -260,11 +368,11 @@ func (r *Reserver) Reserve(ctx context.Context, module, series string, artifacts next = p } } - patch, skipped := nextFree(series, next, held) + patch, skipped, elsewhere := nextFree(series, next, held, tags, src.Commit) out := ReservedVersion{V: 1, Module: module, Series: series, Version: fmt.Sprintf("%s.%d", series, patch), Artifacts: map[string]string{}, At: r.now(), Repository: src.Repository, Commit: src.Commit, Fingerprint: src.Fingerprint, Branch: src.Branch, Source: src.Revision, Revision: src.CatalogRevision} - if src.GoPackage { - out.Tag = GoTagOf(out.Version) + if tagged { + out.Tag = GoTagOf(dir, out.Version) } for _, a := range artifacts { out.Artifacts[a] = "" @@ -302,6 +410,9 @@ func (r *Reserver) Reserve(ctx context.Context, module, series string, artifacts if len(skipped) > 0 && r.HeldElsewhere != nil { r.HeldElsewhere(ctx, module, skipped) } + if len(elsewhere) > 0 && r.TaggedElsewhere != nil { + r.TaggedElsewhere(ctx, module, elsewhere) + } if found && r.Took != nil { r.Took(ctx, cur, out) } diff --git a/modules/mesh-delivery-builder/internal/versions/reserve_test.go b/modules/mesh-delivery-builder/internal/versions/reserve_test.go index 327ad2aa7..3fadf9cd4 100644 --- a/modules/mesh-delivery-builder/internal/versions/reserve_test.go +++ b/modules/mesh-delivery-builder/internal/versions/reserve_test.go @@ -1,14 +1,16 @@ package versions import ( - "encoding/json" - "context" + "encoding/json" "errors" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshbuilds" "reflect" + "strings" "testing" "time" + + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshbuilds" ) type reserveMem struct { @@ -412,8 +414,8 @@ func TestANumberARegistryHoldsIsNeverReserved(t *testing.T) { held = []string{"0.1.37", "0.1.38", "0.1.39", "0.1.40", "0.2.0"} // The build again of a done key reserves as a rebuild (A-490b): a withdrawn number is never its floor's to reuse. again, err := r.Reserve(ctx, "node-tools", "0.1", []string{"node-tools:program"}, Source{Fingerprint: "fp1", GoPackage: true, Rebuild: true}) - if err != nil || again.Version != "0.1.41" || again.Artifacts["node-tools:program"] != "" || again.Withdrawn["0.1.39"] != "fp1" || again.Tag != GoTagOf("0.1.41") { - t.Fatalf("the build again reserved %+v (%v), want 0.1.41 with no digest and 0.1.39 kept withdrawn", again, err) + if err != nil || again.Version != "0.1.41" || again.Artifacts["node-tools:program"] != "" || again.Withdrawn["0.1.39"] != "fp1" || again.Tag != "" { + t.Fatalf("the build again reserved %+v (%v), want 0.1.41 with no digest, 0.1.39 kept withdrawn, and no tag (no Go package name known)", again, err) } if at, _ := r.AtVersion(ctx, "0.1.39"); len(at) != 0 { t.Errorf("the index by version still names the withdrawn number: %v", at) @@ -426,4 +428,50 @@ func TestANumberARegistryHoldsIsNeverReserved(t *testing.T) { if v, err := r.Reserve(ctx, "node-tools", "0.2", []string{"node-tools:program"}, Source{Fingerprint: "fp1"}); err != nil || v.Version != "0.2.1" { t.Errorf("with the registry down reserved %q (%v), want 0.2.1 (what it answered still skipped)", v.Version, err) } + // Design 47 H2 §796: a Go package's tags are read before it reserves, once per catalog revision; a number whose tag + // `/v` stands at another commit is skipped and said, one at the build's own commit is not; the version's + // tag names the Go module's directory; a read met away lets the reservation go on, any other failure refuses it. + r.HeldNumbers = nil + var tagReads int + var tagsErr error + var tagsAway bool + var elsewhere []string + tags := []git.Tag{{Tag: "modules/nt/v0.3.0", Commit: "c-other"}, {Tag: "modules/nt/v0.3.1", Commit: "c-mine"}, {Tag: "modules/nt/v0.3.2", Commit: "c-other2"}} + r.Names = func(_ context.Context, module, artifact string) (string, bool, error) { + return "git.example/o/r/modules/nt", module == "node-tools" && artifact == "lib", nil + } + r.Tags = func(_ context.Context, repository, prefix string) ([]git.Tag, bool, error) { + tagReads++ + if repository != "o/r" || prefix != "modules/nt/v0.3." { + t.Errorf("tags read of %s %q, want o/r modules/nt/v0.3.", repository, prefix) + } + return tags, tagsAway, tagsErr + } + r.TaggedElsewhere = func(_ context.Context, _ string, s []string) { elsewhere = append(elsewhere, s...) } + at := Source{Fingerprint: "fp3", GoPackage: true, GoArtifact: "lib", Repository: "o/r", Commit: "c-mine", Branch: "main", CatalogRevision: 7} + v3, err := r.Reserve(ctx, "node-tools", "0.3", []string{"node-tools:lib"}, at) + if err != nil || v3.Version != "0.3.1" || v3.Tag != "modules/nt/v0.3.1" || len(elsewhere) != 1 || !strings.Contains(elsewhere[0], "0.3.0") { + t.Fatalf("reserved %+v (%v), tagged elsewhere %v: want 0.3.1 (0.3.0 tagged at another commit, 0.3.1 at the build's own), tag modules/nt/v0.3.1", v3, err, elsewhere) + } + at.Fingerprint, at.Commit, elsewhere = "fp4", "c-new", nil + if v4, err := r.Reserve(ctx, "node-tools", "0.3", []string{"node-tools:lib"}, at); err != nil || v4.Version != "0.3.3" || tagReads != 1 || len(elsewhere) != 1 || !strings.Contains(elsewhere[0], "0.3.2") { + t.Fatalf("reserved %+v (%v) after %d reads, tagged elsewhere %v: want 0.3.3 past 0.3.2's tag, the tags read once for revision main.7", v4, err, tagReads, elsewhere) + } + at.CatalogRevision, at.Fingerprint, tagsErr, tagsAway = 8, "fp5", errors.New("the forge is away"), true + if v5, err := r.Reserve(ctx, "node-tools", "0.3", []string{"node-tools:lib"}, at); err != nil || v5.Version != "0.3.4" || tagReads != 2 { + t.Fatalf("with the tags away reserved %+v (%v) after %d reads, want 0.3.4 and the reservation going on", v5, err, tagReads) + } + at.CatalogRevision, at.Fingerprint, tagsAway = 9, "fp6", false + if _, err := r.Reserve(ctx, "node-tools", "0.3", []string{"node-tools:lib"}, at); err == nil || !strings.Contains(err.Error(), "tags") { + t.Errorf("a tags read refused not away reserved anyway (%v), want the reservation refused naming the tags", err) + } + if d, ok := GoDirectory("git.example/novox/mesh-sdk/go", "https://git.example/novox/mesh-sdk.git"); !ok || d != "go" || GoTagOf(d, "0.1.9") != "go/v0.1.9" { + t.Errorf("mesh-sdk's Go package: directory %q (%v), want go and the tag go/v0.1.9", d, ok) + } + if d, ok := GoDirectory("git.example/o/r", "o/r"); !ok || d != "" || GoTagOf(d, "1.0.0") != "v1.0.0" { + t.Errorf("a root Go module: directory %q (%v), want the root and the tag v1.0.0", d, ok) + } + if _, ok := GoDirectory("git.example/o/rr/x", "o/r"); ok { + t.Error("a module path of another repository was given a directory") + } } diff --git a/modules/mesh-delivery-builder/internal/versions/tag.go b/modules/mesh-delivery-builder/internal/versions/tag.go index e83bff9ef..dcb070c26 100644 --- a/modules/mesh-delivery-builder/internal/versions/tag.go +++ b/modules/mesh-delivery-builder/internal/versions/tag.go @@ -1,4 +1,31 @@ package versions -// GoTagOf is the git tag a Go package's released version is written as (design 47 G §370, design 51 *The versions*). -func GoTagOf(version string) string { return "go/v" + version } +import ( + "strings" + + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/trunk" +) + +// GoTagOf is the git tag a Go package's released version is written as (design 47 H2 §796): `/v`, the +// directory of its Go module in the repository, which the Go toolchain's direct fallback reads; `v` at the root. The +// `go/v` tags go from new versions. +func GoTagOf(directory, version string) string { return TagPrefix(directory) + version } + +// GoDirectory is the directory of the Go module path modulePath in repository (`/`, or a clone address naming +// it): the part of the path after the repository's own, as the Go toolchain reads a module kept in a subdirectory; empty at +// the root. ok is false when the path is not one of that repository. +func GoDirectory(modulePath, repository string) (string, bool) { + repo := "/" + strings.ToLower(trunk.RepositoryName(repository)) + lower := strings.ToLower(modulePath) + for from := 0; ; { + i := strings.Index(lower[from:], repo) + if i < 0 || repo == "/" { + return "", false + } + end := from + i + len(repo) + if end == len(lower) || lower[end] == '/' { + return strings.Trim(modulePath[end:], "/"), true + } + from = end + } +}