505 lines
18 KiB
Go
505 lines
18 KiB
Go
// Package forgerpc lets archie-agent call the workflow.Forger methods over
|
|
// NATS request/reply, so only archied holds forge credentials.
|
|
package forgerpc
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"slices"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/nats-io/nats.go"
|
|
|
|
domainidentity "github.com/samcharles93/archie-core/internal/domain/identity"
|
|
"github.com/samcharles93/archie-core/internal/domain/storepkg"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
|
"github.com/samcharles93/archie-core/internal/forge"
|
|
"github.com/samcharles93/archie-core/internal/natsrpc"
|
|
)
|
|
|
|
const (
|
|
SubjectComment = "archie.forge.comment"
|
|
SubjectCreateIssue = "archie.forge.create_issue"
|
|
SubjectCloseIssue = "archie.forge.close_issue"
|
|
SubjectCreatePR = "archie.forge.create_pr"
|
|
SubjectLinkBranch = "archie.forge.link_branch"
|
|
SubjectSetStateLabel = "archie.forge.set_state_label"
|
|
SubjectCreateReviewComment = "archie.forge.create_review_comments"
|
|
SubjectReplyToReview = "archie.forge.reply_to_review"
|
|
)
|
|
|
|
// errorCodes is the wire table for forge sentinels; server and client must
|
|
// share it so a refusal reaches the caller as the same sentinel.
|
|
var errorCodes = map[string]error{"blocked_by_dependencies": forge.ErrBlockedByDependencies}
|
|
|
|
func envelope(err error) natsrpc.Envelope { return natsrpc.NewEnvelopeWith(err, errorCodes) }
|
|
|
|
// Subjects returns every forge RPC subject identity's server answers: the
|
|
// set a task of that identity may publish to.
|
|
func Subjects(identity string) []string {
|
|
bases := []string{
|
|
SubjectComment, SubjectCreateIssue, SubjectCloseIssue, SubjectCreatePR,
|
|
SubjectLinkBranch, SubjectSetStateLabel, SubjectCreateReviewComment,
|
|
SubjectReplyToReview,
|
|
}
|
|
out := make([]string, len(bases))
|
|
for i, base := range bases {
|
|
out[i] = SubjectFor(identity, base)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// SubjectFor returns base scoped to identity.
|
|
func SubjectFor(identity, base string) string {
|
|
// Keyed by the identity's ID, not its name: a name may hold characters a
|
|
// subject cannot, and both ends derive the same ID from the name.
|
|
return "archie.forge." + string(domainidentity.StableID(identity)) + "." + strings.TrimPrefix(base, "archie.forge.")
|
|
}
|
|
|
|
// Target is what every request acts on and the credential that authorizes
|
|
// it: the run credential of the task asking, which only reaches that task's
|
|
// own repository.
|
|
type Target struct {
|
|
Credential string
|
|
Owner, Repo string
|
|
}
|
|
|
|
// Runs resolves a run credential to the task it was issued for.
|
|
type Runs interface {
|
|
TaskForCredential(ctx context.Context, token string) (*workflow.Task, error)
|
|
}
|
|
|
|
type CommentRequest struct {
|
|
Target
|
|
Number int
|
|
Body string
|
|
}
|
|
|
|
type CommentResponse struct {
|
|
ID int64 `json:"id"`
|
|
natsrpc.Envelope
|
|
}
|
|
|
|
type CreateIssueRequest struct {
|
|
Target
|
|
Title, Body string
|
|
Labels []string
|
|
}
|
|
|
|
type CreateIssueResponse struct {
|
|
Number int `json:"number"`
|
|
natsrpc.Envelope
|
|
}
|
|
|
|
type CloseIssueRequest struct {
|
|
Target
|
|
Number int
|
|
Comment string
|
|
}
|
|
|
|
type CreatePRRequest struct {
|
|
Target
|
|
Title, Head, Base, Body string
|
|
}
|
|
|
|
type CreatePRResponse struct {
|
|
Number int `json:"number"`
|
|
natsrpc.Envelope
|
|
}
|
|
|
|
type LinkBranchRequest struct {
|
|
Target
|
|
IssueNumber int
|
|
Branch string
|
|
}
|
|
|
|
type SetStateLabelRequest struct {
|
|
Target
|
|
Number int
|
|
Label string
|
|
KnownLabels []string
|
|
}
|
|
|
|
// CreateReviewCommentsRequest is one review: its event, body and
|
|
// line-anchored comments.
|
|
type CreateReviewCommentsRequest struct {
|
|
Target
|
|
Number int
|
|
// ReviewedHeadSHA is the revision the line numbers were measured on.
|
|
ReviewedHeadSHA string
|
|
Event string
|
|
Body string
|
|
Comments []InlineReviewCommentPayload
|
|
}
|
|
|
|
// InlineReviewCommentPayload is one comment on the wire.
|
|
type InlineReviewCommentPayload struct {
|
|
Path string
|
|
Line int
|
|
Body string
|
|
}
|
|
|
|
// ReplyToReviewRequest carries one threaded reply to a review comment.
|
|
type ReplyToReviewRequest struct {
|
|
Target
|
|
Number int
|
|
CommentID int64
|
|
Body string
|
|
}
|
|
|
|
// Response is a bare success/error envelope for calls with no return value.
|
|
type Response struct {
|
|
natsrpc.Envelope
|
|
}
|
|
|
|
// Authorities answers what operator accepted for an installed package. A
|
|
// package that is not installed, or not accepted, has no authority.
|
|
type Authorities interface {
|
|
AcceptedAuthority(ctx context.Context, name string) (storepkg.Authority, error)
|
|
}
|
|
|
|
// Server proxies forgerpc requests to a real forge.Forge implementation.
|
|
type Server struct {
|
|
Resolve func(context.Context, *workflow.Task) (forge.Forge, error)
|
|
Runs Runs
|
|
Authorities Authorities
|
|
Log *slog.Logger
|
|
}
|
|
|
|
// RegisterFor registers all handlers under the subjects scoped to identity.
|
|
func (s *Server) RegisterFor(ctx context.Context, nc *nats.Conn, identity string) (unsubscribe func(), err error) {
|
|
as := func(h func(context.Context, string, *nats.Msg)) func(context.Context, *nats.Msg) {
|
|
return func(ctx context.Context, msg *nats.Msg) {
|
|
scoped := identity
|
|
if identity == "*" {
|
|
scoped = strings.Split(msg.Subject, ".")[2]
|
|
}
|
|
h(ctx, scoped, msg)
|
|
}
|
|
}
|
|
return natsrpc.RegisterAll(ctx, nc, []natsrpc.Registration{
|
|
{Subject: serverSubject(identity, SubjectComment), Handler: as(s.handleComment)},
|
|
{Subject: serverSubject(identity, SubjectCreateIssue), Handler: as(s.handleCreateIssue)},
|
|
{Subject: serverSubject(identity, SubjectCloseIssue), Handler: as(s.handleCloseIssue)},
|
|
{Subject: serverSubject(identity, SubjectCreatePR), Handler: as(s.handleCreatePR)},
|
|
{Subject: serverSubject(identity, SubjectLinkBranch), Handler: as(s.handleLinkBranch)},
|
|
{Subject: serverSubject(identity, SubjectSetStateLabel), Handler: as(s.handleSetStateLabel)},
|
|
{Subject: serverSubject(identity, SubjectCreateReviewComment), Handler: as(s.handleCreateReviewComments)},
|
|
{Subject: serverSubject(identity, SubjectReplyToReview), Handler: as(s.handleReplyToReview)},
|
|
})
|
|
}
|
|
|
|
// authorize checks that target's credential belongs to a live run of this
|
|
// server's identity and that the run's repository is the one targeted. A run
|
|
// of a package's workflow also needs the forge permission accepted for that
|
|
// package.
|
|
func (s *Server) authorize(ctx context.Context, identity string, target Target, permission string) error {
|
|
if s.Runs == nil || target.Credential == "" {
|
|
return errors.New("forge request needs a run credential")
|
|
}
|
|
task, err := s.Runs.TaskForCredential(ctx, target.Credential)
|
|
if err != nil {
|
|
return fmt.Errorf("forge request credential is invalid: %w", err)
|
|
}
|
|
if (task.Identity != identity && domainidentity.StableID(task.Identity) != domainidentity.IdentityID(identity)) || task.Owner == "" ||
|
|
!strings.EqualFold(task.Owner, target.Owner) || !strings.EqualFold(task.Repo, target.Repo) {
|
|
return errors.New("forge request is outside its run's repository")
|
|
}
|
|
if task.IsTestRun() {
|
|
return errors.New("a test run records deliveries instead of performing them")
|
|
}
|
|
name := workflow.PackageOf(task.WorkflowDefinitionYAML)
|
|
if name == "" {
|
|
return nil
|
|
}
|
|
if s.Authorities == nil {
|
|
return fmt.Errorf("package %q: forge permission %q is not accepted", name, permission)
|
|
}
|
|
accepted, err := s.Authorities.AcceptedAuthority(ctx, name)
|
|
if err != nil {
|
|
return fmt.Errorf("package %q authority: %w", name, err)
|
|
}
|
|
if !slices.Contains(accepted.ForgePermissions, permission) {
|
|
return fmt.Errorf("package %q: forge permission %q is not accepted", name, permission)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func serverSubject(identity, base string) string {
|
|
if identity == "*" {
|
|
return "archie.forge.*." + strings.TrimPrefix(base, "archie.forge.")
|
|
}
|
|
return SubjectFor(identity, base)
|
|
}
|
|
|
|
func (s *Server) authorizedForge(ctx context.Context, identity string, target Target, permission string) (forge.Forge, error) {
|
|
if err := s.authorize(ctx, identity, target, permission); err != nil {
|
|
return nil, err
|
|
}
|
|
if s.Resolve == nil {
|
|
return nil, errors.New("forge connection unavailable")
|
|
}
|
|
task, err := s.Runs.TaskForCredential(ctx, target.Credential)
|
|
if err != nil {
|
|
return nil, errors.New("forge request credential is invalid")
|
|
}
|
|
return s.Resolve(ctx, task)
|
|
}
|
|
|
|
func (s *Server) handleComment(ctx context.Context, identity string, msg *nats.Msg) {
|
|
var req CommentRequest
|
|
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
|
s.respond(msg, CommentResponse{Envelope: envelope(fmt.Errorf("decode comment request: %w", err))})
|
|
return
|
|
}
|
|
client, err := s.authorizedForge(ctx, identity, req.Target, "comment")
|
|
if err != nil {
|
|
s.respond(msg, CommentResponse{Envelope: envelope(err)})
|
|
return
|
|
}
|
|
id, err := client.Comment(ctx, req.Owner, req.Repo, req.Number, req.Body)
|
|
s.respond(msg, CommentResponse{ID: id, Envelope: envelope(err)})
|
|
}
|
|
|
|
func (s *Server) handleCreateIssue(ctx context.Context, identity string, msg *nats.Msg) {
|
|
var req CreateIssueRequest
|
|
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
|
s.respond(msg, CreateIssueResponse{Envelope: envelope(fmt.Errorf("decode create_issue request: %w", err))})
|
|
return
|
|
}
|
|
client, err := s.authorizedForge(ctx, identity, req.Target, "comment")
|
|
if err != nil {
|
|
s.respond(msg, CreateIssueResponse{Envelope: envelope(err)})
|
|
return
|
|
}
|
|
number, err := client.CreateIssue(ctx, req.Owner, req.Repo, req.Title, req.Body, req.Labels)
|
|
s.respond(msg, CreateIssueResponse{Number: number, Envelope: envelope(err)})
|
|
}
|
|
|
|
func (s *Server) handleCloseIssue(ctx context.Context, identity string, msg *nats.Msg) {
|
|
var req CloseIssueRequest
|
|
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
|
s.respond(msg, Response{Envelope: envelope(fmt.Errorf("decode close_issue request: %w", err))})
|
|
return
|
|
}
|
|
client, err := s.authorizedForge(ctx, identity, req.Target, "comment")
|
|
if err != nil {
|
|
s.respond(msg, Response{Envelope: envelope(err)})
|
|
return
|
|
}
|
|
err = client.CloseIssue(ctx, req.Owner, req.Repo, req.Number, req.Comment)
|
|
s.respond(msg, Response{Envelope: envelope(err)})
|
|
}
|
|
|
|
func (s *Server) handleCreatePR(ctx context.Context, identity string, msg *nats.Msg) {
|
|
var req CreatePRRequest
|
|
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
|
s.respond(msg, CreatePRResponse{Envelope: envelope(fmt.Errorf("decode create_pr request: %w", err))})
|
|
return
|
|
}
|
|
client, err := s.authorizedForge(ctx, identity, req.Target, "open_pr")
|
|
if err != nil {
|
|
s.respond(msg, CreatePRResponse{Envelope: envelope(err)})
|
|
return
|
|
}
|
|
num, err := client.CreatePR(ctx, req.Owner, req.Repo, req.Title, req.Head, req.Base, req.Body)
|
|
s.respond(msg, CreatePRResponse{Number: num, Envelope: envelope(err)})
|
|
}
|
|
|
|
func (s *Server) handleLinkBranch(ctx context.Context, identity string, msg *nats.Msg) {
|
|
var req LinkBranchRequest
|
|
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
|
s.respond(msg, Response{Envelope: envelope(fmt.Errorf("decode link_branch request: %w", err))})
|
|
return
|
|
}
|
|
client, err := s.authorizedForge(ctx, identity, req.Target, "open_pr")
|
|
if err != nil {
|
|
s.respond(msg, Response{Envelope: envelope(err)})
|
|
return
|
|
}
|
|
err = client.LinkBranch(ctx, req.Owner, req.Repo, req.IssueNumber, req.Branch)
|
|
s.respond(msg, Response{Envelope: envelope(err)})
|
|
}
|
|
|
|
func (s *Server) handleCreateReviewComments(ctx context.Context, identity string, msg *nats.Msg) {
|
|
var req CreateReviewCommentsRequest
|
|
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
|
s.respond(msg, Response{Envelope: envelope(fmt.Errorf("decode create_review_comments request: %w", err))})
|
|
return
|
|
}
|
|
client, err := s.authorizedForge(ctx, identity, req.Target, "review")
|
|
if err != nil {
|
|
s.respond(msg, Response{Envelope: envelope(err)})
|
|
return
|
|
}
|
|
writer, ok := client.(forge.ReviewCommentWriter)
|
|
if !ok {
|
|
s.respond(msg, Response{Envelope: envelope(errors.New("this forge cannot post review comments"))})
|
|
return
|
|
}
|
|
comments := make([]forge.InlineReviewComment, 0, len(req.Comments))
|
|
for _, cm := range req.Comments {
|
|
comments = append(comments, forge.InlineReviewComment{Path: cm.Path, Line: cm.Line, Body: cm.Body})
|
|
}
|
|
review := forge.ReviewSubmission{Event: req.Event, Body: req.Body, Comments: comments}
|
|
err = writer.CreateReviewComments(ctx, req.Owner, req.Repo, req.Number, req.ReviewedHeadSHA, review)
|
|
s.respond(msg, Response{Envelope: envelope(err)})
|
|
}
|
|
|
|
func (s *Server) handleReplyToReview(ctx context.Context, identity string, msg *nats.Msg) {
|
|
var req ReplyToReviewRequest
|
|
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
|
s.respond(msg, Response{Envelope: envelope(fmt.Errorf("decode reply_to_review request: %w", err))})
|
|
return
|
|
}
|
|
client, err := s.authorizedForge(ctx, identity, req.Target, "review")
|
|
if err != nil {
|
|
s.respond(msg, Response{Envelope: envelope(err)})
|
|
return
|
|
}
|
|
reader, ok := client.(forge.PullRequestReviewReader)
|
|
if !ok {
|
|
s.respond(msg, Response{Envelope: envelope(errors.New("this forge cannot reply to reviews"))})
|
|
return
|
|
}
|
|
err = reader.ReplyToReview(ctx, req.Owner, req.Repo, req.Number, req.CommentID, req.Body)
|
|
s.respond(msg, Response{Envelope: envelope(err)})
|
|
}
|
|
|
|
func (s *Server) handleSetStateLabel(ctx context.Context, identity string, msg *nats.Msg) {
|
|
var req SetStateLabelRequest
|
|
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
|
s.respond(msg, Response{Envelope: envelope(fmt.Errorf("decode set_state_label request: %w", err))})
|
|
return
|
|
}
|
|
client, err := s.authorizedForge(ctx, identity, req.Target, "comment")
|
|
if err != nil {
|
|
s.respond(msg, Response{Envelope: envelope(err)})
|
|
return
|
|
}
|
|
err = client.SetStateLabel(ctx, req.Owner, req.Repo, req.Number, req.Label, req.KnownLabels)
|
|
s.respond(msg, Response{Envelope: envelope(err)})
|
|
}
|
|
|
|
func (s *Server) respond(msg *nats.Msg, v any) {
|
|
natsrpc.Respond(msg, s.Log, "forgerpc", v)
|
|
}
|
|
|
|
// Client calls the forgerpc Server from archie-agent's process. It
|
|
// implements the four proxied forge.Forge methods with matching
|
|
// signatures so it can be used as a drop-in for workflow stages.
|
|
type Client struct {
|
|
Conn *nats.Conn
|
|
// Timeout bounds each call when ctx has no deadline of its own.
|
|
Timeout time.Duration
|
|
// Identity scopes this client's calls to one identity's RPC server.
|
|
Identity string
|
|
// Credential is the task's run credential, presented on every call.
|
|
Credential string
|
|
}
|
|
|
|
func (c *Client) target(owner, repo string) Target {
|
|
return Target{Credential: c.Credential, Owner: owner, Repo: repo}
|
|
}
|
|
|
|
func (c *Client) rpc() *natsrpc.Client { return &natsrpc.Client{Conn: c.Conn, Timeout: c.Timeout} }
|
|
|
|
func (c *Client) subject(base string) string { return SubjectFor(c.Identity, base) }
|
|
|
|
func (c *Client) Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error) {
|
|
req := CommentRequest{Target: c.target(owner, repo), Number: number, Body: body}
|
|
resp, err := natsrpc.Call[CommentResponse](ctx, c.rpc(), c.subject(SubjectComment), req)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if err := resp.ErrWith(errorCodes); err != nil {
|
|
return 0, err
|
|
}
|
|
return resp.ID, nil
|
|
}
|
|
|
|
func (c *Client) CreateIssue(ctx context.Context, owner, repo, title, body string, labels []string) (int, error) {
|
|
req := CreateIssueRequest{Target: c.target(owner, repo), Title: title, Body: body, Labels: labels}
|
|
resp, err := natsrpc.Call[CreateIssueResponse](ctx, c.rpc(), c.subject(SubjectCreateIssue), req)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if err := resp.ErrWith(errorCodes); err != nil {
|
|
return 0, err
|
|
}
|
|
return resp.Number, nil
|
|
}
|
|
|
|
func (c *Client) CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error {
|
|
req := CloseIssueRequest{Target: c.target(owner, repo), Number: number, Comment: comment}
|
|
resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectCloseIssue), req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return resp.ErrWith(errorCodes)
|
|
}
|
|
|
|
func (c *Client) CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) {
|
|
req := CreatePRRequest{Target: c.target(owner, repo), Title: title, Head: head, Base: base, Body: body}
|
|
resp, err := natsrpc.Call[CreatePRResponse](ctx, c.rpc(), c.subject(SubjectCreatePR), req)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if err := resp.ErrWith(errorCodes); err != nil {
|
|
return 0, err
|
|
}
|
|
return resp.Number, nil
|
|
}
|
|
|
|
func (c *Client) LinkBranch(ctx context.Context, owner, repo string, issueNumber int, branch string) error {
|
|
req := LinkBranchRequest{Target: c.target(owner, repo), IssueNumber: issueNumber, Branch: branch}
|
|
resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectLinkBranch), req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return resp.ErrWith(errorCodes)
|
|
}
|
|
|
|
// SetStateLabel remains available for RPC compatibility with older workers;
|
|
// the current workflow deliberately never calls it.
|
|
func (c *Client) SetStateLabel(ctx context.Context, owner, repo string, number int, label string, knownLabels []string) error {
|
|
req := SetStateLabelRequest{Target: c.target(owner, repo), Number: number, Label: label, KnownLabels: knownLabels}
|
|
resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectSetStateLabel), req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return resp.ErrWith(errorCodes)
|
|
}
|
|
|
|
// CreateReviewComments submits one review on the PR through the daemon.
|
|
func (c *Client) CreateReviewComments(ctx context.Context, owner, repo string, number int, reviewedHeadSHA string, review workflow.Review) error {
|
|
payload := make([]InlineReviewCommentPayload, 0, len(review.Comments))
|
|
for _, cm := range review.Comments {
|
|
payload = append(payload, InlineReviewCommentPayload{Path: cm.Path, Line: cm.Line, Body: cm.Body})
|
|
}
|
|
req := CreateReviewCommentsRequest{
|
|
Target: c.target(owner, repo), Number: number,
|
|
ReviewedHeadSHA: reviewedHeadSHA, Event: review.Event, Body: review.Body, Comments: payload,
|
|
}
|
|
resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectCreateReviewComment), req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return resp.ErrWith(errorCodes)
|
|
}
|
|
|
|
// ReplyToReview posts a threaded reply to one review comment, on behalf of
|
|
// the remediate workflow.
|
|
func (c *Client) ReplyToReview(ctx context.Context, owner, repo string, number int, commentID int64, body string) error {
|
|
req := ReplyToReviewRequest{Target: c.target(owner, repo), Number: number, CommentID: commentID, Body: body}
|
|
resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectReplyToReview), req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return resp.ErrWith(errorCodes)
|
|
}
|