Create & Init Project...

app/job/main/passport-user/service/BUILD

@@ -0,0 +1,54 @@
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "aes.go",
+        "aso_full_migration.go",
+        "aso_incr_migration.go",
+        "duplicate.go",
+        "passport_util.go",
+        "service.go",
+        "user.go",
+    ],
+    importpath = "go-common/app/job/main/passport-user/service",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/job/main/passport-user/conf:go_default_library",
+        "//app/job/main/passport-user/dao:go_default_library",
+        "//app/job/main/passport-user/model:go_default_library",
+        "//library/database/sql:go_default_library",
+        "//library/log:go_default_library",
+        "//library/queue/databus:go_default_library",
+        "//library/queue/databus/databusutil:go_default_library",
+        "//vendor/github.com/go-sql-driver/mysql:go_default_library",
+        "//vendor/github.com/pkg/errors:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["aes_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+)

app/job/main/passport-user/service/aes.go

@@ -0,0 +1,51 @@
+package service
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+)
+
+//var key = []byte("bili_account_enc")
+
+// CBCEncrypt aes cbc encrypt
+func (s *Service) CBCEncrypt(origData []byte) ([]byte, error) {
+	block, err := aes.NewCipher(s.aesKey)
+	if err != nil {
+		return nil, err
+	}
+	blockSize := block.BlockSize()
+	origData = PKCS5Padding(origData, blockSize)
+	blockMode := cipher.NewCBCEncrypter(block, s.aesKey[:blockSize])
+	crypted := make([]byte, len(origData))
+	blockMode.CryptBlocks(crypted, origData)
+	return crypted, nil
+}
+
+// CBCDecrypt aes cbc decrypt
+func (s *Service) CBCDecrypt(crypted []byte) ([]byte, error) {
+	block, err := aes.NewCipher(s.aesKey)
+	if err != nil {
+		return nil, err
+	}
+	blockSize := block.BlockSize()
+	blockMode := cipher.NewCBCDecrypter(block, s.aesKey[:blockSize])
+	origData := make([]byte, len(crypted))
+	blockMode.CryptBlocks(origData, crypted)
+	origData = PKCS5UnPadding(origData)
+	return origData, nil
+}
+
+// PKCS5Padding padding
+func PKCS5Padding(ciphertext []byte, blockSize int) []byte {
+	padding := blockSize - len(ciphertext)%blockSize
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(ciphertext, padtext...)
+}
+
+// PKCS5UnPadding unpadding
+func PKCS5UnPadding(origData []byte) []byte {
+	length := len(origData)
+	unpadding := int(origData[length-1])
+	return origData[:(length - unpadding)]
+}

app/job/main/passport-user/service/aes_test.go

@@ -0,0 +1,90 @@
+package service
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"fmt"
+	"testing"
+)
+
+var key = []byte("bili_account_enc")
+
+func TestService_cbcEncrypt(t *testing.T) {
+	tel := []byte("18612340123")
+	cipherText, _ := cbcEncrypt(tel)
+	fmt.Println(len(cipherText))
+	fmt.Println(cipherText)
+}
+
+func TestService_cbcDecrypt(t *testing.T) {
+	cipherText := []byte{115, 201, 179, 163, 254, 77, 59, 220, 62, 178, 19, 241, 165, 28, 249, 249}
+	fmt.Println(string(cipherText))
+	tel, _ := cbcDecrypt(cipherText)
+	fmt.Println(string(tel))
+}
+
+func TestService_cfbEncrypt(t *testing.T) {
+	tel := []byte("18612340123")
+	cipherText, _ := cfbEncrypt(tel)
+	fmt.Println(len(cipherText))
+	fmt.Println(cipherText)
+}
+
+func TestService_cfbDecrypt(t *testing.T) {
+	cipherText := []byte{48, 35, 4, 24, 80, 204, 171, 226, 219, 74, 16, 95, 138, 184, 249, 205}
+	fmt.Println(string(cipherText))
+	tel, _ := cfbDecrypt(cipherText)
+	fmt.Println(string(tel))
+}
+
+func cbcEncrypt(origData []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	blockSize := block.BlockSize()
+	origData = PKCS5Padding(origData, blockSize)
+	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
+	crypted := make([]byte, len(origData))
+	blockMode.CryptBlocks(crypted, origData)
+	return crypted, nil
+}
+
+func cbcDecrypt(crypted []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	blockSize := block.BlockSize()
+	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
+	origData := make([]byte, len(crypted))
+	blockMode.CryptBlocks(origData, crypted)
+	origData = PKCS5UnPadding(origData)
+	return origData, nil
+}
+
+func cfbEncrypt(origData []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	blockSize := block.BlockSize()
+	origData = PKCS5Padding(origData, blockSize)
+	cfb := cipher.NewCFBEncrypter(block, key[:blockSize])
+	crypted := make([]byte, len(origData))
+	cfb.XORKeyStream(crypted, origData)
+	return crypted, nil
+}
+
+func cfbDecrypt(crypted []byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	blockSize := block.BlockSize()
+	cfb := cipher.NewCFBDecrypter(block, key[:blockSize])
+	origData := make([]byte, len(crypted))
+	cfb.XORKeyStream(origData, crypted)
+	origData = PKCS5UnPadding(origData)
+	return origData, nil
+}

