From 60c0f19e63dd15b872145ed89a73fefb73837542 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Fri, 13 Nov 2026 03:46:22 +1100 Subject: [PATCH] fix(forge): a close refused for open dependencies is a typed error across the boundary (#1922) --- go.mod | 2 +- .../domain/workflow/close_blocked_test.go | 4 +- internal/domain/workflow/control_steps.go | 4 +- internal/forge/forge.go | 6 ++ internal/forgerpc/forgerpc.go | 74 ++++++++++--------- internal/infrastructure/forgeext/forgeext.go | 21 ++++++ internal/natsrpc/natsrpc.go | 40 +++++++++- internal/natsrpc/natsrpc_test.go | 44 +++++++++++ 8 files changed, 156 insertions(+), 39 deletions(-) create mode 100644 internal/natsrpc/natsrpc_test.go diff --git a/go.mod b/go.mod index b17283f1c..b59d08080 100644 --- a/go.mod +++ b/go.mod @@ -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 diff --git a/internal/domain/workflow/close_blocked_test.go b/internal/domain/workflow/close_blocked_test.go index 5eb93359e..57df9f7d5 100644 --- a/internal/domain/workflow/close_blocked_test.go +++ b/internal/domain/workflow/close_blocked_test.go @@ -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 { diff --git a/internal/domain/workflow/control_steps.go b/internal/domain/workflow/control_steps.go index b2eeaabd4..7d60511f4 100644 --- a/internal/domain/workflow/control_steps.go +++ b/internal/domain/workflow/control_steps.go @@ -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) diff --git a/internal/forge/forge.go b/internal/forge/forge.go index 170dc6a25..59e136549 100644 --- a/internal/forge/forge.go +++ b/internal/forge/forge.go @@ -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 diff --git a/internal/forgerpc/forgerpc.go b/internal/forgerpc/forgerpc.go index b1453a92d..13cc07315 100644 --- a/internal/forgerpc/forgerpc.go +++ b/internal/forgerpc/forgerpc.go @@ -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) } diff --git a/internal/infrastructure/forgeext/forgeext.go b/internal/infrastructure/forgeext/forgeext.go index e88b2665a..a5dd7b1b7 100644 --- a/internal/infrastructure/forgeext/forgeext.go +++ b/internal/infrastructure/forgeext/forgeext.go @@ -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 { diff --git a/internal/natsrpc/natsrpc.go b/internal/natsrpc/natsrpc.go index baaa671ae..cfc617ccb 100644 --- a/internal/natsrpc/natsrpc.go +++ b/internal/natsrpc/natsrpc.go @@ -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 diff --git a/internal/natsrpc/natsrpc_test.go b/internal/natsrpc/natsrpc_test.go new file mode 100644 index 000000000..47218d684 --- /dev/null +++ b/internal/natsrpc/natsrpc_test.go @@ -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()) + } + }) + } +}