Files
cozystack/cmd/backport-batch/github.go
T
Aleksei Sviridkin a3305e8dd3 fix(backport): push and publish nothing once output is lost
backport-batch writes its body, summary, findings and warnings before
it pushes, opens or edits a pull request, closes a batch or posts a
comment. A run that kept going after that output was lost acted on
what nobody read, and a closed pipe was worse: with Go's default
SIGPIPE handling the process died silently mid-run. Lines that confirm
an action after it happened, such as the URL of an opened pull request,
go to stderr, so a lost stderr matters as much as a lost stdout.

A failed write to either stream is kept, and from then on every push and
every GitHub write is refused at the point it would be made: the GitHub
client is wrapped so that each write checks first, and each push checks
before it runs. Once output is lost, the run changes nothing more: no
push, no GitHub write, no local branch move. No new unit starts after
output is lost; a unit already in flight finishes its rollback. A reset
whose own hint, the only way back to the commits it drops, cannot be
written does not run either. The run exits 2 saying the output was lost;
a confirmation lost after an action fails the run too. Such a
confirmation is lost only when stderr itself fails, so a lost
confirmation can only be reported by the exit code. A test holds every
method of the GitHub interface to being a known read or a guarded write.

The tool catches SIGPIPE with signal.Notify, so a closed pipe is a
write error like any other. It does not use signal.Ignore, whose ignored
disposition the git and gh children would inherit across exec; a test
checks that a child still dies of SIGPIPE.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-11-13 12:35:09 +03:00

449 lines
15 KiB
Go

