feat(forge): github and gitea forge extensions
This commit is contained in:
15 files changed
+2259
-54
No files matched your search
@@ -6,6 +6,7 @@ directory holds one subdirectory per extension.
|
||||
```
|
||||
secret-engines/<name>/ package.yaml + Go source, served over secretengine.v1
|
||||
workflows/<name>/ package.yaml + workflow YAML, projected into workflow-definitions
|
||||
forge/<name>/ package.yaml + Go source, served over forge.v1 (github, gitea)
|
||||
playbooks/<name>/ package.yaml + EDA playbook YAML, projected into eda-playbooks
|
||||
profiles/<name>/ package.yaml + agent profile YAML, projected into agent-profiles
|
||||
sdk/ generated surface stubs and the Serve helper
|
||||
|
||||
@@ -0,0 +1,491 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"math"
|
||||
"net/http"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"github.com/samcharles93/archipelago/sdk/forge"
|
||||
|
||||
"code.gitea.io/sdk/gitea"
|
||||
)
|
||||
|
||||
// GiteaClient implements Forge against a Gitea instance.
|
||||
type GiteaClient struct {
|
||||
cli *gitea.Client
|
||||
host string
|
||||
token string
|
||||
log *slog.Logger
|
||||
|
||||
labelMu sync.Mutex
|
||||
labelsEnsured map[string]bool
|
||||
}
|
||||
|
||||
// NewGitea creates a Gitea-backed Forge implementation.
|
||||
func newGitea(token, host string, log *slog.Logger) (forge.Forge, error) {
|
||||
host = strings.TrimRight(host, "/")
|
||||
cli, err := gitea.NewClient(host, gitea.SetToken(token))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("gitea client %s: %w", host, err)
|
||||
}
|
||||
return &GiteaClient{cli: cli, host: host, token: token, log: log}, nil
|
||||
}
|
||||
|
||||
// ── Forge interface ──────────────────────────────────────────────────
|
||||
|
||||
// AcceptInvitations auto-accepts pending repository invitations.
|
||||
func (c *GiteaClient) AcceptInvitations(ctx context.Context) error {
|
||||
// Gitea doesn't have a direct equivalent to GitHub's user invitations
|
||||
// API. Repository collaborators are added directly by the owner.
|
||||
return nil
|
||||
}
|
||||
|
||||
// AssignedIssues returns open issues assigned to the given user, excluding PRs.
|
||||
func (c *GiteaClient) AssignedIssues(ctx context.Context, owner, repo, assignee string) ([]forge.Issue, error) {
|
||||
opts := gitea.ListIssueOption{
|
||||
PageSize: 50,
|
||||
State: gitea.StateOpen,
|
||||
AssignedBy: assignee,
|
||||
}
|
||||
var out []forge.Issue
|
||||
for {
|
||||
issues, resp, err := c.cli.ListRepoIssues(owner, repo, opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list issues %s/%s: %w", owner, repo, err)
|
||||
}
|
||||
for _, is := range issues {
|
||||
if is.PullRequest == nil {
|
||||
out = append(out, forge.Issue{
|
||||
Number: int(is.Index),
|
||||
Title: is.Title,
|
||||
Body: is.Body,
|
||||
Labels: labelNamesGitea(is.Labels),
|
||||
})
|
||||
}
|
||||
}
|
||||
if resp.NextPage == 0 {
|
||||
break
|
||||
}
|
||||
opts.Page = resp.NextPage
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// IssuesWithLabel returns open issues matching the given label, excluding PRs.
|
||||
func (c *GiteaClient) IssuesWithLabel(ctx context.Context, owner, repo, label string) ([]forge.Issue, error) {
|
||||
opts := gitea.ListIssueOption{
|
||||
PageSize: 50,
|
||||
State: gitea.StateOpen,
|
||||
Labels: []string{label},
|
||||
}
|
||||
var out []forge.Issue
|
||||
for {
|
||||
issues, resp, err := c.cli.ListRepoIssues(owner, repo, opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list issues %s/%s: %w", owner, repo, err)
|
||||
}
|
||||
for _, is := range issues {
|
||||
if is.PullRequest == nil {
|
||||
out = append(out, forge.Issue{
|
||||
Number: int(is.Index),
|
||||
Title: is.Title,
|
||||
Body: is.Body,
|
||||
Labels: labelNamesGitea(is.Labels),
|
||||
})
|
||||
}
|
||||
}
|
||||
if resp.NextPage == 0 {
|
||||
break
|
||||
}
|
||||
opts.Page = resp.NextPage
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// Comment posts an issue comment and returns its id.
|
||||
func (c *GiteaClient) Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error) {
|
||||
cm, _, err := c.cli.CreateIssueComment(owner, repo, int64(number), gitea.CreateIssueCommentOption{Body: body})
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return cm.ID, nil
|
||||
}
|
||||
|
||||
// CreatePR opens a pull request and returns its number.
|
||||
func (c *GiteaClient) CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) {
|
||||
pr, _, err := c.cli.CreatePullRequest(owner, repo, gitea.CreatePullRequestOption{
|
||||
Title: title,
|
||||
Head: head,
|
||||
Base: base,
|
||||
Body: body,
|
||||
})
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("create PR %s/%s: %w", owner, repo, err)
|
||||
}
|
||||
return int(pr.Index), nil
|
||||
}
|
||||
|
||||
// PRState returns "open", "merged", or "closed" for a PR.
|
||||
// Returns "closed" for non-existent PRs (already merged/closed/removed).
|
||||
func (c *GiteaClient) PRState(ctx context.Context, owner, repo string, number int) (string, error) {
|
||||
pr, _, err := c.cli.GetPullRequest(owner, repo, int64(number))
|
||||
if err != nil {
|
||||
// "not found" means the PR was already merged/closed and cleaned up.
|
||||
if strings.Contains(err.Error(), "not found") || strings.Contains(err.Error(), "GetUserByName") {
|
||||
return "closed", nil
|
||||
}
|
||||
return "", err
|
||||
}
|
||||
if pr.HasMerged {
|
||||
return "merged", nil
|
||||
}
|
||||
return string(pr.State), nil
|
||||
}
|
||||
|
||||
// GetPullRequest returns the forge-neutral metadata for an existing PR.
|
||||
func (c *GiteaClient) GetPullRequest(ctx context.Context, owner, repo string, number int) (forge.PullRequest, error) {
|
||||
pr, _, err := c.cli.GetPullRequest(owner, repo, int64(number))
|
||||
if err != nil {
|
||||
return forge.PullRequest{}, fmt.Errorf("get pull request %s/%s#%d: %w", owner, repo, number, err)
|
||||
}
|
||||
// A merged/closed PR whose head branch was deleted returns nil head/base
|
||||
// from Gitea; dereferencing it would panic.
|
||||
if pr.Head == nil || pr.Base == nil {
|
||||
return forge.PullRequest{}, fmt.Errorf("pull request %s/%s#%d has a missing head or base ref", owner, repo, number)
|
||||
}
|
||||
state := string(pr.State)
|
||||
if pr.HasMerged {
|
||||
state = "merged"
|
||||
}
|
||||
return forge.PullRequest{
|
||||
Number: int(pr.Index),
|
||||
Title: pr.Title,
|
||||
Body: pr.Body,
|
||||
HeadRef: pr.Head.Ref,
|
||||
BaseRef: pr.Base.Ref,
|
||||
HeadSHA: pr.Head.Sha,
|
||||
BaseSHA: pr.Base.Sha,
|
||||
State: state,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// GetPullRequestDiff fetches the pull request's unified diff over the Gitea
|
||||
// API, never a local git clone.
|
||||
func (c *GiteaClient) GetPullRequestDiff(_ context.Context, owner, repo string, number int) (string, error) {
|
||||
diff, _, err := c.cli.GetPullRequestDiff(owner, repo, int64(number), gitea.PullRequestDiffOptions{})
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("get pull request diff %s/%s#%d: %w", owner, repo, number, err)
|
||||
}
|
||||
return string(diff), nil
|
||||
}
|
||||
|
||||
// GetRepoArchive fetches a gzipped tar archive of the repository at ref
|
||||
// directly from Gitea's own API -- unlike GitHub, no separate unauthenticated
|
||||
// fetch is needed.
|
||||
func (c *GiteaClient) GetRepoArchive(_ context.Context, owner, repo, ref string) (io.ReadCloser, error) {
|
||||
body, _, err := c.cli.GetArchiveReader(owner, repo, ref, gitea.TarGZArchive)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("get repo archive %s/%s@%s: %w", owner, repo, ref, err)
|
||||
}
|
||||
return body, nil
|
||||
}
|
||||
|
||||
// ListReviews returns the reviews on a PR with ID > sinceID.
|
||||
func (c *GiteaClient) ListReviews(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.Review, error) {
|
||||
var out []forge.Review
|
||||
opts := gitea.ListPullReviewsOptions{}
|
||||
for {
|
||||
reviews, resp, err := c.cli.ListPullReviews(owner, repo, int64(number), opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list reviews %s/%s#%d: %w", owner, repo, number, err)
|
||||
}
|
||||
for _, r := range reviews {
|
||||
if r.ID <= sinceID {
|
||||
continue
|
||||
}
|
||||
out = append(out, forge.Review{
|
||||
ID: r.ID,
|
||||
Author: giteaReviewAuthor(r.Reviewer),
|
||||
State: normalizeGiteaReviewState(r.State),
|
||||
Body: r.Body,
|
||||
SubmittedAt: r.Submitted,
|
||||
})
|
||||
}
|
||||
if resp.NextPage == 0 {
|
||||
break
|
||||
}
|
||||
opts.Page = resp.NextPage
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// ListReviewComments returns the inline review comments on a PR with
|
||||
// ID > sinceID. Gitea nests comments under reviews, so this lists each
|
||||
// review's comments.
|
||||
func (c *GiteaClient) ListReviewComments(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.ReviewComment, error) {
|
||||
reviews, err := c.ListReviews(ctx, owner, repo, number, 0)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var out []forge.ReviewComment
|
||||
for _, rv := range reviews {
|
||||
comments, _, err := c.cli.ListPullReviewComments(owner, repo, int64(number), rv.ID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list review comments %s/%s#%d review %d: %w", owner, repo, number, rv.ID, err)
|
||||
}
|
||||
for _, cm := range comments {
|
||||
if cm.ID <= sinceID {
|
||||
continue
|
||||
}
|
||||
// LineNum is the forge's uint64. A value past the int range is not a
|
||||
// line this client can name, and wrapping it would put a negative
|
||||
// line number in front of a reviewer.
|
||||
if cm.LineNum > math.MaxInt {
|
||||
return nil, fmt.Errorf("review comment %d on %s/%s#%d has line number %d, which does not fit an int", cm.ID, owner, repo, number, cm.LineNum)
|
||||
}
|
||||
out = append(out, forge.ReviewComment{
|
||||
ID: cm.ID,
|
||||
ReviewID: rv.ID,
|
||||
Author: giteaReviewAuthor(cm.Reviewer),
|
||||
Body: cm.Body,
|
||||
Path: cm.Path,
|
||||
Line: int(cm.LineNum),
|
||||
CreatedAt: cm.Created,
|
||||
})
|
||||
}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// ReplyToReview posts a reply to an existing review comment.
|
||||
func (c *GiteaClient) ReplyToReview(ctx context.Context, owner, repo string, number int, commentID int64, body string) error {
|
||||
if _, _, err := c.cli.CreatePullReviewCommentReply(owner, repo, int64(number), commentID, gitea.CreatePullReviewCommentReplyOptions{Body: body}); err != nil {
|
||||
return fmt.Errorf("reply to review comment %d on %s/%s#%d: %w", commentID, owner, repo, number, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CreateReviewComments posts the comments as one COMMENT review on the PR's
|
||||
// head, refused if the head moved past reviewedHeadSHA.
|
||||
func (c *GiteaClient) CreateReviewComments(ctx context.Context, owner, repo string, number int, reviewedHeadSHA string, comments []forge.InlineReviewComment) error {
|
||||
pr, err := c.GetPullRequest(ctx, owner, repo, number)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if pr.HeadSHA == "" {
|
||||
return fmt.Errorf("resolve head revision of %s/%s#%d: the forge reported no head sha", owner, repo, number)
|
||||
}
|
||||
if err := forge.ReviewHeadDrift(owner, repo, number, pr.HeadSHA, reviewedHeadSHA); err != nil {
|
||||
return err
|
||||
}
|
||||
reviewComments := make([]gitea.CreatePullReviewComment, 0, len(comments))
|
||||
for _, cm := range comments {
|
||||
reviewComments = append(reviewComments, gitea.CreatePullReviewComment{
|
||||
Path: cm.Path,
|
||||
Body: cm.Body,
|
||||
NewLineNum: int64(cm.Line),
|
||||
})
|
||||
}
|
||||
if _, _, err := c.cli.CreatePullReview(owner, repo, int64(number), gitea.CreatePullReviewOptions{
|
||||
State: gitea.ReviewStateComment,
|
||||
CommitID: pr.HeadSHA,
|
||||
Comments: reviewComments,
|
||||
}); err != nil {
|
||||
return fmt.Errorf("create review comments on %s/%s#%d: %w", owner, repo, number, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// giteaReviewAuthor returns a review/comment author's login, or "" when the
|
||||
// author is absent (a team review, or a deleted user).
|
||||
func giteaReviewAuthor(u *gitea.User) string {
|
||||
if u == nil {
|
||||
return ""
|
||||
}
|
||||
return u.UserName
|
||||
}
|
||||
|
||||
// normalizeGiteaReviewState maps a Gitea review state onto the neutral
|
||||
// ReviewState* constants. Pending and request-review reviews are not a
|
||||
// decision and pass through lowercased so the caller can ignore them.
|
||||
func normalizeGiteaReviewState(s gitea.ReviewStateType) string {
|
||||
switch s {
|
||||
case gitea.ReviewStateApproved:
|
||||
return forge.ReviewStateApproved
|
||||
case gitea.ReviewStateRequestChanges:
|
||||
return forge.ReviewStateRequestedChanges
|
||||
case gitea.ReviewStateComment:
|
||||
return forge.ReviewStateCommented
|
||||
default:
|
||||
return strings.ToLower(string(s))
|
||||
}
|
||||
}
|
||||
|
||||
// CloseIssue closes an issue with an optional final comment.
|
||||
func (c *GiteaClient) CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error {
|
||||
if comment != "" {
|
||||
if _, err := c.Comment(ctx, owner, repo, number, comment); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
state := gitea.StateClosed
|
||||
_, _, err := c.cli.EditIssue(owner, repo, int64(number), gitea.EditIssueOption{State: &state})
|
||||
return err
|
||||
}
|
||||
|
||||
// React adds an emoji reaction to an issue.
|
||||
func (c *GiteaClient) React(ctx context.Context, owner, repo string, number int, reaction string) error {
|
||||
_, _, err := c.cli.PostIssueReaction(owner, repo, int64(number), reaction)
|
||||
return err
|
||||
}
|
||||
|
||||
// LinkBranch associates a branch with an issue via the Gitea API.
|
||||
func (c *GiteaClient) LinkBranch(ctx context.Context, owner, repo string, issueNumber int, branch string) error {
|
||||
url := fmt.Sprintf("%s/api/v1/repos/%s/%s/issues/%d/refs", c.host, owner, repo, issueNumber)
|
||||
body := fmt.Sprintf(`{"ref": "%s"}`, branch)
|
||||
req, _ := http.NewRequestWithContext(ctx, http.MethodPost, url, strings.NewReader(body))
|
||||
req.Header.Set("Authorization", "token "+c.token)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, _ = io.Copy(io.Discard, resp.Body)
|
||||
_ = resp.Body.Close()
|
||||
if resp.StatusCode >= 300 {
|
||||
return fmt.Errorf("link branch: HTTP %d", resp.StatusCode)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetStateLabel makes label the issue's only state label.
|
||||
func (c *GiteaClient) SetStateLabel(ctx context.Context, owner, repo string, number int, label string, knownLabels []string) {
|
||||
known := make(map[string]bool, len(knownLabels))
|
||||
for _, l := range knownLabels {
|
||||
known[l] = true
|
||||
}
|
||||
issue, _, err := c.cli.GetIssue(owner, repo, int64(number))
|
||||
if err != nil {
|
||||
c.log.Warn("set state label: get issue failed", "issue", number, "err", err)
|
||||
return
|
||||
}
|
||||
// Remove known state labels (except the target).
|
||||
for _, l := range issue.Labels {
|
||||
if l.Name == label {
|
||||
label = "" // already present
|
||||
} else if known[l.Name] {
|
||||
if _, err := c.cli.DeleteIssueLabel(owner, repo, int64(number), l.ID); err != nil {
|
||||
c.log.Warn("remove state label failed", "label", l.Name, "err", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
if label == "" {
|
||||
return
|
||||
}
|
||||
// Find or create the target label and add it by ID.
|
||||
labelID := c.resolveLabelID(owner, repo, label)
|
||||
if labelID == 0 {
|
||||
return // ensureLabel already logged
|
||||
}
|
||||
if _, _, err := c.cli.AddIssueLabels(owner, repo, int64(number), gitea.IssueLabelsOption{
|
||||
Labels: []int64{labelID},
|
||||
}); err != nil {
|
||||
c.log.Warn("add state label failed", "label", label, "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
// resolveLabelID returns the ID of a label, creating it if necessary.
|
||||
func (c *GiteaClient) resolveLabelID(owner, repo, name string) int64 {
|
||||
labels, _, err := c.cli.ListRepoLabels(owner, repo, gitea.ListLabelsOptions{PageSize: 100})
|
||||
if err != nil {
|
||||
c.log.Warn("list repo labels failed", "err", err)
|
||||
return 0
|
||||
}
|
||||
for _, l := range labels {
|
||||
if l.Name == name {
|
||||
return l.ID
|
||||
}
|
||||
}
|
||||
// Create the label.
|
||||
c.ensureLabel(owner, repo, name)
|
||||
// Re-list to get the new ID.
|
||||
labels, _, err = c.cli.ListRepoLabels(owner, repo, gitea.ListLabelsOptions{PageSize: 100})
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
for _, l := range labels {
|
||||
if l.Name == name {
|
||||
return l.ID
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// VerifyPush confirms the token can push to the repo.
|
||||
func (c *GiteaClient) VerifyPush(ctx context.Context, owner, repo string) error {
|
||||
r, _, err := c.cli.GetRepo(owner, repo)
|
||||
if err != nil {
|
||||
// Gitea SDK may return "GetUserByName" for a non-existent repo.
|
||||
if strings.Contains(err.Error(), "GetUserByName") {
|
||||
return fmt.Errorf("repo %s/%s not found or token lacks access", owner, repo)
|
||||
}
|
||||
return fmt.Errorf("get repo %s/%s: %w", owner, repo, err)
|
||||
}
|
||||
if !r.Permissions.Push {
|
||||
return fmt.Errorf("no push permission on %s/%s", owner, repo)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ── helpers ──────────────────────────────────────────────────────────
|
||||
|
||||
func labelNamesGitea(labels []*gitea.Label) []string {
|
||||
var names []string
|
||||
for _, l := range labels {
|
||||
names = append(names, l.Name)
|
||||
}
|
||||
return names
|
||||
}
|
||||
|
||||
// Gitea state label colours matching the GitHub palette.
|
||||
var giteaStateLabelColors = map[string]string{
|
||||
"archie:queued": "#bfd4f2",
|
||||
"archie:working": "#1d76db",
|
||||
"archie:waiting": "#fbca04",
|
||||
"archie:pr": "#0e8a16",
|
||||
"archie:parked": "#d93f0b",
|
||||
}
|
||||
|
||||
func (c *GiteaClient) ensureLabel(owner, repo, name string) {
|
||||
key := owner + "/" + repo + "/" + name
|
||||
c.labelMu.Lock()
|
||||
seen := c.labelsEnsured[key]
|
||||
c.labelMu.Unlock()
|
||||
if seen {
|
||||
return
|
||||
}
|
||||
color := giteaStateLabelColors[name]
|
||||
if color == "" {
|
||||
color = "#bfd4f2"
|
||||
}
|
||||
_, _, err := c.cli.CreateLabel(owner, repo, gitea.CreateLabelOption{
|
||||
Name: name,
|
||||
Color: color,
|
||||
Description: "archie task state (managed automatically)",
|
||||
})
|
||||
if err != nil && !strings.Contains(err.Error(), "already exists") && !strings.Contains(err.Error(), "422") {
|
||||
c.log.Warn("create label failed", "label", name, "err", err)
|
||||
return
|
||||
}
|
||||
c.labelMu.Lock()
|
||||
if c.labelsEnsured == nil {
|
||||
c.labelsEnsured = map[string]bool{}
|
||||
}
|
||||
c.labelsEnsured[key] = true
|
||||
c.labelMu.Unlock()
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
// Command gitea is the Gitea forge extension: issues, pull requests and
|
||||
// reviews over the Gitea API.
|
||||
package main
|
||||
|
||||
import (
|
||||
"log/slog"
|
||||
|
||||
"github.com/samcharles93/archipelago/sdk/forge"
|
||||
)
|
||||
|
||||
func main() {
|
||||
forge.Serve(func(cfg forge.Config) (forge.Forge, error) {
|
||||
return newGitea(cfg.Token, cfg.Host, slog.Default())
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
apiVersion: dev.archie.package.v1
|
||||
displayName: Gitea forge
|
||||
description: Gitea issues, pull requests and reviews for archie-core. The instance's host is named by the operator's egress acceptance.
|
||||
version: 1.0.0
|
||||
contributes:
|
||||
extensions:
|
||||
- surface: forge
|
||||
path: bin/gitea
|
||||
files:
|
||||
- path: bin/gitea
|
||||
mode: 493
|
||||
@@ -0,0 +1,453 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"github.com/samcharles93/archipelago/sdk/forge"
|
||||
|
||||
"github.com/google/go-github/v78/github"
|
||||
)
|
||||
|
||||
// GitHubClient implements Forge against the GitHub API.
|
||||
type GitHubClient struct {
|
||||
gh *github.Client
|
||||
log *slog.Logger
|
||||
|
||||
labelMu sync.Mutex
|
||||
labelsEnsured map[string]bool
|
||||
}
|
||||
|
||||
// NewGitHub creates a GitHub-backed Forge implementation. Non-github.com
|
||||
// hosts are configured using GitHub Enterprise's API and upload URL conventions.
|
||||
func newGitHub(token, host string, log *slog.Logger) (forge.Forge, error) {
|
||||
client := github.NewClient(nil)
|
||||
if strings.TrimRight(host, "/") != "https://github.com" {
|
||||
var err error
|
||||
client, err = client.WithEnterpriseURLs(host, host)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("configure GitHub host %q: %w", host, err)
|
||||
}
|
||||
}
|
||||
return &GitHubClient{gh: client.WithAuthToken(token), log: log}, nil
|
||||
}
|
||||
|
||||
// AcceptInvitations auto-accepts pending repository invitations so
|
||||
// adding archie as a collaborator is all a human has to do.
|
||||
func (c *GitHubClient) AcceptInvitations(ctx context.Context) error {
|
||||
invites, _, err := c.gh.Users.ListInvitations(ctx, nil)
|
||||
if err != nil {
|
||||
return fmt.Errorf("list invitations: %w", err)
|
||||
}
|
||||
for _, inv := range invites {
|
||||
if _, err := c.gh.Users.AcceptInvitation(ctx, inv.GetID()); err != nil {
|
||||
c.log.Warn("accept invitation failed", "repo", inv.GetRepo().GetFullName(), "err", err)
|
||||
continue
|
||||
}
|
||||
c.log.Info("accepted repository invitation", "repo", inv.GetRepo().GetFullName())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// AssignedIssues returns open issues assigned to the given user,
|
||||
// excluding PRs. Assigning an issue to the bot is how work is handed to
|
||||
// archie (tink-bot style); labels only influence workflow routing.
|
||||
func (c *GitHubClient) AssignedIssues(ctx context.Context, owner, repo, assignee string) ([]forge.Issue, error) {
|
||||
var out []forge.Issue
|
||||
opts := &github.IssueListByRepoOptions{
|
||||
State: "open",
|
||||
Assignee: assignee,
|
||||
ListOptions: github.ListOptions{PerPage: 50},
|
||||
}
|
||||
for {
|
||||
issues, resp, err := c.gh.Issues.ListByRepo(ctx, owner, repo, opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list issues %s/%s: %w", owner, repo, err)
|
||||
}
|
||||
for _, is := range issues {
|
||||
if !is.IsPullRequest() {
|
||||
out = append(out, forge.Issue{
|
||||
Number: is.GetNumber(),
|
||||
Title: is.GetTitle(),
|
||||
Body: is.GetBody(),
|
||||
Labels: labelNames(is),
|
||||
})
|
||||
}
|
||||
}
|
||||
if resp.NextPage == 0 {
|
||||
break
|
||||
}
|
||||
opts.ListOptions.Page = resp.NextPage
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// labelNames extracts label names without flattening them, preserving
|
||||
// valid label names that contain commas or leading/trailing whitespace.
|
||||
func labelNames(is *github.Issue) []string {
|
||||
var names []string
|
||||
for _, l := range is.Labels {
|
||||
names = append(names, l.GetName())
|
||||
}
|
||||
return names
|
||||
}
|
||||
|
||||
// IssuesWithLabel returns open issues matching the given label, excluding
|
||||
// PRs. Used when Dispatch.Trigger is "label" or "either" -- no assignee
|
||||
// required, just the label.
|
||||
func (c *GitHubClient) IssuesWithLabel(ctx context.Context, owner, repo, label string) ([]forge.Issue, error) {
|
||||
var out []forge.Issue
|
||||
opts := &github.IssueListByRepoOptions{
|
||||
State: "open",
|
||||
Labels: []string{label},
|
||||
ListOptions: github.ListOptions{PerPage: 50},
|
||||
}
|
||||
for {
|
||||
issues, resp, err := c.gh.Issues.ListByRepo(ctx, owner, repo, opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list issues %s/%s: %w", owner, repo, err)
|
||||
}
|
||||
for _, is := range issues {
|
||||
if !is.IsPullRequest() {
|
||||
out = append(out, forge.Issue{
|
||||
Number: is.GetNumber(),
|
||||
Title: is.GetTitle(),
|
||||
Body: is.GetBody(),
|
||||
Labels: labelNames(is),
|
||||
})
|
||||
}
|
||||
}
|
||||
if resp.NextPage == 0 {
|
||||
break
|
||||
}
|
||||
opts.ListOptions.Page = resp.NextPage
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// Comment posts an issue (or PR) comment and returns its id, so a
|
||||
// workflow can watch for replies that come after it.
|
||||
func (c *GitHubClient) Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error) {
|
||||
cm, _, err := c.gh.Issues.CreateComment(ctx, owner, repo, number,
|
||||
&github.IssueComment{Body: new(body)})
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return cm.GetID(), nil
|
||||
}
|
||||
|
||||
// CreatePR opens a pull request and returns its number.
|
||||
func (c *GitHubClient) CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) {
|
||||
pr, _, err := c.gh.PullRequests.Create(ctx, owner, repo, &github.NewPullRequest{
|
||||
Title: new(title),
|
||||
Head: new(head),
|
||||
Base: new(base),
|
||||
Body: new(body),
|
||||
})
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("create PR %s/%s: %w", owner, repo, err)
|
||||
}
|
||||
return pr.GetNumber(), nil
|
||||
}
|
||||
|
||||
// PRState returns "open", "merged", or "closed" for a PR.
|
||||
func (c *GitHubClient) PRState(ctx context.Context, owner, repo string, number int) (string, error) {
|
||||
pr, _, err := c.gh.PullRequests.Get(ctx, owner, repo, number)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if pr.GetMerged() {
|
||||
return "merged", nil
|
||||
}
|
||||
return pr.GetState(), nil
|
||||
}
|
||||
|
||||
// GetPullRequest returns the forge-neutral metadata for an existing PR.
|
||||
func (c *GitHubClient) GetPullRequest(ctx context.Context, owner, repo string, number int) (forge.PullRequest, error) {
|
||||
pr, _, err := c.gh.PullRequests.Get(ctx, owner, repo, number)
|
||||
if err != nil {
|
||||
return forge.PullRequest{}, fmt.Errorf("get pull request %s/%s#%d: %w", owner, repo, number, err)
|
||||
}
|
||||
state := pr.GetState()
|
||||
if pr.GetMerged() {
|
||||
state = "merged"
|
||||
}
|
||||
return forge.PullRequest{
|
||||
Number: pr.GetNumber(),
|
||||
Title: pr.GetTitle(),
|
||||
Body: pr.GetBody(),
|
||||
HeadRef: pr.GetHead().GetRef(),
|
||||
BaseRef: pr.GetBase().GetRef(),
|
||||
HeadSHA: pr.GetHead().GetSHA(),
|
||||
BaseSHA: pr.GetBase().GetSHA(),
|
||||
State: state,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// GetPullRequestDiff fetches the pull request's unified diff over the
|
||||
// GitHub API, never a local git clone.
|
||||
func (c *GitHubClient) GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error) {
|
||||
diff, _, err := c.gh.PullRequests.GetRaw(ctx, owner, repo, number, github.RawOptions{Type: github.Diff})
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("get pull request diff %s/%s#%d: %w", owner, repo, number, err)
|
||||
}
|
||||
return diff, nil
|
||||
}
|
||||
|
||||
// GetRepoArchive downloads a gzipped tar of the repository at ref. The
|
||||
// download URL is pre-signed, so no token is sent.
|
||||
func (c *GitHubClient) GetRepoArchive(ctx context.Context, owner, repo, ref string) (io.ReadCloser, error) {
|
||||
url, _, err := c.gh.Repositories.GetArchiveLink(ctx, owner, repo, github.Tarball, &github.RepositoryContentGetOptions{Ref: ref}, 5)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("resolve archive link %s/%s@%s: %w", owner, repo, ref, err)
|
||||
}
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url.String(), nil)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("build archive request %s/%s@%s: %w", owner, repo, ref, err)
|
||||
}
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("fetch archive %s/%s@%s: %w", owner, repo, ref, err)
|
||||
}
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
body, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
|
||||
_ = resp.Body.Close()
|
||||
return nil, fmt.Errorf("fetch archive %s/%s@%s: status %s: %s", owner, repo, ref, resp.Status, body)
|
||||
}
|
||||
return resp.Body, nil
|
||||
}
|
||||
|
||||
// ListReviews returns the reviews on a PR with ID > sinceID.
|
||||
func (c *GitHubClient) ListReviews(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.Review, error) {
|
||||
var out []forge.Review
|
||||
opts := &github.ListOptions{PerPage: 100}
|
||||
for {
|
||||
reviews, resp, err := c.gh.PullRequests.ListReviews(ctx, owner, repo, number, opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list reviews %s/%s#%d: %w", owner, repo, number, err)
|
||||
}
|
||||
for _, r := range reviews {
|
||||
if r.GetID() <= sinceID {
|
||||
continue
|
||||
}
|
||||
out = append(out, forge.Review{
|
||||
ID: r.GetID(),
|
||||
Author: r.GetUser().GetLogin(),
|
||||
State: normalizeReviewState(r.GetState()),
|
||||
Body: r.GetBody(),
|
||||
SubmittedAt: r.GetSubmittedAt().Time,
|
||||
})
|
||||
}
|
||||
if resp.NextPage == 0 {
|
||||
break
|
||||
}
|
||||
opts.Page = resp.NextPage
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// ListReviewComments returns the review comments on a PR with ID > sinceID.
|
||||
func (c *GitHubClient) ListReviewComments(ctx context.Context, owner, repo string, number int, sinceID int64) ([]forge.ReviewComment, error) {
|
||||
var out []forge.ReviewComment
|
||||
opts := &github.PullRequestListCommentsOptions{PerPage: 100}
|
||||
for {
|
||||
comments, resp, err := c.gh.PullRequests.ListComments(ctx, owner, repo, number, opts)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("list review comments %s/%s#%d: %w", owner, repo, number, err)
|
||||
}
|
||||
for _, cm := range comments {
|
||||
if cm.GetID() <= sinceID {
|
||||
continue
|
||||
}
|
||||
line := cm.GetOriginalLine()
|
||||
if line == 0 {
|
||||
line = cm.GetLine()
|
||||
}
|
||||
out = append(out, forge.ReviewComment{
|
||||
ID: cm.GetID(),
|
||||
ReviewID: cm.GetPullRequestReviewID(),
|
||||
Author: cm.GetUser().GetLogin(),
|
||||
Body: cm.GetBody(),
|
||||
Path: cm.GetPath(),
|
||||
Line: line,
|
||||
InReplyTo: cm.GetInReplyTo(),
|
||||
CreatedAt: cm.GetCreatedAt().Time,
|
||||
})
|
||||
}
|
||||
if resp.NextPage == 0 {
|
||||
break
|
||||
}
|
||||
opts.Page = resp.NextPage
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// ReplyToReview posts a reply to an existing review comment.
|
||||
func (c *GitHubClient) ReplyToReview(ctx context.Context, owner, repo string, number int, commentID int64, body string) error {
|
||||
if _, _, err := c.gh.PullRequests.CreateCommentInReplyTo(ctx, owner, repo, number, body, commentID); err != nil {
|
||||
return fmt.Errorf("reply to review comment %d on %s/%s#%d: %w", commentID, owner, repo, number, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CreateReviewComments posts each comment on the PR head's new side, refused
|
||||
// if the head moved past reviewedHeadSHA. Failures are joined; the rest are
|
||||
// still posted.
|
||||
func (c *GitHubClient) CreateReviewComments(ctx context.Context, owner, repo string, number int, reviewedHeadSHA string, comments []forge.InlineReviewComment) error {
|
||||
head, err := c.reviewHeadSHA(ctx, owner, repo, number)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := forge.ReviewHeadDrift(owner, repo, number, head, reviewedHeadSHA); err != nil {
|
||||
return err
|
||||
}
|
||||
var errs []error
|
||||
for _, cm := range comments {
|
||||
comment := &github.PullRequestComment{
|
||||
Body: new(cm.Body),
|
||||
Path: new(cm.Path),
|
||||
Line: new(cm.Line),
|
||||
Side: new("RIGHT"),
|
||||
CommitID: new(head),
|
||||
}
|
||||
if _, _, err := c.gh.PullRequests.CreateComment(ctx, owner, repo, number, comment); err != nil {
|
||||
errs = append(errs, fmt.Errorf("create review comment %s:%d on %s/%s#%d: %w", cm.Path, cm.Line, owner, repo, number, err))
|
||||
}
|
||||
}
|
||||
return errors.Join(errs...)
|
||||
}
|
||||
|
||||
// reviewHeadSHA resolves the commit a PR's line numbers are anchored to. A
|
||||
// forge that reports an empty head SHA is a failure, not an anchor: an empty
|
||||
// commit_id makes GitHub reject every comment in the set with nothing that says
|
||||
// why.
|
||||
func (c *GitHubClient) reviewHeadSHA(ctx context.Context, owner, repo string, number int) (string, error) {
|
||||
pr, err := c.GetPullRequest(ctx, owner, repo, number)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if pr.HeadSHA == "" {
|
||||
return "", fmt.Errorf("resolve head revision of %s/%s#%d: the forge reported no head sha", owner, repo, number)
|
||||
}
|
||||
return pr.HeadSHA, nil
|
||||
}
|
||||
|
||||
// CloseIssue closes an issue with a final comment (feasibility "won't do").
|
||||
func (c *GitHubClient) CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error {
|
||||
if comment != "" {
|
||||
if _, err := c.Comment(ctx, owner, repo, number, comment); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
_, _, err := c.gh.Issues.Edit(ctx, owner, repo, number,
|
||||
&github.IssueRequest{State: new("closed")})
|
||||
return err
|
||||
}
|
||||
|
||||
// LinkBranch associates a branch with an issue (GitHub stub -- Gitea is primary).
|
||||
func (c *GitHubClient) LinkBranch(ctx context.Context, owner, repo string, issueNumber int, branch string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// stateLabelColors maps label name → colour for on-demand creation.
|
||||
var stateLabelColors = map[string]string{
|
||||
"archie:queued": "bfd4f2", // grey-blue
|
||||
"archie:working": "1d76db", // blue
|
||||
"archie:waiting": "fbca04", // yellow
|
||||
"archie:pr": "0e8a16", // green
|
||||
"archie:parked": "d93f0b", // orange-red
|
||||
}
|
||||
|
||||
// defaultLabelColor is used for custom labels not in stateLabelColors.
|
||||
const defaultLabelColor = "bfd4f2"
|
||||
|
||||
// React adds an emoji reaction to an issue -- the instant "received"
|
||||
// acknowledgement on pickup.
|
||||
func (c *GitHubClient) React(ctx context.Context, owner, repo string, number int, reaction string) error {
|
||||
_, _, err := c.gh.Reactions.CreateIssueReaction(ctx, owner, repo, number, reaction)
|
||||
return err
|
||||
}
|
||||
|
||||
// ensureLabel creates the state label in the repo if it doesn't exist.
|
||||
func (c *GitHubClient) ensureLabel(ctx context.Context, owner, repo, name string) {
|
||||
key := owner + "/" + repo + "/" + name
|
||||
c.labelMu.Lock()
|
||||
seen := c.labelsEnsured[key]
|
||||
c.labelMu.Unlock()
|
||||
if seen {
|
||||
return
|
||||
}
|
||||
color := stateLabelColors[name]
|
||||
if color == "" {
|
||||
color = defaultLabelColor
|
||||
}
|
||||
_, _, err := c.gh.Issues.CreateLabel(ctx, owner, repo, &github.Label{
|
||||
Name: new(name),
|
||||
Color: new(color),
|
||||
Description: new("archie task state (managed automatically)"),
|
||||
})
|
||||
// 422 = already exists; both outcomes mean the label is available.
|
||||
if err != nil && !strings.Contains(err.Error(), "already_exists") {
|
||||
c.log.Warn("create label failed", "label", name, "err", err)
|
||||
return
|
||||
}
|
||||
c.labelMu.Lock()
|
||||
if c.labelsEnsured == nil {
|
||||
c.labelsEnsured = map[string]bool{}
|
||||
}
|
||||
c.labelsEnsured[key] = true
|
||||
c.labelMu.Unlock()
|
||||
}
|
||||
|
||||
// SetStateLabel makes label the issue's only state label, removing any
|
||||
// other label found in knownLabels first. An empty label clears all
|
||||
// state labels (terminal states).
|
||||
func (c *GitHubClient) SetStateLabel(ctx context.Context, owner, repo string, number int, label string, knownLabels []string) {
|
||||
known := make(map[string]bool, len(knownLabels))
|
||||
for _, l := range knownLabels {
|
||||
known[l] = true
|
||||
}
|
||||
issue, _, err := c.gh.Issues.Get(ctx, owner, repo, number)
|
||||
if err != nil {
|
||||
c.log.Warn("set state label: get issue failed", "issue", number, "err", err)
|
||||
return
|
||||
}
|
||||
for _, l := range issue.Labels {
|
||||
name := l.GetName()
|
||||
if name != label && known[name] {
|
||||
if _, err := c.gh.Issues.RemoveLabelForIssue(ctx, owner, repo, number, name); err != nil {
|
||||
c.log.Warn("remove state label failed", "label", name, "err", err)
|
||||
}
|
||||
}
|
||||
if name == label {
|
||||
label = "" // already present; nothing to add
|
||||
}
|
||||
}
|
||||
if label == "" {
|
||||
return
|
||||
}
|
||||
c.ensureLabel(ctx, owner, repo, label)
|
||||
if _, _, err := c.gh.Issues.AddLabelsToIssue(ctx, owner, repo, number, []string{label}); err != nil {
|
||||
c.log.Warn("add state label failed", "label", label, "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
// VerifyPush confirms the token can push to the repo (permission check
|
||||
// at startup so misconfiguration surfaces before any work is claimed).
|
||||
func (c *GitHubClient) VerifyPush(ctx context.Context, owner, repo string) error {
|
||||
r, _, err := c.gh.Repositories.Get(ctx, owner, repo)
|
||||
if err != nil {
|
||||
return fmt.Errorf("get repo %s/%s: %w", owner, repo, err)
|
||||
}
|
||||
perms := r.GetPermissions()
|
||||
if !perms["push"] {
|
||||
return fmt.Errorf("no push permission on %s/%s", owner, repo)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
// Command github is the GitHub forge extension: issues, pull requests and
|
||||
// reviews over the GitHub API, and webhook decoding.
|
||||
package main
|
||||
|
||||
import (
|
||||
"log/slog"
|
||||
"strings"
|
||||
|
||||
"github.com/samcharles93/archipelago/sdk/forge"
|
||||
)
|
||||
|
||||
func main() {
|
||||
forge.Serve(func(cfg forge.Config) (forge.Forge, error) {
|
||||
return newGitHub(cfg.Token, cfg.Host, slog.Default())
|
||||
})
|
||||
}
|
||||
|
||||
// normalizeReviewState maps a GitHub review state onto the neutral states.
|
||||
// Unknown states pass through lowercased.
|
||||
func normalizeReviewState(s string) string {
|
||||
switch s {
|
||||
case "APPROVED":
|
||||
return forge.ReviewStateApproved
|
||||
case "CHANGES_REQUESTED":
|
||||
return forge.ReviewStateRequestedChanges
|
||||
case "COMMENTED":
|
||||
return forge.ReviewStateCommented
|
||||
case "DISMISSED":
|
||||
return forge.ReviewStateDismissed
|
||||
default:
|
||||
return strings.ToLower(s)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
apiVersion: dev.archie.package.v1
|
||||
displayName: GitHub forge
|
||||
description: GitHub issues, pull requests, reviews and webhooks for archie-core.
|
||||
version: 1.0.0
|
||||
contributes:
|
||||
extensions:
|
||||
- surface: forge
|
||||
path: bin/github
|
||||
authority:
|
||||
egressHosts:
|
||||
- api.github.com
|
||||
- github.com
|
||||
files:
|
||||
- path: bin/github
|
||||
mode: 493
|
||||
@@ -0,0 +1,89 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
|
||||
"github.com/google/go-github/v78/github"
|
||||
|
||||
"github.com/samcharles93/archipelago/sdk/forge"
|
||||
)
|
||||
|
||||
// ParseWebhook decodes a delivery the host has authenticated. Events the host
|
||||
// does not act on (ping, push) decode to no event.
|
||||
func (c *GitHubClient) ParseWebhook(headers map[string]string, body []byte) (forge.WebhookEvent, error) {
|
||||
event, err := github.ParseWebHook(headers[http.CanonicalHeaderKey("X-GitHub-Event")], body)
|
||||
if err != nil {
|
||||
return forge.WebhookEvent{}, fmt.Errorf("%w: %w", forge.ErrBadWebhook, err)
|
||||
}
|
||||
switch e := event.(type) {
|
||||
case *github.IssuesEvent:
|
||||
return forge.WebhookEvent{Issue: issueEvent(e)}, nil
|
||||
case *github.PullRequestReviewEvent:
|
||||
review := e.GetReview()
|
||||
if review == nil {
|
||||
return forge.WebhookEvent{}, nil
|
||||
}
|
||||
return forge.WebhookEvent{Review: &forge.ReviewEvent{
|
||||
Action: e.GetAction(),
|
||||
Owner: e.GetRepo().GetOwner().GetLogin(),
|
||||
Repo: e.GetRepo().GetName(),
|
||||
PRNumber: e.GetPullRequest().GetNumber(),
|
||||
ReviewID: review.GetID(),
|
||||
Author: review.GetUser().GetLogin(),
|
||||
State: review.GetState(),
|
||||
Body: review.GetBody(),
|
||||
}}, nil
|
||||
case *github.PullRequestReviewCommentEvent:
|
||||
comment := e.GetComment()
|
||||
if comment == nil {
|
||||
return forge.WebhookEvent{}, nil
|
||||
}
|
||||
return forge.WebhookEvent{ReviewComment: &forge.ReviewCommentEvent{
|
||||
Action: e.GetAction(),
|
||||
Owner: e.GetRepo().GetOwner().GetLogin(),
|
||||
Repo: e.GetRepo().GetName(),
|
||||
PRNumber: e.GetPullRequest().GetNumber(),
|
||||
ReviewID: comment.GetPullRequestReviewID(),
|
||||
CommentID: comment.GetID(),
|
||||
Author: comment.GetUser().GetLogin(),
|
||||
Body: comment.GetBody(),
|
||||
Path: comment.GetPath(),
|
||||
Line: comment.GetLine(),
|
||||
}}, nil
|
||||
}
|
||||
return forge.WebhookEvent{}, nil
|
||||
}
|
||||
|
||||
func issueEvent(e *github.IssuesEvent) *forge.IssueEvent {
|
||||
issue := e.GetIssue()
|
||||
if issue == nil {
|
||||
return &forge.IssueEvent{Action: e.GetAction()}
|
||||
}
|
||||
var labels []string
|
||||
for _, l := range issue.Labels {
|
||||
if name := l.GetName(); name != "" {
|
||||
labels = append(labels, name)
|
||||
}
|
||||
}
|
||||
seen := map[string]bool{}
|
||||
var assignees []string
|
||||
for _, u := range append(append([]*github.User{}, issue.Assignees...), issue.Assignee, e.GetAssignee()) {
|
||||
if login := u.GetLogin(); login != "" && !seen[login] {
|
||||
seen[login] = true
|
||||
assignees = append(assignees, login)
|
||||
}
|
||||
}
|
||||
return &forge.IssueEvent{
|
||||
Action: e.GetAction(),
|
||||
State: issue.GetState(),
|
||||
PullRequest: issue.IsPullRequest(),
|
||||
Owner: e.GetRepo().GetOwner().GetLogin(),
|
||||
Repo: e.GetRepo().GetName(),
|
||||
Number: issue.GetNumber(),
|
||||
Title: issue.GetTitle(),
|
||||
Body: issue.GetBody(),
|
||||
Labels: labels,
|
||||
Assignees: assignees,
|
||||
}
|
||||
}
|
||||
@@ -3,19 +3,27 @@ module github.com/samcharles93/archipelago
|
||||
go 1.27
|
||||
|
||||
require (
|
||||
code.gitea.io/sdk/gitea v0.25.1
|
||||
github.com/google/go-github/v78 v78.0.0
|
||||
github.com/hashicorp/go-plugin v1.8.0
|
||||
google.golang.org/grpc v1.84.0
|
||||
google.golang.org/protobuf v1.36.12
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/42wim/httpsig v1.2.4 // indirect
|
||||
github.com/davidmz/go-pageant v1.0.2 // indirect
|
||||
github.com/fatih/color v1.13.0 // indirect
|
||||
github.com/go-fed/httpsig v1.1.0 // indirect
|
||||
github.com/golang/protobuf v1.5.4 // indirect
|
||||
github.com/google/go-querystring v1.1.0 // indirect
|
||||
github.com/hashicorp/go-hclog v1.6.3 // indirect
|
||||
github.com/hashicorp/go-version v1.9.0 // indirect
|
||||
github.com/hashicorp/yamux v0.1.2 // indirect
|
||||
github.com/mattn/go-colorable v0.1.12 // indirect
|
||||
github.com/mattn/go-isatty v0.0.17 // indirect
|
||||
github.com/oklog/run v1.1.0 // indirect
|
||||
golang.org/x/crypto v0.54.0 // indirect
|
||||
golang.org/x/net v0.57.0 // indirect
|
||||
golang.org/x/sys v0.47.0 // indirect
|
||||
golang.org/x/text v0.40.0 // indirect
|
||||
|
||||
@@ -1,18 +1,33 @@
|
||||
code.gitea.io/sdk/gitea v0.25.1 h1:yywxWwoV+SdjHtbC6unBiXojWdZOtoHuGhEazEXeWuE=
|
||||
code.gitea.io/sdk/gitea v0.25.1/go.mod h1:uDFWYBU8dgZsgOHwe6C/6olxvf8FHguNB3wW1i83fgg=
|
||||
github.com/42wim/httpsig v1.2.4 h1:mI5bH0nm4xn7K18fo1K3okNDRq8CCJ0KbBYWyA6r8lU=
|
||||
github.com/42wim/httpsig v1.2.4/go.mod h1:yKsYfSyTBEohkPik224QPFylmzEBtda/kjyIAJjh3ps=
|
||||
github.com/bufbuild/protocompile v0.14.1 h1:iA73zAf/fyljNjQKwYzUHD6AD4R8KMasmwa/FBatYVw=
|
||||
github.com/bufbuild/protocompile v0.14.1/go.mod h1:ppVdAIhbr2H8asPk6k4pY7t9zB1OU5DoEw9xY/FUi1c=
|
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
|
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/davidmz/go-pageant v1.0.2 h1:bPblRCh5jGU+Uptpz6LgMZGD5hJoOt7otgT454WvHn0=
|
||||
github.com/davidmz/go-pageant v1.0.2/go.mod h1:P2EDDnMqIwG5Rrp05dTRITj9z2zpGcD9efWSkTNKLIE=
|
||||
github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
|
||||
github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
|
||||
github.com/go-fed/httpsig v1.1.0 h1:9M+hb0jkEICD8/cAiNqEB66R87tTINszBRTjwjQzWcI=
|
||||
github.com/go-fed/httpsig v1.1.0/go.mod h1:RCMrTZvN1bJYtofsG4rd5NaO5obxQ5xBkdiS7xsT7bM=
|
||||
github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
|
||||
github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
|
||||
github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
|
||||
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
|
||||
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
|
||||
github.com/google/go-github/v78 v78.0.0 h1:b1tytzFE8i//lRVDx5Qh/EdJbtTPtSVD3nF7hraEs9w=
|
||||
github.com/google/go-github/v78 v78.0.0/go.mod h1:Uxvdzy82AkNlC6JQ57se9TqvmgBT7RF0ouHDNg2jd6g=
|
||||
github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
|
||||
github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
|
||||
github.com/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB11/k=
|
||||
github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M=
|
||||
github.com/hashicorp/go-plugin v1.8.0 h1:ie8S6RRY8RvB2usYZv+AAZ/wBvx2AU5p5QeP5j/FORs=
|
||||
github.com/hashicorp/go-plugin v1.8.0/go.mod h1:BExt6KEaIYx804z8k4gRzRLEvxKVb+kn0NMcihqOqb8=
|
||||
github.com/hashicorp/go-version v1.9.0 h1:CeOIz6k+LoN3qX9Z0tyQrPtiB1DFYRPfCIBtaXPSCnA=
|
||||
github.com/hashicorp/go-version v1.9.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
|
||||
github.com/hashicorp/yamux v0.1.2 h1:XtB8kyFOyHXYVFnwT5C3+Bdo8gArse7j2AQ0DA0Uey8=
|
||||
github.com/hashicorp/yamux v0.1.2/go.mod h1:C+zze2n6e/7wshOZep2A70/aQU6QBRWJO/G6FT1wIns=
|
||||
github.com/jhump/protoreflect v1.17.0 h1:qOEr613fac2lOuTgWN4tPAtLL7fUSbuJL5X5XumQh94=
|
||||
@@ -29,20 +44,38 @@ github.com/oklog/run v1.1.0/go.mod h1:sVPdnTZT1zYwAJeCMu2Th4T21pA3FPOQRfWjQlk7DV
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.7.2 h1:4jaiDzPyXQvSd7D0EjG45355tLlV3VOECpq10pLC+8s=
|
||||
github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
|
||||
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
|
||||
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
|
||||
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
|
||||
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
|
||||
golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
|
||||
golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
|
||||
golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
|
||||
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
|
||||
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
|
||||
golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
|
||||
golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
|
||||
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
|
||||
golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
|
||||
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
|
||||
golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0=
|
||||
golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w=
|
||||
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
||||
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
|
||||
golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=
|
||||
golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=
|
||||
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
|
||||
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||
gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
|
||||
gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20260706201446-f0a921348800 h1:qEHAMpSaUhtD0p3NbEEI83HwNGFxEwaSJ1G9PLnCBZE=
|
||||
|
||||
@@ -0,0 +1,173 @@
|
||||
package forge
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Config is what the host hands a forge extension once, after launch.
|
||||
type Config struct {
|
||||
Host string
|
||||
Token string
|
||||
Settings map[string]string
|
||||
}
|
||||
|
||||
// Issue is an issue (never a pull request).
|
||||
type Issue struct {
|
||||
Number int
|
||||
Title string
|
||||
Body string
|
||||
Labels []string
|
||||
}
|
||||
|
||||
// Forge is the capability every forge extension has.
|
||||
type Forge interface {
|
||||
AssignedIssues(ctx context.Context, owner, repo, assignee string) ([]Issue, error)
|
||||
IssuesWithLabel(ctx context.Context, owner, repo, label string) ([]Issue, error)
|
||||
Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error)
|
||||
CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error
|
||||
React(ctx context.Context, owner, repo string, number int, reaction string) error
|
||||
// SetStateLabel makes label the issue's only state label, removing any
|
||||
// other label in knownLabels first. An empty label clears them.
|
||||
SetStateLabel(ctx context.Context, owner, repo string, number int, label string, knownLabels []string)
|
||||
CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error)
|
||||
// PRState is "open", "merged" or "closed".
|
||||
PRState(ctx context.Context, owner, repo string, number int) (string, error)
|
||||
AcceptInvitations(ctx context.Context) error
|
||||
VerifyPush(ctx context.Context, owner, repo string) error
|
||||
LinkBranch(ctx context.Context, owner, repo string, issueNumber int, branch string) error
|
||||
}
|
||||
|
||||
// PullRequest summarises an existing pull request.
|
||||
type PullRequest struct {
|
||||
Number int
|
||||
Title string
|
||||
Body string
|
||||
HeadRef string
|
||||
BaseRef string
|
||||
HeadSHA string
|
||||
BaseSHA string
|
||||
State string
|
||||
}
|
||||
|
||||
// PullRequestReader, PullRequestDiffReader, RepoArchiveReader, ReviewReader,
|
||||
// ReviewCommentWriter and WebhookParser are optional: an extension implements
|
||||
// the ones its forge supports and the host sees the rest as unsupported.
|
||||
type PullRequestReader interface {
|
||||
GetPullRequest(ctx context.Context, owner, repo string, number int) (PullRequest, error)
|
||||
}
|
||||
|
||||
type PullRequestDiffReader interface {
|
||||
GetPullRequestDiff(ctx context.Context, owner, repo string, number int) (string, error)
|
||||
}
|
||||
|
||||
type RepoArchiveReader interface {
|
||||
GetRepoArchive(ctx context.Context, owner, repo, ref string) (io.ReadCloser, error)
|
||||
}
|
||||
|
||||
// Review states, normalised across forges.
|
||||
const (
|
||||
ReviewStateApproved = "approved"
|
||||
ReviewStateRequestedChanges = "requested_changes"
|
||||
ReviewStateCommented = "commented"
|
||||
ReviewStateDismissed = "dismissed"
|
||||
)
|
||||
|
||||
type Review struct {
|
||||
ID int64
|
||||
Author string
|
||||
State string
|
||||
Body string
|
||||
SubmittedAt time.Time
|
||||
}
|
||||
|
||||
type ReviewComment struct {
|
||||
ID int64
|
||||
ReviewID int64
|
||||
Author string
|
||||
Body string
|
||||
Path string
|
||||
Line int
|
||||
InReplyTo int64
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
type ReviewReader interface {
|
||||
ListReviews(ctx context.Context, owner, repo string, number int, sinceID int64) ([]Review, error)
|
||||
ListReviewComments(ctx context.Context, owner, repo string, number int, sinceID int64) ([]ReviewComment, error)
|
||||
ReplyToReview(ctx context.Context, owner, repo string, number int, commentID int64, body string) error
|
||||
}
|
||||
|
||||
type InlineReviewComment struct {
|
||||
Path string
|
||||
Line int
|
||||
Body string
|
||||
}
|
||||
|
||||
type ReviewCommentWriter interface {
|
||||
CreateReviewComments(ctx context.Context, owner, repo string, number int, reviewedHeadSHA string, comments []InlineReviewComment) error
|
||||
}
|
||||
|
||||
// WebhookEvent is a decoded delivery; at most one field is set.
|
||||
type WebhookEvent struct {
|
||||
Issue *IssueEvent
|
||||
Review *ReviewEvent
|
||||
ReviewComment *ReviewCommentEvent
|
||||
}
|
||||
|
||||
type IssueEvent struct {
|
||||
Action string
|
||||
State string
|
||||
PullRequest bool
|
||||
Owner, Repo string
|
||||
Number int
|
||||
Title, Body string
|
||||
Labels []string
|
||||
Assignees []string
|
||||
}
|
||||
|
||||
type ReviewEvent struct {
|
||||
Action string
|
||||
Owner, Repo string
|
||||
PRNumber int
|
||||
ReviewID int64
|
||||
Author string
|
||||
State string
|
||||
Body string
|
||||
}
|
||||
|
||||
type ReviewCommentEvent struct {
|
||||
Action string
|
||||
Owner, Repo string
|
||||
PRNumber int
|
||||
ReviewID int64
|
||||
CommentID int64
|
||||
Author string
|
||||
Body string
|
||||
Path string
|
||||
Line int
|
||||
}
|
||||
|
||||
// ErrBadWebhook marks a body the forge could not decode.
|
||||
var ErrBadWebhook = errors.New("undecodable webhook payload")
|
||||
|
||||
// WebhookParser decodes a delivery the host has already authenticated.
|
||||
type WebhookParser interface {
|
||||
ParseWebhook(headers map[string]string, body []byte) (WebhookEvent, error)
|
||||
}
|
||||
|
||||
// ReviewHeadDrift is an error when head is no longer reviewedHeadSHA; an empty
|
||||
// reviewedHeadSHA skips the check.
|
||||
func ReviewHeadDrift(owner, repo string, number int, head, reviewedHeadSHA string) error {
|
||||
if reviewedHeadSHA == "" || strings.EqualFold(head, reviewedHeadSHA) {
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf(
|
||||
"pull request %s/%s#%d has moved off the reviewed revision (%s): head is now %s, so the line-anchored comments would land on lines they were not measured against",
|
||||
owner, repo, number, reviewedHeadSHA, head,
|
||||
)
|
||||
}
|
||||
+2
-1
@@ -30,7 +30,8 @@ func (*plugin) GRPCClient(context.Context, *goplugin.GRPCBroker, *grpc.ClientCon
|
||||
|
||||
// Serve runs impl as the extension process. It returns when archie-core stops
|
||||
// the extension.
|
||||
func Serve(impl forgev1.ForgeServiceServer) {
|
||||
func Serve(build func(Config) (Forge, error)) {
|
||||
impl := &server{build: build}
|
||||
goplugin.Serve(&goplugin.ServeConfig{
|
||||
HandshakeConfig: goplugin.HandshakeConfig{
|
||||
ProtocolVersion: 1,
|
||||
|
||||
@@ -0,0 +1,318 @@
|
||||
package forge
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
|
||||
"google.golang.org/grpc/codes"
|
||||
"google.golang.org/grpc/status"
|
||||
"google.golang.org/protobuf/types/known/timestamppb"
|
||||
|
||||
forgev1 "github.com/samcharles93/archipelago/sdk/forge/v1"
|
||||
)
|
||||
|
||||
// archiveChunk bounds one message of a streamed archive.
|
||||
const archiveChunk = 256 << 10
|
||||
|
||||
// server adapts a Forge to the gRPC surface. Optional capabilities the Forge
|
||||
// lacks answer UNIMPLEMENTED.
|
||||
type server struct {
|
||||
forgev1.UnimplementedForgeServiceServer
|
||||
build func(Config) (Forge, error)
|
||||
|
||||
mu sync.Mutex
|
||||
f atomic.Pointer[Forge]
|
||||
}
|
||||
|
||||
func (s *server) forge() (Forge, error) {
|
||||
f := s.f.Load()
|
||||
if f == nil {
|
||||
return nil, status.Error(codes.FailedPrecondition, "forge is not configured")
|
||||
}
|
||||
return *f, nil
|
||||
}
|
||||
|
||||
func (s *server) Configure(_ context.Context, r *forgev1.ConfigureRequest) (*forgev1.ConfigureResponse, error) {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
f, err := s.build(Config{Host: r.GetHost(), Token: r.GetToken(), Settings: r.GetSettings()})
|
||||
if err != nil {
|
||||
return nil, status.Error(codes.InvalidArgument, err.Error())
|
||||
}
|
||||
s.f.Store(&f)
|
||||
return &forgev1.ConfigureResponse{}, nil
|
||||
}
|
||||
|
||||
func capability[T any](s *server) (T, error) {
|
||||
var zero T
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return zero, err
|
||||
}
|
||||
c, ok := f.(T)
|
||||
if !ok {
|
||||
return zero, status.Error(codes.Unimplemented, "not supported by this forge")
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func fail(err error) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
if _, ok := status.FromError(err); ok {
|
||||
return err
|
||||
}
|
||||
return status.Error(codes.Unknown, err.Error())
|
||||
}
|
||||
|
||||
func issues(in []Issue) []*forgev1.Issue {
|
||||
out := make([]*forgev1.Issue, 0, len(in))
|
||||
for _, i := range in {
|
||||
out = append(out, &forgev1.Issue{Number: int32(i.Number), Title: i.Title, Body: i.Body, Labels: i.Labels}) //nolint:gosec // issue numbers fit int32
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (s *server) AssignedIssues(ctx context.Context, r *forgev1.AssignedIssuesRequest) (*forgev1.AssignedIssuesResponse, error) {
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out, err := f.AssignedIssues(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), r.GetAssignee())
|
||||
return &forgev1.AssignedIssuesResponse{Issues: issues(out)}, fail(err)
|
||||
}
|
||||
|
||||
func (s *server) IssuesWithLabel(ctx context.Context, r *forgev1.IssuesWithLabelRequest) (*forgev1.IssuesWithLabelResponse, error) {
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out, err := f.IssuesWithLabel(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), r.GetLabel())
|
||||
return &forgev1.IssuesWithLabelResponse{Issues: issues(out)}, fail(err)
|
||||
}
|
||||
|
||||
func (s *server) Comment(ctx context.Context, r *forgev1.CommentRequest) (*forgev1.CommentResponse, error) {
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
id, err := f.Comment(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()), r.GetBody())
|
||||
return &forgev1.CommentResponse{Id: id}, fail(err)
|
||||
}
|
||||
|
||||
func (s *server) CloseIssue(ctx context.Context, r *forgev1.CloseIssueRequest) (*forgev1.CloseIssueResponse, error) {
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &forgev1.CloseIssueResponse{}, fail(f.CloseIssue(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()), r.GetComment()))
|
||||
}
|
||||
|
||||
func (s *server) React(ctx context.Context, r *forgev1.ReactRequest) (*forgev1.ReactResponse, error) {
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &forgev1.ReactResponse{}, fail(f.React(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()), r.GetReaction()))
|
||||
}
|
||||
|
||||
func (s *server) SetStateLabel(ctx context.Context, r *forgev1.SetStateLabelRequest) (*forgev1.SetStateLabelResponse, error) {
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
f.SetStateLabel(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()), r.GetLabel(), r.GetKnownLabels())
|
||||
return &forgev1.SetStateLabelResponse{}, nil
|
||||
}
|
||||
|
||||
func (s *server) CreatePR(ctx context.Context, r *forgev1.CreatePRRequest) (*forgev1.CreatePRResponse, error) {
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
n, err := f.CreatePR(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), r.GetTitle(), r.GetHead(), r.GetBase(), r.GetBody())
|
||||
return &forgev1.CreatePRResponse{Number: int32(n)}, fail(err) //nolint:gosec // issue numbers fit int32
|
||||
}
|
||||
|
||||
func (s *server) PRState(ctx context.Context, r *forgev1.PRStateRequest) (*forgev1.PRStateResponse, error) {
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
state, err := f.PRState(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()))
|
||||
return &forgev1.PRStateResponse{State: state}, fail(err)
|
||||
}
|
||||
|
||||
func (s *server) GetPullRequest(ctx context.Context, r *forgev1.GetPullRequestRequest) (*forgev1.GetPullRequestResponse, error) {
|
||||
c, err := capability[PullRequestReader](s)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pr, err := c.GetPullRequest(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()))
|
||||
if err != nil {
|
||||
return nil, fail(err)
|
||||
}
|
||||
return &forgev1.GetPullRequestResponse{PullRequest: &forgev1.PullRequest{
|
||||
Number: int32(pr.Number), Title: pr.Title, Body: pr.Body, HeadRef: pr.HeadRef, BaseRef: pr.BaseRef, //nolint:gosec // issue numbers fit int32
|
||||
HeadSha: pr.HeadSHA, BaseSha: pr.BaseSHA, State: pr.State,
|
||||
}}, nil
|
||||
}
|
||||
|
||||
func (s *server) GetPullRequestDiff(ctx context.Context, r *forgev1.GetPullRequestDiffRequest) (*forgev1.GetPullRequestDiffResponse, error) {
|
||||
c, err := capability[PullRequestDiffReader](s)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
diff, err := c.GetPullRequestDiff(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()))
|
||||
return &forgev1.GetPullRequestDiffResponse{Diff: diff}, fail(err)
|
||||
}
|
||||
|
||||
func (s *server) ListReviews(ctx context.Context, r *forgev1.ListReviewsRequest) (*forgev1.ListReviewsResponse, error) {
|
||||
c, err := capability[ReviewReader](s)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pr := r.GetPullRequest()
|
||||
reviews, err := c.ListReviews(ctx, pr.GetRepo().GetOwner(), pr.GetRepo().GetRepo(), int(pr.GetNumber()), r.GetSinceId())
|
||||
if err != nil {
|
||||
return nil, fail(err)
|
||||
}
|
||||
out := make([]*forgev1.Review, 0, len(reviews))
|
||||
for _, rv := range reviews {
|
||||
out = append(out, &forgev1.Review{Id: rv.ID, Author: rv.Author, State: rv.State, Body: rv.Body, SubmittedAt: timestamppb.New(rv.SubmittedAt)})
|
||||
}
|
||||
return &forgev1.ListReviewsResponse{Reviews: out}, nil
|
||||
}
|
||||
|
||||
func (s *server) ListReviewComments(ctx context.Context, r *forgev1.ListReviewCommentsRequest) (*forgev1.ListReviewCommentsResponse, error) {
|
||||
c, err := capability[ReviewReader](s)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pr := r.GetPullRequest()
|
||||
comments, err := c.ListReviewComments(ctx, pr.GetRepo().GetOwner(), pr.GetRepo().GetRepo(), int(pr.GetNumber()), r.GetSinceId())
|
||||
if err != nil {
|
||||
return nil, fail(err)
|
||||
}
|
||||
out := make([]*forgev1.ReviewComment, 0, len(comments))
|
||||
for _, cm := range comments {
|
||||
out = append(out, &forgev1.ReviewComment{
|
||||
Id: cm.ID, ReviewId: cm.ReviewID, Author: cm.Author, Body: cm.Body, Path: cm.Path,
|
||||
Line: int32(cm.Line), InReplyTo: cm.InReplyTo, CreatedAt: timestamppb.New(cm.CreatedAt), //nolint:gosec // line numbers fit int32
|
||||
})
|
||||
}
|
||||
return &forgev1.ListReviewCommentsResponse{Comments: out}, nil
|
||||
}
|
||||
|
||||
func (s *server) ReplyToReview(ctx context.Context, r *forgev1.ReplyToReviewRequest) (*forgev1.ReplyToReviewResponse, error) {
|
||||
c, err := capability[ReviewReader](s)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pr := r.GetPullRequest()
|
||||
return &forgev1.ReplyToReviewResponse{}, fail(c.ReplyToReview(ctx, pr.GetRepo().GetOwner(), pr.GetRepo().GetRepo(), int(pr.GetNumber()), r.GetCommentId(), r.GetBody()))
|
||||
}
|
||||
|
||||
func (s *server) CreateReviewComments(ctx context.Context, r *forgev1.CreateReviewCommentsRequest) (*forgev1.CreateReviewCommentsResponse, error) {
|
||||
c, err := capability[ReviewCommentWriter](s)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pr := r.GetPullRequest()
|
||||
comments := make([]InlineReviewComment, 0, len(r.GetComments()))
|
||||
for _, cm := range r.GetComments() {
|
||||
comments = append(comments, InlineReviewComment{Path: cm.GetPath(), Line: int(cm.GetLine()), Body: cm.GetBody()})
|
||||
}
|
||||
return &forgev1.CreateReviewCommentsResponse{}, fail(c.CreateReviewComments(ctx, pr.GetRepo().GetOwner(), pr.GetRepo().GetRepo(), int(pr.GetNumber()), r.GetReviewedHeadSha(), comments))
|
||||
}
|
||||
|
||||
func (s *server) AcceptInvitations(ctx context.Context, _ *forgev1.AcceptInvitationsRequest) (*forgev1.AcceptInvitationsResponse, error) {
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &forgev1.AcceptInvitationsResponse{}, fail(f.AcceptInvitations(ctx))
|
||||
}
|
||||
|
||||
func (s *server) VerifyPush(ctx context.Context, r *forgev1.VerifyPushRequest) (*forgev1.VerifyPushResponse, error) {
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &forgev1.VerifyPushResponse{}, fail(f.VerifyPush(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo()))
|
||||
}
|
||||
|
||||
func (s *server) LinkBranch(ctx context.Context, r *forgev1.LinkBranchRequest) (*forgev1.LinkBranchResponse, error) {
|
||||
f, err := s.forge()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &forgev1.LinkBranchResponse{}, fail(f.LinkBranch(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetIssueNumber()), r.GetBranch()))
|
||||
}
|
||||
|
||||
func (s *server) GetRepoArchive(r *forgev1.GetRepoArchiveRequest, stream forgev1.ForgeService_GetRepoArchiveServer) error {
|
||||
c, err := capability[RepoArchiveReader](s)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
body, err := c.GetRepoArchive(stream.Context(), r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), r.GetRef())
|
||||
if err != nil {
|
||||
return fail(err)
|
||||
}
|
||||
defer func() { _ = body.Close() }()
|
||||
buf := make([]byte, archiveChunk)
|
||||
for {
|
||||
n, rerr := body.Read(buf)
|
||||
if n > 0 {
|
||||
if serr := stream.Send(&forgev1.GetRepoArchiveResponse{Data: buf[:n]}); serr != nil {
|
||||
return serr
|
||||
}
|
||||
}
|
||||
if errors.Is(rerr, io.EOF) {
|
||||
return nil
|
||||
}
|
||||
if rerr != nil {
|
||||
return fail(rerr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *server) ParseWebhook(_ context.Context, r *forgev1.ParseWebhookRequest) (*forgev1.ParseWebhookResponse, error) {
|
||||
c, err := capability[WebhookParser](s)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
event, err := c.ParseWebhook(r.GetHeaders(), r.GetBody())
|
||||
if errors.Is(err, ErrBadWebhook) {
|
||||
return nil, status.Error(codes.InvalidArgument, err.Error())
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fail(err)
|
||||
}
|
||||
repo := func(owner, name string) *forgev1.RepoRef { return &forgev1.RepoRef{Owner: owner, Repo: name} }
|
||||
switch {
|
||||
case event.Issue != nil:
|
||||
i := event.Issue
|
||||
return &forgev1.ParseWebhookResponse{Event: &forgev1.ParseWebhookResponse_Issue{Issue: &forgev1.IssueEvent{
|
||||
Action: i.Action, State: i.State, IsPullRequest: i.PullRequest, Repo: repo(i.Owner, i.Repo), Number: int32(i.Number), //nolint:gosec // issue numbers fit int32
|
||||
Title: i.Title, Body: i.Body, Labels: i.Labels, Assignees: i.Assignees,
|
||||
}}}, nil
|
||||
case event.Review != nil:
|
||||
v := event.Review
|
||||
return &forgev1.ParseWebhookResponse{Event: &forgev1.ParseWebhookResponse_Review{Review: &forgev1.ReviewEvent{
|
||||
Action: v.Action, Repo: repo(v.Owner, v.Repo), PrNumber: int32(v.PRNumber), ReviewId: v.ReviewID, //nolint:gosec // issue numbers fit int32
|
||||
Author: v.Author, State: v.State, Body: v.Body,
|
||||
}}}, nil
|
||||
case event.ReviewComment != nil:
|
||||
c := event.ReviewComment
|
||||
return &forgev1.ParseWebhookResponse{Event: &forgev1.ParseWebhookResponse_ReviewComment{ReviewComment: &forgev1.ReviewCommentEvent{
|
||||
Action: c.Action, Repo: repo(c.Owner, c.Repo), PrNumber: int32(c.PRNumber), ReviewId: c.ReviewID, CommentId: c.CommentID, //nolint:gosec // issue numbers fit int32
|
||||
Author: c.Author, Body: c.Body, Path: c.Path, Line: int32(c.Line), //nolint:gosec // line numbers fit int32
|
||||
}}}, nil
|
||||
}
|
||||
return &forgev1.ParseWebhookResponse{}, nil
|
||||
}
|
||||
+572
-52
@@ -2354,6 +2354,464 @@ func (x *GetRepoArchiveResponse) GetData() []byte {
|
||||
return nil
|
||||
}
|
||||
|
||||
type ParseWebhookRequest struct {
|
||||
state protoimpl.MessageState `protogen:"open.v1"`
|
||||
Headers map[string]string `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
|
||||
Body []byte `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
|
||||
unknownFields protoimpl.UnknownFields
|
||||
sizeCache protoimpl.SizeCache
|
||||
}
|
||||
|
||||
func (x *ParseWebhookRequest) Reset() {
|
||||
*x = ParseWebhookRequest{}
|
||||
mi := &file_forge_v1_forge_proto_msgTypes[45]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
|
||||
func (x *ParseWebhookRequest) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*ParseWebhookRequest) ProtoMessage() {}
|
||||
|
||||
func (x *ParseWebhookRequest) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_forge_v1_forge_proto_msgTypes[45]
|
||||
if x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use ParseWebhookRequest.ProtoReflect.Descriptor instead.
|
||||
func (*ParseWebhookRequest) Descriptor() ([]byte, []int) {
|
||||
return file_forge_v1_forge_proto_rawDescGZIP(), []int{45}
|
||||
}
|
||||
|
||||
func (x *ParseWebhookRequest) GetHeaders() map[string]string {
|
||||
if x != nil {
|
||||
return x.Headers
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *ParseWebhookRequest) GetBody() []byte {
|
||||
if x != nil {
|
||||
return x.Body
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type ParseWebhookResponse struct {
|
||||
state protoimpl.MessageState `protogen:"open.v1"`
|
||||
// Types that are valid to be assigned to Event:
|
||||
//
|
||||
// *ParseWebhookResponse_Issue
|
||||
// *ParseWebhookResponse_Review
|
||||
// *ParseWebhookResponse_ReviewComment
|
||||
Event isParseWebhookResponse_Event `protobuf_oneof:"event"`
|
||||
unknownFields protoimpl.UnknownFields
|
||||
sizeCache protoimpl.SizeCache
|
||||
}
|
||||
|
||||
func (x *ParseWebhookResponse) Reset() {
|
||||
*x = ParseWebhookResponse{}
|
||||
mi := &file_forge_v1_forge_proto_msgTypes[46]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
|
||||
func (x *ParseWebhookResponse) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*ParseWebhookResponse) ProtoMessage() {}
|
||||
|
||||
func (x *ParseWebhookResponse) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_forge_v1_forge_proto_msgTypes[46]
|
||||
if x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use ParseWebhookResponse.ProtoReflect.Descriptor instead.
|
||||
func (*ParseWebhookResponse) Descriptor() ([]byte, []int) {
|
||||
return file_forge_v1_forge_proto_rawDescGZIP(), []int{46}
|
||||
}
|
||||
|
||||
func (x *ParseWebhookResponse) GetEvent() isParseWebhookResponse_Event {
|
||||
if x != nil {
|
||||
return x.Event
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *ParseWebhookResponse) GetIssue() *IssueEvent {
|
||||
if x != nil {
|
||||
if x, ok := x.Event.(*ParseWebhookResponse_Issue); ok {
|
||||
return x.Issue
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *ParseWebhookResponse) GetReview() *ReviewEvent {
|
||||
if x != nil {
|
||||
if x, ok := x.Event.(*ParseWebhookResponse_Review); ok {
|
||||
return x.Review
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *ParseWebhookResponse) GetReviewComment() *ReviewCommentEvent {
|
||||
if x != nil {
|
||||
if x, ok := x.Event.(*ParseWebhookResponse_ReviewComment); ok {
|
||||
return x.ReviewComment
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type isParseWebhookResponse_Event interface {
|
||||
isParseWebhookResponse_Event()
|
||||
}
|
||||
|
||||
type ParseWebhookResponse_Issue struct {
|
||||
Issue *IssueEvent `protobuf:"bytes,1,opt,name=issue,proto3,oneof"`
|
||||
}
|
||||
|
||||
type ParseWebhookResponse_Review struct {
|
||||
Review *ReviewEvent `protobuf:"bytes,2,opt,name=review,proto3,oneof"`
|
||||
}
|
||||
|
||||
type ParseWebhookResponse_ReviewComment struct {
|
||||
ReviewComment *ReviewCommentEvent `protobuf:"bytes,3,opt,name=review_comment,json=reviewComment,proto3,oneof"`
|
||||
}
|
||||
|
||||
func (*ParseWebhookResponse_Issue) isParseWebhookResponse_Event() {}
|
||||
|
||||
func (*ParseWebhookResponse_Review) isParseWebhookResponse_Event() {}
|
||||
|
||||
func (*ParseWebhookResponse_ReviewComment) isParseWebhookResponse_Event() {}
|
||||
|
||||
type IssueEvent struct {
|
||||
state protoimpl.MessageState `protogen:"open.v1"`
|
||||
Action string `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"`
|
||||
State string `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
|
||||
IsPullRequest bool `protobuf:"varint,3,opt,name=is_pull_request,json=isPullRequest,proto3" json:"is_pull_request,omitempty"`
|
||||
Repo *RepoRef `protobuf:"bytes,4,opt,name=repo,proto3" json:"repo,omitempty"`
|
||||
Number int32 `protobuf:"varint,5,opt,name=number,proto3" json:"number,omitempty"`
|
||||
Title string `protobuf:"bytes,6,opt,name=title,proto3" json:"title,omitempty"`
|
||||
Body string `protobuf:"bytes,7,opt,name=body,proto3" json:"body,omitempty"`
|
||||
Labels []string `protobuf:"bytes,8,rep,name=labels,proto3" json:"labels,omitempty"`
|
||||
Assignees []string `protobuf:"bytes,9,rep,name=assignees,proto3" json:"assignees,omitempty"`
|
||||
unknownFields protoimpl.UnknownFields
|
||||
sizeCache protoimpl.SizeCache
|
||||
}
|
||||
|
||||
func (x *IssueEvent) Reset() {
|
||||
*x = IssueEvent{}
|
||||
mi := &file_forge_v1_forge_proto_msgTypes[47]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
|
||||
func (x *IssueEvent) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*IssueEvent) ProtoMessage() {}
|
||||
|
||||
func (x *IssueEvent) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_forge_v1_forge_proto_msgTypes[47]
|
||||
if x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use IssueEvent.ProtoReflect.Descriptor instead.
|
||||
func (*IssueEvent) Descriptor() ([]byte, []int) {
|
||||
return file_forge_v1_forge_proto_rawDescGZIP(), []int{47}
|
||||
}
|
||||
|
||||
func (x *IssueEvent) GetAction() string {
|
||||
if x != nil {
|
||||
return x.Action
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *IssueEvent) GetState() string {
|
||||
if x != nil {
|
||||
return x.State
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *IssueEvent) GetIsPullRequest() bool {
|
||||
if x != nil {
|
||||
return x.IsPullRequest
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (x *IssueEvent) GetRepo() *RepoRef {
|
||||
if x != nil {
|
||||
return x.Repo
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *IssueEvent) GetNumber() int32 {
|
||||
if x != nil {
|
||||
return x.Number
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *IssueEvent) GetTitle() string {
|
||||
if x != nil {
|
||||
return x.Title
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *IssueEvent) GetBody() string {
|
||||
if x != nil {
|
||||
return x.Body
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *IssueEvent) GetLabels() []string {
|
||||
if x != nil {
|
||||
return x.Labels
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *IssueEvent) GetAssignees() []string {
|
||||
if x != nil {
|
||||
return x.Assignees
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type ReviewEvent struct {
|
||||
state protoimpl.MessageState `protogen:"open.v1"`
|
||||
Action string `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"`
|
||||
Repo *RepoRef `protobuf:"bytes,2,opt,name=repo,proto3" json:"repo,omitempty"`
|
||||
PrNumber int32 `protobuf:"varint,3,opt,name=pr_number,json=prNumber,proto3" json:"pr_number,omitempty"`
|
||||
ReviewId int64 `protobuf:"varint,4,opt,name=review_id,json=reviewId,proto3" json:"review_id,omitempty"`
|
||||
Author string `protobuf:"bytes,5,opt,name=author,proto3" json:"author,omitempty"`
|
||||
State string `protobuf:"bytes,6,opt,name=state,proto3" json:"state,omitempty"`
|
||||
Body string `protobuf:"bytes,7,opt,name=body,proto3" json:"body,omitempty"`
|
||||
unknownFields protoimpl.UnknownFields
|
||||
sizeCache protoimpl.SizeCache
|
||||
}
|
||||
|
||||
func (x *ReviewEvent) Reset() {
|
||||
*x = ReviewEvent{}
|
||||
mi := &file_forge_v1_forge_proto_msgTypes[48]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
|
||||
func (x *ReviewEvent) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*ReviewEvent) ProtoMessage() {}
|
||||
|
||||
func (x *ReviewEvent) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_forge_v1_forge_proto_msgTypes[48]
|
||||
if x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use ReviewEvent.ProtoReflect.Descriptor instead.
|
||||
func (*ReviewEvent) Descriptor() ([]byte, []int) {
|
||||
return file_forge_v1_forge_proto_rawDescGZIP(), []int{48}
|
||||
}
|
||||
|
||||
func (x *ReviewEvent) GetAction() string {
|
||||
if x != nil {
|
||||
return x.Action
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *ReviewEvent) GetRepo() *RepoRef {
|
||||
if x != nil {
|
||||
return x.Repo
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *ReviewEvent) GetPrNumber() int32 {
|
||||
if x != nil {
|
||||
return x.PrNumber
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *ReviewEvent) GetReviewId() int64 {
|
||||
if x != nil {
|
||||
return x.ReviewId
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *ReviewEvent) GetAuthor() string {
|
||||
if x != nil {
|
||||
return x.Author
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *ReviewEvent) GetState() string {
|
||||
if x != nil {
|
||||
return x.State
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *ReviewEvent) GetBody() string {
|
||||
if x != nil {
|
||||
return x.Body
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
type ReviewCommentEvent struct {
|
||||
state protoimpl.MessageState `protogen:"open.v1"`
|
||||
Action string `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"`
|
||||
Repo *RepoRef `protobuf:"bytes,2,opt,name=repo,proto3" json:"repo,omitempty"`
|
||||
PrNumber int32 `protobuf:"varint,3,opt,name=pr_number,json=prNumber,proto3" json:"pr_number,omitempty"`
|
||||
ReviewId int64 `protobuf:"varint,4,opt,name=review_id,json=reviewId,proto3" json:"review_id,omitempty"`
|
||||
CommentId int64 `protobuf:"varint,5,opt,name=comment_id,json=commentId,proto3" json:"comment_id,omitempty"`
|
||||
Author string `protobuf:"bytes,6,opt,name=author,proto3" json:"author,omitempty"`
|
||||
Body string `protobuf:"bytes,7,opt,name=body,proto3" json:"body,omitempty"`
|
||||
Path string `protobuf:"bytes,8,opt,name=path,proto3" json:"path,omitempty"`
|
||||
Line int32 `protobuf:"varint,9,opt,name=line,proto3" json:"line,omitempty"`
|
||||
unknownFields protoimpl.UnknownFields
|
||||
sizeCache protoimpl.SizeCache
|
||||
}
|
||||
|
||||
func (x *ReviewCommentEvent) Reset() {
|
||||
*x = ReviewCommentEvent{}
|
||||
mi := &file_forge_v1_forge_proto_msgTypes[49]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
|
||||
func (x *ReviewCommentEvent) String() string {
|
||||
return protoimpl.X.MessageStringOf(x)
|
||||
}
|
||||
|
||||
func (*ReviewCommentEvent) ProtoMessage() {}
|
||||
|
||||
func (x *ReviewCommentEvent) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_forge_v1_forge_proto_msgTypes[49]
|
||||
if x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return mi.MessageOf(x)
|
||||
}
|
||||
|
||||
// Deprecated: Use ReviewCommentEvent.ProtoReflect.Descriptor instead.
|
||||
func (*ReviewCommentEvent) Descriptor() ([]byte, []int) {
|
||||
return file_forge_v1_forge_proto_rawDescGZIP(), []int{49}
|
||||
}
|
||||
|
||||
func (x *ReviewCommentEvent) GetAction() string {
|
||||
if x != nil {
|
||||
return x.Action
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *ReviewCommentEvent) GetRepo() *RepoRef {
|
||||
if x != nil {
|
||||
return x.Repo
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (x *ReviewCommentEvent) GetPrNumber() int32 {
|
||||
if x != nil {
|
||||
return x.PrNumber
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *ReviewCommentEvent) GetReviewId() int64 {
|
||||
if x != nil {
|
||||
return x.ReviewId
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *ReviewCommentEvent) GetCommentId() int64 {
|
||||
if x != nil {
|
||||
return x.CommentId
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (x *ReviewCommentEvent) GetAuthor() string {
|
||||
if x != nil {
|
||||
return x.Author
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *ReviewCommentEvent) GetBody() string {
|
||||
if x != nil {
|
||||
return x.Body
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *ReviewCommentEvent) GetPath() string {
|
||||
if x != nil {
|
||||
return x.Path
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (x *ReviewCommentEvent) GetLine() int32 {
|
||||
if x != nil {
|
||||
return x.Line
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
var File_forge_v1_forge_proto protoreflect.FileDescriptor
|
||||
|
||||
const file_forge_v1_forge_proto_rawDesc = "" +
|
||||
@@ -2497,7 +2955,48 @@ const file_forge_v1_forge_proto_rawDesc = "" +
|
||||
"\x04repo\x18\x01 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x10\n" +
|
||||
"\x03ref\x18\x02 \x01(\tR\x03ref\",\n" +
|
||||
"\x16GetRepoArchiveResponse\x12\x12\n" +
|
||||
"\x04data\x18\x01 \x01(\fR\x04data2\xfc\v\n" +
|
||||
"\x04data\x18\x01 \x01(\fR\x04data\"\xab\x01\n" +
|
||||
"\x13ParseWebhookRequest\x12D\n" +
|
||||
"\aheaders\x18\x01 \x03(\v2*.forge.v1.ParseWebhookRequest.HeadersEntryR\aheaders\x12\x12\n" +
|
||||
"\x04body\x18\x02 \x01(\fR\x04body\x1a:\n" +
|
||||
"\fHeadersEntry\x12\x10\n" +
|
||||
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
|
||||
"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xc5\x01\n" +
|
||||
"\x14ParseWebhookResponse\x12,\n" +
|
||||
"\x05issue\x18\x01 \x01(\v2\x14.forge.v1.IssueEventH\x00R\x05issue\x12/\n" +
|
||||
"\x06review\x18\x02 \x01(\v2\x15.forge.v1.ReviewEventH\x00R\x06review\x12E\n" +
|
||||
"\x0ereview_comment\x18\x03 \x01(\v2\x1c.forge.v1.ReviewCommentEventH\x00R\rreviewCommentB\a\n" +
|
||||
"\x05event\"\x81\x02\n" +
|
||||
"\n" +
|
||||
"IssueEvent\x12\x16\n" +
|
||||
"\x06action\x18\x01 \x01(\tR\x06action\x12\x14\n" +
|
||||
"\x05state\x18\x02 \x01(\tR\x05state\x12&\n" +
|
||||
"\x0fis_pull_request\x18\x03 \x01(\bR\risPullRequest\x12%\n" +
|
||||
"\x04repo\x18\x04 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x16\n" +
|
||||
"\x06number\x18\x05 \x01(\x05R\x06number\x12\x14\n" +
|
||||
"\x05title\x18\x06 \x01(\tR\x05title\x12\x12\n" +
|
||||
"\x04body\x18\a \x01(\tR\x04body\x12\x16\n" +
|
||||
"\x06labels\x18\b \x03(\tR\x06labels\x12\x1c\n" +
|
||||
"\tassignees\x18\t \x03(\tR\tassignees\"\xc8\x01\n" +
|
||||
"\vReviewEvent\x12\x16\n" +
|
||||
"\x06action\x18\x01 \x01(\tR\x06action\x12%\n" +
|
||||
"\x04repo\x18\x02 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x1b\n" +
|
||||
"\tpr_number\x18\x03 \x01(\x05R\bprNumber\x12\x1b\n" +
|
||||
"\treview_id\x18\x04 \x01(\x03R\breviewId\x12\x16\n" +
|
||||
"\x06author\x18\x05 \x01(\tR\x06author\x12\x14\n" +
|
||||
"\x05state\x18\x06 \x01(\tR\x05state\x12\x12\n" +
|
||||
"\x04body\x18\a \x01(\tR\x04body\"\x80\x02\n" +
|
||||
"\x12ReviewCommentEvent\x12\x16\n" +
|
||||
"\x06action\x18\x01 \x01(\tR\x06action\x12%\n" +
|
||||
"\x04repo\x18\x02 \x01(\v2\x11.forge.v1.RepoRefR\x04repo\x12\x1b\n" +
|
||||
"\tpr_number\x18\x03 \x01(\x05R\bprNumber\x12\x1b\n" +
|
||||
"\treview_id\x18\x04 \x01(\x03R\breviewId\x12\x1d\n" +
|
||||
"\n" +
|
||||
"comment_id\x18\x05 \x01(\x03R\tcommentId\x12\x16\n" +
|
||||
"\x06author\x18\x06 \x01(\tR\x06author\x12\x12\n" +
|
||||
"\x04body\x18\a \x01(\tR\x04body\x12\x12\n" +
|
||||
"\x04path\x18\b \x01(\tR\x04path\x12\x12\n" +
|
||||
"\x04line\x18\t \x01(\x05R\x04line2\xcb\f\n" +
|
||||
"\fForgeService\x12D\n" +
|
||||
"\tConfigure\x12\x1a.forge.v1.ConfigureRequest\x1a\x1b.forge.v1.ConfigureResponse\x12S\n" +
|
||||
"\x0eAssignedIssues\x12\x1f.forge.v1.AssignedIssuesRequest\x1a .forge.v1.AssignedIssuesResponse\x12V\n" +
|
||||
@@ -2519,7 +3018,8 @@ const file_forge_v1_forge_proto_rawDesc = "" +
|
||||
"\n" +
|
||||
"VerifyPush\x12\x1b.forge.v1.VerifyPushRequest\x1a\x1c.forge.v1.VerifyPushResponse\x12G\n" +
|
||||
"\n" +
|
||||
"LinkBranch\x12\x1b.forge.v1.LinkBranchRequest\x1a\x1c.forge.v1.LinkBranchResponse\x12U\n" +
|
||||
"LinkBranch\x12\x1b.forge.v1.LinkBranchRequest\x1a\x1c.forge.v1.LinkBranchResponse\x12M\n" +
|
||||
"\fParseWebhook\x12\x1d.forge.v1.ParseWebhookRequest\x1a\x1e.forge.v1.ParseWebhookResponse\x12U\n" +
|
||||
"\x0eGetRepoArchive\x12\x1f.forge.v1.GetRepoArchiveRequest\x1a .forge.v1.GetRepoArchiveResponse0\x01B\x95\x01\n" +
|
||||
"\fcom.forge.v1B\n" +
|
||||
"ForgeProtoP\x01Z8github.com/samcharles93/archipelago/sdk/forge/v1;forgev1\xa2\x02\x03FXX\xaa\x02\bForge.V1\xca\x02\bForge\\V1\xe2\x02\x14Forge\\V1\\GPBMetadata\xea\x02\tForge::V1b\x06proto3"
|
||||
@@ -2536,7 +3036,7 @@ func file_forge_v1_forge_proto_rawDescGZIP() []byte {
|
||||
return file_forge_v1_forge_proto_rawDescData
|
||||
}
|
||||
|
||||
var file_forge_v1_forge_proto_msgTypes = make([]protoimpl.MessageInfo, 46)
|
||||
var file_forge_v1_forge_proto_msgTypes = make([]protoimpl.MessageInfo, 52)
|
||||
var file_forge_v1_forge_proto_goTypes = []any{
|
||||
(*ConfigureRequest)(nil), // 0: forge.v1.ConfigureRequest
|
||||
(*ConfigureResponse)(nil), // 1: forge.v1.ConfigureResponse
|
||||
@@ -2583,11 +3083,17 @@ var file_forge_v1_forge_proto_goTypes = []any{
|
||||
(*VerifyPushResponse)(nil), // 42: forge.v1.VerifyPushResponse
|
||||
(*GetRepoArchiveRequest)(nil), // 43: forge.v1.GetRepoArchiveRequest
|
||||
(*GetRepoArchiveResponse)(nil), // 44: forge.v1.GetRepoArchiveResponse
|
||||
nil, // 45: forge.v1.ConfigureRequest.SettingsEntry
|
||||
(*timestamppb.Timestamp)(nil), // 46: google.protobuf.Timestamp
|
||||
(*ParseWebhookRequest)(nil), // 45: forge.v1.ParseWebhookRequest
|
||||
(*ParseWebhookResponse)(nil), // 46: forge.v1.ParseWebhookResponse
|
||||
(*IssueEvent)(nil), // 47: forge.v1.IssueEvent
|
||||
(*ReviewEvent)(nil), // 48: forge.v1.ReviewEvent
|
||||
(*ReviewCommentEvent)(nil), // 49: forge.v1.ReviewCommentEvent
|
||||
nil, // 50: forge.v1.ConfigureRequest.SettingsEntry
|
||||
nil, // 51: forge.v1.ParseWebhookRequest.HeadersEntry
|
||||
(*timestamppb.Timestamp)(nil), // 52: google.protobuf.Timestamp
|
||||
}
|
||||
var file_forge_v1_forge_proto_depIdxs = []int32{
|
||||
45, // 0: forge.v1.ConfigureRequest.settings:type_name -> forge.v1.ConfigureRequest.SettingsEntry
|
||||
50, // 0: forge.v1.ConfigureRequest.settings:type_name -> forge.v1.ConfigureRequest.SettingsEntry
|
||||
2, // 1: forge.v1.PullRequestRef.repo:type_name -> forge.v1.RepoRef
|
||||
4, // 2: forge.v1.AssignedIssuesResponse.issues:type_name -> forge.v1.Issue
|
||||
4, // 3: forge.v1.IssuesWithLabelResponse.issues:type_name -> forge.v1.Issue
|
||||
@@ -2603,9 +3109,9 @@ var file_forge_v1_forge_proto_depIdxs = []int32{
|
||||
21, // 13: forge.v1.GetPullRequestResponse.pull_request:type_name -> forge.v1.PullRequest
|
||||
2, // 14: forge.v1.GetPullRequestDiffRequest.repo:type_name -> forge.v1.RepoRef
|
||||
3, // 15: forge.v1.ListReviewsRequest.pull_request:type_name -> forge.v1.PullRequestRef
|
||||
46, // 16: forge.v1.Review.submitted_at:type_name -> google.protobuf.Timestamp
|
||||
52, // 16: forge.v1.Review.submitted_at:type_name -> google.protobuf.Timestamp
|
||||
27, // 17: forge.v1.ListReviewsResponse.reviews:type_name -> forge.v1.Review
|
||||
46, // 18: forge.v1.ReviewComment.created_at:type_name -> google.protobuf.Timestamp
|
||||
52, // 18: forge.v1.ReviewComment.created_at:type_name -> google.protobuf.Timestamp
|
||||
3, // 19: forge.v1.ListReviewCommentsRequest.pull_request:type_name -> forge.v1.PullRequestRef
|
||||
29, // 20: forge.v1.ListReviewCommentsResponse.comments:type_name -> forge.v1.ReviewComment
|
||||
3, // 21: forge.v1.ReplyToReviewRequest.pull_request:type_name -> forge.v1.PullRequestRef
|
||||
@@ -2614,49 +3120,58 @@ var file_forge_v1_forge_proto_depIdxs = []int32{
|
||||
2, // 24: forge.v1.LinkBranchRequest.repo:type_name -> forge.v1.RepoRef
|
||||
2, // 25: forge.v1.VerifyPushRequest.repo:type_name -> forge.v1.RepoRef
|
||||
2, // 26: forge.v1.GetRepoArchiveRequest.repo:type_name -> forge.v1.RepoRef
|
||||
0, // 27: forge.v1.ForgeService.Configure:input_type -> forge.v1.ConfigureRequest
|
||||
7, // 28: forge.v1.ForgeService.AssignedIssues:input_type -> forge.v1.AssignedIssuesRequest
|
||||
8, // 29: forge.v1.ForgeService.IssuesWithLabel:input_type -> forge.v1.IssuesWithLabelRequest
|
||||
9, // 30: forge.v1.ForgeService.Comment:input_type -> forge.v1.CommentRequest
|
||||
11, // 31: forge.v1.ForgeService.CloseIssue:input_type -> forge.v1.CloseIssueRequest
|
||||
13, // 32: forge.v1.ForgeService.React:input_type -> forge.v1.ReactRequest
|
||||
15, // 33: forge.v1.ForgeService.SetStateLabel:input_type -> forge.v1.SetStateLabelRequest
|
||||
17, // 34: forge.v1.ForgeService.CreatePR:input_type -> forge.v1.CreatePRRequest
|
||||
19, // 35: forge.v1.ForgeService.PRState:input_type -> forge.v1.PRStateRequest
|
||||
22, // 36: forge.v1.ForgeService.GetPullRequest:input_type -> forge.v1.GetPullRequestRequest
|
||||
24, // 37: forge.v1.ForgeService.GetPullRequestDiff:input_type -> forge.v1.GetPullRequestDiffRequest
|
||||
26, // 38: forge.v1.ForgeService.ListReviews:input_type -> forge.v1.ListReviewsRequest
|
||||
30, // 39: forge.v1.ForgeService.ListReviewComments:input_type -> forge.v1.ListReviewCommentsRequest
|
||||
32, // 40: forge.v1.ForgeService.ReplyToReview:input_type -> forge.v1.ReplyToReviewRequest
|
||||
35, // 41: forge.v1.ForgeService.CreateReviewComments:input_type -> forge.v1.CreateReviewCommentsRequest
|
||||
39, // 42: forge.v1.ForgeService.AcceptInvitations:input_type -> forge.v1.AcceptInvitationsRequest
|
||||
41, // 43: forge.v1.ForgeService.VerifyPush:input_type -> forge.v1.VerifyPushRequest
|
||||
37, // 44: forge.v1.ForgeService.LinkBranch:input_type -> forge.v1.LinkBranchRequest
|
||||
43, // 45: forge.v1.ForgeService.GetRepoArchive:input_type -> forge.v1.GetRepoArchiveRequest
|
||||
1, // 46: forge.v1.ForgeService.Configure:output_type -> forge.v1.ConfigureResponse
|
||||
5, // 47: forge.v1.ForgeService.AssignedIssues:output_type -> forge.v1.AssignedIssuesResponse
|
||||
6, // 48: forge.v1.ForgeService.IssuesWithLabel:output_type -> forge.v1.IssuesWithLabelResponse
|
||||
10, // 49: forge.v1.ForgeService.Comment:output_type -> forge.v1.CommentResponse
|
||||
12, // 50: forge.v1.ForgeService.CloseIssue:output_type -> forge.v1.CloseIssueResponse
|
||||
14, // 51: forge.v1.ForgeService.React:output_type -> forge.v1.ReactResponse
|
||||
16, // 52: forge.v1.ForgeService.SetStateLabel:output_type -> forge.v1.SetStateLabelResponse
|
||||
18, // 53: forge.v1.ForgeService.CreatePR:output_type -> forge.v1.CreatePRResponse
|
||||
20, // 54: forge.v1.ForgeService.PRState:output_type -> forge.v1.PRStateResponse
|
||||
23, // 55: forge.v1.ForgeService.GetPullRequest:output_type -> forge.v1.GetPullRequestResponse
|
||||
25, // 56: forge.v1.ForgeService.GetPullRequestDiff:output_type -> forge.v1.GetPullRequestDiffResponse
|
||||
28, // 57: forge.v1.ForgeService.ListReviews:output_type -> forge.v1.ListReviewsResponse
|
||||
31, // 58: forge.v1.ForgeService.ListReviewComments:output_type -> forge.v1.ListReviewCommentsResponse
|
||||
33, // 59: forge.v1.ForgeService.ReplyToReview:output_type -> forge.v1.ReplyToReviewResponse
|
||||
36, // 60: forge.v1.ForgeService.CreateReviewComments:output_type -> forge.v1.CreateReviewCommentsResponse
|
||||
40, // 61: forge.v1.ForgeService.AcceptInvitations:output_type -> forge.v1.AcceptInvitationsResponse
|
||||
42, // 62: forge.v1.ForgeService.VerifyPush:output_type -> forge.v1.VerifyPushResponse
|
||||
38, // 63: forge.v1.ForgeService.LinkBranch:output_type -> forge.v1.LinkBranchResponse
|
||||
44, // 64: forge.v1.ForgeService.GetRepoArchive:output_type -> forge.v1.GetRepoArchiveResponse
|
||||
46, // [46:65] is the sub-list for method output_type
|
||||
27, // [27:46] is the sub-list for method input_type
|
||||
27, // [27:27] is the sub-list for extension type_name
|
||||
27, // [27:27] is the sub-list for extension extendee
|
||||
0, // [0:27] is the sub-list for field type_name
|
||||
51, // 27: forge.v1.ParseWebhookRequest.headers:type_name -> forge.v1.ParseWebhookRequest.HeadersEntry
|
||||
47, // 28: forge.v1.ParseWebhookResponse.issue:type_name -> forge.v1.IssueEvent
|
||||
48, // 29: forge.v1.ParseWebhookResponse.review:type_name -> forge.v1.ReviewEvent
|
||||
49, // 30: forge.v1.ParseWebhookResponse.review_comment:type_name -> forge.v1.ReviewCommentEvent
|
||||
2, // 31: forge.v1.IssueEvent.repo:type_name -> forge.v1.RepoRef
|
||||
2, // 32: forge.v1.ReviewEvent.repo:type_name -> forge.v1.RepoRef
|
||||
2, // 33: forge.v1.ReviewCommentEvent.repo:type_name -> forge.v1.RepoRef
|
||||
0, // 34: forge.v1.ForgeService.Configure:input_type -> forge.v1.ConfigureRequest
|
||||
7, // 35: forge.v1.ForgeService.AssignedIssues:input_type -> forge.v1.AssignedIssuesRequest
|
||||
8, // 36: forge.v1.ForgeService.IssuesWithLabel:input_type -> forge.v1.IssuesWithLabelRequest
|
||||
9, // 37: forge.v1.ForgeService.Comment:input_type -> forge.v1.CommentRequest
|
||||
11, // 38: forge.v1.ForgeService.CloseIssue:input_type -> forge.v1.CloseIssueRequest
|
||||
13, // 39: forge.v1.ForgeService.React:input_type -> forge.v1.ReactRequest
|
||||
15, // 40: forge.v1.ForgeService.SetStateLabel:input_type -> forge.v1.SetStateLabelRequest
|
||||
17, // 41: forge.v1.ForgeService.CreatePR:input_type -> forge.v1.CreatePRRequest
|
||||
19, // 42: forge.v1.ForgeService.PRState:input_type -> forge.v1.PRStateRequest
|
||||
22, // 43: forge.v1.ForgeService.GetPullRequest:input_type -> forge.v1.GetPullRequestRequest
|
||||
24, // 44: forge.v1.ForgeService.GetPullRequestDiff:input_type -> forge.v1.GetPullRequestDiffRequest
|
||||
26, // 45: forge.v1.ForgeService.ListReviews:input_type -> forge.v1.ListReviewsRequest
|
||||
30, // 46: forge.v1.ForgeService.ListReviewComments:input_type -> forge.v1.ListReviewCommentsRequest
|
||||
32, // 47: forge.v1.ForgeService.ReplyToReview:input_type -> forge.v1.ReplyToReviewRequest
|
||||
35, // 48: forge.v1.ForgeService.CreateReviewComments:input_type -> forge.v1.CreateReviewCommentsRequest
|
||||
39, // 49: forge.v1.ForgeService.AcceptInvitations:input_type -> forge.v1.AcceptInvitationsRequest
|
||||
41, // 50: forge.v1.ForgeService.VerifyPush:input_type -> forge.v1.VerifyPushRequest
|
||||
37, // 51: forge.v1.ForgeService.LinkBranch:input_type -> forge.v1.LinkBranchRequest
|
||||
45, // 52: forge.v1.ForgeService.ParseWebhook:input_type -> forge.v1.ParseWebhookRequest
|
||||
43, // 53: forge.v1.ForgeService.GetRepoArchive:input_type -> forge.v1.GetRepoArchiveRequest
|
||||
1, // 54: forge.v1.ForgeService.Configure:output_type -> forge.v1.ConfigureResponse
|
||||
5, // 55: forge.v1.ForgeService.AssignedIssues:output_type -> forge.v1.AssignedIssuesResponse
|
||||
6, // 56: forge.v1.ForgeService.IssuesWithLabel:output_type -> forge.v1.IssuesWithLabelResponse
|
||||
10, // 57: forge.v1.ForgeService.Comment:output_type -> forge.v1.CommentResponse
|
||||
12, // 58: forge.v1.ForgeService.CloseIssue:output_type -> forge.v1.CloseIssueResponse
|
||||
14, // 59: forge.v1.ForgeService.React:output_type -> forge.v1.ReactResponse
|
||||
16, // 60: forge.v1.ForgeService.SetStateLabel:output_type -> forge.v1.SetStateLabelResponse
|
||||
18, // 61: forge.v1.ForgeService.CreatePR:output_type -> forge.v1.CreatePRResponse
|
||||
20, // 62: forge.v1.ForgeService.PRState:output_type -> forge.v1.PRStateResponse
|
||||
23, // 63: forge.v1.ForgeService.GetPullRequest:output_type -> forge.v1.GetPullRequestResponse
|
||||
25, // 64: forge.v1.ForgeService.GetPullRequestDiff:output_type -> forge.v1.GetPullRequestDiffResponse
|
||||
28, // 65: forge.v1.ForgeService.ListReviews:output_type -> forge.v1.ListReviewsResponse
|
||||
31, // 66: forge.v1.ForgeService.ListReviewComments:output_type -> forge.v1.ListReviewCommentsResponse
|
||||
33, // 67: forge.v1.ForgeService.ReplyToReview:output_type -> forge.v1.ReplyToReviewResponse
|
||||
36, // 68: forge.v1.ForgeService.CreateReviewComments:output_type -> forge.v1.CreateReviewCommentsResponse
|
||||
40, // 69: forge.v1.ForgeService.AcceptInvitations:output_type -> forge.v1.AcceptInvitationsResponse
|
||||
42, // 70: forge.v1.ForgeService.VerifyPush:output_type -> forge.v1.VerifyPushResponse
|
||||
38, // 71: forge.v1.ForgeService.LinkBranch:output_type -> forge.v1.LinkBranchResponse
|
||||
46, // 72: forge.v1.ForgeService.ParseWebhook:output_type -> forge.v1.ParseWebhookResponse
|
||||
44, // 73: forge.v1.ForgeService.GetRepoArchive:output_type -> forge.v1.GetRepoArchiveResponse
|
||||
54, // [54:74] is the sub-list for method output_type
|
||||
34, // [34:54] is the sub-list for method input_type
|
||||
34, // [34:34] is the sub-list for extension type_name
|
||||
34, // [34:34] is the sub-list for extension extendee
|
||||
0, // [0:34] is the sub-list for field type_name
|
||||
}
|
||||
|
||||
func init() { file_forge_v1_forge_proto_init() }
|
||||
@@ -2664,13 +3179,18 @@ func file_forge_v1_forge_proto_init() {
|
||||
if File_forge_v1_forge_proto != nil {
|
||||
return
|
||||
}
|
||||
file_forge_v1_forge_proto_msgTypes[46].OneofWrappers = []any{
|
||||
(*ParseWebhookResponse_Issue)(nil),
|
||||
(*ParseWebhookResponse_Review)(nil),
|
||||
(*ParseWebhookResponse_ReviewComment)(nil),
|
||||
}
|
||||
type x struct{}
|
||||
out := protoimpl.TypeBuilder{
|
||||
File: protoimpl.DescBuilder{
|
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
||||
RawDescriptor: unsafe.Slice(unsafe.StringData(file_forge_v1_forge_proto_rawDesc), len(file_forge_v1_forge_proto_rawDesc)),
|
||||
NumEnums: 0,
|
||||
NumMessages: 46,
|
||||
NumMessages: 52,
|
||||
NumExtensions: 0,
|
||||
NumServices: 1,
|
||||
},
|
||||
|
||||
@@ -37,6 +37,7 @@ const (
|
||||
ForgeService_AcceptInvitations_FullMethodName = "/forge.v1.ForgeService/AcceptInvitations"
|
||||
ForgeService_VerifyPush_FullMethodName = "/forge.v1.ForgeService/VerifyPush"
|
||||
ForgeService_LinkBranch_FullMethodName = "/forge.v1.ForgeService/LinkBranch"
|
||||
ForgeService_ParseWebhook_FullMethodName = "/forge.v1.ForgeService/ParseWebhook"
|
||||
ForgeService_GetRepoArchive_FullMethodName = "/forge.v1.ForgeService/GetRepoArchive"
|
||||
)
|
||||
|
||||
@@ -71,6 +72,10 @@ type ForgeServiceClient interface {
|
||||
AcceptInvitations(ctx context.Context, in *AcceptInvitationsRequest, opts ...grpc.CallOption) (*AcceptInvitationsResponse, error)
|
||||
VerifyPush(ctx context.Context, in *VerifyPushRequest, opts ...grpc.CallOption) (*VerifyPushResponse, error)
|
||||
LinkBranch(ctx context.Context, in *LinkBranchRequest, opts ...grpc.CallOption) (*LinkBranchResponse, error)
|
||||
// ParseWebhook decodes one webhook delivery the host has already
|
||||
// authenticated. A delivery that is not an event the host acts on returns no
|
||||
// event; an undecodable body is INVALID_ARGUMENT.
|
||||
ParseWebhook(ctx context.Context, in *ParseWebhookRequest, opts ...grpc.CallOption) (*ParseWebhookResponse, error)
|
||||
// GetRepoArchive streams a gzipped tar of the repository at a ref.
|
||||
GetRepoArchive(ctx context.Context, in *GetRepoArchiveRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetRepoArchiveResponse], error)
|
||||
}
|
||||
@@ -263,6 +268,16 @@ func (c *forgeServiceClient) LinkBranch(ctx context.Context, in *LinkBranchReque
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *forgeServiceClient) ParseWebhook(ctx context.Context, in *ParseWebhookRequest, opts ...grpc.CallOption) (*ParseWebhookResponse, error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
out := new(ParseWebhookResponse)
|
||||
err := c.cc.Invoke(ctx, ForgeService_ParseWebhook_FullMethodName, in, out, cOpts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *forgeServiceClient) GetRepoArchive(ctx context.Context, in *GetRepoArchiveRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GetRepoArchiveResponse], error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
stream, err := c.cc.NewStream(ctx, &ForgeService_ServiceDesc.Streams[0], ForgeService_GetRepoArchive_FullMethodName, cOpts...)
|
||||
@@ -313,6 +328,10 @@ type ForgeServiceServer interface {
|
||||
AcceptInvitations(context.Context, *AcceptInvitationsRequest) (*AcceptInvitationsResponse, error)
|
||||
VerifyPush(context.Context, *VerifyPushRequest) (*VerifyPushResponse, error)
|
||||
LinkBranch(context.Context, *LinkBranchRequest) (*LinkBranchResponse, error)
|
||||
// ParseWebhook decodes one webhook delivery the host has already
|
||||
// authenticated. A delivery that is not an event the host acts on returns no
|
||||
// event; an undecodable body is INVALID_ARGUMENT.
|
||||
ParseWebhook(context.Context, *ParseWebhookRequest) (*ParseWebhookResponse, error)
|
||||
// GetRepoArchive streams a gzipped tar of the repository at a ref.
|
||||
GetRepoArchive(*GetRepoArchiveRequest, grpc.ServerStreamingServer[GetRepoArchiveResponse]) error
|
||||
mustEmbedUnimplementedForgeServiceServer()
|
||||
@@ -379,6 +398,9 @@ func (UnimplementedForgeServiceServer) VerifyPush(context.Context, *VerifyPushRe
|
||||
func (UnimplementedForgeServiceServer) LinkBranch(context.Context, *LinkBranchRequest) (*LinkBranchResponse, error) {
|
||||
return nil, status.Error(codes.Unimplemented, "method LinkBranch not implemented")
|
||||
}
|
||||
func (UnimplementedForgeServiceServer) ParseWebhook(context.Context, *ParseWebhookRequest) (*ParseWebhookResponse, error) {
|
||||
return nil, status.Error(codes.Unimplemented, "method ParseWebhook not implemented")
|
||||
}
|
||||
func (UnimplementedForgeServiceServer) GetRepoArchive(*GetRepoArchiveRequest, grpc.ServerStreamingServer[GetRepoArchiveResponse]) error {
|
||||
return status.Error(codes.Unimplemented, "method GetRepoArchive not implemented")
|
||||
}
|
||||
@@ -727,6 +749,24 @@ func _ForgeService_LinkBranch_Handler(srv interface{}, ctx context.Context, dec
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _ForgeService_ParseWebhook_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(ParseWebhookRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(ForgeServiceServer).ParseWebhook(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: ForgeService_ParseWebhook_FullMethodName,
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(ForgeServiceServer).ParseWebhook(ctx, req.(*ParseWebhookRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _ForgeService_GetRepoArchive_Handler(srv interface{}, stream grpc.ServerStream) error {
|
||||
m := new(GetRepoArchiveRequest)
|
||||
if err := stream.RecvMsg(m); err != nil {
|
||||
@@ -817,6 +857,10 @@ var ForgeService_ServiceDesc = grpc.ServiceDesc{
|
||||
MethodName: "LinkBranch",
|
||||
Handler: _ForgeService_LinkBranch_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "ParseWebhook",
|
||||
Handler: _ForgeService_ParseWebhook_Handler,
|
||||
},
|
||||
},
|
||||
Streams: []grpc.StreamDesc{
|
||||
{
|
||||
|
||||
Reference in new issue
Block a user