293 lines
7.1 KiB
Go
293 lines
7.1 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"strings"
|
||
"time"
|
||
|
||
"go-common/app/interface/main/videoup/conf"
|
||
"go-common/app/interface/main/videoup/dao/account"
|
||
"go-common/app/interface/main/videoup/dao/archive"
|
||
"go-common/app/interface/main/videoup/dao/bfs"
|
||
"go-common/app/interface/main/videoup/dao/creative"
|
||
"go-common/app/interface/main/videoup/dao/dynamic"
|
||
"go-common/app/interface/main/videoup/dao/elec"
|
||
"go-common/app/interface/main/videoup/dao/filter"
|
||
"go-common/app/interface/main/videoup/dao/geetest"
|
||
"go-common/app/interface/main/videoup/dao/mission"
|
||
"go-common/app/interface/main/videoup/dao/order"
|
||
"go-common/app/interface/main/videoup/dao/pay"
|
||
"go-common/app/interface/main/videoup/dao/subtitle"
|
||
"go-common/app/interface/main/videoup/dao/tag"
|
||
arcmdl "go-common/app/interface/main/videoup/model/archive"
|
||
missmdl "go-common/app/interface/main/videoup/model/mission"
|
||
"go-common/app/interface/main/videoup/model/porder"
|
||
"go-common/library/log"
|
||
binfoc "go-common/library/log/infoc"
|
||
"sync"
|
||
)
|
||
|
||
// Service is archive and videos service.
|
||
type Service struct {
|
||
c *conf.Config
|
||
// dao
|
||
arc *archive.Dao
|
||
acc *account.Dao
|
||
bfs *bfs.Dao
|
||
miss *mission.Dao
|
||
elec *elec.Dao
|
||
order *order.Dao
|
||
tag *tag.Dao
|
||
creative *creative.Dao
|
||
filter *filter.Dao
|
||
gt *geetest.Dao
|
||
dynamic *dynamic.Dao
|
||
sub *subtitle.Dao
|
||
pay *pay.Dao
|
||
wg sync.WaitGroup
|
||
asyncCh chan func() error
|
||
// type cache
|
||
typeCache map[int16]*arcmdl.Type
|
||
orderUps map[int64]int64
|
||
staffUps map[int64]int64
|
||
missCache map[int]*missmdl.Mission
|
||
missTagsCache map[string]int
|
||
staffTypeCache map[int16]*arcmdl.StaffTypeConf
|
||
staffGary bool
|
||
descFmtsCache map[int16]map[int8][]*arcmdl.DescFormat
|
||
exemptIDCheckUps map[int64]int64
|
||
exemptZeroLevelAndAnswerUps map[int64]int64
|
||
exemptUgcPayUps map[int64]int64
|
||
exemptHalfMinUps map[int64]int64
|
||
PorderCfgs map[int64]*porder.Config
|
||
PorderGames map[int64]*porder.Game
|
||
infoc *binfoc.Infoc
|
||
}
|
||
|
||
// New new a service.
|
||
func New(c *conf.Config) (s *Service) {
|
||
s = &Service{
|
||
c: c,
|
||
arc: archive.New(c),
|
||
acc: account.New(c),
|
||
bfs: bfs.New(c),
|
||
miss: mission.New(c),
|
||
elec: elec.New(c),
|
||
order: order.New(c),
|
||
tag: tag.New(c),
|
||
creative: creative.New(c),
|
||
filter: filter.New(c),
|
||
gt: geetest.New(c),
|
||
dynamic: dynamic.New(c),
|
||
sub: subtitle.New(c),
|
||
pay: pay.New(c),
|
||
asyncCh: make(chan func() error, 100),
|
||
infoc: binfoc.New(c.AppEditorInfoc),
|
||
}
|
||
s.loadType()
|
||
s.loadMission()
|
||
s.loadOrderUps()
|
||
s.loadPorderCfgListAsMap()
|
||
s.loadPorderGameListAsMap()
|
||
s.loadExemptIDCheckUps()
|
||
s.loadDescFormatCache()
|
||
s.loadExemptZeroLevelAndAnswer()
|
||
s.loadExemptUgcPayUps()
|
||
s.loadStaffUps()
|
||
s.loadStaffConfig()
|
||
s.loadExemptHalfMinUps()
|
||
go s.loadproc()
|
||
go s.asyncproc()
|
||
return s
|
||
}
|
||
|
||
func (s *Service) asyncproc() {
|
||
s.wg.Add(1)
|
||
defer s.wg.Done()
|
||
for {
|
||
f, ok := <-s.asyncCh
|
||
if !ok {
|
||
return
|
||
}
|
||
retry(3, 1*time.Second, f)
|
||
}
|
||
}
|
||
|
||
func retry(attempts int, sleep time.Duration, callback func() error) (err error) {
|
||
for i := 0; ; i++ {
|
||
err = callback()
|
||
if err == nil {
|
||
return
|
||
}
|
||
if i >= (attempts - 1) {
|
||
break
|
||
}
|
||
time.Sleep(sleep)
|
||
log.Error("asyncproc retry retrying after error:(%+v)", err)
|
||
}
|
||
log.Error("asyncproc retry after %d attempts, last error: %s", attempts, err)
|
||
return nil
|
||
}
|
||
|
||
func (s *Service) loadType() {
|
||
tpm, err := s.arc.TypeMapping(context.TODO())
|
||
if err != nil {
|
||
log.Error("s.arc.TypeMapping error(%v)", err)
|
||
return
|
||
}
|
||
s.typeCache = tpm
|
||
}
|
||
|
||
// s.missTagsCache: missionName or first tag
|
||
func (s *Service) loadMission() {
|
||
mm, err := s.miss.Missions(context.TODO())
|
||
if err != nil {
|
||
log.Error("s.miss.Mission error(%v)", err)
|
||
return
|
||
}
|
||
s.missTagsCache = make(map[string]int)
|
||
for _, m := range mm {
|
||
if len(m.Tags) > 0 {
|
||
splitedTags := strings.Split(m.Tags, ",")
|
||
s.missTagsCache[splitedTags[0]] = m.ID
|
||
} else {
|
||
s.missTagsCache[m.Name] = m.ID
|
||
}
|
||
}
|
||
s.missCache = mm
|
||
}
|
||
|
||
func (s *Service) loadOrderUps() {
|
||
orderUps, err := s.order.Ups(context.TODO())
|
||
if err != nil {
|
||
return
|
||
}
|
||
s.orderUps = orderUps
|
||
}
|
||
|
||
// loadDescFormatCache
|
||
func (s *Service) loadDescFormatCache() {
|
||
fmts, err := s.arc.DescFormat(context.TODO())
|
||
if err != nil {
|
||
return
|
||
}
|
||
newFmts := make(map[int16]map[int8][]*arcmdl.DescFormat)
|
||
for _, d := range fmts {
|
||
if _, okTp := newFmts[d.TypeID]; !okTp {
|
||
newFmts[d.TypeID] = make(map[int8][]*arcmdl.DescFormat)
|
||
}
|
||
if _, okCp := newFmts[d.TypeID][d.Copyright]; !okCp {
|
||
newFmts[d.TypeID][d.Copyright] = []*arcmdl.DescFormat{}
|
||
}
|
||
newFmts[d.TypeID][d.Copyright] = append(newFmts[d.TypeID][d.Copyright], d)
|
||
}
|
||
log.Info("s.loadDescFormat: newFmts(%d), fmts(%d)", len(newFmts), len(fmts))
|
||
s.descFmtsCache = newFmts
|
||
}
|
||
|
||
func (s *Service) loadStaffUps() {
|
||
staffUps, err := s.arc.StaffUps(context.TODO())
|
||
if err != nil {
|
||
return
|
||
}
|
||
s.staffUps = staffUps
|
||
}
|
||
|
||
func (s *Service) loadproc() {
|
||
for {
|
||
time.Sleep(time.Duration(s.c.Tick))
|
||
s.loadType()
|
||
s.loadMission()
|
||
s.loadExemptIDCheckUps()
|
||
s.loadExemptZeroLevelAndAnswer()
|
||
s.loadExemptUgcPayUps()
|
||
s.loadExemptHalfMinUps()
|
||
s.loadDescFormatCache()
|
||
s.loadOrderUps()
|
||
s.loadPorderCfgListAsMap()
|
||
s.loadPorderGameListAsMap()
|
||
s.loadStaffUps()
|
||
s.loadStaffConfig()
|
||
}
|
||
}
|
||
|
||
func (s *Service) loadPorderCfgListAsMap() {
|
||
porderCfgList, err := s.arc.PorderCfgList(context.TODO())
|
||
if err != nil {
|
||
log.Error("s.arc.PorderCfgList error(%v)", err)
|
||
return
|
||
}
|
||
s.PorderCfgs = porderCfgList
|
||
}
|
||
|
||
func (s *Service) loadPorderGameListAsMap() {
|
||
list, err := s.arc.GameList(context.TODO())
|
||
if err != nil {
|
||
log.Error("GameList error(%v)", err)
|
||
return
|
||
}
|
||
if len(list) == 0 || list == nil {
|
||
log.Error("GameList empty error(%v)", err)
|
||
return
|
||
}
|
||
s.PorderGames = list
|
||
}
|
||
|
||
// Ping ping success.
|
||
func (s *Service) Ping(c context.Context) (err error) {
|
||
return s.arc.Ping(c)
|
||
}
|
||
|
||
// Close close resource.
|
||
func (s *Service) Close() {
|
||
s.acc.Close()
|
||
s.arc.Close()
|
||
s.infoc.Close()
|
||
close(s.asyncCh)
|
||
s.wg.Wait()
|
||
}
|
||
|
||
// loadExemptIDCheckUps
|
||
func (s *Service) loadExemptIDCheckUps() {
|
||
ups, err := s.arc.UpSpecial(context.TODO(), 8)
|
||
if err != nil {
|
||
return
|
||
}
|
||
s.exemptIDCheckUps = ups
|
||
}
|
||
|
||
// loadExemptIDCheckUps
|
||
func (s *Service) loadExemptZeroLevelAndAnswer() {
|
||
ups, err := s.arc.UpSpecial(context.TODO(), 12)
|
||
if err != nil {
|
||
return
|
||
}
|
||
s.exemptZeroLevelAndAnswerUps = ups
|
||
}
|
||
|
||
// loadExemptUgcPayUps
|
||
func (s *Service) loadExemptUgcPayUps() {
|
||
ups, err := s.arc.UpSpecial(context.TODO(), 17)
|
||
if err != nil {
|
||
return
|
||
}
|
||
s.exemptUgcPayUps = ups
|
||
}
|
||
|
||
// loadStaffConfig 加载联合投稿分区配置
|
||
func (s *Service) loadStaffConfig() {
|
||
var err error
|
||
if s.staffGary, s.staffTypeCache, err = s.arc.StaffTypeConfig(context.TODO()); err != nil {
|
||
s.staffGary = true //怕权限被放出，没有获取到 creative配置的时候，默认开启了灰度策略
|
||
}
|
||
}
|
||
|
||
// loadExemptHalfMinUps
|
||
func (s *Service) loadExemptHalfMinUps() {
|
||
ups, err := s.arc.UpSpecial(context.TODO(), 25)
|
||
if err != nil {
|
||
return
|
||
}
|
||
s.exemptHalfMinUps = ups
|
||
}
|