755 lines
20 KiB
Go
755 lines
20 KiB
Go
package dao
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
v1pb "go-common/app/service/live/dao-anchor/api/grpc/v1"
|
||
"go-common/library/cache/redis"
|
||
"go-common/library/ecode"
|
||
"go-common/library/log"
|
||
)
|
||
|
||
//实时消费缓存设计，异步落地
|
||
|
||
const VALUE = "value"
|
||
const DATE = "date" //是否最新消息，是为1(需要刷新到DB) 否为0(不需要刷新到DB)
|
||
const DATE_1 = "1"
|
||
|
||
type ListIntValueInfo struct {
|
||
Value int64 `json:"value"`
|
||
Time int64 `json:"time"`
|
||
}
|
||
|
||
//Set 设置实时数据
|
||
func (d *Dao) Set(ctx context.Context, redisKey string, value string, timeOut int) (err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
if _, err = conn.Do("HMSET", redisKey, VALUE, value, DATE, DATE_1); err != nil {
|
||
log.Error("redis_set_err:key=%s;value=%s;err=%v", redisKey, value, err)
|
||
return
|
||
}
|
||
conn.Do("EXPIRE", redisKey, timeOut)
|
||
return
|
||
}
|
||
|
||
//Incr 设置增加数据
|
||
func (d *Dao) Incr(ctx context.Context, redisKey string, value int64, timeOut int) (err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
if err = conn.Send("HINCRBY", redisKey, VALUE, value); err != nil {
|
||
log.Error("redis_incr_err:key=%s;value=%d;err=%v", redisKey, value, err)
|
||
return
|
||
}
|
||
if err = conn.Send("HSET", redisKey, DATE, DATE_1); err != nil {
|
||
log.Error("redis_hset_err:key=%s;date_value=%s;err=%v", redisKey, DATE_1, err)
|
||
return
|
||
}
|
||
conn.Send("EXPIRE", redisKey, timeOut)
|
||
|
||
if err = conn.Flush(); err != nil {
|
||
log.Error("redisIncreRoomInfo conn.Flush error(%v)", err)
|
||
return
|
||
}
|
||
|
||
_, err = conn.Receive()
|
||
_, err = conn.Receive()
|
||
_, err = conn.Receive()
|
||
return
|
||
}
|
||
func (d *Dao) HGet(ctx context.Context, redisKey string) (resp int64, err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
resp, err = redis.Int64(conn.Do("HGET", redisKey, VALUE))
|
||
if err != nil {
|
||
log.Error("redis_incr_err:key=%s;reply=%d;err=%v", redisKey, resp, err)
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
func (d *Dao) SetList(ctx context.Context, redisKey string, value string, timeOut int) (err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
if _, err = conn.Do("LPUSH", redisKey, value); err != nil {
|
||
log.Error("redis_setList_error:key=%s;value=%s;err=%v", redisKey, value, err)
|
||
return
|
||
}
|
||
conn.Do("EXPIRE", redisKey, timeOut)
|
||
return
|
||
}
|
||
|
||
func (d *Dao) GetList(ctx context.Context, redisKey string, start int, end int) (resp []*ListIntValueInfo, err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
res, err := redis.Values(conn.Do("LRANGE", redisKey, start, end))
|
||
if err != nil {
|
||
log.Error("redis_getList_error:key=%s;err=%v", redisKey, err)
|
||
return
|
||
}
|
||
for _, sList := range res {
|
||
list := &ListIntValueInfo{}
|
||
if err = json.Unmarshal(sList.([]byte), &list); err != nil {
|
||
log.Error("GetList_json_error")
|
||
continue
|
||
}
|
||
resp = append(resp, list)
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
// GetRoomRecordsCurrent return a list of records corresponding to `content`.
|
||
func (d *Dao) GetRoomRecordsCurrent(ctx context.Context, content string, roomIds []int64) (list []int64, err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
for _, roomId := range roomIds {
|
||
key := d.SRoomRecordCurrent(content, roomId)
|
||
if err = conn.Send("HGET", key.RedisKey, VALUE); err != nil {
|
||
log.Error("GetRoomRecordsCurrent conn.Send(HGET, %s, %s) error(%v)", key.RedisKey, VALUE, err)
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
if err = conn.Flush(); err != nil {
|
||
log.Error("GetRoomRecordsCurrent conn.Flush error(%v)", err)
|
||
return nil, err
|
||
}
|
||
|
||
for i := 0; i < len(roomIds); i++ {
|
||
var data int64
|
||
if data, err = redis.Int64(conn.Receive()); err != nil {
|
||
if err != redis.ErrNil {
|
||
log.Error("GetRoomRecordsCurrent conn.Receive() %d error(%v)", i, err)
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
list = append(list, data)
|
||
}
|
||
|
||
return
|
||
}
|
||
func (d *Dao) DelRoomRecordsCurrent(ctx context.Context, content string, roomIds []int64) (err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
args := make([]interface{}, len(roomIds))
|
||
for i, roomId := range roomIds {
|
||
args[i] = d.SRoomRecordCurrent(content, roomId)
|
||
}
|
||
if _, err = conn.Do("DEL", args...); err != nil {
|
||
log.Error("DelRoomRecordsCurrent_del_error:%v;roomIds=%v", err, roomIds)
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
func (d *Dao) SetRoomRecordsList(ctx context.Context, roomIds []int64, keys map[int64]interface{}, values map[int64]string) (err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
for _, roomId := range roomIds {
|
||
keyInfo := keys[roomId].(*redisKeyResp)
|
||
value := values[roomId]
|
||
if err = conn.Send("LPUSH", keyInfo.RedisKey, value); err != nil {
|
||
log.Error("SetRoomRecordsList conn.Send(LPUSH, %s, %s) error(%v)", keyInfo.RedisKey, value, err)
|
||
return err
|
||
}
|
||
|
||
if err = conn.Send("EXPIRE", keyInfo.RedisKey, keyInfo.TimeOut); err != nil {
|
||
log.Error("SetRoomRecordsList conn.Send(EXPIRE, %s, %d) error(%v)", keyInfo.RedisKey, keyInfo.TimeOut, err)
|
||
return err
|
||
}
|
||
}
|
||
|
||
if err = conn.Flush(); err != nil {
|
||
log.Error("SetRoomRecordsList conn.Flush() error(%v)", err)
|
||
return err
|
||
}
|
||
|
||
for range roomIds {
|
||
conn.Receive()
|
||
conn.Receive()
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
// GetRoomLiveRecordsRange can partially succeed, and in this case, err is still nil.
|
||
func (d *Dao) GetRoomLiveRecordsRange(ctx context.Context, content string, roomIds []int64, liveTime int64, start, end int) (resp map[int64][]*ListIntValueInfo, err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
okRoomIds := make([]int64, 0, len(roomIds))
|
||
for _, roomId := range roomIds {
|
||
keyInfo := d.LRoomLiveRecordList(content, roomId, liveTime)
|
||
if err = conn.Send("LRANGE", keyInfo.RedisKey, start, end); err != nil {
|
||
log.Error("GetRoomLiveRecordsRange conn.Send(LRANGE, %s, %d, %d) error(%v)", keyInfo.RedisKey, start, end, err)
|
||
continue
|
||
}
|
||
|
||
okRoomIds = append(okRoomIds, roomId)
|
||
}
|
||
|
||
if err = conn.Flush(); err != nil {
|
||
log.Error("GetRoomLiveRecordsRange conn.Flush() error(%v)", err)
|
||
return nil, err
|
||
}
|
||
|
||
resp = make(map[int64][]*ListIntValueInfo)
|
||
|
||
for i := 0; i < len(okRoomIds); i++ {
|
||
values, err := redis.Values(conn.Receive())
|
||
if err != nil {
|
||
log.Error("GetRoomLiveRecordsRange redis.Values(conn.Receive()) error(%v)", err)
|
||
continue
|
||
}
|
||
|
||
roomId := okRoomIds[i]
|
||
|
||
for _, info := range values {
|
||
valueInfo := &ListIntValueInfo{}
|
||
if err = json.Unmarshal(info.([]byte), &valueInfo); err != nil {
|
||
log.Error("GetRoomLiveRecordsRange json unmarshall error(%v)", err)
|
||
continue
|
||
}
|
||
resp[roomId] = append(resp[roomId], valueInfo)
|
||
}
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
const (
|
||
_roomInfoKey = "room_info_v3:%d"
|
||
_anchorInfoKey = "anchor_info:%d"
|
||
_onlineListKey = "online_list_v3:%d"
|
||
_tagListKey = "tag_list_v3:%d"
|
||
|
||
_onlineListAllArea = 0
|
||
)
|
||
|
||
var (
|
||
_allRoomInfoFields = []string{"uid", "title", "cover", "tags", "background", "description", "live_start_time", "live_status", "live_screen_type", "live_type", "lock_status", "lock_time", "hidden_time", "hidden_status", "area_id", "parent_area_id", "anchor_profile_type", "anchor_round_switch", "anchor_record_switch", "anchor_exp", "popularity_count", "keyframe"}
|
||
)
|
||
|
||
func (d *Dao) filterOutTagList(fields []string) (resp []string, needTagList bool) {
|
||
resp = make([]string, 0, len(fields))
|
||
for _, f := range fields {
|
||
if f == "tag_list" {
|
||
needTagList = true
|
||
} else {
|
||
resp = append(resp, f)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (d *Dao) redisGetRoomInfo(ctx context.Context, roomID int64, fields []string) (data *v1pb.RoomData, err error) {
|
||
if len(fields) <= 0 {
|
||
return
|
||
}
|
||
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
roomKey := fmt.Sprintf(_roomInfoKey, roomID)
|
||
|
||
ok, err := redis.Bool(conn.Do("EXPIRE", roomKey, d.c.Common.ExpireTime))
|
||
if err != nil && err != redis.ErrNil {
|
||
log.Error("redisGetRoomInfo conn.Do(EXPIRE, %s) error(%v)", roomKey, err)
|
||
return
|
||
}
|
||
|
||
if !ok {
|
||
err = ecode.RoomNotFound
|
||
return
|
||
}
|
||
|
||
for _, f := range fields {
|
||
if f == "room_id" {
|
||
continue
|
||
}
|
||
if err = conn.Send("HGET", roomKey, f); err != nil {
|
||
log.Error("redisGetRoomInfo conn.Send(HGET, %s, %s) error(%v)", roomKey, f, err)
|
||
return
|
||
}
|
||
}
|
||
|
||
if err = conn.Flush(); err != nil {
|
||
log.Error("redisGetRoomInfo conn.Flush error(%v)", err)
|
||
return
|
||
}
|
||
|
||
data = &v1pb.RoomData{
|
||
RoomId: roomID,
|
||
AnchorLevel: new(v1pb.AnchorLevel),
|
||
}
|
||
for _, f := range fields {
|
||
if f == "room_id" {
|
||
continue
|
||
}
|
||
reply, err := conn.Receive()
|
||
if e, ok := err.(*redis.Error); ok && strings.Index(e.Error(), "WRONGTYPE") != -1 {
|
||
return data, err
|
||
}
|
||
switch f {
|
||
case "uid":
|
||
data.Uid, err = redis.Int64(reply, err)
|
||
case "title":
|
||
data.Title, err = redis.String(reply, err)
|
||
case "cover":
|
||
data.Cover, err = redis.String(reply, err)
|
||
case "tags":
|
||
data.Tags, err = redis.String(reply, err)
|
||
case "background":
|
||
data.Background, err = redis.String(reply, err)
|
||
case "description":
|
||
data.Description, err = redis.String(reply, err)
|
||
case "live_start_time":
|
||
data.LiveStartTime, err = redis.Int64(reply, err)
|
||
case "live_status":
|
||
data.LiveStatus, err = redis.Int64(reply, err)
|
||
case "live_screen_type":
|
||
data.LiveScreenType, err = redis.Int64(reply, err)
|
||
case "live_type":
|
||
data.LiveType, err = redis.Int64(reply, err)
|
||
case "lock_status":
|
||
data.LockStatus, err = redis.Int64(reply, err)
|
||
case "lock_time":
|
||
data.LockTime, err = redis.Int64(reply, err)
|
||
case "hidden_time":
|
||
data.HiddenTime, err = redis.Int64(reply, err)
|
||
case "hidden_status":
|
||
data.HiddenStatus, err = redis.Int64(reply, err)
|
||
case "area_id":
|
||
data.AreaId, err = redis.Int64(reply, err)
|
||
case "parent_area_id":
|
||
data.ParentAreaId, err = redis.Int64(reply, err)
|
||
case "anchor_san":
|
||
data.AnchorSan, err = redis.Int64(reply, err)
|
||
case "anchor_profile_type":
|
||
data.AnchorProfileType, err = redis.Int64(reply, err)
|
||
case "anchor_round_switch":
|
||
data.AnchorRoundSwitch, err = redis.Int64(reply, err)
|
||
case "anchor_record_switch":
|
||
data.AnchorRecordSwitch, err = redis.Int64(reply, err)
|
||
case "anchor_exp":
|
||
data.AnchorLevel.Score, err = redis.Int64(reply, err)
|
||
case "popularity_count":
|
||
data.PopularityCount, err = redis.Int64(reply, err)
|
||
case "keyframe":
|
||
data.Keyframe, err = redis.String(reply, err)
|
||
default:
|
||
log.Error("redisGetRoomInfo unsupported field(%v), roomID(%d)", f, roomID)
|
||
err = ecode.InvalidParam
|
||
return nil, err
|
||
}
|
||
if err != nil {
|
||
log.Warn("redisGetRoomInfo conn.Receive() field(%v), error(%v)", f, err)
|
||
return nil, err
|
||
}
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *Dao) redisSetRoomInfo(ctx context.Context, roomID int64, fields []string, data *v1pb.RoomData, fastfail bool) (err error) {
|
||
if len(fields) <= 0 {
|
||
return
|
||
}
|
||
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
roomKey := fmt.Sprintf(_roomInfoKey, roomID)
|
||
|
||
ok, err := redis.Bool(conn.Do("EXPIRE", roomKey, d.c.Common.ExpireTime))
|
||
if err != nil && err != redis.ErrNil {
|
||
log.Error("redisSetRoomInfo conn.Do(EXPIRE, %s) error(%v)", roomKey, err)
|
||
return
|
||
}
|
||
|
||
if !ok && fastfail {
|
||
return
|
||
}
|
||
|
||
args := make([]interface{}, len(fields)*2+1)
|
||
args[0] = roomKey
|
||
|
||
for i, f := range fields {
|
||
var v interface{}
|
||
switch f {
|
||
case "roomid":
|
||
v = data.RoomId
|
||
case "uid":
|
||
v = data.Uid
|
||
case "title":
|
||
v = data.Title
|
||
case "cover":
|
||
v = data.Cover
|
||
case "tags":
|
||
v = data.Tags
|
||
case "background":
|
||
v = data.Background
|
||
case "description":
|
||
v = data.Description
|
||
case "live_start_time":
|
||
v = data.LiveStartTime
|
||
case "live_status":
|
||
v = data.LiveStatus
|
||
case "live_screen_type":
|
||
v = data.LiveScreenType
|
||
case "live_type":
|
||
v = data.LiveType
|
||
case "lock_status":
|
||
v = data.LockStatus
|
||
case "lock_time":
|
||
v = data.LockTime
|
||
case "hidden_time":
|
||
v = data.HiddenTime
|
||
case "hidden_status":
|
||
v = data.HiddenStatus
|
||
case "area_id":
|
||
v = data.AreaId
|
||
case "parent_area_id":
|
||
v = data.ParentAreaId
|
||
case "anchor_san":
|
||
v = data.AnchorSan
|
||
case "anchor_profile_type":
|
||
v = data.AnchorProfileType
|
||
case "anchor_round_switch":
|
||
v = data.AnchorRoundSwitch
|
||
case "anchor_record_switch":
|
||
v = data.AnchorRecordSwitch
|
||
case "anchor_exp":
|
||
v = data.AnchorRecordSwitch
|
||
case "popularity_count":
|
||
v = data.PopularityCount
|
||
case "keyframe":
|
||
v = data.Keyframe
|
||
default:
|
||
log.Error("redisSetRoomInfo unsupported field(%v), roomID(%d)", f, roomID)
|
||
return ecode.InvalidParam
|
||
}
|
||
|
||
args[i*2+1] = f
|
||
args[i*2+2] = v
|
||
}
|
||
|
||
if _, err = conn.Do("HMSET", args...); err != nil {
|
||
log.Error("redisSetRoomInfo conn.Do(HMSET, %v) error(%v)", args, err)
|
||
return
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *Dao) redisIncreRoomInfo(ctx context.Context, roomID int64, fields []string, data *v1pb.RoomData) (err error) {
|
||
if len(fields) <= 0 {
|
||
return
|
||
}
|
||
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
roomKey := fmt.Sprintf(_roomInfoKey, roomID)
|
||
|
||
ok, err := redis.Bool(conn.Do("EXPIRE", roomKey, d.c.Common.ExpireTime))
|
||
if err != nil && err != redis.ErrNil {
|
||
log.Error("redisIncreRoomInfo conn.Do(EXPIRE, %s) error(%v)", roomKey, err)
|
||
return
|
||
}
|
||
|
||
// fast fail if key not exists
|
||
if !ok {
|
||
return
|
||
}
|
||
|
||
for _, f := range fields {
|
||
var v int64
|
||
switch f {
|
||
case "anchor_san":
|
||
v = data.AnchorSan
|
||
case "anchor_exp":
|
||
v = data.AnchorRecordSwitch
|
||
case "popularity_count":
|
||
v = data.PopularityCount
|
||
default:
|
||
log.Error("redisIncreRoomInfo unsupported field(%v), roomID(%d)", f, roomID)
|
||
return ecode.InvalidParam
|
||
}
|
||
if err = conn.Send("HINCRBY", roomKey, f, v); err != nil {
|
||
log.Error("redisIncreRoomInfo conn.Send(HINCRBY, %s, %s, %d) error(%v)", roomKey, f, v, err)
|
||
return
|
||
}
|
||
}
|
||
|
||
if err = conn.Flush(); err != nil {
|
||
log.Error("redisIncreRoomInfo conn.Flush error(%v)", err)
|
||
return
|
||
}
|
||
|
||
for _, f := range fields {
|
||
_, err = conn.Receive()
|
||
if err != nil && err != redis.ErrNil {
|
||
log.Error("redisIncreRoomInfo conn.Receive() field(%v), error(%v)", f, err)
|
||
return
|
||
}
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *Dao) redisGetOnlineList(ctx context.Context, areaID int64) (list []int64, err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
key := fmt.Sprintf(_onlineListKey, areaID)
|
||
|
||
ok, err := redis.Bool(conn.Do("EXPIRE", key, d.c.Common.ExpireTime))
|
||
if err != nil && err != redis.ErrNil {
|
||
log.Error("redisGetOnlineList conn.Do(EXPIRE, %s) error(%v)", key, err)
|
||
return
|
||
}
|
||
|
||
if !ok {
|
||
// 不存在或者在播列表为空都会重新去DB获取
|
||
return
|
||
}
|
||
|
||
list = make([]int64, 0)
|
||
|
||
roomids, err := redis.Strings(conn.Do("SMEMBERS", key))
|
||
if err != nil && err != redis.ErrNil {
|
||
if e, ok := err.(*redis.Error); ok && strings.Index(e.Error(), "WRONGTYPE") == -1 {
|
||
log.Error("redisGetOnlineList conn.Do(SMEMBERS, %s) error(%v)", key, err)
|
||
return
|
||
}
|
||
return list, nil
|
||
}
|
||
|
||
for _, id := range roomids {
|
||
roomid, err := strconv.ParseInt(id, 10, 64)
|
||
if err != nil {
|
||
log.Warn("redisGetOnlineList ParseInt(%d) error(%v)", roomid, err)
|
||
return nil, err
|
||
}
|
||
list = append(list, roomid)
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *Dao) redisSetOnlineList(ctx context.Context, areaID int64, list []int64) (err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
key := fmt.Sprintf(_onlineListKey, areaID)
|
||
|
||
if len(list) <= 0 {
|
||
// 设置哨兵
|
||
if _, err = conn.Do("SETEX", key, d.c.Common.ExpireTime, "emptylist"); err != nil {
|
||
log.Error("redisSetOnlineList conn.Do(SETEX, %s, %v) error(%v)", key, list, err)
|
||
}
|
||
return
|
||
}
|
||
|
||
if _, err = conn.Do("DEL", key); err != nil && err != redis.ErrNil {
|
||
log.Error("redisSetOnlineList conn.Do(DEL, %s) error(%v)", key, err)
|
||
return
|
||
}
|
||
|
||
args := make([]interface{}, len(list)+1)
|
||
args[0] = key
|
||
|
||
for i, id := range list {
|
||
args[i+1] = id
|
||
}
|
||
|
||
if _, err = conn.Do("SADD", args...); err != nil {
|
||
log.Error("redisSetOnlineList conn.Do(SADD, %s, %v) error(%v)", key, list, err)
|
||
return
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *Dao) redisAddOnlineList(ctx context.Context, areaID int64, roomID int64) (err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
key := fmt.Sprintf(_onlineListKey, areaID)
|
||
|
||
typ, err := redis.String(conn.Do("TYPE", key))
|
||
if err != nil && err != redis.ErrNil {
|
||
log.Error("redisAddOnlineList conn.Do(TYPE, %s) error(%v)", key, err)
|
||
return
|
||
}
|
||
|
||
if strings.ToLower(typ) == "none" {
|
||
// 不存在就不处理
|
||
return
|
||
} else if strings.ToLower(typ) != "set" {
|
||
if _, err = conn.Do("DEL", key); err != nil && err != redis.ErrNil {
|
||
log.Error("redisAddOnlineList conn.Do(DEL, %s) error(%v)", key, err)
|
||
return
|
||
}
|
||
}
|
||
|
||
if _, err = conn.Do("SADD", key, roomID); err != nil {
|
||
log.Error("redisAddOnlineList conn.Do(SADD, %s, %d) error(%v)", key, roomID, err)
|
||
return
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *Dao) redisDelOnlineList(ctx context.Context, areaID int64, roomID int64) (err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
key := fmt.Sprintf(_onlineListKey, areaID)
|
||
|
||
typ, err := redis.String(conn.Do("TYPE", key))
|
||
if err != nil && err != redis.ErrNil {
|
||
log.Error("redisDelOnlineList conn.Do(TYPE, %s) error(%v)", key, err)
|
||
return
|
||
}
|
||
|
||
if strings.ToLower(typ) != "set" {
|
||
// 不存在就不处理
|
||
return
|
||
}
|
||
|
||
if _, err = conn.Do("SREM", key, roomID); err != nil {
|
||
log.Error("redisDelOnlineList conn.Do(SADD, %s, %d) error(%v)", key, roomID, err)
|
||
return
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *Dao) redisGetTagList(ctx context.Context, roomID int64) (list []*v1pb.TagData, err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
key := fmt.Sprintf(_tagListKey, roomID)
|
||
|
||
ok, err := redis.Bool(conn.Do("EXPIRE", key, d.c.Common.ExpireTime))
|
||
if err != nil && err != redis.ErrNil {
|
||
log.Error("redisGetTagList conn.Do(EXPIRE, %s) error(%v)", key, err)
|
||
return nil, err
|
||
}
|
||
|
||
if !ok {
|
||
err = ecode.RoomNotFound
|
||
return
|
||
}
|
||
|
||
list = make([]*v1pb.TagData, 0)
|
||
|
||
tags, err := redis.Strings(conn.Do("SMEMBERS", key))
|
||
if err != nil && err != redis.ErrNil {
|
||
if e, ok := err.(*redis.Error); ok && strings.Index(e.Error(), "WRONGTYPE") == -1 {
|
||
log.Error("redisGetTagList conn.Do(SMEMBERS, %s) error(%v)", key, err)
|
||
return
|
||
}
|
||
return list, nil
|
||
}
|
||
|
||
for _, tag := range tags {
|
||
seg := strings.Split(tag, ":")
|
||
if len(seg) < 5 {
|
||
log.Error("redisGetTagList Split(%s) error(%v)", tag, err)
|
||
return nil, err
|
||
}
|
||
data := &v1pb.TagData{
|
||
TagExt: strings.Join(seg[4:], ":"),
|
||
}
|
||
data.TagExpireAt, _ = strconv.ParseInt(seg[3], 10, 64)
|
||
if data.TagExpireAt > time.Now().Unix() {
|
||
data.TagId, _ = strconv.ParseInt(seg[0], 10, 64)
|
||
data.TagSubId, _ = strconv.ParseInt(seg[1], 10, 64)
|
||
data.TagValue, _ = strconv.ParseInt(seg[2], 10, 64)
|
||
list = append(list, data)
|
||
}
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *Dao) redisAddTag(ctx context.Context, roomID int64, tag *v1pb.TagData) (err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
key := fmt.Sprintf(_tagListKey, roomID)
|
||
|
||
typ, err := redis.String(conn.Do("TYPE", key))
|
||
if err != nil && err != redis.ErrNil {
|
||
log.Error("redisAddTag conn.Do(TYPE, %s) error(%v)", key, err)
|
||
return
|
||
}
|
||
|
||
if strings.ToLower(typ) == "none" {
|
||
// 不存在就不处理
|
||
return
|
||
} else if strings.ToLower(typ) != "set" {
|
||
if _, err = conn.Do("DEL", key); err != nil && err != redis.ErrNil {
|
||
log.Error("redisAddTag conn.Do(DEL, %s) error(%v)", key, err)
|
||
return
|
||
}
|
||
}
|
||
|
||
tagVal := fmt.Sprintf("%d:%d:%d:%d:%s", tag.TagId, tag.TagSubId, tag.TagValue, tag.TagExpireAt, tag.TagExt)
|
||
if _, err = conn.Do("SADD", key, tagVal); err != nil {
|
||
log.Error("redisAddTag conn.Do(SADD, %s, %s) error(%v)", key, tagVal, err)
|
||
return
|
||
}
|
||
|
||
return
|
||
}
|
||
|
||
func (d *Dao) redisSetTagList(ctx context.Context, roomID int64, list []*v1pb.TagData) (err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
|
||
key := fmt.Sprintf(_tagListKey, roomID)
|
||
|
||
if len(list) <= 0 {
|
||
// 设置哨兵
|
||
if _, err = conn.Do("SETEX", key, d.c.Common.ExpireTime, "emptylist"); err != nil {
|
||
log.Error("redisSetTagList conn.Do(SETEX, %s, %v) error(%v)", key, list, err)
|
||
}
|
||
return
|
||
}
|
||
|
||
if _, err = conn.Do("DEL", key); err != nil && err != redis.ErrNil {
|
||
log.Error("redisSetTagList conn.Do(DEL, %s) error(%v)", key, err)
|
||
return
|
||
}
|
||
|
||
args := make([]interface{}, len(list)+1)
|
||
args[0] = key
|
||
|
||
for i, tag := range list {
|
||
args[i+1] = fmt.Sprintf("%d:%d:%d:%d:%s", tag.TagId, tag.TagSubId, tag.TagValue, tag.TagExpireAt, tag.TagExt)
|
||
}
|
||
|
||
if _, err = conn.Do("SADD", args...); err != nil {
|
||
log.Error("redisSetTagList conn.Do(SADD, %s, %v) error(%v)", key, list, err)
|
||
return
|
||
}
|
||
|
||
return
|
||
}
|