729 lines
22 KiB
Go
729 lines
22 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
xlog "log"
|
|
"strconv"
|
|
"sync"
|
|
"time"
|
|
|
|
"go-common/app/job/main/vip/conf"
|
|
"go-common/app/job/main/vip/dao"
|
|
"go-common/app/job/main/vip/model"
|
|
couponrpc "go-common/app/service/main/coupon/rpc/client"
|
|
v1 "go-common/app/service/main/vip/api"
|
|
"go-common/library/log"
|
|
"go-common/library/queue/databus"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/robfig/cron"
|
|
)
|
|
|
|
const (
|
|
_tableUserInfo = "vip_user_info"
|
|
_tablePayOrder = "vip_pay_order"
|
|
_insertAction = "insert"
|
|
_updateAction = "update"
|
|
_deleteAction = "delete"
|
|
|
|
notifyAction = "updateVip"
|
|
|
|
_ps = 50
|
|
_defsleepmsec = 100
|
|
)
|
|
|
|
//Service vip service
|
|
type Service struct {
|
|
dao *dao.Dao
|
|
c *conf.Config
|
|
//vipRPC *client.Service
|
|
reducePayOrder map[string]*model.VipPayOrder
|
|
appMap map[int64]*model.VipAppInfo
|
|
confMap map[string]*model.VipConfig
|
|
cleanVipCache chan int64
|
|
cleanAppCache chan *model.AppCache
|
|
ds *databus.Databus
|
|
handlerFailPayOrder chan *model.VipPayOrder
|
|
handlerFailUserInfo chan *model.VipUserInfo
|
|
handlerFailRechargeOrder chan *model.VipPayOrder
|
|
handlerFailVipbuy chan *model.VipBuyResq
|
|
handlerInsertOrder chan *model.VipPayOrder
|
|
handlerUpdateOrder chan *model.VipPayOrder
|
|
handlerRechargeOrder chan *model.VipPayOrder
|
|
handlerInsertUserInfo chan *model.VipUserInfo
|
|
handlerUpdateUserInfo chan *model.VipUserInfo
|
|
handlerStationActive chan *model.VipPayOrder
|
|
handlerAutoRenewLog chan *model.VipUserInfo
|
|
handlerAddVipHistory chan *model.VipChangeHistoryMsg
|
|
handlerAddBcoinSalary chan *model.VipBcoinSalaryMsg
|
|
handlerUpdateBcoinSalary chan *model.VipBcoinSalaryMsg
|
|
handlerDelBcoinSalary chan *model.VipBcoinSalaryMsg
|
|
notifycouponchan chan func()
|
|
accLogin *databus.Databus
|
|
frozenDate time.Duration
|
|
newVipDatabus *databus.Databus
|
|
salaryCoupnDatabus *databus.Databus
|
|
accountNoitfyDatabus *databus.Databus
|
|
couponNotifyDatabus *databus.Databus
|
|
autoRenewdDatabus *databus.Databus
|
|
// waiter
|
|
waiter sync.WaitGroup
|
|
closed bool
|
|
sendmsgchan chan func()
|
|
couponRPC *couponrpc.Service
|
|
// vip service
|
|
vipgRPC v1.VipClient
|
|
}
|
|
|
|
//New new service
|
|
func New(c *conf.Config) (s *Service) {
|
|
s = &Service{
|
|
c: c,
|
|
dao: dao.New(c),
|
|
//vipRPC: client.New(c.VipRPC),
|
|
cleanVipCache: make(chan int64, 10240),
|
|
confMap: make(map[string]*model.VipConfig),
|
|
cleanAppCache: make(chan *model.AppCache, 10240),
|
|
handlerFailPayOrder: make(chan *model.VipPayOrder, 10240),
|
|
handlerFailUserInfo: make(chan *model.VipUserInfo, 10240),
|
|
handlerFailRechargeOrder: make(chan *model.VipPayOrder, 10240),
|
|
handlerInsertOrder: make(chan *model.VipPayOrder, 10240),
|
|
handlerRechargeOrder: make(chan *model.VipPayOrder, 10240),
|
|
handlerUpdateOrder: make(chan *model.VipPayOrder, 10240),
|
|
handlerInsertUserInfo: make(chan *model.VipUserInfo, 10240),
|
|
handlerUpdateUserInfo: make(chan *model.VipUserInfo, 10240),
|
|
handlerStationActive: make(chan *model.VipPayOrder, 10240),
|
|
handlerAutoRenewLog: make(chan *model.VipUserInfo, 10240),
|
|
handlerAddVipHistory: make(chan *model.VipChangeHistoryMsg, 10240),
|
|
handlerAddBcoinSalary: make(chan *model.VipBcoinSalaryMsg, 10240),
|
|
handlerUpdateBcoinSalary: make(chan *model.VipBcoinSalaryMsg, 10240),
|
|
handlerDelBcoinSalary: make(chan *model.VipBcoinSalaryMsg, 10240),
|
|
handlerFailVipbuy: make(chan *model.VipBuyResq, 10240),
|
|
notifycouponchan: make(chan func(), 10240),
|
|
ds: databus.New(c.Databus.OldVipBinLog),
|
|
newVipDatabus: databus.New(c.Databus.NewVipBinLog),
|
|
accLogin: databus.New(c.Databus.AccLogin),
|
|
frozenDate: time.Duration(c.Property.FrozenDate),
|
|
reducePayOrder: make(map[string]*model.VipPayOrder),
|
|
sendmsgchan: make(chan func(), 10240),
|
|
accountNoitfyDatabus: databus.New(c.Databus.AccountNotify),
|
|
couponRPC: couponrpc.New(c.RPCClient2.Coupon),
|
|
}
|
|
vipgRPC, err := v1.NewClient(c.VipClient)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
s.vipgRPC = vipgRPC
|
|
t := cron.New()
|
|
go s.loadappinfoproc()
|
|
go s.cleanappcacheretryproc()
|
|
go s.cleanvipretryproc()
|
|
go s.sendmessageproc()
|
|
go s.handlerfailpayorderproc()
|
|
go s.handlerfailrechargeorderproc()
|
|
go s.handlerfailuserinfoproc()
|
|
go s.handlerautorenewlogproc()
|
|
go s.handlerdelbcoinproc()
|
|
if c.Databus.SalaryCoupon != nil {
|
|
s.salaryCoupnDatabus = databus.New(c.Databus.SalaryCoupon)
|
|
s.waiter.Add(1)
|
|
go s.salarycouponproc()
|
|
}
|
|
if c.Databus.CouponNotify != nil {
|
|
s.couponNotifyDatabus = databus.New(c.Databus.CouponNotify)
|
|
go s.couponnotifyproc()
|
|
s.waiter.Add(1)
|
|
go s.couponnotifybinlogproc()
|
|
}
|
|
for i := 0; i < s.c.Property.HandlerThread; i++ {
|
|
go s.handlerinsertorderproc()
|
|
go s.handlerupdateorderproc()
|
|
go s.handlerinsertuserinfoproc()
|
|
go s.handlerupdateuserinfoproc()
|
|
go s.handleraddchangehistoryproc()
|
|
go s.handleraddbcoinproc()
|
|
go s.handlerupdatebcoinproc()
|
|
go s.handlerupdaterechargeorderproc()
|
|
}
|
|
for i := 0; i < s.c.Property.ReadThread; i++ {
|
|
go s.readdatabusproc()
|
|
}
|
|
go s.readnewvipdatabusproc()
|
|
if c.Property.FrozenCron != "" {
|
|
go s.accloginproc()
|
|
t.AddFunc(c.Property.FrozenCron, s.unFrozenJob)
|
|
}
|
|
t.AddFunc(c.Property.UpdateUserInfoCron, s.updateUserInfoJob)
|
|
t.AddFunc(c.Property.SalaryVideoCouponCron, s.salaryVideoCouponJob)
|
|
t.AddFunc(c.Property.PushDataCron, s.pushDataJob)
|
|
t.AddFunc(c.Property.EleEompensateCron, s.eleEompensateJob)
|
|
//t.AddFunc(c.Property.HadExpiredMsgCron, s.hadExpiredMsgJob)
|
|
//t.AddFunc(c.Property.WillExpireMsgCron, s.willExpiredMsgJob)
|
|
//t.AddFunc(c.Property.SendMessageCron, s.sendMessageJob)
|
|
//t.AddFunc(c.Property.AutoRenewCron, s.autoRenewJob)
|
|
//t.AddFunc(c.Property.SendBcoinCron, s.sendBcoinJob)
|
|
t.Start()
|
|
go s.consumercheckproc()
|
|
if c.Databus.AutoRenew != nil {
|
|
s.autoRenewdDatabus = databus.New(c.Databus.AutoRenew)
|
|
s.waiter.Add(1)
|
|
go s.retryautorenewpayproc()
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Service) readnewvipdatabusproc() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
r = errors.WithStack(r.(error))
|
|
log.Error("Runtime error caught: %+v", r)
|
|
go s.readnewvipdatabusproc()
|
|
}
|
|
}()
|
|
var err error
|
|
|
|
for msg := range s.newVipDatabus.Messages() {
|
|
val := msg.Value
|
|
if err = msg.Commit(); err != nil {
|
|
log.Error("readdatabusproc msg.commit() error(%v)", err)
|
|
msg.Commit()
|
|
}
|
|
log.Info("cur consumer new vip db message(%v)", string(msg.Value))
|
|
message := new(model.Message)
|
|
if err = json.Unmarshal(val, message); err != nil {
|
|
log.Error("readnewvipdatabusproc json.unmarshal val(%+v) error(%+v)", string(val), err)
|
|
continue
|
|
}
|
|
if message.Table == "vip_user_info" {
|
|
userInfo := new(model.VipUserInfoNewMsg)
|
|
if err = json.Unmarshal(message.New, userInfo); err != nil {
|
|
log.Error("readdatabusproc json.Unmarshal val(%v) error(%v)", string(message.New), err)
|
|
continue
|
|
}
|
|
vipUser := convertUserInfoByNewMsg(userInfo)
|
|
s.dao.DelInfoCache(context.Background(), vipUser.Mid)
|
|
if message.Action == _insertAction {
|
|
if vipUser.PayType == model.AutoRenew {
|
|
select {
|
|
case s.handlerAutoRenewLog <- vipUser:
|
|
default:
|
|
log.Error("s.handlerAutoRenewLog full!")
|
|
}
|
|
}
|
|
} else if message.Action == _updateAction {
|
|
oldUserMsg := new(model.VipUserInfoNewMsg)
|
|
if err = json.Unmarshal(message.Old, oldUserMsg); err != nil {
|
|
log.Error("readdatabusproc json.Unmarshal val(%v) error(%v)", string(message.Old), err)
|
|
continue
|
|
}
|
|
oldUser := convertUserInfoByNewMsg(oldUserMsg)
|
|
|
|
if oldUser.PayType != vipUser.PayType {
|
|
select {
|
|
case s.handlerAutoRenewLog <- vipUser:
|
|
default:
|
|
log.Error("s.handlerAutoRenewLog full update!")
|
|
}
|
|
}
|
|
}
|
|
s.pubAccountNotify(vipUser.Mid)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
func (s *Service) readdatabusproc() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
r = errors.WithStack(r.(error))
|
|
log.Error("Runtime error caught: %+v", r)
|
|
go s.readdatabusproc()
|
|
}
|
|
}()
|
|
var err error
|
|
for msg := range s.ds.Messages() {
|
|
val := msg.Value
|
|
message := new(model.Message)
|
|
|
|
if err = json.Unmarshal(val, message); err != nil {
|
|
log.Error("readdatabusproc json.Unmarshal val(%v) error(%v)", string(val), err)
|
|
if err = msg.Commit(); err != nil {
|
|
log.Error("msg.commit() error(%v)", err)
|
|
}
|
|
continue
|
|
}
|
|
|
|
if message.Table == "vip_pay_order" {
|
|
order := new(model.VipPayOrderOldMsg)
|
|
if err = json.Unmarshal(message.New, order); err != nil {
|
|
log.Error("readdatabusproc json.Unmarshal val(%v) error(%v)", string(message.New), err)
|
|
if err = msg.Commit(); err != nil {
|
|
log.Error("msg.commit() error(%v)", err)
|
|
}
|
|
continue
|
|
}
|
|
|
|
payOrder := s.convertPayOrder(order)
|
|
if message.Action == "insert" {
|
|
select {
|
|
case s.handlerInsertOrder <- payOrder:
|
|
default:
|
|
xlog.Panic("s.handlerInsertOrder full!")
|
|
}
|
|
} else if message.Action == "update" {
|
|
select {
|
|
case s.handlerUpdateOrder <- payOrder:
|
|
default:
|
|
xlog.Panic("s.handlerUpdateOrder full!")
|
|
}
|
|
}
|
|
|
|
} else if message.Table == "vip_recharge_order" {
|
|
order := new(model.VipRechargeOrderMsg)
|
|
if err = json.Unmarshal(message.New, order); err != nil {
|
|
log.Error("readdatabusproc json.Unmarshal val(%v) error(%v)", string(message.New), err)
|
|
if err = msg.Commit(); err != nil {
|
|
log.Error("msg.commit() error(%v)", err)
|
|
}
|
|
continue
|
|
}
|
|
|
|
payOrder := s.convertPayOrderByMsg(order)
|
|
if message.Action == "update" {
|
|
select {
|
|
case s.handlerRechargeOrder <- payOrder:
|
|
default:
|
|
xlog.Panic("s.handlerRechargeOrder full!")
|
|
}
|
|
} else if message.Action == "insert" {
|
|
if len(payOrder.ThirdTradeNo) > 0 {
|
|
select {
|
|
case s.handlerRechargeOrder <- payOrder:
|
|
default:
|
|
xlog.Panic("s.handlerRechargeOrder full!")
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if message.Table == "vip_user_info" {
|
|
userInfo := new(model.VipUserInfoMsg)
|
|
if err = json.Unmarshal(message.New, userInfo); err != nil {
|
|
log.Error("readdatabusproc json.Unmarshal val(%v) error(%v)", string(message.New), err)
|
|
if err = msg.Commit(); err != nil {
|
|
log.Error("msg.commit() error(%v)", err)
|
|
}
|
|
continue
|
|
}
|
|
vipUser := convertMsgToUserInfo(userInfo)
|
|
if message.Action == "insert" {
|
|
select {
|
|
case s.handlerInsertUserInfo <- vipUser:
|
|
default:
|
|
xlog.Panic("s.handlerInsertUserInfo full!")
|
|
}
|
|
} else if message.Action == "update" {
|
|
oldUser := new(model.VipUserInfoMsg)
|
|
if err = json.Unmarshal(message.Old, oldUser); err != nil {
|
|
log.Error("readdatabusproc json.Unmarshal val(%v) error(%v)", string(message.Old), err)
|
|
if err = msg.Commit(); err != nil {
|
|
log.Error("msg.commit() error(%v)", err)
|
|
}
|
|
continue
|
|
}
|
|
vipUser.OldVer = oldUser.Ver
|
|
select {
|
|
case s.handlerUpdateUserInfo <- vipUser:
|
|
default:
|
|
xlog.Panic("s.handlerUpdateUserInfo full!")
|
|
}
|
|
}
|
|
if !s.grayScope(userInfo.Mid) {
|
|
s.cleanCache(userInfo.Mid)
|
|
}
|
|
|
|
} else if message.Table == "vip_change_history" {
|
|
historyMsg := new(model.VipChangeHistoryMsg)
|
|
if err = json.Unmarshal(message.New, historyMsg); err != nil {
|
|
log.Error("readdatabusproc json.Unmarshal val(%v) error(%v)", string(message.New), err)
|
|
if err = msg.Commit(); err != nil {
|
|
log.Error("msg.commit() error(%v)", err)
|
|
}
|
|
continue
|
|
}
|
|
if message.Action == "insert" {
|
|
select {
|
|
case s.handlerAddVipHistory <- historyMsg:
|
|
default:
|
|
xlog.Panic("s.handlerAddVipHistory full!")
|
|
}
|
|
}
|
|
} else if message.Table == "vip_bcoin_salary" {
|
|
bcoinMsg := new(model.VipBcoinSalaryMsg)
|
|
|
|
if err = json.Unmarshal(message.New, bcoinMsg); err != nil {
|
|
log.Error("readdatabusproc json.Unmarshal val(%v) error(%v)", string(message.New), err)
|
|
if err = msg.Commit(); err != nil {
|
|
log.Error("msg.commit() error(%v)", err)
|
|
}
|
|
continue
|
|
}
|
|
if message.Action == _insertAction {
|
|
select {
|
|
case s.handlerAddBcoinSalary <- bcoinMsg:
|
|
default:
|
|
xlog.Panic("s.handlerAddBcoinSalary full!")
|
|
}
|
|
} else if message.Action == _updateAction {
|
|
select {
|
|
case s.handlerUpdateBcoinSalary <- bcoinMsg:
|
|
default:
|
|
xlog.Panic("s.handlerUpdateBcoinSalary full!")
|
|
}
|
|
} else if message.Action == _deleteAction {
|
|
select {
|
|
case s.handlerDelBcoinSalary <- bcoinMsg:
|
|
default:
|
|
xlog.Panic("s.handlerDelBcoinSalary full!")
|
|
}
|
|
}
|
|
}
|
|
|
|
if err = msg.Commit(); err != nil {
|
|
log.Error("readdatabusproc msg.commit() error(%v)", err)
|
|
msg.Commit()
|
|
}
|
|
log.Info("cur consumer message(%v)", string(msg.Value))
|
|
}
|
|
}
|
|
|
|
func (s *Service) cleanCache(mid int64) {
|
|
var (
|
|
hv = new(model.HandlerVip)
|
|
err error
|
|
)
|
|
hv.Type = 2
|
|
hv.Days = 0
|
|
hv.Months = 0
|
|
hv.Mid = mid
|
|
if err = s.cleanCacheAndNotify(context.TODO(), hv); err != nil {
|
|
select {
|
|
case s.cleanVipCache <- hv.Mid:
|
|
default:
|
|
xlog.Panic("s.cleanVipCache full!")
|
|
}
|
|
}
|
|
s.pubAccountNotify(mid)
|
|
}
|
|
|
|
func (s *Service) pubAccountNotify(mid int64) (err error) {
|
|
|
|
data := new(struct {
|
|
Mid int64 `json:"mid"`
|
|
Action string `json:"action"`
|
|
})
|
|
data.Mid = mid
|
|
data.Action = notifyAction
|
|
if err = s.accountNoitfyDatabus.Send(context.TODO(), strconv.FormatInt(mid, 10), data); err != nil {
|
|
log.Error("send (%+v) error(%+v)", data, err)
|
|
}
|
|
log.Info("send(mid:%+v) data:%+v", mid, data)
|
|
return
|
|
}
|
|
|
|
func (s *Service) loadappinfoproc() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
r = errors.WithStack(r.(error))
|
|
log.Error("Runtime error caught: %+v", r)
|
|
go s.loadappinfoproc()
|
|
}
|
|
}()
|
|
for {
|
|
s.loadAppInfo()
|
|
time.Sleep(time.Minute * 2)
|
|
}
|
|
}
|
|
|
|
func (s *Service) loadAppInfo() {
|
|
var (
|
|
res []*model.VipAppInfo
|
|
err error
|
|
)
|
|
if res, err = s.dao.SelAppInfo(context.TODO()); err != nil {
|
|
log.Error("loadAppInfo SelAppInfo error(%v)", err)
|
|
return
|
|
}
|
|
aMap := make(map[int64]*model.VipAppInfo, len(res))
|
|
for _, v := range res {
|
|
aMap[v.ID] = v
|
|
}
|
|
s.appMap = aMap
|
|
bytes, _ := json.Marshal(res)
|
|
log.Info("load app success :%v", string(bytes))
|
|
}
|
|
|
|
func (s *Service) cleanvipretryproc() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
r = errors.WithStack(r.(error))
|
|
log.Error("Runtime error caught: %+v", r)
|
|
go s.cleanvipretryproc()
|
|
}
|
|
}()
|
|
for {
|
|
mid := <-s.cleanVipCache
|
|
s.cleanVipRetry(mid)
|
|
}
|
|
|
|
}
|
|
|
|
func (s *Service) cleanVipRetry(mid int64) {
|
|
|
|
hv := new(model.HandlerVip)
|
|
hv.Type = 2
|
|
hv.Days = 0
|
|
hv.Months = 0
|
|
hv.Mid = mid
|
|
s.dao.DelInfoCache(context.Background(), mid)
|
|
for i := 0; i < s.c.Property.Retry; i++ {
|
|
if err := s.cleanCacheAndNotify(context.TODO(), hv); err == nil {
|
|
break
|
|
}
|
|
s.dao.DelVipInfoCache(context.TODO(), int64(hv.Mid))
|
|
|
|
}
|
|
log.Info("handler success cache fail mid(%v)", mid)
|
|
}
|
|
|
|
func (s *Service) cleanappcacheretryproc() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
r = errors.WithStack(r.(error))
|
|
log.Error("Runtime error caught: %+v", r)
|
|
go s.cleanappcacheretryproc()
|
|
}
|
|
}()
|
|
for {
|
|
ac := <-s.cleanAppCache
|
|
s.cleanAppCacheRetry(ac)
|
|
}
|
|
}
|
|
|
|
func (s *Service) cleanAppCacheRetry(ac *model.AppCache) {
|
|
appInfo := s.appMap[ac.AppID]
|
|
hv := new(model.HandlerVip)
|
|
hv.Type = 2
|
|
hv.Days = 0
|
|
hv.Months = 0
|
|
hv.Mid = ac.Mid
|
|
for i := 0; i < s.c.Property.Retry; i++ {
|
|
if err := s.dao.SendAppCleanCache(context.TODO(), hv, appInfo); err == nil {
|
|
break
|
|
}
|
|
}
|
|
log.Info("handler success cache app fail appInfo(%v)", ac)
|
|
}
|
|
|
|
func (s *Service) salarycouponproc() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
r = errors.WithStack(r.(error))
|
|
log.Error("Runtime error caught: %+v", r)
|
|
go s.salarycouponproc()
|
|
}
|
|
}()
|
|
defer s.waiter.Done()
|
|
var (
|
|
err error
|
|
msg *databus.Message
|
|
msgChan = s.salaryCoupnDatabus.Messages()
|
|
ok bool
|
|
c = context.Background()
|
|
)
|
|
for {
|
|
msg, ok = <-msgChan
|
|
if !ok || s.closed {
|
|
log.Info("salary coupon msgChan closed")
|
|
return
|
|
}
|
|
msg.Commit()
|
|
v := &model.Message{}
|
|
if err = json.Unmarshal([]byte(msg.Value), v); err != nil {
|
|
log.Error("json.Unmarshal(%v) err(%v)", v, err)
|
|
continue
|
|
}
|
|
if v.Table != _tableUserInfo {
|
|
continue
|
|
}
|
|
nvip := &model.VipUserInfoMsg{}
|
|
if err = json.Unmarshal(v.New, &nvip); err != nil {
|
|
log.Error("salary new json.Unmarshal values(%v),error(%v)", string(v.New), err)
|
|
continue
|
|
}
|
|
ovip := &model.VipUserInfoMsg{}
|
|
if v.Action != _insertAction {
|
|
if err = json.Unmarshal(v.Old, &ovip); err != nil {
|
|
log.Error("salary old json.Unmarshal values(%v),error(%v)", string(v.Old), err)
|
|
continue
|
|
}
|
|
}
|
|
log.Info("salary coupon start mid(%d)", nvip.Mid)
|
|
if _, err = s.SalaryVideoCouponAtOnce(c, nvip, ovip, v.Action); err != nil {
|
|
log.Error("SalaryVideoCouponAtOnce fail(%d) nvip(%v) ovip(%v) %s error(%v)", nvip.Mid, nvip, ovip, v.Action, err)
|
|
continue
|
|
}
|
|
log.Info("salary coupon suc mid(%d)", nvip.Mid)
|
|
}
|
|
}
|
|
|
|
func (s *Service) couponnotifybinlogproc() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
r = errors.WithStack(r.(error))
|
|
log.Error("Runtime error couponnotifybinlogproc caught: %+v", r)
|
|
go s.couponnotifybinlogproc()
|
|
}
|
|
}()
|
|
defer s.waiter.Done()
|
|
var (
|
|
err error
|
|
msg *databus.Message
|
|
msgChan = s.couponNotifyDatabus.Messages()
|
|
ok bool
|
|
c = context.Background()
|
|
)
|
|
for {
|
|
msg, ok = <-msgChan
|
|
if !ok || s.closed {
|
|
log.Info("coupon notify couponnotifybinlogproc msgChan closed")
|
|
return
|
|
}
|
|
if err = msg.Commit(); err != nil {
|
|
log.Error("couponnotifybinlogproc msg.Commit err(%v)", err)
|
|
continue
|
|
}
|
|
log.Info("cur consumer couponnotifybinlogproc(%v)", string(msg.Value))
|
|
v := &model.Message{}
|
|
if err = json.Unmarshal([]byte(msg.Value), v); err != nil {
|
|
log.Error("couponnotifybinlogproc json.Unmarshal(%v) err(%v)", v, err)
|
|
continue
|
|
}
|
|
if v.Table != _tablePayOrder || v.Action != _updateAction {
|
|
continue
|
|
}
|
|
newo := new(model.VipPayOrderNewMsg)
|
|
if err = json.Unmarshal(v.New, newo); err != nil {
|
|
log.Error("couponnotifybinlogproc json.Unmarshal val(%v) error(%v)", string(v.New), err)
|
|
continue
|
|
}
|
|
oldo := new(model.VipPayOrderNewMsg)
|
|
if err = json.Unmarshal(v.Old, oldo); err != nil {
|
|
log.Error("couponnotifybinlogproc json.Unmarshal val(%v) error(%v)", string(v.Old), err)
|
|
continue
|
|
}
|
|
if newo == nil || oldo == nil {
|
|
continue
|
|
}
|
|
if oldo.Status != model.PAYING {
|
|
continue
|
|
}
|
|
if newo.Status != model.SUCCESS && newo.Status != model.FAILED {
|
|
continue
|
|
}
|
|
if newo.CouponMoney <= 0 {
|
|
continue
|
|
}
|
|
s.couponnotify(func() {
|
|
s.CouponNotify(c, newo)
|
|
})
|
|
}
|
|
}
|
|
|
|
func (s *Service) updateUserInfoJob() {
|
|
log.Info("update user info job start ....................................")
|
|
s.ScanUserInfo(context.TODO())
|
|
log.Info("update user info job end ........................................")
|
|
}
|
|
|
|
func (s *Service) salaryVideoCouponJob() {
|
|
log.Info("salary video coupon job start ....................................")
|
|
var err error
|
|
if ok := s.dao.AddTransferLock(context.TODO(), "_transferLock"); !ok {
|
|
log.Info("salary video coupon job had run ....................................")
|
|
return
|
|
}
|
|
if err = s.ScanSalaryVideoCoupon(context.TODO()); err != nil {
|
|
log.Error("ScanSalaryVideoCoupon error(%v)", err)
|
|
return
|
|
}
|
|
log.Info("salary video coupon job end ........................................")
|
|
}
|
|
|
|
//Ping check db live
|
|
func (s *Service) Ping(c context.Context) (err error) {
|
|
return s.dao.Ping(c)
|
|
}
|
|
|
|
// Close all resource.
|
|
func (s *Service) Close() {
|
|
defer s.waiter.Wait()
|
|
s.closed = true
|
|
s.salaryCoupnDatabus.Close()
|
|
s.dao.Close()
|
|
s.ds.Close()
|
|
s.newVipDatabus.Close()
|
|
}
|
|
|
|
func (s *Service) sendmessageproc() {
|
|
defer func() {
|
|
if x := recover(); x != nil {
|
|
log.Error("service.sendmessageproc panic(%v)", x)
|
|
go s.sendmessageproc()
|
|
log.Info("service.sendmessageproc recover")
|
|
}
|
|
}()
|
|
for {
|
|
f := <-s.sendmsgchan
|
|
f()
|
|
}
|
|
}
|
|
|
|
func (s *Service) sendmessage(f func()) {
|
|
defer func() {
|
|
if x := recover(); x != nil {
|
|
log.Error("service.sendmessage panic(%v)", x)
|
|
}
|
|
}()
|
|
select {
|
|
case s.sendmsgchan <- f:
|
|
default:
|
|
log.Error("service.sendmessage chan full")
|
|
}
|
|
}
|
|
|
|
func (s *Service) consumercheckproc() {
|
|
for {
|
|
time.Sleep(time.Second)
|
|
log.Info("consumercheckproc chan(cleanVipCache) size: %d", len(s.cleanVipCache))
|
|
log.Info("consumercheckproc chan(cleanAppCache) size: %d", len(s.cleanAppCache))
|
|
log.Info("consumercheckproc chan(handlerFailPayOrder) size: %d", len(s.handlerFailPayOrder))
|
|
log.Info("consumercheckproc chan(handlerFailUserInfo) size: %d", len(s.handlerFailUserInfo))
|
|
log.Info("consumercheckproc chan(handlerFailRechargeOrder) size: %d", len(s.handlerFailRechargeOrder))
|
|
log.Info("consumercheckproc chan(handlerFailVipbuy) size: %d", len(s.handlerFailVipbuy))
|
|
log.Info("consumercheckproc chan(handlerInsertOrder) size: %d", len(s.handlerInsertOrder))
|
|
log.Info("consumercheckproc chan(handlerUpdateOrder) size: %d", len(s.handlerUpdateOrder))
|
|
log.Info("consumercheckproc chan(handlerRechargeOrder) size: %d", len(s.handlerRechargeOrder))
|
|
log.Info("consumercheckproc chan(handlerInsertUserInfo) size: %d", len(s.handlerInsertUserInfo))
|
|
log.Info("consumercheckproc chan(handlerUpdateUserInfo) size: %d", len(s.handlerUpdateUserInfo))
|
|
log.Info("consumercheckproc chan(handlerStationActive) size: %d", len(s.handlerStationActive))
|
|
log.Info("consumercheckproc chan(handlerAutoRenewLog) size: %d", len(s.handlerAutoRenewLog))
|
|
log.Info("consumercheckproc chan(handlerAddVipHistory) size: %d", len(s.handlerAddVipHistory))
|
|
log.Info("consumercheckproc chan(handlerAddBcoinSalary) size: %d", len(s.handlerAddBcoinSalary))
|
|
log.Info("consumercheckproc chan(handlerUpdateBcoinSalary) size: %d", len(s.handlerUpdateBcoinSalary))
|
|
log.Info("consumercheckproc chan(handlerDelBcoinSalary) size: %d", len(s.handlerDelBcoinSalary))
|
|
log.Info("consumercheckproc chan(sendmsgchan) size: %d", len(s.sendmsgchan))
|
|
log.Info("consumercheckproc chan(notifycouponchan) size: %d", len(s.notifycouponchan))
|
|
}
|
|
}
|