380 lines
11 KiB
Go
380 lines
11 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"sort"
|
||
"time"
|
||
|
||
model "go-common/app/job/main/reply/model/reply"
|
||
"go-common/library/log"
|
||
)
|
||
|
||
const (
|
||
_replySliceNum = 20000
|
||
)
|
||
|
||
func dialogMapByRoot(rootID int64, rps []*model.RpItem, oid int64, tp int8) (dialogMap map[int64][]*model.RpItem) {
|
||
length := len(rps)
|
||
dialogMap = make(map[int64][]*model.RpItem)
|
||
// 根评论下没有评论
|
||
if length == 0 {
|
||
return
|
||
}
|
||
|
||
// 这里由于种种原因， 可能子评论的ID比父评论大，故按Floor排序
|
||
// 按Floor严格排序，保证父评论也几乎是升序排列，提高后续的命中率
|
||
sort.Slice(rps, func(i, j int) bool {
|
||
return rps[i].Floor < rps[j].Floor
|
||
})
|
||
|
||
for i := 0; i < length; i++ {
|
||
if rps[i] == nil {
|
||
return
|
||
}
|
||
if rps[i].Parent == rootID {
|
||
// 对话根评论
|
||
continue
|
||
}
|
||
// i-1 must >= 0, 因为第一个元素必然是对话根评论which parrent=root, 出现这种情况说明数据是脏的
|
||
if i-1 < 0 {
|
||
log.Error("invalid data, rootID(%d), rpID(%d), parrent(%d) oid(%d) type(%d)", rootID, rps[i].ID, rps[i].Parent, oid, tp)
|
||
return
|
||
}
|
||
|
||
if rps[i].Parent == rps[i-1].Parent {
|
||
// 和上一条评论回复同一条评论的情况，按ID排序，所以这种情况的概率会很高
|
||
rps[i].Next = rps[i-1].Next
|
||
} else {
|
||
var j int
|
||
if sort.IsSorted(model.RpItems(rps)) {
|
||
// 和上一条评论回复不同评论的情况, 其父评论一定在它之前
|
||
j = sort.Search(i, func(n int) bool {
|
||
return rps[n].ID >= rps[i].Parent
|
||
})
|
||
} else {
|
||
for index := range rps[:i] {
|
||
if rps[index].ID == rps[i].Parent {
|
||
j = index
|
||
break
|
||
}
|
||
}
|
||
}
|
||
// search 如果返回j==i说明没搜索,或者遍历到了最后一个, 这种情况说明数据是脏的
|
||
if j == i {
|
||
log.Error("invalid data, rootID(%d), rpID(%d), parrent(%d) oid(%d) type(%d)", rootID, rps[i].ID, rps[i].Parent, oid, tp)
|
||
return nil
|
||
}
|
||
rps[i].Next = rps[j]
|
||
}
|
||
}
|
||
tmp := new(struct {
|
||
ID int64
|
||
DiaglogID int64
|
||
})
|
||
for i := 0; i < length; i++ {
|
||
if rps[i] == nil {
|
||
return
|
||
}
|
||
|
||
next := rps[i].Next
|
||
if next == nil {
|
||
// 如果是对话根评论
|
||
dialogMap[rps[i].ID] = append(dialogMap[rps[i].ID], rps[i])
|
||
} else if next.ID == tmp.ID {
|
||
// 这里tmp缓存了上一个评论的父评论, 减少查找的次数
|
||
// 如果跟上一条评论评论的是同一条评论,则可以直接加进上一个dialog
|
||
dialogMap[tmp.DiaglogID] = append(dialogMap[tmp.DiaglogID], rps[i])
|
||
} else {
|
||
depth := 0
|
||
for next.Next != nil {
|
||
next = next.Next
|
||
depth++
|
||
if depth > 10000 {
|
||
for i := range rps {
|
||
log.Error("rp: %v", rps[i])
|
||
}
|
||
log.Error("recursive reach max depth")
|
||
return nil
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) setDialogByRoot(c context.Context, oid int64, tp int8, rootID int64) (err error) {
|
||
// 循环获取某个根评论下的所有子评论
|
||
rps, err := s.dao.Reply.FixDialogGetRepliesByRoot(c, oid, tp, rootID)
|
||
if err != nil {
|
||
log.Error("fix dialog error (%v)", err)
|
||
return
|
||
}
|
||
//根据所有子评论构造 key为二级父评论(即对话根评论), value为二级父评论下的所有子评论的map
|
||
dialogMap := dialogMapByRoot(rootID, rps, oid, tp)
|
||
for k, v := range dialogMap {
|
||
ids := make([]int64, len(v))
|
||
for i := range v {
|
||
ids[i] = v[i].ID
|
||
}
|
||
s.dao.Reply.FixDialogSetDialogBatch(c, oid, k, ids)
|
||
}
|
||
return
|
||
}
|
||
|
||
// actionRecoverFixDialog fix dialog
|
||
func (s *Service) actionRecoverFixDialog(c context.Context, msg *consumerMsg) {
|
||
var (
|
||
err error
|
||
)
|
||
var d struct {
|
||
Oid int64 `json:"oid"`
|
||
Tp int8 `json:"tp"`
|
||
Root int64 `json:"root"`
|
||
}
|
||
if err = json.Unmarshal([]byte(msg.Data), &d); err != nil {
|
||
log.Error("json.Unmarshal() error(%v)", err)
|
||
return
|
||
}
|
||
s.setDialogByRoot(c, d.Oid, d.Tp, d.Root)
|
||
}
|
||
|
||
func (s *Service) actionRecoverDialog(c context.Context, msg *consumerMsg) {
|
||
var (
|
||
ok bool
|
||
err error
|
||
)
|
||
var d struct {
|
||
Oid int64 `json:"oid"`
|
||
Tp int8 `json:"tp"`
|
||
Root int64 `json:"root"`
|
||
Dialog int64 `json:"dialog"`
|
||
}
|
||
if err = json.Unmarshal([]byte(msg.Data), &d); err != nil {
|
||
log.Error("json.Unmarshal() error(%v)", err)
|
||
return
|
||
}
|
||
if ok, err = s.dao.Redis.ExpireDialogIndex(c, d.Dialog); err == nil && !ok {
|
||
rps, err := s.dao.Reply.GetByDialog(c, d.Oid, d.Tp, d.Root, d.Dialog)
|
||
if err != nil {
|
||
return
|
||
}
|
||
err = s.dao.Redis.AddDialogIndex(c, d.Dialog, rps)
|
||
if err != nil {
|
||
log.Error("s.dao.Redis.AddDialogIndex() error (%v)", err)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
|
||
func (s *Service) acionRecoverFloorIdx(c context.Context, msg *consumerMsg) {
|
||
var (
|
||
err error
|
||
rCount int
|
||
limit int
|
||
ok bool
|
||
sub *model.Subject
|
||
)
|
||
var d struct {
|
||
Oid int64 `json:"oid"`
|
||
Tp int8 `json:"tp"`
|
||
Count int `json:"count"`
|
||
Floor int `json:"floor"`
|
||
}
|
||
if err = json.Unmarshal([]byte(msg.Data), &d); err != nil {
|
||
log.Error("json.Unmarshal() error(%v)", err)
|
||
return
|
||
}
|
||
sub, err = s.getSubject(c, d.Oid, d.Tp)
|
||
if err != nil || sub == nil {
|
||
log.Error("s.getSubject(%d,%d) failed!err:=%v", d.Oid, d.Tp, err)
|
||
return
|
||
}
|
||
if sub.RCount == 0 {
|
||
return
|
||
}
|
||
startFloor := sub.Count + 1
|
||
if ok, err = s.dao.Redis.ExpireIndex(c, d.Oid, d.Tp, model.SortByFloor); err == nil && ok {
|
||
startFloor, err = s.dao.Redis.MinScore(c, d.Oid, d.Tp, model.SortByFloor)
|
||
if err != nil {
|
||
log.Error("s.dao.Redis.MinScore(%d,%d) failed!err:=%v", d.Oid, d.Tp, err)
|
||
return
|
||
}
|
||
if startFloor <= 1 {
|
||
if startFloor != -1 {
|
||
if err = s.dao.Redis.AddFloorIndexEnd(c, d.Oid, d.Tp); err != nil {
|
||
log.Error("s.dao.Redis.AddFloorIndexEnd(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
if d.Count > 0 {
|
||
rCount, err = s.dao.Redis.CountReplies(c, d.Oid, d.Tp, model.SortByFloor)
|
||
if err != nil {
|
||
log.Error("s.dao.Redis.CountReplies(%d,%d) failed!err:=%v", d.Oid, d.Tp, err)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
if d.Count > 0 {
|
||
limit = d.Count - rCount
|
||
} else if d.Floor > 0 {
|
||
limit = startFloor - d.Floor
|
||
} else {
|
||
log.Warn("RecoverFloorByCount(%d,%d) count(%d) or floor(%d) invalid!", d.Oid, d.Tp, d.Floor, d.Count)
|
||
return
|
||
}
|
||
limit += s.batchNumber
|
||
if limit < (s.batchNumber / 2) {
|
||
return
|
||
} else if limit < s.batchNumber {
|
||
limit = s.batchNumber
|
||
}
|
||
rs, err := s.dao.Reply.GetByFloorLimit(c, d.Oid, d.Tp, startFloor, limit)
|
||
if err != nil {
|
||
log.Error("s.dao.Reply.GetByFloorLimit(%d,%d) failed!err:=%v", d.Oid, d.Tp, err)
|
||
return
|
||
}
|
||
if err = s.dao.Redis.AddFloorIndex(c, d.Oid, d.Tp, rs...); err != nil {
|
||
log.Error("s.dao.Redis.AddFloorIndex(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
}
|
||
if len(rs) < limit {
|
||
if err = s.dao.Redis.AddFloorIndexEnd(c, d.Oid, d.Tp); err != nil {
|
||
log.Error("s.dao.Redis.AddFloorIndexEnd(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
}
|
||
return
|
||
}
|
||
}
|
||
|
||
// actionRecoverIndex recover index of archive's reply
|
||
func (s *Service) actionRecoverIndex(c context.Context, msg *consumerMsg) {
|
||
var (
|
||
err error
|
||
ok bool
|
||
sub *model.Subject
|
||
rs []*model.Reply
|
||
)
|
||
var d struct {
|
||
Oid int64 `json:"oid"`
|
||
Tp int8 `json:"tp"`
|
||
Sort int8 `json:"sort"`
|
||
}
|
||
if err = json.Unmarshal([]byte(msg.Data), &d); err != nil {
|
||
log.Error("json.Unmarshal() error(%v)", err)
|
||
return
|
||
}
|
||
if d.Oid <= 0 || !model.CheckSort(d.Sort) {
|
||
log.Error("The structure of doActionRecoverIndex msg.Data(%s) was wrong", msg.Data)
|
||
return
|
||
}
|
||
if ok, err = s.dao.Redis.ExpireIndex(c, d.Oid, d.Tp, d.Sort); err == nil && !ok {
|
||
sub, err = s.getSubject(c, d.Oid, d.Tp)
|
||
if err != nil || sub == nil {
|
||
log.Error("s.getSubject failed , oid(%d,%d) err(%v)", d.Oid, d.Tp, err)
|
||
return
|
||
}
|
||
if d.Sort == model.SortByFloor {
|
||
rs, err = s.dao.Reply.GetAllInSlice(c, d.Oid, d.Tp, sub.Count, _replySliceNum)
|
||
if err != nil {
|
||
log.Error("dao.Reply.GetAllInSlice(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
return
|
||
}
|
||
// floor index
|
||
if ok, err = s.dao.Redis.ExpireIndex(c, d.Oid, d.Tp, model.SortByFloor); err == nil && !ok {
|
||
if err = s.dao.Redis.AddFloorIndex(c, d.Oid, d.Tp, rs...); err != nil {
|
||
log.Error("s.dao.Redis.AddFloorIndex(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
}
|
||
if err = s.dao.Redis.AddFloorIndexEnd(c, d.Oid, d.Tp); err != nil {
|
||
log.Error("s.dao.Redis.AddFloorIndexEnd(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
}
|
||
}
|
||
} else if d.Sort == model.SortByLike {
|
||
rs, err = s.dao.Reply.GetByLikeLimit(c, d.Oid, d.Tp, 30000)
|
||
if err != nil {
|
||
log.Error("dao.Reply.GetAllInSlice(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
return
|
||
}
|
||
// like index
|
||
if ok, err = s.dao.Redis.ExpireIndex(c, d.Oid, d.Tp, model.SortByLike); err == nil && !ok {
|
||
rpts, _ := s.dao.Report.GetMapByOid(c, d.Oid, d.Tp)
|
||
if err = s.dao.Redis.AddLikeIndexBatch(c, d.Oid, d.Tp, rpts, rs...); err != nil {
|
||
log.Error("s.dao.Redis.AddLikeIndexBatch(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
}
|
||
}
|
||
} else if d.Sort == model.SortByCount {
|
||
rs, err = s.dao.Reply.GetByCountLimit(c, d.Oid, d.Tp, 20000)
|
||
if err != nil {
|
||
log.Error("dao.Reply.GetAllInSlice(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
return
|
||
}
|
||
// count index
|
||
if ok, err = s.dao.Redis.ExpireIndex(c, d.Oid, d.Tp, model.SortByCount); err == nil && !ok {
|
||
if err = s.dao.Redis.AddCountIndexBatch(c, d.Oid, d.Tp, rs...); err != nil {
|
||
log.Error("s.dao.Redis.AddCountIndex(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
}
|
||
}
|
||
}
|
||
// 回源index时把top缓存初始化，减少attr扫表慢查询
|
||
if n := sub.TopCount(); n > 0 {
|
||
for _, r := range rs {
|
||
if r.IsTop() {
|
||
top := model.SubAttrAdminTop
|
||
if r.IsUpTop() {
|
||
top = model.SubAttrUpperTop
|
||
}
|
||
err = sub.TopSet(r.RpID, top, 1)
|
||
if err == nil {
|
||
_, err = s.dao.Subject.UpMeta(c, d.Oid, d.Tp, sub.Meta, time.Now())
|
||
if err != nil {
|
||
log.Error("s.dao.Subject.UpMeta(%d,%d,%d) failed!err:=%v ", r.RpID, r.Oid, d.Tp, err)
|
||
}
|
||
s.dao.Mc.AddSubject(c, sub)
|
||
}
|
||
// get reply with content
|
||
var rp *model.Reply
|
||
rp, err = s.getReply(c, d.Oid, r.RpID)
|
||
if err == nil && rp != nil {
|
||
s.dao.Mc.AddTop(c, rp)
|
||
}
|
||
n--
|
||
}
|
||
if n == 0 {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// actionRecoverRootIndex recover index of root reply
|
||
func (s *Service) actionRecoverRootIndex(c context.Context, msg *consumerMsg) {
|
||
var (
|
||
err error
|
||
ok bool
|
||
rs []*model.Reply
|
||
)
|
||
var d struct {
|
||
Oid int64 `json:"oid"`
|
||
Tp int8 `json:"tp"`
|
||
Root int64 `json:"root"`
|
||
}
|
||
if err = json.Unmarshal([]byte(msg.Data), &d); err != nil {
|
||
log.Error("json.Unmarshal() error(%v)", err)
|
||
return
|
||
}
|
||
if d.Oid <= 0 || d.Root <= 0 {
|
||
log.Error("The structure of doActionRecoverRootIndex msg.Data(%s) was wrong", msg.Data)
|
||
return
|
||
}
|
||
if ok, err = s.dao.Redis.ExpireNewChildIndex(c, d.Root); err == nil && !ok {
|
||
if rs, err = s.dao.Reply.GetAllByRoot(c, d.Oid, d.Root, d.Tp); err != nil {
|
||
log.Error("dao.Reply.GetAllReply(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
return
|
||
}
|
||
if err = s.dao.Redis.AddNewChildIndex(c, d.Root, rs...); err != nil {
|
||
log.Error("s.dao.Redis.AddFloorIndexByRoot(%d, %d) error(%v)", d.Oid, d.Tp, err)
|
||
return
|
||
}
|
||
}
|
||
}
|