105 lines
2.5 KiB
Go
105 lines
2.5 KiB
Go
package dao
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"go-common/app/job/main/thumbup/conf"
|
|
"go-common/library/cache/memcache"
|
|
xredis "go-common/library/cache/redis"
|
|
"go-common/library/database/tidb"
|
|
"go-common/library/log"
|
|
"go-common/library/queue/databus"
|
|
)
|
|
|
|
// Dao .
|
|
type Dao struct {
|
|
// config
|
|
c *conf.Config
|
|
// tidb
|
|
tidb *tidb.DB
|
|
itemTidb *tidb.DB
|
|
// memcache
|
|
mc *memcache.Pool
|
|
mcStatsExpire int32
|
|
// redis
|
|
redis *xredis.Pool
|
|
redisStatsExpire int64
|
|
redisUserLikesExpire int64
|
|
redisItemLikesExpire int64
|
|
// databus
|
|
statDbus *databus.Databus
|
|
// stmt
|
|
businessesStmt *tidb.Stmts
|
|
itemLikesStmt *tidb.Stmts
|
|
userLikesStmt *tidb.Stmts
|
|
likeStateStmt *tidb.Stmts
|
|
statStmt *tidb.Stmts
|
|
updateLikeStateStmt *tidb.Stmts
|
|
}
|
|
|
|
// New .
|
|
func New(c *conf.Config) (d *Dao) {
|
|
d = &Dao{
|
|
c: c,
|
|
// tidb
|
|
tidb: tidb.NewTiDB(c.Tidb),
|
|
itemTidb: tidb.NewTiDB(c.ItemTidb),
|
|
// memcache
|
|
mc: memcache.NewPool(c.Memcache.Config),
|
|
mcStatsExpire: int32(time.Duration(c.Memcache.StatsExpire) / time.Second),
|
|
// redis
|
|
redis: xredis.NewPool(c.Redis.Config),
|
|
redisStatsExpire: int64(time.Duration(c.Redis.StatsExpire) / time.Second),
|
|
redisUserLikesExpire: int64(time.Duration(c.Redis.UserLikesExpire) / time.Second),
|
|
redisItemLikesExpire: int64(time.Duration(c.Redis.ItemLikesExpire) / time.Second),
|
|
// databus
|
|
statDbus: databus.New(c.Databus.Stat),
|
|
}
|
|
|
|
d.statStmt = d.tidb.Prepared(_statSQL)
|
|
d.itemLikesStmt = d.itemTidb.Prepared(_itemLikesSQL)
|
|
d.businessesStmt = d.tidb.Prepared(_businessesSQL)
|
|
d.userLikesStmt = d.tidb.Prepared(_userLikeListSQL)
|
|
d.likeStateStmt = d.tidb.Prepared(_likeStateSQL)
|
|
d.updateLikeStateStmt = d.tidb.Prepared(_updateLikeStateSQL)
|
|
|
|
return
|
|
}
|
|
|
|
// Close .
|
|
func (d *Dao) Close() {
|
|
d.mc.Close()
|
|
d.tidb.Close()
|
|
d.redis.Close()
|
|
}
|
|
|
|
// Ping .
|
|
func (d *Dao) Ping(c context.Context) (err error) {
|
|
if err = d.pingMC(c); err != nil {
|
|
log.Error("d.pingMC error(%v)", err)
|
|
return
|
|
}
|
|
if err = d.pingRedis(c); err != nil {
|
|
log.Error("d.pingRedis error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// pingMC ping memcache
|
|
func (d *Dao) pingMC(c context.Context) (err error) {
|
|
conn := d.mc.Get(c)
|
|
defer conn.Close()
|
|
item := memcache.Item{Key: "ping", Value: []byte{1}, Expiration: 100}
|
|
err = conn.Set(&item)
|
|
return
|
|
}
|
|
|
|
// pingRedis ping redis.
|
|
func (d *Dao) pingRedis(c context.Context) (err error) {
|
|
conn := d.redis.Get(c)
|
|
defer conn.Close()
|
|
_, err = conn.Do("SET", "PING", "PONG")
|
|
return
|
|
}
|