diff --git a/modules/mesh-delivery-forge-bridge/forgemsg/forge.go b/modules/mesh-delivery-forge-bridge/forgemsg/forge.go index 027a891c..eff0989a 100644 --- a/modules/mesh-delivery-forge-bridge/forgemsg/forge.go +++ b/modules/mesh-delivery-forge-bridge/forgemsg/forge.go @@ -1,18 +1,16 @@ -// Package forgemsg is the forge bridge's contract on its own stream `forge` (novox/hq ADR 0633 §4): its messages (Forge, -// one per pull request, merge, refusal or list of open pull requests) and a delivery group's end (ForgeGroupEnd). The -// forge bridge writes them; the indexer and the gate read them. It is the forge bridge's own package: one module owns -// these types, so they live with it and not in mesh-sdk (the operator, 2026-11-04). +// Package forgemsg is the forge bridge's contract on its own stream `forge` (novox/hq ADR 0633 §4): its one message per +// move of a watched branch's head (HeadMoved, design 47 H §739) and an owed act's outcome (OwedEnded). The forge bridge +// writes them; the gate reads them. It is the forge bridge's own package: one module owns these types, so they live with +// it and not in mesh-sdk (the operator, 2026-11-04). package forgemsg import ( + "bytes" "encoding/json" "fmt" - "reflect" "regexp" "strings" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/trunk" "git.novox.be/novox/mesh-sdk/go/keys" ) @@ -22,33 +20,89 @@ const Version = keys.Version // ForgeStream is the forge bridge's stream as its manifest declares it; the broker derives the real names. const ForgeStream = "forge" -// The kinds of forge message, the last part of a forge event's name. -const ( - ForgePull = "pull" - ForgeMerged = "merged" - // ForgePushed is a move of a watched branch the forge names no pull request's merge for (design 47 G §509): an - // admitted push, taken in as a merged message is. - ForgePushed = "pushed" - ForgeRefused = "refused" - ForgeOpen = "open" -) +// HeadMovedKind is the last part of a head-moved message's name. +const HeadMovedKind = "head-moved" -// OpenPull names an open pull request into the trunk: the repository as `/` and the number. -type OpenPull struct { +// HeadMoved is the bridge's one message per move of a watched branch's head (design 47 H §739): the repository as +// `/`, the branch, the head the bridge read through git.branch, the head it held for that branch before +// (empty the first time) and Start, true when said at the bridge's start. It names no pull request and no tree. +type HeadMoved struct { + V int `json:"v"` Repository string `json:"repository"` - Number int `json:"number"` + Branch string `json:"branch"` + Head string `json:"head"` + Before string `json:"before,omitempty"` + Start bool `json:"start,omitempty"` } -// OpenEvent is the name of an open message: `forge.open`. It names no repository: it says every open pull request of -// every repository the forge bridge reads (novox/hq ADR 0443 §5). -func OpenEvent() string { return "forge." + ForgeOpen } +// HeadMovedEvent is the name of a head-moved message: `forge....head-moved`, the branch +// escaped as a key's name is, so a branch holding a dot is one token (design 47 H H-A-27). +func HeadMovedEvent(repository, branch string) (string, error) { + if err := checkRepository(repository); err != nil { + return "", err + } + if branch == "" { + return "", fmt.Errorf("delivery: a head-moved message names no branch") + } + owner, name, _ := strings.Cut(repository, "/") + return "forge." + owner + "." + name + "." + keys.EscapeName(branch) + "." + HeadMovedKind, nil +} -// The actions of a pull message. -const ( - PullOpened = "opened" - PullUpdated = "updated" - PullClosed = "closed" -) +// HeadMovedEvents is the filter of every head-moved message's name. +func HeadMovedEvents() string { return "forge.*.*.*." + HeadMovedKind } + +// ParseHeadMovedEvent is the inverse of HeadMovedEvent. +func ParseHeadMovedEvent(event string) (repository, branch string, err error) { + parts := strings.Split(event, ".") + if len(parts) != 5 || parts[0] != "forge" || parts[4] != HeadMovedKind { + return "", "", fmt.Errorf("delivery: %q is not a head-moved message, forge....%s", event, HeadMovedKind) + } + repository = parts[1] + "/" + parts[2] + if err := checkRepository(repository); err != nil { + return "", "", fmt.Errorf("delivery: %q: %w", event, err) + } + if branch, err = keys.UnescapeName(parts[3]); err != nil || branch == "" { + return "", "", fmt.Errorf("delivery: %q: the branch part %q is no escaped name: %v", event, parts[3], err) + } + return repository, branch, nil +} + +func (h HeadMoved) check() error { + if err := checkRepository(h.Repository); err != nil { + return err + } + switch { + case h.Branch == "": + return fmt.Errorf("delivery: the head-moved of %s names no branch", h.Repository) + case h.Head == "": + return fmt.Errorf("delivery: the head-moved of %s %s names no head", h.Repository, h.Branch) + case h.Head == h.Before: + return fmt.Errorf("delivery: the head-moved of %s %s names the head it held, %s: a head equal to the one held writes nothing", h.Repository, h.Branch, h.Head) + } + return nil +} + +// EncodeHeadMoved is h as JSON at Version; it refuses what check refuses. +func EncodeHeadMoved(h HeadMoved) ([]byte, error) { + if err := h.check(); err != nil { + return nil, err + } + h.V = Version + return json.Marshal(h) +} + +// DecodeHeadMoved reads a head-moved message; it refuses an unknown version, a field the message does not have (a tree +// or a base among them) and what EncodeHeadMoved refuses. +func DecodeHeadMoved(data []byte) (HeadMoved, error) { + var h HeadMoved + if err := decode(data, &h); err != nil { + return HeadMoved{}, err + } + if err := h.check(); err != nil { + return HeadMoved{}, err + } + return h, nil +} // checkRepository refuses a repository that is not `/`: exactly one slash, each part a valid name. func checkRepository(repository string) error { @@ -62,346 +116,13 @@ func checkRepository(repository string) error { if err := checkName("repository name", name); err != nil { return fmt.Errorf("delivery: the repository %q: %w", repository, err) } - if strings.Contains(owner, "/") { - return fmt.Errorf("delivery: the repository %q is not /, with exactly one slash", repository) - } return nil } -func checkForgeKind(kind string) error { - switch kind { - case ForgePull, ForgeMerged, ForgePushed, ForgeRefused, ForgeOpen: - return nil - } - return fmt.Errorf("delivery: the forge kind %q is not pull, merged, pushed, refused or open", kind) -} +var nameOK = regexp.MustCompile(`^[-_=a-zA-Z0-9]+$`) -// ForgeEvent is the name of a forge message of the given kind: `forge...`. -func ForgeEvent(repository, kind string) (string, error) { - if err := checkForgeKind(kind); err != nil { - return "", err - } - if kind == ForgeOpen { - return "", fmt.Errorf("delivery: an open message names no repository, its event is %s", OpenEvent()) - } - if err := checkRepository(repository); err != nil { - return "", err - } - owner, name, _ := strings.Cut(repository, "/") - return "forge." + owner + "." + name + "." + kind, nil -} - -// ParseForgeEvent is the inverse of ForgeEvent. -func ParseForgeEvent(event string) (repository, kind string, err error) { - if event == OpenEvent() { - return "", ForgeOpen, nil - } - parts := strings.Split(event, ".") - if len(parts) != 4 || parts[0] != "forge" { - return "", "", fmt.Errorf("delivery: %q is not a forge event, forge...", event) - } - repository = parts[1] + "/" + parts[2] - if _, err := ForgeEvent(repository, parts[3]); err != nil { - return "", "", fmt.Errorf("delivery: %q is not a forge event: %w", event, err) - } - return repository, parts[3], nil -} - -// Forge is a message of the forge bridge's stream, trimmed to repository, branch, pull request and head. A pull -// message says Action; a merged message carries the merge commit, the tree of every directory holding a -// module.json and the repository's root tree; a refused message names the owed act it answers and the forge's own -// words. A pull message may also carry the module directories its head changes (Dirs, in the order the forge said) and -// DirsKnown, true when the forge could say them: known and empty is DirsKnown with no Dirs, not known is neither -// (the forge's module_dirs and module_dirs_said, mesh-catalog modules/gitea/trunk.ts). Other messages carry neither. -type Forge struct { - V int `json:"v"` - Kind string `json:"kind"` - Repository string `json:"repository"` - // Branch is a pull or merged message's pull request branch, and a pushed message's branch pushed. - Branch string `json:"branch,omitempty"` - // Base is the watched branch a merged message's commit landed on (design 47 G §714). - Base string `json:"base,omitempty"` - Number int `json:"number,omitempty"` - // Head is a pull or merged message's pull request head commit, and a pushed message's new head of its branch (A-236). - Head string `json:"head,omitempty"` - // Before is a pushed message's head of its branch before, as the forge bridge last wrote it (A-236), empty for none. - Before string `json:"before,omitempty"` - Action string `json:"action,omitempty"` - Dirs []string `json:"dirs,omitempty"` - DirsKnown bool `json:"dirs-known,omitempty"` - Merge string `json:"merge,omitempty"` - Trees map[string]string `json:"trees,omitempty"` - Root string `json:"root,omitempty"` - // Manifests are the module.json bytes, exact, of each module directory: of the merge's trees on a merged message, - // of Dirs at the head on a pull message. Locks are, of each such directory, its lock files' hex sha256 by path - // relative to it (novox/hq ADR 0465 clause 1). Older writers send neither. - Manifests map[string]string `json:"manifests,omitempty"` - Locks map[string]map[string]string `json:"locks,omitempty"` - // Needs are, of each such directory whose manifest names templates, the reader capabilities of the module whole: - // its manifest's and its templates' text's at the same commit (catalogue.ModuleNeeds; novox/hq ADR 0632 §2). The - // indexer takes them over the manifest's own; a directory absent, or an older writer, has the manifest's alone. - Needs map[string][]string `json:"needs,omitempty"` - // Paths are, of each module directory whose manifest names paths on every artifact, each named path's git object - // id at the same commit as its manifest, by path relative to the directory (novox/hq ADR 0499 clause 3). The - // indexer names the paths; a message without them gives such a module none. Older writers send none. - Paths map[string]map[string]string `json:"paths,omitempty"` - // Packages are, of each module directory, the mesh packages its lock file names (MeshPackagesOf; novox/hq ADR 0573 - // §2): the indexer keeps them in the module's inputs and takes each one's latest published version into its - // fingerprint. Absent for a directory that uses none, and from an older writer. - Packages map[string][]string `json:"packages,omitempty"` - Act string `json:"act,omitempty"` - Words string `json:"words,omitempty"` - Open []OpenPull `json:"open,omitempty"` - // RetiredAssignments is the assignments files a bridge before ADR 0567 carried (ADR 0549 §2, ADR 0559 §2): assignments is - // the seat mesh-module-assigner's state now and no repository holds it (ADR 0567 §11), so a message carrying them is - // refused, loudly, rather than read with them dropped. - RetiredAssignments json.RawMessage `json:"assignments,omitempty"` - RetiredRead bool `json:"assignments-read,omitempty"` - // Predefined is the catalogue's predefined.json, exact, at the merge commit of a merged message (novox/hq ADR 0565 - // §2): what the indexer keeps as its state `predefined`. PredefinedRead says the bridge read the merge and it holds - // no predefined.json. Carried on a merged message only; an older bridge sends neither, and the indexer keeps what it - // held. - Predefined json.RawMessage `json:"predefined,omitempty"` - PredefinedRead bool `json:"predefined-read,omitempty"` - // Group is the delivery group a merged message's pull request was merged in, and Members every approved member of - // that group with its approved head, this one included (novox/hq ADR 0633 §4): the forge bridge sets both from the - // seat mesh-delivery's verb groups, and the indexer gathers the group's merges until the group's end (ForgeGroupEnd). A merge - // with no group carries neither, and an older bridge sends neither; an older reader ignores both. - Group string `json:"group,omitempty"` - Members []meshdeliveryclient.Head `json:"members,omitempty"` -} - -// checkGroup refuses a group on anything but a merged message, a group without its members or members without a -// group, a member that is not a repository's pull request at a head, a member named twice, and members that leave out -// the message's own pull request. -func (f Forge) checkGroup() error { - if f.Group == "" && len(f.Members) == 0 { - return nil - } - if f.Kind != ForgeMerged { - return fmt.Errorf("delivery: only a merged message names its delivery group, not a %s message", f.Kind) - } - if f.Group == "" || len(f.Members) == 0 { - return fmt.Errorf("delivery: a merged message names its group and the group's members together, or neither") - } - self := false - seen := map[string]bool{} - for _, m := range f.Members { - if err := checkRepository(m.Repository); err != nil { - return err - } - if m.Number <= 0 || m.Head == "" { - return fmt.Errorf("delivery: the member %s of the group %q needs its pull request number and head", m.Repository, f.Group) - } - k := fmt.Sprintf("%s#%d", m.Repository, m.Number) - if seen[k] { - return fmt.Errorf("delivery: the group %q names its member %s twice", f.Group, k) - } - seen[k] = true - self = self || (trunk.SameRepository(m.Repository, f.Repository) && m.Number == f.Number) - } - if !self { - return fmt.Errorf("delivery: the members of the group %q leave out the merged pull request %s#%d", f.Group, f.Repository, f.Number) - } - return nil -} - -// checkPredefined refuses the predefined list on anything but a merged message, a list that is not one JSON object, and -// a list said both present and absent. -func (f Forge) checkPredefined() error { - if len(f.Predefined) == 0 && !f.PredefinedRead { - return nil - } - if f.Kind != ForgeMerged && f.Kind != ForgePushed { - return fmt.Errorf("delivery: only a merged or pushed message carries the predefined list, not a %s message", f.Kind) - } - if len(f.Predefined) > 0 && f.PredefinedRead { - return fmt.Errorf("delivery: a merged message carries the predefined list and says the merge holds none (predefined-read)") - } - var list map[string]json.RawMessage - if len(f.Predefined) > 0 && json.Unmarshal(f.Predefined, &list) != nil { - return fmt.Errorf("delivery: the predefined list a merged message carries is not one JSON object") - } - return nil -} - -func (f Forge) check() error { - if err := checkForgeKind(f.Kind); err != nil { - return err - } - if f.Kind == ForgeOpen { - return f.checkOpen() - } - if len(f.Open) > 0 { - return fmt.Errorf("delivery: only an open message names open pull requests") - } - if len(f.RetiredAssignments) > 0 || f.RetiredRead { - return fmt.Errorf("delivery: a forge message carries assignments files, which no repository holds since ADR 0567: " + - "assignments is the seat mesh-module-assigner's state") - } - if err := f.checkPredefined(); err != nil { - return err - } - if err := f.checkGroup(); err != nil { - return err - } - if err := checkRepository(f.Repository); err != nil { - return err - } - switch f.Kind { - case ForgePull: - if f.Number <= 0 { - return fmt.Errorf("delivery: a pull message needs its pull request number") - } - if f.Head == "" { - return fmt.Errorf("delivery: a pull message needs its head") - } - switch f.Action { - case PullOpened, PullUpdated, PullClosed: - default: - return fmt.Errorf("delivery: the pull action %q is not opened, updated or closed", f.Action) - } - if len(f.Dirs) > 0 && !f.DirsKnown { - return fmt.Errorf("delivery: a pull message with module directories must say it knows them (dirs-known)") - } - dirs := map[string]bool{} - for _, d := range f.Dirs { - dirs[d] = true - } - if err := f.checkInputs(func(d string) bool { return dirs[d] }, "its module directories"); err != nil { - return err - } - case ForgeMerged, ForgePushed: - if len(f.Dirs) > 0 || f.DirsKnown { - return fmt.Errorf("delivery: a %s message carries no module directories", f.Kind) - } - if f.Kind == ForgeMerged && f.Number <= 0 { - return fmt.Errorf("delivery: a merged message needs its pull request number") - } - if f.Kind == ForgePushed && (f.Number != 0 || f.Merge != "" || f.Base != "") { - return fmt.Errorf("delivery: a pushed message names no pull request, merge commit or base: its branch is the one pushed") - } - if f.Kind == ForgePushed && f.Branch == "" { - return fmt.Errorf("delivery: a pushed message needs its branch") - } - if f.Head == "" { - return fmt.Errorf("delivery: a %s message needs its head", f.Kind) - } - if f.Kind == ForgeMerged && f.Merge == "" { - return fmt.Errorf("delivery: a merged message needs its merge commit") - } - if f.Root == "" { - return fmt.Errorf("delivery: a %s message needs the repository's root tree", f.Kind) - } - // No trees is a merge that leaves the repository with no module.json anywhere (a documents repository, or one - // whose last module was removed): it is written all the same, so the indexer takes the merge in and drops the - // repository's modules (novox/hq issue 1126). An older writer always sent at least one tree, so none is unambiguous; - // such a message carries no manifests, locks or paths (checkInputs below: each names a directory of its trees). - for dir, tree := range f.Trees { - if tree == "" { - return fmt.Errorf("delivery: a merged message's tree of the directory %q is empty", dir) - } - } - if err := f.checkInputs(func(d string) bool { _, ok := f.Trees[d]; return ok }, "its trees"); err != nil { - return err - } - case ForgeRefused: - if len(f.Dirs) > 0 || f.DirsKnown { - return fmt.Errorf("delivery: a refused message carries no module directories") - } - if len(f.Manifests) > 0 || len(f.Locks) > 0 || len(f.Paths) > 0 { - return fmt.Errorf("delivery: a refused message carries no manifests, lock hashes or named paths") - } - if f.Act == "" { - return fmt.Errorf("delivery: a refused message needs the act it answers") - } - if f.Words == "" { - return fmt.Errorf("delivery: a refused message needs the forge's words") - } - } - return nil -} - -// checkInputs refuses a manifest or a lock hash of a directory that known does not know (of is what it knows them -// by), an empty manifest and an empty lock path or hash, naming the directory. -func (f Forge) checkInputs(known func(dir string) bool, of string) error { - for dir, m := range f.Manifests { - if !known(dir) { - return fmt.Errorf("delivery: the manifest of the directory %q is not of %s", dir, of) - } - if m == "" { - return fmt.Errorf("delivery: the manifest of the directory %q is empty", dir) - } - } - for dir, locks := range f.Locks { - if !known(dir) { - return fmt.Errorf("delivery: the lock hashes of the directory %q are not of %s", dir, of) - } - for path, hash := range locks { - if path == "" || hash == "" { - return fmt.Errorf("delivery: the lock %q of the directory %q has an empty path or hash", path, dir) - } - } - } - for dir, paths := range f.Paths { - if !known(dir) { - return fmt.Errorf("delivery: the named paths of the directory %q are not of %s", dir, of) - } - for path, object := range paths { - if path == "" || object == "" { - return fmt.Errorf("delivery: the named path %q of the directory %q has an empty path or object", path, dir) - } - } - } - return nil -} - -// checkOpen refuses an open message that names a repository, a branch, a head or anything of the other kinds, or -// an open pull request that is not `/` and a number. -func (f Forge) checkOpen() error { - if f.Repository != "" || f.Branch != "" || f.Number != 0 || f.Head != "" || f.Action != "" || len(f.Dirs) > 0 || f.DirsKnown || - f.Merge != "" || len(f.Trees) > 0 || len(f.Manifests) > 0 || len(f.Locks) > 0 || len(f.Paths) > 0 || f.Root != "" || f.Act != "" || f.Words != "" || f.Group != "" || len(f.Members) > 0 { - return fmt.Errorf("delivery: an open message carries only the open pull requests it names") - } - for _, p := range f.Open { - if err := checkRepository(p.Repository); err != nil { - return err - } - if p.Number <= 0 { - return fmt.Errorf("delivery: the open pull request of %s has no number", p.Repository) - } - } - return nil -} - -// EncodeForge is f as JSON at Version; it refuses a message missing what its kind needs. -func EncodeForge(f Forge) ([]byte, error) { - if err := f.check(); err != nil { - return nil, err - } - f.V = Version - return json.Marshal(f) -} - -// DecodeForge reads a forge message; it refuses an unknown version (ErrUnknownVersion) and what EncodeForge refuses. -func DecodeForge(data []byte) (Forge, error) { - var f Forge - if err := decode(data, &f); err != nil { - return Forge{}, err - } - if err := f.check(); err != nil { - return Forge{}, err - } - return f, nil -} - -// SameForge says whether two forge messages are the same value. -func SameForge(a, b Forge) bool { return reflect.DeepEqual(a, b) } - -var nameOK = regexp.MustCompile(`^[-/_=a-zA-Z0-9]+$`) - -// checkName refuses a name that is empty or holds a dot, a wildcard, whitespace or a character a bus key refuses -// (mesh-sdk delivery's rule for a name). +// checkName refuses a name that is empty or holds a dot, a slash, a wildcard, whitespace or a character a bus key +// refuses (mesh-sdk delivery's rule for a name). func checkName(kind, name string) error { if name == "" { return fmt.Errorf("delivery: the %s name is empty", kind) @@ -412,8 +133,8 @@ func checkName(kind, name string) error { return nil } -// decode reads a value of Version, refusing another or none with keys.ErrUnknownVersion, as mesh-sdk delivery's -// values are read. +// decode reads a value of Version, refusing another or none with keys.ErrUnknownVersion, and a field the value's type +// does not have. func decode(data []byte, into any) error { var probe struct { V *int `json:"v"` @@ -427,7 +148,9 @@ func decode(data []byte, into any) error { if *probe.V != Version { return fmt.Errorf("%w: the value is version %d, this reader reads %d", keys.ErrUnknownVersion, *probe.V, Version) } - if err := json.Unmarshal(data, into); err != nil { + dec := json.NewDecoder(bytes.NewReader(data)) + dec.DisallowUnknownFields() + if err := dec.Decode(into); err != nil { return fmt.Errorf("delivery: value does not fit its shape: %w", err) } return nil diff --git a/modules/mesh-delivery-forge-bridge/forgemsg/forge_test.go b/modules/mesh-delivery-forge-bridge/forgemsg/forge_test.go index c31695e5..1a4c6548 100644 --- a/modules/mesh-delivery-forge-bridge/forgemsg/forge_test.go +++ b/modules/mesh-delivery-forge-bridge/forgemsg/forge_test.go @@ -1,206 +1,81 @@ package forgemsg import ( - "encoding/json" "errors" "strings" "testing" "time" - "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient" "git.novox.be/novox/mesh-sdk/go/keys" ) -const oddManifest = "{\n\t\"module\": \"a\",\n \"z\": 1, \"a\": [ \"x\",\"y\" ],\n \"why\": \"é — & \\n\"\n}\n\n" - -func sampleForges() []Forge { - return []Forge{ - {Kind: ForgePull, Repository: "novox/mesh-sdk", Branch: "feat/x", Number: 36, Head: "aaaa", Action: "opened"}, - {Kind: ForgeMerged, Repository: "novox/mesh-sdk", Number: 36, Head: "aaaa", Merge: "cccc", - Trees: map[string]string{"modules/a": "t1"}, Root: "t0"}, - {Kind: ForgeRefused, Repository: "novox/mesh-sdk", Act: "novox/mesh-sdk.36.aaaa.view", Words: "403 forbidden"}, - {Kind: ForgeOpen, Open: []OpenPull{{Repository: "novox/mesh-sdk", Number: 36}, {Repository: "novox/mesh-control", Number: 7}}}, - // 1585/T1: a group member's merged message names its group and every approved member (ADR 0633 §4). - {Kind: ForgeMerged, Repository: "novox/mesh-sdk", Number: 37, Head: "dddd", Merge: "eeee", Root: "t0", - Group: "feat/take-in", Members: []meshdeliveryclient.Head{{Repository: "novox/mesh-sdk", Number: 37, Head: "dddd"}, {Repository: "novox/mesh-delivery", Number: 9, Head: "ffff"}}}, - // design 47 G §509, §714, A-236: a merged message names the watched branch it landed on; a pushed one its branch, new - // head and head before. - {Kind: ForgeMerged, Repository: "novox/mesh-sdk", Number: 38, Branch: "feat/y", Head: "aaaa", Merge: "bbbb", Base: "beta", Root: "t0"}, - {Kind: ForgePushed, Repository: "novox/mesh-sdk", Branch: "beta", Head: "cccc", Before: "bbbb", Root: "t0", Trees: map[string]string{"modules/a": "t1"}}, - } -} - -func mergedWithInputs() Forge { - return Forge{Kind: ForgeMerged, Repository: "novox/mesh-sdk", Number: 36, Head: "aaaa", Merge: "cccc", Root: "t0", - Trees: map[string]string{"a": "t1", "b": "t2"}, - Manifests: map[string]string{"a": oddManifest}, - Locks: map[string]map[string]string{"a": {"go.sum": strings.Repeat("ab", 32)}}} -} - -// TestForge holds the forge bridge's contract, moved whole from mesh-sdk go/delivery with its tests (1200/AC1, AC3, -// AC4; 1279/AC5; 1442/AC1-AC4; 1585/T1). +// design 47 H §739, H-A-27: the bridge's one message, head-moved, on forge....head-moved, +// with repository, branch, head, before and start; a message naming trees, a base or another field is refused. func TestForge(t *testing.T) { t.Run("events", func(t *testing.T) { - ev, err := ForgeEvent("novox/mesh-sdk", ForgeMerged) - if err != nil || ev != "forge.novox.mesh-sdk.merged" { - t.Fatalf("forge event = %q, %v", ev, err) + ev, err := HeadMovedEvent("novox/mesh-sdk", "release.1") + if err != nil || ev != "forge.novox.mesh-sdk.release=2e1.head-moved" { + t.Fatalf("event %q, %v", ev, err) } - if repo, kind, err := ParseForgeEvent(ev); err != nil || repo != "novox/mesh-sdk" || kind != ForgeMerged { - t.Fatalf("parse forge event = %q %q %v", repo, kind, err) + if repo, branch, err := ParseHeadMovedEvent(ev); err != nil || repo != "novox/mesh-sdk" || branch != "release.1" { + t.Fatalf("parse %q: %s %s %v", ev, repo, branch, err) } - for _, bad := range []struct{ repo, kind string }{ - {"", "pull"}, {"novox", "pull"}, {"a/b/c", "pull"}, {"/b", "pull"}, {"a/", "pull"}, - {"a.b/c", "pull"}, {"a/b c", "pull"}, {"a/b", "closed"}, {"a/b", ""}, {"a/b", ForgeOpen}, - } { - if _, err := ForgeEvent(bad.repo, bad.kind); err == nil { - t.Errorf("forge event %q %q accepted", bad.repo, bad.kind) + if all := HeadMovedEvents(); all != "forge.*.*.*.head-moved" { + t.Fatalf("every head-moved is %q", all) + } + for _, bad := range []string{"forge.novox.mesh-sdk.merged", "forge.novox.mesh-sdk.main.merged", "forge.open", + "forge.novox.mesh-sdk.ma=zz.head-moved", "owed.ended", "forge.novox.mesh-sdk.main.x.head-moved"} { + if _, _, err := ParseHeadMovedEvent(bad); err == nil { + t.Errorf("%q parsed", bad) } } - for _, bad := range []string{"", "forge.a.b", "forge.a.b.closed", "x.a.b.pull", "forge.a.b.pull.x", "forge..b.pull", ForgeGroupEndEvent} { - if _, _, err := ParseForgeEvent(bad); err == nil { - t.Errorf("parse forge event %q accepted", bad) + for _, repo := range []string{"mesh-sdk", "a/b/c", "a./b"} { + if _, err := HeadMovedEvent(repo, "main"); err == nil { + t.Errorf("repository %q named", repo) } } - if repo, kind, err := ParseForgeEvent(OpenEvent()); OpenEvent() != "forge.open" || err != nil || repo != "" || kind != ForgeOpen { - t.Errorf("open event %q = %q %q %v", OpenEvent(), repo, kind, err) - } }) t.Run("round trip", func(t *testing.T) { - fs := append(sampleForges(), mergedWithInputs()) - for _, f := range fs { - data, err := EncodeForge(f) - if err != nil { - t.Fatalf("%s: %v", f.Kind, err) - } - var probe map[string]any - if err := json.Unmarshal(data, &probe); err != nil || probe["v"] != float64(1) { - t.Fatalf("%s: json %s does not carry v:1", f.Kind, data) - } - f.V = Version - if got, err := DecodeForge(data); err != nil || !SameForge(got, f) { - t.Errorf("forge %s round trip: %+v %v", f.Kind, got, err) - } - } - // An empty list is an open message too: nothing is open. - if data, err := EncodeForge(Forge{Kind: ForgeOpen, Open: []OpenPull{}}); err != nil { - t.Errorf("empty open: %v", err) - } else if f, err := DecodeForge(data); err != nil || f.Kind != ForgeOpen || len(f.Open) != 0 { - t.Errorf("empty open round trip: %+v %v", f, err) - } - ge := ForgeGroupEnd{Group: "feat/take-in", Members: []GroupMerge{{Repository: "novox/mesh-sdk", Number: 37, Merge: "eeee"}}} - data, err := EncodeForgeGroupEnd(ge) - ge.V = Version - if got, err2 := DecodeForgeGroupEnd(data); err != nil || err2 != nil || !SameForgeGroupEnd(got, ge) { - t.Errorf("group end round trip: %+v %v %v", got, err, err2) - } - // An older bridge's message reads, and is written back byte for byte. - old := `{"v":1,"kind":"merged","repository":"novox/mesh-sdk","number":36,"head":"aaaa","merge":"cccc","trees":{"a":"t1"},"root":"t0"}` - if f, err := DecodeForge([]byte(old)); err != nil || f.Manifests != nil { - t.Fatalf("%+v, %v", f, err) - } else if data, err := EncodeForge(f); err != nil || string(data) != old { - t.Errorf("%s, %v, want exactly %s", data, err, old) - } - // A merge leaving the repository with no module.json is a message too (issue 1126). - f := sampleForges()[1] - f.Trees = nil - if data, err := EncodeForge(f); err != nil { - t.Errorf("a merged message with no trees is refused: %v", err) - } else if got, err := DecodeForge(data); err != nil || len(got.Trees) != 0 { - t.Errorf("a merged message with no trees comes back as %+v, %v", got, err) - } - for name, dec := range map[string]func([]byte) error{ - "forge": func(b []byte) error { _, err := DecodeForge(b); return err }, - "group end": func(b []byte) error { _, err := DecodeForgeGroupEnd(b); return err }, + for _, h := range []HeadMoved{ + {Repository: "novox/mesh-sdk", Branch: "main", Head: "cccc", Before: "bbbb"}, + {Repository: "novox/mesh-sdk", Branch: "feat/x", Head: "aaaa", Start: true}, // the first time: no head held } { - for _, in := range []string{`{"group":"g"}`, `{"v":2,"group":"g"}`} { - if err := dec([]byte(in)); !errors.Is(err, keys.ErrUnknownVersion) { - t.Errorf("%s decode of %s = %v, want keys.ErrUnknownVersion", name, in, err) - } + raw, err := EncodeHeadMoved(h) + if err != nil { + t.Fatal(err) + } + back, err := DecodeHeadMoved(raw) + h.V = Version + if err != nil || back != h { + t.Fatalf("read back %+v, %v; want %+v", back, err, h) } } }) t.Run("refused", func(t *testing.T) { - at := func(i int, mut func(*Forge)) Forge { f := sampleForges()[i]; mut(&f); return f } - in := func(mut func(*Forge)) Forge { f := mergedWithInputs(); mut(&f); return f } - pullIn := func(mut func(*Forge)) Forge { - f := Forge{Kind: ForgePull, Repository: "novox/mesh-sdk", Number: 1, Head: "h", Action: PullOpened, - Dirs: []string{"a"}, DirsKnown: true, Manifests: map[string]string{"a": oddManifest}, - Locks: map[string]map[string]string{"a": {"go.sum": strings.Repeat("0", 64)}}} - mut(&f) - return f - } - for _, c := range []struct { - name, want string - f Forge - }{ - {"merged without merge commit", "merge", at(1, func(f *Forge) { f.Merge = "" })}, - {"merged without root", "root", at(1, func(f *Forge) { f.Root = "" })}, - {"merged with a manifest and no trees", "modules/a", at(1, func(f *Forge) { f.Trees = nil; f.Manifests = map[string]string{"modules/a": "{}"} })}, - {"merged with an empty tree", "modules/a", at(1, func(f *Forge) { f.Trees = map[string]string{"modules/a": ""} })}, - {"pull with an unknown action", "reopened", at(0, func(f *Forge) { f.Action = "reopened" })}, - {"pull without head", "head", at(0, func(f *Forge) { f.Head = "" })}, - {"refused without words", "words", at(2, func(f *Forge) { f.Words = "" })}, - {"refused without act", "act", at(2, func(f *Forge) { f.Act = "" })}, - {"unknown kind", "closed", Forge{Kind: "closed", Repository: "a/b"}}, - {"bad repository", "nope", Forge{Kind: ForgePull, Repository: "nope", Number: 1, Head: "h", Action: "opened"}}, - {"open with a repository", "only the open", Forge{Kind: ForgeOpen, Repository: "a/b", Open: []OpenPull{{Repository: "a/b", Number: 1}}}}, - {"open with a bad entry", "", Forge{Kind: ForgeOpen, Open: []OpenPull{{Repository: "a", Number: 1}}}}, - {"open with a zero number", "no number", Forge{Kind: ForgeOpen, Open: []OpenPull{{Repository: "a/b"}}}}, - {"pull naming open pull requests", "only an open message", Forge{Kind: ForgePull, Repository: "a/b", Number: 1, Head: "h", Action: "updated", Open: []OpenPull{{Repository: "a/b", Number: 1}}}}, - {"manifest outside trees", `"zz"`, in(func(f *Forge) { f.Manifests["zz"] = "{}" })}, - {"locks outside trees", `"yy"`, in(func(f *Forge) { f.Locks["yy"] = map[string]string{"go.sum": "h"} })}, - {"empty manifest", `"b"`, in(func(f *Forge) { f.Manifests["b"] = "" })}, - {"empty lock hash", `"a"`, in(func(f *Forge) { f.Locks["a"]["go.sum"] = "" })}, - {"named paths outside trees", `"other"`, in(func(f *Forge) { f.Paths = map[string]map[string]string{"other": {"src": "o"}} })}, - {"a named path with no object", `"src"`, in(func(f *Forge) { f.Paths = map[string]map[string]string{"a": {"src": ""}} })}, - {"assignments files", "mesh-module-assigner", in(func(f *Forge) { f.RetiredAssignments = []byte(`{"anchor":"{}"}`) })}, - {"assignments read", "mesh-module-assigner", in(func(f *Forge) { f.RetiredRead = true })}, - {"predefined not an object", "one JSON object", in(func(f *Forge) { f.Predefined = []byte(`["domain"]`) })}, - {"predefined both", "says the merge holds none", in(func(f *Forge) { f.Predefined = []byte(`{}`); f.PredefinedRead = true })}, - {"pull with the predefined list", "only a merged or pushed message", Forge{Kind: ForgePull, Repository: "novox/mesh-sdk", Number: 1, Head: "h", Action: PullOpened, PredefinedRead: true}}, - {"pull manifest outside dirs", `"b"`, pullIn(func(f *Forge) { f.Manifests["b"] = "{}" })}, - {"pull locks outside dirs", `"c"`, pullIn(func(f *Forge) { f.Locks["c"] = map[string]string{"go.sum": "h"} })}, - {"refused with manifests", "no manifests", Forge{Kind: ForgeRefused, Repository: "a/b", Act: "x", Words: "no", Manifests: map[string]string{"a": "{}"}}}, - {"open with locks", "only the open", Forge{Kind: ForgeOpen, Locks: map[string]map[string]string{"a": {"go.sum": "h"}}}}, - // 1585/T1: a group only on a merged message, with its members, the message's own pull request among them. - {"pull with a group", "only a merged message names its delivery group", at(0, func(f *Forge) { - f.Group, f.Members = "g", []meshdeliveryclient.Head{{Repository: "novox/mesh-sdk", Number: 36, Head: "aaaa"}} - })}, - {"merged with a group and no members", "together", at(4, func(f *Forge) { f.Members = nil })}, - {"merged with members and no group", "together", at(4, func(f *Forge) { f.Group = "" })}, - {"merged with members leaving itself out", "leave out", at(4, func(f *Forge) { f.Members = f.Members[1:] })}, - {"merged with a member twice", "twice", at(4, func(f *Forge) { f.Members = append(f.Members, f.Members[0]) })}, - {"open with a group", "only the open pull requests", Forge{Kind: ForgeOpen, Group: "g"}}, - // design 47 G §509, A-236: a pushed message names its branch and no pull request, merge commit or base. - {"pushed with a pull request", "names no pull request", Forge{Kind: ForgePushed, Repository: "a/b", Branch: "beta", Head: "h", Root: "r", Number: 3}}, - {"pushed with no branch", "needs its branch", Forge{Kind: ForgePushed, Repository: "a/b", Head: "h", Root: "r"}}, + for name, h := range map[string]HeadMoved{ + "no repository": {Branch: "main", Head: "a"}, + "no branch": {Repository: "novox/x", Head: "a"}, + "no head": {Repository: "novox/x", Branch: "main"}, + "head not moved": {Repository: "novox/x", Branch: "main", Head: "a", Before: "a"}, + "repository form": {Repository: "x", Branch: "main", Head: "a"}, } { - if _, err := EncodeForge(c.f); err == nil || !strings.Contains(err.Error(), c.want) { - t.Errorf("%s: %v, want a refusal naming %q", c.name, err, c.want) + if _, err := EncodeHeadMoved(h); err == nil { + t.Errorf("%s: written", name) } } - // A member's repository in another case still names the merged pull request (10c91fba). - f := sampleForges()[4] - f.Members[0].Repository = "Novox/Mesh-SDK" - if _, err := EncodeForge(f); err != nil { - t.Errorf("a member in another case: %v", err) - } - for _, c := range []struct { - name, want string - e ForgeGroupEnd - }{ - {"group end without members", "no member", ForgeGroupEnd{Group: "g"}}, - {"group end without a group", "names its group", ForgeGroupEnd{Members: []GroupMerge{{Repository: "a/b", Number: 1, Merge: "m"}}}}, - {"group end with a member without its merge", "merge commit", ForgeGroupEnd{Group: "g", Members: []GroupMerge{{Repository: "a/b", Number: 1}}}}, - {"group end with a member twice", "twice", ForgeGroupEnd{Group: "g", Members: []GroupMerge{{Repository: "a/b", Number: 1, Merge: "m"}, {Repository: "a/b", Number: 1, Merge: "m"}}}}, + for name, raw := range map[string]string{ + "trees": `{"v":1,"repository":"novox/x","branch":"main","head":"a","trees":{"m":"t"}}`, + "base": `{"v":1,"repository":"novox/x","branch":"main","head":"a","base":"main"}`, + "merged": `{"v":1,"kind":"merged","repository":"novox/x","number":3,"head":"a","merge":"b"}`, + "no version": `{"repository":"novox/x","branch":"main","head":"a"}`, } { - if _, err := EncodeForgeGroupEnd(c.e); err == nil || !strings.Contains(err.Error(), c.want) { - t.Errorf("%s: %v, want a refusal naming %q", c.name, err, c.want) + if _, err := DecodeHeadMoved([]byte(raw)); err == nil { + t.Errorf("%s: read", name) + } else if name == "no version" && !errors.Is(err, keys.ErrUnknownVersion) { + t.Errorf("no version: %v", err) } } }) - // Design 47 G §164: an owed act's outcome names its seat, its id, one outcome and words for every outcome but - // performed; an act the bridge cannot decode may name no id. t.Run("owed ended", func(t *testing.T) { at := time.Date(2026, 11, 9, 20, 0, 0, 0, time.UTC) ok := OwedEnded{Of: "mesh-delivery", ID: "g1.view.1", Outcome: OwedPerformed, At: at} diff --git a/modules/mesh-delivery-forge-bridge/forgemsg/go.mod b/modules/mesh-delivery-forge-bridge/forgemsg/go.mod index ddbc1c3e..58077783 100644 --- a/modules/mesh-delivery-forge-bridge/forgemsg/go.mod +++ b/modules/mesh-delivery-forge-bridge/forgemsg/go.mod @@ -3,10 +3,3 @@ module git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forge go 1.26.0 require git.novox.be/novox/mesh-sdk/go v0.0.0-00010101000000-000000000000 - -require ( - git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient v0.0.0-00010101000000-000000000000 - git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk v0.0.0-00010101000000-000000000000 -) - -require git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdelivery v0.0.0-00010101000000-000000000000 // indirect diff --git a/modules/mesh-delivery-forge-bridge/forgemsg/group.go b/modules/mesh-delivery-forge-bridge/forgemsg/group.go deleted file mode 100644 index 527c3b7f..00000000 --- a/modules/mesh-delivery-forge-bridge/forgemsg/group.go +++ /dev/null @@ -1,80 +0,0 @@ -package forgemsg - -import ( - "encoding/json" - "fmt" - "reflect" -) - -// ForgeGroupEndEvent is the name of a delivery group's end on the forge bridge's stream (novox/hq ADR 0633 §4): the -// bridge publishes it once every approved member of the group is merged, after the last member's merged message. It -// has three parts, so no repository's forge event (`forge...`) is ever this name. -const ForgeGroupEndEvent = "forge.group.merged" - -// GroupMerge is one merged member of a delivery group: the repository as `/`, its pull request and the -// merge commit the forge made of it. -type GroupMerge struct { - Repository string `json:"repository"` - Number int `json:"number"` - Merge string `json:"merge"` -} - -// ForgeGroupEnd is the body of ForgeGroupEndEvent: the group and every member merged in it on its base, with its merge commit. -// The indexer takes the members it holds in as one source revision once it hears it (ADR 0633 §4). -type ForgeGroupEnd struct { - V int `json:"v"` - Group string `json:"group"` - // Base is the watched branch the members merged into: a group's end is said once per base (design 47 G §715). - Base string `json:"base,omitempty"` - Members []GroupMerge `json:"members"` -} - -func (e ForgeGroupEnd) check() error { - if e.Group == "" { - return fmt.Errorf("delivery: a group's end names its group") - } - if len(e.Members) == 0 { - return fmt.Errorf("delivery: the end of the group %q names no member merged in it", e.Group) - } - seen := map[string]bool{} - for _, m := range e.Members { - if err := checkRepository(m.Repository); err != nil { - return err - } - if m.Number <= 0 || m.Merge == "" { - return fmt.Errorf("delivery: the member %s of the group %q's end needs its pull request number and merge commit", m.Repository, e.Group) - } - k := fmt.Sprintf("%s#%d", m.Repository, m.Number) - if seen[k] { - return fmt.Errorf("delivery: the end of the group %q names its member %s twice", e.Group, k) - } - seen[k] = true - } - return nil -} - -// EncodeForgeGroupEnd is e as JSON at Version; it refuses an end with no group or no member, and a member without its -// pull request or merge commit. -func EncodeForgeGroupEnd(e ForgeGroupEnd) ([]byte, error) { - if err := e.check(); err != nil { - return nil, err - } - e.V = Version - return json.Marshal(e) -} - -// DecodeForgeGroupEnd reads a group's end; it refuses an unknown version (ErrUnknownVersion) and what -// EncodeForgeGroupEnd refuses. -func DecodeForgeGroupEnd(data []byte) (ForgeGroupEnd, error) { - var e ForgeGroupEnd - if err := decode(data, &e); err != nil { - return ForgeGroupEnd{}, err - } - if err := e.check(); err != nil { - return ForgeGroupEnd{}, err - } - return e, nil -} - -// SameForgeGroupEnd says whether two group ends are the same value. -func SameForgeGroupEnd(a, b ForgeGroupEnd) bool { return reflect.DeepEqual(a, b) }