优化服务筛选

2.优化日志

README.md

@@ -661,51 +661,7 @@ Module1 Release.
 第四章：事件使用
 ----------------
 
-事件是origin中一个重要的组成部分，可以在同一个node中的service与service或者与module之间进行事件通知。系统内置的几个服务，如：TcpService/HttpService等都是通过事件功能实现。他也是一个典型的观察者设计模型。在event中有两个类型的interface，一个是event.IEventProcessor它提供注册与卸载功能，另一个是event.IEventHandler提供消息广播等功能。
+事件是origin中一个重要的组成部分，可以在服务与各module之间进行事件通知。它也是一个典型的观察者设计模型。在event中有两个类型的interface，一个是event.IEventProcessor它提供注册与卸载功能，另一个是event.IEventHandler提供消息广播等功能。
-
-在目录simple_event/TestService4.go中
-
-```
-package simple_event
-
-import (
-    "github.com/duanhf2012/origin/v2/event"
-    "github.com/duanhf2012/origin/v2/node"
-    "github.com/duanhf2012/origin/v2/service"
-    "time"
-)
-
-const (
-    //自定义事件类型，必需从event.Sys_Event_User_Define开始
-    //event.Sys_Event_User_Define以内给系统预留
-    EVENT1 event.EventType =event.Sys_Event_User_Define+1
-)
-
-func init(){
-    node.Setup(&TestService4{})
-}
-
-type TestService4 struct {
-    service.Service
-}
-
-func (slf *TestService4) OnInit() error {
-    //10秒后触发广播事件
-    slf.AfterFunc(time.Second*10,slf.TriggerEvent)
-    return nil
-}
-
-func (slf *TestService4) TriggerEvent(){
-    //广播事件，传入event.Event对象，类型为EVENT1,Data可以自定义任何数据
-    //这样，所有监听者都可以收到该事件
-    slf.GetEventHandler().NotifyEvent(&event.Event{
-        Type: EVENT1,
-        Data: "event data.",
-    })
-}
-
-
-```
 
 在目录simple_event/TestService5.go中
 
