108 lines
2.4 KiB
Go
108 lines
2.4 KiB
Go
package dao
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strconv"
|
|
|
|
"go-common/app/job/main/dm/model"
|
|
"go-common/library/cache/memcache"
|
|
"go-common/library/log"
|
|
)
|
|
|
|
const (
|
|
_prefixSub = "s_"
|
|
_keyDuration = "d_" // video duration
|
|
)
|
|
|
|
func keySubject(tp int32, oid int64) string {
|
|
return _prefixSub + fmt.Sprintf("%d_%d", tp, oid)
|
|
}
|
|
|
|
// keyDuration return video duration key.
|
|
func keyDuration(oid int64) string {
|
|
return _keyDuration + strconv.FormatInt(oid, 10)
|
|
}
|
|
|
|
// SubjectCache get subject from memcache.
|
|
func (d *Dao) SubjectCache(c context.Context, tp int32, oid int64) (sub *model.Subject, err error) {
|
|
var (
|
|
conn = d.mc.Get(c)
|
|
key = keySubject(tp, oid)
|
|
rp *memcache.Item
|
|
)
|
|
defer conn.Close()
|
|
if rp, err = conn.Get(key); err != nil {
|
|
if err == memcache.ErrNotFound {
|
|
err = nil
|
|
} else {
|
|
log.Error("mc.Get(%s) error(%v)", key, err)
|
|
}
|
|
return
|
|
}
|
|
sub = &model.Subject{}
|
|
if err = conn.Scan(rp, &sub); err != nil {
|
|
log.Error("conn.Scan() error(%v)", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetSubjectCache add subject cache.
|
|
func (d *Dao) SetSubjectCache(c context.Context, sub *model.Subject) (err error) {
|
|
var (
|
|
conn = d.mc.Get(c)
|
|
key = keySubject(sub.Type, sub.Oid)
|
|
)
|
|
defer conn.Close()
|
|
item := &memcache.Item{
|
|
Key: key,
|
|
Object: sub,
|
|
Flags: memcache.FlagJSON,
|
|
Expiration: d.mcExpire,
|
|
}
|
|
if err = conn.Set(item); err != nil {
|
|
log.Error("conn.Set(%v) error(%v)", item, err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// DurationCache return duration of video.
|
|
func (d *Dao) DurationCache(c context.Context, oid int64) (duration int64, err error) {
|
|
var (
|
|
key = keyDuration(oid)
|
|
conn = d.mc.Get(c)
|
|
item *memcache.Item
|
|
)
|
|
defer conn.Close()
|
|
if item, err = conn.Get(key); err != nil {
|
|
if err == memcache.ErrNotFound {
|
|
duration = model.NotFound
|
|
err = nil
|
|
} else {
|
|
log.Error("conn.Get(%s) error(%v)", key, err)
|
|
}
|
|
return
|
|
}
|
|
if duration, err = strconv.ParseInt(string(item.Value), 10, 64); err != nil {
|
|
log.Error("strconv.ParseInt(%s) error(%v)", item.Value, err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SetDurationCache set video duration to redis.
|
|
func (d *Dao) SetDurationCache(c context.Context, oid, duration int64) (err error) {
|
|
key := keyDuration(oid)
|
|
conn := d.mc.Get(c)
|
|
item := memcache.Item{
|
|
Key: key,
|
|
Value: []byte(fmt.Sprint(duration)),
|
|
Expiration: d.mcExpire,
|
|
Flags: memcache.FlagRAW,
|
|
}
|
|
if err = conn.Set(&item); err != nil {
|
|
log.Error("mc.Set(%v) error(%v)", item, err)
|
|
}
|
|
conn.Close()
|
|
return
|
|
}
|