diff --git a/.github/workflows/bot.yml b/.github/workflows/bot.yml
index 0870103c1b95..f51cecd92695 100644
--- a/.github/workflows/bot.yml
+++ b/.github/workflows/bot.yml
@@ -1,5 +1,8 @@
+name: GitHub Bot
+
on:
- pull_request: # Watch changes on PR assignement, label and code
+ # Watch for changes on PR state, assignees, labels and head branch
+ pull_request:
types:
- assigned
- unassigned
@@ -7,56 +10,95 @@ on:
- unlabeled
- opened
- reopened
- - synchronize # PR code updated
+ - synchronize # PR head updated
- issue_comment: # Watch PR comment changes
+ # Watch for changes on PR comment
+ issue_comment:
types: [created, edited, deleted]
- workflow_dispatch: # Manual run from Github Actions interface
+ # Manual run from GitHub Actions interface
+ workflow_dispatch:
inputs:
pull-request-list:
- description: "PR(s) to process. Specify `all` or a comma separated list of PR numbers like `42,1337,7890`."
+ description: "PR(s) to process : specify 'all' or a comma separated list of PR numbers, e.g. '42,1337,7890'"
required: true
- default: "all"
+ default: all
type: string
jobs:
- prevent-concurrency:
+ # This job creates a matrix of PR numbers based on the inputs from the various
+ # events that can trigger this workflow so that the process-pr job below can
+ # handle the parallel processing of the pull-requests
+ define-prs-matrix:
+ name: Define PRs matrix
+ # Prevent bot from retriggering itself
+ if: ${{ github.actor != vars.GH_BOT_LOGIN }}
runs-on: ubuntu-latest
+ permissions:
+ pull-requests: read
outputs:
pr-numbers: ${{ steps.pr-numbers.outputs.pr-numbers }}
steps:
- - name: Set PR numbers inside matrix
+ - name: Parse event inputs
id: pr-numbers
+ env:
+ GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
- if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
- if [ "${{ inputs.perform_deploy }}" = "all" ]; then
- echo 'pr-numbers=[""]' >> "$GITHUB_OUTPUT"
+ # Triggered by a workflow dispatch event
+ if [ '${{ github.event_name }}' = 'workflow_dispatch' ]; then
+ # If the input is 'all', create a matrix with every open PRs
+ if [ '${{ inputs.pull-request-list }}' = 'all' ]; then
+ pr_list=`gh pr list --state 'open' --repo '${{ github.repository }}' --json 'number' --template '{{$first := true}}{{range .}}{{if $first}}{{$first = false}}{{else}}, {{end}}{{"\""}}{{.number}}{{"\""}}{{end}}'`
+ [ -z "$pr_list" ] && echo 'Error : no opened PR found' >&2 && exit 1
+ echo "pr-numbers=[$pr_list]" >> "$GITHUB_OUTPUT"
+ # If the input is not 'all', test for each number in the comma separated
+ # list if the associated PR is opened, then add it to the matrix
else
- echo 'pr-numbers=[""]' >> "$GITHUB_OUTPUT"
+ pr_list_raw='${{ inputs.pull-request-list }}'
+ pr_list=''
+ IFS=','
+ for number in $pr_list; do
+ trimed=`echo "$number" | xargs`
+ pr_state=`gh pr view "$trimed" --repo '${{ github.repository }}' --json 'state' --template '{{.state}}' 2> /dev/null`
+ [ "$pr_state" != 'OPEN' ] && echo "Error : PR with number <$trimed> is not opened" >&2 && exit 1
+ done
+ echo "pr-numbers=[$pr_list]" >> "$GITHUB_OUTPUT"
fi
+ # Triggered by comment event, just add the associated PR number to the matrix
+ elif [ '${{ github.event_name }}' = 'issue_comment' ]; then
+ echo 'pr-numbers=["${{ github.event.issue.number }}"]' >> "$GITHUB_OUTPUT"
+ # Triggered by pull request event, just add the associated PR number to the matrix
+ elif [ '${{ github.event_name }}' = 'pull_request' ]; then
+ echo 'pr-numbers=["${{ github.event.pull_request.number }}"]' >> "$GITHUB_OUTPUT"
else
- echo 'pr-numbers=[""]' >> "$GITHUB_OUTPUT"
+ echo 'Error : unknown event ${{ github.event_name }}' >&2 && exit 1
fi
+ # This job processes each pull request in the matrix individually while ensuring
+ # that a same PR cannot be processed concurrently by mutliple runners
process-pr:
- needs: prevent-concurrency
+ name: Process PR
+ needs: define-prs-matrix
runs-on: ubuntu-latest
strategy:
matrix:
- pr-number: ${{ fromJSON(needs.prevent-concurrency.outputs.pr-numbers) }}
+ # Run one job for each PR to process
+ pr-number: ${{ fromJSON(needs.define-prs-matrix.outputs.pr-numbers) }}
+ concurrency:
+ # Prevent running concurrent jobs for a given PR number
+ group: ${{ matrix.pr-number }}
steps:
- - name: Checkout
+ - name: Checkout code
uses: actions/checkout@v4
- name: Install Go
uses: actions/setup-go@v5
with:
- go-version-file: "go.mod"
+ go-version-file: go.mod
- - name: Start bot
+ - name: Run GitHub Bot
env:
- GITHUB_TOKEN: ${{ secrets.PAT }}
- run: go run .
+ GITHUB_TOKEN: ${{ secrets.GH_BOT_PAT }}
+ run: go run . -pr-numbers '${{ matrix.pr-number }}' -verbose
diff --git a/contribs/github_bot/client/client.go b/contribs/github_bot/client/client.go
new file mode 100644
index 000000000000..5a011573be4c
--- /dev/null
+++ b/contribs/github_bot/client/client.go
@@ -0,0 +1,235 @@
+package client
+
+import (
+ "bot/logger"
+ "bot/param"
+ "context"
+ "log"
+ "os"
+ "time"
+
+ "github.com/google/go-github/v66/github"
+)
+
+const PageSize = 100
+
+type GitHub struct {
+ Client *github.Client
+ Ctx context.Context
+ DryRun bool
+ Logger logger.Logger
+ Owner string
+ Repo string
+}
+
+func (gh *GitHub) GetBotComment(prNum int) *github.IssueComment {
+ // List existing comments
+ var (
+ allComments []*github.IssueComment
+ sort = "created"
+ direction = "desc"
+ opts = &github.IssueListCommentsOptions{
+ Sort: &sort,
+ Direction: &direction,
+ ListOptions: github.ListOptions{
+ PerPage: PageSize,
+ },
+ }
+ )
+
+ for {
+ comments, response, err := gh.Client.Issues.ListComments(
+ gh.Ctx,
+ gh.Owner,
+ gh.Repo,
+ prNum,
+ opts,
+ )
+ if err != nil {
+ gh.Logger.Errorf("Unable to list comments for PR %d : %v", prNum, err)
+ return nil
+ }
+
+ allComments = append(allComments, comments...)
+
+ if response.NextPage == 0 {
+ break
+ }
+ opts.Page = response.NextPage
+ }
+
+ // Get current user (bot)
+ currentUser, _, err := gh.Client.Users.Get(gh.Ctx, "")
+ if err != nil {
+ gh.Logger.Errorf("Unable to get current user : %v", err)
+ return nil
+ }
+
+ // Get the comment created by current user
+ for _, comment := range allComments {
+ if comment.GetUser().GetLogin() == currentUser.GetLogin() {
+ return comment
+ }
+ }
+
+ return nil
+}
+
+func (gh *GitHub) SetBotComment(body string, prNum int) *github.IssueComment {
+ // Create bot comment if it not already exists
+ if comment := gh.GetBotComment(prNum); comment == nil {
+ newComment, _, err := gh.Client.Issues.CreateComment(
+ gh.Ctx,
+ gh.Owner,
+ gh.Repo,
+ prNum,
+ &github.IssueComment{Body: &body},
+ )
+ if err != nil {
+ gh.Logger.Errorf("Unable to create bot comment for PR %d : %v", prNum, err)
+ return nil
+ }
+ return newComment
+ } else {
+ comment.Body = &body
+ editComment, _, err := gh.Client.Issues.EditComment(
+ gh.Ctx,
+ gh.Owner,
+ gh.Repo,
+ comment.GetID(),
+ comment,
+ )
+ if err != nil {
+ gh.Logger.Errorf("Unable to edit bot comment with ID %d : %v", comment.GetID(), err)
+ return nil
+ }
+ return editComment
+ }
+}
+
+func (gh *GitHub) ListTeamMembers(team string) []*github.User {
+ var (
+ allMembers []*github.User
+ opts = &github.TeamListTeamMembersOptions{
+ ListOptions: github.ListOptions{
+ PerPage: PageSize,
+ },
+ }
+ )
+
+ for {
+ members, response, err := gh.Client.Teams.ListTeamMembersBySlug(
+ gh.Ctx,
+ gh.Owner,
+ team,
+ opts,
+ )
+ if err != nil {
+ gh.Logger.Errorf("Unable to list members for team %s : %v", team, err)
+ return nil
+ }
+
+ allMembers = append(allMembers, members...)
+
+ if response.NextPage == 0 {
+ break
+ }
+ opts.Page = response.NextPage
+ }
+
+ return allMembers
+}
+
+func (gh *GitHub) ListPrReviewers(prNum int) *github.Reviewers {
+ var (
+ allReviewers = &github.Reviewers{}
+ opts = &github.ListOptions{
+ PerPage: PageSize,
+ }
+ )
+
+ for {
+ reviewers, response, err := gh.Client.PullRequests.ListReviewers(
+ gh.Ctx,
+ gh.Owner,
+ gh.Repo,
+ prNum,
+ opts,
+ )
+ if err != nil {
+ gh.Logger.Errorf("Unable to list reviewers for PR %d : %v", prNum, err)
+ return nil
+ }
+
+ allReviewers.Teams = append(allReviewers.Teams, reviewers.Teams...)
+ allReviewers.Users = append(allReviewers.Users, reviewers.Users...)
+
+ if response.NextPage == 0 {
+ break
+ }
+ opts.Page = response.NextPage
+ }
+
+ return allReviewers
+}
+
+func (gh *GitHub) ListPrReviews(prNum int) []*github.PullRequestReview {
+ var (
+ allReviews []*github.PullRequestReview
+ opts = &github.ListOptions{
+ PerPage: PageSize,
+ }
+ )
+
+ for {
+ reviews, response, err := gh.Client.PullRequests.ListReviews(
+ gh.Ctx,
+ gh.Owner,
+ gh.Repo,
+ prNum,
+ opts,
+ )
+ if err != nil {
+ gh.Logger.Errorf("Unable to list reviews for PR %d : %v", prNum, err)
+ return nil
+ }
+
+ allReviews = append(allReviews, reviews...)
+
+ if response.NextPage == 0 {
+ break
+ }
+ opts.Page = response.NextPage
+ }
+
+ return allReviews
+}
+
+func New(params param.Params) *GitHub {
+ gh := &GitHub{
+ Owner: params.Owner,
+ Repo: params.Repo,
+ DryRun: params.DryRun,
+ }
+
+ // This method will detect if the current process was launched by
+ // a GitHub Action or not and will accordingly return a logger suitable for
+ // the terminal output or for the GitHub Actions web interface
+ gh.Logger = logger.NewLogger(params.Verbose)
+
+ // Create context with timeout if specified in flags
+ if params.Timeout > 0 {
+ gh.Ctx, _ = context.WithTimeout(context.Background(), time.Duration(params.Timeout)*time.Millisecond)
+ } else {
+ gh.Ctx = context.Background()
+ }
+
+ // Init GitHub API Client using token from env
+ token, set := os.LookupEnv("GITHUB_TOKEN")
+ if !set {
+ log.Fatalf("GITHUB_TOKEN is not set in env")
+ }
+ gh.Client = github.NewClient(nil).WithAuthToken(token)
+
+ return gh
+}
diff --git a/contribs/github_bot/comment.go b/contribs/github_bot/comment.go
new file mode 100644
index 000000000000..4aa22b26926c
--- /dev/null
+++ b/contribs/github_bot/comment.go
@@ -0,0 +1,289 @@
+package main
+
+import (
+ "bot/client"
+ "bytes"
+ "fmt"
+ "os"
+ "regexp"
+ "text/template"
+
+ "github.com/google/go-github/v66/github"
+ "github.com/sethvargo/go-githubactions"
+)
+
+type AutoContent struct {
+ Description string
+ Satisfied bool
+ ConditionDetails string
+ RequirementDetails string
+}
+type ManualContent struct {
+ Description string
+ ConditionDetails string
+ CheckedBy string
+ Teams []string
+}
+
+type CommentContent struct {
+ AutoRules []AutoContent
+ ManualRules []ManualContent
+}
+
+// getCommentManualChecks parses the bot comment to get both the check
+// description and the username who checked it
+func getCommentManualChecks(gh *client.GitHub, commentBody string) map[string][2]string {
+ checks := make(map[string][2]string)
+
+ reg := regexp.MustCompile(`(?m:^- \[([ x])\] (.+) \(checked by @(\w+)\)$)`)
+ matches := reg.FindAllStringSubmatch(commentBody, -1)
+
+ gh.Logger.Infof("LOG", matches)
+ for _, match := range matches {
+ checks[match[2]] = [2]string{match[1], match[3]}
+ }
+
+ return checks
+}
+
+// This function checks if :
+// - the current run was triggered by GitHub Actions
+// - the triggering event is an edit of the bot comment
+// - the comment was not edited by the bot itself (prevent infinite loop)
+// - the comment change is only a checkbox being checked or unckecked (or restore)
+// - the actor / comment editor has permission to modify this checkbox (or restore)
+func handleCommentUpdate(gh *client.GitHub) {
+ // Get GitHub Actions context to retrieve comment update
+ actionCtx, err := githubactions.Context()
+ if err != nil {
+ gh.Logger.Debugf("Unable to retrieve GitHub Actions context : %v", err)
+ return
+ }
+
+ // Ignore if it's not an comment related event
+ if actionCtx.EventName != "issue_comment" {
+ gh.Logger.Debugf("Event is not issue comment related : %s", actionCtx.EventName)
+ return
+ }
+
+ // Ignore if action type is not deleted or edited
+ actionType, ok := actionCtx.Event["action"].(string)
+ if !ok {
+ gh.Logger.Errorf("Unable to get type on issue comment event")
+ os.Exit(1)
+ }
+
+ if actionType != "deleted" && actionType != "edited" {
+ return
+ }
+
+ // Exit if comment was edited by bot (current authenticated user)
+ authUser, _, err := gh.Client.Users.Get(gh.Ctx, "")
+ if err != nil {
+ gh.Logger.Errorf("Unable to get authenticated user : %v", err)
+ os.Exit(1)
+ }
+
+ if actionCtx.Actor == authUser.GetLogin() {
+ gh.Logger.Debugf("Prevent infinite loop if the bot comment was edited by the bot itself")
+ os.Exit(0)
+ }
+
+ // Ignore if edited comment author is not the bot
+ comment, ok := actionCtx.Event["comment"].(map[string]any)
+ if !ok {
+ gh.Logger.Errorf("Unable to get comment on issue comment event")
+ os.Exit(1)
+ }
+
+ author, ok := comment["user"].(map[string]any)
+ if !ok {
+ gh.Logger.Errorf("Unable to get comment user on issue comment event")
+ os.Exit(1)
+ }
+
+ login, ok := author["login"].(string)
+ if !ok {
+ gh.Logger.Errorf("Unable to get comment user login on issue comment event")
+ os.Exit(1)
+ }
+
+ if login != authUser.GetLogin() {
+ return
+ }
+
+ // Get comment current body
+ current, ok := comment["body"].(string)
+ if !ok {
+ gh.Logger.Errorf("Unable to get comment body on issue comment event")
+ os.Exit(1)
+ }
+
+ // Get comment updated body
+ changes, ok := actionCtx.Event["changes"].(map[string]any)
+ if !ok {
+ gh.Logger.Errorf("Unable to get changes on issue comment event")
+ os.Exit(1)
+ }
+
+ changesBody, ok := changes["body"].(map[string]any)
+ if !ok {
+ gh.Logger.Errorf("Unable to get changes body on issue comment event")
+ os.Exit(1)
+ }
+
+ previous, ok := changesBody["from"].(string)
+ if !ok {
+ gh.Logger.Errorf("Unable to get changes body content on issue comment event")
+ os.Exit(1)
+ }
+
+ // Get PR number from GitHub Actions context
+ issue, ok := actionCtx.Event["issue"].(map[string]any)
+ if !ok {
+ gh.Logger.Errorf("Unable to get issue on issue comment event")
+ os.Exit(1)
+ }
+
+ num, ok := issue["number"].(float64)
+ if !ok || num <= 0 {
+ gh.Logger.Errorf("Unable to get issue number on issue comment event")
+ os.Exit(1)
+ }
+
+ // Check if change is only a checkbox being checked or unckecked
+ checkboxes := regexp.MustCompile(`(?m:^- \[[ x]\])`)
+ if checkboxes.ReplaceAllString(current, "") != checkboxes.ReplaceAllString(previous, "") {
+ // If not, restore previous comment body
+ gh.Logger.Errorf("Bot comment edited outside of checkboxes")
+ gh.SetBotComment(previous, int(num))
+ os.Exit(1)
+ }
+
+ // Check if actor / comment editor has permission to modify changed boxes
+ currentChecks := getCommentManualChecks(gh, current)
+ previousChecks := getCommentManualChecks(gh, previous)
+ edited := ""
+ for key := range currentChecks {
+ if currentChecks[key][0] != previousChecks[key][0] {
+ // Get teams allowed to edit this box from config
+ var teams []string
+ found := false
+ _, manualRules := config(gh)
+
+ for _, manualRule := range manualRules {
+ if manualRule.Description == key {
+ found = true
+ teams = manualRule.Teams
+ }
+ }
+
+ // If rule were not found, return to reprocess the bot comment entirely
+ // (maybe bot config was updated since last run?)
+ if !found {
+ gh.Logger.Debugf("Updated rule not found in config : %s", key)
+ return
+ }
+
+ // If teams specified in rule, check if actor is a member of one of them
+ if len(teams) > 0 {
+ found = false
+ for _, team := range teams {
+ for _, member := range gh.ListTeamMembers(team) {
+ if member.GetLogin() == actionCtx.Actor {
+ found = true
+ break
+ }
+ }
+ if found {
+ break
+ }
+ }
+
+ // If not, restore previous comment body
+ if !found {
+ gh.Logger.Errorf("Checkbox edited by a user not allowed to")
+ gh.SetBotComment(previous, int(num))
+ os.Exit(1)
+ }
+ }
+
+ // If box was checked
+ reg := regexp.MustCompile(fmt.Sprintf("(?m:^- [%s] %s.*$)", currentChecks[key][0], key))
+ if currentChecks[key][0] == "x" {
+ edited = reg.ReplaceAllString(
+ current,
+ fmt.Sprintf("- [%s] %s (checked by @%s)", currentChecks[key][0], key, currentChecks[key][1]),
+ )
+ } else {
+ edited = reg.ReplaceAllString(
+ current,
+ fmt.Sprintf("- [%s] %s", currentChecks[key][0], key),
+ )
+ }
+ }
+ }
+
+ // Update comment then exit
+ if edited != "" {
+ gh.SetBotComment(edited, int(num))
+ gh.Logger.Debugf("Comment manual checks updated successfuly")
+ os.Exit(0)
+ }
+}
+
+func updateComment(gh *client.GitHub, pr *github.PullRequest, content CommentContent) {
+ // Create bot comment using template file
+ const tmplFile = "comment.tmpl"
+ tmpl, err := template.New(tmplFile).ParseFiles(tmplFile)
+ if err != nil {
+ panic(err)
+ }
+
+ var commentBytes bytes.Buffer
+ if err := tmpl.Execute(&commentBytes, content); err != nil {
+ panic(err)
+ }
+
+ // Create commit status
+ var (
+ comment = gh.SetBotComment(commentBytes.String(), pr.GetNumber())
+ context = "Merge Requirements"
+ targetURL = comment.GetHTMLURL()
+ state = "pending"
+ description = "Some requirements are not satisfied yet. See bot comment."
+ allSatisfied = true
+ )
+
+ // Check if every requirements are satisfied
+ for _, auto := range content.AutoRules {
+ if !auto.Satisfied {
+ allSatisfied = false
+ }
+ }
+
+ for _, manual := range content.ManualRules {
+ if manual.CheckedBy == "" {
+ allSatisfied = false
+ }
+ }
+
+ if allSatisfied {
+ state = "success"
+ description = "All requirements are satisfied."
+ }
+
+ if _, _, err := gh.Client.Repositories.CreateStatus(
+ gh.Ctx,
+ gh.Owner,
+ gh.Repo,
+ pr.GetHead().GetSHA(),
+ &github.RepoStatus{
+ Context: &context,
+ State: &state,
+ TargetURL: &targetURL,
+ Description: &description,
+ }); err != nil {
+ gh.Logger.Errorf("Unable to create status on PR %d : %v", pr.GetNumber(), err)
+ }
+}
diff --git a/contribs/github_bot/comment.tmpl b/contribs/github_bot/comment.tmpl
new file mode 100644
index 000000000000..cd66795df9ab
--- /dev/null
+++ b/contribs/github_bot/comment.tmpl
@@ -0,0 +1,49 @@
+# Merge Requirements
+
+The following requirements must be fulfilled before a pull request can be merged.
+Some requirement checks are automated and can be verified by the CI, while others need manual verification by a staff member.
+
+These requirements are defined in this [config file](https://github.com/gnolang/gno/blob/master/misc/github-bot/config.go).
+
+## Automated Checks
+
+{{ range .AutoRules }} {{ if .Satisfied }}🟢{{ else }}🟠{{ end }} {{ .Description }}
+{{ end }}
+
+Details
+{{ range .AutoRules }}
+{{ .Description }}
+
+### If :
+```
+{{ .ConditionDetails }}
+```
+### Then :
+```
+{{ .RequirementDetails }}
+```
+
Details
+{{ range .ManualRules }}
+{{ .Description }}
+
+### If :
+```
+{{ .ConditionDetails }}
+```
+### Can be checked by :
+{{range $item := .Teams }} - team {{ $item }}
+{{ else }}
+- Any user with comment edit permission
+{{end}}
+