diff --git a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer-tools/main.go b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer-tools/main.go index c767b78b..a584fa9b 100644 --- a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer-tools/main.go +++ b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer-tools/main.go @@ -316,6 +316,10 @@ func main() { })...) tools = append(tools, viewTools(os.Getenv, trunk.State, time.Now)...) tools = append(tools, index.PendingTools(keptRead{stdio.State(index.PendingState)}, keptRead{stdio.State(index.OwnBuildStateName)}, asks, time.Now)...) + tools = append(tools, index.ValidationTools(asks, time.Now, func(what, why string) error { + _, err := acts.Record(meshhandactsclient.Request{What: what, Why: why, Cause: index.ValidateAgainTool, Verb: "validate-again"}) + return err + })...) tools = append(tools, index.FingerprintsTools(asks, time.Now, func(what, why string) error { _, err := acts.Record(meshhandactsclient.Request{What: what, Why: why, Cause: index.FingerprintsAgainTool, Verb: "fingerprints-again"}) return err diff --git a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/takein.go b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/takein.go index e72897a0..dde180b0 100644 --- a/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/takein.go +++ b/modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/takein.go @@ -28,6 +28,7 @@ type takerIn interface { NamedDrop(ctx context.Context, fingerprint, member, by, why string) index.TakenIn Unpin(ctx context.Context, revision, record, by, why string) index.TakenIn DropRunByHand(ctx context.Context, run, by, why string) index.TakenIn + ValidateAgainByHand(ctx context.Context, key, by, why string) index.TakenIn RegistryAct(ctx context.Context, a index.TakeInAsk) index.TakenIn } @@ -69,6 +70,9 @@ func takenIn(ctx context.Context, ix takerIn, kv jetstream.KeyValue, e jetstream } else if a.Merge != "" { asked, r = "hand take-in of a merge", ix.TakeInMerge(ctx, a.MergeRepository, a.Merge, a.Sequence, a.By, a.Why) a.Module = r.Module + } else if a.Pending != "" && a.ValidateAgain { + asked, r = "validation asked again", ix.ValidateAgainByHand(ctx, a.Pending, a.By, a.Why) + a.Module = a.Pending } else if a.Pending != "" && a.Drop { asked, r = "drop of a pending merge", ix.DropPending(ctx, a.Pending, a.By, a.Why, a.Abandon) a.Module = a.Pending diff --git a/modules/mesh-delivery-indexer/internal/index/pending_tools.go b/modules/mesh-delivery-indexer/internal/index/pending_tools.go index 366654eb..c27abaa7 100644 --- a/modules/mesh-delivery-indexer/internal/index/pending_tools.go +++ b/modules/mesh-delivery-indexer/internal/index/pending_tools.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "fmt" + "strings" "time" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-indexer/takein" @@ -111,3 +112,33 @@ func PendingTools(pending, ownBuild Store, ask func(key string, value []byte) (T Run: merge}, } } + +// ValidationTools is indexer_validate_again (class act, design 47 G §713): the tools bundle writes an ask in takeins and the +// indexer asks the revision's validation again; record says the hand act in the hand-act log before it is asked. +func ValidationTools(ask func(key string, value []byte) (TakeInAsk, error), now func() time.Time, record func(what, why string) error) []stdio.Tool { + return []stdio.Tool{{Name: ValidateAgainTool, + Description: "Ask again the validation of a pending revision that could not validate (design 47 G §712, §713): the manifest " + + "validator's run on the build seat node-build-go ended could not run, exited other than 0, or answered not both cases. " + + "The revision is asked under its next try; the answer says the validation's state (the ask, its try, accepted, refused, " + + "or why it could not validate). A revision accepted, refused or whose ask is out is asked nothing: a refusal is asked " + + "again only by a later merge of its branch. A hand act, recorded through mesh-hand-acts before it is asked. " + + "indexer_pending names the keys and shows the validation whole.", + Input: map[string]any{"type": "object", "required": []string{"key", "why"}, "properties": map[string]any{ + "key": map[string]any{"type": "string", "description": "the revision's wait key, m., as indexer_pending names it"}, + "why": map[string]any{"type": "string", "description": "why it is asked again, in plain words"}}}, + Run: func(args map[string]any) (any, error) { + str := func(k string) string { s, _ := args[k].(string); return s } + key, value, err := NewValidateAgainAsk(str("key"), str("why"), stdio.CallerOf(args), now()) + if err != nil { + return nil, err + } + if err := record("asked the validation of the pending revision "+strings.TrimSpace(str("key"))+" again by hand", strings.TrimSpace(str("why"))); err != nil { + return nil, fmt.Errorf("the hand act was not recorded through mesh-hand-acts, so nothing was asked: %w", err) + } + a, err := ask(key, value) + if err != nil { + return nil, err + } + return a.Result, nil + }}} +} diff --git a/modules/mesh-delivery-indexer/internal/index/takein.go b/modules/mesh-delivery-indexer/internal/index/takein.go index 7e581059..632a35fb 100644 --- a/modules/mesh-delivery-indexer/internal/index/takein.go +++ b/modules/mesh-delivery-indexer/internal/index/takein.go @@ -52,6 +52,9 @@ type TakeInAsk struct { // Abandon, with Drop, drops a pending merge no later merge covers (ADR 0633 §5 asks a later merge; issue 1966, ADR // 0668 §5): the hand act says why it is abandoned all the same. Abandon bool `json:"abandon,omitempty"` + // ValidateAgain, with Pending, asks the validation of the revision under that key again (indexer_validate_again, design 47 + // G §713): one that could not validate. + ValidateAgain bool `json:"validate-again,omitempty"` // Merge asks the merge of MergeRepository at this commit to be taken in by hand (indexer_take_in_merge): its merged message // is asked of the forge bridge and run through the take-in as a delivered one, under its stream sequence Sequence. Merge string `json:"merge,omitempty"` @@ -165,6 +168,20 @@ func NewMergeAsk(repository, merge string, sequence uint64, why, by string, at t return "merge." + merge, data, err } +// NewValidateAgainAsk is the value indexer_validate_again writes: its key in takeins, `pending.validate-again.`, and the +// value. key is a revision's wait key, m., as indexer_pending names it. +func NewValidateAgainAsk(key, why, by string, at time.Time) (string, []byte, error) { + key = strings.TrimSpace(key) + if !strings.HasPrefix(key, "m.") { + return "", nil, errors.New("name the revision whose validation is asked again by its key, m., as indexer_pending names it") + } + if strings.TrimSpace(why) == "" { + return "", nil, errors.New("say why (why): a hand act is recorded through mesh-hand-acts") + } + data, err := json.Marshal(TakeInAsk{V: 1, Pending: key, ValidateAgain: true, Why: strings.TrimSpace(why), By: by, At: at.UTC()}) + return "pending.validate-again." + key, data, err +} + // NewPendingAsk is the value indexer_take_in_pending (drop false) or indexer_drop_pending (drop true) writes: its key // in takeins, `pending..`, and the value. key is a wait's key as indexer_pending names it, for a // drop one pending merge's; abandon drops one no later merge covers. diff --git a/modules/mesh-delivery-indexer/internal/index/validation_wait.go b/modules/mesh-delivery-indexer/internal/index/validation_wait.go index f5fc3f5b..f24e27a1 100644 --- a/modules/mesh-delivery-indexer/internal/index/validation_wait.go +++ b/modules/mesh-delivery-indexer/internal/index/validation_wait.go @@ -6,6 +6,7 @@ import ( "errors" "fmt" "strings" + "time" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/buildstep" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/composer" @@ -264,3 +265,74 @@ func (ix *Indexer) validationAnswer(ctx context.Context, ready []PendingEntry, e } return RefusedWords(refused), "" } + +// ValidateAgainTool asks the validation of a revision that could not validate again by hand (§713). +const ValidateAgainTool = "indexer_validate_again" + +// validationWords is the validation's state as the hand ask answers it. +func validationWords(v *takein.Validation, refused string) string { + switch { + case v == nil: + return "no validation is asked yet" + case v.Accepted != 0: + return fmt.Sprintf("accepted at %d (try %d, the ask %s)", v.Accepted, v.Try, v.Ask) + case v.Failed != "": + return fmt.Sprintf("could not validate at %d (try %d): %s", v.Seq, v.Try, v.Failed) + case refused != "": + return fmt.Sprintf("refused at %d (try %d): %s", v.Seq, v.Try, refused) + default: + return fmt.Sprintf("the ask %s is out since %s (try %d at %d)", v.Ask, v.Asked.UTC().Format(time.RFC3339), v.Try, v.Seq) + } +} + +// ValidateAgainByHand is indexer_validate_again answered (§713): the ready revision under key (its oldest merge's m. key, as +// indexer_pending names it) whose validation could not validate is asked again, the next try; its answer says the ask's state. +// A revision accepted, refused or whose ask is out is asked nothing: a refusal is asked again only by a later merge of its branch. +func (ix *Indexer) ValidateAgainByHand(ctx context.Context, key, by, why string) TakenIn { + r := TakenIn{Module: key} + if ix.Pending == nil || ix.ValidationAsks == nil { + r.Answer = "this indexer asks no validation: nothing asked" + return r + } + own := ix.ownBuildNow(ctx) + ix.pendingMu.Lock() + defer ix.pendingMu.Unlock() + entries, err := ReadPending(ctx, ix.Pending, ix.logf) + if err != nil { + r.Answer = err.Error() + return r + } + ready := WaitsOf(entries).Ready + if len(ready) == 0 || ready[0].Key != key { + r.Answer = fmt.Sprintf("no revision waits under %s: indexer_pending names the waits", key) + return r + } + ready, lost, reasons, _ := ix.loadNewest(ctx, ready) + if len(lost) > 0 { + r.Answer = fmt.Sprintf("nothing asked: the message of %s is not read (%s)", lost[0].Key, reasons[lost[0].Key]) + return r + } + newest := ready[newestOfRevision(ready)] + v := newest.Value.Validation + if v == nil || v.Seq != newest.Value.Seq || v.Failed == "" { + r.Answer = "nothing asked: the validation is " + validationWords(v, newest.Value.Refused) + "; only one that could not validate is asked again by hand" + return r + } + ix.logf("take-in: the validation of %s is asked again by hand by %s: %s", key, by, why) + if err := ix.askValidation(ctx, ready, own); err != nil { + r.Answer = "the validation was not asked again: " + err.Error() + return r + } + after, err := ReadPending(ctx, ix.Pending, ix.logf) + if err == nil { + ready = WaitsOf(after).Ready + } + if err != nil || len(ready) == 0 { + r.Answer = "asked again; its state is not read back" + return r + } + n := ready[newestOfRevision(ready)] + r.Stored = n.Value.Validation != nil && n.Value.Validation.Failed == "" + r.Answer = fmt.Sprintf("asked again by %s (%s): the validation is %s", by, why, validationWords(n.Value.Validation, n.Value.Refused)) + return r +} diff --git a/modules/mesh-delivery-indexer/internal/index/validation_wait_test.go b/modules/mesh-delivery-indexer/internal/index/validation_wait_test.go index 5d344a47..bc749e59 100644 --- a/modules/mesh-delivery-indexer/internal/index/validation_wait_test.go +++ b/modules/mesh-delivery-indexer/internal/index/validation_wait_test.go @@ -76,6 +76,32 @@ func TestAPendingRevisionWaitsForItsValidation(t *testing.T) { if v := readPending(t, b)[0].Value.Validation; v == nil || v.Failed != "could not run: no build node" || v.Accepted != 0 { t.Fatalf("after could not run: %+v", v) } + // indexer_validate_again (§713): its hand act recorded first, then the next try asked; the answer says the ask's state. + var recorded []string + tools := ValidationTools(func(key string, value []byte) (TakeInAsk, error) { + a, err := DecodeTakeIn(value) + if err != nil || key != "pending.validate-again."+takein.PendingKey(2) || !a.ValidateAgain { + t.Fatalf("asked %s %+v %v", key, a, err) + } + r := b.ix.ValidateAgainByHand(ctx, a.Pending, a.By, a.Why) + a.Result = &r + return a, nil + }, b.ix.now, func(what, why string) error { recorded = append(recorded, what); return nil }) + if len(tools) != 1 || tools[0].Name != ValidateAgainTool { + t.Fatalf("tools = %v", tools) + } + if _, err := tools[0].Run(map[string]any{"key": takein.PendingKey(2)}); err == nil || len(recorded) != 0 { + t.Fatalf("asked again with no why: %v, %v", err, recorded) + } + got, err := tools[0].Run(map[string]any{"key": takein.PendingKey(2), "why": "the build node is back"}) + if v := readPending(t, b)[0].Value.Validation; err != nil || len(recorded) != 1 || v == nil || v.Try != 3 || v.Failed == "could not run: no build node" || + !strings.Contains(got.(*TakenIn).Answer, "try 3") { + t.Fatalf("asked again: %v, recorded %v, validation %+v, answer %+v: want the try after 2 asked", err, recorded, v, got) + } + setValidation(takein.Validation{Ask: "mvl0frv18d1959", Input: runDigest(raw), Seq: 2, Try: 3}) + if r := b.ix.ValidateAgainByHand(ctx, takein.PendingKey(2), "lead", "again"); r.Stored || !strings.Contains(r.Answer, "is out") || readPending(t, b)[0].Value.Validation.Try != 3 { + t.Fatalf("an ask out was asked again: %+v", r) + } // Asked again (by hand or by a later merge) and accepted: the revision is taken in, and its keys go. setValidation(takein.Validation{Ask: "mvl0frv18d1958", Input: runDigest(raw), Seq: 2, Try: 3}) if err := b.ix.HearValidationEnded(ctx, end("mvl0frv18d1958", buildstep.OutcomePassed, "", accepted)); err != nil { diff --git a/modules/mesh-delivery-indexer/manifest_test.go b/modules/mesh-delivery-indexer/manifest_test.go index d7da242e..5dfaa46b 100644 --- a/modules/mesh-delivery-indexer/manifest_test.go +++ b/modules/mesh-delivery-indexer/manifest_test.go @@ -202,8 +202,9 @@ func TestManifestDeclarations(t *testing.T) { // 1238/AC1, 1444 (reads the build // milestone 47/G W4.12 (design 47, the indexer's tools): the catalog graph revisions read and steered. index.CatalogRevisionTool, index.CatalogRevisionsTool, index.CandidateGraphsTool, index.RecomputeTool, index.DropCandidateGraphTool, index.EntryIndexTool, index.NamedDropTool, // design 47 G §675 - index.ProposalsTool, index.ProposalDropTool, index.SeedAgainTool, index.InputsTool, index.PinsTool, index.UnpinTool, index.ConsumerTool, index.RunsTool, index.RunDropTool) // design 47 G §667, §8, §579, §64 (A-194) - if !reflect.DeepEqual(m.Tools, want) || len(want) != 49 || slices.Contains(m.Tools, "modules") { + index.ProposalsTool, index.ProposalDropTool, index.SeedAgainTool, index.InputsTool, index.PinsTool, index.UnpinTool, index.ConsumerTool, index.RunsTool, index.RunDropTool, // design 47 G §667, §8, §579, §64 (A-194) + index.ValidateAgainTool) // design 47 G §713 + if !reflect.DeepEqual(m.Tools, want) || len(want) != 50 || slices.Contains(m.Tools, "modules") { t.Errorf("tools = %v, want %v", m.Tools, want) } // Design 47 G §2, §9: every version of every registration is kept with no age limit, 64 MiB, on the old streams section. diff --git a/modules/mesh-delivery-indexer/module.json b/modules/mesh-delivery-indexer/module.json index 6041744f..1255de8a 100644 --- a/modules/mesh-delivery-indexer/module.json +++ b/modules/mesh-delivery-indexer/module.json @@ -75,7 +75,8 @@ "indexer_unpin", "indexer_consumer", "indexer_runs", - "indexer_run_drop" + "indexer_run_drop", + "indexer_validate_again" ], "consumes": [ "go-package-registry.published",