package build import ( "context" "fmt" "strings" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-builder/builds" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient" "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 candidate's build is the runner's step ask** (design 47 G A-97, A-84, A-99): the runner's asking half asks the seat // mesh-builds a `build` step naming each entry by fingerprint, and the builder, its one entry point for a candidate, reads each // entry through the seat mesh-catalog's `entry` (the repository and the commit are the member's head), builds it as it builds any // fingerprint (the existing claim, plan and lanes) and answers the step's end. A build is per fingerprint, so no pull request // number is needed, and the builder follows no candidate. // BuildStep builds the entries of one step ask and answers its end: passed when every entry's build is done, failed when one // failed (said), could not run when an entry could not be read, nothing to run for an ask naming none. The ask's id and the node // are the caller's to set. func (b *Builder) BuildStep(ctx context.Context, run meshbuilds.StepRun) meshbuilds.StepEnded { b.init() started := b.now() end := meshbuilds.StepEnded{V: 1, Pipeline: run.Pipeline, Step: meshbuilds.StepEndedStepBuild, Rerun: run.Rerun, By: run.By, Entries: run.Entries, Node: b.Node, Started: &started} finish := func(outcome, said string) meshbuilds.StepEnded { at := b.now() end.Ended, end.Outcome, end.Said = &at, outcome, said return end } if len(run.Entries) == 0 { return finish(meshbuilds.StepEndedOutcomeNothingToRun, "the ask names no entry") } if b.StepEntry == nil { return finish(meshbuilds.StepEndedOutcomeCouldNotRun, "the builder reads no entry of the seat mesh-catalog") } // The version is reserved before the build (H-A-155): the ask waits for the builder's picture to hold its revision. if outcome, said := b.awaitRevision(ctx, run); outcome != "" { return finish(outcome, said) } b.askedRevision(run) var failed []string for _, e := range run.Entries { var pins map[string]string outcome, said := b.buildEntry(ctx, e, &pins) // The end reports the pins each entry was built with, so the runner asks its held test steps with them (H-A-207). for path, version := range pins { if version == "" { continue } if end.Packages == nil { end.Packages = map[string]string{} } end.Packages[path] = version } switch outcome { case meshbuilds.StepEndedOutcomeCouldNotRun: return finish(outcome, said) case meshbuilds.StepEndedOutcomeFailed: failed = append(failed, said) } } if len(failed) > 0 { return finish(meshbuilds.StepEndedOutcomeFailed, strings.Join(failed, "; ")) } return finish(meshbuilds.StepEndedOutcomePassed, "") } // askedRevision records on the origin of each entry of run the catalog revision the ask names (design 47 H H-A-218), where // the origin is of the ask's branch and source revision: the version reserved for its build names it, and so does its // package-published, so the runner finds the publishing pipeline by branch and revision. func (b *Builder) askedRevision(run meshbuilds.StepRun) { if run.Revision <= 0 { return } b.mu.Lock() defer b.mu.Unlock() for _, e := range run.Entries { key, err := builds.BuilderBuildKey(e.Module, e.Fingerprint) if err != nil { continue } if o, ok := b.origin[key]; ok && o.Branch == run.Branch && o.Source == run.Source { o.Revision = run.Revision b.origin[key] = o } } } // buildEntry builds one entry at its fingerprint and waits for its end; pins is set, when it is done, to the pins its // done key keeps it was built with, the registry's included (H-A-207). func (b *Builder) buildEntry(ctx context.Context, e meshbuilds.BuildEntry, pins *map[string]string) (outcome, said string) { entry, err := b.StepEntry(ctx, e.Fingerprint) if err != nil { return meshbuilds.StepEndedOutcomeCouldNotRun, fmt.Sprintf("the entry %s at %s cannot be read: %v", e.Module, e.Fingerprint, err) } if entry.Module != e.Module || (e.Commit != "" && entry.Commit != e.Commit) { return meshbuilds.StepEndedOutcomeCouldNotRun, fmt.Sprintf("the entry of %s at %s is of %s at %s", e.Module, e.Fingerprint, entry.Module, entry.Commit) } // A package the entry names with no pin is built against its publish, waited for (H-A-192, H-A-165). pinned, outcome, said := b.awaitPublished(ctx, entry.Module, entry.Fp, meshcatalogclient.BareManifestDigest(entry.ManifestDigest), entry.Packages) if outcome != "" { return outcome, said } entry.Packages = pinned key, err := builds.BuilderBuildKey(entry.Module, entry.Fp) if err != nil { return meshbuilds.StepEndedOutcomeCouldNotRun, err.Error() } ended := b.awaitEnd(key) defer b.dropEnd(key, ended) if done, failedWords, found := b.keyEnd(ctx, key); found { if done { // A key done before reports the pins it was built with, kept with it, never the ones a publish gives now. *pins = b.keptPins(ctx, key) return b.passedWithItsVersion(ctx, entry) } return meshbuilds.StepEndedOutcomeFailed, failedWords } m := meshcatalog.ModulesByModuleValue{Repository: entry.Repository, Commit: entry.Commit, Fp2: entry.Fp, Manifest: meshcatalogclient.BareManifestDigest(entry.ManifestDigest), Path: entry.Path, Toolchains: CatalogToolchains(b.agreedFor(ctx, meshcatalogclient.BareManifestDigest(entry.ManifestDigest))), Packages: entry.Packages} b.consider(ctx, entry.Module, m) select { case log := <-ended: if log.Outcome == builds.BuildDone { *pins = b.keptPins(ctx, key) return b.passedWithItsVersion(ctx, entry) } return meshbuilds.StepEndedOutcomeFailed, fmt.Sprintf("%s at %s: %s %s", log.Module, log.FP, log.Outcome, log.Error) case <-ctx.Done(): return meshbuilds.StepEndedOutcomeCouldNotRun, fmt.Sprintf("%s at %s: the builder stopped before its build ended", entry.Module, entry.Fp) } } // passedWithItsVersion is the verdict of a build that ended done (design 47 G A-456): a build that reserves a version (a build // of the first watched branch's trunk, with a MAJOR.MINOR series and artifacts) passes only when a version is reserved for its // fingerprint; one that ended done with none fails loudly, naming builder_reserve_done, so no pipeline says passed for a build // that can never be released. A build that reserves none (a candidate's, a series of before G) passes as it did. func (b *Builder) passedWithItsVersion(ctx context.Context, entry meshcatalog.CatalogEntry) (outcome, said string) { if b.Reserved == nil { return meshbuilds.StepEndedOutcomePassed, "" } key, err := builds.BuilderBuildKey(entry.Module, entry.Fp) if err != nil { return meshbuilds.StepEndedOutcomeCouldNotRun, err.Error() } b.mu.Lock() reserving := b.trunkFP[key] && b.origin[key].First b.mu.Unlock() if !reserving { return meshbuilds.StepEndedOutcomePassed, "" } plan, planErr, _ := b.planOf(ctx, meshcatalogclient.BareManifestDigest(entry.ManifestDigest)) switch { case planErr != nil: return meshbuilds.StepEndedOutcomeCouldNotRun, fmt.Sprintf("%s at %s: the plan cannot be read to judge its version: %v", entry.Module, entry.Fp, planErr) case len(plan.Tasks) == 0 || strings.Count(plan.Series, ".") != 1: return meshbuilds.StepEndedOutcomePassed, "" } _, held, err := b.Reserved.ReservedFor(ctx, entry.Module, entry.Fp) switch { 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, "" } // keptPins are the pins a done key keeps it was built with (H-A-207); none when it keeps none or cannot be read, so the // runner ends the steps that waited for them could not run, loud. func (b *Builder) keptPins(ctx context.Context, key string) map[string]string { raw, _, ok, err := b.Claimer.Store.Get(ctx, key) if err != nil || !ok { return nil } v, err := builds.DecodeBuilderBuild(raw) if err != nil || v.State != builds.BuildDone { return nil } return v.Packages } // keyEnd reads the build key: whether it is done, and its error when it failed for good; found only for a key that has ended. func (b *Builder) keyEnd(ctx context.Context, key string) (done bool, failed string, found bool) { raw, _, ok, err := b.Claimer.Store.Get(ctx, key) if err != nil || !ok { return false, "", false } v, err := builds.DecodeBuilderBuild(raw) if err != nil { return false, "", false } switch { case v.State == builds.BuildDone && !Unpublished(v, b.Seats): return true, "", true case v.State == builds.BuildFailed && builds.FailedUntilChanged(v.Error): return false, key + ": " + v.Error, true } return false, "", false } // awaitEnd registers a wait for the end of the build of key, heard at its log entry (logBuild). func (b *Builder) awaitEnd(key string) chan builds.BuildLogEntry { ch := make(chan builds.BuildLogEntry, 1) b.mu.Lock() if b.stepWaits == nil { b.stepWaits = map[string][]chan builds.BuildLogEntry{} } b.stepWaits[key] = append(b.stepWaits[key], ch) b.mu.Unlock() return ch } func (b *Builder) dropEnd(key string, ch chan builds.BuildLogEntry) { b.mu.Lock() defer b.mu.Unlock() for i, c := range b.stepWaits[key] { if c == ch { b.stepWaits[key] = append(b.stepWaits[key][:i], b.stepWaits[key][i+1:]...) break } } if len(b.stepWaits[key]) == 0 { delete(b.stepWaits, key) } } // stepEnded tells the step asks waiting for a build that its end was logged. func (b *Builder) stepEnded(e builds.BuildLogEntry) { if e.Event != builds.BuildEndedEvent { return } key, err := builds.BuilderBuildKey(e.Module, e.FP) if err != nil { return } b.mu.Lock() chans := append([]chan builds.BuildLogEntry(nil), b.stepWaits[key]...) b.mu.Unlock() for _, ch := range chans { select { case ch <- e: default: } } }