app/job/main/passport-user/service/aso_full_migration.go

@@ -0,0 +1,263 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/job/main/passport-user/model"
+	"go-common/library/log"
+	"time"
+)
+
+func (s *Service) getAsoAccount(start, end, count int64) {
+	chanNum := int64(s.c.FullSync.AsoAccount.ChanNum)
+	for {
+		log.Info("getAsoAccount, start %d, end %d, count %d", start, end, count)
+		var (
+			res []*model.OriginAccount
+			err error
+		)
+		for {
+			if res, err = s.d.AsoAccount(context.Background(), start, count); err != nil {
+				log.Error("fail to get AsoAccount error(%+v)", err)
+				time.Sleep(100 * time.Millisecond)
+				continue
+			}
+			break
+		}
+		for _, a := range res {
+			s.asoAccountChan[a.Mid%chanNum] <- a
+		}
+		if start > end || len(res) == 0 {
+			log.Info("sync asoAccount finished! endID(%d)", start)
+			break
+		}
+		start = res[len(res)-1].Mid
+	}
+}
+
+func (s *Service) asoAccountConsume(c chan *model.OriginAccount) {
+	for {
+		a, ok := <-c
+		if !ok {
+			log.Error("asoAccountChan closed")
+			return
+		}
+		for i := 0; i < _retry; i++ {
+			if err := s.syncAsoAccount(a); err != nil {
+				log.Error("fail to sync asoAccount(%+v) error(%+v)", a, err)
+				time.Sleep(100 * time.Millisecond)
+				continue
+			}
+			break
+		}
+	}
+}
+
+func (s *Service) getAsoAccountInfo(start, end, count int64) {
+	chanNum := int64(s.c.FullSync.AsoAccountInfo.ChanNum)
+	initStart, initEnd, initCount := start, end, count
+	for i := 0; i < _asoAccountInfoSharding; i++ {
+		start, end, count = initStart, initEnd, initCount
+		for {
+			log.Info("getAsoAccountInfo, start %d, end %d, count %d, suffix %d", start, end, count, i)
+			var (
+				res []*model.OriginAccountInfo
+				err error
+			)
+			for {
+				if res, err = s.d.AsoAccountInfo(context.Background(), start, count, int64(i)); err != nil {
+					log.Error("fail to get AsoAccountInfo error(%+v)", err)
+					time.Sleep(100 * time.Millisecond)
+					continue
+				}
+				break
+			}
+			for _, a := range res {
+				s.asoAccountInfoChan[a.ID%chanNum] <- a
+			}
+			if start > end || len(res) == 0 {
+				log.Info("sync asoAccountInfo(%d) finished! endID(%d)", i, start)
+				break
+			}
+			start = res[len(res)-1].ID
+		}
+	}
+}
+
+func (s *Service) asoAccountInfoConsume(c chan *model.OriginAccountInfo) {
+	for {
+		a, ok := <-c
+		if !ok {
+			log.Error("asoAccountInfoChan closed")
+			return
+		}
+		for {
+			if err := s.syncAsoAccountInfo(a); err != nil {
+				log.Error("fail to sync asoAccountInfo(%+v) error(%+v)", a, err)
+				time.Sleep(100 * time.Millisecond)
+				continue
+			}
+			break
+		}
+	}
+}
+
+func (s *Service) getAsoAccountReg(start, end, count int64) {
+	chanNum := int64(s.c.FullSync.AsoAccountReg.ChanNum)
+	initStart, initEnd, initCount := start, end, count
+	for i := 0; i < _asoAccountRegOriginSharding; i++ {
+		start, end, count = initStart, initEnd, initCount
+		for {
+			log.Info("getAsoAccountReg, start %d, end %d, count %d, suffix %d", start, end, count, i)
+			var (
+				res []*model.OriginAccountReg
+				err error
+			)
+			for {
+				if res, err = s.d.AsoAccountReg(context.Background(), start, count, int64(i)); err != nil {
+					log.Error("fail to get AsoAccountReg error(%+v)", err)
+					time.Sleep(100 * time.Millisecond)
+					continue
+				}
+				break
+			}
+			for _, a := range res {
+				s.asoAccountRegChan[a.ID%chanNum] <- a
+			}
+			if start > end || len(res) == 0 {
+				log.Info("sync asoAccountReg(%d) finished! endID(%d)", i, start)
+				break
+			}
+			start = res[len(res)-1].ID
+		}
+	}
+}
+
+func (s *Service) asoAccountRegConsume(c chan *model.OriginAccountReg) {
+	for {
+		a, ok := <-c
+		if !ok {
+			log.Error("asoAccountRegChan closed")
+			return
+		}
+		for {
+			if err := s.syncAsoAccountReg(a); err != nil {
+				log.Error("fail to sync asoAccountReg(%+v) error(%+v)", a, err)
+				time.Sleep(100 * time.Millisecond)
+				continue
+			}
+			break
+		}
+	}
+}
+
+func (s *Service) getAsoAccountSns(start, end, count int64) {
+	chanNum := int64(s.c.FullSync.AsoAccountReg.ChanNum)
+	for {
+		log.Info("getAsoAccountSns, start %d, end %d, count %d", start, end, count)
+		var (
+			res []*model.OriginAccountSns
+			err error
+		)
+		for {
+			if res, err = s.d.AsoAccountSns(context.Background(), start, count); err != nil {
+				log.Error("fail to get AsoAccountSns error(%+v)", err)
+				time.Sleep(100 * time.Millisecond)
+				continue
+			}
+			break
+		}
+		for _, a := range res {
+			s.asoAccountSnsChan[a.Mid%chanNum] <- a
+		}
+		if start > end || len(res) == 0 {
+			log.Info("sync asoAccountSns finished! endID(%d)", start)
+			break
+		}
+		start = res[len(res)-1].Mid
+	}
+}
+
+func (s *Service) asoAccountSnsConsume(c chan *model.OriginAccountSns) {
+	for {
+		a, ok := <-c
+		if !ok {
+			log.Error("asoAccountSnsChan closed")
+			return
+		}
+		for {
+			if err := s.syncAsoAccountSns(a); err != nil {
+				log.Error("fail to sync asoAccountSns(%+v) error(%+v)", a, err)
+				time.Sleep(100 * time.Millisecond)
+				continue
+			}
+			break
+		}
+	}
+}
+
+func (s *Service) getAsoTelBindLog(start, end, count int64) {
+	chanNum := int64(s.c.FullSync.AsoAccountReg.ChanNum)
+	for {
+		log.Info("getAsoTelBindLog, start %d, end %d, count %d", start, end, count)
+		var (
+			res []*model.UserTel
+			err error
+		)
+		for {
+			if res, err = s.d.UserTel(context.Background(), start, count); err != nil {
+				log.Error("fail to get UserTel error(%+v)", err)
+				time.Sleep(100 * time.Millisecond)
+				continue
+			}
+			break
+		}
+		for _, a := range res {
+			s.asoTelBindLogChan[a.Mid%chanNum] <- a
+		}
+		if start > end || len(res) == 0 {
+			log.Info("sync asoTelBindLog finished! endID(%d)", start)
+			break
+		}
+		start = res[len(res)-1].Mid
+	}
+}
+
+func (s *Service) asoTelBindLogConsume(c chan *model.UserTel) {
+	filterStart := 1536572121
+	filterEnd := 1536616436
+	for {
+		a, ok := <-c
+		if !ok {
+			log.Error("asoTelBindLogChan closed")
+			return
+		}
+		for {
+			var (
+				err         error
+				telBindTime int64
+			)
+			if telBindTime, err = s.d.AsoTelBindLog(context.Background(), a.Mid); err != nil {
+				log.Error("fail to get AsoTelBindLog error(%+v)", err)
+				time.Sleep(100 * time.Millisecond)
+				continue
+			}
+			if telBindTime == 0 {
+				break
+			}
+			if telBindTime > int64(filterStart) && telBindTime < int64(filterEnd) {
+				break
+			}
+			userTel := &model.UserTel{
+				Mid:         a.Mid,
+				TelBindTime: telBindTime,
+			}
+			if _, err = s.d.UpdateUserTelBindTime(context.Background(), userTel); err != nil {
+				log.Error("fail to update tel bind log userTel(%+v) error(%+v)", userTel, err)
+				time.Sleep(100 * time.Millisecond)
+				continue
+			}
+			break
+		}
+	}
+}

