You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
130 lines
3.3 KiB
130 lines
3.3 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"fmt" |
|
|
|
"go-common/app/service/main/archive/api" |
|
"go-common/library/cache/redis" |
|
"go-common/library/log" |
|
"go-common/library/time" |
|
) |
|
|
|
const ( |
|
// new list |
|
_keyNl = "n_%d_%d" |
|
) |
|
|
|
func keyNl(rid int32, tp int8) string { |
|
return fmt.Sprintf(_keyNl, rid, tp) |
|
} |
|
|
|
func keyNlBak(rid int32, tp int8) string { |
|
return _keyBakPrefix + keyNl(rid, tp) |
|
} |
|
|
|
// NewListCache get region rank list from cache. |
|
func (d *Dao) NewListCache(c context.Context, rid int32, tp int8, start, end int) (arcs []*api.Arc, count int, err error) { |
|
key := keyNl(rid, tp) |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
arcs, count, err = d.nlCache(c, conn, key, start, end) |
|
return |
|
} |
|
|
|
// NewListBakCache get region rank list from bak cache. |
|
func (d *Dao) NewListBakCache(c context.Context, rid int32, tp int8, start, end int) (arcs []*api.Arc, count int, err error) { |
|
d.cacheProm.Incr("newlist_remote_cache") |
|
key := keyNlBak(rid, tp) |
|
conn := d.redisBak.Get(c) |
|
defer conn.Close() |
|
arcs, count, err = d.nlCache(c, conn, key, start, end) |
|
if len(arcs) == 0 { |
|
log.Error("NewlistBakCache(%s,%d,%d) is nil", key, start, end) |
|
} |
|
return |
|
} |
|
|
|
func (d *Dao) nlCache(c context.Context, conn redis.Conn, key string, start, end int) (arcs []*api.Arc, count int, err error) { |
|
values, err := redis.Values(conn.Do("ZREVRANGE", key, start, end, "WITHSCORES")) |
|
if err != nil { |
|
log.Error("conn.Do(ZREVRANGE, %s) error(%v)", key, err) |
|
return |
|
} |
|
if len(values) == 0 { |
|
return |
|
} |
|
var num int64 |
|
for len(values) > 0 { |
|
bs := []byte{} |
|
if values, err = redis.Scan(values, &bs, &num); err != nil { |
|
log.Error("redis.Scan(%v) error(%v)", values, err) |
|
return |
|
} |
|
arc := &api.Arc{} |
|
if err = json.Unmarshal(bs, arc); err != nil { |
|
log.Error("json.Unmarshal(%v) error(%v)", bs, err) |
|
return |
|
} |
|
arcs = append(arcs, arc) |
|
} |
|
count = from(num) |
|
return |
|
} |
|
|
|
// SetNewListCache set region cache. |
|
func (d *Dao) SetNewListCache(c context.Context, rid int32, tp int8, arcs []*api.Arc, count int) (err error) { |
|
key := keyNl(rid, tp) |
|
conn := d.redis.Get(c) |
|
defer conn.Close() |
|
if err = d.setNlCache(c, conn, key, d.redisNlExpire, arcs, count); err != nil { |
|
return |
|
} |
|
key = keyNlBak(rid, tp) |
|
connBak := d.redisBak.Get(c) |
|
err = d.setNlCache(c, connBak, key, d.redisNlBakExpire, arcs, count) |
|
connBak.Close() |
|
return |
|
} |
|
|
|
func (d *Dao) setNlCache(c context.Context, conn redis.Conn, key string, expire int32, arcs []*api.Arc, num int) (err error) { |
|
count := 0 |
|
if err = conn.Send("DEL", key); err != nil { |
|
log.Error("conn.Send(DEL, %s) error(%v)", key, err) |
|
return |
|
} |
|
count++ |
|
for _, arc := range arcs { |
|
bs, _ := json.Marshal(arc) |
|
if err = conn.Send("ZADD", key, combine(arc.PubDate, num), bs); err != nil { |
|
log.Error("conn.Send(ZADD, %s, %s) error(%v)", key, string(bs), err) |
|
return |
|
} |
|
count++ |
|
} |
|
if err = conn.Send("EXPIRE", key, expire); err != nil { |
|
log.Error("conn.Send(Expire, %s, %d) error(%v)", key, expire, err) |
|
return |
|
} |
|
count++ |
|
if err = conn.Flush(); err != nil { |
|
log.Error("conn.Flush error(%v)", err) |
|
return |
|
} |
|
for i := 0; i < count; i++ { |
|
if _, err = conn.Receive(); err != nil { |
|
log.Error("conn.Receive() error(%v)", err) |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
func from(i int64) int { |
|
return int(i & 0xffffff) |
|
} |
|
|
|
func combine(pubdate time.Time, count int) int64 { |
|
return pubdate.Time().Unix()<<24 | int64(count) |
|
}
|
|
|