Files
tasks/tools/sql/clitest/conn_tests.go
Tim Deeb-SwihartandGitHub be7b5514a5 Reconnect to SQL databases when connections fail (#5926)
## What changed?

Both our PostgreSQL and MySQL database backends will now automatically
reconnect to the database when certain errors occur: all errors chosen
have been experienced when testing this behavior through an AWS Aurora
RDS failover of either MySQL or PostgreSQL.

For both backends we will reconnect when we see:
- `ECONNRESET`
- `ECONNABORTED`
- `ECONNREFUSED`
- `io.EOF`
- `io.ErrUnexpectedEOF`
- `database/sql/driver.ErrBadConn`

for postgres we will also reconnect on the following SQLStates:
- `25006` read-only transaction
- `57P03` cannot connect now
- `0A000` feature not supported, but ONLY when the message is `cannot
set transaction read-write mode during recovery`

for mysql we will also reconnect when we see the following error codes:
- `1040` too many connections 
- `1792` read-only transaction (SQLstate `25006`)
- `1836` running in read-only mode

This logic is easily extensible should we discover more failure modes
over time

## Why?

We've had multiple community reports of Temporal problems during RDS
failover. One part of this is the fact that we wouldn't necessarily
reconnect; we were at the whims of our chosen SQL abstraction's
connection pooling logic.

## How did you test it?

I manually tested this functionality in the presence of repeated RDS
failovers: 

- [x] postgres12 plugin with pq driver
- [x] postgres12 plugin with pgx driver
- [x] mysql plugin

Automated testing will be added to our regular testing pipelines once
our infrastructure friends have added the support I need (it's in
progress)

## Potential risks

We're concerned there's a correctness issue in our PostgreSQL backend
that's related to our behavior during an RDS failover. If we merge this
before I figure out what's going on, we could hide the issue and make it
harder to reproduce.

## Documentation
N/A

## Is hotfix candidate?
Yes?
2024-05-17 16:59:15 -07:00

122 lines
3.3 KiB
Go

// The MIT License
//
// Copyright (c) 2020 Temporal Technologies Inc. All rights reserved.
//
// Copyright (c) 2020 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
package clitest
import (
"net"
"github.com/stretchr/testify/require"
"go.temporal.io/server/common/config"
"go.temporal.io/server/common/log"
"go.temporal.io/server/common/log/tag"
"go.temporal.io/server/tools/common/schema/test"
"go.temporal.io/server/tools/sql"
)
type (
// SQLConnTestSuite defines a test suite
SQLConnTestSuite struct {
test.DBTestBase
host string
port string
pluginName string
sqlQuery string
}
)
var _ test.DB = (*sql.Connection)(nil)
const (
testUser = "temporal"
testPassword = "temporal"
)
// NewSQLConnTestSuite returns the test suite
func NewSQLConnTestSuite(
host string,
port string,
pluginName string,
sqlQuery string,
) *SQLConnTestSuite {
return &SQLConnTestSuite{
host: host,
port: port,
pluginName: pluginName,
sqlQuery: sqlQuery,
}
}
// SetupTest setups test
func (s *SQLConnTestSuite) SetupTest() {
s.Assertions = require.New(s.T()) // Have to define our overridden assertions in the test setup. If we did it earlier, s.T() will return nil
}
// SetupSuite setups test suite
func (s *SQLConnTestSuite) SetupSuite() {
conn, err := newTestConn("", s.host, s.port, s.pluginName)
if err != nil {
logger := log.NewTestLogger()
logger.Fatal("error creating sql conn", tag.Error(err))
}
s.SetupSuiteBase(conn)
}
// TearDownSuite tear down test suite
func (s *SQLConnTestSuite) TearDownSuite() {
s.TearDownSuiteBase()
}
// TestParseCQLFile test
func (s *SQLConnTestSuite) TestParseCQLFile() {
s.RunParseFileTest(s.sqlQuery)
}
// TestSQLConn test
func (s *SQLConnTestSuite) TestSQLConn() {
conn, err := newTestConn(s.DBName, s.host, s.port, s.pluginName)
s.Nil(err)
s.RunCreateTest(conn)
s.RunUpdateTest(conn)
s.RunDropTest(conn)
conn.Close()
}
func newTestConn(
database string,
host string,
port string,
pluginName string,
) (*sql.Connection, error) {
connectAddr := net.JoinHostPort(host, port)
return sql.NewConnection(&config.SQL{
ConnectAddr: connectAddr,
User: testUser,
Password: testPassword,
PluginName: pluginName,
DatabaseName: database,
}, log.NewTestLogger())
}