app/job/main/passport-user/service/duplicate.go

@@ -0,0 +1,123 @@
+package service
+
+//func (s *Service) updateTelDuplicateJob() {
+//	log.Info("update tel duplicate job start...")
+//	res, err := s.d.UserTelDuplicate(context.Background())
+//	if err != nil {
+//		log.Error("fail to get UserTelDuplicate, error(%+v)", err)
+//		return
+//	}
+//	for _, r := range res {
+//		userTel := &model.UserTel{
+//			Mid: r.Mid,
+//			Tel: r.Tel,
+//			Cid: r.Cid,
+//		}
+//		if _, err = s.d.UpdateUserTel(context.Background(), userTel); err != nil {
+//			log.Error("fail to update user tel userTel(%+v), error(%+v)", userTel, err)
+//			continue
+//		}
+//		log.Info("update userTel by userTelDuplicate success, userTelDuplicate(%+v)", r)
+//		if _, err = s.d.UpdateUserTelDuplicateStatus(context.Background(), r.Mid); err != nil {
+//			log.Error("fail to update user tel duplicate status, mid(%d) error(%+v)", r.Mid, err)
+//		}
+//		log.Info("update userTelDuplicate status success, mid(%d)", r.Mid)
+//	}
+//	log.Info("update tel duplicate job end...")
+//}
+//
+//func (s *Service) updateEmailDuplicateJob() {
+//	log.Info("update email duplicate job start...")
+//	res, err := s.d.UserEmailDuplicate(context.Background())
+//	if err != nil {
+//		log.Error("fail to get UserTelDuplicate, error(%+v)", err)
+//		return
+//	}
+//	for _, r := range res {
+//		userEmail := &model.UserEmail{
+//			Mid:   r.Mid,
+//			Email: r.Email,
+//		}
+//		if _, err = s.d.UpdateUserEmail(context.Background(), userEmail); err != nil {
+//			log.Error("fail to update user email userEmail(%+v), error(%+v)", userEmail, err)
+//			continue
+//		}
+//		log.Info("update userEmail by userEmailDuplicate success, userEmailDuplicate(%+v)", r)
+//		if _, err = s.d.UpdateUserTelDuplicateStatus(context.Background(), r.Mid); err != nil {
+//			log.Error("fail to update user email duplicate status, mid(%d) error(%+v)", r.Mid, err)
+//		}
+//		log.Info("update userEmailDuplicate status success, mid(%d)", r.Mid)
+//	}
+//	log.Info("update email duplicate job end...")
+//}
+
+/**
+func (s *Service) checkTelDuplicateJob() {
+	log.Info("check tel duplicate job start...")
+	res, err := s.d.UserTelDuplicate(context.Background())
+	if err != nil {
+		log.Error("fail to get UserTelDuplicate, error(%+v)", err)
+		return
+	}
+	var (
+		asoAccount *model.OriginAccount
+		userTel    *model.UserTel
+	)
+	for _, r := range res {
+		if asoAccount, err = s.d.GetAsoAccountByMid(context.Background(), r.Mid); err != nil {
+			log.Error("fail to check tel duplicate mid(%d) error(%+v)", r.Mid, err)
+			return
+		}
+		if userTel, err = s.d.GetUserTelByMid(context.Background(), r.Mid); err != nil {
+			log.Error("fail to check tel duplicate mid(%d) error(%+v)", r.Mid, err)
+			return
+		}
+		a := s.convertAccountToUserTel(asoAccount)
+		originHex := hex.EncodeToString(a.Tel)
+		newHex := hex.EncodeToString(userTel.Tel)
+		if originHex == newHex {
+			log.Info("check user tel duplicate success, userTelDuplicate(%+v)", r)
+			if _, err = s.d.UpdateUserTelDuplicateStatus(context.Background(), r.ID); err != nil {
+				log.Error("fail to update user tel duplicate status, id(%d) error(%+v)", r.ID, err)
+			}
+		} else {
+			log.Info("fail to check user tel duplicate, new(%s) origin(%s) userTelDuplicate(%+v)", newHex, originHex, r)
+		}
+	}
+	log.Info("update tel duplicate job end...")
+}
+
+func (s *Service) checkEmailDuplicateJob() {
+	log.Info("check email duplicate job start...")
+	res, err := s.d.UserEmailDuplicate(context.Background())
+	if err != nil {
+		log.Error("fail to get UserEmailDuplicate, error(%+v)", err)
+		return
+	}
+	var (
+		asoAccount *model.OriginAccount
+		userEmail  *model.UserEmail
+	)
+	for _, r := range res {
+		if asoAccount, err = s.d.GetAsoAccountByMid(context.Background(), r.Mid); err != nil {
+			log.Error("fail to check email duplicate mid(%d) error(%+v)", r.Mid, err)
+			return
+		}
+		if userEmail, err = s.d.GetUserEmailByMid(context.Background(), r.Mid); err != nil {
+			log.Error("fail to check email duplicate mid(%d) error(%+v)", r.Mid, err)
+			return
+		}
+		a := s.convertAccountToUserEmail(asoAccount)
+		originHex := hex.EncodeToString(a.Email)
+		newHex := hex.EncodeToString(userEmail.Email)
+		if originHex == newHex {
+			log.Info("check user email duplicate success, userEmailDuplicate(%+v)", r)
+			if _, err = s.d.UpdateUserTelDuplicateStatus(context.Background(), r.ID); err != nil {
+				log.Error("fail to update user email duplicate status, id(%d) error(%+v)", r.ID, err)
+			}
+		} else {
+			log.Info("fail to check user tel duplicate, new(%s) origin(%s) userEmailDuplicate(%+v)", newHex, originHex, r)
+		}
+	}
+	log.Info("update email duplicate job end...")
+}**/

