Design 47 H1: the gate (merge-pull is the start), gitea, build modules, bus tools; retired parts removed #709
@@ -243,33 +243,3 @@ func TestAMissedEventIsPutRightAtStart(t *testing.T) {
|
||||
t.Fatal("a forge that cannot be read is said")
|
||||
}
|
||||
}
|
||||
|
||||
// A-281: the switch runs once; a start, then a pull-updated, then a second start opens no record.
|
||||
func TestTheSwitchRunsOnceSoDeliveriesNeverBecomeRecordsAtAStart(t *testing.T) {
|
||||
h, k := gateWithDeliveries(t)
|
||||
h.Old = kvKeptOld{k}
|
||||
if _, _, err := h.Switch(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := h.PullUpdated(updated("novox/app", 3, strings.Repeat("a", 40), "main", "feat")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
opened, found, err := h.Switch()
|
||||
if err != nil || opened != 0 || found != 0 {
|
||||
t.Fatalf("the second start switched: %d %d %v", opened, found, err)
|
||||
}
|
||||
if kept, _ := h.Records.Kept(); len(kept) != 0 {
|
||||
t.Fatalf("a delivery became a record: %+v", kept)
|
||||
}
|
||||
if done, err := h.Records.SwitchDone(); err != nil || !done {
|
||||
t.Fatalf("switch.done %v %v", done, err)
|
||||
}
|
||||
}
|
||||
|
||||
type kvKeptOld struct{ k *memKept }
|
||||
|
||||
func (o kvKeptOld) Keys(state string) ([]string, error) { return o.k.Keys(state) }
|
||||
func (o kvKeptOld) Get(state, key string) ([]byte, uint64, error) {
|
||||
v, err := o.k.Get(state, key)
|
||||
return v, 1, err
|
||||
}
|
||||
|
||||
@@ -2,28 +2,22 @@ package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strconv"
|
||||
|
||||
"git.novox.be/novox/mesh-contracts/health-and-repair/go/seats/meshconditions"
|
||||
gitseat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git"
|
||||
stdio "git.novox.be/novox/mesh-sdk/go"
|
||||
"git.novox.be/novox/mesh-sdk/go/keys"
|
||||
"git.novox.be/novox/mesh-sdk/go/views"
|
||||
)
|
||||
|
||||
// The gate's own findings (design 47 G A-39, A-29, A-37, A-30, §592): they go through one held writer over the gate's own state
|
||||
// `findings`, whose three events the manifest declares. The first is `approval-carried-open`: for each `approval-carried` the
|
||||
// gate says, a carried Approve nobody uses is seen, and cleared when the seat `git` says that pull request merged or closed.
|
||||
// `findings`, whose three events the manifest declares.
|
||||
|
||||
// Module is the gate's module name, the observer of its findings.
|
||||
const Module = "mesh-delivery-gate"
|
||||
|
||||
// The scope and the kind of the finding a carried approval nobody uses is (design 47 §592, A-42: the scope the mesh already uses for the delivery's findings).
|
||||
const (
|
||||
FindingScope = "delivery"
|
||||
ApprovalCarriedOpen = "approval-carried-open"
|
||||
FindingScope = "delivery"
|
||||
)
|
||||
|
||||
// pullMergedEvent and pullClosedEvent are the seat git's events that end a pull request, as the gate's manifest consumes them.
|
||||
@@ -44,55 +38,5 @@ 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, SourceUncompared}})
|
||||
}
|
||||
|
||||
// approvalID is the id of a pull request's finding: its repository and number, each escaped as a key's name is.
|
||||
func approvalID(repository string, number int64) string {
|
||||
return keys.EscapeName(repository) + "." + keys.EscapeName(strconv.FormatInt(number, 10))
|
||||
}
|
||||
|
||||
// approvalOpen writes the finding for an `approval-carried` the gate says, naming the head the Approve named, unless it holds it.
|
||||
func (h *Holder) approvalOpen(repository string, number int, head string) error {
|
||||
if h.Findings == nil {
|
||||
return nil
|
||||
}
|
||||
id := approvalID(repository, int64(number))
|
||||
for _, f := range h.Findings.Held() {
|
||||
if f.Scope == FindingScope && f.ID == id && f.Kind == ApprovalCarriedOpen {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
at := h.Now().UTC()
|
||||
pull := fmt.Sprintf("%s#%d", repository, number)
|
||||
return h.Findings.Write(context.Background(), meshconditions.Finding{Scope: FindingScope, ID: id, Kind: ApprovalCarriedOpen,
|
||||
Subject: meshconditions.Subject{Scope: FindingScope, ID: id},
|
||||
Severity: meshconditions.FindingSeverityWarning, Resolver: "operator",
|
||||
Summary: fmt.Sprintf("the Approve of %s at %s, given before G, is carried and no merge or close of that pull request followed", pull, shortOf(head, 12)),
|
||||
Headline: "An Approve carried over waits for its pull request",
|
||||
Explanation: "The operator's Approve of this pull request, given before the delivery's switch, counts as its approval step. Nobody has merged or closed the pull request since.",
|
||||
Needs: "merge the pull request through the seat git's merge-pull, or close it; the finding clears when the seat git says either.",
|
||||
Source: "approval-carried", Observer: Module, At: at, Since: at})
|
||||
}
|
||||
|
||||
// pullEnded clears the finding of a pull request the seat git said merged or closed; a pull request with none changes nothing.
|
||||
func (h *Holder) pullEnded(body []byte, why string) error {
|
||||
if h.Findings == nil {
|
||||
return nil
|
||||
}
|
||||
var p struct {
|
||||
Repository string `json:"repository"`
|
||||
Number int64 `json:"number"`
|
||||
}
|
||||
if err := json.Unmarshal(body, &p); err != nil || p.Repository == "" || p.Number <= 0 {
|
||||
h.Refuse(fmt.Errorf("a %s of the seat git is not readable: %v", why, err))
|
||||
return nil
|
||||
}
|
||||
id := approvalID(p.Repository, p.Number)
|
||||
for _, f := range h.Findings.Held() {
|
||||
if f.Scope == FindingScope && f.ID == id && f.Kind == ApprovalCarriedOpen {
|
||||
return h.Findings.Clear(context.Background(), FindingScope, id, ApprovalCarriedOpen, "the pull request was "+why)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
Asked: meshconditions.SubjectFindingsAsked, Module: Module, State: stdio.State("findings"), Kinds: []string{SourceUncompared}})
|
||||
}
|
||||
|
||||
@@ -1,123 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.novox.be/novox/mesh-contracts/health-and-repair/go/seats/meshconditions"
|
||||
mdc "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient"
|
||||
stdio "git.novox.be/novox/mesh-sdk/go"
|
||||
"git.novox.be/novox/mesh-sdk/go/views"
|
||||
)
|
||||
|
||||
// memState is the gate's state `findings` in memory.
|
||||
type memState struct {
|
||||
mu sync.Mutex
|
||||
m map[string][]byte
|
||||
}
|
||||
|
||||
func (s *memState) Get(key string) (*stdio.StateEntry, error) {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
if v, ok := s.m[key]; ok {
|
||||
return &stdio.StateEntry{Key: key, Value: v}, nil
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
func (s *memState) Put(key string, value any) (uint64, error) {
|
||||
raw, _ := json.Marshal(value)
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
s.m[key] = raw
|
||||
return 1, nil
|
||||
}
|
||||
func (s *memState) Delete(key string) error { s.mu.Lock(); delete(s.m, key); s.mu.Unlock(); return nil }
|
||||
func (s *memState) Keys() (k []string, _ error) {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
for key := range s.m {
|
||||
k = append(k, key)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
type oldFake map[string][]byte
|
||||
|
||||
func (o oldFake) Keys(string) (k []string, _ error) {
|
||||
for key := range o {
|
||||
k = append(k, key)
|
||||
}
|
||||
return
|
||||
}
|
||||
func (o oldFake) Get(_, key string) ([]byte, uint64, error) { return o[key], 1, nil }
|
||||
|
||||
// The gate's own finding (A-39, A-29, A-37, §592): written through the held writer for each approval carried, once, and cleared
|
||||
// when the seat git says that pull request merged or closed; the writer's events are the manifest's.
|
||||
func TestTheGatesApprovalCarriedOpenIsWrittenThroughItsHeldWriterAndClearedByTheSeatGit(t *testing.T) {
|
||||
at := time.Date(2026, 11, 11, 21, 0, 0, 0, time.UTC)
|
||||
head := strings.Repeat("1", 40)
|
||||
state := &memState{m: map[string][]byte{}}
|
||||
var mu sync.Mutex
|
||||
var said []string
|
||||
w, err := views.NewHeldWriter(views.WriterConfig[meshconditions.Finding, meshconditions.FindingCleared, meshconditions.FindingsStated, meshconditions.FindingsAskedEvent]{
|
||||
Asked: meshconditions.SubjectFindingsAsked, Module: Module, State: state, Kinds: []string{ApprovalCarriedOpen}, Node: "ace",
|
||||
Now: func() time.Time { return at },
|
||||
Publish: func(_ context.Context, subject string, _ []byte, _ string) error {
|
||||
mu.Lock()
|
||||
said = append(said, subject)
|
||||
mu.Unlock()
|
||||
return nil
|
||||
},
|
||||
Listen: func(context.Context, string, func([]byte)) (func(), error) { return func() {}, nil }})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := w.Start(context.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
merge, merr := mdc.EncodeMerge(Merge{V: 1, Group: "feat/x", Ask: "merge.feat_x.0123456789ab", Approved: map[string]string{"novox/app@7": head, "novox/web@8": head, "novox/db@9": head},
|
||||
Pulls: []MergePull{{Head: mdc.Head{Repository: "novox/db", Number: 9, Head: head}, State: mdc.MergeMerged, Commit: "c0ffee"}}}.stored())
|
||||
h := &Holder{Logf: t.Logf, Now: func() time.Time { return at }, Old: oldFake{"feat_x": merge}, Findings: w, SaySeat: func(string, any, string) error { return nil }}
|
||||
if merr != nil {
|
||||
t.Fatal(merr)
|
||||
}
|
||||
if err := h.carryApprovals(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
held := w.Held()
|
||||
if len(held) != 2 {
|
||||
t.Fatalf("held %+v", held)
|
||||
}
|
||||
for _, f := range held {
|
||||
if f.Kind != ApprovalCarriedOpen || f.Scope != "delivery" || f.Observer != Module || !strings.Contains(f.Summary, head[:12]) {
|
||||
t.Fatalf("finding %+v", f)
|
||||
}
|
||||
}
|
||||
if id := approvalID("novox/app", 7); held[0].ID != id && held[1].ID != id {
|
||||
t.Fatalf("no finding with id %s: %+v", id, held)
|
||||
}
|
||||
n := len(said)
|
||||
if err := h.carryApprovals(); err != nil || len(said) != n {
|
||||
t.Fatalf("said again: %v, %d events (was %d)", err, len(said), n)
|
||||
}
|
||||
// the seat git says one merged and the other closed; one it does not know changes nothing
|
||||
if err := h.pullEnded([]byte(`{"repository":"novox/app","number":7}`), "merged"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := h.pullEnded([]byte(`{"repository":"novox/other","number":1}`), "merged"); err != nil || len(w.Held()) != 1 {
|
||||
t.Fatalf("held %+v: %v", w.Held(), err)
|
||||
}
|
||||
if err := h.pullEnded([]byte(`{"repository":"novox/web","number":8}`), "closed"); err != nil || len(w.Held()) != 0 {
|
||||
t.Fatalf("held %+v: %v", w.Held(), err)
|
||||
}
|
||||
got := strings.Join(said, " ")
|
||||
for _, ev := range []string{"finding-written", "finding-cleared"} {
|
||||
if !strings.Contains(got, ev) {
|
||||
t.Fatalf("no %s said: %v", ev, said)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -20,8 +20,6 @@ type Holder struct {
|
||||
Settings func() Settings
|
||||
Now func() time.Time
|
||||
Logf func(format string, a ...any)
|
||||
// Merges and Old are the old sections the switch reads (switch.go); Source is the gate's source (merges.go).
|
||||
Merges MergeStore
|
||||
// Kept is the gate's states deliveries and groups, and Forge the seat git's reads (deliveries.go, §716).
|
||||
Kept DeliveryStore
|
||||
Forge ForgeReads
|
||||
@@ -29,7 +27,6 @@ type Holder struct {
|
||||
Catalog Registered
|
||||
startMu sync.Mutex
|
||||
dmu sync.Mutex
|
||||
Old OldState
|
||||
Source SourceStore
|
||||
// Owed says what the gate owes the forge as the seat's event owed (owed.go).
|
||||
Owed OwedSayer
|
||||
|
||||
@@ -6,7 +6,7 @@ import "git.novox.be/novox/mesh-sdk/go/announce"
|
||||
// issue 1790): the module says it itself, from its code, before it serves, and a reader is granted what it said
|
||||
// (clause 3). A state is readable when another module's manifest reads it (keeps_test.go names the readers). keeps_test.go holds the list to the
|
||||
// manifest's `state`, and keeps_integration_test.go that the module announces it on a bus.
|
||||
var Kept = []announce.State{{Name: "conditions"}, {Name: "deliveries"}, {Name: "findings"}, {Name: "groups"}, {Name: "merges", Readable: true}, {Name: "owed", Readable: true}, {Name: "source", Readable: true}}
|
||||
var Kept = []announce.State{{Name: "conditions"}, {Name: "deliveries"}, {Name: "findings"}, {Name: "groups"}, {Name: "source", Readable: true}}
|
||||
|
||||
// announceKept says Kept through keeps, which is stdio.Keeps.
|
||||
func announceKept(keeps func(...announce.State) error) error { return keeps(Kept...) }
|
||||
|
||||
@@ -13,14 +13,7 @@ import (
|
||||
// announced the state readable), kept here and not read from other repositories' manifests (clause 1). Each line names
|
||||
// the modules of mesh-delivery whose manifest reads the state, as of R4e.
|
||||
var readers = map[string][]string{
|
||||
"asks": {"mesh-delivery-teller", "mesh-delivery-view"},
|
||||
"merges": {"mesh-delivery-forge-bridge"},
|
||||
"pulls": {"build-agent"}, // in mesh-controller
|
||||
"owed": {"mesh-delivery-forge-bridge"},
|
||||
"source": {"mesh-delivery-indexer", "mesh-delivery-checker"},
|
||||
// ADR 0548 §3, §4: the checker reads the merge turns and claims no check of a repository one names; the gate alone writes
|
||||
// them (a state is written by its owner's account alone, ADR 0495 §3: announcing it readable grants a read, never a write).
|
||||
"turns": {"mesh-delivery-checker"},
|
||||
}
|
||||
|
||||
// 1790/S: the states the module announces are the states its manifest declares, no more, no fewer, and the readable
|
||||
@@ -75,8 +68,9 @@ func TestTheStatesTheModuleAnnouncesAreTheStatesItsManifestDeclares(t *testing.T
|
||||
}
|
||||
}
|
||||
|
||||
// Design 47 G §613 (A-20): deliveries, groups, owed and conditions are `requires` entries of the template `state` under
|
||||
// their local names, taking the buckets they already had; merges and source stay in the old `state` section.
|
||||
// Design 47 G §613 (A-20): deliveries, groups and conditions are `requires` entries of the template `state` under
|
||||
// their local names, taking the buckets they already had; source stays in the old `state` section, and merges and the old
|
||||
// owed go (design 47 H §764).
|
||||
func TestTheFourStatesMoveToTheTemplateAndTwoStayOld(t *testing.T) {
|
||||
raw, err := os.ReadFile(filepath.Join("..", "..", "module.json"))
|
||||
if err != nil {
|
||||
@@ -97,12 +91,12 @@ func TestTheFourStatesMoveToTheTemplateAndTwoStayOld(t *testing.T) {
|
||||
}
|
||||
old := string(raw[strings.Index(string(raw), `"state": [`):])
|
||||
old = old[:strings.Index(old, "]")]
|
||||
for _, n := range []string{"deliveries", "groups", "owed", "conditions"} {
|
||||
for _, n := range []string{"deliveries", "groups", "conditions"} {
|
||||
if !moved[n] || strings.Contains(old, `"`+n+`"`) {
|
||||
t.Errorf("%s: template state %v, old section lists it %v", n, moved[n], strings.Contains(old, `"`+n+`"`))
|
||||
}
|
||||
}
|
||||
for _, n := range []string{"merges", "source"} {
|
||||
for _, n := range []string{"source"} {
|
||||
if moved[n] || !strings.Contains(old, `"`+n+`"`) {
|
||||
t.Errorf("%s stays in the old section", n)
|
||||
}
|
||||
|
||||
@@ -54,7 +54,6 @@ func main() {
|
||||
h := &Holder{
|
||||
Settings: settings,
|
||||
Logf: logf,
|
||||
Merges: kvMerges{},
|
||||
Source: kvSource{},
|
||||
Owed: seatOwed{say: stdio.SeatPublish},
|
||||
// The gate says what stalled to the operator itself (issue 1275, ADR 0437 §9).
|
||||
@@ -65,7 +64,6 @@ func main() {
|
||||
h.SaySeat = stdio.SeatPublish
|
||||
h.Records = &Records{Ledger: sdkLedger{}, Now: h.Now, Retention: h.recordRetention, Say: stdio.SeatPublish, Logf: logf}
|
||||
h.Records.Changed = h.recordChanged
|
||||
h.Old = kvOld{}
|
||||
h.Kept = kvKept{}
|
||||
h.Forge = seatGit{ask: stdio.Ask}
|
||||
h.Catalog = seatCatalog{ask: stdio.Ask}
|
||||
@@ -100,7 +98,6 @@ func main() {
|
||||
// tick, no forge poll, no reconcile loop. Each step is retried, each failure said, never given up on quietly.
|
||||
func run(h *Holder, l *listening) {
|
||||
<-stdio.Served() // Serve first: the state is reached through it, and an event is heard from as soon as it serves
|
||||
switchToRecords(h, l)
|
||||
statePins(h, l)
|
||||
go h.Work()
|
||||
for _, pattern := range followed {
|
||||
@@ -131,21 +128,6 @@ func run(h *Holder, l *listening) {
|
||||
}
|
||||
}
|
||||
|
||||
// switchToRecords carries the groups in flight into their delivery records (switch.go), retrying until it can: no event is
|
||||
// taken before, so no outcome reaches a record the switch has not opened yet.
|
||||
func switchToRecords(h *Holder, l *listening) {
|
||||
for wait := 2 * time.Second; ; wait = min(wait*2, time.Minute) {
|
||||
opened, found, err := h.Switch()
|
||||
if err == nil {
|
||||
logf("[mesh-delivery] the switch to the delivery records: %d opened, %d already there", opened, found)
|
||||
return
|
||||
}
|
||||
l.set("not yet: " + err.Error())
|
||||
logf("[mesh-delivery] the switch to the delivery records cannot be made yet (%v); asking again in %s", err, wait)
|
||||
time.Sleep(wait)
|
||||
}
|
||||
}
|
||||
|
||||
// statePins says every pin the records hold once at each start (design 47 G §579), retrying until it can.
|
||||
func statePins(h *Holder, l *listening) {
|
||||
for wait := 2 * time.Second; ; wait = min(wait*2, time.Minute) {
|
||||
@@ -179,7 +161,7 @@ func take(h *Holder, e stdio.Envelope) error {
|
||||
return h.PullUpdated(e.Body)
|
||||
}
|
||||
if e.Key == pullMergedEvent {
|
||||
return errors.Join(h.DeliveryMerged(e.Body), h.pullEnded(e.Body, "merged"))
|
||||
return h.DeliveryMerged(e.Body)
|
||||
}
|
||||
if e.Key == registrationChangedEvent {
|
||||
_, err := h.StartSources()
|
||||
@@ -189,7 +171,7 @@ func take(h *Holder, e stdio.Envelope) error {
|
||||
return h.ForgeMerged(e.Body)
|
||||
}
|
||||
if e.Key == pullClosedEvent {
|
||||
return errors.Join(h.DeliveryClosed(e.Body), h.pullEnded(e.Body, "closed"))
|
||||
return h.DeliveryClosed(e.Body)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -161,7 +161,7 @@ func TestItClaimsTheDeliverySeatAndFollowsWhatItHandles(t *testing.T) {
|
||||
// Two buckets still in the old `state` (merges, source), `pulls` and `asks` gone (§613), the four of the template `state` moved to `requires` (design 47 G §613), and no `asked` (the teller asks, ADR 0437 §6): ADR 0450 §3 and the conditions it raised (issue 1275). No
|
||||
// `turns`, no turn tool and no `check-gates-merge`: no check gates a merge (novox/hq ADR 0661 §1, §2, §6).
|
||||
buckets := m.buckets()
|
||||
if !reflect.DeepEqual(buckets, []string{"merges", "source"}) {
|
||||
if !reflect.DeepEqual(buckets, []string{"source"}) { // merges goes (design 47 H §764)
|
||||
t.Fatalf("state %v", buckets)
|
||||
}
|
||||
for _, tool := range m.Tools {
|
||||
@@ -307,3 +307,39 @@ func TestTheGateHoldsTheSeatAsTheSDKsTableOfRelease6HasIt(t *testing.T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// GATE-1/AC1 (design 47 H §764): the earlier model's states leave the gate, as its manifest, its announced states and its
|
||||
// code say: no `merges`, `owed` (the old bucket), `asks`, `pulls` or `turns`, and no `approval-carried` said.
|
||||
func TestTheEarlierModelsStatesAndApprovalAreGone(t *testing.T) {
|
||||
m, _ := readManifest(t)
|
||||
kept := []string{}
|
||||
for _, s := range Kept {
|
||||
kept = append(kept, s.Name)
|
||||
}
|
||||
gone := []string{"merges", "owed", "asks", "pulls", "turns"}
|
||||
for _, row := range []struct {
|
||||
where string
|
||||
names []string
|
||||
}{{"the manifest's state and requires", m.withTemplateStates()}, {"the announced states", kept}} {
|
||||
for _, n := range gone {
|
||||
if slices.Contains(row.names, n) {
|
||||
t.Errorf("%s still name %s", row.where, n)
|
||||
}
|
||||
}
|
||||
}
|
||||
sources, _ := filepath.Glob("*.go")
|
||||
for _, f := range sources {
|
||||
if strings.HasSuffix(f, "_test.go") {
|
||||
continue
|
||||
}
|
||||
raw, err := os.ReadFile(f)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, name := range []string{"approval-carried", "ApprovalCarried", "SwitchedOwed"} {
|
||||
if strings.Contains(string(raw), name) {
|
||||
t.Errorf("%s still names %s", f, name)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,38 +12,19 @@ import (
|
||||
"git.novox.be/novox/mesh-sdk/go/keys"
|
||||
)
|
||||
|
||||
// The gate merges nothing and hands nothing to the forge (design 47 G §592): `merges` stays an old section the switch reads
|
||||
// (switch.go, §613), never written; `source` is the gate's source revision per watched branch (§15, §291), served by the verb
|
||||
// The gate merges nothing and hands nothing to the forge (design 47 G §592; H §764: `merges` goes): `source` is the gate's source revision per watched branch (§15, §291), served by the verb
|
||||
// `source` below.
|
||||
|
||||
// Source is the state source's value, the seat mesh-delivery's type used as it is (novox/hq ADR 0634 §2).
|
||||
type (
|
||||
Source = seat.SourceByBranchValue
|
||||
// Owed is what the forge bridge performs, as the seat's event owed says it.
|
||||
Owed = seat.OwedByRepositoryNumberHeadActValue
|
||||
)
|
||||
|
||||
// changeAttempts is how often a lost compare-and-set is read and applied again before it is said.
|
||||
const changeAttempts = 10
|
||||
|
||||
// MergeStore is the gate's bucket merges.
|
||||
type MergeStore interface {
|
||||
Get(group string) (*Merge, error)
|
||||
}
|
||||
|
||||
// OldState reads the gate's old state owed, which the switch says again as switched acts (switch.go): each key, and one
|
||||
// key's value with its revision.
|
||||
type OldState interface {
|
||||
Keys(state string) ([]string, error)
|
||||
Get(state, key string) (value []byte, revision uint64, err error)
|
||||
}
|
||||
|
||||
// kvOld is the old state over the runtime.
|
||||
type kvOld struct{}
|
||||
|
||||
func (kvOld) Keys(state string) ([]string, error) { return stdio.State(state).Keys() }
|
||||
|
||||
func (kvOld) Get(state, key string) ([]byte, uint64, error) {
|
||||
e, err := stdio.State(state).Get(key)
|
||||
if err != nil || e == nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
return e.Value, e.Revision, nil
|
||||
}
|
||||
|
||||
// SourceStore is the gate's bucket source, one key per watched branch (design 47 G §15), moved by compare-and-set.
|
||||
type SourceStore interface {
|
||||
// Set reads a branch's source key and writes what update makes of it, unless update says nothing is to be written, and answers
|
||||
@@ -55,25 +36,6 @@ type SourceStore interface {
|
||||
Branches() ([]string, error)
|
||||
}
|
||||
|
||||
// kvMerges is merges over the runtime.
|
||||
type kvMerges struct{}
|
||||
|
||||
func (kvMerges) Get(group string) (*Merge, error) {
|
||||
key, err := mdc.MergesKey(group)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
e, err := stdio.State("merges").Get(key)
|
||||
if err != nil || e == nil {
|
||||
return nil, err
|
||||
}
|
||||
m, err := DecodeMerge(e.Value)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("the merge of %s is not readable: %w", group, err)
|
||||
}
|
||||
return &m, nil
|
||||
}
|
||||
|
||||
// kvSource is source over the runtime.
|
||||
type kvSource struct{}
|
||||
|
||||
|
||||
@@ -39,8 +39,6 @@ const RecordForm = 1
|
||||
const (
|
||||
TypeRecord = "record"
|
||||
TypeHeld = "held"
|
||||
// TypeSwitch holds the one key `switch.done` (A-281): the gate's fingerprint and the time of the switch to the records.
|
||||
TypeSwitch = "switch"
|
||||
)
|
||||
|
||||
// The operations of a record, each one effect (ADR 0597 §2), and of the month's list. The manifest's `requires` declares
|
||||
@@ -59,7 +57,6 @@ const (
|
||||
OpAct = "act" // set-entry into acts, by id: an act owed the forge with its outcome
|
||||
OpHold = "hold" // a month's list: set-entry into records, by instance
|
||||
OpDrop = "drop" // a month's list: remove from records, by instance
|
||||
OpDone = "done" // the switch: set-fields, the gate's fingerprint and the time
|
||||
)
|
||||
|
||||
// RecordOperations are a record's operations, in the order the manifest's type allows them.
|
||||
@@ -68,27 +65,6 @@ var RecordOperations = []string{OpOpen, OpGroup, OpTrace, OpEntry, OpOutcome, Op
|
||||
// HeldOperations are the month's list's operations.
|
||||
var HeldOperations = []string{OpHold, OpDrop}
|
||||
|
||||
// SwitchOperations are the switch key's operations.
|
||||
var SwitchOperations = []string{OpDone}
|
||||
|
||||
// switchInstance is the instance of the key `switch.done`, written once the switch has carried today's state in (A-281).
|
||||
const switchInstance = TypeSwitch + "/done"
|
||||
|
||||
// SwitchDone says whether the key `switch.done` is there: the switch has run, and no later start runs it again (A-281).
|
||||
func (rs *Records) SwitchDone() (bool, error) {
|
||||
raw, _, err := rs.Ledger.Get(switchInstance)
|
||||
if err != nil {
|
||||
return false, fmt.Errorf("the key switch.done cannot be read: %w", err)
|
||||
}
|
||||
return len(raw) > 0 && string(raw) != "null", nil
|
||||
}
|
||||
|
||||
// MarkSwitched writes the key `switch.done`: the gate's fingerprint and the time (A-281).
|
||||
func (rs *Records) MarkSwitched(fingerprint string) error {
|
||||
_, err := rs.Ledger.Apply(switchInstance, OpDone, map[string]any{"fingerprint": fingerprint, "at": rs.now().UTC().Format(time.RFC3339)})
|
||||
return err
|
||||
}
|
||||
|
||||
// DefaultRecordRetention is how long a record is kept when the setting record-retention gives none (design 47: 90 days
|
||||
// covers every trace the operator has asked of a past delivery so far).
|
||||
const DefaultRecordRetention = 90 * 24 * time.Hour
|
||||
|
||||
@@ -386,7 +386,7 @@ func TestTheDeliveryRecordIsALedgerInstanceKeyedByMilestoneAndHeads(t *testing.T
|
||||
// W11.1: the manifest's ledger types allow exactly the operations the gate applies, and the ledger is capped at 768 MiB.
|
||||
func TestTheManifestsLedgerTypesAreTheRecordsOperations(t *testing.T) {
|
||||
l := newLedgerFake(t)
|
||||
for name, want := range map[string][]string{TypeRecord: RecordOperations, TypeHeld: HeldOperations, TypeSwitch: SwitchOperations} {
|
||||
for name, want := range map[string][]string{TypeRecord: RecordOperations, TypeHeld: HeldOperations} {
|
||||
var got []string
|
||||
for _, op := range l.types[name].Operations {
|
||||
got = append(got, op.Name)
|
||||
|
||||
@@ -4,13 +4,14 @@ import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
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"
|
||||
stdio "git.novox.be/novox/mesh-sdk/go"
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
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"
|
||||
stdio "git.novox.be/novox/mesh-sdk/go"
|
||||
)
|
||||
|
||||
type branchSource struct{ memSource }
|
||||
|
||||
@@ -1,296 +0,0 @@
|
||||
package main
|
||||
|
||||
// The switch to the delivery record (design 47 *The delivery record*: "The switch carries today's state in, once"): at
|
||||
// the new gate's start, every group in flight and its merge as the old sections hold them become records, keyed by the
|
||||
// milestone and the heads. It is safe to run twice: a group in flight whose record is there already leaves it as it is
|
||||
// (Records.Open), and a group state the record holds already is not written again (Records.SetGroup), so delivering milestone
|
||||
// G again after a revert makes no second record and asks nothing again. The old sections are read, never written (§613).
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
mdc "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient"
|
||||
seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdelivery"
|
||||
"git.novox.be/novox/mesh-sdk/go/keys"
|
||||
"git.novox.be/novox/mesh-sdk/go/process"
|
||||
)
|
||||
|
||||
// oldDelivery is a delivery as the old section `deliveries` kept it, as far as the switch reads it.
|
||||
type oldDelivery struct {
|
||||
ID string `json:"id"`
|
||||
Repository string `json:"repository"`
|
||||
Commit string `json:"commit"`
|
||||
Number int `json:"number"`
|
||||
Branch string `json:"branch"`
|
||||
Group string `json:"group"`
|
||||
State string `json:"state"`
|
||||
InSource bool `json:"in_source"`
|
||||
NewerHead string `json:"newer_head"`
|
||||
ClosedUnmerged bool `json:"closed_unmerged"`
|
||||
}
|
||||
|
||||
// milestone is the name a delivery's record is kept under: its group's, a lone pull request's branch, its id.
|
||||
func (d oldDelivery) milestone() string {
|
||||
switch {
|
||||
case d.Group != "":
|
||||
return d.Group
|
||||
case d.Branch != "":
|
||||
return d.Branch
|
||||
}
|
||||
return d.ID
|
||||
}
|
||||
|
||||
// recordGroupOf is a merge, as the old section merges holds it, as the record's group state.
|
||||
func recordGroupOf(m Merge, members []string) RecordGroup {
|
||||
g := RecordGroup{Group: m.Group, Members: members, Ask: m.Ask, Approved: m.Approved}
|
||||
for _, p := range m.Pulls {
|
||||
g.Pulls = append(g.Pulls, RecordPull{Repository: p.Repository, Number: p.Number, Head: p.Head.Head, State: string(p.State),
|
||||
Commit: p.Commit, Words: p.Words})
|
||||
}
|
||||
return g
|
||||
}
|
||||
|
||||
// switchGroup is one group in flight as the switch finds it: its milestone, its heads and its members.
|
||||
type switchGroup struct {
|
||||
milestone string
|
||||
heads map[string]string
|
||||
members []string
|
||||
}
|
||||
|
||||
// inFlight are the groups in flight in the old section deliveries: every milestone with a delivery not final, its live
|
||||
// members' heads as `<repository>@<number>` to the full commit.
|
||||
func (h *Holder) inFlight() ([]switchGroup, error) {
|
||||
if h.Old == nil {
|
||||
return nil, nil
|
||||
}
|
||||
keys, err := h.Old.Keys("deliveries")
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("the old section deliveries cannot be read for the switch: %w", err)
|
||||
}
|
||||
by := map[string]*switchGroup{}
|
||||
for _, key := range keys {
|
||||
raw, _, err := h.Old.Get("deliveries", key)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("the old delivery %s cannot be read for the switch: %w", key, err)
|
||||
}
|
||||
var d oldDelivery
|
||||
if raw == nil || json.Unmarshal(raw, &d) != nil || d.ID == "" {
|
||||
continue // a mark an earlier owner kept, or no delivery
|
||||
}
|
||||
final := d.State == "merged" || d.State == "held" || d.State == "closed"
|
||||
if final && !(d.State == "merged" && !d.InSource) || d.Number == 0 || d.NewerHead != "" || d.ClosedUnmerged {
|
||||
continue
|
||||
}
|
||||
name := d.milestone()
|
||||
g := by[name]
|
||||
if g == nil {
|
||||
g = &switchGroup{milestone: name, heads: map[string]string{}}
|
||||
by[name] = g
|
||||
}
|
||||
g.heads[mdc.ApprovedKey(d.Repository, d.Number)] = d.Commit
|
||||
g.members = append(g.members, d.ID)
|
||||
}
|
||||
out := make([]switchGroup, 0, len(by))
|
||||
for _, g := range by {
|
||||
sort.Strings(g.members)
|
||||
out = append(out, *g)
|
||||
}
|
||||
sort.Slice(out, func(i, j int) bool { return out[i].milestone < out[j].milestone })
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// Switch carries today's state into the records, once and safe to run again: each group in flight becomes a record at
|
||||
// its heads, or at the heads its merge was approved at when `merges` holds one, with that merge as its group state.
|
||||
// It answers how many records it opened and how many it found there. It runs once (A-281): when it has carried today's state in
|
||||
// it writes the key `switch.done`, and a start that finds the key runs no switch, so the deliveries the gate writes from the
|
||||
// seat git's events (§716) never become records at a start. A revert's restore brings back the state without the key, so
|
||||
// delivering G again switches again.
|
||||
func (h *Holder) Switch() (opened, found int, err error) {
|
||||
if h.Records == nil {
|
||||
return 0, 0, nil
|
||||
}
|
||||
if done, err := h.Records.SwitchDone(); err != nil || done {
|
||||
return 0, 0, err
|
||||
}
|
||||
defer func() {
|
||||
if err == nil {
|
||||
err = h.Records.MarkSwitched(process.ReadOwnBuild(os.Getenv).String())
|
||||
}
|
||||
}()
|
||||
groups, err := h.inFlight()
|
||||
if err != nil {
|
||||
return 0, 0, err
|
||||
}
|
||||
for _, g := range groups {
|
||||
var merge *Merge
|
||||
if h.Merges != nil {
|
||||
if merge, err = h.Merges.Get(g.milestone); err != nil {
|
||||
return opened, found, fmt.Errorf("the merge of %s cannot be read for the switch: %w", g.milestone, err)
|
||||
}
|
||||
}
|
||||
heads := g.heads
|
||||
if merge != nil && len(merge.Approved) > 0 {
|
||||
heads = merge.Approved
|
||||
}
|
||||
r, made, err := h.Records.Open(g.milestone, heads, false)
|
||||
if err != nil {
|
||||
return opened, found, fmt.Errorf("the switch cannot open the record of %s: %w", g.milestone, err)
|
||||
}
|
||||
if made {
|
||||
opened++
|
||||
} else {
|
||||
found++
|
||||
}
|
||||
if merge != nil {
|
||||
if err := h.Records.SetGroup(r, recordGroupOf(*merge, g.members)); err != nil {
|
||||
return opened, found, fmt.Errorf("the switch cannot carry the merge of %s: %w", g.milestone, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
if err := h.carryOwed(); err != nil {
|
||||
return opened, found, err
|
||||
}
|
||||
err = h.carryApprovals()
|
||||
return opened, found, err
|
||||
}
|
||||
|
||||
// oldMerge is a group's merge as the old state merges holds it, with its key and revision; nil when it holds none.
|
||||
func (h *Holder) oldMerge(group string) (*Merge, uint64, error) {
|
||||
if h.Old == nil {
|
||||
return nil, 0, nil
|
||||
}
|
||||
key, err := mdc.MergesKey(group)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
raw, rev, err := h.Old.Get(mdc.SwitchedMerges, key)
|
||||
if err != nil || raw == nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
m, err := DecodeMerge(raw)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
return &m, rev, nil
|
||||
}
|
||||
|
||||
// carryOwed says every act the old state owed holds as owed, under its switched id (the state, the key and its revision:
|
||||
// meshdeliveryclient.SwitchedActID), so the forge bridge performs what the old bridge did not and counts as performed what
|
||||
// it did (design 47 G §169). No merge act is made from the old state merges (G §167, §542). Said at every switch, it is the same act each time. A key that cannot be read as an act is said
|
||||
// as refused and skipped.
|
||||
func (h *Holder) carryOwed() error {
|
||||
if h.Old == nil || h.Owed == nil {
|
||||
return nil
|
||||
}
|
||||
now := h.Now().UTC()
|
||||
keys, err := h.Old.Keys(mdc.SwitchedOwed)
|
||||
if err != nil {
|
||||
return fmt.Errorf("the state owed cannot be read for the switch: %w", err)
|
||||
}
|
||||
for _, key := range keys {
|
||||
raw, rev, err := h.Old.Get(mdc.SwitchedOwed, key)
|
||||
if err != nil {
|
||||
return fmt.Errorf("the owed act %s cannot be read for the switch: %w", key, err)
|
||||
}
|
||||
if raw == nil {
|
||||
continue
|
||||
}
|
||||
repository, number, head, _, kerr := mdc.ParseOwedKey(key)
|
||||
var o Owed
|
||||
id, ierr := mdc.SwitchedActID(mdc.SwitchedOwed, key, rev)
|
||||
if derr := json.Unmarshal(raw, &o); kerr != nil || derr != nil || ierr != nil {
|
||||
h.Refuse(fmt.Errorf("the owed act %s is not carried by the switch: %v", key, errors.Join(kerr, derr, ierr)))
|
||||
continue
|
||||
}
|
||||
said := seatOwedOf(o, id, repository, number, head, &now)
|
||||
if r := h.recordHolding(repository, head); r != nil {
|
||||
err = h.owe(r, said)
|
||||
} else {
|
||||
err = h.Owed.Say(said)
|
||||
}
|
||||
if err != nil {
|
||||
return fmt.Errorf("the owed act %s cannot be said for the switch: %w", key, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// recordHolding is the open record that holds a pull request of the repository at the head, nil when none does.
|
||||
func (h *Holder) recordHolding(repository, head string) *Record {
|
||||
if h.Records == nil {
|
||||
return nil
|
||||
}
|
||||
current, err := h.Records.Current()
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
for _, r := range current {
|
||||
for _, m := range membersOf(r) {
|
||||
if strings.EqualFold(m.Repository, repository) && sameCommit(m.Head, head) {
|
||||
return r
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// approver is who an Approve carried across the switch was given by (design 47 §542).
|
||||
const approver = "the operator"
|
||||
|
||||
// carryApprovals says, for each key of the old section merges the old bridge had not performed, `approval-carried` of each
|
||||
// pull request it had not merged, once (design 47 §542, §592): the runner takes it as that pull request's `approval` step.
|
||||
// The keys stay, read no more. Said at every switch, it is the same event under the same id each time, which the bus keeps once.
|
||||
func (h *Holder) carryApprovals() error {
|
||||
if h.Old == nil || h.SaySeat == nil {
|
||||
return nil
|
||||
}
|
||||
names, err := h.Old.Keys(mdc.SwitchedMerges)
|
||||
if err != nil {
|
||||
return fmt.Errorf("the old section merges cannot be read for the switch: %w", err)
|
||||
}
|
||||
now := h.Now().UTC()
|
||||
for _, key := range names {
|
||||
raw, _, err := h.Old.Get(mdc.SwitchedMerges, key)
|
||||
if err != nil {
|
||||
return fmt.Errorf("the old merge %s cannot be read for the switch: %w", key, err)
|
||||
}
|
||||
if raw == nil {
|
||||
continue
|
||||
}
|
||||
m, err := DecodeMerge(raw)
|
||||
if err != nil {
|
||||
h.Refuse(fmt.Errorf("the old merge %s is not carried by the switch: %v", key, err))
|
||||
continue
|
||||
}
|
||||
for approved, head := range m.Approved {
|
||||
repository, number, ok := parseApprovedKey(approved)
|
||||
if !ok || mergedIn(m, repository, number) {
|
||||
continue
|
||||
}
|
||||
body := seat.ApprovalCarriedEvent{Approver: approver, At: now, Commit: head, Pull: int64(number), Repository: repository}
|
||||
subject := seat.SubjectApprovalCarried(keys.EscapeName(repository), fmt.Sprint(number))
|
||||
if err := h.SaySeat(subject, body, fmt.Sprintf("approval-carried.%s.%d", repository, number)); err != nil {
|
||||
return fmt.Errorf("the approval of %s#%d cannot be said carried: %w", repository, number, err)
|
||||
}
|
||||
if err := h.approvalOpen(repository, number, head); err != nil {
|
||||
return fmt.Errorf("the finding of the approval of %s#%d cannot be written: %w", repository, number, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// mergedIn is whether a merge's pull request of that repository and number was merged.
|
||||
func mergedIn(m Merge, repository string, number int) bool {
|
||||
for _, p := range m.Pulls {
|
||||
if strings.EqualFold(p.Repository, repository) && p.Number == number && p.State == mdc.MergeMerged {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -1,130 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"reflect"
|
||||
|
||||
mdc "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient"
|
||||
seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdelivery"
|
||||
)
|
||||
|
||||
// The values the gate keeps in the seat mesh-delivery's states. The seat's types are the layout and meshdeliveryclient
|
||||
// holds their rules and codecs; Source, Owed and Answer are used as they are, and the three whose seat form differs from the
|
||||
// form the gate works in (a pull request that holds its head, the router's ask as bytes, a turn's times as plain times)
|
||||
// are converted at the edge, so a stored value decodes unchanged (novox/hq ADR 0634 §2).
|
||||
type (
|
||||
// Source is the state source's value.
|
||||
Source = seat.SourceByBranchValue
|
||||
// Owed is the state owed's value: what the forge bridge performs.
|
||||
Owed = seat.OwedByRepositoryNumberHeadActValue
|
||||
// Answer is the operator's answer as the gate acts on it.
|
||||
Answer = mdc.Answer
|
||||
)
|
||||
|
||||
// Merge is the state merges' value: a group's merge.
|
||||
type Merge struct {
|
||||
V int
|
||||
Group string
|
||||
Ask string
|
||||
Approved map[string]string
|
||||
Pulls []MergePull
|
||||
}
|
||||
|
||||
// MergePull is one pull request of a merge: its expected head, its state, the merge commit once merged, the forge's words
|
||||
// when refused.
|
||||
type MergePull struct {
|
||||
mdc.Head
|
||||
State mdc.MergeState
|
||||
Commit string
|
||||
Words string
|
||||
}
|
||||
|
||||
func (m Merge) stored() seat.MergesByGroupValue {
|
||||
out := seat.MergesByGroupValue{Approved: m.Approved, Ask: m.Ask, Group: m.Group, V: int64(m.V)}
|
||||
if m.Pulls != nil {
|
||||
out.Pulls = make([]seat.MergesByGroupValuePullsItem, len(m.Pulls))
|
||||
}
|
||||
for i, p := range m.Pulls {
|
||||
out.Pulls[i] = seat.MergesByGroupValuePullsItem{Commit: p.Commit, Head: p.Head.Head, Number: int64(p.Number),
|
||||
Repository: p.Repository, State: string(p.State), Words: p.Words}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func mergeFromSeat(s seat.MergesByGroupValue) Merge {
|
||||
out := Merge{V: int(s.V), Group: s.Group, Ask: s.Ask, Approved: s.Approved}
|
||||
for _, p := range s.Pulls {
|
||||
out.Pulls = append(out.Pulls, MergePull{Head: mdc.Head{Repository: p.Repository, Number: int(p.Number), Head: p.Head},
|
||||
State: mdc.MergeState(p.State), Commit: p.Commit, Words: p.Words})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// EncodeMerge is m as the value of a merges key.
|
||||
func EncodeMerge(m Merge) ([]byte, error) { return mdc.EncodeMerge(m.stored()) }
|
||||
|
||||
// DecodeMerge reads the value of a merges key.
|
||||
func DecodeMerge(data []byte) (Merge, error) {
|
||||
s, err := mdc.DecodeMerge(data)
|
||||
if err != nil {
|
||||
return Merge{}, err
|
||||
}
|
||||
return mergeFromSeat(s), nil
|
||||
}
|
||||
|
||||
// SameMerge says whether two merges are the same value.
|
||||
func SameMerge(a, b Merge) bool { return mdc.SameMerge(a.stored(), b.stored()) }
|
||||
|
||||
// Ask is the state asks' value: the router's ask for a group's merge at its heads.
|
||||
type Ask struct {
|
||||
V int
|
||||
Group string
|
||||
Heads []mdc.Head
|
||||
Ask json.RawMessage
|
||||
// Asking counts the times the gate wrote this group's ask at these heads (0 or 1 for the first).
|
||||
Asking int
|
||||
}
|
||||
|
||||
func (a Ask) stored() seat.AsksByMergeGroupHeadsValue {
|
||||
out := seat.AsksByMergeGroupHeadsValue{Asking: int64(a.Asking), Group: a.Group, V: int64(a.V)}
|
||||
if len(a.Ask) > 0 {
|
||||
out.Ask = a.Ask
|
||||
}
|
||||
if a.Heads != nil {
|
||||
out.Heads = make([]seat.AsksByMergeGroupHeadsValueHeadsItem, len(a.Heads))
|
||||
}
|
||||
for i, h := range a.Heads {
|
||||
out.Heads[i] = seat.AsksByMergeGroupHeadsValueHeadsItem{Head: h.Head, Number: int64(h.Number), Repository: h.Repository}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func askFromSeat(s seat.AsksByMergeGroupHeadsValue) (Ask, error) {
|
||||
raw, err := json.Marshal(s.Ask)
|
||||
if err != nil {
|
||||
return Ask{}, err
|
||||
}
|
||||
return Ask{V: int(s.V), Group: s.Group, Heads: mdc.HeadsOf(s.Heads), Ask: raw, Asking: int(s.Asking)}, nil
|
||||
}
|
||||
|
||||
// EncodeAsk is a as the value of an asks key.
|
||||
func EncodeAsk(a Ask) ([]byte, error) { return mdc.EncodeAsk(a.stored()) }
|
||||
|
||||
// DecodeAsk reads the value of an asks key.
|
||||
func DecodeAsk(data []byte) (Ask, error) {
|
||||
s, err := mdc.DecodeAsk(data)
|
||||
if err != nil {
|
||||
return Ask{}, err
|
||||
}
|
||||
return askFromSeat(s)
|
||||
}
|
||||
|
||||
// SameAsk says whether two asks are the same value, the router's ask by its content.
|
||||
func SameAsk(a, b Ask) bool {
|
||||
var x, y any
|
||||
if json.Unmarshal(a.Ask, &x) != nil || json.Unmarshal(b.Ask, &y) != nil {
|
||||
return false
|
||||
}
|
||||
a.Ask, b.Ask = nil, nil
|
||||
return reflect.DeepEqual(a, b) && reflect.DeepEqual(x, y)
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
mdc "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient"
|
||||
)
|
||||
|
||||
// What go/delivery wrote into the seat's states, key order and all, must decode as it did and encode to the same
|
||||
// content (ADR 0634 §2): the gate's working values are converted to the seat's types at the edge.
|
||||
func TestStoredValuesOfTheEarlierLayoutDecodeUnchanged(t *testing.T) {
|
||||
head := mdc.Head{Repository: "novox/app", Number: 7, Head: "0123456789abcdef0123456789abcdef01234567"}
|
||||
rows := []struct {
|
||||
name string
|
||||
stored string
|
||||
decode func(string) (any, error)
|
||||
encode func(any) ([]byte, error)
|
||||
want any
|
||||
}{
|
||||
{"merge with a merged and a refused pull", `{"v":1,"group":"feat/x","ask":"merge.feat_x.0123456789ab","approved":{"novox/app@7":"` + head.Head + `","novox/web@8":"abc"},` +
|
||||
`"pulls":[{"repository":"novox/app","number":7,"head":"` + head.Head + `","state":"merged","commit":"c0ffee"},` +
|
||||
`{"repository":"novox/web","number":8,"head":"abc","state":"refused","words":"mesh/check (missing)"}]}`,
|
||||
func(s string) (any, error) { return DecodeMerge([]byte(s)) }, func(v any) ([]byte, error) { return EncodeMerge(v.(Merge)) },
|
||||
Merge{V: 1, Group: "feat/x", Ask: "merge.feat_x.0123456789ab", Approved: map[string]string{"novox/app@7": head.Head, "novox/web@8": "abc"}, Pulls: []MergePull{
|
||||
{Head: head, State: mdc.MergeMerged, Commit: "c0ffee"},
|
||||
{Head: mdc.Head{Repository: "novox/web", Number: 8, Head: "abc"}, State: mdc.MergeRefused, Words: "mesh/check (missing)"}}}},
|
||||
{"ask keeps the router's ask as bytes", `{"v":1,"group":"feat/x","heads":[{"repository":"novox/app","number":7,"head":"` + head.Head + `"}],"ask":{"id":"a","options":["Approve"]},"asking":2}`,
|
||||
func(s string) (any, error) { return DecodeAsk([]byte(s)) }, func(v any) ([]byte, error) { return EncodeAsk(v.(Ask)) },
|
||||
Ask{V: 1, Group: "feat/x", Heads: []mdc.Head{head}, Ask: json.RawMessage(`{"id":"a","options":["Approve"]}`), Asking: 2}},
|
||||
{"source", `{"v":1,"group":"feat/x","heads":{"novox/app":"c0ffee"}}`,
|
||||
func(s string) (any, error) { return mdc.DecodeSource([]byte(s)) }, func(v any) ([]byte, error) { return mdc.EncodeSource(v.(Source)) },
|
||||
Source{V: 1, Group: "feat/x", Heads: map[string]string{"novox/app": "c0ffee"}}},
|
||||
{"owed status", `{"v":1,"act":"status","context":"mesh/delivery","target":"https://x/y","state":"pending"}`,
|
||||
func(s string) (any, error) { return mdc.DecodeOwed([]byte(s)) }, func(v any) ([]byte, error) { return mdc.EncodeOwed(v.(Owed)) },
|
||||
Owed{V: 1, Act: "status", Context: "mesh/delivery", Target: "https://x/y", State: "pending"}},
|
||||
{"answer", `{"v":1,"option":"Approve","warrant":"w@2026-11-05T10:00:00Z","words":"chose Approve"}`,
|
||||
func(s string) (any, error) { return mdc.DecodeAnswer([]byte(s)) }, func(v any) ([]byte, error) { return mdc.EncodeAnswer(v.(Answer)) },
|
||||
Answer{V: 1, Option: "Approve", Warrant: "w@2026-11-05T10:00:00Z", Words: "chose Approve"}},
|
||||
}
|
||||
for _, r := range rows {
|
||||
t.Run(r.name, func(t *testing.T) {
|
||||
got, err := r.decode(r.stored)
|
||||
if err != nil {
|
||||
t.Fatalf("the earlier layout does not decode: %v", err)
|
||||
}
|
||||
if !sameValue(got, r.want) {
|
||||
t.Fatalf("decoded %+v, want %+v", got, r.want)
|
||||
}
|
||||
raw, err := r.encode(got)
|
||||
if err != nil {
|
||||
t.Fatalf("encode: %v", err)
|
||||
}
|
||||
var a, b any
|
||||
if json.Unmarshal(raw, &a) != nil || json.Unmarshal([]byte(r.stored), &b) != nil || !reflect.DeepEqual(a, b) {
|
||||
t.Fatalf("encoded %s, the earlier layout was %s", raw, r.stored)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func sameValue(a, b any) bool {
|
||||
if x, ok := a.(Ask); ok {
|
||||
return SameAsk(x, b.(Ask))
|
||||
}
|
||||
return reflect.DeepEqual(a, b)
|
||||
}
|
||||
@@ -7,7 +7,6 @@ require (
|
||||
git.novox.be/novox/mesh-contracts/health-and-repair/go/seats/meshconditions v0.0.0-00010101000000-000000000000
|
||||
git.novox.be/novox/mesh-contracts/operator-and-conversation/go/clients/operatorchannelclient v0.0.0-00010101000000-000000000000
|
||||
git.novox.be/novox/mesh-contracts/operator-and-conversation/go/seats/operatorchannel v0.0.0-00010101000000-000000000000
|
||||
git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliverycheckerclient v0.0.0-00010101000000-000000000000
|
||||
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-contracts/go/seats/git v0.0.0-00010101000000-000000000000
|
||||
git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdelivery v0.0.0-00010101000000-000000000000
|
||||
|
||||
@@ -282,27 +282,6 @@
|
||||
"key": "instance"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "switch",
|
||||
"schema": {
|
||||
"fingerprint": {
|
||||
"type": "string"
|
||||
},
|
||||
"at": {
|
||||
"type": "string"
|
||||
}
|
||||
},
|
||||
"operations": [
|
||||
{
|
||||
"name": "done",
|
||||
"effect": "set-fields",
|
||||
"fields": [
|
||||
"fingerprint",
|
||||
"at"
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
@@ -316,14 +295,6 @@
|
||||
"storage": "key-value",
|
||||
"template": "state"
|
||||
},
|
||||
{
|
||||
"name": "owed",
|
||||
"storage": "key-value",
|
||||
"template": "state",
|
||||
"options": {
|
||||
"history": 5
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "conditions",
|
||||
"storage": "key-value",
|
||||
@@ -362,10 +333,6 @@
|
||||
"seat:node-engine.composition"
|
||||
],
|
||||
"state": [
|
||||
{
|
||||
"name": "merges",
|
||||
"history": 10
|
||||
},
|
||||
{
|
||||
"name": "source",
|
||||
"history": 64
|
||||
|
||||
Reference in New Issue
Block a user