格式化代码

dispatch/app/app.go

@@ -18,7 +18,7 @@ func Run(ctx context.Context, configFile string) error {
 	config.InitConfig(configFile)
 
 	logger.InitLogger("dispatch")
-	logger.LOG.Info("dispatch start")
+	logger.Warn("dispatch start")
 
 	db := dao.NewDao()
 	defer db.CloseDao()
@@ -32,10 +32,10 @@ func Run(ctx context.Context, configFile string) error {
 		case <-ctx.Done():
 			return nil
 		case s := <-c:
-			logger.LOG.Info("get a signal %s", s.String())
+			logger.Warn("get a signal %s", s.String())
 			switch s {
 			case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
-				logger.LOG.Info("dispatch exit")
+				logger.Warn("dispatch exit")
 
 				time.Sleep(time.Second)
 				return nil

dispatch/controller/controller.go

@@ -2,7 +2,6 @@ package controller
 
 import (
 	"encoding/base64"
-	"hk4e/pkg/random"
 	"net/http"
 	"strconv"
 
@@ -10,6 +9,7 @@ import (
 	"hk4e/common/region"
 	"hk4e/dispatch/dao"
 	"hk4e/pkg/logger"
+	"hk4e/pkg/random"
 
 	"github.com/gin-gonic/gin"
 	pb "google.golang.org/protobuf/proto"
@@ -35,13 +35,13 @@ func NewController(dao *dao.Dao) (r *Controller) {
 	r.signRsaKey, r.encRsaKeyMap, r.pwdRsaKey = region.LoadRsaKey()
 	regionCurrModify, err := pb.Marshal(regionCurr)
 	if err != nil {
-		logger.LOG.Error("Marshal QueryCurrRegionHttpRsp error")
+		logger.Error("Marshal QueryCurrRegionHttpRsp error")
 		return nil
 	}
 	r.regionCurrBase64 = base64.StdEncoding.EncodeToString(regionCurrModify)
 	regionListModify, err := pb.Marshal(regionList)
 	if err != nil {
-		logger.LOG.Error("Marshal QueryRegionListHttpRsp error")
+		logger.Error("Marshal QueryRegionListHttpRsp error")
 		return nil
 	}
 	r.regionListBase64 = base64.StdEncoding.EncodeToString(regionListModify)
@@ -75,7 +75,7 @@ func (c *Controller) registerRouter() {
 	{
 		// 404
 		engine.NoRoute(func(context *gin.Context) {
-			logger.LOG.Info("no route find, fallback to fuck mhy, url: %v", context.Request.RequestURI)
+			logger.Info("no route find, fallback to fuck mhy, url: %v", context.Request.RequestURI)
 			context.Header("Content-type", "text/html; charset=UTF-8")
 			context.Status(http.StatusNotFound)
 			_, _ = context.Writer.WriteString("FUCK MHY")
@@ -148,6 +148,6 @@ func (c *Controller) registerRouter() {
 	addr := ":" + strconv.Itoa(int(port))
 	err := engine.Run(addr)
 	if err != nil {
-		logger.LOG.Error("gin run error: %v", err)
+		logger.Error("gin run error: %v", err)
 	}
 }

dispatch/controller/dispatch_controller.go

@@ -19,7 +19,7 @@ import (
 func (c *Controller) query_security_file(context *gin.Context) {
 	file, err := os.ReadFile("static/security_file")
 	if err != nil {
-		logger.LOG.Error("open security_file error")
+		logger.Error("open security_file error")
 		return
 	}
 	context.Header("Content-type", "text/html; charset=UTF-8")
@@ -39,7 +39,7 @@ func (c *Controller) query_cur_region(context *gin.Context) {
 	}
 	reg, err := regexp.Compile("[0-9]+")
 	if err != nil {
-		logger.LOG.Error("compile regexp error: %v", err)
+		logger.Error("compile regexp error: %v", err)
 		return
 	}
 	versionSlice := reg.FindAllString(versionName, -1)
@@ -47,7 +47,7 @@ func (c *Controller) query_cur_region(context *gin.Context) {
 	for index := 0; index < len(versionSlice); index++ {
 		v, err := strconv.Atoi(versionSlice[index])
 		if err != nil {
-			logger.LOG.Error("parse client version error: %v", err)
+			logger.Error("parse client version error: %v", err)
 			return
 		}
 		for i := 0; i < len(versionSlice)-1-index; i++ {
@@ -60,7 +60,7 @@ func (c *Controller) query_cur_region(context *gin.Context) {
 		version /= 10
 	}
 	if version >= 275 {
-		logger.LOG.Debug("do hk4e 2.8 rsa logic")
+		logger.Debug("do hk4e 2.8 rsa logic")
 		if context.Query("dispatchSeed") == "" {
 			rsp := &api.QueryCurRegionRspJson{
 				Content: response,
@@ -72,12 +72,12 @@ func (c *Controller) query_cur_region(context *gin.Context) {
 		keyId := context.Query("key_id")
 		encPubPrivKey, exist := c.encRsaKeyMap[keyId]
 		if !exist {
-			logger.LOG.Error("can not found key id: %v", keyId)
+			logger.Error("can not found key id: %v", keyId)
 			return
 		}
 		regionInfo, err := base64.StdEncoding.DecodeString(response)
 		if err != nil {
-			logger.LOG.Error("decode region info error: %v", err)
+			logger.Error("decode region info error: %v", err)
 			return
 		}
 		chunkSize := 256 - 11
@@ -90,47 +90,47 @@ func (c *Controller) query_cur_region(context *gin.Context) {
 			chunk := regionInfo[from:to]
 			pubKey, err := endec.RsaParsePubKeyByPrivKey(encPubPrivKey)
 			if err != nil {
-				logger.LOG.Error("parse rsa pub key error: %v", err)
+				logger.Error("parse rsa pub key error: %v", err)
 				return
 			}
 			privKey, err := endec.RsaParsePrivKey(encPubPrivKey)
 			if err != nil {
-				logger.LOG.Error("parse rsa priv key error: %v", err)
+				logger.Error("parse rsa priv key error: %v", err)
 				return
 			}
 			encrypt, err := endec.RsaEncrypt(chunk, pubKey)
 			if err != nil {
-				logger.LOG.Error("rsa enc error: %v", err)
+				logger.Error("rsa enc error: %v", err)
 				return
 			}
 			decrypt, err := endec.RsaDecrypt(encrypt, privKey)
 			if err != nil {
-				logger.LOG.Error("rsa dec error: %v", err)
+				logger.Error("rsa dec error: %v", err)
 				return
 			}
 			if bytes.Compare(decrypt, chunk) != 0 {
-				logger.LOG.Error("rsa dec test fail")
+				logger.Error("rsa dec test fail")
 				return
 			}
 			encryptedRegionInfo = append(encryptedRegionInfo, encrypt...)
 		}
 		signPrivkey, err := endec.RsaParsePrivKey(c.signRsaKey)
 		if err != nil {
-			logger.LOG.Error("parse rsa priv key error: %v", err)
+			logger.Error("parse rsa priv key error: %v", err)
 			return
 		}
 		signData, err := endec.RsaSign(regionInfo, signPrivkey)
 		if err != nil {
-			logger.LOG.Error("rsa sign error: %v", err)
+			logger.Error("rsa sign error: %v", err)
 			return
 		}
 		ok, err := endec.RsaVerify(regionInfo, signData, &signPrivkey.PublicKey)
 		if err != nil {
-			logger.LOG.Error("rsa verify error: %v", err)
+			logger.Error("rsa verify error: %v", err)
 			return
 		}
 		if !ok {
-			logger.LOG.Error("rsa verify test fail")
+			logger.Error("rsa verify test fail")
 			return
 		}
 		rsp := &api.QueryCurRegionRspJson{

dispatch/controller/fixed_controller.go

@@ -195,7 +195,7 @@ func (c *Controller) webp(context *gin.Context) {
 	context.Header("Content-type", "image/webp")
 	file, err := os.ReadFile("static/a330cf996.webp")
 	if err != nil {
-		logger.LOG.Error("open a330cf996.webp error")
+		logger.Error("open a330cf996.webp error")
 		return
 	}
 	_, _ = context.Writer.Write(file)
@@ -206,7 +206,7 @@ func (c *Controller) bgWebp(context *gin.Context) {
 	context.Header("Content-type", "image/webp")
 	file, err := os.ReadFile("static/86f9db021.webp")
 	if err != nil {
-		logger.LOG.Error("open 86f9db021.webp error")
+		logger.Error("open 86f9db021.webp error")
 		return
 	}
 	_, _ = context.Writer.Write(file)
@@ -217,7 +217,7 @@ func (c *Controller) slicePng(context *gin.Context) {
 	context.Header("Content-type", "image/png")
 	file, err := os.ReadFile("static/86f9db021.png")
 	if err != nil {
-		logger.LOG.Error("open 86f9db021.png error")
+		logger.Error("open 86f9db021.png error")
 		return
 	}
 	_, _ = context.Writer.Write(file)
@@ -228,7 +228,7 @@ func (c *Controller) sprite2xPng(context *gin.Context) {
 	context.Header("Content-type", "image/png")
 	file, err := os.ReadFile("static/sprite2x.1.2.6.png")
 	if err != nil {
-		logger.LOG.Error("open sprite2x.1.2.6.png error")
+		logger.Error("open sprite2x.1.2.6.png error")
 		return
 	}
 	_, _ = context.Writer.Write(file)

dispatch/controller/gate_controller.go

@@ -1,10 +1,12 @@
 package controller
 
 import (
-	"github.com/gin-gonic/gin"
-	"hk4e/pkg/logger"
 	"net/http"
 	"strconv"
+
+	"hk4e/pkg/logger"
+
+	"github.com/gin-gonic/gin"
 )
 
 type TokenVerifyReq struct {
@@ -25,7 +27,7 @@ func (c *Controller) gateTokenVerify(context *gin.Context) {
 	if err != nil {
 		return
 	}
-	logger.LOG.Debug("gate token verify, req: %v", tokenVerifyReq)
+	logger.Debug("gate token verify, req: %v", tokenVerifyReq)
 	accountId, err := strconv.ParseUint(tokenVerifyReq.AccountId, 10, 64)
 	if err != nil {
 		return

dispatch/controller/login_controller.go

@@ -3,13 +3,13 @@ package controller
 import (
 	"encoding/base64"
 	"encoding/json"
-	"hk4e/dispatch/model"
 	"net/http"
 	"regexp"
 	"strconv"
 	"strings"
 
 	"hk4e/dispatch/api"
+	"hk4e/dispatch/model"
 	"hk4e/pkg/endec"
 	"hk4e/pkg/logger"
 	"hk4e/pkg/random"
@@ -21,28 +21,28 @@ func (c *Controller) apiLogin(context *gin.Context) {
 	requestData := new(api.LoginAccountRequestJson)
 	err := context.ShouldBindJSON(requestData)
 	if err != nil {
-		logger.LOG.Error("parse LoginAccountRequestJson error: %v", err)
+		logger.Error("parse LoginAccountRequestJson error: %v", err)
 		return
 	}
 
 	encPwdData, err := base64.StdEncoding.DecodeString(requestData.Password)
 	if err != nil {
-		logger.LOG.Error("decode password enc data error: %v", err)
+		logger.Error("decode password enc data error: %v", err)
 		return
 	}
 	pwdPrivKey, err := endec.RsaParsePrivKey(c.pwdRsaKey)
 	if err != nil {
-		logger.LOG.Error("parse rsa key error: %v", err)
+		logger.Error("parse rsa key error: %v", err)
 		return
 	}
 	pwdDecData, err := endec.RsaDecrypt(encPwdData, pwdPrivKey)
 	useAtAtMode := false
 	if err != nil {
-		logger.LOG.Debug("rsa dec error: %v", err)
-		logger.LOG.Debug("password rsa dec fail, fallback to @@ mode")
+		logger.Debug("rsa dec error: %v", err)
+		logger.Debug("password rsa dec fail, fallback to @@ mode")
 		useAtAtMode = true
 	} else {
-		logger.LOG.Debug("password dec: %v", string(pwdDecData))
+		logger.Debug("password dec: %v", string(pwdDecData))
 		useAtAtMode = false
 	}
 
@@ -94,7 +94,7 @@ func (c *Controller) apiLogin(context *gin.Context) {
 	// TODO SDK账号登陆
 	account, err := c.dao.QueryAccountByField("username", username)
 	if err != nil {
-		logger.LOG.Error("query account from db error: %v", err)
+		logger.Error("query account from db error: %v", err)
 		return
 	}
 	if account == nil {
@@ -158,17 +158,17 @@ func (c *Controller) apiVerify(context *gin.Context) {
 	requestData := new(api.LoginTokenRequest)
 	err := context.ShouldBindJSON(requestData)
 	if err != nil {
-		logger.LOG.Error("parse LoginTokenRequest error: %v", err)
+		logger.Error("parse LoginTokenRequest error: %v", err)
 		return
 	}
 	uid, err := strconv.ParseInt(requestData.Uid, 10, 64)
 	if err != nil {
-		logger.LOG.Error("parse uid error: %v", err)
+		logger.Error("parse uid error: %v", err)
 		return
 	}
 	account, err := c.dao.QueryAccountByField("accountID", uid)
 	if err != nil {
-		logger.LOG.Error("query account from db error: %v", err)
+		logger.Error("query account from db error: %v", err)
 		return
 	}
 	responseData := api.NewLoginResult()
@@ -189,23 +189,23 @@ func (c *Controller) v2Login(context *gin.Context) {
 	requestData := new(api.ComboTokenReq)
 	err := context.ShouldBindJSON(requestData)
 	if err != nil {
-		logger.LOG.Error("parse ComboTokenReq error: %v", err)
+		logger.Error("parse ComboTokenReq error: %v", err)
 		return
 	}
 	data := requestData.Data
 	if len(data) == 0 {
-		logger.LOG.Error("requestData.Data len == 0")
+		logger.Error("requestData.Data len == 0")
 		return
 	}
 	loginData := new(api.LoginTokenData)
 	err = json.Unmarshal([]byte(data), loginData)
 	if err != nil {
-		logger.LOG.Error("Unmarshal LoginTokenData error: %v", err)
+		logger.Error("Unmarshal LoginTokenData error: %v", err)
 		return
 	}
 	uid, err := strconv.ParseInt(loginData.Uid, 10, 64)
 	if err != nil {
-		logger.LOG.Error("ParseInt uid error: %v", err)
+		logger.Error("ParseInt uid error: %v", err)
 		return
 	}
 	responseData := api.NewComboTokenRes()

dispatch/dao/account_dao.go

@@ -2,8 +2,8 @@ package dao
 
 import (
 	"context"
-	"hk4e/dispatch/model"
 
+	"hk4e/dispatch/model"
 	"hk4e/pkg/logger"
 
 	"github.com/pkg/errors"
@@ -96,7 +96,7 @@ func (d *Dao) InsertAccount(account *model.Account) (primitive.ObjectID, error)
 	} else {
 		_id, ok := id.InsertedID.(primitive.ObjectID)
 		if !ok {
-			logger.LOG.Error("get insert id error")
+			logger.Error("get insert id error")
 			return primitive.ObjectID{}, nil
 		}
 		return _id, nil

dispatch/dao/dao.go

@@ -20,7 +20,7 @@ func NewDao() (r *Dao) {
 	clientOptions := options.Client().ApplyURI(config.CONF.Database.Url)
 	client, err := mongo.Connect(context.TODO(), clientOptions)
 	if err != nil {
-		logger.LOG.Error("mongo connect error: %v", err)
+		logger.Error("mongo connect error: %v", err)
 		return nil
 	}
 	r.client = client
@@ -31,6 +31,6 @@ func NewDao() (r *Dao) {
 func (d *Dao) CloseDao() {
 	err := d.client.Disconnect(context.TODO())
 	if err != nil {
-		logger.LOG.Error("mongo close error: %v", err)
+		logger.Error("mongo close error: %v", err)
 	}
 }

dispatch/service/service.go

@@ -23,15 +23,15 @@ func (f *Service) UserPasswordChange(uid uint32) bool {
 	if account == nil {
 		return false
 	}
-	//convId, exist := f.getConvIdByUserId(uint32(account.PlayerID))
-	//if !exist {
+	// convId, exist := f.getConvIdByUserId(uint32(account.PlayerID))
+	// if !exist {
 	//	return true
-	//}
-	//f.kcpEventInput <- &net.KcpEvent{
+	// }
+	// f.kcpEventInput <- &net.KcpEvent{
 	//	ConvId:       convId,
 	//	EventId:      net.KcpConnForceClose,
 	//	EventMessage: uint32(kcp.EnetAccountPasswordChange),
-	//}
+	// }
 	return true
 }
 
@@ -57,15 +57,15 @@ func (f *Service) ForbidUser(info *ForbidUserInfo) bool {
 	if account == nil {
 		return false
 	}
-	//convId, exist := f.getConvIdByUserId(uint32(account.PlayerID))
-	//if !exist {
+	// convId, exist := f.getConvIdByUserId(uint32(account.PlayerID))
+	// if !exist {
 	//	return true
-	//}
-	//f.kcpEventInput <- &net.KcpEvent{
+	// }
+	// f.kcpEventInput <- &net.KcpEvent{
 	//	ConvId:       convId,
 	//	EventId:      net.KcpConnForceClose,
 	//	EventMessage: uint32(kcp.EnetServerKillClient),
-	//}
+	// }
 	return true
 }