A test step held for an entry's empty pin had nothing to run with once the build passed: the builder took the pin from the registry and kept it to itself. The seat mesh-builds' step end gains packages, and the builder sets it from the pins each entry was built with, the registry's included, so the runner asks the held steps with what the build was built against. The seat's definition changes: its Go and TypeScript contracts are generated again. Builds: design 47 H H-A-207
216 lines
9.0 KiB
Go
216 lines
9.0 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)
|
|
}
|
|
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, "")
|
|
}
|
|
|
|
// buildEntry builds one entry at its fingerprint and waits for its end; pins is set to the pins it is built with, the
|
|
// entry's own and those the registry gave a package the entry named with none (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
|
|
*pins = 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 {
|
|
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 {
|
|
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, ""
|
|
}
|
|
|
|
// 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:
|
|
}
|
|
}
|
|
}
|