新增etcd认证配置

cluster/etcddiscovery.go

@@ -13,10 +13,12 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"go.uber.org/zap"
 	"path"
 	"strings"
 	"sync/atomic"
+	"io/ioutil"
+	"crypto/x509"
+	"crypto/tls"
 )
 
 const originDir = "/origin"
@@ -40,11 +42,16 @@ type EtcdDiscoveryService struct {
 	mapDiscoveryNodeId map[string]map[string]struct{} //map[networkName]map[nodeId]
 }
 
+var  etcdDiscovery *EtcdDiscoveryService
 func getEtcdDiscovery() IServiceDiscovery {
-	etcdDiscovery := &EtcdDiscoveryService{}
+	if etcdDiscovery == nil {
+		etcdDiscovery = &EtcdDiscoveryService{}
+	}
+
 	return etcdDiscovery
 }
 
+
 func (ed *EtcdDiscoveryService) InitDiscovery(localNodeId string, funDelNode FunDelNode, funSetNode FunSetNode) error {
 	ed.localNodeId = localNodeId
 
@@ -87,15 +94,44 @@ func (ed *EtcdDiscoveryService) OnInit() error {
 	}
 
 	for i := 0; i < len(etcdDiscoveryCfg.EtcdList); i++ {
-		client, cerr := clientv3.New(clientv3.Config{
+		var client *clientv3.Client
+		var tlsConfig *tls.Config
+
+		if etcdDiscoveryCfg.EtcdList[i].Cert != "" {
+			// load cert
+			cert, cerr := tls.LoadX509KeyPair(etcdDiscoveryCfg.EtcdList[i].Cert, etcdDiscoveryCfg.EtcdList[i].CertKey)
+			if cerr != nil {
+				log.Error("load cert error", log.ErrorField("err", cerr))
+				return cerr
+			}
+
+			// load root ca
+			caData, cerr := ioutil.ReadFile(etcdDiscoveryCfg.EtcdList[i].Ca)
+			if cerr != nil {
+				log.Error("load root ca error", log.ErrorField("err", cerr))
+				return cerr
+			}
+			pool := x509.NewCertPool()
+			pool.AppendCertsFromPEM(caData)
+			tlsConfig = &tls.Config{
+				Certificates: []tls.Certificate{cert},
+				RootCAs:      pool,
+			}
+		}
+
+		client, err = clientv3.New(clientv3.Config{
 			Endpoints:   etcdDiscoveryCfg.EtcdList[i].Endpoints,
 			DialTimeout: etcdDiscoveryCfg.DialTimeoutMillisecond,
-			Logger:      zap.NewNop(),
+			Username: etcdDiscoveryCfg.EtcdList[i].UserName,
+			Password: etcdDiscoveryCfg.EtcdList[i].Password,
+			Logger:      log.GetLogger().Logger,
+			TLS: tlsConfig,
 		})
 
-		if cerr != nil {
-			log.Error("etcd discovery init fail", log.ErrorField("err", cerr))
-			return cerr
+
+		if err != nil {
+			log.Error("etcd discovery init fail", log.ErrorField("err", err))
+			return err
 		}
 
 		ctx, _ := context.WithTimeout(context.Background(), time.Second*3)

cluster/parsecfg.go

@@ -15,9 +15,15 @@ import (
 
 var json = jsoniter.ConfigCompatibleWithStandardLibrary
 
+
 type EtcdList struct {
 	NetworkName []string
 	Endpoints   []string
+	UserName string
+	Password string
+	Cert string
+	CertKey string
+	Ca string
 }
 
 type EtcdDiscovery struct {

log/log.go

@@ -22,11 +22,12 @@ type Logger struct {
 	LogLevel      zapcore.Level
 	Encoder       zapcore.Encoder
 	LogConfig     *lumberjack.Logger
-	sugaredLogger *zap.SugaredLogger
+	SugaredLogger *zap.SugaredLogger
+	CoreList      []zapcore.Core
 }
 
 func SetLogger(logger *Logger) {
-	if logger != nil && isSetLogger == false {
+	if logger != nil {
 		gLogger = logger
 		isSetLogger = true
 	}
@@ -95,22 +96,27 @@ func (logger *Logger) Enabled(zapcore.Level) bool {
 }
 
 func (logger *Logger) Init() {
-	var coreList []zapcore.Core
+	if isSetLogger {
+		return
+	}
 
+	var coreList []zapcore.Core
 	if logger.OpenConsole == nil || *logger.OpenConsole {
 		core := zapcore.NewCore(logger.Encoder, zapcore.AddSync(os.Stdout), logger.LogLevel)
 		coreList = append(coreList, core)
 	}
 
-	if logger.LogPath != "" {
-		writeSyncer := zapcore.AddSync(logger.LogConfig)
-		core := zapcore.NewCore(logger.Encoder, writeSyncer, logger.LogLevel)
+	if logger.CoreList != nil {
+		coreList = append(coreList, logger.CoreList...)
+	}else if logger.LogPath != "" {
+		WriteSyncer := zapcore.AddSync(logger.LogConfig)
+		core := zapcore.NewCore(logger.Encoder, WriteSyncer, logger.LogLevel)
 		coreList = append(coreList, core)
 	}
 
 	core := zapcore.NewTee(coreList...)
 	logger.Logger = zap.New(core, zap.AddCaller(), zap.AddStacktrace(logger), zap.AddCallerSkip(1+logger.Skip))
-	logger.sugaredLogger = logger.Logger.Sugar()
+	logger.SugaredLogger = logger.Logger.Sugar()
 }
 
 func (logger *Logger) Debug(msg string, fields ...zap.Field) {
@@ -170,84 +176,84 @@ func Fatal(msg string, fields ...zap.Field) {
 }
 
 func Debugf(template string, args ...any) {
-	gLogger.sugaredLogger.Debugf(template, args...)
+	gLogger.SugaredLogger.Debugf(template, args...)
 }
 
 func Infof(template string, args ...any) {
-	gLogger.sugaredLogger.Infof(template, args...)
+	gLogger.SugaredLogger.Infof(template, args...)
 }
 
 func Warnf(template string, args ...any) {
-	gLogger.sugaredLogger.Warnf(template, args...)
+	gLogger.SugaredLogger.Warnf(template, args...)
 }
 
 func Errorf(template string, args ...any) {
-	gLogger.sugaredLogger.Errorf(template, args...)
+	gLogger.SugaredLogger.Errorf(template, args...)
 }
 
 func StackErrorf(template string, args ...any) {
 	gLogger.stack = true
-	gLogger.sugaredLogger.Errorf(template, args...)
+	gLogger.SugaredLogger.Errorf(template, args...)
 	gLogger.stack = false
 }
 
 func Fatalf(template string, args ...any) {
-	gLogger.sugaredLogger.Fatalf(template, args...)
+	gLogger.SugaredLogger.Fatalf(template, args...)
 }
 
 func (logger *Logger) SDebug(args ...interface{}) {
-	logger.sugaredLogger.Debugln(args...)
+	logger.SugaredLogger.Debugln(args...)
 }
 
 func (logger *Logger) SInfo(args ...interface{}) {
-	logger.sugaredLogger.Infoln(args...)
+	logger.SugaredLogger.Infoln(args...)
 }
 
 func (logger *Logger) SWarn(args ...interface{}) {
-	logger.sugaredLogger.Warnln(args...)
+	logger.SugaredLogger.Warnln(args...)
 }
 
 func (logger *Logger) SError(args ...interface{}) {
-	logger.sugaredLogger.Errorln(args...)
+	logger.SugaredLogger.Errorln(args...)
 }
 
 func (logger *Logger) SStackError(args ...interface{}) {
 	gLogger.stack = true
-	logger.sugaredLogger.Errorln(args...)
+	logger.SugaredLogger.Errorln(args...)
 	gLogger.stack = false
 }
 
 func (logger *Logger) SFatal(args ...interface{}) {
 	gLogger.stack = true
-	logger.sugaredLogger.Fatalln(args...)
+	logger.SugaredLogger.Fatalln(args...)
 	gLogger.stack = false
 }
 
 func SDebug(args ...interface{}) {
-	gLogger.sugaredLogger.Debugln(args...)
+	gLogger.SugaredLogger.Debugln(args...)
 }
 
 func SInfo(args ...interface{}) {
-	gLogger.sugaredLogger.Infoln(args...)
+	gLogger.SugaredLogger.Infoln(args...)
 }
 
 func SWarn(args ...interface{}) {
-	gLogger.sugaredLogger.Warnln(args...)
+	gLogger.SugaredLogger.Warnln(args...)
 }
 
 func SError(args ...interface{}) {
-	gLogger.sugaredLogger.Errorln(args...)
+	gLogger.SugaredLogger.Errorln(args...)
 }
 
 func SStackError(args ...interface{}) {
 	gLogger.stack = true
-	gLogger.sugaredLogger.Errorln(args...)
+	gLogger.SugaredLogger.Errorln(args...)
 	gLogger.stack = false
 }
 
 func SFatal(args ...interface{}) {
 	gLogger.stack = true
-	gLogger.sugaredLogger.Fatalln(args...)
+	gLogger.SugaredLogger.Fatalln(args...)
 	gLogger.stack = false
 }
 

node/node.go

@@ -230,7 +230,6 @@ func initLog() error {
 	localNodeInfo := cluster.GetCluster().GetLocalNodeInfo()
 	fileName := fmt.Sprintf("%s.log", localNodeInfo.NodeId)
 	logger.FileName = fileName
-	filepath.Join()
 	logger.LogConfig.Filename = filepath.Join(logger.LogPath, logger.FileName)
 
 	logger.Init()
@@ -487,9 +486,9 @@ func setLogPath(args interface{}) error {
 	}
 
 	if err != nil {
-		err = os.Mkdir(log.GetLogger().LogPath, os.ModePerm)
+		err = os.MkdirAll(logPath, os.ModePerm)
 		if err != nil {
-			return errors.New("Cannot create dir " + log.GetLogger().LogPath)
+			return errors.New("Cannot create dir " + logPath)
 		}
 	}
 

service/module.go

@@ -125,14 +125,15 @@ func (m *Module) AddModule(module IModule) (uint32, error) {
 
 func (m *Module) ReleaseModule(moduleId uint32) {
 	pModule := m.GetModule(moduleId).getBaseModule().(*Module)
-	//释放子孙
+	pModule.self.OnRelease()
+	log.Debug("Release module " + pModule.GetModuleName())
+
 	for i:=len(pModule.child)-1; i>=0; i-- {
 		m.ReleaseModule(pModule.child[i].GetModuleId())
 	}
 
-	pModule.self.OnRelease()
 	pModule.GetEventHandler().Destroy()
-	log.Debug("Release module " + pModule.GetModuleName())
+
 	for pTimer := range pModule.mapActiveTimer {
 		pTimer.Cancel()
 	}

service/service.go

@@ -264,12 +264,11 @@ func (s *Service) Release() {
 		}
 	}()
 
-	for i:=len(s.child)-1; i>=0; i-- {
-		s.ReleaseModule(s.child[i].GetModuleId())
-	}
-
 	if atomic.AddInt32(&s.isRelease, -1) == -1 {
 		s.self.OnRelease()
+		for i:=len(s.child)-1; i>=0; i-- {
+			s.ReleaseModule(s.child[i].GetModuleId())
+		}
 	}
 }
 

sysmodule/netmodule/wsmodule/WSModule.go

@@ -14,7 +14,7 @@ import (
 type WSModule struct {
 	service.Module
 
-	wsServer network.WSServer
+	WSServer network.WSServer
 
 	mapClientLocker sync.RWMutex
 	mapClient       map[string]*WSClient
@@ -57,16 +57,16 @@ func (ws *WSModule) OnInit() error {
 		return fmt.Errorf("please call the Init function correctly")
 	}
 
-	ws.wsServer.MaxConnNum = ws.wsCfg.MaxConnNum
-	ws.wsServer.PendingWriteNum = ws.wsCfg.PendingWriteNum
-	ws.wsServer.MaxMsgLen = ws.wsCfg.MaxMsgLen
-	ws.wsServer.Addr = ws.wsCfg.ListenAddr
+	ws.WSServer.MaxConnNum = ws.wsCfg.MaxConnNum
+	ws.WSServer.PendingWriteNum = ws.wsCfg.PendingWriteNum
+	ws.WSServer.MaxMsgLen = ws.wsCfg.MaxMsgLen
+	ws.WSServer.Addr = ws.wsCfg.ListenAddr
 
 	//3.设置解析处理器
 	ws.process.SetByteOrder(ws.wsCfg.LittleEndian)
 
-	ws.mapClient = make(map[string]*WSClient, ws.wsServer.MaxConnNum)
-	ws.wsServer.NewAgent = ws.NewWSClient
+	ws.mapClient = make(map[string]*WSClient, ws.WSServer.MaxConnNum)
+	ws.WSServer.NewAgent = ws.NewWSClient
 
 	//4.设置网络事件处理
 	ws.GetEventProcessor().RegEventReceiverFunc(event.Sys_Event_WebSocket, ws.GetEventHandler(), ws.wsEventHandler)
@@ -80,7 +80,7 @@ func (ws *WSModule) Init(wsCfg *WSCfg, process processor.IRawProcessor) {
 }
 
 func (ws *WSModule) Start() error {
-	return ws.wsServer.Start()
+	return ws.WSServer.Start()
 }
 
 func (ws *WSModule) wsEventHandler(ev event.IEvent) {
@@ -197,3 +197,7 @@ func (ws *WSModule) SendRawMsg(clientId string, msg []byte) error {
 	ws.mapClientLocker.Unlock()
 	return client.wsConn.WriteMsg(msg)
 }
+
+func (ws *WSModule) SetMessageType(messageType int) {
+	ws.WSServer.SetMessageType(messageType)
+}

util/smath/smath.go

@@ -32,10 +32,10 @@ func Abs[NumType typ.Signed | typ.Float](Num NumType) NumType {
 func AddSafe[NumType typ.Number](number1 NumType, number2 NumType) (NumType, bool) {
 	ret := number1 + number2
 	if number2 > 0 && ret < number1 {
-		log.Stack("Calculation overflow", log.Any("number1", number1), log.Any("number2", number2))
+		log.SStackError("Calculation overflow", log.Any("number1", number1), log.Any("number2", number2))
 		return ret, false
 	} else if number2 < 0 && ret > number1 {
-		log.Stack("Calculation overflow", log.Any("number1", number1), log.Any("number2", number2))
+		log.SStackError("Calculation overflow", log.Any("number1", number1), log.Any("number2", number2))
 		return ret, false
 	}
 
@@ -45,10 +45,10 @@ func AddSafe[NumType typ.Number](number1 NumType, number2 NumType) (NumType, boo
 func SubSafe[NumType typ.Number](number1 NumType, number2 NumType) (NumType, bool) {
 	ret := number1 - number2
 	if number2 > 0 && ret > number1 {
-		log.Stack("Calculation overflow", log.Any("number1", number1), log.Any("number2", number2))
+		log.SStackError("Calculation overflow", log.Any("number1", number1), log.Any("number2", number2))
 		return ret, false
 	} else if number2 < 0 && ret < number1 {
-		log.Stack("Calculation overflow", log.Any("number1", number1), log.Any("number2", number2))
+		log.SStackError("Calculation overflow", log.Any("number1", number1), log.Any("number2", number2))
 		return ret, false
 	}
 
@@ -65,7 +65,7 @@ func MulSafe[NumType typ.Number](number1 NumType, number2 NumType) (NumType, boo
 		return ret, true
 	}
 
-	log.Stack("Calculation overflow", log.Any("number1", number1), log.Any("number2", number2))
+	log.SStackError("Calculation overflow", log.Any("number1", number1), log.Any("number2", number2))
 	return ret, true
 }