Compare commits

...
6 Commits
Author SHA1 Message Date
mesh-tools d6c209a10c Merge pull request 'Design 47 H1: the catalog seat's revision verb answers the store; the builder's picture holds a kept revision by number (H-A-222)' (#299) from fix/47-H1-revision-verb-store into main 2026-11-21 00:14:44 +00:00
mesh-tools 51ac838732 Merge pull request 'Design 47 H1: the indexer decodes every hand tool's ask (H-A-208, H-A-210)' (#298) from fix/47-H1-indexer-again-decode into main 2026-11-21 00:14:40 +00:00
jschoubben 773e2e33a1 Builder: a kept revision of another source or fingerprint fails the ask at once
Review round 1: an ask names the revision and the source of one revision, so a
kept revision read by number whose source differs from the ask's is not the
ask's; the check is restored, naming both sources. And a kept revision naming
another source or other fingerprints is a mismatch no wait can mend: the step
fails at once, loud, instead of waiting out revision-wait-minutes; only a
revision the catalog does not answer is waited for.

Builds: design 47 H-A-222 (2), H-A-218
2026-11-21 01:10:37 +01:00
jschoubben d817d85fca Builder: an ask naming a revision is held by that revision read by number
An ask of the very source the picture holds, whose entries the picture no
longer names (a re-pin keeps a later revision of the same source), waited for
the picture and failed past its bound, because the kept revision was read by
number only for a source below the picture's. Now an ask naming a revision is
read by number whenever the picture does not name its entries, and is built
when the catalog keeps it and it names every fingerprint asked, whatever the
source says; the source is compared only for an ask naming no revision.

Builds: design 47 H-A-222 (2), H-A-205, H-A-213
2026-11-21 01:07:18 +01:00
jschoubben 6d5000871d Indexer: the revision verb answers the newest kept revision from the store
The tools bundle answered the catalog seat's revision verb from its view of the
trunk in memory, which ran one or more revisions behind what the indexer kept
until it heard the event, so the runner and the builder waited on revisions the
bus held all along. The verb now reads which revision is newest from the store
at the time of the ask (a listing and one object) and takes the view's entries
only when the view holds that very revision.

Builds: design 47 H-A-222 (1), H-A-205, H-A-213
2026-11-21 01:05:55 +01:00
jschoubben 5c7648744d Indexer: read a takeins value's hand acts from TakeInAsk's tags, not a hand-kept list
indexer_take_in_again wrote TakeInAsk{Again} and DecodeTakeIn refused it: its
hand-kept list of act fields lacked Again, so the handler never reached its
Again branch. Every field of TakeInAsk now says by its tag takein whether it is
an act, an argument or of the ask; DecodeTakeIn reads the acts from the tags,
and a table test builds every hand tool's value by its own Run path, decodes it
and acts on it through takenIn, and refuses a field left unclassed.

Builds: design 47 H §774, H-A-208, H-A-210
2026-11-21 01:03:32 +01:00
6 changed files with 301 additions and 44 deletions
@@ -25,6 +25,12 @@ import (
// below the newest the picture holds, whose entries the picture no longer names, asks the catalog seat's verb revision for
// its catalog revision by number, once, and is built when that kept revision is of its source and names every entry it
// asks; it never waits, since the picture only moves on. Only a revision above the newest is waited for.
//
// **An ask naming a revision is held by its number** (design 47 H H-A-222): when the picture does not name the ask's
// entries, the ask's catalog revision is read by number, and the ask is built when the catalog keeps it and it names every
// fingerprint asked, whatever the source the picture holds says (a re-pin keeps a later revision of the same source, H-A-211,
// H-A-213, so the source alone cannot say it). The source is compared only for an ask naming no revision; an ask whose
// revision the catalog does not answer and whose source is not below the picture's waits as before.
// DefaultRevisionWait is the bound of a step ask's wait for its revision, its setting revision-wait-minutes' default (H-A-156).
const DefaultRevisionWait = 2 * time.Minute
@@ -73,10 +79,13 @@ func (b *Builder) holdsRevision(branch string, source int64, entries []meshbuild
return true
}
// keptRevisionHolds answers no outcome when the catalog keeps the ask's revision (its catalog revision by number, of its
// source revision) and that revision names every entry of the ask; else failed or could not run, with its words.
// keptRevisionHolds answers no outcome when the catalog keeps the ask's revision (its catalog revision by number) and that
// revision names every entry of the ask (H-A-205, H-A-222); else failed or could not run, with its words.
func (b *Builder) keptRevisionHolds(ctx context.Context, run meshbuilds.StepRun, held int64) (outcome, said string) {
below := fmt.Sprintf("revision %d of %s is below the %d the builder's picture holds", run.Source, run.Branch, held)
below := fmt.Sprintf("revision %d of %s is not named by the builder's picture, which holds source revision %d", run.Source, run.Branch, held)
if run.Source < held {
below = fmt.Sprintf("revision %d of %s is below the %d the builder's picture holds", run.Source, run.Branch, held)
}
if b.KeptRevision == nil || run.Revision <= 0 {
return meshbuilds.StepEndedOutcomeFailed, below + ", and the ask names no catalog revision to read it by"
}
@@ -85,11 +94,15 @@ func (b *Builder) keptRevisionHolds(ctx context.Context, run meshbuilds.StepRun,
b.logf("%s: %s, and the catalog's revision %d cannot be read: %v", run.Pipeline, below, run.Revision, err)
return meshbuilds.StepEndedOutcomeCouldNotRun, fmt.Sprintf("%s, and the catalog's revision %d cannot be read: %v", below, run.Revision, err)
}
// An ask names the revision and the source of one revision (H-A-218, H-A-219): a kept revision of another source is
// not the ask's.
if source != run.Source {
return meshbuilds.StepEndedOutcomeFailed, fmt.Sprintf("%s, and the catalog's revision %d is of source revision %d", below, run.Revision, source)
b.logf("%s: %s, and the catalog's revision %d is of source revision %d, the ask names %d: the step fails, nothing is built", run.Pipeline, below, run.Revision, source, run.Source)
return meshbuilds.StepEndedOutcomeFailed, fmt.Sprintf("%s, and the catalog's revision %d is of source revision %d, the ask names %d", below, run.Revision, source, run.Source)
}
for _, e := range run.Entries {
if fps[e.Module] != e.Fingerprint {
b.logf("%s: %s, and the catalog's revision %d names %s at %q, not %s: the step fails, nothing is built", run.Pipeline, below, run.Revision, e.Module, fps[e.Module], e.Fingerprint)
return meshbuilds.StepEndedOutcomeFailed, fmt.Sprintf("%s, and the catalog's revision %d names %s at %q, not %s", below, run.Revision, e.Module, fps[e.Module], e.Fingerprint)
}
}
@@ -116,8 +129,17 @@ func (b *Builder) awaitRevision(ctx context.Context, run meshbuilds.StepRun) (ou
if b.Picture == nil || run.Source <= 0 || run.Branch == "" {
return "", ""
}
if held, ok := b.Picture(run.Branch); ok && run.Source < held && !b.holdsRevision(run.Branch, run.Source, run.Entries) {
return b.keptRevisionHolds(ctx, run, held)
if held, ok := b.Picture(run.Branch); !b.holdsRevision(run.Branch, run.Source, run.Entries) {
below := ok && run.Source < held
if (run.Revision > 0 && b.KeptRevision != nil) || below {
// By its number (H-A-222), whatever the source the picture holds; for an ask naming none, only below the
// picture (H-A-205). A kept revision of another source or naming other fingerprints is a mismatch the wait
// cannot mend: it fails at once; only a revision the catalog does not answer is waited for.
outcome, said := b.keptRevisionHolds(ctx, run, held)
if outcome == "" || below || outcome == meshbuilds.StepEndedOutcomeFailed {
return outcome, said
}
}
}
bound := b.revisionWait()
notHeld := fmt.Sprintf("revision %d of %s not in the builder's picture", run.Source, run.Branch)
@@ -356,7 +356,7 @@ func aStepAskWaitsForItsRevision(t *testing.T) {
held.Store(40)
asked := make(chan struct{}, 1)
r, res, entry := revisionRig(t, &held, asked)
var keptReads atomic.Int64 // H-A-205: a revision above the newest is waited for, never read by number
var keptReads atomic.Int64 // H-A-205, H-A-222: a revision above the newest is read by number once; not answered, it is waited for
r.b.KeptRevision = func(context.Context, string, int64) (int64, map[string]string, error) {
keptReads.Add(1)
return 0, nil, errors.New("not asked")
@@ -385,8 +385,8 @@ func aStepAskWaitsForItsRevision(t *testing.T) {
t.Fatal("the ask was not woken by the entry the picture took in")
}
r.b.Wait()
if end.Outcome != meshbuilds.StepEndedOutcomePassed || len(res.sources) != 1 || res.sources[0].Revision != 41 || keptReads.Load() != 0 {
t.Errorf("end = %+v, reserved from %+v, kept revisions read %d; want passed with one version reserved from revision 41, none read", end, res.sources, keptReads.Load())
if end.Outcome != meshbuilds.StepEndedOutcomePassed || len(res.sources) != 1 || res.sources[0].Revision != 41 || keptReads.Load() != 1 {
t.Errorf("end = %+v, reserved from %+v, kept revisions read %d; want passed with one version reserved from revision 41, read by number once", end, res.sources, keptReads.Load())
}
}
@@ -425,6 +425,45 @@ func anOlderKeptRevisionIsReadByNumber(t *testing.T) {
if end := r2.b.BuildStep(t.Context(), run); end.Outcome != meshbuilds.StepEndedOutcomeFailed || !strings.Contains(end.Said, "names m at \"src2:other\"") {
t.Errorf("end = %+v; want failed naming the fingerprint the kept revision names", end)
}
// H-A-222: an ask of the very source the picture holds, whose entries the picture no longer names (a re-pin kept revision 48
// of the same source 46 and the picture took its entries in), is held by its revision read by number, never waited for.
r3, res3, _ := revisionRig(t, &held, make(chan struct{}, 1))
r3.b.RevisionWait = time.Nanosecond
r3.b.FirstBranch = func(branch, module string) bool { return branch == "main" && module == "m" }
var read3 []string
r3.b.KeptRevision = func(_ context.Context, branch string, revision int64) (int64, map[string]string, error) {
read3 = append(read3, fmt.Sprintf("%s %d", branch, revision))
return 46, map[string]string{"m": fp1}, nil
}
same := meshbuilds.StepRun{Pipeline: "main.48.m", Step: meshbuilds.StepRunStepBuild, Branch: "main", Revision: 48, Source: 46,
Entries: []meshbuilds.BuildEntry{{Module: "m", Fingerprint: fp1}}}
end3 := r3.b.BuildStep(t.Context(), same)
r3.b.Wait()
if end3.Outcome != meshbuilds.StepEndedOutcomePassed || !slices.Equal(read3, []string{"main 48"}) || len(res3.sources) != 1 || res3.sources[0].CatalogRevision != 48 {
t.Errorf("end = %+v, kept revisions read %v, reserved %+v; want passed, revision 48 of main read once and reserved at it", end3, read3, res3.sources)
}
// H-A-218, H-A-222: a kept revision of another source than the ask names, or naming another fingerprint, is a mismatch:
// the step fails at once naming it, never waiting out its bound (the bound here is long, the ask is not below the picture).
for _, c := range []struct {
name string
source int64
fp string
said string
}{
{"another source", 45, fp1, "the catalog's revision 48 is of source revision 45, the ask names 46"},
{"another fingerprint", 46, "src2:other", "names m at \"src2:other\""},
} {
rc, resc, _ := revisionRig(t, &held, make(chan struct{}, 1))
rc.b.RevisionWait = time.Hour
rc.b.KeptRevision = func(context.Context, string, int64) (int64, map[string]string, error) {
return c.source, map[string]string{"m": c.fp}, nil
}
end := rc.b.BuildStep(t.Context(), same)
rc.b.Wait()
if end.Outcome != meshbuilds.StepEndedOutcomeFailed || !strings.Contains(end.Said, c.said) || len(resc.sources) != 0 {
t.Errorf("%s: end = %+v, reserved %+v; want failed at once saying %q, nothing reserved", c.name, end, resc.sources, c.said)
}
}
}
func aStepAskPastItsRevisionBoundFails(t *testing.T) {
@@ -0,0 +1,147 @@
package main
import (
"context"
"encoding/json"
"reflect"
"slices"
"strings"
"testing"
"time"
"github.com/nats-io/nats.go/jetstream"
"mesh-delivery-indexer/internal/index"
)
// askedBy is a takerIn that names the hand act it was asked.
type askedBy struct{ asked []string }
func (s *askedBy) did(act string) index.TakenIn {
s.asked = append(s.asked, act)
return index.TakenIn{Module: "m", Stored: true, Answer: act}
}
func (s *askedBy) SeatDefinitionsAgain(context.Context, string) index.TakenIn {
return s.did("seat-definitions")
}
func (s *askedBy) FingerprintsAgain(context.Context, string) index.TakenIn {
return s.did("fingerprints")
}
func (s *askedBy) RecomputeByHand(context.Context, string, string) index.TakenIn {
return s.did("recompute")
}
func (s *askedBy) DropCandidateGraph(context.Context, string, string, string, string) index.TakenIn {
return s.did("candidate-group")
}
func (s *askedBy) NamedDrop(context.Context, string, string, string, string) index.TakenIn {
return s.did("named-fingerprint")
}
func (s *askedBy) PinDrop(context.Context, string, string, string) index.TakenIn {
return s.did("pin-drop")
}
func (s *askedBy) DropRunByHand(context.Context, string, string, string) index.TakenIn {
return s.did("run-drop")
}
func (s *askedBy) RegistryAct(context.Context, index.TakeInAsk) index.TakenIn {
return s.did("registry")
}
func (s *askedBy) HeldAgain(context.Context, string) index.TakenIn { return s.did("held") }
func (s *askedBy) HeldSkip(context.Context, string, int64, string, string) index.TakenIn {
return s.did("held-skip")
}
func (s *askedBy) TakeInAgain(context.Context, string) index.TakenIn { return s.did("again") }
// answeredKV keeps the answer takenIn writes back.
type answeredKV struct {
jetstream.KeyValue
written []byte
}
func (k *answeredKV) Update(_ context.Context, _ string, value []byte, _ uint64) (uint64, error) {
k.written = value
return 2, nil
}
type askEntry struct {
jetstream.KeyValueEntry
key string
value []byte
}
func (e askEntry) Key() string { return e.key }
func (e askEntry) Value() []byte { return e.value }
func (e askEntry) Revision() uint64 { return 1 }
func (e askEntry) Operation() jetstream.KeyValueOp { return jetstream.KeyValuePut }
// Design 47 H-A-208, H-A-210, H §774: every hand tool's takeins value, built by the tool's own Run path (or the constructor it
// calls), is read by DecodeTakeIn and acted on by takenIn as the act it names; indexer_take_in_again's was refused, its Again
// missing from a hand-kept list. Every field of TakeInAsk says by its tag whether it is an act, so an act added is read.
func TestEveryHandToolsAskIsReadAndActedOn(t *testing.T) {
t.Run("every field is classed", func(t *testing.T) {
ty := reflect.TypeFor[index.TakeInAsk]()
for i := range ty.NumField() {
if c := ty.Field(i).Tag.Get("takein"); !slices.Contains([]string{"act", "argument", "ask"}, c) {
t.Errorf("TakeInAsk.%s has takein %q, want act, argument or ask", ty.Field(i).Name, c)
}
}
})
var values [][]byte
ask := func(_ string, value []byte) (index.TakeInAsk, error) {
values = append(values, value)
return index.TakeInAsk{V: 1, Result: &index.TakenIn{Stored: true}, Answered: time.Now()}, nil
}
record := func(string, string) error { return nil }
tools := map[string]func(map[string]any) (any, error){}
for _, tl := range slices.Concat(index.HeldTools(nil, ask, time.Now, record), index.PinsTools(nil, nil, ask, time.Now, record),
index.RunsTools(nil, nil, ask, time.Now, record), index.NamedTools(ask, time.Now, record),
index.FingerprintsTools(ask, time.Now, record, time.Minute), index.CatalogRevisionTools(nil, ask, time.Now, record),
index.RegistrationTools(nil, nil, ask, time.Now, func(string, string, string, string) error { return nil })) {
tools[tl.Name] = tl.Run
}
tools[index.SeatDefinitionsAgainTool] = func(args map[string]any) (any, error) { // its tool lives in the tools bundle
_, value, err := index.NewSeatDefinitionsAgain(args["module"].(string), "why", "by", time.Now())
values = append(values, value)
return nil, err
}
for _, c := range []struct {
tool string
args map[string]any
act string
}{
{index.TakeInAgainTool, map[string]any{"repository": "novox/mesh-host", "why": "rule changed"}, "again"},
{index.TakeInPendingTool, map[string]any{"branch": "main"}, "held"},
{index.TakeInSkipTool, map[string]any{"branch": "main", "source": float64(4), "why": "stale"}, "held-skip"},
{index.PinDropTool, map[string]any{"key": "main.7", "why": "no pipeline"}, "pin-drop"},
{index.RunDropTool, map[string]any{"run": "run-12", "why": "never ends"}, "run-drop"},
{index.NamedDropTool, map[string]any{"fingerprint": "abc", "member": "ace.feh", "why": "gone"}, "named-fingerprint"},
{index.FingerprintsAgainTool, map[string]any{"module": "feh", "why": "unread packages"}, "fingerprints"},
{index.RecomputeTool, map[string]any{"why": "check"}, "recompute"},
{index.DropCandidateGraphTool, map[string]any{"group": "g", "heads": "h", "why": "no gate event"}, "candidate-group"},
{index.SeedAgainTool, map[string]any{"why": "empty"}, "registry"},
{index.SeatDefinitionsAgainTool, map[string]any{"module": "mesh-contracts"}, "seat-definitions"},
} {
t.Run(c.tool, func(t *testing.T) {
run, ok := tools[c.tool]
if !ok {
t.Fatalf("no tool %s", c.tool)
}
values = nil
if _, err := run(c.args); err != nil || len(values) != 1 {
t.Fatalf("%s wrote %d values (%v)", c.tool, len(values), err)
}
if _, err := index.DecodeTakeIn(values[0]); err != nil {
t.Fatalf("DecodeTakeIn refuses %s: %v", values[0], err)
}
ix, kv := &askedBy{}, &answeredKV{}
var said []string
takenIn(t.Context(), ix, kv, askEntry{key: "k", value: values[0]}, func(f string, a ...any) { said = append(said, f) })
if !slices.Equal(ix.asked, []string{c.act}) {
t.Errorf("takenIn asked %v of %s, want %s (said %s)", ix.asked, values[0], c.act, strings.Join(said, "; "))
}
var answered index.TakeInAsk
if err := json.Unmarshal(kv.written, &answered); err != nil || !answered.Done() {
t.Errorf("takenIn wrote back %s (%v), want the answered ask", kv.written, err)
}
})
}
}
@@ -93,16 +93,20 @@ func TestTheKeptTrunkIsReadAtTheStartAndOncePerHeardRevision(t *testing.T) {
if e, ok, err := modules.Get("ca-trust"); err != nil || !ok || e.Revision != 2 {
t.Errorf("after the event ca-trust = %+v %v (%v), want it at revision 2", e, ok, err)
}
// A-487c: the manifests by digest and the verb revision asked of the trunk's newest answer from the view held.
// A-487c: the manifests by digest answer from the view held; the verb revision asked of the trunk's newest lists the bucket
// once for which revision is newest (H-A-222) and takes the entries of the view held at that very revision.
listed = objects.n.Load()
if raw, err := kept.Manifest(meshcatalogclient.BareManifestDigest(keptDigest("ca-trust"))); err != nil || raw != `{"module":"ca-trust"}` {
t.Errorf("the held manifest = %q (%v), want the entry's manifest", raw, err)
}
if got := objects.n.Load() - listed; got != 0 {
t.Errorf("the manifest listed the bucket %d times, want none", got)
}
if a, err := Revision(context.Background(), objects, kept, meshcatalog.RevisionInput{}); err != nil || a.Revision.Revision != 2 || len(a.Entries) != 2 {
t.Errorf("revision of the newest answered %+v (%v), want revision 2 whole", a, err)
}
if got := objects.n.Load() - listed; got != 0 {
t.Errorf("the manifest and the verb revision listed the bucket %d times, want none", got)
if got := objects.n.Load() - listed; got != 1 {
t.Errorf("the verb revision listed the bucket %d times, want once, for the newest", got)
}
if len(said) != 2 || !strings.Contains(said[1], "read revision 2 (was 1), 2 modules, in ") {
t.Errorf("said %q, want each read with its revision, module count and time", said)
@@ -126,6 +130,16 @@ func TestTheKeptTrunkIsReadAtTheStartAndOncePerHeardRevision(t *testing.T) {
if keys, _ := modules.Keys(); len(keys) != 3 {
t.Errorf("the next heard event left the view at %v, want revision 3's three modules", keys)
}
// H-A-222: two revisions kept that the view has not heard are answered by the verb revision from the store, whole; the
// view held stays a cache at its own revision.
keep(4, "avahi", "ca-trust", "dbus")
keep(5, "avahi", "ca-trust", "dbus", "feh")
if a, err := Revision(context.Background(), objects, kept, meshcatalog.RevisionInput{}); err != nil || a.Revision == nil || a.Revision.Revision != 5 || len(a.Entries) != 4 {
t.Errorf("revision of the newest answered %+v (%v) while the view held 3, want revision 5 whole from the store", a, err)
}
if keys, _ := modules.Keys(); len(keys) != 3 {
t.Errorf("the verb moved the view held to %v, want it at revision 3 until it hears the event", keys)
}
}
// A-487: the verb module reads the one module it is asked.
@@ -23,17 +23,22 @@ const RevisionInvoke = "seat:" + meshcatalog.Seat + "." + meshcatalog.VerbRevisi
// H-A-66: every account may call every verb). With no trunk revision kept yet the answer is `none-yet` alone (design 47 G §530), never an empty
// catalog and never an error.
//
// kept, when not nil, is the trunk's newest revision held in memory: the trunk's newest answers from it with no read of
// the bucket (A-487c); a candidate, a branch and an older number read the bucket.
// The trunk's newest is the newest the bucket keeps at the time of the ask, read from the store (a listing of the names and
// one object, design 47 H-A-222), never the view held in memory, which runs behind until it hears the revision. kept, when
// not nil, is that view: a cache of the entries only, used when it holds the very revision read; else the entries are read
// from the bucket. A candidate, a branch and an older number read the bucket.
func Revision(ctx context.Context, o Objects, kept *KeptTrunk, in meshcatalog.RevisionInput) (meshcatalog.RevisionAnswer, error) {
var out meshcatalog.RevisionAnswer
var newest meshcatalog.CatalogRevision
var ok bool
var trunkEntries, branchEntries []meshcatalog.CatalogEntry
var err error
if kept != nil {
newest, trunkEntries, ok, err = kept.Newest(ctx, o)
} else {
newest, ok, err := newestOf(ctx, o, TrunkBranch)
cached := false
if err == nil && ok && kept != nil {
if held, entries, any, kerr := kept.Newest(ctx, o); kerr == nil && any && held.Revision == newest.Revision {
trunkEntries, cached = entries, true
}
}
if !cached && (err != nil || ok) {
// readNewestOf reads the entries whole, and the newest again when the pin judge removed one under the read.
newest, trunkEntries, ok, err = readNewestOf(ctx, o, TrunkBranch)
}
if err != nil {
@@ -4,6 +4,8 @@ import (
"encoding/json"
"errors"
"fmt"
"reflect"
"strings"
"time"
)
@@ -18,45 +20,48 @@ const (
)
// TakeInAsk is a value of the takeins state: which hand act a person asked, why, who and when, and, once the indexer read
// it, its answer.
// it, its answer. Every field says by its tag takein what it is: an act (a field that alone names a hand act the indexer
// serves), an argument of an act, or of the ask itself (version, who, why, when, the answer); DecodeTakeIn reads the acts
// from these tags, so a hand act added here is read the moment its field is (H-A-208, H-A-210: indexer_take_in_again's
// Again was refused by a hand-kept list).
type TakeInAsk struct {
V int `json:"v"`
Module string `json:"module,omitempty"`
Why string `json:"why,omitempty"`
V int `json:"v" takein:"ask"`
Module string `json:"module,omitempty" takein:"argument"`
Why string `json:"why,omitempty" takein:"ask"`
// SeatDefinitions asks a contracts module's trunk seat definitions to be read again now (indexer_seat_definitions_again,
// DLV-I19).
SeatDefinitions bool `json:"seat-definitions,omitempty"`
SeatDefinitions bool `json:"seat-definitions,omitempty" takein:"act"`
// Fingerprints asks the fingerprints of Module ("all": every module) to be computed again now, from the published
// packages as they are read (indexer_fingerprints_again, fingerprints.go).
Fingerprints bool `json:"fingerprints,omitempty"`
Fingerprints bool `json:"fingerprints,omitempty" takein:"act"`
// Recompute asks the catalog graph to be computed again now and compared with the newest kept revision (indexer_recompute).
Recompute bool `json:"recompute,omitempty"`
Recompute bool `json:"recompute,omitempty" takein:"act"`
// CandidateGroup and CandidateHeads, with Drop, ask that candidate's catalog half to be dropped (indexer_drop_candidate_graph).
CandidateGroup string `json:"candidate-group,omitempty"`
CandidateHeads string `json:"candidate-heads,omitempty"`
Drop bool `json:"drop,omitempty"`
CandidateGroup string `json:"candidate-group,omitempty" takein:"act"`
CandidateHeads string `json:"candidate-heads,omitempty" takein:"argument"`
Drop bool `json:"drop,omitempty" takein:"argument"`
// NamedFingerprint and NamedMember, with Drop, ask one member to be removed from that fingerprint's set of the state named
// (indexer_named_drop, named.go, design 47 G §675).
NamedFingerprint string `json:"named-fingerprint,omitempty"`
NamedFingerprint string `json:"named-fingerprint,omitempty" takein:"act"`
// PinDrop asks one pin of the state pins, by its key, to be dropped (indexer_pin_drop, design 47 H §765).
PinDrop string `json:"pin-drop,omitempty"`
PinDrop string `json:"pin-drop,omitempty" takein:"act"`
// Held names the watched branch whose held source-moved is taken in again now (indexer_take_in_pending) or, with Skip and
// HeldSource, ended unwritten (indexer_take_in_skip; design 47 H §744).
Held string `json:"held,omitempty"`
HeldSource int64 `json:"held-source,omitempty"`
Skip bool `json:"skip,omitempty"`
NamedMember string `json:"named-member,omitempty"`
Held string `json:"held,omitempty" takein:"act"`
HeldSource int64 `json:"held-source,omitempty" takein:"argument"`
Skip bool `json:"skip,omitempty" takein:"argument"`
NamedMember string `json:"named-member,omitempty" takein:"argument"`
// Again names the repository taken in again at its kept merge commit (indexer_take_in_again, take_in_again.go; H-A-208, H-A-210).
Again string `json:"again,omitempty"`
Again string `json:"again,omitempty" takein:"act"`
// RunDrop asks one run on request, by its group run-<id>, to be dropped with its candidate (indexer_run_drop, runs_tools.go, A-194).
RunDrop string `json:"run-drop,omitempty"`
RunDrop string `json:"run-drop,omitempty" takein:"act"`
// Registry asks one of the registrations' acts (registrations.go): a trusted change of one, the verb registrations,
// indexer_proposal_drop or indexer_seed_again (design 47 G §3, §4, §8, §667).
Registry *RegistryAct `json:"registry,omitempty"`
By string `json:"by,omitempty"`
At time.Time `json:"at"`
Result *TakenIn `json:"result,omitempty"`
Answered time.Time `json:"answered,omitzero"`
Registry *RegistryAct `json:"registry,omitempty" takein:"act"`
By string `json:"by,omitempty" takein:"ask"`
At time.Time `json:"at" takein:"ask"`
Result *TakenIn `json:"result,omitempty" takein:"ask"`
Answered time.Time `json:"answered,omitzero" takein:"ask"`
}
// Done says the ask is answered.
@@ -71,8 +76,33 @@ func DecodeTakeIn(data []byte) (TakeInAsk, error) {
if a.V != 1 {
return a, fmt.Errorf("a takeins value of version %d, not 1", a.V)
}
if a.Module == "" && !a.Fingerprints && !a.Recompute && a.CandidateGroup == "" && a.NamedFingerprint == "" && a.PinDrop == "" && a.Held == "" && a.RunDrop == "" && a.Registry == nil {
if len(a.Acts()) == 0 {
return a, errors.New("a takeins value naming no hand act the indexer serves")
}
return a, nil
}
// takeInActs are the indices of TakeInAsk's fields tagged takein:"act".
var takeInActs = func() []int {
var out []int
t := reflect.TypeFor[TakeInAsk]()
for i := range t.NumField() {
if t.Field(i).Tag.Get("takein") == "act" {
out = append(out, i)
}
}
return out
}()
// Acts names the hand acts the ask names, by their json names: its fields tagged takein:"act" that are set.
func (a TakeInAsk) Acts() []string {
var out []string
v := reflect.ValueOf(a)
for _, i := range takeInActs {
if !v.Field(i).IsZero() {
name, _, _ := strings.Cut(v.Type().Field(i).Tag.Get("json"), ",")
out = append(out, name)
}
}
return out
}