From 35b670ce0db0776bd26591cfbeed654e25cf9207 Mon Sep 17 00:00:00 2001 From: MrTeeett Date: Sun, 15 Nov 2026 13:12:26 +0300 Subject: [PATCH] Propagate cancel watcher deadline errors --- fbconn/cancel_operation_test.go | 99 +++++++++++++++++++++++++++++++++ fbconn/fbconn.go | 32 +++++++---- 2 files changed, 119 insertions(+), 12 deletions(-) create mode 100644 fbconn/cancel_operation_test.go diff --git a/fbconn/cancel_operation_test.go b/fbconn/cancel_operation_test.go new file mode 100644 index 0000000..e7b42bd --- /dev/null +++ b/fbconn/cancel_operation_test.go @@ -0,0 +1,99 @@ +package fbconn + +import ( + "context" + "errors" + "testing" + "time" + + "github.com/firebirdsql/fbx/fbproto" + "github.com/stretchr/testify/require" +) + +type cancelDeadlineErrorConn struct { + noopConn + cancel context.CancelFunc + deadlineSet chan struct{} + setErr error + resetErr error + writeErr error + deadlineResets int +} + +func (c *cancelDeadlineErrorConn) Write(b []byte) (int, error) { + c.cancel() + <-c.deadlineSet + if c.writeErr != nil { + return 0, c.writeErr + } + return len(b), nil +} + +func (c *cancelDeadlineErrorConn) SetDeadline(deadline time.Time) error { + if deadline.IsZero() { + c.deadlineResets++ + return c.resetErr + } + defer close(c.deadlineSet) + return c.setErr +} + +func TestSendCancelOperationDeadlineErrors(t *testing.T) { + setErr := errors.New("set deadline failed") + resetErr := errors.New("reset deadline failed") + writeErr := errors.New("cancel write failed") + for _, tt := range []struct { + name string + setErr error + resetErr error + writeErr error + }{ + {name: "success"}, + {name: "set_error", setErr: setErr}, + {name: "reset_error", resetErr: resetErr}, + {name: "set_and_reset_errors", setErr: setErr, resetErr: resetErr}, + {name: "write_error", writeErr: writeErr}, + {name: "write_and_set_errors", writeErr: writeErr, setErr: setErr}, + {name: "write_and_reset_errors", writeErr: writeErr, resetErr: resetErr}, + {name: "all_errors", writeErr: writeErr, setErr: setErr, resetErr: resetErr}, + } { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + conn := &cancelDeadlineErrorConn{ + cancel: cancel, + deadlineSet: make(chan struct{}), + setErr: tt.setErr, + resetErr: tt.resetErr, + writeErr: tt.writeErr, + } + fbConn := newCancelOperationTestFbConn(conn) + t.Cleanup(func() { + fbConn.asyncClose() + waitCleanupDone(t, fbConn) + }) + + err := fbConn.sendCancelOperation(ctx, fbproto.Fb_cancel_raise) + + for _, wantErr := range []error{tt.setErr, tt.resetErr, tt.writeErr} { + if wantErr != nil { + require.ErrorIs(t, err, wantErr) + } + } + if tt.setErr == nil && tt.resetErr == nil && tt.writeErr == nil { + require.NoError(t, err) + } + require.Equal(t, 1, conn.deadlineResets) + if tt.setErr != nil || tt.resetErr != nil { + require.True(t, conn.closed.Load()) + require.True(t, fbConn.IsClosed()) + require.ErrorIs(t, fbConn.lock(), ErrConnClosed) + waitCleanupDone(t, fbConn) + } else { + require.False(t, fbConn.IsClosed()) + require.False(t, conn.closed.Load()) + } + }) + } +} diff --git a/fbconn/fbconn.go b/fbconn/fbconn.go index bdce366..49a15d3 100644 --- a/fbconn/fbconn.go +++ b/fbconn/fbconn.go @@ -1843,26 +1843,30 @@ func (fbConn *FbConn) internalPrepareTx( } // CancelRequest sends a cancel request to the server. It returns an error if unable to deliver the cancel -// request, but lack of an error does not ensure that the query was canceled. Delivery errors do not close the -// connection; callers that consider a failed cancel request fatal must close the connection themselves. +// request, but lack of an error does not ensure that the query was canceled. If setting or clearing a context +// cancellation deadline fails, the connection is closed. Other delivery errors do not close the connection; +// callers that consider a failed cancel request fatal must close the connection themselves. func (fbConn *FbConn) CancelRequest(ctx context.Context) error { return fbConn.sendCancelOperation(ctx, fbproto.Fb_cancel_raise) } -func (fbConn *FbConn) sendCancelOperation(ctx context.Context, kind int) error { +func (fbConn *FbConn) sendCancelOperation(ctx context.Context, kind int) (err error) { if ctx != context.Background() { - contextWatcher := ctxwatch.NewContextWatcher(&DeadlineContextWatcherHandler{Conn: fbConn.conn}) + handler := &DeadlineContextWatcherHandler{Conn: fbConn.conn} + contextWatcher := ctxwatch.NewContextWatcher(handler) contextWatcher.Watch(ctx) - defer contextWatcher.Unwatch() + defer func() { + contextWatcher.Unwatch() + if handler.err != nil { + fbConn.asyncClose() + err = operationerror.Join(err, handler.err) + } + }() } - if err := fbConn.withWriteLockAndFlush(func() error { + return fbConn.withWriteLockAndFlush(func() error { return fbConn.client.WriteMessage(&fbproto.OpCancel{Kind: kind}) - }); err != nil { - return err - } - - return nil + }) } // ExecImmediate executes statement immediate inside internal transaction @@ -3268,16 +3272,20 @@ type DeadlineContextWatcherHandler struct { // DeadlineDelay is the delay to set on the deadline set on net.Conn when the context is canceled. DeadlineDelay time.Duration + + err error } func (h *DeadlineContextWatcherHandler) HandleCancel(ctx context.Context) { - if err := h.Conn.SetDeadline(time.Now().Add(h.DeadlineDelay)); err != nil { + h.err = h.Conn.SetDeadline(time.Now().Add(h.DeadlineDelay)) + if h.err != nil { _ = h.Conn.Close() } } func (h *DeadlineContextWatcherHandler) HandleUnwatchAfterCancel() { if err := h.Conn.SetDeadline(time.Time{}); err != nil { + h.err = operationerror.Join(h.err, err) _ = h.Conn.Close() } }