// Command mesh-delivery-forge-bridge-tools serves the forge bridge's tools (novox/hq ADR 0633 §4, issue 1585; design 51): // the runtime launches it for a call. bridge_tags reads a package's git tags through the seat git's verb tags, for the // builder's floor. bridge_groups reads the delivery groups the gate holds and what the bridge kept of their ends; // bridge_group_end_again writes an ask into the bridge's state end-asks and waits for the bridge's answer there, since the // bridge is the other program and serves no request subject (ADR 0437 §4). package main import ( "context" "encoding/json" "fmt" "os" "strings" "sync" "time" "git.novox.be/novox/mesh-contracts/health-and-repair/go/clients/meshhandactsclient" seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshdelivery" stdio "git.novox.be/novox/mesh-sdk/go" "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg" "mesh-delivery-forge-bridge/internal/bridge" "mesh-delivery-forge-bridge/internal/groups" ) // Tool names. const ( GroupsTool = "bridge_groups" EndAgainTool = "bridge_group_end_again" // MergedTool answers the merged message of a merge on request (issue 1585). MergedTool = "bridge_merged_message" ) // asker writes an end-asks value and waits for the bridge's answer to it. type asker func(key string, value []byte) (groups.EndAsk, error) // Tools are the bridge's tools: groupsRead reads the seat mesh-delivery's groups with what the bridge kept of them. func Tools(ask asker, now func() time.Time, groupsRead func() ([]groups.Row, []string, error), merged func(repository, merge string, number int) (json.RawMessage, error), forge bridge.Caller) []stdio.Tool { str := func(args map[string]any, k string) string { s, _ := args[k].(string); return strings.TrimSpace(s) } return []stdio.Tool{ {Name: bridge.TagsTool, Description: "A package's git tags on the forge, for the builder's floor (design 51): every tag of repository whose name starts " + "with prefix (go/v for a Go package in the go directory, v for one at the root), sorted. Read-only; read through the seat " + "git's verb tags, at most " + fmt.Sprint(bridge.TagsMaxPages) + " pages (more says so).", Input: map[string]any{"type": "object", "required": []string{"repository"}, "properties": map[string]any{ "repository": map[string]any{"type": "string", "description": "/"}, "prefix": map[string]any{"type": "string", "description": "only tags starting with it"}}}, Run: func(args map[string]any) (any, error) { return bridge.Tags(context.Background(), forge, str(args, "repository"), str(args, "prefix")) }}, {Name: MergedTool, Description: "The merged message of one merge, asked again (issue 1585): the message the bridge wrote on its stream FORGE when the " + "pull request was merged into the trunk, built the same way from the forge (the merge commit's trees and the manifests " + "and lock files of its module directories), the pull request's number, branch and head from the seat git's verb pull, and " + "for a delivery group's member its group and members from the seat mesh-delivery's verb groups. For the indexer, which asks it when it takes in a held merge it does not hold in memory (a restart, a new " + "build), and the ask-again a lost message lacked. About 0.5 MB for a repository of many modules. Answers {message} " + "with the forge message whole, or why it cannot: the forge gives no merged pull request with that commit, or a seat did not answer. " + "A merge made on the forge (a recovery merge, the operator's own) is read the same way.", Input: map[string]any{"type": "object", "required": []string{"repository", "merge"}, "properties": map[string]any{ "repository": map[string]any{"type": "string", "description": "the repository, owner/name, as the forge names it"}, "merge": map[string]any{"type": "string", "description": "the merge commit, 40 hex digits"}, "number": map[string]any{"type": "integer", "description": "the pull request's number, when known: the bridge reads that pull request and checks its merge commit"}}}, Run: func(args map[string]any) (any, error) { number, _ := args["number"].(float64) raw, err := merged(str(args, "repository"), str(args, "merge"), int(number)) if err != nil { return nil, err } return map[string]any{"message": raw}, nil }}, {Name: GroupsTool, Description: "The delivery groups the seat mesh-delivery's verb groups answers (more than one member), each with its members' delivery " + "state and whether each merged message is written on the forge stream (with the merge commit it named), and whether the " + "group's end (forge.group.merged) is written: ended, or open with why (gathered, or every message written and its end " + "not written yet). An open group with every member's message written is " + "what bridge_group_end_again says the end of. Each group names its last end ask (who, why, when) and the bridge's " + "answer to it, from the state end-asks. A group's name narrows it to that group; open lists only open ones.", Input: map[string]any{"type": "object", "properties": map[string]any{ "group": map[string]any{"type": "string", "description": "only this group, by its id (its branch)"}, "open": map[string]any{"type": "boolean", "description": "only the groups whose end is not written"}}}, Run: func(args map[string]any) (any, error) { rows, unread, err := groupsRead() if err != nil { return nil, err } only, _ := args["open"].(bool) group := str(args, "group") kept := rows[:0] for _, r := range rows { if (group != "" && r.Group != group) || (only && !r.Open) { continue } kept = append(kept, r) } return map[string]any{"groups": kept, "unread": unread}, nil }}, {Name: EndAgainTool, Description: "Say a delivery group's end (forge.group.merged) again, by hand, for a group whose end the indexer did not take " + "in (a group bridge_groups names as merged with its end not written, or one the indexer waits for). The bridge " + "writes it again from the seat mesh-delivery's groups, with the time appended to the message id so the stream does not drop it as " + "a duplicate; the indexer takes an end for a group it already took in without changing anything. Refused while " + "a member's merged message is not written. Answers whether it was written.", Input: map[string]any{"type": "object", "required": []string{"group", "base"}, "properties": map[string]any{ "group": map[string]any{"type": "string", "description": "the group, by its id (its branch)"}, "base": map[string]any{"type": "string", "description": "the watched branch its members merged into, whose end is said again"}, "why": map[string]any{"type": "string", "description": "why its end is said again, in plain words"}}}, Run: func(args map[string]any) (any, error) { key, value, err := groups.NewEndAsk(str(args, "group"), str(args, "base"), str(args, "why"), stdio.CallerOf(args), now()) if err != nil { return nil, err } a, err := ask(key, value) if err != nil { return nil, err } return map[string]any{"group": a.Group, "base": a.Base, "written": a.Written, "answer": a.Answer, "by": a.By, "why": a.Why}, nil }}, } } // MergedOf is the merged message of the merge of repository at commit merge, as the bridge writes it: the pull request's // number, branch and head through the seat git's verb pull (by number when given, else by the merge commit; a merge made // on the forge is read the same way), the rest from the forge through trees and files (bridge.MergedMessage), and, for a // member of a delivery group the seat mesh-delivery names (of), the group and its members as the process sets them. func MergedOf(groupOf func(id string) ([]seat.Group, error), repository, merge string, number int, trees bridge.Trees, files bridge.Files, forge bridge.Caller) (json.RawMessage, error) { owner, repo, ok := strings.Cut(repository, "/") if !ok || owner == "" || repo == "" { return nil, fmt.Errorf("%q is not owner/name", repository) } fp, err := bridge.ForgeMade(context.Background(), forge, owner, repo, number, merge) if err != nil { return nil, fmt.Errorf("the forge gives no merged pull request of %s with the commit %s: %w", repository, merge, err) } msg, err := bridge.MergedMessage(owner, repo, fp.Number, fp.Branch, fp.Head, merge, fp.Base, trees, files) if err != nil { return nil, fmt.Errorf("the merged message of %s at %s cannot be built: %w", repository, merge, err) } f, err := forgemsg.DecodeForge(msg.Data) if err != nil { return nil, err } of, err := groupOf(f.Branch) // the one group the pull request's branch names, never the whole list if err != nil { return nil, err } if g, ok := groups.Named(of, f.Branch, f.Repository, f.Number); ok { f.Group, f.Members = g.ID, groups.MembersOf(g) } return forgemsg.EncodeForge(f) } // read is the groups the seat mesh-delivery answers with what the bridge kept of them: the merged messages written and // their ends in performed, and the last ask of each in end-asks with the bridge's answer. func read(of []seat.Group, performed, asks stdio.KeptState) ([]groups.Row, []string, error) { pkeys, err := performed.Keys() if err != nil { return nil, nil, fmt.Errorf("the bridge's performed state cannot be listed: %w", err) } published, ended := map[string]string{}, map[string]string{} for _, k := range pkeys { into := ended switch { case strings.HasPrefix(k, "published."): into = published case !strings.HasPrefix(k, "groups."): continue } if e, err := performed.Get(k); err == nil && e != nil { into[k] = strings.TrimSpace(string(e.Value)) } } akeys, err := asks.Keys() if err != nil { return nil, nil, fmt.Errorf("the bridge's state %s cannot be listed: %w", groups.EndAsksState, err) } askRaws := map[string][]byte{} for _, k := range akeys { if e, err := asks.Get(k); err == nil && e != nil { askRaws[k] = e.Value } } rows, unread := groups.Rows(of, published, ended, askRaws) return rows, unread, nil } // askEnd writes the end-asks value at key and waits at most bound for the bridge's answer. func askEnd(s stdio.KeptState, module string, bound time.Duration) asker { wait := askState(s, groups.EndAsksBucket(module), bound, func(v []byte) bool { a, err := groups.DecodeEndAsk(v); return err == nil && a.Done() }) return func(key string, value []byte) (groups.EndAsk, error) { v, err := wait(key, value) if err != nil { return groups.EndAsk{}, err } return groups.DecodeEndAsk(v) } } // askState writes an ask's value at key of the state s (its bucket named bucket) and waits, on a watch of the key, at most // bound for the bridge's answer, a later value that done says is answered. func askState(s stdio.KeptState, bucket string, bound time.Duration, done func([]byte) bool) func(key string, value []byte) ([]byte, error) { return func(key string, value []byte) ([]byte, error) { answered := make(chan []byte, 1) var rev uint64 var mu sync.Mutex take := func(revision uint64, v []byte) { mu.Lock() mine := rev mu.Unlock() if mine == 0 || revision <= mine || !done(v) { return } select { case answered <- v: default: } } if err := s.Watch(key, func(c stdio.StateChange) error { if c.Op == "put" { take(c.Revision, c.Value) } return nil }); err != nil { return nil, fmt.Errorf("watching %s.%s: %w", bucket, key, err) } r, err := s.Put(key, json.RawMessage(value)) if err != nil { return nil, fmt.Errorf("the ask could not be written to %s: %w", bucket, err) } mu.Lock() rev = r mu.Unlock() if e, err := s.Get(key); err == nil && e != nil { take(e.Revision, e.Value) } wait, cancel := context.WithTimeout(context.Background(), bound) // a context's bound, no timer (ADR 0437 §8) defer cancel() select { case v := <-answered: return v, nil case <-wait.Done(): return nil, fmt.Errorf("the bridge did not answer within %s: its answer will be in %s.%s", bound, bucket, key) } } } // askCaller calls a tool as this bundle's module, through the runtime (stdio.Ask), the module's own invokes granting it. func askCaller(_ context.Context, key string, body any) (json.RawMessage, error) { return stdio.Ask(key, body) } func main() { // The module the runtime serves these tools as: the bridge's, whose states they ask (design 47 G A-296). served := os.Getenv(stdio.ServedAs) performed, asks := stdio.State(groups.PerformedState), stdio.State(groups.EndAsksState) tools := Tools(askEnd(asks, served, 25*time.Second), time.Now, func() ([]groups.Row, []string, error) { of, err := groups.ReadAll(context.Background(), askCaller) if err != nil { return nil, nil, err } return read(of, performed, asks) }, func(repository, merge string, number int) (json.RawMessage, error) { ctx := context.Background() return MergedOf(func(id string) ([]seat.Group, error) { return groups.ReadGroup(ctx, askCaller, id) }, repository, merge, number, bridge.TreesVia(ctx, askCaller), bridge.FilesVia(ctx, askCaller), askCaller) }, askCaller) owedAsks := stdio.State(groups.OwedAsksState) recorder := meshhandactsclient.Recorder{Ask: stdio.Ask} tools = append(tools, OwedTools(askState(owedAsks, groups.OwedAsksBucket(served), 25*time.Second, func(v []byte) bool { a, err := groups.DecodeOwedAsk(v) return err == nil && a.Done() }), func() ([]OwedRow, error) { return performedRows(performed) }, func(what, why string) error { _, err := recorder.Record(meshhandactsclient.Request{What: what, Why: why, Cause: "owed-dropped"}) return err }, time.Now)...) if err := stdio.Serve("", tools); err != nil { fmt.Fprintf(os.Stderr, "[mesh-delivery-forge-bridge-tools] %v\n", err) os.Exit(1) } }