|
|
package rank
|
|
|
|
|
|
import (
|
|
|
"context"
|
|
|
"git.noahlan.cn/northlan/ntools-go/uuid"
|
|
|
lru "github.com/hashicorp/golang-lru"
|
|
|
zset "github.com/longzhiri/gozset"
|
|
|
"github.com/pkg/errors"
|
|
|
"github.com/robfig/cron/v3"
|
|
|
"github.com/zeromicro/go-zero/core/logx"
|
|
|
"live-service/app/user_center/model"
|
|
|
"live-service/app/user_center/rpc/internal/svc"
|
|
|
"live-service/app/user_center/rpc/pb"
|
|
|
"time"
|
|
|
)
|
|
|
|
|
|
var Service *Job
|
|
|
|
|
|
type (
|
|
|
CachedUserInfo struct {
|
|
|
UserId int64
|
|
|
Username string
|
|
|
Avatar string
|
|
|
}
|
|
|
Job struct {
|
|
|
ctx context.Context
|
|
|
svcCtx *svc.ServiceContext
|
|
|
|
|
|
// 实时排行榜(定期读取，半实时)
|
|
|
rankByTypeMap map[pb.RankType]*zset.ZSetInt
|
|
|
|
|
|
//damageRank *zset.ZSetInt
|
|
|
//deDamageRank *zset.ZSetInt
|
|
|
//generalRank *zset.ZSetInt
|
|
|
//deGeneralRank *zset.ZSetInt
|
|
|
//killUnitRank *zset.ZSetInt
|
|
|
//deKillUnitRank *zset.ZSetInt
|
|
|
//killPlayerRank *zset.ZSetInt
|
|
|
//deKillPlayerRank *zset.ZSetInt
|
|
|
//winRank *zset.ZSetInt
|
|
|
//lostRank *zset.ZSetInt
|
|
|
//firstBloodRank *zset.ZSetInt
|
|
|
//deFirstBloodRank *zset.ZSetInt
|
|
|
|
|
|
// 用户数据表内存缓存
|
|
|
userCache *lru.Cache
|
|
|
}
|
|
|
)
|
|
|
|
|
|
func InitRankJob(svcCtx *svc.ServiceContext) {
|
|
|
lessFunc := func(l, r int32) bool {
|
|
|
return l > r
|
|
|
}
|
|
|
uc, _ := lru.New(4*model.MaxRankN + 1000)
|
|
|
Service = &Job{
|
|
|
ctx: context.Background(),
|
|
|
svcCtx: svcCtx,
|
|
|
rankByTypeMap: map[pb.RankType]*zset.ZSetInt{
|
|
|
pb.RankType_Damage: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
pb.RankType_DeDamage: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
pb.RankType_General: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
pb.RankType_DeGeneral: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
pb.RankType_KillUnit: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
pb.RankType_DeKillUnit: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
pb.RankType_KillPlayer: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
pb.RankType_DeKillPlayer: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
pb.RankType_Win: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
pb.RankType_Lost: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
pb.RankType_FirstBlood: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
pb.RankType_DeFirstBlood: zset.NewZSetInt(lessFunc, model.MaxRankN),
|
|
|
},
|
|
|
userCache: uc,
|
|
|
}
|
|
|
|
|
|
if !svcCtx.Config.Rank.Enabled {
|
|
|
return
|
|
|
}
|
|
|
Service.initJob()
|
|
|
}
|
|
|
|
|
|
// InitJob 初始化RankJob,启动时加载
|
|
|
// 1. 读取落地的排行榜数据，并Add到榜内（读取 用户数据）
|
|
|
// 2. 开启任务 定时读取 分数大于排行榜最后一位的数据，存在则Update
|
|
|
// 3. 开启任务 定时落库
|
|
|
func (j *Job) initJob() {
|
|
|
logx.Info("开启排行榜服务...")
|
|
|
// TODO 读取历史数据功能暂时移除
|
|
|
//j.initByType(model.RankTypeDamage)
|
|
|
//j.initByType(model.RankTypeDeDamage)
|
|
|
//j.initByType(model.RankTypeGeneral)
|
|
|
//j.initByType(model.RankTypeDeGeneral)
|
|
|
//j.initByType(model.RankTypeKillUnit)
|
|
|
//j.initByType(model.RankTypeDeKillUnit)
|
|
|
//j.initByType(model.RankTypeKillPlayer)
|
|
|
//j.initByType(model.RankTypeDeKillPlayer)
|
|
|
//j.initByType(model.RankTypeWin)
|
|
|
//j.initByType(model.RankTypeLost)
|
|
|
//j.initByType(model.RankTypeFirstBlood)
|
|
|
//j.initByType(model.RankTypeDeFirstBlood)
|
|
|
|
|
|
cfg := j.svcCtx.Config.Rank
|
|
|
// job read and update
|
|
|
c := cron.New()
|
|
|
_, _ = c.AddFunc(cfg.Cron.Update, func() {
|
|
|
go j.readAndUpdate(pb.RankType_Damage)
|
|
|
go j.readAndUpdate(pb.RankType_DeDamage)
|
|
|
go j.readAndUpdate(pb.RankType_General)
|
|
|
go j.readAndUpdate(pb.RankType_DeGeneral)
|
|
|
go j.readAndUpdate(pb.RankType_KillUnit)
|
|
|
go j.readAndUpdate(pb.RankType_DeKillUnit)
|
|
|
go j.readAndUpdate(pb.RankType_KillPlayer)
|
|
|
go j.readAndUpdate(pb.RankType_DeKillPlayer)
|
|
|
go j.readAndUpdate(pb.RankType_Win)
|
|
|
go j.readAndUpdate(pb.RankType_Lost)
|
|
|
go j.readAndUpdate(pb.RankType_FirstBlood)
|
|
|
go j.readAndUpdate(pb.RankType_DeFirstBlood)
|
|
|
})
|
|
|
// persistence
|
|
|
_, _ = c.AddFunc(cfg.Cron.Persistence, func() {
|
|
|
go j.persistence(pb.RankType_Damage)
|
|
|
go j.persistence(pb.RankType_DeDamage)
|
|
|
go j.persistence(pb.RankType_General)
|
|
|
go j.persistence(pb.RankType_DeGeneral)
|
|
|
go j.persistence(pb.RankType_KillUnit)
|
|
|
go j.persistence(pb.RankType_DeKillUnit)
|
|
|
go j.persistence(pb.RankType_KillPlayer)
|
|
|
go j.persistence(pb.RankType_DeKillPlayer)
|
|
|
go j.persistence(pb.RankType_Win)
|
|
|
go j.persistence(pb.RankType_Lost)
|
|
|
go j.persistence(pb.RankType_FirstBlood)
|
|
|
go j.persistence(pb.RankType_DeFirstBlood)
|
|
|
})
|
|
|
c.Start()
|
|
|
}
|
|
|
|
|
|
func (j *Job) RankByScore(rankType pb.RankType, score int32) int32 {
|
|
|
rankZSet, _, err := j.getRankInstanceAndScoreType(rankType)
|
|
|
if err != nil {
|
|
|
return 0
|
|
|
}
|
|
|
|
|
|
rank := rankZSet.RangeByScore(score, score)
|
|
|
if len(rank) > 0 {
|
|
|
return int32(rankZSet.Rank(rank[0]))
|
|
|
}
|
|
|
return 0
|
|
|
}
|
|
|
|
|
|
func (j *Job) RangeRankByType(rankType pb.RankType, topN int32) *pb.RankPvpResp {
|
|
|
result := &pb.RankPvpResp{
|
|
|
Type: int32(rankType),
|
|
|
}
|
|
|
rankZSet, _, err := j.getRankInstanceAndScoreType(rankType)
|
|
|
if err != nil {
|
|
|
return result
|
|
|
}
|
|
|
if topN > model.MaxRankN {
|
|
|
topN = model.MaxRankN
|
|
|
}
|
|
|
rank := rankZSet.RangeByRank(1, uint32(topN))
|
|
|
|
|
|
// 这里make 减少扩容次数
|
|
|
result.Items = make([]*pb.RankPvpResp_Item, 0, len(rank))
|
|
|
for _, r := range rank {
|
|
|
uid := r[0]
|
|
|
score := r[1]
|
|
|
|
|
|
var item pb.RankPvpResp_Item
|
|
|
if c, ok := j.userCache.Get(uid); ok {
|
|
|
cached := c.(CachedUserInfo)
|
|
|
item = pb.RankPvpResp_Item{
|
|
|
Uid: cached.UserId,
|
|
|
Uname: cached.Username,
|
|
|
Score: score,
|
|
|
Avatar: cached.Avatar,
|
|
|
}
|
|
|
} else {
|
|
|
dbUser, err := j.svcCtx.UserPlatformModel.FindDisplayOneByUserId(j.ctx, uid)
|
|
|
if err != nil {
|
|
|
item = pb.RankPvpResp_Item{
|
|
|
Uid: uid,
|
|
|
Score: score,
|
|
|
}
|
|
|
} else {
|
|
|
item = pb.RankPvpResp_Item{
|
|
|
Uid: uid,
|
|
|
Uname: dbUser.PUname,
|
|
|
Score: score,
|
|
|
Avatar: dbUser.PAvatar,
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
result.Items = append(result.Items, &item)
|
|
|
}
|
|
|
return result
|
|
|
}
|
|
|
|
|
|
func (j *Job) initByType(rankType pb.RankType) {
|
|
|
list, err := j.svcCtx.RankPvpModel.RankListByType(j.ctx, int64(rankType), model.MaxRankN)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
rankZSet, _, err := j.getRankInstanceAndScoreType(rankType)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
for _, user := range list {
|
|
|
// 缓存用户信息
|
|
|
j.userCache.Add(user.UserId, CachedUserInfo{
|
|
|
UserId: user.UserId,
|
|
|
Username: user.PUname,
|
|
|
Avatar: user.PAvatar,
|
|
|
})
|
|
|
rankZSet.Add(user.UserId, int32(user.Score))
|
|
|
}
|
|
|
}
|
|
|
|
|
|
func (j *Job) readAndUpdate(rankType pb.RankType) {
|
|
|
rankZSet, scoreType, err := j.getRankInstanceAndScoreType(rankType)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
rank := rankZSet.RangeByRank(1, model.MaxRankN)
|
|
|
|
|
|
rankLen := len(rank)
|
|
|
var score int64
|
|
|
if rankLen > 0 {
|
|
|
// 取当前榜最后一名分数
|
|
|
score = rank[rankLen-1][1]
|
|
|
}
|
|
|
// 若榜内数量不够，则直接取 max - len 数量的人 score排序一下
|
|
|
limit := model.MaxRankN
|
|
|
if rankLen < model.MaxRankN {
|
|
|
limit = model.MaxRankN - rankLen + 1 // +1是避免取到自己 少取一位
|
|
|
}
|
|
|
|
|
|
// 末位 score
|
|
|
byScore, err := j.svcCtx.StatisticsPvpModel.FindGreaterByScore(j.ctx, score, scoreType, limit)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
for _, s := range byScore {
|
|
|
// 缓存用户信息
|
|
|
if ok := j.userCache.Contains(s.UserId); !ok {
|
|
|
if dbUser, err := j.svcCtx.UserPlatformModel.FindDisplayOneByUserId(j.ctx, s.UserId); err == nil {
|
|
|
j.userCache.Add(dbUser.UserId, CachedUserInfo{
|
|
|
UserId: dbUser.UserId,
|
|
|
Username: dbUser.PUname,
|
|
|
Avatar: dbUser.PAvatar,
|
|
|
})
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if _, ok := rankZSet.Score(s.UserId); ok {
|
|
|
rankZSet.Update(s.UserId, int32(s.Score))
|
|
|
} else {
|
|
|
rankZSet.Add(s.UserId, int32(s.Score))
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
func (j *Job) persistence(rankType pb.RankType) {
|
|
|
rankZSet, _, err := j.getRankInstanceAndScoreType(rankType)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
rank := rankZSet.RangeByRank(1, model.MaxRankN)
|
|
|
dbModel := make([]model.RankPvp, 0, len(rank))
|
|
|
for _, r := range rank {
|
|
|
uid := r[0]
|
|
|
score := r[1]
|
|
|
dbModel = append(dbModel, model.RankPvp{
|
|
|
Id: uuid.NextId(),
|
|
|
UserId: uid,
|
|
|
RankType: int64(rankType),
|
|
|
Score: score,
|
|
|
})
|
|
|
}
|
|
|
if len(dbModel) > 0 {
|
|
|
// 简单避免死锁
|
|
|
time.Sleep(1 * time.Second)
|
|
|
if err = j.svcCtx.RankPvpModel.UpdateRank(j.ctx, int64(rankType), dbModel); err != nil {
|
|
|
logx.Error("更新排行榜错误", err)
|
|
|
return
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
func (j *Job) getRankInstanceAndScoreType(rankType pb.RankType) (*zset.ZSetInt, model.ScoreType, error) {
|
|
|
var rankZSet *zset.ZSetInt
|
|
|
scoreType := model.ScoreTypeByRankType(rankType)
|
|
|
rankZSet, _ = j.rankByTypeMap[rankType]
|
|
|
if rankZSet == nil {
|
|
|
return nil, scoreType, errors.Errorf("没有此类型 [%d] 的排行榜", rankType)
|
|
|
}
|
|
|
return rankZSet, scoreType, nil
|
|
|
}
|