|
|
|
@@ -24,6 +24,9 @@ import (
|
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/announce"
|
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/delivery"
|
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/process"
|
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/views"
|
|
|
|
|
|
|
|
|
|
"git.novox.be/novox/mesh-delivery/sdk/firstview"
|
|
|
|
|
|
|
|
|
|
"mesh-delivery-checker/internal/check"
|
|
|
|
|
)
|
|
|
|
@@ -61,6 +64,20 @@ func durationEnv(getenv func(string) string, name string, def time.Duration) (ti
|
|
|
|
|
return d, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// The checker's own states of its first views (views.StatusState) and of its findings, where the condition keeper raises a
|
|
|
|
|
// first view unanswered past its bound (ADR 0615 §6); and the indexer's states it follows (delivery.CandidatesBucket,
|
|
|
|
|
// ModulesBucket, ManifestsBucket).
|
|
|
|
|
var (
|
|
|
|
|
firstViewsBucket = delivery.CheckerModule + "_" + views.StatusState
|
|
|
|
|
findingsBucket = delivery.CheckerModule + "_findings"
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
const (
|
|
|
|
|
candidatesState = "candidates"
|
|
|
|
|
modulesState = "modules"
|
|
|
|
|
manifestsState = "manifests"
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
// run is the program: it returns when ctx ends or the bus cannot be used.
|
|
|
|
|
// keptStates is every state the checker keeps and which others may read (ADR 0495 §2-§3): owed by the forge module,
|
|
|
|
|
// which writes mesh/check from it (ADR 0521), and by the forge bridge; previews by the indexer; verdicts by the gate; tries by the delivery view.
|
|
|
|
@@ -77,6 +94,10 @@ var keptStates = []announce.State{
|
|
|
|
|
// The tries are read by the delivery view, which tells a try's asks from a candidate's by the asks each names (build_usage).
|
|
|
|
|
{Name: "tries", Readable: true},
|
|
|
|
|
{Name: "verdicts", Readable: true},
|
|
|
|
|
// Where its first views of the indexer's and the assigner's states stand (read by checker_first_views alone), and its
|
|
|
|
|
// findings of one unanswered past its bound, which the condition keeper observes as it does every reader's (ADR 0615 §6).
|
|
|
|
|
{Name: views.StatusState},
|
|
|
|
|
{Name: "findings"},
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func run(ctx context.Context, getenv func(string) string, logOut io.Writer) error {
|
|
|
|
@@ -90,11 +111,10 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
defer conn.Close()
|
|
|
|
|
// Its own states, the candidates it checks, and the modules and manifests that say which build modules judge a repository:
|
|
|
|
|
// a check without one of them would be wrong or unwritten, so each stops the start, naming its grant (issue 1945).
|
|
|
|
|
// Its own states: a check without one of them would be unwritten, so each stops the start, naming its grant (issue 1945).
|
|
|
|
|
buckets := map[string]jetstream.KeyValue{}
|
|
|
|
|
for _, name := range []string{delivery.CheckerVerdictsBucket, delivery.CheckerKeptBucket, delivery.CheckerOwedBucket, delivery.PreviewsBucket,
|
|
|
|
|
delivery.CandidatesBucket, delivery.ModulesBucket, delivery.ManifestsBucket, check.TriesBucket} {
|
|
|
|
|
check.TriesBucket} {
|
|
|
|
|
if buckets[name], err = process.EssentialBucket(ctx, js, "checker", name, "judge or keep a check"); err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
@@ -111,6 +131,19 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
|
|
|
|
|
if err := caller.Keeps(keptStates...); err != nil {
|
|
|
|
|
logger.Printf("what the checker keeps could not be said on the bus, so readers of owed, previews and verdicts are not granted until it is: %v", err)
|
|
|
|
|
}
|
|
|
|
|
// The candidates it checks, the modules and manifests that say which build modules judge a repository, the published
|
|
|
|
|
// packages, the predefined keys and the placement are their owners' states (the indexer's, the assigner's), read by the
|
|
|
|
|
// first view of their read tools and then their views families, never their buckets (ADR 0615 §1, ADR 0596, DLV-M2).
|
|
|
|
|
// An owner that is down never holds the start: the checks start once every first view is answered, and until then the
|
|
|
|
|
// unanswered first view is the checker's finding.
|
|
|
|
|
reader := &firstview.Reader{Module: delivery.CheckerModule, Call: caller.Call, Logf: logger.Printf}
|
|
|
|
|
reader.Findings = process.AwaitBucket(ctx, js, conn, findingsBucket, "a first view unanswered past its bound is said in the log alone", logger.Printf).KV
|
|
|
|
|
candidates := reader.Follow(delivery.IndexerModule, candidatesState)
|
|
|
|
|
modules := reader.Follow(delivery.IndexerModule, modulesState)
|
|
|
|
|
manifests := reader.Follow(delivery.IndexerModule, manifestsState)
|
|
|
|
|
packages := reader.Follow(delivery.IndexerModule, delivery.PackagesState)
|
|
|
|
|
predefined := reader.Follow(delivery.IndexerModule, delivery.IndexerPredefinedState)
|
|
|
|
|
placement := reader.Follow(delivery.AssignerModule, delivery.PlacementState)
|
|
|
|
|
|
|
|
|
|
stepBound, err := durationEnv(getenv, "MESH_CHECKER_STEP_BOUND", check.DefaultStepBound)
|
|
|
|
|
if err != nil {
|
|
|
|
@@ -183,7 +216,7 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
|
|
|
|
|
verdicts := &manifestVerdicts{}
|
|
|
|
|
compositions := check.EngineCompositions{
|
|
|
|
|
Asker: engineAsks{call: caller.CallOn},
|
|
|
|
|
Placed: placedNodes{kv: func(at context.Context) (jetstream.KeyValue, error) { return js.KeyValue(at, delivery.PlacementBucket) }}.Placed,
|
|
|
|
|
Placed: placedNodes{kv: func(context.Context) (jetstream.KeyValue, error) { return placement, nil }}.Placed,
|
|
|
|
|
Bound: answerBound,
|
|
|
|
|
Sandbox: seatSandbox{asker: buildrun.Asker{Publisher: asks, Waiter: waiter, Bound: stepBound}},
|
|
|
|
|
Verdicts: verdicts.all,
|
|
|
|
@@ -196,23 +229,12 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
|
|
|
|
|
logger.Printf("%s of %s was written and the part that reads it could not be told: %v", event, key, err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
repos := &repoModules{manifests: kvStore{buckets[delivery.ManifestsBucket]}, logf: logger.Printf, verdicts: verdicts}
|
|
|
|
|
repos := &repoModules{manifests: kvStore{manifests}, logf: logger.Printf, verdicts: verdicts}
|
|
|
|
|
compositions.Composer = func() string { return repos.CommitOf(check.NodeEngineModule) }
|
|
|
|
|
compositions.Manifests = repos
|
|
|
|
|
// The indexer's packages state (ADR 0593 §2): followed once the bus has it, so a Go check builds every mesh package at
|
|
|
|
|
// its published version; until then a check builds each at the version its go.mod names.
|
|
|
|
|
// The indexer's packages state (ADR 0593 §2), so a Go check builds every mesh package at its published version: read
|
|
|
|
|
// once the first views are answered, before any check starts (afterFirstViews).
|
|
|
|
|
published := &publishedPackages{}
|
|
|
|
|
process.AwaitBucket(ctx, js, conn, delivery.PackagesBucket, "a Go check builds each mesh package at the version its go.mod names",
|
|
|
|
|
logger.Printf).Ready(func(kv jetstream.KeyValue) {
|
|
|
|
|
w, err := settle(ctx, kv, func(e jetstream.KeyValueEntry) { published.Put(e.Key(), e.Value(), !opOf(e)) })
|
|
|
|
|
if err != nil {
|
|
|
|
|
logger.Printf("%s cannot be watched, so a Go check builds each mesh package at the version its go.mod names: %v", delivery.PackagesBucket, err)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
go func() {
|
|
|
|
|
_ = follow(ctx, w, func(e jetstream.KeyValueEntry) { published.Put(e.Key(), e.Value(), !opOf(e)) })
|
|
|
|
|
}()
|
|
|
|
|
})
|
|
|
|
|
ch.Runs = repos // the node-engine a check reads beside at its running commit (ADR 0548 §6)
|
|
|
|
|
// A group's tagged versions (design 51 *Tagged versions*): tag-wanted on the checker's stream asks, and the package
|
|
|
|
|
// registry seats' published heard on the checker's durable consumer of the shared events stream. Where that consumer is
|
|
|
|
@@ -239,9 +261,8 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
|
|
|
|
|
kept: kvStore{buckets[delivery.CheckerKeptBucket]}, previews: kvStore{buckets[delivery.PreviewsBucket]},
|
|
|
|
|
repos: repos, published: published, builds: builds, ends: ends, buildWait: set.buildWait, forge: forgeReads{call: caller.Call}, logf: logger.Printf,
|
|
|
|
|
announce: announce, compositions: compositions, tags: tags,
|
|
|
|
|
nodes: openNodeNames(ctx, js, logger.Printf),
|
|
|
|
|
predefined: keptPredefined{process.AwaitBucket(ctx, js, conn, delivery.IndexerModule+"_"+delivery.IndexerPredefinedState,
|
|
|
|
|
"a change's manifests are judged with no predefined keys, each fallback as its value declares it", logger.Printf)},
|
|
|
|
|
nodes: openNodeNames(ctx, js, logger.Printf),
|
|
|
|
|
predefined: keptPredefined{predefined},
|
|
|
|
|
})
|
|
|
|
|
ch.Announce = announce
|
|
|
|
|
tryer.Judge = ch.Judge
|
|
|
|
@@ -252,10 +273,21 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
|
|
|
|
|
// placement is settled first, so the toolchains settle through the gate already knowing it.
|
|
|
|
|
gate := buildrun.NewToolchainGate([]string{buildrun.GoBuildModule, buildrun.NodeBuildModule}, tools.Put, logger.Printf)
|
|
|
|
|
watch.put = gate.Toolchain
|
|
|
|
|
placementErrs, err := buildrun.FollowPlacement(ctx, js, gate, ch.NodesChanged, logger.Printf)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
// Until the placement's first view is answered the gate passes every report on, as before the placement is settled.
|
|
|
|
|
placementErrs := make(chan error, 1)
|
|
|
|
|
go func() {
|
|
|
|
|
select {
|
|
|
|
|
case <-ctx.Done():
|
|
|
|
|
return
|
|
|
|
|
case <-placement.Follower().Ready():
|
|
|
|
|
}
|
|
|
|
|
pe, err := buildrun.FollowPlacement(ctx, reader, gate, ch.NodesChanged, logger.Printf)
|
|
|
|
|
if err != nil {
|
|
|
|
|
placementErrs <- err
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
placementErrs <- <-pe
|
|
|
|
|
}()
|
|
|
|
|
if err := watch.start(); err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
@@ -338,65 +370,89 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
lazy.ensure()
|
|
|
|
|
// The modules say which repository holds a TypeScript module, so the Node build module judges it too.
|
|
|
|
|
mw, err := settle(ctx, buckets[delivery.ModulesBucket], func(e jetstream.KeyValueEntry) { repos.Put(ctx, e.Key(), e.Value(), !opOf(e)) })
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
go func() {
|
|
|
|
|
errs <- follow(ctx, mw, func(e jetstream.KeyValueEntry) {
|
|
|
|
|
before := repos.CommitOf(check.NodeEngineModule)
|
|
|
|
|
repos.Put(ctx, e.Key(), e.Value(), !opOf(e))
|
|
|
|
|
if after := repos.CommitOf(check.NodeEngineModule); after != before {
|
|
|
|
|
ch.TrunkMoved(ctx) // the node-engine the mesh runs moved: a verdict that read it beside is carried (ADR 0548 §6)
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
}()
|
|
|
|
|
each := func(e jetstream.KeyValueEntry) {
|
|
|
|
|
if opOf(e) {
|
|
|
|
|
ch.Candidate(ctx, e.Key(), e.Value())
|
|
|
|
|
} else {
|
|
|
|
|
ch.Forget(e.Key())
|
|
|
|
|
afterFirstViews := func() error {
|
|
|
|
|
// The modules say which repository holds a TypeScript module, so the Node build module judges it too.
|
|
|
|
|
pw, err := settle(ctx, packages, func(e jetstream.KeyValueEntry) { published.Put(e.Key(), e.Value(), !opOf(e)) })
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
w, err := settle(ctx, buckets[delivery.CandidatesBucket], each)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
// A key left running for heads no candidate holds is closed; the candidates are all known now.
|
|
|
|
|
if err := ch.Sweep(ctx); err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
// The tries: a queued one starts, one left running is taken over, an ended one past its keeping is removed.
|
|
|
|
|
tw, err := settle(ctx, buckets[check.TriesBucket], func(jetstream.KeyValueEntry) {})
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
tryer.Reconsider(ctx)
|
|
|
|
|
go func() {
|
|
|
|
|
errs <- follow(ctx, tw, func(e jetstream.KeyValueEntry) {
|
|
|
|
|
go func() {
|
|
|
|
|
errs <- follow(ctx, pw, func(e jetstream.KeyValueEntry) { published.Put(e.Key(), e.Value(), !opOf(e)) })
|
|
|
|
|
}()
|
|
|
|
|
mw, err := settle(ctx, modules, func(e jetstream.KeyValueEntry) { repos.Put(ctx, e.Key(), e.Value(), !opOf(e)) })
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
go func() {
|
|
|
|
|
errs <- follow(ctx, mw, func(e jetstream.KeyValueEntry) {
|
|
|
|
|
before := repos.CommitOf(check.NodeEngineModule)
|
|
|
|
|
repos.Put(ctx, e.Key(), e.Value(), !opOf(e))
|
|
|
|
|
if after := repos.CommitOf(check.NodeEngineModule); after != before {
|
|
|
|
|
ch.TrunkMoved(ctx) // the node-engine the mesh runs moved: a verdict that read it beside is carried (ADR 0548 §6)
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
}()
|
|
|
|
|
each := func(e jetstream.KeyValueEntry) {
|
|
|
|
|
if opOf(e) {
|
|
|
|
|
tryer.Put(ctx, e.Key(), e.Value())
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
}()
|
|
|
|
|
// The checker's own verdicts, updates only, in one watch: one checker_ask_again wrote asks its check again
|
|
|
|
|
// (Checker.VerdictWritten); a deleted key of heads a candidate holds is judged again (Checker.VerdictDeleted, issue 1733).
|
|
|
|
|
vw, err := buckets[delivery.CheckerVerdictsBucket].WatchAll(ctx, jetstream.UpdatesOnly())
|
|
|
|
|
if err != nil {
|
|
|
|
|
return fmt.Errorf("the checker's verdicts cannot be watched, so no check can be asked again by hand and a deleted verdict would never be written again: %w", err)
|
|
|
|
|
}
|
|
|
|
|
go func() {
|
|
|
|
|
errs <- follow(ctx, vw, func(e jetstream.KeyValueEntry) {
|
|
|
|
|
if opOf(e) {
|
|
|
|
|
ch.VerdictWritten(ctx, e.Key(), e.Value())
|
|
|
|
|
ch.Candidate(ctx, e.Key(), e.Value())
|
|
|
|
|
} else {
|
|
|
|
|
ch.VerdictDeleted(ctx, e.Key())
|
|
|
|
|
ch.Forget(e.Key())
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
w, err := settle(ctx, candidates, each)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
// A key left running for heads no candidate holds is closed; the candidates are all known now.
|
|
|
|
|
if err := ch.Sweep(ctx); err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
// The tries: a queued one starts, one left running is taken over, an ended one past its keeping is removed.
|
|
|
|
|
tw, err := settle(ctx, buckets[check.TriesBucket], func(jetstream.KeyValueEntry) {})
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
tryer.Reconsider(ctx)
|
|
|
|
|
go func() {
|
|
|
|
|
errs <- follow(ctx, tw, func(e jetstream.KeyValueEntry) {
|
|
|
|
|
if opOf(e) {
|
|
|
|
|
tryer.Put(ctx, e.Key(), e.Value())
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
}()
|
|
|
|
|
// The checker's own verdicts, updates only, in one watch: one checker_ask_again wrote asks its check again
|
|
|
|
|
// (Checker.VerdictWritten); a deleted key of heads a candidate holds is judged again (Checker.VerdictDeleted, issue 1733).
|
|
|
|
|
vw, err := buckets[delivery.CheckerVerdictsBucket].WatchAll(ctx, jetstream.UpdatesOnly())
|
|
|
|
|
if err != nil {
|
|
|
|
|
return fmt.Errorf("the checker's verdicts cannot be watched, so no check can be asked again by hand and a deleted verdict would never be written again: %w", err)
|
|
|
|
|
}
|
|
|
|
|
go func() {
|
|
|
|
|
errs <- follow(ctx, vw, func(e jetstream.KeyValueEntry) {
|
|
|
|
|
if opOf(e) {
|
|
|
|
|
ch.VerdictWritten(ctx, e.Key(), e.Value())
|
|
|
|
|
} else {
|
|
|
|
|
ch.VerdictDeleted(ctx, e.Key())
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
}()
|
|
|
|
|
go func() { errs <- follow(ctx, w, each) }()
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
reader.Start(ctx, js, cred, process.AwaitBucket(ctx, js, conn, firstViewsBucket, "checker_first_views reads nothing and checker_first_view_again is not heard", logger.Printf))
|
|
|
|
|
// The checks, the tries and the hand asks, once every first view is answered (the lead's ruling for DLV-M2): a check
|
|
|
|
|
// judged without the candidates, the modules, the manifests, the published packages, the predefined keys or the
|
|
|
|
|
// placement would be another check.
|
|
|
|
|
go func() {
|
|
|
|
|
select {
|
|
|
|
|
case <-ctx.Done():
|
|
|
|
|
return
|
|
|
|
|
case <-reader.Ready():
|
|
|
|
|
}
|
|
|
|
|
if err := afterFirstViews(); err != nil {
|
|
|
|
|
errs <- err
|
|
|
|
|
}
|
|
|
|
|
}()
|
|
|
|
|
logger.Printf("started on %s", cred.Node)
|
|
|
|
|
go func() { errs <- follow(ctx, w, each) }()
|
|
|
|
|
select {
|
|
|
|
|
case <-ctx.Done():
|
|
|
|
|
ch.Wait()
|
|
|
|
|