/*
Copyright 2026 The Cozystack Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package main
import (
"encoding/json"
"fmt"
"regexp"
"strconv"
"strings"
)
// openPullsCap is the page size of the open pull request listing. The REST
// listing stops at it in silence, so a full page is an error, not an answer.
const openPullsCap = 100
// recentPullsPage is the page size of the listing of every pull request
// against a line, newest first, and recentPullsPages how many pages of it a
// search for the line's record reads.
const (
recentPullsPage = 100
recentPullsPages = 10
)
// searchResultCap is the most results GitHub search returns for one query,
// however far it is paginated. gh pr list answers a --label filter through
// search, so a listing that long has to be taken as cut short.
const searchResultCap = 1000
// The labels count on a pull request merged into main, the original, and on
// no batch pull request.
const (
labelInclude = "backport/include"
labelSkip = "backport/skip"
)
var (
batchBranchRE = regexp.MustCompile(`^backport-batch/(release-\d+\.\d+)-(\d{8})$`)
loginRE = regexp.MustCompile(`^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?$`)
botLoginRE = regexp.MustCompile(`^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?\[bot\]$`)
pullURLRE = regexp.MustCompile(`^https://[^/\s]+/[^/\s]+/[^/\s]+/pull/([1-9][0-9]{0,8})$`)
)
// batchBotEnv names the GitHub App bot the scheduled batch opens its pull
// requests and comments as, <app slug>[bot]. The workflow sets it from the
// token it mints. Unset, it is defaultBatchBot, so that a maintainer's run by
// hand continues the scheduled batch instead of opening a second one; set and
// empty, no bot is trusted.
const (
batchBotEnv = "BACKPORT_BATCH_BOT"
defaultBatchBot = "cozystack-ci[bot]"
)
// batchBotLogin is the bot to trust given lookup, os.LookupEnv outside tests.
func batchBotLogin(lookup func(string) (string, bool)) string {
if v, ok := lookup(batchBotEnv); ok {
return v
}
return defaultBatchBot
}
// pullRequest is the REST view of a pull request: unlike gh pr list, it
// carries the author's association with the repository.
type pullRequest struct {
Number int `json:"number"`
HTMLURL string `json:"html_url"`
Body string `json:"body"`
State string `json:"state"`
MergedAt *string `json:"merged_at"`
AuthorAssociation string `json:"author_association"`
User struct {
Login string `json:"login"`
Type string `json:"type"`
} `json:"user"`
Head struct {
Ref string `json:"ref"`
SHA string `json:"sha"`
Repo *struct {
FullName string `json:"full_name"`
} `json:"repo"`
} `json:"head"`
Base struct {
Ref string `json:"ref"`
Repo struct {
FullName string `json:"full_name"`
} `json:"repo"`
} `json:"base"`
}
// issueComment is the REST view of a comment on a pull request.
type issueComment struct {
ID int64 `json:"id"`
Body string `json:"body"`
User struct {
Login string `json:"login"`
Type string `json:"type"`
} `json:"user"`
}
// github is the part of GitHub the tool talks to: gh outside tests.
type github interface {
openPulls(base string) ([]pullRequest, error)
// recentPulls is one page of every pull request against base, open,
// merged or closed, newest first.
recentPulls(base string, page int) ([]pullRequest, error)
// permission is login's permission on the repository as GitHub's
// legacy field gives it: admin, write, read or none.
permission(login string) (string, error)
// labelled lists the pull requests merged into main that carry label.
labelled(label string) ([]int, error)
// pull reads one pull request as it is now.
pull(number int) (pullRequest, error)
// createPull opens the draft and returns its number and URL.
createPull(base, head, title, bodyFile string) (int, string, error)
editPull(number int, title, bodyFile string) error
// editBody replaces the body of pull request number and nothing else.
editBody(number int, bodyFile string) error
closePull(number int) error
comments(number int) ([]issueComment, error)
createComment(number int, bodyFile string) error
editComment(id int64, bodyFile string) error
// batchBot is the bot the batch writes as, from batchBotEnv, or "".
batchBot() string
}
// guardedGitHub refuses every GitHub write once the run's output was lost.
type guardedGitHub struct {
github
a *app
}
func (g guardedGitHub) createPull(base, head, title, bodyFile string) (int, string, error) {
if err := g.a.mayAct(); err != nil {
return 0, "", err
}
return g.github.createPull(base, head, title, bodyFile)
}
func (g guardedGitHub) editPull(number int, title, bodyFile string) error {
if err := g.a.mayAct(); err != nil {
return err
}
return g.github.editPull(number, title, bodyFile)
}
func (g guardedGitHub) editBody(number int, bodyFile string) error {
if err := g.a.mayAct(); err != nil {
return err
}
return g.github.editBody(number, bodyFile)
}
func (g guardedGitHub) closePull(number int) error {
if err := g.a.mayAct(); err != nil {
return err
}
return g.github.closePull(number)
}
func (g guardedGitHub) createComment(number int, bodyFile string) error {
if err := g.a.mayAct(); err != nil {
return err
}
return g.github.createComment(number, bodyFile)
}
func (g guardedGitHub) editComment(id int64, bodyFile string) error {
if err := g.a.mayAct(); err != nil {
return err
}
return g.github.editComment(id, bodyFile)
}
type ghCLI struct{ bot string }
func (g ghCLI) batchBot() string { return g.bot }
func (ghCLI) openPulls(base string) ([]pullRequest, error) {
out, err := capture("gh", "api", "-X", "GET", "repos/{owner}/{repo}/pulls",
"-f", "state=open", "-f", "base="+base, "-f", "per_page="+strconv.Itoa(openPullsCap))
if err != nil {
return nil, err
}
var prs []pullRequest
if err := json.Unmarshal([]byte(out), &prs); err != nil {
return nil, fmt.Errorf("reading the open pull requests on %s: %w", base, err)
}
if len(prs) >= openPullsCap {
return nil, fmt.Errorf("the open pull requests on %s fill a page of %d, so the list may be truncated", base, openPullsCap)
}
return prs, nil
}
func (ghCLI) recentPulls(base string, page int) ([]pullRequest, error) {
out, err := capture("gh", "api", "-X", "GET", "repos/{owner}/{repo}/pulls",
"-f", "state=all", "-f", "base="+base, "-f", "sort=created", "-f", "direction=desc",
"-f", "per_page="+strconv.Itoa(recentPullsPage), "-f", "page="+strconv.Itoa(page))
if err != nil {
return nil, err
}
var prs []pullRequest
if err := json.Unmarshal([]byte(out), &prs); err != nil {
return nil, fmt.Errorf("reading the pull requests against %s: %w", base, err)
}
return prs, nil
}
// permCache asks GitHub for a login's permission once per command: the open
// batch's author is asked when it is chosen and again when its record is.
type permCache struct {
github
perms map[string]string
}
func (c *permCache) permission(login string) (string, error) {
if p, ok := c.perms[login]; ok {
return p, nil
}
p, err := c.github.permission(login)
if err == nil {
c.perms[login] = p
}
return p, err
}
func (ghCLI) permission(login string) (string, error) {
if !loginRE.MatchString(login) {
return "", fmt.Errorf("%q is not a GitHub login", login)
}
out, err := capture("gh", "api", "repos/{owner}/{repo}/collaborators/"+login+"/permission")
if err != nil {
return "", err
}
var answer struct {
Permission string `json:"permission"`
}
if err := json.Unmarshal([]byte(out), &answer); err != nil {
return "", fmt.Errorf("reading %s's permission: %w", login, err)
}
return answer.Permission, nil
}
func (ghCLI) labelled(label string) ([]int, error) {
out, err := capture("gh", "pr", "list", "--base", "main", "--state", "merged", "--label", label,
"--limit", strconv.Itoa(searchResultCap), "--json", "number")
if err != nil {
return nil, err
}
var prs []struct {
Number int `json:"number"`
}
if err := json.Unmarshal([]byte(out), &prs); err != nil {
return nil, fmt.Errorf("reading the pull requests labelled %s: %w", label, err)
}
if len(prs) >= searchResultCap {
return nil, fmt.Errorf("%d pull requests carry %s, as many as GitHub search returns, so the list may be cut short", len(prs), label)
}
numbers := make([]int, 0, len(prs))
for _, pr := range prs {
numbers = append(numbers, pr.Number)
}
return numbers, nil
}
func (ghCLI) pull(number int) (pullRequest, error) {
var pr pullRequest
out, err := capture("gh", "api", "repos/{owner}/{repo}/pulls/"+strconv.Itoa(number))
if err != nil {
return pr, err
}
if err := json.Unmarshal([]byte(out), &pr); err != nil {
return pr, fmt.Errorf("reading pull request #%d: %w", number, err)
}
if pr.Number != number {
return pr, fmt.Errorf("asked for pull request #%d, GitHub answered with #%d", number, pr.Number)
}
return pr, nil
}
func (ghCLI) createPull(base, head, title, bodyFile string) (int, string, error) {
out, err := capture("gh", "pr", "create", "--draft", "--base", base, "--head", head, "--title", title, "--body-file", bodyFile)
if err != nil {
return 0, "", err
}
url := strings.TrimSpace(out)
m := pullURLRE.FindStringSubmatch(url)
if m == nil {
return 0, "", fmt.Errorf("gh pr create printed %q, not the URL of a pull request", url)
}
n, err := strconv.Atoi(m[1])
return n, url, err
}
func (ghCLI) editPull(number int, title, bodyFile string) error {
_, err := capture("gh", "pr", "edit", strconv.Itoa(number), "--title", title, "--body-file", bodyFile)
return err
}
func (ghCLI) editBody(number int, bodyFile string) error {
_, err := capture("gh", "pr", "edit", strconv.Itoa(number), "--body-file", bodyFile)
return err
}
func (ghCLI) closePull(number int) error {
_, err := capture("gh", "pr", "close", strconv.Itoa(number))
return err
}
func (ghCLI) comments(number int) ([]issueComment, error) {
out, err := capture("gh", "api", "--paginate", "--slurp", "repos/{owner}/{repo}/issues/"+strconv.Itoa(number)+"/comments")
if err != nil {
return nil, err
}
var pages [][]issueComment
if err := json.Unmarshal([]byte(out), &pages); err != nil {
return nil, fmt.Errorf("reading the comments on #%d: %w", number, err)
}
var all []issueComment
for _, page := range pages {
all = append(all, page...)
}
return all, nil
}
func (ghCLI) createComment(number int, bodyFile string) error {
_, err := capture("gh", "api", "--method", "POST", "repos/{owner}/{repo}/issues/"+strconv.Itoa(number)+"/comments", "-F", "body=@"+bodyFile)
return err
}
func (ghCLI) editComment(id int64, bodyFile string) error {
_, err := capture("gh", "api", "--method", "PATCH", "repos/{owner}/{repo}/issues/comments/"+strconv.FormatInt(id, 10), "-F", "body=@"+bodyFile)
return err
}
// trusted says why a pull request's author may not speak for the batch, or ""
// when they may.
func trusted(gh github, pr pullRequest) (string, error) {
why, err := trustedAuthor(gh, pr.User.Login, pr.User.Type)
if why != "" {
why = "opened by " + why
}
return why, err
}
// trustedAuthor says why an author may not speak for the batch, or "" when
// they may: the bot the batch runs as, by its exact login, or a person whose
// permission on the repository is write or admin. Any other bot is refused,
// GitHub Actions' own included: anything with a workflow's token can write as
// it. The author association is not asked: an organization member or an
// invited collaborator can hold read access only, and the legacy permission
// folds maintain into write and triage into read. A permission GitHub does not
// answer is an error, not a refusal: taken for one, it would hide the open
// batch and its comment, and the run would open a second of each.
func trustedAuthor(gh github, login, kind string) (string, error) {
switch {
case kind == "Bot" && gh.batchBot() != "" && login == gh.batchBot():
return "", nil
case kind != "User" || !loginRE.MatchString(login):
return fmt.Sprintf("%q, which is neither a person nor the batch's bot (%s)", login, batchBotEnv), nil
}
perm, err := gh.permission(login)
switch {
case err != nil:
return "", err
case perm != "write" && perm != "admin":
return fmt.Sprintf("%s, whose permission is %q", login, perm), nil
}
return "", nil
}
// batchPull picks the open batch pull request for l out of prs, or nil.
//
// A pull request counts only when its head is a batch branch for l in this
// repository, not a fork, and a trusted author opened it: anyone can open a
// pull request from a branch named like one, and its -x lines and its list of
// deferred conflicts are what check believes. Look-alikes come back as
// warnings.
func batchPull(gh github, prs []pullRequest, l line) (*pullRequest, []string, error) {
var found []*pullRequest
var warnings []string
for i := range prs {
pr := &prs[i]
m := batchBranchRE.FindStringSubmatch(pr.Head.Ref)
if m == nil || m[1] != l.branch() || pr.Base.Ref != l.branch() {
continue
}
switch {
case pr.Head.Repo == nil || pr.Head.Repo.FullName != pr.Base.Repo.FullName:
warnings = append(warnings, fmt.Sprintf("ignoring #%d: its batch branch is in a fork", pr.Number))
case checkSHA(pr.Head.SHA) != nil:
warnings = append(warnings, fmt.Sprintf("ignoring #%d: GitHub reports no head commit for it", pr.Number))
default:
why, err := trusted(gh, *pr)
if err != nil {
return nil, warnings, fmt.Errorf("batch pull request #%d: %w", pr.Number, err)
}
if why != "" {
warnings = append(warnings, fmt.Sprintf("ignoring #%d: %s", pr.Number, why))
continue
}
found = append(found, pr)
}
}
switch len(found) {
case 0:
return nil, warnings, nil
case 1:
return found[0], warnings, nil
}
return nil, warnings, fmt.Errorf("more than one open batch pull request on %s (#%d, #%d); close all but one", l.branch(), found[0].Number, found[1].Number)
}
// batchHead is the head of the batch pull request as fetched here, refused
// unless it is the commit GitHub reports for the pull request.
func batchHead(pr *pullRequest) (string, error) {
if err := checkBranch(pr.Head.Ref); err != nil {
return "", err
}
ref := "refs/remotes/" + remote + "/" + pr.Head.Ref
got, err := lookup(ref)
if err != nil || got == pr.Head.SHA {
return got, err
}
if _, err := git("fetch", "--quiet", "--end-of-options", remote, "+refs/heads/"+pr.Head.Ref+":"+ref); err != nil {
return "", err
}
if got, err = resolve(ref); err != nil {
return "", err
}
if got != pr.Head.SHA {
return "", fmt.Errorf("batch pull request #%d: %s is at %.12s, not at %.12s as GitHub reports; run again", pr.Number, pr.Head.Ref, got, pr.Head.SHA)
}
return got, nil
}