363 lines
13 KiB
Go
363 lines
13 KiB
Go
package forge
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"sync"
|
|
"sync/atomic"
|
|
|
|
"google.golang.org/genproto/googleapis/rpc/errdetails"
|
|
"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
|
|
}
|
|
if errors.Is(err, errors.ErrUnsupported) {
|
|
return status.Error(codes.Unimplemented, err.Error())
|
|
}
|
|
if errors.Is(err, ErrBlockedByDependencies) {
|
|
return blockedByDependencies(err)
|
|
}
|
|
return status.Error(codes.Unknown, err.Error())
|
|
}
|
|
|
|
// blockedByDependencies carries the refusal as a FailedPrecondition with an
|
|
// ErrorInfo detail, which the host reads to tell a dependency block from a
|
|
// generic failure.
|
|
func blockedByDependencies(err error) error {
|
|
st := status.New(codes.FailedPrecondition, err.Error())
|
|
withDetails, derr := st.WithDetails(&errdetails.ErrorInfo{Reason: "BLOCKED_BY_DEPENDENCIES", Domain: "archie.forge"})
|
|
if derr != nil {
|
|
return st.Err()
|
|
}
|
|
return withDetails.Err()
|
|
}
|
|
|
|
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, Author: i.Author}) //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) CreateIssue(ctx context.Context, r *forgev1.CreateIssueRequest) (*forgev1.CreateIssueResponse, error) {
|
|
f, err := s.forge()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
number, err := f.CreateIssue(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), r.GetTitle(), r.GetBody(), r.GetLabels())
|
|
return &forgev1.CreateIssueResponse{Number: int32(number)}, fail(err) // issue numbers fit int32
|
|
}
|
|
|
|
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) ClosePR(ctx context.Context, r *forgev1.ClosePRRequest) (*forgev1.ClosePRResponse, error) {
|
|
f, err := s.forge()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &forgev1.ClosePRResponse{}, fail(f.ClosePR(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber()), r.GetComment()))
|
|
}
|
|
|
|
func (s *server) MergePR(ctx context.Context, r *forgev1.MergePRRequest) (*forgev1.MergePRResponse, error) {
|
|
f, err := s.forge()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &forgev1.MergePRResponse{}, fail(f.MergePR(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), int(r.GetNumber())))
|
|
}
|
|
|
|
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) HasWriteAccess(ctx context.Context, r *forgev1.HasWriteAccessRequest) (*forgev1.HasWriteAccessResponse, error) {
|
|
c, err := capability[WriteAccessChecker](s)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
write, err := c.HasWriteAccess(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo(), r.GetUser())
|
|
return &forgev1.HasWriteAccessResponse{Write: write}, fail(err)
|
|
}
|
|
|
|
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
|
|
}
|
|
event := r.GetEvent()
|
|
switch event {
|
|
case "":
|
|
event = ReviewEventComment
|
|
case ReviewEventComment, ReviewEventRequestChanges:
|
|
default:
|
|
return nil, status.Errorf(codes.InvalidArgument, "review event %q is not COMMENT or REQUEST_CHANGES", event)
|
|
}
|
|
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(), ReviewSubmission{Event: event, Body: r.GetBody(), Comments: comments}))
|
|
}
|
|
|
|
func (s *server) AcceptInvitations(ctx context.Context, r *forgev1.AcceptInvitationsRequest) (*forgev1.AcceptInvitationsResponse, error) {
|
|
f, err := s.forge()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
repos := make([]RepoRef, 0, len(r.GetRepositories()))
|
|
for _, repo := range r.GetRepositories() {
|
|
repos = append(repos, RepoRef{Owner: repo.GetOwner(), Repo: repo.GetRepo()})
|
|
}
|
|
return &forgev1.AcceptInvitationsResponse{}, fail(f.AcceptInvitations(ctx, repos))
|
|
}
|
|
|
|
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) GitCredential(ctx context.Context, r *forgev1.GitCredentialRequest) (*forgev1.GitCredentialResponse, error) {
|
|
c, err := capability[GitCredentialIssuer](s)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
cred, err := c.GitCredential(ctx, r.GetRepo().GetOwner(), r.GetRepo().GetRepo())
|
|
if err != nil {
|
|
return nil, fail(err)
|
|
}
|
|
return &forgev1.GitCredentialResponse{
|
|
Username: cred.Username, Token: cred.Token, ExpiresAt: timestamppb.New(cred.ExpiresAt),
|
|
CommitName: cred.CommitName, CommitEmail: cred.CommitEmail,
|
|
}, nil
|
|
}
|