app/job/main/passport-user/service/passport_util.go

@@ -0,0 +1,63 @@
+package service
+
+import (
+	"crypto/md5"
+	"fmt"
+	"math/big"
+	"net"
+)
+
+func (s *Service) doEncrypt(param string) []byte {
+	var (
+		err error
+		res = make([]byte, 0)
+	)
+	if param == "" || len(param) == 0 {
+		return nil
+	}
+	input := []byte(param)
+	if res, err = s.CBCEncrypt(input); err != nil {
+		return input
+	}
+	return res
+}
+
+//func (s *Service) doDecrypt(param []byte) string {
+//	var (
+//		err error
+//		res = make([]byte, 0)
+//	)
+//	if param == nil {
+//		return ""
+//	}
+//	input := []byte(param)
+//	if res, err = s.CBCDecrypt(input); err != nil {
+//		return string(param)
+//	}
+//	return string(res)
+//}
+
+// InetNtoA convert int64 to ip addr .
+func InetNtoA(ip int64) string {
+	return fmt.Sprintf("%d.%d.%d.%d",
+		byte(ip>>24), byte(ip>>16), byte(ip>>8), byte(ip))
+}
+
+// InetAtoN convert ip addr to int64.
+func InetAtoN(ip string) int64 {
+	ret := big.NewInt(0)
+	ret.SetBytes(net.ParseIP(ip).To4())
+	return ret.Int64()
+}
+
+func (s *Service) doHash(plaintext string) []byte {
+	var res = make([]byte, 0)
+	if plaintext == "" {
+		return res
+	}
+	hash := md5.New()
+	hash.Write([]byte(plaintext))
+	hash.Write([]byte(s.salt))
+	res = hash.Sum(nil)
+	return res
+}

