304 lines
8.4 KiB
Go
304 lines
8.4 KiB
Go
package redis
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"time"
|
||
|
||
"go-common/app/admin/main/aegis/model/common"
|
||
modtask "go-common/app/admin/main/aegis/model/task"
|
||
"go-common/library/cache/redis"
|
||
"go-common/library/log"
|
||
|
||
"github.com/pkg/errors"
|
||
)
|
||
|
||
/*
|
||
四个缓存
|
||
1. personalPool 存储每个用户的任务池 类型为List []taskid
|
||
2. publicPool 存储还未被领取的任务 类型为Sorted Set weight-taskid
|
||
3. delayPool 存储每个用户的延迟任务 类型为List
|
||
4. hashTask 存储所有任务的所有其他字段信息
|
||
*/
|
||
|
||
const (
|
||
_hashexpire = 24 * 60 * 60
|
||
)
|
||
|
||
func personalKey(businessID, flowID int64, uid int64) string {
|
||
return fmt.Sprintf("personal_%d_%d_%d", businessID, flowID, uid)
|
||
}
|
||
|
||
func publicKey(businessID, flowID int64) string {
|
||
return fmt.Sprintf("{%d-%d}public_%d_%d", businessID, flowID, businessID, flowID)
|
||
}
|
||
|
||
func delayKey(businessID, flowID int64, uid int64) string {
|
||
return fmt.Sprintf("delay_%d_%d_%d", businessID, flowID, uid)
|
||
}
|
||
|
||
func haskKey(taskid int64) string {
|
||
return fmt.Sprintf("task_%d", taskid)
|
||
}
|
||
|
||
// formatID 在sorted set里面，id要扩展出来，否则排序不对
|
||
func formatID(taskid int64) string {
|
||
return fmt.Sprintf("%.11d", taskid)
|
||
}
|
||
|
||
// CountPersonalTask 统计个数
|
||
func (d *Dao) CountPersonalTask(c context.Context, opt *common.BaseOptions) (count int64, err error) {
|
||
conn := d.cluster.Get(c)
|
||
defer conn.Close()
|
||
key := personalKey(opt.BusinessID, opt.FlowID, opt.UID)
|
||
if count, err = redis.Int64(conn.Do("LLEN", key)); err != nil {
|
||
log.Error("conn.Do(LLEN,%s) error(%v)", key, err)
|
||
}
|
||
return
|
||
}
|
||
|
||
// RangePersonalTask 从本人的任务池取
|
||
func (d *Dao) RangePersonalTask(c context.Context, opt *modtask.ListOptions) (tasks map[int64]*modtask.Task, count int64, hitids, missids []int64, err error) {
|
||
tasks, count, hitids, missids, err = d.rangefuncCluster(c, "personal", opt)
|
||
return
|
||
}
|
||
|
||
// RangeDealyTask .
|
||
func (d *Dao) RangeDealyTask(c context.Context, opt *modtask.ListOptions) (tasks map[int64]*modtask.Task, count int64, hitids, missids []int64, err error) {
|
||
return d.rangefuncCluster(c, "delay", opt)
|
||
}
|
||
|
||
// RangePublicTask .
|
||
func (d *Dao) RangePublicTask(c context.Context, opt *modtask.ListOptions) (tasks map[int64]*modtask.Task, count int64, hitids, missids []int64, err error) {
|
||
return d.rangefuncCluster(c, "public", opt)
|
||
}
|
||
|
||
// PushPersonalTask 放入本人任务池
|
||
func (d *Dao) PushPersonalTask(c context.Context, opt *common.BaseOptions, ids ...interface{}) (err error) {
|
||
key := personalKey(opt.BusinessID, opt.FlowID, opt.UID)
|
||
return d.pushList(c, key, ids...)
|
||
}
|
||
|
||
// RemovePersonalTask 任务延迟或完成
|
||
func (d *Dao) RemovePersonalTask(c context.Context, opt *common.BaseOptions, ids ...interface{}) (err error) {
|
||
key := personalKey(opt.BusinessID, opt.FlowID, opt.UID)
|
||
return d.removeList(c, key, ids...)
|
||
}
|
||
|
||
// RemoveDelayTask 延迟任务完成
|
||
func (d *Dao) RemoveDelayTask(c context.Context, opt *common.BaseOptions, ids ...interface{}) (err error) {
|
||
key := delayKey(opt.BusinessID, opt.FlowID, opt.UID)
|
||
return d.removeList(c, key, ids...)
|
||
}
|
||
|
||
func (d *Dao) removeList(c context.Context, key string, ids ...interface{}) (err error) {
|
||
conn := d.cluster.Get(c)
|
||
defer conn.Close()
|
||
for _, id := range ids {
|
||
if err = conn.Send("LREM", key, 1, id); err != nil {
|
||
log.Error("LREM error(%v)", errors.WithStack(err))
|
||
continue
|
||
}
|
||
}
|
||
if err = conn.Flush(); err != nil {
|
||
log.Error("Flush error(%v)", errors.WithStack(err))
|
||
return
|
||
}
|
||
for i := 0; i < len(ids); i++ {
|
||
if _, err = conn.Receive(); err != nil {
|
||
log.Error("Receive error(%v)", errors.WithStack(err))
|
||
return
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// Release 清空个人任务 直接删除key
|
||
func (d *Dao) Release(c context.Context, opt *common.BaseOptions, delay bool) (err error) {
|
||
var conn = d.cluster.Get(c)
|
||
defer conn.Close()
|
||
key := personalKey(opt.BusinessID, opt.FlowID, opt.UID)
|
||
|
||
log.Info("Redis Release(%+v) delay(%v)", opt, delay)
|
||
if delay {
|
||
debug := func(msg string) {
|
||
tasks, count, hitids, missids, err1 := d.rangefuncCluster(c, "personal", &modtask.ListOptions{
|
||
BaseOptions: *opt,
|
||
Pager: common.Pager{
|
||
Pn: 1,
|
||
Ps: 10,
|
||
},
|
||
})
|
||
|
||
for id, task := range tasks {
|
||
log.Info(msg+" Release task(%d)(%+v)", id, task)
|
||
}
|
||
log.Info(msg+" Release count(%d)", count)
|
||
log.Info(msg+" Release hitids(%+v)", hitids)
|
||
log.Info(msg+" Release missids(%+v)", missids)
|
||
log.Info(msg+" Release err(%+v)", err1)
|
||
}
|
||
debug("Before")
|
||
|
||
if _, err = conn.Do("LTRIM", key, 0, 0); err != nil {
|
||
log.Error("LTRIM ReleasePersonalTask(%s), error(%v)", key, err)
|
||
}
|
||
|
||
debug("Middle")
|
||
|
||
time.AfterFunc(5*time.Minute, func() {
|
||
d.Release(context.Background(), opt, false)
|
||
})
|
||
|
||
debug("After")
|
||
} else {
|
||
log.Info("Redis DEL Release(%+v) delay(%v)", opt, delay)
|
||
if _, err = conn.Do("DEL", key); err != nil {
|
||
log.Error("DEL ReleasePersonalTask(%s), error(%v)", key, err)
|
||
}
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
// PushDelayTask 延迟任务队列
|
||
func (d *Dao) PushDelayTask(c context.Context, opt *common.BaseOptions, ids ...interface{}) (err error) {
|
||
key := delayKey(opt.BusinessID, opt.FlowID, opt.UID)
|
||
return d.pushList(c, key, ids...)
|
||
}
|
||
|
||
func (d *Dao) pushList(c context.Context, key string, values ...interface{}) (err error) {
|
||
var (
|
||
conn = d.cluster.Get(c)
|
||
)
|
||
defer conn.Close()
|
||
|
||
for _, id := range values {
|
||
if _, err = conn.Do("LREM", key, 0, id); err != nil {
|
||
log.Error("conn.Do(LREM, %v, %v, %v) error(%v)", key, 0, id, err)
|
||
return
|
||
}
|
||
}
|
||
|
||
args2 := []interface{}{key}
|
||
args2 = append(args2, values...)
|
||
if _, err = conn.Do("RPUSH", args2...); err != nil {
|
||
log.Error("conn.Do(RPUSH, %v) error(%v)", args2, err)
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
// RemovePublicTask 移除
|
||
func (d *Dao) RemovePublicTask(c context.Context, opt *common.BaseOptions, ids ...interface{}) (err error) {
|
||
conn := d.cluster.Get(c)
|
||
defer conn.Close()
|
||
key := publicKey(opt.BusinessID, opt.FlowID)
|
||
args := []interface{}{key}
|
||
nids := []interface{}{}
|
||
for _, id := range ids {
|
||
nids = append(nids, fmt.Sprintf("%.11d", id))
|
||
}
|
||
|
||
args = append(args, nids...)
|
||
if _, err = conn.Do("ZREM", args...); err != nil {
|
||
log.Error("(ZREM,%v) error(%v)", args, errors.WithStack(err))
|
||
}
|
||
return err
|
||
}
|
||
|
||
// PopPublicTask 从实时任务池取出来
|
||
func (d *Dao) PopPublicTask(c context.Context, businessID, flowID, count int64) (ids []int64, err error) {
|
||
conn := d.cluster.Get(c)
|
||
defer conn.Close()
|
||
key := publicKey(businessID, flowID)
|
||
var tempids []int64
|
||
if tempids, err = redis.Int64s(conn.Do("ZRANGE", key, 0, count)); err != nil {
|
||
log.Error("conn.Do(ZADD,%s) error(%v)", key, errors.WithStack(err))
|
||
}
|
||
|
||
ids = append(ids, tempids...)
|
||
return
|
||
}
|
||
|
||
// PushPublicTask 放入实时任务池
|
||
func (d *Dao) PushPublicTask(c context.Context, tasks ...*modtask.Task) (err error) {
|
||
conn := d.cluster.Get(c)
|
||
defer conn.Close()
|
||
|
||
for _, task := range tasks {
|
||
key := publicKey(task.BusinessID, task.FlowID)
|
||
id := formatID(task.ID)
|
||
fmt.Println("id:", id)
|
||
if _, err = conn.Do("ZADD", key, -task.Weight, id); err != nil {
|
||
log.Error("conn.Do(ZADD,%s) error(%v)", key, errors.WithStack(err))
|
||
}
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
// SetTask .
|
||
func (d *Dao) SetTask(c context.Context, tasks ...*modtask.Task) (err error) {
|
||
conn := d.cluster.Get(c)
|
||
defer conn.Close()
|
||
|
||
for _, task := range tasks {
|
||
var bs []byte
|
||
key := haskKey(task.ID)
|
||
if bs, err = json.Marshal(task); err != nil {
|
||
log.Error("json.Marshal(%+v) error(%v)", task, err)
|
||
continue
|
||
}
|
||
|
||
if err = conn.Send("SET", key, bs); err != nil {
|
||
log.Error("SET error(%v)", err)
|
||
continue
|
||
}
|
||
if err = conn.Send("EXPIRE", key, _hashexpire); err != nil {
|
||
log.Error("EXPIRE error(%v)", err)
|
||
continue
|
||
}
|
||
}
|
||
|
||
if err = conn.Flush(); err != nil {
|
||
log.Error("conn.Flush error(%v)", err)
|
||
return
|
||
}
|
||
|
||
for i := 0; i < 2*len(tasks); i++ {
|
||
if _, err = conn.Receive(); err != nil {
|
||
log.Error("conn.Receive error(%v)", err)
|
||
return
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// GetTask .
|
||
func (d *Dao) GetTask(c context.Context, ids []int64) (tasks []*modtask.Task, err error) {
|
||
conn := d.cluster.Get(c)
|
||
defer conn.Close()
|
||
|
||
for _, id := range ids {
|
||
key := haskKey(id)
|
||
conn.Send("GET", key)
|
||
}
|
||
conn.Flush()
|
||
var data []byte
|
||
for i := 0; i < len(ids); i++ {
|
||
if data, err = redis.Bytes(conn.Receive()); err != nil {
|
||
log.Errorv(c, log.KV("event", "redis_get"), log.KV("key", haskKey(ids[i])), log.KV("error", err))
|
||
return
|
||
}
|
||
task := new(modtask.Task)
|
||
if err = json.Unmarshal(data, task); err != nil {
|
||
log.Errorv(c, log.KV("event", "json.Unmarshal"), log.KV("task", string(data)), log.KV("error", err))
|
||
return
|
||
}
|
||
tasks = append(tasks, task)
|
||
}
|
||
return
|
||
}
|