Skip to content

Commit 3c979bb

Browse files
bendortonbendorton
committed
Normalize context cancellation errors
1 parent ac9ba37 commit 3c979bb

File tree

3 files changed

+277
-6
lines changed

3 files changed

+277
-6
lines changed

‎config.go

Lines changed: 16 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -6,12 +6,13 @@ import (
66
)
77

88
type configuration struct {
9-
txOptions *sql.TxOptions
10-
splitStatement bool
11-
panicOnBindError bool
12-
stackTraceOnError bool
13-
parameterPrefix string
14-
retrySleep time.Duration
9+
txOptions *sql.TxOptions
10+
splitStatement bool
11+
panicOnBindError bool
12+
normalizeContextCancellation bool
13+
stackTraceOnError bool
14+
parameterPrefix string
15+
retrySleep time.Duration
1516
}
1617

1718
func NewPool(handle *sql.DB, options ...option) ConnectionPool {
@@ -31,6 +32,10 @@ func newPool(handle *sql.DB, config configuration) ConnectionPool {
3132
pool = NewSplitStatementConnectionPool(pool, config.parameterPrefix)
3233
}
3334

35+
if config.normalizeContextCancellation {
36+
pool = NewNormalizeContextCancellationConnectionPool(pool)
37+
}
38+
3439
if config.stackTraceOnError {
3540
pool = NewStackTraceConnectionPool(pool)
3641
}
@@ -59,6 +64,9 @@ func (singleton) TxOptions(value *sql.TxOptions) option {
5964
func (singleton) PanicOnBindError(value bool) option {
6065
return func(this *configuration) { this.panicOnBindError = value }
6166
}
67+
func (singleton) NormalizeContextCancellation(value bool) option {
68+
return func(this *configuration) { this.normalizeContextCancellation = value }
69+
}
6270
func (singleton) MySQL() option {
6371
return func(this *configuration) { this.splitStatement = true; this.parameterPrefix = "?" }
6472
}
@@ -86,13 +94,15 @@ func (singleton) defaults(options ...option) []option {
8694
var defaultTxOptions = &sql.TxOptions{Isolation: sql.LevelReadCommitted}
8795
const defaultStackTraceErrDiagnostics = true
8896
const defaultPanicOnBindError = true
97+
const defaultNormalizeContextCancellation = true
8998
const defaultSplitStatement = true
9099
const defaultParameterPrefix = "?"
91100
const defaultRetrySleep = 0
92101

93102
return append([]option{
94103
Options.TxOptions(defaultTxOptions),
95104
Options.PanicOnBindError(defaultPanicOnBindError),
105+
Options.NormalizeContextCancellation(defaultNormalizeContextCancellation),
96106
Options.StackTraceErrDiagnostics(defaultStackTraceErrDiagnostics),
97107
Options.ParameterPrefix(defaultParameterPrefix),
98108
Options.SplitStatement(defaultSplitStatement),

‎normalize_context_cancellation_connection_pool.go

Lines changed: 55 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,55 @@
1+
package sqldb
2+
3+
import (
4+
"context"
5+
"fmt"
6+
"strings"
7+
)
8+
9+
type NormalizeContextCancellationConnectionPool struct {
10+
inner ConnectionPool
11+
}
12+
13+
func NewNormalizeContextCancellationConnectionPool(inner ConnectionPool) *NormalizeContextCancellationConnectionPool {
14+
return &NormalizeContextCancellationConnectionPool{inner: inner}
15+
}
16+
17+
func (this *NormalizeContextCancellationConnectionPool) Ping(ctx context.Context) error {
18+
return this.normalizeContextCancellationError(this.inner.Ping(ctx))
19+
}
20+
21+
func (this *NormalizeContextCancellationConnectionPool) BeginTransaction(ctx context.Context) (Transaction, error) {
22+
if tx, err := this.inner.BeginTransaction(ctx); err == nil {
23+
return NewStackTraceTransaction(tx), nil
24+
} else {
25+
return nil, this.normalizeContextCancellationError(err)
26+
}
27+
}
28+
29+
func (this *NormalizeContextCancellationConnectionPool) Close() error {
30+
return this.normalizeContextCancellationError(this.inner.Close())
31+
}
32+
33+
func (this *NormalizeContextCancellationConnectionPool) Execute(ctx context.Context, statement string, parameters ...interface{}) (uint64, error) {
34+
affected, err := this.inner.Execute(ctx, statement, parameters...)
35+
return affected, this.normalizeContextCancellationError(err)
36+
}
37+
38+
func (this *NormalizeContextCancellationConnectionPool) Select(ctx context.Context, query string, parameters ...interface{}) (SelectResult, error) {
39+
result, err := this.inner.Select(ctx, query, parameters...)
40+
return result, this.normalizeContextCancellationError(err)
41+
}
42+
43+
// TODO remove manual check of "use of closed network connection" with release of https://github.com/go-sql-driver/mysql/pull/1615
44+
func (this *NormalizeContextCancellationConnectionPool) normalizeContextCancellationError(err error) error {
45+
if err == nil {
46+
return nil
47+
}
48+
if strings.Contains(err.Error(), "operation was canceled") {
49+
return fmt.Errorf("%w: %w", context.Canceled, err)
50+
}
51+
if strings.Contains(err.Error(), "use of closed network connection") {
52+
return fmt.Errorf("%w: %w", context.Canceled, err)
53+
}
54+
return err
55+
}

‎normalize_context_cancellation_connection_pool_test.go

Lines changed: 206 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,206 @@
1+
package sqldb
2+
3+
import (
4+
"context"
5+
"errors"
6+
"testing"
7+
8+
"github.com/smarty/assertions/should"
9+
"github.com/smarty/gunit"
10+
)
11+
12+
func TestNormalizeContextCancellationConnectionPoolFixture(t *testing.T) {
13+
gunit.Run(new(NormalizeContextCancellationConnectionPoolFixture), t)
14+
}
15+
16+
type NormalizeContextCancellationConnectionPoolFixture struct {
17+
*gunit.Fixture
18+
19+
inner *FakeConnectionPool
20+
adapter *NormalizeContextCancellationConnectionPool
21+
}
22+
23+
func (this *NormalizeContextCancellationConnectionPoolFixture) Setup() {
24+
this.inner = &FakeConnectionPool{}
25+
this.adapter = NewNormalizeContextCancellationConnectionPool(this.inner)
26+
}
27+
28+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestPing_Successful() {
29+
err := this.adapter.Ping(context.Background())
30+
31+
this.So(err, should.BeNil)
32+
this.So(this.inner.pingCalls, should.Equal, 1)
33+
}
34+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestPing_Failed() {
35+
pingErr := errors.New("PING ERROR")
36+
this.inner.pingError = pingErr
37+
38+
err := this.adapter.Ping(context.Background())
39+
40+
this.So(this.inner.pingCalls, should.Equal, 1)
41+
this.So(err, should.Equal, pingErr)
42+
}
43+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestPing_AdaptContextCancelled() {
44+
this.inner.pingError = operationCanceledErr
45+
46+
err := this.adapter.Ping(context.Background())
47+
48+
this.So(this.inner.pingCalls, should.Equal, 1)
49+
this.So(errors.Is(err, operationCanceledErr), should.BeTrue)
50+
this.So(errors.Is(err, context.Canceled), should.BeTrue)
51+
}
52+
53+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestBeginTransaction_Successful() {
54+
transaction := new(FakeTransaction)
55+
this.inner.transaction = transaction
56+
57+
tx, err := this.adapter.BeginTransaction(context.Background())
58+
59+
this.So(err, should.BeNil)
60+
this.So(this.inner.transactionCalls, should.Equal, 1)
61+
this.So(tx, should.NotBeNil)
62+
}
63+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestBeginTransaction_Failed() {
64+
transactionErr := errors.New("BEGIN TRANSACTION ERROR")
65+
this.inner.transactionError = transactionErr
66+
67+
tx, err := this.adapter.BeginTransaction(context.Background())
68+
69+
this.So(tx, should.BeNil)
70+
this.So(err, should.Equal, transactionErr)
71+
}
72+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestBeginTransaction_AdaptContextCancelled() {
73+
this.inner.transactionError = operationCanceledErr
74+
75+
tx, err := this.adapter.BeginTransaction(context.Background())
76+
77+
this.So(tx, should.BeNil)
78+
this.So(errors.Is(err, operationCanceledErr), should.BeTrue)
79+
this.So(errors.Is(err, context.Canceled), should.BeTrue)
80+
}
81+
82+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestClose_Successful() {
83+
err := this.adapter.Close()
84+
85+
this.So(err, should.BeNil)
86+
this.So(this.inner.closeCalls, should.Equal, 1)
87+
}
88+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestClose_Failed() {
89+
closeErr := errors.New("CLOSE ERROR")
90+
this.inner.closeError = closeErr
91+
92+
err := this.adapter.Close()
93+
94+
this.So(this.inner.closeCalls, should.Equal, 1)
95+
this.So(err, should.Equal, closeErr)
96+
}
97+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestClose_AdaptContextCancelled() {
98+
this.inner.closeError = operationCanceledErr
99+
100+
err := this.adapter.Close()
101+
102+
this.So(this.inner.closeCalls, should.Equal, 1)
103+
this.So(errors.Is(err, operationCanceledErr), should.BeTrue)
104+
this.So(errors.Is(err, context.Canceled), should.BeTrue)
105+
}
106+
107+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestExecute_Successful() {
108+
this.inner.executeResult = 42
109+
110+
result, err := this.adapter.Execute(context.Background(), "statement")
111+
112+
this.So(result, should.Equal, 42)
113+
this.So(err, should.BeNil)
114+
this.So(this.inner.executeCalls, should.Equal, 1)
115+
this.So(this.inner.executeStatement, should.Equal, "statement")
116+
}
117+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestExecute_Failed() {
118+
this.inner.executeResult = 42
119+
executeErr := errors.New("EXECUTE ERROR")
120+
this.inner.executeError = executeErr
121+
122+
result, err := this.adapter.Execute(context.Background(), "statement")
123+
124+
this.So(result, should.Equal, 42)
125+
this.So(err, should.Equal, executeErr)
126+
this.So(this.inner.executeCalls, should.Equal, 1)
127+
this.So(this.inner.executeStatement, should.Equal, "statement")
128+
}
129+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestExecute_AdaptContextCancelled() {
130+
this.inner.executeResult = 42
131+
this.inner.executeError = operationCanceledErr
132+
133+
result, err := this.adapter.Execute(context.Background(), "statement")
134+
135+
this.So(result, should.Equal, 42)
136+
this.So(this.inner.executeCalls, should.Equal, 1)
137+
this.So(this.inner.executeStatement, should.Equal, "statement")
138+
this.So(errors.Is(err, operationCanceledErr), should.BeTrue)
139+
this.So(errors.Is(err, context.Canceled), should.BeTrue)
140+
}
141+
142+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestSelect_Successful() {
143+
expectedResult := new(FakeSelectResult)
144+
this.inner.selectResult = expectedResult
145+
146+
result, err := this.adapter.Select(context.Background(), "query", 1, 2, 3)
147+
148+
this.So(result, should.Equal, expectedResult)
149+
this.So(err, should.BeNil)
150+
this.So(this.inner.selectCalls, should.Equal, 1)
151+
this.So(this.inner.selectStatement, should.Equal, "query")
152+
this.So(this.inner.selectParameters, should.Equal, []any{1, 2, 3})
153+
}
154+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestSelect_Failed() {
155+
expectedResult := new(FakeSelectResult)
156+
this.inner.selectResult = expectedResult
157+
selectErr := errors.New("SELECT ERROR")
158+
this.inner.selectError = selectErr
159+
160+
result, err := this.adapter.Select(context.Background(), "query", 1, 2, 3)
161+
162+
this.So(result, should.Equal, expectedResult)
163+
this.So(err, should.Equal, selectErr)
164+
this.So(this.inner.selectCalls, should.Equal, 1)
165+
this.So(this.inner.selectStatement, should.Equal, "query")
166+
this.So(this.inner.selectParameters, should.Equal, []any{1, 2, 3})
167+
}
168+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestSelect_AdaptContextCancelled() {
169+
expectedResult := new(FakeSelectResult)
170+
this.inner.selectResult = expectedResult
171+
this.inner.selectError = operationCanceledErr
172+
173+
result, err := this.adapter.Select(context.Background(), "query", 1, 2, 3)
174+
175+
this.So(result, should.Equal, expectedResult)
176+
this.So(this.inner.selectCalls, should.Equal, 1)
177+
this.So(this.inner.selectStatement, should.Equal, "query")
178+
this.So(this.inner.selectParameters, should.Equal, []any{1, 2, 3})
179+
this.So(errors.Is(err, operationCanceledErr), should.BeTrue)
180+
this.So(errors.Is(err, context.Canceled), should.BeTrue)
181+
}
182+
183+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestContextCancellationErrorAdapter_NilError() {
184+
err := this.adapter.normalizeContextCancellationError(nil)
185+
this.So(err, should.BeNil)
186+
}
187+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestContextCancellationErrorAdapter_GenericError() {
188+
genericErr := errors.New("generic error")
189+
err := this.adapter.normalizeContextCancellationError(genericErr)
190+
this.So(err, should.Equal, genericErr)
191+
}
192+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestContextCancellationErrorAdapter_OperationCanceledError() {
193+
err := this.adapter.normalizeContextCancellationError(operationCanceledErr)
194+
this.So(errors.Is(err, operationCanceledErr), should.BeTrue)
195+
this.So(errors.Is(err, context.Canceled), should.BeTrue)
196+
}
197+
func (this *NormalizeContextCancellationConnectionPoolFixture) TestContextCancellationErrorAdapter_ClosedConnectionError() {
198+
err := this.adapter.normalizeContextCancellationError(closedNetworkConnectionErr)
199+
this.So(errors.Is(err, closedNetworkConnectionErr), should.BeTrue)
200+
this.So(errors.Is(err, context.Canceled), should.BeTrue)
201+
}
202+
203+
var (
204+
operationCanceledErr = errors.New("operation was canceled")
205+
closedNetworkConnectionErr = errors.New("use of closed network connection")
206+
)

0 commit comments

Comments
 (0)