mirror of
https://github.com/seaweedfs/seaweedfs.git
synced 2026-09-16 19:40:43 +02:00
Chris Lu
9f6efc8b53
* filer: give the SQL stores' key-value reads their own connections A listing holds the connection its rows are on for the whole iteration, and FilerStoreWrapper calls maybeReadHardLink -> KvGet from inside that iteration, so a hard-linked entry needs a second connection while the first is still busy. Out of one bounded pool that is a deadlock: the listings fill the pool and then wait for a connection none of them will release, and the wrapper's context.WithoutCancel leaves the waiters without a deadline, so the filer stays wedged rather than erroring. The sqlite store shows it at its sharpest -- it allows a single connection, so one listing over one hard-linked entry never returns. On postgres with connection_max_open = 50, 60 concurrent listings over hard-linked entries made no progress at all. Key-value reads now run on their own pool, carved out of connection_max_open rather than added to it, so the operator's cap still bounds what the store opens against the database. An unbounded pool keeps a single pool: nothing can wait there. sqlite's single connection becomes two, one per pool, and its writes get a busy timeout so a write that meets the reader waits instead of failing. Claude-Session: https://claude.ai/code/session_018DWwctzD4T2DmnczPRM47t * sqlite: keep both pools on one database, whatever the dbFile spells A dbFile that already carries URI options got a second "?" appended, which the driver reads as part of the preceding option value, and a bare :memory: is private to each connection, so the key-value pool would open its own empty database and every key-value operation would fail on a missing filemeta. Claude-Session: https://claude.ai/code/session_018DWwctzD4T2DmnczPRM47t * sqlite: assert the busy timeout on the in-memory DSN too Claude-Session: https://claude.ai/code/session_018DWwctzD4T2DmnczPRM47t
112 lines
3.6 KiB
Go
112 lines
3.6 KiB
Go
package mysql2
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"strings"
|
|
|
|
_ "github.com/go-sql-driver/mysql"
|
|
"github.com/seaweedfs/seaweedfs/weed/filer"
|
|
"github.com/seaweedfs/seaweedfs/weed/filer/abstract_sql"
|
|
"github.com/seaweedfs/seaweedfs/weed/filer/mysql"
|
|
"github.com/seaweedfs/seaweedfs/weed/util"
|
|
)
|
|
|
|
const (
|
|
CONNECTION_URL_PATTERN = "%s:%s@tcp(%s:%d)/%s?collation=utf8mb4_bin"
|
|
)
|
|
|
|
var _ filer.BucketAware = (*MysqlStore2)(nil)
|
|
|
|
func init() {
|
|
filer.Stores = append(filer.Stores, &MysqlStore2{})
|
|
}
|
|
|
|
type MysqlStore2 struct {
|
|
abstract_sql.AbstractSqlStore
|
|
}
|
|
|
|
func (store *MysqlStore2) GetName() string {
|
|
return "mysql2"
|
|
}
|
|
|
|
func (store *MysqlStore2) Initialize(configuration util.Configuration, prefix string) (err error) {
|
|
// Fewer idle slots than concurrent operations means a fresh connection per
|
|
// operation, until the filer runs out of ephemeral ports. connection_max_open
|
|
// stays unset: a listing runs a second query from its own callback, so a
|
|
// bounded pool deadlocks once the concurrency reaches it.
|
|
configuration.SetDefault(prefix+"connection_max_idle", 50)
|
|
configuration.SetDefault(prefix+"connection_max_lifetime_seconds", 300)
|
|
// Default on so minimal configs avoid the duplicate-key roundtrip the
|
|
// inode-index KvPut would otherwise emit on every write.
|
|
configuration.SetDefault(prefix+"enableUpsert", true)
|
|
return store.initialize(
|
|
configuration.GetString(prefix+"createTable"),
|
|
configuration.GetString(prefix+"upsertQuery"),
|
|
configuration.GetBool(prefix+"enableUpsert"),
|
|
configuration.GetString(prefix+"username"),
|
|
configuration.GetString(prefix+"password"),
|
|
configuration.GetString(prefix+"hostname"),
|
|
configuration.GetInt(prefix+"port"),
|
|
configuration.GetString(prefix+"database"),
|
|
configuration.GetInt(prefix+"connection_max_idle"),
|
|
configuration.GetInt(prefix+"connection_max_open"),
|
|
configuration.GetInt(prefix+"connection_max_lifetime_seconds"),
|
|
configuration.GetBool(prefix+"interpolateParams"),
|
|
)
|
|
}
|
|
|
|
func (store *MysqlStore2) initialize(createTable, upsertQuery string, enableUpsert bool, user, password, hostname string, port int, database string, maxIdle, maxOpen,
|
|
maxLifetimeSeconds int, interpolateParams bool) (err error) {
|
|
|
|
store.SupportBucketTable = true
|
|
if createTable == "" {
|
|
createTable = mysql.DefaultCreateTableQuery
|
|
}
|
|
if !enableUpsert {
|
|
upsertQuery = ""
|
|
} else if upsertQuery == "" {
|
|
upsertQuery = mysql.DefaultUpsertQuery
|
|
}
|
|
gen := &mysql.SqlGenMysql{
|
|
CreateTableSqlTemplate: createTable,
|
|
DropTableSqlTemplate: "DROP TABLE IF EXISTS `%s`",
|
|
UpsertQueryTemplate: upsertQuery,
|
|
}
|
|
store.SqlGenerator = gen
|
|
|
|
sqlUrl := fmt.Sprintf(CONNECTION_URL_PATTERN, user, password, hostname, port, database)
|
|
adaptedSqlUrl := fmt.Sprintf(CONNECTION_URL_PATTERN, user, "<ADAPTED>", hostname, port, database)
|
|
if interpolateParams {
|
|
sqlUrl += "&interpolateParams=true"
|
|
adaptedSqlUrl += "&interpolateParams=true"
|
|
}
|
|
|
|
db, dbErr := sql.Open("mysql", sqlUrl)
|
|
if dbErr != nil {
|
|
if db != nil {
|
|
db.Close()
|
|
}
|
|
return fmt.Errorf("can not connect to %s error:%w", adaptedSqlUrl, dbErr)
|
|
}
|
|
|
|
if err = store.UseConnectionPools(db, func() (*sql.DB, error) {
|
|
return sql.Open("mysql", sqlUrl)
|
|
}, maxIdle, maxOpen, maxLifetimeSeconds); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err = store.DB.Ping(); err != nil {
|
|
return fmt.Errorf("connect to %s error:%v", adaptedSqlUrl, err)
|
|
}
|
|
|
|
if err = store.CreateTable(context.Background(), abstract_sql.DEFAULT_TABLE); err != nil && !strings.Contains(err.Error(), "table already exist") {
|
|
return fmt.Errorf("init table %s: %v", abstract_sql.DEFAULT_TABLE, err)
|
|
}
|
|
|
|
mysql.ConfigureListOrdering(store.DB, gen)
|
|
|
|
return nil
|
|
}
|