A step ask waiting for a package the entry names with no pin took the release number of the module holding it
("v" + release), and the lane of an entry taken in dropped the empty pin and asked its build without one, so the Go
build module took another package's version: both built against versions never published (main.41, v0.1.25,
v0.1.97, v0.1.103 of the builder's builds). The builder now hears each package registry seat's published (the
package path and the version it carries) and keeps the newest per series; a build, the step's and the lane's alike,
waits for one in the series its module's manifest accepts (packages, else the default) up to package-wait-minutes,
and past it fails naming the package. The release-number pin (VersionReleased, NewestReleased) is gone.
Builds: design 47 H H-A-192, H-A-183, H-A-184, H-A-185, H-A-165
202 lines
8.4 KiB
Go
202 lines
8.4 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/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 {
|
|
outcome, said := b.buildEntry(ctx, e)
|
|
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.
|
|
func (b *Builder) buildEntry(ctx context.Context, e meshbuilds.BuildEntry) (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, meshcatalog.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 {
|
|
return b.passedWithItsVersion(ctx, entry)
|
|
}
|
|
return meshbuilds.StepEndedOutcomeFailed, failedWords
|
|
}
|
|
m := meshcatalog.ModulesByModuleValue{Repository: entry.Repository, Commit: entry.Commit, Fp2: entry.Fp, Manifest: meshcatalog.BareManifestDigest(entry.ManifestDigest), Path: entry.Path,
|
|
Toolchains: CatalogToolchains(b.agreedFor(ctx, meshcatalog.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, meshcatalog.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:
|
|
}
|
|
}
|
|
}
|