126 lines
2.5 KiB
Go
126 lines
2.5 KiB
Go
package archive
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"runtime"
|
|
|
|
"go-common/app/interface/main/app-player/conf"
|
|
"go-common/app/interface/main/app-player/model/archive"
|
|
arcrpc "go-common/app/service/main/archive/api"
|
|
"go-common/library/cache/memcache"
|
|
"go-common/library/log"
|
|
)
|
|
|
|
// Dao is archive dao.
|
|
type Dao struct {
|
|
// memcache
|
|
arcMc *memcache.Pool
|
|
// chan
|
|
mCh chan func()
|
|
// rpc
|
|
arcRPC arcrpc.ArchiveClient
|
|
}
|
|
|
|
// New new a archive dao.
|
|
func New(c *conf.Config) (d *Dao) {
|
|
d = &Dao{
|
|
// memcache
|
|
arcMc: memcache.NewPool(c.Memcache),
|
|
// mc proc
|
|
mCh: make(chan func(), 1024),
|
|
}
|
|
var err error
|
|
d.arcRPC, err = arcrpc.NewClient(c.ArchiveClient)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("archive NewClient error(%v)", err))
|
|
}
|
|
for i := 0; i < runtime.NumCPU(); i++ {
|
|
go d.cacheproc()
|
|
}
|
|
return
|
|
}
|
|
|
|
// Ping ping check memcache connection
|
|
func (d *Dao) Ping(c context.Context) (err error) {
|
|
return d.pingMC(c)
|
|
}
|
|
|
|
// addCache add archive to mc or redis
|
|
func (d *Dao) addCache(f func()) {
|
|
select {
|
|
case d.mCh <- f:
|
|
default:
|
|
log.Warn("cacheproc chan full")
|
|
}
|
|
}
|
|
|
|
// cacheproc write memcache and stat redis use goroutine
|
|
func (d *Dao) cacheproc() {
|
|
for {
|
|
f, ok := <-d.mCh
|
|
if !ok {
|
|
return
|
|
}
|
|
f()
|
|
}
|
|
}
|
|
|
|
// ArchiveCache is
|
|
func (d *Dao) ArchiveCache(c context.Context, aid int64) (arc *archive.Info, err error) {
|
|
if arc, err = d.archiveCache(c, aid); err != nil {
|
|
log.Error("%+v", err)
|
|
err = nil
|
|
}
|
|
if arc != nil {
|
|
return
|
|
}
|
|
var (
|
|
view *arcrpc.ViewReply
|
|
cids []int64
|
|
)
|
|
if view, err = d.arcRPC.View(c, &arcrpc.ViewRequest{Aid: aid}); err != nil {
|
|
log.Error("d.arcRPC.View3(%d) error(%+v)", aid, err)
|
|
return
|
|
}
|
|
for _, p := range view.Pages {
|
|
cids = append(cids, p.Cid)
|
|
}
|
|
arc = &archive.Info{
|
|
Aid: view.Arc.Aid,
|
|
State: view.Arc.State,
|
|
Mid: view.Arc.Author.Mid,
|
|
Cids: cids,
|
|
Attribute: view.Arc.Attribute,
|
|
}
|
|
d.addCache(func() {
|
|
d.addArchiveCache(context.Background(), aid, arc)
|
|
})
|
|
return
|
|
}
|
|
|
|
// Views is
|
|
func (d *Dao) Views(c context.Context, aids []int64) (arcs map[int64]*archive.Info, err error) {
|
|
var reply *arcrpc.ViewsReply
|
|
if reply, err = d.arcRPC.Views(c, &arcrpc.ViewsRequest{Aids: aids}); err != nil {
|
|
return
|
|
}
|
|
arcs = make(map[int64]*archive.Info)
|
|
for _, v := range reply.Views {
|
|
var (
|
|
info = new(archive.Info)
|
|
cids []int64
|
|
)
|
|
info.Aid = v.Arc.Aid
|
|
info.State = v.Arc.State
|
|
info.Mid = v.Arc.Author.Mid
|
|
info.Attribute = v.Arc.Attribute
|
|
for _, p := range v.Pages {
|
|
cids = append(cids, p.Cid)
|
|
}
|
|
info.Cids = cids
|
|
arcs[info.Aid] = info
|
|
}
|
|
return
|
|
}
|