One source now has several catalog revisions, so a publish naming branch and source alone does not say which pipeline published it. The seat mesh-builds' package-published gains an optional revision (seatgen regenerated). The version reserved for a build keeps the catalog revision number: from the picture's half when the picture starts the build (the same revision its source comes from), from the step ask's run when the ask reaches the build first. Its package-published says it. A reservation from before the field says none. Builds: design 47 H H-A-218, H-A-220
225 lines
9.2 KiB
Go
225 lines
9.2 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 {
|
|
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, "")
|
|
}
|
|
|
|
// 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.
|
|
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, 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 {
|
|
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:
|
|
}
|
|
}
|
|
}
|