323 lines
8.3 KiB
Go
323 lines
8.3 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"math/rand"
|
||
"time"
|
||
|
||
"go-common/app/job/main/aegis/model"
|
||
moniMdl "go-common/app/job/main/aegis/model/monitor"
|
||
"go-common/library/log"
|
||
"go-common/library/queue/databus"
|
||
)
|
||
|
||
var (
|
||
_taskTable = "task"
|
||
)
|
||
|
||
func (s *Service) taskconsumeproc() {
|
||
defer func() {
|
||
log.Warn("taskconsumeproc exited.")
|
||
s.wg.Done()
|
||
}()
|
||
|
||
var (
|
||
binLogMsgs = s.binLogDataBus.Messages()
|
||
)
|
||
|
||
for {
|
||
select {
|
||
case msg, ok := <-binLogMsgs:
|
||
if !ok {
|
||
log.Warn("binLogDataBus has been closed.")
|
||
return
|
||
}
|
||
log.Info("binLogDataBus key(%s) offset(%d) message(%s)",
|
||
msg.Key, msg.Offset, msg.Value)
|
||
s.handleBinLog(msg)
|
||
case rpi := <-s.chanReport:
|
||
s.reportResource(context.Background(), rpi.BizID, rpi.FlowID, rpi.RID, rpi.UID)
|
||
default:
|
||
time.Sleep(time.Second)
|
||
}
|
||
}
|
||
}
|
||
|
||
func (s *Service) archiveConsumeProc() {
|
||
defer func() {
|
||
log.Warn("archiveConsumeProc exited.")
|
||
s.wg.Done()
|
||
}()
|
||
var (
|
||
msgs = s.archiveDataBus.Messages()
|
||
)
|
||
for {
|
||
var (
|
||
msg *databus.Message
|
||
ok bool
|
||
err error
|
||
)
|
||
if msg, ok = <-msgs; !ok {
|
||
log.Error("s.archiveDataBus.Messages() closed.")
|
||
return
|
||
}
|
||
msg.Commit()
|
||
|
||
m := &model.BinLog{}
|
||
if err = json.Unmarshal(msg.Value, m); err != nil {
|
||
log.Error("json.Unmarshal(%s) error(%v)", msg.Value, err)
|
||
continue
|
||
}
|
||
if m.Table == "archive" {
|
||
s.handleArchiveBinlog(m)
|
||
} else if m.Table == "archive_video" {
|
||
s.handleVideoBinlog(m)
|
||
}
|
||
}
|
||
}
|
||
|
||
func (s *Service) handleArchiveBinlog(m *model.BinLog) {
|
||
var (
|
||
err error
|
||
)
|
||
na := &moniMdl.BinlogArchive{}
|
||
oa := &moniMdl.BinlogArchive{}
|
||
if err = json.Unmarshal(m.New, na); err != nil {
|
||
log.Error("json.Unmarshal(%s,%+v) error(%v)", m.New, na, err)
|
||
return
|
||
}
|
||
if err = json.Unmarshal(m.New, oa); err != nil {
|
||
log.Error("json.Unmarshal(%s,%+v) error(%v)", m.New, oa, err)
|
||
return
|
||
}
|
||
s.monitorArchive(m.Action, na, oa)
|
||
|
||
}
|
||
|
||
func (s *Service) handleVideoBinlog(m *model.BinLog) {
|
||
var (
|
||
err error
|
||
)
|
||
nv := &moniMdl.BinlogVideo{}
|
||
ov := &moniMdl.BinlogVideo{}
|
||
if err = json.Unmarshal(m.New, nv); err != nil {
|
||
log.Error("json.Unmarshal(%s,%+v) error(%v)", m.New, nv, err)
|
||
return
|
||
}
|
||
if err = json.Unmarshal(m.New, ov); err != nil {
|
||
log.Error("json.Unmarshal(%s,%+v) error(%v)", m.New, ov, err)
|
||
return
|
||
}
|
||
s.monitorVideo(m.Action, nv, ov)
|
||
|
||
}
|
||
|
||
func (s *Service) handleBinLog(msg *databus.Message) {
|
||
defer msg.Commit()
|
||
|
||
bmsg := new(model.BinLog)
|
||
if err := json.Unmarshal(msg.Value, bmsg); err != nil {
|
||
log.Error("json.Unmarshal(%s) error(%v)", string(msg.Value), err)
|
||
return
|
||
}
|
||
if bmsg.Table == _taskTable {
|
||
old := new(model.Task)
|
||
new := new(model.Task)
|
||
if err := json.Unmarshal(bmsg.New, new); err != nil {
|
||
log.Error("json.Unmarshal(%s) error(%v)", string(bmsg.New), err)
|
||
return
|
||
}
|
||
if bmsg.Action == "update" {
|
||
if err := json.Unmarshal(bmsg.Old, old); err != nil {
|
||
log.Error("json.Unmarshal(%s) error(%v)", string(bmsg.New), err)
|
||
return
|
||
}
|
||
}
|
||
s.handleBinLogMsg(context.Background(), bmsg.Action, old, new)
|
||
}
|
||
|
||
// use specify goroutine to merge messages
|
||
log.Info("handleBinlog table:%s key:%s partition:%d offset:%d", bmsg.Table, msg.Key, msg.Partition, msg.Offset)
|
||
}
|
||
|
||
//各种状态简写
|
||
const (
|
||
INT = model.TaskStateInit
|
||
DSP = model.TaskStateDispatch
|
||
DEY = model.TaskStateDelay
|
||
SUB = model.TaskStateSubmit
|
||
RSB = model.TaskStateRscSb
|
||
CLO = model.TaskStateClosed
|
||
LTD = model.LogTypeTaskDispatch
|
||
)
|
||
|
||
func (s *Service) handleRelease(c context.Context, old, new *model.Task) {
|
||
s.dao.RemovePersonalTask(c, old.BusinessID, old.FlowID, old.UID, old.ID)
|
||
s.dao.PushPublicTask(c, new)
|
||
s.sendTaskLog(c, new, LTD, "release", new.UID, "")
|
||
s.dao.IncresByField(c, old.BusinessID, old.FlowID, old.UID, model.Release, 1)
|
||
}
|
||
|
||
func (s *Service) handleDisptach(c context.Context, old, new *model.Task) {
|
||
//这里不做缓存同步，顺序会乱
|
||
s.sendTaskLog(c, new, LTD, "dispatch", new.UID, "")
|
||
s.dao.IncresByField(c, new.BusinessID, new.FlowID, new.UID, model.Dispatch, 1)
|
||
}
|
||
|
||
func (s *Service) handleDelay(c context.Context, old, new *model.Task) {
|
||
//这里不做缓存同步，顺序会乱
|
||
s.sendTaskLog(c, new, LTD, "delay", new.UID, "")
|
||
s.dao.IncresByField(c, new.BusinessID, new.FlowID, new.UID, model.Delay, 1)
|
||
}
|
||
|
||
/*
|
||
数据统计时，容易产生误差的几种数据
|
||
1. 任务被a领取，被b在资源列表提交
|
||
2. 任务被a延迟，被b在资源列表 或者 延迟列表提交
|
||
*/
|
||
func (s *Service) handleSubmit(c context.Context, old, new *model.Task) {
|
||
switch old.State {
|
||
case INT: // 未分配直接提交，资源列表里操作
|
||
s.dao.RemovePublicTask(c, old.BusinessID, old.FlowID, old.ID)
|
||
case DSP: // 领取后提交，也可能是资源列表操作
|
||
s.dao.RemovePersonalTask(c, old.BusinessID, old.FlowID, old.UID, old.ID)
|
||
case DEY: // 延迟列表提交，也可能是资源列表操作
|
||
s.dao.RemoveDelayTask(c, old.BusinessID, old.FlowID, old.UID, old.ID)
|
||
default: // 其他未知情况
|
||
log.Error("handleSubmit UNEXPECTED old(%+v) new(%v)", old, new)
|
||
}
|
||
|
||
switch new.State {
|
||
case SUB:
|
||
s.sendTaskLog(c, new, LTD, "tasksubmit", new.UID, "")
|
||
case RSB:
|
||
s.sendTaskLog(c, new, LTD, "rscsubmit", new.UID, "")
|
||
case CLO:
|
||
s.sendTaskLog(c, new, LTD, "close", new.UID, "")
|
||
}
|
||
s.reportSubmit(c, old, new)
|
||
}
|
||
|
||
func (s *Service) handleCreate(c context.Context, new *model.Task) {
|
||
s.dao.PushPublicTask(c, new)
|
||
s.sendTaskLog(c, new, LTD, "create", 399, "aegis-job")
|
||
s.reportTaskCreate(c, new)
|
||
}
|
||
|
||
func (s *Service) handleBinLogMsg(c context.Context, act string, old, new *model.Task) {
|
||
log.Info("handleTaskBinlog act(%s) old(%+v) new(%+v)", act, old, new)
|
||
s.dao.SetTask(c, new)
|
||
if act == "insert" {
|
||
s.handleCreate(c, new)
|
||
}
|
||
|
||
if act == "update" {
|
||
switch {
|
||
case old.State != new.State: //状态变更
|
||
switch new.State {
|
||
case INT: // 初始
|
||
switch old.State {
|
||
case DSP: //释放
|
||
s.handleRelease(c, old, new)
|
||
default: //其他情况
|
||
s.dao.PushPublicTask(c, new)
|
||
log.Error("handleTaskBinlog UNEXPECTED INT old(%+v) new(%+v)", old, new)
|
||
}
|
||
case DSP: // 领取
|
||
switch old.State {
|
||
case INT:
|
||
s.handleDisptach(c, old, new)
|
||
default:
|
||
log.Error("handleTaskBinlog UNEXPECTED DSP old(%+v) new(%+v)", old, new)
|
||
}
|
||
case DEY: // 延迟
|
||
switch old.State {
|
||
case DSP:
|
||
s.handleDelay(c, old, new)
|
||
default:
|
||
log.Error("handleTaskBinlog UNEXPECTED DEY old(%+v) new(%+v)", old, new)
|
||
}
|
||
case SUB, RSB, CLO: // 提交,关闭
|
||
s.handleSubmit(c, old, new)
|
||
}
|
||
case old.AdminID != new.AdminID: //指派变更
|
||
default:
|
||
log.Info("其他变更 old(%+v)->new(%+v)", old, new)
|
||
}
|
||
}
|
||
}
|
||
|
||
func (s *Service) setAssign(c context.Context, task *model.Task) bool {
|
||
log.Info("指派判断 setAssign(%+v)", task)
|
||
auids := s.hitAssignUids(c, task)
|
||
log.Info("指派判断 hitAssignUids(%v)", auids)
|
||
if len(auids) == 0 {
|
||
return false
|
||
}
|
||
|
||
log.Info("task(%d) 命中指派配置 (%v)", task.ID, auids)
|
||
var huids []int64
|
||
for auid, uids := range auids {
|
||
task.AdminID = auid
|
||
huids = s.hitActiveUids(c, task, uids)
|
||
length := len(huids)
|
||
if length != 0 {
|
||
break
|
||
}
|
||
}
|
||
|
||
log.Info("task(%d) 指派在线 (%v)", task.ID, huids)
|
||
length := len(huids)
|
||
if length == 0 {
|
||
return false
|
||
}
|
||
|
||
if length == 1 {
|
||
task.UID = huids[0]
|
||
} else {
|
||
// 随机数选一个
|
||
task.UID = huids[rand.Intn(length)]
|
||
}
|
||
log.Info("task(%d) admin(%d) 指派成功 (%d)", task.ID, task.AdminID, task.UID)
|
||
|
||
return true
|
||
}
|
||
|
||
func (s *Service) hitAssignUids(c context.Context, task *model.Task) (uids map[int64][]int64) {
|
||
key := fmt.Sprintf("%d-%d", task.BusinessID, task.FlowID)
|
||
uids = make(map[int64][]int64)
|
||
if assignC, ok := s.assignConfig[key]; ok {
|
||
for _, item := range assignC {
|
||
log.Info("指派判断 task(%+v) item(%+v)", task, item)
|
||
for _, mid := range item.Mids {
|
||
if mid == task.MID {
|
||
if aus, ok := uids[item.Admin]; ok {
|
||
uids[item.Admin] = append(aus, item.Uids...)
|
||
} else {
|
||
uids[item.Admin] = item.Uids
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (s *Service) hitActiveUids(c context.Context, task *model.Task, uids []int64) (hitid []int64) {
|
||
s.ccMux.RLock()
|
||
defer s.ccMux.RUnlock()
|
||
key := fmt.Sprintf("%d-%d", task.BusinessID, task.FlowID)
|
||
if uidCache, ok := s.consumerCache[key]; ok {
|
||
for _, uid := range uids {
|
||
if _, ok := uidCache[uid]; ok {
|
||
if on, _ := s.dao.IsConsumerOn(c, int(task.BusinessID), int(task.FlowID), uid); on {
|
||
hitid = append(hitid, uid)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|