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.
316 lines
8.0 KiB
316 lines
8.0 KiB
package archive |
|
|
|
import ( |
|
"context" |
|
"strconv" |
|
|
|
"go-common/app/service/main/up/model" |
|
"go-common/library/cache/redis" |
|
"go-common/library/log" |
|
"go-common/library/time" |
|
) |
|
|
|
const ( |
|
_prefixUpCnt = "uc_" |
|
_prefixUpPas = "up_" |
|
) |
|
|
|
func upCntKey(mid int64) string { |
|
return _prefixUpCnt + strconv.FormatInt(mid, 10) |
|
} |
|
|
|
func upPasKey(mid int64) string { |
|
return _prefixUpPas + strconv.FormatInt(mid, 10) |
|
} |
|
|
|
// AddUpperCountCache the count of up's archives |
|
func (d *Dao) AddUpperCountCache(c context.Context, mid int64, count int64) (err error) { |
|
var ( |
|
key = upCntKey(mid) |
|
conn = d.upRds.Get(c) |
|
expireTime = d.upExpire |
|
) |
|
defer conn.Close() |
|
if count == 0 { |
|
expireTime = 600 |
|
} |
|
if _, err = conn.Do("SETEX", key, expireTime, count); err != nil { |
|
log.Error("conn.Do(SETEX, %s, %d, %d)", key, expireTime, count) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// UpperCountCache get up count from cache. |
|
func (d *Dao) UpperCountCache(c context.Context, mid int64) (count int64, err error) { |
|
var ( |
|
key = upCntKey(mid) |
|
conn = d.upRds.Get(c) |
|
) |
|
defer conn.Close() |
|
if count, err = redis.Int64(conn.Do("GET", key)); err != nil { |
|
if err == redis.ErrNil { |
|
count = -1 |
|
err = nil |
|
} else { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Do(GET, %s) error(%v)", key, err) |
|
} |
|
} |
|
return |
|
} |
|
|
|
// UppersCountCache return uppers count cache |
|
func (d *Dao) UppersCountCache(c context.Context, mids []int64) (cached map[int64]int64, missed []int64, err error) { |
|
conn := d.upRds.Get(c) |
|
defer conn.Close() |
|
cached = make(map[int64]int64) |
|
for _, mid := range mids { |
|
key := upCntKey(mid) |
|
if err = conn.Send("GET", key); err != nil { |
|
missed = mids |
|
continue |
|
} |
|
} |
|
if err = conn.Flush(); err != nil { |
|
missed = mids |
|
return |
|
} |
|
for _, mid := range mids { |
|
var cnt int64 |
|
if cnt, err = redis.Int64(conn.Receive()); err != nil { |
|
if err == redis.ErrNil { |
|
missed = append(missed, mid) |
|
err = nil |
|
continue |
|
} |
|
} |
|
cached[mid] = int64(cnt) |
|
} |
|
return |
|
} |
|
|
|
// UpperPassedCache get upper passed archives from cache. |
|
func (d *Dao) UpperPassedCache(c context.Context, mid int64, start, end int) (aids []int64, err error) { |
|
var ( |
|
key = upPasKey(mid) |
|
conn = d.upRds.Get(c) |
|
) |
|
defer conn.Close() |
|
if aids, err = redis.Int64s(conn.Do("ZREVRANGE", key, start, end)); err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Do(ZRANGE, %s, 0, -1) error(%v)", key, err) |
|
} |
|
return |
|
} |
|
|
|
// UppersPassedCacheWithScore get uppers passed archive from cache with score |
|
func (d *Dao) UppersPassedCacheWithScore(c context.Context, mids []int64, start, end int) (aidm map[int64][]*model.AidPubTime, err error) { |
|
conn := d.upRds.Get(c) |
|
defer conn.Close() |
|
aidm = make(map[int64][]*model.AidPubTime, len(mids)) |
|
for _, mid := range mids { |
|
key := upPasKey(mid) |
|
if err = conn.Send("ZREVRANGE", key, start, end, "WITHSCORES"); err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Send(ZREVRANGE, %s) error(%v)", key, err) |
|
return |
|
} |
|
} |
|
if err = conn.Flush(); err != nil { |
|
log.Error("conn.Flush error(%v)", err) |
|
return |
|
} |
|
for _, mid := range mids { |
|
aidScores, err := redis.Int64s(conn.Receive()) |
|
if err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Do(GET, %d) error(%v)", mid, err) |
|
continue |
|
} |
|
for i := 0; i < len(aidScores); i += 2 { |
|
var ( |
|
score int64 |
|
ptime int64 |
|
copyright int8 |
|
) |
|
score = aidScores[i+1] |
|
if score > 1000000000 { |
|
ptime = score >> 2 |
|
copyright = int8(score & 3) |
|
aidm[mid] = append(aidm[mid], &model.AidPubTime{Aid: aidScores[i], PubDate: time.Time(ptime), Copyright: copyright}) |
|
} else { |
|
aidm[mid] = append(aidm[mid], &model.AidPubTime{Aid: aidScores[i], PubDate: time.Time(score)}) |
|
} |
|
} |
|
} |
|
return |
|
} |
|
|
|
// UppersPassedCache get uppers passed archives from cache. |
|
func (d *Dao) UppersPassedCache(c context.Context, mids []int64, start, end int) (aidm map[int64][]int64, err error) { |
|
conn := d.upRds.Get(c) |
|
defer conn.Close() |
|
aidm = make(map[int64][]int64, len(mids)) |
|
for _, mid := range mids { |
|
key := upPasKey(mid) |
|
if err = conn.Send("ZREVRANGE", key, start, end); err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Send(ZREVRANGE, %s) error(%v)", key, err) |
|
return |
|
} |
|
} |
|
if err = conn.Flush(); err != nil { |
|
log.Error("conn.Flush error(%v)", err) |
|
return |
|
} |
|
for _, mid := range mids { |
|
aids, err := redis.Int64s(conn.Receive()) |
|
if err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Do(GET, %d) error(%v)", mid, err) |
|
continue |
|
} |
|
aidm[mid] = aids |
|
} |
|
return |
|
} |
|
|
|
// ExpireUpperPassedCache expire up passed cache. |
|
func (d *Dao) ExpireUpperPassedCache(c context.Context, mid int64) (ok bool, err error) { |
|
var ( |
|
key = upPasKey(mid) |
|
conn = d.upRds.Get(c) |
|
) |
|
defer conn.Close() |
|
if ok, err = redis.Bool(conn.Do("EXPIRE", key, d.upExpire)); err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Do(EXPIRE, %s, %d) error(%v)", key, d.upExpire, err) |
|
} |
|
return |
|
} |
|
|
|
// ExpireUppersCountCache expire ups count cache |
|
func (d *Dao) ExpireUppersCountCache(c context.Context, mids []int64) (cachedUp, missed []int64, err error) { |
|
var conn = d.upRds.Get(c) |
|
defer conn.Close() |
|
defer func() { |
|
if err != nil { |
|
d.errProm.Incr("upper_redis") |
|
} |
|
}() |
|
for _, mid := range mids { |
|
var key = upCntKey(mid) |
|
if err = conn.Send("GET", key); err != nil { |
|
log.Error("conn.Send(GET, %s) error(%v)", key, err) |
|
return |
|
} |
|
} |
|
for _, mid := range mids { |
|
var key = upCntKey(mid) |
|
if err = conn.Send("EXPIRE", key, d.upExpire); err != nil { |
|
log.Error("conn.Send(GET, %s) error(%v)", key, err) |
|
return |
|
} |
|
} |
|
if err = conn.Flush(); err != nil { |
|
log.Error("conn.Flush error(%v)", err) |
|
return |
|
} |
|
cachedUp = make([]int64, 0) |
|
missed = make([]int64, 0) |
|
for _, mid := range mids { |
|
var cnt int |
|
if cnt, err = redis.Int(conn.Receive()); err != nil { |
|
if err == redis.ErrNil { |
|
err = nil |
|
missed = append(missed, mid) |
|
} else { |
|
log.Error("conn.Receive error(%v)", err) |
|
return |
|
} |
|
} else if cnt > 0 { |
|
cachedUp = append(cachedUp, mid) |
|
} |
|
} |
|
for _, mid := range mids { |
|
if _, err = redis.Bool(conn.Receive()); err != nil { |
|
log.Error("conn.Receive mid(%d) error(%v)", mid, err) |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// ExpireUppersPassedCache expire uppers passed cache. |
|
func (d *Dao) ExpireUppersPassedCache(c context.Context, mids []int64) (res map[int64]bool, err error) { |
|
conn := d.upRds.Get(c) |
|
defer conn.Close() |
|
res = make(map[int64]bool, len(mids)) |
|
for _, mid := range mids { |
|
key := upPasKey(mid) |
|
if err = conn.Send("EXPIRE", key, d.upExpire); err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Send(%s) error(%v)", key, err) |
|
return |
|
} |
|
} |
|
if err = conn.Flush(); err != nil { |
|
log.Error("conn.Flush error(%v)", err) |
|
return |
|
} |
|
var ok bool |
|
for _, mid := range mids { |
|
if ok, err = redis.Bool(conn.Receive()); err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Receive() error(%v)", err) |
|
return |
|
} |
|
res[mid] = ok |
|
} |
|
return |
|
} |
|
|
|
// AddUpperPassedCache add up paassed cache. |
|
func (d *Dao) AddUpperPassedCache(c context.Context, mid int64, aids []int64, ptimes []time.Time, copyrights []int8) (err error) { |
|
var ( |
|
key = upPasKey(mid) |
|
conn = d.upRds.Get(c) |
|
) |
|
defer conn.Close() |
|
for k, aid := range aids { |
|
score := int64(ptimes[k]<<2) | int64(copyrights[k]) |
|
if err = conn.Send("ZADD", key, score, aid); err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Send(ZADD, %s, %d, %d) error(%v)", key, aid, ptimes[k], err) |
|
return |
|
} |
|
} |
|
if err = conn.Flush(); err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Flush error(%v)", err) |
|
return |
|
} |
|
for i := 0; i < len(aids); i++ { |
|
if _, err = conn.Receive(); err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Receive error(%v)", err) |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// DelUpperPassedCache delete up passed cache. |
|
func (d *Dao) DelUpperPassedCache(c context.Context, mid, aid int64) (err error) { |
|
var ( |
|
key = upPasKey(mid) |
|
conn = d.upRds.Get(c) |
|
) |
|
defer conn.Close() |
|
if _, err = conn.Do("ZREM", key, aid); err != nil { |
|
d.errProm.Incr("upper_redis") |
|
log.Error("conn.Do(ZERM, %s, %d) error(%v)", key, aid, err) |
|
} |
|
return |
|
}
|
|
|