diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/deliveries.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/deliveries.go deleted file mode 100644 index d1363a7d2..000000000 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/deliveries.go +++ /dev/null @@ -1,462 +0,0 @@ -package main - -// The gate keeps a group's members from their announcement (design 47 G §716; A-279, A-236): its states `deliveries` and -// `groups`, written from the seat git's pull-updated, pull-merged and pull-closed, deleted when a record carries a member (the -// take-in, takenin.go) or its pull request closes unmerged, and put right at the gate's start from the seat git's open-pulls and -// pull. A delivery's key is its id `@` escaped as a key name; a group's key is its head branch -// escaped as a key name. Only the gate writes either state. - -import ( - "encoding/json" - "errors" - "fmt" - "sort" - "strings" - - 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" -) - -// The two states, by their names in the gate's manifest. -const ( - deliveriesState = "deliveries" - groupsState = "groups" -) - -// The states of a delivery the gate writes; any other state an old table kept counts open (§716). -const ( - deliveryOpen = "open" - deliveryMerged = "merged" -) - -// Delivery is one pull request as the state `deliveries` keeps it. -type Delivery struct { - ID string `json:"id"` - Repository string `json:"repository"` - Number int `json:"number"` - Commit string `json:"commit"` - // Base is the pull request's base branch as the seat git says it (A-279); Branch its head branch, which names its group. - Base string `json:"base,omitempty"` - Branch string `json:"branch,omitempty"` - Group string `json:"group,omitempty"` - State string `json:"state"` -} - -// openOrMerged is a delivery's state as the gate reads it: merged, or else open. -func (d Delivery) openOrMerged() string { - if d.State == deliveryMerged { - return deliveryMerged - } - return deliveryOpen -} - -// keptGroup is one key of the state `groups`: the group, its head branch, and its members' delivery ids. -type keptGroup struct { - Group string `json:"group"` - Members []string `json:"members"` -} - -// DeliveryStore is the gate's two states over the runtime. -type DeliveryStore interface { - Keys(state string) ([]string, error) - Get(state, key string) ([]byte, error) - Put(state, key string, value any) error - Delete(state, key string) error -} - -// ForgeReads is what the gate reads of the seat git: open-pulls and pull. -type ForgeReads interface { - OpenPulls() (gitseat.OpenPullsAnswer, error) - Pull(repository string, number int64) (gitseat.PullAnswer, error) - // Branch is a repository branch's head (the seat git's verb branch). - Branch(repository, branch string) (gitseat.BranchAnswer, error) - // Contains is whether commit is in (or is) the commit in (the seat git's verb contains). - Contains(repository, commit, in string) (bool, error) -} - -// kvKept is the store over the runtime. -type kvKept struct{} - -func (kvKept) Keys(state string) ([]string, error) { return stdio.State(state).Keys() } - -func (kvKept) Get(state, key string) ([]byte, error) { - e, err := stdio.State(state).Get(key) - if err != nil || e == nil { - return nil, err - } - return e.Value, nil -} - -func (kvKept) Put(state, key string, value any) error { - _, err := stdio.State(state).Put(key, value) - return err -} - -func (kvKept) Delete(state, key string) error { return stdio.State(state).Delete(key) } - -// seatGit reads the seat git through the tool runner. -type seatGit struct{ ask asking } - -func (s seatGit) call(verb string, in any, out any) error { - raw, err := s.ask("seat:"+gitseat.Seat+"."+verb, in) - if err != nil { - return err - } - answer, said, ok := answerOf(raw) - if !ok { - return fmt.Errorf("%s refused: %s", verb, lastLine(said)) - } - if err := json.Unmarshal(answer, out); err != nil { - return fmt.Errorf("the answer of %s is not readable: %w", verb, err) - } - return nil -} - -func (s seatGit) OpenPulls() (gitseat.OpenPullsAnswer, error) { - var a gitseat.OpenPullsAnswer - return a, s.call(gitseat.VerbOpenPulls, gitseat.OpenPullsInput{}, &a) -} - -func (s seatGit) Pull(repository string, number int64) (gitseat.PullAnswer, error) { - var a gitseat.PullAnswer - return a, s.call(gitseat.VerbPull, gitseat.PullInput{Repository: repository, Number: number}, &a) -} - -func deliveryKey(id string) string { return keys.EscapeName(id) } - -func samePull(d Delivery, repository string, number int) bool { - return strings.EqualFold(d.Repository, repository) && d.Number == number -} - -// deliveries are every delivery the state keeps by its key; a key that is no delivery (a mark an earlier owner kept) is left. -func (h *Holder) deliveries() (map[string]Delivery, error) { - if h.Kept == nil { - return nil, errors.New("this gate keeps no state deliveries") - } - names, err := h.Kept.Keys(deliveriesState) - if err != nil { - return nil, fmt.Errorf("the state deliveries cannot be read: %w", err) - } - out := map[string]Delivery{} - for _, k := range names { - raw, err := h.Kept.Get(deliveriesState, k) - if err != nil { - return nil, fmt.Errorf("the delivery %s cannot be read: %w", k, err) - } - var d Delivery - if raw == nil || json.Unmarshal(raw, &d) != nil || d.ID == "" || d.Number == 0 { - continue - } - out[k] = d - } - return out, nil -} - -// keptGroups are every group the state keeps by its key. -func (h *Holder) keptGroups() (map[string]keptGroup, error) { - if h.Kept == nil { - return nil, errors.New("this gate keeps no state groups") - } - names, err := h.Kept.Keys(groupsState) - if err != nil { - return nil, fmt.Errorf("the state groups cannot be read: %w", err) - } - out := map[string]keptGroup{} - for _, k := range names { - raw, err := h.Kept.Get(groupsState, k) - if err != nil { - return nil, fmt.Errorf("the group %s cannot be read: %w", k, err) - } - var g keptGroup - if raw == nil || json.Unmarshal(raw, &g) != nil || g.Group == "" { - continue - } - out[k] = g - } - return out, nil -} - -// PullUpdated takes one pull-updated: the delivery is written under its id with its base and head branch, and a newer head of the -// same pull request takes the older's place, in its group too. -func (h *Holder) PullUpdated(body []byte) error { - var e gitseat.PullUpdatedEvent - if err := json.Unmarshal(body, &e); err != nil || e.Repository == "" || e.Number <= 0 || e.Head == "" { - h.Refuse(fmt.Errorf("a pull-updated of the seat git is not readable: %v", err)) - return nil - } - h.dmu.Lock() - defer h.dmu.Unlock() - return h.writeDelivery(Delivery{ID: IDOf(e.Repository, e.Head), Repository: e.Repository, Number: int(e.Number), Commit: e.Head, - Base: e.Base, Branch: e.Branch, State: deliveryOpen}) -} - -// writeDelivery writes a delivery in place of any other head of its pull request and puts the groups right; under dmu. -func (h *Holder) writeDelivery(d Delivery) error { - all, err := h.deliveries() - if err != nil { - return err - } - branches := map[string]bool{d.Branch: true} - key := deliveryKey(d.ID) - for k, o := range all { - if k == key || !samePull(o, d.Repository, d.Number) { - continue - } - if err := h.Kept.Delete(deliveriesState, k); err != nil { - return fmt.Errorf("the older delivery %s cannot be deleted: %w", o.ID, err) - } - delete(all, k) - branches[o.Branch] = true - } - if o, ok := all[key]; ok { - d.State = o.openOrMerged() - d.Group = o.Group - } - if err := h.Kept.Put(deliveriesState, key, d); err != nil { - return fmt.Errorf("the delivery %s cannot be written: %w", d.ID, err) - } - return h.refreshGroups(branches) -} - -// DeliveryMerged takes one pull-merged: the delivery of that pull request is merged. A pull request the gate keeps no delivery of is -// left: nothing would delete it. -func (h *Holder) DeliveryMerged(body []byte) error { - var e gitseat.PullMergedEvent - if err := json.Unmarshal(body, &e); err != nil || e.Repository == "" || e.Number <= 0 { - h.Refuse(fmt.Errorf("a pull-merged of the seat git is not readable: %v", err)) - return nil - } - h.dmu.Lock() - defer h.dmu.Unlock() - return h.setMerged(e.Repository, int(e.Number), e.Base) -} - -// setMerged sets the state of a pull request's delivery to merged; under dmu. -func (h *Holder) setMerged(repository string, number int, base string) error { - all, err := h.deliveries() - if err != nil { - return err - } - for k, d := range all { - if !samePull(d, repository, number) || d.State == deliveryMerged { - continue - } - d.State = deliveryMerged - if base != "" { - d.Base = base - } - if err := h.Kept.Put(deliveriesState, k, d); err != nil { - return fmt.Errorf("the delivery %s cannot be set merged: %w", d.ID, err) - } - } - return nil -} - -// DeliveryClosed takes one pull-closed: the delivery of a pull request not merged is deleted, and its group put right. -func (h *Holder) DeliveryClosed(body []byte) error { - var e gitseat.PullClosedEvent - if err := json.Unmarshal(body, &e); err != nil || e.Repository == "" || e.Number <= 0 { - h.Refuse(fmt.Errorf("a pull-closed of the seat git is not readable: %v", err)) - return nil - } - h.dmu.Lock() - defer h.dmu.Unlock() - return h.dropUnmerged(e.Repository, int(e.Number)) -} - -// dropUnmerged deletes the deliveries of a pull request that are not merged and puts their groups right; under dmu. -func (h *Holder) dropUnmerged(repository string, number int) error { - all, err := h.deliveries() - if err != nil { - return err - } - branches := map[string]bool{} - for k, d := range all { - if !samePull(d, repository, number) || d.State == deliveryMerged { - continue - } - if err := h.Kept.Delete(deliveriesState, k); err != nil { - return fmt.Errorf("the delivery %s cannot be deleted: %w", d.ID, err) - } - branches[d.Branch] = true - } - return h.refreshGroups(branches) -} - -// recordGroupsHeld are the group ids the delivery records carry, ended or not. -func (h *Holder) recordGroupsHeld() (map[string]bool, error) { - out := map[string]bool{} - if h.Records == nil { - return out, nil - } - kept, err := h.Records.Kept() - if err != nil { - return nil, fmt.Errorf("the delivery records cannot be read for the groups: %w", err) - } - for _, r := range kept { - if r.Group != nil && r.Group.Group != "" && len(membersOf(r)) > 0 { - out[r.Group.Group] = true - } - } - return out, nil -} - -// refreshGroups writes, for each head branch, the group key of its deliveries and their `group`: pull requests with one head branch -// form one group; a group of one with no member in a record is no group, its key deleted and its member's `group` cleared; a group -// key once no member remains outside a record is deleted (§716). Under dmu. -func (h *Holder) refreshGroups(branches map[string]bool) error { - inRecords, err := h.recordGroupsHeld() - if err != nil { - return err - } - all, err := h.deliveries() - if err != nil { - return err - } - for branch := range branches { - if branch == "" { - continue - } - var members []string - keysOf := map[string]string{} - for k, d := range all { - if d.Branch == branch { - members = append(members, d.ID) - keysOf[d.ID] = k - } - } - sort.Strings(members) - gkey := keys.EscapeName(branch) - isGroup := len(members) > 1 || len(members) == 1 && inRecords[branch] - if !isGroup { - if err := h.Kept.Delete(groupsState, gkey); err != nil { - return fmt.Errorf("the group %s cannot be deleted: %w", branch, err) - } - } else if err := h.Kept.Put(groupsState, gkey, keptGroup{Group: branch, Members: members}); err != nil { - return fmt.Errorf("the group %s cannot be written: %w", branch, err) - } - for _, id := range members { - k := keysOf[id] - d := all[k] - want := "" - if isGroup { - want = branch - } - if d.Group != want { - d.Group = want - all[k] = d - if err := h.Kept.Put(deliveriesState, k, d); err != nil { - return fmt.Errorf("the delivery %s cannot be put in its group: %w", id, err) - } - } - } - } - return nil -} - -// ReadForge puts right what a missed pull event left, once at the gate's start (§716, after §613's copy): each open pull request -// the seat git's open-pulls says that the gate lacks, or keeps at another head, is written; each delivery kept open that the answer -// does not name is read by pull: merged sets merged, closed deletes it. A read that fails is said in the journal and made again at -// the next start. -func (h *Holder) ReadForge() error { - if h.Forge == nil || h.Kept == nil { - return nil - } - answer, err := h.Forge.OpenPulls() - if err != nil { - return fmt.Errorf("open-pulls: %w", err) - } - if answer.Error != "" { - return fmt.Errorf("open-pulls: %s", answer.Error) - } - h.dmu.Lock() - defer h.dmu.Unlock() - listed := map[string]bool{} - var failed []error - for _, o := range answer.Pulls { - p := o.Pull - if p.Repository == "" || p.Number <= 0 || p.Head == "" { - continue - } - listed[strings.ToLower(p.Repository)+"#"+fmt.Sprint(p.Number)] = true - all, err := h.deliveries() - if err != nil { - return err - } - if d, ok := all[deliveryKey(IDOf(p.Repository, p.Head))]; ok && d.Base == p.Base && d.Branch == p.Branch { - continue - } - if err := h.writeDelivery(Delivery{ID: IDOf(p.Repository, p.Head), Repository: p.Repository, Number: int(p.Number), Commit: p.Head, - Base: p.Base, Branch: p.Branch, State: deliveryOpen}); err != nil { - failed = append(failed, err) - } - } - all, err := h.deliveries() - if err != nil { - return err - } - for _, d := range all { - if d.openOrMerged() != deliveryOpen || listed[strings.ToLower(d.Repository)+"#"+fmt.Sprint(d.Number)] { - continue - } - got, err := h.Forge.Pull(d.Repository, int64(d.Number)) - if err == nil && got.Error != "" { - err = errors.New(got.Error) - } - if err == nil && got.Pull == nil { - err = errors.New("the answer names no pull request") - } - if err != nil { - h.Logf("[mesh-delivery] the pull request %s#%d cannot be read at the start: %v", d.Repository, d.Number, err) - failed = append(failed, err) - continue - } - switch got.Pull.State { - case gitseat.PullStateMerged: - err = h.setMerged(d.Repository, d.Number, got.Pull.Base) - case gitseat.PullStateClosed: - err = h.dropUnmerged(d.Repository, d.Number) - } - if err != nil { - failed = append(failed, err) - } - } - return errors.Join(failed...) -} - -// baseOf is the base of a pull request's delivery, and whether the gate keeps one. -func baseOf(all map[string]Delivery, repository string, number int) (string, bool) { - for _, d := range all { - if samePull(d, repository, number) { - return d.Base, true - } - } - return "", false -} - -// carried puts the deliveries of the pull requests a record carries away, once the record holds them with their base: each delivery -// is deleted and the groups put right. A deletion is made in the old section too (§613): the state's keys are the one table. -func (h *Holder) carried(pulls []RecordPull) error { - if h.Kept == nil { - return nil - } - h.dmu.Lock() - defer h.dmu.Unlock() - all, err := h.deliveries() - if err != nil { - return err - } - branches := map[string]bool{} - for k, d := range all { - for _, p := range pulls { - if samePull(d, p.Repository, p.Number) { - if err := h.Kept.Delete(deliveriesState, k); err != nil { - return fmt.Errorf("the delivery %s cannot be deleted: %w", d.ID, err) - } - branches[d.Branch] = true - } - } - } - return h.refreshGroups(branches) -} diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/deliveries_test.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/deliveries_test.go deleted file mode 100644 index ba49f95cf..000000000 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/deliveries_test.go +++ /dev/null @@ -1,245 +0,0 @@ -package main - -import ( - "encoding/json" - "errors" - "fmt" - "sort" - "strings" - "testing" - "time" - - gitseat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git" -) - -// memKept is the gate's states deliveries and groups in memory. -type memKept struct{ m map[string]map[string][]byte } - -func (k *memKept) Keys(state string) ([]string, error) { - var out []string - for key := range k.m[state] { - out = append(out, key) - } - sort.Strings(out) - return out, nil -} -func (k *memKept) Get(state, key string) ([]byte, error) { return k.m[state][key], nil } -func (k *memKept) Put(state, key string, v any) error { - if k.m == nil { - k.m = map[string]map[string][]byte{} - } - if k.m[state] == nil { - k.m[state] = map[string][]byte{} - } - raw, _ := json.Marshal(v) - k.m[state][key] = raw - return nil -} -func (k *memKept) Delete(state, key string) error { delete(k.m[state], key); return nil } - -// fakeForge is the seat git's reads: the open pull requests and each pull request by its number. -type fakeForge struct { - open []gitseat.OpenPull - pulls map[string]gitseat.Pull - heads map[string]string // "@" -> head - // contains says whether commit is in `in`; nil means every commit is in every other (a straight line forward) - contains func(commit, in string) bool - fail bool -} - -func (f *fakeForge) OpenPulls() (gitseat.OpenPullsAnswer, error) { - if f.fail { - return gitseat.OpenPullsAnswer{}, errors.New("the forge is away") - } - return gitseat.OpenPullsAnswer{Pulls: f.open}, nil -} -func (f *fakeForge) Branch(repository, branch string) (gitseat.BranchAnswer, error) { - if f.fail { - return gitseat.BranchAnswer{}, errors.New("the forge is away") - } - head, ok := f.heads[repository+"@"+branch] - if !ok { - return gitseat.BranchAnswer{Error: "no such branch"}, nil - } - return gitseat.BranchAnswer{Branch: branch, Repository: repository, Head: head}, nil -} -func (f *fakeForge) Contains(repository, commit, in string) (bool, error) { - if f.fail { - return false, errors.New("the forge is away") - } - if f.contains == nil { - return true, nil - } - return f.contains(commit, in), nil -} -func (f *fakeForge) Pull(repository string, number int64) (gitseat.PullAnswer, error) { - p, ok := f.pulls[fmt.Sprintf("%s#%d", repository, number)] - if !ok { - return gitseat.PullAnswer{Error: "no such pull request"}, nil - } - return gitseat.PullAnswer{Pull: &p}, nil -} - -func gateWithDeliveries(t *testing.T) (*Holder, *memKept) { - t.Helper() - k := &memKept{} - h := &Holder{Now: func() time.Time { return time.Date(2026, 11, 12, 10, 0, 0, 0, time.UTC) }, Kept: k, Logf: func(string, ...any) {}} - h.Records = &Records{Ledger: newLedgerFake(t), Now: h.Now} - return h, k -} - -func updated(repository string, number int, head, base, branch string) []byte { - raw, _ := json.Marshal(gitseat.PullUpdatedEvent{Repository: repository, Number: int64(number), Head: head, Base: base, Branch: branch}) - return raw -} - -func groupNamed(t *testing.T, h *Holder, id string) []string { - t.Helper() - a := h.Groups(false, id) - if a.Error != "" || len(a.Groups) != 1 { - t.Fatalf("groups %q: %+v", id, a) - } - var out []string - for _, m := range a.Groups[0].Members { - out = append(out, fmt.Sprintf("%s#%d@%s/%s/%s/%v", m.Repository, m.Number, m.Base, m.State, m.Head[:1], m.Open)) - } - return out -} - -// §716, A-279: a group read before any take-in names its members with their base, from the seat git's pull-updated. -func TestAGroupReadBeforeAnyTakeInNamesItsMembersWithTheirBase(t *testing.T) { - h, k := gateWithDeliveries(t) - a, b := strings.Repeat("a", 40), strings.Repeat("b", 40) - for _, body := range [][]byte{updated("novox/app", 3, a, "main", "feat"), updated("novox/lib", 4, b, "beta", "feat")} { - if err := h.PullUpdated(body); err != nil { - t.Fatal(err) - } - } - got := groupNamed(t, h, "feat") - want := []string{"novox/app#3@main/open/a/true", "novox/lib#4@beta/open/b/true"} - if strings.Join(got, " ") != strings.Join(want, " ") { - t.Fatalf("members %v, wanted %v", got, want) - } - if len(k.m[groupsState]) != 1 || len(k.m[deliveriesState]) != 2 { - t.Fatalf("states %v", k.m) - } - // The delivery's key is its id escaped as a key name, with its group set (§42). - var d Delivery - if err := json.Unmarshal(k.m[deliveriesState]["novox/app=40"+strings.Repeat("a", 12)], &d); err != nil || d.Group != "feat" || d.Base != "main" || d.State != "open" || d.Number != 3 { - t.Fatalf("the delivery %+v %v (keys %v)", d, err, k.m[deliveriesState]) - } -} - -// §716: a newer head of the same pull request takes the older's place in its group, and the older key is deleted. -func TestANewerHeadReplacesTheOlder(t *testing.T) { - h, k := gateWithDeliveries(t) - a, b, c := strings.Repeat("a", 40), strings.Repeat("b", 40), strings.Repeat("c", 40) - for _, body := range [][]byte{updated("novox/app", 3, a, "main", "feat"), updated("novox/lib", 4, b, "main", "feat"), updated("novox/app", 3, c, "main", "feat")} { - if err := h.PullUpdated(body); err != nil { - t.Fatal(err) - } - } - got := groupNamed(t, h, "feat") - if strings.Join(got, " ") != "novox/app#3@main/open/c/true novox/lib#4@main/open/b/true" || len(k.m[deliveriesState]) != 2 { - t.Fatalf("members %v, deliveries %d", got, len(k.m[deliveriesState])) - } -} - -// §716: a closed unmerged pull request leaves; a group of one with no member in a record is no group, its key deleted and the -// member's group cleared. -func TestAClosedUnmergedPullRequestLeavesItsGroup(t *testing.T) { - h, k := gateWithDeliveries(t) - a, b := strings.Repeat("a", 40), strings.Repeat("b", 40) - _ = h.PullUpdated(updated("novox/app", 3, a, "main", "feat")) - _ = h.PullUpdated(updated("novox/lib", 4, b, "main", "feat")) - closed, _ := json.Marshal(gitseat.PullClosedEvent{Repository: "novox/lib", Number: 4, Head: b, Base: "main", Branch: "feat"}) - if err := h.DeliveryClosed(closed); err != nil { - t.Fatal(err) - } - if len(k.m[groupsState]) != 0 || len(k.m[deliveriesState]) != 1 { - t.Fatalf("states %v", k.m) - } - for _, raw := range k.m[deliveriesState] { - var d Delivery - _ = json.Unmarshal(raw, &d) - if d.Group != "" || d.Number != 3 { - t.Fatalf("the member of a group of one keeps its group: %+v", d) - } - } -} - -// §716, A-279: the take-in copies the delivery's base onto the record's member and deletes the delivery; the member not taken in stays -// in the group, which names both. -func TestTheTakeInCopiesTheBaseAndKeepsTheRestOfTheGroup(t *testing.T) { - h, k := gateWithDeliveries(t) - merge := strings.Repeat("m", 40) - a, b := strings.Repeat("a", 40), strings.Repeat("b", 40) - _ = h.PullUpdated(updated("novox/app", 3, a, "main", "feat")) - _ = h.PullUpdated(updated("novox/lib", 4, b, "beta", "feat")) - merged, _ := json.Marshal(gitseat.PullMergedEvent{Repository: "novox/app", Number: 3, Head: a, Base: "main", Branch: "feat", MergeCommit: merge}) - if err := h.DeliveryMerged(merged); err != nil { - t.Fatal(err) - } - if got := groupNamed(t, h, "feat"); got[0] != "novox/app#3@main/merged/a/false" { - t.Fatalf("a merged member before its take-in: %v", got) - } - body := json.RawMessage(`{"v":1,"kind":"taken","key":"g.feat","what":"group","group":"feat","branch":"main","source":7,` + - `"merges":[{"repository":"novox/app","number":3,"merge":"` + merge + `"}],` + - `"entries":[{"module":"app","commit":"` + merge + `","fingerprint":"f","repository":"novox/app","pull":3}],"since":"2026-11-12T09:00:00Z"}`) - for i := 0; i < 2; i++ { // heard again: the base the record holds stays - if err := h.TakenIn(body); err != nil { - t.Fatal(err) - } - } - kept, _ := h.Records.Kept() - if len(kept) != 1 || kept[0].Group == nil || len(kept[0].Group.Pulls) != 1 || kept[0].Group.Pulls[0].Base != "main" { - t.Fatalf("the record's member lacks its base: %+v", kept) - } - if len(k.m[deliveriesState]) != 1 || len(k.m[groupsState]) != 1 { - t.Fatalf("states after the take-in: %v", k.m) - } - got := groupNamed(t, h, "feat") - if strings.Join(got, " ") != "novox/app#3@main/merged/m/false novox/lib#4@beta/open/b/true" && strings.Join(got, " ") != "novox/app#3@main/merged/a/false novox/lib#4@beta/open/b/true" { - t.Fatalf("members %v", got) - } -} - -// §716: a missed event is put right at the start: an open pull request the gate lacks is written, one kept at another head is -// replaced, and a kept delivery the answer does not name is read: merged is set, closed is deleted; a read that fails is -// said and left. -func TestAMissedEventIsPutRightAtStart(t *testing.T) { - h, k := gateWithDeliveries(t) - a, a2, b, c, d := strings.Repeat("a", 40), strings.Repeat("1", 40), strings.Repeat("b", 40), strings.Repeat("c", 40), strings.Repeat("d", 40) - _ = h.PullUpdated(updated("novox/app", 3, a, "main", "feat")) - _ = h.PullUpdated(updated("novox/gone", 5, c, "main", "feat")) - _ = h.PullUpdated(updated("novox/done", 6, d, "main", "feat")) - _ = h.PullUpdated(updated("novox/away", 7, d, "main", "other")) - h.Forge = &fakeForge{ - open: []gitseat.OpenPull{ - {Pull: gitseat.Pull{Repository: "novox/app", Number: 3, Head: a2, Base: "main", Branch: "feat"}}, - {Pull: gitseat.Pull{Repository: "novox/lib", Number: 4, Head: b, Base: "beta", Branch: "feat"}}}, - pulls: map[string]gitseat.Pull{ - "novox/gone#5": {Repository: "novox/gone", Number: 5, State: gitseat.PullStateClosed, Base: "main"}, - "novox/done#6": {Repository: "novox/done", Number: 6, State: gitseat.PullStateMerged, Base: "main"}}, - } - err := h.ReadForge() - if err == nil || !strings.Contains(err.Error(), "no such pull request") { - t.Fatalf("a pull request the forge does not know is said: %v", err) - } - all, _ := h.deliveries() - got := map[string]string{} - for _, d := range all { - got[fmt.Sprintf("%s#%d", d.Repository, d.Number)] = d.Commit[:1] + "/" + d.State + "/" + d.Base - } - want := map[string]string{"novox/app#3": "1/open/main", "novox/lib#4": "b/open/beta", "novox/done#6": "d/merged/main", "novox/away#7": "d/open/main"} - if fmt.Sprint(got) != fmt.Sprint(want) { - t.Fatalf("deliveries %v, wanted %v", got, want) - } - if len(k.m[groupsState]) != 1 { - t.Fatalf("groups %v", k.m[groupsState]) - } - h.Forge = &fakeForge{fail: true} - if err := h.ReadForge(); err == nil { - t.Fatal("a forge that cannot be read is said") - } -} diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/findings.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/findings.go index b5b1678f0..c769e9a4b 100644 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/findings.go +++ b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/findings.go @@ -4,7 +4,6 @@ import ( "context" "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/views" ) @@ -15,17 +14,8 @@ import ( // 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" -) - -// pullMergedEvent and pullClosedEvent are the seat git's events that end a pull request, as the gate's manifest consumes them. -var ( - pullUpdatedEvent = declared(gitseat.EventPullUpdated) - pullMergedEvent = declared(gitseat.EventPullMerged) - pullClosedEvent = declared(gitseat.EventPullClosed) -) +// FindingScope is the scope of the gate's findings (A-42: the scope the mesh already uses for the delivery's findings). +const FindingScope = "delivery" // FindingWriter is what the gate holds of the one held writer (views.NewStdioHeldWriter over its state `findings`). type FindingWriter interface { diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/gate.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/gate.go index 7522e6dc9..4c129bb92 100644 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/gate.go +++ b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/gate.go @@ -20,13 +20,11 @@ type Holder struct { Settings func() Settings Now func() time.Time Logf func(format string, a ...any) - // Kept is the gate's states deliveries and groups, and Forge the seat git's reads (deliveries.go, §716). - Kept DeliveryStore + // Forge is the seat git's reads (sourcestart.go). Forge ForgeReads // Catalog reads the seat mesh-catalog's registrations (sourcestart.go); startMu keeps one start of the sources at a time. Catalog Registered startMu sync.Mutex - dmu sync.Mutex Source SourceStore // Owed says what the gate owes the forge as the seat's event owed (owed.go). Owed OwedSayer diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/keeps.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/keeps.go index 7991c8974..d5f3a20db 100644 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/keeps.go +++ b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/keeps.go @@ -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: "source", Readable: true}} +var Kept = []announce.State{{Name: "conditions"}, {Name: "findings"}, {Name: "source", Readable: true}} // announceKept says Kept through keeps, which is stdio.Keeps. func announceKept(keeps func(...announce.State) error) error { return keeps(Kept...) } diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/keeps_test.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/keeps_test.go index 79bddbc3f..59cced012 100644 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/keeps_test.go +++ b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/keeps_test.go @@ -68,9 +68,8 @@ func TestTheStatesTheModuleAnnouncesAreTheStatesItsManifestDeclares(t *testing.T } } -// 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). +// Design 47 G §613 (A-20): conditions is a `requires` entry of the template `state` under its local name, taking the +// bucket it already had; source stays in the old `state` section; merges, the old owed, deliveries and groups go (design 47 H §764). func TestTheFourStatesMoveToTheTemplateAndTwoStayOld(t *testing.T) { raw, err := os.ReadFile(filepath.Join("..", "..", "module.json")) if err != nil { @@ -91,7 +90,7 @@ func TestTheFourStatesMoveToTheTemplateAndTwoStayOld(t *testing.T) { } old := string(raw[strings.Index(string(raw), `"state": [`):]) old = old[:strings.Index(old, "]")] - for _, n := range []string{"deliveries", "groups", "conditions"} { + for _, n := range []string{"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+`"`)) } diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/main.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/main.go index 66ea8c028..df8d272b5 100644 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/main.go +++ b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/main.go @@ -32,7 +32,7 @@ func (l *listening) get() string { l.mu.Lock(); defer l.mu.Unlock(); return l.n // The events this owner follows: the forge bridge's word on an act owed, and the step events the delivery records are built // from (consumer.go). -var followed = append(append([]string{owedEndedEvent}, stepPatterns()...), pullUpdatedEvent, pullMergedEvent, pullClosedEvent, registrationChangedEvent, forgeMergedEvent) +var followed = append(append([]string{owedEndedEvent}, stepPatterns()...), registrationChangedEvent, forgeMergedEvent) func main() { settingsFile := os.Getenv("MESH_DELIVERY_GATE_SETTINGS") @@ -64,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.Kept = kvKept{} h.Forge = seatGit{ask: stdio.Ask} h.Catalog = seatCatalog{ask: stdio.Ask} h.Consumer = &StepConsumer{Records: h.Records, Families: stepFamilies, Now: h.Now, Logf: logf, Taken: h.TakenIn} @@ -122,10 +121,6 @@ func run(h *Holder, l *listening) { logf("[mesh-delivery] the sources were not all compared with the forge's heads: %v", err) } }() - // A missed pull event is put right from the forge's own record, once at each start (§716). - if err := h.ReadForge(); err != nil { - logf("[mesh-delivery] the open pull requests were not read from the forge, they are read again at the next start: %v", err) - } } // statePins says every pin the records hold once at each start (design 47 G §579), retrying until it can. @@ -157,12 +152,6 @@ func take(h *Holder, e stdio.Envelope) error { if e.Key == owedEndedEvent { return h.OwedEnded(e.Body) } - if e.Key == pullUpdatedEvent { - return h.PullUpdated(e.Body) - } - if e.Key == pullMergedEvent { - return h.DeliveryMerged(e.Body) - } if e.Key == registrationChangedEvent { _, err := h.StartSources() return err @@ -170,9 +159,6 @@ func take(h *Holder, e stdio.Envelope) error { if forgeMergedEvent != "" && stdio.TopicMatches(forgeMergedEvent, e.Key) { return h.ForgeMerged(e.Body) } - if e.Key == pullClosedEvent { - return h.DeliveryClosed(e.Body) - } return nil } diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/manifest_test.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/manifest_test.go index beaa20794..b0542e949 100644 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/manifest_test.go +++ b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/manifest_test.go @@ -9,6 +9,7 @@ import ( "sort" "strings" "testing" + "time" "git.novox.be/novox/mesh-contracts/health-and-repair/go/seats/meshconditions" "git.novox.be/novox/mesh-sdk/go/buscalls" @@ -150,10 +151,9 @@ func TestItClaimsTheDeliverySeatAndFollowsWhatItHandles(t *testing.T) { } } } - // A-30: the events its held writer says are declared in the manifest, and the two events that clear its finding are consumed. - if !strings.Contains(raw, `"finding-written.*"`) || !strings.Contains(raw, `"finding-cleared.*"`) || !strings.Contains(raw, `"findings-stated.*"`) || - pullMergedEvent == "" || pullClosedEvent == "" || pullUpdatedEvent == "" { - t.Fatalf("the finding events are not declared, or the pull events not consumed: %q %q", pullMergedEvent, pullClosedEvent) + // A-30: the events its held writer says are declared in the manifest. + if !strings.Contains(raw, `"finding-written.*"`) || !strings.Contains(raw, `"finding-cleared.*"`) || !strings.Contains(raw, `"findings-stated.*"`) { + t.Fatal("the finding events are not declared") } if !reflect.DeepEqual(m.Emits, []string{"transition"}) { // `group` and `merged` go with the merge states (§431) t.Fatalf("emits %v", m.Emits) @@ -184,7 +184,7 @@ func TestItClaimsTheDeliverySeatAndFollowsWhatItHandles(t *testing.T) { } // It calls no controller verb and no forge verb: the forge's reads and writes are the bridge's (ADR 0437 §8; design 47 §592). // It uses operator-channel only to say its conditions (ADR 0437 §9, issue 1275): the teller asks no more (§431). - want := []string{"seat:git.branch", "seat:git.open-pulls", "seat:git.pull", "seat:mesh-catalog.registrations", "seat:mesh-hand-acts.hand-act", WantsEntryVerb, EngineCompositionVerb} + want := []string{"seat:git.branch", "seat:mesh-catalog.registrations", "seat:mesh-hand-acts.hand-act", WantsEntryVerb, EngineCompositionVerb} if !reflect.DeepEqual(m.Uses, []string{"operator-channel"}) { t.Fatalf("uses %v: operator-channel, for its conditions alone", m.Uses) } @@ -343,3 +343,37 @@ func TestTheEarlierModelsStatesAndApprovalAreGone(t *testing.T) { } } } + +// GATE-2/AC2 (design 47 H §764): the per-pull-request model goes: the gate consumes no pull request event, keeps no +// `deliveries` or `groups`, reads no open pull request, and `deliveries` and `show` answer from the +// records alone. +func TestTheGroupsFromBranchNamesAreGone(t *testing.T) { + m, _ := readManifest(t) + for _, c := range m.Consumes { + if strings.HasPrefix(c, "git.pull-") { + t.Errorf("the manifest consumes %s", c) + } + } + for _, n := range []string{"deliveries", "groups"} { + if slices.Contains(m.withTemplateStates(), n) { + t.Errorf("the manifest still keeps %s", n) + } + } + for _, v := range []string{"seat:git.open-pulls", "seat:git.pull"} { + if slices.Contains(m.Invokes, v) { + t.Errorf("the manifest still invokes %s", v) + } + } + h := &Holder{Now: func() time.Time { return time.Date(2026, 11, 20, 10, 0, 0, 0, time.UTC) }, Logf: func(string, ...any) {}} + h.Records = &Records{Ledger: newLedgerFake(t), Now: h.Now} + if _, _, err := h.Records.Open("main.7", map[string]string{"novox/app#3": strings.Repeat("a", 40)}, false); err != nil { + t.Fatal(err) + } + d, err := h.Deliveries("", "", "", true) + if err != nil || len(d["deliveries"].([]recordView)) != 1 { + t.Fatalf("deliveries from the records: %v %v", d, err) + } + if s, err := h.Show("main.7"); err != nil || len(s.(map[string]any)["records"].([]recordView)) != 1 { + t.Fatalf("show from the records: %v %v", s, err) + } +} diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/sourcestart.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/sourcestart.go index 20341b06c..2d559de34 100644 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/sourcestart.go +++ b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/sourcestart.go @@ -50,6 +50,32 @@ func (s seatCatalog) Registrations() (meshcatalog.RegistrationsAnswer, error) { } // Branch is the seat git's verb branch: a repository's branch head. +// ForgeReads is what the gate reads of the seat git. +type ForgeReads interface { + // Branch is a repository branch's head (the seat git's verb branch). + Branch(repository, branch string) (gitseat.BranchAnswer, error) + // Contains is whether commit is in (or is) the commit in (the seat git's verb contains). + Contains(repository, commit, in string) (bool, error) +} + +// seatGit reads the seat git through the tool runner. +type seatGit struct{ ask asking } + +func (s seatGit) call(verb string, in any, out any) error { + raw, err := s.ask("seat:"+gitseat.Seat+"."+verb, in) + if err != nil { + return err + } + answer, said, ok := answerOf(raw) + if !ok { + return fmt.Errorf("%s refused: %s", verb, lastLine(said)) + } + if err := json.Unmarshal(answer, out); err != nil { + return fmt.Errorf("the answer of %s is not readable: %w", verb, err) + } + return nil +} + func (s seatGit) Branch(repository, branch string) (gitseat.BranchAnswer, error) { var a gitseat.BranchAnswer return a, s.call(gitseat.VerbBranch, gitseat.BranchInput{Repository: repository, Branch: branch}, &a) diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/sourcetools_test.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/sourcetools_test.go index d181be618..6968dee4e 100644 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/sourcetools_test.go +++ b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/sourcetools_test.go @@ -9,6 +9,7 @@ import ( "testing" "time" + gitseat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/git" 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" @@ -310,3 +311,31 @@ func (f *flakyCatalog) Registrations() (meshcatalog.RegistrationsAnswer, error) } return f.fakeCatalog.Registrations() } + +// fakeForge is the seat git's reads: a branch's head and whether one commit is in another. +type fakeForge struct { + heads map[string]string // "@" -> head + // contains says whether commit is in `in`; nil means every commit is in every other (a straight line forward) + contains func(commit, in string) bool + fail bool +} + +func (f *fakeForge) Branch(repository, branch string) (gitseat.BranchAnswer, error) { + if f.fail { + return gitseat.BranchAnswer{}, errors.New("the forge is away") + } + head, ok := f.heads[repository+"@"+branch] + if !ok { + return gitseat.BranchAnswer{Error: "no such branch"}, nil + } + return gitseat.BranchAnswer{Branch: branch, Repository: repository, Head: head}, nil +} +func (f *fakeForge) Contains(repository, commit, in string) (bool, error) { + if f.fail { + return false, errors.New("the forge is away") + } + if f.contains == nil { + return true, nil + } + return f.contains(commit, in), nil +} diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/takenin.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/takenin.go index 11fd7131a..15619be8a 100644 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/takenin.go +++ b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/takenin.go @@ -5,6 +5,7 @@ import ( "fmt" "sort" "strconv" + "strings" mdc "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshdeliveryclient" meshcatalog "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog" @@ -59,41 +60,21 @@ func (h *Holder) TakenIn(body json.RawMessage) error { g.Members = append(g.Members, mdc.ApprovedKey(e.Repository, int(e.Pull))) } sort.Strings(g.Members) - // §716: each member's base is copied from its delivery onto the record's member; a record that holds the member already - // (a take-in heard again, its delivery deleted) keeps the base it holds. - var kept map[string]Delivery - if h.Kept != nil { - h.dmu.Lock() - kept, err = h.deliveries() - h.dmu.Unlock() - if err != nil { - return err - } - } for _, m := range t.Merges { p := RecordPull{Repository: m.Repository, Number: int(m.Number), Head: heads[mdc.ApprovedKey(m.Repository, int(m.Number))], State: string(mdc.MergeMerged), Commit: m.Merge} - if base, ok := baseOf(kept, m.Repository, int(m.Number)); ok { - p.Base = base - } else if r.Group != nil { + if r.Group != nil { for _, o := range r.Group.Pulls { - if samePull(Delivery{Repository: o.Repository, Number: o.Number}, m.Repository, int(m.Number)) { + if strings.EqualFold(o.Repository, m.Repository) && o.Number == int(m.Number) { p.Base = o.Base } } } - if p.Base == "" && h.Kept != nil && h.Logf != nil { - h.Logf("[mesh-delivery] the take-in of %s names no delivery of %s#%d: its base is not known, the take-in's branch is %s", t.Group, m.Repository, m.Number, t.Branch) - } g.Pulls = append(g.Pulls, p) } if err := h.Records.SetGroup(r, g); err != nil { return err } - // The record that carries the members now holds their bases: their deliveries, and a group no member of which remains outside a record, go. - if err := h.carried(g.Pulls); err != nil { - return err - } } return h.moveSource(t) } diff --git a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/verbs.go b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/verbs.go index 52e21c370..2d84649dc 100644 --- a/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/verbs.go +++ b/modules/mesh-delivery-gate/cmd/mesh-delivery-gate/verbs.go @@ -164,7 +164,7 @@ func (h *Holder) Show(id string) (any, error) { return map[string]any{"records": out}, nil } -// Groups is the seat's verb groups: every record's group not ended (all: those that ended too), or with only that group +// Groups is the seat's verb groups, from the records alone until the seat's definition drops it (design 47 H §764): every record's group not ended (all: those that ended too), or with only that group // alone, ended or not, and none for a group it does not know. Each with its members, its state, why, and the acts the gate said // for it with the outcome recorded in the record (owedended.go). func (h *Holder) Groups(all bool, only string) seat.GroupsAnswer { @@ -185,74 +185,10 @@ func (h *Holder) Groups(all bool, only string) seat.GroupsAnswer { } out.Groups = append(out.Groups, g) } - if err := h.addKeptMembers(&out, kept, all, only); err != nil { - return seat.GroupsAnswer{Error: err.Error()} - } sort.SliceStable(out.Groups, func(i, j int) bool { return out.Groups[i].ID < out.Groups[j].ID }) return out } -// memberOf is a pull request as one key: the repository in lower case and the number. -func memberOf(repository string, number int64) string { - return fmt.Sprintf("%s#%d", strings.ToLower(repository), number) -} - -// addKeptMembers answers a group from its records and its key in the state `groups` together, each member once, a record's first -// (§716, A-279): the members of a group the gate keeps and no record carries, with their delivery's base, head, state and open -// while not merged, so before any take-in the verb names every member and its base. A group only its key holds is open. -func (h *Holder) addKeptMembers(out *seat.GroupsAnswer, kept []*Record, all bool, only string) error { - if h.Kept == nil { - return nil - } - groups, err := h.keptGroups() - if err != nil { - return err - } - deliveries, err := h.deliveries() - if err != nil { - return err - } - carried := map[string]map[string]bool{} - for _, r := range kept { - id := groupOf(r) - if carried[id] == nil { - carried[id] = map[string]bool{} - } - for _, m := range membersOf(r) { - carried[id][memberOf(m.Repository, m.Number)] = true - } - } - for _, kg := range groups { - if only != "" && kg.Group != only { - continue - } - var add []seat.Member - for _, d := range deliveries { - if d.Branch != kg.Group || carried[kg.Group][memberOf(d.Repository, int64(d.Number))] { - continue - } - add = append(add, seat.Member{ID: d.ID, Repository: d.Repository, State: d.openOrMerged(), Number: int64(d.Number), Head: d.Commit, - Open: d.openOrMerged() != deliveryMerged, Base: d.Base}) - } - if len(add) == 0 { - continue - } - sort.Slice(add, func(i, j int) bool { return add[i].ID < add[j].ID }) - placed := false - for i := range out.Groups { - if out.Groups[i].ID == kg.Group { - out.Groups[i].Members = append(out.Groups[i].Members, add...) - placed = true - } - } - if !placed { - out.Groups = append(out.Groups, seat.Group{ID: kg.Group, State: stateOpen, Members: add, Acts: []seat.Act{}, - Why: "its pull requests are not taken in yet"}) - } - } - return nil -} - // recordedActs are the acts a record holds, each with its outcome when the forge bridge said one, ordered by id. func recordedActs(r *Record) []seat.Act { out := []seat.Act{} diff --git a/modules/mesh-delivery-gate/module.json b/modules/mesh-delivery-gate/module.json index 75af30f9a..1ac0100fd 100644 --- a/modules/mesh-delivery-gate/module.json +++ b/modules/mesh-delivery-gate/module.json @@ -19,9 +19,6 @@ "consumes": [ "mesh-delivery-forge-bridge.owed.ended", "mesh-delivery-indexer.take-in.taken", - "git.pull-updated", - "git.pull-merged", - "git.pull-closed", "mesh-catalog.registration-changed", "mesh-delivery-forge-bridge.forge.*.*.merged", "mesh-conditions.findings-asked" @@ -285,16 +282,6 @@ } ] }, - { - "name": "deliveries", - "storage": "key-value", - "template": "state" - }, - { - "name": "groups", - "storage": "key-value", - "template": "state" - }, { "name": "conditions", "storage": "key-value", @@ -325,8 +312,6 @@ }, "invokes": [ "seat:git.branch", - "seat:git.open-pulls", - "seat:git.pull", "seat:mesh-catalog.registrations", "seat:mesh-hand-acts.hand-act", "seat:mesh-wants.entry",