136 lines
3.1 KiB
Go
136 lines
3.1 KiB
Go
package sql
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"net"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
mysqldriver "github.com/go-sql-driver/mysql"
|
|
|
|
"gorm.io/driver/mysql"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/logger"
|
|
|
|
"github.com/FAU-CDI/wisski-distillery/internal/models"
|
|
"github.com/FAU-CDI/wisski-distillery/pkg/timex"
|
|
)
|
|
|
|
//
|
|
// ========== low-level connection ==========
|
|
//
|
|
|
|
// Exec executes a database-independent database query.
|
|
func (sql *SQL) Exec(query string, args ...interface{}) error {
|
|
// connect to the server
|
|
conn, err := sql.connect("")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// do the query!
|
|
{
|
|
_, err := conn.Exec(query, args...)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
//
|
|
// ========== connection via gorm ==========
|
|
//
|
|
|
|
// QueryTable returns a gorm.DB to connect to the provided distillery database table
|
|
func (sql *SQL) QueryTable(ctx context.Context, silent bool, table string) (*gorm.DB, error) {
|
|
conn, err := sql.connect(sql.Config.DistilleryDatabase)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// gorm configuration
|
|
config := &gorm.Config{
|
|
Logger: newGormLogger(),
|
|
}
|
|
if silent {
|
|
config.Logger = config.Logger.LogMode(logger.Silent)
|
|
} else {
|
|
config.Logger = config.Logger.LogMode(logger.Info)
|
|
}
|
|
|
|
// mysql connection
|
|
cfg := mysql.Config{
|
|
Conn: conn,
|
|
|
|
DefaultStringSize: 256,
|
|
}
|
|
|
|
// open the gorm connection!
|
|
db, err := gorm.Open(mysql.New(cfg), config)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// set the table
|
|
db = db.WithContext(ctx).Table(table)
|
|
|
|
// check that nothing went wrong
|
|
if db.Error != nil {
|
|
return nil, db.Error
|
|
}
|
|
return db, nil
|
|
}
|
|
|
|
// WaitQueryTable waits for a connection to succeed via QueryTable
|
|
func (sql *SQL) WaitQueryTable(ctx context.Context) error {
|
|
// TODO: Establish a convention on when to wait for this!
|
|
return timex.TickUntilFunc(func(time.Time) bool {
|
|
_, err := sql.QueryTable(ctx, true, models.InstanceTable)
|
|
return err == nil
|
|
}, ctx, sql.PollInterval)
|
|
}
|
|
|
|
//
|
|
// ========== low-level database connection ==========
|
|
//
|
|
|
|
func (ssql *SQL) connect(database string) (*sql.DB, error) {
|
|
conn, err := sql.Open("mysql", ssql.dsn(database))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
conn.SetMaxIdleConns(0)
|
|
|
|
return conn, nil
|
|
}
|
|
|
|
// dsn returns a dsn fof connecting to the database
|
|
func (sql *SQL) dsn(database string) string {
|
|
user := sql.Config.MysqlAdminUser
|
|
pass := sql.Config.MysqlAdminPassword
|
|
network := sql.network()
|
|
server := sql.ServerURL
|
|
|
|
return fmt.Sprintf("%s:%s@%s(%s)/%s?charset=utf8&parseTime=True&loc=Local", user, pass, network, server, database)
|
|
}
|
|
|
|
var proxyNameCounter uint64
|
|
|
|
// network returns the network to use to connect to the database
|
|
func (sql *SQL) network() string {
|
|
return sql.lazyNetwork.Get(func() (name string) {
|
|
network := "tcp"
|
|
|
|
// register a new DialContext function to use the environment.
|
|
// this seems like a bit of a hack, but it works for now.
|
|
name = fmt.Sprintf("sql-network-%d", atomic.AddUint64(&proxyNameCounter, 1))
|
|
mysqldriver.RegisterDialContext(name, func(ctx context.Context, addr string) (net.Conn, error) {
|
|
return sql.Still.Environment.DialContext(ctx, network, addr)
|
|
})
|
|
return
|
|
})
|
|
}
|