138 lines
3.4 KiB
Go
138 lines
3.4 KiB
Go
package service
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"go-common/app/job/main/passport/model"
|
|
"go-common/library/log"
|
|
"go-common/library/queue/databus"
|
|
)
|
|
|
|
func (s *Service) authBinLogconsumeproc() {
|
|
mergeNum := s.c.Group.AuthBinLog.Num
|
|
var (
|
|
err error
|
|
n int
|
|
msgs = s.authBinLog.Messages()
|
|
)
|
|
for {
|
|
msg, ok := <-msgs
|
|
if !ok {
|
|
log.Error("s.authBinLogconsumeproc closed")
|
|
return
|
|
}
|
|
// marked head to first commit
|
|
m := &message{data: msg}
|
|
if n, err = strconv.Atoi(msg.Key); err != nil {
|
|
log.Error("strconv.Atoi(%s) error(%v)", msg.Key, err)
|
|
continue
|
|
}
|
|
s.authBinLogMu.Lock()
|
|
if s.authBinLogHead == nil {
|
|
s.authBinLogHead = m
|
|
s.authBinLogLast = m
|
|
} else {
|
|
s.authBinLogLast.next = m
|
|
s.authBinLogLast = m
|
|
}
|
|
s.authBinLogMu.Unlock()
|
|
// use specify goroutine to merge messages
|
|
s.authBinLogMergeChans[n%mergeNum] <- m
|
|
log.Info("authBinLogconsumeproc key:%s partition:%d offset:%d", msg.Key, msg.Partition, msg.Offset)
|
|
}
|
|
}
|
|
|
|
func (s *Service) authBinLogcommitproc() {
|
|
commits := make(map[int32]*databus.Message, s.c.Group.AuthBinLog.Size)
|
|
for {
|
|
done := <-s.authBinLogDoneChan
|
|
// merge partitions to commit offset
|
|
for _, d := range done {
|
|
d.done = true
|
|
}
|
|
s.mu.Lock()
|
|
for ; s.authBinLogHead != nil && s.authBinLogHead.done; s.authBinLogHead = s.authBinLogHead.next {
|
|
commits[s.authBinLogHead.data.Partition] = s.authBinLogHead.data
|
|
}
|
|
s.mu.Unlock()
|
|
for k, m := range commits {
|
|
log.Info("authBinLogcommitproc committed, key:%s partition:%d offset:%d", m.Key, m.Partition, m.Offset)
|
|
m.Commit()
|
|
delete(commits, k)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Service) authBinLogmergeproc(c chan *message) {
|
|
var (
|
|
err error
|
|
max = s.c.Group.AuthBinLog.Size
|
|
merges = make([]*model.AuthToken, 0, max)
|
|
marked = make([]*message, 0, max)
|
|
ticker = time.NewTicker(time.Duration(s.c.Group.AuthBinLog.Ticker))
|
|
)
|
|
for {
|
|
select {
|
|
case msg, ok := <-c:
|
|
if !ok {
|
|
log.Error("s.authBinLogmergeproc closed")
|
|
return
|
|
}
|
|
bmsg := &model.BMsg{}
|
|
if err = json.Unmarshal(msg.data.Value, bmsg); err != nil {
|
|
log.Error("json.Unmarshal(%s) error(%v)", string(msg.data.Value), err)
|
|
continue
|
|
}
|
|
if bmsg.Action == "delete" && strings.HasPrefix(bmsg.Table, "user_token_") {
|
|
t := &model.AuthToken{}
|
|
if err = json.Unmarshal(bmsg.New, t); err != nil {
|
|
log.Error("json.Unmarshal(%s) error(%v)", string(bmsg.New), err)
|
|
continue
|
|
}
|
|
merges = append(merges, t)
|
|
}
|
|
marked = append(marked, msg)
|
|
if len(marked) < max && len(merges) < max {
|
|
continue
|
|
}
|
|
case <-ticker.C:
|
|
}
|
|
if len(merges) > 0 {
|
|
s.cleanAuthTokens(merges)
|
|
merges = make([]*model.AuthToken, 0, max)
|
|
}
|
|
if len(marked) > 0 {
|
|
s.authBinLogDoneChan <- marked
|
|
marked = make([]*message, 0, max)
|
|
}
|
|
}
|
|
}
|
|
|
|
// cleanTokens by auth .
|
|
func (s *Service) cleanAuthTokens(authTokens []*model.AuthToken) {
|
|
for _, authToken := range authTokens {
|
|
var (
|
|
bytes []byte
|
|
err error
|
|
)
|
|
if bytes, err = base64.StdEncoding.DecodeString(authToken.Token); err != nil {
|
|
log.Error("cleanAuthTokens base64 decode err %v", err)
|
|
continue
|
|
}
|
|
token := hex.EncodeToString(bytes)
|
|
log.Info("auth binlog clear cleanAuthTokens,msg is (%+v)", authToken)
|
|
t := &model.AccessInfo{
|
|
Mid: authToken.Mid,
|
|
AppID: int32(authToken.AppID),
|
|
Token: token,
|
|
Expires: authToken.Expires,
|
|
}
|
|
s.cleanToken(t)
|
|
}
|
|
}
|