|
|
package service |
|
|
|
|
|
import ( |
|
|
"context" |
|
|
"sync" |
|
|
"time" |
|
|
|
|
|
"go-common/app/admin/main/videoup-task/conf" |
|
|
"go-common/app/admin/main/videoup-task/dao" |
|
|
"go-common/app/admin/main/videoup-task/model" |
|
|
account "go-common/app/service/main/account/api" |
|
|
upsrpc "go-common/app/service/main/up/api/v1" |
|
|
"go-common/library/database/elastic" |
|
|
"go-common/library/log" |
|
|
bm "go-common/library/net/http/blademaster" |
|
|
) |
|
|
|
|
|
// MemberCache . |
|
|
type MemberCache struct { |
|
|
sync.RWMutex |
|
|
uptime time.Time |
|
|
ms map[int64]*model.MemberStat |
|
|
} |
|
|
|
|
|
//Service service |
|
|
type Service struct { |
|
|
c *conf.Config |
|
|
dao *dao.Dao |
|
|
es *elastic.Elastic |
|
|
|
|
|
httpClient *bm.Client |
|
|
memberCache *MemberCache |
|
|
// cache |
|
|
typeCache map[int16]*model.Type |
|
|
reviewCache *model.ReviewCache |
|
|
twConCache map[int8]map[int64]*model.WCItem |
|
|
upperCache map[int8]map[int64]struct{} |
|
|
typeCache2 map[int16][]int64 // 记录每个一级分区下的二级分区 |
|
|
|
|
|
//grpc |
|
|
accRPC account.AccountClient |
|
|
upsRPC upsrpc.UpClient |
|
|
} |
|
|
|
|
|
//New new service |
|
|
func New(conf *conf.Config) (svr *Service) { |
|
|
svr = &Service{ |
|
|
c: conf, |
|
|
dao: dao.New(conf), |
|
|
es: elastic.NewElastic(nil), |
|
|
|
|
|
httpClient: bm.NewClient(conf.HTTPClient), |
|
|
memberCache: &MemberCache{}, |
|
|
// cache |
|
|
reviewCache: model.NewRC(), |
|
|
} |
|
|
var err error |
|
|
if svr.accRPC, err = account.NewClient(conf.GRPC.AccRPC); err != nil { |
|
|
panic(err) |
|
|
} |
|
|
if svr.upsRPC, err = upsrpc.NewClient(conf.GRPC.UpsRPC); err != nil { |
|
|
panic(err) |
|
|
} |
|
|
|
|
|
go svr.memberproc() |
|
|
svr.loadConf() |
|
|
go svr.cacheproc() |
|
|
go svr.delProc() |
|
|
svr.loadRC() |
|
|
go svr.loadRCproc() |
|
|
|
|
|
return |
|
|
} |
|
|
|
|
|
//Close close |
|
|
func (s *Service) Close() { |
|
|
s.dao.Close() |
|
|
} |
|
|
|
|
|
//Ping ping |
|
|
func (s *Service) Ping(ctx context.Context) (err error) { |
|
|
err = s.dao.Ping(ctx) |
|
|
return |
|
|
} |
|
|
|
|
|
func (s *Service) loadConf() { |
|
|
var ( |
|
|
err error |
|
|
tpm map[int16]*model.Type |
|
|
tpm2 map[int16][]int64 |
|
|
twConCache map[int8]map[int64]*model.WCItem |
|
|
upm map[int8]map[int64]struct{} |
|
|
) |
|
|
if tpm, err = s.dao.TypeMapping(context.TODO()); err != nil { |
|
|
log.Error("s.dao.TypeMapping error(%v)", err) |
|
|
return |
|
|
} |
|
|
s.typeCache = tpm |
|
|
|
|
|
tpm2 = make(map[int16][]int64) |
|
|
for id, tmod := range tpm { |
|
|
if tmod.PID == 0 { |
|
|
if _, ok := tpm2[id]; !ok { |
|
|
tpm2[id] = []int64{} |
|
|
} |
|
|
continue |
|
|
} |
|
|
arrid, ok := tpm2[tmod.PID] |
|
|
if !ok { |
|
|
tpm2[tmod.PID] = []int64{int64(id)} |
|
|
} else { |
|
|
tpm2[tmod.PID] = append(arrid, int64(id)) |
|
|
} |
|
|
} |
|
|
s.typeCache2 = tpm2 |
|
|
|
|
|
if twConCache, err = s.weightConf(context.TODO()); err != nil { |
|
|
log.Error("s.weightConf error(%v)", err) |
|
|
return |
|
|
} |
|
|
s.twConCache = twConCache |
|
|
|
|
|
upm, err = s.upSpecial(context.TODO()) |
|
|
if err != nil { |
|
|
log.Error("s.upSpecial error(%v)", err) |
|
|
return |
|
|
} |
|
|
s.upperCache = upm |
|
|
} |
|
|
|
|
|
func (s *Service) cacheproc() { |
|
|
for { |
|
|
time.Sleep(3 * time.Minute) |
|
|
s.loadConf() |
|
|
} |
|
|
}
|
|
|
|