app/job/main/passport-user/service/service.go

@@ -0,0 +1,176 @@
+package service
+
+import (
+	"context"
+
+	"go-common/app/job/main/passport-user/conf"
+	"go-common/app/job/main/passport-user/dao"
+	"go-common/app/job/main/passport-user/model"
+	"go-common/library/log"
+	"go-common/library/queue/databus"
+	"go-common/library/queue/databus/databusutil"
+)
+
+const (
+	_asoAccountTable             = "aso_account"
+	_asoAccountInfoTable         = "aso_account_info"
+	_asoAccountSnsTable          = "aso_account_sns"
+	_asoAccountRegOriginTable    = "aso_account_reg_origin"
+	_insertAction                = "insert"
+	_updateAction                = "update"
+	_deleteAction                = "delete"
+	_asoAccountInfoSharding      = 30
+	_asoAccountRegOriginSharding = 20
+	_mySQLErrCodeDuplicateEntry  = 1062
+	_retry                       = 3
+)
+
+// Service service.
+type Service struct {
+	c *conf.Config
+	d *dao.Dao
+	// aso binlog consumer
+	asoBinLogConsumer *databus.Databus
+	group             *databusutil.Group
+	// fullSync chan
+	asoAccountChan     []chan *model.OriginAccount
+	asoAccountInfoChan []chan *model.OriginAccountInfo
+	asoAccountRegChan  []chan *model.OriginAccountReg
+	asoAccountSnsChan  []chan *model.OriginAccountSns
+	asoTelBindLogChan  []chan *model.UserTel
+
+	countryMap map[int64]string
+	aesKey     []byte
+	salt       []byte
+	//cron       *cron.Cron
+
+	ch chan func()
+}
+
+// New new a service instance.
+func New(c *conf.Config) (s *Service) {
+	s = &Service{
+		c:                  c,
+		d:                  dao.New(c),
+		asoAccountChan:     make([]chan *model.OriginAccount, c.FullSync.AsoAccount.ChanNum),
+		asoAccountInfoChan: make([]chan *model.OriginAccountInfo, c.FullSync.AsoAccountInfo.ChanNum),
+		asoAccountRegChan:  make([]chan *model.OriginAccountReg, c.FullSync.AsoAccountReg.ChanNum),
+		asoAccountSnsChan:  make([]chan *model.OriginAccountSns, c.FullSync.AsoAccountSns.ChanNum),
+		asoTelBindLogChan:  make([]chan *model.UserTel, c.FullSync.AsoTelBindLog.ChanNum),
+		ch:                 make(chan func(), 1024000),
+	}
+	go s.cacheproc()
+	if c.FullSync.AsoCountryCodeSwitch {
+		err := s.syncAsoCountryCode()
+		if err != nil {
+			log.Error("fail to sync AsoCountryCode")
+			panic(err)
+		}
+	}
+	aesKey, err := s.d.AesKey(context.Background())
+	if err != nil || aesKey == "" {
+		log.Error("fail to get rsaKey")
+		panic(err)
+	}
+	s.aesKey = []byte(aesKey)
+	salt, err := s.d.Salt(context.Background())
+	if err != nil || salt == "" {
+		log.Error("fail to get salt")
+		panic(err)
+	}
+	s.salt = []byte(salt)
+	s.countryMap, err = s.d.CountryCodeMap(context.Background())
+	if err != nil || len(s.countryMap) == 0 {
+		log.Error("fail to get country map")
+		panic(err)
+	}
+	if c.FullSync.AsoAccount.Switch {
+		for i := 0; i < c.FullSync.AsoAccount.ChanNum; i++ {
+			ch := make(chan *model.OriginAccount, c.FullSync.AsoAccount.ChanSize)
+			s.asoAccountChan[i] = ch
+			go s.asoAccountConsume(ch)
+		}
+		go s.getAsoAccount(c.FullSync.AsoAccount.Start, c.FullSync.AsoAccount.End, c.FullSync.AsoAccount.Count)
+	}
+	if c.FullSync.AsoAccountInfo.Switch {
+		for i := 0; i < c.FullSync.AsoAccountInfo.ChanNum; i++ {
+			ch := make(chan *model.OriginAccountInfo, c.FullSync.AsoAccountInfo.ChanSize)
+			s.asoAccountInfoChan[i] = ch
+			go s.asoAccountInfoConsume(ch)
+		}
+		go s.getAsoAccountInfo(c.FullSync.AsoAccountInfo.Start, c.FullSync.AsoAccountInfo.End, c.FullSync.AsoAccountInfo.Count)
+	}
+	if c.FullSync.AsoAccountReg.Switch {
+		for i := 0; i < c.FullSync.AsoAccountReg.ChanNum; i++ {
+			ch := make(chan *model.OriginAccountReg, c.FullSync.AsoAccountReg.ChanSize)
+			s.asoAccountRegChan[i] = ch
+			go s.asoAccountRegConsume(ch)
+		}
+		go s.getAsoAccountReg(c.FullSync.AsoAccountReg.Start, c.FullSync.AsoAccountReg.End, c.FullSync.AsoAccountReg.Count)
+	}
+	if c.FullSync.AsoAccountSns.Switch {
+		for i := 0; i < c.FullSync.AsoAccountSns.ChanNum; i++ {
+			ch := make(chan *model.OriginAccountSns, c.FullSync.AsoAccountSns.ChanSize)
+			s.asoAccountSnsChan[i] = ch
+			go s.asoAccountSnsConsume(ch)
+		}
+		go s.getAsoAccountSns(c.FullSync.AsoAccountSns.Start, c.FullSync.AsoAccountSns.End, c.FullSync.AsoAccountSns.Count)
+	}
+	if c.FullSync.AsoTelBindLog.Switch {
+		for i := 0; i < c.FullSync.AsoTelBindLog.ChanNum; i++ {
+			ch := make(chan *model.UserTel, c.FullSync.AsoTelBindLog.ChanSize)
+			s.asoTelBindLogChan[i] = ch
+			go s.asoTelBindLogConsume(ch)
+		}
+		go s.getAsoTelBindLog(c.FullSync.AsoTelBindLog.Start, c.FullSync.AsoTelBindLog.End, c.FullSync.AsoTelBindLog.Count)
+	}
+	if c.IncSync.Switch {
+		s.asoBinLogConsumer = databus.New(c.DataBus.AsoBinLogSub)
+		s.group = databusutil.NewGroup(
+			c.DatabusUtil,
+			s.asoBinLogConsumer.Messages(),
+		)
+		s.consumeproc()
+	}
+	//if c.Scheduler.Switch {
+	//	s.cron = cron.New()
+	//	if err := s.cron.AddFunc(c.Scheduler.EmailDuplicateCron, s.checkEmailDuplicateJob); err != nil {
+	//		panic(err)
+	//	}
+	//	if err := s.cron.AddFunc(c.Scheduler.TelDuplicateCron, s.checkTelDuplicateJob); err != nil {
+	//		panic(err)
+	//	}
+	//	s.cron.Start()
+	//}
+	return
+}
+
+// Ping check server ok.
+func (s *Service) Ping(c context.Context) (err error) {
+	return s.d.Ping(c)
+}
+
+// Close close service, including databus and outer service.
+func (s *Service) Close() (err error) {
+	if err = s.group.Close(); err != nil {
+		log.Error("s.group.Close() error(%v)", err)
+	}
+	s.d.Close()
+	return
+}
+
+func (s *Service) addCache(f func()) {
+	select {
+	case s.ch <- f:
+	default:
+		log.Warn("cacheproc chan full")
+	}
+}
+
+// cacheproc is a routine for executing closure.
+func (s *Service) cacheproc() {
+	for {
+		f := <-s.ch
+		f()
+	}
+}

