Archived
Compare commits
5
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
19173aeb07 | ||
|
|
1826b68a22 | ||
|
|
05576db018 | ||
|
|
a688dcff39 | ||
|
|
95556b8def |
@@ -939,11 +939,16 @@ func planBatch(ctx context.Context, open *stores, batch *inventory.Plan, carry [
|
||||
commits, named := carriedOf(merges)
|
||||
var moved []string
|
||||
var members []batchMember
|
||||
unchanged := map[string]string{}
|
||||
for _, m := range combinedMerges(merges) {
|
||||
// **News, whatever was seen since** (review of this change): each merge was judged when it was heard, and
|
||||
// a cut, a fold or a failed walk since marks its modules seen — so a merge walked alone after a failed
|
||||
// walk, or folded, would read as history and move nothing. When it was made is not asked again here.
|
||||
m.MergedAt = ""
|
||||
// **Unchanged, said** (novox/hq issue 611): read before the merge is acted on, from the same records.
|
||||
for n, why := range unchangedOfMerge(m, entries, read) {
|
||||
unchanged[n] = why
|
||||
}
|
||||
names, err := movesOfMerge(ctx, inv, m, entries, read)
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -995,12 +1000,16 @@ func planBatch(ctx context.Context, open *stores, batch *inventory.Plan, carry [
|
||||
plan.Delivery.Merges = named
|
||||
plan.Delivery.Alone = batch.Delivery != nil && batch.Delivery.Alone
|
||||
plan.Delivery.Withheld = withheld
|
||||
plan.Delivery.Unchanged = unchangedLeft(unchanged, plan.Modules)
|
||||
// **Its moments and its class** (novox/hq ADR 0282 decision 6): measured, never acted on.
|
||||
plan.Times = walkTimesAtCut(*batch, plan, entries, now)
|
||||
if len(moved) == 0 {
|
||||
plan.State = inventory.PlanDone
|
||||
plan.Tiers = [][]string{}
|
||||
plan.Note = "moved nothing the mesh holds: nothing to walk"
|
||||
if len(plan.Delivery.Unchanged) > 0 {
|
||||
plan.Note = "moved nothing the mesh holds: nothing to walk; " + unchangedSaid(plan.Delivery.Unchanged)
|
||||
}
|
||||
if err := inv.SavePlan(ctx, &plan); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -1045,6 +1054,31 @@ func planBatch(ctx context.Context, open *stores, batch *inventory.Plan, carry [
|
||||
return nil
|
||||
}
|
||||
|
||||
// unchangedSaid names the modules a walk says matched what runs, for its note.
|
||||
func unchangedSaid(unchanged map[string]string) string {
|
||||
names := make([]string, 0, len(unchanged))
|
||||
for n := range unchanged {
|
||||
names = append(names, n)
|
||||
}
|
||||
sort.Strings(names)
|
||||
return "unchanged, the build the mesh holds is theirs: " + strings.Join(names, ", ")
|
||||
}
|
||||
|
||||
// unchangedLeft is what a walk says matched what runs: every module a merge left unchanged that the walk does not
|
||||
// build anyway, as another merge's module or a dependent (novox/hq issue 611). Nil when none is.
|
||||
func unchangedLeft(unchanged map[string]string, builds map[string]*inventory.PlanModule) map[string]string {
|
||||
out := map[string]string{}
|
||||
for n, why := range unchanged {
|
||||
if _, built := builds[n]; !built {
|
||||
out[n] = why
|
||||
}
|
||||
}
|
||||
if len(out) == 0 {
|
||||
return nil
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// withhold takes from a plan every module named that its merges do not move, and the tiers left empty: the
|
||||
// modules taken.
|
||||
func withhold(plan *inventory.Plan, names, moved []string) []string {
|
||||
|
||||
@@ -0,0 +1,145 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"sort"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/novox/mesh-controller/internal/inventory"
|
||||
"github.com/novox/mesh-controller/internal/link"
|
||||
)
|
||||
|
||||
// novox/hq issue 611: mesh-controller #293 changed one test file. Its delivery plan, made while another walk built
|
||||
// build-agent and route-proxy (issue 606), read them whole and named them; at the cut their recorded build sources
|
||||
// held none of its files, so its walk moved nothing and its record named no module. mesh-delivery could not tell
|
||||
// "matched what runs" from "never built" and stopped the delivery, asking the operator about a change already on
|
||||
// every machine. The walk now says, per module, that its build matched what runs (delivery.unchanged, ADR 0267 §5).
|
||||
|
||||
// The shape of #293: a test file of the controller's repository. The controller, built from the root, and the two
|
||||
// modules packaging the repository each recorded a build source holding none of it: each is said unchanged, with
|
||||
// why; a module of another repository is not named.
|
||||
func TestAMergeSaysTheModulesWhoseBuildSourceItLeftUnchanged(t *testing.T) {
|
||||
const catalogueRepo = "http://forge.internal:20000/novox/mesh-catalog.git"
|
||||
const controllerRepo = "http://forge.internal:20000/novox/mesh-controller.git"
|
||||
entries := []inventory.Entry{
|
||||
fromRepo("mesh-controller", controllerRepo, ""),
|
||||
fromRepo("build-agent", catalogueRepo, "modules/build-agent"),
|
||||
fromRepo("route-proxy", catalogueRepo, "modules/route-proxy"),
|
||||
fromRepo("gitea", catalogueRepo, "modules/gitea"),
|
||||
}
|
||||
read := map[string][]inventory.ReadRepository{
|
||||
"mesh-controller": {{Own: true, Paths: []string{"go.mod", "module.json", "cmd/mesh-controller/", "internal/builder/"}}},
|
||||
"build-agent": {
|
||||
{Repository: "novox/mesh-controller", Ref: "main", Paths: []string{"go.mod", "cmd/mesh-builder/", "internal/builder/"}},
|
||||
{Own: true, Paths: []string{"modules/build-agent/Dockerfile", "modules/build-agent/module.json"}},
|
||||
},
|
||||
"route-proxy": {
|
||||
{Repository: "novox/mesh-controller", Ref: "main", Paths: []string{"go.mod", "examples/route-proxy/"}},
|
||||
{Own: true, Paths: []string{"modules/route-proxy/Dockerfile", "modules/route-proxy/module.json"}},
|
||||
},
|
||||
}
|
||||
m := link.SourceMoved{Owner: "novox", Repo: "mesh-controller", Base: "main", Commit: "8f1aec0",
|
||||
Paths: []string{"internal/builder/replay363_test.go"}}
|
||||
if moved := reachOfMerge(m, entries, read, sharedRepositoryEdges).Moved(); len(moved) != 0 {
|
||||
t.Fatalf("the fixture moves %v: a test file is in no build source", moved)
|
||||
}
|
||||
got := unchangedOfMerge(m, entries, read)
|
||||
var names []string
|
||||
for n, why := range got {
|
||||
names = append(names, n)
|
||||
if !strings.Contains(why, "holds none of") || !strings.Contains(why, "internal/builder/replay363_test.go") ||
|
||||
!strings.Contains(why, "the build the mesh holds is its build") {
|
||||
t.Errorf("%s is said unchanged as %q", n, why)
|
||||
}
|
||||
}
|
||||
if want := []string{"build-agent", "mesh-controller", "route-proxy"}; !reflect.DeepEqual(sortedOf(names), want) {
|
||||
t.Fatalf("said unchanged: %v; want %v", sortedOf(names), want)
|
||||
}
|
||||
|
||||
// A module whose build source holds a changed file is moved, never said unchanged.
|
||||
touched := m
|
||||
touched.Paths = []string{"internal/builder/builder.go"}
|
||||
if got := unchangedOfMerge(touched, entries, read); got["mesh-controller"] != "" || got["build-agent"] != "" {
|
||||
t.Errorf("a module the merge moves is said unchanged: %v", got)
|
||||
}
|
||||
if got := unchangedOfMerge(touched, entries, read); got["route-proxy"] == "" {
|
||||
t.Errorf("the route proxy, whose build source holds none of it, is not said unchanged: %v", got)
|
||||
}
|
||||
// With no build source recorded, the module is read whole and moved: nothing says it unchanged.
|
||||
unsaid := map[string][]inventory.ReadRepository{"build-agent": {{Repository: "novox/mesh-controller", Ref: "main"}}}
|
||||
if got := unchangedOfMerge(m, entries, unsaid); len(got) != 0 {
|
||||
t.Errorf("modules with no recorded build source are said unchanged: %v", got)
|
||||
}
|
||||
// Files not all said: every module is moved, none said unchanged.
|
||||
truncated := m
|
||||
truncated.PathsTruncated = true
|
||||
if got := unchangedOfMerge(truncated, entries, read); len(got) != 0 {
|
||||
t.Errorf("a merge whose files were not all said says %v unchanged", got)
|
||||
}
|
||||
}
|
||||
|
||||
// A module the walk builds anyway — another merge's, or a dependent — is not said unchanged: the modules map keeps
|
||||
// meaning what the walk builds, and the two never name one module.
|
||||
func TestAWalkSaysUnchangedOnlyWhatItDoesNotBuild(t *testing.T) {
|
||||
unchanged := map[string]string{"build-agent": "why a", "route-proxy": "why b"}
|
||||
got := unchangedLeft(unchanged, map[string]*inventory.PlanModule{"build-agent": {}})
|
||||
if !reflect.DeepEqual(got, map[string]string{"route-proxy": "why b"}) {
|
||||
t.Fatalf("left %v", got)
|
||||
}
|
||||
if got := unchangedLeft(map[string]string{"x": "y"}, map[string]*inventory.PlanModule{"x": {}}); got != nil {
|
||||
t.Fatalf("left %v; want none", got)
|
||||
}
|
||||
}
|
||||
|
||||
// Against the store, the path a real merge takes: a merge whose module recorded a build source that holds none
|
||||
// of its files is cut into a walk done with nothing to walk, whose record names the module unchanged and why.
|
||||
func TestAWalkThatMovedNothingSaysWhichModulesMatchedWhatRuns(t *testing.T) {
|
||||
open := windowed(t)
|
||||
endsItsLine(t)
|
||||
asksRecorded(t)
|
||||
ctx := t.Context()
|
||||
inv := open.inventory
|
||||
if err := inv.RecordBuild(ctx, inventory.Build{ID: "build-one", Repository: "novox/one", Ref: "main",
|
||||
Module: "one", Commit: "c0", On: "builder", Asked: t0.Add(-time.Hour),
|
||||
Sources: []inventory.BuildSource{{Paths: []string{"main.go", "go.mod"}}}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
readme := repoMerge("one", "one1aaaaaaaa", t0)
|
||||
readme.Paths = []string{"README.md"}
|
||||
hear(t, open, readme, t0.Add(time.Second))
|
||||
cutAt(t, open, t0.Add(2*time.Minute))
|
||||
ws, _ := walks(t, open)
|
||||
if len(ws) != 1 {
|
||||
t.Fatalf("walks: %+v", ws)
|
||||
}
|
||||
w := ws[0]
|
||||
if w.State != inventory.PlanDone || len(w.Tiers) != 0 || len(w.Modules) != 0 {
|
||||
t.Fatalf("the walk reads %s, tiers %v, modules %v; want done with nothing to walk", w.State, w.Tiers, w.Modules)
|
||||
}
|
||||
if w.Delivery == nil || !strings.Contains(w.Delivery.Unchanged["one"], "holds none of the 1 changed file(s)") {
|
||||
t.Fatalf("the walk does not say one matched what runs: %+v", w.Delivery)
|
||||
}
|
||||
if !strings.Contains(w.Note, "unchanged") || !strings.Contains(w.Note, "one") {
|
||||
t.Errorf("the walk's note does not name it: %q", w.Note)
|
||||
}
|
||||
|
||||
// A merge that changes the build source is walked, and says nothing unchanged.
|
||||
code := repoMerge("one", "one2bbbbbbbb", t0.Add(3*time.Minute))
|
||||
hear(t, open, code, t0.Add(3*time.Minute+time.Second))
|
||||
cutAt(t, open, t0.Add(6*time.Minute))
|
||||
ws, _ = walks(t, open)
|
||||
if len(ws) != 2 {
|
||||
t.Fatalf("walks: %+v", ws)
|
||||
}
|
||||
if _, built := ws[0].Modules["one"]; !built || ws[0].Delivery == nil || len(ws[0].Delivery.Unchanged) != 0 {
|
||||
t.Fatalf("the walk of a change to main.go reads modules %v, delivery %+v", ws[0].Modules, ws[0].Delivery)
|
||||
}
|
||||
}
|
||||
|
||||
func sortedOf(names []string) []string {
|
||||
out := append([]string{}, names...)
|
||||
sort.Strings(out)
|
||||
return out
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/novox/mesh-controller/internal/catalogue"
|
||||
"github.com/novox/mesh-controller/internal/inventory"
|
||||
"github.com/novox/mesh-controller/internal/link"
|
||||
)
|
||||
|
||||
// Replay of novox/hq issue 239 (2026-10-04): the photo app's module `photos` was built from the app's own
|
||||
// repository, and the catalogue held a stub of the same name in `modules/photos` that had never run. Rebuilding
|
||||
// `photos` "to main" built the catalogue's main instead; the controller registered the outcome and recorded the
|
||||
// catalogue as the module's new source, and the next push replaced the app with the stub: two sites' containers
|
||||
// and five of its six routes went. Nothing compared the build's source with the source recorded before it.
|
||||
//
|
||||
// Written only with what the controller had before its fix (mesh-controller #174, hq ADR 0266 §7): a mesh, the
|
||||
// inventory's RegisterModule and SourceOf, a kept build request, and takeIn for the build's outcome — so the
|
||||
// prover (mesh-lab replays/cmd/prove) lays it over the commit before. Its outcome is the issue's acceptance: a
|
||||
// build asked through a verb, of a module's name from a repository other than the one the module is registered
|
||||
// from, is refused, says both sources, and leaves the module and its recorded source as they were. Needs a
|
||||
// store: MESH_TEST_POSTGRES.
|
||||
func TestReplay239AModuleNameIsNotTakenOverByAnotherRepository(t *testing.T) {
|
||||
open := aMesh(t)
|
||||
ctx := t.Context()
|
||||
inv := open.inventory
|
||||
// Every verb's command runs marked as the serving controller's: never the terminal.
|
||||
t.Setenv("MESH_SERVED_BY_THE_CONTROLLER", "1")
|
||||
|
||||
register := func(raw, repository, path string) {
|
||||
t.Helper()
|
||||
m, err := catalogue.ParseManifest([]byte(raw))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := inv.RegisterModule(ctx, m, inventory.Source{Repository: repository, Seat: "git", Path: path,
|
||||
Ref: "main", BuiltFrom: "1111111111111111"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
// The app, built from its own repository; and another module of the catalogue, so the catalogue is a
|
||||
// repository the mesh builds from.
|
||||
register(`{"module": "photos", "version": "app"}`, "novox/photos", "")
|
||||
register(`{"module": "sudo", "version": "1"}`, "novox/mesh-catalog", "modules/sudo")
|
||||
|
||||
// The rebuild "to main", asked through the build verb: the catalogue's stub of the same name.
|
||||
const id = "build-photos-from-the-catalogue"
|
||||
if err := inv.RecordBuildRequest(ctx, inventory.BuildRequest{ID: id, Repository: "novox/mesh-catalog",
|
||||
Seat: "git", Path: "modules/photos", Ref: "main", For: "build"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
stub, _ := json.Marshal(map[string]any{"module": "photos", "version": "stub"})
|
||||
_, _, err := takeIn(ctx, inv, link.BuildResult{ID: id,
|
||||
Repository: "http://forge.internal:20000/novox/mesh-catalog.git", Path: "modules/photos", Ref: "main",
|
||||
On: "anchor", Commit: "2222222222222222", Manifest: stub, Trunk: "main", OnTrunk: true,
|
||||
Branches: []string{"main"}, Source: &link.SourceOnSeat{Seat: "git", Repository: "novox/mesh-catalog"}})
|
||||
|
||||
if err == nil {
|
||||
t.Error("a build of photos from the catalogue was registered over the app's own repository")
|
||||
} else if !strings.Contains(err.Error(), "novox/photos") || !strings.Contains(err.Error(), "novox/mesh-catalog") {
|
||||
t.Errorf("the refusal does not say both sources: %v", err)
|
||||
}
|
||||
if src, err := inv.SourceOf(ctx, "photos"); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if src.Repository != "novox/photos" {
|
||||
t.Errorf("photos is now recorded as built from %q, not its own repository", src.Repository)
|
||||
}
|
||||
shelf, err := inv.Catalogue(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := shelf["photos"].Version; got != "app" {
|
||||
t.Errorf("photos is now %q: the next push sends the catalogue's stub", got)
|
||||
}
|
||||
if _, found, _ := inv.BuildByID(ctx, id); !found {
|
||||
t.Error("the refused build is not recorded")
|
||||
}
|
||||
}
|
||||
@@ -692,9 +692,73 @@ func readsFile(e inventory.Entry, read []inventory.ReadRepository, p string) boo
|
||||
if own := ownSource(read); own != nil {
|
||||
return builder.SourceHolds(own, p)
|
||||
}
|
||||
return readsDirectory(e, p)
|
||||
}
|
||||
|
||||
// readsDirectory is whether a changed file is in a module's directory, or anywhere for a module built from its
|
||||
// repository's root: the reading of a module with no recorded build source.
|
||||
func readsDirectory(e inventory.Entry, p string) bool {
|
||||
return strings.Trim(e.Source.Path, "/") == "" || inside(p, e.Source.Path)
|
||||
}
|
||||
|
||||
// unchangedOfMerge are the modules a merge changed files for under a reading without recorded build sources, but
|
||||
// whose recorded build source holds none of them, each with why (novox/hq issue 611): not built, because the build
|
||||
// the mesh holds is theirs (ADR 0267 §5). That reading — a delivery plan made while another walk built the module
|
||||
// (issue 606) — would have moved them; the walk says they matched what runs rather than leaving them unnamed.
|
||||
// A module built from the repository whose directory, or whole repository when built from its root, holds a
|
||||
// changed file, and a module packaging the repository's branch, are each read so. A merge whose changed files
|
||||
// were not all said moves every one of them: none is said here. Without acting.
|
||||
func unchangedOfMerge(m link.SourceMoved, entries []inventory.Entry,
|
||||
read map[string][]inventory.ReadRepository) map[string]string {
|
||||
if len(m.Paths) == 0 || m.PathsTruncated {
|
||||
return nil
|
||||
}
|
||||
from, _, _ := mergeCandidates(m, entries, read)
|
||||
touched, _, _ := touchedBy(from, entries, m, read)
|
||||
out := map[string]string{}
|
||||
for _, e := range from {
|
||||
name := e.Manifest.Module
|
||||
if ownSource(read[name]) == nil || slices.ContainsFunc(touched, func(t inventory.Entry) bool {
|
||||
return t.Manifest.Module == name
|
||||
}) {
|
||||
continue
|
||||
}
|
||||
var in []string
|
||||
for _, p := range m.Paths {
|
||||
if readsDirectory(e, p) {
|
||||
in = append(in, p)
|
||||
}
|
||||
}
|
||||
if len(in) > 0 {
|
||||
out[name] = fmt.Sprintf("its build source holds none of the %d changed file(s) in its directory (e.g. %s): "+
|
||||
"the build the mesh holds is its build", len(in), in[0])
|
||||
}
|
||||
}
|
||||
for _, e := range entries {
|
||||
name := e.Manifest.Module
|
||||
if sourceIs(e.Source, m) || !packagesSaid(read[name], m) || readsFrom(read[name], m) {
|
||||
continue
|
||||
}
|
||||
out[name] = fmt.Sprintf("its build source in %s/%s holds none of the %d changed file(s) (e.g. %s): "+
|
||||
"the build the mesh holds is its build", m.Owner, m.Repo, len(m.Paths), m.Paths[0])
|
||||
}
|
||||
if len(out) == 0 {
|
||||
return nil
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// packagesSaid is whether a module's newest trunk build said the build source it read in a merge's repository and
|
||||
// branch, as a context beside its own.
|
||||
func packagesSaid(read []inventory.ReadRepository, m link.SourceMoved) bool {
|
||||
for _, r := range read {
|
||||
if !r.Own && sameRepository(r.Repository, m) && (r.Ref == "" || r.Ref == m.Base) && len(r.Paths) > 0 {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// staleIn is the modules whose recorded build source a plan has overtaken (novox/hq ADR 0267): a plan still
|
||||
// working that has yet to build one, or a plan made after that build which never built it — failed, stopped
|
||||
// or superseded. What such a module is built from is changing, or changed without a build to say so: a merge
|
||||
|
||||
@@ -322,6 +322,9 @@ var defaultSeats = append([]Seat{
|
||||
// node-mounts writes a mount and an automount unit per share on a machine that asks (shares.go).
|
||||
{Name: NFSServerSeat, Scope: ScopeNode, Decision: "novox/hq ADR 0263", Serves: nfsServerVerbs()},
|
||||
{Name: MountsSeat, Scope: ScopeNode, Decision: "novox/hq ADR 0263", Serves: mountsVerbs()},
|
||||
// A machine's SMB shares for the devices on its own network (novox/hq ADR 0341, smb.go): its holder
|
||||
// writes the SMB configuration, serves 445 alone and maps every client to the shared folder's owner.
|
||||
{Name: SMBServerSeat, Scope: ScopeNode, Decision: "novox/hq ADR 0341", Serves: smbServerVerbs()},
|
||||
// A node's files and accounts, read (novox/hq ADR 0310, reads.go): by an account of the holder's own that holds
|
||||
// no secret, on every node, so the reads ADR 0268 §5 takes over from the login shell's execute have a tool.
|
||||
{Name: ReadsSeat, Scope: ScopeNode, Decision: "novox/hq ADR 0310", Serves: readsVerbs()},
|
||||
|
||||
@@ -48,7 +48,7 @@ func TestTheSeatsAreAClosedSetAndEachNamesItsDecision(t *testing.T) {
|
||||
delivered[s.Delivers] = s.Name
|
||||
}
|
||||
}
|
||||
// Forty-one with node-reads (novox/hq ADR 0310); forty with node-nfs-server and node-mounts (novox/hq ADR 0263); thirty-eight with node-resolver (novox/hq ADR 0247); thirty-seven with mesh-delivery (novox/hq ADR 0239); thirty-six since node-resolver-config retired
|
||||
// Forty-two with node-smb-server (novox/hq ADR 0341); forty-one with node-reads (novox/hq ADR 0310); forty with node-nfs-server and node-mounts (novox/hq ADR 0263); thirty-eight with node-resolver (novox/hq ADR 0247); thirty-seven with mesh-delivery (novox/hq ADR 0239); thirty-six since node-resolver-config retired
|
||||
// into node-uplink (novox/hq ADR 0223); thirty-seven
|
||||
// since the retired node-dns-resolver went (novox/hq ADR 0220); thirty-eight with
|
||||
// node-backup (novox/hq ADR 0214); thirty-seven with node-message-bus (novox/hq ADR 0215);
|
||||
@@ -59,8 +59,8 @@ func TestTheSeatsAreAClosedSetAndEachNamesItsDecision(t *testing.T) {
|
||||
// node-container-runtime (ADR 0207); nineteen with node-environment and node-login-shell (ADR 0203,
|
||||
// ADR 0204); seventeen with node-build-agent (ADR 0190). One fewer once the retired
|
||||
// mesh-build-machine row goes, when no registered manifest claims it.
|
||||
if len(Seats()) != 41 {
|
||||
t.Errorf("the mesh defines %d seats rather than 41; the set is closed, so a change here is "+
|
||||
if len(Seats()) != 42 {
|
||||
t.Errorf("the mesh defines %d seats rather than 42; the set is closed, so a change here is "+
|
||||
"a decision (novox/hq ADR 0110): %s", len(Seats()), seatNames())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -31,9 +31,10 @@ func nfsServerVerbs() []Verb {
|
||||
{Name: "exports", Description: "Every share this machine exports: its name, its path, read-write or " +
|
||||
"read-only, the owner every client is mapped to (uid and gid), each node it is exported to with that " +
|
||||
"node's private address and access (only the nodes the server grants it to and that ask for it), " +
|
||||
"what is granted and not asked for or asked for and not granted, and whether the kernel holds it " +
|
||||
"now. Also the exports found that are not the mesh's: a dataset's sharenfs property, a line in " +
|
||||
"/etc/exports.",
|
||||
"the subnets of this machine's local network it is exported to when the server grants it " +
|
||||
"local-network (novox/hq ADR 0341), what is granted and not asked for or asked for and not " +
|
||||
"granted, and whether the kernel holds it now. Also the exports found that are not the mesh's: a " +
|
||||
"dataset's sharenfs property, a line in /etc/exports.",
|
||||
Input: schema(map[string]string{}, nil),
|
||||
Replaces: []string{"exportfs -v", "cat /etc/exports", "zfs get sharenfs"}},
|
||||
{Name: "clients", Description: "Which machines have mounted which share now, as the NFS server " +
|
||||
@@ -55,8 +56,10 @@ func nfsServerVerbs() []Verb {
|
||||
Input: schema(map[string]string{}, nil),
|
||||
Replaces: []string{"exportfs -ra"}},
|
||||
{Name: "adopt", Description: "Take over an export a person made by hand: clear a dataset's sharenfs " +
|
||||
"property for a path the mesh's own export now serves — only when that export is live. Without " +
|
||||
"confirm, says what it would do and changes nothing.",
|
||||
"property for a path the mesh's own export now serves — only when that export is live and covers " +
|
||||
"every client the property exported to: for a property exporting to the local network, the " +
|
||||
"mesh's local-network export of the path (novox/hq ADR 0341). Without confirm, says what it " +
|
||||
"would do and changes nothing.",
|
||||
Input: schema(map[string]string{
|
||||
"path": "the shared path whose hand-made export is taken over",
|
||||
"confirm": "\"true\": change it (needs why); anything else is a dry run",
|
||||
|
||||
@@ -0,0 +1,53 @@
|
||||
package catalogue
|
||||
|
||||
// A machine's SMB shares, served to the devices on its own network that are not nodes (novox/hq
|
||||
// ADR 0341).
|
||||
//
|
||||
// **One holder per machine.** Two modules writing one machine's Samba configuration is the conflict a
|
||||
// seat exists to refuse, so the role is a node seat. It delivers nothing: its clients are devices that
|
||||
// are not nodes, and a node that wants the same files mounts the NFS share (ADR 0263), so no provision
|
||||
// is answered through it.
|
||||
//
|
||||
// **The data is the operator's** (ADR 0051). The holder never creates, chowns or removes anything under
|
||||
// a shared path, and every client acts as the shared folder's owner. Its verbs read, and the one that
|
||||
// takes over the configuration a person wrote by hand does it only on a person's word, keeping a dated
|
||||
// copy of what it replaces.
|
||||
|
||||
// SMBServerSeat is the role of the machine that shares folders over SMB with its local network
|
||||
// (novox/hq ADR 0341).
|
||||
const SMBServerSeat = "node-smb-server"
|
||||
|
||||
// smbServerVerbs is the contract every holder of node-smb-server serves (novox/hq ADR 0341).
|
||||
func smbServerVerbs() []Verb {
|
||||
return []Verb{
|
||||
{Name: "shares", Description: "Every SMB share this machine serves: its name, its path, read-write " +
|
||||
"or read-only, the owner every client acts as (uid and gid), the logins allowed and whether each " +
|
||||
"login's password was given or is kept as found, and whether the service serves it now. Also " +
|
||||
"whether the configuration is the mesh's or still the hand-written one, and each hand-written " +
|
||||
"share with whether the settings name it. A password is never shown.",
|
||||
Input: schema(map[string]string{}, nil),
|
||||
Replaces: []string{"testparm -s", "cat /etc/samba/smb.conf", "pdbedit -L"}},
|
||||
{Name: "sessions", Description: "Which devices are connected to which share now, with the login and " +
|
||||
"the protocol version each uses, as the SMB service knows them.",
|
||||
Input: schema(map[string]string{}, nil),
|
||||
Replaces: []string{"smbstatus"}},
|
||||
{Name: "test", Description: "Whether this machine serves one share now and whether its SMB service " +
|
||||
"is up and listening on 445: what a device on the local network is answered.",
|
||||
Input: schema(map[string]string{"share": "the share, by its name"}, []string{"share"}),
|
||||
Replaces: []string{"smbclient -L"}},
|
||||
{Name: "reload", Description: "Have the SMB service read its configuration again now (smbcontrol " +
|
||||
"reload-config) and answer the shares as it then serves them. The module's own process writes the " +
|
||||
"configuration; this is for after a change made outside it. Changes no shared path.",
|
||||
Input: schema(map[string]string{}, nil),
|
||||
Replaces: []string{"smbcontrol smbd reload-config", "systemctl reload smb"}},
|
||||
{Name: "adopt", Description: "Take over the SMB configuration a person wrote by hand: keep a dated " +
|
||||
"copy of it beside it and write the mesh's own in its place — only when every hand-written share " +
|
||||
"has its counterpart in the settings, so no share disappears. Without confirm, says what it would " +
|
||||
"do and changes nothing: each hand-written share beside the mesh's rendering of it.",
|
||||
Input: schema(map[string]string{
|
||||
"confirm": "\"true\": change it (needs why); anything else is a dry run",
|
||||
"why": "why, for the record",
|
||||
}, nil, "confirm"),
|
||||
Replaces: []string{"edit /etc/samba/smb.conf"}},
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
package catalogue
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// Defends novox/hq ADR 0341: a machine's SMB shares are one node seat, node-smb-server, with its verbs
|
||||
// required of every holder, delivering nothing — its clients are devices that are not nodes.
|
||||
|
||||
func TestTheSMBServerIsANodeSeatWithItsVerbs(t *testing.T) {
|
||||
s, ok := SeatNamed(SMBServerSeat)
|
||||
if !ok {
|
||||
t.Fatalf("%s is not in the mesh's set", SMBServerSeat)
|
||||
}
|
||||
if s.Scope != ScopeNode || s.Decision != "novox/hq ADR 0341" || s.Delivers != "" || s.Replicated {
|
||||
t.Errorf("%s is %+v; a node seat under ADR 0341 that delivers nothing", SMBServerSeat, s)
|
||||
}
|
||||
var got []string
|
||||
for _, v := range s.Serves {
|
||||
got = append(got, v.Name)
|
||||
if v.Optional {
|
||||
t.Errorf("%s.%s is optional; its first holder serves it", SMBServerSeat, v.Name)
|
||||
}
|
||||
if v.Description == "" || v.Input["type"] != "object" || len(v.Replaces) == 0 {
|
||||
t.Errorf("%s.%s has no description, no object schema or says it replaces nothing", SMBServerSeat, v.Name)
|
||||
}
|
||||
}
|
||||
if strings.Join(got, " ") != "shares sessions test reload adopt" {
|
||||
t.Errorf("%s serves %v", SMBServerSeat, got)
|
||||
}
|
||||
}
|
||||
|
||||
// Taking over the hand-written configuration is a person's act (ADR 0341 clause 7): a dry run unless the
|
||||
// string switch says "true", and it says it keeps a dated copy and refuses to drop a share.
|
||||
func TestTheSMBAdoptIsADryRunUnlessConfirmed(t *testing.T) {
|
||||
s, _ := SeatNamed(SMBServerSeat)
|
||||
for _, v := range s.Serves {
|
||||
if v.Name != "adopt" {
|
||||
continue
|
||||
}
|
||||
props, _ := v.Input["properties"].(map[string]any)
|
||||
confirm, _ := props["confirm"].(map[string]any)
|
||||
if confirm == nil || confirm["enum"] == nil || confirm["type"] != "string" {
|
||||
t.Errorf("adopt has no string confirm switch: %v", v.Input)
|
||||
}
|
||||
for _, says := range []string{"Without confirm, says what it would do and changes nothing", "dated copy", "no share disappears"} {
|
||||
if !strings.Contains(v.Description, says) {
|
||||
t.Errorf("adopt does not say %q: %s", says, v.Description)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
t.Error("node-smb-server has no adopt")
|
||||
}
|
||||
|
||||
// A holder serving every verb holds the seat; a verb too many, one too few or the mesh's scope is refused,
|
||||
// as the catalogue's smb-server module claims it.
|
||||
func TestAHolderOfTheSMBSeatServesEveryVerbAndNothingElse(t *testing.T) {
|
||||
seat, _ := SeatNamed(SMBServerSeat)
|
||||
verbs := []string{"shares", "sessions", "test", "reload", "adopt"}
|
||||
holder := Manifest{Module: "smb-server", Version: "1",
|
||||
Claims: []Claim{{Name: SMBServerSeat, Scope: ScopeNode, Serves: verbs}}}
|
||||
if err := CanHold(holder, seat); err != nil {
|
||||
t.Errorf("smb-server serving every verb is refused: %v", err)
|
||||
}
|
||||
short := holder
|
||||
short.Claims = []Claim{{Name: SMBServerSeat, Scope: ScopeNode, Serves: verbs[:4]}}
|
||||
if err := CanHold(short, seat); err == nil || !strings.Contains(err.Error(), "adopt") {
|
||||
t.Errorf("leaving adopt out was accepted: %v", err)
|
||||
}
|
||||
mesh := holder
|
||||
mesh.Claims = []Claim{{Name: SMBServerSeat, Scope: ScopeMesh, Serves: verbs}}
|
||||
if err := CanHold(mesh, seat); err == nil {
|
||||
t.Error("claiming a node seat at the mesh's scope was accepted")
|
||||
}
|
||||
}
|
||||
|
||||
// node-nfs-server's adopt clears sharenfs only once the mesh's export covers every client the property
|
||||
// exported to, the local network included (ADR 0341 clause 10), and exports names the local-network grant.
|
||||
func TestTheNFSVerbsSayTheLocalNetworkGrant(t *testing.T) {
|
||||
s, _ := SeatNamed(NFSServerSeat)
|
||||
for _, v := range s.Serves {
|
||||
switch v.Name {
|
||||
case "adopt":
|
||||
if !strings.Contains(v.Description, "covers every client the property exported to") {
|
||||
t.Errorf("nfs adopt does not wait for the export to cover every client: %s", v.Description)
|
||||
}
|
||||
case "exports":
|
||||
if !strings.Contains(v.Description, "local-network") {
|
||||
t.Errorf("nfs exports does not say the local-network grant: %s", v.Description)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -220,6 +220,11 @@ type PlanDelivery struct {
|
||||
// Withheld are, on a walk cut from a batch a stop walked merges again in, the modules it did not build: a
|
||||
// stopped merge moves them, and built only as dependents at the branch they would deliver it (ADR 0299).
|
||||
Withheld []string `json:"withheld,omitempty"`
|
||||
// Unchanged are the modules a merge it answers changed files in the directory of, whose recorded build source
|
||||
// holds none of them, each with why (novox/hq issue 611, ADR 0267 §5): not built, because the build the mesh
|
||||
// holds is their build. A delivery plan that read them whole named them; this says they matched what runs,
|
||||
// rather than that the walk left them unbuilt. Modules keeps meaning what the walk builds.
|
||||
Unchanged map[string]string `json:"unchanged,omitempty"`
|
||||
// Batch is the window of a batch; nil once it is cut into a walk.
|
||||
Batch *PlanBatch `json:"batch,omitempty"`
|
||||
// Alone says the walk walks one merge on its own commit, after a failed walk carried it in a later one:
|
||||
|
||||
Vendored
+2
@@ -43,3 +43,5 @@
|
||||
./cmd/mesh-controller TestOnlyATrustedFilesNamedKeyIsRefusedThroughAVerb
|
||||
./cmd/mesh-controller TestReplay349
|
||||
./cmd/mesh-controller TestReplay348AFaultFromBeforeTheSendFailsNoGate
|
||||
./cmd/mesh-controller TestReplay239AModuleNameIsNotTakenOverByAnotherRepository
|
||||
./cmd/mesh-controller TestAWalkThatMovedNothingSaysWhichModulesMatchedWhatRuns
|
||||
|
||||
Reference in New Issue
Block a user