The builder's step end reports the pins it built with (H-A-207, from the runner branch) and names the run's catalog revision on its origin (H-A-218, H-A-220); step.go keeps both. The seat mesh-builds carries packages on step-ended and revision on package-published once each; seatgen -check is clean. Builds: design 47 H H-A-207, H-A-218, H-A-220
254 lines
10 KiB
Go
254 lines
10 KiB
Go
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:
|
|
}
|
|
}
|
|
}
|