package build import ( "context" "fmt" "maps" "slices" "time" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" "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" ) // **A build waits for its revision; a build with no version is never made** (design 47 H H-A-155, H-A-156; H-A-141): a step // ask names its branch and source revision, and the builder reserves the version before it builds. When the builder's picture // of that branch does not hold that source revision yet, or holds it but has not taken in the entry of the asked fingerprint // from it, the ask waits for the picture to take it in, woken by each entry the picture takes in (take, EntryGone) and each // revision its view holds (PictureHeld, H-A-162), never a // timer or a poll, up to RevisionWait (the setting revision-wait-minutes); past it the ask fails, naming the revision and the // branch, and nothing is built. A step ask with no source (a run on request) does not wait. // DefaultRevisionWait is the bound of a step ask's wait for its revision, its setting revision-wait-minutes' default (H-A-156). const DefaultRevisionWait = 2 * time.Minute func (b *Builder) revisionWait() time.Duration { if b.RevisionWait > 0 { return b.RevisionWait } return DefaultRevisionWait } // PictureHeld is told each revision a branch's view takes in whole, whether or not an entry changed (H-A-162): every step // ask waiting for its revision looks again. func (b *Builder) PictureHeld() { b.init() b.pictureMoved() } // pictureMoved wakes every step ask waiting for the picture: an entry was taken in or went, or a revision was held. func (b *Builder) pictureMoved() { b.mu.Lock() moved := b.moved b.moved = make(chan struct{}) b.mu.Unlock() close(moved) } // holdsRevision says whether the builder's picture of branch holds the source revision and has taken in every entry of the // ask from that branch. func (b *Builder) holdsRevision(branch string, source int64, entries []meshbuilds.BuildEntry) bool { held, ok := b.Picture(branch) if !ok || held < source { return false } b.mu.Lock() defer b.mu.Unlock() for _, e := range entries { key, err := builds.BuilderBuildKey(e.Module, e.Fingerprint) if err != nil { return true // the build key is refused where the entry is built, with why } if b.origin[key].Branch != branch && b.heard[branch+"\x00"+e.Module].Fp2 != e.Fingerprint { return false } } return true } // awaitRevision returns no outcome once the builder's picture of the ask's branch holds its source revision; past the bound the // step's outcome failed, at the builder's stop could not run, each with its words. func (b *Builder) awaitRevision(ctx context.Context, run meshbuilds.StepRun) (outcome, said string) { if b.Picture == nil || run.Source <= 0 || run.Branch == "" { return "", "" } bound := b.revisionWait() notHeld := fmt.Sprintf("revision %d of %s not in the builder's picture", run.Source, run.Branch) wait, stop := context.WithTimeout(ctx, bound) // a context's bound, no timer (ADR 0437 §8) defer stop() told := false for { b.mu.Lock() moved := b.moved b.mu.Unlock() if b.holdsRevision(run.Branch, run.Source, run.Entries) { if told { b.logf("%s: revision %d of %s is in the builder's picture: the build goes on", run.Pipeline, run.Source, run.Branch) } return "", "" } if !told { b.logf("%s: %s yet: the ask waits for it, at most %s", run.Pipeline, notHeld, bound) told = true } select { case <-moved: case <-wait.Done(): if ctx.Err() != nil { return meshbuilds.StepEndedOutcomeCouldNotRun, notHeld + ": the builder stopped before it was" } b.logf("%s: %s within %s: the step fails, nothing is built", run.Pipeline, notHeld, bound) return meshbuilds.StepEndedOutcomeFailed, fmt.Sprintf("%s within %s", notHeld, bound) } } } // **A package with no pin waits for its release** (design 47 H H-A-165, H-A-161): an entry keeps a mesh package none of // whose versions is released with an empty version. Its step ask waits, as for its revision, for the release of the module // that holds the package (the catalog's version-released, VersionReleased), up to PackageWait (the setting // package-wait-minutes), then builds with that release as the package's pin (v); past the bound the step fails, // naming the package, and nothing is built. // DefaultPackageWait is the bound of a step ask's wait for a package's release, its setting package-wait-minutes' default. const DefaultPackageWait = 10 * time.Minute func (b *Builder) packageWait() time.Duration { if b.PackageWait > 0 { return b.PackageWait } return DefaultPackageWait } // VersionReleased takes the catalog's version-released of module in: a step ask waiting for a package of it wakes. func (b *Builder) VersionReleased(module, version string) { b.init() b.mu.Lock() b.releases[module] = version b.mu.Unlock() b.pictureMoved() } // releaseOf is the pin a package is built against: the release of the module holding it, as Go names it; "" for none yet. func (b *Builder) releaseOf(ctx context.Context, pkg string) string { if b.Members == nil { return "" } module, _, found, err := b.Members(ctx, pkg) if err != nil || !found { return "" } b.mu.Lock() v := b.releases[module] b.mu.Unlock() if v == "" && b.NewestReleased != nil { if kept, ok, err := b.NewestReleased(ctx, module); err == nil && ok { v = kept } } if v == "" { return "" } return "v" + v } // awaitPins fills each package entry names with no pin from its release, waiting for one; no outcome once every package has // a pin, failed past the bound, could not run at the builder's stop. func (b *Builder) awaitPins(ctx context.Context, entry *meshcatalog.CatalogEntry) (outcome, said string) { var unpinned []string for p, v := range entry.Packages { if v == "" { unpinned = append(unpinned, p) } } if len(unpinned) == 0 { return "", "" } slices.Sort(unpinned) bound := b.packageWait() wait, stop := context.WithTimeout(ctx, bound) // a context's bound, no timer (ADR 0437 §8) defer stop() pins := map[string]string{} told := false for { b.mu.Lock() moved := b.moved b.mu.Unlock() missing := "" for _, p := range unpinned { if pins[p] == "" { pins[p] = b.releaseOf(ctx, p) } if pins[p] == "" && missing == "" { missing = p } } if missing == "" { packages := maps.Clone(entry.Packages) maps.Copy(packages, pins) entry.Packages = packages if told { b.logf("%s at %s: every package it names has a released version: built with %v", entry.Module, entry.Fp, pins) } return "", "" } notReleased := fmt.Sprintf("package %s has no released version", missing) if !told { b.logf("%s at %s: %s yet: the ask waits for its release, at most %s", entry.Module, entry.Fp, notReleased, bound) told = true } select { case <-moved: case <-wait.Done(): if ctx.Err() != nil { return meshbuilds.StepEndedOutcomeCouldNotRun, notReleased + ": the builder stopped before it was" } b.logf("%s at %s: %s within %s: the step fails, nothing is built", entry.Module, entry.Fp, notReleased, bound) return meshbuilds.StepEndedOutcomeFailed, fmt.Sprintf("%s within %s", notReleased, bound) } } }