fix(forge): a close refused for open dependencies is a typed error across the boundary (#1922)

This commit is contained in:
sam committed 2026-11-13 03:47:34 +11:00
1 parent 65e6bafb23
commit 60c0f19e63
8 files changed
+156 -39

No files matched your search

+1 -1
View File
@@ -63,7 +63,6 @@ require (
golang.org/x/text v0.44.0 // indirect
golang.org/x/time v0.16.0 // indirect
google.golang.org/genproto/googleapis/api v0.0.0-20261110000943-09e21b237f2c // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20261110000943-09e21b237f2c // indirect
)
require (
@@ -106,6 +105,7 @@ require (
golang.org/x/oauth2 v0.38.0
golang.org/x/sys v0.50.0
golang.org/x/term v0.48.0
google.golang.org/genproto/googleapis/rpc v0.0.0-20261110000943-09e21b237f2c
google.golang.org/grpc v1.86.0-dev
google.golang.org/protobuf v1.36.12
gopkg.in/yaml.v3 v3.0.1
@@ -3,10 +3,12 @@ package workflow
import (
"context"
"errors"
"fmt"
"log/slog"
"testing"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/forge"
)
type closeForge struct {
@@ -39,7 +41,7 @@ func TestCloseIssueRefusedForDependenciesRecordsTheDecision(t *testing.T) {
wantLabels int
}{
{name: "closes"},
{name: "open dependencies are commented and labelled", closeErr: errors.New("close issue: it still has open dependencies"), wantComments: 1, wantLabels: 1},
{name: "open dependencies are commented and labelled", closeErr: fmt.Errorf("close issue: %w", forge.ErrBlockedByDependencies), wantComments: 1, wantLabels: 1},
{name: "other failures still park", closeErr: errors.New("forge unreachable"), wantErr: true},
}
for _, tt := range tests {
+3 -1
View File
@@ -3,6 +3,7 @@ package workflow
import (
"context"
"encoding/json"
"errors"
"fmt"
"maps"
"slices"
@@ -11,6 +12,7 @@ import (
"gopkg.in/yaml.v3"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/forge"
)
// Control step types: they decide where the task goes next.
@@ -117,7 +119,7 @@ const blockedLabel = "blocked"
func closeIssueOrRecordBlock(ctx context.Context, tc *TaskContext) error {
t := tc.Task
err := tc.Forge.CloseIssue(ctx, t.Owner, t.Repo, t.IssueNumber, "")
if err == nil || !strings.Contains(strings.ToLower(err.Error()), "dependenc") {
if !errors.Is(err, forge.ErrBlockedByDependencies) {
return err
}
note := fmt.Sprintf("Ready to close, but the forge refused because the issue has open dependencies: %s\n\nClose it once they are resolved.", err)
+6
View File
@@ -5,10 +5,16 @@ package forge
import (
"context"
"errors"
"io"
"time"
)
// ErrBlockedByDependencies is returned by CloseIssue when the forge refuses to
// close an issue that still has open dependencies. Callers match it with
// errors.Is; the forge's own message stays in the error text.
var ErrBlockedByDependencies = errors.New("forge refused: open dependencies")
// Issue is a forge-neutral representation of an issue (not a PR).
type Issue struct {
Number int
+40 -34
View File
@@ -32,6 +32,12 @@ const (
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 {
@@ -247,92 +253,92 @@ func (s *Server) authorizedForge(ctx context.Context, identity string, target Ta
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: natsrpc.NewEnvelope(fmt.Errorf("decode comment request: %w", err))})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(fmt.Errorf("decode create_issue request: %w", err))})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(fmt.Errorf("decode close_issue request: %w", err))})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(fmt.Errorf("decode create_pr request: %w", err))})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(fmt.Errorf("decode link_branch request: %w", err))})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(fmt.Errorf("decode create_review_comments request: %w", err))})
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: natsrpc.NewEnvelope(err)})
s.respond(msg, Response{Envelope: envelope(err)})
return
}
writer, ok := client.(forge.ReviewCommentWriter)
if !ok {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(errors.New("this forge cannot post review comments"))})
s.respond(msg, Response{Envelope: envelope(errors.New("this forge cannot post review comments"))})
return
}
comments := make([]forge.InlineReviewComment, 0, len(req.Comments))
@@ -341,42 +347,42 @@ func (s *Server) handleCreateReviewComments(ctx context.Context, identity string
}
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(fmt.Errorf("decode reply_to_review request: %w", err))})
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: natsrpc.NewEnvelope(err)})
s.respond(msg, Response{Envelope: envelope(err)})
return
}
reader, ok := client.(forge.PullRequestReviewReader)
if !ok {
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(errors.New("this forge cannot reply to reviews"))})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(fmt.Errorf("decode set_state_label request: %w", err))})
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: natsrpc.NewEnvelope(err)})
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: natsrpc.NewEnvelope(err)})
s.respond(msg, Response{Envelope: envelope(err)})
}
func (s *Server) respond(msg *nats.Msg, v any) {
@@ -410,7 +416,7 @@ func (c *Client) Comment(ctx context.Context, owner, repo string, number int, bo
if err != nil {
return 0, err
}
if err := resp.Err(); err != nil {
if err := resp.ErrWith(errorCodes); err != nil {
return 0, err
}
return resp.ID, nil
@@ -422,7 +428,7 @@ func (c *Client) CreateIssue(ctx context.Context, owner, repo, title, body strin
if err != nil {
return 0, err
}
if err := resp.Err(); err != nil {
if err := resp.ErrWith(errorCodes); err != nil {
return 0, err
}
return resp.Number, nil
@@ -434,7 +440,7 @@ func (c *Client) CloseIssue(ctx context.Context, owner, repo string, number int,
if err != nil {
return err
}
return resp.Err()
return resp.ErrWith(errorCodes)
}
func (c *Client) CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) {
@@ -443,7 +449,7 @@ func (c *Client) CreatePR(ctx context.Context, owner, repo, title, head, base, b
if err != nil {
return 0, err
}
if err := resp.Err(); err != nil {
if err := resp.ErrWith(errorCodes); err != nil {
return 0, err
}
return resp.Number, nil
@@ -455,7 +461,7 @@ func (c *Client) LinkBranch(ctx context.Context, owner, repo string, issueNumber
if err != nil {
return err
}
return resp.Err()
return resp.ErrWith(errorCodes)
}
// SetStateLabel remains available for RPC compatibility with older workers;
@@ -466,7 +472,7 @@ func (c *Client) SetStateLabel(ctx context.Context, owner, repo string, number i
if err != nil {
return err
}
return resp.Err()
return resp.ErrWith(errorCodes)
}
// CreateReviewComments submits one review on the PR through the daemon.
@@ -483,7 +489,7 @@ func (c *Client) CreateReviewComments(ctx context.Context, owner, repo string, n
if err != nil {
return err
}
return resp.Err()
return resp.ErrWith(errorCodes)
}
// ReplyToReview posts a threaded reply to one review comment, on behalf of
@@ -494,5 +500,5 @@ func (c *Client) ReplyToReview(ctx context.Context, owner, repo string, number i
if err != nil {
return err
}
return resp.Err()
return resp.ErrWith(errorCodes)
}
@@ -12,6 +12,7 @@ import (
"sync"
goplugin "github.com/hashicorp/go-plugin"
"google.golang.org/genproto/googleapis/rpc/errdetails"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
@@ -136,12 +137,32 @@ func call[T any](ctx context.Context, f *Forge, op string, fn func(forgev1.Forge
if status.Code(err) == codes.Unimplemented {
return zero, fmt.Errorf("this forge does not support %s", op)
}
if blockedByDependencies(err) {
return zero, fmt.Errorf("forge %s: %w: %s", op, forge.ErrBlockedByDependencies, status.Convert(err).Message())
}
if err != nil {
return zero, extensionError{op: op, err: err}
}
return out, nil
}
// blockedReason is the ErrorInfo reason a forge extension attaches to a
// FailedPrecondition close refused for open dependencies.
const blockedReason = "BLOCKED_BY_DEPENDENCIES"
func blockedByDependencies(err error) bool {
st, ok := status.FromError(err)
if !ok || st.Code() != codes.FailedPrecondition {
return false
}
for _, d := range st.Details() {
if info, ok := d.(*errdetails.ErrorInfo); ok && info.GetReason() == blockedReason {
return true
}
}
return false
}
// extensionError prints the extension's own message without the gRPC framing
// around it, and still unwraps to the status for callers that branch on it.
type extensionError struct {
+38 -2
View File
@@ -20,24 +20,60 @@ import (
// free instead of hand-rolling an `Error string` field and its checks.
type Envelope struct {
Error string `json:"error,omitempty"`
// Code names a sentinel from the table both ends pass to NewEnvelopeWith
// and ErrWith, so the receiver can match it with errors.Is.
Code string `json:"code,omitempty"`
}
// NewEnvelope builds an Envelope from err, leaving Error empty on nil.
func NewEnvelope(err error) Envelope {
return NewEnvelopeWith(err, nil)
}
// NewEnvelopeWith is NewEnvelope that also sets Code when err wraps one of the
// sentinels in codes (code name to sentinel).
func NewEnvelopeWith(err error, codes map[string]error) Envelope {
if err == nil {
return Envelope{}
}
return Envelope{Error: err.Error()}
env := Envelope{Error: err.Error()}
for code, sentinel := range codes {
if errors.Is(err, sentinel) {
env.Code = code
break
}
}
return env
}
// Err converts a populated Error string back into an error, or nil.
func (e Envelope) Err() error {
return e.ErrWith(nil)
}
// ErrWith is Err that rebuilds the sentinel named by Code from codes, so
// errors.Is matches it. The text is the sender's, unchanged.
func (e Envelope) ErrWith(codes map[string]error) error {
if e.Error == "" {
return nil
}
return errors.New(e.Error)
sentinel, ok := codes[e.Code]
if e.Code == "" || !ok {
return errors.New(e.Error)
}
return codedError{msg: e.Error, sentinel: sentinel}
}
// codedError keeps the sender's message and unwraps to the sentinel. It is not
// fmt.Errorf("%s: %w"), which would repeat the sentinel's text in the message.
type codedError struct {
msg string
sentinel error
}
func (e codedError) Error() string { return e.msg }
func (e codedError) Unwrap() error { return e.sentinel }
// Client sends timeout-bounded NATS request/reply calls.
type Client struct {
Conn *nats.Conn
+44
View File
@@ -0,0 +1,44 @@
package natsrpc
import (
"encoding/json"
"errors"
"fmt"
"testing"
"github.com/samcharles93/archie-core/internal/forge"
)
// TestEnvelopeKeepsSentinel guards that a forge sentinel survives the NATS
// envelope: a caller that matches it with errors.Is on the receiving side must
// get the same answer as on the sending side, with the sender's text kept.
func TestEnvelopeKeepsSentinel(t *testing.T) {
codes := map[string]error{"blocked_by_dependencies": forge.ErrBlockedByDependencies}
tests := []struct {
name string
err error
want bool
}{
{name: "sentinel wrapped", err: fmt.Errorf("close issue: %w", forge.ErrBlockedByDependencies), want: true},
{name: "plain error", err: errors.New("forge unreachable"), want: false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
data, err := json.Marshal(NewEnvelopeWith(tt.err, codes))
if err != nil {
t.Fatalf("marshal envelope: %v", err)
}
var env Envelope
if err := json.Unmarshal(data, &env); err != nil {
t.Fatalf("unmarshal envelope: %v", err)
}
got := env.ErrWith(codes)
if errors.Is(got, forge.ErrBlockedByDependencies) != tt.want {
t.Errorf("errors.Is(%v, sentinel) = %t, want %t", got, !tt.want, tt.want)
}
if got.Error() != tt.err.Error() {
t.Errorf("text = %q, want %q", got.Error(), tt.err.Error())
}
})
}
}