格式化代码

gate/app/app.go

@@ -19,7 +19,7 @@ func Run(ctx context.Context, configFile string) error {
 	config.InitConfig(configFile)
 
 	logger.InitLogger("gate")
-	logger.LOG.Info("gate start")
+	logger.Warn("gate start")
 
 	netMsgInput := make(chan *cmd.NetMsg, 10000)
 	netMsgOutput := make(chan *cmd.NetMsg, 10000)
@@ -45,10 +45,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("gate exit")
+				logger.Warn("gate exit")
 				time.Sleep(time.Second)
 				return nil
 			case syscall.SIGHUP:

gate/kcp/crypt.go

@@ -9,7 +9,6 @@ import (
 
 	xor "github.com/templexxx/xorsimd"
 	"github.com/tjfoc/gmsm/sm4"
-
 	"golang.org/x/crypto/blowfish"
 	"golang.org/x/crypto/cast5"
 	"golang.org/x/crypto/pbkdf2"

gate/kcp/entropy.go

@@ -36,7 +36,7 @@ type nonceAES128 struct {
 }
 
 func (n *nonceAES128) Init() {
-	var key [16]byte //aes-128
+	var key [16]byte // aes-128
 	io.ReadFull(rand.Reader, key[:])
 	io.ReadFull(rand.Reader, n.seed[:])
 	block, _ := aes.NewCipher(key[:])

gate/kcp/fec.go

@@ -112,7 +112,7 @@ func (dec *fecDecoder) decode(in fecPacket) (recovered [][]byte) {
 				dec.codec = codec
 				dec.decodeCache = make([][]byte, dec.shardSize)
 				dec.flagCache = make([]bool, dec.shardSize)
-				//log.Println("autotune to :", dec.dataShards, dec.parityShards)
+				// log.Println("autotune to :", dec.dataShards, dec.parityShards)
 			}
 		}
 	}

gate/kcp/readloop.go

@@ -3,6 +3,7 @@ package kcp
 import (
 	"bytes"
 	"encoding/binary"
+
 	"github.com/pkg/errors"
 )
 
@@ -17,8 +18,8 @@ func (s *UDPSession) defaultReadLoop() {
 			if src == "" { // set source address
 				src = addr.String()
 			} else if addr.String() != src {
-				//atomic.AddUint64(&DefaultSnmp.InErrs, 1)
-				//continue
+				// atomic.AddUint64(&DefaultSnmp.InErrs, 1)
+				// continue
 				s.remote = addr
 				src = addr.String()
 			}

gate/kcp/readloop_linux.go

@@ -6,11 +6,12 @@ package kcp
 import (
 	"bytes"
 	"encoding/binary"
+	"net"
+	"os"
+
 	"github.com/pkg/errors"
 	"golang.org/x/net/ipv4"
 	"golang.org/x/net/ipv6"
-	"net"
-	"os"
 )
 
 // the read loop for a client session
@@ -37,8 +38,8 @@ func (s *UDPSession) readLoop() {
 				if src == "" { // set source address if nil
 					src = msg.Addr.String()
 				} else if msg.Addr.String() != src {
-					//atomic.AddUint64(&DefaultSnmp.InErrs, 1)
-					//continue
+					// atomic.AddUint64(&DefaultSnmp.InErrs, 1)
+					// continue
 					s.remote = msg.Addr
 					src = msg.Addr.String()
 				}

gate/kcp/sess.go

@@ -291,7 +291,7 @@ func (s *UDPSession) WriteBuffers(v [][]byte) (n int, err error) {
 			for _, b := range v {
 				n += len(b)
 				// 原神KCP是消息模式 上层不要对消息进行分割 并且保证消息长度小于256*mss
-				//for {
+				// for {
 				//	if len(b) <= int(s.kcp.mss) {
 				//		s.kcp.Send(b)
 				//		break
@@ -299,7 +299,7 @@ func (s *UDPSession) WriteBuffers(v [][]byte) (n int, err error) {
 				//		s.kcp.Send(b[:s.kcp.mss])
 				//		b = b[s.kcp.mss:]
 				//	}
-				//}
+				// }
 				s.kcp.Send(b)
 			}
 

gate/kcp/sess_test.go

@@ -29,10 +29,10 @@ func init() {
 }
 
 func dialEcho(port int) (*UDPSession, error) {
-	//block, _ := NewNoneBlockCrypt(pass)
-	//block, _ := NewSimpleXORBlockCrypt(pass)
-	//block, _ := NewTEABlockCrypt(pass[:16])
-	//block, _ := NewAESBlockCrypt(pass)
+	// block, _ := NewNoneBlockCrypt(pass)
+	// block, _ := NewSimpleXORBlockCrypt(pass)
+	// block, _ := NewTEABlockCrypt(pass[:16])
+	// block, _ := NewAESBlockCrypt(pass)
 	block, _ := NewSalsa20BlockCrypt(pass)
 	sess, err := DialWithOptions(fmt.Sprintf("127.0.0.1:%v", port), block, 10, 3)
 	if err != nil {
@@ -75,10 +75,10 @@ func dialSink(port int) (*UDPSession, error) {
 }
 
 func dialTinyBufferEcho(port int) (*UDPSession, error) {
-	//block, _ := NewNoneBlockCrypt(pass)
-	//block, _ := NewSimpleXORBlockCrypt(pass)
-	//block, _ := NewTEABlockCrypt(pass[:16])
-	//block, _ := NewAESBlockCrypt(pass)
+	// block, _ := NewNoneBlockCrypt(pass)
+	// block, _ := NewSimpleXORBlockCrypt(pass)
+	// block, _ := NewTEABlockCrypt(pass[:16])
+	// block, _ := NewAESBlockCrypt(pass)
 	block, _ := NewSalsa20BlockCrypt(pass)
 	sess, err := DialWithOptions(fmt.Sprintf("127.0.0.1:%v", port), block, 10, 3)
 	if err != nil {
@@ -89,18 +89,18 @@ func dialTinyBufferEcho(port int) (*UDPSession, error) {
 
 // ////////////////////////
 func listenEcho(port int) (net.Listener, error) {
-	//block, _ := NewNoneBlockCrypt(pass)
-	//block, _ := NewSimpleXORBlockCrypt(pass)
-	//block, _ := NewTEABlockCrypt(pass[:16])
-	//block, _ := NewAESBlockCrypt(pass)
+	// block, _ := NewNoneBlockCrypt(pass)
+	// block, _ := NewSimpleXORBlockCrypt(pass)
+	// block, _ := NewTEABlockCrypt(pass[:16])
+	// block, _ := NewAESBlockCrypt(pass)
 	block, _ := NewSalsa20BlockCrypt(pass)
 	return ListenWithOptions(fmt.Sprintf("127.0.0.1:%v", port), block, 10, 0)
 }
 func listenTinyBufferEcho(port int) (net.Listener, error) {
-	//block, _ := NewNoneBlockCrypt(pass)
-	//block, _ := NewSimpleXORBlockCrypt(pass)
-	//block, _ := NewTEABlockCrypt(pass[:16])
-	//block, _ := NewAESBlockCrypt(pass)
+	// block, _ := NewNoneBlockCrypt(pass)
+	// block, _ := NewSimpleXORBlockCrypt(pass)
+	// block, _ := NewTEABlockCrypt(pass[:16])
+	// block, _ := NewAESBlockCrypt(pass)
 	block, _ := NewSalsa20BlockCrypt(pass)
 	return ListenWithOptions(fmt.Sprintf("127.0.0.1:%v", port), block, 10, 3)
 }
@@ -178,7 +178,7 @@ func tinyBufferEchoServer(port int) net.Listener {
 	return l
 }
 
-///////////////////////////
+// /////////////////////////
 
 func handleEcho(conn *UDPSession) {
 	conn.SetStreamMode(true)
@@ -229,7 +229,7 @@ func handleTinyBufferEcho(conn *UDPSession) {
 	}
 }
 
-///////////////////////////
+// /////////////////////////
 
 func TestTimeout(t *testing.T) {
 	port := int(atomic.AddUint32(&baseport, 1))
@@ -242,7 +242,7 @@ func TestTimeout(t *testing.T) {
 	}
 	buf := make([]byte, 10)
 
-	//timeout
+	// timeout
 	cli.SetDeadline(time.Now().Add(time.Second))
 	<-time.After(2 * time.Second)
 	n, err := cli.Read(buf)
@@ -554,7 +554,7 @@ func TestListenerClose(t *testing.T) {
 	}
 
 	l.Close()
-	//fakeaddr, _ := net.ResolveUDPAddr("udp6", "127.0.0.1:1111")
+	// fakeaddr, _ := net.ResolveUDPAddr("udp6", "127.0.0.1:1111")
 	fakeConvId := uint64(0)
 	if l.closeSession(fakeConvId) {
 		t.Fail()

gate/kcp/tx_linux.go

@@ -4,13 +4,13 @@
 package kcp
 
 import (
-	"golang.org/x/net/ipv6"
 	"net"
 	"os"
 	"sync/atomic"
 
 	"github.com/pkg/errors"
 	"golang.org/x/net/ipv4"
+	"golang.org/x/net/ipv6"
 )
 
 func (l *Listener) SendEnetNotifyToClient(enet *Enet) {

gate/mq/mq.go

@@ -22,14 +22,14 @@ func NewMessageQueue(netMsgInput chan *cmd.NetMsg, netMsgOutput chan *cmd.NetMsg
 	r = new(MessageQueue)
 	conn, err := nats.Connect(config.CONF.MQ.NatsUrl)
 	if err != nil {
-		logger.LOG.Error("connect nats error: %v", err)
+		logger.Error("connect nats error: %v", err)
 		return nil
 	}
 	r.natsConn = conn
 	r.natsMsgChan = make(chan *nats.Msg, 10000)
 	_, err = r.natsConn.ChanSubscribe("GATE_CMD_HK4E", r.natsMsgChan)
 	if err != nil {
-		logger.LOG.Error("nats subscribe error: %v", err)
+		logger.Error("nats subscribe error: %v", err)
 		return nil
 	}
 	r.netMsgInput = netMsgInput
@@ -54,7 +54,7 @@ func (m *MessageQueue) startRecvHandler() {
 		netMsg := new(cmd.NetMsg)
 		err := msgpack.Unmarshal(natsMsg.Data, netMsg)
 		if err != nil {
-			logger.LOG.Error("parse bin to net msg error: %v", err)
+			logger.Error("parse bin to net msg error: %v", err)
 			continue
 		}
 		if netMsg.EventId == cmd.NormalMsg {
@@ -62,7 +62,7 @@ func (m *MessageQueue) startRecvHandler() {
 			payloadMessage := m.cmdProtoMap.GetProtoObjByCmdId(netMsg.CmdId)
 			err = pb.Unmarshal(netMsg.PayloadMessageData, payloadMessage)
 			if err != nil {
-				logger.LOG.Error("parse bin to payload msg error: %v", err)
+				logger.Error("parse bin to payload msg error: %v", err)
 				continue
 			}
 			netMsg.PayloadMessage = payloadMessage
@@ -77,21 +77,21 @@ func (m *MessageQueue) startSendHandler() {
 		// protobuf PayloadMessage
 		payloadMessageData, err := pb.Marshal(netMsg.PayloadMessage)
 		if err != nil {
-			logger.LOG.Error("parse payload msg to bin error: %v", err)
+			logger.Error("parse payload msg to bin error: %v", err)
 			continue
 		}
 		netMsg.PayloadMessageData = payloadMessageData
 		// msgpack NetMsg
 		netMsgData, err := msgpack.Marshal(netMsg)
 		if err != nil {
-			logger.LOG.Error("parse net msg to bin error: %v", err)
+			logger.Error("parse net msg to bin error: %v", err)
 			continue
 		}
 		natsMsg := nats.NewMsg("GS_CMD_HK4E")
 		natsMsg.Data = netMsgData
 		err = m.natsConn.PublishMsg(natsMsg)
 		if err != nil {
-			logger.LOG.Error("nats publish msg error: %v", err)
+			logger.Error("nats publish msg error: %v", err)
 			continue
 		}
 	}

gate/net/forward.go

@@ -5,6 +5,11 @@ import (
 	"encoding/base64"
 	"encoding/binary"
 	"fmt"
+	"math/rand"
+	"strconv"
+	"strings"
+	"time"
+
 	"hk4e/dispatch/controller"
 	"hk4e/gate/kcp"
 	"hk4e/pkg/endec"
@@ -13,10 +18,6 @@ import (
 	"hk4e/pkg/random"
 	"hk4e/protocol/cmd"
 	"hk4e/protocol/proto"
-	"math/rand"
-	"strconv"
-	"strings"
-	"time"
 )
 
 const (
@@ -32,7 +33,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
 	headMeta := session.headMeta
 	connState := session.connState
 	if protoMsg.HeadMessage == nil {
-		logger.LOG.Error("recv null head msg: %v", protoMsg)
+		logger.Error("recv null head msg: %v", protoMsg)
 	}
 	headMeta.seq = protoMsg.HeadMessage.ClientSequenceId
 	// gate本地处理的请求
@@ -77,7 +78,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
 		netMsg.EventId = cmd.UserLoginNotify
 		netMsg.ClientSeq = headMeta.seq
 		k.netMsgInput <- netMsg
-		logger.LOG.Info("send to gs user login ok, ConvId: %v, UserId: %v", protoMsg.ConvId, netMsg.UserId)
+		logger.Info("send to gs user login ok, ConvId: %v, UserId: %v", protoMsg.ConvId, netMsg.UserId)
 	case cmd.SetPlayerBornDataReq:
 		// 玩家注册请求
 		if connState != ConnAlive {
@@ -106,7 +107,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
 			return
 		}
 		pingReq := protoMsg.PayloadMessage.(*proto.PingReq)
-		logger.LOG.Debug("user ping req, data: %v", pingReq.String())
+		logger.Debug("user ping req, data: %v", pingReq.String())
 		// 返回数据到客户端
 		// TODO 记录客户端最后一次ping时间做超时下线处理
 		pingRsp := new(proto.PingRsp)
@@ -124,7 +125,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
 		netMsg.ClientTime = pingReq.ClientTime
 		k.netMsgInput <- netMsg
 		// RTT
-		logger.LOG.Debug("convId: %v, RTO: %v, SRTT: %v, RTTVar: %v", protoMsg.ConvId, session.conn.GetRTO(), session.conn.GetSRTT(), session.conn.GetSRTTVar())
+		logger.Debug("convId: %v, RTO: %v, SRTT: %v, RTTVar: %v", protoMsg.ConvId, session.conn.GetRTO(), session.conn.GetSRTT(), session.conn.GetSRTTVar())
 		// 客户端往返时延通知
 		rtt := session.conn.GetSRTT()
 		// 通知GS玩家客户端往返时延
@@ -151,7 +152,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
 
 // 从GS接收消息
 func (k *KcpConnectManager) sendMsgHandle() {
-	logger.LOG.Debug("send msg handle start")
+	logger.Debug("send msg handle start")
 	kcpRawSendChanMap := make(map[uint64]chan *ProtoMsg)
 	userIdConvMap := make(map[uint32]uint64)
 	sendToClientFn := func(protoMsg *ProtoMsg) {
@@ -161,10 +162,10 @@ func (k *KcpConnectManager) sendMsgHandle() {
 			select {
 			case kcpRawSendChan <- protoMsg:
 			default:
-				logger.LOG.Error("kcpRawSendChan is full, convId: %v", protoMsg.ConvId)
+				logger.Error("kcpRawSendChan is full, convId: %v", protoMsg.ConvId)
 			}
 		} else {
-			logger.LOG.Error("kcpRawSendChan is nil, convId: %v", protoMsg.ConvId)
+			logger.Error("kcpRawSendChan is nil, convId: %v", protoMsg.ConvId)
 		}
 	}
 	for {
@@ -181,7 +182,7 @@ func (k *KcpConnectManager) sendMsgHandle() {
 		case netMsg := <-k.netMsgOutput:
 			convId, exist := userIdConvMap[netMsg.UserId]
 			if !exist {
-				logger.LOG.Error("can not find convId by userId")
+				logger.Error("can not find convId by userId")
 				continue
 			}
 			if netMsg.EventId == cmd.NormalMsg {
@@ -192,7 +193,7 @@ func (k *KcpConnectManager) sendMsgHandle() {
 				protoMsg.PayloadMessage = netMsg.PayloadMessage
 				sendToClientFn(protoMsg)
 			} else {
-				logger.LOG.Error("recv unknown event from game server, event id: %v", netMsg.EventId)
+				logger.Error("recv unknown event from game server, event id: %v", netMsg.EventId)
 			}
 		}
 	}
@@ -213,11 +214,11 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
 		AccountToken: req.AccountToken,
 	}, "")
 	if err != nil {
-		logger.LOG.Error("verify token error: %v", err)
+		logger.Error("verify token error: %v", err)
 		return nil
 	}
 	if !tokenVerifyRsp.Valid {
-		logger.LOG.Error("token error")
+		logger.Error("token error")
 		return nil
 	}
 	// comboToken验证成功
@@ -273,38 +274,38 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
 	split := strings.Split(addr, ":")
 	rsp.ClientIpStr = split[0]
 	if req.GetKeyId() != 0 {
-		logger.LOG.Debug("do hk4e 2.8 rsa logic")
+		logger.Debug("do hk4e 2.8 rsa logic")
 		keyId := strconv.Itoa(int(req.GetKeyId()))
 		encPubPrivKey, exist := k.encRsaKeyMap[keyId]
 		if !exist {
-			logger.LOG.Error("can not found key id: %v", keyId)
+			logger.Error("can not found key id: %v", keyId)
 			return
 		}
 		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 nil
 		}
 		signPrivkey, err := endec.RsaParsePrivKey(k.signRsaKey)
 		if err != nil {
-			logger.LOG.Error("parse rsa priv key error: %v", err)
+			logger.Error("parse rsa priv key error: %v", err)
 			return nil
 		}
 		clientSeedBase64 := req.GetClientRandKey()
 		clientSeedEnc, err := base64.StdEncoding.DecodeString(clientSeedBase64)
 		if err != nil {
-			logger.LOG.Error("parse client seed base64 error: %v", err)
+			logger.Error("parse client seed base64 error: %v", err)
 			return nil
 		}
 		clientSeed, err := endec.RsaDecrypt(clientSeedEnc, signPrivkey)
 		if err != nil {
-			logger.LOG.Error("rsa dec error: %v", err)
+			logger.Error("rsa dec error: %v", err)
 			return rsp
 		}
 		clientSeedUint64 := uint64(0)
 		err = binary.Read(bytes.NewReader(clientSeed), binary.BigEndian, &clientSeedUint64)
 		if err != nil {
-			logger.LOG.Error("parse client seed to uint64 error: %v", err)
+			logger.Error("parse client seed to uint64 error: %v", err)
 			return rsp
 		}
 		timeRand := random.GetTimeRand()
@@ -315,18 +316,18 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
 		seedBuf := new(bytes.Buffer)
 		err = binary.Write(seedBuf, binary.BigEndian, seedUint64)
 		if err != nil {
-			logger.LOG.Error("conv seed uint64 to bytes error: %v", err)
+			logger.Error("conv seed uint64 to bytes error: %v", err)
 			return rsp
 		}
 		seed := seedBuf.Bytes()
 		seedEnc, err := endec.RsaEncrypt(seed, pubKey)
 		if err != nil {
-			logger.LOG.Error("rsa enc error: %v", err)
+			logger.Error("rsa enc error: %v", err)
 			return rsp
 		}
 		seedSign, err := endec.RsaSign(seed, signPrivkey)
 		if err != nil {
-			logger.LOG.Error("rsa sign error: %v", err)
+			logger.Error("rsa sign error: %v", err)
 			return rsp
 		}
 		rsp.KeyId = req.KeyId
@@ -337,7 +338,7 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
 }
 
 func (k *KcpConnectManager) playerLogin(req *proto.PlayerLoginReq, session *Session) (rsp *proto.PlayerLoginRsp) {
-	logger.LOG.Debug("player login, info: %v", req.String())
+	logger.Debug("player login, info: %v", req.String())
 	// TODO 验证token
 	session.connState = ConnAlive
 	// 返回响应

gate/net/kcp_connect_manager.go

@@ -3,19 +3,19 @@ package net
 import (
 	"bytes"
 	"encoding/binary"
-	"hk4e/common/region"
-	"hk4e/dispatch/controller"
-	"hk4e/pkg/httpclient"
-	"hk4e/protocol/cmd"
-	"hk4e/protocol/proto"
 	"strconv"
 	"sync"
 	"time"
 
 	"hk4e/common/config"
+	"hk4e/common/region"
+	"hk4e/dispatch/controller"
 	"hk4e/gate/kcp"
+	"hk4e/pkg/httpclient"
 	"hk4e/pkg/logger"
 	"hk4e/pkg/random"
+	"hk4e/protocol/cmd"
+	"hk4e/protocol/proto"
 )
 
 type KcpConnectManager struct {
@@ -63,15 +63,15 @@ func (k *KcpConnectManager) Start() {
 	// key
 	dispatchEc2bSeedRsp, err := httpclient.Get[controller.DispatchEc2bSeedRsp]("http://127.0.0.1:8080/dispatch/ec2b/seed", "")
 	if err != nil {
-		logger.LOG.Error("get dispatch ec2b seed error: %v", err)
+		logger.Error("get dispatch ec2b seed error: %v", err)
 		return
 	}
 	dispatchEc2bSeed, err := strconv.ParseUint(dispatchEc2bSeedRsp.Seed, 10, 64)
 	if err != nil {
-		logger.LOG.Error("parse dispatch ec2b seed error: %v", err)
+		logger.Error("parse dispatch ec2b seed error: %v", err)
 		return
 	}
-	logger.LOG.Debug("get dispatch ec2b seed: %v", dispatchEc2bSeed)
+	logger.Debug("get dispatch ec2b seed: %v", dispatchEc2bSeed)
 	gateDispatchEc2b := random.NewEc2b()
 	gateDispatchEc2b.SetSeed(dispatchEc2bSeed)
 	k.dispatchKey = gateDispatchEc2b.XorKey()
@@ -79,7 +79,7 @@ func (k *KcpConnectManager) Start() {
 	port := strconv.Itoa(int(config.CONF.Hk4e.KcpPort))
 	listener, err := kcp.ListenWithOptions(config.CONF.Hk4e.KcpAddr+":"+port, nil, 0, 0)
 	if err != nil {
-		logger.LOG.Error("listen kcp err: %v", err)
+		logger.Error("listen kcp err: %v", err)
 		return
 	}
 	go k.enetHandle(listener)
@@ -89,11 +89,11 @@ func (k *KcpConnectManager) Start() {
 }
 
 func (k *KcpConnectManager) acceptHandle(listener *kcp.Listener) {
-	logger.LOG.Debug("accept handle start")
+	logger.Debug("accept handle start")
 	for {
 		conn, err := listener.AcceptKCP()
 		if err != nil {
-			logger.LOG.Error("accept kcp err: %v", err)
+			logger.Error("accept kcp err: %v", err)
 			return
 		}
 		if k.openState == false {
@@ -103,7 +103,7 @@ func (k *KcpConnectManager) acceptHandle(listener *kcp.Listener) {
 		conn.SetACKNoDelay(true)
 		conn.SetWriteDelay(false)
 		convId := conn.GetConv()
-		logger.LOG.Debug("client connect, convId: %v", convId)
+		logger.Debug("client connect, convId: %v", convId)
 		kcpRawSendChan := make(chan *ProtoMsg, 1000)
 		session := &Session{
 			conn:      conn,
@@ -129,12 +129,12 @@ func (k *KcpConnectManager) acceptHandle(listener *kcp.Listener) {
 }
 
 func (k *KcpConnectManager) enetHandle(listener *kcp.Listener) {
-	logger.LOG.Debug("enet handle start")
+	logger.Debug("enet handle start")
 	// conv短时间内唯一生成
 	convGenMap := make(map[uint64]int64)
 	for {
 		enetNotify := <-listener.EnetNotify
-		logger.LOG.Info("[Enet Notify], addr: %v, conv: %v, conn: %v, enet: %v", enetNotify.Addr, enetNotify.ConvId, enetNotify.ConnType, enetNotify.EnetType)
+		logger.Info("[Enet Notify], addr: %v, conv: %v, conn: %v, enet: %v", enetNotify.Addr, enetNotify.ConvId, enetNotify.ConnType, enetNotify.EnetType)
 		switch enetNotify.ConnType {
 		case kcp.ConnEnetSyn:
 			if enetNotify.EnetType == kcp.EnetClientConnectKey {
@@ -156,7 +156,7 @@ func (k *KcpConnectManager) enetHandle(listener *kcp.Listener) {
 					}
 				}
 				k.sessionMapLock.RUnlock()
-				logger.LOG.Info("clean dead conv list: %v", delConvList)
+				logger.Info("clean dead conv list: %v", delConvList)
 				// 生成没用过的conv
 				var conv uint64
 				for {
@@ -182,7 +182,7 @@ func (k *KcpConnectManager) enetHandle(listener *kcp.Listener) {
 		case kcp.ConnEnetFin:
 			session := k.GetSessionByConvId(enetNotify.ConvId)
 			if session == nil {
-				logger.LOG.Error("session not exist, convId: %v", enetNotify.ConvId)
+				logger.Error("session not exist, convId: %v", enetNotify.ConvId)
 				continue
 			}
 			session.conn.SendEnetNotify(&kcp.Enet{
@@ -218,7 +218,7 @@ type Session struct {
 }
 
 func (k *KcpConnectManager) recvHandle(session *Session) {
-	logger.LOG.Debug("recv handle start")
+	logger.Debug("recv handle start")
 	// 接收
 	conn := session.conn
 	convId := conn.GetConv()
@@ -229,7 +229,7 @@ func (k *KcpConnectManager) recvHandle(session *Session) {
 		_ = conn.SetReadDeadline(time.Now().Add(time.Second * 15))
 		recvLen, err := conn.Read(recvBuf)
 		if err != nil {
-			logger.LOG.Error("exit recv loop, conn read err: %v, convId: %v", err, convId)
+			logger.Error("exit recv loop, conn read err: %v, convId: %v", err, convId)
 			k.closeKcpConn(session, kcp.EnetServerKick)
 			break
 		}
@@ -246,7 +246,7 @@ func (k *KcpConnectManager) recvHandle(session *Session) {
 		now := time.Now().UnixNano()
 		if now-pktFreqLimitTimer > int64(time.Second) {
 			if pktFreqLimitCounter > 100 {
-				logger.LOG.Error("exit recv loop, client packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
+				logger.Error("exit recv loop, client packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
 				k.closeKcpConn(session, kcp.EnetPacketFreqTooHigh)
 				break
 			} else {
@@ -267,7 +267,7 @@ func (k *KcpConnectManager) recvHandle(session *Session) {
 }
 
 func (k *KcpConnectManager) sendHandle(session *Session) {
-	logger.LOG.Debug("send handle start")
+	logger.Debug("send handle start")
 	// 发送
 	conn := session.conn
 	convId := conn.GetConv()
@@ -276,20 +276,20 @@ func (k *KcpConnectManager) sendHandle(session *Session) {
 	for {
 		protoMsg, ok := <-session.kcpRawSendChan
 		if !ok {
-			logger.LOG.Error("exit send loop, send chan close, convId: %v", convId)
+			logger.Error("exit send loop, send chan close, convId: %v", convId)
 			k.closeKcpConn(session, kcp.EnetServerKick)
 			break
 		}
 		kcpMsg := k.protoEncode(protoMsg)
 		if kcpMsg == nil {
-			logger.LOG.Error("decode kcp msg is nil, convId: %v", convId)
+			logger.Error("decode kcp msg is nil, convId: %v", convId)
 			continue
 		}
 		bin := k.encodePayloadToBin(kcpMsg, session.xorKey)
 		_ = conn.SetWriteDeadline(time.Now().Add(time.Second * 5))
 		_, err := conn.Write(bin)
 		if err != nil {
-			logger.LOG.Error("exit send loop, conn write err: %v, convId: %v", err, convId)
+			logger.Error("exit send loop, conn write err: %v, convId: %v", err, convId)
 			k.closeKcpConn(session, kcp.EnetServerKick)
 			break
 		}
@@ -298,7 +298,7 @@ func (k *KcpConnectManager) sendHandle(session *Session) {
 		now := time.Now().UnixNano()
 		if now-pktFreqLimitTimer > int64(time.Second) {
 			if pktFreqLimitCounter > 100 {
-				logger.LOG.Error("exit send loop, server packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
+				logger.Error("exit send loop, server packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
 				k.closeKcpConn(session, kcp.EnetPacketFreqTooHigh)
 				break
 			} else {
@@ -336,7 +336,7 @@ func (k *KcpConnectManager) closeKcpConn(session *Session, enetType uint32) {
 	netMsg.UserId = session.userId
 	netMsg.EventId = cmd.UserOfflineNotify
 	k.netMsgInput <- netMsg
-	logger.LOG.Info("send to gs user offline, ConvId: %v, UserId: %v", convId, netMsg.UserId)
+	logger.Info("send to gs user offline, ConvId: %v, UserId: %v", convId, netMsg.UserId)
 	k.destroySessionChan <- session
 }
 

gate/net/kcp_endecode.go

@@ -42,12 +42,12 @@ func (k *KcpConnectManager) decodeBinToPayload(data []byte, convId uint64, kcpMs
 func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[]*KcpMsg) {
 	// 长度太短
 	if len(data) < 12 {
-		logger.LOG.Debug("packet len less 12 byte")
+		logger.Debug("packet len less 12 byte")
 		return
 	}
 	// 头部幻数错误
 	if data[0] != 0x45 || data[1] != 0x67 {
-		logger.LOG.Error("packet head magic 0x4567 error")
+		logger.Error("packet head magic 0x4567 error")
 		return
 	}
 	// 协议号
@@ -58,7 +58,7 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
 	var cmdId int64
 	err := binary.Read(cmdIdBuffer, binary.BigEndian, &cmdId)
 	if err != nil {
-		logger.LOG.Error("packet cmd id parse fail: %v", err)
+		logger.Error("packet cmd id parse fail: %v", err)
 		return
 	}
 	// 头部长度
@@ -69,7 +69,7 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
 	var headLen int64
 	err = binary.Read(headLenBuffer, binary.BigEndian, &headLen)
 	if err != nil {
-		logger.LOG.Error("packet head len parse fail: %v", err)
+		logger.Error("packet head len parse fail: %v", err)
 		return
 	}
 	// proto长度
@@ -82,17 +82,17 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
 	var protoLen int64
 	err = binary.Read(protoLenBuffer, binary.BigEndian, &protoLen)
 	if err != nil {
-		logger.LOG.Error("packet proto len parse fail: %v", err)
+		logger.Error("packet proto len parse fail: %v", err)
 		return
 	}
 	// 检查最小长度
 	if len(data) < int(headLen+protoLen)+12 {
-		logger.LOG.Error("packet len error")
+		logger.Error("packet len error")
 		return
 	}
 	// 尾部幻数错误
 	if data[headLen+protoLen+10] != 0x89 || data[headLen+protoLen+11] != 0xAB {
-		logger.LOG.Error("packet tail magic 0x89AB error")
+		logger.Error("packet tail magic 0x89AB error")
 		return
 	}
 	// 判断是否有不止一个包
@@ -108,10 +108,10 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
 	kcpMsg := new(KcpMsg)
 	kcpMsg.ConvId = convId
 	kcpMsg.CmdId = uint16(cmdId)
-	//kcpMsg.HeadData = make([]byte, len(headData))
-	//copy(kcpMsg.HeadData, headData)
-	//kcpMsg.ProtoData = make([]byte, len(protoData))
-	//copy(kcpMsg.ProtoData, protoData)
+	// kcpMsg.HeadData = make([]byte, len(headData))
+	// copy(kcpMsg.HeadData, headData)
+	// kcpMsg.ProtoData = make([]byte, len(protoData))
+	// copy(kcpMsg.ProtoData, protoData)
 	kcpMsg.HeadData = headData
 	kcpMsg.ProtoData = protoData
 	*kcpMsgList = append(*kcpMsgList, kcpMsg)
@@ -136,7 +136,7 @@ func (k *KcpConnectManager) encodePayloadToBin(kcpMsg *KcpMsg, xorKey []byte) (b
 	cmdIdBuffer := bytes.NewBuffer([]byte{})
 	err := binary.Write(cmdIdBuffer, binary.BigEndian, kcpMsg.CmdId)
 	if err != nil {
-		logger.LOG.Error("cmd id encode err: %v", err)
+		logger.Error("cmd id encode err: %v", err)
 		return nil
 	}
 	bin[2] = (cmdIdBuffer.Bytes())[0]
@@ -145,7 +145,7 @@ func (k *KcpConnectManager) encodePayloadToBin(kcpMsg *KcpMsg, xorKey []byte) (b
 	headLenBuffer := bytes.NewBuffer([]byte{})
 	err = binary.Write(headLenBuffer, binary.BigEndian, uint16(len(kcpMsg.HeadData)))
 	if err != nil {
-		logger.LOG.Error("head len encode err: %v", err)
+		logger.Error("head len encode err: %v", err)
 		return nil
 	}
 	bin[4] = (headLenBuffer.Bytes())[0]
@@ -154,7 +154,7 @@ func (k *KcpConnectManager) encodePayloadToBin(kcpMsg *KcpMsg, xorKey []byte) (b
 	protoLenBuffer := bytes.NewBuffer([]byte{})
 	err = binary.Write(protoLenBuffer, binary.BigEndian, uint32(len(kcpMsg.ProtoData)))
 	if err != nil {
-		logger.LOG.Error("proto len encode err: %v", err)
+		logger.Error("proto len encode err: %v", err)
 		return nil
 	}
 	bin[6] = (protoLenBuffer.Bytes())[0]

gate/net/kcp_event.go

@@ -1,9 +1,10 @@
 package net
 
 import (
+	"reflect"
+
 	"hk4e/gate/kcp"
 	"hk4e/pkg/logger"
-	"reflect"
 )
 
 const (
@@ -30,22 +31,22 @@ func (k *KcpConnectManager) GetKcpEventOutputChan() chan *KcpEvent {
 }
 
 func (k *KcpConnectManager) eventHandle() {
-	logger.LOG.Debug("event handle start")
+	logger.Debug("event handle start")
 	// 事件处理
 	for {
 		event := <-k.kcpEventInput
-		logger.LOG.Info("kcp manager recv event, ConvId: %v, EventId: %v, EventMessage Type: %v", event.ConvId, event.EventId, reflect.TypeOf(event.EventMessage))
+		logger.Info("kcp manager recv event, ConvId: %v, EventId: %v, EventMessage Type: %v", event.ConvId, event.EventId, reflect.TypeOf(event.EventMessage))
 		switch event.EventId {
 		case KcpConnForceClose:
 			// 强制关闭某个连接
 			session := k.GetSessionByConvId(event.ConvId)
 			if session == nil {
-				logger.LOG.Error("session not exist, convId: %v", event.ConvId)
+				logger.Error("session not exist, convId: %v", event.ConvId)
 				continue
 			}
 			reason, ok := event.EventMessage.(uint32)
 			if !ok {
-				logger.LOG.Error("event KcpConnForceClose msg type error")
+				logger.Error("event KcpConnForceClose msg type error")
 				continue
 			}
 			session.conn.SendEnetNotify(&kcp.Enet{
@@ -53,16 +54,16 @@ func (k *KcpConnectManager) eventHandle() {
 				EnetType: reason,
 			})
 			_ = session.conn.Close()
-			logger.LOG.Info("conn has been force close, convId: %v", event.ConvId)
+			logger.Info("conn has been force close, convId: %v", event.ConvId)
 		case KcpAllConnForceClose:
 			// 强制关闭所有连接
 			k.closeAllKcpConn()
-			logger.LOG.Info("all conn has been force close")
+			logger.Info("all conn has been force close")
 		case KcpGateOpenState:
 			// 改变网关开放状态
 			openState, ok := event.EventMessage.(bool)
 			if !ok {
-				logger.LOG.Error("event KcpGateOpenState msg type error")
+				logger.Error("event KcpGateOpenState msg type error")
 				continue
 			}
 			k.openState = openState

gate/net/proto_endecode.go

@@ -30,7 +30,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
 		headMsg := new(proto.PacketHead)
 		err := pb.Unmarshal(kcpMsg.HeadData, headMsg)
 		if err != nil {
-			logger.LOG.Error("unmarshal head data err: %v", err)
+			logger.Error("unmarshal head data err: %v", err)
 			return protoMsgList
 		}
 		protoMsg.HeadMessage = headMsg
@@ -41,7 +41,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
 	protoMessageList := make([]*ProtoMessage, 0)
 	k.protoDecodePayloadLoop(kcpMsg.CmdId, kcpMsg.ProtoData, &protoMessageList)
 	if len(protoMessageList) == 0 {
-		logger.LOG.Error("decode proto object is nil")
+		logger.Error("decode proto object is nil")
 		return protoMsgList
 	}
 	if kcpMsg.CmdId == cmd.UnionCmdNotify {
@@ -58,7 +58,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
 			if msg.PayloadMessage != nil {
 				cmdName = string(msg.PayloadMessage.ProtoReflect().Descriptor().FullName())
 			}
-			logger.LOG.Debug("[RECV UNION CMD], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", msg.CmdId, cmdName, msg.ConvId, msg.HeadMessage)
+			logger.Debug("[RECV UNION CMD], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", msg.CmdId, cmdName, msg.ConvId, msg.HeadMessage)
 		}
 	} else {
 		protoMsg.PayloadMessage = protoMessageList[0].message
@@ -67,7 +67,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
 		if protoMsg.PayloadMessage != nil {
 			cmdName = string(protoMsg.PayloadMessage.ProtoReflect().Descriptor().FullName())
 		}
-		logger.LOG.Debug("[RECV], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
+		logger.Debug("[RECV], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
 	}
 	return protoMsgList
 }
@@ -75,14 +75,14 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
 func (k *KcpConnectManager) protoDecodePayloadLoop(cmdId uint16, protoData []byte, protoMessageList *[]*ProtoMessage) {
 	protoObj := k.decodePayloadToProto(cmdId, protoData)
 	if protoObj == nil {
-		logger.LOG.Error("decode proto object is nil")
+		logger.Error("decode proto object is nil")
 		return
 	}
 	if cmdId == cmd.UnionCmdNotify {
 		// 处理聚合消息
 		unionCmdNotify, ok := protoObj.(*proto.UnionCmdNotify)
 		if !ok {
-			logger.LOG.Error("parse union cmd error")
+			logger.Error("parse union cmd error")
 			return
 		}
 		for _, unionCmd := range unionCmdNotify.GetCmdList() {
@@ -100,7 +100,7 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
 	if protoMsg.PayloadMessage != nil {
 		cmdName = string(protoMsg.PayloadMessage.ProtoReflect().Descriptor().FullName())
 	}
-	logger.LOG.Debug("[SEND], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
+	logger.Debug("[SEND], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
 	kcpMsg = new(KcpMsg)
 	kcpMsg.ConvId = protoMsg.ConvId
 	kcpMsg.CmdId = protoMsg.CmdId
@@ -108,7 +108,7 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
 	if protoMsg.HeadMessage != nil {
 		headData, err := pb.Marshal(protoMsg.HeadMessage)
 		if err != nil {
-			logger.LOG.Error("marshal head data err: %v", err)
+			logger.Error("marshal head data err: %v", err)
 			return nil
 		}
 		kcpMsg.HeadData = headData
@@ -119,11 +119,11 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
 	if protoMsg.PayloadMessage != nil {
 		cmdId, protoData := k.encodeProtoToPayload(protoMsg.PayloadMessage)
 		if cmdId == 0 || protoData == nil {
-			logger.LOG.Error("encode proto data is nil")
+			logger.Error("encode proto data is nil")
 			return nil
 		}
 		if cmdId != 65535 && cmdId != protoMsg.CmdId {
-			logger.LOG.Error("cmd id is not match with proto obj, src cmd id: %v, found cmd id: %v", protoMsg.CmdId, cmdId)
+			logger.Error("cmd id is not match with proto obj, src cmd id: %v, found cmd id: %v", protoMsg.CmdId, cmdId)
 			return nil
 		}
 		kcpMsg.ProtoData = protoData
@@ -136,12 +136,12 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
 func (k *KcpConnectManager) decodePayloadToProto(cmdId uint16, protoData []byte) (protoObj pb.Message) {
 	protoObj = k.cmdProtoMap.GetProtoObjByCmdId(cmdId)
 	if protoObj == nil {
-		logger.LOG.Error("get new proto object is nil")
+		logger.Error("get new proto object is nil")
 		return nil
 	}
 	err := pb.Unmarshal(protoData, protoObj)
 	if err != nil {
-		logger.LOG.Error("unmarshal proto data err: %v", err)
+		logger.Error("unmarshal proto data err: %v", err)
 		return nil
 	}
 	return protoObj
@@ -152,7 +152,7 @@ func (k *KcpConnectManager) encodeProtoToPayload(protoObj pb.Message) (cmdId uin
 	var err error = nil
 	protoData, err = pb.Marshal(protoObj)
 	if err != nil {
-		logger.LOG.Error("marshal proto object err: %v", err)
+		logger.Error("marshal proto object err: %v", err)
 		return 0, nil
 	}
 	return cmdId, protoData