Compare commits
30
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
247d89e152 | ||
|
|
7ade318cfa | ||
|
|
7e96d61268 | ||
|
|
9d43fa4b24 | ||
|
|
cd3ef2fd41 | ||
|
|
b75481733b | ||
|
|
282758456c | ||
|
|
0e9f916806 | ||
|
|
daa5d3ea5f | ||
|
|
be993cb2c5 | ||
|
|
cd3b8fe8e9 | ||
|
|
f0c21ca033 | ||
|
|
c6ec42bc2e | ||
|
|
f65d789052 | ||
|
|
62b8251b99 | ||
|
|
90c88fc7b5 | ||
|
|
740c218139 | ||
|
|
1481465ec7 | ||
|
|
d2b8f64c94 | ||
|
|
eed95cd63b | ||
|
|
84106a9338 | ||
|
|
9ed13cd9dc | ||
|
|
d76c3588e3 | ||
|
|
377d42f5ea | ||
|
|
9ade421e12 | ||
|
|
46f3dc8cd7 | ||
|
|
7da6dd20a1 | ||
|
|
c87cf1ace5 | ||
|
|
3f3f6789dd | ||
|
|
7c6aed9d69 |
@@ -1,6 +1,6 @@
|
||||
#!/bin/sh
|
||||
# The wallpaper (module feh, novox/hq ADR 0208). Owned by the mesh: replaced at every push. The
|
||||
# The wallpaper (module feh, novox/hq ADR 0208). Owned by the mesh: replaced at every delivery. The
|
||||
# session's start runs it, and so may anything that wants the declared wallpaper back. The image is
|
||||
# the module's own, in ~/.local/share/feh/wallpapers. feh_set changes the wallpaper for a session
|
||||
# without touching this file.
|
||||
# without touching this file (the second single-module proof, 2026-11-17).
|
||||
feh --no-fehbg --bg-fill "$HOME/.local/share/feh/wallpapers/default.jpg"
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
// Package buildstep is kept empty as a bridge: the running pre-G indexer publishes mesh-catalog's packages only while
|
||||
// every package directory it published before is in the tree. It goes once G's indexer runs.
|
||||
package buildstep
|
||||
@@ -58,6 +58,7 @@ func main() {
|
||||
// compiles that program and runs it shut off, answers its mark judged by the candidate at the tree's commit, and the
|
||||
// program reached no key, no login, no name and no socket of the machine.
|
||||
func TestTheUnitLevelUnderTheWorkspaceRunnerRunsTheTreesProgramShutOff(t *testing.T) {
|
||||
t.Parallel()
|
||||
needTools(t, "the candidate's program shut off", "go", "git", "bwrap")
|
||||
home := t.TempDir()
|
||||
key, login := filepath.Join(home, ".ssh", "mesh_ed25519"), filepath.Join(home, "broker")
|
||||
|
||||
@@ -195,6 +195,7 @@ func TestACandidateThatDoesNotCompileFailsTheStepWithTheCompilersFirstErrorAndRu
|
||||
}
|
||||
|
||||
func TestTheInstalledProgramSaysItJudged(t *testing.T) { // 1898 K1, ADR 0535 §5
|
||||
t.Parallel()
|
||||
m, states, ws, _ := workspaceFor(t, "slow")
|
||||
for _, runner := range []any{nil, RunnerInstalled} {
|
||||
args := map[string]any{"workspace": ws, "level": LevelUnit}
|
||||
@@ -223,6 +224,7 @@ func TestAnUnknownRunnerIsRefused(t *testing.T) { // 1898 K1
|
||||
}
|
||||
|
||||
func TestTheShutOffProcessRunsTheStepItIsAsked(t *testing.T) { // 1898 K2: the candidate's side of the spec
|
||||
t.Parallel()
|
||||
m, _, ws, calls := workspaceFor(t, "slow")
|
||||
m.Inside = true
|
||||
a := m.answer(context.Background(), levelSpec{Step: stepUnit, Workspace: ws, Packages: []string{"./..."}, Bound: UnitBound})
|
||||
|
||||
@@ -24,70 +24,7 @@ import (
|
||||
"git.novox.be/novox/mesh-sdk/go/testbus"
|
||||
)
|
||||
|
||||
// nodeEngineTree is the node-engine's repository as the checker places it beside this check (MESH_CHECK_BESIDE, the
|
||||
// repository mesh-host), and with it every Go module of the other repositories placed there (mesh-sdk, mesh-contracts,
|
||||
// mesh-delivery, mesh-networking, the catalogue's trunk) and of the catalogue under check, first, as candidates: the workspace lays those the
|
||||
// node-engine's composer requires at the zero version, transitively (workspaceOf), so they resolve as the group lays
|
||||
// them, wherever the composer lives. The test
|
||||
// builds the node-engine's real composer command from that tree; it does not stand one in. With no beside directory it
|
||||
// fails, and with the node-engine beside but no composer command in it it fails: a composer test that could not build its
|
||||
// composer proves nothing. With a beside directory that holds no node-engine at all it skips aloud (NOT JUDGED), since a
|
||||
// checker from before this release places none for the catalogue.
|
||||
func nodeEngineTree(t *testing.T) (tree string, modules []string) {
|
||||
t.Helper()
|
||||
beside := os.Getenv("MESH_CHECK_BESIDE")
|
||||
if beside == "" {
|
||||
t.Fatal("NOT CHECKED: MESH_CHECK_BESIDE is not set, so the node-engine's repository (mesh-host) is not beside this check")
|
||||
}
|
||||
tree = filepath.Join(beside, "mesh-host")
|
||||
if !dirExists(tree) {
|
||||
// A checker from before novox/hq ADR 0593 places only mesh-sdk beside a catalogue check, so the node-engine's
|
||||
// repository is absent, not wrong: said aloud, since nothing here could build a composer to judge.
|
||||
t.Skipf("NOT JUDGED: the node-engine's repository (mesh-host) is not beside this check in MESH_CHECK_BESIDE=%s; the running checker places none for the catalogue, so the composer is judged only once it does", beside)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(tree, "cmd", "mesh-compose")); err != nil {
|
||||
t.Fatalf("NOT CHECKED: the node-engine's composer command is not beside this check in MESH_CHECK_BESIDE=%s: %v", beside, err)
|
||||
}
|
||||
entries, err := os.ReadDir(beside)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var roots []string
|
||||
for _, e := range entries {
|
||||
if e.Name() == "mesh-host" || !dirExists(filepath.Join(beside, e.Name())) {
|
||||
continue
|
||||
}
|
||||
root, err := filepath.EvalSymlinks(filepath.Join(beside, e.Name()))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
roots = append(roots, root)
|
||||
}
|
||||
// The catalogue under check, first: beside lies its trunk (issue 1295), whose modules a head's must win over.
|
||||
catalogue, err := filepath.Abs(filepath.Join("..", "..", "..", ".."))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, root := range append([]string{catalogue}, roots...) {
|
||||
filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
if d.IsDir() && (d.Name() == ".git" || d.Name() == "testdata" || d.Name() == "node_modules") {
|
||||
return filepath.SkipDir
|
||||
}
|
||||
if !d.IsDir() && d.Name() == "go.mod" {
|
||||
modules = append(modules, filepath.Dir(p))
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
return tree, modules
|
||||
}
|
||||
|
||||
func dirExists(p string) bool { st, err := os.Stat(p); return err == nil && st.IsDir() }
|
||||
|
||||
// copyTree copies the files of a source tree into dst, leaving out its .git.
|
||||
// copyHostTree copies the files of a source tree into dst, leaving out its .git.
|
||||
func copyHostTree(t *testing.T, src, dst string) {
|
||||
t.Helper()
|
||||
src, err := filepath.EvalSymlinks(src)
|
||||
@@ -130,7 +67,7 @@ func goEnvOf(t *testing.T, name string) string {
|
||||
}
|
||||
|
||||
// 1622/AC1, AC3 against the real bus (ADR 0593 §7, C9): a compose ask put on the Go build seat's check stream is pulled by
|
||||
// the module started whole on that bus, which fetches the commit (the node-engine's repository beside the check, its Go module at the root), builds the composer command the ask names there with nothing fetched, fills the
|
||||
// the module started whole on that bus, which fetches the commit (a stand-in composer of this module's testdata, its Go module at the root), builds the composer command the ask names there with nothing fetched, fills the
|
||||
// request's manifests from the indexer's state and runs the composer; the step key <node>.<ask id> passes with the
|
||||
// composer's verdict. A second ask of the same commit runs the kept composer: fetched and built once.
|
||||
func TestAComposeAskIsBuiltOnceAndAnsweredOnTheBus(t *testing.T) {
|
||||
@@ -157,14 +94,11 @@ func TestAComposeAskIsBuiltOnceAndAnsweredOnTheBus(t *testing.T) {
|
||||
m.Run = StepRunner(t.TempDir())
|
||||
m.GoModCache = goEnvOf(t, "GOMODCACHE") // the module cache this module's own build filled, read and not fetched
|
||||
run, gocache := m.Run, goEnvOf(t, "GOCACHE") // this machine's build cache, so the composer's packages compile once
|
||||
hostTree, beside := nodeEngineTree(t)
|
||||
workFile := ""
|
||||
// The composer is a stand-in of this module's own testdata (design 47 G A-474: a module's tests read nothing outside it, and a
|
||||
// pipeline's step places no other repository beside the tree): a program of the composer's contract that imports nothing.
|
||||
hostTree := filepath.Join("testdata", "composer")
|
||||
m.Run = func(ctx context.Context, env []string, name string, args ...string) forgekey.Ran {
|
||||
env = append(env, "GOCACHE="+gocache)
|
||||
if workFile != "" {
|
||||
env = append(env, "GOWORK="+workFile, "GOFLAGS=-mod=readonly") // a workspace takes no -mod=mod
|
||||
}
|
||||
return run(ctx, env, name, args...)
|
||||
return run(ctx, append(env, "GOCACHE="+gocache), name, args...)
|
||||
}
|
||||
read, digests := catalogHolds(t, `{"module":"demo","version":"1"}`)
|
||||
m.ReadEntry = read
|
||||
@@ -181,18 +115,6 @@ func TestAComposeAskIsBuiltOnceAndAnsweredOnTheBus(t *testing.T) {
|
||||
return nil, err
|
||||
}
|
||||
copyHostTree(t, hostTree, tree)
|
||||
if len(beside) > 0 { // the group's other repositories, laid beside the node-engine's tree as one workspace
|
||||
work, err := workspaceOf(tree, beside)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(m.Work, ws, "go.work"), []byte(work), 0o600); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
workFile = filepath.Join(m.Work, ws, "go.work")
|
||||
// Nothing is downloaded here: this level has no network. The check's own fetch downloaded this workspace's
|
||||
// graph (downloadBeside), and a module it lacks fails the build naming it.
|
||||
}
|
||||
return map[string]any{"workspace": ws}, nil
|
||||
}
|
||||
}
|
||||
@@ -203,7 +125,7 @@ func TestAComposeAskIsBuiltOnceAndAnsweredOnTheBus(t *testing.T) {
|
||||
|
||||
ask := func() sdkstep.Step {
|
||||
a := composeAskOf(t, digests[0])
|
||||
a.Compose.Fetch.Repository, a.Compose.Dir, a.Compose.Package = "novox/mesh-host", catalogclient.RootPath, "github.com/novox/mesh-host/cmd/mesh-compose"
|
||||
a.Compose.Fetch.Repository, a.Compose.Dir, a.Compose.Package = "novox/mesh-catalog", catalogclient.RootPath, "standin/cmd/mesh-compose"
|
||||
raw, err := sdkstep.EncodeStepAsk(a)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
|
||||
@@ -273,6 +273,7 @@ func TestAPackageWithTheReadsOutsideMarkerIsKeptOnlyByWhatItLists(t *testing.T)
|
||||
}
|
||||
edit(t, tree, "docs/one.md", "one\n")
|
||||
edit(t, tree, "other.md", "other\n")
|
||||
// Each marker is judged in a fixture of its own, side by side: the digests are go commands, and the table is the test's longest part.
|
||||
for name, marker := range map[string]string{
|
||||
"an empty marker": "# nothing listed\n\n",
|
||||
"a sentence": "the tests read ../docs\n",
|
||||
@@ -282,19 +283,44 @@ func TestAPackageWithTheReadsOutsideMarkerIsKeptOnlyByWhatItLists(t *testing.T)
|
||||
"a path that is not clean": "docs/./one.md\n",
|
||||
"a good line and a bad line": "docs\nnope/*.md\n",
|
||||
} {
|
||||
edit(t, tree, "c/"+ReadsOutsideMarker, marker)
|
||||
first, second := digests(t, m, "unit"), digests(t, m, "unit")
|
||||
if len(first.Packages[c]) != 64 || first.Packages[c] == second.Packages[c] || first.Packages[c] == plain.Packages[c] {
|
||||
t.Errorf("%s: c's digest is stable: %s, %s, before %s", name, first.Packages[c], second.Packages[c], plain.Packages[c])
|
||||
}
|
||||
if strings.Join(first.ReadsOutside, ",") != c {
|
||||
t.Errorf("%s: the answer does not name the package that reads outside: %v", name, first.ReadsOutside)
|
||||
}
|
||||
if first.Packages[a] != plain.Packages[a] || first.Packages[a] != second.Packages[a] {
|
||||
t.Errorf("%s: a has no marker and its digest moved: %s, %s, before %s", name, first.Packages[a], second.Packages[a], plain.Packages[a])
|
||||
}
|
||||
t.Run(name, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
m, tree := digestFixture(t)
|
||||
plain := digests(t, m, "unit")
|
||||
if err := os.MkdirAll(filepath.Join(tree, "docs"), 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
edit(t, tree, "docs/one.md", "one\n")
|
||||
edit(t, tree, "other.md", "other\n")
|
||||
edit(t, tree, "c/"+ReadsOutsideMarker, marker)
|
||||
first, second := digests(t, m, "unit"), digests(t, m, "unit")
|
||||
if len(first.Packages[c]) != 64 || first.Packages[c] == second.Packages[c] || first.Packages[c] == plain.Packages[c] {
|
||||
t.Errorf("%s: c's digest is stable: %s, %s, before %s", name, first.Packages[c], second.Packages[c], plain.Packages[c])
|
||||
}
|
||||
if strings.Join(first.ReadsOutside, ",") != c {
|
||||
t.Errorf("%s: the answer does not name the package that reads outside: %v", name, first.ReadsOutside)
|
||||
}
|
||||
if first.Packages[a] != plain.Packages[a] || first.Packages[a] != second.Packages[a] {
|
||||
t.Errorf("%s: a has no marker and its digest moved: %s, %s, before %s", name, first.Packages[a], second.Packages[a], plain.Packages[a])
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// The marker that lists what the package's tests read, and the marker of what the package needs (issue 890/AC3): in a fixture of its
|
||||
// own, so it runs beside the table above.
|
||||
func TestAListedReadsOutsideMarkerKeepsTheDigestOfOnlyWhatItLists(t *testing.T) {
|
||||
t.Parallel()
|
||||
m, tree := digestFixture(t)
|
||||
plain := digests(t, m, "unit")
|
||||
c, a := "fixture/digest/c", "fixture/digest/a"
|
||||
if err := os.MkdirAll(filepath.Join(tree, "docs"), 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
edit(t, tree, "docs/one.md", "one\n")
|
||||
edit(t, tree, "other.md", "other\n")
|
||||
|
||||
// A list: a glob, a directory read whole, and a path whose absence is read.
|
||||
edit(t, tree, "c/"+ReadsOutsideMarker, "# what c's tests read\ndocs/*.md\ndocs\n?gone\n")
|
||||
before := digests(t, m, "unit")
|
||||
|
||||
@@ -34,7 +34,7 @@ func TestTheGuardSaysToolchainReportedOnAChangeWithTheProgramDigest(t *testing.T
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(got) != 1 || got[0].subject != "mesh.seat.node-build-go.event.toolchain-reported.ace" || got[0].body["node"] != "ace" || got[0].body["language"] != "go" ||
|
||||
got[0].body["version"] != "go1.27.1" || got[0].body["recipe"] != m.Recipe.Version() || len(got[0].body["digest"]) != len("sha256:")+64 {
|
||||
got[0].body["version"] != "go1.27" || got[0].body["recipe"] != m.Recipe.Version() || len(got[0].body["digest"]) != len("sha256:")+64 {
|
||||
t.Fatalf("events = %+v, want one toolchain-reported for ace, go with the program's digest", got)
|
||||
}
|
||||
if tc, _ := states.toolchain("ace.go"); tc.Digest != got[0].body["digest"] {
|
||||
@@ -51,7 +51,7 @@ func TestTheGuardSaysToolchainReportedOnAChangeWithTheProgramDigest(t *testing.T
|
||||
os.WriteFile(prog, []byte("another go program"), 0o755)
|
||||
m.Probe = func(context.Context) (string, error) { return "go1.27.2", nil }
|
||||
m.Check(context.Background())
|
||||
if len(got) != 2 || got[1].body["version"] != "go1.27.2" || got[1].body["digest"] == got[0].body["digest"] {
|
||||
if len(got) != 2 || got[1].body["version"] != "go1.27" || got[1].body["digest"] == got[0].body["digest"] {
|
||||
t.Errorf("a new version said %+v, want a second event with another digest", got)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -149,8 +149,8 @@ func TestAnyInstalledGoIsHealthyNamedAndReported(t *testing.T) {
|
||||
t.Errorf("health = %+v, want healthy naming %s", a, installed)
|
||||
}
|
||||
tc, ok := states.toolchain("ace.go")
|
||||
if !ok || tc.Version != installed || tc.Recipe != m.Recipe.Version() {
|
||||
t.Errorf("ace.go = %+v, %v; want version %s and recipe %s", tc, ok, installed, m.Recipe.Version())
|
||||
if !ok || tc.Version != sdkstep.LanguageVersion(installed) || tc.Recipe != m.Recipe.Version() {
|
||||
t.Errorf("ace.go = %+v, %v; want version %s and recipe %s", tc, ok, sdkstep.LanguageVersion(installed), m.Recipe.Version())
|
||||
}
|
||||
ran := false
|
||||
run := func(context.Context, map[string]any) (any, error) { ran = true; return "done", nil }
|
||||
|
||||
@@ -186,6 +186,7 @@ func TestABuildRunsShutOffAndOnlyATrunkBuildWritesTheCaches(t *testing.T) {
|
||||
|
||||
// 1309-S3: the digest's go list runs shut off.
|
||||
func TestTheDigestListsPackagesShutOff(t *testing.T) {
|
||||
t.Parallel()
|
||||
m, _ := digestFixture(t)
|
||||
var seen []shutOff
|
||||
m.Run = throughBubblewrap(t, m.Run, &seen)
|
||||
|
||||
@@ -15,6 +15,7 @@ import (
|
||||
// resolves no name, reaches no socket of the machine (a TCP port on its loopback, a unix socket) and leaves the shared
|
||||
// caches unchanged. The probe is testdata/repos/probe.
|
||||
func TestARunStepReachesNoKeyLoginNameOrSocketAndLeavesTheCachesUnchanged(t *testing.T) {
|
||||
t.Parallel()
|
||||
needTools(t, "the shut-off unit level", "go", "git", "bwrap")
|
||||
tree := repository(t, "probe")
|
||||
work, err := os.MkdirTemp("", "w")
|
||||
|
||||
@@ -195,6 +195,16 @@ func TestTheModuleInvokesTheArtifactSeatsVerbsAndWritesNoStore(t *testing.T) {
|
||||
if !slices.Contains(m.Consumes, "mesh-conditions.findings-asked") {
|
||||
t.Errorf("consumes %v lack mesh-conditions.findings-asked", m.Consumes)
|
||||
}
|
||||
// Design 47 G A-488a, A-488b: its runtime follows the seat list, so the module consumes the seat's two events (which makes its
|
||||
// durable consumer) and invokes the verb that reads the list.
|
||||
for _, ev := range []string{"mesh-catalog.seat-definition-changed", "mesh-catalog.seat-definition-removed"} {
|
||||
if !slices.Contains(m.Consumes, ev) {
|
||||
t.Errorf("consumes %v lack %s", m.Consumes, ev)
|
||||
}
|
||||
}
|
||||
if !slices.Contains(m.Invokes, "seat:mesh-catalog.seat-definitions") {
|
||||
t.Errorf("invokes %v lack seat:mesh-catalog.seat-definitions", m.Invokes)
|
||||
}
|
||||
// Not a foundation part, it asks its finding stream in requires, by the template events (design 47 G §529, A-30), and
|
||||
// declares no stream of that name.
|
||||
for _, st := range m.Streams {
|
||||
|
||||
@@ -158,6 +158,7 @@ func sleepABit() { time.Sleep(30 * time.Millisecond) }
|
||||
// The workspace is self-contained after the fetch: no alternates file, and git finds the commit with the mirror gone,
|
||||
// as a step shut off with the workspace alone needs. Real git, a local repository as the forge.
|
||||
func TestTheWorkspaceIsSelfContainedAfterAFetchThroughTheMirror(t *testing.T) {
|
||||
t.Parallel()
|
||||
if _, err := exec.LookPath("git"); err != nil {
|
||||
t.Skip("no git")
|
||||
}
|
||||
|
||||
@@ -93,8 +93,8 @@ func TestStartWritesTheToolchainAndHealthIsHealthy(t *testing.T) {
|
||||
break
|
||||
}
|
||||
}
|
||||
if tc.Version != "go1.27.1" || tc.Recipe != m.Recipe.Version() || tc.Language != "go" {
|
||||
t.Fatalf("ace.go = %+v, want go1.27.1 and recipe %s", tc, m.Recipe.Version())
|
||||
if tc.Version != "go1.27" || tc.Recipe != m.Recipe.Version() || tc.Language != "go" {
|
||||
t.Fatalf("ace.go = %+v, want go1.27 and recipe %s", tc, m.Recipe.Version())
|
||||
}
|
||||
if a := m.Health(ctx); a.State != health.StateHealthy || !a.Healthy {
|
||||
t.Errorf("health = %+v, want healthy", a)
|
||||
|
||||
@@ -21,6 +21,7 @@ import (
|
||||
// build_go_fetch is asked that head as the package's version and build_go_build runs on the member, then both pass, the
|
||||
// build with GOPROXY=off against the head: the older commit holds no Go package at all.
|
||||
func TestRealFetchAndBuildOfAMemberAskedAPullHeadItsGoModDoesNotName(t *testing.T) {
|
||||
t.Parallel()
|
||||
// Not skipped when a tool is missing: a pass of the check must mean this test ran (the check prints no test log).
|
||||
for _, tool := range []string{"go", "git"} {
|
||||
if _, err := exec.LookPath(tool); err != nil {
|
||||
|
||||
@@ -304,6 +304,7 @@ func TestARelativeReplaceStillResolvesInTheTemporaryModfile(t *testing.T) {
|
||||
// the asked versions, else from the trunk's latest published version, and never looked for as the commit 000000000000
|
||||
// among the pull request heads.
|
||||
func TestARequirementAtTheZeroVersionIsTakenFromTheAskOrTheTrunk(t *testing.T) {
|
||||
t.Parallel()
|
||||
const sdk = "git.novox.be/novox/mesh-sdk/go"
|
||||
zeroMod := "module fixture/member\n\ngo 1.26\n\nrequire (\n\t" + sdk + " v0.0.0-00010101000000-" + zeroShort + "\n)\n"
|
||||
trunk := strings.Repeat("a", 40)
|
||||
|
||||
@@ -171,6 +171,7 @@ func TestRealFetchMergesConflictsAndPlainlyFetches(t *testing.T) {
|
||||
// sibling and passes with it; the sibling is a plain directory with no symlink in it; and a sibling that holds a
|
||||
// symlink fails the fetch naming it.
|
||||
func TestRealTestsReadTheSiblingBesideTheTree(t *testing.T) {
|
||||
t.Parallel()
|
||||
needTools(t, "the shut-off unit level", "go", "git", "bwrap") // the tests run in bubblewrap (1309)
|
||||
f := newForge(t)
|
||||
files := map[string]string{}
|
||||
|
||||
@@ -118,6 +118,7 @@ func resolve(t *testing.T, addr string, a builds.BuiltArtifact) []byte {
|
||||
// reference resolves in a real artifact store to bytes of that digest. The build is the real go's, shut off, of the
|
||||
// fixture testdata/repos/build, with an archive beside its bundle.
|
||||
func TestADoneBuildsArtifactsResolveInARealArtifactStore(t *testing.T) {
|
||||
t.Parallel()
|
||||
needTools(t, "the build", "go", "bwrap")
|
||||
work := t.TempDir()
|
||||
tree := filepath.Join(work, "ws1", "tree")
|
||||
|
||||
@@ -62,6 +62,7 @@ func repository(t *testing.T, name string) string {
|
||||
// test_test.go read the output captured from them, and this one proves the capture is what the real go says today. It
|
||||
// starts go test, so it carries the tag.
|
||||
func TestUnitLevelRunsTheRealGoOnTheFixtureRepositories(t *testing.T) {
|
||||
t.Parallel()
|
||||
needTools(t, "the unit level on fixtures", "go", "git", "bwrap")
|
||||
want := map[string]struct {
|
||||
passed, noTests bool
|
||||
@@ -104,6 +105,7 @@ func TestUnitLevelRunsTheRealGoOnTheFixtureRepositories(t *testing.T) {
|
||||
// 086 A-C3 against the real go (design 47 line 571 at b229f5c4): a tree holding an unformatted file passes its unit
|
||||
// level, its two tests run, and the lint step's body fails naming the file.
|
||||
func TestAnUnformattedFileFailsTheRealLintStepAndNotTheUnitLevel(t *testing.T) {
|
||||
t.Parallel()
|
||||
needTools(t, "the unit level's gofmt and vet", "go", "git", "bwrap")
|
||||
home := t.TempDir()
|
||||
m := &Module{Home: home, Work: t.TempDir(), Cache: t.TempDir()}
|
||||
@@ -150,7 +152,7 @@ func TestIntegrationLevelRunsAgainstARealStoreAndBusAndLeavesNothing(t *testing.
|
||||
needTools(t, "the integration level", "go", "git", "initdb", "pg_ctl", "postgres", "bwrap")
|
||||
tree := repository(t, "store")
|
||||
// A short work directory: a unix socket's path is bounded at 108 bytes.
|
||||
work, err := os.MkdirTemp("/tmp", "w")
|
||||
work, err := os.MkdirTemp(os.TempDir(), "w")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -185,6 +187,7 @@ func TestIntegrationLevelRunsAgainstARealStoreAndBusAndLeavesNothing(t *testing.
|
||||
// 1487/AC2: given a fixture Go module, when it is built twice, both digests are equal and the archive holds one
|
||||
// executable named as binaryName says. It runs the real go, so it carries the tag.
|
||||
func TestBuildTwiceGivesOneDigestAndOneExecutable(t *testing.T) {
|
||||
t.Parallel()
|
||||
needTools(t, "the build", "go", "bwrap")
|
||||
work := t.TempDir()
|
||||
tree := filepath.Join(work, "ws1", "tree")
|
||||
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
// Command mesh-compose is the stand-in composer the compose ask's test builds: a program of the contract the Go build module
|
||||
// runs (`-request <file>`, the last line of its standard output a composer verdict of version 1), which judges nothing and
|
||||
// answers each case of the request by its name, with no manifest and no machine. It imports nothing of the mesh.
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"flag"
|
||||
"fmt"
|
||||
"os"
|
||||
)
|
||||
|
||||
func main() {
|
||||
file := flag.String("request", "", "the request file")
|
||||
flag.Parse()
|
||||
raw, err := os.ReadFile(*file)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
var req struct {
|
||||
Cases []struct {
|
||||
Name string `json:"name"`
|
||||
} `json:"cases"`
|
||||
}
|
||||
if err := json.Unmarshal(raw, &req); err != nil {
|
||||
fmt.Fprintln(os.Stderr, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
type verdict struct {
|
||||
Name string `json:"name"`
|
||||
Manifests map[string]any `json:"manifests"`
|
||||
}
|
||||
out := struct {
|
||||
V int `json:"v"`
|
||||
SDK string `json:"sdk"`
|
||||
Cases []verdict `json:"cases"`
|
||||
}{V: 1, SDK: "stand-in"}
|
||||
for _, c := range req.Cases {
|
||||
out.Cases = append(out.Cases, verdict{Name: c.Name, Manifests: map[string]any{}})
|
||||
}
|
||||
line, _ := json.Marshal(out)
|
||||
fmt.Println(string(line))
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
module standin
|
||||
|
||||
go 1.26
|
||||
@@ -19,6 +19,7 @@ import (
|
||||
// group's head Go cannot fetch is placed from the forge's pull request heads; a go.mod that does not require the package
|
||||
// takes nothing.
|
||||
func TestAnAskedVersionIsWrittenIntoTheModfileWhateverGoModNames(t *testing.T) {
|
||||
t.Parallel()
|
||||
const sdk = "git.novox.be/novox/mesh-sdk/go"
|
||||
trunk := strings.Repeat("a", 40)
|
||||
offHead := strings.Repeat("b", 40) // a commit no pull request's head carries
|
||||
|
||||
@@ -33,7 +33,9 @@
|
||||
}
|
||||
],
|
||||
"consumes": [
|
||||
"mesh-conditions.findings-asked"
|
||||
"mesh-conditions.findings-asked",
|
||||
"mesh-catalog.seat-definition-changed",
|
||||
"mesh-catalog.seat-definition-removed"
|
||||
],
|
||||
"invokes": [
|
||||
"seat:mesh-hand-acts.hand-act",
|
||||
@@ -46,6 +48,7 @@
|
||||
"seat:mesh-wants.input",
|
||||
"seat:mesh-module-assigner.assignments",
|
||||
"seat:mesh-catalog.module",
|
||||
"seat:mesh-catalog.seat-definitions",
|
||||
"seat:mesh-catalog.entry"
|
||||
],
|
||||
"config": {
|
||||
|
||||
@@ -24,7 +24,7 @@ func TestTheModuleInvokesTheImageSeatAndHoldsNoRegistry(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if want := []string{"seat:mesh-hand-acts.hand-act", "seat:container-image-registry.publish", "seat:container-image-registry.publish-part",
|
||||
"seat:container-image-registry.mirror", "seat:mesh-module-assigner.assignments", "seat:mesh-catalog.module"}; !slices.Equal(m.Invokes, want) {
|
||||
"seat:container-image-registry.mirror", "seat:mesh-module-assigner.assignments", "seat:mesh-catalog.module", "seat:mesh-catalog.seat-definitions"}; !slices.Equal(m.Invokes, want) {
|
||||
t.Errorf("invokes = %v, want %v", m.Invokes, want)
|
||||
}
|
||||
// The seat's outcomes a copy waits on; the version comes in the ask, so version.numbered is not heard (design 47 G §413).
|
||||
@@ -32,6 +32,7 @@ func TestTheModuleInvokesTheImageSeatAndHoldsNoRegistry(t *testing.T) {
|
||||
for _, e := range OutcomeEvents {
|
||||
consumes = append(consumes, "container-image-registry."+e)
|
||||
}
|
||||
consumes = append(consumes, "mesh-catalog.seat-definition-changed", "mesh-catalog.seat-definition-removed") // the seat list, A-488a
|
||||
if !slices.Equal(m.Consumes, consumes) {
|
||||
t.Errorf("consumes = %v, want %v", m.Consumes, consumes)
|
||||
}
|
||||
|
||||
@@ -113,6 +113,16 @@ func TestWorkAndStoreDirectoriesLieOutsideTheHome(t *testing.T) {
|
||||
// and the registry's address is bound into a file of the home that the program reads.
|
||||
func TestManifestKeepsItsStatesClaimsItsBuildSeatAndDeclaresItsHealthTool(t *testing.T) {
|
||||
m := readManifest(t)
|
||||
// Design 47 G A-488a, A-488b: its runtime follows the seat list, so the module consumes the seat's two events (which makes its
|
||||
// durable consumer) and invokes the verb that reads the list.
|
||||
for _, ev := range []string{"mesh-catalog.seat-definition-changed", "mesh-catalog.seat-definition-removed"} {
|
||||
if !slices.Contains(m.Consumes, ev) {
|
||||
t.Errorf("consumes %v lack %s", m.Consumes, ev)
|
||||
}
|
||||
}
|
||||
if !slices.Contains(m.Invokes, "seat:mesh-catalog.seat-definitions") {
|
||||
t.Errorf("invokes %v lack seat:mesh-catalog.seat-definitions", m.Invokes)
|
||||
}
|
||||
states := []string{}
|
||||
for _, s := range m.State {
|
||||
states = append(states, s.Name)
|
||||
|
||||
@@ -68,11 +68,14 @@
|
||||
"seat:container-image-registry.publish-part",
|
||||
"seat:container-image-registry.mirror",
|
||||
"seat:mesh-module-assigner.assignments",
|
||||
"seat:mesh-catalog.module"
|
||||
"seat:mesh-catalog.module",
|
||||
"seat:mesh-catalog.seat-definitions"
|
||||
],
|
||||
"consumes": [
|
||||
"container-image-registry.published",
|
||||
"container-image-registry.refused"
|
||||
"container-image-registry.refused",
|
||||
"mesh-catalog.seat-definition-changed",
|
||||
"mesh-catalog.seat-definition-removed"
|
||||
],
|
||||
"own-secrets": {
|
||||
"broker": "${dir:state}/broker"
|
||||
|
||||
@@ -34,7 +34,7 @@ func TestTheGuardSaysToolchainReportedOnAChangeWithTheProgramDigest(t *testing.T
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(got) != 1 || got[0].subject != "mesh.seat.node-build-node.event.toolchain-reported.ace" || got[0].body["node"] != "ace" || got[0].body["language"] != "typescript" ||
|
||||
got[0].body["version"] != "v26.10.0" || got[0].body["recipe"] != m.Recipe.Version() || len(got[0].body["digest"]) != len("sha256:")+64 {
|
||||
got[0].body["version"] != "v26.10" || got[0].body["recipe"] != m.Recipe.Version() || len(got[0].body["digest"]) != len("sha256:")+64 {
|
||||
t.Fatalf("events = %+v, want one toolchain-reported for ace, go with the program's digest", got)
|
||||
}
|
||||
if tc, _ := states.toolchain("ace.typescript"); tc.Digest != got[0].body["digest"] {
|
||||
@@ -51,7 +51,7 @@ func TestTheGuardSaysToolchainReportedOnAChangeWithTheProgramDigest(t *testing.T
|
||||
os.WriteFile(prog, []byte("another node program"), 0o755)
|
||||
m.Probe = func(context.Context) (string, error) { return "v26.11.0", nil }
|
||||
m.Check(context.Background())
|
||||
if len(got) != 2 || got[1].body["version"] != "v26.11.0" || got[1].body["digest"] == got[0].body["digest"] {
|
||||
if len(got) != 2 || got[1].body["version"] != "v26.11" || got[1].body["digest"] == got[0].body["digest"] {
|
||||
t.Errorf("a new version said %+v, want a second event with another digest", got)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,6 +8,7 @@ import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
sdkstep "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/buildstep"
|
||||
"git.novox.be/novox/mesh-sdk/go/health"
|
||||
)
|
||||
|
||||
@@ -36,8 +37,8 @@ func TestAnyInstalledNodeIsHealthyNamedAndReported(t *testing.T) {
|
||||
t.Errorf("health = %+v, want healthy naming %s", a, installed)
|
||||
}
|
||||
tc, ok := states.toolchain("ace.typescript")
|
||||
if !ok || tc.Version != installed || tc.Recipe != m.Recipe.Version() {
|
||||
t.Errorf("ace.typescript = %+v, %v; want version %s and recipe %s", tc, ok, installed, m.Recipe.Version())
|
||||
if !ok || tc.Version != sdkstep.LanguageVersion(installed) || tc.Recipe != m.Recipe.Version() {
|
||||
t.Errorf("ace.typescript = %+v, %v; want version %s and recipe %s", tc, ok, sdkstep.LanguageVersion(installed), m.Recipe.Version())
|
||||
}
|
||||
if err := m.Prepare(context.Background()); err != nil {
|
||||
t.Errorf("no step can run on node %s: %v", installed, err)
|
||||
|
||||
@@ -277,6 +277,17 @@ func TestTheModuleRequiresNodeToolsItPullsThrough(t *testing.T) {
|
||||
if !slices.Contains(m.Requires, "node-tools") {
|
||||
t.Errorf("requires %v lack node-tools", m.Requires)
|
||||
}
|
||||
// Design 47 G A-488a: its runtime follows the seat list (seatlist.Start subscribes to the seat mesh-catalog's events), so the
|
||||
// module consumes both, which makes its durable consumer <node>_mesh-build-node_tools: with none, the seat list is never
|
||||
// read and the asks of a named asker are given back for ever.
|
||||
for _, ev := range []string{"mesh-catalog.seat-definition-changed", "mesh-catalog.seat-definition-removed"} {
|
||||
if !slices.Contains(m.Consumes, ev) {
|
||||
t.Errorf("consumes %v lack %s", m.Consumes, ev)
|
||||
}
|
||||
}
|
||||
if !slices.Contains(m.Invokes, "seat:mesh-catalog.seat-definitions") {
|
||||
t.Errorf("invokes %v lack seat:mesh-catalog.seat-definitions (A-488b)", m.Invokes)
|
||||
}
|
||||
}
|
||||
|
||||
// Design 47 G A-254, A-313, A-314: the module keeps a run's answer over what step-ended carries inline in the steps state's own
|
||||
|
||||
@@ -94,8 +94,8 @@ func TestStartWritesTheToolchainAndHealthIsHealthy(t *testing.T) {
|
||||
break
|
||||
}
|
||||
}
|
||||
if tc.Version != "v26.10.0" || tc.Recipe != m.Recipe.Version() || tc.Language != "typescript" {
|
||||
t.Fatalf("ace.typescript = %+v, want v26.10.0 and recipe %s", tc, m.Recipe.Version())
|
||||
if tc.Version != "v26.10" || tc.Recipe != m.Recipe.Version() || tc.Language != "typescript" {
|
||||
t.Fatalf("ace.typescript = %+v, want v26.10 and recipe %s", tc, m.Recipe.Version())
|
||||
}
|
||||
if a := m.Health(ctx); a.State != health.StateHealthy || !a.Healthy {
|
||||
t.Errorf("health = %+v, want healthy", a)
|
||||
|
||||
@@ -24,6 +24,10 @@
|
||||
"serves": ["current", "drop", "pause", "resume", "steps", "kept-artifact", "output"]
|
||||
}
|
||||
],
|
||||
"consumes": [
|
||||
"mesh-catalog.seat-definition-changed",
|
||||
"mesh-catalog.seat-definition-removed"
|
||||
],
|
||||
"config": {
|
||||
"capacity": {
|
||||
"type": "number",
|
||||
@@ -76,7 +80,8 @@
|
||||
"seat:npm-package-registry.publish",
|
||||
"seat:npm-package-registry.publish-part",
|
||||
"seat:mesh-module-assigner.assignments",
|
||||
"seat:mesh-catalog.module"
|
||||
"seat:mesh-catalog.module",
|
||||
"seat:mesh-catalog.seat-definitions"
|
||||
],
|
||||
"own-secrets": {
|
||||
"broker": "${dir:state}/broker"
|
||||
|
||||
@@ -289,12 +289,12 @@ var commands = []command{
|
||||
does: "clear one of a module's config values on one node", allowed: []string{"node", "why"},
|
||||
build: func(l line) (call, error) { return configChange(l, "clear") }},
|
||||
{words: []string{"config"}, usage: "[list|set|clear|history|propose|proposals] [--module m] [--node n] [--key k] [--value v] [--why w]",
|
||||
does: "the mesh's config values, at any level", allowed: []string{"module", "node", "key", "value", "why", "limit", "proposal", "pull", "clear"},
|
||||
does: "the mesh's config values, at any level", allowed: []string{"module", "node", "key", "value", "why", "limit", "proposal", "clear"},
|
||||
build: func(l line) (call, error) {
|
||||
if len(l.pos) > 1 {
|
||||
return call{}, usageErr("give at most one action")
|
||||
}
|
||||
a := pick(l, "module", "node", "key", "why", "proposal", "pull", "clear", "limit")
|
||||
a := pick(l, "module", "node", "key", "why", "proposal", "clear", "limit")
|
||||
if len(l.pos) == 1 {
|
||||
a["action"] = l.pos[0]
|
||||
}
|
||||
|
||||
@@ -173,6 +173,7 @@ func TestALineWithNoOwnerOrNotReadCallsNothingAndSaysWhy(t *testing.T) {
|
||||
{"conditions --bogus x", 2, "--bogus is not a flag"},
|
||||
{"settings set zsh {\"execute\":\"withhold\"} --node g14 --why x", 2, "set each key"},
|
||||
{"healers --days soon", 2, "takes a number"},
|
||||
{"config propose --pull novox/x#1", 2, "--pull is not a flag"},
|
||||
{"frobnicate", 2, "is not a command"},
|
||||
} {
|
||||
got := console(t, nil)
|
||||
|
||||
@@ -30,7 +30,7 @@ module none of whose manifests can be read is listed under `unresolved` with why
|
||||
values last resolved for it. Then: the manifest's default; mesh config for the predefined key the value falls back
|
||||
to; node config for that key on the node; the module's own value on that node, the most specific winning. A value
|
||||
naming no predefined key resolves from its default and the module's own value only (ADR 0348 §2). It resolves at
|
||||
start, whenever an assignment, a want or a trunk module moves, and every five minutes, writing only the values that moved.
|
||||
start, whenever an assignment, a want or a trunk module moves, writing only the values that moved.
|
||||
|
||||
## The verb
|
||||
|
||||
@@ -87,8 +87,9 @@ Each directory or archive this module declares says how it treats a file it did
|
||||
- `mesh-config_declared`: each placed module's declarations at the trunk, with the manifest and commit they come
|
||||
from, written only when they differ.
|
||||
- Its own sources hold always (novox/hq ADR 0590): declarations from the modules' own manifests, the list from the
|
||||
indexer's `predefined`, pull requests' config from the indexer's `config-candidates`. The controller's
|
||||
`pull-declares`, the take-over, compare and hand-back went with the controller. `config_declared` and
|
||||
indexer's `predefined`. The controller's `pull-declares`, the take-over, compare and hand-back went with the
|
||||
controller, and so did every pull request path (`pulls`, `kept`, `held`, a proposal's `pull`): the mesh knows no pull
|
||||
request (design 47 G, ADR 0502 ended by the operator's word, record pending). `config_declared` and
|
||||
`config_resync` read and write again what it keeps.
|
||||
- A trusted value is set only through propose and the operator's Approve: no controller relay is trusted (issue 1126).
|
||||
- Its sets, clears and warrants are recorded in the hand-act log of the seat `mesh-hand-acts` alone.
|
||||
|
||||
@@ -73,10 +73,6 @@ type Change struct {
|
||||
Approved string `json:"approved,omitempty"`
|
||||
At time.Time `json:"at"`
|
||||
Moved []Moved `json:"moved"`
|
||||
// Pull and Head name the pull request a value is held for, dropped from, or applied from at its merge (novox/hq
|
||||
// ADR 0502): the actions hold and drop are always about one, and a set with a pull is its merge.
|
||||
Pull string `json:"pull,omitempty"`
|
||||
Head string `json:"head,omitempty"`
|
||||
}
|
||||
|
||||
// Config is the module: its store, its clock, and one lock, so a set and a resolution never interleave.
|
||||
@@ -94,8 +90,6 @@ type Config struct {
|
||||
|
||||
// Asks is the operator channel as this module asks on it (proposals.go); nil, nothing can be proposed.
|
||||
Asks AskBus
|
||||
// Forge is the forge as pulls are asked of it (pulls.go); nil, a merge or a close is heard from its events alone.
|
||||
Forge PullForge
|
||||
// Delivery is what the delivery parts answer (renames.go, retiring.go); nil, no window closes and nothing retires.
|
||||
Delivery Delivery
|
||||
// Catalog is the catalog half: which modules exist and the manifest each entry carries, and the entry of a build's
|
||||
@@ -130,13 +124,6 @@ type Call struct {
|
||||
// Clear asks a proposal to clear the value instead of setting it; Proposal names one proposal to read.
|
||||
Clear bool
|
||||
Proposal string
|
||||
// Pull names the open pull request that introduces the key, for propose (a held value) and pull-declares; Head is
|
||||
// the commit its declarations are read at; Declares the config declarations the head adds or changes, by module;
|
||||
// Pulls the pull requests held asks about, each at a head.
|
||||
Pull string
|
||||
Head string
|
||||
Declares map[string]any
|
||||
Pulls []PullAt
|
||||
|
||||
// approval is the operator's warrant a set or a clear is made on: given by a decided proposal alone, never by
|
||||
// a call's arguments.
|
||||
@@ -177,13 +164,8 @@ func (c *Config) Do(call Call) (any, error) {
|
||||
return c.Propose(call)
|
||||
case "proposals":
|
||||
return c.Proposals(call)
|
||||
case "pull-declares":
|
||||
return c.PullDeclares(call)
|
||||
case "held":
|
||||
return c.Held(call)
|
||||
}
|
||||
return nil, fmt.Errorf("config does set, clear, list, history, propose, proposals, pull-declares or held; %q is "+
|
||||
"none of them", call.Action)
|
||||
return nil, fmt.Errorf("config does set, clear, list, history, propose or proposals; %q is none of them", call.Action)
|
||||
}
|
||||
|
||||
// level is the level a call names, refused as ADR 0348 §3 says: a module's own value is for one node.
|
||||
@@ -211,10 +193,6 @@ func (c *Config) Change(call Call) (*SetAnswer, error) {
|
||||
if call.Clear || call.Proposal != "" {
|
||||
return nil, fmt.Errorf("clear and proposal are a proposal's: %s takes neither", call.Action)
|
||||
}
|
||||
if call.Pull != "" {
|
||||
return nil, fmt.Errorf("pull names the pull request a value is held for, which only a proposal does: %s takes "+
|
||||
"none", call.Action)
|
||||
}
|
||||
call.approval = nil // only a decided proposal gives one
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
|
||||
@@ -131,3 +131,37 @@ func (v toolVault) Retire(r RetireRequest) error {
|
||||
_, err = v.ask(VaultRetireAsk, map[string]any{"node": r.Node, "module": r.Module, "name": r.Name, "warrant": rec.Act.ID, "ask": r.Ask})
|
||||
return err
|
||||
}
|
||||
|
||||
// unwrapAnswer reads a tool's answer whatever wraps it: the protocol's content list, or {output, ok, answer}.
|
||||
func unwrapAnswer(raw json.RawMessage) (json.RawMessage, string, bool) {
|
||||
var s string
|
||||
if json.Unmarshal(raw, &s) == nil {
|
||||
return unwrapAnswer(json.RawMessage(s))
|
||||
}
|
||||
var m map[string]json.RawMessage
|
||||
if json.Unmarshal(raw, &m) != nil {
|
||||
return raw, string(raw), true
|
||||
}
|
||||
if content, has := m["content"]; has {
|
||||
var items []struct {
|
||||
Text string `json:"text"`
|
||||
}
|
||||
var e struct {
|
||||
IsError bool `json:"isError"`
|
||||
}
|
||||
_ = json.Unmarshal(raw, &e)
|
||||
if json.Unmarshal(content, &items) == nil && len(items) > 0 {
|
||||
inner, out, ok := unwrapAnswer(json.RawMessage(items[0].Text))
|
||||
return inner, out, ok && !e.IsError
|
||||
}
|
||||
}
|
||||
var v struct {
|
||||
Output string `json:"output"`
|
||||
OK *bool `json:"ok"`
|
||||
Answer json.RawMessage `json:"answer"`
|
||||
}
|
||||
if json.Unmarshal(raw, &v) == nil && v.OK != nil {
|
||||
return v.Answer, v.Output, *v.OK
|
||||
}
|
||||
return raw, string(raw), true
|
||||
}
|
||||
|
||||
@@ -19,8 +19,6 @@ type Listed struct {
|
||||
Withheld string `json:"withheld,omitempty"`
|
||||
// Unresolved is each placed module the call narrows to whose declarations cannot be read, with why (issue 1953).
|
||||
Unresolved []Unresolved `json:"unresolved,omitempty"`
|
||||
// Held is the approved values held for open pull requests, not yet set (novox/hq ADR 0502).
|
||||
Held []HeldValue `json:"held,omitempty"`
|
||||
}
|
||||
|
||||
// SetValue is one value set, at its level.
|
||||
@@ -95,10 +93,6 @@ func (c *Config) List(call Call) (*Listed, error) {
|
||||
if call.Module == "" {
|
||||
out.Predefined = s.Predefined
|
||||
}
|
||||
out.Held = heldListed(s, call)
|
||||
if len(out.Held) == 0 {
|
||||
out.Held = nil
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
|
||||
@@ -38,15 +38,19 @@ func logf(format string, a ...any) { fmt.Fprintf(os.Stderr, format+"\n", a...) }
|
||||
var theViews *ownerViews
|
||||
|
||||
// runtimeStore is the bus, through the runtime that launched this bundle. A state of the delivery owners that the
|
||||
// owners' tools answer is read from the picture those keep (ownerviews.go), the rest from the bus.
|
||||
type runtimeStore struct{}
|
||||
// owners' tools answer is read from the picture those keep (ownerviews.go), this module's own states from the copy their
|
||||
// watches keep (ownstates.go), the rest from the bus.
|
||||
type runtimeStore struct{ own *ownCopy }
|
||||
|
||||
func (runtimeStore) Get(state, key string) (*Entry, error) {
|
||||
func (r runtimeStore) Get(state, key string) (*Entry, error) {
|
||||
if theViews != nil {
|
||||
if e, followed, err := theViews.get(state, key); followed {
|
||||
return e, err
|
||||
}
|
||||
}
|
||||
if r.own != nil && ownStates[state] {
|
||||
return r.own.get(state, key)
|
||||
}
|
||||
e, err := stdio.State(state).Get(key)
|
||||
if err != nil || e == nil {
|
||||
return nil, err
|
||||
@@ -54,19 +58,30 @@ func (runtimeStore) Get(state, key string) (*Entry, error) {
|
||||
return &Entry{Key: e.Key, Value: e.Value, Revision: e.Revision}, nil
|
||||
}
|
||||
|
||||
func (runtimeStore) Put(state, key string, value any) error {
|
||||
func (r runtimeStore) Put(state, key string, value any) error {
|
||||
if r.own != nil && ownStates[state] {
|
||||
return r.own.write(state, key, value)
|
||||
}
|
||||
_, err := stdio.State(state).Put(key, value)
|
||||
return err
|
||||
}
|
||||
|
||||
func (runtimeStore) Delete(state, key string) error { return stdio.State(state).Delete(key) }
|
||||
func (r runtimeStore) Delete(state, key string) error {
|
||||
if r.own != nil && ownStates[state] {
|
||||
return r.own.remove(state, key)
|
||||
}
|
||||
return stdio.State(state).Delete(key)
|
||||
}
|
||||
|
||||
func (runtimeStore) Keys(state string) ([]string, error) {
|
||||
func (r runtimeStore) Keys(state string) ([]string, error) {
|
||||
if theViews != nil {
|
||||
if keys, followed, err := theViews.keys(state); followed {
|
||||
return keys, err
|
||||
}
|
||||
}
|
||||
if r.own != nil && ownStates[state] {
|
||||
return r.own.keys(state)
|
||||
}
|
||||
return stdio.State(state).Keys()
|
||||
}
|
||||
|
||||
@@ -119,8 +134,22 @@ func (runtimeAsks) Warranted(ask string) error {
|
||||
return err
|
||||
}
|
||||
|
||||
// armsDeadline says a write to this state can move the deadline timer: a proposal, a retirement or a rename window (A-490l).
|
||||
func armsDeadline(state string) bool {
|
||||
return state == ProposalsState || state == RetiringState || state == RenamesState
|
||||
}
|
||||
|
||||
func main() {
|
||||
c := &Config{Store: runtimeStore{}, Logf: logf, Asks: runtimeAsks{}, Forge: toolForge{ask: stdio.Ask},
|
||||
own, rearm := newOwnCopy(), make(chan struct{}, 1)
|
||||
own.changed = func(state string) {
|
||||
if armsDeadline(state) {
|
||||
select {
|
||||
case rearm <- struct{}{}:
|
||||
default:
|
||||
}
|
||||
}
|
||||
}
|
||||
c := &Config{Store: runtimeStore{own: own}, Logf: logf, Asks: runtimeAsks{},
|
||||
Delivery: toolDelivery{ask: stdio.Ask}, Vault: toolVault{ask: stdio.Ask, recorder: recorder}}
|
||||
// The module's one held writer (design 47 G §689, A-16, A-29, A-32): the renames' and retirements' findings and the views reader's go through it.
|
||||
w, err := views.NewStdioHeldWriter(views.WriterConfig[meshconditions.Finding, meshconditions.FindingCleared, meshconditions.FindingsStated, meshconditions.FindingsAskedEvent]{
|
||||
@@ -181,6 +210,7 @@ func main() {
|
||||
theViews.Start(context.Background())
|
||||
go resolving(c, moved)
|
||||
go hearing(c)
|
||||
go deciding(c, rearm)
|
||||
go hearingDelivery(c)
|
||||
if err := stdio.Serve("", append(Tools(c), branches.EntryAgainTool("config", c.Store.HandAct))); err != nil {
|
||||
logf("%v", err)
|
||||
@@ -188,23 +218,12 @@ func main() {
|
||||
}
|
||||
}
|
||||
|
||||
// resolving resolves at start and again whenever a source moves, and every five minutes besides, so a change
|
||||
// heard nowhere is still resolved. The runtime answers only once Serve runs, so the watches are asked again
|
||||
// until they are taken.
|
||||
// resolving resolves at start and again whenever a source moves: an assignment, a want, a catalog revision, an entry
|
||||
// answered or the predefined list (each reaches `moved` through its view, ownerviews.go and main), and never on a timer
|
||||
// (novox/hq principle 1, issue 1982). The runtime answers only once Serve runs.
|
||||
func resolving(c *Config, moved chan struct{}) {
|
||||
// The owners' states reach `moved` through their views (ownerviews.go); the builder's builds, which has no tool yet,
|
||||
// is read when a want moves, and nothing else is watched.
|
||||
tick := time.NewTicker(5 * time.Minute)
|
||||
defer tick.Stop()
|
||||
time.Sleep(time.Second)
|
||||
for sweep := true; ; {
|
||||
if sweep {
|
||||
// A merge or a close of a pull request a value is held for, heard nowhere, is found here (ADR 0502).
|
||||
for _, s := range c.SweepPulls() {
|
||||
logf("[mesh-config] %s", s)
|
||||
}
|
||||
}
|
||||
sweep = false
|
||||
<-stdio.Served()
|
||||
for {
|
||||
r, err := c.Reconcile()
|
||||
switch {
|
||||
case err != nil:
|
||||
@@ -215,21 +234,22 @@ func resolving(c *Config, moved chan struct{}) {
|
||||
if r.Published != "" {
|
||||
logf("[mesh-config] published %s", r.Published)
|
||||
}
|
||||
// A window or a retirement judged while the entry of the build it waits on was still asked stays open until the
|
||||
// entry answers: the answer moves this pass, and the open ones are judged again here (design 32 *A config value
|
||||
// renamed*). It reads nothing from the bus when none is open.
|
||||
for _, s := range c.Windows("") {
|
||||
logf("[mesh-config] %s", s)
|
||||
}
|
||||
<-moved
|
||||
time.Sleep(500 * time.Millisecond) // a burst of writes is one resolution
|
||||
select {
|
||||
case <-moved:
|
||||
time.Sleep(500 * time.Millisecond) // a burst of writes is one resolution
|
||||
select {
|
||||
case <-moved:
|
||||
default:
|
||||
}
|
||||
case <-tick.C:
|
||||
sweep = true
|
||||
default:
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// hearing takes the router's word on this module's asks, asked again until the runtime takes the subscription, and
|
||||
// reads the router's record of every waiting ask once a minute besides, so an answer heard nowhere is still taken.
|
||||
// hearing takes the router's word on this module's asks, asked again until the runtime takes the subscription.
|
||||
func hearing(c *Config) {
|
||||
go func() {
|
||||
<-stdio.Served() // subscribed as soon as the runtime serves, never after a guessed wait: an event sent meanwhile is heard
|
||||
@@ -251,32 +271,32 @@ func hearing(c *Config) {
|
||||
time.Sleep(wait)
|
||||
}
|
||||
}()
|
||||
for _, pattern := range []string{"git.pull-merged", "git.pull-closed"} {
|
||||
go func(pattern string) {
|
||||
<-stdio.Served() // subscribed as soon as the runtime serves, never after a guessed wait: an event sent meanwhile is heard
|
||||
for wait := 2 * time.Second; ; wait = min(wait*2, time.Minute) {
|
||||
err := stdio.Subscribe(pattern, func(e stdio.Envelope) error {
|
||||
p, ok := pullEventOf(e.Body)
|
||||
if !ok {
|
||||
logf("[mesh-config] %s is not readable", pattern)
|
||||
return nil
|
||||
}
|
||||
for _, s := range c.HeardPull(p, pattern == "git.pull-merged") {
|
||||
logf("[mesh-config] %s", s)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
if err == nil {
|
||||
return
|
||||
}
|
||||
logf("[mesh-config] does not hear %s yet (%v); asking again in %s", pattern, err, wait)
|
||||
time.Sleep(wait)
|
||||
}
|
||||
}(pattern)
|
||||
}
|
||||
|
||||
// DeadlineFloorKey is this module's setting for the least wait of its one deadline timer, in seconds (module.json `config`).
|
||||
const DeadlineFloorKey = "deadline-floor-seconds"
|
||||
|
||||
// DefaultDeadlineFloor is the floor when the setting cannot be read.
|
||||
const DefaultDeadlineFloor = time.Minute
|
||||
|
||||
// floorOf is the floor a setting's value names: its seconds, or the default for a value that is not a positive number.
|
||||
func floorOf(raw json.RawMessage, err error) time.Duration {
|
||||
var seconds float64
|
||||
if err != nil || json.Unmarshal(raw, &seconds) != nil || seconds < 1 {
|
||||
return DefaultDeadlineFloor
|
||||
}
|
||||
tick := time.NewTicker(time.Minute)
|
||||
defer tick.Stop()
|
||||
for range tick.C {
|
||||
return time.Duration(seconds * float64(time.Second))
|
||||
}
|
||||
|
||||
func deadlineFloor() time.Duration { return floorOf(stdio.Config(DeadlineFloorKey)) }
|
||||
|
||||
// deciding reads the router's record of every waiting ask once at start, which finds an answer said while this module was
|
||||
// down, and then when the router says an ask ended (hearing's `decided` subscription calls Decide itself) or the next
|
||||
// deadline of a waiting proposal or retirement passes: one timer for the earliest, set again whenever a proposal or a
|
||||
// retirement is written (issue 1982; novox/hq ADR 0426 §3: a timer is a deadline, never a poll).
|
||||
func deciding(c *Config, rearm chan struct{}) {
|
||||
<-stdio.Served()
|
||||
decide := func() {
|
||||
said, err := c.Decide()
|
||||
if err != nil {
|
||||
logf("[mesh-config] reading the operator's answers: %v", err)
|
||||
@@ -284,6 +304,25 @@ func hearing(c *Config) {
|
||||
for _, s := range said {
|
||||
logf("[mesh-config] %s", s)
|
||||
}
|
||||
if err := c.JudgeHeldWindows(); err != nil {
|
||||
logf("[mesh-config] the held windows cannot be judged: %v", err)
|
||||
}
|
||||
}
|
||||
decide()
|
||||
for {
|
||||
at, ok := c.NextDeadline()
|
||||
if !ok {
|
||||
<-rearm
|
||||
continue
|
||||
}
|
||||
// Not sooner than the floor: a deadline that passed and was not settled (an ask the router refused) is tried again, not spun on.
|
||||
timer := time.NewTimer(max(time.Until(at), deadlineFloor()))
|
||||
select {
|
||||
case <-timer.C:
|
||||
decide()
|
||||
case <-rearm:
|
||||
timer.Stop()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -379,13 +418,10 @@ func Tools(c *Config) []stdio.Tool {
|
||||
"who and why. A trusted value is set only on the operator's Approve: " +
|
||||
"propose asks the operator, under mesh-config's own name on a channel that proves who answered, and sets " +
|
||||
"the value on Approve if what it was shown against still stands; proposals lists them, or one with " +
|
||||
"proposal. A proposal naming the open pull request that introduces its key (pull) is judged against what " +
|
||||
"that pull request declares and asked of the operator, and on Approve is held until the pull request " +
|
||||
"merges, then set; list shows the held values. pull-declares and held are the controller's. list and " +
|
||||
"history are narrowed by module, node and key.",
|
||||
"proposal. list and history are narrowed by module, node and key.",
|
||||
Input: map[string]any{"type": "object", "properties": map[string]any{
|
||||
"action": map[string]any{"type": "string",
|
||||
"enum": []string{"list", "set", "clear", "history", "propose", "proposals", "pull-declares", "held"},
|
||||
"enum": []string{"list", "set", "clear", "history", "propose", "proposals"},
|
||||
"description": "list when not given"},
|
||||
"key": map[string]any{"type": "string", "description": "the config key"},
|
||||
"value": map[string]any{"description": "for set: the value, of the key's declared type"},
|
||||
@@ -398,14 +434,6 @@ func Tools(c *Config) []stdio.Tool {
|
||||
"clear": map[string]any{"type": "boolean",
|
||||
"description": "for propose: propose clearing the value at its level instead of setting one"},
|
||||
"proposal": map[string]any{"type": "string", "description": "for proposals: one proposal's id, read whole"},
|
||||
"pull": map[string]any{"type": "string", "description": "owner/repository#number: for propose, the open " +
|
||||
"pull request that introduces the key, so the value is judged against what it declares and held until " +
|
||||
"it merges (a module's own value on one node); for pull-declares, the pull request declared for"},
|
||||
"head": map[string]any{"type": "string", "description": "for pull-declares: the commit the declarations are read at"},
|
||||
"declares": map[string]any{"type": "object", "description": "for pull-declares (the controller's): the " +
|
||||
"config declarations the head adds or changes against its base, by module and key"},
|
||||
"pulls": map[string]any{"type": "array", "description": "for held (the controller's): the pull requests " +
|
||||
"asked about, each {pull, head}", "items": map[string]any{"type": "object"}},
|
||||
}},
|
||||
Run: func(args map[string]any) (any, error) {
|
||||
call, err := callOf(args)
|
||||
@@ -421,8 +449,7 @@ func Tools(c *Config) []stdio.Tool {
|
||||
// callOf reads a call's arguments strictly: an argument it does not know is refused, not ignored.
|
||||
func callOf(args map[string]any) (Call, error) {
|
||||
known := map[string]bool{"action": true, "key": true, "value": true, "module": true, "node": true, "why": true,
|
||||
"by": true, "limit": true, "clear": true, "proposal": true, "pull": true, "head": true, "declares": true,
|
||||
"pulls": true}
|
||||
"by": true, "limit": true, "clear": true, "proposal": true}
|
||||
var unknown []string
|
||||
for k := range args {
|
||||
if !known[k] {
|
||||
@@ -431,7 +458,7 @@ func callOf(args map[string]any) (Call, error) {
|
||||
}
|
||||
if len(unknown) > 0 {
|
||||
return Call{}, fmt.Errorf("config takes no %s; it takes action, key, value, module, node, why, by, limit, "+
|
||||
"clear, proposal, pull, head, declares and pulls",
|
||||
"clear and proposal",
|
||||
strings.Join(unknown, ", "))
|
||||
}
|
||||
str := func(k string) (string, error) {
|
||||
@@ -448,8 +475,7 @@ func callOf(args map[string]any) (Call, error) {
|
||||
var call Call
|
||||
var problems []error
|
||||
for k, into := range map[string]*string{"action": &call.Action, "key": &call.Key, "module": &call.Module,
|
||||
"node": &call.Node, "why": &call.Why, "by": &call.By, "proposal": &call.Proposal, "pull": &call.Pull,
|
||||
"head": &call.Head} {
|
||||
"node": &call.Node, "why": &call.Why, "by": &call.By, "proposal": &call.Proposal} {
|
||||
s, err := str(k)
|
||||
problems = append(problems, err)
|
||||
*into = s
|
||||
@@ -468,19 +494,6 @@ func callOf(args map[string]any) (Call, error) {
|
||||
}
|
||||
call.Clear = b
|
||||
}
|
||||
if v, ok := args["declares"]; ok && v != nil {
|
||||
m, ok := v.(map[string]any)
|
||||
if !ok {
|
||||
problems = append(problems, errors.New("declares is an object: a module to its keys' declarations"))
|
||||
}
|
||||
call.Declares = m
|
||||
}
|
||||
if v, ok := args["pulls"]; ok && v != nil {
|
||||
raw, _ := json.Marshal(v)
|
||||
if err := json.Unmarshal(raw, &call.Pulls); err != nil {
|
||||
problems = append(problems, errors.New("pulls is a list of {pull, head}"))
|
||||
}
|
||||
}
|
||||
if v, ok := args["value"]; ok {
|
||||
// The value as given, a JSON value: a number for a number, never its text; the validation judges it.
|
||||
call.Value = v
|
||||
|
||||
@@ -50,10 +50,10 @@ func TestEveryStateAndActHasItsTool(t *testing.T) {
|
||||
}
|
||||
via := map[string]string{
|
||||
ValuesState: "config list", ResolvedState: "config list", PredefinedState: "config list",
|
||||
ProposalsState: "config proposals", PullsState: "config list", KeptState: "config list", HistoryLog: "config history",
|
||||
ProposalsState: "config proposals", HistoryLog: "config history",
|
||||
DeclaredState: DeclaredTool,
|
||||
AssignmentsRead: "config list", WantsRead: "config list", IndexerPredefinedRead: "config list", CandidatesRead: ResyncTool,
|
||||
"a resolution": ResyncTool, "the indexer's candidates taken": ResyncTool,
|
||||
AssignmentsRead: "config list", WantsRead: "config list", IndexerPredefinedRead: "config list",
|
||||
"a resolution": ResyncTool,
|
||||
// design 32: each new state with the tool that reads it, each act with the tool that starts it.
|
||||
RenamesState: RenamesTool, RetiringState: RetiringTool, FindingsState: "config_renames and config_retiring",
|
||||
"a move refused": RenameAgainTool, "a window dropped": RenameCloseTool, "an ask again": RetiringTool,
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
package main
|
||||
|
||||
// What mesh-config reads of the delivery owners' state, through their tools and views families (novox/hq ADR 0615 §1,
|
||||
// §4 to §6, ADR 0596): never a bucket of theirs. For each of the four states it follows (the indexer's predefined and
|
||||
// config-candidates, the assigner's assignments and wants) it asks the owner's read tool for the whole
|
||||
// §4 to §6, ADR 0596): never a bucket of theirs. For each of the three states it follows (the indexer's predefined, the
|
||||
// assigner's assignments and wants) it asks the owner's read tool for the whole
|
||||
// state at its start, keeps the picture from the owner's `views.<state>` events, and asks again only on a gap. Started
|
||||
// while an owner is down it keeps asking, and past two minutes writes a finding naming the owner and the tool.
|
||||
//
|
||||
@@ -28,7 +28,6 @@ import (
|
||||
// The tools of the owners that mesh-config asks, by the state they read.
|
||||
const (
|
||||
IndexerPredefTool = "indexer_read_predefined"
|
||||
IndexerCandidatesTool = "indexer_read_config_candidates"
|
||||
AssignerAssignmentsTool = "assigner_read_assignments"
|
||||
AssignerWantsTool = "assigner_read_wants"
|
||||
|
||||
@@ -40,7 +39,6 @@ const (
|
||||
// state and its tool.
|
||||
var followed = []struct{ Read, Owner, State, Tool string }{
|
||||
{IndexerPredefinedRead, indexerModule, catalog.StatePredefined, IndexerPredefTool},
|
||||
{CandidatesRead, indexerModule, catalog.StateConfigCandidates, IndexerCandidatesTool},
|
||||
{AssignmentsRead, assignerModule, "assignments", AssignerAssignmentsTool},
|
||||
{WantsRead, assignerModule, "wants", AssignerWantsTool},
|
||||
}
|
||||
@@ -189,7 +187,7 @@ func viewTools(c *Config, o func() *ownerViews) []stdio.Tool {
|
||||
return []stdio.Tool{
|
||||
{Name: FirstViewsTool,
|
||||
Description: "mesh-config's first views of the delivery owners' state: for each of the indexer's " +
|
||||
"predefined and config-candidates, the assigner's assignments and wants and the catalog half's registrations and " +
|
||||
"predefined, the assigner's assignments and wants and the catalog half's registrations and " +
|
||||
"each watched branch's revision, the tool it asks, the revision its " +
|
||||
"picture holds, when it asked and was answered, how many asks (and by hand), and whether its condition is raised.",
|
||||
Run: func(map[string]any) (any, error) {
|
||||
|
||||
@@ -0,0 +1,77 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
|
||||
stdio "git.novox.be/novox/mesh-sdk/go"
|
||||
)
|
||||
|
||||
// The module's own states are read from a copy each one's watch keeps, never key by key (novox/hq ADR 0580 §1, issue 1982):
|
||||
// a resolution reads every key of values, resolved, declared and the rest, and a get per key for each of them, once per
|
||||
// pass and once per delivery event, was about 4,000 requests to the bus every time. A state is watched on its first read, the
|
||||
// watch hands every current value over before the read is answered, and this process's own writes are taken into the copy
|
||||
// as they are made, so a read right after a write sees it.
|
||||
|
||||
// ownStates are the states this module keeps and reads through its store (its manifest's `state`, but the findings, which its
|
||||
// held writer alone reads and writes): the ones read from the copy.
|
||||
var ownStates = map[string]bool{
|
||||
ValuesState: true, ResolvedState: true, PredefinedState: true, ProposalsState: true, DeclaredState: true, RenamesState: true, RetiringState: true,
|
||||
}
|
||||
|
||||
// ownCopy is the copy of the module's own states over a bus: watch hands every current value of a state and then each change,
|
||||
// get reads one key, put and del write one.
|
||||
type ownCopy struct {
|
||||
copy *stdio.WatchedStates
|
||||
put func(state, key string, value any) (uint64, error)
|
||||
del func(state, key string) error
|
||||
// changed, when not nil, is told of each write or removal after it is in the copy: what waits on a deadline is judged again.
|
||||
changed func(state string)
|
||||
}
|
||||
|
||||
// newOwnCopy is the copy over this bundle's runtime.
|
||||
func newOwnCopy() *ownCopy {
|
||||
return &ownCopy{copy: stdio.NewWatchedStates(),
|
||||
put: func(state, key string, value any) (uint64, error) { return stdio.State(state).Put(key, value) },
|
||||
del: func(state, key string) error { return stdio.State(state).Delete(key) }}
|
||||
}
|
||||
|
||||
func (o *ownCopy) get(state, key string) (*Entry, error) {
|
||||
raw, ok, err := o.copy.Get(state, key)
|
||||
if err != nil || !ok {
|
||||
return nil, err
|
||||
}
|
||||
return &Entry{Key: key, Value: raw}, nil
|
||||
}
|
||||
|
||||
func (o *ownCopy) keys(state string) ([]string, error) { return o.copy.Keys(state) }
|
||||
|
||||
// write puts a key and takes it into the copy at the revision the bus answered.
|
||||
func (o *ownCopy) write(state, key string, value any) error {
|
||||
rev, err := o.put(state, key, value)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
raw, err := json.Marshal(value)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = o.copy.Wrote(state, key, raw, rev)
|
||||
o.told(state)
|
||||
return err
|
||||
}
|
||||
|
||||
func (o *ownCopy) told(state string) {
|
||||
if o.changed != nil {
|
||||
o.changed(state)
|
||||
}
|
||||
}
|
||||
|
||||
// remove deletes a key and takes that into the copy.
|
||||
func (o *ownCopy) remove(state, key string) error {
|
||||
if err := o.del(state, key); err != nil {
|
||||
return err
|
||||
}
|
||||
err := o.copy.Removed(state, key)
|
||||
o.told(state)
|
||||
return err
|
||||
}
|
||||
@@ -98,11 +98,9 @@ type Proposal struct {
|
||||
HadValue bool `json:"had-value"`
|
||||
WasDigest string `json:"was-digest"`
|
||||
Trusted bool `json:"trusted,omitempty"`
|
||||
// Pull is the open pull request the value is held for, when it is (novox/hq ADR 0502): the value is then not set
|
||||
// on Approve but kept apart until the pull request merges, and DeclDigest is the digest of the pull request's
|
||||
// declaration of the key it was judged and shown against.
|
||||
Pull string `json:"pull,omitempty"`
|
||||
DeclDigest string `json:"declaration,omitempty"`
|
||||
// Pull is read only: a proposal an earlier mesh-config kept for a pull request (ADR 0502, superseded by ADR 0681 §5).
|
||||
// It is never set on an Approve now, and judged not to be one this module makes (problem).
|
||||
Pull string `json:"pull,omitempty"`
|
||||
// Reaches is each module on each node whose value it moves, as it was judged when proposed.
|
||||
Reaches []string `json:"reaches"`
|
||||
// From is who proposed it, as the bus proved the caller; Why is theirs; At is when.
|
||||
@@ -175,9 +173,6 @@ func (p Proposal) Fingerprint() string {
|
||||
// about is what its ask is about: the value's place, so a newer proposal for it replaces an older one still open
|
||||
// (ADR 0277 §10, at a level, a key).
|
||||
func (p Proposal) about() string {
|
||||
if p.Pull != "" {
|
||||
return "config.held." + pullKey(p.Pull) + "." + p.Level.ValueKey(p.Key)
|
||||
}
|
||||
return "config." + p.Level.ValueKey(p.Key)
|
||||
}
|
||||
|
||||
@@ -188,9 +183,6 @@ func (p Proposal) Act(option string) occ.Act {
|
||||
"level": p.Level.Kind, "node": p.Level.Node, "module": p.Level.Module, "key": p.Key, "value": p.Digest,
|
||||
"was": p.WasDigest, "had-value": strconv.FormatBool(p.HadValue), "from": p.From,
|
||||
"at": p.At.UTC().Format(time.RFC3339Nano)}
|
||||
if p.Pull != "" {
|
||||
act["pull"], act["declaration"] = p.Pull, p.DeclDigest
|
||||
}
|
||||
return act
|
||||
}
|
||||
|
||||
@@ -270,16 +262,6 @@ func (p Proposal) summary() string {
|
||||
if p.Trusted {
|
||||
trusted = ", a trusted value,"
|
||||
}
|
||||
if p.Pull != "" {
|
||||
s := fmt.Sprintf("Holds %s for %s on %s for %s; approved, it takes effect when that pull request merges, "+
|
||||
"and is dropped if it closes unmerged. Nothing reaches a machine before the merge.", p.Key, p.Level.Module,
|
||||
p.Level.Node, p.Pull)
|
||||
if len([]rune(s)) > occ.SummaryLength {
|
||||
s = fmt.Sprintf("Holds %s for %s on %s for %s until it merges; dropped if it closes unmerged.", p.Key,
|
||||
p.Level.Module, p.Level.Node, p.Pull)
|
||||
}
|
||||
return s
|
||||
}
|
||||
reach := p.reaches()
|
||||
s := fmt.Sprintf("%s%s at %s; approved, it takes effect at once on every node it reaches: %s.", verb, trusted,
|
||||
p.Level, reach)
|
||||
@@ -305,9 +287,6 @@ func (p Proposal) headline() string {
|
||||
if p.Action == "clear" {
|
||||
verb = "Clear"
|
||||
}
|
||||
if p.Pull != "" {
|
||||
verb = "Hold"
|
||||
}
|
||||
where := "for the whole mesh"
|
||||
switch p.Level.Kind {
|
||||
case LevelNode:
|
||||
@@ -359,9 +338,6 @@ func (p Proposal) Ask() oc.Ask {
|
||||
a.WholeDetails = w
|
||||
}
|
||||
does := "the value is set at once, and every node it reaches takes it"
|
||||
if p.Pull != "" {
|
||||
does = "the value is held for " + p.Pull + ": it is set when that pull request merges, and dropped if it closes unmerged"
|
||||
}
|
||||
if p.Action == "clear" {
|
||||
does = "the value is cleared at once, and every node it reaches takes what is below it"
|
||||
}
|
||||
@@ -392,8 +368,8 @@ func (p Proposal) problem() string {
|
||||
return "its value is not the value its digest names: it changed after it was asked"
|
||||
case p.Action == "clear" && (len(p.Value) != 0 || p.Digest != valueDigest(nil, false)):
|
||||
return "a clear carries no value"
|
||||
case p.Pull != "" && (p.Action != "set" || p.Level.Kind != LevelModule || p.DeclDigest == ""):
|
||||
return "a value held for a pull request is a set of a module's own value, judged against its declaration"
|
||||
case p.Pull != "":
|
||||
return "it was held for a pull request, which the mesh knows no more: nothing is set on it"
|
||||
case valueDigest(p.Was, p.HadValue) != p.WasDigest:
|
||||
return "the value it was shown against is not the one its digest names: it changed after it was asked"
|
||||
}
|
||||
@@ -559,39 +535,16 @@ func (c *Config) propose(call Call, action string) (Proposal, oc.Ask, []string,
|
||||
// **Judged as a set judges it, before anyone is asked** (ADR 0277 §4): no ask for a value the verb would refuse.
|
||||
var r rule
|
||||
var trusted bool
|
||||
var declDigest string
|
||||
vk := level.ValueKey(call.Key)
|
||||
was, had := s.Values[vk]
|
||||
if call.Pull != "" {
|
||||
// **A value held for the open pull request that introduces its key** (novox/hq ADR 0502): judged against what
|
||||
// the pull request declares at its head, as the controller told it, and asked of the operator whatever the
|
||||
// key's trust.
|
||||
if action != "set" {
|
||||
return fail("a clear is not held for a pull request: only a value to set is")
|
||||
}
|
||||
if _, _, _, err := parsePull(call.Pull); err != nil {
|
||||
return fail("%v", err)
|
||||
}
|
||||
call.Pull = strings.TrimSpace(call.Pull)
|
||||
var herr error
|
||||
r, _, declDigest, herr = heldRule(s, call, level)
|
||||
if herr != nil {
|
||||
return fail("%v", herr)
|
||||
}
|
||||
trusted = false
|
||||
k, kept := s.Kept[keptKey(call.Pull, level.Node, level.Module, call.Key)]
|
||||
was, had = Value{Value: heldValue(k)}, kept
|
||||
} else {
|
||||
var derr error
|
||||
r, trusted, derr = c.declared(s, level, call.Key)
|
||||
if derr != nil {
|
||||
return fail("%v", derr)
|
||||
}
|
||||
r, trusted, derr := c.declared(s, level, call.Key)
|
||||
if derr != nil {
|
||||
return fail("%v", derr)
|
||||
}
|
||||
now := c.now()
|
||||
prop := Proposal{ID: newProposalID(), Action: action, Level: level, Key: call.Key, HadValue: had,
|
||||
WasDigest: valueDigest(was.Value, had), Trusted: trusted, From: call.Caller, Why: why, At: now,
|
||||
State: ProposalWaiting, Digest: valueDigest(nil, false), Pull: call.Pull, DeclDigest: declDigest}
|
||||
State: ProposalWaiting, Digest: valueDigest(nil, false)}
|
||||
if had {
|
||||
prop.Was = compact(was.Value)
|
||||
}
|
||||
@@ -618,19 +571,15 @@ func (c *Config) propose(call Call, action string) (Proposal, oc.Ask, []string,
|
||||
if had && string(compact(was.Value)) == string(prop.Value) {
|
||||
return fail("%s at %s already holds exactly %s", call.Key, level, prop.Value)
|
||||
}
|
||||
if call.Pull == "" {
|
||||
after.Values[vk] = Value{Value: prop.Value}
|
||||
}
|
||||
after.Values[vk] = Value{Value: prop.Value}
|
||||
case "clear":
|
||||
if !had {
|
||||
return fail("nothing is set for %s at %s, so there is nothing to clear", call.Key, level)
|
||||
}
|
||||
delete(after.Values, vk)
|
||||
}
|
||||
if call.Pull == "" {
|
||||
for _, m := range diff(Resolve(s), Resolve(after)) {
|
||||
prop.Reaches = append(prop.Reaches, m.Module+" on "+m.Node)
|
||||
}
|
||||
for _, m := range diff(Resolve(s), Resolve(after)) {
|
||||
prop.Reaches = append(prop.Reaches, m.Module+" on "+m.Node)
|
||||
}
|
||||
if prop.Reaches == nil {
|
||||
prop.Reaches = []string{}
|
||||
@@ -830,14 +779,6 @@ func (c *Config) decide(p Proposal, w oc.Warrant) string {
|
||||
return fmt.Sprintf("proposal %s: approved by the operator, and not set: the decision could not be kept (%v); "+
|
||||
"it is read again on the next look", p.ID, err)
|
||||
}
|
||||
if p.Pull != "" {
|
||||
// **A held value is kept apart, never set on Approve** (ADR 0502 clause 3).
|
||||
said, err := c.keep(p)
|
||||
if err != nil {
|
||||
return keep(ProposalRefused, "approved by the operator, and refused on Approve, so nothing is held: "+err.Error())
|
||||
}
|
||||
return keep(ProposalApproved, "approved by the operator and held: "+said)
|
||||
}
|
||||
call := Call{Action: p.Action, Key: p.Key, Module: p.Level.Module, Node: p.Level.Node, Why: p.Why, Caller: p.From,
|
||||
approval: &approval{Proposal: p.ID, By: "the operator", Says: p.Approved, Was: p.Was, HadValue: p.HadValue,
|
||||
WasDigest: p.WasDigest}}
|
||||
@@ -910,19 +851,63 @@ func (c *Config) HeardEnd(w oc.Warrant) []string {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
defer c.tellEnded(w.Ask, endedWord{Outcome: w.Outcome, Words: w.Words})
|
||||
// A retirement's ask ended with no choice is taken from the router's record the same way (retiring.go): the router's word
|
||||
// is the only thing that moves it, and no timer looks.
|
||||
said := c.decideRetirements()
|
||||
e, err := c.Store.Get(ProposalsState, w.Ask)
|
||||
if err != nil || e == nil {
|
||||
return nil
|
||||
return said
|
||||
}
|
||||
var p Proposal
|
||||
if json.Unmarshal(e.Value, &p) != nil || p.ID != w.Ask || p.State != ProposalWaiting {
|
||||
return nil
|
||||
return said
|
||||
}
|
||||
why := "the ask " + string(w.Outcome)
|
||||
if w.Words != "" {
|
||||
why += " (" + w.Words + ")"
|
||||
}
|
||||
return []string{c.end(p, why+"; nothing was set")}
|
||||
return append(said, c.end(p, why+"; nothing was set"))
|
||||
}
|
||||
|
||||
// NextDeadline is when a waiting proposal or retirement is next judged for want of an answer: a proposal with no record
|
||||
// at the router ends an hour after its ask lapses (Decide), and a retirement left unanswered is asked once more after
|
||||
// HeldFinding, and an open rename window's held finding comes after HeldFinding too (lead answer A-490l). The earliest of
|
||||
// them; false when nothing waits on a time.
|
||||
func (c *Config) NextDeadline() (time.Time, bool) {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
var at time.Time
|
||||
earlier := func(t time.Time) {
|
||||
if at.IsZero() || t.Before(at) {
|
||||
at = t
|
||||
}
|
||||
}
|
||||
if all, err := c.proposals(); err == nil {
|
||||
for _, p := range all {
|
||||
if p.State == ProposalWaiting {
|
||||
earlier(p.At.Add(ProposalLasts + time.Hour))
|
||||
}
|
||||
}
|
||||
}
|
||||
if held, err := c.readRetiring(); err == nil {
|
||||
for _, e := range held {
|
||||
if e.State == RetireUnanswered && !e.AskedAgain {
|
||||
earlier(e.Asked.Add(HeldFinding))
|
||||
}
|
||||
}
|
||||
}
|
||||
// An open rename window reaches its held finding after HeldFinding (renames.go): its deadline, while it lies ahead.
|
||||
if renames, err := c.readRenames(); err == nil {
|
||||
now := c.now()
|
||||
for _, r := range renames {
|
||||
for _, node := range r.Open() {
|
||||
if d := r.Nodes[node].Since.Add(HeldFinding); d.After(now) {
|
||||
earlier(d)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return at, !at.IsZero()
|
||||
}
|
||||
|
||||
// ---- the list ----------------------------------------------------------------------------------------------
|
||||
@@ -940,8 +925,6 @@ type ProposalRow struct {
|
||||
Expires time.Time `json:"expires"`
|
||||
Fingerprint string `json:"fingerprint"`
|
||||
Approved string `json:"approved,omitempty"`
|
||||
// Pull is the pull request a value is held for, when it is.
|
||||
Pull string `json:"pull,omitempty"`
|
||||
// What one proposal read whole says besides.
|
||||
Value json.RawMessage `json:"value,omitempty"`
|
||||
Was json.RawMessage `json:"was,omitempty"`
|
||||
@@ -970,8 +953,7 @@ func (c *Config) Proposals(call Call) ([]ProposalRow, error) {
|
||||
continue
|
||||
}
|
||||
row := ProposalRow{ID: p.ID, Action: p.Action, Level: p.Level, Key: p.Key, State: p.State, Outcome: p.Outcome,
|
||||
From: p.From, At: p.At, Expires: p.At.Add(ProposalLasts), Fingerprint: p.Fingerprint(), Approved: p.Approved,
|
||||
Pull: p.Pull}
|
||||
From: p.From, At: p.At, Expires: p.At.Add(ProposalLasts), Fingerprint: p.Fingerprint(), Approved: p.Approved}
|
||||
if p.State == ProposalWaiting && c.now().After(row.Expires) {
|
||||
row.State = "expired, not yet heard"
|
||||
}
|
||||
|
||||
@@ -590,3 +590,42 @@ func TestAnOwnersListOfNamesWithDigitsIsProposed(t *testing.T) {
|
||||
t.Fatalf("the owners were not put to the operator: %+v, asked on %v", a, r.subjects)
|
||||
}
|
||||
}
|
||||
|
||||
// **An approved proposal records a hand act that names no pull request** (ADR 0681 clause 1: nothing it records as a hand act is a
|
||||
// held value).
|
||||
func TestAnApprovedProposalsHandActNamesNoPullRequest(t *testing.T) {
|
||||
c, m, r := aProposingMesh(t)
|
||||
a := propose(t, c, Call{Key: "font-size", Value: 12.0, Node: "g14"})
|
||||
r.choose(t, a.Proposal, OptionApprove, nil)
|
||||
m.handActs = nil
|
||||
if said, err := c.Decide(); err != nil || len(said) == 0 {
|
||||
t.Fatalf("decide: %v, %v", said, err)
|
||||
}
|
||||
if len(m.handActs) == 0 {
|
||||
t.Fatal("the approval recorded no hand act")
|
||||
}
|
||||
for _, act := range m.handActs {
|
||||
if strings.Contains(strings.ToLower(act), "pull") || strings.Contains(act, "#") {
|
||||
t.Errorf("a hand act names a pull request: %q", act)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// A stored proposal that names a pull request is refused on its approval, saying why, and nothing is set (lead answer A-490l).
|
||||
func TestAStoredProposalNamingAPullRequestIsRefusedOnApproval(t *testing.T) {
|
||||
c, m, r := aProposingMesh(t)
|
||||
a := propose(t, c, Call{Key: "font-size", Value: 12.0, Node: "g14"})
|
||||
p := storedProposal(t, m, a.Proposal)
|
||||
p.Pull = "novox/mesh-catalog#7"
|
||||
if err := m.Put(ProposalsState, p.ID, p); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
r.choose(t, a.Proposal, OptionApprove, nil)
|
||||
said, _ := c.Decide()
|
||||
if got := storedProposal(t, m, a.Proposal); got.State == ProposalApproved || len(said) == 0 || !strings.Contains(strings.Join(said, " "), "pull request") {
|
||||
t.Errorf("said %v, proposal %+v", said, got)
|
||||
}
|
||||
if _, ok := storedValue(t, m, "node.g14.font-size"); ok {
|
||||
t.Error("a value was set on a proposal that names a pull request")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// toolForge.Pull reads the seat git's answer of the verb pull (design 47 G §654), bare or in the wrappings the runtime puts
|
||||
// around an answer; pullEventOf reads the seat's pull-merged and pull-closed bodies.
|
||||
func TestToolForgePullReadsTheSeatGitAnswersAndEventsAreRead(t *testing.T) {
|
||||
var asked struct {
|
||||
key string
|
||||
body map[string]any
|
||||
}
|
||||
for _, tc := range []struct {
|
||||
answer string
|
||||
open, merged bool
|
||||
head string
|
||||
}{
|
||||
{`{"pull":{"repository":"novox/mesh-catalog","number":435,"state":"merged","head":"7b5f7f84acb73aaf8189200548ff69fd9aac04b2"}}`, false, true, "7b5f7f84acb73aaf8189200548ff69fd9aac04b2"},
|
||||
{`{"pull":{"repository":"novox/mesh-catalog","number":434,"state":"open","head":"c948f3a61c74257e6e3147effb396d9d6434f491"}}`, true, false, "c948f3a61c74257e6e3147effb396d9d6434f491"},
|
||||
{`{"pull":{"state":"closed","head":"c948f3a61c74257e6e3147effb396d9d6434f491"}}`, false, false, "c948f3a61c74257e6e3147effb396d9d6434f491"},
|
||||
} {
|
||||
raw := json.RawMessage(tc.answer)
|
||||
content, _ := json.Marshal(map[string]any{"content": []map[string]any{{"type": "text", "text": tc.answer}}})
|
||||
ok, _ := json.Marshal(map[string]any{"ok": true, "output": "", "answer": raw})
|
||||
for name, answer := range map[string]json.RawMessage{"bare": raw, "content list": content, "ok answer": ok} {
|
||||
f := toolForge{ask: func(key string, body any) (json.RawMessage, error) {
|
||||
asked.key, asked.body = key, body.(map[string]any)
|
||||
return answer, nil
|
||||
}}
|
||||
open, merged, head, err := f.Pull("novox", "mesh-catalog", 434)
|
||||
if err != nil || open != tc.open || merged != tc.merged || head != tc.head {
|
||||
t.Errorf("%s (%s): open %v merged %v head %q, err %v", tc.answer, name, open, merged, head, err)
|
||||
}
|
||||
if asked.key != "seat:git.pull" || asked.body["repository"] != "novox/mesh-catalog" || asked.body["number"] != 434 {
|
||||
t.Errorf("asked %+v", asked)
|
||||
}
|
||||
}
|
||||
}
|
||||
failed := toolForge{ask: func(string, any) (json.RawMessage, error) {
|
||||
return json.RawMessage(`{"error":"no such pull request","error-kind":"not-found"}`), nil
|
||||
}}
|
||||
if _, _, _, err := failed.Pull("novox", "mesh-catalog", 9); err == nil {
|
||||
t.Error("an error answer was read as a pull request")
|
||||
}
|
||||
p, ok := pullEventOf([]byte(`{"repository":"novox/mesh-catalog","number":435,"branch":"fix/a","head":"7b5f7f84acb73aaf8189200548ff69fd9aac04b2","base":"main"}`))
|
||||
if !ok || p.Owner != "novox" || p.Repo != "mesh-catalog" || p.Number != 435 || p.HeadSHA != "7b5f7f84acb73aaf8189200548ff69fd9aac04b2" {
|
||||
t.Errorf("%+v %v", p, ok)
|
||||
}
|
||||
if _, ok := pullEventOf([]byte(`{"repository":"norepo","number":1}`)); ok {
|
||||
t.Error("a repository with no owner was read")
|
||||
}
|
||||
}
|
||||
@@ -1,644 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.novox.be/novox/mesh-contracts/go/clients/meshconfigclient"
|
||||
)
|
||||
|
||||
// A config value held for the open pull request that introduces its key (novox/hq ADR 0502, issue 1826).
|
||||
//
|
||||
// A key a pull request adds is declared by no registered manifest until it merges, so a value for it, which the
|
||||
// pull request's composed check needs, was refused. The controller reads each pull request's manifests from the
|
||||
// forge at its head and tells this module the config declarations the head adds or changes (PullDeclares); mesh-config
|
||||
// reads no manifest itself (ADR 0495 §1). A proposal that names the pull request is judged against those, asked of the
|
||||
// operator whatever the key's trust, and on Approve kept apart (KeptState) from the values it resolves. The
|
||||
// controller asks for the approved held values of a check's pull requests (Held) and hands them to the composed
|
||||
// check. At the merge the value is written as the module's own value on its node (PullMerged), where it resolves
|
||||
// once the trunk declares the key; a pull request closed unmerged drops it (PullClosed). Nothing reaches a machine
|
||||
// before the merge.
|
||||
|
||||
// The states of held values, and the actions their changes carry in the history and in `config-changed`.
|
||||
const (
|
||||
PullsState = "pulls"
|
||||
KeptState = "kept"
|
||||
|
||||
ActionHold = "hold"
|
||||
ActionDrop = "drop"
|
||||
)
|
||||
|
||||
// pullName is a pull request as it is named: owner/repository#number.
|
||||
var pullName = regexp.MustCompile(`^([A-Za-z0-9_.-]+)/([A-Za-z0-9_.-]+)#([0-9]+)$`)
|
||||
|
||||
func parsePull(s string) (owner, repo string, number int, err error) {
|
||||
m := pullName.FindStringSubmatch(strings.TrimSpace(s))
|
||||
if m == nil {
|
||||
return "", "", 0, fmt.Errorf("%q is not a pull request: name it owner/repository#number", s)
|
||||
}
|
||||
n, _ := strconv.Atoi(m[3])
|
||||
if n <= 0 {
|
||||
return "", "", 0, fmt.Errorf("%q is not a pull request: its number is above zero", s)
|
||||
}
|
||||
return m[1], m[2], n, nil
|
||||
}
|
||||
|
||||
// pullKey is a pull request's key in the states.
|
||||
func pullKey(pull string) string {
|
||||
return strings.NewReplacer("/", ".", "#", ".").Replace(strings.TrimSpace(pull))
|
||||
}
|
||||
|
||||
// PullDecl is what the controller told: the config declarations a pull request's head adds or changes, by module.
|
||||
type PullDecl struct {
|
||||
Pull string `json:"pull"`
|
||||
Head string `json:"head"`
|
||||
Declares map[string]map[string]Declaration `json:"declares"`
|
||||
At time.Time `json:"at"`
|
||||
}
|
||||
|
||||
// KeptValue is an approved held value, kept apart from the values mesh-config resolves, in the layout of the seat's state
|
||||
// `kept`, which the checker and the assigner's composition check read (novox/hq ADR 0565 §5, ADR 0634 §4).
|
||||
type KeptValue = meshconfigclient.Kept
|
||||
|
||||
// keptKey is a held value's key in `kept`: the pull request's key form (pullKey), the node, the module and the config
|
||||
// key, joined by dots.
|
||||
func keptKey(pull, node, module, key string) string {
|
||||
k, _ := meshconfigclient.HeldValueKey(pull, node, module, key) // a held value of no pull request has no key, and is found by none
|
||||
return k
|
||||
}
|
||||
|
||||
// heldValue is the value held, as the operator approved it, in its JSON form.
|
||||
func heldValue(k KeptValue) json.RawMessage {
|
||||
raw, _ := meshconfigclient.ValueOf(k) // a value that was read from JSON writes as JSON
|
||||
return raw
|
||||
}
|
||||
|
||||
func heldAt(t time.Time) *time.Time { return &t }
|
||||
|
||||
func keptStateKey(k KeptValue) string { return keptKey(k.Pull, k.Node, k.Module, k.Key) }
|
||||
|
||||
func keptLevel(k KeptValue) Level { return Level{Kind: LevelModule, Node: k.Node, Module: k.Module} }
|
||||
|
||||
// declDigest is the digest of what a declaration holds a value to: a held value stays only while it is the same.
|
||||
func declDigest(d Declaration) string {
|
||||
d.Description, d.Why, d.Kind, d.Runtime = "", "", "", false
|
||||
if !d.HasDefault() {
|
||||
d.Default = nil
|
||||
} else {
|
||||
d.Default = compact(d.Default)
|
||||
}
|
||||
raw, _ := json.Marshal(d)
|
||||
sum := sha256.Sum256(raw)
|
||||
return "sha256:" + hex.EncodeToString(sum[:])
|
||||
}
|
||||
|
||||
// PullForge is the forge as this module asks it of a pull request: its state, and whether it merged.
|
||||
type PullForge interface {
|
||||
Pull(owner, repo string, number int) (open, merged bool, head string, err error)
|
||||
}
|
||||
|
||||
// pulls reads what is kept for pull requests, and the held values.
|
||||
func (c *Config) readPulls(s *Sources) error {
|
||||
s.Pulls, s.Kept = map[string]PullDecl{}, map[string]KeptValue{}
|
||||
if err := c.each(PullsState, func(key string, raw []byte) error {
|
||||
var p PullDecl
|
||||
if err := json.Unmarshal(raw, &p); err != nil || p.Pull == "" {
|
||||
return nil // not one this module wrote
|
||||
}
|
||||
s.Pulls[pullKey(p.Pull)] = p
|
||||
return nil
|
||||
}); err != nil {
|
||||
return fmt.Errorf("the pull requests' declarations cannot be read: %w", err)
|
||||
}
|
||||
if err := c.each(KeptState, func(key string, raw []byte) error {
|
||||
k, err := meshconfigclient.DecodeKept(key, raw)
|
||||
if err != nil {
|
||||
return nil // not a held value of the seat's layout under its own key
|
||||
}
|
||||
s.Kept[key] = k
|
||||
return nil
|
||||
}); err != nil {
|
||||
return fmt.Errorf("the held values cannot be read: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ---- pull-declares ---------------------------------------------------------------------------------------
|
||||
|
||||
// PullDeclaresAnswer is what pull-declares answers.
|
||||
type PullDeclaresAnswer struct {
|
||||
Said string `json:"said"`
|
||||
Pull string `json:"pull"`
|
||||
Head string `json:"head"`
|
||||
Modules []string `json:"modules"`
|
||||
Dropped []string `json:"dropped,omitempty"`
|
||||
Unsaid []string `json:"unsaid,omitempty"`
|
||||
}
|
||||
|
||||
// PullDeclares is gone: a pull request's config declarations are read from the indexer's config-candidates
|
||||
// (takeCandidates), and the controller that told them is not placed (novox/hq ADR 0565 §4, ADR 0590).
|
||||
func (c *Config) PullDeclares(Call) (*PullDeclaresAnswer, error) {
|
||||
return nil, errors.New("pull-declares is gone: mesh-config reads a pull request's config declarations from the " +
|
||||
"indexer's config-candidates (novox/hq ADR 0565 §4, ADR 0590)")
|
||||
}
|
||||
|
||||
// declarePull keeps what a pull request's head declares and judges again the values held for it, from the indexer's
|
||||
// config candidates. The caller holds the lock.
|
||||
func (c *Config) declarePull(pull, head string, declares map[string]map[string]Declaration) (*PullDeclaresAnswer, error) {
|
||||
if err := c.Store.Put(PullsState, pullKey(pull), PullDecl{Pull: pull, Head: head, Declares: declares,
|
||||
At: c.now()}); err != nil {
|
||||
return nil, fmt.Errorf("the declarations were not kept: %v", err)
|
||||
}
|
||||
a := &PullDeclaresAnswer{Pull: pull, Head: head, Modules: sortedKeys(declares)}
|
||||
var s Sources
|
||||
if err := c.readPulls(&s); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, k := range sortedKeys(s.Kept) {
|
||||
kv := s.Kept[k]
|
||||
if pullKey(kv.Pull) != pullKey(pull) {
|
||||
continue
|
||||
}
|
||||
why := ""
|
||||
d, declared := declares[kv.Module][kv.Key]
|
||||
switch {
|
||||
case !declared:
|
||||
why = "the head no longer adds or changes its declaration"
|
||||
case declDigest(d) != kv.Declaration:
|
||||
why = "the head declares the key otherwise than the value was approved against"
|
||||
default:
|
||||
var v any
|
||||
_ = json.Unmarshal(heldValue(kv), &v)
|
||||
if p := d.rule().check(v); len(p) > 0 {
|
||||
why = "the value no longer passes: " + strings.Join(p, "; ")
|
||||
}
|
||||
}
|
||||
if why != "" {
|
||||
a.Unsaid = append(a.Unsaid, c.dropKept(kv, "the new head "+short(head)+": "+why)...)
|
||||
a.Dropped = append(a.Dropped, fmt.Sprintf("%s for %s on %s: %s", kv.Key, kv.Module, kv.Node, why))
|
||||
continue
|
||||
}
|
||||
if kv.Head != head {
|
||||
kv.Head = head
|
||||
if err := c.Store.Put(KeptState, k, kv); err != nil {
|
||||
a.Unsaid = append(a.Unsaid, "the held value "+k+" was not moved to the new head: "+err.Error())
|
||||
}
|
||||
}
|
||||
}
|
||||
a.Said = fmt.Sprintf("keeps what %s declares at %s for %d module(s)", pull, short(head), len(declares))
|
||||
if len(a.Dropped) > 0 {
|
||||
a.Said += fmt.Sprintf("; %d held value(s) dropped", len(a.Dropped))
|
||||
}
|
||||
return a, nil
|
||||
}
|
||||
|
||||
// heldChange records a hold, a drop or a merge's set of a held value in the history, the hand-act log and
|
||||
// config-changed; what could not be done is answered, not dropped.
|
||||
func (c *Config) heldChange(kv KeptValue, action, why, approved string) []string {
|
||||
level := keptLevel(kv)
|
||||
ch := Change{Action: action, Level: &level, Key: kv.Key, Value: heldValue(kv), By: kv.By, Via: kv.Via, Why: why,
|
||||
Approved: approved, Pull: kv.Pull, Head: kv.Head, At: c.now(), Moved: []Moved{}}
|
||||
unsaid := c.record(level.ValueKey(kv.Key), ch)
|
||||
cause := "a value held for " + kv.Pull
|
||||
what := fmt.Sprintf("config %s %s of %s for %s, held for %s", action, kv.Key, kv.Module, kv.Node, kv.Pull)
|
||||
if action != ActionDrop {
|
||||
what += " (" + string(heldValue(kv)) + ")"
|
||||
}
|
||||
if err := c.Store.HandAct(what, why, cause); err != nil {
|
||||
unsaid = append(unsaid, "the hand-act log does not hold it: "+err.Error())
|
||||
}
|
||||
return unsaid
|
||||
}
|
||||
|
||||
// dropKept removes a held value, saying why.
|
||||
func (c *Config) dropKept(kv KeptValue, why string) []string {
|
||||
if err := c.Store.Delete(KeptState, keptStateKey(kv)); err != nil {
|
||||
return []string{"the held value " + keptStateKey(kv) + " was not dropped: " + err.Error()}
|
||||
}
|
||||
c.logf("[mesh-config] dropped %s of %s on %s held for %s: %s", kv.Key, kv.Module, kv.Node, kv.Pull, why)
|
||||
return c.heldChange(kv, ActionDrop, "dropped, nothing was set: "+why, "")
|
||||
}
|
||||
|
||||
// ---- held ------------------------------------------------------------------------------------------------
|
||||
|
||||
// HeldAnswer is what held answers: the approved held values of the pull requests asked, at the heads asked.
|
||||
type HeldAnswer struct {
|
||||
Held []HeldValue `json:"held"`
|
||||
Skipped []HeldSkipped `json:"skipped"`
|
||||
}
|
||||
|
||||
// HeldValue is one approved held value as it is handed to a composed check and listed.
|
||||
type HeldValue struct {
|
||||
Pull string `json:"pull"`
|
||||
Head string `json:"head"`
|
||||
Node string `json:"node"`
|
||||
Module string `json:"module"`
|
||||
Key string `json:"key"`
|
||||
Value json.RawMessage `json:"value"`
|
||||
Approved string `json:"approved"`
|
||||
By string `json:"by,omitempty"`
|
||||
Why string `json:"why,omitempty"`
|
||||
At time.Time `json:"at"`
|
||||
}
|
||||
|
||||
// HeldSkipped is a pull request asked for whose held values are not answered, and why.
|
||||
type HeldSkipped struct {
|
||||
Pull string `json:"pull"`
|
||||
Why string `json:"why"`
|
||||
}
|
||||
|
||||
func heldValueOf(k KeptValue) HeldValue {
|
||||
return HeldValue{Pull: k.Pull, Head: k.Head, Node: k.Node, Module: k.Module, Key: k.Key, Value: compact(heldValue(k)),
|
||||
Approved: k.Approved, By: k.By, Why: k.Why, At: timeOf(k.At)}
|
||||
}
|
||||
|
||||
// Held answers the approved held values for the pull requests asked, at the heads asked, to the controller alone: a
|
||||
// pull request at another head than the one kept is skipped and said (ADR 0502 clause 4).
|
||||
func (c *Config) Held(call Call) (*HeldAnswer, error) {
|
||||
if call.Caller != ControllerCaller {
|
||||
return nil, fmt.Errorf("held is the controller's: it hands the held values to a composed check; %s is not "+
|
||||
"the controller", call.Caller)
|
||||
}
|
||||
asked := map[string]string{}
|
||||
var order []string
|
||||
for _, p := range call.Pulls {
|
||||
if _, _, _, err := parsePull(p.Pull); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if strings.TrimSpace(p.Head) == "" {
|
||||
return nil, fmt.Errorf("name the head of %s", p.Pull)
|
||||
}
|
||||
if _, dup := asked[pullKey(p.Pull)]; !dup {
|
||||
order = append(order, strings.TrimSpace(p.Pull))
|
||||
}
|
||||
asked[pullKey(p.Pull)] = strings.TrimSpace(p.Head)
|
||||
}
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
var s Sources
|
||||
if err := c.readPulls(&s); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := &HeldAnswer{Held: []HeldValue{}, Skipped: []HeldSkipped{}}
|
||||
for _, p := range order {
|
||||
head := asked[pullKey(p)]
|
||||
var mine []KeptValue
|
||||
for _, k := range sortedKeys(s.Kept) {
|
||||
if pullKey(s.Kept[k].Pull) == pullKey(p) {
|
||||
mine = append(mine, s.Kept[k])
|
||||
}
|
||||
}
|
||||
for _, k := range mine {
|
||||
if k.Head != head {
|
||||
out.Skipped = append(out.Skipped, HeldSkipped{Pull: p, Why: fmt.Sprintf("%s for %s on %s is held "+
|
||||
"at head %s, not %s", k.Key, k.Module, k.Node, short(k.Head), short(head))})
|
||||
continue
|
||||
}
|
||||
out.Held = append(out.Held, heldValueOf(k))
|
||||
}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// HeldListed is the held values a listing shows, narrowed by module, node and key.
|
||||
func heldListed(s Sources, call Call) []HeldValue {
|
||||
out := []HeldValue{}
|
||||
for _, k := range sortedKeys(s.Kept) {
|
||||
kv := s.Kept[k]
|
||||
if (call.Module == "" || kv.Module == call.Module) && (call.Node == "" || kv.Node == call.Node) &&
|
||||
(call.Key == "" || kv.Key == call.Key) {
|
||||
out = append(out, heldValueOf(kv))
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// ---- the proposal's rule -------------------------------------------------------------------------------
|
||||
|
||||
// heldRule is the rule a value held for a pull request is judged by: the pull request's declaration of the key for
|
||||
// the module at its head, and the module's assignment to the node. Refused, saying what the pull request does
|
||||
// declare, when it declares none.
|
||||
func heldRule(s Sources, call Call, level Level) (rule, PullDecl, string, error) {
|
||||
if level.Kind != LevelModule {
|
||||
return rule{}, PullDecl{}, "", fmt.Errorf("a value held for a pull request is a module's own value on one "+
|
||||
"node, and %s is not one: a predefined key a pull request adds is set after its merge (novox/hq ADR 0502)",
|
||||
level)
|
||||
}
|
||||
pd, ok := s.Pulls[pullKey(call.Pull)]
|
||||
if !ok {
|
||||
return rule{}, PullDecl{}, "", fmt.Errorf("mesh-config holds no declaration for %s: the controller tells it "+
|
||||
"what a pull request declares when its head is announced, and none has been", strings.TrimSpace(call.Pull))
|
||||
}
|
||||
d, ok := pd.Declares[level.Module][call.Key]
|
||||
if !ok {
|
||||
return rule{}, PullDecl{}, "", fmt.Errorf("%s does not add or change a value %q for %s at %s; it declares "+
|
||||
"for %s: %s", pd.Pull, call.Key, level.Module, short(pd.Head), level.Module, joinKeys(pd.Declares[level.Module]))
|
||||
}
|
||||
if _, reg := s.Declared[level.Module]; !reg {
|
||||
return rule{}, PullDecl{}, "", fmt.Errorf("%s is not a registered module, so a value cannot be held for it", level.Module)
|
||||
}
|
||||
if !assigned(s, level.Node, level.Module) {
|
||||
return rule{}, PullDecl{}, "", fmt.Errorf("%s is not placed on %s, and a module's own value is set for a node "+
|
||||
"it is placed on (novox/hq ADR 0348 §3); it is placed on: %s", level.Module, level.Node,
|
||||
strings.Join(nodesOf(s, level.Module), ", "))
|
||||
}
|
||||
return d.rule(), pd, declDigest(d), nil
|
||||
}
|
||||
|
||||
// keep holds an approved proposal's value apart. The caller holds the lock.
|
||||
func (c *Config) keep(p Proposal) (string, error) {
|
||||
var s Sources
|
||||
if err := c.readPulls(&s); err != nil {
|
||||
return "", err
|
||||
}
|
||||
pd, ok := s.Pulls[pullKey(p.Pull)]
|
||||
if !ok {
|
||||
return "", fmt.Errorf("mesh-config holds no declaration for %s any more", p.Pull)
|
||||
}
|
||||
d, ok := pd.Declares[p.Level.Module][p.Key]
|
||||
if !ok || declDigest(d) != p.DeclDigest {
|
||||
return "", fmt.Errorf("%s declares %s otherwise than the operator was shown, or no longer declares it: "+
|
||||
"propose it again", p.Pull, p.Key)
|
||||
}
|
||||
was, had := s.Kept[keptKey(p.Pull, p.Level.Node, p.Level.Module, p.Key)]
|
||||
if had != p.HadValue || valueDigest(heldValue(was), had) != p.WasDigest {
|
||||
return "", fmt.Errorf("the value held for %s changed since the operator was shown the change: propose it "+
|
||||
"again", p.Pull)
|
||||
}
|
||||
kv := KeptValue{Pull: p.Pull, Head: pd.Head, Declaration: p.DeclDigest, Node: p.Level.Node, Module: p.Level.Module,
|
||||
Key: p.Key, Value: p.Value, By: "the operator", Via: p.From, Why: p.Why, Approved: p.Approved, Proposal: p.ID,
|
||||
At: heldAt(c.now())}
|
||||
if err := c.Store.Put(KeptState, keptStateKey(kv), kv); err != nil {
|
||||
return "", fmt.Errorf("the value was not kept: %v", err)
|
||||
}
|
||||
unsaid := c.heldChange(kv, ActionHold, "held for "+p.Pull+" until it merges: "+p.Why, p.Approved)
|
||||
said := fmt.Sprintf("%s of %s on %s is held at %s for %s until it merges", p.Key, p.Level.Module, p.Level.Node,
|
||||
short(pd.Head), p.Pull)
|
||||
if len(unsaid) > 0 {
|
||||
said += " (" + strings.Join(unsaid, "; ") + ")"
|
||||
}
|
||||
return said, nil
|
||||
}
|
||||
|
||||
// ---- the merge and the close ---------------------------------------------------------------------------
|
||||
|
||||
// PullMerged writes each value held for a pull request as the module's own value on its node, with the approval kept
|
||||
// beside it; it resolves once the trunk declares the key. It answers a line for each.
|
||||
func (c *Config) PullMerged(pull, head string) []string {
|
||||
return c.settlePull(pull, true, head)
|
||||
}
|
||||
|
||||
// PullClosed drops the values held for a pull request closed unmerged, and says that nothing was set.
|
||||
func (c *Config) PullClosed(pull string) []string {
|
||||
return c.settlePull(pull, false, "")
|
||||
}
|
||||
|
||||
func (c *Config) settlePull(pull string, merged bool, head string) []string {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
var s Sources
|
||||
if err := c.readPulls(&s); err != nil {
|
||||
return []string{err.Error()}
|
||||
}
|
||||
var said []string
|
||||
wrote := false
|
||||
for _, k := range sortedKeys(s.Kept) {
|
||||
kv := s.Kept[k]
|
||||
if pullKey(kv.Pull) != pullKey(pull) {
|
||||
continue
|
||||
}
|
||||
if !merged {
|
||||
said = append(said, fmt.Sprintf("%s of %s on %s was held for %s, which closed unmerged: dropped, "+
|
||||
"nothing was set", kv.Key, kv.Module, kv.Node, kv.Pull))
|
||||
said = append(said, c.dropKept(kv, kv.Pull+" closed unmerged")...)
|
||||
continue
|
||||
}
|
||||
// **Only a value held at the merged head, whose key that head declares as it was approved** (ADR 0502 clause 7).
|
||||
why := ""
|
||||
pd, known := s.Pulls[pullKey(pull)]
|
||||
d, declared := pd.Declares[kv.Module][kv.Key]
|
||||
switch {
|
||||
case head == "":
|
||||
why = "the merged head is not known, so the value cannot be held to it"
|
||||
case !strings.EqualFold(head, kv.Head):
|
||||
why = fmt.Sprintf("it is held at head %s and the pull request merged at %s", short(kv.Head), short(head))
|
||||
case !known || !declared || declDigest(d) != kv.Declaration:
|
||||
why = "the merged head does not declare the key as the operator was shown"
|
||||
}
|
||||
if why != "" {
|
||||
said = append(said, fmt.Sprintf("%s of %s on %s was held for %s, which merged: dropped, nothing was set (%s)",
|
||||
kv.Key, kv.Module, kv.Node, kv.Pull, why))
|
||||
said = append(said, c.dropKept(kv, kv.Pull+" merged, but "+why)...)
|
||||
continue
|
||||
}
|
||||
vk := keptLevel(kv).ValueKey(kv.Key)
|
||||
v := Value{Value: compact(heldValue(kv)), By: kv.By, Via: kv.Via, Why: kv.Why + " (held for " + kv.Pull +
|
||||
", merged)", Approved: kv.Approved, At: c.now()}
|
||||
if err := c.Store.Put(ValuesState, vk, v); err != nil {
|
||||
said = append(said, fmt.Sprintf("%s of %s on %s held for %s is not written yet: %v; it is tried "+
|
||||
"again", kv.Key, kv.Module, kv.Node, kv.Pull, err))
|
||||
continue
|
||||
}
|
||||
if err := c.Store.Delete(KeptState, k); err != nil {
|
||||
said = append(said, "the held value "+k+" is written but not removed: "+err.Error())
|
||||
}
|
||||
wrote = true
|
||||
said = append(said, c.heldChange(kv, "set", kv.Pull+" merged: the held value is the module's own value now",
|
||||
kv.Approved)...)
|
||||
said = append(said, fmt.Sprintf("%s of %s on %s held for %s is set: %s", kv.Key, kv.Module, kv.Node,
|
||||
kv.Pull, kv.Value))
|
||||
}
|
||||
if wrote {
|
||||
if s2, err := c.sources(); err == nil {
|
||||
if _, err := c.writeResolved(s2); err != nil {
|
||||
said = append(said, "the resolved values are not all written yet ("+err.Error()+"); the next "+
|
||||
"resolution writes them")
|
||||
}
|
||||
}
|
||||
}
|
||||
left := 0
|
||||
for _, k := range sortedKeys(s.Kept) {
|
||||
if pullKey(s.Kept[k].Pull) != pullKey(pull) {
|
||||
continue
|
||||
}
|
||||
if e, err := c.Store.Get(KeptState, k); err != nil || e != nil {
|
||||
left++
|
||||
}
|
||||
}
|
||||
if left == 0 {
|
||||
if err := c.Store.Delete(PullsState, pullKey(pull)); err != nil {
|
||||
said = append(said, "the declarations of "+pull+" were not removed: "+err.Error())
|
||||
}
|
||||
}
|
||||
return said
|
||||
}
|
||||
|
||||
// PullEvent is a pull request merged or closed, as far as this module reads it: the seat `git`'s `pull-merged` or `pull-closed`
|
||||
// (design 47 G §654), read by pullEventOf.
|
||||
type PullEvent struct {
|
||||
Owner string
|
||||
Repo string
|
||||
Number int
|
||||
Merged bool
|
||||
// HeadSHA is the head the pull request merged at.
|
||||
HeadSHA string
|
||||
}
|
||||
|
||||
// pullEventOf reads the seat `git`'s `pull-merged` or `pull-closed` body: the repository `<owner>/<name>`, the number and the head.
|
||||
func pullEventOf(body []byte) (PullEvent, bool) {
|
||||
var e struct {
|
||||
Repository string `json:"repository"`
|
||||
Number int `json:"number"`
|
||||
Head string `json:"head"`
|
||||
}
|
||||
if json.Unmarshal(body, &e) != nil {
|
||||
return PullEvent{}, false
|
||||
}
|
||||
owner, repo, ok := strings.Cut(e.Repository, "/")
|
||||
return PullEvent{Owner: owner, Repo: repo, Number: e.Number, HeadSHA: e.Head}, ok
|
||||
}
|
||||
|
||||
func (p PullEvent) name() string { return fmt.Sprintf("%s/%s#%d", p.Owner, p.Repo, p.Number) }
|
||||
|
||||
// HeardPull takes the forge's word that a pull request merged or closed. A close is asked of the forge when it can
|
||||
// be, because a merged pull request may be announced as closed too.
|
||||
func (c *Config) HeardPull(p PullEvent, merged bool) []string {
|
||||
if p.Owner == "" || p.Repo == "" || p.Number <= 0 {
|
||||
return nil
|
||||
}
|
||||
head := p.HeadSHA
|
||||
if !merged && !p.Merged && c.Forge != nil {
|
||||
// A close is told from a merge by the forge; when it cannot be asked nothing is dropped, and the five-minute
|
||||
// look finds it.
|
||||
open, m, h, err := c.Forge.Pull(p.Owner, p.Repo, p.Number)
|
||||
if err != nil {
|
||||
c.logf("[mesh-config] %s closed, and the forge does not say whether it merged (%v); the next look decides", p.name(), err)
|
||||
return nil
|
||||
}
|
||||
if open {
|
||||
return nil
|
||||
}
|
||||
merged = m
|
||||
if head == "" {
|
||||
head = h
|
||||
}
|
||||
}
|
||||
return c.settlePull(p.name(), merged || p.Merged, head)
|
||||
}
|
||||
|
||||
// SweepPulls looks at the forge for every pull request it keeps something for, so a merge or a close it did not hear
|
||||
// is found: run with each five-minute resolution.
|
||||
func (c *Config) SweepPulls() []string {
|
||||
if c.Forge == nil {
|
||||
return nil
|
||||
}
|
||||
c.mu.Lock()
|
||||
var s Sources
|
||||
err := c.readPulls(&s)
|
||||
c.mu.Unlock()
|
||||
if err != nil {
|
||||
return []string{err.Error()}
|
||||
}
|
||||
seen := map[string]string{}
|
||||
for _, p := range s.Pulls {
|
||||
seen[pullKey(p.Pull)] = p.Pull
|
||||
}
|
||||
for _, k := range s.Kept {
|
||||
seen[pullKey(k.Pull)] = k.Pull
|
||||
}
|
||||
var said []string
|
||||
for _, key := range sortedKeys(seen) {
|
||||
pull := seen[key]
|
||||
owner, repo, n, err := parsePull(pull)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
open, merged, head, err := c.Forge.Pull(owner, repo, n)
|
||||
if err != nil {
|
||||
said = append(said, fmt.Sprintf("the forge does not say whether %s is open: %v", pull, err))
|
||||
continue
|
||||
}
|
||||
if !open {
|
||||
said = append(said, c.settlePull(pull, merged, head)...)
|
||||
}
|
||||
}
|
||||
return said
|
||||
}
|
||||
|
||||
// PullAt is a pull request at a head, as held asks about it.
|
||||
type PullAt struct {
|
||||
Pull string `json:"pull"`
|
||||
Head string `json:"head"`
|
||||
}
|
||||
|
||||
// toolForge asks the forge's holder through its tools.
|
||||
type toolForge struct {
|
||||
ask func(key string, body any) (json.RawMessage, error)
|
||||
}
|
||||
|
||||
// Pull asks the seat `git`'s verb `pull` whether a pull request is open, and whether it merged.
|
||||
func (f toolForge) Pull(owner, repo string, number int) (bool, bool, string, error) {
|
||||
raw, err := f.ask(GitPullAsk, map[string]any{"repository": owner + "/" + repo, "number": number})
|
||||
if err != nil {
|
||||
return false, false, "", err
|
||||
}
|
||||
answer, output, ok := unwrapAnswer(raw)
|
||||
if !ok {
|
||||
return false, false, "", fmt.Errorf("the seat git refused pull: %s", output)
|
||||
}
|
||||
var a struct {
|
||||
Pull struct {
|
||||
State string `json:"state"`
|
||||
Head string `json:"head"`
|
||||
} `json:"pull"`
|
||||
Error string `json:"error"`
|
||||
}
|
||||
if err := json.Unmarshal(answer, &a); err != nil || a.Error != "" || a.Pull.State == "" {
|
||||
return false, false, "", fmt.Errorf("the seat git's pull is not readable: %s", output)
|
||||
}
|
||||
return a.Pull.State == "open", a.Pull.State == "merged", a.Pull.Head, nil
|
||||
}
|
||||
|
||||
// GitPullAsk is the seat `git`'s verb that answers one pull request.
|
||||
const GitPullAsk = "seat:git.pull"
|
||||
|
||||
// unwrapAnswer reads a tool's answer whatever wraps it: the protocol's content list, or {output, ok, answer}.
|
||||
func unwrapAnswer(raw json.RawMessage) (json.RawMessage, string, bool) {
|
||||
var s string
|
||||
if json.Unmarshal(raw, &s) == nil {
|
||||
return unwrapAnswer(json.RawMessage(s))
|
||||
}
|
||||
var m map[string]json.RawMessage
|
||||
if json.Unmarshal(raw, &m) != nil {
|
||||
return raw, string(raw), true
|
||||
}
|
||||
if content, has := m["content"]; has {
|
||||
var items []struct {
|
||||
Text string `json:"text"`
|
||||
}
|
||||
var e struct {
|
||||
IsError bool `json:"isError"`
|
||||
}
|
||||
_ = json.Unmarshal(raw, &e)
|
||||
if json.Unmarshal(content, &items) == nil && len(items) > 0 {
|
||||
inner, out, ok := unwrapAnswer(json.RawMessage(items[0].Text))
|
||||
return inner, out, ok && !e.IsError
|
||||
}
|
||||
}
|
||||
var v struct {
|
||||
Output string `json:"output"`
|
||||
OK *bool `json:"ok"`
|
||||
Answer json.RawMessage `json:"answer"`
|
||||
}
|
||||
if json.Unmarshal(raw, &v) == nil && v.OK != nil {
|
||||
return v.Answer, v.Output, *v.OK
|
||||
}
|
||||
return raw, string(raw), true
|
||||
}
|
||||
@@ -1,504 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.novox.be/novox/mesh-contracts/go/clients/meshconfigclient"
|
||||
|
||||
occ "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient"
|
||||
)
|
||||
|
||||
// Issue 1826 (novox/hq ADR 0502): a value held for the open pull request that introduces its key.
|
||||
|
||||
const thePull = "novox/mesh-catalog#434"
|
||||
|
||||
// n8nPullDeclares is what the controller tells of the pull request: n8n gets a required number media-gid.
|
||||
func n8nPullDeclares() map[string]any {
|
||||
return map[string]any{"n8n": map[string]any{"media-gid": map[string]any{"type": "number",
|
||||
"description": "the media group", "required": true, "minimum": 1, "maximum": 65535}}}
|
||||
}
|
||||
|
||||
// aHoldingMesh is a proposing mesh with n8n assigned to ace and declaring nothing on the trunk (the case of the
|
||||
// issue), and a stand-in forge.
|
||||
func aHoldingMesh(t *testing.T) (*Config, *memStore, *standIn, *standForge) {
|
||||
t.Helper()
|
||||
c, m, r := aProposingMesh(t)
|
||||
m.declare(t, "n8n", `{"module":"n8n","settings":{}}`)
|
||||
m.assign(t, "ace", "n8n")
|
||||
f := &standForge{state: map[string][2]bool{}}
|
||||
c.Forge = f
|
||||
if _, err := c.Reconcile(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
m.events, m.handActs = nil, nil
|
||||
return c, m, r, f
|
||||
}
|
||||
|
||||
type standForge struct {
|
||||
state map[string][2]bool // pull -> open, merged
|
||||
head string
|
||||
err error
|
||||
}
|
||||
|
||||
func (f *standForge) Pull(owner, repo string, n int) (bool, bool, string, error) {
|
||||
if f.err != nil {
|
||||
return false, false, "", f.err
|
||||
}
|
||||
st, ok := f.state[(PullEvent{Owner: owner, Repo: repo, Number: n}).name()]
|
||||
if !ok {
|
||||
return true, false, f.head, nil
|
||||
}
|
||||
return st[0], st[1], f.head, nil
|
||||
}
|
||||
|
||||
// tell keeps what a pull request's head declares as the indexer's candidate is taken (takeCandidates).
|
||||
func tell(t *testing.T, c *Config, pull, head string, declares map[string]any) *PullDeclaresAnswer {
|
||||
t.Helper()
|
||||
raw, _ := json.Marshal(declares)
|
||||
d := map[string]map[string]Declaration{}
|
||||
if err := json.Unmarshal(raw, &d); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
a, err := c.declarePull(pull, head, d)
|
||||
if err != nil {
|
||||
t.Fatalf("declare: %v", err)
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
// holdIt proposes media-gid=2000 for n8n on ace held for the pull request and has the operator approve it.
|
||||
func holdIt(t *testing.T, c *Config, m *memStore, r *standIn) string {
|
||||
t.Helper()
|
||||
a := propose(t, c, Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull,
|
||||
Why: "n8n's container joins the media group, held for #434"})
|
||||
r.choose(t, a.Proposal, OptionApprove, nil)
|
||||
said, err := c.Decide()
|
||||
if err != nil || len(said) != 1 || !strings.Contains(said[0], "approved by the operator and held") {
|
||||
t.Fatalf("the Approve decided %v (%v)", said, err)
|
||||
}
|
||||
return a.Proposal
|
||||
}
|
||||
|
||||
func keptCount(m *memStore) int { k, _ := m.Keys(KeptState); return len(k) }
|
||||
|
||||
// 1826/K1: mesh-config keeps what a pull request declares per pull request; pull-declares is gone (ADR 0590).
|
||||
func TestAPullRequestsDeclarationsAreKeptPerPullRequest(t *testing.T) {
|
||||
c, m, _, _ := aHoldingMesh(t)
|
||||
for _, caller := range []string{"g14.node-tools", Unproven, "", ControllerCaller} {
|
||||
if _, err := c.Do(Call{Action: "pull-declares", Pull: thePull, Head: "abc1234", Declares: n8nPullDeclares(),
|
||||
Caller: caller}); err == nil || !strings.Contains(err.Error(), "config-candidates") {
|
||||
t.Errorf("pull-declares from %q: %v", caller, err)
|
||||
}
|
||||
}
|
||||
a := tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
if len(a.Modules) != 1 || a.Modules[0] != "n8n" {
|
||||
t.Errorf("answered %+v", a)
|
||||
}
|
||||
e, _ := m.Get(PullsState, "novox.mesh-catalog.434")
|
||||
var pd PullDecl
|
||||
if e == nil || json.Unmarshal(e.Value, &pd) != nil || pd.Head != "abc1234def" ||
|
||||
pd.Declares["n8n"]["media-gid"].Type != "number" || !pd.Declares["n8n"]["media-gid"].Required {
|
||||
t.Errorf("kept %s", func() string {
|
||||
if e == nil {
|
||||
return "nothing"
|
||||
}
|
||||
return string(e.Value)
|
||||
}())
|
||||
}
|
||||
// Nothing is resolved from a pull request's declaration.
|
||||
if r, _ := m.Get(ResolvedState, ResolvedKey("ace", "n8n", "media-gid")); r != nil {
|
||||
t.Errorf("a pull request's declaration was resolved: %s", r.Value)
|
||||
}
|
||||
}
|
||||
|
||||
// 1826/K2: a proposal for a key only the pull request declares is refused without its declaration, for a mesh or
|
||||
// node level, for a clear, for an undeclared key, and for a module not placed on the node; and trunk-only
|
||||
// proposals are judged as before.
|
||||
func TestAProposalNamingAPullRequestIsJudgedAgainstItsDeclaration(t *testing.T) {
|
||||
c, m, _, _ := aHoldingMesh(t)
|
||||
try := func(call Call) error {
|
||||
call.Action, call.Caller, call.Why = "propose", "g14.node-tools", "held for 434"
|
||||
_, err := c.Propose(call)
|
||||
return err
|
||||
}
|
||||
base := Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull}
|
||||
if err := try(base); err == nil || !strings.Contains(err.Error(), "holds no declaration for "+thePull) {
|
||||
t.Errorf("without the pull request's declaration: %v", err)
|
||||
}
|
||||
// And without the pull argument it is the trunk's refusal, as before.
|
||||
plain := base
|
||||
plain.Pull = ""
|
||||
if err := try(plain); err == nil || !strings.Contains(err.Error(), `n8n declares no value "media-gid"`) {
|
||||
t.Errorf("the trunk's refusal changed: %v", err)
|
||||
}
|
||||
tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
for name, tc := range map[string]struct {
|
||||
mutate func(*Call)
|
||||
want string
|
||||
}{
|
||||
"a mesh level": {func(c *Call) { c.Module, c.Node = "", "" }, "a module's own value on one node"},
|
||||
"a node level": {func(c *Call) { c.Module = "" }, "a module's own value on one node"},
|
||||
"a clear": {func(c *Call) { c.Clear, c.Value = true, nil }, "a clear is not held"},
|
||||
"a key not added": {func(c *Call) { c.Key = "other" }, "does not add or change a value"},
|
||||
"a bad value": {func(c *Call) { c.Value = 0.0 }, "below the minimum"},
|
||||
"a wrong type": {func(c *Call) { c.Value = "2000" }, "is not a number"},
|
||||
"another node": {func(c *Call) { c.Node = "g14" }, "is not placed on g14"},
|
||||
"another pull": {func(c *Call) { c.Pull = "novox/mesh-catalog#435" }, "holds no declaration for"},
|
||||
"a malformed pull": {func(c *Call) { c.Pull = "434" }, "owner/repository#number"},
|
||||
} {
|
||||
call := base
|
||||
tc.mutate(&call)
|
||||
if err := try(call); err == nil || !strings.Contains(err.Error(), tc.want) {
|
||||
t.Errorf("%s: %v, want %q", name, err, tc.want)
|
||||
}
|
||||
}
|
||||
// A set or a clear through the verb takes no pull request.
|
||||
if _, err := c.Change(Call{Action: "set", Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull,
|
||||
Caller: "g14.node-tools", Why: "w"}); err == nil || !strings.Contains(err.Error(), "only a proposal") {
|
||||
t.Errorf("a set naming a pull request: %v", err)
|
||||
}
|
||||
if keptCount(m) != 0 {
|
||||
t.Error("something was held")
|
||||
}
|
||||
}
|
||||
|
||||
// 1826/K2: every held value is asked whatever the key's trust; the ask says it is held and dropped on a close; on
|
||||
// Approve the value is kept apart, never set or resolved; history, event and hand-act say it; held answers it.
|
||||
func TestAHeldValueIsAskedAndKeptApartOnApprove(t *testing.T) {
|
||||
c, m, r, _ := aHoldingMesh(t)
|
||||
tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
a := propose(t, c, Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull, Why: "held for #434"})
|
||||
if len(a.Reaches) != 0 {
|
||||
t.Errorf("a held value reaches %v", a.Reaches)
|
||||
}
|
||||
ask := r.asks[a.Proposal]
|
||||
if err := occ.Check(ask, c.now()); err != nil {
|
||||
t.Fatalf("the ask: %v", err)
|
||||
}
|
||||
for _, want := range []string{thePull, "merges", "dropped if it closes unmerged", "media-gid", "n8n", "ace"} {
|
||||
if !strings.Contains(ask.Explanation, want) {
|
||||
t.Errorf("the ask does not say %q:\n%s", want, ask.Explanation)
|
||||
}
|
||||
}
|
||||
if strings.Contains(ask.Explanation, "takes effect at once") || !strings.Contains(ask.Headline, "Hold") {
|
||||
t.Errorf("the ask: %q\n%s", ask.Headline, ask.Explanation)
|
||||
}
|
||||
if ap := ask.Options[0]; !strings.Contains(ap.Does, thePull) || ap.Level == "" {
|
||||
t.Errorf("the approve option does %q", ap.Does)
|
||||
}
|
||||
if keptCount(m) != 0 {
|
||||
t.Fatal("a proposal held something")
|
||||
}
|
||||
r.choose(t, a.Proposal, OptionApprove, nil)
|
||||
said, _ := c.Decide()
|
||||
if len(said) != 1 || !strings.Contains(said[0], "held at abc1234d for "+thePull) {
|
||||
t.Fatalf("decided %v", said)
|
||||
}
|
||||
// Kept apart: not a value, not resolved.
|
||||
if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set {
|
||||
t.Error("an Approve set the value")
|
||||
}
|
||||
if e, _ := m.Get(ResolvedState, ResolvedKey("ace", "n8n", "media-gid")); e != nil {
|
||||
t.Errorf("an Approve resolved the value: %s", e.Value)
|
||||
}
|
||||
if keptCount(m) != 1 {
|
||||
t.Fatalf("%d values held", keptCount(m))
|
||||
}
|
||||
if len(m.events) != 1 || m.events[0].Action != ActionHold || m.events[0].Pull != thePull ||
|
||||
m.events[0].Key != "media-gid" || m.events[0].Head != "abc1234def" || len(m.events[0].Moved) != 0 ||
|
||||
!strings.Contains(m.events[0].Approved, "approved by the operator") {
|
||||
t.Errorf("raised %+v", m.events)
|
||||
}
|
||||
if len(m.handActs) != 1 || !strings.Contains(m.handActs[0], thePull) {
|
||||
t.Errorf("hand-acts %q", m.handActs)
|
||||
}
|
||||
h, _ := c.History(Call{Module: "n8n", Node: "ace"})
|
||||
if len(h) != 1 || h[0].Action != ActionHold || h[0].Pull != thePull {
|
||||
t.Errorf("history %+v", h)
|
||||
}
|
||||
// held answers it, at the head it is kept at, to the controller alone.
|
||||
if _, err := c.Do(Call{Action: "held", Caller: "g14.node-tools", Pulls: []PullAt{{thePull, "abc1234def"}}}); err == nil {
|
||||
t.Error("held answered a caller that is not the controller")
|
||||
}
|
||||
got, err := c.Do(Call{Action: "held", Caller: ControllerCaller, Pulls: []PullAt{{thePull, "abc1234def"}}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ha := got.(*HeldAnswer)
|
||||
if len(ha.Held) != 1 || ha.Held[0].Module != "n8n" || ha.Held[0].Node != "ace" || ha.Held[0].Key != "media-gid" ||
|
||||
string(ha.Held[0].Value) != "2000" || !strings.Contains(ha.Held[0].Approved, "approved by the operator") ||
|
||||
ha.Held[0].Pull != thePull || len(ha.Skipped) != 0 {
|
||||
t.Errorf("held answered %+v", ha)
|
||||
}
|
||||
// Another head, and another pull request, are not answered.
|
||||
got, _ = c.Do(Call{Action: "held", Caller: ControllerCaller,
|
||||
Pulls: []PullAt{{thePull, "ffff0000"}, {"novox/mesh-catalog#435", "abc"}}})
|
||||
if ha = got.(*HeldAnswer); len(ha.Held) != 0 || len(ha.Skipped) != 1 || !strings.Contains(ha.Skipped[0].Why, "held at") {
|
||||
t.Errorf("held at another head answered %+v", ha)
|
||||
}
|
||||
// The listing shows it as held, and the proposal as held for the pull request.
|
||||
l, _ := c.List(Call{Module: "n8n"})
|
||||
if len(l.Held) != 1 || len(l.Set) != 0 {
|
||||
t.Errorf("the listing: held %+v set %+v", l.Held, l.Set)
|
||||
}
|
||||
rows, _ := c.Proposals(Call{})
|
||||
if len(rows) != 1 || rows[0].Pull != thePull || rows[0].State != ProposalApproved {
|
||||
t.Errorf("proposals %+v", rows)
|
||||
}
|
||||
}
|
||||
|
||||
// 1826/K2: an Approve is refused when the pull request's declaration changed after the operator was shown it.
|
||||
func TestAnApproveOfAHeldValueIsRefusedWhenTheDeclarationChanged(t *testing.T) {
|
||||
c, m, r, _ := aHoldingMesh(t)
|
||||
tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
a := propose(t, c, Call{Module: "n8n", Node: "ace", Key: "media-gid", Value: 2000.0, Pull: thePull, Why: "w"})
|
||||
changed := n8nPullDeclares()
|
||||
changed["n8n"].(map[string]any)["media-gid"].(map[string]any)["maximum"] = 1000.0
|
||||
tell(t, c, thePull, "def5678abc", changed)
|
||||
r.choose(t, a.Proposal, OptionApprove, nil)
|
||||
said, _ := c.Decide()
|
||||
if len(said) != 1 || !strings.Contains(said[0], "nothing is held") || keptCount(m) != 0 {
|
||||
t.Errorf("decided %v; %d held", said, keptCount(m))
|
||||
}
|
||||
}
|
||||
|
||||
// 1826/K1: at a new head a held value is kept if its key is declared the same and it still passes; otherwise it is
|
||||
// dropped, recorded, raised and said.
|
||||
func TestANewHeadKeepsAHeldValueOnlyWhileItsDeclarationIsUnchanged(t *testing.T) {
|
||||
c, m, r, _ := aHoldingMesh(t)
|
||||
tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
holdIt(t, c, m, r)
|
||||
m.events = nil
|
||||
|
||||
// The same declaration at a new head (the description may differ): kept, moved to the new head.
|
||||
same := n8nPullDeclares()
|
||||
same["n8n"].(map[string]any)["media-gid"].(map[string]any)["description"] = "reworded"
|
||||
if a := tell(t, c, thePull, "1111111111", same); len(a.Dropped) != 0 {
|
||||
t.Errorf("an unchanged declaration dropped %v", a.Dropped)
|
||||
}
|
||||
got, _ := c.Do(Call{Action: "held", Caller: ControllerCaller, Pulls: []PullAt{{thePull, "1111111111"}}})
|
||||
if len(got.(*HeldAnswer).Held) != 1 || len(m.events) != 0 {
|
||||
t.Errorf("after an unchanged head: %+v, events %+v", got, m.events)
|
||||
}
|
||||
|
||||
// A changed declaration: dropped.
|
||||
changed := n8nPullDeclares()
|
||||
changed["n8n"].(map[string]any)["media-gid"].(map[string]any)["maximum"] = 1000.0
|
||||
a := tell(t, c, thePull, "2222222222", changed)
|
||||
if len(a.Dropped) != 1 || !strings.Contains(a.Dropped[0], "declares the key otherwise") || keptCount(m) != 0 {
|
||||
t.Fatalf("a changed declaration: %+v, %d held", a, keptCount(m))
|
||||
}
|
||||
if len(m.events) != 1 || m.events[0].Action != ActionDrop || m.events[0].Pull != thePull {
|
||||
t.Errorf("raised %+v", m.events)
|
||||
}
|
||||
got, _ = c.Do(Call{Action: "held", Caller: ControllerCaller, Pulls: []PullAt{{thePull, "2222222222"}}})
|
||||
if len(got.(*HeldAnswer).Held) != 0 {
|
||||
t.Error("a dropped value was answered")
|
||||
}
|
||||
|
||||
// A head that no longer adds the key drops it too.
|
||||
tell(t, c, thePull, "3333333333", n8nPullDeclares())
|
||||
holdIt(t, c, m, r)
|
||||
if a = tell(t, c, thePull, "4444444444", map[string]any{}); len(a.Dropped) != 1 ||
|
||||
!strings.Contains(a.Dropped[0], "no longer adds or changes") {
|
||||
t.Errorf("a head without the key: %+v", a)
|
||||
}
|
||||
}
|
||||
|
||||
// 1826/K3: the merge writes the held value as the module's own value with its approval kept, before the trunk
|
||||
// declares the key; it resolves right after the declared-config mirror moves.
|
||||
func TestTheMergeAppliesAHeldValueAndItResolvesOnceTheTrunkDeclaresTheKey(t *testing.T) {
|
||||
c, m, r, _ := aHoldingMesh(t)
|
||||
tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
holdIt(t, c, m, r)
|
||||
approved := func() string {
|
||||
raw, _ := m.Get(KeptState, "novox.mesh-catalog.434.ace.n8n.media-gid")
|
||||
// the state kept is the seat's layout, under the seat's key: the checker and the assigner read it with this
|
||||
k, err := meshconfigclient.DecodeKept("novox.mesh-catalog.434.ace.n8n.media-gid", raw.Value)
|
||||
if err != nil || string(heldValue(k)) != "2000" || k.Declaration == "" || k.At == nil {
|
||||
t.Fatalf("the held value is not the seat's: %+v, %v", k, err)
|
||||
}
|
||||
return k.Approved
|
||||
}()
|
||||
m.events, m.handActs = nil, nil
|
||||
|
||||
said := c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: "abc1234def"}, true)
|
||||
if len(said) == 0 {
|
||||
t.Fatal("the merge said nothing")
|
||||
}
|
||||
v, set := storedValue(t, m, "module.ace.n8n.media-gid")
|
||||
if !set || string(v.Value) != "2000" || v.Approved != approved || v.Approved == "" || v.By != "the operator" ||
|
||||
!strings.Contains(v.Why, thePull) {
|
||||
t.Fatalf("the merge wrote %+v", v)
|
||||
}
|
||||
if keptCount(m) != 0 {
|
||||
t.Error("the value is still held after the merge")
|
||||
}
|
||||
if p, _ := m.Keys(PullsState); len(p) != 0 {
|
||||
t.Errorf("the pull request's declarations are still kept: %v", p)
|
||||
}
|
||||
if len(m.events) != 1 || m.events[0].Action != "set" || m.events[0].Pull != thePull ||
|
||||
m.events[0].Approved != approved || len(m.handActs) != 1 {
|
||||
t.Errorf("raised %+v, recorded %q", m.events, m.handActs)
|
||||
}
|
||||
// Not resolved before the trunk declares it.
|
||||
if e, _ := m.Get(ResolvedState, ResolvedKey("ace", "n8n", "media-gid")); e != nil {
|
||||
t.Errorf("resolved before the trunk declares the key: %s", e.Value)
|
||||
}
|
||||
m.declare(t, "n8n", `{"module":"n8n","settings":{"media-gid":{"kind":"","default":null,"why":"",`+
|
||||
`"type":"number","required":true,"minimum":1,"maximum":65535}}}`)
|
||||
if _, err := c.Reconcile(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if res := m.resolved(t, "ace", "n8n", "media-gid"); string(res.Value) != "2000" || res.Source != SourceModule {
|
||||
t.Errorf("media-gid resolves as %+v", res)
|
||||
}
|
||||
l, _ := c.List(Call{Module: "n8n", Node: "ace"})
|
||||
if len(l.Set) != 1 || l.Set[0].Approved != approved || len(l.Held) != 0 {
|
||||
t.Errorf("the listing: set %+v held %+v", l.Set, l.Held)
|
||||
}
|
||||
// A merge heard twice sets nothing twice.
|
||||
m.events = nil
|
||||
c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: "abc1234def"}, true)
|
||||
if len(m.events) != 0 {
|
||||
t.Errorf("a second merge raised %+v", m.events)
|
||||
}
|
||||
}
|
||||
|
||||
// 1826/K3: a pull request closed unmerged drops its held values and says so; nothing is set or resolved.
|
||||
func TestAClosedPullRequestDropsItsHeldValuesAndSaysSo(t *testing.T) {
|
||||
c, m, r, f := aHoldingMesh(t)
|
||||
tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
holdIt(t, c, m, r)
|
||||
m.events = nil
|
||||
f.state[thePull] = [2]bool{false, false}
|
||||
said := c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434}, false)
|
||||
if len(said) == 0 || !strings.Contains(strings.Join(said, "\n"), "closed unmerged: dropped, nothing was set") {
|
||||
t.Errorf("said %v", said)
|
||||
}
|
||||
if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set || keptCount(m) != 0 {
|
||||
t.Error("a closed pull request left a value")
|
||||
}
|
||||
if len(m.events) != 1 || m.events[0].Action != ActionDrop || m.events[0].Pull != thePull ||
|
||||
!strings.Contains(m.events[0].Why, "closed unmerged") {
|
||||
t.Errorf("raised %+v", m.events)
|
||||
}
|
||||
if p, _ := m.Keys(PullsState); len(p) != 0 {
|
||||
t.Errorf("declarations of a closed pull request kept: %v", p)
|
||||
}
|
||||
}
|
||||
|
||||
// 1826/K3: a close event for a pull request the forge says merged is the merge.
|
||||
func TestACloseEventForAMergedPullRequestIsItsMerge(t *testing.T) {
|
||||
c, m, r, f := aHoldingMesh(t)
|
||||
tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
holdIt(t, c, m, r)
|
||||
f.state[thePull] = [2]bool{false, true}
|
||||
f.head = "abc1234def"
|
||||
c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434}, false)
|
||||
if v, set := storedValue(t, m, "module.ace.n8n.media-gid"); !set || string(v.Value) != "2000" {
|
||||
t.Errorf("the merge of a pull request announced closed set %+v", v)
|
||||
}
|
||||
}
|
||||
|
||||
// 1826/K3: the five-minute look finds a merge, a close, and an open pull request, and says a forge that does not
|
||||
// answer.
|
||||
func TestTheLookAtTheForgeFindsAMissedMergeOrCloseAndLeavesAnOpenPullRequest(t *testing.T) {
|
||||
c, m, r, f := aHoldingMesh(t)
|
||||
tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
holdIt(t, c, m, r)
|
||||
if said := c.SweepPulls(); len(said) != 0 || keptCount(m) != 1 {
|
||||
t.Errorf("an open pull request: said %v, %d held", said, keptCount(m))
|
||||
}
|
||||
f.err = errors.New("the forge is down")
|
||||
if said := c.SweepPulls(); len(said) != 1 || !strings.Contains(said[0], "does not say whether") || keptCount(m) != 1 {
|
||||
t.Errorf("a silent forge: said %v", said)
|
||||
}
|
||||
f.err = nil
|
||||
f.head = "abc1234def"
|
||||
f.state[thePull] = [2]bool{false, true}
|
||||
c.SweepPulls()
|
||||
if v, set := storedValue(t, m, "module.ace.n8n.media-gid"); !set || string(v.Value) != "2000" || keptCount(m) != 0 {
|
||||
t.Errorf("a missed merge: %+v", v)
|
||||
}
|
||||
// A missed close.
|
||||
tell(t, c, "novox/mesh-catalog#440", "abc", n8nPullDeclares())
|
||||
f.state["novox/mesh-catalog#440"] = [2]bool{false, false}
|
||||
c.SweepPulls()
|
||||
if p, _ := m.Keys(PullsState); len(p) != 0 {
|
||||
t.Errorf("a missed close left %v", p)
|
||||
}
|
||||
}
|
||||
|
||||
// 1826/K1: the new arguments are read strictly and the new actions are the verb's.
|
||||
func TestThePullArgumentsAreRead(t *testing.T) {
|
||||
call, err := callOf(map[string]any{"action": "pull-declares", "pull": " " + thePull + " ", "head": "abc",
|
||||
"declares": map[string]any{"n8n": map[string]any{}}, "pulls": []any{map[string]any{"pull": thePull, "head": "h"}}})
|
||||
if err != nil || call.Pull != thePull || call.Head != "abc" || len(call.Declares) != 1 || len(call.Pulls) != 1 ||
|
||||
call.Pulls[0].Head != "h" {
|
||||
t.Errorf("read %+v (%v)", call, err)
|
||||
}
|
||||
if _, err := callOf(map[string]any{"declares": "x"}); err == nil {
|
||||
t.Error("declares that is not an object was read")
|
||||
}
|
||||
if _, err := callOf(map[string]any{"pulls": "x"}); err == nil {
|
||||
t.Error("pulls that is not a list was read")
|
||||
}
|
||||
if _, err := callOf(map[string]any{"bogus": 1}); err == nil || !strings.Contains(err.Error(), "pull") {
|
||||
t.Errorf("an unknown argument: %v", err)
|
||||
}
|
||||
_ = time.Second
|
||||
}
|
||||
|
||||
// 1826 review r1: the merge applies a value only if it is held at the merged head; otherwise it is dropped and said.
|
||||
func TestTheMergeAppliesOnlyAValueHeldAtTheMergedHead(t *testing.T) {
|
||||
for name, head := range map[string]string{"another head": "9999999999", "no head told": ""} {
|
||||
c, m, r, _ := aHoldingMesh(t)
|
||||
tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
holdIt(t, c, m, r)
|
||||
said := c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: head}, true)
|
||||
if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set || keptCount(m) != 0 ||
|
||||
!strings.Contains(strings.Join(said, "\n"), "dropped, nothing was set") {
|
||||
t.Errorf("%s: set=%v held=%d said %v", name, set, keptCount(m), said)
|
||||
}
|
||||
if len(m.events) == 0 || m.events[len(m.events)-1].Action != ActionDrop {
|
||||
t.Errorf("%s: raised %+v", name, m.events)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 1826 review r1: a later head without the declaration drops the value, so the merge has nothing to apply.
|
||||
func TestALaterHeadWithoutTheDeclarationLeavesNothingToApplyAtTheMerge(t *testing.T) {
|
||||
c, m, r, _ := aHoldingMesh(t)
|
||||
tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
holdIt(t, c, m, r)
|
||||
tell(t, c, thePull, "bbbbbbbbbb", map[string]any{})
|
||||
c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434, Merged: true, HeadSHA: "bbbbbbbbbb"}, true)
|
||||
if _, set := storedValue(t, m, "module.ace.n8n.media-gid"); set {
|
||||
t.Error("a value held for a declaration the merged head lacks was set")
|
||||
}
|
||||
}
|
||||
|
||||
// 1826 review r1: a close the forge cannot be asked about drops nothing; the five-minute look decides.
|
||||
func TestACloseThatTheForgeCannotBeAskedAboutDropsNothing(t *testing.T) {
|
||||
c, m, r, f := aHoldingMesh(t)
|
||||
tell(t, c, thePull, "abc1234def", n8nPullDeclares())
|
||||
holdIt(t, c, m, r)
|
||||
f.err = errors.New("the forge is down")
|
||||
c.HeardPull(PullEvent{Owner: "novox", Repo: "mesh-catalog", Number: 434}, false)
|
||||
if keptCount(m) != 1 {
|
||||
t.Fatal("a close the forge could not confirm dropped the value")
|
||||
}
|
||||
f.err = nil
|
||||
f.state[thePull] = [2]bool{false, false}
|
||||
c.SweepPulls()
|
||||
if keptCount(m) != 0 {
|
||||
t.Error("the look did not drop it")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
//go:build integration
|
||||
|
||||
package main
|
||||
|
||||
// Issue 1982, against a real bus: mesh-config whole asks the bus for nothing while no input of it changes, and a changed input
|
||||
// resolves only what it touches. The binary runs as the node's tool runtime plays it (whole_integration_test.go), and every
|
||||
// request it makes of the runtime is counted: what a state read, a watch and a write ask of the bus.
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/nats-io/nats.go"
|
||||
"github.com/nats-io/nats.go/jetstream"
|
||||
|
||||
"git.novox.be/novox/mesh-sdk/go/testbus"
|
||||
)
|
||||
|
||||
func (p *player) snapshot() (calls map[string]int, puts []string) {
|
||||
p.mu.Lock()
|
||||
defer p.mu.Unlock()
|
||||
calls = map[string]int{}
|
||||
for k, v := range p.calls {
|
||||
calls[k] = v
|
||||
}
|
||||
return calls, slices.Clone(p.puts)
|
||||
}
|
||||
|
||||
// asked is how many requests of these methods the module made between two snapshots.
|
||||
func asked(before, after map[string]int, methods ...string) int {
|
||||
n := 0
|
||||
for _, m := range methods {
|
||||
n += after[m] - before[m]
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func TestConfigWholeAsksTheBusForNothingWhileNoInputChanges(t *testing.T) {
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
t.Cleanup(cancel)
|
||||
bin := filepath.Join(t.TempDir(), Module)
|
||||
build := exec.Command("go", "build", "-o", bin, ".")
|
||||
build.Stderr = os.Stderr
|
||||
if err := build.Run(); err != nil {
|
||||
t.Fatalf("mesh-config does not build: %v", err)
|
||||
}
|
||||
nc, err := nats.Connect(testbus.URL(t))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(nc.Close)
|
||||
js, err := jetstream.New(nc)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
buckets := []string{"mesh-delivery-assigner_assignments", "mesh-delivery-assigner_wants", "mesh-delivery-indexer_predefined"}
|
||||
for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, DeclaredState,
|
||||
RenamesState, RetiringState, FindingsState} {
|
||||
buckets = append(buckets, Module+"_"+s)
|
||||
}
|
||||
for _, b := range buckets {
|
||||
if _, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: b, History: 2}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
haves := map[string]string{"g14.player": fpOf("player", fp1), "novox.player": fpOf("player", fp1), "g14.radio": fpOf("radio", fp1)}
|
||||
p := start(t, bin, js, newStandIn(), haves, nil)
|
||||
p.viewsReady()
|
||||
|
||||
const radio = `{"module":"radio","config":{"band":{"type":"number","default":1}}}`
|
||||
p.manifestIn("player", oldPlayer)
|
||||
p.manifestIn("radio", radio)
|
||||
p.buildIn("g14", "player", fpOf("player", fp1), oldPlayer)
|
||||
p.buildIn("novox", "player", fpOf("player", fp1), oldPlayer)
|
||||
p.buildIn("g14", "radio", fpOf("radio", fp1), radio)
|
||||
p.placed("g14", "player", "radio")
|
||||
p.placed("novox", "player")
|
||||
p.hearsTheViews()
|
||||
eventually(t, "every value is resolved", func() bool {
|
||||
a, okA := resolvedValue(p, "g14", "player", "volume")
|
||||
b, okB := resolvedValue(p, "novox", "player", "volume")
|
||||
c, okC := resolvedValue(p, "g14", "radio", "band")
|
||||
return okA && okB && okC && a == "5" && b == "5" && c == "1"
|
||||
})
|
||||
// The passes the setup moved have ended when the module answers a tool: it takes its lock for none.
|
||||
if _, err := p.call(ResyncTool, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// No input changes: the delivery says it delivered and a node-engine says what it reads, with no rename window open and no retirement
|
||||
// waiting. Each is heard and none is a pass: nothing is asked of the bus. (The module has no polling timer; its one deadline
|
||||
// timer is set for a real deadline, and none is near.)
|
||||
before, putsBefore := p.snapshot()
|
||||
for i := 0; i < 20; i++ {
|
||||
p.event("mesh-delivery-view.delivered", map[string]any{"revision": "r"})
|
||||
p.event("node-engine.manifest-reads-changed", map[string]any{"node": "g14"})
|
||||
}
|
||||
after, putsAfter := p.snapshot()
|
||||
p.noGitAsk()
|
||||
if n := asked(before, after, "mesh/state.get", "mesh/state.keys", "mesh/state.watch", "mesh/state.put", "mesh/state.create",
|
||||
"mesh/state.update", "mesh/state.delete", "mesh/ask"); n != 0 || len(putsAfter) != len(putsBefore) {
|
||||
t.Errorf("40 events that move nothing asked %d requests of the bus (%v); wrote %v", n, after, putsAfter[len(putsBefore):])
|
||||
}
|
||||
|
||||
// One input changes: player's manifest declares a second value. Only player's values on its two nodes are written, and `declared`
|
||||
// for player; radio's resolved values are not written again, and nothing is read key by key.
|
||||
before, putsBefore = p.snapshot()
|
||||
const gain = `{"module":"player","config":{"volume":{"type":"number","default":5},"gain":{"type":"number","default":2}}}`
|
||||
p.manifestIn("player", gain)
|
||||
eventually(t, "the new value is resolved on both nodes", func() bool {
|
||||
a, okA := resolvedValue(p, "g14", "player", "gain")
|
||||
b, okB := resolvedValue(p, "novox", "player", "gain")
|
||||
return okA && okB && a == "2" && b == "2"
|
||||
})
|
||||
after, putsAfter = p.snapshot()
|
||||
var wrote []string
|
||||
for _, w := range putsAfter[len(putsBefore):] {
|
||||
wrote = append(wrote, strings.TrimPrefix(w, "mesh/state."))
|
||||
}
|
||||
for _, w := range wrote {
|
||||
if !strings.Contains(w, ResolvedState+"/g14.player.") && !strings.Contains(w, ResolvedState+"/novox.player.") &&
|
||||
!strings.Contains(w, DeclaredState+"/player") {
|
||||
t.Errorf("a changed manifest of player wrote %q, which is not player's", w)
|
||||
}
|
||||
}
|
||||
if n := asked(before, after, "mesh/state.get", "mesh/state.keys", "mesh/state.watch"); n != 0 {
|
||||
t.Errorf("a changed manifest read %d keys of the bus's states one by one (%v)", n, after)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,353 @@
|
||||
package main
|
||||
|
||||
// What mesh-config asks of the bus per input (issue 1982): its own states are read from the copy their watches keep, an event
|
||||
// that moves nothing reads nothing, and the one timer left is a deadline.
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
occ "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient"
|
||||
oc "git.novox.be/novox/mesh-contracts/operator-and-conversation/go/seats/operatorchannel"
|
||||
stdio "git.novox.be/novox/mesh-sdk/go"
|
||||
)
|
||||
|
||||
// countingStore counts the reads of the states by state: what the bus would be asked.
|
||||
type countingStore struct {
|
||||
*memStore
|
||||
mu sync.Mutex
|
||||
reads map[string]int
|
||||
}
|
||||
|
||||
func (s *countingStore) Get(state, key string) (*Entry, error) {
|
||||
s.mu.Lock()
|
||||
s.reads[state]++
|
||||
s.mu.Unlock()
|
||||
return s.memStore.Get(state, key)
|
||||
}
|
||||
|
||||
func (s *countingStore) Keys(state string) ([]string, error) {
|
||||
s.mu.Lock()
|
||||
s.reads[state]++
|
||||
s.mu.Unlock()
|
||||
return s.memStore.Keys(state)
|
||||
}
|
||||
|
||||
// readsOf is the reads of every state but those named.
|
||||
func (s *countingStore) readsExcept(states ...string) map[string]int {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
out := map[string]int{}
|
||||
for k, n := range s.reads {
|
||||
out[k] = n
|
||||
}
|
||||
for _, k := range states {
|
||||
delete(out, k)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// **An event that moves nothing reads nothing but what it judges** (design 32 *A config value renamed*, *A value no longer
|
||||
// read*): with no rename window open, `delivered` and `manifest-reads-changed` read no source, and a `manifest-accepted`
|
||||
// whose rows are all marked or read again reads none either. Each was a read of every key of every state of the module
|
||||
// (about 4,000 requests) under a delivery's burst of events.
|
||||
func TestAnEventThatMovesNothingReadsNoSource(t *testing.T) {
|
||||
c, m, d, _, _, _ := retiringMesh(t)
|
||||
cs := &countingStore{memStore: m, reads: map[string]int{}}
|
||||
c.Store = cs
|
||||
d.rows = []ReaderRow{{Module: "player", Key: "volume", Kind: KindValue, Readers: []string{"g14"}}} // read: nothing to retire
|
||||
for name, event := range map[string]func(){
|
||||
"delivered": func() { c.Windows("") },
|
||||
"manifest-reads-changed": func() { c.Windows("g14") },
|
||||
"manifest-accepted": func() { c.Retirements("player") },
|
||||
} {
|
||||
cs.reads = map[string]int{}
|
||||
event()
|
||||
if got := cs.readsExcept(RenamesState, RetiringState); len(got) != 0 {
|
||||
t.Errorf("%s read %v", name, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// An open window is judged, and reads what judging it needs: the same event with a window open reads the sources.
|
||||
func TestAnEventWithAWindowOpenJudgesIt(t *testing.T) {
|
||||
c, m, _, _ := aRenamingMesh(t)
|
||||
m.declare(t, "player", newPlayer)
|
||||
if _, err := c.Reconcile(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cs := &countingStore{memStore: m, reads: map[string]int{}}
|
||||
c.Store = cs
|
||||
c.Windows("")
|
||||
if cs.reads[ValuesState] == 0 {
|
||||
t.Errorf("an open window was judged on no source: %v", cs.reads)
|
||||
}
|
||||
}
|
||||
|
||||
// **An ask of a retirement that ends with no choice is taken when the router says so** (design 32 *A value no longer read*):
|
||||
// with no minute's look at the router's record, the `decided` event of an ask that expired moves the retirement.
|
||||
func TestARetirementWhoseAskExpiredIsTakenOnTheRoutersWord(t *testing.T) {
|
||||
c, m, d, r, _, _ := retiringMesh(t)
|
||||
for _, node := range []string{"g14", "novox"} {
|
||||
m.want(t, node, "player", fp3, donePlayer)
|
||||
d.haves[node+".player"] = fp3
|
||||
}
|
||||
c.Windows("")
|
||||
c.Retirements("player")
|
||||
rows := retiringOf(t, c)
|
||||
if len(rows) != 1 || rows[0].State != RetireAsked {
|
||||
t.Fatalf("retiring %+v, want asked", rows)
|
||||
}
|
||||
r.choose(t, rows[0].Ask, OptionApprove, func(w *oc.Warrant) { w.Outcome = occ.OutcomeExpired })
|
||||
c.HeardEnd(oc.Warrant{Ask: rows[0].Ask, Asker: Module, Outcome: occ.OutcomeExpired})
|
||||
if rows = retiringOf(t, c); rows[0].State != RetireUnanswered {
|
||||
t.Errorf("after the router said the ask expired: %+v", rows)
|
||||
}
|
||||
}
|
||||
|
||||
// The next deadline is the earliest of a waiting proposal's (an hour past its ask lapsing, with no record at the router)
|
||||
// and an unanswered retirement's (asked once more after HeldFinding); none when nothing waits on a time.
|
||||
func TestTheNextDeadlineIsTheEarliestOfWhatWaitsOnATime(t *testing.T) {
|
||||
m := newStore()
|
||||
c := &Config{Store: m, Catalog: m, Logf: t.Logf}
|
||||
if _, ok := c.NextDeadline(); ok {
|
||||
t.Fatal("a deadline with nothing waiting")
|
||||
}
|
||||
t0 := time.Date(2026, 11, 19, 10, 0, 0, 0, time.UTC)
|
||||
put := func(state, key string, v any) {
|
||||
if err := m.Put(state, key, v); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
put(ProposalsState, "p1", Proposal{ID: "p1", State: ProposalWaiting, At: t0.Add(48 * time.Hour)})
|
||||
put(ProposalsState, "p2", Proposal{ID: "p2", State: ProposalEnded, At: t0})
|
||||
want := t0.Add(48*time.Hour + ProposalLasts + time.Hour)
|
||||
if at, ok := c.NextDeadline(); !ok || !at.Equal(want) {
|
||||
t.Errorf("deadline %v, %v; want %v", at, ok, want)
|
||||
}
|
||||
put(RetiringState, "player.volume", Retiring{Module: "player", Key: "volume", State: RetireUnanswered, Asked: t0.Add(-6 * 24 * time.Hour)})
|
||||
want = t0.Add(HeldFinding - 6*24*time.Hour)
|
||||
if at, ok := c.NextDeadline(); !ok || !at.Equal(want) {
|
||||
t.Errorf("deadline %v, %v; want the retirement's %v", at, ok, want)
|
||||
}
|
||||
}
|
||||
|
||||
// busOf is a bus of states for the copy's tests: what each state holds, the watches handed out and the requests asked.
|
||||
type busOf struct {
|
||||
mu sync.Mutex
|
||||
held map[string]map[string][]byte
|
||||
handles map[string]func(stdio.StateChange) error
|
||||
watches int
|
||||
gets int
|
||||
writes int
|
||||
revision uint64
|
||||
}
|
||||
|
||||
func (b *busOf) ownCopy() *ownCopy {
|
||||
return &ownCopy{
|
||||
copy: stdio.WatchedStatesOver(func(state string, handle func(stdio.StateChange) error) error {
|
||||
b.mu.Lock()
|
||||
b.watches++
|
||||
b.handles[state] = handle
|
||||
current := map[string][]byte{}
|
||||
for k, v := range b.held[state] {
|
||||
current[k] = v
|
||||
}
|
||||
b.mu.Unlock()
|
||||
for k, v := range current {
|
||||
if err := handle(stdio.StateChange{State: state, Key: k, Op: stdio.OpPut, Value: v, Revision: 1, Current: true}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}, func(state, key string) ([]byte, bool, error) {
|
||||
b.mu.Lock()
|
||||
defer b.mu.Unlock()
|
||||
b.gets++
|
||||
v, ok := b.held[state][key]
|
||||
return v, ok, nil
|
||||
}),
|
||||
put: func(state, key string, value any) (uint64, error) {
|
||||
raw, _ := json.Marshal(value)
|
||||
b.mu.Lock()
|
||||
defer b.mu.Unlock()
|
||||
b.writes++
|
||||
b.revision++
|
||||
if b.held[state] == nil {
|
||||
b.held[state] = map[string][]byte{}
|
||||
}
|
||||
b.held[state][key] = raw
|
||||
return b.revision + 1, nil
|
||||
},
|
||||
del: func(state, key string) error {
|
||||
b.mu.Lock()
|
||||
defer b.mu.Unlock()
|
||||
b.writes++
|
||||
delete(b.held[state], key)
|
||||
return nil
|
||||
}}
|
||||
}
|
||||
|
||||
// **The module's own states are read from a copy, never key by key** (ADR 0580 §1, issue 1982): a whole state read of 1,176
|
||||
// keys is one watch and no get, again and again; this process's write is in the copy at once, another's arrives by the watch.
|
||||
func TestAnOwnStateIsReadFromItsWatchedCopyNotKeyByKey(t *testing.T) {
|
||||
b := &busOf{held: map[string]map[string][]byte{ValuesState: {}}, handles: map[string]func(stdio.StateChange) error{}}
|
||||
for i := 0; i < 1176; i++ {
|
||||
b.held[ValuesState]["mesh.key-"+time.Duration(i).String()] = []byte(`{"value":1}`)
|
||||
}
|
||||
n := len(b.held[ValuesState])
|
||||
own := b.ownCopy()
|
||||
for pass := 0; pass < 3; pass++ {
|
||||
keys, err := own.keys(ValuesState)
|
||||
if err != nil || len(keys) != n {
|
||||
t.Fatalf("keys %d, %v; want %d", len(keys), err, n)
|
||||
}
|
||||
for _, k := range keys {
|
||||
if e, err := own.get(ValuesState, k); err != nil || e == nil {
|
||||
t.Fatalf("get %s: %v, %v", k, e, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
if b.watches != 1 || b.gets != 0 {
|
||||
t.Errorf("3 passes over %d keys asked the bus for %d watches and %d gets; want 1 and 0", n, b.watches, b.gets)
|
||||
}
|
||||
// Its own write and removal are in the copy at once.
|
||||
if err := own.write(ValuesState, "mine", map[string]string{"x": "mine"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if e, _ := own.get(ValuesState, "mine"); e == nil {
|
||||
t.Error("a key just written is not read")
|
||||
}
|
||||
if err := own.remove(ValuesState, "mine"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if e, _ := own.get(ValuesState, "mine"); e != nil {
|
||||
t.Error("a key just removed is still read")
|
||||
}
|
||||
// Another writer's change arrives by the watch.
|
||||
if err := b.handles[ValuesState](stdio.StateChange{State: ValuesState, Key: "theirs", Op: stdio.OpPut, Value: []byte(`{"value":2}`), Revision: 99}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if e, _ := own.get(ValuesState, "theirs"); e == nil {
|
||||
t.Error("a change another wrote is not read")
|
||||
}
|
||||
if b.gets != 0 {
|
||||
t.Errorf("%d gets", b.gets)
|
||||
}
|
||||
}
|
||||
|
||||
// A write and a removal tell what waits on a deadline, once each.
|
||||
func TestAWriteTellsWhatWaitsOnADeadline(t *testing.T) {
|
||||
b := &busOf{held: map[string]map[string][]byte{}, handles: map[string]func(stdio.StateChange) error{}}
|
||||
own := b.ownCopy()
|
||||
var told []string
|
||||
own.changed = func(state string) { told = append(told, state) }
|
||||
if err := own.write(ProposalsState, "p", Proposal{ID: "p"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := own.remove(ProposalsState, "p"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(told) != 2 || told[0] != ProposalsState {
|
||||
t.Errorf("told %v", told)
|
||||
}
|
||||
}
|
||||
|
||||
// The mesh knows no pull request (design 47 G; ADR 0502 ended by the operator's word, record pending): the verb takes no `pull`,
|
||||
// `head`, `declares` or `pulls`, and does neither `pull-declares` nor `held`.
|
||||
func TestTheVerbKnowsNoPullRequest(t *testing.T) {
|
||||
for _, arg := range []string{"pull", "head", "declares", "pulls"} {
|
||||
if _, err := callOf(map[string]any{"action": "propose", arg: "x"}); err == nil || !strings.Contains(err.Error(), arg) {
|
||||
t.Errorf("an argument %s was taken: %v", arg, err)
|
||||
}
|
||||
}
|
||||
c, _ := aMesh(t)
|
||||
for _, action := range []string{"pull-declares", "held"} {
|
||||
if _, err := c.Do(Call{Action: action}); err == nil || !strings.Contains(err.Error(), action) {
|
||||
t.Errorf("the action %s was done: %v", action, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The deadline timer's floor is the setting deadline-floor-seconds, the default for a value that is not a positive number.
|
||||
func TestTheDeadlineFloorIsTheSettingOrItsDefault(t *testing.T) {
|
||||
for _, c := range []struct {
|
||||
raw string
|
||||
err error
|
||||
want time.Duration
|
||||
}{
|
||||
{`5`, nil, 5 * time.Second}, {`0`, nil, DefaultDeadlineFloor}, {`"x"`, nil, DefaultDeadlineFloor},
|
||||
{``, errors.New("not declared"), DefaultDeadlineFloor}, {`90`, nil, 90 * time.Second},
|
||||
} {
|
||||
if got := floorOf(json.RawMessage(c.raw), c.err); got != c.want {
|
||||
t.Errorf("floor of %q (%v) = %v, want %v", c.raw, c.err, got, c.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// **A rename window held seven days comes as a finding in a quiet mesh** (lead answer A-490l): the deadline is the window's
|
||||
// seventh day, the finding is written at it with no resolution pass, and a window that is not yet seven days old writes none.
|
||||
func TestAHeldWindowIsAFindingAtItsDeadlineWithNoPass(t *testing.T) {
|
||||
c, m, _, clock := aRenamingMesh(t)
|
||||
m.declare(t, "player", newPlayer)
|
||||
if _, err := c.Reconcile(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
at, ok := c.NextDeadline()
|
||||
if !ok || !at.Equal(clock.Add(HeldFinding)) {
|
||||
t.Fatalf("deadline %v, %v; want the window's seventh day %v", at, ok, clock.Add(HeldFinding))
|
||||
}
|
||||
if err := c.JudgeHeldWindows(); err != nil || len(findingsOf(t, m, FindingWindowHeld)) != 0 {
|
||||
t.Fatalf("a young window wrote a finding (%v)", err)
|
||||
}
|
||||
*clock = at
|
||||
cs := &countingStore{memStore: m, reads: map[string]int{}}
|
||||
c.Store = cs
|
||||
if err := c.JudgeHeldWindows(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if fs := findingsOf(t, m, FindingWindowHeld); len(fs) != 2 {
|
||||
t.Errorf("findings %+v, want one for each node holding the window", fs)
|
||||
}
|
||||
if got := cs.readsExcept(RenamesState); len(got) != 0 {
|
||||
t.Errorf("judging the held windows read %v", got)
|
||||
}
|
||||
if _, ok := c.NextDeadline(); ok {
|
||||
t.Error("a deadline is still set once the finding is written")
|
||||
}
|
||||
}
|
||||
|
||||
// A write of a proposal, a retirement or a rename window sets the deadline timer again, and no other state does: a window opened
|
||||
// after start, with nothing else waiting on a time, must not leave the timer blocked (A-490l).
|
||||
func TestAWriteOfARenameWindowRearmsTheDeadlineTimer(t *testing.T) {
|
||||
for state, want := range map[string]bool{ProposalsState: true, RetiringState: true, RenamesState: true,
|
||||
ValuesState: false, ResolvedState: false, DeclaredState: false} {
|
||||
if got := armsDeadline(state); got != want {
|
||||
t.Errorf("a write of %s arms the timer: %v, want %v", state, got, want)
|
||||
}
|
||||
}
|
||||
// Wired as main wires it: the copy's write of a window tells the channel the timer waits on.
|
||||
b := &busOf{held: map[string]map[string][]byte{}, handles: map[string]func(stdio.StateChange) error{}}
|
||||
own := b.ownCopy()
|
||||
rearm := make(chan struct{}, 1)
|
||||
own.changed = func(state string) {
|
||||
if armsDeadline(state) {
|
||||
select {
|
||||
case rearm <- struct{}{}:
|
||||
default:
|
||||
}
|
||||
}
|
||||
}
|
||||
if err := own.write(RenamesState, "player.level", Rename{Module: "player"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
select {
|
||||
case <-rearm:
|
||||
default:
|
||||
t.Error("a rename window written after start did not rearm the timer")
|
||||
}
|
||||
}
|
||||
@@ -293,14 +293,26 @@ func (c *Config) Windows(node string) []string {
|
||||
return said
|
||||
}
|
||||
|
||||
// windowOpen says whether any rename holds a window open on the node named, or on any node when none is named.
|
||||
func windowOpen(renames map[string]Rename, only string) bool {
|
||||
for _, r := range renames {
|
||||
for _, node := range r.Open() {
|
||||
if only == "" || only == node {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// closeWindows is Windows' rename half; the caller holds the lock.
|
||||
func (c *Config) closeWindows(only string) []string {
|
||||
renames, err := c.readRenames()
|
||||
if err != nil {
|
||||
return []string{"the renames cannot be read: " + err.Error()}
|
||||
}
|
||||
if c.Delivery == nil {
|
||||
return nil
|
||||
if c.Delivery == nil || !windowOpen(renames, only) {
|
||||
return nil // no window to judge: the delivery's word moves nothing, and no source is read for it (issue 1982)
|
||||
}
|
||||
s, err := c.sources()
|
||||
if err != nil {
|
||||
@@ -475,6 +487,20 @@ func (c *Config) RenameClose(module, to, node, why string) (any, error) {
|
||||
return map[string]any{"closed": node, "open": r.Open()}, nil
|
||||
}
|
||||
|
||||
// JudgeHeldWindows writes the finding of each window held open past HeldFinding, and clears one that is not, from the renames
|
||||
// kept: run at start and at the deadline the next window reaches (NextDeadline), so the finding comes in a quiet mesh too (lead
|
||||
// answer A-490l); it reads no source and asks nothing.
|
||||
func (c *Config) JudgeHeldWindows() error {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
renames, err := c.readRenames()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
c.sweepRenameFindings(&Sources{Renames: renames}, c.now())
|
||||
return nil
|
||||
}
|
||||
|
||||
// sweepRenameFindings writes a finding for each window held open past HeldFinding, naming the node, and clears one
|
||||
// whose window closed.
|
||||
func (c *Config) sweepRenameFindings(s *Sources, now time.Time) {
|
||||
|
||||
@@ -140,10 +140,6 @@ type Sources struct {
|
||||
Unresolved []Unresolved
|
||||
Predefined map[string]Published
|
||||
Values map[string]Value
|
||||
// Pulls is what the controller told of each open pull request's declarations, and Kept the approved values held
|
||||
// for them (pulls.go); neither is resolved.
|
||||
Pulls map[string]PullDecl
|
||||
Kept map[string]KeptValue
|
||||
// Renames are the renames kept, by `<module>.<to>`, whose open windows answer the old name (renames.go).
|
||||
Renames map[string]Rename
|
||||
}
|
||||
|
||||
@@ -148,9 +148,15 @@ func (c *Config) Retirements(module string) []string {
|
||||
if err != nil {
|
||||
return []string{"the retirements cannot be read: " + err.Error()}
|
||||
}
|
||||
s, err := c.sources()
|
||||
if err != nil {
|
||||
return []string{"the retirements cannot be judged: " + err.Error()}
|
||||
// The sources are read only when a row is one to judge: a row already marked, or read again, needs none (issue 1982).
|
||||
var s Sources
|
||||
for _, row := range rows {
|
||||
if _, has := held[retiringKey(module, row.Key)]; (row.Module == "" || row.Module == module) && (len(row.Readers) == 0 && !has) {
|
||||
if s, err = c.sources(); err != nil {
|
||||
return []string{"the retirements cannot be judged: " + err.Error()}
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
var said []string
|
||||
for _, row := range rows {
|
||||
|
||||
@@ -51,9 +51,6 @@ func (c *Config) sources() (Sources, error) {
|
||||
}); err != nil {
|
||||
return s, fmt.Errorf("the values cannot be read: %w", err)
|
||||
}
|
||||
if err := c.readPulls(&s); err != nil {
|
||||
return s, err
|
||||
}
|
||||
if renames, err := c.readRenames(); err != nil {
|
||||
return s, fmt.Errorf("the renames cannot be read: %w", err)
|
||||
} else {
|
||||
@@ -339,10 +336,8 @@ type Resolution struct {
|
||||
Moved []Moved `json:"moved"`
|
||||
Published string `json:"published,omitempty"`
|
||||
Withheld string `json:"withheld,omitempty"`
|
||||
// Declared are the modules whose `declared` key was written, and Candidates what the indexer's config candidates
|
||||
// did after the take-over.
|
||||
Declared []string `json:"declared,omitempty"`
|
||||
Candidates []string `json:"candidates,omitempty"`
|
||||
// Declared are the modules whose `declared` key was written.
|
||||
Declared []string `json:"declared,omitempty"`
|
||||
// Renamed is what the renames did in this pass.
|
||||
Renamed []string `json:"renamed,omitempty"`
|
||||
// SourceGone is said while the stored switch still names the controller, whose records are no longer read.
|
||||
@@ -383,9 +378,6 @@ func (c *Config) reconcileLocked() (Resolution, error) {
|
||||
} else if len(written) > 0 {
|
||||
r.Declared = written
|
||||
}
|
||||
if sw, serr := c.source(); serr == nil && sw.Source == SourceIndexer {
|
||||
r.Candidates = c.takeCandidates()
|
||||
}
|
||||
return r, err
|
||||
}
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@ package main
|
||||
|
||||
// Config's records out of the controller (novox/hq ADR 0565 §3, §15, and the progressive insight of 2026-10-29):
|
||||
// mesh-config keeps each placed module's declarations in its own state `declared`, reads the list of predefined keys
|
||||
// from the indexer's `predefined` and a pull request's config from the indexer's `config-candidates`.
|
||||
// from the indexer's `predefined`. A pull request's config is not read: the mesh knows no pull request (design 47 G).
|
||||
//
|
||||
// **Its own sources hold always** (ADR 0590, issue 1126): the controller ended by its unassignment, so its pull-declares,
|
||||
// the take-over that switched away from them, compare and hand-back are gone, and the switch is the indexer's whatever
|
||||
@@ -23,12 +23,11 @@ const (
|
||||
// DeclaredState is each placed module's declarations at the trunk, one key per module (ADR 0565 §3).
|
||||
DeclaredState = "declared"
|
||||
|
||||
// IndexerPredefinedRead and CandidatesRead are the indexer's states (ADR 0565 §2).
|
||||
// IndexerPredefinedRead is the indexer's state of the predefined list (ADR 0565 §2).
|
||||
IndexerPredefinedRead = indexerModule + "." + catalog.StatePredefined
|
||||
CandidatesRead = indexerModule + "." + catalog.StateConfigCandidates
|
||||
)
|
||||
|
||||
// SourceIndexer is the one source of a pull request's config and of the predefined list: the indexer's.
|
||||
// SourceIndexer is the one source of the predefined list: the indexer's.
|
||||
const SourceIndexer = "indexer"
|
||||
|
||||
// Switch is which source holds: the indexer's, always, since the controller ended (ADR 0590).
|
||||
@@ -105,7 +104,7 @@ func (c *Config) writeDeclared(s Sources) ([]string, error) {
|
||||
return written, errors.Join(problems...)
|
||||
}
|
||||
|
||||
// ---- the predefined list and the pull requests from the indexer ------------------------------------------
|
||||
// ---- the predefined list from the indexer -----------------------------------------------------------------------------------------
|
||||
|
||||
// indexerList is the indexer's predefined list as the mirror's list holds one: the keys, and the commit.
|
||||
func (c *Config) indexerList() (PredefinedList, bool, error) {
|
||||
@@ -128,75 +127,6 @@ func (c *Config) indexerList() (PredefinedList, bool, error) {
|
||||
return list, true, nil
|
||||
}
|
||||
|
||||
// candidates is every open pull request's config declarations as the indexer keeps them, by pull key.
|
||||
func (c *Config) candidates() (map[string]PullDecl, error) {
|
||||
out := map[string]PullDecl{}
|
||||
err := c.each(CandidatesRead, func(key string, raw []byte) error {
|
||||
var cand catalog.ConfigCandidatesByPullValue
|
||||
if err := json.Unmarshal(raw, &cand); err != nil || cand.Pull == "" {
|
||||
return fmt.Errorf("the indexer's config candidate %s is not one", key)
|
||||
}
|
||||
p := PullDecl{Pull: cand.Pull, Head: cand.Head, Declares: map[string]map[string]Declaration{}, At: timeOf(cand.At)}
|
||||
for module, keys := range cand.Declares {
|
||||
raw, _ := json.Marshal(keys)
|
||||
var d map[string]Declaration
|
||||
if err := json.Unmarshal(raw, &d); err != nil {
|
||||
return fmt.Errorf("the indexer's config candidate %s declares %s unreadably", key, module)
|
||||
}
|
||||
for k, decl := range d {
|
||||
if !decl.HasDefault() {
|
||||
decl.Default = nil
|
||||
}
|
||||
d[k] = decl
|
||||
}
|
||||
p.Declares[module] = d
|
||||
}
|
||||
out[pullKey(cand.Pull)] = p
|
||||
return nil
|
||||
})
|
||||
return out, err
|
||||
}
|
||||
|
||||
// takeCandidates is the indexer's config candidates taken in place of pull-declares, after the take-over: each one
|
||||
// whose head or declarations differ from what `pulls` holds is declared again, its held values judged again (ADR 0502
|
||||
// §6). The caller holds the lock.
|
||||
func (c *Config) takeCandidates() []string {
|
||||
cands, err := c.candidates()
|
||||
if err != nil {
|
||||
return []string{"the indexer's config candidates cannot be read: " + err.Error()}
|
||||
}
|
||||
var s Sources
|
||||
if err := c.readPulls(&s); err != nil {
|
||||
return []string{err.Error()}
|
||||
}
|
||||
var said []string
|
||||
for _, k := range sortedKeys(cands) {
|
||||
p := cands[k]
|
||||
if have, ok := s.Pulls[k]; ok && have.Head == p.Head && declaresDigest(have.Declares) == declaresDigest(p.Declares) {
|
||||
continue
|
||||
}
|
||||
a, err := c.declarePull(p.Pull, p.Head, p.Declares)
|
||||
if err != nil {
|
||||
said = append(said, fmt.Sprintf("%s from the indexer: %v", p.Pull, err))
|
||||
continue
|
||||
}
|
||||
said = append(said, a.Said+" (from the indexer)")
|
||||
}
|
||||
return said
|
||||
}
|
||||
|
||||
// declaresDigest is what a pull request's declarations hold a value to, in one encoding.
|
||||
func declaresDigest(d map[string]map[string]Declaration) string {
|
||||
flat := map[string]string{}
|
||||
for m, keys := range d {
|
||||
for k, decl := range keys {
|
||||
flat[m+"."+k] = declDigest(decl)
|
||||
}
|
||||
}
|
||||
raw, _ := json.Marshal(flat)
|
||||
return string(raw)
|
||||
}
|
||||
|
||||
// Declared is the read of `declared`: every module's key, or one whole.
|
||||
func (c *Config) Declared(module string) (any, error) {
|
||||
if module != "" {
|
||||
@@ -221,20 +151,14 @@ func (c *Config) Declared(module string) (any, error) {
|
||||
return map[string]any{"declared": rows, "count": len(rows), "source": sw}, err
|
||||
}
|
||||
|
||||
// Resync reads every source again and writes what differs: the published list, the resolved values, `declared`, and
|
||||
// the indexer's config candidates (ADR 0565 §15).
|
||||
// Resync reads every source again and writes what differs: the published list, the resolved values and `declared`
|
||||
// (ADR 0565 §15).
|
||||
func (c *Config) Resync() (any, error) {
|
||||
r, err := c.Reconcile()
|
||||
if err != nil {
|
||||
return r, err
|
||||
}
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
out := map[string]any{"resolution": r}
|
||||
if sw, err := c.source(); err == nil && sw.Source == SourceIndexer {
|
||||
out["candidates"] = c.takeCandidates()
|
||||
}
|
||||
return out, nil
|
||||
return map[string]any{"resolution": r}, nil
|
||||
}
|
||||
|
||||
// timeOf is an optional time of a seat's value as a time, the zero time when it is absent.
|
||||
|
||||
@@ -15,7 +15,7 @@ const (
|
||||
oldDeclared = `{"module":"old","settings":{"workers":{"kind":"preference","default":4,"why":"two per core"}}}`
|
||||
)
|
||||
|
||||
// anAgreeingMesh is aProposingMesh with the indexer's predefined list in place and no open pull request.
|
||||
// anAgreeingMesh is aProposingMesh with the indexer's predefined list in place.
|
||||
func anAgreeingMesh(t *testing.T) (*Config, *memStore, *standIn) {
|
||||
t.Helper()
|
||||
c, m, r := aProposingMesh(t)
|
||||
@@ -34,19 +34,9 @@ func indexerList(t *testing.T, m *memStore, commit, list string) {
|
||||
m.mirror(t, IndexerPredefinedRead, catalog.PredefinedByListKey(), string(raw))
|
||||
}
|
||||
|
||||
// candidate is the indexer's config candidate of a pull request.
|
||||
func candidate(t *testing.T, m *memStore, pull, head, declares string) {
|
||||
t.Helper()
|
||||
key, err := catalog.ConfigCandidatesByPullKey(pullKey(pull)), error(nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
m.mirror(t, CandidatesRead, key, `{"v":1,"pull":"`+pull+`","head":"`+head+`","declares":`+declares+`}`)
|
||||
}
|
||||
|
||||
// ADR 0590 (issue 1126): config reads its own sources always, with no take-over: declared is written once per
|
||||
// manifest, pull-declares is refused naming the indexer's candidates, and the list and a pull request's config come from
|
||||
// the indexer. compare, take-over and hand-back went with the controller.
|
||||
// manifest, and the list comes from the indexer. compare, take-over, hand-back and a pull request's config went (the
|
||||
// mesh knows no pull request, design 47 G).
|
||||
func TestConfigReadsItsOwnSourcesAlways(t *testing.T) {
|
||||
c, m, _ := anAgreeingMesh(t)
|
||||
steps := []struct {
|
||||
@@ -60,11 +50,6 @@ func TestConfigReadsItsOwnSourcesAlways(t *testing.T) {
|
||||
again, _ := c.Reconcile()
|
||||
return strings.Join(first.Declared, ",") + "|" + strings.Join(again.Declared, ","), err
|
||||
}, "dunst|"},
|
||||
{"pull-declares refused, naming the indexer", func() (string, error) {
|
||||
_, err := c.PullDeclares(Call{Caller: ControllerCaller, Pull: "novox/mesh-catalog#8", Head: "h1",
|
||||
Declares: map[string]any{}})
|
||||
return "", err
|
||||
}, "config-candidates"},
|
||||
{"the list comes from the indexer", func() (string, error) {
|
||||
indexerList(t, m, "cccccccccccc", `{"font-size":{"type":"number","description":"text size","minimum":6,"maximum":72},
|
||||
"agent-managed-settings":{"type":"object","description":"managed settings","trusted":true},
|
||||
@@ -72,11 +57,6 @@ func TestConfigReadsItsOwnSourcesAlways(t *testing.T) {
|
||||
res, err := c.Reconcile()
|
||||
return res.Published, err
|
||||
}, "theme"},
|
||||
{"a pull request's config comes from the indexer", func() (string, error) {
|
||||
candidate(t, m, "novox/mesh-catalog#9", "h9", `{"dunst":{"gap":{"kind":"","type":"number","default":2}}}`)
|
||||
res, err := c.Reconcile()
|
||||
return strings.Join(res.Candidates, "; "), err
|
||||
}, "from the indexer"},
|
||||
}
|
||||
for _, s := range steps {
|
||||
got, err := s.do()
|
||||
|
||||
@@ -81,6 +81,12 @@ type player struct {
|
||||
catalog map[string]catalog.CatalogEntry
|
||||
byFp map[string]catalog.CatalogEntry
|
||||
catRev int64
|
||||
// calls counts what the module asked of the runtime, by method (and by key for an ask); puts are the keys it wrote, "<state>/<key>".
|
||||
calls map[string]int
|
||||
asks map[string]int // the asks of tools and seat verbs, by key
|
||||
puts []string
|
||||
// stop ends the module this player runs: the restart of a module is the old process gone and a new one started.
|
||||
stop func()
|
||||
}
|
||||
|
||||
// ownedState is one state of an owner (the indexer's modules, the assigner's wants...), kept from its bucket.
|
||||
@@ -232,6 +238,12 @@ func (p *player) handle(m wire) {
|
||||
Bucket string `json:"bucket"`
|
||||
}
|
||||
_ = json.Unmarshal(m.Params, &a)
|
||||
p.mu.Lock()
|
||||
p.calls[m.Method]++
|
||||
if strings.HasPrefix(m.Method, "mesh/state.") && m.Method != "mesh/state.get" && m.Method != "mesh/state.keys" && m.Method != "mesh/state.watch" {
|
||||
p.puts = append(p.puts, m.Method+" "+a.State+"/"+a.Key)
|
||||
}
|
||||
p.mu.Unlock()
|
||||
kv, kvErr := p.kv(a.State)
|
||||
switch m.Method {
|
||||
case "mesh/state.get":
|
||||
@@ -357,6 +369,9 @@ func (p *player) handle(m wire) {
|
||||
Body json.RawMessage `json:"body"`
|
||||
}
|
||||
_ = json.Unmarshal(m.Params, &q)
|
||||
p.mu.Lock()
|
||||
p.asks[q.Key]++
|
||||
p.mu.Unlock()
|
||||
p.answer(m.ID, p.asked(q.Key, q.Body), nil)
|
||||
default:
|
||||
p.answer(m.ID, nil, errors.New("nats: no responders available for request"))
|
||||
@@ -675,14 +690,16 @@ func start(t *testing.T, bin string, js jetstream.JetStream, router *standIn, ha
|
||||
stdout, _ := cmd.StdoutPipe()
|
||||
cmd.Stderr = os.Stderr
|
||||
p := &player{t: t, ctx: ctx, js: js, router: router, in: stdin, pending: map[string]chan wire{}, haves: haves, readers: readers,
|
||||
owned: map[string]*ownedState{}, catalog: map[string]catalog.CatalogEntry{}, byFp: map[string]catalog.CatalogEntry{}}
|
||||
owned: map[string]*ownedState{}, catalog: map[string]catalog.CatalogEntry{}, byFp: map[string]catalog.CatalogEntry{},
|
||||
calls: map[string]int{}, asks: map[string]int{}}
|
||||
for _, f := range followed {
|
||||
p.own(f.Read)
|
||||
}
|
||||
if err := cmd.Start(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = stdin.Close(); cancel(); _ = cmd.Wait() })
|
||||
p.stop = func() { _ = stdin.Close(); cancel(); _ = cmd.Wait() }
|
||||
t.Cleanup(p.stop)
|
||||
go p.serve(stdout)
|
||||
t.Cleanup(cancel)
|
||||
return p
|
||||
@@ -708,9 +725,8 @@ func TestConfigWholeRenamesAndRetiresAgainstTheBus(t *testing.T) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
buckets := []string{"mesh-delivery-assigner_assignments", "mesh-delivery-assigner_wants",
|
||||
"mesh-delivery-indexer_predefined",
|
||||
"mesh-delivery-indexer_config-candidates"}
|
||||
for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, PullsState, KeptState, DeclaredState,
|
||||
"mesh-delivery-indexer_predefined"}
|
||||
for _, s := range []string{ValuesState, ResolvedState, PredefinedState, ProposalsState, DeclaredState,
|
||||
RenamesState, RetiringState, FindingsState} {
|
||||
buckets = append(buckets, Module+"_"+s)
|
||||
}
|
||||
@@ -785,6 +801,7 @@ func TestConfigWholeRenamesAndRetiresAgainstTheBus(t *testing.T) {
|
||||
|
||||
// The module restarted inside the window keeps it, and says renamed no more.
|
||||
said := p.publishedCount(EventRenamed)
|
||||
p.stop()
|
||||
p2 := start(t, bin, js, router, haves, nil)
|
||||
p2.viewsReady()
|
||||
if _, err := p2.call(ResyncTool, nil); err != nil {
|
||||
@@ -869,6 +886,21 @@ func TestConfigWholeRenamesAndRetiresAgainstTheBus(t *testing.T) {
|
||||
p2.conforms(EventRetiring, &meshconfig.RetiringHolderEvent{}, meshconfig.HolderSubjectRetiring)
|
||||
p2.conforms(EventRetired, &meshconfig.RetiredHolderEvent{}, meshconfig.HolderSubjectRetired)
|
||||
eventually(t, "the retirement is dropped", func() bool { _, ok := p2.get(RetiringState, "radio.band"); return !ok })
|
||||
p.noGitAsk()
|
||||
p2.noGitAsk()
|
||||
}
|
||||
|
||||
// noGitAsk fails when the module asked the seat git for anything over the whole run (ADR 0681 clause 1: it calls no
|
||||
// `seat:git.pull`, and no other verb of the seat git is its).
|
||||
func (p *player) noGitAsk() {
|
||||
p.t.Helper()
|
||||
p.mu.Lock()
|
||||
defer p.mu.Unlock()
|
||||
for key, n := range p.asks {
|
||||
if strings.HasPrefix(key, "seat:git.") {
|
||||
p.t.Errorf("the module asked %s %d times: it holds no value for a pull request", key, n)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// streamCarries says whether the module's manifest names event among its own streams' events.
|
||||
|
||||
@@ -3,7 +3,6 @@ module mesh-config
|
||||
go 1.26.0
|
||||
|
||||
require (
|
||||
git.novox.be/novox/mesh-contracts/go/clients/meshconfigclient v0.0.0-00010101000000-000000000000
|
||||
git.novox.be/novox/mesh-contracts/go/clients/meshmoduleassignerclient v0.0.0-00010101000000-000000000000
|
||||
git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient v0.0.0-00010101000000-000000000000
|
||||
git.novox.be/novox/mesh-contracts/go/seats/meshconfig v0.0.0-00010101000000-000000000000
|
||||
|
||||
@@ -19,13 +19,10 @@
|
||||
"operator-channel"
|
||||
],
|
||||
"consumes": [
|
||||
"git.pull-merged",
|
||||
"git.pull-closed",
|
||||
"mesh-delivery-view.delivered",
|
||||
"node-engine.manifest-reads-changed",
|
||||
"mesh-catalog.manifest-accepted",
|
||||
"mesh-delivery-indexer.views.predefined",
|
||||
"mesh-delivery-indexer.views.config-candidates",
|
||||
"mesh-delivery-assigner.views.assignments",
|
||||
"mesh-delivery-assigner.views.wants",
|
||||
"mesh-catalog.catalog-revision",
|
||||
@@ -36,13 +33,11 @@
|
||||
"invokes": [
|
||||
"seat:mesh-hand-acts.hand-act",
|
||||
"seat:mesh-hand-acts.warranted",
|
||||
"seat:git.pull",
|
||||
"mesh-delivery-view.node_haves",
|
||||
"seat:node-engine.manifest-reads",
|
||||
"mesh-delivery-indexer.indexer_config_readers",
|
||||
"seat:mesh-vault.retire",
|
||||
"mesh-delivery-indexer.indexer_read_predefined",
|
||||
"mesh-delivery-indexer.indexer_read_config_candidates",
|
||||
"mesh-delivery-assigner.assigner_read_assignments",
|
||||
"mesh-delivery-assigner.assigner_read_wants",
|
||||
"seat:mesh-catalog.revision",
|
||||
@@ -66,8 +61,6 @@
|
||||
"resolved",
|
||||
"predefined",
|
||||
"proposals",
|
||||
"pulls",
|
||||
"kept",
|
||||
"declared",
|
||||
"renames",
|
||||
"retiring",
|
||||
@@ -132,5 +125,16 @@
|
||||
"max-age-days": 7,
|
||||
"max-mib": 16
|
||||
}
|
||||
]
|
||||
],
|
||||
"config": {
|
||||
"deadline-floor-seconds": {
|
||||
"type": "number",
|
||||
"description": "the least wait, in seconds, of mesh-config's one deadline timer: it is set for the earliest real deadline it holds (a waiting proposal's end, an unanswered retirement's second ask, a rename window's seven-day held finding) and never sooner than this after a look, so a deadline passed and not settled is tried again, not spun on (lead answer A-490l, ADR 0681).",
|
||||
"minimum": 1,
|
||||
"maximum": 3600,
|
||||
"trusted": false,
|
||||
"default": 60,
|
||||
"runtime": true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -71,6 +71,8 @@ type ForgeReads interface {
|
||||
Pull(repository string, number int64) (gitseat.PullAnswer, error)
|
||||
// Branch is a repository branch's head (the seat git's verb branch).
|
||||
Branch(repository, branch string) (gitseat.BranchAnswer, error)
|
||||
// Contains is whether commit is in (or is) the commit in (the seat git's verb contains).
|
||||
Contains(repository, commit, in string) (bool, error)
|
||||
}
|
||||
|
||||
// kvKept is the store over the runtime.
|
||||
|
||||
@@ -42,7 +42,9 @@ type fakeForge struct {
|
||||
open []gitseat.OpenPull
|
||||
pulls map[string]gitseat.Pull
|
||||
heads map[string]string // "<repository>@<branch>" -> head
|
||||
fail bool
|
||||
// contains says whether commit is in `in`; nil means every commit is in every other (a straight line forward)
|
||||
contains func(commit, in string) bool
|
||||
fail bool
|
||||
}
|
||||
|
||||
func (f *fakeForge) OpenPulls() (gitseat.OpenPullsAnswer, error) {
|
||||
@@ -61,6 +63,15 @@ func (f *fakeForge) Branch(repository, branch string) (gitseat.BranchAnswer, err
|
||||
}
|
||||
return gitseat.BranchAnswer{Branch: branch, Repository: repository, Head: head}, nil
|
||||
}
|
||||
func (f *fakeForge) Contains(repository, commit, in string) (bool, error) {
|
||||
if f.fail {
|
||||
return false, errors.New("the forge is away")
|
||||
}
|
||||
if f.contains == nil {
|
||||
return true, nil
|
||||
}
|
||||
return f.contains(commit, in), nil
|
||||
}
|
||||
func (f *fakeForge) Pull(repository string, number int64) (gitseat.PullAnswer, error) {
|
||||
p, ok := f.pulls[fmt.Sprintf("%s#%d", repository, number)]
|
||||
if !ok {
|
||||
|
||||
@@ -44,7 +44,7 @@ type FindingWriter interface {
|
||||
// generated contract of the seat that defines it (A-17). It is started once the runtime serves (A-40).
|
||||
func NewFindingWriter() (*views.HeldWriter[meshconditions.Finding, meshconditions.FindingCleared, meshconditions.FindingsStated, meshconditions.FindingsAskedEvent], error) {
|
||||
return views.NewStdioHeldWriter(views.WriterConfig[meshconditions.Finding, meshconditions.FindingCleared, meshconditions.FindingsStated, meshconditions.FindingsAskedEvent]{
|
||||
Asked: meshconditions.SubjectFindingsAsked, Module: Module, State: stdio.State("findings"), Kinds: []string{ApprovalCarriedOpen}})
|
||||
Asked: meshconditions.SubjectFindingsAsked, Module: Module, State: stdio.State("findings"), Kinds: []string{ApprovalCarriedOpen, SourceUncompared}})
|
||||
}
|
||||
|
||||
// approvalID is the id of a pull request's finding: its repository and number, each escaped as a key's name is.
|
||||
|
||||
@@ -32,7 +32,7 @@ func (l *listening) get() string { l.mu.Lock(); defer l.mu.Unlock(); return l.n
|
||||
|
||||
// The events this owner follows: the forge bridge's word on an act owed, and the step events the delivery records are built
|
||||
// from (consumer.go).
|
||||
var followed = append(append([]string{owedEndedEvent}, stepPatterns()...), pullUpdatedEvent, pullMergedEvent, pullClosedEvent, registrationChangedEvent)
|
||||
var followed = append(append([]string{owedEndedEvent}, stepPatterns()...), pullUpdatedEvent, pullMergedEvent, pullClosedEvent, registrationChangedEvent, forgeMergedEvent)
|
||||
|
||||
func main() {
|
||||
settingsFile := os.Getenv("MESH_DELIVERY_GATE_SETTINGS")
|
||||
@@ -118,7 +118,13 @@ func run(h *Holder, l *listening) {
|
||||
l.set("listening")
|
||||
logf("[mesh-delivery] listening: %s", strings.Join(followed, ", "))
|
||||
// A watched branch no source key holds starts from the forge, once at each start and at each registration change (A-401).
|
||||
go startSourcesAtStart(h)
|
||||
// then each head is compared with the forge's, and a merge made outside the gate is followed (A-464).
|
||||
go func() {
|
||||
startSourcesAtStart(h)
|
||||
if _, err := h.FollowAtStart(); err != nil {
|
||||
logf("[mesh-delivery] the sources were not all compared with the forge's heads: %v", err)
|
||||
}
|
||||
}()
|
||||
// A missed pull event is put right from the forge's own record, once at each start (§716).
|
||||
if err := h.ReadForge(); err != nil {
|
||||
logf("[mesh-delivery] the open pull requests were not read from the forge, they are read again at the next start: %v", err)
|
||||
@@ -179,6 +185,9 @@ func take(h *Holder, e stdio.Envelope) error {
|
||||
_, err := h.StartSources()
|
||||
return err
|
||||
}
|
||||
if forgeMergedEvent != "" && stdio.TopicMatches(forgeMergedEvent, e.Key) {
|
||||
return h.ForgeMerged(e.Body)
|
||||
}
|
||||
if e.Key == pullClosedEvent {
|
||||
return errors.Join(h.DeliveryClosed(e.Body), h.pullEnded(e.Body, "closed"))
|
||||
}
|
||||
|
||||
@@ -134,13 +134,16 @@ func TestItClaimsTheDeliverySeatAndFollowsWhatItHandles(t *testing.T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
// From G's delivery the gate hears neither the bridge's merged and pushed messages nor the teller's answers nor the view's
|
||||
// reach (design 47 G §592, §593): it consumes the indexer's take-in.taken and the bridge's owed.ended, and the git events that clear
|
||||
// From G's delivery the gate hears neither the bridge's pushed messages nor the teller's answers nor the view's reach
|
||||
// (design 47 G §592, §593); it hears the bridge's merged message alone, to follow every merge (A-464): it consumes the indexer's take-in.taken and the bridge's owed.ended, and the git events that clear
|
||||
// an approval carried.
|
||||
if want := append(slices.Clone(followed), meshconditions.Seat+"."+meshconditions.EventFindingsAsked); !reflect.DeepEqual(m.Consumes, want) {
|
||||
t.Fatalf("consumes %v, follows %v", m.Consumes, followed)
|
||||
}
|
||||
for _, c := range m.Consumes {
|
||||
if c == forgeMergedEvent {
|
||||
continue // A-464: the source follows every merge, so the gate hears the forge bridge's merged message, and it alone
|
||||
}
|
||||
for _, gone := range []string{".forge.", "teller", "view", "forge-pull", "forge-status"} {
|
||||
if strings.Contains(c, gone) {
|
||||
t.Errorf("the manifest still consumes %s, which G's gate does not hear (§431, §592, §593)", c)
|
||||
|
||||
@@ -0,0 +1,278 @@
|
||||
package main
|
||||
|
||||
// The gate's source of a watched branch follows every merge into that branch, whoever made it (design 47 G A-464, A-464b, amending
|
||||
// A-463): on the forge bridge's `merged` of a repository the source names, at the branch the source watches, the gate moves that
|
||||
// repository's head to the merge and says source-moved, as a take-in moves it; at its start it compares each head with the
|
||||
// forge's branch head, asked of the seat git, and moves every one behind it the same way, so a merge whose message was lost is
|
||||
// followed too; gate_source_follow does the same for one repository now. A head the source does not name, or a branch it does
|
||||
// not watch, is left: only a start or a registration change adds them (sourcestart.go).
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.novox.be/novox/mesh-contracts/health-and-repair/go/clients/meshhandactsclient"
|
||||
"git.novox.be/novox/mesh-contracts/health-and-repair/go/seats/meshconditions"
|
||||
seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdelivery"
|
||||
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg"
|
||||
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/trunk"
|
||||
"git.novox.be/novox/mesh-sdk/go/keys"
|
||||
)
|
||||
|
||||
// forgeMergedEvent is the forge bridge's merged message of any repository, as the manifest consumes it.
|
||||
var forgeMergedEvent = declared("forge.*.*.merged")
|
||||
|
||||
// moveHead moves the head the branch's source names for repository to head, and says source-moved with the key's revision. It
|
||||
// answers false, and writes nothing, when the branch has no source key, the key does not name the repository or names the head
|
||||
// already. group is the group that made the merge, empty for a merge no group of the gate made.
|
||||
func (h *Holder) moveHead(branch, repository, head, group string) (moved bool, err error) {
|
||||
if h.Source == nil || head == "" {
|
||||
return false, nil
|
||||
}
|
||||
held, _, err := h.Source.Read(branch)
|
||||
if err != nil || held == nil {
|
||||
return false, err
|
||||
}
|
||||
name := ""
|
||||
for r := range held.Heads {
|
||||
if trunk.SameRepository(r, repository) {
|
||||
name = r
|
||||
}
|
||||
}
|
||||
if name == "" || held.Heads[name] == head {
|
||||
return false, nil // not named, or no change: no revision and no source-moved (A-464c)
|
||||
}
|
||||
was := held.Heads[name]
|
||||
// Only forward (A-464c): the head held must be contained in the merge, asked of the seat git.
|
||||
if h.Forge == nil {
|
||||
return false, errors.New("this gate reads no forge, so it cannot tell whether the merge is ahead of the head")
|
||||
}
|
||||
ahead, err := h.Forge.Contains(name, was, head)
|
||||
if err != nil {
|
||||
return false, fmt.Errorf("whether %.12s is in %.12s of %s cannot be read, so the head stays: %w", was, head, name, err)
|
||||
}
|
||||
if !ahead {
|
||||
h.logf("[mesh-delivery] source.%s keeps %s at %.12s: the merge %.12s does not contain it (heard again, late or out of order), left without effect", branch, name, was, head)
|
||||
return false, nil
|
||||
}
|
||||
rev, err := h.Source.Set(branch, func(prev *Source) (Source, bool) {
|
||||
moved = false
|
||||
if prev == nil || prev.Heads[name] != was {
|
||||
return Source{}, false // another writer moved it first
|
||||
}
|
||||
next := Source{Group: group, Heads: map[string]string{}}
|
||||
for r, c := range prev.Heads {
|
||||
next.Heads[r] = c
|
||||
}
|
||||
next.Heads[name] = head
|
||||
moved = true
|
||||
return next, true
|
||||
})
|
||||
if err != nil {
|
||||
return false, fmt.Errorf("source.%s cannot be moved: %w", branch, err)
|
||||
}
|
||||
if !moved || h.SaySeat == nil {
|
||||
return moved, nil
|
||||
}
|
||||
at := h.Now().UTC()
|
||||
return true, h.SaySeat(seat.SubjectSourceMoved(keys.EscapeName(branch)),
|
||||
seat.SourceMovedEvent{Branch: branch, Group: group, Revision: int64(rev), At: &at},
|
||||
"source-moved."+keys.EscapeName(branch)+"."+strconv.FormatUint(rev, 10))
|
||||
}
|
||||
|
||||
// ForgeMerged takes one merged message of the forge bridge: the head of its repository in the source of the branch it landed on
|
||||
// moves to the merge. A merge no delivery group made (the message names no group) is said so. A message that cannot be read, or
|
||||
// names no branch or merge, is said and taken: heard again it would be refused again.
|
||||
func (h *Holder) ForgeMerged(body json.RawMessage) error {
|
||||
f, err := forgemsg.DecodeForge(body)
|
||||
if err != nil {
|
||||
h.logf("[mesh-delivery] a merged message of the forge bridge is not readable, the source does not follow it: %v", err)
|
||||
return nil
|
||||
}
|
||||
if f.Kind != forgemsg.ForgeMerged {
|
||||
return nil
|
||||
}
|
||||
if f.Base == "" || f.Merge == "" {
|
||||
h.logf("[mesh-delivery] the merged message of %s names no branch or no merge, the source does not follow it", f.Repository)
|
||||
return nil
|
||||
}
|
||||
moved, err := h.moveHead(f.Base, f.Repository, f.Merge, f.Group)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if moved {
|
||||
if f.Group == "" { // A-464b: a merge whose message names no delivery group is one the gate did not make
|
||||
h.logf("[mesh-delivery] source.%s follows the merge %.12s of %s: not made by a delivery group of the gate", f.Base, f.Merge, f.Repository)
|
||||
} else {
|
||||
h.logf("[mesh-delivery] source.%s follows the merge %.12s of %s, made by the delivery group %s", f.Base, f.Merge, f.Repository, f.Group)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SourceUncompared is the finding of a start comparison that left a head uncompared (A-464e).
|
||||
const SourceUncompared = "source-uncompared"
|
||||
|
||||
// FollowAtStart compares each head of every source key with the forge's head of that branch and moves every one behind it, at
|
||||
// each start. It ends only when every head was compared (A-464e): a head the forge could not be asked for (the seat git not
|
||||
// answering yet, as when its bundle starts in the same tool runner) is compared again after a growing pause of at most a
|
||||
// minute, and the finding source-uncompared names the repositories and the last error while any stands. It answers the heads
|
||||
// moved as "<repository>@<branch>".
|
||||
func (h *Holder) FollowAtStart() ([]string, error) {
|
||||
if h.Source == nil || h.Forge == nil {
|
||||
return nil, errors.New("this gate keeps no source or reads no forge")
|
||||
}
|
||||
var moved []string
|
||||
var only map[string]bool
|
||||
for wait := 2 * time.Second; ; wait = min(wait*2, time.Minute) {
|
||||
got, left := h.followPass(only)
|
||||
moved = append(moved, got...)
|
||||
if len(left) == 0 {
|
||||
h.clearUncompared()
|
||||
h.logf("[mesh-delivery] the sources compared with the forge's heads at the start: moved %v", moved)
|
||||
return moved, nil
|
||||
}
|
||||
only = map[string]bool{}
|
||||
var names []string
|
||||
var last error
|
||||
for n, err := range left {
|
||||
only[n] = true
|
||||
names = append(names, n)
|
||||
last = err
|
||||
}
|
||||
sort.Strings(names)
|
||||
h.sayUncompared(names, last)
|
||||
h.logf("[mesh-delivery] %d heads are not compared with the forge's yet (%s; last: %v); asking again in %s", len(names), strings.Join(names, ", "), last, wait)
|
||||
startSleep(wait)
|
||||
}
|
||||
}
|
||||
|
||||
// followPass compares the heads named in only (every head when nil) once; it answers the heads moved and, by "<repository>@<branch>",
|
||||
// each head it could not compare with why. A source it cannot list or read is one entry named for itself.
|
||||
func (h *Holder) followPass(only map[string]bool) (moved []string, left map[string]error) {
|
||||
left = map[string]error{}
|
||||
branches, err := h.Source.Branches()
|
||||
if err != nil {
|
||||
left["the branches of the source"] = err
|
||||
return nil, left
|
||||
}
|
||||
for _, branch := range branches {
|
||||
held, _, err := h.Source.Read(branch)
|
||||
if err != nil {
|
||||
left["source."+branch] = err
|
||||
continue
|
||||
}
|
||||
if held == nil {
|
||||
continue
|
||||
}
|
||||
for repository, head := range held.Heads {
|
||||
name := repository + "@" + branch
|
||||
if only != nil && !only[name] {
|
||||
continue
|
||||
}
|
||||
ok, err := h.followForge(branch, repository, head)
|
||||
if err != nil {
|
||||
left[name] = err
|
||||
continue
|
||||
}
|
||||
if ok {
|
||||
moved = append(moved, name)
|
||||
}
|
||||
}
|
||||
}
|
||||
return moved, left
|
||||
}
|
||||
|
||||
func (h *Holder) sayUncompared(names []string, last error) {
|
||||
if h.Findings == nil {
|
||||
return
|
||||
}
|
||||
at := h.Now().UTC()
|
||||
err := h.Findings.Write(context.Background(), meshconditions.Finding{Scope: FindingScope, ID: SourceUncompared, Kind: SourceUncompared,
|
||||
Subject: meshconditions.Subject{Scope: FindingScope, ID: SourceUncompared},
|
||||
Severity: meshconditions.FindingSeverityWarning, Resolver: "operator",
|
||||
Summary: fmt.Sprintf("the gate's source is not compared with the forge's head for %s; the last error: %v", strings.Join(names, ", "), last),
|
||||
Headline: "The gate's source is not compared with the forge",
|
||||
Explanation: "At its start the gate compares each head of its source with the forge's head of the branch. A head it could not compare is asked again after a growing pause, and this clears once every head is compared.",
|
||||
Needs: "the seat git answering; gate_source_follow moves one repository's head by hand.",
|
||||
Source: SourceUncompared, Observer: Module, At: at, Since: at})
|
||||
if err != nil {
|
||||
h.logf("[mesh-delivery] the finding %s is not written: %v", SourceUncompared, err)
|
||||
}
|
||||
}
|
||||
|
||||
func (h *Holder) clearUncompared() {
|
||||
if h.Findings == nil {
|
||||
return
|
||||
}
|
||||
for _, f := range h.Findings.Held() {
|
||||
if f.Scope == FindingScope && f.ID == SourceUncompared && f.Kind == SourceUncompared {
|
||||
if err := h.Findings.Clear(context.Background(), FindingScope, SourceUncompared, SourceUncompared, "every head is compared with the forge's"); err != nil {
|
||||
h.logf("[mesh-delivery] the finding %s is not cleared: %v", SourceUncompared, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// followForge moves one repository's head in a branch's source to the forge's head of the branch when they differ.
|
||||
func (h *Holder) followForge(branch, repository, held string) (bool, error) {
|
||||
a, err := h.Forge.Branch(repository, branch)
|
||||
if err == nil && a.Error != "" {
|
||||
err = errors.New(a.Error)
|
||||
}
|
||||
if err == nil && a.Head == "" {
|
||||
err = errors.New("the forge named no head")
|
||||
}
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
if sameCommit(held, a.Head) && len(held) == len(a.Head) {
|
||||
return false, nil
|
||||
}
|
||||
moved, err := h.moveHead(branch, repository, a.Head, "")
|
||||
if moved {
|
||||
h.logf("[mesh-delivery] source.%s follows the forge: %s from %.12s to %.12s", branch, repository, held, a.Head)
|
||||
}
|
||||
return moved, err
|
||||
}
|
||||
|
||||
// SourceFollow moves one repository's head to the forge's head of the branch by hand, after the hand-act log took it.
|
||||
func (h *Holder) SourceFollow(branch, repository, why, by string, acts handActs) (map[string]any, error) {
|
||||
if strings.TrimSpace(branch) == "" || strings.TrimSpace(repository) == "" || strings.TrimSpace(why) == "" {
|
||||
return nil, errors.New("say the branch, the repository and why its head follows the forge")
|
||||
}
|
||||
if h.Source == nil || h.Forge == nil {
|
||||
return nil, errors.New("this gate keeps no source or reads no forge")
|
||||
}
|
||||
if acts == nil {
|
||||
return nil, errors.New("the hand-act log cannot be reached here, so nothing was moved")
|
||||
}
|
||||
held, _, err := h.Source.Read(branch)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if held == nil {
|
||||
return nil, fmt.Errorf("the gate keeps no source of the branch %s", branch)
|
||||
}
|
||||
name := ""
|
||||
for r := range held.Heads {
|
||||
if trunk.SameRepository(r, repository) {
|
||||
name = r
|
||||
}
|
||||
}
|
||||
if name == "" {
|
||||
return nil, fmt.Errorf("the source of %s names no head of %s", branch, repository)
|
||||
}
|
||||
if _, err := acts.Record(meshhandactsclient.Request{What: "moved the head of " + repository + " in the source of the branch " + branch + " to the forge's head",
|
||||
Why: why, Cause: "gate_source_follow", Verb: "source-follow"}); err != nil {
|
||||
return nil, fmt.Errorf("the hand act was not recorded through mesh-hand-acts, so nothing was moved: %w", err)
|
||||
}
|
||||
moved, err := h.followForge(branch, name, held.Heads[name])
|
||||
return map[string]any{"branch": branch, "repository": name, "moved": moved, "by": by}, err
|
||||
}
|
||||
@@ -0,0 +1,193 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.novox.be/novox/mesh-contracts/health-and-repair/go/seats/meshconditions"
|
||||
meshcatalog "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
|
||||
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg"
|
||||
stdio "git.novox.be/novox/mesh-sdk/go"
|
||||
)
|
||||
|
||||
// Design 47 G A-464, A-464b: the forge bridge's merged message moves the head of its repository in the source of the branch it
|
||||
// landed on and says source-moved; a merge naming no delivery group is said not made by one; a branch no source key holds, a
|
||||
// repository the key does not name, and a head the key holds already move nothing.
|
||||
func TestAMergedMessageMovesTheSourceOfItsBranchWhoeverMadeTheMerge(t *testing.T) {
|
||||
old, merge := strings.Repeat("a", 40), strings.Repeat("b", 40)
|
||||
body := func(repository, base, group string) []byte {
|
||||
f := forgemsg.Forge{V: 1, Kind: forgemsg.ForgeMerged, Repository: repository, Base: base, Merge: merge, Head: merge, Number: 14, Root: strings.Repeat("d", 40)}
|
||||
data, err := forgemsg.EncodeForge(f)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return data
|
||||
}
|
||||
for _, c := range []struct {
|
||||
name, repository, base string
|
||||
moved bool
|
||||
}{
|
||||
{"watched branch, named repository", "novox/mesh-contracts", "main", true},
|
||||
{"a branch no source key holds", "novox/mesh-contracts", "other", false},
|
||||
{"a repository the key does not name", "novox/other", "main", false},
|
||||
} {
|
||||
t.Run(c.name, func(t *testing.T) {
|
||||
src := &memSource{vals: map[string]Source{"main": {Group: "g", Heads: map[string]string{"novox/mesh-contracts": old}}}}
|
||||
var said []string
|
||||
var logged []string
|
||||
h := &Holder{Now: time.Now, Source: src, Forge: &fakeForge{},
|
||||
Logf: func(f string, a ...any) { logged = append(logged, f) },
|
||||
SaySeat: func(subject string, _ any, id string) error { said = append(said, id); return nil }}
|
||||
if err := h.ForgeMerged(body(c.repository, c.base, "")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got := src.vals["main"]
|
||||
if c.moved != (got.Heads["novox/mesh-contracts"] == merge) || c.moved != (len(said) == 1) || (c.moved && got.Group != "") {
|
||||
t.Fatalf("source %+v said %v: moved wanted %v", got, said, c.moved)
|
||||
}
|
||||
if c.moved && !strings.Contains(strings.Join(logged, "\n"), "not made by a delivery group of the gate") {
|
||||
t.Errorf("a merge no group made is not said so: %v", logged)
|
||||
}
|
||||
// Heard again, the key names the head already: nothing is moved or said twice.
|
||||
if err := h.ForgeMerged(body(c.repository, c.base, "")); err != nil || len(said) > 1 {
|
||||
t.Errorf("heard twice: %v, said %v", err, said)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Design 47 G A-464: at its start the gate compares each head with the forge's branch head and moves every one behind it; a head
|
||||
// the forge cannot read is said and left; gate_source_follow does it for one repository after the hand-act log took it.
|
||||
func TestTheStartAndTheToolMoveAHeadBehindTheForge(t *testing.T) {
|
||||
old, now := strings.Repeat("a", 40), strings.Repeat("c", 40)
|
||||
mk := func() (*Holder, *branchSource, *[]string) {
|
||||
src := &branchSource{memSource{vals: map[string]Source{"main": {Heads: map[string]string{"o/f1": old, "o/f2": old, "o/f3": now}}}}}
|
||||
var said []string
|
||||
return &Holder{Now: time.Now, Source: src, Logf: func(string, ...any) {},
|
||||
Forge: &fakeForge{heads: map[string]string{"o/f1@main": now, "o/f3@main": now}}, // o/f2 cannot be read
|
||||
SaySeat: func(_ string, _ any, id string) error { said = append(said, id); return nil }}, src, &said
|
||||
}
|
||||
h, src, said := mk()
|
||||
fw := &fakeFindings{}
|
||||
h.Findings = fw
|
||||
forge := h.Forge.(*fakeForge)
|
||||
var pauses []time.Duration
|
||||
var heldWhileWaiting int
|
||||
prevSleep := startSleep
|
||||
startSleep = func(d time.Duration) {
|
||||
pauses = append(pauses, d)
|
||||
heldWhileWaiting = len(fw.held) // the finding stands while a head is uncompared
|
||||
forge.heads["o/f2@main"] = now // the seat git answers by the second pass
|
||||
}
|
||||
defer func() { startSleep = prevSleep }()
|
||||
moved, err := h.FollowAtStart()
|
||||
if err != nil || len(moved) != 2 || src.vals["main"].Heads["o/f1"] != now || src.vals["main"].Heads["o/f2"] != now || len(*said) != 2 {
|
||||
t.Fatalf("start: moved %v err %v heads %v said %v: want o/f1 and, after the second pass, o/f2 moved", moved, err, src.vals["main"].Heads, *said)
|
||||
}
|
||||
if len(pauses) != 1 || heldWhileWaiting != 1 || len(fw.held) != 0 {
|
||||
t.Fatalf("pauses %v, finding held while waiting %d and after %d: want one pause, the finding raised while a head stood uncompared and cleared after", pauses, heldWhileWaiting, len(fw.held))
|
||||
}
|
||||
h, src, said = mk()
|
||||
acts := &handActsFake{refuse: errors.New("log down")}
|
||||
if _, err := h.SourceFollow("main", "o/f1", "missed a merge", "me", acts); err == nil || src.vals["main"].Heads["o/f1"] != old {
|
||||
t.Fatalf("moved without the log: %v", err)
|
||||
}
|
||||
acts.refuse = nil
|
||||
if _, err := h.SourceFollow("main", "o/f1", "", "me", acts); err == nil {
|
||||
t.Fatal("moved with no reason")
|
||||
}
|
||||
out, err := h.SourceFollow("main", "o/f1", "missed a merge", "me", acts)
|
||||
if err != nil || out["moved"] != true || len(acts.took) != 1 || acts.took[0].Cause != "gate_source_follow" || src.vals["main"].Heads["o/f1"] != now {
|
||||
t.Fatalf("tool: %v %v log %+v heads %v", out, err, acts.took, src.vals["main"].Heads)
|
||||
}
|
||||
}
|
||||
|
||||
// Design 47 G A-464: the gate takes the forge bridge's merged event of any repository, by the manifest's own pattern.
|
||||
func TestTheGateTakesTheForgeBridgesMergedEventOfAnyRepository(t *testing.T) {
|
||||
merge := strings.Repeat("b", 40)
|
||||
data, err := forgemsg.EncodeForge(forgemsg.Forge{V: 1, Kind: forgemsg.ForgeMerged, Repository: "novox/mesh-contracts", Base: "main", Merge: merge, Head: merge, Number: 14, Root: strings.Repeat("d", 40)})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
src := &memSource{vals: map[string]Source{"main": {Heads: map[string]string{"novox/mesh-contracts": strings.Repeat("a", 40)}}}}
|
||||
h := &Holder{Now: time.Now, Source: src, Forge: &fakeForge{}, Logf: func(string, ...any) {}}
|
||||
key := strings.Replace(strings.Replace(forgeMergedEvent, "*", "novox", 1), "*", "mesh-contracts", 1)
|
||||
if err := take(h, stdio.Envelope{Key: key, Body: data}); err != nil || src.vals["main"].Heads["novox/mesh-contracts"] != merge {
|
||||
t.Fatalf("event %q: %v, source %+v", key, err, src.vals["main"])
|
||||
}
|
||||
}
|
||||
|
||||
// Design 47 G A-464c: a head moves only forward and only when it changes. A merged message for a commit that does not contain
|
||||
// the held head (replayed, late, out of order) moves nothing and is said; a second message for the same head writes no
|
||||
// revision; and a take-in.taken for a head a merged already moved writes none and says no source-moved.
|
||||
func TestAHeadMovesOnlyForwardAndOnlyWhenItChanges(t *testing.T) {
|
||||
oldC, newC := strings.Repeat("a", 40), strings.Repeat("b", 40)
|
||||
msg := func(merge string) []byte {
|
||||
data, err := forgemsg.EncodeForge(forgemsg.Forge{V: 1, Kind: forgemsg.ForgeMerged, Repository: "novox/app", Base: "main", Merge: merge, Head: merge, Number: 3, Root: strings.Repeat("d", 40)})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return data
|
||||
}
|
||||
src := &memSource{vals: map[string]Source{"main": {Heads: map[string]string{"novox/app": newC}}}}
|
||||
var said, logged []string
|
||||
// newC contains oldC, not the other way round.
|
||||
forge := &fakeForge{contains: func(commit, in string) bool { return commit == in || (commit == oldC && in == newC) }}
|
||||
h := &Holder{Now: time.Now, Source: src, Forge: forge, Logf: func(f string, a ...any) { logged = append(logged, f) },
|
||||
SaySeat: func(_ string, _ any, id string) error { said = append(said, id); return nil }}
|
||||
if err := h.ForgeMerged(msg(oldC)); err != nil || src.vals["main"].Heads["novox/app"] != newC || src.rev != 0 || len(said) != 0 || len(logged) == 0 {
|
||||
t.Fatalf("a replayed old merge: %v, source %+v, revisions %d, said %v, logged %v: want nothing moved and a log line", err, src.vals["main"], src.rev, said, logged)
|
||||
}
|
||||
if err := h.ForgeMerged(msg(newC)); err != nil || src.rev != 0 || len(said) != 0 {
|
||||
t.Fatalf("a second message for the same head wrote revision %d, said %v", src.rev, said)
|
||||
}
|
||||
// A take-in.taken naming the head a merged moved already writes no revision and says nothing.
|
||||
body := []byte(`{"v":1,"kind":"taken","key":"g.feat","what":"group","group":"feat","branch":"main","source":7,` +
|
||||
`"merges":[{"repository":"novox/app","number":3,"merge":"` + newC + `"}],"entries":[]}`)
|
||||
if err := h.moveSource(mustTaken(t, body)); err != nil || src.rev != 0 || len(said) != 0 {
|
||||
t.Fatalf("take-in for a head already moved: %v, revision %d, said %v", err, src.rev, said)
|
||||
}
|
||||
// A real forward move still writes one revision.
|
||||
src.vals["main"] = Source{Heads: map[string]string{"novox/app": oldC}}
|
||||
if err := h.ForgeMerged(msg(newC)); err != nil || src.rev != 1 || len(said) != 1 {
|
||||
t.Fatalf("a forward move: %v, revision %d, said %v", err, src.rev, said)
|
||||
}
|
||||
}
|
||||
|
||||
func mustTaken(t *testing.T, body []byte) meshcatalog.TakeInTaken {
|
||||
t.Helper()
|
||||
var v meshcatalog.TakeInTaken
|
||||
if err := json.Unmarshal(body, &v); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// Design 47 G A-464d: a take-in.taken arriving after a later merge moved the head leaves the head where it is.
|
||||
func TestATakeInTakenAfterALaterMergeLeavesTheHead(t *testing.T) {
|
||||
oldC, newC := strings.Repeat("a", 40), strings.Repeat("b", 40)
|
||||
src := &memSource{vals: map[string]Source{"main": {Heads: map[string]string{"novox/app": newC}}}}
|
||||
var said []string
|
||||
h := &Holder{Now: time.Now, Source: src, Logf: func(string, ...any) {},
|
||||
Forge: &fakeForge{contains: func(commit, in string) bool { return commit == in || (commit == oldC && in == newC) }},
|
||||
SaySeat: func(_ string, _ any, id string) error { said = append(said, id); return nil }}
|
||||
body := []byte(`{"v":1,"kind":"taken","key":"g.feat","what":"group","group":"feat","branch":"main","source":7,` +
|
||||
`"merges":[{"repository":"novox/app","number":3,"merge":"` + oldC + `"}],"entries":[]}`)
|
||||
if err := h.moveSource(mustTaken(t, body)); err != nil || src.vals["main"].Heads["novox/app"] != newC || src.rev != 0 || len(said) != 0 {
|
||||
t.Fatalf("take-in of an older merge: %v, source %+v, revision %d, said %v: want the head left at the later merge", err, src.vals["main"], src.rev, said)
|
||||
}
|
||||
}
|
||||
|
||||
// fakeFindings is the gate's finding writer in memory.
|
||||
type fakeFindings struct{ held []meshconditions.Finding }
|
||||
|
||||
func (f *fakeFindings) Write(_ context.Context, x meshconditions.Finding) error {
|
||||
f.held = append(f.held, x)
|
||||
return nil
|
||||
}
|
||||
func (f *fakeFindings) Clear(_ context.Context, _, _, _, _ string) error { f.held = nil; return nil }
|
||||
func (f *fakeFindings) Held() []meshconditions.Finding { return f.held }
|
||||
@@ -55,6 +55,18 @@ func (s seatGit) Branch(repository, branch string) (gitseat.BranchAnswer, error)
|
||||
return a, s.call(gitseat.VerbBranch, gitseat.BranchInput{Repository: repository, Branch: branch}, &a)
|
||||
}
|
||||
|
||||
// Contains is whether commit is the commit in or an ancestor of it.
|
||||
func (s seatGit) Contains(repository, commit, in string) (bool, error) {
|
||||
var a gitseat.ContainsAnswer
|
||||
if err := s.call(gitseat.VerbContains, gitseat.ContainsInput{Repository: repository, Commit: commit, In: in}, &a); err != nil {
|
||||
return false, err
|
||||
}
|
||||
if a.Error != "" {
|
||||
return false, errors.New(a.Error)
|
||||
}
|
||||
return a.Contains, nil
|
||||
}
|
||||
|
||||
// watchedRepositories are the repositories each watched branch is registered for, each once, sorted.
|
||||
func watchedRepositories(regs []meshcatalog.Registration) map[string][]string {
|
||||
seen := map[string]map[string]bool{}
|
||||
|
||||
@@ -89,5 +89,16 @@ func sourceTools(h *Holder, acts handActs) []stdio.Tool {
|
||||
Run: func(a map[string]any) (any, error) {
|
||||
return h.SourceStart(strArg(a, "branch"), strArg(a, "why"), stdio.CallerOf(a), acts)
|
||||
}},
|
||||
{Name: "gate_source_follow",
|
||||
Description: "Move the head one watched branch's source names for one repository to the forge's head of that branch now, as " +
|
||||
"the gate does when it hears a merge and at its start (design 47 G A-464); recorded in the hand-act log of the seat " +
|
||||
"mesh-hand-acts first. Nothing is moved when the source already names the forge's head.",
|
||||
Input: map[string]any{"type": "object", "properties": map[string]any{
|
||||
"branch": str("the watched branch"), "repository": str("the repository, owner/name"),
|
||||
"why": str("why its head follows the forge by hand, in plain words")},
|
||||
"required": []string{"branch", "repository", "why"}},
|
||||
Run: func(a map[string]any) (any, error) {
|
||||
return h.SourceFollow(strArg(a, "branch"), strArg(a, "repository"), strArg(a, "why"), stdio.CallerOf(a), acts)
|
||||
}},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,6 +9,7 @@ import (
|
||||
mdc "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient"
|
||||
meshcatalog "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
|
||||
seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdelivery"
|
||||
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/trunk"
|
||||
"git.novox.be/novox/mesh-sdk/go/keys"
|
||||
)
|
||||
|
||||
@@ -107,9 +108,43 @@ func (h *Holder) moveSource(t meshcatalog.TakeInTaken) error {
|
||||
for _, m := range t.Merges {
|
||||
heads[m.Repository] = m.Merge
|
||||
}
|
||||
// A head moves only forward (A-464d): a repository whose held head is not contained in the merge is left where it is.
|
||||
if held, _, err := h.Source.Read(t.Branch); err != nil {
|
||||
return err
|
||||
} else if held != nil && h.Forge != nil {
|
||||
for r, c := range heads {
|
||||
for name, was := range held.Heads {
|
||||
if !trunk.SameRepository(name, r) || was == c {
|
||||
continue
|
||||
}
|
||||
ahead, err := h.Forge.Contains(name, was, c)
|
||||
if err != nil {
|
||||
return fmt.Errorf("whether %.12s is in %.12s of %s cannot be read, so the head stays: %w", was, c, name, err)
|
||||
}
|
||||
if !ahead {
|
||||
h.logf("[mesh-delivery] source.%s keeps %s at %.12s: the take-in's merge %.12s does not contain it, left without effect", t.Branch, name, was, c)
|
||||
delete(heads, r)
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(heads) == 0 {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
wrote := false
|
||||
rev, err := h.Source.Set(t.Branch, func(prev *Source) (Source, bool) {
|
||||
wrote = false
|
||||
next := Source{Group: t.Group, Heads: heads}
|
||||
if prev != nil {
|
||||
same := true
|
||||
for r, c := range heads {
|
||||
if prev.Heads[r] != c {
|
||||
same = false
|
||||
}
|
||||
}
|
||||
if same {
|
||||
return Source{}, false // a merged message moved these heads already: no revision (A-464c)
|
||||
}
|
||||
next.Heads = map[string]string{}
|
||||
for r, c := range prev.Heads {
|
||||
next.Heads[r] = c
|
||||
@@ -118,12 +153,13 @@ func (h *Holder) moveSource(t meshcatalog.TakeInTaken) error {
|
||||
next.Heads[r] = c
|
||||
}
|
||||
}
|
||||
wrote = true
|
||||
return next, true
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("source.%s cannot be moved: %w", t.Branch, err)
|
||||
}
|
||||
if h.SaySeat == nil {
|
||||
if h.SaySeat == nil || !wrote {
|
||||
return nil
|
||||
}
|
||||
at := h.Now().UTC()
|
||||
|
||||
@@ -84,7 +84,7 @@ func TestATakeInTakenOpensOneRecordAndMovesItsBranchsSource(t *testing.T) {
|
||||
if s := src.vals["main"]; s.Group != "feat" || s.Heads["novox/app"] != merge {
|
||||
t.Fatalf("source.main %+v", s)
|
||||
}
|
||||
if len(events) != 2 || !strings.HasSuffix(events[0].subject, ".event.source-moved.main") {
|
||||
if len(events) != 1 || !strings.HasSuffix(events[0].subject, ".event.source-moved.main") {
|
||||
t.Fatalf("said %+v", events)
|
||||
}
|
||||
drop := json.RawMessage(`{"v":1,"kind":"taken","key":"m.00000000000000000002","what":"revision","dropped":true,"branch":"main","source":8,` +
|
||||
@@ -92,7 +92,7 @@ func TestATakeInTakenOpensOneRecordAndMovesItsBranchsSource(t *testing.T) {
|
||||
if err := c.Hear(stdio.Envelope{Key: "mesh-delivery-indexer.take-in.taken", Body: drop}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if kept, _ := h.Records.Kept(); len(kept) != 1 || len(events) != 2 {
|
||||
if kept, _ := h.Records.Kept(); len(kept) != 1 || len(events) != 1 {
|
||||
t.Fatalf("a hand drop opened %d records and said %d events", len(kept), len(events))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,6 +23,7 @@
|
||||
"git.pull-merged",
|
||||
"git.pull-closed",
|
||||
"mesh-catalog.registration-changed",
|
||||
"mesh-delivery-forge-bridge.forge.*.*.merged",
|
||||
"mesh-conditions.findings-asked"
|
||||
],
|
||||
"emits": [
|
||||
@@ -383,6 +384,7 @@
|
||||
"gate_records",
|
||||
"gate_source",
|
||||
"gate_source_again",
|
||||
"gate_source_follow",
|
||||
"gate_source_start"
|
||||
],
|
||||
"config": {
|
||||
|
||||
@@ -33,6 +33,7 @@
|
||||
"backup_delete_retired",
|
||||
"backup_deleted"
|
||||
],
|
||||
"secrets-owner": "${machine:account}",
|
||||
"own-secrets": {
|
||||
"repository": "${dir:state}/repository.secret",
|
||||
"broker": "${dir:state}/broker"
|
||||
|
||||
Reference in New Issue
Block a user