Files
archipelago/sdk/forge/server.go
T
2026-11-13 03:51:42 +11:00

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
}