app/job/main/passport-user/service/user.go

@@ -0,0 +1,294 @@
+package service
+
+import (
+	"context"
+	"encoding/hex"
+	"strconv"
+	"time"
+
+	"go-common/app/job/main/passport-user/model"
+	"go-common/library/database/sql"
+	"go-common/library/log"
+)
+
+const (
+	_platformSINA = 1
+	_platformQQ   = 2
+)
+
+func (s *Service) convertAccountToUserBase(a *model.OriginAccount) (res *model.UserBase, err error) {
+	pwdBytes, err := hex.DecodeString(a.Pwd)
+	if err != nil {
+		log.Error("fail to hex decode pwd(%+v) error(%+v)", a.Pwd, err)
+		return
+	}
+	res = &model.UserBase{
+		Mid:     a.Mid,
+		UserID:  a.UserID,
+		Pwd:     pwdBytes,
+		Salt:    a.Salt,
+		Status:  a.Isleak,
+		Deleted: 0,
+		MTime:   a.MTime,
+	}
+	return
+}
+
+func (s *Service) convertAccountToUserEmail(a *model.OriginAccount) (res *model.UserEmail) {
+	if a.Email == "" {
+		res = &model.UserEmail{
+			Mid:           a.Mid,
+			EmailBindTime: time.Now().Unix(),
+			MTime:         a.MTime,
+		}
+		return
+	}
+	res = &model.UserEmail{
+		Mid:           a.Mid,
+		Email:         s.doEncrypt(a.Email),
+		EmailBindTime: time.Now().Unix(),
+		MTime:         a.MTime,
+	}
+	return
+}
+
+func (s *Service) convertAccountToUserTel(a *model.OriginAccount) (res *model.UserTel) {
+	if a.Tel == "" {
+		res = &model.UserTel{
+			Mid:         a.Mid,
+			TelBindTime: time.Now().Unix(),
+			MTime:       a.MTime,
+		}
+		return
+	}
+	res = &model.UserTel{
+		Mid:         a.Mid,
+		Tel:         s.doEncrypt(a.Tel),
+		Cid:         s.countryMap[a.CountryID],
+		TelBindTime: time.Now().Unix(),
+		MTime:       a.MTime,
+	}
+	return
+}
+
+func (s *Service) convertAccountInfoToUserSafeQuestion(a *model.OriginAccountInfo) (res *model.UserSafeQuestion) {
+	res = &model.UserSafeQuestion{
+		Mid:          a.Mid,
+		SafeQuestion: a.SafeQuestion,
+		SafeAnswer:   s.doHash(a.SafeAnswer),
+		SafeBindTime: time.Now().Unix(),
+	}
+	return
+}
+
+func (s *Service) convertAccountInfoToUserRegOrigin(a *model.OriginAccountInfo) (res *model.UserRegOrigin) {
+	res = &model.UserRegOrigin{
+		Mid:      a.Mid,
+		JoinIP:   InetAtoN(a.JoinIP),
+		JoinIPV6: a.JoinIPV6,
+		JoinTime: a.JoinTime,
+	}
+	return
+}
+
+func (s *Service) convertAccountInfoToUserEmail(a *model.OriginAccountInfo) (res *model.UserEmail) {
+	var (
+		verified   int32
+		activeTime int64
+	)
+	if a.Spacesta >= 0 {
+		verified = 1
+		activeTime = a.ActiveTime
+	}
+	res = &model.UserEmail{
+		Mid:           a.Mid,
+		Verified:      verified,
+		EmailBindTime: activeTime,
+	}
+	return
+}
+
+func (s *Service) convertAccountRegToUserRegOrigin(a *model.OriginAccountReg) (res *model.UserRegOrigin) {
+	res = &model.UserRegOrigin{
+		Mid:     a.Mid,
+		Origin:  a.OriginType,
+		RegType: a.RegType,
+		AppID:   a.AppID,
+		CTime:   a.MTime,
+		MTime:   a.CTime,
+	}
+	return
+}
+
+func (s *Service) convertAccountSnsToUserThirdBindQQ(a *model.OriginAccountSns) (res *model.UserThirdBind) {
+	res = &model.UserThirdBind{
+		Mid:      a.Mid,
+		OpenID:   a.QQOpenid,
+		PlatForm: _platformQQ,
+		Token:    a.QQAccessToken,
+		Expires:  a.QQAccessExpires,
+	}
+	return
+}
+
+func (s *Service) convertAccountSnsToUserThirdBindSina(a *model.OriginAccountSns) (res *model.UserThirdBind) {
+	res = &model.UserThirdBind{
+		Mid:      a.Mid,
+		OpenID:   strconv.FormatInt(a.SinaUID, 10),
+		PlatForm: _platformSINA,
+		Token:    a.SinaAccessToken,
+		Expires:  a.SinaAccessExpires,
+	}
+	return
+}
+
+func (s *Service) syncAsoAccount(a *model.OriginAccount) (err error) {
+	var (
+		tx       *sql.Tx
+		userBase *model.UserBase
+	)
+	userBase, err = s.convertAccountToUserBase(a)
+	if err != nil {
+		log.Error("fail to convert AsoAccount(%+v) to UserBase error(%+v)", a, err)
+		return
+	}
+	tx, err = s.d.BeginTran(context.Background())
+	if err != nil {
+		log.Error("s.dao.Begin error(%+v)", err)
+		return
+	}
+	if _, err = s.d.TxAddUserBase(tx, userBase); err != nil {
+		log.Error("fail to add UserBase(%+v) error(%+v)", userBase, err)
+		tx.Rollback()
+		return
+	}
+	if a.Email != "" {
+		userEmail := s.convertAccountToUserEmail(a)
+		userEmail.EmailBindTime = 0
+		if _, err = s.d.TxAddUserEmail(tx, userEmail); err != nil {
+			log.Error("fail to add userEmail(%+v) error(%+v)", userEmail, err)
+			tx.Rollback()
+			return
+		}
+	}
+	if a.Tel != "" {
+		userTel := s.convertAccountToUserTel(a)
+		userTel.TelBindTime = 0
+		if _, err = s.d.TxAddUserTel(tx, userTel); err != nil {
+			log.Error("fail to add userTel(%+v) error(%+v)", userTel, err)
+			tx.Rollback()
+			return
+		}
+	}
+	if err = tx.Commit(); err != nil {
+		log.Error("tx.Commit(), error(%v)", err)
+		return
+	}
+	return
+}
+
+func (s *Service) syncAsoAccountInfo(a *model.OriginAccountInfo) (err error) {
+	var (
+		tx               *sql.Tx
+		userSafeQuestion *model.UserSafeQuestion
+		userRegOrigin    *model.UserRegOrigin
+		userEmail        *model.UserEmail
+	)
+	userRegOrigin = s.convertAccountInfoToUserRegOrigin(a)
+	userEmail = s.convertAccountInfoToUserEmail(a)
+	tx, err = s.d.BeginTran(context.Background())
+	if err != nil {
+		log.Error("s.dao.Begin error(%+v)", err)
+		return
+	}
+	if a.SafeQuestion != 0 || a.SafeAnswer != "" {
+		userSafeQuestion = s.convertAccountInfoToUserSafeQuestion(a)
+		userSafeQuestion.SafeBindTime = 0
+		if _, err = s.d.TxInsertIgnoreUserSafeQuestion(tx, userSafeQuestion); err != nil {
+			tx.Rollback()
+			return
+		}
+	}
+	if _, err = s.d.TxInsertIgnoreUserRegOrigin(tx, userRegOrigin); err != nil {
+		tx.Rollback()
+		return
+	}
+	if err = tx.Commit(); err != nil {
+		log.Error("tx.Commit(), error(%v)", err)
+		return
+	}
+	if _, err = s.d.UpdateUserEmailBindTime(context.Background(), userEmail); err != nil {
+		tx.Rollback()
+		return
+	}
+	return
+}
+
+func (s *Service) syncAsoAccountReg(a *model.OriginAccountReg) (err error) {
+	userRegOrigin := s.convertAccountRegToUserRegOrigin(a)
+	if _, err = s.d.InsertUpdateUserRegOriginType(context.Background(), userRegOrigin); err != nil {
+		log.Error("fail to insert update reg origin type userRegOrigin(%+v) error(%+v)", userRegOrigin, err)
+	}
+	return
+}
+
+func (s *Service) syncAsoAccountSns(a *model.OriginAccountSns) (err error) {
+	var (
+		tx   *sql.Tx
+		qq   *model.UserThirdBind
+		sina *model.UserThirdBind
+		utb  *model.UserThirdBind
+	)
+	sina = s.convertAccountSnsToUserThirdBindSina(a)
+	qq = s.convertAccountSnsToUserThirdBindQQ(a)
+	tx, err = s.d.BeginTran(context.Background())
+	if err != nil {
+		log.Error("s.dao.Begin error(%+v)", err)
+		return
+	}
+	if a.QQOpenid != "" {
+		if utb, err = s.d.GetUserThirdBindByMidAndPlatform(context.Background(), a.Mid, _platformQQ); err != nil {
+			return
+		}
+		if utb == nil {
+			if _, err = s.d.TxAddUserThirdBind(tx, qq); err != nil {
+				log.Error("fail to add third bind qq userThirdBind(%+v) error(%+v)", qq, err)
+				tx.Rollback()
+				return
+			}
+		} else {
+			log.Error("third bind qq is exist, userThirdBind(%+v)", utb)
+		}
+	}
+	if a.SinaUID != 0 {
+		if utb, err = s.d.GetUserThirdBindByMidAndPlatform(context.Background(), a.Mid, _platformSINA); err != nil {
+			return
+		}
+		if utb == nil {
+			if _, err = s.d.TxAddUserThirdBind(tx, sina); err != nil {
+				log.Error("fail to add third bind sina userThirdBind(%+v) error(%+v)", sina, err)
+				tx.Rollback()
+				return
+			}
+		} else {
+			log.Error("third bind weibo is exist, userThirdBind(%+v)", utb)
+		}
+	}
+	if err = tx.Commit(); err != nil {
+		log.Error("tx.Commit(), error(%v)", err)
+		return
+	}
+	return
+}
+
+func (s *Service) syncAsoCountryCode() (err error) {
+	res, err := s.d.AsoCountryCode(context.Background())
+	if err != nil {
+		log.Error("fail to get country code error(%+v)", err)
+		return
+	}
+	for _, r := range res {
+		s.d.AddCountryCode(context.Background(), r)
+	}
+	return
+}