Moved some common SQL function to public utils as they are used in plugins (#26412)

* Moved some common SQL function tu public utls as they are used in plugins

* goimported file

* Added tests

* Created sub-package

* MOved SetupConnection to public sql utils

server/channels/store/sqlstore/store.go

@@ -15,6 +15,8 @@ import (
 	"sync/atomic"
 	"time"
 
+	sqlUtils "github.com/mattermost/mattermost/server/public/utils/sql"
+
 	sq "github.com/mattermost/squirrel"
 
 	"github.com/go-sql-driver/mysql"
@@ -44,7 +46,6 @@ const (
 	PGDuplicateObjectErrorCode        = "42710"
 	MySQLDuplicateObjectErrorCode     = 1022
 	DBPingAttempts                    = 5
-	DBPingTimeoutSecs                 = 10
 	// This is a numerical version string by postgres. The format is
 	// 2 characters for major, minor, and patch version prior to 10.
 	// After 10, it's major and minor only.
@@ -241,58 +242,6 @@ func New(settings model.SqlSettings, logger mlog.LoggerIFace, metrics einterface
 	return store, nil
 }
 
-// SetupConnection sets up the connection to the database and pings it to make sure it's alive.
-// It also applies any database configuration settings that are required.
-func SetupConnection(logger mlog.LoggerIFace, connType string, dataSource string, settings *model.SqlSettings, attempts int) (*dbsql.DB, error) {
-	db, err := dbsql.Open(*settings.DriverName, dataSource)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to open SQL connection")
-	}
-
-	// At this point, we have passed sql.Open, so we deliberately ignore any errors.
-	sanitized, _ := SanitizeDataSource(*settings.DriverName, dataSource)
-
-	logger = logger.With(
-		mlog.String("database", connType),
-		mlog.String("dataSource", sanitized),
-	)
-
-	for i := 0; i < attempts; i++ {
-		logger.Info("Pinging SQL")
-		ctx, cancel := context.WithTimeout(context.Background(), DBPingTimeoutSecs*time.Second)
-		defer cancel()
-		err = db.PingContext(ctx)
-		if err != nil {
-			if i == attempts-1 {
-				return nil, err
-			}
-			logger.Error("Failed to ping DB", mlog.Int("retrying in seconds", DBPingTimeoutSecs), mlog.Err(err))
-			time.Sleep(DBPingTimeoutSecs * time.Second)
-			continue
-		}
-		break
-	}
-
-	if strings.HasPrefix(connType, replicaLagPrefix) {
-		// If this is a replica lag connection, we just open one connection.
-		//
-		// Arguably, if the query doesn't require a special credential, it does take up
-		// one extra connection from the replica DB. But falling back to the replica
-		// data source when the replica lag data source is null implies an ordering constraint
-		// which makes things brittle and is not a good design.
-		// If connections are an overhead, it is advised to use a connection pool.
-		db.SetMaxOpenConns(1)
-		db.SetMaxIdleConns(1)
-	} else {
-		db.SetMaxIdleConns(*settings.MaxIdleConns)
-		db.SetMaxOpenConns(*settings.MaxOpenConns)
-	}
-	db.SetConnMaxLifetime(time.Duration(*settings.ConnMaxLifetimeMilliseconds) * time.Millisecond)
-	db.SetConnMaxIdleTime(time.Duration(*settings.ConnMaxIdleTimeMilliseconds) * time.Millisecond)
-
-	return db, nil
-}
-
 func (ss *SqlStore) SetContext(context context.Context) {
 	ss.context = context
 }
@@ -314,13 +263,13 @@ func (ss *SqlStore) initConnection() error {
 		// covers that already. Ideally we'd like to do this only for the upgrade
 		// step. To be reviewed in MM-35789.
 		var err error
-		dataSource, err = ResetReadTimeout(dataSource)
+		dataSource, err = sqlUtils.ResetReadTimeout(dataSource)
 		if err != nil {
 			return errors.Wrap(err, "failed to reset read timeout from datasource")
 		}
 	}
 
-	handle, err := SetupConnection(ss.Logger(), "master", dataSource, ss.settings, DBPingAttempts)
+	handle, err := sqlUtils.SetupConnection(ss.Logger(), "master", dataSource, ss.settings, DBPingAttempts)
 	if err != nil {
 		return err
 	}
@@ -338,7 +287,7 @@ func (ss *SqlStore) initConnection() error {
 		ss.ReplicaXs = make([]*atomic.Pointer[sqlxDBWrapper], len(ss.settings.DataSourceReplicas))
 		for i, replica := range ss.settings.DataSourceReplicas {
 			ss.ReplicaXs[i] = &atomic.Pointer[sqlxDBWrapper]{}
-			handle, err = SetupConnection(ss.Logger(), fmt.Sprintf("replica-%v", i), replica, ss.settings, DBPingAttempts)
+			handle, err = sqlUtils.SetupConnection(ss.Logger(), fmt.Sprintf("replica-%v", i), replica, ss.settings, DBPingAttempts)
 			if err != nil {
 				// Initializing to be offline
 				ss.ReplicaXs[i].Store(&sqlxDBWrapper{isOnline: &atomic.Bool{}})
@@ -353,7 +302,7 @@ func (ss *SqlStore) initConnection() error {
 		ss.searchReplicaXs = make([]*atomic.Pointer[sqlxDBWrapper], len(ss.settings.DataSourceSearchReplicas))
 		for i, replica := range ss.settings.DataSourceSearchReplicas {
 			ss.searchReplicaXs[i] = &atomic.Pointer[sqlxDBWrapper]{}
-			handle, err = SetupConnection(ss.Logger(), fmt.Sprintf("search-replica-%v", i), replica, ss.settings, DBPingAttempts)
+			handle, err = sqlUtils.SetupConnection(ss.Logger(), fmt.Sprintf("search-replica-%v", i), replica, ss.settings, DBPingAttempts)
 			if err != nil {
 				// Initializing to be offline
 				ss.searchReplicaXs[i].Store(&sqlxDBWrapper{isOnline: &atomic.Bool{}})
@@ -370,7 +319,7 @@ func (ss *SqlStore) initConnection() error {
 			if src.DataSource == nil {
 				continue
 			}
-			ss.replicaLagHandles[i], err = SetupConnection(ss.Logger(), fmt.Sprintf(replicaLagPrefix+"-%d", i), *src.DataSource, ss.settings, DBPingAttempts)
+			ss.replicaLagHandles[i], err = sqlUtils.SetupConnection(ss.Logger(), fmt.Sprintf(replicaLagPrefix+"-%d", i), *src.DataSource, ss.settings, DBPingAttempts)
 			if err != nil {
 				mlog.Warn("Failed to setup replica lag handle. Skipping..", mlog.String("db", fmt.Sprintf(replicaLagPrefix+"-%d", i)), mlog.Err(err))
 				continue
@@ -525,7 +474,7 @@ func (ss *SqlStore) monitorReplicas() {
 					return
 				}
 
-				handle, err := SetupConnection(ss.Logger(), name, dsn, ss.settings, 1)
+				handle, err := sqlUtils.SetupConnection(ss.Logger(), name, dsn, ss.settings, 1)
 				if err != nil {
 					mlog.Warn("Failed to setup connection. Skipping..", mlog.String("db", name), mlog.Err(err))
 					return