@@ -713,53 +669,68 @@ func (slf *TestService4) TriggerEvent(){
 package simple_event
 
 import (
-    "fmt"
+	"fmt"
-    "github.com/duanhf2012/origin/v2/event"
+	"github.com/duanhf2012/origin/v2/event"
-    "github.com/duanhf2012/origin/v2/node"
+	"github.com/duanhf2012/origin/v2/node"
-    "github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/v2/service"
+	"github.com/duanhf2012/origin/v2/util/timer"
+	"time"
 )
 
-func init(){
+func init() {
-    node.Setup(&TestService5{})
+	node.Setup(&TestService5{})
 }
 
+const (
+	//自定义事件类型，必需从event.Sys_Event_User_Define开始
+	//event.Sys_Event_User_Define以内给系统预留
+	EVENT1 event.EventType = event.Sys_Event_User_Define + 1
+)
+
 type TestService5 struct {
-    service.Service
+	service.Service
 }
 
 type TestModule struct {
-    service.Module
+	service.Module
 }
 
-func (slf *TestModule) OnInit() error{
+func (slf *TestModule) OnInit() error {
-    //在当前node中查找TestService4
+	//在TestModule中注册监听EVENT1事件
-    pService := node.GetService("TestService4")
+	slf.GetEventProcessor().RegEventReceiverFunc(EVENT1, slf.GetEventHandler(), slf.OnModuleEvent)
 
-    //在TestModule中，往TestService4中注册EVENT1类型事件监听
+	return nil
-    pService.(*TestService4).GetEventProcessor().RegEventReciverFunc(EVENT1,slf.GetEventHandler(),slf.OnModuleEvent)
-    return nil
 }
 
-func (slf *TestModule) OnModuleEvent(ev event.IEvent){
+// OnModuleEvent 模块监听事件回调
-    event := ev.(*event.Event)
+func (slf *TestModule) OnModuleEvent(ev event.IEvent) {
-    fmt.Printf("OnModuleEvent type :%d data:%+v\n",event.GetEventType(),event.Data)
+	event := ev.(*event.Event)
+	fmt.Printf("OnModuleEvent type :%d data:%+v\n", event.GetEventType(), event.Data)
 }
 
-
+// OnInit 服务初始化函数，在安装服务时，服务将自动调用OnInit函数
-//服务初始化函数，在安装服务时，服务将自动调用OnInit函数
 func (slf *TestService5) OnInit() error {
-    //通过服务名获取服务对象
+	//在服务中注册监听EVENT1类型事件
-    pService := node.GetService("TestService4")
+	slf.RegEventReceiverFunc(EVENT1, slf.GetEventHandler(), slf.OnServiceEvent)
+	slf.AddModule(&TestModule{})
 
-    ////在TestModule中，往TestService4中注册EVENT1类型事件监听
+	slf.AfterFunc(time.Second*10, slf.TriggerEvent)
-    pService.(*TestService4).GetEventProcessor().RegEventReciverFunc(EVENT1,slf.GetEventHandler(),slf.OnServiceEvent)
+	return nil
-    slf.AddModule(&TestModule{})
-    return nil
 }
 
-func (slf *TestService5) OnServiceEvent(ev event.IEvent){
+// OnServiceEvent 服务监听事件回调
-    event := ev.(*event.Event)
+func (slf *TestService5) OnServiceEvent(ev event.IEvent) {
-    fmt.Printf("OnServiceEvent type :%d data:%+v\n",event.Type,event.Data)
+	event := ev.(*event.Event)
+	fmt.Printf("OnServiceEvent type :%d data:%+v\n", event.Type, event.Data)
+}
+
+func (slf *TestService5) TriggerEvent(t *timer.Timer) {
+	//广播事件，传入event.Event对象，类型为EVENT1,Data可以自定义任何数据
+	//这样，所有监听者都可以收到该事件
+	slf.GetEventHandler().NotifyEvent(&event.Event{
+		Type: EVENT1,
+		Data: "event data.",
+	})
 }
 
 
@@ -768,8 +739,8 @@ func (slf *TestService5) OnServiceEvent(ev event.IEvent){
 程序运行10秒后，调用slf.TriggerEvent函数广播事件，于是在TestService5中会收到
 
 ```
-OnServiceEvent type :1001 data:event data.
+OnServiceEvent type :2 data:event data.
-OnModuleEvent type :1001 data:event data.
+OnModuleEvent type :2 data:event data.
 ```
 
 在上面的TestModule中监听的事情，当这个Module被Release时监听会自动卸载。
@@ -1181,6 +1152,8 @@ func (slf *TestTcpService) OnRequest (clientid string,msg proto.Message){
 * log/log.go:日志的封装，可以使用它构建对象记录业务文件日志
 * util:在该目录下，有常用的uuid,hash,md5,协程封装等工具库
 * https://github.com/duanhf2012/originservice: 其他扩展支持的服务可以在该工程上看到，目前支持firebase推送的封装。
+* https://github.com/duanhf2012/origingame: 基础游戏服务器的框架
+* etcd与nats开发环境搭建可以从https://github.com/duanhf2012/originserver_v2下的docker-compose获取
 
 备注:
 -----

cluster/cluster.go

@@ -8,6 +8,8 @@ import (
 	"strings"
 	"sync"
 	"github.com/duanhf2012/origin/v2/event"
+	"errors"
+	"reflect"
 )
 
 var configDir = "./config/"
@@ -62,6 +64,7 @@ type Cluster struct {
 	locker         sync.RWMutex                //结点与服务关系保护锁
 	mapRpc           map[string]*NodeRpcInfo    //nodeId
 	mapServiceNode map[string]map[string]struct{} //map[serviceName]map[NodeId]
+	mapTemplateServiceNode map[string]map[string]struct{} //map[templateServiceName]map[serviceName]nodeId
 
 	callSet rpc.CallSet
 	rpcNats rpc.RpcNats
@@ -137,6 +140,20 @@ func (cls *Cluster) delServiceNode(serviceName string, nodeId string) {
 		return
 	}
 
+	//处理模板服务
+	splitServiceName := strings.Split(serviceName,":")
+	if len(splitServiceName) == 2 {
+		serviceName = splitServiceName[0]
+		templateServiceName := splitServiceName[1]
+
+		mapService := cls.mapTemplateServiceNode[templateServiceName]
+		delete(mapService,serviceName)
+
+		if len(cls.mapTemplateServiceNode[templateServiceName]) == 0 {
+			delete(cls.mapTemplateServiceNode,templateServiceName)
+		}
+	}
+
 	mapNode := cls.mapServiceNode[serviceName]
 	delete(mapNode, nodeId)
 	if len(mapNode) == 0 {
@@ -171,7 +188,20 @@ func (cls *Cluster) serviceDiscoverySetNodeInfo(nodeInfo *NodeInfo) {
 			continue
 		}
 		mapDuplicate[serviceName] = nil
-		if _, ok := cls.mapServiceNode[serviceName]; ok == false {
+
+		//如果是模板服务，则记录模板关系
+		splitServiceName := strings.Split(serviceName,":")
+		if len(splitServiceName) == 2 {
+			serviceName = splitServiceName[0]
+			templateServiceName := splitServiceName[1]
+			//记录模板
+			if _, ok = cls.mapTemplateServiceNode[templateServiceName]; ok == false {
+				cls.mapTemplateServiceNode[templateServiceName]=map[string]struct{}{}
+			}
+			cls.mapTemplateServiceNode[templateServiceName][serviceName] = struct{}{}
+		}
+
+		if _, ok = cls.mapServiceNode[serviceName]; ok == false {
 			cls.mapServiceNode[serviceName] = make(map[string]struct{}, 1)
 		}
 		cls.mapServiceNode[serviceName][nodeInfo.NodeId] = struct{}{}
@@ -259,25 +289,29 @@ func (cls *Cluster) GetRpcClient(nodeId string) (*rpc.Client,bool) {
 	return cls.getRpcClient(nodeId)
 }
 
-func GetRpcClient(nodeId string, serviceMethod string,filterRetire bool, clientList []*rpc.Client) (error, int) {
+func GetNodeIdByTemplateService(templateServiceName string, rpcClientList []*rpc.Client, filterRetire bool) (error, []*rpc.Client) {
+	return GetCluster().GetNodeIdByTemplateService(templateServiceName, rpcClientList, filterRetire)
+}
+
+func GetRpcClient(nodeId string, serviceMethod string,filterRetire bool, clientList []*rpc.Client) (error, []*rpc.Client) {
 	if nodeId != rpc.NodeIdNull {
 		pClient,retire := GetCluster().GetRpcClient(nodeId)
 		if pClient == nil {
-			return fmt.Errorf("cannot find  nodeid %d!", nodeId), 0
+			return fmt.Errorf("cannot find  nodeid %d!", nodeId), nil
 		}
 
 		//如果需要筛选掉退休结点
 		if filterRetire == true && retire == true {
-			return fmt.Errorf("cannot find  nodeid %d!", nodeId), 0
+			return fmt.Errorf("cannot find  nodeid %d!", nodeId), nil
 		}
 
-		clientList[0] = pClient
+		clientList = append(clientList,pClient)
-		return nil, 1
+		return nil, clientList
 	}
 
 	findIndex := strings.Index(serviceMethod, ".")
 	if findIndex == -1 {
-		return fmt.Errorf("servicemethod param  %s is error!", serviceMethod), 0
+		return fmt.Errorf("servicemethod param  %s is error!", serviceMethod), nil
 	}
 	serviceName := serviceMethod[:findIndex]
 
@@ -376,10 +410,50 @@ func GetNodeByServiceName(serviceName string) map[string]struct{} {
 	return mapNodeId
 }
 
+// GetNodeByTemplateServiceName 通过模板服务名获取服务名,返回 map[serviceName真实服务名]NodeId
+func GetNodeByTemplateServiceName(templateServiceName string) map[string]string {
+	cluster.locker.RLock()
+	defer cluster.locker.RUnlock()
+
+	mapServiceName := cluster.mapTemplateServiceNode[templateServiceName]
+	mapNodeId := make(map[string]string,9)
+	for serviceName := range mapServiceName {
+		mapNode, ok := cluster.mapServiceNode[serviceName]
+		if ok == false {
+			return nil
+		}
+
+		for nodeId,_ := range mapNode {
+			mapNodeId[serviceName] = nodeId
+		}
+	}
+
+	return mapNodeId
+}
+
 func (cls *Cluster) GetGlobalCfg() interface{} {
 	return cls.globalCfg
 }
 
+
+func (cls *Cluster) ParseGlobalCfg(cfg interface{}) error{
+	if  cls.globalCfg == nil {
+		return errors.New("no service configuration found")
+	}
+
+	rv := reflect.ValueOf(cls.globalCfg)
+	if  rv.Kind() == reflect.Ptr && rv.IsNil() {
+		return errors.New("no service configuration found")
+	}
+
+	bytes,err := json.Marshal(cls.globalCfg)
+	if err != nil {
+		return err
+	}
+
+	return json.Unmarshal(bytes,cfg)
+}
+
 func (cls *Cluster) GetNodeInfo(nodeId string) (NodeInfo,bool) {
 	cls.locker.RLock()
 	defer cls.locker.RUnlock()
@@ -395,6 +469,11 @@ func (cls *Cluster) GetNodeInfo(nodeId string) (NodeInfo,bool) {
 func (dc *Cluster) CanDiscoveryService(fromMasterNodeId string,serviceName string) bool{
 	canDiscovery := true
 
+	splitServiceName := strings.Split(serviceName,":")
+	if len(splitServiceName) == 2 {
+		serviceName = splitServiceName[0]
+	}
+
 	for i:=0;i<len(dc.GetLocalNodeInfo().DiscoveryService);i++{
 		masterNodeId := dc.GetLocalNodeInfo().DiscoveryService[i].MasterNodeId
 		//无效的配置，则跳过

cluster/origindiscovery.go

@@ -160,6 +160,12 @@ func (dc *OriginDiscoveryMaster)  OnNatsDisconnect(){
 }
 
 func (ds *OriginDiscoveryMaster) OnNodeConnected(nodeId string) {
+	var notifyDiscover rpc.SubscribeDiscoverNotify
+	notifyDiscover.IsFull = true
+	notifyDiscover.NodeInfo = ds.nodeInfo
+	notifyDiscover.MasterNodeId = cluster.GetLocalNodeInfo().NodeId
+
+	ds.GoNode(nodeId, SubServiceDiscover, &notifyDiscover)
 }
 
 func (ds *OriginDiscoveryMaster) OnNodeDisconnect(nodeId string) {
@@ -183,6 +189,10 @@ func (ds *OriginDiscoveryMaster) OnNodeDisconnect(nodeId string) {
 
 func (ds *OriginDiscoveryMaster) RpcCastGo(serviceMethod string, args interface{}) {
 	for nodeId, _ := range ds.mapNodeInfo {
+		if nodeId == cluster.GetLocalNodeInfo().NodeId {
+			continue
+		}
+
 		ds.GoNode(nodeId, serviceMethod, args)
 	}
 }

cluster/parsecfg.go

@@ -270,7 +270,7 @@ func (cls *Cluster) readLocalClusterConfig(nodeId string) (DiscoveryInfo, []Node
 	}
 
 	if nodeId != rpc.NodeIdNull && (len(nodeInfoList) != 1) {
-		return discoveryInfo, nil,rpcMode, fmt.Errorf("%d configurations were found for the configuration with node ID %d!", len(nodeInfoList), nodeId)
+		return discoveryInfo, nil,rpcMode, fmt.Errorf("nodeid %s configuration error in NodeList", nodeId)
 	}
 
 	for i, _ := range nodeInfoList {
@@ -325,6 +325,10 @@ func (cls *Cluster) readLocalService(localNodeId string) error {
 		//保存公共配置
 		for _, s := range cls.localNodeInfo.ServiceList {
 			for {
+				splitServiceName := strings.Split(s,":")
+				if len(splitServiceName) == 2 {
+					s = splitServiceName[0]
+				}
 				//取公共服务配置
 				pubCfg, ok := serviceConfig[s]
 				if ok == true {
@@ -355,6 +359,11 @@ func (cls *Cluster) readLocalService(localNodeId string) error {
 
 	//组合所有的配置
 	for _, s := range cls.localNodeInfo.ServiceList {
+		splitServiceName := strings.Split(s,":")
+		if len(splitServiceName) == 2 {
+			s = splitServiceName[0]
+		}
+
 		//先从NodeService中找
 		var serviceCfg interface{}
 		var ok bool
@@ -382,12 +391,24 @@ func (cls *Cluster) parseLocalCfg() {
 
 	cls.mapRpc[cls.localNodeInfo.NodeId] = &rpcInfo
 
-	for _, sName := range cls.localNodeInfo.ServiceList {
+	for _, serviceName := range cls.localNodeInfo.ServiceList {
-		if _, ok := cls.mapServiceNode[sName]; ok == false {
+		splitServiceName := strings.Split(serviceName,":")
-			cls.mapServiceNode[sName] = make(map[string]struct{})
+		if len(splitServiceName) == 2 {
+			serviceName = splitServiceName[0]
+			templateServiceName := splitServiceName[1]
+			//记录模板
+			if _, ok := cls.mapTemplateServiceNode[templateServiceName]; ok == false {
+				cls.mapTemplateServiceNode[templateServiceName]=map[string]struct{}{}
+			}
+			cls.mapTemplateServiceNode[templateServiceName][serviceName] = struct{}{}
 		}
 
-		cls.mapServiceNode[sName][cls.localNodeInfo.NodeId] = struct{}{}
+
+		if _, ok := cls.mapServiceNode[serviceName]; ok == false {
+			cls.mapServiceNode[serviceName] = make(map[string]struct{})
+		}
+
+		cls.mapServiceNode[serviceName][cls.localNodeInfo.NodeId] = struct{}{}
 	}
 }
 
@@ -403,6 +424,7 @@ func (cls *Cluster) InitCfg(localNodeId string) error {
 	cls.localServiceCfg = map[string]interface{}{}
 	cls.mapRpc = map[string]*NodeRpcInfo{}
 	cls.mapServiceNode = map[string]map[string]struct{}{}
+	cls.mapTemplateServiceNode = map[string]map[string]struct{}{}
 
 	//加载本地结点的NodeList配置
 	discoveryInfo, nodeInfoList,rpcMode, err := cls.readLocalClusterConfig(localNodeId)
@@ -436,12 +458,37 @@ func (cls *Cluster) IsConfigService(serviceName string) bool {
 	return ok
 }
 
+func (cls *Cluster) GetNodeIdByTemplateService(templateServiceName string, rpcClientList []*rpc.Client, filterRetire bool) (error, []*rpc.Client) {
+	cls.locker.RLock()
+	defer cls.locker.RUnlock()
 
-func (cls *Cluster) GetNodeIdByService(serviceName string, rpcClientList []*rpc.Client, filterRetire bool) (error, int) {
+	mapServiceName := cls.mapTemplateServiceNode[templateServiceName]
+	 for serviceName := range mapServiceName {
+		 mapNodeId, ok := cls.mapServiceNode[serviceName]
+		 if ok == true {
+			 for nodeId, _ := range mapNodeId {
+				 pClient,retire := GetCluster().getRpcClient(nodeId)
+				 if pClient == nil || pClient.IsConnected() == false {
+					 continue
+				 }
+
+				 //如果需要筛选掉退休的，对retire状态的结点略过
+				 if filterRetire == true && retire == true {
+					 continue
+				 }
+
+				 rpcClientList = append(rpcClientList,pClient)
+			 }
+		 }
+	 }
+
+	return nil, rpcClientList
+}
+
+func (cls *Cluster) GetNodeIdByService(serviceName string, rpcClientList []*rpc.Client, filterRetire bool) (error, []*rpc.Client) {
 	cls.locker.RLock()
 	defer cls.locker.RUnlock()
 	mapNodeId, ok := cls.mapServiceNode[serviceName]
-	count := 0
 	if ok == true {
 		for nodeId, _ := range mapNodeId {
 			pClient,retire := GetCluster().getRpcClient(nodeId)
@@ -454,15 +501,11 @@ func (cls *Cluster) GetNodeIdByService(serviceName string, rpcClientList []*rpc.
 				continue
 			}
 
-			rpcClientList[count] = pClient
+			rpcClientList = append(rpcClientList,pClient)
-			count++
-			if count >= cap(rpcClientList) {
-				break
-			}
 		}
 	}
 
-	return nil, count
+	return nil, rpcClientList
 }
 
 func (cls *Cluster) GetServiceCfg(serviceName string) interface{} {

concurrent/dispatch.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/duanhf2012/origin/v2/log"
 	"github.com/duanhf2012/origin/v2/util/queue"
+	"context"
 )
 
 var idleTimeout = int64(2 * time.Second)
@@ -30,6 +31,9 @@ type dispatch struct {
 
 	waitWorker   sync.WaitGroup
 	waitDispatch sync.WaitGroup
+
+	cancelContext context.Context
+	cancel context.CancelFunc
 }
 
 func (d *dispatch) open(minGoroutineNum int32, maxGoroutineNum int32, tasks chan task, cbChannel chan func(error)) {
@@ -40,7 +44,7 @@ func (d *dispatch) open(minGoroutineNum int32, maxGoroutineNum int32, tasks chan
 	d.workerQueue = make(chan task)
 	d.cbChannel = cbChannel
 	d.queueIdChannel = make(chan int64, cap(tasks))
-
+	d.cancelContext,d.cancel = context.WithCancel(context.Background())
 	d.waitDispatch.Add(1)
 	go d.run()
 }
@@ -64,10 +68,12 @@ func (d *dispatch) run() {
 				d.processqueueEvent(queueId)
 			case <-timeout.C:
 				d.processTimer()
-				if atomic.LoadInt32(&d.minConcurrentNum) == -1 && len(d.tasks) == 0 {
+			case <- d.cancelContext.Done():
-					atomic.StoreInt64(&idleTimeout,int64(time.Millisecond * 10))
+				atomic.StoreInt64(&idleTimeout,int64(time.Millisecond * 5))
-				}
 				timeout.Reset(time.Duration(atomic.LoadInt64(&idleTimeout)))
+				for i:=int32(0);i<d.workerNum;i++{
+					d.processIdle()
+				}
 			}
 		}
 
@@ -166,6 +172,8 @@ func (c *dispatch) pushAsyncDoCallbackEvent(cb func(err error)) {
 
 func (d *dispatch) close() {
 	atomic.StoreInt32(&d.minConcurrentNum, -1)
+	d.cancel()
+
 
 breakFor:
 	for {

event/eventtype.go

@@ -17,6 +17,7 @@ const (
 	Sys_Event_QueueTaskFinish  	EventType = -10
 	Sys_Event_Retire       		EventType = -11
 	Sys_Event_EtcdDiscovery 	EventType = -12
+	Sys_Event_Gin_Event 		EventType = -13
 	
 	Sys_Event_User_Define 		EventType = 1
 )

log/handler.go

@@ -10,16 +10,20 @@ import (
 	"sync"
 )
 
+const defaultSkip = 7
 type IOriginHandler interface {
 	slog.Handler
 	Lock()
 	UnLock()
+	SetSkip(skip int)
+	GetSkip() int
 }
 
 type BaseHandler struct {
 	addSource bool
 	w io.Writer
 	locker sync.Mutex
+	skip int
 }
 
 type OriginTextHandler struct {
@@ -32,6 +36,14 @@ type OriginJsonHandler struct {
 	*slog.JSONHandler
 }
 
+func (bh *BaseHandler) SetSkip(skip int){
+	bh.skip = skip
+}
+
+func (bh *BaseHandler) GetSkip() int{
+	return bh.skip
+}
+
 func getStrLevel(level slog.Level) string{
 	switch level {
 	case LevelTrace:
@@ -78,6 +90,7 @@ func NewOriginTextHandler(level slog.Level,w io.Writer,addSource bool,replaceAtt
 		ReplaceAttr: replaceAttr,
 	})
 
+	textHandler.skip  = defaultSkip
 	return &textHandler
 }
 
@@ -124,6 +137,7 @@ func NewOriginJsonHandler(level slog.Level,w io.Writer,addSource bool,replaceAtt
 		ReplaceAttr: replaceAttr,
 	})
 
+	jsonHandler.skip = defaultSkip
 	return &jsonHandler
 }
 
@@ -141,7 +155,7 @@ func (oh *OriginJsonHandler) Handle(context context.Context, record slog.Record)
 func (b *BaseHandler) Fill(context context.Context, record *slog.Record) {
 	if b.addSource {
 		var pcs [1]uintptr
-		runtime.Callers(7, pcs[:])
+		runtime.Callers(b.skip, pcs[:])
 		record.PC = pcs[0]
 	}
 }

log/log.go

@@ -239,6 +239,10 @@ func (iw *IoWriter) swichFile() error{
 	return nil
 }
 
+func GetDefaultHandler() IOriginHandler{
+	return gLogger.(*Logger).Slogger.Handler().(IOriginHandler)
+}
+
 func NewTextLogger(level slog.Level,pathName string,filePrefix string,addSource bool,logChannelCap int) (ILogger,error){
 	var logger Logger
 	logger.ioWriter.filePath = pathName

network/processor/jsonprocessor.go

@@ -45,8 +45,10 @@ func (jsonProcessor *JsonProcessor) SetByteOrder(littleEndian bool) {
 }
 
 // must goroutine safe
-func (jsonProcessor *JsonProcessor ) MsgRoute(clientId string,msg interface{}) error{
+func (jsonProcessor *JsonProcessor ) MsgRoute(clientId string,msg interface{},recyclerReaderBytes func(data []byte)) error{
 	pPackInfo := msg.(*JsonPackInfo)
+	defer recyclerReaderBytes(pPackInfo.rawMsg)
+
 	v,ok := jsonProcessor.mapMsg[pPackInfo.typ]
 	if ok == false {
 		return fmt.Errorf("cannot find msgtype %d is register!",pPackInfo.typ)
@@ -58,7 +60,6 @@ func (jsonProcessor *JsonProcessor ) MsgRoute(clientId string,msg interface{}) e
 
 func (jsonProcessor *JsonProcessor) Unmarshal(clientId string,data []byte) (interface{}, error) {
 	typeStruct := struct {Type int `json:"typ"`}{}
-	defer jsonProcessor.ReleaseBytes(data)
 	err := json.Unmarshal(data, &typeStruct)
 	if err != nil {
 		return nil, err
@@ -76,7 +77,7 @@ func (jsonProcessor *JsonProcessor) Unmarshal(clientId string,data []byte) (inte
 		return nil,err
 	}
 
-	return &JsonPackInfo{typ:msgType,msg:msgData},nil
+	return &JsonPackInfo{typ:msgType,msg:msgData,rawMsg: data},nil
 }
 
 func (jsonProcessor *JsonProcessor) Marshal(clientId string,msg interface{}) ([]byte, error) {
@@ -104,7 +105,8 @@ func (jsonProcessor *JsonProcessor) MakeRawMsg(msgType uint16,msg []byte) *JsonP
 	return &JsonPackInfo{typ:msgType,rawMsg:msg}
 }
 
-func (jsonProcessor *JsonProcessor) UnknownMsgRoute(clientId string,msg interface{}){
+func (jsonProcessor *JsonProcessor) UnknownMsgRoute(clientId string,msg interface{},recyclerReaderBytes func(data []byte)){
+	defer recyclerReaderBytes(msg.([]byte))
 	if jsonProcessor.unknownMessageHandler==nil {
 		log.Debug("Unknown message",log.String("clientId",clientId))
 		return

network/processor/pbprocessor.go

@@ -54,8 +54,10 @@ func (slf *PBPackInfo) GetMsg() proto.Message {
 }
 
 // must goroutine safe
-func (pbProcessor *PBProcessor) MsgRoute(clientId string, msg interface{}) error {
+func (pbProcessor *PBProcessor) MsgRoute(clientId string, msg interface{},recyclerReaderBytes func(data []byte)) error {
 	pPackInfo := msg.(*PBPackInfo)
+	defer recyclerReaderBytes(pPackInfo.rawMsg)
+	
 	v, ok := pbProcessor.mapMsg[pPackInfo.typ]
 	if ok == false {
 		return fmt.Errorf("Cannot find msgtype %d is register!", pPackInfo.typ)
@@ -67,7 +69,6 @@ func (pbProcessor *PBProcessor) MsgRoute(clientId string, msg interface{}) error
 
 // must goroutine safe
 func (pbProcessor *PBProcessor) Unmarshal(clientId string, data []byte) (interface{}, error) {
-	defer pbProcessor.ReleaseBytes(data)
 	return pbProcessor.UnmarshalWithOutRelease(clientId, data)
 }
 
@@ -91,7 +92,7 @@ func (pbProcessor *PBProcessor) UnmarshalWithOutRelease(clientId string, data []
 		return nil, err
 	}
 
-	return &PBPackInfo{typ: msgType, msg: protoMsg}, nil
+	return &PBPackInfo{typ: msgType, msg: protoMsg,rawMsg:data}, nil
 }
 
 // must goroutine safe
@@ -133,8 +134,9 @@ func (pbProcessor *PBProcessor) MakeRawMsg(msgType uint16, msg []byte) *PBPackIn
 	return &PBPackInfo{typ: msgType, rawMsg: msg}
 }
 
-func (pbProcessor *PBProcessor) UnknownMsgRoute(clientId string, msg interface{}) {
+func (pbProcessor *PBProcessor) UnknownMsgRoute(clientId string, msg interface{},recyclerReaderBytes func(data []byte)) {
 	pbProcessor.unknownMessageHandler(clientId, msg.([]byte))
+	recyclerReaderBytes(msg.([]byte))
 }
 
 // connect event

network/processor/pbrawprocessor.go

@@ -38,9 +38,11 @@ func (pbRawProcessor *PBRawProcessor) SetByteOrder(littleEndian bool) {
 }
 
 // must goroutine safe
-func (pbRawProcessor *PBRawProcessor ) MsgRoute(clientId string, msg interface{}) error{
+func (pbRawProcessor *PBRawProcessor ) MsgRoute(clientId string, msg interface{},recyclerReaderBytes func(data []byte)) error{
 	pPackInfo := msg.(*PBRawPackInfo)
 	pbRawProcessor.msgHandler(clientId,pPackInfo.typ,pPackInfo.rawMsg)
+	recyclerReaderBytes(pPackInfo.rawMsg)
+	
 	return nil
 }
 
@@ -80,7 +82,8 @@ func (pbRawProcessor *PBRawProcessor) MakeRawMsg(msgType uint16,msg []byte,pbRaw
 	pbRawPackInfo.rawMsg = msg
 }
 
-func (pbRawProcessor *PBRawProcessor) UnknownMsgRoute(clientId string,msg interface{}){
+func (pbRawProcessor *PBRawProcessor) UnknownMsgRoute(clientId string,msg interface{},recyclerReaderBytes func(data []byte)){
+	defer recyclerReaderBytes(msg.([]byte))
 	if pbRawProcessor.unknownMessageHandler == nil {
 		return
 	}

network/processor/processor.go

@@ -3,9 +3,9 @@ package processor
 
 type IProcessor interface {
 	// must goroutine safe
-	MsgRoute(clientId string,msg interface{}) error
+	MsgRoute(clientId string,msg interface{},recyclerReaderBytes func(data []byte)) error
 	//must goroutine safe
-	UnknownMsgRoute(clientId string,msg interface{})
+	UnknownMsgRoute(clientId string,msg interface{},recyclerReaderBytes func(data []byte))
 	// connect event
 	ConnectedRoute(clientId string)
 	DisConnectedRoute(clientId string)

network/tcp_conn.go

@@ -129,6 +129,13 @@ func (tcpConn *TCPConn) ReadMsg() ([]byte, error) {
 	return tcpConn.msgParser.Read(tcpConn)
 }
 
+func (tcpConn *TCPConn) GetRecyclerReaderBytes() func (data []byte) {
+	bytePool := tcpConn.msgParser.IBytesMempool
+	return func(data []byte) {
+		bytePool.ReleaseBytes(data)
+	}
+}
+
 func (tcpConn *TCPConn) ReleaseReadMsg(byteBuff []byte){
 	tcpConn.msgParser.ReleaseBytes(byteBuff)
 }

node/node.go

@@ -25,9 +25,11 @@ import (
 var sig chan os.Signal
 var nodeId string
 var preSetupService []service.IService //预安装
+var preSetupTemplateService []func()service.IService
 var profilerInterval time.Duration
 var bValid bool
 var configDir = "./config/"
+var NodeIsRun = false
 
 const(
 	SingleStop   syscall.Signal = 10
@@ -56,7 +58,7 @@ func init() {
 	console.RegisterCommandString("loglevel", "debug", "<-loglevel debug|release|warning|error|fatal> Set loglevel.", setLevel)
 	console.RegisterCommandString("logpath", "", "<-logpath path> Set log file path.", setLogPath)
 	console.RegisterCommandInt("logsize", 0, "<-logsize size> Set log size(MB).", setLogSize)
-	console.RegisterCommandInt("logchannelcap", 0, "<-logchannelcap num> Set log channel cap.", setLogChannelCapNum)
+	console.RegisterCommandInt("logchannelcap", -1, "<-logchannelcap num> Set log channel cap.", setLogChannelCapNum)
 	console.RegisterCommandString("pprof", "", "<-pprof ip:port> Open performance analysis.", setPprof)
 }
 
@@ -169,6 +171,31 @@ func initNode(id string) {
 	serviceOrder := cluster.GetCluster().GetLocalNodeInfo().ServiceList
 	for _,serviceName:= range serviceOrder{
 		bSetup := false
+
+		//判断是否有配置模板服务
+		splitServiceName := strings.Split(serviceName,":")
+		if len(splitServiceName) == 2 {
+			serviceName = splitServiceName[0]
+			templateServiceName :=  splitServiceName[1]
+			for _,newSer := range preSetupTemplateService {
+				ser := newSer()
+				ser.OnSetup(ser)
+				if ser.GetName() == templateServiceName {
+					ser.SetName(serviceName)
+					ser.Init(ser,cluster.GetRpcClient,cluster.GetRpcServer,cluster.GetCluster().GetServiceCfg(ser.GetName()))
+					service.Setup(ser)
+
+					bSetup = true
+					break
+				}
+			}
+
+			if bSetup == false{
+				log.Error("Template service not found",log.String("service name",serviceName),log.String("template service name",templateServiceName))
+				os.Exit(1)
+			}
+		}
+
 		for _, s := range preSetupService {
 			if s.GetName() != serviceName {
 				continue
@@ -328,13 +355,14 @@ func startNode(args interface{}) error {
 	cluster.GetCluster().Start()
 	
 	//6.监听程序退出信号&性能报告
-	bRun := true
+
 	var pProfilerTicker *time.Ticker = &time.Ticker{}
 	if profilerInterval > 0 {
 		pProfilerTicker = time.NewTicker(profilerInterval)
 	}
 
-	for bRun {
+	NodeIsRun = true
+	for NodeIsRun {
 		select {
 		case s := <-sig:
 			signal := s.(syscall.Signal)
@@ -342,7 +370,7 @@ func startNode(args interface{}) error {
 				log.Info("receipt retire signal.")
 				notifyAllServiceRetire()
 			}else {
-				bRun = false
+				NodeIsRun = false
 				log.Info("receipt stop signal.")
 			}
 		case <-pProfilerTicker.C:
@@ -367,6 +395,12 @@ func Setup(s ...service.IService) {
 	}
 }
 
+func SetupTemplate(fs ...func()service.IService){
+	for _, f := range fs {
+		preSetupTemplateService = append(preSetupTemplateService, f)
+	}
+}
+
 func GetService(serviceName string) service.IService {
 	return service.GetService(serviceName)
 }
@@ -472,6 +506,10 @@ func setLogChannelCapNum(args interface{}) error {
 		return errors.New("param logsize is error")
 	}
 
+	if logChannelCap == -1 {
+		return nil
+	}
+
 	log.LogChannelCap = logChannelCap
 	return nil
 }

rpc/messagequeue.pb.go

@@ -1,8 +1,8 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.31.0
-// 	protoc        v3.11.4
+// 	protoc        v4.24.0
-// source: test/rpc/messagequeue.proto
+// source: rpcproto/messagequeue.proto
 
 package rpc
 
@@ -50,11 +50,11 @@ func (x SubscribeType) String() string {
 }
 
 func (SubscribeType) Descriptor() protoreflect.EnumDescriptor {
-	return file_test_rpc_messagequeue_proto_enumTypes[0].Descriptor()
+	return file_rpcproto_messagequeue_proto_enumTypes[0].Descriptor()
 }
 
 func (SubscribeType) Type() protoreflect.EnumType {
-	return &file_test_rpc_messagequeue_proto_enumTypes[0]
+	return &file_rpcproto_messagequeue_proto_enumTypes[0]
 }
 
 func (x SubscribeType) Number() protoreflect.EnumNumber {
@@ -63,7 +63,7 @@ func (x SubscribeType) Number() protoreflect.EnumNumber {
 
 // Deprecated: Use SubscribeType.Descriptor instead.
 func (SubscribeType) EnumDescriptor() ([]byte, []int) {
-	return file_test_rpc_messagequeue_proto_rawDescGZIP(), []int{0}
+	return file_rpcproto_messagequeue_proto_rawDescGZIP(), []int{0}
 }
 
 type SubscribeMethod int32
@@ -96,11 +96,11 @@ func (x SubscribeMethod) String() string {
 }
 
 func (SubscribeMethod) Descriptor() protoreflect.EnumDescriptor {
-	return file_test_rpc_messagequeue_proto_enumTypes[1].Descriptor()
+	return file_rpcproto_messagequeue_proto_enumTypes[1].Descriptor()
 }
 
 func (SubscribeMethod) Type() protoreflect.EnumType {
-	return &file_test_rpc_messagequeue_proto_enumTypes[1]
+	return &file_rpcproto_messagequeue_proto_enumTypes[1]
 }
 
 func (x SubscribeMethod) Number() protoreflect.EnumNumber {
@@ -109,7 +109,7 @@ func (x SubscribeMethod) Number() protoreflect.EnumNumber {
 
 // Deprecated: Use SubscribeMethod.Descriptor instead.
 func (SubscribeMethod) EnumDescriptor() ([]byte, []int) {
-	return file_test_rpc_messagequeue_proto_rawDescGZIP(), []int{1}
+	return file_rpcproto_messagequeue_proto_rawDescGZIP(), []int{1}
 }
 
 type DBQueuePopReq struct {
@@ -127,7 +127,7 @@ type DBQueuePopReq struct {
 func (x *DBQueuePopReq) Reset() {
 	*x = DBQueuePopReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_test_rpc_messagequeue_proto_msgTypes[0]
+		mi := &file_rpcproto_messagequeue_proto_msgTypes[0]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -140,7 +140,7 @@ func (x *DBQueuePopReq) String() string {
 func (*DBQueuePopReq) ProtoMessage() {}
 
 func (x *DBQueuePopReq) ProtoReflect() protoreflect.Message {
-	mi := &file_test_rpc_messagequeue_proto_msgTypes[0]
+	mi := &file_rpcproto_messagequeue_proto_msgTypes[0]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -153,7 +153,7 @@ func (x *DBQueuePopReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DBQueuePopReq.ProtoReflect.Descriptor instead.
 func (*DBQueuePopReq) Descriptor() ([]byte, []int) {
-	return file_test_rpc_messagequeue_proto_rawDescGZIP(), []int{0}
+	return file_rpcproto_messagequeue_proto_rawDescGZIP(), []int{0}
 }
 
 func (x *DBQueuePopReq) GetCustomerId() string {
@@ -203,7 +203,7 @@ type DBQueuePopRes struct {
 func (x *DBQueuePopRes) Reset() {
 	*x = DBQueuePopRes{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_test_rpc_messagequeue_proto_msgTypes[1]
+		mi := &file_rpcproto_messagequeue_proto_msgTypes[1]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -216,7 +216,7 @@ func (x *DBQueuePopRes) String() string {
 func (*DBQueuePopRes) ProtoMessage() {}
 
 func (x *DBQueuePopRes) ProtoReflect() protoreflect.Message {
-	mi := &file_test_rpc_messagequeue_proto_msgTypes[1]
+	mi := &file_rpcproto_messagequeue_proto_msgTypes[1]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -229,7 +229,7 @@ func (x *DBQueuePopRes) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DBQueuePopRes.ProtoReflect.Descriptor instead.
 func (*DBQueuePopRes) Descriptor() ([]byte, []int) {
-	return file_test_rpc_messagequeue_proto_rawDescGZIP(), []int{1}
+	return file_rpcproto_messagequeue_proto_rawDescGZIP(), []int{1}
 }
 
 func (x *DBQueuePopRes) GetQueueName() string {
@@ -255,7 +255,7 @@ type DBQueueSubscribeReq struct {
 	SubType          SubscribeType   `protobuf:"varint,1,opt,name=SubType,proto3,enum=SubscribeType" json:"SubType,omitempty"` //订阅类型
 	Method           SubscribeMethod `protobuf:"varint,2,opt,name=Method,proto3,enum=SubscribeMethod" json:"Method,omitempty"` //订阅方法
 	CustomerId       string          `protobuf:"bytes,3,opt,name=CustomerId,proto3" json:"CustomerId,omitempty"`               //消费者Id
-	FromNodeId       int32           `protobuf:"varint,4,opt,name=FromNodeId,proto3" json:"FromNodeId,omitempty"`
+	FromNodeId       string          `protobuf:"bytes,4,opt,name=FromNodeId,proto3" json:"FromNodeId,omitempty"`
 	RpcMethod        string          `protobuf:"bytes,5,opt,name=RpcMethod,proto3" json:"RpcMethod,omitempty"`
 	TopicName        string          `protobuf:"bytes,6,opt,name=TopicName,proto3" json:"TopicName,omitempty"`                //主题名称
 	StartIndex       uint64          `protobuf:"varint,7,opt,name=StartIndex,proto3" json:"StartIndex,omitempty"`             //开始位置 ,格式前4位是时间戳秒，后面是序号。如果填0时，服务自动修改成：(4bit 当前时间秒)| (0000 4bit)
@@ -265,7 +265,7 @@ type DBQueueSubscribeReq struct {
 func (x *DBQueueSubscribeReq) Reset() {
 	*x = DBQueueSubscribeReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_test_rpc_messagequeue_proto_msgTypes[2]
+		mi := &file_rpcproto_messagequeue_proto_msgTypes[2]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -278,7 +278,7 @@ func (x *DBQueueSubscribeReq) String() string {
 func (*DBQueueSubscribeReq) ProtoMessage() {}
 
 func (x *DBQueueSubscribeReq) ProtoReflect() protoreflect.Message {
-	mi := &file_test_rpc_messagequeue_proto_msgTypes[2]
+	mi := &file_rpcproto_messagequeue_proto_msgTypes[2]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -291,7 +291,7 @@ func (x *DBQueueSubscribeReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DBQueueSubscribeReq.ProtoReflect.Descriptor instead.
 func (*DBQueueSubscribeReq) Descriptor() ([]byte, []int) {
-	return file_test_rpc_messagequeue_proto_rawDescGZIP(), []int{2}
+	return file_rpcproto_messagequeue_proto_rawDescGZIP(), []int{2}
 }
 
 func (x *DBQueueSubscribeReq) GetSubType() SubscribeType {
@@ -315,11 +315,11 @@ func (x *DBQueueSubscribeReq) GetCustomerId() string {
 	return ""
 }
 
-func (x *DBQueueSubscribeReq) GetFromNodeId() int32 {
+func (x *DBQueueSubscribeReq) GetFromNodeId() string {
 	if x != nil {
 		return x.FromNodeId
 	}
-	return 0
+	return ""
 }
 
 func (x *DBQueueSubscribeReq) GetRpcMethod() string {
@@ -359,7 +359,7 @@ type DBQueueSubscribeRes struct {
 func (x *DBQueueSubscribeRes) Reset() {
 	*x = DBQueueSubscribeRes{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_test_rpc_messagequeue_proto_msgTypes[3]
+		mi := &file_rpcproto_messagequeue_proto_msgTypes[3]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -372,7 +372,7 @@ func (x *DBQueueSubscribeRes) String() string {
 func (*DBQueueSubscribeRes) ProtoMessage() {}
 
 func (x *DBQueueSubscribeRes) ProtoReflect() protoreflect.Message {
-	mi := &file_test_rpc_messagequeue_proto_msgTypes[3]
+	mi := &file_rpcproto_messagequeue_proto_msgTypes[3]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -385,7 +385,7 @@ func (x *DBQueueSubscribeRes) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DBQueueSubscribeRes.ProtoReflect.Descriptor instead.
 func (*DBQueueSubscribeRes) Descriptor() ([]byte, []int) {
-	return file_test_rpc_messagequeue_proto_rawDescGZIP(), []int{3}
+	return file_rpcproto_messagequeue_proto_rawDescGZIP(), []int{3}
 }
 
 type DBQueuePublishReq struct {
@@ -400,7 +400,7 @@ type DBQueuePublishReq struct {
 func (x *DBQueuePublishReq) Reset() {
 	*x = DBQueuePublishReq{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_test_rpc_messagequeue_proto_msgTypes[4]
+		mi := &file_rpcproto_messagequeue_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -413,7 +413,7 @@ func (x *DBQueuePublishReq) String() string {
 func (*DBQueuePublishReq) ProtoMessage() {}
 
 func (x *DBQueuePublishReq) ProtoReflect() protoreflect.Message {
-	mi := &file_test_rpc_messagequeue_proto_msgTypes[4]
+	mi := &file_rpcproto_messagequeue_proto_msgTypes[4]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -426,7 +426,7 @@ func (x *DBQueuePublishReq) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DBQueuePublishReq.ProtoReflect.Descriptor instead.
 func (*DBQueuePublishReq) Descriptor() ([]byte, []int) {
-	return file_test_rpc_messagequeue_proto_rawDescGZIP(), []int{4}
+	return file_rpcproto_messagequeue_proto_rawDescGZIP(), []int{4}
 }
 
 func (x *DBQueuePublishReq) GetTopicName() string {
@@ -452,7 +452,7 @@ type DBQueuePublishRes struct {
 func (x *DBQueuePublishRes) Reset() {
 	*x = DBQueuePublishRes{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_test_rpc_messagequeue_proto_msgTypes[5]
+		mi := &file_rpcproto_messagequeue_proto_msgTypes[5]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -465,7 +465,7 @@ func (x *DBQueuePublishRes) String() string {
 func (*DBQueuePublishRes) ProtoMessage() {}
 
 func (x *DBQueuePublishRes) ProtoReflect() protoreflect.Message {
-	mi := &file_test_rpc_messagequeue_proto_msgTypes[5]
+	mi := &file_rpcproto_messagequeue_proto_msgTypes[5]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -478,13 +478,13 @@ func (x *DBQueuePublishRes) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DBQueuePublishRes.ProtoReflect.Descriptor instead.
 func (*DBQueuePublishRes) Descriptor() ([]byte, []int) {
-	return file_test_rpc_messagequeue_proto_rawDescGZIP(), []int{5}
+	return file_rpcproto_messagequeue_proto_rawDescGZIP(), []int{5}
 }
 
-var File_test_rpc_messagequeue_proto protoreflect.FileDescriptor
+var File_rpcproto_messagequeue_proto protoreflect.FileDescriptor
 
-var file_test_rpc_messagequeue_proto_rawDesc = []byte{
+var file_rpcproto_messagequeue_proto_rawDesc = []byte{
-	0x0a, 0x1b, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x72, 0x70, 0x63, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x0a, 0x1b, 0x72, 0x70, 0x63, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61,
 	0x67, 0x65, 0x71, 0x75, 0x65, 0x75, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa3, 0x01,
 	0x0a, 0x0d, 0x44, 0x42, 0x51, 0x75, 0x65, 0x75, 0x65, 0x50, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x12,
 	0x1e, 0x0a, 0x0a, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x49, 0x64, 0x18, 0x01, 0x20,
@@ -510,7 +510,7 @@ var file_test_rpc_messagequeue_proto_rawDesc = []byte{
 	0x6f, 0x64, 0x52, 0x06, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x43, 0x75,
 	0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x49, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
 	0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x46, 0x72,
-	0x6f, 0x6d, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a,
+	0x6f, 0x6d, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
 	0x46, 0x72, 0x6f, 0x6d, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x52, 0x70,
 	0x63, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x52,
 	0x70, 0x63, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x54, 0x6f, 0x70, 0x69,
@@ -539,20 +539,20 @@ var file_test_rpc_messagequeue_proto_rawDesc = []byte{
 }
 
 var (
-	file_test_rpc_messagequeue_proto_rawDescOnce sync.Once
+	file_rpcproto_messagequeue_proto_rawDescOnce sync.Once
-	file_test_rpc_messagequeue_proto_rawDescData = file_test_rpc_messagequeue_proto_rawDesc
+	file_rpcproto_messagequeue_proto_rawDescData = file_rpcproto_messagequeue_proto_rawDesc
 )
 
-func file_test_rpc_messagequeue_proto_rawDescGZIP() []byte {
+func file_rpcproto_messagequeue_proto_rawDescGZIP() []byte {
-	file_test_rpc_messagequeue_proto_rawDescOnce.Do(func() {
+	file_rpcproto_messagequeue_proto_rawDescOnce.Do(func() {
-		file_test_rpc_messagequeue_proto_rawDescData = protoimpl.X.CompressGZIP(file_test_rpc_messagequeue_proto_rawDescData)
+		file_rpcproto_messagequeue_proto_rawDescData = protoimpl.X.CompressGZIP(file_rpcproto_messagequeue_proto_rawDescData)
 	})
-	return file_test_rpc_messagequeue_proto_rawDescData
+	return file_rpcproto_messagequeue_proto_rawDescData
 }
 
-var file_test_rpc_messagequeue_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
+var file_rpcproto_messagequeue_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
-var file_test_rpc_messagequeue_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
+var file_rpcproto_messagequeue_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
-var file_test_rpc_messagequeue_proto_goTypes = []interface{}{
+var file_rpcproto_messagequeue_proto_goTypes = []interface{}{
 	(SubscribeType)(0),          // 0: SubscribeType
 	(SubscribeMethod)(0),        // 1: SubscribeMethod
 	(*DBQueuePopReq)(nil),       // 2: DBQueuePopReq
@@ -562,7 +562,7 @@ var file_test_rpc_messagequeue_proto_goTypes = []interface{}{
 	(*DBQueuePublishReq)(nil),   // 6: DBQueuePublishReq
 	(*DBQueuePublishRes)(nil),   // 7: DBQueuePublishRes
 }
-var file_test_rpc_messagequeue_proto_depIdxs = []int32{
+var file_rpcproto_messagequeue_proto_depIdxs = []int32{
 	0, // 0: DBQueueSubscribeReq.SubType:type_name -> SubscribeType
 	1, // 1: DBQueueSubscribeReq.Method:type_name -> SubscribeMethod
 	2, // [2:2] is the sub-list for method output_type
@@ -572,13 +572,13 @@ var file_test_rpc_messagequeue_proto_depIdxs = []int32{
 	0, // [0:2] is the sub-list for field type_name
 }
 
-func init() { file_test_rpc_messagequeue_proto_init() }
+func init() { file_rpcproto_messagequeue_proto_init() }
-func file_test_rpc_messagequeue_proto_init() {
+func file_rpcproto_messagequeue_proto_init() {
-	if File_test_rpc_messagequeue_proto != nil {
+	if File_rpcproto_messagequeue_proto != nil {
 		return
 	}
 	if !protoimpl.UnsafeEnabled {
-		file_test_rpc_messagequeue_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+		file_rpcproto_messagequeue_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DBQueuePopReq); i {
 			case 0:
 				return &v.state
@@ -590,7 +590,7 @@ func file_test_rpc_messagequeue_proto_init() {
 				return nil
 			}
 		}
-		file_test_rpc_messagequeue_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+		file_rpcproto_messagequeue_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DBQueuePopRes); i {
 			case 0:
 				return &v.state
@@ -602,7 +602,7 @@ func file_test_rpc_messagequeue_proto_init() {
 				return nil
 			}
 		}
-		file_test_rpc_messagequeue_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+		file_rpcproto_messagequeue_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DBQueueSubscribeReq); i {
 			case 0:
 				return &v.state
@@ -614,7 +614,7 @@ func file_test_rpc_messagequeue_proto_init() {
 				return nil
 			}
 		}
-		file_test_rpc_messagequeue_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+		file_rpcproto_messagequeue_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DBQueueSubscribeRes); i {
 			case 0:
 				return &v.state
@@ -626,7 +626,7 @@ func file_test_rpc_messagequeue_proto_init() {
 				return nil
 			}
 		}
-		file_test_rpc_messagequeue_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+		file_rpcproto_messagequeue_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DBQueuePublishReq); i {
 			case 0:
 				return &v.state
@@ -638,7 +638,7 @@ func file_test_rpc_messagequeue_proto_init() {
 				return nil
 			}
 		}
-		file_test_rpc_messagequeue_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+		file_rpcproto_messagequeue_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DBQueuePublishRes); i {
 			case 0:
 				return &v.state
@@ -655,19 +655,19 @@ func file_test_rpc_messagequeue_proto_init() {
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_test_rpc_messagequeue_proto_rawDesc,
+			RawDescriptor: file_rpcproto_messagequeue_proto_rawDesc,
 			NumEnums:      2,
 			NumMessages:   6,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
-		GoTypes:           file_test_rpc_messagequeue_proto_goTypes,
+		GoTypes:           file_rpcproto_messagequeue_proto_goTypes,
-		DependencyIndexes: file_test_rpc_messagequeue_proto_depIdxs,
+		DependencyIndexes: file_rpcproto_messagequeue_proto_depIdxs,
-		EnumInfos:         file_test_rpc_messagequeue_proto_enumTypes,
+		EnumInfos:         file_rpcproto_messagequeue_proto_enumTypes,
-		MessageInfos:      file_test_rpc_messagequeue_proto_msgTypes,
+		MessageInfos:      file_rpcproto_messagequeue_proto_msgTypes,
 	}.Build()
-	File_test_rpc_messagequeue_proto = out.File
+	File_rpcproto_messagequeue_proto = out.File
-	file_test_rpc_messagequeue_proto_rawDesc = nil
+	file_rpcproto_messagequeue_proto_rawDesc = nil
-	file_test_rpc_messagequeue_proto_goTypes = nil
+	file_rpcproto_messagequeue_proto_goTypes = nil
-	file_test_rpc_messagequeue_proto_depIdxs = nil
+	file_rpcproto_messagequeue_proto_depIdxs = nil
 }

rpc/messagequeue.proto

@@ -31,7 +31,7 @@ message DBQueueSubscribeReq {
     SubscribeType SubType = 1; //订阅类型
     SubscribeMethod Method = 2; //订阅方法
     string  CustomerId     = 3; //消费者Id
-    int32 FromNodeId      = 4;
+    string FromNodeId      = 4;
     string RpcMethod       = 5;
     string TopicName      = 6; //主题名称
     uint64  StartIndex    = 7; //开始位置 ,格式前4位是时间戳秒，后面是序号。如果填0时，服务自动修改成：(4bit 当前时间秒)| (0000 4bit)

rpc/rpchandler.go

@@ -13,9 +13,9 @@ import (
 	"time"
 )
 
-const maxClusterNode int = 128
+const maxClusterNode int = 32
 
-type FuncRpcClient func(nodeId string, serviceMethod string,filterRetire bool, client []*Client) (error, int)
+type FuncRpcClient func(nodeId string, serviceMethod string,filterRetire bool, client []*Client) (error, []*Client)
 type FuncRpcServer func() IServer
 const NodeIdNull = ""
 
@@ -63,7 +63,7 @@ type RpcHandler struct {
 	funcRpcClient   FuncRpcClient
 	funcRpcServer   FuncRpcServer
 
-	pClientList []*Client
+	//pClientList []*Client
 }
 
 //type TriggerRpcConnEvent func(bConnect bool, clientSeq uint32, nodeId string)
@@ -110,7 +110,6 @@ type IRpcHandler interface {
 	GoNode(nodeId string, serviceMethod string, args interface{}) error
 	RawGoNode(rpcProcessorType RpcProcessorType, nodeId string, rpcMethodId uint32, serviceName string, rawArgs []byte) error
 	CastGo(serviceMethod string, args interface{}) error
-	IsSingleCoroutine() bool
 	UnmarshalInParam(rpcProcessor IRpcProcessor, serviceMethod string, rawRpcMethodId uint32, inParam []byte) (interface{}, error)
 	GetRpcServer() FuncRpcServer
 }
@@ -135,7 +134,6 @@ func (handler *RpcHandler) InitRpcHandler(rpcHandler IRpcHandler, getClientFun F
 	handler.mapFunctions = map[string]RpcMethodInfo{}
 	handler.funcRpcClient = getClientFun
 	handler.funcRpcServer = getServerFun
-	handler.pClientList = make([]*Client, maxClusterNode)
 	handler.RegisterRpc(rpcHandler)
 }
 
@@ -274,7 +272,7 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
 	//普通的rpc请求
 	v, ok := handler.mapFunctions[request.RpcRequestData.GetServiceMethod()]
 	if ok == false {
-		err := "RpcHandler " + handler.rpcHandler.GetName() + "cannot find " + request.RpcRequestData.GetServiceMethod()
+		err := "RpcHandler " + handler.rpcHandler.GetName() + " cannot find " + request.RpcRequestData.GetServiceMethod()
 		log.Error("HandlerRpcRequest cannot find serviceMethod",log.String("RpcHandlerName",handler.rpcHandler.GetName()),log.String("serviceMethod",request.RpcRequestData.GetServiceMethod()))
 		if request.requestHandle != nil {
 			request.requestHandle(nil, RpcError(err))
@@ -435,9 +433,9 @@ func (handler *RpcHandler) CallMethod(client *Client,ServiceMethod string, param
 }
 
 func (handler *RpcHandler) goRpc(processor IRpcProcessor, bCast bool, nodeId string, serviceMethod string, args interface{}) error {
-	var pClientList [maxClusterNode]*Client
+	pClientList :=make([]*Client,0,maxClusterNode)
-	err, count := handler.funcRpcClient(nodeId, serviceMethod,false, pClientList[:])
+	err, pClientList := handler.funcRpcClient(nodeId, serviceMethod,false, pClientList)
-	if count == 0 {
+	if len(pClientList) == 0 {
 		if err != nil {
 			log.Error("call serviceMethod is failed",log.String("serviceMethod",serviceMethod),log.ErrorAttr("error",err))
 		} else {
@@ -446,13 +444,13 @@ func (handler *RpcHandler) goRpc(processor IRpcProcessor, bCast bool, nodeId str
 		return err
 	}
 
-	if count > 1 && bCast == false {
+	if len(pClientList) > 1 && bCast == false {
 		log.Error("cannot call serviceMethod more then 1 node",log.String("serviceMethod",serviceMethod))
 		return errors.New("cannot call more then 1 node")
 	}
 
 	//2.rpcClient调用
-	for i := 0; i < count; i++ {
+	for i := 0; i < len(pClientList); i++ {
 		pCall := pClientList[i].Go(pClientList[i].GetTargetNodeId(),DefaultRpcTimeout,handler.rpcHandler,true, serviceMethod, args, nil)
 		if pCall.Err != nil {
 			err = pCall.Err
@@ -465,16 +463,16 @@ func (handler *RpcHandler) goRpc(processor IRpcProcessor, bCast bool, nodeId str
 }
 
 func (handler *RpcHandler) callRpc(timeout time.Duration,nodeId string, serviceMethod string, args interface{}, reply interface{}) error {
-	var pClientList [maxClusterNode]*Client
+	pClientList :=make([]*Client,0,maxClusterNode)
-	err, count := handler.funcRpcClient(nodeId, serviceMethod,false, pClientList[:])
+	err, pClientList := handler.funcRpcClient(nodeId, serviceMethod,false, pClientList)
 	if err != nil {
 		log.Error("Call serviceMethod is failed",log.ErrorAttr("error",err))
 		return err
-	} else if count <= 0 {
+	} else if len(pClientList) <= 0 {
 		err = errors.New("Call serviceMethod is error:cannot find " + serviceMethod)
 		log.Error("cannot find serviceMethod",log.String("serviceMethod",serviceMethod))
 		return err
-	} else if count > 1 {
+	} else if len(pClientList) > 1 {
 		log.Error("Cannot call more then 1 node!",log.String("serviceMethod",serviceMethod))
 		return errors.New("cannot call more then 1 node")
 	}
@@ -509,9 +507,9 @@ func (handler *RpcHandler) asyncCallRpc(timeout time.Duration,nodeId string, ser
 	}
 
 	reply := reflect.New(fVal.Type().In(0).Elem()).Interface()
-	var pClientList [2]*Client
+	pClientList :=make([]*Client,0,1)
-	err, count := handler.funcRpcClient(nodeId, serviceMethod,false, pClientList[:])
+	err, pClientList := handler.funcRpcClient(nodeId, serviceMethod,false, pClientList[:])
-	if count == 0 || err != nil {
+	if len(pClientList) == 0 || err != nil {
 		if err == nil {
 			if nodeId  != NodeIdNull {
 				err = fmt.Errorf("cannot find %s from nodeId %d",serviceMethod,nodeId)
@@ -524,7 +522,7 @@ func (handler *RpcHandler) asyncCallRpc(timeout time.Duration,nodeId string, ser
 		return emptyCancelRpc,nil
 	}
 
-	if count > 1 {
+	if len(pClientList) > 1 {
 		err := errors.New("cannot call more then 1 node")
 		fVal.Call([]reflect.Value{reflect.ValueOf(reply), reflect.ValueOf(err)})
 		log.Error("cannot call more then 1 node",log.String("serviceMethod",serviceMethod))
@@ -540,10 +538,6 @@ func (handler *RpcHandler) GetName() string {
 	return handler.rpcHandler.GetName()
 }
 
-func (handler *RpcHandler) IsSingleCoroutine() bool {
-	return handler.rpcHandler.IsSingleCoroutine()
-}
-
 func (handler *RpcHandler) CallWithTimeout(timeout time.Duration,serviceMethod string, args interface{}, reply interface{}) error {
 	return handler.callRpc(timeout,NodeIdNull, serviceMethod, args, reply)
 }
@@ -593,12 +587,13 @@ func (handler *RpcHandler) CastGo(serviceMethod string, args interface{}) error
 
 func (handler *RpcHandler) RawGoNode(rpcProcessorType RpcProcessorType, nodeId string, rpcMethodId uint32, serviceName string, rawArgs []byte) error {
 	processor := GetProcessor(uint8(rpcProcessorType))
-	err, count := handler.funcRpcClient(nodeId, serviceName,false, handler.pClientList)
+	pClientList := make([]*Client,0,1)
-	if count == 0 || err != nil {
+	err, pClientList := handler.funcRpcClient(nodeId, serviceName,false, pClientList)
+	if len(pClientList) == 0 || err != nil {
 		log.Error("call serviceMethod is failed",log.ErrorAttr("error",err))
 		return err
 	}
-	if count > 1 {
+	if len(pClientList) > 1 {
 		err := errors.New("cannot call more then 1 node")
 		log.Error("cannot call more then 1 node",log.String("serviceName",serviceName))
 		return err
@@ -606,14 +601,14 @@ func (handler *RpcHandler) RawGoNode(rpcProcessorType RpcProcessorType, nodeId s
 
 	//2.rpcClient调用
 	//如果调用本结点服务
-	for i := 0; i < count; i++ {
+	for i := 0; i < len(pClientList); i++ {
 		//跨node调用
-		pCall := handler.pClientList[i].RawGo(handler.pClientList[i].GetTargetNodeId(),DefaultRpcTimeout,handler.rpcHandler,processor, true, rpcMethodId, serviceName, rawArgs, nil)
+		pCall := pClientList[i].RawGo(pClientList[i].GetTargetNodeId(),DefaultRpcTimeout,handler.rpcHandler,processor, true, rpcMethodId, serviceName, rawArgs, nil)
 		if pCall.Err != nil {
 			err = pCall.Err
 		}
 
-		handler.pClientList[i].RemovePending(pCall.Seq)
+		pClientList[i].RemovePending(pCall.Seq)
 		ReleaseCall(pCall)
 	}
 

service/service.go

@@ -14,11 +14,14 @@ import (
 	"sync"
 	"sync/atomic"
 	"github.com/duanhf2012/origin/v2/concurrent"
+	"encoding/json"
 )
 
 var timerDispatcherLen = 100000
 var maxServiceEventChannelNum = 2000000
 
+
+
 type IService interface {
 	concurrent.IConcurrent
 	Init(iService IService,getClientFun rpc.FuncRpcClient,getServerFun rpc.FuncRpcServer,serviceCfg interface{})
@@ -55,6 +58,7 @@ type Service struct {
 	serviceCfg     interface{}
 	goroutineNum   int32
 	startStatus    bool
+	isRelease      int32
 	retire int32
 	eventProcessor event.IEventProcessor
 	profiler *profiler.Profiler //性能分析器
@@ -145,6 +149,7 @@ func (s *Service) Init(iService IService,getClientFun rpc.FuncRpcClient,getServe
 
 func (s *Service) Start() {
 	s.startStatus = true
+	atomic.StoreInt32(&s.isRelease,0)
 	var waitRun sync.WaitGroup
 
 	for i:=int32(0);i< s.goroutineNum;i++{
@@ -173,6 +178,7 @@ func (s *Service) Run() {
 		select {
 		case <- s.closeSig:
 			bStop = true
+			s.Release()
 			concurrent.Close()
 		case cb:=<-concurrentCBChannel:
 			concurrent.DoCallback(cb)
@@ -245,10 +251,6 @@ func (s *Service) Run() {
 		}
 
 		if bStop == true {
-			if atomic.AddInt32(&s.goroutineNum,-1)<=0 {
-				s.startStatus = false
-				s.Release()
-			}
 			break
 		}
 	}
@@ -271,8 +273,11 @@ func (s *Service) Release(){
 			log.Dump(string(buf[:l]),log.String("error",errString))
 		}
 	}()
-	
+
-	s.self.OnRelease()
+	if atomic.AddInt32(&s.isRelease,-1) == -1{
+		s.self.OnRelease()
+	}
+
 }
 
 func (s *Service) OnRelease(){
@@ -293,6 +298,24 @@ func (s *Service) GetServiceCfg()interface{}{
 	return s.serviceCfg
 }
 
+func (s *Service) ParseServiceCfg(cfg interface{}) error{
+	if s.serviceCfg == nil {
+		return errors.New("no service configuration found")
+	}
+
+	rv := reflect.ValueOf(s.serviceCfg)
+	if  rv.Kind() == reflect.Ptr && rv.IsNil() {
+		return errors.New("no service configuration found")
+	}
+
+	bytes,err := json.Marshal(s.serviceCfg)
+	if err != nil {
+		return err
+	}
+
+	return json.Unmarshal(bytes,cfg)
+}
+
 func (s *Service) GetProfiler() *profiler.Profiler{
 	return s.profiler
 }
@@ -305,10 +328,6 @@ func (s *Service) UnRegEventReceiverFunc(eventType event.EventType, receiver eve
 	s.eventProcessor.UnRegEventReceiverFun(eventType, receiver)
 }
 
-func (s *Service) IsSingleCoroutine() bool {
-	return s.goroutineNum == 1
-}
-
 func (s *Service) RegRawRpc(rpcMethodId uint32,rawRpcCB rpc.RawRpcCallBack){
 	s.rpcHandler.RegRawRpc(rpcMethodId,rawRpcCB)
 }

service/servicemgr.go

@@ -23,7 +23,7 @@ func Init() {
 	for _,s := range setupServiceList {
 		err := s.OnInit()
 		if err != nil {
-			log.SError("Failed to initialize "+s.GetName()+" service:"+err.Error())
+			log.Error("Failed to initialize "+s.GetName()+" service",log.ErrorAttr("err",err))
 			os.Exit(1)
 		}
 	}

sysmodule/ginmodule/GinModule.go

@@ -2,7 +2,6 @@ package ginmodule
 
 import (
 	"context"
-	"datacenter/common/processor"
 	"github.com/duanhf2012/origin/v2/event"
 	"github.com/duanhf2012/origin/v2/log"
 	"github.com/duanhf2012/origin/v2/service"
@@ -10,34 +9,36 @@ import (
 	"log/slog"
 	"net/http"
 	"strings"
+	"time"
+	"io"
 )
 
+type IGinProcessor interface {
+	Process(data *gin.Context) (*gin.Context, error)
+}
+
 type GinModule struct {
 	service.Module
 
-	*GinConf
 	*gin.Engine
 	srv *http.Server
 
-	processor []processor.IGinProcessor
+	listenAddr string
+	handleTimeout time.Duration
+	processor []IGinProcessor
 }
 
-type GinConf struct {
+func (gm *GinModule) Init(addr string, handleTimeout time.Duration,engine *gin.Engine) {
-	Addr string
+	gm.listenAddr = addr
-}
+	gm.handleTimeout = handleTimeout
-
-const Sys_Event_Gin_Event event.EventType = -11
-
-func (gm *GinModule) Init(conf *GinConf, engine *gin.Engine) {
-	gm.GinConf = conf
 	gm.Engine = engine
 }
 
-func (gm *GinModule) SetupDataProcessor(processor ...processor.IGinProcessor) {
+func (gm *GinModule) SetupDataProcessor(processor ...IGinProcessor) {
 	gm.processor = processor
 }
 
-func (gm *GinModule) AppendDataProcessor(processor ...processor.IGinProcessor) {
+func (gm *GinModule) AppendDataProcessor(processor ...IGinProcessor) {
 	gm.processor = append(gm.processor, processor...)
 }
 
@@ -47,27 +48,28 @@ func (gm *GinModule) OnInit() error {
 	}
 
 	gm.srv = &http.Server{
-		Addr:    gm.Addr,
+		Addr:    gm.listenAddr,
 		Handler: gm.Engine,
 	}
 
 	gm.Engine.Use(Logger())
 	gm.Engine.Use(gin.Recovery())
-	gm.GetEventProcessor().RegEventReceiverFunc(Sys_Event_Gin_Event, gm.GetEventHandler(), gm.eventHandler)
+	gm.GetEventProcessor().RegEventReceiverFunc(event.Sys_Event_Gin_Event, gm.GetEventHandler(), gm.eventHandler)
 	return nil
 }
 
 func (gm *GinModule) eventHandler(ev event.IEvent) {
 	ginEvent := ev.(*GinEvent)
 	for _, handler := range ginEvent.handlersChain {
-		handler(ginEvent.c)
+		handler(&ginEvent.c)
 	}
 
-	ginEvent.chanWait <- struct{}{}
+	//ginEvent.chanWait <- struct{}{}
 }
 
 func (gm *GinModule) Start() {
-	log.Info("http start listen", slog.Any("addr", gm.Addr))
+	gm.srv.Addr = gm.listenAddr
+	log.Info("http start listen", slog.Any("addr", gm.listenAddr))
 	go func() {
 		err := gm.srv.ListenAndServe()
 		if err != nil {
@@ -77,7 +79,7 @@ func (gm *GinModule) Start() {
 }
 
 func (gm *GinModule) StartTLS(certFile, keyFile string) {
-	log.Info("http start listen", slog.Any("addr", gm.Addr))
+	log.Info("http start listen", slog.Any("addr", gm.listenAddr))
 	go func() {
 		err := gm.srv.ListenAndServeTLS(certFile, keyFile)
 		if err != nil {
@@ -92,17 +94,102 @@ func (gm *GinModule) Stop(ctx context.Context) {
 	}
 }
 
-type GinEvent struct {
+type SafeContext struct {
-	handlersChain gin.HandlersChain
+	*gin.Context
 	chanWait      chan struct{}
-	c             *gin.Context
 }
 
+func (c *SafeContext) JSONAndDone(code int, obj any) {
+	c.Context.JSON(code,obj)
+	c.Done()
+}
+
+func (c *SafeContext) AsciiJSONAndDone(code int, obj any){
+	c.Context.AsciiJSON(code,obj)
+	c.Done()
+}
+
+func (c *SafeContext) PureJSONAndDone(code int, obj any){
+	c.Context.PureJSON(code,obj)
+	c.Done()
+}
+
+func (c *SafeContext) XMLAndDone(code int, obj any){
+	c.Context.XML(code,obj)
+	c.Done()
+}
+
+func (c *SafeContext) YAMLAndDone(code int, obj any){
+	c.Context.YAML(code,obj)
+	c.Done()
+}
+
+func (c *SafeContext) TOMLAndDone(code int, obj any){
+	c.Context.TOML(code,obj)
+	c.Done()
+}
+
+func (c *SafeContext) ProtoBufAndDone(code int, obj any){
+	c.Context.ProtoBuf(code,obj)
+	c.Done()
+}
+
+func (c *SafeContext) StringAndDone(code int, format string, values ...any){
+	c.Context.String(code,format,values...)
+	c.Done()
+}
+
+func (c *SafeContext) RedirectAndDone(code int, location string){
+	c.Context.Redirect(code,location)
+	c.Done()
+}
+
+func (c *SafeContext) DataAndDone(code int, contentType string, data []byte){
+	c.Context.Data(code,contentType,data)
+	c.Done()
+}
+
+func (c *SafeContext) DataFromReaderAndDone(code int, contentLength int64, contentType string, reader io.Reader, extraHeaders map[string]string){
+	c.DataFromReader(code,contentLength,contentType,reader,extraHeaders)
+	c.Done()
+}
+
+func (c *SafeContext) HTMLAndDone(code int, name string, obj any){
+	c.Context.HTML(code,name,obj)
+	c.Done()
+}
+
+func (c *SafeContext) IndentedJSONAndDone(code int, obj any){
+	c.Context.IndentedJSON(code,obj)
+	c.Done()
+}
+
+func (c *SafeContext) SecureJSONAndDone(code int, obj any){
+	c.Context.SecureJSON(code,obj)
+	c.Done()
+}
+
+func (c *SafeContext) JSONPAndDone(code int, obj any){
+	c.Context.JSONP(code,obj)
+	c.Done()
+}
+
+func (c *SafeContext) Done(){
+	c.chanWait <- struct{}{}
+}
+
+type GinEvent struct {
+	handlersChain []SafeHandlerFunc
+	c SafeContext
+}
+
+type SafeHandlerFunc func(*SafeContext)
+
 func (ge *GinEvent) GetEventType() event.EventType {
-	return Sys_Event_Gin_Event
+	return event.Sys_Event_Gin_Event
 }
 
-func (gm *GinModule) handleMethod(httpMethod, relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
+func (gm *GinModule) handleMethod(httpMethod, relativePath string, handlers ...SafeHandlerFunc) gin.IRoutes {
 	return gm.Engine.Handle(httpMethod, relativePath, func(c *gin.Context) {
 		for _, p := range gm.processor {
 			_, err := p.Process(c)
@@ -112,33 +199,71 @@ func (gm *GinModule) handleMethod(httpMethod, relativePath string, handlers ...g
 		}
 
 		var ev GinEvent
-		chanWait := make(chan struct{})
+		chanWait := make(chan struct{},2)
-		ev.chanWait = chanWait
+		ev.c.chanWait = chanWait
 		ev.handlersChain = handlers
-		ev.c = c
+		ev.c.Context = c
 		gm.NotifyEvent(&ev)
 
-		<-chanWait
+		ctx,cancel := context.WithTimeout(context.Background(), gm.handleTimeout)
+		defer cancel()
+
+		select{
+		case <-ctx.Done():
+			log.Error("GinModule process timeout", slog.Any("path", c.Request.URL.Path))
+			c.AbortWithStatus(http.StatusRequestTimeout)
+		case <-chanWait:
+		}
 	})
 }
 
-func (gm *GinModule) SafeGET(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
+// GET 回调处理是在gin协程中
+func (gm *GinModule) GET(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
+	return gm.Engine.GET(relativePath, handlers...)
+}
+
+// POST 回调处理是在gin协程中
+func (gm *GinModule) POST(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
+	return gm.Engine.POST(relativePath, handlers...)
+}
+
+// DELETE 回调处理是在gin协程中
+func (gm *GinModule) DELETE(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
+	return gm.Engine.DELETE(relativePath, handlers...)
+}
+
+// PATCH 回调处理是在gin协程中
+func (gm *GinModule) PATCH(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
+	return gm.Engine.PATCH(relativePath, handlers...)
+}
+
+// Put 回调处理是在gin协程中
+func (gm *GinModule) Put(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
+	return gm.Engine.PUT(relativePath, handlers...)
+}
+
+// SafeGET 回调处理是在service协程中
+func (gm *GinModule) SafeGET(relativePath string, handlers ...SafeHandlerFunc) gin.IRoutes {
 	return gm.handleMethod(http.MethodGet, relativePath, handlers...)
 }
 
-func (gm *GinModule) SafePOST(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
+// SafePOST 回调处理是在service协程中
+func (gm *GinModule) SafePOST(relativePath string, handlers ...SafeHandlerFunc) gin.IRoutes {
 	return gm.handleMethod(http.MethodPost, relativePath, handlers...)
 }
 
-func (gm *GinModule) SafeDELETE(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
+// SafeDELETE 回调处理是在service协程中
+func (gm *GinModule) SafeDELETE(relativePath string, handlers ...SafeHandlerFunc) gin.IRoutes {
 	return gm.handleMethod(http.MethodDelete, relativePath, handlers...)
 }
 
-func (gm *GinModule) SafePATCH(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
+// SafePATCH 回调处理是在service协程中
+func (gm *GinModule) SafePATCH(relativePath string, handlers ...SafeHandlerFunc) gin.IRoutes {
 	return gm.handleMethod(http.MethodPatch, relativePath, handlers...)
 }
 
-func (gm *GinModule) SafePut(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
+// SafePut 回调处理是在service协程中
+func (gm *GinModule) SafePut(relativePath string, handlers ...SafeHandlerFunc) gin.IRoutes {
 	return gm.handleMethod(http.MethodPut, relativePath, handlers...)
 }
 

sysmodule/ginmodule/logger.go

@@ -2,7 +2,7 @@ package ginmodule
 
 import (
 	"fmt"
-	"github.com/duanhf2012/origin/log"
+	"github.com/duanhf2012/origin/v2/log"
 	"github.com/gin-gonic/gin"
 	"time"
 )

sysmodule/mongodbmodule/mongodbmodule.go

@@ -5,7 +5,6 @@ import (
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
-	"go.mongodb.org/mongo-driver/x/bsonx"
 	"time"
 )
 
@@ -48,6 +47,10 @@ func (mm *MongoModule) Start() error {
 	return nil
 }
 
+func (mm *MongoModule) Stop() error {
+	return mm.client.Disconnect(context.Background())
+}
+
 func (mm *MongoModule) TakeSession() Session {
 	return Session{Client: mm.client, maxOperatorTimeOut: mm.maxOperatorTimeOut}
 }
@@ -86,12 +89,12 @@ func (s *Session) EnsureUniqueIndex(db string, collection string, indexKeys [][]
 func (s *Session) ensureIndex(db string, collection string, indexKeys [][]string, bBackground bool, unique bool, sparse bool, asc bool) error {
 	var indexes []mongo.IndexModel
 	for _, keys := range indexKeys {
-		keysDoc := bsonx.Doc{}
+		keysDoc := bson.D{}
 		for _, key := range keys {
 			if asc {
-				keysDoc = keysDoc.Append(key, bsonx.Int32(1))
+				keysDoc = append(keysDoc, bson.E{Key:key,Value:1})
 			} else {
-				keysDoc = keysDoc.Append(key, bsonx.Int32(-1))
+				keysDoc = append(keysDoc, bson.E{Key:key,Value:-1})
 			}
 
 		}

sysservice/messagequeueservice/CustomerSubscriber.go

@@ -16,7 +16,7 @@ type CustomerSubscriber struct {
 	rpc.IRpcHandler
 	topic             string
 	subscriber        *Subscriber
-	fromNodeId        int
+	fromNodeId        string
 	callBackRpcMethod string
 	serviceName       string
 	StartIndex        uint64
@@ -37,7 +37,7 @@ const (
 	MethodLast   SubscribeMethod = 1 //Last模式，以该消费者上次记录的位置开始订阅
 )
 
-func (cs *CustomerSubscriber) trySetSubscriberBaseInfo(rpcHandler rpc.IRpcHandler, ss *Subscriber, topic string, subscribeMethod SubscribeMethod, customerId string, fromNodeId int, callBackRpcMethod string, startIndex uint64, oneBatchQuantity int32) error {
+func (cs *CustomerSubscriber) trySetSubscriberBaseInfo(rpcHandler rpc.IRpcHandler, ss *Subscriber, topic string, subscribeMethod SubscribeMethod, customerId string, fromNodeId string, callBackRpcMethod string, startIndex uint64, oneBatchQuantity int32) error {
 	cs.subscriber = ss
 	cs.fromNodeId = fromNodeId
 	cs.callBackRpcMethod = callBackRpcMethod
@@ -85,7 +85,7 @@ func (cs *CustomerSubscriber) trySetSubscriberBaseInfo(rpcHandler rpc.IRpcHandle
 }
 
 // 开始订阅
-func (cs *CustomerSubscriber) Subscribe(rpcHandler rpc.IRpcHandler, ss *Subscriber, topic string, subscribeMethod SubscribeMethod, customerId string, fromNodeId int, callBackRpcMethod string, startIndex uint64, oneBatchQuantity int32) error {
+func (cs *CustomerSubscriber) Subscribe(rpcHandler rpc.IRpcHandler, ss *Subscriber, topic string, subscribeMethod SubscribeMethod, customerId string, fromNodeId string, callBackRpcMethod string, startIndex uint64, oneBatchQuantity int32) error {
 	err := cs.trySetSubscriberBaseInfo(rpcHandler, ss, topic, subscribeMethod, customerId, fromNodeId, callBackRpcMethod, startIndex, oneBatchQuantity)
 	if err != nil {
 		return err

sysservice/messagequeueservice/MessageQueueService.go

@@ -122,5 +122,5 @@ func (ms *MessageQueueService) RPC_Publish(inParam *rpc.DBQueuePublishReq, outPa
 
 func (ms *MessageQueueService) RPC_Subscribe(req *rpc.DBQueueSubscribeReq, res *rpc.DBQueueSubscribeRes) error {
 	topicRoom := ms.GetTopicRoom(req.TopicName)
-	return topicRoom.TopicSubscribe(ms.GetRpcHandler(), req.SubType, int32(req.Method), int(req.FromNodeId), req.RpcMethod, req.TopicName, req.CustomerId, req.StartIndex, req.OneBatchQuantity)
+	return topicRoom.TopicSubscribe(ms.GetRpcHandler(), req.SubType, int32(req.Method), req.FromNodeId, req.RpcMethod, req.TopicName, req.CustomerId, req.StartIndex, req.OneBatchQuantity)
 }

sysservice/messagequeueservice/Subscriber.go

@@ -31,7 +31,7 @@ func (ss *Subscriber) PersistTopicData(topic string, topics []TopicData, retryCo
 	return ss.dataPersist.PersistTopicData(topic, topics, retryCount)
 }
 
-func (ss *Subscriber) TopicSubscribe(rpcHandler rpc.IRpcHandler, subScribeType rpc.SubscribeType, subscribeMethod SubscribeMethod, fromNodeId int, callBackRpcMethod string, topic string, customerId string, StartIndex uint64, oneBatchQuantity int32) error {
+func (ss *Subscriber) TopicSubscribe(rpcHandler rpc.IRpcHandler, subScribeType rpc.SubscribeType, subscribeMethod SubscribeMethod, fromNodeId string, callBackRpcMethod string, topic string, customerId string, StartIndex uint64, oneBatchQuantity int32) error {
 	//取消订阅时
 	if subScribeType == rpc.SubscribeType_Unsubscribe {
 		ss.UnSubscribe(customerId)

sysservice/rankservice/MongodbPersist.go

@@ -263,7 +263,7 @@ func (mp *MongoPersist) JugeTimeoutSave() bool{
 
 func (mp *MongoPersist)  persistCoroutine(){
 	defer mp.waitGroup.Done()
-	for atomic.LoadInt32(&mp.stop)==0 || mp.hasPersistData(){
+	for atomic.LoadInt32(&mp.stop)==0 {
 		//间隔时间sleep
 		time.Sleep(time.Second*1)
 

sysservice/tcpservice/tcpservice.go

@@ -107,12 +107,16 @@ func (tcpService *TcpService) TcpEventHandler(ev event.IEvent) {
 	case TPT_DisConnected:
 		tcpService.process.DisConnectedRoute(pack.ClientId)
 	case TPT_UnknownPack:
-		tcpService.process.UnknownMsgRoute(pack.ClientId,pack.Data)
+		tcpService.process.UnknownMsgRoute(pack.ClientId,pack.Data,tcpService.recyclerReaderBytes)
 	case TPT_Pack:
-		tcpService.process.MsgRoute(pack.ClientId,pack.Data)
+		tcpService.process.MsgRoute(pack.ClientId,pack.Data,tcpService.recyclerReaderBytes)
 	}
 }
 
+func (tcpService *TcpService) recyclerReaderBytes(data []byte) {
+}
+
+
 func (tcpService *TcpService) SetProcessor(process processor.IProcessor,handler event.IEventHandler){
 	tcpService.process = process
 	tcpService.RegEventReceiverFunc(event.Sys_Event_Tcp,handler, tcpService.TcpEventHandler)

sysservice/wsservice/wsservice.go

@@ -95,9 +95,9 @@ func (ws *WSService) WSEventHandler(ev event.IEvent) {
 	case WPT_DisConnected:
 		pack.MsgProcessor.DisConnectedRoute(pack.ClientId)
 	case WPT_UnknownPack:
-		pack.MsgProcessor.UnknownMsgRoute(pack.ClientId,pack.Data)
+		pack.MsgProcessor.UnknownMsgRoute(pack.ClientId,pack.Data,ws.recyclerReaderBytes)
 	case WPT_Pack:
-		pack.MsgProcessor.MsgRoute(pack.ClientId,pack.Data)
+		pack.MsgProcessor.MsgRoute(pack.ClientId,pack.Data,ws.recyclerReaderBytes)
 	}
 }
 
@@ -129,7 +129,7 @@ func (slf *WSClient) Run() {
 	for{
 		bytes,err := slf.wsConn.ReadMsg()
 		if err != nil {
-			log.Debug("read client id %d is error:%+v",slf.id,err)
+			log.Debug("read client id %s is error:%+v",slf.id,err)
 			break
 		}
 		data,err:=slf.wsService.process.Unmarshal(slf.id,bytes)
@@ -153,7 +153,7 @@ func (ws *WSService) SendMsg(clientid string,msg interface{}) error{
 	client,ok := ws.mapClient[clientid]
 	if ok == false{
 		ws.mapClientLocker.Unlock()
-		return fmt.Errorf("client %d is disconnect!",clientid)
+		return fmt.Errorf("client %s is disconnect!",clientid)
 	}
 
 	ws.mapClientLocker.Unlock()
@@ -180,3 +180,5 @@ func (ws *WSService) Close(clientid string) {
 	return
 }
 
+func (ws *WSService) recyclerReaderBytes(data []byte) {
+}