278 lines
13 KiB
Go
278 lines
13 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"regexp"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/novox/mesh-controller/internal/conditions"
|
|
"github.com/novox/mesh-controller/internal/inventory"
|
|
"github.com/novox/mesh-controller/internal/link"
|
|
)
|
|
|
|
// firstBuilds asks the first build of every module a merge adds to a repository no registered module is built from, when
|
|
// the merge was announced as made on the operator's Approve of that head (novox/hq ADR 0432, issue 1146): the modules'
|
|
// directories are the ones the announcement says hold a module.json at the merge commit, as touchedBy reads them. The
|
|
// merge is kept, so the build's outcome is judged by the rule that registers it (mayRegisterFrom, approvedMove).
|
|
//
|
|
// **Complete in either order, with no timer** (ADR 0426): when mesh-delivery's word is kept first, it is found here; when
|
|
// the forge's merge is heard first, the merge is kept as a first merge waiting for the word, and keepingDeliveryMerges
|
|
// runs this again when the word is kept (resumeFirstBuilds). A word that says no (a Decline, another head) asks nothing and
|
|
// says why. Answers whether the merge was dealt with here.
|
|
func (f following) firstBuilds(ctx context.Context, m link.SourceMoved, entries []inventory.Entry,
|
|
read map[string][]inventory.ReadRepository, now time.Time) (bool, error) {
|
|
inv := f.open.inventory
|
|
repository := m.Owner + "/" + m.Repo
|
|
added, why, err := firstBuildsOf(ctx, inv, m, entries, read)
|
|
switch {
|
|
case errors.Is(err, errFirstNotApproved):
|
|
fmt.Printf("%s merged into %s (%.8s) adds %s, and no build is asked: %v\n", repository, m.Base, m.Commit,
|
|
strings.Join(addedDirs(m, entries, read), ", "), err)
|
|
return true, nil
|
|
case errors.Is(err, errNotAnnounced):
|
|
// Kept, waiting for mesh-delivery's word: a restart keeps it, and the word's arrival asks the builds.
|
|
if kerr := keepFirstMerge(ctx, inv, m, now, true); kerr != nil {
|
|
return true, notNow(kerr)
|
|
}
|
|
fmt.Printf("%s merged into %s (%.8s) adds %s; it is kept, and the first build is asked when mesh-delivery "+
|
|
"announces the merge on the operator's Approve\n", repository, m.Base, m.Commit,
|
|
strings.Join(addedDirs(m, entries, read), ", "))
|
|
return true, nil
|
|
case err != nil:
|
|
return true, notNow(err)
|
|
case len(added) == 0:
|
|
return false, nil
|
|
}
|
|
if err := askFirstBuilds(ctx, f.open, m, now, added, why); err != nil {
|
|
return true, notNow(err)
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
// keepFirstMerge keeps a first merge as the controller heard it, waiting (no plan answers it).
|
|
func keepFirstMerge(ctx context.Context, inv *inventory.Inventory, m link.SourceMoved, now time.Time, waitingForWord bool) error {
|
|
merged, err := time.Parse(time.RFC3339Nano, m.MergedAt)
|
|
if err != nil {
|
|
merged = now
|
|
}
|
|
event, err := json.Marshal(keptMerge{SourceMoved: m, FirstBuild: waitingForWord})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = inv.AddMerge(ctx, inventory.BatchedMerge{Repository: m.Owner + "/" + m.Repo, Branch: m.Base, Commit: m.Commit,
|
|
Merged: merged.UTC(), Heard: now, Event: event})
|
|
return err
|
|
}
|
|
|
|
// askFirstBuilds keeps the merge as answered and registers its modules from the builder's done keys (novox/hq ADR 0501
|
|
// §3, §6): nothing asks their first builds. The merge kept is the registration's warrant (approvedMove reads it by the
|
|
// commit the indexer's trunk value names); a module whose key is not done yet is registered when the key's write wakes
|
|
// the take-in (new_modules.go).
|
|
func askFirstBuilds(ctx context.Context, open *stores, m link.SourceMoved, now time.Time, added []string,
|
|
why string) error {
|
|
inv := open.inventory
|
|
repository := m.Owner + "/" + m.Repo
|
|
if err := keepFirstMerge(ctx, inv, m, now, false); err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("%s merged into %s (%.8s) on the operator's Approve (%s): the mesh builds nothing from it yet, so %s "+
|
|
"are registered from the builder's done keys, asking no build\n", repository, m.Base, m.Commit, why,
|
|
strings.Join(added, ", "))
|
|
// Answered: it no longer waits, so the word's arrival again does nothing twice.
|
|
if err := inv.AnswerMerge(ctx, repository, m.Commit, inventory.WaitingRecord, false); err != nil {
|
|
return err
|
|
}
|
|
modules, err := newModulesOf(ctx, repository)
|
|
switch {
|
|
case err != nil:
|
|
// Said, not failed: the merge is answered, and the look at every module when a controller starts, or the next
|
|
// write of the builder or the indexer for one of them, registers them.
|
|
fmt.Printf(" the indexer's modules of %s cannot be read now (%v): they are registered when the builder's next "+
|
|
"write of one wakes the take-in\n", repository, err)
|
|
case len(modules) > 0:
|
|
inBackground(func() { takeNewModules(context.WithoutCancel(ctx), open, modules...) })
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// resumeFirstBuilds runs firstBuilds for the first merges waiting for the word mesh-delivery just announced for a pull
|
|
// request's head: the other order of the same two events.
|
|
func (f following) resumeFirstBuilds(ctx context.Context, d deliveryMerge) error {
|
|
actingOnMerges.Lock()
|
|
defer actingOnMerges.Unlock()
|
|
inv := f.open.inventory
|
|
waiting, err := inv.WaitingMerges(ctx)
|
|
if err != nil {
|
|
return notNow(err)
|
|
}
|
|
for _, w := range waiting {
|
|
k := announcedOf(w)
|
|
if !k.FirstBuild || len(k.Held) > 0 || !strings.EqualFold(k.Owner+"/"+k.Repo, d.Owner+"/"+d.Repo) || k.Number != d.Number ||
|
|
k.HeadSHA != d.HeadSHA {
|
|
continue
|
|
}
|
|
entries, err := inv.Catalogued(ctx)
|
|
if err != nil {
|
|
return notNow(err)
|
|
}
|
|
read, err := readForPlanning(ctx, inv)
|
|
if err != nil {
|
|
return notNow(err)
|
|
}
|
|
added, why, err := firstBuildsOf(ctx, inv, k.SourceMoved, entries, read)
|
|
switch {
|
|
case errors.Is(err, errFirstNotApproved):
|
|
fmt.Printf("%s/%s merged into %s (%.8s) was waiting for mesh-delivery's word, and no build is asked: %v\n",
|
|
k.Owner, k.Repo, k.Base, k.Commit, err)
|
|
if aerr := inv.AnswerMerge(ctx, w.Repository, w.Commit, inventory.WaitingRecord, false); aerr != nil {
|
|
return notNow(aerr)
|
|
}
|
|
case err != nil:
|
|
return notNow(err)
|
|
case len(added) > 0:
|
|
if err := askFirstBuilds(ctx, f.open, k.SourceMoved, time.Now().UTC(), added, why); err != nil {
|
|
return notNow(err)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// errFirstNotApproved says a merge into a repository the mesh builds nothing from is not one the operator approved.
|
|
var errFirstNotApproved = errors.New("it is no merge made on the operator's Approve of its head, so a hand `build` " +
|
|
"registers a module from a repository the mesh does not build yet")
|
|
|
|
// addedDirs are the module directories the merge adds to a repository no registered module is built from, none where
|
|
// the merge is not into the trunk or some module is built from the repository already.
|
|
func addedDirs(m link.SourceMoved, entries []inventory.Entry, read map[string][]inventory.ReadRepository) []string {
|
|
if m.Base != "main" {
|
|
return nil
|
|
}
|
|
for _, e := range entries {
|
|
if !e.Provided && sameRepository(e.Source.Repository, m) {
|
|
return nil
|
|
}
|
|
}
|
|
_, added, _ := touchedBy(nil, entries, m, read)
|
|
return added
|
|
}
|
|
|
|
// firstBuildsOf is the directories whose first build a merge asks, and the warrant it was made on; none when the merge
|
|
// is no first merge into a repository the mesh builds nothing from. errFirstNotApproved when it is and the word on record
|
|
// is no Approve of its head; errNotAnnounced when mesh-delivery's word is not kept yet.
|
|
func firstBuildsOf(ctx context.Context, inv catalogueReader, m link.SourceMoved, entries []inventory.Entry,
|
|
read map[string][]inventory.ReadRepository) ([]string, string, error) {
|
|
added := addedDirs(m, entries, read)
|
|
if len(added) == 0 {
|
|
return nil, "", nil
|
|
}
|
|
why, err := approvedAnnounced(ctx, inv, m.Owner, m.Repo, keptMerge{SourceMoved: m})
|
|
switch {
|
|
case err == nil:
|
|
return added, why, nil
|
|
case errors.Is(err, errWordNotAnApprove):
|
|
return nil, "", fmt.Errorf("%w (%v)", errFirstNotApproved, err)
|
|
}
|
|
// Not announced yet, or the bus or the store could not be asked: the caller waits or tries again, and asks nothing.
|
|
return nil, "", err
|
|
}
|
|
|
|
// heldFirstBuild says a first build was refused because its manifest uses a word the running build-agent does not read,
|
|
// and its merge is kept waiting for a build-agent that reads it (novox/hq ADR 0482 §5, issue 1173). Read from a merge kept
|
|
// before R4e, never written since: nothing asks a first build (ADR 0501 §6), and a controller that starts answers such a
|
|
// merge and registers its modules from their keys (answerHeldMerges).
|
|
type heldFirstBuild struct {
|
|
Module string `json:"module"`
|
|
Path string `json:"path"`
|
|
Word string `json:"word"`
|
|
At time.Time `json:"at"`
|
|
}
|
|
|
|
// unknownWord is how the strict reading of a manifest says a word is not one it knows: encoding/json's own words, which
|
|
// the build-agent's answer carries whole. The build's answer has no typed field for it (Failed is the builder's words).
|
|
var unknownWord = regexp.MustCompile(`json: unknown field "([^"]+)"`)
|
|
|
|
// refusedWord is the word a build's failure says the reader did not know; empty when it says none.
|
|
func refusedWord(failed string) string {
|
|
if m := unknownWord.FindStringSubmatch(failed); m != nil {
|
|
return m[1]
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// probeFirstBuildsID is the probe that reads the first merges waiting for mesh-delivery's word.
|
|
const probeFirstBuildsID = "D18"
|
|
|
|
// kindFirstBuildUnasked is what a first merge waiting too long for mesh-delivery's word raises.
|
|
const kindFirstBuildUnasked = "first-build-unasked"
|
|
|
|
// firstBuildWaitBound is how long a first merge waits for mesh-delivery's announcement of the operator's Approve before
|
|
// it is said: a bound in the sense of ADR 0426 §3, not a delay. Nothing waits on it: the word's arrival asks the builds
|
|
// at once, and the merge is said, never dropped, once it is past this (issue 1146).
|
|
const firstBuildWaitBound = 10 * time.Minute
|
|
|
|
// firstBuildObservations are the conditions of the first merges waiting past the bound, one for each; a merge answered is
|
|
// no longer listed as waiting, so its condition clears with the next look.
|
|
func firstBuildObservations(waiting []inventory.BatchedMerge, now time.Time) []conditions.Observation {
|
|
var out []conditions.Observation
|
|
for _, w := range waiting {
|
|
k := announcedOf(w)
|
|
if !k.FirstBuild || now.Sub(w.Heard) <= firstBuildWaitBound {
|
|
continue
|
|
}
|
|
repository := k.Owner + "/" + k.Repo
|
|
for_ := now.Sub(w.Heard).Round(time.Minute)
|
|
out = append(out, conditions.Observation{Scope: conditions.ScopeMerge,
|
|
ID: fmt.Sprintf("%s_%.8s", repository, k.Commit), Kind: kindFirstBuildUnasked, Severity: conditions.Warning,
|
|
Summary: fmt.Sprintf("the merge %.8s of %s adds modules the mesh builds nothing from yet, and has waited %s for "+
|
|
"mesh-delivery's announcement of the operator's Approve of its head: no build is asked", k.Commit, repository, for_),
|
|
Said: fmt.Sprintf("%s at %s waits for mesh-delivery's word on pull request %d (head %.8s)", repository, k.Commit,
|
|
k.Number, k.HeadSHA),
|
|
Headline: fmt.Sprintf("The first build of %s is not asked: no Approve was announced", repository),
|
|
Explanation: fmt.Sprintf("The merge %.8s into %s adds modules the mesh builds nothing from yet. It registers them "+
|
|
"only when mesh-delivery announces that it merged the pull request on your Approve of that head, and no such "+
|
|
"announcement has come in %s. The merge is kept, and the modules are registered from the builder's keys the moment "+
|
|
"the announcement is kept.",
|
|
k.Commit, repository, for_),
|
|
Resolved: "mesh-delivery announces the merge, or the operator registers the modules at the controller's terminal",
|
|
})
|
|
}
|
|
return out
|
|
}
|
|
|
|
// probeFirstBuilds is D18: no first merge waits past its bound for mesh-delivery's word unsaid.
|
|
func probeFirstBuilds(ctx context.Context, d *doctor) ([]conditions.Observation, error) {
|
|
waiting, err := d.open.inventory.WaitingMerges(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
now := time.Now().UTC()
|
|
return append(firstBuildObservations(waiting, now), newModuleObservations(now)...), nil
|
|
}
|
|
|
|
// answerHeldMerges answers every merge a controller of before held for a build-agent that reads its new modules'
|
|
// manifests (issue 1173): nothing asks their first builds any more, and the look at every module when this controller
|
|
// starts registers them from their keys (ADR 0501 §6, §7).
|
|
func answerHeldMerges(ctx context.Context, inv *inventory.Inventory) {
|
|
waiting, err := inv.WaitingMerges(ctx)
|
|
if err != nil {
|
|
fmt.Printf("the merges held for a newer build-agent could not be read: %v\n", err)
|
|
return
|
|
}
|
|
for _, w := range waiting {
|
|
if k := announcedOf(w); len(k.Held) > 0 {
|
|
if err := inv.AnswerMerge(ctx, w.Repository, w.Commit, inventory.WaitingRecord, false); err != nil {
|
|
fmt.Printf("the merge %.8s of %s held for a newer build-agent could not be answered: %v\n", w.Commit,
|
|
w.Repository, err)
|
|
continue
|
|
}
|
|
fmt.Printf("the merge %.8s of %s was held for a newer build-agent; its modules are registered from the "+
|
|
"builder's keys instead\n", w.Commit, w.Repository)
|
|
}
|
|
}
|
|
}
|