Create & Init Project...

app/job/main/passport-game-cloud/service/service.go

@@ -0,0 +1,152 @@
+package service
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"go-common/app/job/main/passport-game-cloud/conf"
+	"go-common/app/job/main/passport-game-cloud/dao"
+	"go-common/library/queue/databus"
+)
+
+const (
+	// cache retry count and duration
+	_accountCacheRetryCount    = 3
+	_accountCacheRetryDuration = time.Second
+
+	// table and duration
+	_asoAccountTable   = "aso_account"
+	_memberTablePrefix = "dede_member"
+
+	_changePwd      = "changePwd"
+	_updateUserInfo = "updateUserInfo"
+
+	_gameAppID = int32(876)
+)
+
+// Service service.
+type Service struct {
+	c      *conf.Config
+	d      *dao.Dao
+	missch chan func()
+
+	// prom
+	tokenInterval      *Interval
+	memberInterval     *Interval
+	asoAccountInterval *Interval
+	transInterval      *Interval
+
+	gameAppIDs []int32
+	// bin log proc
+	binLogDataBus    *databus.Databus
+	binLogMergeChans []chan *message
+	binLogDoneChan   chan []*message
+	head, last       *message
+	mu               sync.Mutex
+	// aso acc proc
+	encryptTransDataBus    *databus.Databus
+	encryptTransMergeChans []chan *message
+	encryptTransDoneChan   chan []*message
+	asoHead, asoLast       *message
+	asoMu                  sync.Mutex
+}
+
+type message struct {
+	next   *message
+	data   *databus.Message
+	object interface{}
+	done   bool
+}
+
+// New new a service instance.
+func New(c *conf.Config) (s *Service) {
+	gameAppIDs := make([]int32, 0)
+	gameAppIDs = append(gameAppIDs, _gameAppID)
+	for _, id := range c.Game.AppIDs {
+		if id == _gameAppID {
+			continue
+		}
+		gameAppIDs = append(gameAppIDs, id)
+	}
+
+	s = &Service{
+		c:      c,
+		d:      dao.New(c),
+		missch: make(chan func(), 10240),
+
+		// prom
+		tokenInterval: NewInterval(&IntervalConfig{
+			Name: "interval_token",
+			Rate: 1000,
+		}),
+		memberInterval: NewInterval(&IntervalConfig{
+			Name: "interval_member",
+			Rate: 1000,
+		}),
+		asoAccountInterval: NewInterval(&IntervalConfig{
+			Name: "interval_aso_account",
+			Rate: 1000,
+		}),
+		transInterval: NewInterval(&IntervalConfig{
+			Name: "interval_trans",
+			Rate: 1000,
+		}),
+		gameAppIDs:       gameAppIDs,
+		binLogDataBus:    databus.New(c.DataBus.BinLogSub),
+		binLogMergeChans: make([]chan *message, c.Group.BinLog.Num),
+		binLogDoneChan:   make(chan []*message, c.Group.BinLog.Chan),
+		// aso acc proc
+		encryptTransDataBus:    databus.New(c.DataBus.EncryptTransSub),
+		encryptTransMergeChans: make([]chan *message, c.Group.EncryptTrans.Num),
+		encryptTransDoneChan:   make(chan []*message, c.Group.EncryptTrans.Chan),
+	}
+	// start bin log proc
+	go s.binlogcommitproc()
+	for i := 0; i < c.Group.BinLog.Num; i++ {
+		ch := make(chan *message, c.Group.BinLog.Chan)
+		s.binLogMergeChans[i] = ch
+		go s.binlogmergeproc(ch)
+	}
+	go s.binlogconsumeproc()
+	// start encrypt trans proc
+	go s.encrypttranscommitproc()
+	for i := 0; i < c.Group.EncryptTrans.Num; i++ {
+		ch := make(chan *message, c.Group.EncryptTrans.Chan)
+		s.encryptTransMergeChans[i] = ch
+		go s.encrypttransmergeproc(ch)
+	}
+	go s.encrypttransconsumeproc()
+	// go s.cacheproc()
+	return
+}
+
+//func (s *Service) addCache(f func()) {
+//	select {
+//	case s.missch <- f:
+//	default:
+//		log.Warn("cache chan full")
+//	}
+//}
+
+// cacheproc is a routine for executing closure.
+//func (s *Service) cacheproc() {
+//	for {
+//		f := <-s.missch
+//		f()
+//	}
+//}
+
+// Ping check server ok.
+func (s *Service) Ping(c context.Context) (err error) {
+	err = s.d.Ping(c)
+	return
+}
+
+// Close close service, including closing dao.
+func (s *Service) Close() (err error) {
+	s.binLogDataBus.Close()
+	s.encryptTransDataBus.Close()
+	s.d.Close()
+	return
+}