refactor(state): delete the dead IncrementRetryCount RPC (breaking change, accepted)

IncrementRetryCount had zero production callers -- only tests and the
staterpc plumbing referenced it. taskactions.Service.applyRetry already
uses the atomic RetryTask exclusively, which increments retry_count and
requeues in one transaction.

Unlike ListCaptures/ListUndispatchedCaptures (kept as declared-unconsumed
compatibility surfaces because a rolling deploy could have an old
client/server pairing mid-flight), this repo has one production consumer
(see AGENTS.md's solo-project note), so the breaking removal is accepted
outright rather than deprecated-and-kept. Deleted the Go method, the
storecontract interface entry, the staterpc server/client methods, and the
RPC/messages from state.proto, regenerating the .pb.go/_grpc.pb.go pair.

Test fixtures that used IncrementRetryCount as a setup helper now drive
retry_count through the real path instead: queries_test.go bumps it via
direct SQL (same package, no contract to route through), and
api_tasks_actions_test.go now loops RetryTask+Transition, which exercises
production code instead of a deleted one.
This commit is contained in:
sam committed 2026-09-15 11:24:57 +10:00
1 parent ac38c442d5
commit e84aded3fb
11 files changed
+325 -505

No files matched your search

File diff suppressed because it is too large. Load diff
@@ -37,7 +37,6 @@ const (
StateStoreService_ClearTerminalTasks_FullMethodName = "/state.v1.StateStoreService/ClearTerminalTasks"
StateStoreService_Tasks_FullMethodName = "/state.v1.StateStoreService/Tasks"
StateStoreService_StatusCounts_FullMethodName = "/state.v1.StateStoreService/StatusCounts"
StateStoreService_IncrementRetryCount_FullMethodName = "/state.v1.StateStoreService/IncrementRetryCount"
StateStoreService_InsertEvent_FullMethodName = "/state.v1.StateStoreService/InsertEvent"
StateStoreService_EventsSince_FullMethodName = "/state.v1.StateStoreService/EventsSince"
StateStoreService_TaskEvents_FullMethodName = "/state.v1.StateStoreService/TaskEvents"
@@ -101,7 +100,6 @@ type StateStoreServiceClient interface {
ClearTerminalTasks(ctx context.Context, in *ClearTerminalTasksRequest, opts ...grpc.CallOption) (*ClearTerminalTasksResponse, error)
Tasks(ctx context.Context, in *TasksRequest, opts ...grpc.CallOption) (*TasksResponse, error)
StatusCounts(ctx context.Context, in *StatusCountsRequest, opts ...grpc.CallOption) (*StatusCountsResponse, error)
IncrementRetryCount(ctx context.Context, in *IncrementRetryCountRequest, opts ...grpc.CallOption) (*IncrementRetryCountResponse, error)
// Events
InsertEvent(ctx context.Context, in *InsertEventRequest, opts ...grpc.CallOption) (*InsertEventResponse, error)
EventsSince(ctx context.Context, in *EventsSinceRequest, opts ...grpc.CallOption) (*EventsSinceResponse, error)
@@ -341,16 +339,6 @@ func (c *stateStoreServiceClient) StatusCounts(ctx context.Context, in *StatusCo
return out, nil
}
func (c *stateStoreServiceClient) IncrementRetryCount(ctx context.Context, in *IncrementRetryCountRequest, opts ...grpc.CallOption) (*IncrementRetryCountResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(IncrementRetryCountResponse)
err := c.cc.Invoke(ctx, StateStoreService_IncrementRetryCount_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) InsertEvent(ctx context.Context, in *InsertEventRequest, opts ...grpc.CallOption) (*InsertEventResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(InsertEventResponse)
@@ -675,7 +663,6 @@ type StateStoreServiceServer interface {
ClearTerminalTasks(context.Context, *ClearTerminalTasksRequest) (*ClearTerminalTasksResponse, error)
Tasks(context.Context, *TasksRequest) (*TasksResponse, error)
StatusCounts(context.Context, *StatusCountsRequest) (*StatusCountsResponse, error)
IncrementRetryCount(context.Context, *IncrementRetryCountRequest) (*IncrementRetryCountResponse, error)
// Events
InsertEvent(context.Context, *InsertEventRequest) (*InsertEventResponse, error)
EventsSince(context.Context, *EventsSinceRequest) (*EventsSinceResponse, error)
@@ -789,9 +776,6 @@ func (UnimplementedStateStoreServiceServer) Tasks(context.Context, *TasksRequest
func (UnimplementedStateStoreServiceServer) StatusCounts(context.Context, *StatusCountsRequest) (*StatusCountsResponse, error) {
return nil, status.Error(codes.Unimplemented, "method StatusCounts not implemented")
}
func (UnimplementedStateStoreServiceServer) IncrementRetryCount(context.Context, *IncrementRetryCountRequest) (*IncrementRetryCountResponse, error) {
return nil, status.Error(codes.Unimplemented, "method IncrementRetryCount not implemented")
}
func (UnimplementedStateStoreServiceServer) InsertEvent(context.Context, *InsertEventRequest) (*InsertEventResponse, error) {
return nil, status.Error(codes.Unimplemented, "method InsertEvent not implemented")
}
@@ -1218,24 +1202,6 @@ func _StateStoreService_StatusCounts_Handler(srv interface{}, ctx context.Contex
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_IncrementRetryCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(IncrementRetryCountRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).IncrementRetryCount(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_IncrementRetryCount_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).IncrementRetryCount(ctx, req.(*IncrementRetryCountRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_InsertEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InsertEventRequest)
if err := dec(in); err != nil {
@@ -1787,10 +1753,6 @@ var StateStoreService_ServiceDesc = grpc.ServiceDesc{
MethodName: "StatusCounts",
Handler: _StateStoreService_StatusCounts_Handler,
},
{
MethodName: "IncrementRetryCount",
Handler: _StateStoreService_IncrementRetryCount_Handler,
},
{
MethodName: "InsertEvent",
Handler: _StateStoreService_InsertEvent_Handler,
@@ -72,7 +72,6 @@ type TaskQueries interface {
ClearTerminalTasks(ctx context.Context) (int64, error)
Tasks(ctx context.Context, limit int) ([]task.Task, error)
StatusCounts(ctx context.Context) (map[string]int, error)
IncrementRetryCount(ctx context.Context, taskID int64) error
}
// TaskEvents groups observability and lifecycle methods.
@@ -182,11 +182,6 @@ func (c *Client) StatusCounts(ctx context.Context) (map[string]int, error) {
return out, nil
}
func (c *Client) IncrementRetryCount(ctx context.Context, taskID int64) error {
_, err := c.client.IncrementRetryCount(ctx, &pb.IncrementRetryCountRequest{TaskId: taskID})
return unmapError(err)
}
// Events
func (c *Client) InsertEvent(ctx context.Context, e events.Event) (int64, error) {
@@ -111,9 +111,6 @@ func TestStateStoreConformance(t *testing.T) {
if _, err := c.OpenPRs(ctx); err != nil {
t.Fatalf("OpenPRs: %v", err)
}
if err := c.IncrementRetryCount(ctx, task.ID); err != nil {
t.Fatalf("IncrementRetryCount: %v", err)
}
// TaskEvents / EventsSince / stats.
if evs, err := c.TaskEvents(ctx, task.ID); err != nil || len(evs) != 1 || evs[0].Data["duration_ms"] != 12.0 {
@@ -218,13 +218,6 @@ func (s *server) StatusCounts(ctx context.Context, _ *pb.StatusCountsRequest) (*
return &pb.StatusCountsResponse{Counts: out}, nil
}
func (s *server) IncrementRetryCount(ctx context.Context, r *pb.IncrementRetryCountRequest) (*pb.IncrementRetryCountResponse, error) {
if err := s.deps.Tasks.IncrementRetryCount(ctx, r.TaskId); err != nil {
return nil, s.logErr("IncrementRetryCount", err)
}
return &pb.IncrementRetryCountResponse{}, nil
}
// Events
func (s *server) InsertEvent(ctx context.Context, r *pb.InsertEventRequest) (*pb.InsertEventResponse, error) {
+5 -3
View File
@@ -87,11 +87,13 @@ func TestRequeueFromWaitingHuman(t *testing.T) {
t.Fatalf("Requeue must clear park_reason, got %q", retried.ParkReason)
}
// Verify retry_count is NOT reset by Requeue (it persists).
if err := s.IncrementRetryCount(ctx, task2.ID); err != nil {
// Verify retry_count is NOT reset by Requeue (it persists). Bumped
// directly rather than through RetryTask, which also transitions
// status -- this fixture only needs the counter moved.
if _, err := s.db.ExecContext(ctx, `UPDATE tasks SET retry_count = retry_count + 1 WHERE id = ?`, task2.ID); err != nil {
t.Fatal(err)
}
if err := s.IncrementRetryCount(ctx, task2.ID); err != nil {
if _, err := s.db.ExecContext(ctx, `UPDATE tasks SET retry_count = retry_count + 1 WHERE id = ?`, task2.ID); err != nil {
t.Fatal(err)
}
// Park again and requeue.
-9
View File
@@ -213,15 +213,6 @@ func OpenTest(t interface {
return s
}
// IncrementRetryCount atomically bumps retry_count by 1. Called when an
// operator retries a parked task; the caller enforces max_retries against
// the resulting count.
func (s *Store) IncrementRetryCount(ctx context.Context, taskID int64) error {
_, err := s.db.ExecContext(ctx,
`UPDATE tasks SET retry_count = retry_count + 1, updated_at = datetime('now') WHERE id = ?`, taskID)
return err
}
// EnqueueIssue inserts a new queued task for the issue; returns false if
// the issue is already tracked (the idempotency key is owner/repo/number).
// The task's Source defaults to "forge" (the SQLite column default).
-33
View File
@@ -682,39 +682,6 @@ func TestRequeueRejectsStaleFrom(t *testing.T) {
}
}
func TestIncrementRetryCount(t *testing.T) {
s := openTest(t)
ctx := context.Background()
if _, err := s.EnqueueIssue(ctx, "acme", "todo", 1, "t", "", "", ""); err != nil {
t.Fatal(err)
}
task, err := s.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim = (%v, %v)", task, err)
}
if task.RetryCount != 0 {
t.Fatalf("expected retry_count=0, got %d", task.RetryCount)
}
// Increment twice and verify.
if err := s.IncrementRetryCount(ctx, task.ID); err != nil {
t.Fatal(err)
}
if err := s.IncrementRetryCount(ctx, task.ID); err != nil {
t.Fatal(err)
}
got, err := s.TaskByIssue(ctx, "acme", "todo", 1)
if err != nil || got == nil {
t.Fatalf("TaskByIssue = (%+v, %v)", got, err)
}
if got.RetryCount != 2 {
t.Fatalf("expected retry_count=2, got %d", got.RetryCount)
}
}
func TestRetryTaskAtomicallyRequeuesAndIncrements(t *testing.T) {
s := openTest(t)
ctx := t.Context()
+7 -1
View File
@@ -225,8 +225,14 @@ func TestRetryEnforcesMaxRetries(t *testing.T) {
srv, task, _, _, _ := actionServer(t, workflow.StatusParked, "it broke")
operatorActions(t, srv).cfg = config.NewHolder(config.Config{MaxRetries: tc.maxRetries})
ctx := t.Context()
// Drive retry_count up through the real atomic retry path
// (RetryTask) rather than a raw counter bump, re-parking
// between retries so each call sees the fromStatus it needs.
for range tc.priorCount {
if err := srv.Store.IncrementRetryCount(ctx, task.ID); err != nil {
if err := srv.Store.RetryTask(ctx, task.ID, workflow.StatusParked, ""); err != nil {
t.Fatal(err)
}
if err := srv.Store.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusParked, "re-parked for test fixture"); err != nil {
t.Fatal(err)
}
}
-4
View File
@@ -36,7 +36,6 @@ service StateStoreService {
rpc ClearTerminalTasks(ClearTerminalTasksRequest) returns (ClearTerminalTasksResponse);
rpc Tasks(TasksRequest) returns (TasksResponse);
rpc StatusCounts(StatusCountsRequest) returns (StatusCountsResponse);
rpc IncrementRetryCount(IncrementRetryCountRequest) returns (IncrementRetryCountResponse);
// Events
rpc InsertEvent(InsertEventRequest) returns (InsertEventResponse);
@@ -333,9 +332,6 @@ message TasksResponse { repeated Task tasks = 1; }
message StatusCountsRequest {}
message StatusCountsResponse { map<string, int64> counts = 1; }
message IncrementRetryCountRequest { int64 task_id = 1; }
message IncrementRetryCountResponse {}
message InsertEventRequest { Event event = 1; }
message InsertEventResponse { int64 id = 1; }