gomod/model
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v0.1.0

Browse Source
This commit is contained in:
bryan 2025-04-08 08:54:28 +08:00
parent 1151bf1156
commit bc5dac0e12
2 changed files with 144 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
go.mod
View File

@ -3,11 +3,16 @@ module qoobing.com/gomod/model
go 1.19.2 go 1.19.2
require ( require (
gorm.io/driver/postgres v1.5.9 qoobing.com/gomod/gorm v0.0.2
gorm.io/gorm v1.25.10 qoobing.com/gomod/log v1.4.0
qoobing.com/gomod/database v0.0.0-20240627111018-316f516e9b69 qoobing.com/gomod/redis v1.3.8
qoobing.com/gomod/log v1.2.8 )
qoobing.com/gomod/redis v1.3.4
require (
github.com/go-sql-driver/mysql v1.7.0 // indirect
gorm.io/driver/mysql v1.5.7 // indirect
gorm.io/driver/postgres v1.5.9 // indirect
gorm.io/gorm v1.25.12 // indirect
) )
require ( require (

326
model.go
View File

@ -1,234 +1,176 @@
package model package model
import ( import (
"strings" "fmt"
"time" "sync"
"gorm.io/driver/mysql" "qoobing.com/gomod/gorm"
"gorm.io/driver/postgres"
"gorm.io/gorm"
"qoobing.com/gomod/database"
"qoobing.com/gomod/log" "qoobing.com/gomod/log"
"qoobing.com/gomod/redis" "qoobing.com/gomod/redis"
"qoobing.com/gomod/redis/sentinel"
)
type Model struct {
DB *gorm.DB
DbTxStatus DbTxStatus
Redis redis.Conn
RedisPool *redis.Pool
}
type DbTxStatus int
const (
DBTX_STATUS_TX_NONE DbTxStatus = 0
DBTX_STATUS_TX_DOING DbTxStatus = 1
DBTX_STATUS_TX_SUCCESS DbTxStatus = 2
DBTX_STATUS_TX_FAILED DbTxStatus = 3
) )
var ( var (
defaultDb *database.Config instances = map[string]instance{}
defaultDsn string errNoModelFound = errorsWrap("named model(%s) not found")
defaultDbDebug bool errModeAlreadyInit = errorsWrap("named model(%s) already initilized")
defaultGormDB *gorm.DB errOpenDBFailed = errorsWrap("open database failed: %s")
defaultRds *redis.Config errOpenRedisFailed = errorsWrap("open redis failed: %s")
defaultRedis *redis.Pool
defaultRedisDebug bool
defaultOptions []Option
) )
func NewModel() *Model { func errorsWrap(base string) func(...any) error {
if len(defaultOptions) == 0 { return func(v ...any) error {
panic("No defualt Database&Redis been configed") return fmt.Errorf(base, v...)
} }
return NewModelWithOption(defaultOptions...)
} }
func NewModelDefault() *Model { const (
return NewModelWithOption(OptOpenDefaultDatabase, OptOpenDefaultRedis) tx_status_none = 0
} tx_status_doing = 1
tx_status_commit = 2
tx_status_rollback = 3
)
func NewModelDefaultRedis() *Model { type Model struct {
return NewModelWithOption(OptOpenDefaultRedis) mu sync.Mutex
} dbCfg *gorm.Config
redisCfg *redis.Config
func NewModelDefaultDatabase() *Model { db *gorm.DB
return NewModelWithOption(OptOpenDefaultDatabase) dbTxStatus int
} redis redis.Conn
redisPool *redis.Pool
func NewModelWithOption(options ...Option) *Model {
n := 0
m := Model{}
//log.Debugf("Start NewModelWithOption...")
for _, option := range options {
n++
option(&m)
}
//log.Debugf("Finish NewModelWithOption(with %d options)", n)
return &m
}
func (m *Model) Close() {
if m.Redis != nil {
m.Redis.Close()
}
if m.DB == nil {
m.DbTxStatus = DBTX_STATUS_TX_NONE
} else if m.DbTxStatus == DBTX_STATUS_TX_DOING {
m.DB.Rollback()
m.DbTxStatus = DBTX_STATUS_TX_FAILED
}
} }
func (m *Model) Begin() { func (m *Model) Begin() {
if m.DB == nil { if m.DB() == nil {
panic("unreachable code, m.DB is uninitialized") panic("unreachable code, db is uninitialized")
} else if m.DbTxStatus != DBTX_STATUS_TX_NONE { } else if m.dbTxStatus != tx_status_none {
panic("unreachable code, begin transaction towice???") panic("unreachable code, begin transaction towice???")
} else { } else {
m.DbTxStatus = DBTX_STATUS_TX_DOING m.dbTxStatus = tx_status_doing
m.DB = m.DB.Begin() m.db = m.db.Begin()
} }
} }
func (m *Model) Commit() error { func (m *Model) Commit() error {
if m.DB == nil { if m.DB() == nil {
panic("unreachable code, m.DB is uninitialized") panic("unreachable code, db is uninitialized")
} else if m.DbTxStatus != DBTX_STATUS_TX_DOING { } else if m.dbTxStatus != tx_status_doing {
return nil return nil
} else if err := m.DB.Commit().Error; err != nil { } else if err := m.db.Commit().Error; err != nil {
m.DbTxStatus = DBTX_STATUS_TX_FAILED m.dbTxStatus = tx_status_rollback
return err return err
} else { } else {
m.DbTxStatus = DBTX_STATUS_TX_SUCCESS m.dbTxStatus = tx_status_commit
return nil return nil
} }
} }
// Option is model's option func (m *Model) Close() {
type Option func(*Model) if m.redis != nil {
m.redis.Close()
// OptOpenDefaultDatabase option function for open default database
func OptOpenDefaultDatabase(m *Model) {
var err error
if defaultDb == nil {
panic("defaultDb not init")
} }
if m.db == nil {
if defaultGormDB != nil { m.dbTxStatus = tx_status_none
m.DB = defaultGormDB } else if m.dbTxStatus == tx_status_doing {
//TODO: check cocurrent m.db.Rollback()
m.DB = m.DB.Session(&gorm.Session{QueryFields: true}) m.dbTxStatus = tx_status_rollback
//log.Debugf("Opt for open default database done")
return
} }
var dialector gorm.Dialector
var gormconfig = &gorm.Config{
NowFunc: func() time.Time {
return time.Now().UTC()
},
}
switch defaultDb.Type {
case "mysql":
dialector = mysql.New(
mysql.Config{
DSN: defaultDsn,
DefaultStringSize: 512,
},
)
case "pgsql":
dialector = postgres.New(
postgres.Config{
DSN: defaultDsn,
PreferSimpleProtocol: true,
},
)
default:
panic("UNKNOWN DATABASE TYPE:" + defaultDb.Type)
}
var db *gorm.DB
db, err = gorm.Open(dialector, gormconfig)
if err != nil {
panic("DATABASE_OPEN_ERROR")
}
if defaultDbDebug {
m.DB = db.Debug()
} else {
m.DB = db
}
if sqlDB, err := m.DB.DB(); err != nil {
panic("DATABASE_OPEN_ERROR")
} else {
sqlDB.SetMaxIdleConns(3)
sqlDB.SetMaxOpenConns(10)
sqlDB.SetConnMaxLifetime(time.Minute)
}
defaultGormDB = m.DB
//TODO: check cocurrent
m.DB = m.DB.Session(&gorm.Session{QueryFields: true})
//log.Debugf("Opt for open default database done")
return
} }
// OptOpenDefaultRedisSentinelPool option function for open default redis sentinel func (m *Model) DB() *gorm.DB {
func OptOpenDefaultRedis(m *Model) { return m.db
if defaultRedis != nil { }
m.Redis = defaultRedis.Get()
m.RedisPool = defaultRedis func (m *Model) Redis() redis.Conn {
} else if pool := sentinel.NewPool(*defaultRds); pool == nil { return m.redis
panic("REDIS_ERROR") }
} else {
defaultRedis = pool func (m *Model) RedisPool() *redis.Pool {
m.Redis = defaultRedis.Get() return m.redisPool
m.RedisPool = defaultRedis }
type instance struct {
db *gorm.DB
dbCfg *gorm.Config
redis *redis.Pool
redisCfg *redis.Config
}
// OpenDefault open 'default' model
func OpenDefault() (*Model, error) {
return Open("default")
}
// OpenDefault open named model, if err is nil, caller MUST call m.Close() in defer.
func Open(name string) (m *Model, err error) {
// check initialize
cfg, ok := instances[name]
if !ok {
return nil, errNoModelFound(name)
} }
//log.Debugf("Opt for open default redis done") // open redis
return var rds redis.Conn
if cfg.redisCfg == nil {
// don't need to open redis
} else if cfg.redis != nil {
rds = cfg.redis.Get()
} else if cfg.redis = redis.NewPool(*cfg.redisCfg); cfg.redis == nil {
return nil, errOpenRedisFailed("new redis pool return nil")
} else {
rds = cfg.redis.Get()
}
defer func() {
if m == nil && rds != nil {
rds.Close()
}
}()
// open db
var db *gorm.DB
if cfg.dbCfg == nil {
// don't need to open database
} else if cfg.db != nil {
db = gorm.NewSession(cfg.db)
} else if cfg.db, err = gorm.NewDB(*cfg.dbCfg); err != nil {
return nil, errOpenDBFailed(err)
} else {
db = gorm.NewSession(cfg.db)
}
// success
m = &Model{
dbCfg: cfg.dbCfg,
redisCfg: cfg.redisCfg,
db: db,
redis: rds,
redisPool: cfg.redis,
}
return m, nil
} }
// Init init default database config & redis config // Init init default database config & redis config
func Init(_defaultDb *database.Config, _defaultRds *redis.Config) { func InitDefault(_defaultDb *gorm.Config, _defaultRds *redis.Config) error {
defaultDb = _defaultDb return Init("default", _defaultDb, _defaultRds)
defaultRds = _defaultRds }
defaultOptions = []Option{}
// Init init named database config & redis config
if defaultDb != nil { func Init(name string, dbCfg *gorm.Config, rdsCfg *redis.Config) error {
// database init _, ok := instances[name]
defaultDsn = database.GetDsn(defaultDb) if ok {
defaultDbDebug = defaultDb.Debug return errModeAlreadyInit(name)
}
// database debug instances[name] = instance{
if defaultDbDebug && len(defaultDb.Password) > 5 { dbCfg: dbCfg,
p := defaultDb.Password redisCfg: rdsCfg,
l := len(p) }
secDefaultDsn := strings.Replace(defaultDsn, p[2:l-3], "*****", 1) if dbCfg != nil && dbCfg.Debug {
log.Infof("defaultDsn='%s'", secDefaultDsn) log.Infof("init model(%s) database:%s", name, gorm.GetSecDsn(dbCfg))
} }
if rdsCfg != nil && rdsCfg.Debug {
defaultOptions = append(defaultOptions, OptOpenDefaultDatabase) log.Infof("init model(%s) redis:%s", name, redis.)
} }
log.Infof("init model(%s) done", name)
if defaultRds != nil { return nil
// redis init
defaultRds = defaultRds
defaultRedisDebug = defaultRds.Debug
// redis debug
if defaultRedisDebug && len(defaultRds.Password) > 5 {
p := defaultRds.Password
l := len(p)
secDefaultRds := *defaultRds
secDefaultRds.Password = strings.Replace(p, p[2:l-3], "*****", 1)
log.PrintPretty("defaultRds=", secDefaultRds)
}
defaultOptions = append(defaultOptions, OptOpenDefaultRedis)
}
} }